Version: 231.0.0

* Add CompRegistry methods to EntManager / CompFac

CompRegistries are nice to use and this just makes it a bit easier to extend functionality.

* fix bad pull

Directory.Packages.props

@@ -19,6 +19,7 @@
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzer.Testing" Version="1.1.1" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.NUnit" Version="1.1.1" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.NUnit" Version="1.1.1" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.8.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.8.0" />
@@ -55,7 +56,7 @@
     <PackageVersion Include="Serilog" Version="3.1.1" />
     <PackageVersion Include="Serilog.Sinks.Loki" Version="4.0.0-beta3" />
     <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
-    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.3" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.5" />
     <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
     <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
     <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />

MSBuild/Robust.Engine.Version.props

@@ -1,4 +1,4 @@
 <Project>
 
-    <!-- This file automatically reset by Tools/version.py -->
+    <!-- This file automatically reset by Tools/version.py -->
 

RELEASE-NOTES.md

@@ -54,6 +54,174 @@ END TEMPLATE-->
 *None yet*
 
 
+## 231.0.0
+
+### Breaking changes
+
+* ViewSubscriber has been moved to shared; it doesn't actually do anything on the client but makes shared code easier.
+
+### New features
+
+* ContactEnumreator exists to iterate the contacts of a particular entity.
+* Add FixturesChangeComponent as a generic way to add and remove fixtures easily.
+* PointLightComponent enabling / disabling now has an attempt event if you wish to block it on content side.
+* There's an OpenScreenAt overload for screen-relative coordinates.
+* SpriteSystem has methods to get an entity's position in sprite terms.
+* EntityManager and ComponentFactory now have additional methods that interact with ComponentRegistry and ComponentRegistryEntry.
+
+### Bugfixes
+
+* Fix PrototypeFlags Add not actually working.
+* Fix BUIs going BRRT opening and closing repeatedly upon prediction. The closing now gets deferred to the update loop if it's still closed at the end of prediction.
+
+
+## 230.2.0
+
+### New features
+
+* Add ProcessNow for IRobustJob as a convenience method where you may not want to run a job in the background sometimes.
+* Add Vector2i helpers to all 8 neighbouring directions.
+
+### Other
+
+* Remove IThreadPoolWorkItem interface from IRobustJob.
+
+
+## 230.1.0
+
+### New features
+
+* You can now pass `bool[]` parameters to shaders.
+* Added `toolshed.nearby_entities_limit` CVar.
+* Fix `RichTextLabel.Text` to clear and reset the message properly in all cases.
+* `scene` command has tab completion now.
+* `devwindow` UI inspector property catches exceptions for read properties.
+* `SplitContainer.Flip()`
+
+### Bugfixes
+
+* Fix tile enlargement not being applied for some EntityLookup queries.
+* `LocalizedEntityCommands` are now not initialized inside `RobustUnitTest`, fixing guaranteed test failures.
+* Fixed issues with broadphase init breaking replays frequently.
+* Fix uploaded prototypes and resources for clients connecting to a server.
+
+### Other
+
+* Improved error reporting for DataField analyzer.
+
+
+## 230.0.1
+
+
+## 230.0.0
+
+### New features
+
+* Added `InterpolatedStringHandlerArgumentAttribute` to the sandbox whitelist.
+* `IUserInterfaceManager.Popup()` popups now have a copy to clipboard button.
+
+### Bugfixes
+
+* Security fixes
+* Fix exception in `TimedDespawnComponent` spawning another `TimedDespawnComponent`.
+* Fixed pool memory leak in physics `SolveIsland`.
+
+
+## 229.1.2
+
+### Bugfixes
+
+* Fixed a bug where the client might not add entities to the broadphase/lookup components.
+
+
+## 229.1.1
+
+### Bugfixes
+
+* Fix some teleportation commands not working in singleplayer or replays
+
+### Other
+
+* Audio entity names now include the filepath of the audio being played if relevant for debugging.
+
+
+## 229.1.0
+
+### Bugfixes
+
+* Fix multithreading bug in ParallelTracker that caused the game to crash randomly.
+* Fixed IPv6-only hosts not working properly with built-in HTTP clients.
+
+### Other
+
+* Added obsoletion warning for `Control.Dispose()`. New code should not rely on it.
+* Reduced the default tickrate to 30 ticks.
+* Encryption of network messages is now done concurrently to avoid spending main thread time. In profiles, this added up to ~8% of main thread time on RMC-14.
+
+
+## 229.0.0
+
+### Breaking changes
+
+* Fixes large entities causing entity spawn menu to break.
+* Made PhysicsHull an internal ref struct for some PolygonShape speedup.
+
+### New features
+
+* Audio ticks-per-second is now capped at 30 by default and controlled via `audio.tick_rate` cvar.
+* Add CreateWindow and CreateDisposableControl helpers for BUIs.
+* Add OnProtoReload virtual method to BUIs that gets called on prototype reloads.
+* Add RemoveData to AppearanceSystem data.
+
+
+## 228.0.0
+
+### Breaking changes
+
+* The `Color` struct's equality methods now check for exact equality. Use `MathHelper.CloseToPercent(Color, Color)` for the previous functionality.
+* Added a toolshed.nearby_limit cvar to limit the maximum range of the nearby command. Defaults to 200.
+
+### New features
+
+* Added command usage with types to Toolshed command help.
+* Add Text property to RichTextLabel.
+* Whitelist System.Net.IPEndPoint.
+* Add event for mass & angular inertia changes.
+* Add SpriteSystem.IsVisible for layers.
+* Add TryQueueDeleteEntity that checks if the entity is already deleted / queuedeleted first.
+
+### Bugfixes
+
+* Clients connecting to a server now always load prototype uploads after resource uploads, fixing ordering bugs that could cause various errors.
+
+
+## 227.0.0
+
+### Breaking changes
+
+* Add a `loop` arg to SpriteSystem.GetFrame in case you don't want to get a looping animation.
+* Remove obsolete VisibileSystem methods.
+
+### New features
+
+* Added `LocalizedEntityCommands`, which are console commands that have the ability to take entity system dependencies.
+* Added `BeginRegistrationRegion` to `IConsoleHost` to allow efficient bulk-registration of console commands.
+* Added `IConsoleHost.RegisterCommand` overload that takes an `IConsoleCommand`.
+* Added a `Finished` boolean to `AnimationCompletedEvent` which allows distinguishing if an animation was removed prematurely or completed naturally.
+* Add GetLocalTilesIntersecting for MapSystem.
+* Add an analyzer for methods that should call the base implementation and use it for EntitySystems.
+
+### Bugfixes
+
+* Fix loading replays if string package is compressed inside a zip.
+
+### Other
+
+* Tab completions containing spaces are now properly quoted, so the command will actually work properly once entered.
+* Mark EntityCoordinates.Offset as Pure so it shows as warnings if the variable is unused.
+* Networked events will always be processed in order even if late.
+
+
 ## 226.3.0
 
 ### New features

Resources/Locale/en-US/userinterface.ftl

@@ -0,0 +1,2 @@
+popup-copy-button = Copy
+popup-title = Alert!

Robust.Analyzers.Tests/DataDefinitionAnalyzerTest.cs

@@ -0,0 +1,91 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.DataDefinitionAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class DataDefinitionAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<DataDefinitionAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using System;
+            using Robust.Shared.ViewVariables;
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            namespace Robust.Shared.ViewVariables
+            {
+                public sealed class ViewVariablesAttribute : Attribute
+                {
+                    public readonly VVAccess Access = VVAccess.ReadOnly;
+
+                    public ViewVariablesAttribute() { }
+
+                    public ViewVariablesAttribute(VVAccess access)
+                    {
+                        Access = access;
+                    }
+                }
+                public enum VVAccess : byte
+                {
+                    ReadOnly = 0,
+                    ReadWrite = 1,
+                }
+            }
+
+            namespace Robust.Shared.Serialization.Manager.Attributes
+            {
+                public class DataFieldBaseAttribute : Attribute;
+                public class DataFieldAttribute : DataFieldBaseAttribute;
+                public sealed class DataDefinitionAttribute : Attribute;
+            }
+
+            [DataDefinition]
+            public sealed partial class Foo
+            {
+                [DataField, ViewVariables(VVAccess.ReadWrite)]
+                public int Bad;
+
+                [DataField]
+                public int Good;
+
+                [DataField, ViewVariables]
+                public int Good2;
+
+                [DataField, ViewVariables(VVAccess.ReadOnly)]
+                public int Good3;
+
+                [ViewVariables]
+                public int Good4;
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(35,17): info RA0028: Data field Bad in data definition Foo has ViewVariables attribute with ReadWrite access, which is redundant
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldNoVVReadWriteRule).WithSpan(35, 17, 35, 50).WithArguments("Bad", "Foo")
+        );
+    }
+}

Robust.Analyzers.Tests/MustCallBaseAnalyzerTest.cs

@@ -0,0 +1,92 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.MustCallBaseAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class MustCallBaseAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<MustCallBaseAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.IoC.MustCallBaseAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class Foo
+            {
+                [MustCallBase]
+                public virtual void Function()
+                {
+
+                }
+
+                [MustCallBase(true)]
+                public virtual void Function2()
+                {
+
+                }
+            }
+
+            public class Bar : Foo
+            {
+                public override void Function()
+                {
+
+                }
+
+                public override void Function2()
+                {
+
+                }
+            }
+
+            public class Baz : Foo
+            {
+                public override void Function()
+                {
+                    base.Function();
+                }
+            }
+
+            public class Bal : Bar
+            {
+                public override void Function2()
+                {
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(20,26): warning RA0028: Overriders of this function must always call the base function
+            VerifyCS.Diagnostic().WithSpan(20, 26, 20, 34),
+            // /0/Test0.cs(41,26): warning RA0028: Overriders of this function must always call the base function
+            VerifyCS.Diagnostic().WithSpan(41, 26, 41, 35));
+    }
+}

Robust.Analyzers.Tests/PreferNonGenericVariantForTest.cs

@@ -0,0 +1,71 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.PreferNonGenericVariantForAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class PreferNonGenericVariantForTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<PreferNonGenericVariantForAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code },
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class Bar { };
+            public class Baz { };
+            public class Okay { };
+
+            public static class Foo
+            {
+                [PreferNonGenericVariantFor(typeof(Bar), typeof(Baz))]
+                public static void DoFoo<T>() { }
+            }
+
+            public class Test
+            {
+                public void DoBad()
+                {
+                    Foo.DoFoo<Bar>();
+                }
+
+                public void DoGood()
+                {
+                    Foo.DoFoo<Okay>();
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(17,9): warning RA0029: Use the non-generic variant of this method for type Bar
+            VerifyCS.Diagnostic().WithSpan(17, 9, 17, 25).WithArguments("Bar")
+        );
+    }
+}

Robust.Analyzers.Tests/PreferOtherTypeAnalyzerTest.cs

@@ -0,0 +1,62 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.PreferOtherTypeAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class PreferOtherTypeAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<PreferOtherTypeAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code },
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class EntityPrototype { };
+            public class EntProtoId { };
+            public class ReagentPrototype { };
+
+            [PreferOtherType(typeof(EntityPrototype), typeof(EntProtoId))]
+            public class ProtoId<T> { };
+
+            public class Test
+            {
+                public ProtoId<EntityPrototype> Bad = new();
+
+                public ProtoId<ReagentPrototype> Good = new();
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(12,12): warning RA0031: Use the specific type EntProtoId instead of ProtoId when the type argument is EntityPrototype
+            VerifyCS.Diagnostic().WithSpan(12, 12, 12, 48).WithArguments("EntProtoId", "ProtoId", "EntityPrototype")
+        );
+    }
+}

Robust.Analyzers.Tests/PreferOtherTypeFixerTest.cs

@@ -0,0 +1,81 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.PreferOtherTypeAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+public sealed class PreferOtherTypeFixerTest
+{
+    private static Task Verifier(string code, string fixedCode, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpCodeFixTest<PreferOtherTypeAnalyzer, PreferOtherTypeFixer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code },
+            },
+            FixedState =
+            {
+                Sources = { fixedCode },
+            }
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs"
+        );
+
+        TestHelper.AddEmbeddedSources(
+            test.FixedState,
+            "Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs"
+        );
+
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            public class EntityPrototype { };
+            public class EntProtoId { };
+            public class ReagentPrototype { };
+
+            [PreferOtherType(typeof(EntityPrototype), typeof(EntProtoId))]
+            public class ProtoId<T> { };
+
+            public class Test
+            {
+                public ProtoId<EntityPrototype> Foo = new();
+            }
+            """;
+
+        const string fixedCode = """
+            using Robust.Shared.Analyzers;
+
+            public class EntityPrototype { };
+            public class EntProtoId { };
+            public class ReagentPrototype { };
+
+            [PreferOtherType(typeof(EntityPrototype), typeof(EntProtoId))]
+            public class ProtoId<T> { };
+
+            public class Test
+            {
+                public EntProtoId Foo = new();
+            }
+            """;
+
+        await Verifier(code, fixedCode,
+        // /0/Test0.cs(12,12): error RA0031: Use the specific type EntProtoId instead of ProtoId when the type argument is EntityPrototype
+        VerifyCS.Diagnostic().WithSpan(12, 12, 12, 48).WithArguments("EntProtoId", "ProtoId", "EntityPrototype"));
+    }
+}

Robust.Analyzers.Tests/Robust.Analyzers.Tests.csproj

@@ -10,6 +10,9 @@
   <ItemGroup>
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\AccessAttribute.cs" LogicalName="Robust.Shared.Analyzers.AccessAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\AccessPermissions.cs" LogicalName="Robust.Shared.Analyzers.AccessPermissions.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\MustCallBaseAttribute.cs" LogicalName="Robust.Shared.IoC.MustCallBaseAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferNonGenericVariantForAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferOtherTypeAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\IoC\DependencyAttribute.cs" LogicalName="Robust.Shared.IoC.DependencyAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
@@ -25,6 +28,7 @@
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzer.Testing"/>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp"/>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.NUnit"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing.NUnit"/>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces"/>
     <PackageReference Include="NUnit"/>
     <PackageReference Include="NUnit3TestAdapter"/>

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -7,6 +7,7 @@ using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Robust.Roslyn.Shared;
 using Robust.Shared.Serialization.Manager.Definition;
+using Robust.Shared.ViewVariables;
 
 namespace Robust.Analyzers;
 
@@ -16,6 +17,9 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private const string DataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataDefinitionAttribute";
     private const string ImplicitDataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.ImplicitDataDefinitionForInheritorsAttribute";
     private const string DataFieldBaseNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataFieldBaseAttribute";
+    private const string ViewVariablesNamespace = "Robust.Shared.ViewVariables.ViewVariablesAttribute";
+    private const string DataFieldAttributeName = "DataField";
+    private const string ViewVariablesAttributeName = "ViewVariables";
 
     private static readonly DiagnosticDescriptor DataDefinitionPartialRule = new(
         Diagnostics.IdDataDefinitionPartial,
@@ -66,9 +70,20 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         true,
         "Make sure to remove the tag string from the data field attribute."
     );
+
+    public static readonly DiagnosticDescriptor DataFieldNoVVReadWriteRule = new(
+        Diagnostics.IdDataFieldNoVVReadWrite,
+        "Data field has VV ReadWrite",
+        "Data field {0} in data definition {1} has ViewVariables attribute with ReadWrite access, which is redundant",
+        "Usage",
+        DiagnosticSeverity.Info,
+        true,
+        "Make sure to remove the ViewVariables attribute."
+    );
+
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
         DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule,
-        DataFieldRedundantTagRule
+        DataFieldRedundantTagRule, DataFieldNoVVReadWriteRule
     );
 
     public override void Initialize(AnalysisContext context)
@@ -139,7 +154,14 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
 
             if (HasRedundantTag(fieldSymbol))
             {
-                context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, context.Node.GetLocation(), fieldSymbol.Name, type.Name));
+                TryGetAttributeLocation(field, DataFieldAttributeName, out var location);
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, fieldSymbol.Name, type.Name));
+            }
+
+            if (HasVVReadWrite(fieldSymbol))
+            {
+                TryGetAttributeLocation(field, ViewVariablesAttributeName, out var location);
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldNoVVReadWriteRule, location, fieldSymbol.Name, type.Name));
             }
         }
     }
@@ -168,7 +190,14 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
 
         if (HasRedundantTag(propertySymbol))
         {
-            context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, context.Node.GetLocation(), propertySymbol.Name, type.Name));
+            TryGetAttributeLocation(property, DataFieldAttributeName, out var location);
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, location, propertySymbol.Name, type.Name));
+        }
+
+        if (HasVVReadWrite(propertySymbol))
+        {
+            TryGetAttributeLocation(property, ViewVariablesAttributeName, out var location);
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldNoVVReadWriteRule, location, propertySymbol.Name, type.Name));
         }
     }
 
@@ -238,6 +267,24 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
+    private static bool TryGetAttributeLocation(MemberDeclarationSyntax syntax, string attributeName, out Location location)
+    {
+        foreach (var attributeList in syntax.AttributeLists)
+        {
+            foreach (var attribute in attributeList.Attributes)
+            {
+                if (attribute.Name.ToString() != attributeName)
+                    continue;
+
+                location = attribute.GetLocation();
+                return true;
+            }
+        }
+        // Default to the declaration syntax's location
+        location = syntax.GetLocation();
+        return false;
+    }
+
     private static bool IsReadOnlyMember(ITypeSymbol type, ISymbol member)
     {
         if (member is IFieldSymbol field)
@@ -292,6 +339,34 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return explicitName == automaticName;
     }
 
+    private static bool HasVVReadWrite(ISymbol symbol)
+    {
+        if (!IsDataField(symbol, out _, out _))
+            return false;
+
+        // Make sure it has ViewVariablesAttribute
+        AttributeData? viewVariablesAttribute = null;
+        foreach (var attr in symbol.GetAttributes())
+        {
+            if (attr.AttributeClass?.ToDisplayString() == ViewVariablesNamespace)
+            {
+                viewVariablesAttribute = attr;
+            }
+        }
+        if (viewVariablesAttribute == null)
+            return false;
+
+        // Default is ReadOnly, which is fine
+        if (viewVariablesAttribute.ConstructorArguments.Length == 0)
+            return false;
+
+        var accessArgument = viewVariablesAttribute.ConstructorArguments[0];
+        if (accessArgument.Value is not byte accessByte)
+            return false;
+
+        return (VVAccess)accessByte == VVAccess.ReadWrite;
+    }
+
     private static bool IsImplicitDataDefinition(ITypeSymbol type)
     {
         if (HasAttribute(type, ImplicitDataDefinitionNamespace))

Robust.Analyzers/DataDefinitionFixer.cs

@@ -15,9 +15,11 @@ public sealed class DefinitionFixer : CodeFixProvider
 {
     private const string DataFieldAttributeName = "DataField";
 
+    private const string ViewVariablesAttributeName = "ViewVariables";
+
     public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
         IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable,
-        IdDataFieldRedundantTag
+        IdDataFieldRedundantTag, IdDataFieldNoVVReadWrite
     );
 
     public override Task RegisterCodeFixesAsync(CodeFixContext context)
@@ -36,6 +38,8 @@ public sealed class DefinitionFixer : CodeFixProvider
                     return RegisterDataFieldPropertyFix(context, diagnostic);
                 case IdDataFieldRedundantTag:
                     return RegisterRedundantTagFix(context, diagnostic);
+                case IdDataFieldNoVVReadWrite:
+                    return RegisterVVReadWriteFix(context, diagnostic);
             }
         }
 
@@ -136,6 +140,48 @@ public sealed class DefinitionFixer : CodeFixProvider
         return document.WithSyntaxRoot(root);
     }
 
+    private static async Task RegisterVVReadWriteFix(CodeFixContext context, Diagnostic diagnostic)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+        var span = diagnostic.Location.SourceSpan;
+        var token = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<MemberDeclarationSyntax>().First();
+
+        if (token == null)
+            return;
+
+        context.RegisterCodeFix(CodeAction.Create(
+            "Remove ViewVariables attribute",
+            c => RemoveVVAttribute(context.Document, token, c),
+            "Remove ViewVariables attribute"
+        ), diagnostic);
+    }
+
+    private static async Task<Document> RemoveVVAttribute(Document document, MemberDeclarationSyntax syntax, CancellationToken cancellation)
+    {
+        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
+
+        var newLists = new SyntaxList<AttributeListSyntax>();
+        foreach (var attributeList in syntax.AttributeLists)
+        {
+            var attributes = new SeparatedSyntaxList<AttributeSyntax>();
+            foreach (var attribute in attributeList.Attributes)
+            {
+                if (attribute.Name.ToString() != ViewVariablesAttributeName)
+                {
+                    attributes = attributes.Add(attribute);
+                }
+            }
+            // Don't add empty lists []
+            if (attributes.Count > 0)
+                newLists = newLists.Add(attributeList.WithAttributes(attributes));
+        }
+        var newSyntax = syntax.WithAttributeLists(newLists);
+
+        root = root!.ReplaceNode(syntax, newSyntax);
+
+        return document.WithSyntaxRoot(root);
+    }
+
     private static async Task RegisterDataFieldFix(CodeFixContext context, Diagnostic diagnostic)
     {
         var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);

Robust.Analyzers/MustCallBaseAnalyzer.cs

@@ -0,0 +1,111 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+#nullable enable
+
+/// <summary>
+/// Enforces <c>MustCallBaseAttribute</c>.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class MustCallBaseAnalyzer : DiagnosticAnalyzer
+{
+    private const string Attribute = "Robust.Shared.Analyzers.MustCallBaseAttribute";
+
+    private static readonly DiagnosticDescriptor Rule = new(
+        Diagnostics.IdMustCallBase,
+        "No base call in overriden function",
+        "Overriders of this function must always call the base function",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSymbolAction(AnalyzeSymbol, SymbolKind.Method);
+    }
+
+    private static void AnalyzeSymbol(SymbolAnalysisContext context)
+    {
+        if (context.Symbol is not IMethodSymbol { IsOverride: true } method)
+            return;
+
+        var attrSymbol = context.Compilation.GetTypeByMetadataName(Attribute);
+        if (attrSymbol == null)
+            return;
+
+        if (DoesMethodOverriderHaveAttribute(method, attrSymbol) is not { } data)
+            return;
+
+        if (data is { onlyOverrides: true, depth: < 2 })
+            return;
+
+        var syntax = (MethodDeclarationSyntax) method.DeclaringSyntaxReferences[0].GetSyntax();
+        if (HasBaseCall(syntax))
+            return;
+
+        var diag = Diagnostic.Create(Rule, syntax.Identifier.GetLocation());
+        context.ReportDiagnostic(diag);
+    }
+
+    private static (int depth, bool onlyOverrides)? DoesMethodOverriderHaveAttribute(
+        IMethodSymbol method,
+        INamedTypeSymbol attributeSymbol)
+    {
+        var depth = 0;
+        while (method.OverriddenMethod != null)
+        {
+            depth += 1;
+            method = method.OverriddenMethod;
+            if (GetAttribute(method, attributeSymbol) is not { } attribute)
+                continue;
+
+            var onlyOverrides = attribute.ConstructorArguments is [{Kind: TypedConstantKind.Primitive, Value: true}];
+            return (depth, onlyOverrides);
+        }
+
+        return null;
+    }
+
+    private static bool HasBaseCall(MethodDeclarationSyntax syntax)
+    {
+        return syntax.Accept(new BaseCallLocator());
+    }
+
+    private static AttributeData? GetAttribute(ISymbol namedTypeSymbol, INamedTypeSymbol attrSymbol)
+    {
+        return namedTypeSymbol.GetAttributes()
+            .SingleOrDefault(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attrSymbol));
+    }
+
+    private sealed class BaseCallLocator : CSharpSyntaxVisitor<bool>
+    {
+        public override bool VisitBaseExpression(BaseExpressionSyntax node)
+        {
+            return true;
+        }
+
+        public override bool DefaultVisit(SyntaxNode node)
+        {
+            foreach (var childNode in node.ChildNodes())
+            {
+                if (childNode is not CSharpSyntaxNode cSharpSyntax)
+                    continue;
+
+                if (cSharpSyntax.Accept(this))
+                    return true;
+            }
+
+            return false;
+        }
+    }
+}

Robust.Analyzers/PreferNonGenericVariantForAnalyzer.cs

@@ -0,0 +1,65 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class PreferNonGenericVariantForAnalyzer : DiagnosticAnalyzer
+{
+    private const string AttributeType = "Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute";
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
+        UseNonGenericVariantDescriptor
+    );
+
+    private static readonly DiagnosticDescriptor UseNonGenericVariantDescriptor = new(
+        Diagnostics.IdUseNonGenericVariant,
+        "Consider using the non-generic variant of this method",
+        "Use the non-generic variant of this method for type {0}",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true,
+        "Use the generic variant of this method.");
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.ReportDiagnostics | GeneratedCodeAnalysisFlags.Analyze);
+        context.EnableConcurrentExecution();
+        context.RegisterOperationAction(CheckForNonGenericVariant, OperationKind.Invocation);
+    }
+
+    private void CheckForNonGenericVariant(OperationAnalysisContext obj)
+    {
+        if (obj.Operation is not IInvocationOperation invocationOperation) return;
+
+        var preferNonGenericAttribute = obj.Compilation.GetTypeByMetadataName(AttributeType);
+
+        HashSet<ITypeSymbol> forTypes = [];
+        foreach (var attribute in invocationOperation.TargetMethod.GetAttributes())
+        {
+            if (!SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, preferNonGenericAttribute))
+                continue;
+
+            foreach (var type in attribute.ConstructorArguments[0].Values)
+                forTypes.Add((ITypeSymbol)type.Value);
+
+            break;
+        }
+
+        if (forTypes == null)
+            return;
+
+        foreach (var typeArg in invocationOperation.TargetMethod.TypeArguments)
+        {
+            if (forTypes.Contains(typeArg))
+            {
+                obj.ReportDiagnostic(
+                Diagnostic.Create(UseNonGenericVariantDescriptor,
+                    invocationOperation.Syntax.GetLocation(), typeArg.Name));
+            }
+        }
+    }
+}

Robust.Analyzers/PreferOtherTypeAnalyzer.cs

@@ -0,0 +1,75 @@
+#nullable enable
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class PreferOtherTypeAnalyzer : DiagnosticAnalyzer
+{
+    private const string AttributeType = "Robust.Shared.Analyzers.PreferOtherTypeAttribute";
+
+    private static readonly DiagnosticDescriptor PreferOtherTypeDescriptor = new(
+        Diagnostics.IdPreferOtherType,
+        "Use the specific type",
+        "Use the specific type {0} instead of {1} when the type argument is {2}",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true,
+        "Use the specific type.");
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
+        PreferOtherTypeDescriptor
+    );
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.ReportDiagnostics | GeneratedCodeAnalysisFlags.Analyze);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeField, SyntaxKind.VariableDeclaration);
+    }
+
+    private void AnalyzeField(SyntaxNodeAnalysisContext context)
+    {
+        if (context.Node is not VariableDeclarationSyntax node)
+            return;
+
+        // Get the type of the generic being used
+        if (node.Type is not GenericNameSyntax genericName)
+            return;
+        var genericSyntax = genericName.TypeArgumentList.Arguments[0];
+        if (context.SemanticModel.GetSymbolInfo(genericSyntax).Symbol is not { } genericType)
+            return;
+
+        // Look for the PreferOtherTypeAttribute
+        var symbolInfo = context.SemanticModel.GetSymbolInfo(node.Type);
+        if (symbolInfo.Symbol?.GetAttributes() is not { } attributes)
+            return;
+
+        var preferOtherTypeAttribute = context.Compilation.GetTypeByMetadataName(AttributeType);
+
+        foreach (var attribute in attributes)
+        {
+            if (!SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, preferOtherTypeAttribute))
+                continue;
+
+            // See if the generic type argument matches the type the attribute specifies
+            if (attribute.ConstructorArguments[0].Value is not ITypeSymbol checkedType)
+                return;
+            if (!SymbolEqualityComparer.Default.Equals(checkedType, genericType))
+                continue;
+
+            if (attribute.ConstructorArguments[1].Value is not ITypeSymbol replacementType)
+                continue;
+            context.ReportDiagnostic(Diagnostic.Create(PreferOtherTypeDescriptor,
+                context.Node.GetLocation(),
+                replacementType.Name,
+                symbolInfo.Symbol.Name,
+                genericType.Name));
+        }
+    }
+}

Robust.Analyzers/PreferOtherTypeFixer.cs

@@ -0,0 +1,97 @@
+#nullable enable
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using static Robust.Roslyn.Shared.Diagnostics;
+
+namespace Robust.Analyzers;
+
+[ExportCodeFixProvider(LanguageNames.CSharp)]
+public sealed class PreferOtherTypeFixer : CodeFixProvider
+{
+    private const string PreferOtherTypeAttributeName = "PreferOtherTypeAttribute";
+
+    public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
+        IdPreferOtherType
+    );
+
+    public override FixAllProvider GetFixAllProvider()
+    {
+        return WellKnownFixAllProviders.BatchFixer;
+    }
+
+    public override Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        foreach (var diagnostic in context.Diagnostics)
+        {
+            switch (diagnostic.Id)
+            {
+                case IdPreferOtherType:
+                    return RegisterReplaceType(context, diagnostic);
+            }
+        }
+
+        return Task.CompletedTask;
+    }
+
+    private static async Task RegisterReplaceType(CodeFixContext context, Diagnostic diagnostic)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+        var span = diagnostic.Location.SourceSpan;
+        var token = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<VariableDeclarationSyntax>().First();
+
+        if (token == null)
+            return;
+
+        context.RegisterCodeFix(CodeAction.Create(
+            "Replace type",
+            c => ReplaceType(context.Document, token, c),
+            "Replace type"
+        ), diagnostic);
+    }
+
+    private static async Task<Document> ReplaceType(Document document, VariableDeclarationSyntax syntax, CancellationToken cancellation)
+    {
+        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
+        var model = await document.GetSemanticModelAsync(cancellation);
+
+        if (model == null)
+            return document;
+
+        if (syntax.Type is not GenericNameSyntax genericNameSyntax)
+            return document;
+        var genericTypeSyntax = genericNameSyntax.TypeArgumentList.Arguments[0];
+        if (model.GetSymbolInfo(genericTypeSyntax).Symbol is not {} genericTypeSymbol)
+            return document;
+
+        var symbolInfo = model.GetSymbolInfo(syntax.Type);
+        if (symbolInfo.Symbol?.GetAttributes() is not { } attributes)
+            return document;
+
+        foreach (var attribute in attributes)
+        {
+            if (attribute.AttributeClass?.Name != PreferOtherTypeAttributeName)
+                continue;
+
+            if (attribute.ConstructorArguments[0].Value is not ITypeSymbol checkedTypeSymbol)
+                continue;
+
+            if (!SymbolEqualityComparer.Default.Equals(checkedTypeSymbol, genericTypeSymbol))
+                continue;
+
+            if (attribute.ConstructorArguments[1].Value is not ITypeSymbol replacementTypeSymbol)
+                continue;
+
+            var replacementIdentifier = SyntaxFactory.IdentifierName(replacementTypeSymbol.Name);
+            var replacementSyntax = syntax.WithType(replacementIdentifier);
+
+            root = root!.ReplaceNode(syntax, replacementSyntax);
+            return document.WithSyntaxRoot(root);
+        }
+
+        return document;
+    }
+}

Robust.Analyzers/Robust.Analyzers.csproj

@@ -16,9 +16,21 @@
     <Compile Include="..\Robust.Shared\Analyzers\PreferGenericVariantAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
+  <ItemGroup>
+    <!-- Needed for PreferNonGenericVariantAnalyzer. -->
+    <Compile Include="..\Robust.Shared\Analyzers\PreferNonGenericVariantForAttribute.cs" LinkBase="Implementations" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <!-- Needed for PreferOtherTypeAnalyzer. -->
+    <Compile Include="..\Robust.Shared\Analyzers\PreferOtherTypeAttribute.cs" LinkBase="Implementations" />
+  </ItemGroup>
+
   <ItemGroup>
     <!-- Needed for DataDefinitionAnalyzer. -->
     <Compile Include="..\Robust.Shared\Serialization\Manager\Definition\DataDefinitionUtility.cs" LinkBase="Implementations" />
+    <Compile Include="..\Robust.Shared\ViewVariables\ViewVariablesAttribute.cs" LinkBase="Implementations" />
+    <Compile Include="..\Robust.Shared\Serialization\NetSerializableAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
   <Import Project="../Robust.Roslyn.Shared/Robust.Roslyn.Shared.props" />

Robust.Client/Audio/AudioManager.Public.cs

@@ -302,7 +302,7 @@ internal partial class AudioManager
     }
 
     /// <inheritdoc/>
-    IBufferedAudioSource? IAudioInternal.CreateBufferedAudioSource(int buffers, bool floatAudio=false)
+    IBufferedAudioSource? IAudioInternal.CreateBufferedAudioSource(int buffers, bool floatAudio)
     {
         var source = AL.GenSource();
 

Robust.Client/Audio/AudioManager.cs

@@ -143,12 +143,11 @@ internal sealed partial class AudioManager : IAudioInternal
     /// <summary>
     /// Like _checkAlError but allows custom data to be passed in as relevant.
     /// </summary>
-    internal void LogALError(string message, [CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1)
+    internal void LogALError(ALErrorInterpolatedStringHandler message, [CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1)
     {
-        var error = AL.GetError();
-        if (error != ALError.NoError)
+        if (message.Error != ALError.NoError)
         {
-            OpenALSawmill.Error("[{0}:{1}] AL error: {2}, {3}. Stacktrace is {4}", callerMember, callerLineNumber, error, message, Environment.StackTrace);
+            OpenALSawmill.Error("[{0}:{1}] AL error: {2}, {3}. Stacktrace is {4}", callerMember, callerLineNumber, message.Error, message.ToStringAndClear(), Environment.StackTrace);
         }
     }
 
@@ -170,4 +169,32 @@ internal sealed partial class AudioManager : IAudioInternal
             BufferHandle = bufferHandle;
         }
     }
+
+    [InterpolatedStringHandler]
+    internal ref struct ALErrorInterpolatedStringHandler
+    {
+        private DefaultInterpolatedStringHandler _handler;
+        public ALError Error;
+
+        public ALErrorInterpolatedStringHandler(int literalLength, int formattedCount, out bool shouldAppend)
+        {
+            Error = AL.GetError();
+            if (Error == ALError.NoError)
+            {
+                shouldAppend = false;
+                _handler = default;
+            }
+            else
+            {
+                shouldAppend = true;
+                _handler = new DefaultInterpolatedStringHandler(literalLength, formattedCount);
+            }
+        }
+
+        public string ToStringAndClear() => _handler.ToStringAndClear();
+        public override string ToString() => _handler.ToString();
+        public void AppendLiteral(string value) => _handler.AppendLiteral(value);
+        public void AppendFormatted<T>(T value) => _handler.AppendFormatted(value);
+        public void AppendFormatted<T>(T value, string? format) => _handler.AppendFormatted(value, format);
+    }
 }

Robust.Client/Audio/AudioOverlay.cs

@@ -46,7 +46,7 @@ public sealed class AudioOverlay : Overlay
 
         var screenHandle = args.ScreenHandle;
         var output = new StringBuilder();
-        var listenerPos = _entManager.GetComponent<TransformComponent>(localPlayer.Value).MapPosition;
+        var listenerPos = _transform.GetMapCoordinates(_entManager.GetComponent<TransformComponent>(localPlayer.Value));
 
         if (listenerPos.MapId != args.MapId)
             return;

Robust.Client/Audio/AudioSystem.cs

@@ -37,7 +37,6 @@ public sealed partial class AudioSystem : SharedAudioSystem
     [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
     [Dependency] private readonly IEyeManager _eyeManager = default!;
     [Dependency] private readonly IResourceCache _resourceCache = default!;
-    [Dependency] private readonly IMapManager _mapManager = default!;
     [Dependency] private readonly IParallelManager _parMan = default!;
     [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
     [Dependency] private readonly IAudioInternal _audio = default!;
@@ -49,9 +48,10 @@ public sealed partial class AudioSystem : SharedAudioSystem
     /// Per-tick cache of relevant streams.
     /// </summary>
     private readonly List<(EntityUid Entity, AudioComponent Component, TransformComponent Xform)> _streams = new();
-    private EntityUid? _listenerGrid;
     private UpdateAudioJob _updateAudioJob;
 
+    private float _audioFrameTime;
+    private float _audioFrameTimeRemaining;
 
     private EntityQuery<PhysicsComponent> _physicsQuery;
 
@@ -110,9 +110,16 @@ public sealed partial class AudioSystem : SharedAudioSystem
 
         Subs.CVar(CfgManager, CVars.AudioAttenuation, OnAudioAttenuation, true);
         Subs.CVar(CfgManager, CVars.AudioRaycastLength, OnRaycastLengthChanged, true);
+        Subs.CVar(CfgManager, CVars.AudioTickRate, OnAudioTickRate, true);
         InitializeLimit();
     }
 
+    private void OnAudioTickRate(int obj)
+    {
+        _audioFrameTime = 1f / obj;
+        _audioFrameTimeRemaining = MathF.Min(_audioFrameTimeRemaining, _audioFrameTime);
+    }
+
     private void OnAudioState(EntityUid uid, AudioComponent component, ref AfterAutoHandleStateEvent args)
     {
         ApplyAudioParams(component.Params, component);
@@ -254,6 +261,13 @@ public sealed partial class AudioSystem : SharedAudioSystem
 
     public override void FrameUpdate(float frameTime)
     {
+        _audioFrameTimeRemaining -= frameTime;
+
+        if (_audioFrameTimeRemaining > 0f)
+            return;
+
+        // Clamp to 0 in case we have a really long frame.
+        _audioFrameTimeRemaining = MathF.Max(0f, _audioFrameTime + _audioFrameTimeRemaining);
         var eye = _eyeManager.CurrentEye;
         var localEntity = _playerManager.LocalEntity;
         Vector2 listenerVelocity;
@@ -277,9 +291,6 @@ public sealed partial class AudioSystem : SharedAudioSystem
             _streams.Add((uid, comp, xform));
         }
 
-        _mapManager.TryFindGridAt(ourPos, out var gridUid, out _);
-        _listenerGrid = gridUid == EntityUid.Invalid ? null : gridUid;
-
         try
         {
             _updateAudioJob.OurPosition = ourPos;
@@ -332,7 +343,6 @@ public sealed partial class AudioSystem : SharedAudioSystem
 
         Vector2 worldPos;
         component.Volume = component.Params.Volume;
-        Vector2 delta;
 
         // Handle grid audio differently by using grid position.
         if ((component.Flags & AudioFlags.GridAudio) != 0x0)
@@ -346,7 +356,7 @@ public sealed partial class AudioSystem : SharedAudioSystem
         }
 
         // Max distance check
-        delta = worldPos - listener.Position;
+        var delta = worldPos - listener.Position;
         var distance = delta.Length();
 
         // Out of range so just clip it for us.

Robust.Client/Audio/Sources/BufferedAudioSource.cs

@@ -1,24 +1,18 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Numerics;
 using OpenTK.Audio.OpenAL;
 using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
-using Robust.Client.Graphics;
 using Robust.Shared.Audio.Sources;
-using Robust.Shared.Maths;
 
 namespace Robust.Client.Audio.Sources;
 
 internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSource
 {
-    private int? SourceHandle = null;
     private int[] BufferHandles;
     private Dictionary<int, int> BufferMap = new();
     private readonly AudioManager _master;
     private bool _mono = true;
     private bool _float = false;
-    private int FilterHandle;
 
     public int SampleRate { get; set; } = 44100;
 
@@ -43,7 +37,7 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
         get
         {
             _checkDisposed();
-            var state = AL.GetSourceState(SourceHandle!.Value);
+            var state = AL.GetSourceState(SourceHandle);
             _master._checkAlError();
             return state == ALSourceState.Playing;
         }
@@ -53,7 +47,7 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
             {
                 _checkDisposed();
                 // IDK why this stackallocs but gonna leave it for now.
-                AL.SourcePlay(stackalloc int[] {SourceHandle!.Value});
+                AL.SourcePlay(stackalloc int[] {SourceHandle});
                 _master._checkAlError();
             }
             else
@@ -61,7 +55,7 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
                 if (_isDisposed())
                     return;
 
-                AL.SourceStop(SourceHandle!.Value);
+                AL.SourceStop(SourceHandle);
                 _master._checkAlError();
             }
         }
@@ -74,13 +68,13 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
 
     protected override void Dispose(bool disposing)
     {
-        if (SourceHandle == null)
+        if (SourceHandle == -1)
             return;
 
         if (!_master.IsMainThread())
         {
             // We can't run this code inside another thread so tell Clyde to clear it up later.
-            _master.DeleteBufferedSourceOnMainThread(SourceHandle.Value, FilterHandle);
+            _master.DeleteBufferedSourceOnMainThread(SourceHandle, FilterHandle);
 
             foreach (var handle in BufferHandles)
             {
@@ -92,21 +86,21 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
             if (FilterHandle != 0)
                 EFX.DeleteFilter(FilterHandle);
 
-            AL.DeleteSource(SourceHandle.Value);
+            AL.DeleteSource(SourceHandle);
             AL.DeleteBuffers(BufferHandles);
-            _master.RemoveBufferedAudioSource(SourceHandle.Value);
+            _master.RemoveBufferedAudioSource(SourceHandle);
             _master._checkAlError();
         }
 
         FilterHandle = 0;
-        SourceHandle = null;
+        SourceHandle = -1;
     }
 
     public int GetNumberOfBuffersProcessed()
     {
         _checkDisposed();
         // ReSharper disable once PossibleInvalidOperationException
-        AL.GetSource(SourceHandle!.Value, ALGetSourcei.BuffersProcessed, out var buffersProcessed);
+        AL.GetSource(SourceHandle, ALGetSourcei.BuffersProcessed, out var buffersProcessed);
         return buffersProcessed;
     }
 
@@ -116,7 +110,7 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
         var entries = Math.Min(Math.Min(handles.Length, BufferHandles.Length), GetNumberOfBuffersProcessed());
         fixed (int* ptr = handles)
         {
-            AL.SourceUnqueueBuffers(SourceHandle!.Value, entries, ptr);
+            AL.SourceUnqueueBuffers(SourceHandle, entries, ptr);
         }
 
         for (var i = 0; i < entries; i++)
@@ -183,7 +177,7 @@ internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSourc
         fixed (int* ptr = realHandles)
             // ReSharper disable once PossibleInvalidOperationException
         {
-            AL.SourceQueueBuffers(SourceHandle!.Value, handles.Length, ptr);
+            AL.SourceQueueBuffers(SourceHandle, handles.Length, ptr);
         }
     }
 

Robust.Client/Console/Commands/Debug.cs

@@ -291,9 +291,9 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal sealed class SnapGridGetCell : LocalizedCommands
+    internal sealed class SnapGridGetCell : LocalizedEntityCommands
     {
-        [Dependency] private readonly IEntityManager _entManager = default!;
+        [Dependency] private readonly SharedMapSystem _map = default!;
 
         public override string Command => "sggcell";
 
@@ -319,9 +319,10 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            if (_entManager.TryGetComponent<MapGridComponent>(_entManager.GetEntity(gridNet), out var grid))
+            var gridEnt = EntityManager.GetEntity(gridNet);
+            if (EntityManager.TryGetComponent<MapGridComponent>(gridEnt, out var grid))
             {
-                foreach (var entity in grid.GetAnchoredEntities(new Vector2i(
+                foreach (var entity in _map.GetAnchoredEntities(gridEnt, grid, new Vector2i(
                              int.Parse(indices.Split(',')[0], CultureInfo.InvariantCulture),
                              int.Parse(indices.Split(',')[1], CultureInfo.InvariantCulture))))
                 {
@@ -425,9 +426,9 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal sealed class GridTileCount : LocalizedCommands
+    internal sealed class GridTileCount : LocalizedEntityCommands
     {
-        [Dependency] private readonly IEntityManager _entManager = default!;
+        [Dependency] private readonly SharedMapSystem _map = default!;
 
         public override string Command => "gridtc";
 
@@ -440,15 +441,15 @@ namespace Robust.Client.Console.Commands
             }
 
             if (!NetEntity.TryParse(args[0], out var gridUidNet) ||
-                !_entManager.TryGetEntity(gridUidNet, out var gridUid))
+                !EntityManager.TryGetEntity(gridUidNet, out var gridUid))
             {
                 shell.WriteLine($"{args[0]} is not a valid entity UID.");
                 return;
             }
 
-            if (_entManager.TryGetComponent<MapGridComponent>(gridUid, out var grid))
+            if (EntityManager.TryGetComponent<MapGridComponent>(gridUid, out var grid))
             {
-                shell.WriteLine(grid.GetAllTiles().Count().ToString());
+                shell.WriteLine(_map.GetAllTiles(gridUid.Value, grid).Count().ToString());
             }
             else
             {
@@ -578,7 +579,20 @@ namespace Robust.Client.Console.Commands
         private static string GetMemberValue(MemberInfo? member, Control control, string separator, string
                 wrap = "{0}")
         {
-            var value = member?.GetValue(control);
+            object? value = null;
+            try
+            {
+                value = member?.GetValue(control);
+            }
+            catch (TargetInvocationException exception)
+            {
+                var exceptionToPrint = exception.InnerException ?? exception;
+                value = $"{exceptionToPrint.GetType()}: {exceptionToPrint.Message}";
+            }
+            catch (Exception exception)
+            {
+                value = $"{exception.GetType()}: {exception.Message}";
+            }
             var o = value switch
             {
                 ICollection<Control> controls => string.Join(separator,
@@ -680,12 +694,12 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal sealed class ChunkInfoCommand : LocalizedCommands
+    internal sealed class ChunkInfoCommand : LocalizedEntityCommands
     {
-        [Dependency] private readonly IEntityManager _entManager = default!;
         [Dependency] private readonly IMapManager _map = default!;
         [Dependency] private readonly IEyeManager _eye = default!;
         [Dependency] private readonly IInputManager _input = default!;
+        [Dependency] private readonly SharedMapSystem _mapSystem = default!;
 
         public override string Command => "chunkinfo";
 
@@ -699,8 +713,8 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var mapSystem = _entManager.System<SharedMapSystem>();
-            var chunkIndex = mapSystem.LocalToChunkIndices(gridUid, grid, grid.MapToGrid(mousePos));
+            var mapSystem = EntityManager.System<SharedMapSystem>();
+            var chunkIndex = mapSystem.LocalToChunkIndices(gridUid, grid, _mapSystem.MapToGrid(gridUid, mousePos));
             var chunk = mapSystem.GetOrAddChunk(gridUid, grid, chunkIndex);
 
             shell.WriteLine($"worldBounds: {mapSystem.CalcWorldAABB(gridUid, grid, chunk)} localBounds: {chunk.CachedBounds}");

Robust.Client/Console/Commands/DumpMetadataMembersCommand.cs

@@ -11,7 +11,7 @@ namespace Robust.Client.Console.Commands
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var type = Type.GetType(args[0]);
+            var type = GetType(args[0]);
 
             if (type == null)
             {
@@ -25,6 +25,17 @@ namespace Robust.Client.Console.Commands
                 shell.WriteLine(sig);
             }
         }
+
+        private Type? GetType(string name)
+        {
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                if (assembly.GetType(name) is { } type)
+                    return type;
+            }
+
+            return null;
+        }
     }
 #endif
 }

Robust.Client/Console/Commands/GridChunkBBCommand.cs

@@ -1,16 +1,19 @@
 using Robust.Client.GameObjects;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 
 namespace Robust.Client.Console.Commands
 {
-    public sealed class GridChunkBBCommand : LocalizedCommands
+    public sealed class GridChunkBBCommand : LocalizedEntityCommands
     {
+        [Dependency] private readonly GridChunkBoundsDebugSystem _system = default!;
+
         public override string Command => "showchunkbb";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            EntitySystem.Get<GridChunkBoundsDebugSystem>().Enabled ^= true;
+            _system.Enabled ^= true;
         }
     }
 }

Robust.Client/Console/Commands/UITestCommand.cs

@@ -204,7 +204,7 @@ Suspendisse hendrerit blandit urna ut laoreet. Suspendisse ac elit at erat males
     private Control TabRichText()
     {
         var label = new RichTextLabel();
-        label.SetMessage(FormattedMessage.FromMarkup(Lipsum));
+        label.SetMessage(FormattedMessage.FromMarkupOrThrow(Lipsum));
 
         TabContainer.SetTabTitle(label, "RichText");
         return label;

Robust.Client/Debugging/DebugDrawingSystem.cs

@@ -1,4 +1,5 @@
 using System.Numerics;
+using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
@@ -14,6 +15,8 @@ namespace Robust.Client.Debugging
     {
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
         [Dependency] private readonly EntityLookupSystem _lookup = default!;
+        [Dependency] private readonly TransformSystem _transform = default!;
+
 
         private bool _debugPositions;
         private bool _debugRotations;
@@ -35,7 +38,7 @@ namespace Robust.Client.Debugging
 
                 if (value && !_overlayManager.HasOverlay<EntityPositionOverlay>())
                 {
-                    _overlayManager.AddOverlay(new EntityPositionOverlay(_lookup, EntityManager));
+                    _overlayManager.AddOverlay(new EntityPositionOverlay(_lookup, EntityManager, _transform));
                 }
                 else
                 {
@@ -74,13 +77,15 @@ namespace Robust.Client.Debugging
         {
             private readonly EntityLookupSystem _lookup;
             private readonly IEntityManager _entityManager;
+            private readonly SharedTransformSystem _transform;
 
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public EntityPositionOverlay(EntityLookupSystem lookup, IEntityManager entityManager)
+            public EntityPositionOverlay(EntityLookupSystem lookup, IEntityManager entityManager, SharedTransformSystem transform)
             {
                 _lookup = lookup;
                 _entityManager = entityManager;
+                _transform = transform;
             }
 
             protected internal override void Draw(in OverlayDrawArgs args)
@@ -88,11 +93,10 @@ namespace Robust.Client.Debugging
                 const float stubLength = 0.25f;
 
                 var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
-                var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
 
                 foreach (var entity in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldBounds))
                 {
-                    var (center, worldRotation) = xformQuery.GetComponent(entity).GetWorldPositionRotation();
+                    var (center, worldRotation) = _transform.GetWorldPositionRotation(entity);
 
                     var xLine = worldRotation.RotateVec(Vector2.UnitX);
                     var yLine = worldRotation.RotateVec(Vector2.UnitY);

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -47,6 +47,7 @@
 using System;
 using System.Collections.Generic;
 using System.Numerics;
+using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
 using Robust.Client.Player;
@@ -78,6 +79,14 @@ namespace Robust.Client.Debugging
         internal int PointCount;
 
         [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+        [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
+        [Dependency] private readonly TransformSystem _transform = default!;
+        [Dependency] private readonly IOverlayManager _overlay = default!;
+        [Dependency] private readonly IEyeManager _eye = default!;
+        [Dependency] private readonly IInputManager _input = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+        [Dependency] private readonly IPlayerManager _player = default!;
+        [Dependency] private readonly IResourceCache _resourceCache = default!;
 
         internal ContactPoint[] Points = new ContactPoint[MaxContactPoints];
 
@@ -89,20 +98,21 @@ namespace Robust.Client.Debugging
                 if (value == _flags) return;
 
                 if (_flags == PhysicsDebugFlags.None)
-                    IoCManager.Resolve<IOverlayManager>().AddOverlay(
+                    _overlay.AddOverlay(
                         new PhysicsDebugOverlay(
                             EntityManager,
-                            IoCManager.Resolve<IEyeManager>(),
-                            IoCManager.Resolve<IInputManager>(),
-                            IoCManager.Resolve<IMapManager>(),
-                            IoCManager.Resolve<IPlayerManager>(),
-                            IoCManager.Resolve<IResourceCache>(),
+                            _eye,
+                            _input,
+                            _map,
+                            _player,
+                            _resourceCache,
                             this,
-                            Get<EntityLookupSystem>(),
-                            Get<SharedPhysicsSystem>()));
+                            _entityLookup,
+                            _physics,
+                            _transform));
 
                 if (value == PhysicsDebugFlags.None)
-                    IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsDebugOverlay));
+                    _overlay.RemoveOverlay(typeof(PhysicsDebugOverlay));
 
                 _flags = value;
             }
@@ -198,6 +208,7 @@ namespace Robust.Client.Debugging
         private readonly DebugPhysicsSystem _debugPhysicsSystem;
         private readonly EntityLookupSystem _lookup;
         private readonly SharedPhysicsSystem _physicsSystem;
+        private readonly SharedTransformSystem _transformSystem;
 
         public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
 
@@ -208,7 +219,7 @@ namespace Robust.Client.Debugging
         private HashSet<Joint> _drawnJoints = new();
         private List<Entity<MapGridComponent>> _grids = new();
 
-        public PhysicsDebugOverlay(IEntityManager entityManager, IEyeManager eyeManager, IInputManager inputManager, IMapManager mapManager, IPlayerManager playerManager, IResourceCache cache, DebugPhysicsSystem system, EntityLookupSystem lookup, SharedPhysicsSystem physicsSystem)
+        public PhysicsDebugOverlay(IEntityManager entityManager, IEyeManager eyeManager, IInputManager inputManager, IMapManager mapManager, IPlayerManager playerManager, IResourceCache cache, DebugPhysicsSystem system, EntityLookupSystem lookup, SharedPhysicsSystem physicsSystem, SharedTransformSystem transformSystem)
         {
             _entityManager = entityManager;
             _eyeManager = eyeManager;
@@ -218,6 +229,7 @@ namespace Robust.Client.Debugging
             _debugPhysicsSystem = system;
             _lookup = lookup;
             _physicsSystem = physicsSystem;
+            _transformSystem = transformSystem;
             _font = new VectorFont(cache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
         }
 
@@ -327,7 +339,7 @@ namespace Robust.Client.Debugging
                 {
                     if (jointComponent.JointCount == 0 ||
                         !_entityManager.TryGetComponent(uid, out TransformComponent? xf1) ||
-                        !viewAABB.Contains(xf1.WorldPosition)) continue;
+                        !viewAABB.Contains(_transformSystem.GetWorldPosition(xf1))) continue;
 
                     foreach (var (_, joint) in jointComponent.Joints)
                     {
@@ -517,8 +529,8 @@ namespace Robust.Client.Debugging
             if (!_entityManager.TryGetComponent(joint.BodyAUid, out TransformComponent? xform1) ||
                 !_entityManager.TryGetComponent(joint.BodyBUid, out TransformComponent? xform2)) return;
 
-            var matrix1 = xform1.WorldMatrix;
-            var matrix2 = xform2.WorldMatrix;
+            var matrix1 = _transformSystem.GetWorldMatrix(xform1);
+            var matrix2 = _transformSystem.GetWorldMatrix(xform2);
 
             var xf1 = new Vector2(matrix1.M31, matrix1.M32);
             var xf2 = new Vector2(matrix2.M31, matrix2.M32);
@@ -526,8 +538,8 @@ namespace Robust.Client.Debugging
             var p1 = Vector2.Transform(joint.LocalAnchorA, matrix1);
             var p2 = Vector2.Transform(joint.LocalAnchorB, matrix2);
 
-            var xfa = new Transform(xf1, xform1.WorldRotation);
-            var xfb = new Transform(xf2, xform2.WorldRotation);
+            var xfa = new Transform(xf1, _transformSystem.GetWorldRotation(xform1));
+            var xfb = new Transform(xf2, _transformSystem.GetWorldRotation(xform2));
 
             switch (joint)
             {

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -26,6 +26,9 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IBaseClient _client = default!;
         [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
 
+        internal event Action? AfterStartup;
+        internal event Action? AfterShutdown;
+
         public override void Initialize()
         {
             SetupNetworking();
@@ -34,6 +37,20 @@ namespace Robust.Client.GameObjects
             base.Initialize();
         }
 
+        public override void Startup()
+        {
+            base.Startup();
+
+            AfterStartup?.Invoke();
+        }
+
+        public override void Shutdown()
+        {
+            base.Shutdown();
+
+            AfterShutdown?.Invoke();
+        }
+
         public override void FlushEntities()
         {
             // Server doesn't network deletions on client shutdown so we need to
@@ -48,16 +65,6 @@ namespace Robust.Client.GameObjects
             return base.CreateEntity(prototypeName, out metadata);
         }
 
-        void IClientEntityManagerInternal.InitializeEntity(EntityUid entity, MetaDataComponent? meta)
-        {
-            base.InitializeEntity(entity, meta);
-        }
-
-        void IClientEntityManagerInternal.StartEntity(EntityUid entity)
-        {
-            base.StartEntity(entity);
-        }
-
         /// <inheritdoc />
         public override void DirtyEntity(EntityUid uid, MetaDataComponent? meta = null)
         {
@@ -128,7 +135,10 @@ namespace Robust.Client.GameObjects
             var sequence = _stateMan.SystemMessageDispatched(msg);
             EntityNetManager?.SendSystemNetworkMessage(msg, sequence);
 
-            DebugTools.Assert(!_stateMan.IsPredictionEnabled || _gameTiming.InPrediction && _gameTiming.IsFirstTimePredicted || _client.RunLevel != ClientRunLevel.Connected);
+            if (!_stateMan.IsPredictionEnabled && _client.RunLevel != ClientRunLevel.SinglePlayerGame)
+                return;
+
+            DebugTools.Assert(_gameTiming.InPrediction && _gameTiming.IsFirstTimePredicted || _client.RunLevel == ClientRunLevel.SinglePlayerGame);
 
             var eventArgs = new EntitySessionEventArgs(session!);
             EventBus.RaiseEvent(EventSource.Local, msg);

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -76,7 +76,8 @@ namespace Robust.Client.GameObjects
             foreach (var key in remie)
             {
                 component.PlayingAnimations.Remove(key);
-                EntityManager.EventBus.RaiseLocalEvent(uid, new AnimationCompletedEvent {Uid = uid, Key = key}, true);
+                var completedEvent = new AnimationCompletedEvent {Uid = uid, Key = key, Finished = true};
+                EntityManager.EventBus.RaiseLocalEvent(uid, completedEvent, true);
             }
 
             return false;
@@ -187,7 +188,8 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            EntityManager.EventBus.RaiseLocalEvent(entity.Owner, new AnimationCompletedEvent {Uid = entity.Owner, Key = key}, true);
+            var completedEvent = new AnimationCompletedEvent {Uid = entity.Owner, Key = key, Finished = false};
+            EntityManager.EventBus.RaiseLocalEvent(entity.Owner, completedEvent, true);
         }
 
         public void Stop(EntityUid uid, AnimationPlayerComponent? component, string key)
@@ -203,5 +205,11 @@ namespace Robust.Client.GameObjects
     {
         public EntityUid Uid { get; init; }
         public string Key { get; init; } = string.Empty;
+
+        /// <summary>
+        /// If true, the animation finished by getting to its natural end.
+        /// If false, it was removed prematurely via <see cref="AnimationPlayerSystem.Stop(Robust.Client.GameObjects.AnimationPlayerComponent,string)"/> or similar overloads.
+        /// </summary>
+        public bool Finished { get; init; }
     }
 }

Robust.Client/GameObjects/EntitySystems/AppearanceSystem.cs

@@ -2,8 +2,11 @@ using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization;
 using Robust.Shared.GameStates;
 using Robust.Shared.Utility;
+using Robust.Shared.Serialization.Manager;
 
 namespace Robust.Client.GameObjects
 {
@@ -11,6 +14,7 @@ namespace Robust.Client.GameObjects
     public sealed class AppearanceSystem : SharedAppearanceSystem
     {
         private readonly Queue<(EntityUid uid, AppearanceComponent)> _queuedUpdates = new();
+        [Dependency] private readonly ISerializationManager _serialization = default!;
 
         public override void Initialize()
         {
@@ -74,10 +78,13 @@ namespace Robust.Client.GameObjects
 
             foreach (var (key, value) in data)
             {
+                object? serializationObject;
                 if (value.GetType().IsValueType)
                     newDict[key] = value;
                 else if (value is ICloneable cloneable)
                     newDict[key] = cloneable.Clone();
+                else if ((serializationObject = _serialization.CreateCopy(value)) != null)
+                    newDict[key] = serializationObject;
                 else
                     throw new NotSupportedException("Invalid object in appearance data dictionary. Appearance data must be cloneable");
             }

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -6,6 +6,7 @@ using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using System;
 using System.Collections.Generic;
+using Robust.Shared.IoC;
 using static Robust.Shared.GameObjects.OccluderComponent;
 
 namespace Robust.Client.GameObjects;
@@ -20,6 +21,7 @@ namespace Robust.Client.GameObjects;
 internal sealed class ClientOccluderSystem : OccluderSystem
 {
     private readonly HashSet<EntityUid> _dirtyEntities = new();
+    [Dependency] private readonly SharedMapSystem _mapSystem = default!;
 
     /// <inheritdoc />
     public override void Initialize()
@@ -102,7 +104,8 @@ internal sealed class ClientOccluderSystem : OccluderSystem
 
         if (occluder.Enabled && xform.Anchored && TryComp(xform.GridUid, out grid))
         {
-            pos = grid.TileIndicesFor(xform.Coordinates);
+            gridId = xform.GridUid.Value;
+            pos = _mapSystem.TileIndicesFor(gridId, grid, xform.Coordinates);
             _dirtyEntities.Add(sender);
         }
         else if (occluder.LastPosition != null)
@@ -117,10 +120,10 @@ internal sealed class ClientOccluderSystem : OccluderSystem
             return;
         }
 
-        DirtyNeighbours(grid.GetAnchoredEntitiesEnumerator(pos + new Vector2i(0, 1)), query);
-        DirtyNeighbours(grid.GetAnchoredEntitiesEnumerator(pos + new Vector2i(0, -1)), query);
-        DirtyNeighbours(grid.GetAnchoredEntitiesEnumerator(pos + new Vector2i(1, 0)), query);
-        DirtyNeighbours(grid.GetAnchoredEntitiesEnumerator(pos + new Vector2i(-1, 0)), query);
+        DirtyNeighbours(_mapSystem.GetAnchoredEntitiesEnumerator(gridId, grid, pos + new Vector2i(0, 1)), query);
+        DirtyNeighbours(_mapSystem.GetAnchoredEntitiesEnumerator(gridId, grid, pos + new Vector2i(0, -1)), query);
+        DirtyNeighbours(_mapSystem.GetAnchoredEntitiesEnumerator(gridId, grid, pos + new Vector2i(1, 0)), query);
+        DirtyNeighbours(_mapSystem.GetAnchoredEntitiesEnumerator(gridId, grid, pos + new Vector2i(-1, 0)), query);
     }
 
     private void DirtyNeighbours(AnchoredEntitiesEnumerator enumerator, EntityQuery<OccluderComponent> occluderQuery)
@@ -166,7 +169,7 @@ internal sealed class ClientOccluderSystem : OccluderSystem
             return;
         }
 
-        var tile = grid.TileIndicesFor(xform.Coordinates);
+        var tile = _mapSystem.TileIndicesFor(xform.GridUid.Value, grid, xform.Coordinates);
 
         // TODO: Sub to parent changes instead or something.
         // DebugTools.Assert(occluder.LastPosition == null
@@ -175,16 +178,16 @@ internal sealed class ClientOccluderSystem : OccluderSystem
 
         // dir starts at the relative effective south direction;
         var dir = xform.LocalRotation.GetCardinalDir();
-        CheckDir(dir, OccluderDir.South, tile, occluder, grid, occluders, xforms);
+        CheckDir(dir, OccluderDir.South, tile, occluder, xform.GridUid.Value, grid, occluders, xforms);
 
         dir = dir.GetClockwise90Degrees();
-        CheckDir(dir, OccluderDir.West, tile, occluder, grid, occluders, xforms);
+        CheckDir(dir, OccluderDir.West, tile, occluder, xform.GridUid.Value, grid, occluders, xforms);
 
         dir = dir.GetClockwise90Degrees();
-        CheckDir(dir, OccluderDir.North, tile, occluder, grid, occluders, xforms);
+        CheckDir(dir, OccluderDir.North, tile, occluder, xform.GridUid.Value, grid, occluders, xforms);
 
         dir = dir.GetClockwise90Degrees();
-        CheckDir(dir, OccluderDir.East, tile, occluder, grid, occluders, xforms);
+        CheckDir(dir, OccluderDir.East, tile, occluder, xform.GridUid.Value, grid, occluders, xforms);
     }
 
     private void CheckDir(
@@ -192,6 +195,7 @@ internal sealed class ClientOccluderSystem : OccluderSystem
         OccluderDir occDir,
         Vector2i tile,
         OccluderComponent occluder,
+        EntityUid gridUid,
         MapGridComponent grid,
         EntityQuery<OccluderComponent> query,
         EntityQuery<TransformComponent> xforms)
@@ -199,7 +203,7 @@ internal sealed class ClientOccluderSystem : OccluderSystem
         if ((occluder.Occluding & occDir) != 0)
             return;
 
-        foreach (var neighbor in grid.GetAnchoredEntities(tile.Offset(dir)))
+        foreach (var neighbor in _mapSystem.GetAnchoredEntities(gridUid, grid, tile.Offset(dir)))
         {
             if (!query.TryGetComponent(neighbor, out var otherOccluder) || !otherOccluder.Enabled)
                 continue;

Robust.Client/GameObjects/EntitySystems/GridChunkBoundsDebugSystem.cs

@@ -18,6 +18,8 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
+        [Dependency] private readonly TransformSystem _transform = default!;
+        [Dependency] private readonly SharedMapSystem _map = default!;
 
         private GridChunkBoundsOverlay? _overlay;
 
@@ -36,7 +38,9 @@ namespace Robust.Client.GameObjects
                     _overlay = new GridChunkBoundsOverlay(
                         EntityManager,
                         _eyeManager,
-                        _mapManager);
+                        _mapManager,
+                        _transform,
+                        _map);
 
                     _overlayManager.AddOverlay(_overlay);
                 }
@@ -56,16 +60,20 @@ namespace Robust.Client.GameObjects
         private readonly IEntityManager _entityManager;
         private readonly IEyeManager _eyeManager;
         private readonly IMapManager _mapManager;
+        private readonly SharedTransformSystem _transformSystem;
+        private readonly SharedMapSystem _mapSystem;
 
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
         private List<Entity<MapGridComponent>> _grids = new();
 
-        public GridChunkBoundsOverlay(IEntityManager entManager, IEyeManager eyeManager, IMapManager mapManager)
+        public GridChunkBoundsOverlay(IEntityManager entManager, IEyeManager eyeManager, IMapManager mapManager, SharedTransformSystem transformSystem, SharedMapSystem mapSystem)
         {
             _entityManager = entManager;
             _eyeManager = eyeManager;
             _mapManager = mapManager;
+            _transformSystem = transformSystem;
+            _mapSystem = mapSystem;
         }
 
         protected internal override void Draw(in OverlayDrawArgs args)
@@ -78,11 +86,11 @@ namespace Robust.Client.GameObjects
             _mapManager.FindGridsIntersecting(currentMap, viewport, ref _grids);
             foreach (var grid in _grids)
             {
-                var worldMatrix = _entityManager.GetComponent<TransformComponent>(grid).WorldMatrix;
+                var worldMatrix = _transformSystem.GetWorldMatrix(grid);
                 worldHandle.SetTransform(worldMatrix);
                 var transform = new Transform(Vector2.Zero, Angle.Zero);
 
-                var chunkEnumerator = grid.Comp.GetMapChunks(viewport);
+                var chunkEnumerator = _mapSystem.GetMapChunks(grid.Owner, grid.Comp, viewport);
 
                 while (chunkEnumerator.MoveNext(out var chunk))
                 {

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -196,7 +196,7 @@ namespace Robust.Client.GameObjects
                 wOffset = new Vector2(wX, wY);
             }
 
-            var coords = EntityCoordinates.FromMap(pent, _transform.GetMapCoordinates(pent).Offset(wOffset), _transform, EntityManager);
+            var coords = _transform.ToCoordinates(pent, _transform.GetMapCoordinates(pent).Offset(wOffset));
             var funcId = _inputManager.NetworkBindMap.KeyFunctionID(keyFunction);
 
             var message = new ClientFullInputCmdMessage(_timing.CurTick,

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Helpers.cs

@@ -0,0 +1,43 @@
+using System.Numerics;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+
+namespace Robust.Client.GameObjects;
+
+public sealed partial class SpriteSystem
+{
+    /// <summary>
+    /// Gets an entity's sprite position in world terms.
+    /// </summary>
+    public Vector2 GetSpriteWorldPosition(Entity<SpriteComponent?, TransformComponent?> entity)
+    {
+        if (!Resolve(entity, ref entity.Comp2))
+            return Vector2.Zero;
+
+        var (worldPos, worldRot) = _xforms.GetWorldPositionRotation(entity.Owner);
+
+        if (!Resolve(entity, ref entity.Comp1, false))
+        {
+            return worldPos;
+        }
+
+        if (entity.Comp1.NoRotation)
+        {
+            return worldPos + entity.Comp1.Offset;
+        }
+
+        return worldPos + worldRot.RotateVec(entity.Comp1.Rotation.RotateVec(entity.Comp1.Offset));
+    }
+
+    /// <summary>
+    /// Gets an entity's sprite position in screen coordinates.
+    /// </summary>
+    public ScreenCoordinates GetSpriteScreenCoordinates(Entity<SpriteComponent?, TransformComponent?> entity)
+    {
+        if (!Resolve(entity, ref entity.Comp2))
+            return ScreenCoordinates.Invalid;
+
+        var spriteCoords = GetSpriteWorldPosition(entity);
+        return _eye.MapToScreen(new MapCoordinates(spriteCoords, entity.Comp2.MapID));
+    }
+}

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -30,10 +30,12 @@ namespace Robust.Client.GameObjects
     public sealed partial class SpriteSystem : EntitySystem
     {
         [Dependency] private readonly IConfigurationManager _cfg = default!;
+        [Dependency] private readonly IEyeManager _eye = default!;
         [Dependency] private readonly IGameTiming _timing = default!;
         [Dependency] private readonly IPrototypeManager _proto = default!;
         [Dependency] private readonly IResourceCache _resourceCache = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
+        [Dependency] private readonly SharedTransformSystem _xforms = default!;
 
         private readonly Queue<SpriteComponent> _inertUpdateQueue = new();
 
@@ -66,6 +68,11 @@ namespace Robust.Client.GameObjects
             _sawmill = _logManager.GetSawmill("sprite");
         }
 
+        public bool IsVisible(Layer layer)
+        {
+            return layer.Visible && layer.CopyToShaderParameters == null;
+        }
+
         private void OnInit(EntityUid uid, SpriteComponent component, ComponentInit args)
         {
             // I'm not 100% this is needed, but I CBF with this ATM. Somebody kill server sprite component please.
@@ -184,7 +191,8 @@ namespace Robust.Client.GameObjects
         /// <summary>
         /// Gets the specified frame for this sprite at the specified time.
         /// </summary>
-        public Texture GetFrame(SpriteSpecifier spriteSpec, TimeSpan curTime)
+        /// <param name="loop">Should we clamp on the last frame and not loop</param>
+        public Texture GetFrame(SpriteSpecifier spriteSpec, TimeSpan curTime, bool loop = true)
         {
             Texture? sprite = null;
 
@@ -196,19 +204,29 @@ namespace Robust.Client.GameObjects
                     var frames = state!.GetFrames(RsiDirection.South);
                     var delays = state.GetDelays();
                     var totalDelay = delays.Sum();
-                    var time = curTime.TotalSeconds % totalDelay;
-                    var delaySum = 0f;
 
-                    for (var i = 0; i < delays.Length; i++)
+                    // No looping
+                    if (!loop && curTime.TotalSeconds >= totalDelay)
                     {
-                        var delay = delays[i];
-                        delaySum += delay;
+                        sprite = frames[^1];
+                    }
+                    // Loopable
+                    else
+                    {
+                        var time = curTime.TotalSeconds % totalDelay;
+                        var delaySum = 0f;
 
-                        if (time > delaySum)
-                            continue;
+                        for (var i = 0; i < delays.Length; i++)
+                        {
+                            var delay = delays[i];
+                            delaySum += delay;
 
-                        sprite = frames[i];
-                        break;
+                            if (time > delaySum)
+                                continue;
+
+                            sprite = frames[i];
+                            break;
+                        }
                     }
 
                     sprite ??= Frame0(spriteSpec);

Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -1,8 +1,38 @@
 using Robust.Shared.GameObjects;
+using Robust.Shared.Prototypes;
 
 namespace Robust.Client.GameObjects;
 
 public sealed class UserInterfaceSystem : SharedUserInterfaceSystem
 {
+    public override void Initialize()
+    {
+        base.Initialize();
+        ProtoManager.PrototypesReloaded += OnProtoReload;
+    }
 
+    public override void Shutdown()
+    {
+        base.Shutdown();
+        ProtoManager.PrototypesReloaded -= OnProtoReload;
+    }
+
+    private void OnProtoReload(PrototypesReloadedEventArgs obj)
+    {
+        var player = Player.LocalEntity;
+
+        if (!UserQuery.TryComp(player, out var userComp))
+            return;
+
+        foreach (var uid in userComp.OpenInterfaces.Keys)
+        {
+            if (!UIQuery.TryComp(uid, out var uiComp))
+                continue;
+
+            foreach (var bui in uiComp.ClientOpenInterfaces.Values)
+            {
+                bui.OnProtoReload(obj);
+            }
+        }
+    }
 }

Robust.Client/GameObjects/EntitySystems/VelocityDebugSystem.cs

@@ -14,6 +14,7 @@ namespace Robust.Client.GameObjects
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly TransformSystem _transform = default!;
 
         internal bool Enabled { get; set; }
 
@@ -43,7 +44,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            var screenPos = _eyeManager.WorldToScreen(EntityManager.GetComponent<TransformComponent>(player.Value).WorldPosition);
+            var screenPos = _eyeManager.WorldToScreen(_transform.GetWorldPosition(Transform(player.Value)));
             LayoutContainer.SetPosition(_label, screenPos + new Vector2(0, 50));
             _label.Visible = true;
 

Robust.Client/GameObjects/EntitySystems/ViewSubscriberSystem.cs

@@ -0,0 +1,5 @@
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.GameObjects;
+
+public sealed class ViewSubscriberSystem : SharedViewSubscriberSystem;

Robust.Client/GameObjects/IClientEntityManagerInternal.cs

@@ -7,9 +7,5 @@ namespace Robust.Client.GameObjects
         // These methods are used by the Game State Manager.
 
         EntityUid CreateEntity(string? prototypeName, out MetaDataComponent metadata);
-
-        void InitializeEntity(EntityUid entity, MetaDataComponent? meta = null);
-
-        void StartEntity(EntityUid entity);
     }
 }

Robust.Client/Graphics/Clyde/Clyde.Events.cs

@@ -33,7 +33,7 @@ namespace Robust.Client.Graphics.Clyde
 #if EXCEPTION_TOLERANCE_LOCAL
                 catch (Exception e)
                 {
-                    Logger.ErrorS("clyde.win", $"Error dispatching window event {ev.GetType().Name}:\n{e}");
+                    _sawmillWin.Error($"Error dispatching window event {ev.GetType().Name}:\n{e}");
                 }
 #endif
             }

Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs

@@ -5,7 +5,6 @@ using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Graphics;
-using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Maths;
@@ -15,8 +14,6 @@ namespace Robust.Client.Graphics.Clyde
 {
     internal partial class Clyde
     {
-        [Dependency] private readonly IEntityManager _entityManager = default!;
-
         private readonly Dictionary<EntityUid, Dictionary<Vector2i, MapChunkData>> _mapChunkData =
             new();
 
@@ -67,7 +64,7 @@ namespace Robust.Client.Graphics.Clyde
                 }
 
                 var transform = _entityManager.GetComponent<TransformComponent>(mapGrid);
-                gridProgram.SetUniform(UniIModelMatrix, transform.WorldMatrix);
+                gridProgram.SetUniform(UniIModelMatrix, _transformSystem.GetWorldMatrix(transform));
                 var enumerator = mapSystem.GetMapChunks(mapGrid.Owner, mapGrid.Comp, worldBounds);
 
                 while (enumerator.MoveNext(out var chunk))

Robust.Client/Graphics/Clyde/Clyde.HLR.cs

@@ -9,6 +9,7 @@ using Robust.Client.ResourceManagement;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared;
 using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Graphics;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
@@ -513,7 +514,7 @@ namespace Robust.Client.Graphics.Clyde
 
                     if (_lightManager.Enabled && _lightManager.DrawHardFov && eye.DrawLight && eye.DrawFov)
                     {
-                        var mapUid = _mapManager.GetMapEntityId(eye.Position.MapId);
+                        var mapUid = _mapSystem.GetMap(eye.Position.MapId);
                         if (_entityManager.GetComponent<MapComponent>(mapUid).LightingEnabled)
                             ApplyFovToBuffer(viewport, eye);
                     }

Robust.Client/Graphics/Clyde/Clyde.LightRendering.cs

@@ -203,7 +203,7 @@ namespace Robust.Client.Graphics.Clyde
                     return resource.ClydeHandle;
                 }
 
-                Logger.Warning($"Can't load shader {path}\n");
+                _clydeSawmill.Warning($"Can't load shader {path}\n");
                 return default;
             }
 
@@ -345,13 +345,12 @@ namespace Robust.Client.Graphics.Clyde
                 return;
 
             // If this map has lighting disabled, return
-            var mapUid = _mapManager.GetMapEntityId(mapId);
+            var mapUid = _mapSystem.GetMapOrInvalid(mapId);
             if (!_entityManager.TryGetComponent<MapComponent>(mapUid, out var map) || !map.LightingEnabled)
             {
                 return;
             }
 
-            (PointLightComponent light, Vector2 pos, float distanceSquared, Angle rot)[] lights;
             int count;
             Box2 expandedBounds;
             using (_prof.Group("LightsToRender"))
@@ -541,7 +540,6 @@ namespace Robust.Client.Graphics.Clyde
             Clyde clyde,
             int count,
             int shadowCastingCount,
-            TransformSystem xformSystem,
             EntityQuery<TransformComponent> xforms,
             Box2 worldAABB) state,
             in ComponentTreeEntry<PointLightComponent> value)
@@ -554,7 +552,7 @@ namespace Robust.Client.Graphics.Clyde
                 return false;
 
             var (light, transform) = value;
-            var (lightPos, rot) = state.xformSystem.GetWorldPositionRotation(transform, state.xforms);
+            var (lightPos, rot) = state.clyde._transformSystem.GetWorldPositionRotation(transform, state.xforms);
             lightPos += rot.RotateVec(light.Offset);
             var circle = new Circle(lightPos, light.Radius);
 
@@ -600,16 +598,13 @@ namespace Robust.Client.Graphics.Clyde
             in Box2Rotated worldBounds,
             in Box2 worldAABB)
         {
-            var lightTreeSys = _entitySystemManager.GetEntitySystem<LightTreeSystem>();
-            var xformSystem = _entitySystemManager.GetEntitySystem<TransformSystem>();
-
             // Use worldbounds for this one as we only care if the light intersects our actual bounds
             var xforms = _entityManager.GetEntityQuery<TransformComponent>();
-            var state = (this, count: 0, shadowCastingCount: 0, xformSystem, xforms, worldAABB);
+            var state = (this, count: 0, shadowCastingCount: 0, xforms, worldAABB);
 
-            foreach (var (uid, comp) in lightTreeSys.GetIntersectingTrees(map, worldAABB))
+            foreach (var (uid, comp) in _lightTreeSystem.GetIntersectingTrees(map, worldAABB))
             {
-                var bounds = xformSystem.GetInvWorldMatrix(uid, xforms).TransformBox(worldBounds);
+                var bounds = _transformSystem.GetInvWorldMatrix(uid, xforms).TransformBox(worldBounds);
                 comp.Tree.QueryAabb(ref state, LightQuery, bounds);
             }
 
@@ -941,18 +936,16 @@ namespace Robust.Client.Graphics.Clyde
             var imi = 0;
             var amiMax = _maxOccluders * 4;
 
-            var occluderSystem = _entitySystemManager.GetEntitySystem<OccluderSystem>();
-            var xformSystem = _entitySystemManager.GetEntitySystem<TransformSystem>();
             var xforms = _entityManager.GetEntityQuery<TransformComponent>();
 
             try
             {
-                foreach (var (uid, comp) in occluderSystem.GetIntersectingTrees(map, expandedBounds))
+                foreach (var (uid, comp) in _occluderSystem.GetIntersectingTrees(map, expandedBounds))
                 {
                     if (ami >= amiMax)
                         break;
 
-                    var treeBounds = xforms.GetComponent(uid).InvWorldMatrix.TransformBox(expandedBounds);
+                    var treeBounds = _transformSystem.GetInvWorldMatrix(uid).TransformBox(expandedBounds);
 
                     comp.Tree.QueryAabb((in ComponentTreeEntry<OccluderComponent> entry) =>
                     {
@@ -965,7 +958,7 @@ namespace Robust.Client.Graphics.Clyde
                         if (ami >= amiMax)
                             return false;
 
-                        var worldTransform = xformSystem.GetWorldMatrix(transform, xforms);
+                        var worldTransform = _transformSystem.GetWorldMatrix(transform, xforms);
                         var box = occluder.BoundingBox;
 
                         var tl = Vector2.Transform(box.TopLeft, worldTransform);

Robust.Client/Graphics/Clyde/Clyde.Rendering.cs

@@ -496,6 +496,9 @@ namespace Robust.Client.Graphics.Clyde
                     case bool b:
                         program.SetUniform(name, b ? 1 : 0);
                         break;
+                    case bool[] bArr:
+                        program.SetUniform(name, bArr);
+                        break;
                     case Matrix3x2 matrix3:
                         program.SetUniform(name, matrix3);
                         break;

Robust.Client/Graphics/Clyde/Clyde.Shaders.cs

@@ -506,6 +506,14 @@ namespace Robust.Client.Graphics.Clyde
                 data.Parameters[name] = value;
             }
 
+            private protected override void SetParameterImpl(string name, bool[] value)
+            {
+                var data = Parent._shaderInstances[Handle];
+                data.ParametersDirty = true;
+                data.Parameters[name] = value;
+            }
+
+
             private protected override void SetParameterImpl(string name, in Matrix3x2 value)
             {
                 var data = Parent._shaderInstances[Handle];

Robust.Client/Graphics/Clyde/Clyde.Sprite.cs

@@ -61,12 +61,11 @@ internal partial class Clyde
         var index = 0;
         var added = 0;
         var opts = new ParallelOptions { MaxDegreeOfParallelism = _parMan.ParallelProcessCount };
-        var xformSystem = _entitySystemManager.GetEntitySystem<SharedTransformSystem>();
 
-        foreach (var (treeOwner, comp) in _entitySystemManager.GetEntitySystem<SpriteTreeSystem>().GetIntersectingTrees(map, worldBounds))
+        foreach (var (treeOwner, comp) in _spriteTreeSystem.GetIntersectingTrees(map, worldBounds))
         {
             var treeXform = query.GetComponent(treeOwner);
-            var bounds = xformSystem.GetInvWorldMatrix(treeOwner).TransformBox(worldBounds);
+            var bounds = _transformSystem.GetInvWorldMatrix(treeOwner).TransformBox(worldBounds);
             DebugTools.Assert(treeXform.MapUid == treeXform.ParentUid || !treeXform.ParentUid.IsValid());
 
             treeData = treeData with

Robust.Client/Graphics/Clyde/Clyde.Systems.cs

@@ -0,0 +1,39 @@
+using Robust.Client.ComponentTrees;
+using Robust.Client.GameObjects;
+
+namespace Robust.Client.Graphics.Clyde;
+
+internal sealed partial class Clyde
+{
+    // Caches entity systems required by Clyde.
+
+    private MapSystem _mapSystem = default!;
+    private LightTreeSystem _lightTreeSystem = default!;
+    private TransformSystem _transformSystem = default!;
+    private SpriteTreeSystem _spriteTreeSystem = default!;
+    private ClientOccluderSystem _occluderSystem = default!;
+
+    private void InitSystems()
+    {
+        _entityManager.AfterStartup += EntityManagerOnAfterStartup;
+        _entityManager.AfterShutdown += EntityManagerOnAfterShutdown;
+    }
+
+    private void EntityManagerOnAfterStartup()
+    {
+        _mapSystem = _entitySystemManager.GetEntitySystem<MapSystem>();
+        _lightTreeSystem = _entitySystemManager.GetEntitySystem<LightTreeSystem>();
+        _transformSystem = _entitySystemManager.GetEntitySystem<TransformSystem>();
+        _spriteTreeSystem = _entitySystemManager.GetEntitySystem<SpriteTreeSystem>();
+        _occluderSystem = _entitySystemManager.GetEntitySystem<ClientOccluderSystem>();
+    }
+
+    private void EntityManagerOnAfterShutdown()
+    {
+        _mapSystem = null!;
+        _lightTreeSystem = null!;
+        _transformSystem = null!;
+        _spriteTreeSystem = null!;
+        _occluderSystem = null!;
+    }
+}

Robust.Client/Graphics/Clyde/Clyde.Windowing.cs

@@ -188,7 +188,7 @@ namespace Robust.Client.Graphics.Clyde
                 {
                     if (!TryInitMainWindow(glSpec, out lastError))
                     {
-                        Logger.DebugS("clyde.win", $"OpenGL {glSpec.OpenGLVersion} unsupported: {lastError}");
+                        _sawmillWin.Debug($"OpenGL {glSpec.OpenGLVersion} unsupported: {lastError}");
                         continue;
                     }
 
@@ -199,7 +199,7 @@ namespace Robust.Client.Graphics.Clyde
             else
             {
                 if (!TryInitMainWindow(null, out lastError))
-                    Logger.DebugS("clyde.win", $"Failed to create window: {lastError}");
+                    _sawmillWin.Debug($"Failed to create window: {lastError}");
                 else
                     succeeded = true;
             }
@@ -230,8 +230,7 @@ namespace Robust.Client.Graphics.Clyde
                     }
                 }
 
-                Logger.FatalS("clyde.win",
-                    "Failed to create main game window! " +
+                _sawmillWin.Fatal("Failed to create main game window! " +
                     "This probably means your GPU is too old to run the game. " +
                     $"That or update your graphics drivers. {lastError}");
 

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -5,6 +5,7 @@ using System.Runtime.InteropServices;
 using System.Threading;
 using OpenToolkit;
 using OpenToolkit.Graphics.OpenGL4;
+using Robust.Client.GameObjects;
 using Robust.Client.Input;
 using Robust.Client.Map;
 using Robust.Client.ResourceManagement;
@@ -46,6 +47,7 @@ namespace Robust.Client.Graphics.Clyde
         [Dependency] private readonly IDependencyCollection _deps = default!;
         [Dependency] private readonly ILocalizationManager _loc = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
+        [Dependency] private readonly ClientEntityManager _entityManager = default!;
 
         private GLUniformBuffer<ProjViewMatrices> ProjViewUBO = default!;
         private GLUniformBuffer<UniformConstants> UniformConstantsUBO = default!;
@@ -78,6 +80,7 @@ namespace Robust.Client.Graphics.Clyde
 
         private ISawmill _clydeSawmill = default!;
         private ISawmill _sawmillOgl = default!;
+        private ISawmill _sawmillWin = default!;
 
         private IBindingsContext _glBindingsContext = default!;
         private bool _earlyGLInit;
@@ -94,6 +97,7 @@ namespace Robust.Client.Graphics.Clyde
         {
             _clydeSawmill = _logManager.GetSawmill("clyde");
             _sawmillOgl = _logManager.GetSawmill("clyde.ogl");
+            _sawmillWin = _logManager.GetSawmill("clyde.win");
 
             _cfg.OnValueChanged(CVars.DisplayOGLCheckErrors, b => _checkGLErrors = b, true);
             _cfg.OnValueChanged(CVars.DisplayVSync, VSyncChanged, true);
@@ -122,6 +126,8 @@ namespace Robust.Client.Graphics.Clyde
         {
             _gameThread = Thread.CurrentThread;
 
+            InitSystems();
+
             InitGLContextManager();
             if (!InitMainWindowAndRenderer())
                 return false;

Robust.Client/Graphics/Clyde/ClydeHeadless.cs

@@ -361,6 +361,10 @@ namespace Robust.Client.Graphics.Clyde
             {
             }
 
+            private protected override void SetParameterImpl(string name, bool[] value)
+            {
+            }
+
             private protected override void SetParameterImpl(string name, in Matrix3x2 value)
             {
             }

Robust.Client/Graphics/Clyde/GLContext/GLContextAngle.cs

@@ -37,6 +37,8 @@ namespace Robust.Client.Graphics.Clyde
             // NOTE: This class only handles GLES3/D3D11.
             // For anything lower we just let ANGLE fall back and do the work 100%.
 
+            private readonly ISawmill _sawmill;
+
             private IDXGIFactory1* _factory;
             private IDXGIAdapter1* _adapter;
             private ID3D11Device* _device;
@@ -58,6 +60,7 @@ namespace Robust.Client.Graphics.Clyde
 
             public GLContextAngle(Clyde clyde) : base(clyde)
             {
+                _sawmill = clyde._logManager.GetSawmill("clyde.ogl.angle");
             }
 
             public override GLContextSpec? SpecWithOpenGLVersion(RendererOpenGLVersion version)
@@ -187,7 +190,7 @@ namespace Robust.Client.Graphics.Clyde
                 }
                 catch (Exception e)
                 {
-                    Logger.ErrorS("clyde.ogl.angle", $"Failed to initialize custom ANGLE: {e}");
+                    _sawmill.Error($"Failed to initialize custom ANGLE: {e}");
                     Shutdown();
                     return false;
                 }
@@ -207,7 +210,7 @@ namespace Robust.Client.Graphics.Clyde
             private void TryInitializeCore()
             {
                 var extensions = Marshal.PtrToStringUTF8((nint) eglQueryString(null, EGL_EXTENSIONS));
-                Logger.DebugS("clyde.ogl.angle", $"EGL client extensions: {extensions}!");
+                _sawmill.Debug($"EGL client extensions: {extensions}!");
 
                 CreateD3D11Device();
                 CreateEglContext();
@@ -232,10 +235,10 @@ namespace Robust.Client.Graphics.Clyde
                 var version = Marshal.PtrToStringUTF8((nint) eglQueryString(_eglDisplay, EGL_VERSION));
                 var extensions = Marshal.PtrToStringUTF8((nint) eglQueryString(_eglDisplay, EGL_EXTENSIONS));
 
-                Logger.DebugS("clyde.ogl.angle", "EGL initialized!");
-                Logger.DebugS("clyde.ogl.angle", $"EGL vendor: {vendor}!");
-                Logger.DebugS("clyde.ogl.angle", $"EGL version: {version}!");
-                Logger.DebugS("clyde.ogl.angle", $"EGL extensions: {extensions}!");
+                _sawmill.Debug("EGL initialized!");
+                _sawmill.Debug($"EGL vendor: {vendor}!");
+                _sawmill.Debug($"EGL version: {version}!");
+                _sawmill.Debug($"EGL extensions: {extensions}!");
 
                 if (eglBindAPI(EGL_OPENGL_ES_API) != EGL_TRUE)
                     throw new Exception("eglBindAPI failed.");
@@ -262,11 +265,11 @@ namespace Robust.Client.Graphics.Clyde
                 if (numConfigs == 0)
                     throw new Exception("No compatible EGL configurations returned!");
 
-                Logger.DebugS("clyde.ogl.angle", $"{numConfigs} EGL configs possible!");
+                _sawmill.Debug($"{numConfigs} EGL configs possible!");
 
                 for (var i = 0; i < numConfigs; i++)
                 {
-                    Logger.DebugS("clyde.ogl.angle", DumpEglConfig(_eglDisplay, configs[i]));
+                    _sawmill.Debug(DumpEglConfig(_eglDisplay, configs[i]));
                 }
 
                 _eglConfig = configs[0];
@@ -286,7 +289,7 @@ namespace Robust.Client.Graphics.Clyde
                 if (_eglContext == (void*) EGL_NO_CONTEXT)
                     throw new Exception("eglCreateContext failed!");
 
-                Logger.DebugS("clyde.ogl.angle", "EGL context created!");
+                _sawmill.Debug("EGL context created!");
 
                 Clyde._openGLVersion = _es3 ? RendererOpenGLVersion.GLES3 : RendererOpenGLVersion.GLES2;
             }
@@ -311,11 +314,10 @@ namespace Robust.Client.Graphics.Clyde
 
                         if (_adapter == null)
                         {
-                            Logger.WarningS("clyde.ogl.angle",
-                                $"Unable to find display adapter with requested name: {adapterName}");
+                            _sawmill.Warning($"Unable to find display adapter with requested name: {adapterName}");
                         }
 
-                        Logger.DebugS("clyde.ogl.angle", $"Found display adapter with name: {adapterName}");
+                        _sawmill.Debug($"Found display adapter with name: {adapterName}");
                     }
 
 #pragma warning disable CA1416
@@ -415,9 +417,9 @@ namespace Robust.Client.Graphics.Clyde
 
                     var descName = ((ReadOnlySpan<char>)desc.Description).TrimEnd('\0');
 
-                    Logger.DebugS("clyde.ogl.angle", "Successfully created D3D11 device!");
-                    Logger.DebugS("clyde.ogl.angle", $"D3D11 Device Adapter: {descName.ToString()}");
-                    Logger.DebugS("clyde.ogl.angle", $"D3D11 Device FL: {_deviceFl}");
+                    _sawmill.Debug("Successfully created D3D11 device!");
+                    _sawmill.Debug($"D3D11 Device Adapter: {descName.ToString()}");
+                    _sawmill.Debug($"D3D11 Device FL: {_deviceFl}");
 
                     if (_deviceFl == D3D_FEATURE_LEVEL_9_1)
                     {

Robust.Client/Graphics/Clyde/GLContext/GLContextEgl.cs

@@ -22,6 +22,8 @@ namespace Robust.Client.Graphics.Clyde
 
             private readonly Dictionary<WindowId, WindowData> _windowData = new();
 
+            private readonly ISawmill _sawmill;
+
             private void* _eglDisplay;
             private void* _eglContext;
             private void* _eglConfig;
@@ -30,6 +32,7 @@ namespace Robust.Client.Graphics.Clyde
 
             public GLContextEgl(Clyde clyde) : base(clyde)
             {
+                _sawmill = clyde._logManager.GetSawmill("clyde.ogl.egl");
             }
 
             public override GLContextSpec? SpecWithOpenGLVersion(RendererOpenGLVersion version)
@@ -47,7 +50,7 @@ namespace Robust.Client.Graphics.Clyde
             public void InitializePublic()
             {
                 var extensions = Marshal.PtrToStringUTF8((nint) eglQueryString(null, EGL_EXTENSIONS));
-                Logger.DebugS("clyde.ogl.egl", $"EGL client extensions: {extensions}!");
+                _sawmill.Debug($"EGL client extensions: {extensions}!");
             }
 
             public override void WindowCreated(GLContextSpec? spec, WindowReg reg)
@@ -133,10 +136,10 @@ namespace Robust.Client.Graphics.Clyde
                 var version = Marshal.PtrToStringUTF8((nint) eglQueryString(_eglDisplay, EGL_VERSION));
                 var extensions = Marshal.PtrToStringUTF8((nint) eglQueryString(_eglDisplay, EGL_EXTENSIONS));
 
-                Logger.DebugS("clyde.ogl.egl", "EGL initialized!");
-                Logger.DebugS("clyde.ogl.egl", $"EGL vendor: {vendor}!");
-                Logger.DebugS("clyde.ogl.egl", $"EGL version: {version}!");
-                Logger.DebugS("clyde.ogl.egl", $"EGL extensions: {extensions}!");
+                _sawmill.Debug("EGL initialized!");
+                _sawmill.Debug($"EGL vendor: {vendor}!");
+                _sawmill.Debug($"EGL version: {version}!");
+                _sawmill.Debug($"EGL extensions: {extensions}!");
 
                 if (eglBindAPI(EGL_OPENGL_ES_API) != EGL_TRUE)
                     throw new Exception("eglBindAPI failed.");
@@ -164,11 +167,11 @@ namespace Robust.Client.Graphics.Clyde
                 if (numConfigs == 0)
                     throw new Exception("No compatible EGL configurations returned!");
 
-                Logger.DebugS("clyde.ogl.egl", $"{numConfigs} EGL configs possible!");
+                _sawmill.Debug($"{numConfigs} EGL configs possible!");
 
                 for (var i = 0; i < numConfigs; i++)
                 {
-                    Logger.DebugS("clyde.ogl.egl", DumpEglConfig(_eglDisplay, configs[i]));
+                    _sawmill.Debug(DumpEglConfig(_eglDisplay, configs[i]));
                 }
 
                 _eglConfig = configs[0];
@@ -183,7 +186,7 @@ namespace Robust.Client.Graphics.Clyde
                 if (_eglContext == (void*) EGL_NO_CONTEXT)
                     throw new Exception("eglCreateContext failed!");
 
-                Logger.DebugS("clyde.ogl.egl", "EGL context created!");
+                _sawmill.Debug("EGL context created!");
             }
 
             public override void Shutdown()

Robust.Client/Graphics/Clyde/GLObjects/Clyde.ShaderProgram.cs

@@ -418,6 +418,37 @@ namespace Robust.Client.Graphics.Clyde
                 }
             }
 
+            public void SetUniform(string uniformName, bool[] bools)
+            {
+                var uniformId = GetUniform(uniformName);
+                SetUniformDirect(uniformId, bools);
+            }
+
+            public void SetUniform(int uniformName, bool[] bools)
+            {
+                var uniformId = GetUniform(uniformName);
+                SetUniformDirect(uniformId, bools);
+            }
+
+            private void SetUniformDirect(int slot, bool[] bools)
+            {
+                Span<int> intBools = stackalloc int[bools.Length];
+
+                for (var i = 0; i < bools.Length; i++)
+                {
+                    intBools[i] = bools[i] ? 1 : 0;
+                }
+
+                unsafe
+                {
+                    fixed (int* intBoolsPtr = intBools)
+                    {
+                        GL.Uniform1(slot, bools.Length, intBoolsPtr);
+                        _clyde.CheckGlError();
+                    }
+                }
+            }
+
             public void SetUniformTexture(string uniformName, TextureUnit textureUnit)
             {
                 var uniformId = GetUniform(uniformName);

Robust.Client/Graphics/Shaders/ParsedShader.cs

@@ -224,7 +224,8 @@ namespace Robust.Client.Graphics
             // TODO: add support for int, and vec3/4 arrays
             return
                 (type == ShaderDataType.Float) ||
-                (type == ShaderDataType.Vec2);
+                (type == ShaderDataType.Vec2) ||
+                (type == ShaderDataType.Bool);
         }
 
         [SuppressMessage("ReSharper", "StringLiteralTypo")]

Robust.Client/Graphics/Shaders/ShaderInstance.cs

@@ -148,6 +148,13 @@ namespace Robust.Client.Graphics
             SetParameterImpl(name, value);
         }
 
+        public void SetParameter(string name, bool[] value)
+        {
+            EnsureAlive();
+            EnsureMutable();
+            SetParameterImpl(name, value);
+        }
+
         public void SetParameter(string name, in Matrix3x2 value)
         {
             EnsureAlive();
@@ -219,6 +226,7 @@ namespace Robust.Client.Graphics
         private protected abstract void SetParameterImpl(string name, int value);
         private protected abstract void SetParameterImpl(string name, Vector2i value);
         private protected abstract void SetParameterImpl(string name, bool value);
+        private protected abstract void SetParameterImpl(string name, bool[] value);
         private protected abstract void SetParameterImpl(string name, in Matrix3x2 value);
         private protected abstract void SetParameterImpl(string name, in Matrix4 value);
         private protected abstract void SetParameterImpl(string name, Texture value);

Robust.Client/Map/ClydeTileDefinitionManager.cs

@@ -21,9 +21,12 @@ using SixLabors.ImageSharp.PixelFormats;
 
 namespace Robust.Client.Map
 {
-    internal sealed class ClydeTileDefinitionManager : TileDefinitionManager, IClydeTileDefinitionManager
+    internal sealed class ClydeTileDefinitionManager : TileDefinitionManager, IClydeTileDefinitionManager, IPostInjectInit
     {
         [Dependency] private readonly IResourceManager _manager = default!;
+        [Dependency] private readonly ILogManager _logManager = default!;
+
+        private ISawmill _sawmill = default!;
 
         private Texture? _tileTextureAtlas;
 
@@ -98,8 +101,7 @@ namespace Robust.Client.Map
             if (imgWidth >= 2048 || imgHeight >= 2048)
             {
                 // Sanity warning, some machines don't have textures larger than this and need multiple atlases.
-                Logger.WarningS("clyde",
-                    $"Tile texture atlas is ({imgWidth} x {imgHeight}), larger than 2048 x 2048. If you really need {tileCount} tiles, file an issue on RobustToolbox.");
+                _sawmill.Warning($"Tile texture atlas is ({imgWidth} x {imgHeight}), larger than 2048 x 2048. If you really need {tileCount} tiles, file an issue on RobustToolbox.");
             }
 
             var column = 1;
@@ -151,6 +153,11 @@ namespace Robust.Client.Map
 
             _tileTextureAtlas = Texture.LoadFromImage(sheet, "Tile Atlas");
         }
+
+        void IPostInjectInit.PostInject()
+        {
+            _sawmill = _logManager.GetSawmill("clyde");
+        }
     }
 
     public sealed class ReloadTileTexturesCommand : LocalizedCommands

Robust.Client/Placement/Modes/AlignSnapgridCenter.cs

@@ -34,13 +34,13 @@ namespace Robust.Client.Placement.Modes
                 {
                     var from = ScreenToWorld(new Vector2(a, 0));
                     var to = ScreenToWorld(new Vector2(a, viewportSize.Y));
-                    args.WorldHandle.DrawLine(from, to, new Color(0, 0, 1f));
+                    args.WorldHandle.DrawLine(from, to, new Color(0, 0, 0.3f));
                 }
                 for (var a = gridstart.Y; a < viewportSize.Y; a += SnapSize * EyeManager.PixelsPerMeter)
                 {
                     var from = ScreenToWorld(new Vector2(0, a));
                     var to = ScreenToWorld(new Vector2(viewportSize.X, a));
-                    args.WorldHandle.DrawLine(from, to, new Color(0, 0, 1f));
+                    args.WorldHandle.DrawLine(from, to, new Color(0, 0, 0.3f));
                 }
             }
 

Robust.Client/Player/PlayerManager.cs

@@ -167,7 +167,6 @@ namespace Robust.Client.Player
                 if (_client.RunLevel != ClientRunLevel.SinglePlayerGame)
                     Sawmill.Warning($"Attaching local player to an entity {EntManager.ToPrettyString(uid)} without an eye. This eye will not be netsynced and may cause issues.");
                 var eye = (EyeComponent) Factory.GetComponent(typeof(EyeComponent));
-                eye.Owner = uid.Value;
                 eye.NetSyncEnabled = false;
                 EntManager.AddComponent(uid.Value, eye);
             }

Robust.Client/Replays/Loading/ReplayLoadManager.Read.cs

@@ -162,9 +162,7 @@ public sealed partial class ReplayLoadManager
         }
 
         using var stringFile = fileReader.Open(FileStrings);
-        var stringData = new byte[stringFile.Length];
-        stringFile.ReadExactly(stringData);
-        _serializer.SetStringSerializerPackage(stringHash, stringData);
+        _serializer.SetStringSerializerPackage(stringHash, stringFile.CopyToArray());
 
         using var cvarsFile = fileReader.Open(FileCvars);
         // Note, this does not invoke the received-initial-cvars event. But at least currently, that doesn't matter

Robust.Client/UserInterface/BoundUserInterfaceExt.cs

@@ -0,0 +1,33 @@
+using System;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.UserInterface;
+
+public static class BoundUserInterfaceExt
+{
+    /// <summary>
+    /// Helper method to create a window and also handle closing the BUI when it's closed.
+    /// </summary>
+    public static T CreateWindow<T>(this BoundUserInterface bui) where T : BaseWindow, new()
+    {
+        var window = bui.CreateDisposableControl<T>();
+        window.OpenCentered();
+        window.OnClose += bui.Close;
+        return window;
+    }
+
+    /// <summary>
+    /// Creates a control for this BUI that will be disposed when it is disposed.
+    /// </summary>
+    /// <param name="bui"></param>
+    /// <typeparam name="T"></typeparam>
+    /// <returns></returns>
+    public static T CreateDisposableControl<T>(this BoundUserInterface bui) where T : Control, IDisposable, new()
+    {
+        var control = new T();
+        bui.Disposals ??= [];
+        bui.Disposals.Add(control);
+        return control;
+    }
+}

Robust.Client/UserInterface/Control.cs

@@ -602,6 +602,7 @@ namespace Robust.Client.UserInterface
         ///     Dispose this control, its own scene control, and all its children.
         ///     Basically the big delete button.
         /// </summary>
+        [Obsolete("Controls should only be removed from UI tree instead of being disposed")]
         public void Dispose()
         {
             if (Disposed)
@@ -613,6 +614,7 @@ namespace Robust.Client.UserInterface
             Disposed = true;
         }
 
+        [Obsolete("Controls should only be removed from UI tree instead of being disposed")]
         protected virtual void Dispose(bool disposing)
         {
             if (!disposing)

Robust.Client/UserInterface/Controllers/Implementations/EntitySpawningUIController.cs

@@ -327,8 +327,7 @@ public sealed class EntitySpawningUIController : UIController
         if (_window == null || _window.Disposed)
             return;
 
-        var textures = SpriteComponent.GetPrototypeTextures(prototype, _resources).Select(o => o.Default).ToList();
-        var button = _window.InsertEntityButton(prototype, insertFirst, index, textures);
+        var button = _window.InsertEntityButton(prototype, insertFirst, index);
 
         button.ActualButton.OnToggled += OnEntityButtonToggled;
     }

Robust.Client/UserInterface/Controls/CheckBox.cs

@@ -15,6 +15,36 @@ namespace Robust.Client.UserInterface.Controls
         public Label Label { get; }
         public TextureRect TextureRect { get; }
 
+        /// <summary>
+        /// Should the checkbox be to the left or the right of the label.
+        /// </summary>
+        public bool LeftAlign
+        {
+            get => _leftAlign;
+            set
+            {
+                if (_leftAlign == value)
+                    return;
+
+                _leftAlign = value;
+
+                if (value)
+                {
+                    Label.HorizontalExpand = false;
+                    TextureRect.SetPositionFirst();
+                    Label.SetPositionInParent(1);
+                }
+                else
+                {
+                    Label.HorizontalExpand = true;
+                    Label.SetPositionFirst();
+                    TextureRect.SetPositionInParent(1);
+                }
+            }
+        }
+
+        private bool _leftAlign = true;
+        
         public CheckBox()
         {
             ToggleMode = true;
@@ -31,10 +61,21 @@ namespace Robust.Client.UserInterface.Controls
                 StyleClasses = { StyleClassCheckBox },
                 VerticalAlignment = VAlignment.Center,
             };
-            hBox.AddChild(TextureRect);
 
             Label = new Label();
-            hBox.AddChild(Label);
+
+            if (LeftAlign)
+            {
+                Label.HorizontalExpand = false;
+                hBox.AddChild(TextureRect);
+                hBox.AddChild(Label);
+            }
+            else
+            {
+                Label.HorizontalExpand = true;
+                hBox.AddChild(Label);
+                hBox.AddChild(TextureRect);
+            }
         }
 
         protected override void DrawModeChanged()

Robust.Client/UserInterface/Controls/EntityPrototypeView.cs

@@ -33,10 +33,7 @@ public class EntityPrototypeView : SpriteView
 
         _currentPrototype = entProto;
         SetEntity(null);
-        if (_ourEntity != null)
-        {
-            EntMan.DeleteEntity(_ourEntity);
-        }
+        EntMan.DeleteEntity(_ourEntity);
 
         if (_currentPrototype != null)
         {
@@ -57,8 +54,6 @@ public class EntityPrototypeView : SpriteView
     protected override void ExitedTree()
     {
         base.ExitedTree();
-
-        if (!EntMan.Deleted(_ourEntity))
-            EntMan.QueueDeleteEntity(_ourEntity);
+        EntMan.TryQueueDeleteEntity(_ourEntity);
     }
 }

Robust.Client/UserInterface/Controls/OptionButton.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Numerics;
 using Robust.Client.Graphics;
@@ -14,6 +14,7 @@ namespace Robust.Client.UserInterface.Controls
         public const string StyleClassOptionButton = "optionButton";
         public const string StyleClassPopup = "optionButtonPopup";
         public const string StyleClassOptionTriangle = "optionTriangle";
+        public const string StyleClassOptionsBackground = "optionButtonBackground";
         public readonly ScrollContainer OptionsScroll;
 
         private readonly List<ButtonData> _buttonData = new();
@@ -75,7 +76,12 @@ namespace Robust.Client.UserInterface.Controls
 
             _popup = new Popup()
             {
-                Children = { new PanelContainer(), OptionsScroll },
+                Children = {
+                    new PanelContainer {
+                        StyleClasses = { StyleClassOptionsBackground }
+                    },
+                    OptionsScroll
+                },
                 StyleClasses = { StyleClassPopup }
             };
             _popup.OnPopupHide += OnPopupHide;

Robust.Client/UserInterface/Controls/RichTextLabel.cs

@@ -38,6 +38,21 @@ namespace Robust.Client.UserInterface.Controls
             }
         }
 
+        public string? Text
+        {
+            get => _message?.ToMarkup();
+            set
+            {
+                if (value == null)
+                {
+                    _message?.Clear();
+                    return;
+                }
+
+                SetMessage(FormattedMessage.FromMarkupPermissive(value));
+            }
+        }
+
         public RichTextLabel()
         {
             IoCManager.InjectDependencies(this);

Robust.Client/UserInterface/Controls/SpinBox.cs

@@ -1,4 +1,3 @@
-using Robust.Shared.Maths;
 using System;
 using System.Collections.Generic;
 using System.Numerics;
@@ -15,9 +14,10 @@ namespace Robust.Client.UserInterface.Controls
         public const string RightButtonStyle = "spinbox-right";
         public const string MiddleButtonStyle = "spinbox-middle";
         public LineEdit LineEditControl { get; }
-        private List<Button> _leftButtons = new();
-        private List<Button> _rightButtons = new();
+        private List<SpinBoxButton> _leftButtons = new();
+        private List<SpinBoxButton> _rightButtons = new();
         private int _stepSize = 1;
+        private bool _buttonsDisabled;
 
         /// <summary>
         ///     Determines whether the SpinBox value gets changed by the input text.
@@ -30,12 +30,7 @@ namespace Robust.Client.UserInterface.Controls
             get => _value;
             set
             {
-                if (IsValid != null && !IsValid(value))
-                {
-                    return;
-                }
-                _value = value;
-                LineEditControl.Text = value.ToString();
+                OverrideValue(value);
                 ValueChanged?.Invoke(new ValueChangedEventArgs(value));
             }
         }
@@ -52,6 +47,7 @@ namespace Robust.Client.UserInterface.Controls
                 return;
             }
             _value = value;
+            UpdateButtonCanPress();
             LineEditControl.Text = value.ToString();
         }
 
@@ -87,6 +83,7 @@ namespace Robust.Client.UserInterface.Controls
             ClearButtons();
             AddLeftButton(-1, "-");
             AddRightButton(1, "+");
+            UpdateButtonCanPress();
         }
 
         /// <summary>
@@ -94,8 +91,8 @@ namespace Robust.Client.UserInterface.Controls
         /// </summary>
         public void AddRightButton(int num, string text)
         {
-            var button = new Button { Text = text };
-            button.OnPressed += (args) => Value += num;
+            var button = new SpinBoxButton(num) { Text = text };
+            button.OnPressed += _ => Value += num;
             AddChild(button);
             button.AddStyleClass(RightButtonStyle);
             if (_rightButtons.Count > 0)
@@ -111,8 +108,8 @@ namespace Robust.Client.UserInterface.Controls
         /// </summary>
         public void AddLeftButton(int num, string text)
         {
-            var button = new Button { Text = text };
-            button.OnPressed += (args) => Value += num;
+            var button = new SpinBoxButton(num) { Text = text };
+            button.OnPressed += _ => Value += num;
             AddChild(button);
             button.SetPositionInParent(_leftButtons.Count);
             button.AddStyleClass(_leftButtons.Count == 0 ? LeftButtonStyle : MiddleButtonStyle);
@@ -162,6 +159,24 @@ namespace Robust.Client.UserInterface.Controls
             {
                 rightButton.Disabled = disabled;
             }
+
+            _buttonsDisabled = disabled;
+        }
+
+        private void UpdateButtonCanPress()
+        {
+            if (IsValid == null)
+                return;
+
+            foreach (var button in _leftButtons)
+            {
+                button.Disabled = !IsValid(_value + button.Value) || _buttonsDisabled;
+            }
+
+            foreach (var button in _rightButtons)
+            {
+                button.Disabled = !IsValid(_value + button.Value) || _buttonsDisabled;
+            }
         }
 
         /// <summary>
@@ -195,6 +210,16 @@ namespace Robust.Client.UserInterface.Controls
             else if (args.Delta.Y < 0)
                 Value -= _stepSize;
         }
+
+        private sealed class SpinBoxButton : Button
+        {
+            public readonly int Value;
+
+            public SpinBoxButton(int value)
+            {
+                Value = value;
+            }
+        }
     }
 
     public sealed class ValueChangedEventArgs : EventArgs

Robust.Client/UserInterface/Controls/SplitContainer.cs

@@ -191,6 +191,19 @@ namespace Robust.Client.UserInterface.Controls
             _splitDragArea.OnMouseMove += OnMove;
         }
 
+        /// <summary>
+        /// Swaps the position of the first and zeroeth children; for a 2-control viewport it effectively flips them.
+        /// </summary>
+        public void Flip()
+        {
+            if (ChildCount < 3)
+                return;
+
+            DebugTools.Assert(ChildCount <= 3);
+            GetChild(1).SetPositionFirst();
+            InvalidateArrange();
+        }
+
         private void OnMove(GUIMouseMoveEventArgs args)
         {
             if (ResizeMode == SplitResizeMode.NotResizable)

Robust.Client/UserInterface/CustomControls/BaseWindow.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Numerics;
+using Robust.Client.Graphics;
 using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Input;
 using Robust.Shared.IoC;
@@ -235,6 +236,15 @@ namespace Robust.Client.UserInterface.CustomControls
         public void OpenToRight() => OpenCenteredAt(new Vector2(1, 0.5f));
         public void OpenCenteredRight() => OpenCenteredAt(new Vector2(0.75f, 0.5f));
 
+        /// <summary>
+        /// Opens a window and centers it relative to the screen position.
+        /// </summary>
+        public void OpenScreenAt(Vector2 relativePosition, IClyde clyde)
+        {
+            var adjusted = relativePosition / clyde.ScreenSize;
+            OpenCenteredAt(adjusted);
+        }
+
         /// <summary>
         ///     Opens a window, attempting to place the center of the window at some relative point on the screen.
         /// </summary>

Robust.Client/UserInterface/CustomControls/DebugConsole.xaml.Completions.cs

@@ -277,8 +277,21 @@ public sealed partial class DebugConsole
                 CommandBar.CursorPosition = lastRange.end;
                 CommandBar.SelectionStart = lastRange.start;
                 var insertValue = CommandParsing.Escape(completion);
+
+                // If the replacement contains a space, we must quote it to treat it as a single argument.
+                var mustQuote = insertValue.Contains(' ');
                 if ((completionFlags & CompletionOptionFlags.PartialCompletion) == 0)
+                {
+                    if (mustQuote)
+                        insertValue = $"\"{insertValue}\"";
+
                     insertValue += " ";
+                }
+                else if (mustQuote)
+                {
+                    // If it's a partial completion, only quote the start.
+                    insertValue = '"' + insertValue;
+                }
 
                 CommandBar.InsertAtCursor(insertValue);
 

Robust.Client/UserInterface/CustomControls/DebugMonitorControls/DebugCoordsPanel.cs

@@ -83,7 +83,7 @@ namespace Robust.Client.UserInterface.CustomControls.DebugMonitorControls
                     }
                     else
                     {
-                        mouseGridPos = new EntityCoordinates(_mapManager.GetMapEntityId(mouseWorldMap.MapId),
+                        mouseGridPos = new EntityCoordinates(mapSystem.GetMapOrInvalid(mouseWorldMap.MapId),
                             mouseWorldMap.Position);
                         tile = new TileRef(EntityUid.Invalid,
                             mouseGridPos.ToVector2i(_entityManager, _mapManager, xformSystem), Tile.Empty);

Robust.Client/UserInterface/CustomControls/EntitySpawnButton.cs

@@ -12,7 +12,7 @@ public sealed class EntitySpawnButton : Control
     public EntityPrototype Prototype { get; set; } = default!;
     public Button ActualButton { get; private set; }
     public Label EntityLabel { get; private set; }
-    public LayeredTextureRect EntityTextureRects { get; private set; }
+    public EntityPrototypeView EntityTextureRects {get; private set; }
     public int Index { get; set; }
 
     public EntitySpawnButton()
@@ -27,13 +27,12 @@ public sealed class EntitySpawnButton : Control
             Orientation = BoxContainer.LayoutOrientation.Horizontal,
             Children =
             {
-                (EntityTextureRects = new LayeredTextureRect
+                (EntityTextureRects = new EntityPrototypeView
                 {
-                    MinSize = new Vector2(32, 32),
+                    SetSize = new Vector2(32, 32),
                     HorizontalAlignment = HAlignment.Center,
                     VerticalAlignment = VAlignment.Center,
-                    Stretch = TextureRect.StretchMode.KeepAspectCentered,
-                    CanShrink = true
+                    Stretch = SpriteView.StretchMode.Fill
                 }),
                 (EntityLabel = new Label
                 {

Robust.Client/UserInterface/CustomControls/EntitySpawnWindow.xaml.cs

@@ -44,7 +44,7 @@ namespace Robust.Client.UserInterface.CustomControls
         }
 
         // Create a spawn button and insert it into the start or end of the list.
-        public EntitySpawnButton InsertEntityButton(EntityPrototype prototype, bool insertFirst, int index, List<Texture> textures)
+        public EntitySpawnButton InsertEntityButton(EntityPrototype prototype, bool insertFirst, int index)
         {
             var button = new EntitySpawnButton
             {
@@ -67,7 +67,7 @@ namespace Robust.Client.UserInterface.CustomControls
             }
 
             var rect = button.EntityTextureRects;
-            rect.Textures = textures;
+            rect.SetPrototype(prototype.ID);
 
             PrototypeList.AddChild(button);
             if (insertFirst)

Robust.Client/UserInterface/IUserInterfaceManager.cs

@@ -64,7 +64,7 @@ namespace Robust.Client.UserInterface
 
         IDebugMonitors DebugMonitors { get; }
 
-        void Popup(string contents, string title = "Alert!");
+        void Popup(string contents, string? title = null, bool clipboardButton = true);
 
         Control? MouseGetControl(ScreenCoordinates coordinates);
 

Robust.Client/UserInterface/UiCommands.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using Robust.Client.State;
 using Robust.Shared.Console;
 using Robust.Shared.IoC;
@@ -7,11 +8,12 @@ namespace Robust.Client.UserInterface
 {
     sealed class ChangeSceneCommpand : LocalizedCommands
     {
+        [Dependency] private readonly IReflectionManager _reflection = default!;
+
         public override string Command => "scene";
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var reflection = IoCManager.Resolve<IReflectionManager>();
-            var types = reflection.GetAllChildren(typeof(State.State));
+            var types = _reflection.GetAllChildren(typeof(State.State));
 
             foreach (var tryType in types)
             {
@@ -26,5 +28,13 @@ namespace Robust.Client.UserInterface
 
             shell.WriteError($"No scene child class type ends with {args[0]}");
         }
+
+        public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+        {
+            if (args.Length != 1)
+                return CompletionResult.Empty;
+            var types = _reflection.GetAllChildren(typeof(State.State));
+            return CompletionResult.FromHintOptions(types.Select(x => x.Name), "[State name]");
+        }
     }
 }

Robust.Client/UserInterface/UserInterfaceManager.Layout.cs

@@ -4,6 +4,7 @@ using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Localization;
 using Robust.Shared.Log;
 using Robust.Shared.Maths;
 using Robust.Shared.Profiling;
@@ -53,14 +54,47 @@ internal sealed partial class UserInterfaceManager
             }
         }
 
-        public void Popup(string contents, string title = "Alert!")
+        public void Popup(string contents, string? title = null, bool clipboardButton = true)
         {
             var popup = new DefaultWindow
             {
-                Title = title
+                Title = string.IsNullOrEmpty(title) ? Loc.GetString("popup-title") : title,
             };
 
-            popup.Contents.AddChild(new Label {Text = contents});
+            var label = new Label { Text = contents };
+
+            var vBox = new BoxContainer
+            {
+                Orientation = BoxContainer.LayoutOrientation.Vertical,
+            };
+
+            vBox.AddChild(label);
+
+            if (clipboardButton)
+            {
+                var copyButton = new Button
+                {
+                    Text = Loc.GetString("popup-copy-button"),
+                    HorizontalExpand = true,
+                };
+
+                copyButton.OnPressed += _ =>
+                {
+                    _clipboard.SetText(contents);
+                };
+
+                var hBox = new BoxContainer
+                {
+                    Orientation = BoxContainer.LayoutOrientation.Horizontal,
+                    HorizontalAlignment = Control.HAlignment.Right,
+                };
+
+                hBox.AddChild(copyButton);
+                vBox.AddChild(hBox);
+            }
+
+            popup.Contents.AddChild(vBox);
+
             popup.OpenCentered();
         }
 

Robust.Client/UserInterface/UserInterfaceManager.cs

@@ -54,6 +54,7 @@ namespace Robust.Client.UserInterface
         [Dependency] private readonly IEntitySystemManager _systemManager = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
         [Dependency] private readonly IRuntimeLog _runtime = default!;
+        [Dependency] private readonly IClipboardManager _clipboard = null!;
 
         private IAudioSource? _clickSource;
         private IAudioSource? _hoverSource;

Robust.Client/ViewVariables/Editors/VVPropEditorEnum.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Utility;
@@ -7,41 +8,135 @@ namespace Robust.Client.ViewVariables.Editors
 {
     sealed class VVPropEditorEnum : VVPropEditor
     {
+        private readonly Dictionary<int, int> _idToValue = new();
+        private readonly Dictionary<int, int> _valueToId = new();
+
+        private readonly Dictionary<int, Button> _buttons = new();
+
+        private int _invalidOptionId;
+
+        private int _value;
+        private bool _flagEnum;
+
         protected override Control MakeUI(object? value)
         {
             DebugTools.Assert(value!.GetType().IsEnum);
             var enumType = value.GetType();
             var enumList = Enum.GetValues(enumType);
+            var enumNames = Enum.GetNames(enumType);
+            var underlyingType = Enum.GetUnderlyingType(enumType);
+
+            var convertedValue = Convert.ToInt32(value);
+
+            var hBoxContainer = new BoxContainer
+            {
+                Orientation = BoxContainer.LayoutOrientation.Horizontal,
+            };
 
             var optionButton = new OptionButton();
-            bool hasValue = false;
+            hBoxContainer.AddChild(optionButton);
+
+            var hasValue = false;
+            var selectedId = 0;
+            var i = 0;
             foreach (var val in enumList)
             {
-                var label = val?.ToString();
-                if (label == null)
-                    continue;
-                optionButton.AddItem(label, Convert.ToInt32(val));
-                hasValue |= Convert.ToInt32(val) == Convert.ToInt32(value);
+                var label = enumNames[i];
+                var entry = Convert.ToInt32(val);
+                _idToValue.Add(i, entry);
+                _valueToId.TryAdd(entry, i);
+                optionButton.AddItem(label, i);
+                if (entry == convertedValue)
+                {
+                    hasValue = true;
+                    selectedId = i;
+                }
+                i += 1;
             }
 
-            // TODO properly support enum flags
-            if (!hasValue)
-                optionButton.AddItem(value.ToString() ?? string.Empty, Convert.ToInt32(value));
+            var isFlags = enumType.GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
 
-            optionButton.SelectId(Convert.ToInt32(value));
+            // Handle unnamed enum values.
+            if (!hasValue || isFlags)
+            {
+                _invalidOptionId = i;
+                _idToValue.Add(_invalidOptionId, convertedValue);
+                optionButton.AddItem(string.Empty, _invalidOptionId);
+                if (!hasValue)
+                    selectedId = _invalidOptionId;
+            }
+
+            optionButton.SelectId(selectedId);
             optionButton.Disabled = ReadOnly;
 
+            // Flags
+            if (isFlags)
+            {
+                _flagEnum = true;
+                var flags = 0;
+                foreach (var val in enumList)
+                {
+                    var entry = Convert.ToInt32(val);
+                    if ((entry & flags) != 0 || entry == 0)
+                        continue;
+
+                    flags |= entry;
+                    var button = new Button
+                    {
+                        Text = enumNames[_valueToId[entry]],
+                    };
+                    _buttons.Add(entry, button);
+                    hBoxContainer.AddChild(button);
+                    button.ToggleMode = true;
+                    if (!ReadOnly)
+                    {
+                        button.OnToggled += args =>
+                        {
+                            if (args.Pressed)
+                                SelectButtons(_value | entry);
+                            else
+                                SelectButtons(_value & ~entry);
+                        };
+                    }
+                }
+            }
+
             if (!ReadOnly)
             {
-                var underlyingType = Enum.GetUnderlyingType(value.GetType());
                 optionButton.OnItemSelected += e =>
                 {
-                    optionButton.SelectId(e.Id);
-                    ValueChanged(Convert.ChangeType(e.Id, underlyingType));
+                    if (e.Id == _invalidOptionId)
+                    {
+                        optionButton.SelectId(_invalidOptionId);
+                        return;
+                    }
+
+                    SelectButtons(_idToValue[e.Id]);
                 };
             }
 
-            return optionButton;
+            SelectButtons(convertedValue, false);
+
+            return hBoxContainer;
+
+            void SelectButtons(int flags, bool changeValue = true)
+            {
+                _value = flags;
+                if (_flagEnum)
+                {
+                    foreach (var (buttonFlags, button) in _buttons)
+                    {
+                        button.Pressed = (buttonFlags & flags) != 0;
+                    }
+                }
+
+                if (!_valueToId.TryGetValue(flags, out var id)
+                    || !optionButton.TrySelectId(id))
+                    optionButton.SelectId(_invalidOptionId);
+
+                if (changeValue)
+                    ValueChanged(Convert.ChangeType(flags, underlyingType));
+            }
         }
     }
 }

Robust.Client/ViewVariables/Editors/VVPropEditorIPrototype.cs

@@ -77,7 +77,7 @@ namespace Robust.Client.ViewVariables.Editors
         {
             var protoMan = IoCManager.Resolve<IPrototypeManager>();
 
-            if (!protoMan.TryGetVariantFrom(typeof(T), out var variant)) return;
+            if (!protoMan.TryGetKindFrom(typeof(T), out var variant)) return;
 
             var list = new List<string>();
 

Robust.Client/ViewVariables/Editors/VVPropEditorReference.cs

@@ -8,9 +8,16 @@ namespace Robust.Client.ViewVariables.Editors
 {
     internal sealed class VVPropEditorReference : VVPropEditor
     {
+        [Dependency] private readonly IClientViewVariablesManager _vvMan = default!;
+
         private object? _localValue;
         private ViewVariablesObjectSelector? _selector;
 
+        public VVPropEditorReference()
+        {
+            IoCManager.InjectDependencies(this);
+        }
+
         protected override Control MakeUI(object? value)
         {
             if (value == null)
@@ -36,14 +43,13 @@ namespace Robust.Client.ViewVariables.Editors
 
         private void ButtonOnOnPressed(BaseButton.ButtonEventArgs obj)
         {
-            var vvm = IoCManager.Resolve<IClientViewVariablesManager>();
             if (_selector != null)
             {
-                vvm.OpenVV(_selector);
+                _vvMan.OpenVV(_selector);
             }
             else if (_localValue != null)
             {
-                vvm.OpenVV(_localValue);
+                _vvMan.OpenVV(_localValue);
             }
         }
 

Robust.Roslyn.Shared/Diagnostics.cs

@@ -31,6 +31,10 @@ public static class Diagnostics
     public const string IdDependencyFieldAssigned = "RA0025";
     public const string IdUncachedRegex = "RA0026";
     public const string IdDataFieldRedundantTag = "RA0027";
+    public const string IdMustCallBase = "RA0028";
+    public const string IdDataFieldNoVVReadWrite = "RA0029";
+    public const string IdUseNonGenericVariant = "RA0030";
+    public const string IdPreferOtherType = "RA0031";
 
     public static SuppressionDescriptor MeansImplicitAssignment =>
         new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");

Robust.Server/BaseServer.cs

@@ -104,6 +104,7 @@ namespace Robust.Server
         [Dependency] private readonly IComponentFactory _componentFactory = default!;
         [Dependency] private readonly IReplayRecordingManagerInternal _replay = default!;
         [Dependency] private readonly IGamePrototypeLoadManager _protoLoadMan = default!;
+        [Dependency] private readonly UploadedContentManager _uploadedContMan = default!;
         [Dependency] private readonly NetworkResourceManager _netResMan = default!;
         [Dependency] private readonly IReflectionManager _refMan = default!;
 
@@ -393,6 +394,7 @@ namespace Robust.Server
             _scriptHost.Initialize();
             _protoLoadMan.Initialize();
             _netResMan.Initialize();
+            _uploadedContMan.Initialize();
 
             // String serializer has to be locked before PostInit as content can depend on it (e.g., replays that start
             // automatically recording on startup).

Robust.Server/GameObjects/Components/Eye/ViewSubscriberComponent.cs

@@ -1,12 +0,0 @@
-using System.Collections.Generic;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Player;
-
-namespace Robust.Server.GameObjects
-{
-    [RegisterComponent]
-    internal sealed partial class ViewSubscriberComponent : Component
-    {
-        internal readonly HashSet<ICommonSession> SubscribedSessions = new();
-    }
-}

Robust.Server/GameObjects/Components/VisibilityComponent.cs

@@ -3,6 +3,10 @@ using Robust.Shared.Serialization.Manager.Attributes;
 
 namespace Robust.Server.GameObjects
 {
+    /// <summary>
+    /// Controls PVS visibility of entities. THIS COMPONENT CONTROLS WHETHER ENTITIES ARE NETWORKED TO PLAYERS
+    /// AND SHOULD NOT BE USED AS THE SOLE WAY TO HIDE AN ENTITY FROM A PLAYER.
+    /// </summary>
     [RegisterComponent]
     [Access(typeof(VisibilitySystem))]
     public sealed partial class VisibilityComponent : Component

Robust.Server/GameObjects/EntitySystems/MapLoaderSystem.cs

@@ -155,7 +155,7 @@ public sealed class MapLoaderSystem : EntitySystem
             result = Deserialize(data);
             _logLoader.Debug($"Loaded map in {sw.Elapsed}");
 
-            var mapEnt = _mapManager.GetMapEntityId(mapId);
+            var mapEnt = _mapSystem.GetMapOrInvalid(mapId);
             var xformQuery = _serverEntityManager.GetEntityQuery<TransformComponent>();
             var rootEnts = new List<EntityUid>();
             // aeoeoeieioe content
@@ -217,13 +217,13 @@ public sealed class MapLoaderSystem : EntitySystem
 
     public void SaveMap(MapId mapId, string ymlPath)
     {
-        if (!_mapManager.MapExists(mapId))
+        if (!_mapSystem.TryGetMap(mapId, out var mapUid))
         {
             _logLoader.Error($"Unable to find map {mapId}");
             return;
         }
 
-        Save(_mapManager.GetMapEntityId(mapId), ymlPath);
+        Save(mapUid.Value, ymlPath);
     }
 
     #endregion
@@ -422,7 +422,7 @@ public sealed class MapLoaderSystem : EntitySystem
     private HashSet<EntityUid> AllocEntities(MapData data, BeforeEntityReadEvent ev)
     {
         _stopwatch.Restart();
-        var mapUid = _mapManager.GetMapEntityId(data.TargetMap);
+        var mapUid = _mapSystem.GetMapOrInvalid(data.TargetMap);
         var pauseTime = mapUid.IsValid() ? _meta.GetPauseTime(mapUid) : TimeSpan.Zero;
         _context.Set(data.UidEntityMap, new Dictionary<EntityUid, int>(), data.MapIsPostInit, pauseTime, null);
         HashSet<EntityUid> deletedPrototypeUids = new();

Robust.Server/GameObjects/EntitySystems/ViewSubscriberSystem.cs

@@ -1,89 +1,87 @@
 using Robust.Shared.GameObjects;
 using Robust.Shared.Player;
 
-namespace Robust.Server.GameObjects
+namespace Robust.Server.GameObjects;
+
+/// <summary>
+///     Entity System that handles subscribing and unsubscribing to PVS views.
+/// </summary>
+public sealed class ViewSubscriberSystem : SharedViewSubscriberSystem
 {
-    /// <summary>
-    ///     Entity System that handles subscribing and unsubscribing to PVS views.
-    /// </summary>
-    public sealed class ViewSubscriberSystem : EntitySystem
+    public override void Initialize()
     {
-        public override void Initialize()
+        base.Initialize();
+        SubscribeLocalEvent<ViewSubscriberComponent, ComponentShutdown>(OnViewSubscriberShutdown);
+    }
+
+    /// <summary>
+    ///     Subscribes the session to get PVS updates from the point of view of the specified entity.
+    /// </summary>
+    public override void AddViewSubscriber(EntityUid uid, ICommonSession session)
+    {
+        // If the entity doesn't have the component, it will be added.
+        var viewSubscriber = EntityManager.EnsureComponent<Shared.GameObjects.ViewSubscriberComponent>(uid);
+
+        if (viewSubscriber.SubscribedSessions.Contains(session))
+            return; // Already subscribed, do nothing else.
+
+        viewSubscriber.SubscribedSessions.Add(session);
+        session.ViewSubscriptions.Add(uid);
+
+        RaiseLocalEvent(uid, new ViewSubscriberAddedEvent(uid, session), true);
+    }
+
+    /// <summary>
+    ///     Unsubscribes the session from getting PVS updates from the point of view of the specified entity.
+    /// </summary>
+    public override void RemoveViewSubscriber(EntityUid uid, ICommonSession session)
+    {
+        if(!EntityManager.TryGetComponent(uid, out Shared.GameObjects.ViewSubscriberComponent? viewSubscriber))
+            return; // Entity didn't have any subscriptions, do nothing.
+
+        if (!viewSubscriber.SubscribedSessions.Remove(session))
+            return; // Session wasn't subscribed, do nothing.
+
+        session.ViewSubscriptions.Remove(uid);
+        RaiseLocalEvent(uid, new ViewSubscriberRemovedEvent(uid, session), true);
+    }
+
+    private void OnViewSubscriberShutdown(EntityUid uid, ViewSubscriberComponent component, ComponentShutdown _)
+    {
+        foreach (var session in component.SubscribedSessions)
         {
-            base.Initialize();
-
-            SubscribeLocalEvent<ViewSubscriberComponent, ComponentShutdown>(OnViewSubscriberShutdown);
-        }
-
-        /// <summary>
-        ///     Subscribes the session to get PVS updates from the point of view of the specified entity.
-        /// </summary>
-        public void AddViewSubscriber(EntityUid uid, ICommonSession session)
-        {
-            // If the entity doesn't have the component, it will be added.
-            var viewSubscriber = EntityManager.EnsureComponent<ViewSubscriberComponent>(uid);
-
-            if (viewSubscriber.SubscribedSessions.Contains(session))
-                return; // Already subscribed, do nothing else.
-
-            viewSubscriber.SubscribedSessions.Add(session);
-            session.ViewSubscriptions.Add(uid);
-
-            RaiseLocalEvent(uid, new ViewSubscriberAddedEvent(uid, session), true);
-        }
-
-        /// <summary>
-        ///     Unsubscribes the session from getting PVS updates from the point of view of the specified entity.
-        /// </summary>
-        public void RemoveViewSubscriber(EntityUid uid, ICommonSession session)
-        {
-            if(!EntityManager.TryGetComponent(uid, out ViewSubscriberComponent? viewSubscriber))
-                return; // Entity didn't have any subscriptions, do nothing.
-
-            if (!viewSubscriber.SubscribedSessions.Remove(session))
-                return; // Session wasn't subscribed, do nothing.
-
             session.ViewSubscriptions.Remove(uid);
-            RaiseLocalEvent(uid, new ViewSubscriberRemovedEvent(uid, session), true);
-        }
-
-        private void OnViewSubscriberShutdown(EntityUid uid, ViewSubscriberComponent component, ComponentShutdown _)
-        {
-            foreach (var session in component.SubscribedSessions)
-            {
-                session.ViewSubscriptions.Remove(uid);
-            }
-        }
-    }
-
-    /// <summary>
-    ///     Raised when a session subscribes to an entity's PVS view.
-    /// </summary>
-    public sealed class ViewSubscriberAddedEvent : EntityEventArgs
-    {
-        public EntityUid View { get; }
-        public ICommonSession Subscriber { get; }
-
-        public ViewSubscriberAddedEvent(EntityUid view, ICommonSession subscriber)
-        {
-            View = view;
-            Subscriber = subscriber;
-        }
-    }
-
-    /// <summary>
-    ///     Raised when a session is unsubscribed from an entity's PVS view.
-    ///     Not raised when sessions are unsubscribed due to the component being removed.
-    /// </summary>
-    public sealed class ViewSubscriberRemovedEvent : EntityEventArgs
-    {
-        public EntityUid View { get; }
-        public ICommonSession Subscriber { get; }
-
-        public ViewSubscriberRemovedEvent(EntityUid view, ICommonSession subscriber)
-        {
-            View = view;
-            Subscriber = subscriber;
         }
     }
 }
+
+/// <summary>
+///     Raised when a session subscribes to an entity's PVS view.
+/// </summary>
+public sealed class ViewSubscriberAddedEvent : EntityEventArgs
+{
+    public EntityUid View { get; }
+    public ICommonSession Subscriber { get; }
+
+    public ViewSubscriberAddedEvent(EntityUid view, ICommonSession subscriber)
+    {
+        View = view;
+        Subscriber = subscriber;
+    }
+}
+
+/// <summary>
+///     Raised when a session is unsubscribed from an entity's PVS view.
+///     Not raised when sessions are unsubscribed due to the component being removed.
+/// </summary>
+public sealed class ViewSubscriberRemovedEvent : EntityEventArgs
+{
+    public EntityUid View { get; }
+    public ICommonSession Subscriber { get; }
+
+    public ViewSubscriberRemovedEvent(EntityUid view, ICommonSession subscriber)
+    {
+        View = view;
+        Subscriber = subscriber;
+    }
+}

Robust.Server/GameObjects/EntitySystems/VisibilitySystem.cs

@@ -40,12 +40,6 @@ namespace Robust.Server.GameObjects
             EntityManager.EntityInitialized -= OnEntityInit;
         }
 
-        [Obsolete("Use Entity<T> variant")]
-        public void AddLayer(EntityUid uid, VisibilityComponent component, int layer, bool refresh = true)
-        {
-            AddLayer((uid, component), (ushort)layer, refresh);
-        }
-
         public void AddLayer(Entity<VisibilityComponent?> ent, ushort layer, bool refresh = true)
         {
             ent.Comp ??= _visibilityQuery.CompOrNull(ent.Owner) ?? AddComp<VisibilityComponent>(ent.Owner);
@@ -59,13 +53,6 @@ namespace Robust.Server.GameObjects
                 RefreshVisibility(ent);
         }
 
-
-        [Obsolete("Use Entity<T> variant")]
-        public void RemoveLayer(EntityUid uid, VisibilityComponent component, int layer, bool refresh = true)
-        {
-            RemoveLayer((uid, component), (ushort)layer, refresh);
-        }
-
         public void RemoveLayer(Entity<VisibilityComponent?> ent, ushort layer, bool refresh = true)
         {
             if (!_visibilityQuery.Resolve(ent.Owner, ref ent.Comp, false))
@@ -80,12 +67,6 @@ namespace Robust.Server.GameObjects
                 RefreshVisibility(ent);
         }
 
-        [Obsolete("Use Entity<T> variant")]
-        public void SetLayer(EntityUid uid, VisibilityComponent component, int layer, bool refresh = true)
-        {
-            SetLayer((uid, component), (ushort)layer, refresh);
-        }
-
         public void SetLayer(Entity<VisibilityComponent?> ent, ushort layer, bool refresh = true)
         {
             ent.Comp ??= _visibilityQuery.CompOrNull(ent.Owner) ?? AddComp<VisibilityComponent>(ent.Owner);

Robust.Server/GameObjects/ServerComponentFactory.cs

@@ -2,12 +2,13 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Reflection;
+using Robust.Shared.Serialization.Manager;
 
 namespace Robust.Server.GameObjects;
 
 internal sealed class ServerComponentFactory : ComponentFactory
 {
-    public ServerComponentFactory(IDynamicTypeFactoryInternal typeFactory, IReflectionManager reflectionManager, ILogManager logManager) : base(typeFactory, reflectionManager, logManager)
+    public ServerComponentFactory(IDynamicTypeFactoryInternal typeFactory, IReflectionManager reflectionManager, ISerializationManager serManager, ILogManager logManager) : base(typeFactory, reflectionManager, serManager, logManager)
     {
         RegisterIgnore("Input");
         RegisterIgnore("AnimationPlayer");

Robust.Server/GameObjects/ServerEntityManager.cs

@@ -229,21 +229,6 @@ namespace Robust.Server.GameObjects
 
         private void HandleEntityNetworkMessage(MsgEntity message)
         {
-            var msgT = message.SourceTick;
-            var cT = _gameTiming.CurTick;
-
-            if (msgT <= cT)
-            {
-                if (msgT < cT && _logLateMsgs)
-                {
-                    _netEntSawmill.Warning("Got late MsgEntity! Diff: {0}, msgT: {2}, cT: {3}, player: {1}",
-                        (int) msgT.Value - (int) cT.Value, message.MsgChannel.UserName, msgT, cT);
-                }
-
-                DispatchEntityNetworkMessage(message);
-                return;
-            }
-
             _queue.Add(message);
         }
 

Robust.Server/GameStates/PvsSystem.Session.cs

@@ -80,14 +80,17 @@ internal sealed partial class PvsSystem
         // Update visibility masks & viewer positions
         // TODO PVS do this before sending state.
         // I,e, we already enumerate over all eyes when computing visible chunks.
-        Span<MapCoordinates> positions = stackalloc MapCoordinates[session.Viewers.Length];
+        Span<(MapCoordinates pos, float scale)> positions = stackalloc (MapCoordinates, float)[session.Viewers.Length];
         int i = 0;
         foreach (var viewer in session.Viewers)
         {
             if (viewer.Comp2 != null)
                 session.VisMask |= viewer.Comp2.VisibilityMask;
 
-            positions[i++] = _transform.GetMapCoordinates(viewer.Owner, viewer.Comp1);
+            var mapCoordinates = _transform.GetMapCoordinates(viewer.Owner, viewer.Comp1);
+            mapCoordinates = mapCoordinates.Offset(viewer.Comp2?.Offset ?? Vector2.Zero);
+            var scale = MathF.Max((viewer.Comp2?.PvsScale ?? 1), 0.1f);
+            positions[i++] = (mapCoordinates, scale);
         }
 
         if (!CullingEnabled || session.DisableCulling)
@@ -112,7 +115,7 @@ internal sealed partial class PvsSystem
             DebugTools.Assert(!chunk.UpdateQueued);
             DebugTools.Assert(!chunk.Dirty);
 
-            foreach (var pos in positions)
+            foreach (var (pos, scale) in positions)
             {
                 if (pos.MapId != chunk.Position.MapId)
                     continue;
@@ -120,8 +123,9 @@ internal sealed partial class PvsSystem
                 dist = Math.Min(dist, (pos.Position - chunk.Position.Position).LengthSquared());
 
                 var relative = Vector2.Transform(pos.Position, chunk.InvWorldMatrix)  - chunk.Centre;
+
                 relative = Vector2.Abs(relative);
-                chebDist = Math.Min(chebDist, Math.Max(relative.X, relative.Y));
+                chebDist = Math.Min(chebDist, Math.Max(relative.X, relative.Y) / scale);
             }
 
             distances.Add(dist);

Robust.Server/GameStates/PvsSystem.cs

@@ -362,8 +362,19 @@ internal sealed partial class PvsSystem : EntitySystem
 
     private (Vector2 worldPos, float range, EntityUid? map) CalcViewBounds(Entity<TransformComponent, EyeComponent?> eye)
     {
-        var size = Math.Max(eye.Comp2?.PvsSize ?? _priorityViewSize, 1);
-        return (_transform.GetWorldPosition(eye.Comp1), size / 2f, eye.Comp1.MapUid);
+        var size = _priorityViewSize;
+        var worldPos = _transform.GetWorldPosition(eye.Comp1);
+
+        if (eye.Comp2 is not null)
+        {
+            // not using EyeComponent.Eye.Position, because it's updated only on the client's side
+            worldPos += eye.Comp2.Offset;
+            size *= eye.Comp2.PvsScale;
+        }
+
+        size = Math.Max(size, 1);
+
+        return (worldPos, size / 2f, eye.Comp1.MapUid);
     }
 
     private void CullDeletionHistoryUntil(GameTick tick)

Robust.Server/ServerIoC.cs

@@ -93,8 +93,10 @@ namespace Robust.Server
             deps.Register<IServerNetConfigurationManager, ServerNetConfigurationManager>();
             deps.Register<INetConfigurationManagerInternal, ServerNetConfigurationManager>();
             deps.Register<IGamePrototypeLoadManager, GamePrototypeLoadManager>();
+            deps.Register<GamePrototypeLoadManager>();
             deps.Register<NetworkResourceManager>();
             deps.Register<IHttpClientHolder, HttpClientHolder>();
+            deps.Register<UploadedContentManager>();
         }
     }
 }

Robust.Server/Upload/GamePrototypeLoadManager.cs

@@ -24,8 +24,6 @@ public sealed class GamePrototypeLoadManager : SharedPrototypeLoadManager
         base.Initialize();
 
         _sawmill = _logManager.GetSawmill("adminbus");
-
-        _netManager.Connected += NetManagerOnConnected;
     }
 
     public override void SendGamePrototype(string prototype)
@@ -50,7 +48,7 @@ public sealed class GamePrototypeLoadManager : SharedPrototypeLoadManager
         }
     }
 
-    private void NetManagerOnConnected(object? sender, NetChannelArgs e)
+    internal void SendToNewUser(INetChannel channel)
     {
         // Just dump all the prototypes on connect, before them missing could be an issue.
         foreach (var prototype in LoadedPrototypes)
@@ -59,7 +57,7 @@ public sealed class GamePrototypeLoadManager : SharedPrototypeLoadManager
             {
                 PrototypeData = prototype
             };
-            e.Channel.SendMessage(msg);
+            channel.SendMessage(msg);
         }
     }
 }

Robust.Server/Upload/NetworkResourceManager.cs

@@ -27,7 +27,6 @@ public sealed class NetworkResourceManager : SharedNetworkResourceManager
     {
         base.Initialize();
 
-        _serverNetManager.Connected += ServerNetManagerOnConnected;
         _cfgManager.OnValueChanged(CVars.ResourceUploadingEnabled, value => Enabled = value, true);
         _cfgManager.OnValueChanged(CVars.ResourceUploadingLimitMb, value => SizeLimit = value, true);
     }
@@ -65,14 +64,14 @@ public sealed class NetworkResourceManager : SharedNetworkResourceManager
         OnResourceUploaded?.Invoke(session, msg);
     }
 
-    private void ServerNetManagerOnConnected(object? sender, NetChannelArgs e)
+    internal void SendToNewUser(INetChannel channel)
     {
         foreach (var (path, data) in ContentRoot.GetAllFiles())
         {
             var msg = new NetworkResourceUploadMessage();
             msg.RelativePath = path;
             msg.Data = data;
-            e.Channel.SendMessage(msg);
+            channel.SendMessage(msg);
         }
     }
 }

Robust.Server/Upload/UploadedContentManager.cs

@@ -0,0 +1,28 @@
+using Robust.Shared.IoC;
+using Robust.Shared.Network;
+
+namespace Robust.Server.Upload;
+
+/// <summary>
+/// Responsible for sending uploaded content to clients when they connect.
+/// </summary>
+internal sealed class UploadedContentManager
+{
+    [Dependency] private readonly IServerNetManager _netManager = default!;
+    [Dependency] private readonly GamePrototypeLoadManager _prototypeLoadManager = default!;
+    [Dependency] private readonly NetworkResourceManager _networkResourceManager = default!;
+
+    public void Initialize()
+    {
+        _netManager.Connected += NetManagerOnConnected;
+    }
+
+    private void NetManagerOnConnected(object? sender, NetChannelArgs e)
+    {
+        // This just shells out to the other managers, ensuring they are ordered properly.
+        // Resources must be done before prototypes.
+        // Note: both net messages sent here are on the same group and are therefore ordered.
+        _networkResourceManager.SendToNewUser(e.Channel);
+        _prototypeLoadManager.SendToNewUser(e.Channel);
+    }
+}

Robust.Server/ViewVariables/ViewVariablesTrait.cs

@@ -107,7 +107,7 @@ namespace Robust.Server.ViewVariables
 
                 // We don't blindly send any prototypes, we ONLY send prototypes for valid, registered variants.
                 if (typeof(IPrototype).IsAssignableFrom(valType)
-                    && IoCManager.Resolve<IPrototypeManager>().TryGetVariantFrom(valType, out var variant))
+                    && IoCManager.Resolve<IPrototypeManager>().TryGetKindFrom(valType, out var variant))
                 {
                     return new ViewVariablesBlobMembers.PrototypeReferenceToken()
                     {
@@ -161,7 +161,7 @@ namespace Robust.Server.ViewVariables
             {
                 var protoMan = IoCManager.Resolve<IPrototypeManager>();
 
-                if (protoMan.TryGetVariantFrom(type, out var variant))
+                if (protoMan.TryGetKindFrom(type, out var variant))
                     return new ViewVariablesBlobMembers.PrototypeReferenceToken()
                     {
                         ID = null, Variant = variant, Stringified = PrettyPrint.PrintUserFacing(null),

Robust.Server/server_config.toml

@@ -9,7 +9,7 @@ level = 1
 enabled = false
 
 [net]
-tickrate = 60
+tickrate = 30
 port = 1212
 bindto = "::,0.0.0.0"
 max_connections = 256

Robust.Shared.Maths/Color.cs

@@ -26,6 +26,7 @@
 using System;
 using System.Collections.Frozen;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Linq;
 using System.Runtime.CompilerServices;
@@ -35,11 +36,6 @@ using Robust.Shared.Utility;
 using SysVector3 = System.Numerics.Vector3;
 using SysVector4 = System.Numerics.Vector4;
 
-#if NETCOREAPP
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-#endif
-
 namespace Robust.Shared.Maths
 {
     /// <summary>
@@ -50,37 +46,43 @@ namespace Robust.Shared.Maths
     public struct Color : IEquatable<Color>, ISpanFormattable
     {
         /// <summary>
-        ///     The red component of this Color4 structure.
+        ///     The red component of this Color structure.
         /// </summary>
         public float R;
 
         /// <summary>
-        ///     The green component of this Color4 structure.
+        ///     The green component of this Color structure.
         /// </summary>
         public float G;
 
         /// <summary>
-        ///     The blue component of this Color4 structure.
+        ///     The blue component of this Color structure.
         /// </summary>
         public float B;
 
         /// <summary>
-        ///     The alpha component of this Color4 structure.
+        ///     The alpha component of this Color structure.
         /// </summary>
         public float A;
 
+        /// <summary>
+        /// Vector representation, for easy SIMD operations.
+        /// </summary>
+        // ReSharper disable once InconsistentNaming
+        public readonly SysVector4 RGBA => Unsafe.BitCast<Color, SysVector4>(this);
+
         public readonly byte RByte => (byte) (R * byte.MaxValue);
         public readonly byte GByte => (byte) (G * byte.MaxValue);
         public readonly byte BByte => (byte) (B * byte.MaxValue);
         public readonly byte AByte => (byte) (A * byte.MaxValue);
 
         /// <summary>
-        ///     Constructs a new Color4 structure from the specified components.
+        ///     Constructs a new <see cref="Color"/> structure from the specified components.
         /// </summary>
-        /// <param name="r">The red component of the new Color4 structure.</param>
-        /// <param name="g">The green component of the new Color4 structure.</param>
-        /// <param name="b">The blue component of the new Color4 structure.</param>
-        /// <param name="a">The alpha component of the new Color4 structure.</param>
+        /// <param name="r">The red component of the new Color structure.</param>
+        /// <param name="g">The green component of the new Color structure.</param>
+        /// <param name="b">The blue component of the new Color structure.</param>
+        /// <param name="a">The alpha component of the new Color structure.</param>
         public Color(float r, float g, float b, float a = 1)
         {
             R = r;
@@ -90,14 +92,23 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Constructs a new Color4 structure from the specified components.
+        ///     Constructs a new Color structure from the components in a <see cref="SysVector4"/>.
         /// </summary>
-        /// <param name="r">The red component of the new Color4 structure.</param>
-        /// <param name="g">The green component of the new Color4 structure.</param>
-        /// <param name="b">The blue component of the new Color4 structure.</param>
-        /// <param name="a">The alpha component of the new Color4 structure.</param>
+        public Color(in SysVector4 vec)
+        {
+            this = Unsafe.BitCast<SysVector4, Color>(vec);
+        }
+
+        /// <summary>
+        ///     Constructs a new Color structure from the specified components.
+        /// </summary>
+        /// <param name="r">The red component of the new Color structure.</param>
+        /// <param name="g">The green component of the new Color structure.</param>
+        /// <param name="b">The blue component of the new Color structure.</param>
+        /// <param name="a">The alpha component of the new Color structure.</param>
         public Color(byte r, byte g, byte b, byte a = 255)
         {
+            Unsafe.SkipInit(out this);
             R = r / (float) byte.MaxValue;
             G = g / (float) byte.MaxValue;
             B = b / (float) byte.MaxValue;
@@ -124,7 +135,7 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Compares the specified Color4 structures for equality.
+        ///     Compares the specified Color structures for equality.
         /// </summary>
         /// <param name="left">The left-hand side of the comparison.</param>
         /// <param name="right">The right-hand side of the comparison.</param>
@@ -135,7 +146,7 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Compares the specified Color4 structures for inequality.
+        ///     Compares the specified Color structures for inequality.
         /// </summary>
         /// <param name="left">The left-hand side of the comparison.</param>
         /// <param name="right">The right-hand side of the comparison.</param>
@@ -146,10 +157,10 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Converts the specified System.Drawing.Color to a Color4 structure.
+        ///     Converts the specified System.Drawing.Color to a Color structure.
         /// </summary>
         /// <param name="color">The System.Drawing.Color to convert.</param>
-        /// <returns>A new Color4 structure containing the converted components.</returns>
+        /// <returns>A new Color structure containing the converted components.</returns>
         public static implicit operator Color(System.Drawing.Color color)
         {
             return new(color.R, color.G, color.B, color.A);
@@ -181,9 +192,9 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Converts the specified Color4 to a System.Drawing.Color structure.
+        ///     Converts the specified Color to a System.Drawing.Color structure.
         /// </summary>
-        /// <param name="color">The Color4 to convert.</param>
+        /// <param name="color">The Color to convert.</param>
         /// <returns>A new System.Drawing.Color structure containing the converted components.</returns>
         public static explicit operator System.Drawing.Color(Color color)
         {
@@ -210,11 +221,11 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Compares whether this Color4 structure is equal to the specified object.
+        ///     Compares whether this Color structure is equal to the specified object.
         /// </summary>
         /// <param name="obj">An object to compare to.</param>
-        /// <returns>True obj is a Color4 structure with the same components as this Color4; false otherwise.</returns>
-        public override readonly bool Equals(object? obj)
+        /// <returns>True obj is a Color structure with the same components as this Color; false otherwise.</returns>
+        public readonly override bool Equals(object? obj)
         {
             if (!(obj is Color))
                 return false;
@@ -223,19 +234,19 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Calculates the hash code for this Color4 structure.
+        ///     Calculates the hash code for this Color structure.
         /// </summary>
-        /// <returns>A System.Int32 containing the hash code of this Color4 structure.</returns>
-        public override readonly int GetHashCode()
+        /// <returns>A System.Int32 containing the hash code of this Color structure.</returns>
+        public readonly override int GetHashCode()
         {
             return ToArgb();
         }
 
         /// <summary>
-        ///     Creates a System.String that describes this Color4 structure.
+        ///     Creates a System.String that describes this Color structure.
         /// </summary>
-        /// <returns>A System.String that describes this Color4 structure.</returns>
-        public override readonly string ToString()
+        /// <returns>A System.String that describes this Color structure.</returns>
+        public readonly override string ToString()
         {
             return $"{{(R, G, B, A) = ({R}, {G}, {B}, {A})}}";
         }
@@ -309,7 +320,6 @@ namespace Robust.Shared.Maths
         public static Color FromSrgb(Color srgb)
         {
             float r, g, b;
-#if NETCOREAPP
             if (srgb.R <= 0.04045f)
                 r = srgb.R / 12.92f;
             else
@@ -324,22 +334,6 @@ namespace Robust.Shared.Maths
                 b = srgb.B / 12.92f;
             else
                 b = MathF.Pow((srgb.B + 0.055f) / (1.0f + 0.055f), 2.4f);
-#else
-            if (srgb.R <= 0.04045f)
-                r = srgb.R / 12.92f;
-            else
-                r = (float) Math.Pow((srgb.R + 0.055f) / (1.0f + 0.055f), 2.4f);
-
-            if (srgb.G <= 0.04045f)
-                g = srgb.G / 12.92f;
-            else
-                g = (float) Math.Pow((srgb.G + 0.055f) / (1.0f + 0.055f), 2.4f);
-
-            if (srgb.B <= 0.04045f)
-                b = srgb.B / 12.92f;
-            else
-                b = (float) Math.Pow((srgb.B + 0.055f) / (1.0f + 0.055f), 2.4f);
-#endif
 
             return new Color(r, g, b, srgb.A);
         }
@@ -355,7 +349,6 @@ namespace Robust.Shared.Maths
         {
             float r, g, b;
 
-#if NETCOREAPP
             if (rgb.R <= 0.0031308)
                 r = 12.92f * rgb.R;
             else
@@ -370,22 +363,6 @@ namespace Robust.Shared.Maths
                 b = 12.92f * rgb.B;
             else
                 b = (1.0f + 0.055f) * MathF.Pow(rgb.B, 1.0f / 2.4f) - 0.055f;
-#else
-            if (rgb.R <= 0.0031308)
-                r = 12.92f * rgb.R;
-            else
-                r = (1.0f + 0.055f) * (float) Math.Pow(rgb.R, 1.0f / 2.4f) - 0.055f;
-
-            if (rgb.G <= 0.0031308)
-                g = 12.92f * rgb.G;
-            else
-                g = (1.0f + 0.055f) * (float) Math.Pow(rgb.G, 1.0f / 2.4f) - 0.055f;
-
-            if (rgb.B <= 0.0031308)
-                b = 12.92f * rgb.B;
-            else
-                b = (1.0f + 0.055f) * (float) Math.Pow(rgb.B, 1.0f / 2.4f) - 0.055f;
-#endif
 
             return new Color(r, g, b, rgb.A);
         }
@@ -471,6 +448,7 @@ namespace Robust.Shared.Maths
         ///     Each has a range of 0.0 to 1.0.
         /// </returns>
         /// <param name="rgb">Color value to convert.</param>
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
         public static Vector4 ToHsl(Color rgb)
         {
             var max = MathF.Max(rgb.R, MathF.Max(rgb.G, rgb.B));
@@ -582,6 +560,7 @@ namespace Robust.Shared.Maths
         ///     Each has a range of 0.0 to 1.0.
         /// </returns>
         /// <param name="rgb">Color value to convert.</param>
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
         public static Vector4 ToHsv(Color rgb)
         {
             var max = MathF.Max(rgb.R, MathF.Max(rgb.G, rgb.B));
@@ -770,6 +749,7 @@ namespace Robust.Shared.Maths
         ///     Each has a range of 0.0 to 1.0.
         /// </returns>
         /// <param name="rgb">Color value to convert.</param>
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
         public static Vector4 ToHcy(Color rgb)
         {
             var max = MathF.Max(rgb.R, MathF.Max(rgb.G, rgb.B));
@@ -828,23 +808,10 @@ namespace Robust.Shared.Maths
         ///     with 0.5 being 50% of both colors, 0.25 being 25% of <paramref name="β" /> and 75%
         ///     <paramref name="α" />.
         /// </param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static Color InterpolateBetween(Color α, Color β, float λ)
         {
-            if (Sse.IsSupported && Fma.IsSupported)
-            {
-                var vecA = Unsafe.As<Color, Vector128<float>>(ref α);
-                var vecB = Unsafe.As<Color, Vector128<float>>(ref β);
-
-                vecB = Fma.MultiplyAdd(Sse.Subtract(vecB, vecA), Vector128.Create(λ), vecA);
-
-                return Unsafe.As<Vector128<float>, Color>(ref vecB);
-            }
-            ref var svA = ref Unsafe.As<Color, SysVector4>(ref α);
-            ref var svB = ref Unsafe.As<Color, SysVector4>(ref β);
-
-            var res = SysVector4.Lerp(svA, svB, λ);
-
-            return Unsafe.As<SysVector4, Color>(ref res);
+            return new(SysVector4.Lerp(α.RGBA, β.RGBA, λ));
         }
 
         public static Color? TryFromHex(ReadOnlySpan<char> hexColor)
@@ -1000,13 +967,8 @@ namespace Robust.Shared.Maths
         /// <summary>
         ///     Component wise multiplication of two colors.
         /// </summary>
-        /// <param name="a"></param>
-        /// <param name="b"></param>
-        /// <returns></returns>
-        public static Color operator *(Color a, Color b)
-        {
-            return new(a.R * b.R, a.G * b.G, a.B * b.B, a.A * b.A);
-        }
+        public static Color operator *(in Color a, in Color b)
+            => new(a.RGBA * b.RGBA);
 
         public readonly string ToHex()
         {
@@ -1030,18 +992,12 @@ namespace Robust.Shared.Maths
         }
 
         /// <summary>
-        ///     Compares whether this Color4 structure is equal to the specified Color4.
+        ///     Compares whether this Color structure is equal to the specified Color.
         /// </summary>
-        /// <param name="other">The Color4 structure to compare to.</param>
-        /// <returns>True if both Color4 structures contain the same components; false otherwise.</returns>
+        /// <param name="other">The Color structure to compare to.</param>
+        /// <returns>True if both Color structures contain the same components; false otherwise.</returns>
         public readonly bool Equals(Color other)
-        {
-            return
-                MathHelper.CloseToPercent(R, other.R) &&
-                MathHelper.CloseToPercent(G, other.G) &&
-                MathHelper.CloseToPercent(B, other.B) &&
-                MathHelper.CloseToPercent(A, other.A);
-        }
+            => RGBA == other.RGBA;
 
         [PublicAPI]
         public enum BlendFactor : byte
@@ -1942,7 +1898,7 @@ namespace Robust.Shared.Maths
 
         public readonly string? Name()
         {
-            return DefaultColorsInverted.TryGetValue(this, out var name) ? name : null;
+            return DefaultColorsInverted.GetValueOrDefault(this);
         }
 
         public static bool TryParse(string input, out Color color)

Robust.Shared.Maths/MathHelper.cs

@@ -15,6 +15,7 @@ using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using System.Runtime.CompilerServices;
+using Vec4 = System.Numerics.Vector4;
 
 namespace Robust.Shared.Maths
 {
@@ -525,6 +526,27 @@ namespace Robust.Shared.Maths
             return Math.Abs(a - b) <= epsilon;
         }
 
+        /// <summary>
+        /// Returns whether two vectors are within <paramref name="percentage"/> of each other
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool CloseToPercent(Vec4 a, Vec4 b, float percentage = .00001f)
+        {
+            a = Vec4.Abs(a);
+            b = Vec4.Abs(b);
+            var p = new Vec4(percentage);
+            var epsilon = Vec4.Max(Vec4.Max(a, b) * p, p);
+            var delta = Vec4.Abs(a - b);
+            return delta.X <= epsilon.X && delta.Y <= epsilon.Y && delta.Z <= epsilon.Z && delta.W <= epsilon.W;
+        }
+
+        /// <summary>
+        /// Returns whether two colours are within <paramref name="percentage"/> of each other
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool CloseToPercent(Color a, Color b, float percentage = .00001f)
+            => CloseToPercent(a.RGBA, b.RGBA, percentage);
+
         /// <summary>
         /// Returns whether two floating point numbers are within <paramref name="percentage"/> of eachother
         /// </summary>