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

.editorconfig

@@ -7,6 +7,18 @@ indent_size = 4
 trim_trailing_whitespace = true
 charset = utf-8
 
+max_line_length = 120
+
+# ReSharper properties
+resharper_csharp_max_line_length = 120
+resharper_csharp_wrap_after_declaration_lpar = true
+resharper_csharp_wrap_arguments_style = chop_if_long
+resharper_csharp_wrap_parameters_style = chop_if_long
+resharper_keep_existing_attribute_arrangement = true
+resharper_place_field_attribute_on_same_line = if_owner_is_single_line
+resharper_wrap_chained_binary_patterns = chop_if_long
+resharper_wrap_chained_method_calls = chop_if_long
+
 [*.{csproj,xml,yml,dll.config,targets,props}]
 indent_size = 2
 

.github/workflows/build-test.yml

@@ -10,7 +10,7 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
+        os: [ubuntu-latest, windows-latest ] # , macos-latest] - temporarily disabled due to libfreetype.dll errors.
 
     runs-on: ${{ matrix.os }}
 
@@ -27,7 +27,8 @@ jobs:
       run: dotnet restore
     - name: Build
       run: dotnet build --no-restore /p:WarningsAsErrors=nullable
-    - name: Test Engine
+    - name: Robust.UnitTesting
       run: dotnet test --no-build Robust.UnitTesting/Robust.UnitTesting.csproj -- NUnit.ConsoleOut=0
-
+    - name: Robust.Analyzers.Tests
+      run: dotnet test --no-build Robust.Analyzers.Tests/Robust.Analyzers.Tests.csproj -- NUnit.ConsoleOut=0
 

.github/workflows/publish-client.yml

@@ -33,10 +33,10 @@ jobs:
         mkdir "release/${{ steps.parse_version.outputs.version }}"
         mv release/*.zip "release/${{ steps.parse_version.outputs.version }}"
 
-    - name: Upload files to centcomm
+    - name: Upload files to Suns
       uses: appleboy/scp-action@master
       with:
-        host: centcomm.spacestation14.io
+        host: suns.spacestation14.com
         username: robust-build-push
         key: ${{ secrets.CENTCOMM_ROBUST_BUILDS_PUSH_KEY }}
         source: "release/${{ steps.parse_version.outputs.version }}"
@@ -46,7 +46,7 @@ jobs:
     - name: Update manifest JSON
       uses: appleboy/ssh-action@master
       with:
-        host: centcomm.spacestation14.io
+        host: suns.spacestation14.com
         username: robust-build-push
         key: ${{ secrets.CENTCOMM_ROBUST_BUILDS_PUSH_KEY }}
         script: /home/robust-build-push/push.ps1 ${{ steps.parse_version.outputs.version }}

Directory.Packages.props

@@ -1,14 +1,25 @@
 <Project>
+  <PropertyGroup>
+    <!--
+    We actually set ManagePackageVersionsCentrally manually in another import file.
+    Since .NET SDK 8.0.300, ManagePackageVersionsCentrally is automatically set if Directory.Packages.props exists.
+    https://github.com/NuGet/NuGet.Client/pull/5572
+    We actively negate this here, as we have some packages in tree we don't want such automatic behavior for.
+    We use Directory.Build.props to get copy the state *after* our MSBuild config but before Nuget's config.
+    -->
+    <ManagePackageVersionsCentrally />
+  </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="BenchmarkDotNet" Version="0.13.12" />
     <PackageVersion Include="DiscordRichPresence" Version="1.2.1.24" />
     <PackageVersion Include="ILReader.Core" Version="1.0.0.4" />
     <PackageVersion Include="JetBrains.Annotations" Version="2023.3.0" />
     <PackageVersion Include="JetBrains.Profiler.Api" Version="1.4.0" />
-    <PackageVersion Include="Linguini.Bundle" Version="0.1.3" />
+    <PackageVersion Include="Linguini.Bundle" Version="0.8.1" />
     <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.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" />
@@ -33,7 +44,7 @@
     <PackageVersion Include="NUnit.Analyzers" Version="3.10.0" />
     <PackageVersion Include="NUnit3TestAdapter" Version="4.5.0" />
     <PackageVersion Include="Nett" Version="0.15.0" />
-    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.4" />
+    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="8.0.0" />
     <PackageVersion Include="OpenTK.OpenAL" Version="4.7.7" />
     <PackageVersion Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" />
     <PackageVersion Include="Pidgin" Version="3.2.2" />
@@ -45,17 +56,20 @@
     <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.2" />
-    <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.0" />
+    <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" />
     <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
     <PackageVersion Include="System.Numerics.Vectors" Version="4.5.0" />
+    <PackageVersion Include="System.Memory" Version="4.5.5" />
+    <PackageVersion Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
     <PackageVersion Include="TerraFX.Interop.Windows" Version="10.0.22621.5" />
     <PackageVersion Include="TerraFX.Interop.Xlib" Version="6.4.0" />
     <PackageVersion Include="VorbisPizza" Version="1.3.0" />
     <PackageVersion Include="YamlDotNet" Version="13.7.1" />
     <PackageVersion Include="prometheus-net" Version="8.2.1" />
     <PackageVersion Include="prometheus-net.DotNetRuntime" Version="4.4.0" />
+    <PackageVersion Include="PolySharp" Version="1.14.1" />
   </ItemGroup>
 </Project>

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 -->
 

MSBuild/XamlIL.targets

@@ -24,12 +24,16 @@
     <RobustInjectorsConfiguration>$(Configuration)</RobustInjectorsConfiguration>
     <RobustInjectorsConfiguration Condition="'$(Configuration)' == 'DebugOpt'">Debug</RobustInjectorsConfiguration>
     <RobustInjectorsConfiguration Condition="'$(Configuration)' == 'Tools'">Release</RobustInjectorsConfiguration>
+    <RobustInjectorsConfiguration Condition="'$(UseArtifactsOutput)' == 'true' And '$(RuntimeIdentifier)' != ''">$(RobustInjectorsConfiguration)_$(RuntimeIdentifier)</RobustInjectorsConfiguration>
+    <RobustInjectorsConfiguration Condition="'$(UseArtifactsOutput)' == 'true'">$(RobustInjectorsConfiguration.ToLower())</RobustInjectorsConfiguration>
+    <CompileRobustXamlTaskAssemblyFile Condition="'$(UseArtifactsOutput)' != 'true'">$(MSBuildThisFileDirectory)\..\Robust.Client.Injectors\bin\$(RobustInjectorsConfiguration)\netstandard2.0\Robust.Client.Injectors.dll</CompileRobustXamlTaskAssemblyFile>
+    <CompileRobustXamlTaskAssemblyFile Condition="'$(UseArtifactsOutput)' == 'true'">$(MSBuildThisFileDirectory)\..\..\artifacts\bin\Robust.Client.Injectors\$(RobustInjectorsConfiguration)\Robust.Client.Injectors.dll</CompileRobustXamlTaskAssemblyFile>
   </PropertyGroup>
 
   <UsingTask
     Condition="'$(_RobustUseExternalMSBuild)' != 'true' And $(DesignTimeBuild) != true"
     TaskName="CompileRobustXamlTask"
-    AssemblyFile="$(MSBuildThisFileDirectory)\..\Robust.Client.Injectors\bin\$(RobustInjectorsConfiguration)\netstandard2.0\Robust.Client.Injectors.dll"/>
+    AssemblyFile="$(CompileRobustXamlTaskAssemblyFile)"/>
   <Target
     Name="CompileRobustXaml"
     Condition="Exists('@(IntermediateAssembly)')"

Resources/EnginePrototypes/Audio/audio_entities.yml

@@ -2,4 +2,7 @@
   id: Audio
   name: Audio
   description: Audio entity used by engine
-  save: false
+  save: false
+  components:
+    - type: Transform
+      gridTraversal: false

Resources/EnginePrototypes/Debug/rotation.yml

@@ -1,7 +1,7 @@
 - type: entity
   id: debugRotation
   abstract: true
-  categories: [ debug ]
+  categories: [ Debug ]
   components:
   - type: Sprite
     netsync: false

Resources/EnginePrototypes/entityCategory.yml

@@ -1,17 +1,20 @@
 # debug related entities
 - type: entityCategory
-  id: debug
+  id: Debug
   name: entity-category-name-debug
   description: entity-category-desc-debug
+  suffix: entity-category-suffix-debug
 
 # entities that spawn other entities
 - type: entityCategory
-  id: spawner
+  id: Spawner
   name: entity-category-name-spawner
   description: entity-category-desc-spawner
 
-# entities that should be hidden from the spawn menu
+# simple category that just exists to hide prototypes in spawn menus
 - type: entityCategory
-  id: hideSpawnMenu
+  id: HideSpawnMenu
   name: entity-category-name-hide
   description: entity-category-desc-hide
+  hideSpawnMenu: true
+  inheritable: false

Resources/Locale/en-US/commands.ftl

@@ -9,8 +9,10 @@ cmd-parse-failure-float = {$arg} is not a valid float.
 cmd-parse-failure-bool = {$arg} is not a valid bool.
 cmd-parse-failure-uid = {$arg} is not a valid entity UID.
 cmd-parse-failure-mapid = {$arg} is not a valid MapId.
+cmd-parse-failure-enum = {$arg} is not a {$enum} Enum.
 cmd-parse-failure-grid = {$arg} is not a valid grid.
 cmd-parse-failure-entity-exist = UID {$arg} does not correspond to an existing entity.
+cmd-parse-failure-session = There is no session with username: {$username}
 
 cmd-error-file-not-found = Could not find file: {$file}.
 cmd-error-dir-not-found = Could not find directory: {$dir}.
@@ -42,6 +44,13 @@ cmd-cvar-compl-list = List available CVars
 cmd-cvar-arg-name = <name | ?>
 cmd-cvar-value-hidden = <value hidden>
 
+## 'cvar_subs' command
+cmd-cvar_subs-desc = Lists the OnValueChanged subscriptions for a CVar.
+cmd-cvar_subs-help = Usage: cvar_subs <name>
+
+cmd-cvar_subs-invalid-args = Must provide exactly one argument.
+cmd-cvar_subs-arg-name = <name>
+
 ## 'list' command
 cmd-list-desc = Lists available commands, with optional search filter
 cmd-list-help = Usage: list [filter]
@@ -244,9 +253,6 @@ cmd-bind-arg-command = <InputCommand>
 cmd-net-draw-interp-desc = Toggles the debug drawing of the network interpolation.
 cmd-net-draw-interp-help = Usage: net_draw_interp
 
-cmd-net-draw-interp-desc = Toggles the debug drawing of the network interpolation.
-cmd-net-draw-interp-help = Usage: net_draw_interp
-
 cmd-net-watch-ent-desc = Dumps all network updates for an EntityId to the console.
 cmd-net-watch-ent-help = Usage: net_watchent <0|EntityUid>
 
@@ -298,16 +304,9 @@ cmd-savegrid-help = savegrid <gridID> <Path>
 cmd-testbed-desc = Loads a physics testbed on the specified map.
 cmd-testbed-help = testbed <mapid> <test>
 
-cmd-saveconfig-desc = Saves the client configuration to the config file.
-cmd-saveconfig-help = saveconfig
-
 ## 'flushcookies' command
 # Note: the flushcookies command is from Robust.Client.WebView, it's not in the main engine code.
 
-cmd-flushcookies-desc = Flush CEF cookie storage to disk
-cmd-flushcookies-help = This ensure cookies are properly saved to disk in the event of unclean shutdowns.
-    Note that the actual operation is asynchronous.
-
 ## 'addcomp' command
 cmd-addcomp-desc = Adds a component to an entity.
 cmd-addcomp-help = addcomp <uid> <componentName>
@@ -383,9 +382,9 @@ cmd-tp-desc = Teleports a player to any location in the round.
 cmd-tp-help = tp <x> <y> [<mapID>]
 
 cmd-tpto-desc = Teleports the current player or the specified players/entities to the location of the first player/entity.
-cmd-tpto-help = tpto <username|uid> [username|uid]...
-cmd-tpto-destination-hint = destination (uid or username)
-cmd-tpto-victim-hint = entity to teleport (uid or username)
+cmd-tpto-help = tpto <username|uid> [username|NetEntity]...
+cmd-tpto-destination-hint = destination (NetEntity or username)
+cmd-tpto-victim-hint = entity to teleport (NetEntity or username)
 cmd-tpto-parse-error = Cant resolve entity or player: {$str}
 
 cmd-listplayers-desc = Lists all players currently connected.
@@ -445,9 +444,6 @@ cmd-showanchored-help = Usage: showanchored
 cmd-dmetamem-desc = Dumps a type's members in a format suitable for the sandbox configuration file.
 cmd-dmetamem-help = Usage: dmetamem <type>
 
-cmd-dmetamem-desc = Displays chunk bounds for the purposes of rendering.
-cmd-dmetamem-help = Usage: showchunkbb <type>
-
 cmd-launchauth-desc = Load authentication tokens from launcher data to aid in testing of live servers.
 cmd-launchauth-help = Usage: launchauth <account name>
 
@@ -490,7 +486,7 @@ cmd-net_entityreport-help = Usage: net_entityreport
 cmd-net_refresh-desc = Requests a full server state.
 cmd-net_refresh-help = Usage: net_refresh
 
-cmd-net_graph-desc = Toggles the net statistics pannel.
+cmd-net_graph-desc = Toggles the net statistics panel.
 cmd-net_graph-help = Usage: net_graph
 
 cmd-net_watchent-desc = Dumps all network updates for an EntityId to the console.
@@ -514,9 +510,6 @@ cmd-profsnap-help = Usage: profsnap
 cmd-devwindow-desc = Dev Window
 cmd-devwindow-help = Usage: devwindow
 
-cmd-devwindow-desc = Open file
-cmd-devwindow-help = Usage: testopenfile
-
 cmd-scene-desc = Immediately changes the UI scene/state.
 cmd-scene-help = Usage: scene <className>
 
@@ -527,14 +520,11 @@ cmd-hwid-desc = Returns the current HWID (HardWare ID).
 cmd-hwid-help = Usage: hwid
 
 cmd-vvread-desc = Retrieve a path's value using VV (View Variables).
-cmd-vvread-desc = Usage: vvread <path>
+cmd-vvread-help = Usage: vvread <path>
 
 cmd-vvwrite-desc = Modify a path's value using VV (View Variables).
 cmd-vvwrite-help = Usage: vvwrite <path>
 
-cmd-vv-desc = Opens View Variables (VV).
-cmd-vv-help = Usage: vv <path|entity ID|guihover>
-
 cmd-vvinvoke-desc = Invoke/Call a path with arguments using VV.
 cmd-vvinvoke-help = Usage: vvinvoke <path> [arguments...]
 
@@ -566,3 +556,9 @@ cmd-reloadtiletextures-help = Usage: reloadtiletextures
 cmd-audio_length-desc = Shows the length of an audio file
 cmd-audio_length-help = Usage: audio_length { cmd-audio_length-arg-file-name }
 cmd-audio_length-arg-file-name = <file name>
+
+## PVS
+cmd-pvs-override-info-desc = Prints information about any PVS overrides associated with an entity.
+cmd-pvs-override-info-empty = Entity {$nuid} has no PVS overrides.
+cmd-pvs-override-info-global = Entity {$nuid} has a global override.
+cmd-pvs-override-info-clients = Entity {$nuid} has a session override for {$clients}.

Resources/Locale/en-US/entity-category.ftl

@@ -1,8 +1,9 @@
 entity-category-name-debug = Debug
 entity-category-desc-debug = Entity prototypes intended for debugging & testing.
+entity-category-suffix-debug = Debug
 
 entity-category-name-spawner = Spawner
 entity-category-desc-spawner = Entity prototypes that spawn other entities.
 
 entity-category-name-hide = Hidden
-entity-category-desc-hide = Entity prototypes that should be hidden from the spawn menu
+entity-category-desc-hide = Entity prototypes that should be hidden from entity spawn menus

Resources/Locale/en-US/toolshed-commands.ftl

@@ -70,9 +70,9 @@ command-description-ls-in =
 command-description-methods-get =
     Returns all methods associated with the input type.
 command-description-methods-overrides =
-    Returns all methods overriden on the input type.
+    Returns all methods overridden on the input type.
 command-description-methods-overridesfrom =
-    Returns all methods overriden from the given type on the input type.
+    Returns all methods overridden from the given type on the input type.
 command-description-cmd-moo =
     Asks the important questions.
 command-description-cmd-descloc =
@@ -418,6 +418,6 @@ command-description-tee =
     This essentially lets you have a branch in your code to do multiple operations on one value.
 command-description-cmd-info =
     Returns a CommandSpec for the given command.
-    On it's own, this means it'll print the comamnd's help message.
+    On its own, this means it'll print the command's help message.
 command-description-comp-rm =
     Removes the given component from the entity.

Resources/Locale/en-US/userinterface.ftl

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

Resources/Locale/en-US/view-variables.ftl

@@ -10,3 +10,18 @@ view-variable-instance-entity-client-components-search-bar-placeholder = Search
 view-variable-instance-entity-server-components-search-bar-placeholder = Search
 view-variable-instance-entity-add-window-server-components = Add Component [S]
 view-variable-instance-entity-add-window-client-components = Add Component [C]
+
+
+## SoundSpecifier
+vv-sound-none = None
+vv-sound-path = Path
+vv-sound-collection = Collection
+
+vv-sound-volume = volume
+vv-sound-pitch = Pitch
+vv-sound-max-distance = Max Distance
+vv-sound-rolloff-factor = Rolloff Factor
+vv-sound-reference-distance = Reference Distance
+vv-sound-loop = Loop
+vv-sound-play-offset = Play Offset (s)
+vv-sound-variation = Pitch variation

Robust.Analyzers.Tests/AccessAnalyzer_Test.cs

@@ -20,11 +20,16 @@ public sealed class AccessAnalyzer_Test
         {
             TestState =
             {
-                AdditionalReferences = { typeof(AccessAnalyzer).Assembly },
                 Sources = { code }
             },
         };
 
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.AccessAttribute.cs",
+            "Robust.Shared.Analyzers.AccessPermissions.cs"
+        );
+
         // ExpectedDiagnostics cannot be set, so we need to AddRange here...
         test.TestState.ExpectedDiagnostics.AddRange(expected);
 

Robust.Analyzers.Tests/Aliases.cs

@@ -0,0 +1,8 @@
+// OH BOY. TURNS OUT IT GETS EVEN MORE CURSED.
+//
+// So because we're compiling a copy of Robust.Roslyn.Shared into every analyzer project,
+// the test project sees multiple copies of it. This would make it impossible to use.
+// UNLESS you use this obscure C# feature called "extern alias"
+// that I guarantee you you've never heard of before, and are now concerned about.
+
+extern alias SerializationGenerator;

Robust.Analyzers.Tests/ComponentPauseGeneratorTest.cs

@@ -0,0 +1,340 @@
+extern alias SerializationGenerator;
+using System.Linq;
+using System.Reflection;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Text;
+using NUnit.Framework;
+using SerializationGenerator::Robust.Roslyn.Shared;
+using SerializationGenerator::Robust.Serialization.Generator;
+
+namespace Robust.Analyzers.Tests;
+
+[TestFixture]
+[TestOf(typeof(ComponentPauseGenerator))]
+[Parallelizable(ParallelScope.All)]
+public sealed class ComponentPauseGeneratorTest
+{
+    private const string TypesCode = """
+        global using System;
+        global using Robust.Shared.Analyzers;
+        global using Robust.Shared.GameObjects;
+
+        namespace Robust.Shared.Analyzers
+        {
+            [AttributeUsage(AttributeTargets.Class, Inherited = false)]
+            public sealed class AutoGenerateComponentPauseAttribute : Attribute
+            {
+                public bool Dirty = false;
+            }
+
+            [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+            public sealed class AutoPausedFieldAttribute : Attribute;
+
+            [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+            public sealed class AutoNetworkedFieldAttribute : Attribute
+            {
+            }
+        }
+
+        namespace Robust.Shared.GameObjects
+        {
+            public interface IComponent;
+        }
+        """;
+
+    [Test]
+    public void TestBasic()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    component.Foo += args.PausedTime;
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestNullable()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan? Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    if (component.Foo.HasValue)
+                        component.Foo = component.Foo.Value + args.PausedTime;
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestAutoState()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField, AutoNetworkedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    component.Foo += args.PausedTime;
+                    Dirty(uid, component);
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestExplicitDirty()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause(Dirty = true)]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoDiagnostics(result);
+        ExpectSource(
+            result,
+            """
+            // <auto-generated />
+
+            using Robust.Shared.GameObjects;
+
+            public partial class FooComponent
+            {
+            [RobustAutoGenerated]
+            public sealed class FooComponent_AutoPauseSystem : EntitySystem
+            {
+                public override void Initialize()
+                {
+                    SubscribeLocalEvent<FooComponent, EntityUnpausedEvent>(OnEntityUnpaused);
+                }
+
+                private void OnEntityUnpaused(EntityUid uid, FooComponent component, ref EntityUnpausedEvent args)
+                {
+                    component.Foo += args.PausedTime;
+                    Dirty(uid, component);
+                }
+            }
+            }
+
+            """);
+    }
+
+    [Test]
+    public void TestDiagnosticNotIComponent()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseNotComponent, new LinePositionSpan(new LinePosition(1, 28), new LinePosition(1, 40)))
+        ]);
+    }
+
+    [Test]
+    public void TestDiagnosticNoFields()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                public TimeSpan Foo;
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseNoFields, new LinePositionSpan(new LinePosition(1, 28), new LinePosition(1, 40)))
+        ]);
+    }
+
+    [Test]
+    public void TestDiagnosticNoParentAttribute()
+    {
+        var result = RunGenerator("""
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public TimeSpan Foo, Fooz;
+
+                [AutoPausedField]
+                public TimeSpan Bar { get; set; }
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseNoParentAttribute, new LinePositionSpan(new LinePosition(3, 20), new LinePosition(3, 23))),
+            (Diagnostics.IdComponentPauseNoParentAttribute, new LinePositionSpan(new LinePosition(3, 25), new LinePosition(3, 29))),
+            (Diagnostics.IdComponentPauseNoParentAttribute, new LinePositionSpan(new LinePosition(6, 20), new LinePosition(6, 23)))
+        ]);
+    }
+
+    [Test]
+    public void TestDiagnosticWrongType()
+    {
+        var result = RunGenerator("""
+            [AutoGenerateComponentPause]
+            public sealed partial class FooComponent : IComponent
+            {
+                [AutoPausedField]
+                public int Foo, Fooz;
+
+                [AutoPausedField]
+                public int Bar { get; set; }
+            }
+            """);
+
+        ExpectNoSource(result);
+        ExpectDiagnostics(result, [
+            (Diagnostics.IdComponentPauseWrongTypeAttribute, new LinePositionSpan(new LinePosition(4, 15), new LinePosition(4, 18))),
+            (Diagnostics.IdComponentPauseWrongTypeAttribute, new LinePositionSpan(new LinePosition(4, 20), new LinePosition(4, 24))),
+            (Diagnostics.IdComponentPauseWrongTypeAttribute, new LinePositionSpan(new LinePosition(7, 15), new LinePosition(7, 18)))
+        ]);
+    }
+
+    private static void ExpectSource(GeneratorRunResult result, string expected)
+    {
+        Assert.That(result.GeneratedSources, Has.Length.EqualTo(1));
+
+        var source = result.GeneratedSources[0];
+
+        Assert.That(source.SourceText.ToString(), Is.EqualTo(expected));
+    }
+
+    private static void ExpectNoSource(GeneratorRunResult result)
+    {
+        Assert.That(result.GeneratedSources, Is.Empty);
+    }
+
+    private static void ExpectNoDiagnostics(GeneratorRunResult result)
+    {
+        Assert.That(result.Diagnostics, Is.Empty);
+    }
+
+    private static void ExpectDiagnostics(GeneratorRunResult result, (string code, LinePositionSpan span)[] diagnostics)
+    {
+        Assert.Multiple(() =>
+        {
+            Assert.That(result.Diagnostics, Has.Length.EqualTo(diagnostics.Length));
+            foreach (var (code, span) in diagnostics)
+            {
+                Assert.That(
+                    result.Diagnostics.Any(x => x.Id == code && x.Location.GetLineSpan().Span == span),
+                    $"Expected diagnostic with code {code} and location {span}");
+            }
+        });
+    }
+
+    private static GeneratorRunResult RunGenerator(string source)
+    {
+        var compilation = (Compilation)CSharpCompilation.Create("compilation",
+            new[]
+            {
+                CSharpSyntaxTree.ParseText(source, path: "Source.cs"),
+                CSharpSyntaxTree.ParseText(TypesCode, path: "Types.cs")
+            },
+            new[] { MetadataReference.CreateFromFile(typeof(Binder).GetTypeInfo().Assembly.Location) },
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+        var generator = new ComponentPauseGenerator();
+        GeneratorDriver driver = CSharpGeneratorDriver.Create(generator);
+        driver = driver.RunGeneratorsAndUpdateCompilation(compilation, out var newCompilation, out _);
+        var result = driver.GetRunResult();
+
+        return result.Results[0];
+    }
+}

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/DependencyAssignAnalyzerTest.cs

@@ -0,0 +1,58 @@
+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.DependencyAssignAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class DependencyAssignAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<DependencyAssignAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.IoC.DependencyAttribute.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.IoC;
+
+            public sealed class Foo
+            {
+                [Dependency]
+                private object? Field;
+
+                public Foo()
+                {
+                    Field = "A";
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(10,9): warning RA0025: Tried to assign to [Dependency] field 'Field'. Remove [Dependency] or inject it via field injection instead.
+            VerifyCS.Diagnostic().WithSpan(10, 9, 10, 20).WithArguments("Field"));
+    }
+}

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/NoUncachedRegexAnalyzerTest.cs

@@ -0,0 +1,57 @@
+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.NoUncachedRegexAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class NoUncachedRegexAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<NoUncachedRegexAnalyzer, 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.Text.RegularExpressions;
+
+            public static class Foo
+            {
+                public static void Bad()
+                {
+                    Regex.Replace("foo", "bar", "baz");
+                }
+
+                public static void Good()
+                {
+                    var r = new Regex("bar");
+                    r.Replace("foo", "baz");
+                }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(7,9): warning RA0026: Usage of a static Regex function that takes in a pattern string. This can cause constant re-parsing of the pattern.
+            VerifyCS.Diagnostic().WithSpan(7, 9, 7, 43)
+        );
+    }
+}

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

@@ -1,7 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <SkipRobustAnalyzer>true</SkipRobustAnalyzer>
+  </PropertyGroup>
+
   <Import Project="..\MSBuild\Robust.Properties.targets"/>
   <Import Project="..\MSBuild\Robust.Engine.props"/>
 
+  <!-- Engine source files needed to make the tests work -->
+  <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>
+
   <PropertyGroup>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
@@ -14,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"/>
@@ -23,5 +38,6 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Robust.Analyzers\Robust.Analyzers.csproj"/>
+    <ProjectReference Include="..\Robust.Serialization.Generator\Robust.Serialization.Generator.csproj" Aliases="SerializationGenerator" />
   </ItemGroup>
 </Project>

Robust.Analyzers.Tests/TestHelper.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Text;
+
+namespace Robust.Analyzers.Tests;
+
+public static class TestHelper
+{
+    public static void AddEmbeddedSources(SolutionState state, params string[] embeddedFiles)
+    {
+        AddEmbeddedSources(state, (IEnumerable<string>) embeddedFiles);
+    }
+
+    public static void AddEmbeddedSources(SolutionState state, IEnumerable<string> embeddedFiles)
+    {
+        foreach (var fileName in embeddedFiles)
+        {
+            using var stream = typeof(AccessAnalyzer_Test).Assembly.GetManifestResourceStream(fileName)!;
+            state.Sources.Add((fileName, SourceText.From(stream)));
+        }
+    }
+}

Robust.Analyzers/AccessAnalyzer.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 using Robust.Shared.Analyzers.Implementation;
 
 namespace Robust.Analyzers

Robust.Analyzers/ByRefEventAnalyzer.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 using static Microsoft.CodeAnalysis.SymbolEqualityComparer;
 
 namespace Robust.Analyzers;
@@ -16,7 +17,7 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor ByRefEventSubscribedByValueRule = new(
         Diagnostics.IdByRefEventSubscribedByValue,
         "By-ref event subscribed to by value",
-        "Tried to subscribe to a by-ref event '{0}' by value.",
+        "Tried to subscribe to a by-ref event '{0}' by value",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -26,7 +27,7 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor ByRefEventRaisedByValueRule = new(
         Diagnostics.IdByRefEventRaisedByValue,
         "By-ref event raised by value",
-        "Tried to raise a by-ref event '{0}' by value.",
+        "Tried to raise a by-ref event '{0}' by value",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -36,7 +37,7 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor ByValueEventRaisedByRefRule = new(
         Diagnostics.IdValueEventRaisedByRef,
         "Value event raised by-ref",
-        "Tried to raise a value event '{0}' by-ref.",
+        "Tried to raise a value event '{0}' by-ref",
         "Usage",
         DiagnosticSeverity.Error,
         true,

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -5,6 +5,9 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 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;
 
@@ -14,11 +17,14 @@ 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,
         "Type must be partial",
-        "Type {0} is a DataDefinition but is not partial.",
+        "Type {0} is a DataDefinition but is not partial",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -28,7 +34,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor NestedDataDefinitionPartialRule = new(
         Diagnostics.IdNestedDataDefinitionPartial,
         "Type must be partial",
-        "Type {0} contains nested data definition {1} but is not partial.",
+        "Type {0} contains nested data definition {1} but is not partial",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -38,7 +44,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor DataFieldWritableRule = new(
         Diagnostics.IdDataFieldWritable,
         "Data field must not be readonly",
-        "Data field {0} in data definition {1} is readonly.",
+        "Data field {0} in data definition {1} is readonly",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -48,15 +54,36 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
         Diagnostics.IdDataFieldPropertyWritable,
         "Data field property must have a setter",
-        "Data field property {0} in data definition {1} does not have a setter.",
+        "Data field property {0} in data definition {1} does not have a setter",
         "Usage",
         DiagnosticSeverity.Error,
         true,
         "Make sure to add a setter."
     );
 
+    private static readonly DiagnosticDescriptor DataFieldRedundantTagRule = new(
+        Diagnostics.IdDataFieldRedundantTag,
+        "Data field has redundant tag specified",
+        "Data field {0} in data definition {1} has an explicitly set tag that matches autogenerated tag",
+        "Usage",
+        DiagnosticSeverity.Info,
+        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
+        DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule,
+        DataFieldRedundantTagRule, DataFieldNoVVReadWriteRule
     );
 
     public override void Initialize(AnalysisContext context)
@@ -124,6 +151,18 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
             {
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, context.Node.GetLocation(), fieldSymbol.Name, type.Name));
             }
+
+            if (HasRedundantTag(fieldSymbol))
+            {
+                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));
+            }
         }
     }
 
@@ -148,6 +187,18 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         {
             context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, context.Node.GetLocation(), propertySymbol.Name, type.Name));
         }
+
+        if (HasRedundantTag(propertySymbol))
+        {
+            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));
+        }
     }
 
     private static bool IsReadOnlyDataField(ITypeSymbol type, ISymbol field)
@@ -216,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)
@@ -247,6 +316,57 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
+    private static bool HasRedundantTag(ISymbol symbol)
+    {
+        if (!IsDataField(symbol, out var _, out var attribute))
+            return false;
+
+        // No args, no problem
+        if (attribute.ConstructorArguments.Length == 0)
+            return false;
+
+        // If a tag is explicitly specified, it will be the first argument...
+        var tagArgument = attribute.ConstructorArguments[0];
+        // ...but the first arg could also something else, since tag is optional
+        // so we make sure that it's a string
+        if (tagArgument.Value is not string explicitName)
+            return false;
+
+        // Get the name that sourcegen would provide
+        var automaticName = DataDefinitionUtility.AutoGenerateTag(symbol.Name);
+
+        // If the explicit name matches the sourcegen name, we have a redundancy
+        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

@@ -1,23 +1,25 @@
 #nullable enable
 using System.Collections.Immutable;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxKind;
-using static Robust.Analyzers.Diagnostics;
+using static Robust.Roslyn.Shared.Diagnostics;
 
 namespace Robust.Analyzers;
 
 [ExportCodeFixProvider(LanguageNames.CSharp)]
 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
+        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable,
+        IdDataFieldRedundantTag, IdDataFieldNoVVReadWrite
     );
 
     public override Task RegisterCodeFixesAsync(CodeFixContext context)
@@ -34,6 +36,10 @@ public sealed class DefinitionFixer : CodeFixProvider
                     return RegisterDataFieldFix(context, diagnostic);
                 case IdDataFieldPropertyWritable:
                     return RegisterDataFieldPropertyFix(context, diagnostic);
+                case IdDataFieldRedundantTag:
+                    return RegisterRedundantTagFix(context, diagnostic);
+                case IdDataFieldNoVVReadWrite:
+                    return RegisterVVReadWriteFix(context, diagnostic);
             }
         }
 
@@ -72,6 +78,110 @@ public sealed class DefinitionFixer : CodeFixProvider
         return document.WithSyntaxRoot(root);
     }
 
+    private static async Task RegisterRedundantTagFix(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;
+
+        // Find the DataField attribute
+        AttributeSyntax? dataFieldAttribute = null;
+        foreach (var attributeList in token.AttributeLists)
+        {
+            foreach (var attribute in attributeList.Attributes)
+            {
+                if (attribute.Name.ToString() == DataFieldAttributeName)
+                {
+                    dataFieldAttribute = attribute;
+                    break;
+                }
+            }
+            if (dataFieldAttribute != null)
+                break;
+        }
+
+        if (dataFieldAttribute == null)
+            return;
+
+        context.RegisterCodeFix(CodeAction.Create(
+            "Remove explicitly set tag",
+            c => RemoveRedundantTag(context.Document, dataFieldAttribute, c),
+            "Remove explicitly set tag"
+        ), diagnostic);
+    }
+
+    private static async Task<Document> RemoveRedundantTag(Document document, AttributeSyntax syntax, CancellationToken cancellation)
+    {
+        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
+
+        if (syntax.ArgumentList == null)
+            return document;
+
+        AttributeSyntax? newSyntax;
+        if (syntax.ArgumentList.Arguments.Count == 1)
+        {
+            // If this is the only argument, delete the ArgumentList so we don't leave empty parentheses
+            newSyntax = syntax.RemoveNode(syntax.ArgumentList, SyntaxRemoveOptions.KeepNoTrivia);
+        }
+        else
+        {
+            // Remove the first argument, which is the tag
+            var newArgs = syntax.ArgumentList.Arguments.RemoveAt(0);
+            var newArgList = syntax.ArgumentList.WithArguments(newArgs);
+            // Construct a new attribute with the tag removed
+            newSyntax = syntax.WithArgumentList(newArgList);
+        }
+
+        root = root!.ReplaceNode(syntax, newSyntax!);
+
+        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/DependencyAssignAnalyzer.cs

@@ -0,0 +1,61 @@
+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 DependencyAssignAnalyzer : DiagnosticAnalyzer
+{
+    private const string DependencyAttributeType = "Robust.Shared.IoC.DependencyAttribute";
+
+    private static readonly DiagnosticDescriptor Rule = new (
+        Diagnostics.IdDependencyFieldAssigned,
+        "Assignment to dependency field",
+        "Tried to assign to [Dependency] field '{0}'. Remove [Dependency] or inject it via field injection instead.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.RegisterOperationAction(CheckAssignment, OperationKind.SimpleAssignment);
+    }
+
+    private static void CheckAssignment(OperationAnalysisContext context)
+    {
+        if (context.Operation is not ISimpleAssignmentOperation assignment)
+            return;
+
+        if (assignment.Target is not IFieldReferenceOperation fieldRef)
+            return;
+
+        var field = fieldRef.Field;
+        var attributes = field.GetAttributes();
+        if (attributes.Length == 0)
+            return;
+
+        var depAttribute = context.Compilation.GetTypeByMetadataName(DependencyAttributeType);
+        if (!HasAttribute(attributes, depAttribute))
+            return;
+
+        context.ReportDiagnostic(Diagnostic.Create(Rule, assignment.Syntax.GetLocation(), field.Name));
+    }
+
+    private static bool HasAttribute(ImmutableArray<AttributeData> attributes, ISymbol symbol)
+    {
+        foreach (var attribute in attributes)
+        {
+            if (SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, symbol))
+                return true;
+        }
+
+        return false;
+    }
+}

Robust.Analyzers/ExplicitInterfaceAnalyzer.cs

@@ -10,6 +10,7 @@ using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 using Document = Microsoft.CodeAnalysis.Document;
 
 namespace Robust.Analyzers

Robust.Analyzers/ExplicitVirtualAnalyzer.cs

@@ -5,6 +5,7 @@ using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 

Robust.Analyzers/MeansImplicitAssigmentSuppressor.cs

@@ -2,6 +2,7 @@ using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers
 {

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/NoUncachedRegexAnalyzer.cs

@@ -0,0 +1,66 @@
+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 NoUncachedRegexAnalyzer : DiagnosticAnalyzer
+{
+    private const string RegexTypeName = "Regex";
+    private const string RegexType = $"System.Text.RegularExpressions.{RegexTypeName}";
+
+    private static readonly DiagnosticDescriptor Rule = new (
+        Diagnostics.IdUncachedRegex,
+        "Use of uncached static Regex function",
+        "Usage of a static Regex function that takes in a pattern string. This can cause constant re-parsing of the pattern.",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public static readonly HashSet<string> BadFunctions =
+    [
+        "Count",
+        "EnumerateMatches",
+        "IsMatch",
+        "Match",
+        "Matches",
+        "Replace",
+        "Split"
+    ];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.EnableConcurrentExecution();
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.RegisterOperationAction(CheckInvocation, OperationKind.Invocation);
+    }
+
+    private static void CheckInvocation(OperationAnalysisContext context)
+    {
+        if (context.Operation is not IInvocationOperation invocation)
+            return;
+
+        // All Regex functions we care about are static.
+        var targetMethod = invocation.TargetMethod;
+        if (!targetMethod.IsStatic)
+            return;
+
+        // Bail early.
+        if (targetMethod.ContainingType.Name != "Regex")
+            return;
+
+        var regexType = context.Compilation.GetTypeByMetadataName(RegexType);
+        if (!SymbolEqualityComparer.Default.Equals(regexType, targetMethod.ContainingType))
+            return;
+
+        if (!BadFunctions.Contains(targetMethod.Name))
+            return;
+
+        context.ReportDiagnostic(Diagnostic.Create(Rule, invocation.Syntax.GetLocation()));
+    }
+}

Robust.Analyzers/NotNullableFlagAnalyzer.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 
@@ -31,7 +32,7 @@ public sealed class NotNullableFlagAnalyzer : DiagnosticAnalyzer
 
     private static readonly DiagnosticDescriptor InvalidNotNullableImplementationRule = new (
         Diagnostics.IdInvalidNotNullableFlagImplementation,
-        "Invalid NotNullable flag implementation.",
+        "Invalid NotNullable flag implementation",
         "NotNullable flag is either not typed as bool, or does not have a default value equaling false",
         "Usage",
         DiagnosticSeverity.Error,
@@ -41,7 +42,7 @@ public sealed class NotNullableFlagAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor InvalidNotNullableTypeRule = new (
         Diagnostics.IdInvalidNotNullableFlagType,
         "Failed to resolve type parameter",
-        "Failed to resolve type parameter \"{0}\".",
+        "Failed to resolve type parameter \"{0}\"",
         "Usage",
         DiagnosticSeverity.Error,
         true,
@@ -49,7 +50,7 @@ public sealed class NotNullableFlagAnalyzer : DiagnosticAnalyzer
 
     private static readonly DiagnosticDescriptor NotNullableFlagValueTypeRule = new (
         Diagnostics.IdNotNullableFlagValueType,
-        "NotNullable flag not supported for value types.",
+        "NotNullable flag not supported for value types",
         "Value types as generic arguments are not supported for NotNullable flags",
         "Usage",
         DiagnosticSeverity.Error,

Robust.Analyzers/PreferGenericVariantAnalyzer.cs

@@ -11,6 +11,7 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 

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

@@ -1,31 +1,47 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-  <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <LangVersion>10</LangVersion>
-    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" />
-  </ItemGroup>
-
   <ItemGroup>
     <!-- Needed for NotNullableFlagAnalyzer. -->
-    <Compile Include="..\Robust.Shared\Analyzers\NotNullableFlagAttribute.cs" />
+    <Compile Include="..\Robust.Shared\Analyzers\NotNullableFlagAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
   <ItemGroup>
     <!-- Needed for FriendAnalyzer. -->
-    <Compile Include="..\Robust.Shared\Analyzers\AccessAttribute.cs" />
-    <Compile Include="..\Robust.Shared\Analyzers\AccessPermissions.cs" />
+    <Compile Include="..\Robust.Shared\Analyzers\AccessAttribute.cs" LinkBase="Implementations" />
+    <Compile Include="..\Robust.Shared\Analyzers\AccessPermissions.cs" LinkBase="Implementations" />
   </ItemGroup>
 
   <ItemGroup>
     <!-- Needed for PreferGenericVariantAnalyzer. -->
-    <Compile Include="..\Robust.Shared\Analyzers\PreferGenericVariantAttribute.cs" />
+    <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" />
+
+  <PropertyGroup>
+    <Nullable>disable</Nullable>
+    <!--
+    Rider seems to get really confused with hot reload if we directly compile in the above-linked classes.
+    As such, they have an #if to change their namespace in this project.
+    -->
+    <DefineConstants>$(DefineConstants);ROBUST_ANALYZERS_IMPL</DefineConstants>
+  </PropertyGroup>
+
 </Project>

Robust.Analyzers/SerializableAnalyzer.cs

@@ -10,6 +10,7 @@ using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers
 {

Robust.Analyzers/TaskResultAnalyzer.cs

@@ -3,6 +3,7 @@ using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
+using Robust.Roslyn.Shared;
 
 namespace Robust.Analyzers;
 

Robust.Benchmarks/Collections/ValueListEnumerationBenchmarks.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
+using Robust.Shared.Collections;
+
+namespace Robust.Benchmarks.Collections;
+
+[Virtual]
+public class ValueListEnumerationBenchmarks
+{
+    [Params(4, 16, 64)]
+    public int N { get; set; }
+
+    private sealed class Data(int i)
+    {
+        public readonly int I = i;
+    }
+
+    private ValueList<Data> _valueList;
+    private Data[] _array = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        var list = new List<Data>(N);
+        for (var i = 0; i < N; i++)
+        {
+            list.Add(new(i));
+        }
+
+        _array = list.ToArray();
+        _valueList = new(list.ToArray());
+    }
+
+    [Benchmark]
+    public int ValueList()
+    {
+        var total = 0;
+        foreach (var ev in _valueList)
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+
+    [Benchmark]
+    public int ValueListSpan()
+    {
+        var total = 0;
+        foreach (var ev in _valueList.Span)
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+
+    [Benchmark]
+    public int Array()
+    {
+        var total = 0;
+        foreach (var ev in _array)
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+
+    [Benchmark]
+    public int Span()
+    {
+        var total = 0;
+        foreach (var ev in _array.AsSpan())
+        {
+            total += ev.I;
+        }
+
+        return total;
+    }
+}

Robust.Benchmarks/Configs/DefaultSQLConfig.cs

@@ -26,7 +26,8 @@ public sealed class DefaultSQLConfig : IConfig
 
     public IEnumerable<IExporter> GetExporters()
     {
-        yield return SQLExporter.Default;
+        //yield return SQLExporter.Default;
+        yield break;
     }
 
     public IEnumerable<IColumnProvider> GetColumnProviders() => DefaultConfig.Instance.GetColumnProviders();

Robust.Benchmarks/EntityManager/AddRemoveComponentBenchmark.cs

@@ -26,9 +26,8 @@ public partial class AddRemoveComponentBenchmark
             .InitializeInstance();
 
         _entityManager = _simulation.Resolve<IEntityManager>();
-
-        var coords = new MapCoordinates(0, 0, new MapId(1));
-        _simulation.AddMap(coords.MapId);
+        var map = _simulation.CreateMap().Uid;
+        var coords = new EntityCoordinates(map, default);
 
         for (var i = 0; i < N; i++)
         {

Robust.Benchmarks/EntityManager/ComponentIteratorBenchmark.cs

@@ -29,8 +29,8 @@ public partial class ComponentIteratorBenchmark
 
         Comps = new A[N+2];
 
-        var coords = new MapCoordinates(0, 0, new MapId(1));
-        _simulation.AddMap(coords.MapId);
+        var map = _simulation.CreateMap().MapId;
+        var coords = new MapCoordinates(default, map);
 
         for (var i = 0; i < N; i++)
         {

Robust.Benchmarks/EntityManager/GetComponentBenchmark.cs

@@ -31,8 +31,8 @@ public partial class GetComponentBenchmark
 
         Comps = new A[N+2];
 
-        var coords = new MapCoordinates(0, 0, new MapId(1));
-        _simulation.AddMap(coords.MapId);
+        var map = _simulation.CreateMap().Uid;
+        var coords = new EntityCoordinates(map, default);
 
         for (var i = 0; i < N; i++)
         {

Robust.Benchmarks/EntityManager/SpawnDeleteEntityBenchmark.cs

@@ -29,10 +29,9 @@ public partial class SpawnDeleteEntityBenchmark
             .InitializeInstance();
 
         _entityManager = _simulation.Resolve<IEntityManager>();
-
-        _mapCoords = new MapCoordinates(0, 0, new MapId(1));
-        var uid = _simulation.AddMap(_mapCoords.MapId);
-        _entCoords = new EntityCoordinates(uid, 0, 0);
+        var (map, mapId) = _simulation.CreateMap();
+        _mapCoords = new MapCoordinates(default, mapId);
+        _entCoords = new EntityCoordinates(map, 0, 0);
     }
 
     [Benchmark(Baseline = true)]

Robust.Benchmarks/Exporters/SQLExporter.cs

@@ -15,11 +15,10 @@ using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Design;
 using Npgsql;
 using Npgsql.Internal;
-using Npgsql.Internal.TypeHandlers;
-using Npgsql.Internal.TypeHandling;
 
 namespace Robust.Benchmarks.Exporters;
 
+/*
 public sealed class SQLExporter : IExporter
 {
     private static readonly JsonSerializerOptions JsonSerializerOptions = new JsonSerializerOptions
@@ -98,7 +97,9 @@ public sealed class SQLExporter : IExporter
 
     public string Name => "sql";
 }
+*/
 
+/*
 // https://github.com/npgsql/efcore.pg/issues/1107#issuecomment-945126627
 class JsonOverrideTypeHandlerResolverFactory : TypeHandlerResolverFactory
 {
@@ -138,6 +139,7 @@ class JsonOverrideTypeHandlerResolverFactory : TypeHandlerResolverFactory
             => null; // Let the built-in resolver do this
     }
 }
+*/
 
 public sealed class DesignTimeContextFactoryPostgres : IDesignTimeDbContextFactory<BenchmarkContext>
 {

Robust.Benchmarks/Transform/RecursiveMoveBenchmark.cs

@@ -91,8 +91,7 @@ public class RecursiveMoveBenchmark : RobustIntegrationTest
         // Set up map and spawn player
         server.WaitPost(() =>
         {
-            var mapId = mapMan.CreateMap();
-            var map = mapMan.GetMapEntityId(mapId);
+            var map = server.ResolveDependency<SharedMapSystem>().CreateMap(out var mapId);
             var gridComp = mapMan.CreateGridEntity(mapId);
             var grid = gridComp.Owner;
             mapSys.SetTile(grid, gridComp, Vector2i.Zero, new Tile(1));

Robust.Client.Injectors/XamlCompiler.cs

@@ -239,6 +239,7 @@ namespace Robust.Build.Tasks
                         engine.LogErrorEvent(new BuildErrorEventArgs("XAMLIL", "", res.FilePath, 0, 0, 0, 0,
                             $"{res.FilePath}: {e.Message}", "", "CompileRobustXaml"));
                     }
+                    res.Remove();
                 }
                 return true;
             }

Robust.Client.NameGenerator/Robust.Client.NameGenerator.csproj

@@ -1,19 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
-    <PropertyGroup>
-        <TargetFramework>netstandard2.0</TargetFramework>
-      <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
-    </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" PrivateAssets="all" />
-  </ItemGroup>
-
   <ItemGroup>
     <Compile Link="XamlX\filename" Include="../XamlX/src/XamlX/**/*.cs" />
     <Compile Remove="../XamlX/src/XamlX/**/SreTypeSystem.cs" />
     <Compile Remove="../XamlX/src/XamlX/obj/**" />
     <Compile Include="..\Robust.Client\UserInterface\ControlPropertyAccess.cs" />
   </ItemGroup>
+
+  <Import Project="../Robust.Roslyn.Shared/Robust.Roslyn.Shared.props" />
+
+  <PropertyGroup>
+    <!-- XamlX doesn't do NRTs. -->
+    <Nullable>disable</Nullable>
+  </PropertyGroup>
+
 </Project>

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;
@@ -74,11 +74,13 @@ public sealed class AudioOverlay : Overlay
             output.Clear();
             output.AppendLine("Audio Source");
             output.AppendLine("Runtime:");
+            output.AppendLine($"- Distance: {_audio.GetAudioDistance(distance.Length()):0.00}");
             output.AppendLine($"- Occlusion: {posOcclusion:0.0000}");
             output.AppendLine("Params:");
+            output.AppendLine($"- RolloffFactor: {comp.RolloffFactor:0.0000}");
             output.AppendLine($"- Volume: {comp.Volume:0.0000}");
-            output.AppendLine($"- Reference distance: {comp.ReferenceDistance}");
-            output.AppendLine($"- Max distance: {comp.MaxDistance}");
+            output.AppendLine($"- Reference distance: {comp.ReferenceDistance:0.00}");
+            output.AppendLine($"- Max distance: {comp.MaxDistance:0.00}");
             var outputText = output.ToString().Trim();
             var dimensions = screenHandle.GetDimensions(_font, outputText, 1f);
             var buffer = new Vector2(3f, 3f);

Robust.Client/Audio/AudioSystem.Limits.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using Robust.Shared;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Audio;
+
+public sealed partial class AudioSystem
+{
+    /*
+     * Handles limiting concurrent sounds for audio to avoid blowing the source budget on one sound getting spammed.
+     */
+
+    private readonly Dictionary<string, int> _playingCount = new();
+
+    private int _maxConcurrent;
+
+    private void InitializeLimit()
+    {
+        Subs.CVar(CfgManager, CVars.AudioDefaultConcurrent, SetConcurrentLimit, true);
+    }
+
+    private void SetConcurrentLimit(int obj)
+    {
+        _maxConcurrent = obj;
+    }
+
+    private bool TryAudioLimit(string sound)
+    {
+        if (string.IsNullOrEmpty(sound))
+            return true;
+
+        ref var count = ref CollectionsMarshal.GetValueRefOrAddDefault(_playingCount, sound, out _);
+
+        if (count >= _maxConcurrent)
+            return false;
+
+        count++;
+        return true;
+    }
+
+    private void RemoveAudioLimit(string sound)
+    {
+        if (!_playingCount.TryGetValue(sound, out var count))
+            return;
+
+        count--;
+
+        if (count <= 0)
+        {
+            _playingCount.Remove(sound);
+            return;
+        }
+
+        _playingCount[sound] = count;
+    }
+}

Robust.Client/Audio/AudioSystem.cs

@@ -37,10 +37,10 @@ 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!;
+    [Dependency] private readonly SharedMapSystem _maps = default!;
     [Dependency] private readonly SharedTransformSystem _xformSys = default!;
     [Dependency] private readonly SharedPhysicsSystem _physics = default!;
 
@@ -48,9 +48,11 @@ 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;
 
     private float _maxRayLength;
@@ -108,6 +110,14 @@ 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)
@@ -123,6 +133,33 @@ public sealed partial class AudioSystem : SharedAudioSystem
         {
             component.Source.SetAuxiliary(null);
         }
+
+        switch (component.State)
+        {
+            case AudioState.Playing:
+                component.StartPlaying();
+                break;
+            case AudioState.Paused:
+                component.Pause();
+                break;
+            case AudioState.Stopped:
+                component.StopPlaying();
+                component.PlaybackPosition = 0f;
+                break;
+        }
+
+        // If playback position changed then update it.
+        if (!string.IsNullOrEmpty(component.FileName))
+        {
+            var position = (float) ((component.PauseTime ?? Timing.CurTime) - component.AudioStart).TotalSeconds;
+            var currentPosition = component.Source.PlaybackPosition;
+            var diff = Math.Abs(position - currentPosition);
+
+            if (diff > 0.1f)
+            {
+                component.PlaybackPosition = position;
+            }
+        }
     }
 
     /// <summary>
@@ -163,26 +200,32 @@ public sealed partial class AudioSystem : SharedAudioSystem
             return;
         }
 
-        SetupSource(component, audioResource);
+        SetupSource((uid, component), audioResource);
         component.Loaded = true;
     }
 
-    private void SetupSource(AudioComponent component, AudioResource audioResource, TimeSpan? length = null)
+    private void SetupSource(Entity<AudioComponent> entity, AudioResource audioResource, TimeSpan? length = null)
     {
-        var source = _audio.CreateAudioSource(audioResource);
+        var component = entity.Comp;
 
-        if (source == null)
+        if (TryAudioLimit(component.FileName))
         {
-            Log.Error($"Error creating audio source for {audioResource}");
-            DebugTools.Assert(false);
-            source = component.Source;
-        }
+            var newSource = _audio.CreateAudioSource(audioResource);
 
-        component.Source = source;
+            if (newSource == null)
+            {
+                Log.Error($"Error creating audio source for {audioResource}");
+                DebugTools.Assert(false);
+            }
+            else
+            {
+                component.Source = newSource;
+            }
+        }
 
         // Need to set all initial data for first frame.
         ApplyAudioParams(component.Params, component);
-        source.Global = component.Global;
+        component.Source.Global = component.Global;
 
         // Don't play until first frame so occlusion etc. are correct.
         component.Gain = 0f;
@@ -202,6 +245,8 @@ public sealed partial class AudioSystem : SharedAudioSystem
     {
         // Breaks with prediction?
         component.Source.Dispose();
+
+        RemoveAudioLimit(component.FileName);
     }
 
     private void OnAudioAttenuation(int obj)
@@ -216,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;
@@ -239,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;
@@ -293,59 +342,25 @@ public sealed partial class AudioSystem : SharedAudioSystem
         }
 
         Vector2 worldPos;
-        var gridUid = xform.ParentUid;
+        component.Volume = component.Params.Volume;
 
-        // Handle grid audio differently by using nearest-edge instead of entity centre.
+        // Handle grid audio differently by using grid position.
         if ((component.Flags & AudioFlags.GridAudio) != 0x0)
         {
-            // It's our grid so max volume.
-            if (_listenerGrid == gridUid)
-            {
-                component.Volume = component.Params.Volume;
-                component.Occlusion = 0f;
-                component.Position = listener.Position;
-                return;
-            }
-
-            // TODO: Need a grid-optimised version because this is gonna be expensive.
-            // Just to avoid clipping on and off grid or nearestPoint changing we'll
-            // always set the sound to listener's pos, we'll just manually do gain ourselves.
-            if (_physics.TryGetNearest(gridUid, listener, out _, out var gridDistance))
-            {
-                // Out of range
-                if (gridDistance > component.MaxDistance)
-                {
-                    component.Gain = 0f;
-                    return;
-                }
-
-                var paramsGain = VolumeToGain(component.Params.Volume);
-
-                // Thought I'd never have to manually calculate gain again but this is the least
-                // unpleasant audio I could get at the moment.
-                component.Gain = paramsGain * _audio.GetAttenuationGain(
-                    gridDistance,
-                    component.Params.RolloffFactor,
-                    component.Params.ReferenceDistance,
-                    component.Params.MaxDistance);
-                component.Position = listener.Position;
-                return;
-            }
-
-            // Can't get nearest point so don't play anymore.
-            component.Gain = 0f;
-            return;
+            var parentUid = xform.ParentUid;
+            worldPos = _maps.GetGridPosition(parentUid);
+        }
+        else
+        {
+            worldPos = _xformSys.GetWorldPosition(entity);
         }
-
-        worldPos = _xformSys.GetWorldPosition(entity);
-        component.Volume = component.Params.Volume;
 
         // Max distance check
         var delta = worldPos - listener.Position;
         var distance = delta.Length();
 
         // Out of range so just clip it for us.
-        if (distance > component.MaxDistance)
+        if (GetAudioDistance(distance) > component.MaxDistance)
         {
             // Still keeps the source playing, just with no volume.
             component.Gain = 0f;
@@ -360,8 +375,15 @@ public sealed partial class AudioSystem : SharedAudioSystem
         }
 
         // Update audio occlusion
-        var occlusion = GetOcclusion(listener, delta, distance, entity);
-        component.Occlusion = occlusion;
+        if ((component.Flags & AudioFlags.NoOcclusion) == AudioFlags.NoOcclusion)
+        {
+            component.Occlusion = 0f;
+        }
+        else
+        {
+            var occlusion = GetOcclusion(listener, delta, distance, entity);
+            component.Occlusion = occlusion;
+        }
 
         // Update audio positions.
         component.Position = worldPos;
@@ -411,13 +433,13 @@ public sealed partial class AudioSystem : SharedAudioSystem
         return false;
     }
 
-    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string filename, EntityCoordinates coordinates,
+    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string? filename, EntityCoordinates coordinates,
         AudioParams? audioParams = null)
     {
         return PlayStatic(filename, Filter.Local(), coordinates, true, audioParams);
     }
 
-    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string filename, EntityUid uid, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string? filename, EntityUid uid, AudioParams? audioParams = null)
     {
         return PlayEntity(filename, Filter.Local(), uid, true, audioParams);
     }
@@ -444,8 +466,11 @@ public sealed partial class AudioSystem : SharedAudioSystem
     /// </summary>
     /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
     /// <param name="audioParams"></param>
-    private (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, AudioParams? audioParams = null, bool recordReplay = true)
+    private (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, AudioParams? audioParams = null, bool recordReplay = true)
     {
+        if (string.IsNullOrEmpty(filename))
+            return null;
+
         if (recordReplay && _replayRecording.IsRecording)
         {
             _replayRecording.RecordReplayMessage(new PlayAudioGlobalMessage
@@ -477,8 +502,11 @@ public sealed partial class AudioSystem : SharedAudioSystem
     /// </summary>
     /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
     /// <param name="entity">The entity "emitting" the audio.</param>
-    private (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, EntityUid entity, AudioParams? audioParams = null, bool recordReplay = true)
+    private (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, EntityUid entity, AudioParams? audioParams = null, bool recordReplay = true)
     {
+        if (string.IsNullOrEmpty(filename))
+            return null;
+
         if (recordReplay && _replayRecording.IsRecording)
         {
             _replayRecording.RecordReplayMessage(new PlayAudioEntityMessage
@@ -518,8 +546,11 @@ public sealed partial class AudioSystem : SharedAudioSystem
     /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
     /// <param name="coordinates">The coordinates at which to play the audio.</param>
     /// <param name="audioParams"></param>
-    private (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, EntityCoordinates coordinates, AudioParams? audioParams = null, bool recordReplay = true)
+    private (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, EntityCoordinates coordinates, AudioParams? audioParams = null, bool recordReplay = true)
     {
+        if (string.IsNullOrEmpty(filename))
+            return null;
+
         if (recordReplay && _replayRecording.IsRecording)
         {
             _replayRecording.RecordReplayMessage(new PlayAudioPositionalMessage
@@ -553,65 +584,65 @@ public sealed partial class AudioSystem : SharedAudioSystem
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, Filter playerFilter, bool recordReplay, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, Filter playerFilter, bool recordReplay, AudioParams? audioParams = null)
     {
         return PlayGlobal(filename, audioParams);
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, Filter playerFilter, EntityUid entity, bool recordReplay, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, Filter playerFilter, EntityUid entity, bool recordReplay, AudioParams? audioParams = null)
     {
         return PlayEntity(filename, entity, audioParams);
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, Filter playerFilter, EntityCoordinates coordinates, bool recordReplay, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, Filter playerFilter, EntityCoordinates coordinates, bool recordReplay, AudioParams? audioParams = null)
     {
         return PlayStatic(filename, coordinates, audioParams);
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, ICommonSession recipient, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, ICommonSession recipient, AudioParams? audioParams = null)
     {
         return PlayGlobal(filename, audioParams);
     }
 
-    public override void LoadStream<T>(AudioComponent component, T stream)
+    public override void LoadStream<T>(Entity<AudioComponent> entity, T stream)
     {
         if (stream is AudioStream audioStream)
         {
             TryGetAudio(audioStream, out var audio);
-            SetupSource(component, audio!, audioStream.Length);
-            component.Loaded = true;
+            SetupSource(entity, audio!, audioStream.Length);
+            entity.Comp.Loaded = true;
         }
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, EntityUid recipient, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, EntityUid recipient, AudioParams? audioParams = null)
     {
         return PlayGlobal(filename, audioParams);
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, ICommonSession recipient, EntityUid uid, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, ICommonSession recipient, EntityUid uid, AudioParams? audioParams = null)
     {
         return PlayEntity(filename, uid, audioParams);
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, EntityUid recipient, EntityUid uid, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string? filename, EntityUid recipient, EntityUid uid, AudioParams? audioParams = null)
     {
         return PlayEntity(filename, uid, audioParams);
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, ICommonSession recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, ICommonSession recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
     {
         return PlayStatic(filename, coordinates, audioParams);
     }
 
     /// <inheritdoc />
-    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, EntityUid recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string? filename, EntityUid recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
     {
         return PlayStatic(filename, coordinates, audioParams);
     }
@@ -619,10 +650,10 @@ public sealed partial class AudioSystem : SharedAudioSystem
     private (EntityUid Entity, AudioComponent Component) CreateAndStartPlayingStream(AudioParams? audioParams, AudioStream stream)
     {
         var audioP = audioParams ?? AudioParams.Default;
-        var entity = EntityManager.CreateEntityUninitialized("Audio", MapCoordinates.Nullspace);
-        var comp = SetupAudio(entity, null, audioP, stream.Length);
-        LoadStream(comp, stream);
+        var entity = SetupAudio(null, audioP, initialize: false, length: stream.Length);
+        LoadStream(entity, stream);
         EntityManager.InitializeAndStartEntity(entity);
+        var comp = entity.Comp;
         var source = comp.Source;
 
         // TODO clamp the offset inside of SetPlaybackPosition() itself.

Robust.Client/Audio/Midi/MidiManager.cs

@@ -114,7 +114,7 @@ internal sealed partial class MidiManager : IMidiManager
         "/usr/share/sounds/sf2/TimGM6mb.sf2",
     };
 
-    private const string WindowsSoundfont = @"C:\WINDOWS\system32\drivers\gm.dls";
+    private static readonly string WindowsSoundfont = $@"{Environment.GetEnvironmentVariable("SystemRoot")}\system32\drivers\gm.dls";
 
     private const string OsxSoundfont =
         "/System/Library/Components/CoreAudio.component/Contents/Resources/gs_instruments.dls";

Robust.Client/Audio/Sources/BaseAudioSource.cs

@@ -314,6 +314,8 @@ public abstract class BaseAudioSource : IAudioSource
         set
         {
             _checkDisposed();
+
+            value = MathF.Max(value, 0f);
             AL.Source(SourceHandle, ALSourcef.SecOffset, value);
             Master._checkAlError($"Tried to set invalid playback position of {value:0.00}");
         }

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/BaseClient.cs

@@ -285,6 +285,7 @@ namespace Robust.Client
     /// <summary>
     ///     Enumeration of the run levels of the BaseClient.
     /// </summary>
+    /// <seealso cref="ClientRunLevelExt"/>
     public enum ClientRunLevel : byte
     {
         Error = 0,
@@ -315,6 +316,21 @@ namespace Robust.Client
         SinglePlayerGame,
     }
 
+    /// <summary>
+    /// Helper functions for working with <see cref="ClientRunLevel"/>.
+    /// </summary>
+    public static class ClientRunLevelExt
+    {
+        /// <summary>
+        /// Check if a <see cref="ClientRunLevel"/> is <see cref="ClientRunLevel.InGame"/>
+        /// or <see cref="ClientRunLevel.SinglePlayerGame"/>.
+        /// </summary>
+        public static bool IsInGameLike(this ClientRunLevel runLevel)
+        {
+            return runLevel is ClientRunLevel.InGame or ClientRunLevel.SinglePlayerGame;
+        }
+    }
+
     /// <summary>
     ///     Event arguments for when something changed with the player.
     /// </summary>

Robust.Client/Console/Commands/Debug.cs

@@ -291,10 +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 IMapManager _map = default!;
+        [Dependency] private readonly SharedMapSystem _map = default!;
 
         public override string Command => "sggcell";
 
@@ -320,9 +319,10 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            if (_map.TryGetGrid(_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))))
                 {
@@ -426,10 +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 IMapManager _map = default!;
+        [Dependency] private readonly SharedMapSystem _map = default!;
 
         public override string Command => "gridtc";
 
@@ -442,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 (_map.TryGetGrid(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
             {
@@ -555,7 +554,7 @@ namespace Robust.Client.Console.Commands
                 if (type != typeof(Control))
                     cname = $"Control > {cname}";
 
-                returnVal.GetOrNew(cname).Add((member.Name, member.GetValue(control)?.ToString() ?? "null"));
+                returnVal.GetOrNew(cname).Add((member.Name, GetMemberValue(member, control, ", ")));
             }
 
             foreach (var (attachedProperty, value) in control.AllAttachedProperties)
@@ -570,6 +569,41 @@ namespace Robust.Client.Console.Commands
             }
             return returnVal;
         }
+
+        internal static string PropertyValuesString(Control control, string key)
+        {
+            var member = GetAllMembers(control).Find(m => m.Name == key);
+            return GetMemberValue(member, control, "\n", "\"{0}\"");
+        }
+
+        private static string GetMemberValue(MemberInfo? member, Control control, string separator, string
+                wrap = "{0}")
+        {
+            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,
+                    controls.Select(ctrl => $"{ctrl.Name}({ctrl.GetType()})")),
+                ICollection<string> list => string.Join(separator, list),
+                null => null,
+                _ => value.ToString()
+            };
+            // Convert to quote surrounded string or null with no quotes
+            return o is not null ? string.Format(wrap, o) : "null";
+        }
     }
 
     internal sealed class SetClipboardCommand : LocalizedCommands
@@ -660,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";
 
@@ -679,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

@@ -165,7 +165,7 @@ Suspendisse hendrerit blandit urna ut laoreet. Suspendisse ac elit at erat males
     {
         var textEdit = new TextEdit
         {
-            Placeholder = new Rope.Leaf("You deleted the lipsum OwO")
+            Placeholder = new Rope.Leaf("You deleted the lipsum\nOwO")
         };
         TabContainer.SetTabTitle(textEdit, "TextEdit");
 
@@ -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);
         }
 
@@ -225,7 +237,7 @@ namespace Robust.Client.Debugging
         {
             var viewBounds = args.WorldBounds;
             var viewAABB = args.WorldAABB;
-            var mapId = _eyeManager.CurrentMap;
+            var mapId = args.MapId;
 
             if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.Shapes) != 0)
             {
@@ -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)
                     {
@@ -368,12 +380,12 @@ namespace Robust.Client.Debugging
             }
 
             worldHandle.UseShader(null);
-            worldHandle.SetTransform(Matrix3.Identity);
+            worldHandle.SetTransform(Matrix3x2.Identity);
         }
 
         private void DrawScreen(DrawingHandleScreen screenHandle, OverlayDrawArgs args)
         {
-            var mapId = _eyeManager.CurrentMap;
+            var mapId = args.MapId;
             var mousePos = _inputManager.MouseScreenPosition;
 
             if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.ShapeInfo) != 0x0)
@@ -443,7 +455,7 @@ namespace Robust.Client.Debugging
             }
 
             screenHandle.UseShader(null);
-            screenHandle.SetTransform(Matrix3.Identity);
+            screenHandle.SetTransform(Matrix3x2.Identity);
         }
 
         protected internal override void Draw(in OverlayDrawArgs args)
@@ -517,17 +529,17 @@ 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.R0C2, matrix1.R1C2);
-            var xf2 = new Vector2(matrix2.R0C2, matrix2.R1C2);
+            var xf1 = new Vector2(matrix1.M31, matrix1.M32);
+            var xf2 = new Vector2(matrix2.M31, matrix2.M32);
 
-            var p1 = matrix1.Transform(joint.LocalAnchorA);
-            var p2 = matrix2.Transform(joint.LocalAnchorB);
+            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/GameController/GameController.cs

@@ -612,6 +612,8 @@ namespace Robust.Client
             {
                 _modLoader.BroadcastUpdate(ModUpdateLevel.FramePostEngine, frameEventArgs);
             }
+
+            _audio.FlushALDisposeQueues();
         }
 
         internal static void SetupLogging(

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -8,6 +8,7 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
+using Robust.Shared.Player;
 using Robust.Shared.Replays;
 using Robust.Shared.Utility;
 
@@ -25,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();
@@ -33,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
@@ -47,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)
         {
@@ -127,13 +135,34 @@ 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);
             EventBus.RaiseEvent(EventSource.Local, new EntitySessionMessage<T>(eventArgs, msg));
         }
 
+        /// <inheritdoc />
+        public override void RaiseSharedEvent<T>(T message, EntityUid? user = null)
+        {
+            if (user == null || user != _playerManager.LocalEntity || !_gameTiming.IsFirstTimePredicted)
+                return;
+
+            EventBus.RaiseEvent(EventSource.Local, ref message);
+        }
+
+        /// <inheritdoc />
+        public override void RaiseSharedEvent<T>(T message, ICommonSession? user = null)
+        {
+            if (user == null || user != _playerManager.LocalSession || !_gameTiming.IsFirstTimePredicted)
+                return;
+
+            EventBus.RaiseEvent(EventSource.Local, ref message);
+        }
+
         #region IEntityNetworkManager impl
 
         public override IEntityNetworkManager EntityNetManager => this;

Robust.Client/GameObjects/Components/Renderable/SpriteComponent.cs

@@ -6,13 +6,12 @@ using System.Linq;
 using System.Numerics;
 using System.Text;
 using Robust.Client.Graphics;
+using Robust.Client.Graphics.Clyde;
 using Robust.Client.ResourceManagement;
 using Robust.Client.Utility;
-using Robust.Shared;
 using Robust.Shared.Animations;
 using Robust.Shared.ComponentTrees;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Graphics;
 using Robust.Shared.Graphics.RSI;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
@@ -30,6 +29,7 @@ using static Robust.Client.ComponentTrees.SpriteTreeSystem;
 using DrawDepthTag = Robust.Shared.GameObjects.DrawDepth;
 using static Robust.Shared.Serialization.TypeSerializers.Implementations.SpriteSpecifierSerializer;
 using Direction = Robust.Shared.Maths.Direction;
+using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.GameObjects
 {
@@ -150,7 +150,7 @@ namespace Robust.Client.GameObjects
         [DataField("color")]
         private Color color = Color.White;
 
-        public Matrix3 LocalMatrix = Matrix3.Identity;
+        public Matrix3x2 LocalMatrix = Matrix3x2.Identity;
 
         [Animatable]
         [ViewVariables(VVAccess.ReadWrite)]
@@ -389,10 +389,10 @@ namespace Robust.Client.GameObjects
 
         internal void UpdateLocalMatrix()
         {
-            LocalMatrix = Matrix3.CreateTransform(in offset, in rotation, in scale);
+            LocalMatrix = Matrix3Helpers.CreateTransform(in offset, in rotation, in scale);
         }
 
-        public Matrix3 GetLocalMatrix()
+        public Matrix3x2 GetLocalMatrix()
         {
             return LocalMatrix;
         }
@@ -772,15 +772,7 @@ namespace Robust.Client.GameObjects
             {
                 foreach (var keyString in layerDatum.MapKeys)
                 {
-                    object key;
-                    if (reflection.TryParseEnumReference(keyString, out var @enum))
-                    {
-                        key = @enum;
-                    }
-                    else
-                    {
-                        key = keyString;
-                    }
+                    var key = ParseKey(keyString);
 
                     if (LayerMap.TryGetValue(key, out var mappedIndex))
                     {
@@ -806,9 +798,30 @@ namespace Robust.Client.GameObjects
             // If neither state: nor texture: were provided we assume that they want a blank invisible layer.
             layer.Visible = layerDatum.Visible ?? layer.Visible;
 
+            if (layerDatum.CopyToShaderParameters is { } copyParameters)
+            {
+                layer.CopyToShaderParameters = new CopyToShaderParameters(ParseKey(copyParameters.LayerKey))
+                {
+                    ParameterTexture = copyParameters.ParameterTexture,
+                    ParameterUV = copyParameters.ParameterUV
+                };
+            }
+            else
+            {
+                layer.CopyToShaderParameters = null;
+            }
+
             RebuildBounds();
         }
 
+        private object ParseKey(string keyString)
+        {
+            if (reflection.TryParseEnumReference(keyString, out var @enum))
+                return @enum;
+
+            return keyString;
+        }
+
         public void LayerSetData(object layerKey, PrototypeLayerData data)
         {
             if (!LayerMapTryGet(layerKey, out var layer, true))
@@ -1237,9 +1250,9 @@ namespace Robust.Client.GameObjects
         public IEnumerable<ISpriteLayer> AllLayers => Layers;
 
         // Lobby SpriteView rendering path
-        public void Render(DrawingHandleWorld drawingHandle, Angle eyeRotation, Angle worldRotation, Direction? overrideDirection = null)
+        public void Render(DrawingHandleWorld drawingHandle, Angle eyeRotation, Angle worldRotation, Direction? overrideDirection = null, Vector2 position = default)
         {
-            RenderInternal(drawingHandle, eyeRotation, worldRotation, Vector2.Zero, overrideDirection);
+            RenderInternal(drawingHandle, eyeRotation, worldRotation, position, overrideDirection);
         }
 
         [DataField("noRot")] private bool _screenLock = false;
@@ -1291,22 +1304,21 @@ namespace Robust.Client.GameObjects
 
             // worldRotation + eyeRotation should be the angle of the entity on-screen. If no-rot is enabled this is just set to zero.
             // However, at some point later the eye-matrix is applied separately, so we subtract -eye rotation for now:
-            var entityMatrix = Matrix3.CreateTransform(worldPosition, NoRotation ? -eyeRotation : worldRotation - cardinal);
+            var entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, NoRotation ? -eyeRotation : worldRotation - cardinal);
 
-            Matrix3.Multiply(in LocalMatrix, in entityMatrix, out var transformSprite);
+            var transformSprite = Matrix3x2.Multiply(LocalMatrix, entityMatrix);
 
             if (GranularLayersRendering)
             {
                 //Default rendering
-                entityMatrix = Matrix3.CreateTransform(worldPosition, worldRotation);
-                Matrix3.Multiply(in LocalMatrix, in entityMatrix, out var transformDefault);
+                entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, worldRotation);
+                var transformDefault = Matrix3x2.Multiply(LocalMatrix, entityMatrix);
                 //Snap to cardinals
-                entityMatrix = Matrix3.CreateTransform(worldPosition, worldRotation - angle.GetCardinalDir().ToAngle());
-                Matrix3.Multiply(in LocalMatrix, in entityMatrix, out var transformSnap);
+                entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, worldRotation - angle.GetCardinalDir().ToAngle());
+                var transformSnap = Matrix3x2.Multiply(LocalMatrix, entityMatrix);
                 //No rotation
-                entityMatrix = Matrix3.CreateTransform(worldPosition, -eyeRotation);
-                Matrix3.Multiply(in LocalMatrix, in entityMatrix, out var transformNoRot);
-
+                entityMatrix = Matrix3Helpers.CreateTransform(worldPosition, -eyeRotation);
+                var transformNoRot = Matrix3x2.Multiply(LocalMatrix, entityMatrix);
 
                 foreach (var layer in Layers) {
                     switch (layer.RenderingStrategy)
@@ -1367,7 +1379,7 @@ namespace Robust.Client.GameObjects
 
             // TODO whenever sprite comp gets ECS'd , just make this a direct method call.
             var ev = new QueueSpriteTreeUpdateEvent(entities.GetComponent<TransformComponent>(Owner));
-            entities.EventBus.RaiseComponentEvent(this, ref ev);
+            entities.EventBus.RaiseComponentEvent(Owner, this, ref ev);
         }
 
         private void QueueUpdateIsInert()
@@ -1377,7 +1389,7 @@ namespace Robust.Client.GameObjects
 
             // TODO whenever sprite comp gets ECS'd , just make this a direct method call.
             var ev = new SpriteUpdateInertEvent();
-            entities.EventBus.RaiseComponentEvent(this, ref ev);
+            entities.EventBus.RaiseComponentEvent(Owner, this, ref ev);
         }
 
         [Obsolete("Use SpriteSystem instead.")]
@@ -1533,7 +1545,7 @@ namespace Robust.Client.GameObjects
             private RSI.State? _actualState;
             [ViewVariables] public RSI.State? ActualState => _actualState;
 
-            public Matrix3 LocalMatrix = Matrix3.Identity;
+            public Matrix3x2 LocalMatrix = Matrix3x2.Identity;
 
             [ViewVariables(VVAccess.ReadWrite)]
             public Vector2 Scale
@@ -1637,6 +1649,9 @@ namespace Robust.Client.GameObjects
             [ViewVariables]
             public LayerRenderingStrategy RenderingStrategy = LayerRenderingStrategy.UseSpriteStrategy;
 
+            [ViewVariables(VVAccess.ReadWrite)]
+            public CopyToShaderParameters? CopyToShaderParameters;
+
             public Layer(SpriteComponent parent)
             {
                 _parent = parent;
@@ -1665,6 +1680,8 @@ namespace Robust.Client.GameObjects
                 DirOffset = toClone.DirOffset;
                 _autoAnimated = toClone._autoAnimated;
                 RenderingStrategy = toClone.RenderingStrategy;
+                if (toClone.CopyToShaderParameters is { } copyToShaderParameters)
+                    CopyToShaderParameters = new CopyToShaderParameters(copyToShaderParameters);
             }
 
             void ISerializationHooks.AfterDeserialization()
@@ -1674,7 +1691,7 @@ namespace Robust.Client.GameObjects
 
             internal void UpdateLocalMatrix()
             {
-                LocalMatrix = Matrix3.CreateTransform(in _offset, in _rotation, in _scale);
+                LocalMatrix = Matrix3Helpers.CreateTransform(in _offset, in _rotation, in _scale);
             }
 
             RSI? ISpriteLayer.Rsi { get => RSI; set => SetRsi(value); }
@@ -1946,27 +1963,27 @@ namespace Robust.Client.GameObjects
             ///     Given the apparent rotation of an entity on screen (world + eye rotation), get layer's matrix for drawing &
             ///     relevant RSI direction.
             /// </summary>
-            public void GetLayerDrawMatrix(RsiDirection dir, out Matrix3 layerDrawMatrix)
+            public void GetLayerDrawMatrix(RsiDirection dir, out Matrix3x2 layerDrawMatrix)
             {
                 if (_parent.NoRotation || dir == RsiDirection.South)
                     layerDrawMatrix = LocalMatrix;
                 else
                 {
-                    Matrix3.Multiply(in _rsiDirectionMatrices[(int)dir], in LocalMatrix, out layerDrawMatrix);
+                    layerDrawMatrix = Matrix3x2.Multiply(_rsiDirectionMatrices[(int)dir], LocalMatrix);
                 }
             }
 
-            private static Matrix3[] _rsiDirectionMatrices = new Matrix3[]
+            private static Matrix3x2[] _rsiDirectionMatrices = new Matrix3x2[]
             {
                 // array order chosen such that this array can be indexed by casing an RSI direction to an int
-                Matrix3.Identity, // should probably just avoid matrix multiplication altogether if the direction is south.
-                Matrix3.CreateRotation(-Direction.North.ToAngle()),
-                Matrix3.CreateRotation(-Direction.East.ToAngle()),
-                Matrix3.CreateRotation(-Direction.West.ToAngle()),
-                Matrix3.CreateRotation(-Direction.SouthEast.ToAngle()),
-                Matrix3.CreateRotation(-Direction.SouthWest.ToAngle()),
-                Matrix3.CreateRotation(-Direction.NorthEast.ToAngle()),
-                Matrix3.CreateRotation(-Direction.NorthWest.ToAngle())
+                Matrix3x2.Identity, // should probably just avoid matrix multiplication altogether if the direction is south.
+                Matrix3Helpers.CreateRotation(-Direction.North.ToAngle()),
+                Matrix3Helpers.CreateRotation(-Direction.East.ToAngle()),
+                Matrix3Helpers.CreateRotation(-Direction.West.ToAngle()),
+                Matrix3Helpers.CreateRotation(-Direction.SouthEast.ToAngle()),
+                Matrix3Helpers.CreateRotation(-Direction.SouthWest.ToAngle()),
+                Matrix3Helpers.CreateRotation(-Direction.NorthEast.ToAngle()),
+                Matrix3Helpers.CreateRotation(-Direction.NorthWest.ToAngle())
             };
 
             /// <summary>
@@ -2000,7 +2017,7 @@ namespace Robust.Client.GameObjects
             /// <summary>
             ///     Render a layer. This assumes that the input angle is between 0 and 2pi.
             /// </summary>
-            internal void Render(DrawingHandleWorld drawingHandle, ref Matrix3 spriteMatrix, Angle angle, Direction? overrideDirection)
+            internal void Render(DrawingHandleWorld drawingHandle, ref Matrix3x2 spriteMatrix, Angle angle, Direction? overrideDirection)
             {
                 if (!Visible || Blank)
                     return;
@@ -2009,8 +2026,6 @@ namespace Robust.Client.GameObjects
 
                 // Set the drawing transform for this layer
                 GetLayerDrawMatrix(dir, out var layerMatrix);
-                Matrix3.Multiply(in layerMatrix, in spriteMatrix, out var transformMatrix);
-                drawingHandle.SetTransform(in transformMatrix);
 
                 // The direction used to draw the sprite can differ from the one that the angle would naively suggest,
                 // due to direction overrides or offsets.
@@ -2020,7 +2035,41 @@ namespace Robust.Client.GameObjects
 
                 // Get the correct directional texture from the state, and draw it!
                 var texture = GetRenderTexture(_actualState, dir);
-                RenderTexture(drawingHandle, texture);
+
+                if (CopyToShaderParameters == null)
+                {
+                    // Set the drawing transform for this layer
+                    var transformMatrix = Matrix3x2.Multiply(layerMatrix, spriteMatrix);
+                    drawingHandle.SetTransform(in transformMatrix);
+
+                    RenderTexture(drawingHandle, texture);
+                }
+                else
+                {
+                    // Multiple atrocities to god being committed right here.
+                    var otherLayerIdx = _parent.LayerMap[CopyToShaderParameters.LayerKey!];
+                    var otherLayer = _parent.Layers[otherLayerIdx];
+                    if (otherLayer.Shader is not { } shader)
+                    {
+                        // No shader set apparently..?
+                        return;
+                    }
+
+                    if (!shader.Mutable)
+                        otherLayer.Shader = shader = shader.Duplicate();
+
+                    var clydeTexture = Clyde.RenderHandle.ExtractTexture(texture, null, out var csr);
+                    var sr = Clyde.RenderHandle.WorldTextureBoundsToUV(clydeTexture, csr);
+
+                    if (CopyToShaderParameters.ParameterTexture is { } paramTexture)
+                        shader.SetParameter(paramTexture, clydeTexture);
+
+                    if (CopyToShaderParameters.ParameterUV is { } paramUV)
+                    {
+                        var uv = new Vector4(sr.Left, sr.Bottom, sr.Right, sr.Top);
+                        shader.SetParameter(paramUV, uv);
+                    }
+                }
             }
 
             private void RenderTexture(DrawingHandleWorld drawingHandle, Texture texture)
@@ -2098,6 +2147,23 @@ namespace Robust.Client.GameObjects
             }
         }
 
+        /// <summary>
+        /// Instantiated version of <see cref="PrototypeCopyToShaderParameters"/>.
+        /// Has <see cref="LayerKey"/> actually resolved to a a real key.
+        /// </summary>
+        public sealed class CopyToShaderParameters(object layerKey)
+        {
+            public object LayerKey = layerKey;
+            public string? ParameterTexture;
+            public string? ParameterUV;
+
+            public CopyToShaderParameters(CopyToShaderParameters toClone) : this(toClone.LayerKey)
+            {
+                ParameterTexture = toClone.ParameterTexture;
+                ParameterUV = toClone.ParameterUV;
+            }
+        }
+
         void IAnimationProperties.SetAnimatableProperty(string name, object value)
         {
             if (!name.StartsWith("layer/"))

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -11,6 +11,7 @@ namespace Robust.Client.GameObjects
     {
         private readonly List<Entity<AnimationPlayerComponent>> _activeAnimations = new();
 
+        private EntityQuery<AnimationPlayerComponent> _playerQuery;
         private EntityQuery<MetaDataComponent> _metaQuery;
 
         [Dependency] private readonly IComponentFactory _compFact = default!;
@@ -18,6 +19,7 @@ namespace Robust.Client.GameObjects
         public override void Initialize()
         {
             base.Initialize();
+            _playerQuery = GetEntityQuery<AnimationPlayerComponent>();
             _metaQuery = GetEntityQuery<MetaDataComponent>();
         }
 
@@ -74,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;
@@ -171,31 +174,42 @@ namespace Robust.Client.GameObjects
             return component.PlayingAnimations.ContainsKey(key);
         }
 
+        [Obsolete]
         public void Stop(AnimationPlayerComponent component, string key)
         {
-            component.PlayingAnimations.Remove(key);
+            Stop((component.Owner, component), key);
         }
 
-        public void Stop(EntityUid uid, string key)
+        public void Stop(Entity<AnimationPlayerComponent?> entity, string key)
         {
-            if (!TryComp<AnimationPlayerComponent>(uid, out var player))
+            if (!_playerQuery.Resolve(entity.Owner, ref entity.Comp, false) ||
+                !entity.Comp.PlayingAnimations.Remove(key))
+            {
                 return;
+            }
 
-            player.PlayingAnimations.Remove(key);
+            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)
         {
-            if (!Resolve(uid, ref component, false))
-                return;
-
-            component.PlayingAnimations.Remove(key);
+            Stop((uid, component), key);
         }
     }
 
+    /// <summary>
+    /// Raised whenever an animation stops, either due to running its course or being stopped manually.
+    /// </summary>
     public sealed class AnimationCompletedEvent : EntityEventArgs
     {
         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/ContainerSystem.cs

@@ -107,7 +107,7 @@ namespace Robust.Client.GameObjects
                 toDelete.Add(id);
             }
 
-            foreach (var dead in toDelete)
+            foreach (var dead in toDelete.Span)
             {
                 component.Containers.Remove(dead);
             }
@@ -120,7 +120,7 @@ namespace Robust.Client.GameObjects
                 {
                     var type = _serializer.FindSerializedType(typeof(BaseContainer), data.ContainerType);
                     container = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type!, inject:false);
-                    InitContainer(container, (uid, component), id);
+                    container.Init(this, id, (uid, component));
                     component.Containers.Add(id, container);
                 }
 
@@ -142,7 +142,7 @@ namespace Robust.Client.GameObjects
                         toRemove.Add(entity);
                 }
 
-                foreach (var entity in toRemove)
+                foreach (var entity in toRemove.Span)
                 {
                     Remove(
                         (entity, TransformQuery.GetComponent(entity), MetaQuery.GetComponent(entity)),
@@ -162,7 +162,7 @@ namespace Robust.Client.GameObjects
                         removedExpected.Add(netEntity);
                 }
 
-                foreach (var entityUid in removedExpected)
+                foreach (var entityUid in removedExpected.Span)
                 {
                     RemoveExpectedEntity(entityUid, out _);
                 }

Robust.Client/GameObjects/EntitySystems/DebugEntityLookupSystem.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Shared.Console;
 using Robust.Shared.Containers;
@@ -118,7 +119,7 @@ public sealed class EntityLookupOverlay : Overlay
                 //DebugTools.Assert(!ent.IsInContainer(_entityManager));
                 var (entPos, entRot) = _transform.GetWorldPositionRotation(ent);
 
-                var lookupPos = invMatrix.Transform(entPos);
+                var lookupPos = Vector2.Transform(entPos, invMatrix);
                 var lookupRot = entRot - rotation;
 
                 var aabb = _lookup.GetAABB(ent, lookupPos, lookupRot, xform, _xformQuery);
@@ -127,6 +128,6 @@ public sealed class EntityLookupOverlay : Overlay
             }
         });
 
-        worldHandle.SetTransform(Matrix3.Identity);
+        worldHandle.SetTransform(Matrix3x2.Identity);
     }
 }

Robust.Client/GameObjects/EntitySystems/DebugLightTreeSystem.cs

@@ -63,7 +63,7 @@ namespace Robust.Client.GameObjects
 
             protected internal override void Draw(in OverlayDrawArgs args)
             {
-                var map = _eyeManager.CurrentMap;
+                var map = args.MapId;
                 if (map == MapId.Nullspace) return;
 
                 foreach (var (_, treeComp) in _trees.GetIntersectingTrees(map, args.WorldBounds))

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,21 +60,25 @@ 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)
         {
-            var currentMap = _eyeManager.CurrentMap;
+            var currentMap = args.MapId;
             var viewport = args.WorldBounds;
             var worldHandle = args.WorldHandle;
 
@@ -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))
                 {
@@ -109,7 +117,7 @@ namespace Robust.Client.GameObjects
                 }
             }
 
-            worldHandle.SetTransform(Matrix3.Identity);
+            worldHandle.SetTransform(Matrix3x2.Identity);
         }
     }
 }

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -20,12 +20,14 @@ namespace Robust.Client.GameObjects
     /// </summary>
     public sealed class InputSystem : SharedInputSystem, IPostInjectInit
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IClientGameStateManager _stateManager = default!;
         [Dependency] private readonly IConsoleHost _conHost = default!;
         [Dependency] private readonly IGameTiming _timing = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
+        [Dependency] private readonly SharedTransformSystem _transform = default!;
 
         private ISawmill _sawmillInputContext = default!;
 
@@ -81,18 +83,35 @@ namespace Robust.Client.GameObjects
                 }
             }
 
-            // send it off to the server
-            var clientMsg = (ClientFullInputCmdMessage)message;
-            var fullMsg = new FullInputCmdMessage(
-                clientMsg.Tick,
-                clientMsg.SubTick,
-                (int)clientMsg.InputSequence,
-                clientMsg.InputFunctionId,
-                clientMsg.State,
-                GetNetCoordinates(clientMsg.Coordinates),
-                clientMsg.ScreenCoordinates)
+            var clientMsg = message switch
             {
-                Uid = GetNetEntity(clientMsg.Uid)
+                ClientFullInputCmdMessage clientInput => clientInput,
+                FullInputCmdMessage fullInput => new ClientFullInputCmdMessage(
+                    fullInput.Tick,
+                    fullInput.SubTick,
+                    fullInput.InputFunctionId,
+                    GetCoordinates(fullInput.Coordinates),
+                    fullInput.ScreenCoordinates,
+                    fullInput.State,
+                    GetEntity(fullInput.Uid)),
+
+                _ => throw new ArgumentOutOfRangeException()
+            };
+
+            var fullMsg = message switch
+            {
+                FullInputCmdMessage fullInput => fullInput,
+                ClientFullInputCmdMessage client => new FullInputCmdMessage(
+                    client.Tick,
+                    client.SubTick,
+                    client.InputFunctionId,
+                    clientMsg.State,
+                    GetNetCoordinates(client.Coordinates),
+                    clientMsg.ScreenCoordinates,
+                    GetNetEntity(clientMsg.Uid)
+                    ),
+
+                _ => throw new ArgumentOutOfRangeException()
             };
 
             DispatchInputCommand(clientMsg, fullMsg);
@@ -130,7 +149,7 @@ namespace Robust.Client.GameObjects
 
             _conHost.RegisterCommand("incmd",
                 "Inserts an input command into the simulation",
-                "incmd <KeyFunction> <d|u KeyState> <wxPos> <wyPos>",
+                "incmd <KeyFunction> <KeyState> [wxPos] [wyPos]",
                 GenerateInputCommand);
         }
 
@@ -146,17 +165,47 @@ namespace Robust.Client.GameObjects
             if (_playerManager.LocalEntity is not { } pent)
                 return;
 
-            BoundKeyFunction keyFunction = new BoundKeyFunction(args[0]);
-            BoundKeyState state = args[1] == "u" ? BoundKeyState.Up: BoundKeyState.Down;
+            if (args.Length is not (2 or 4))
+            {
+                shell.WriteLine(Loc.GetString($"cmd-invalid-arg-number-error"));
+                return;
+            }
 
-            var pxform = Transform(pent);
-            var wPos = pxform.WorldPosition + new Vector2(float.Parse(args[2]), float.Parse(args[3]));
-            var coords = EntityCoordinates.FromMap(EntityManager, pent, new MapCoordinates(wPos, pxform.MapID));
+            var keyFunction = new BoundKeyFunction(args[0]);
+            if (!Enum.TryParse<BoundKeyState>(args[1], out var state))
+            {
+                shell.WriteLine(Loc.GetString("cmd-parse-failure-enum", ("arg", args[1]), ("enum", nameof(BoundKeyState))));
+                return;
+            }
 
+            var wOffset = Vector2.Zero;
+            if (args.Length == 4)
+            {
+                if (!float.TryParse(args[2], out var wX))
+                {
+                    shell.WriteError(Loc.GetString("cmd-parse-failure-float", ("arg", args[2])));
+                    return;
+                }
+
+                if (!float.TryParse(args[3], out var wY))
+                {
+                    shell.WriteError(Loc.GetString("cmd-parse-failure-float", ("arg", args[3])));
+                    return;
+                }
+
+                wOffset = new Vector2(wX, wY);
+            }
+
+            var coords = _transform.ToCoordinates(pent, _transform.GetMapCoordinates(pent).Offset(wOffset));
             var funcId = _inputManager.NetworkBindMap.KeyFunctionID(keyFunction);
 
-            var message = new FullInputCmdMessage(_timing.CurTick, _timing.TickFraction, funcId, state,
-                GetNetCoordinates(coords), new ScreenCoordinates(0, 0, default), NetEntity.Invalid);
+            var message = new ClientFullInputCmdMessage(_timing.CurTick,
+                _timing.TickFraction,
+                funcId,
+                coords,
+                new ScreenCoordinates(0, 0, default),
+                state,
+                EntityUid.Invalid);
 
             HandleInputCommand(_playerManager.LocalSession, keyFunction, message);
         }

Robust.Client/GameObjects/EntitySystems/MapSystem.cs

@@ -1,12 +1,9 @@
 using Robust.Client.Graphics;
 using Robust.Client.Map;
-using Robust.Client.Physics;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
-using Robust.Shared.Map.Components;
-using Robust.Shared.Physics.Dynamics;
 
 namespace Robust.Client.GameObjects;
 
@@ -16,6 +13,17 @@ public sealed class MapSystem : SharedMapSystem
     [Dependency] private readonly IResourceCache _resource = default!;
     [Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
 
+    protected override MapId GetNextMapId()
+    {
+        // Client-side map entities use negative map Ids to avoid conflict with server-side maps.
+        var id = new MapId(--LastMapId);
+        while (MapManager.MapExists(id))
+        {
+            id = new MapId(--LastMapId);
+        }
+        return id;
+    }
+
     public override void Initialize()
     {
         base.Initialize();
@@ -27,9 +35,4 @@ public sealed class MapSystem : SharedMapSystem
         base.Shutdown();
         _overlayManager.RemoveOverlay<TileEdgeOverlay>();
     }
-
-    protected override void OnMapAdd(EntityUid uid, MapComponent component, ComponentAdd args)
-    {
-        EnsureComp<PhysicsMapComponent>(uid);
-    }
 }

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,84 +1,38 @@
-using Robust.Client.Player;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Reflection;
-using System;
-using UserInterfaceComponent = Robust.Shared.GameObjects.UserInterfaceComponent;
+using Robust.Shared.Prototypes;
 
-namespace Robust.Client.GameObjects
+namespace Robust.Client.GameObjects;
+
+public sealed class UserInterfaceSystem : SharedUserInterfaceSystem
 {
-    public sealed class UserInterfaceSystem : SharedUserInterfaceSystem
+    public override void Initialize()
     {
-        [Dependency] private readonly IDynamicTypeFactory _dynamicTypeFactory = default!;
-        [Dependency] private readonly IPlayerManager _playerManager = default!;
-        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
+        base.Initialize();
+        ProtoManager.PrototypesReloaded += OnProtoReload;
+    }
 
-        public override void Initialize()
+    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)
         {
-            base.Initialize();
+            if (!UIQuery.TryComp(uid, out var uiComp))
+                continue;
 
-            SubscribeNetworkEvent<BoundUIWrapMessage>(MessageReceived);
-        }
-
-        private void MessageReceived(BoundUIWrapMessage ev)
-        {
-            var uid = GetEntity(ev.Entity);
-
-            if (!TryComp<UserInterfaceComponent>(uid, out var cmp))
-                return;
-
-            var uiKey = ev.UiKey;
-            var message = ev.Message;
-            message.Session = _playerManager.LocalSession!;
-            message.Entity = GetNetEntity(uid);
-            message.UiKey = uiKey;
-
-            // Raise as object so the correct type is used.
-            RaiseLocalEvent(uid, (object)message, true);
-
-            switch (message)
+            foreach (var bui in uiComp.ClientOpenInterfaces.Values)
             {
-                case OpenBoundInterfaceMessage _:
-                    TryOpenUi(uid, uiKey, cmp);
-                    break;
-
-                case CloseBoundInterfaceMessage _:
-                    TryCloseUi(message.Session, uid, uiKey, remoteCall: true, uiComp: cmp);
-                    break;
-
-                default:
-                    if (cmp.OpenInterfaces.TryGetValue(uiKey, out var bui))
-                        bui.InternalReceiveMessage(message);
-
-                    break;
+                bui.OnProtoReload(obj);
             }
         }
-
-        private bool TryOpenUi(EntityUid uid, Enum uiKey, UserInterfaceComponent? uiComp = null)
-        {
-            if (!Resolve(uid, ref uiComp))
-                return false;
-
-            if (uiComp.OpenInterfaces.ContainsKey(uiKey))
-                return false;
-
-            var data = uiComp.MappedInterfaceData[uiKey];
-
-            // TODO: This type should be cached, but I'm too lazy.
-            var type = _reflectionManager.LooseGetType(data.ClientType);
-            var boundInterface =
-                (BoundUserInterface) _dynamicTypeFactory.CreateInstance(type, new object[] {uid, uiKey});
-
-            boundInterface.Open();
-            uiComp.OpenInterfaces[uiKey] = boundInterface;
-
-            if (_playerManager.LocalSession is { } playerSession)
-            {
-                uiComp.Interfaces[uiKey]._subscribedSessions.Add(playerSession);
-                RaiseLocalEvent(uid, new BoundUIOpenedEvent(uiKey, uid, playerSession), true);
-            }
-
-            return true;
-        }
     }
 }

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/GameStates/ClientGameStateManager.cs

@@ -54,11 +54,11 @@ namespace Robust.Client.GameStates
         private readonly HashSet<NetEntity> _stateEnts = new();
         private readonly List<EntityUid> _toDelete = new();
         private readonly List<IComponent> _toRemove = new();
-        private readonly Dictionary<NetEntity, Dictionary<ushort, IComponentState>> _outputData = new();
+        private readonly Dictionary<NetEntity, Dictionary<ushort, IComponentState?>> _outputData = new();
         private readonly List<(EntityUid, TransformComponent)> _queuedBroadphaseUpdates = new();
 
-        private readonly ObjectPool<Dictionary<ushort, IComponentState>> _compDataPool =
-            new DefaultObjectPool<Dictionary<ushort, IComponentState>>(new DictPolicy<ushort, IComponentState>(), 256);
+        private readonly ObjectPool<Dictionary<ushort, IComponentState?>> _compDataPool =
+            new DefaultObjectPool<Dictionary<ushort, IComponentState?>>(new DictPolicy<ushort, IComponentState?>(), 256);
 
         private uint _metaCompNetId;
 
@@ -125,6 +125,8 @@ namespace Robust.Client.GameStates
 #endif
 
         private bool _resettingPredictedEntities;
+        private readonly List<EntityUid> _brokenEnts = new();
+        private readonly List<(EntityUid, NetEntity)> _toStart = new();
 
         /// <inheritdoc />
         public void Initialize()
@@ -257,7 +259,7 @@ namespace Robust.Client.GameStates
         public void UpdateFullRep(GameState state, bool cloneDelta = false)
             => _processor.UpdateFullRep(state, cloneDelta);
 
-        public Dictionary<NetEntity, Dictionary<ushort, IComponentState>> GetFullRep()
+        public Dictionary<NetEntity, Dictionary<ushort, IComponentState?>> GetFullRep()
             => _processor.GetFullRep();
 
         private void HandlePvsLeaveMessage(MsgStateLeavePvs message)
@@ -598,8 +600,12 @@ namespace Robust.Client.GameStates
                         if (_sawmill.Level <= LogLevel.Debug)
                             _sawmill.Debug($"  A component was dirtied: {comp.GetType()}");
 
-                        var handleState = new ComponentHandleState(compState, null);
-                        _entities.EventBus.RaiseComponentEvent(comp, ref handleState);
+                        if (compState != null)
+                        {
+                            var handleState = new ComponentHandleState(compState, null);
+                            _entities.EventBus.RaiseComponentEvent(entity, comp, ref handleState);
+                        }
+
                         comp.LastModifiedTick = _timing.LastRealTick;
                     }
                 }
@@ -631,8 +637,12 @@ namespace Robust.Client.GameStates
                         if (_sawmill.Level <= LogLevel.Debug)
                             _sawmill.Debug($"  A component was removed: {comp.GetType()}");
 
-                        var stateEv = new ComponentHandleState(state, null);
-                        _entities.EventBus.RaiseComponentEvent(comp, ref stateEv);
+                        if (state != null)
+                        {
+                            var stateEv = new ComponentHandleState(state, null);
+                            _entities.EventBus.RaiseComponentEvent(entity, comp, ref stateEv);
+                        }
+
                         comp.ClearCreationTick(); // don't undo the re-adding.
                         comp.LastModifiedTick = _timing.LastRealTick;
                     }
@@ -667,7 +677,16 @@ namespace Robust.Client.GameStates
 
             foreach (var netEntity in createdEntities)
             {
+#if EXCEPTION_TOLERANCE
+                if (!_entityManager.TryGetEntityData(netEntity, out _, out var meta))
+                {
+                    _sawmill.Error($"Encountered deleted entity while merging implicit data! NetEntity: {netEntity}");
+                    continue;
+                }
+#else
                 var (_, meta) = _entityManager.GetEntityData(netEntity);
+#endif
+
                 var compData = _compDataPool.Get();
                 _outputData.Add(netEntity, compData);
 
@@ -676,7 +695,7 @@ namespace Robust.Client.GameStates
                     DebugTools.Assert(component.NetSyncEnabled);
 
                     var state = _entityManager.GetComponentState(bus, component, null, GameTick.Zero);
-                    DebugTools.Assert(state is not IComponentDeltaState delta || delta.FullState);
+                    DebugTools.Assert(state is not IComponentDeltaState);
                     compData.Add(netId, state);
                 }
             }
@@ -700,7 +719,7 @@ namespace Robust.Client.GameStates
         {
             using var _ = _timing.StartStateApplicationArea();
 
-            // TODO repays optimize this.
+            // TODO replays optimize this.
             // This currently just saves game states as they are applied.
             // However this is inefficient and may have redundant data.
             // E.g., we may record states: [10 to 15] [11 to 16] *error* [0 to 18] [18 to 19] [18 to 20] ...
@@ -876,9 +895,22 @@ namespace Robust.Client.GameStates
             {
                 foreach (var (entity, data) in _toApply)
                 {
+#if EXCEPTION_TOLERANCE
+                    try
+                    {
+#endif
                     HandleEntityState(entity, data.NetEntity, data.Meta, _entities.EventBus, data.curState,
-                        data.nextState, data.LastApplied, curState.ToSequence, data.EnteringPvs);
-
+                            data.nextState, data.LastApplied, curState.ToSequence, data.EnteringPvs);
+#if EXCEPTION_TOLERANCE
+                    }
+                    catch (Exception e)
+                    {
+                        _sawmill.Error($"Caught exception while applying entity state. Entity: {_entities.ToPrettyString(entity)}. Exception: {e}");
+                        _entityManager.DeleteEntity(entity);
+                        RequestFullState();
+                        continue;
+                    }
+#endif
                     if (!data.EnteringPvs)
                         continue;
 
@@ -917,7 +949,7 @@ namespace Robust.Client.GameStates
             {
                 try
                 {
-                    ProcessDeletions(delSpan, xforms, xformSys);
+                    ProcessDeletions(delSpan, xforms, metas, xformSys);
                 }
                 catch (Exception e)
                 {
@@ -962,6 +994,7 @@ namespace Robust.Client.GameStates
             }
 
             var xforms = _entities.GetEntityQuery<TransformComponent>();
+            var metas = _entities.GetEntityQuery<MetaDataComponent>();
             var xformSys = _entitySystemManager.GetEntitySystem<SharedTransformSystem>();
 
             _toDelete.Clear();
@@ -990,12 +1023,12 @@ namespace Robust.Client.GameStates
 
                 // This entity is going to get deleted, but maybe some if its children won't be, so lets detach them to
                 // null. First we will detach the parent in order to reduce the number of broadphase/lookup updates.
-                xformSys.DetachParentToNull(ent, xform);
+                xformSys.DetachEntity(ent, xform);
 
                 // Then detach all children.
                 foreach (var child in xform._children)
                 {
-                    xformSys.DetachParentToNull(child, xforms.GetComponent(child), xform);
+                    xformSys.DetachEntity(child, xforms.Get(child), metas.Get(child), xform);
 
                     if (deleteClientChildren
                         && !deleteClientEntities // don't add duplicates
@@ -1014,9 +1047,9 @@ namespace Robust.Client.GameStates
             }
         }
 
-        private void ProcessDeletions(
-            ReadOnlySpan<NetEntity> delSpan,
+        private void ProcessDeletions(ReadOnlySpan<NetEntity> delSpan,
             EntityQuery<TransformComponent> xforms,
+            EntityQuery<MetaDataComponent> metas,
             SharedTransformSystem xformSys)
         {
             // Processing deletions is non-trivial, because by default deletions will also delete all child entities.
@@ -1043,13 +1076,13 @@ namespace Robust.Client.GameStates
                     continue; // Already deleted? or never sent to us?
 
                 // First, a single recursive map change
-                xformSys.DetachParentToNull(id.Value, xform);
+                xformSys.DetachEntity(id.Value, xform);
 
                 // Then detach all children.
                 var childEnumerator = xform.ChildEnumerator;
                 while (childEnumerator.MoveNext(out var child))
                 {
-                    xformSys.DetachParentToNull(child, xforms.GetComponent(child), xform);
+                    xformSys.DetachEntity(child, xforms.Get(child), metas.Get(child), xform);
                 }
 
                 // Finally, delete the entity.
@@ -1120,7 +1153,7 @@ namespace Robust.Client.GameStates
                     continue;
                 }
 
-                if ((meta.Flags & MetaDataFlags.Detached) != 0)
+                if ((meta.Flags & (MetaDataFlags.Detached | MetaDataFlags.Undetachable)) != 0)
                     continue;
 
                 if (lastStateApplied.HasValue)
@@ -1138,13 +1171,13 @@ namespace Robust.Client.GameStates
                     if ((meta.Flags & MetaDataFlags.InContainer) != 0 &&
                         metas.TryGetComponent(xform.ParentUid, out var containerMeta) &&
                         (containerMeta.Flags & MetaDataFlags.Detached) == 0 &&
-                        containerSys.TryGetContainingContainer(xform.ParentUid, ent.Value, out container, null, true))
+                        containerSys.TryGetContainingContainer(xform.ParentUid, ent.Value, out container))
                     {
                         containerSys.Remove((ent.Value, xform, meta), container, false, true);
                     }
 
                     meta._flags |= MetaDataFlags.Detached;
-                    xformSys.DetachParentToNull(ent.Value, xform);
+                    xformSys.DetachEntity(ent.Value, xform);
                     DebugTools.Assert((meta.Flags & MetaDataFlags.InContainer) == 0);
 
                     if (container != null)
@@ -1157,63 +1190,58 @@ namespace Robust.Client.GameStates
 
         private void InitializeAndStart(Dictionary<NetEntity, EntityState> toCreate)
         {
-            var metaQuery = _entityManager.GetEntityQuery<MetaDataComponent>();
+            _toStart.Clear();
 
-#if EXCEPTION_TOLERANCE
-            var brokenEnts = new List<EntityUid>();
-#endif
             using (_prof.Group("Initialize Entity"))
             {
+                EntityUid entity = default;
                 foreach (var netEntity in toCreate.Keys)
                 {
-                    var entity = _entityManager.GetEntity(netEntity);
-#if EXCEPTION_TOLERANCE
                     try
                     {
-#endif
-                    _entities.InitializeEntity(entity, metaQuery.GetComponent(entity));
-#if EXCEPTION_TOLERANCE
+                        (entity, var meta) = _entityManager.GetEntityData(netEntity);
+                        _entities.InitializeEntity(entity, meta);
+                        _toStart.Add((entity, netEntity));
                     }
                     catch (Exception e)
                     {
-                        _sawmill.Error($"Server entity threw in Init: ent={_entities.ToPrettyString(entity)}");
+                        _sawmill.Error($"Server entity threw in Init: nent={netEntity}, ent={_entities.ToPrettyString(entity)}");
                         _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(InitializeAndStart)}");
-                        brokenEnts.Add(entity);
-                        toCreate.Remove(netEntity);
-                    }
+                        _toCreate.Remove(netEntity);
+                        _brokenEnts.Add(entity);
+#if !EXCEPTION_TOLERANCE
+                        throw;
 #endif
+                    }
                 }
             }
 
             using (_prof.Group("Start Entity"))
             {
-                foreach (var netEntity in toCreate.Keys)
+                foreach (var (entity, netEntity) in _toStart)
                 {
-                    var entity = _entityManager.GetEntity(netEntity);
-#if EXCEPTION_TOLERANCE
                     try
                     {
-#endif
-                    _entities.StartEntity(entity);
-#if EXCEPTION_TOLERANCE
+                        _entities.StartEntity(entity);
                     }
                     catch (Exception e)
                     {
-                        _sawmill.Error($"Server entity threw in Start: ent={_entityManager.ToPrettyString(entity)}");
+                        _sawmill.Error($"Server entity threw in Start:  nent={netEntity}, ent={_entityManager.ToPrettyString(entity)}");
                         _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(InitializeAndStart)}");
-                        brokenEnts.Add(entity);
-                        toCreate.Remove(netEntity);
-                    }
+                        _toCreate.Remove(netEntity);
+                        _brokenEnts.Add(entity);
+#if !EXCEPTION_TOLERANCE
+                        throw;
 #endif
+                    }
                 }
             }
 
-#if EXCEPTION_TOLERANCE
-            foreach (var entity in brokenEnts)
+            foreach (var entity in _brokenEnts)
             {
                 _entityManager.DeleteEntity(entity);
             }
-#endif
+            _brokenEnts.Clear();
         }
 
         private void HandleEntityState(EntityUid uid, NetEntity netEntity, MetaDataComponent meta, IEventBus bus, EntityState? curState,
@@ -1329,23 +1357,11 @@ namespace Robust.Client.GameStates
 
             foreach (var (comp, cur, next) in _compStateWork.Values)
             {
-                try
-                {
-                    var handleState = new ComponentHandleState(cur, next);
-                    bus.RaiseComponentEvent(comp, ref handleState);
-                }
-#pragma warning disable CS0168 // Variable is declared but never used
-                catch (Exception e)
-#pragma warning restore CS0168 // Variable is declared but never used
-                {
-#if EXCEPTION_TOLERANCE
-                    _sawmill.Error($"Failed to apply comp state: entity={_entities.ToPrettyString(uid)}, comp={comp.GetType()}");
-                    _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(HandleEntityState)}");
-#else
-                    _sawmill.Error($"Failed to apply comp state: entity={_entities.ToPrettyString(uid)}, comp={comp.GetType()}");
-                    throw;
-#endif
-                }
+                if (cur == null && next == null)
+                    continue;
+
+                var handleState = new ComponentHandleState(cur, next);
+                bus.RaiseComponentEvent(uid, comp, ref handleState);
             }
         }
 
@@ -1414,10 +1430,10 @@ namespace Robust.Client.GameStates
                     _entities.TryGetComponent(xform.ParentUid, out MetaDataComponent? containerMeta) &&
                     (containerMeta.Flags & MetaDataFlags.Detached) == 0)
                 {
-                    containerSys.TryGetContainingContainer(xform.ParentUid, uid, out container, null, true);
+                    containerSys.TryGetContainingContainer(xform.ParentUid, uid, out container);
                 }
 
-                _entities.EntitySysManager.GetEntitySystem<TransformSystem>().DetachParentToNull(uid, xform);
+                _entities.EntitySysManager.GetEntitySystem<TransformSystem>().DetachEntity(uid, xform);
 
                 if (container != null)
                     containerSys.AddExpectedEntity(_entities.GetNetEntity(uid), container);
@@ -1496,8 +1512,11 @@ namespace Robust.Client.GameStates
                     _entityManager.AddComponent(uid, comp, true, meta);
                 }
 
+                if (state == null)
+                    continue;
+
                 var handleState = new ComponentHandleState(state, null);
-                _entityManager.EventBus.RaiseComponentEvent(comp, ref handleState);
+                _entityManager.EventBus.RaiseComponentEvent(uid, comp, ref handleState);
             }
 
             // ensure we don't have any extra components

Robust.Client/GameStates/GameStateProcessor.cs

@@ -32,7 +32,7 @@ namespace Robust.Client.GameStates
         /// <summary>
         /// This dictionary stores the full most recently received server state of any entity. This is used whenever predicted entities get reset.
         /// </summary>
-        internal readonly Dictionary<NetEntity, Dictionary<ushort, IComponentState>> _lastStateFullRep
+        internal readonly Dictionary<NetEntity, Dictionary<ushort, IComponentState?>> _lastStateFullRep
             = new();
 
         /// <inheritdoc />
@@ -212,7 +212,7 @@ Had full state: {LastFullState != null}"
             {
                 if (!_lastStateFullRep.TryGetValue(entityState.NetEntity, out var compData))
                 {
-                    compData = new Dictionary<ushort, IComponentState>();
+                    compData = new();
                     _lastStateFullRep.Add(entityState.NetEntity, compData);
                 }
 
@@ -221,21 +221,20 @@ Had full state: {LastFullState != null}"
                     var compState = change.State;
 
                     if (compState is IComponentDeltaState delta
-                        && !delta.FullState
                         && compData.TryGetValue(change.NetID, out var old)) // May fail if relying on implicit data
                     {
-                        DebugTools.Assert(old is IComponentDeltaState oldDelta && oldDelta.FullState, "last state is not a full state");
+                        DebugTools.Assert(old is not IComponentDeltaState, "last state is not a full state");
 
                         if (cloneDelta)
                         {
-                            compState = delta.CreateNewFullState(old);
+                            compState = delta.CreateNewFullState(old!);
                         }
                         else
                         {
-                            delta.ApplyToFullState(old);
+                            delta.ApplyToFullState(old!);
                             compState = old;
                         }
-                        DebugTools.Assert(compState is IComponentDeltaState newState && newState.FullState, "newly constructed state is not a full state");
+                        DebugTools.Assert(compState is not IComponentDeltaState, "newly constructed state is not a full state");
                     }
 
                     compData[change.NetID] = compState;
@@ -391,7 +390,7 @@ Had full state: {LastFullState != null}"
             LastFullStateRequested = null;
         }
 
-        public void MergeImplicitData(Dictionary<NetEntity, Dictionary<ushort, IComponentState>> implicitData)
+        public void MergeImplicitData(Dictionary<NetEntity, Dictionary<ushort, IComponentState?>> implicitData)
         {
             foreach (var (netEntity, implicitEntState) in implicitData)
             {
@@ -399,6 +398,7 @@ Had full state: {LastFullState != null}"
 
                 foreach (var (netId, implicitCompState) in implicitEntState)
                 {
+                    DebugTools.Assert(implicitCompState is not IComponentDeltaState);
                     ref var serverState = ref CollectionsMarshal.GetValueRefOrAddDefault(fullRep, netId, out var exists);
 
                     if (!exists)
@@ -407,36 +407,32 @@ Had full state: {LastFullState != null}"
                         continue;
                     }
 
-                    if (serverState is not IComponentDeltaState serverDelta || serverDelta.FullState)
+                    if (serverState is not IComponentDeltaState serverDelta)
                         continue;
 
+                    DebugTools.AssertNotNull(implicitCompState);
+
                     // Server sent an initial delta state. This is fine as long as the client can infer an initial full
                     // state from the entity prototype.
-                    if (implicitCompState is not IComponentDeltaState implicitDelta || !implicitDelta.FullState)
-                    {
-                        _logger.Error($"Server sent delta state and client failed to construct an implicit full state for entity {netEntity}");
-                        continue;
-                    }
-
-                    serverDelta.ApplyToFullState(implicitCompState);
+                    serverDelta.ApplyToFullState(implicitCompState!);
                     serverState = implicitCompState;
-                    DebugTools.Assert(implicitCompState is IComponentDeltaState d && d.FullState);
+                    DebugTools.Assert(serverState is not IComponentDeltaState);
                 }
             }
         }
 
-        public Dictionary<ushort, IComponentState> GetLastServerStates(NetEntity netEntity)
+        public Dictionary<ushort, IComponentState?> GetLastServerStates(NetEntity netEntity)
         {
             return _lastStateFullRep[netEntity];
         }
 
-        public Dictionary<NetEntity, Dictionary<ushort, IComponentState>> GetFullRep()
+        public Dictionary<NetEntity, Dictionary<ushort, IComponentState?>> GetFullRep()
         {
             return _lastStateFullRep;
         }
 
         public bool TryGetLastServerStates(NetEntity entity,
-            [NotNullWhen(true)] out Dictionary<ushort, IComponentState>? dictionary)
+            [NotNullWhen(true)] out Dictionary<ushort, IComponentState?>? dictionary)
         {
             return _lastStateFullRep.TryGetValue(entity, out dictionary);
         }

Robust.Client/GameStates/IClientGameStateManager.cs

@@ -113,7 +113,7 @@ namespace Robust.Client.GameStates
         /// <summary>
         /// Returns the full collection of cached game states that are used to reset predicted entities.
         /// </summary>
-        Dictionary<NetEntity, Dictionary<ushort, IComponentState>> GetFullRep();
+        Dictionary<NetEntity, Dictionary<ushort, IComponentState?>> GetFullRep();
 
         /// <summary>
         /// This will perform some setup in order to reset the game to an earlier state. To fully reset the state

Robust.Client/GameStates/IGameStateProcessor.cs

@@ -83,13 +83,13 @@ namespace Robust.Client.GameStates
         ///     The data to merge.
         ///     It's a dictionary of entity ID -> (component net ID -> ComponentState)
         /// </param>
-        void MergeImplicitData(Dictionary<NetEntity, Dictionary<ushort, IComponentState>> data);
+        void MergeImplicitData(Dictionary<NetEntity, Dictionary<ushort, IComponentState?>> data);
 
         /// <summary>
         ///     Get the last state data from the server for an entity.
         /// </summary>
         /// <returns>Dictionary (net ID -> ComponentState)</returns>
-        Dictionary<ushort, IComponentState> GetLastServerStates(NetEntity entity);
+        Dictionary<ushort, IComponentState?> GetLastServerStates(NetEntity entity);
 
         /// <summary>
         ///     Calculate the number of applicable states in the game state buffer from a given tick.
@@ -99,6 +99,6 @@ namespace Robust.Client.GameStates
         int GetApplicableStateCount(GameTick? fromTick);
 
         bool TryGetLastServerStates(NetEntity entity,
-            [NotNullWhen(true)] out Dictionary<ushort, IComponentState>? dictionary);
+            [NotNullWhen(true)] out Dictionary<ushort, IComponentState?>? dictionary);
     }
 }

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -49,7 +49,7 @@ namespace Robust.Client.GameStates
             while (query.MoveNext(out var uid, out var transform))
             {
                 // if not on the same map, continue
-                if (transform.MapID != _eyeManager.CurrentMap || _container.IsEntityInContainer(uid))
+                if (transform.MapID != args.MapId || _container.IsEntityInContainer(uid))
                     continue;
 
                 if (transform.GridUid == uid)

Robust.Client/Graphics/ClientEye/EyeManager.cs

@@ -64,29 +64,22 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public Box2 GetWorldViewport()
         {
-            var vpSize = _displayManager.ScreenSize;
-
-            var topLeft = ScreenToMap(Vector2.Zero);
-            var topRight = ScreenToMap(new Vector2(vpSize.X, 0));
-            var bottomRight = ScreenToMap(vpSize);
-            var bottomLeft = ScreenToMap(new Vector2(0, vpSize.Y));
-
-            var left = MathHelper.Min(topLeft.X, topRight.X, bottomRight.X, bottomLeft.X);
-            var bottom = MathHelper.Min(topLeft.Y, topRight.Y, bottomRight.Y, bottomLeft.Y);
-            var right = MathHelper.Max(topLeft.X, topRight.X, bottomRight.X, bottomLeft.X);
-            var top = MathHelper.Max(topLeft.Y, topRight.Y, bottomRight.Y, bottomLeft.Y);
-
-            return new Box2(left, bottom, right, top);
+            return GetWorldViewbounds().CalcBoundingBox();
         }
 
         /// <inheritdoc />
         public Box2Rotated GetWorldViewbounds()
         {
-            var vpSize = _displayManager.ScreenSize;
+            // This is an inefficient and roundabout way of geting the viewport.
+            // But its a method that shouldn't get used much.
+
+            var vp = MainViewport as Control;
+            var vpSize = vp?.PixelSize ?? _displayManager.ScreenSize;
 
             var topRight = ScreenToMap(new Vector2(vpSize.X, 0)).Position;
             var bottomLeft = ScreenToMap(new Vector2(0, vpSize.Y)).Position;
 
+            // This assumes the main viewports eye and the main eye are the same.
             var rotation = new Angle(CurrentEye.Rotation);
             var center = (bottomLeft + topRight) / 2;
 
@@ -108,18 +101,16 @@ namespace Robust.Client.Graphics
         }
 
         /// <inheritdoc />
-        public void GetScreenProjectionMatrix(out Matrix3 projMatrix)
+        public void GetScreenProjectionMatrix(out Matrix3x2 projMatrix)
         {
-            Matrix3 result = default;
+            Matrix3x2 result = default;
 
-            result.R0C0 = PixelsPerMeter;
-            result.R1C1 = -PixelsPerMeter;
+            result.M11 = PixelsPerMeter;
+            result.M22 = -PixelsPerMeter;
 
             var screenSize = _displayManager.ScreenSize;
-            result.R0C2 = screenSize.X / 2f;
-            result.R1C2 = screenSize.Y / 2f;
-
-            result.R2C2 = 1;
+            result.M31 = screenSize.X / 2f;
+            result.M32 = screenSize.Y / 2f;
 
             /* column major
              Sx 0 Tx

Robust.Client/Graphics/ClientEye/IEyeManager.cs

@@ -1,4 +1,5 @@
-using System.Numerics;
+using System;
+using System.Numerics;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.Graphics;
 using Robust.Shared.Map;
@@ -13,26 +14,29 @@ namespace Robust.Client.Graphics
     public interface IEyeManager
     {
         /// <summary>
-        /// The current eye that is being used to render the game.
+        /// The primary eye, which is usually the eye associated with the main viewport.
         /// </summary>
         /// <remarks>
+        /// Generally, you should avoid using this whenever possible. E.g., when rendering overlays should use the
+        /// eye & viewbounds that gets passed to the draw method.
         /// Setting this property to null will use the default eye.
         /// </remarks>
         IEye CurrentEye { get; set; }
 
         IViewportControl MainViewport { get; set; }
 
-        /// <summary>
-        /// The ID of the map on which the current eye is "placed".
-        /// </summary>
+        [Obsolete]
         MapId CurrentMap { get; }
 
         /// <summary>
-        /// A world-space box that is at LEAST the area covered by the viewport.
+        /// A world-space box that is at LEAST the area covered by the main viewport.
         /// May be larger due to say rotation.
         /// </summary>
         Box2 GetWorldViewport();
 
+        /// <summary>
+        /// A world-space box of the area visible in the main viewport.
+        /// </summary>
         Box2Rotated GetWorldViewbounds();
 
         /// <summary>
@@ -40,10 +44,10 @@ namespace Robust.Client.Graphics
         /// to UI screen space.
         /// </summary>
         /// <param name="projMatrix"></param>
-        void GetScreenProjectionMatrix(out Matrix3 projMatrix);
+        void GetScreenProjectionMatrix(out Matrix3x2 projMatrix);
 
         /// <summary>
-        /// Projects a point from world space to UI screen space using the current camera.
+        /// Projects a point from world space to UI screen space using the main viewport.
         /// </summary>
         /// <param name="point">Point in world to transform.</param>
         /// <returns>Corresponding point in UI screen space.</returns>

Robust.Client/Graphics/Clyde/Clyde.Constants.cs

@@ -6,7 +6,8 @@ namespace Robust.Client.Graphics.Clyde
         {
             ("aPos", 0),
             ("tCoord", 1),
-            ("modulate", 2)
+            ("tCoord2", 2),
+            ("modulate", 3)
         };
 
         private const int UniIModUV = 0;

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))
@@ -124,7 +121,7 @@ namespace Robust.Client.Graphics.Clyde
         {
             foreach (var (grid, chunks) in _mapChunkData)
             {
-                var gridComp = _mapManager.GetGridComp(grid);
+                var gridComp = _entityManager.GetComponent<MapGridComponent>(grid);
                 foreach (var (index, chunk) in chunks)
                 {
                     if (!chunk.Dirty || gridComp.Chunks.ContainsKey(index))

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

@@ -9,8 +9,10 @@ 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;
 using Robust.Shared.Maths;
 using Robust.Shared.Profiling;
 using Robust.Shared.Utility;
@@ -250,10 +252,8 @@ namespace Robust.Client.Graphics.Clyde
         private void DrawEntities(Viewport viewport, Box2Rotated worldBounds, Box2 worldAABB, IEye eye)
         {
             var mapId = eye.Position.MapId;
-            if (mapId == MapId.Nullspace || !_mapManager.HasMapEntity(mapId))
-            {
+            if (mapId == MapId.Nullspace)
                 return;
-            }
 
             RenderOverlays(viewport, OverlaySpace.WorldSpaceBelowEntities, worldAABB, worldBounds);
             var worldOverlays = GetOverlaysForSpace(OverlaySpace.WorldSpaceEntities);
@@ -368,7 +368,7 @@ namespace Robust.Client.Graphics.Clyde
                     _renderHandle.UseShader(entry.Sprite.PostShader);
                     CalcScreenMatrices(viewport.Size, out var proj, out var view);
                     _renderHandle.SetProjView(proj, view);
-                    _renderHandle.SetModelTransform(Matrix3.Identity);
+                    _renderHandle.SetModelTransform(Matrix3x2.Identity);
 
                     var rounded = roundedPos - entityPostRenderTarget.Size / 2;
 
@@ -481,7 +481,7 @@ namespace Robust.Client.Graphics.Clyde
                 var worldBounds = CalcWorldBounds(viewport);
                 var worldAABB = worldBounds.CalcBoundingBox();
 
-                if (_eyeManager.CurrentMap != MapId.Nullspace)
+                if (eye.Position.MapId != MapId.Nullspace)
                 {
                     using (DebugGroup("Lights"))
                     using (_prof.Group("Lights"))
@@ -514,7 +514,9 @@ namespace Robust.Client.Graphics.Clyde
 
                     if (_lightManager.Enabled && _lightManager.DrawHardFov && eye.DrawLight && eye.DrawFov)
                     {
-                        ApplyFovToBuffer(viewport, eye);
+                        var mapUid = _mapSystem.GetMap(eye.Position.MapId);
+                        if (_entityManager.GetComponent<MapComponent>(mapUid).LightingEnabled)
+                            ApplyFovToBuffer(viewport, eye);
                     }
                 }
 
@@ -529,7 +531,7 @@ namespace Robust.Client.Graphics.Clyde
                     // Because the math is wrong.
                     // So there are distortions from incorrect projection.
                     _renderHandle.UseShader(_fovDebugShaderInstance);
-                    _renderHandle.DrawingHandleScreen.SetTransform(Matrix3.Identity);
+                    _renderHandle.DrawingHandleScreen.SetTransform(Matrix3x2.Identity);
                     var pos = UIBox2.FromDimensions(viewport.Size / 2 - new Vector2(200, 200), new Vector2(400, 400));
                     _renderHandle.DrawingHandleScreen.DrawTextureRect(FovTexture, pos);
                 }
@@ -537,15 +539,18 @@ namespace Robust.Client.Graphics.Clyde
                 if (DebugLayers == ClydeDebugLayers.Light)
                 {
                     _renderHandle.UseShader(null);
-                    _renderHandle.DrawingHandleScreen.SetTransform(Matrix3.Identity);
+                    _renderHandle.DrawingHandleScreen.SetTransform(Matrix3x2.Identity);
                     _renderHandle.DrawingHandleScreen.DrawTextureRect(
                         viewport.WallBleedIntermediateRenderTarget2.Texture,
                         UIBox2.FromDimensions(Vector2.Zero, viewport.Size), new Color(1, 1, 1, 0.5f));
                 }
 
-                using (_prof.Group("Overlays WS"))
+                if (eye.Position.MapId != MapId.Nullspace)
                 {
-                    RenderOverlays(viewport, OverlaySpace.WorldSpace, worldAABB, worldBounds);
+                    using (_prof.Group("Overlays WS"))
+                    {
+                        RenderOverlays(viewport, OverlaySpace.WorldSpace, worldAABB, worldBounds);
+                    }
                 }
 
                 _currentViewport = oldVp;