Version: 223.2.0

* Improve FormattedMessage exception handling

* comments

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

.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,4 +1,14 @@
 <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" />

MSBuild/Robust.Engine.Version.props

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

RELEASE-NOTES.md

@@ -54,6 +54,185 @@ END TEMPLATE-->
 *None yet*
 
 
+## 223.2.0
+
+### New features
+
+* Added several new `FormattedMessage` methods for better exception tolerance when parsing markup. Several existing methods have been marked as obsolete, with new renamed methods taking their place.
+
+
+## 223.1.2
+
+### Bugfixes
+
+* `MapGridComponent.LastTileModifiedTick` is now actually networked to clients.
+
+
+## 223.1.1
+
+### Bugfixes
+
+* Fixed an exception caused by enum cvars using integer type values instead of enum values
+
+
+## 223.1.0
+
+### Other
+
+* Various `ContainerSystem` methods have been obsoleted in favour of overrides that take in an `Entity` struct instead of `EntityUid`
+* Various `EntityCoordinates` methods have been obsoleted with replacements added  to `SharedTransformSystem`
+
+
+## 223.0.0
+
+### Breaking changes
+
+* The `ComponentState` class is now abstract. Networked components that don't have state information now just return a null state.
+* The way that delta component states work has changed. It now expects there to be two different state classes, only one of which should implement `IComponentDeltaState<TFullState>`
+
+### New features
+
+* A new `replay.checkpoint_min_interval` cvar has been added. It can be used to limit the frequency at which checkpoints are generated when loading a replay.
+* Added `IConfigurationManager.OnCVarValueChanged`. This is a c# event that gets invoked whenever any cvar value changes.
+
+### Bugfixes
+
+* `IEyeManager.GetWorldViewbounds()` and `IEyeManager.GetWorldViewbounds()` should now return the correct bounds if the main viewport does not take up the whole screen.
+
+### Other
+
+* The default values of various replay related cvars have been changed to try and reduce memory usage.
+
+
+## 222.4.0
+
+### New features
+
+* Added the following types from `System.Numerics` to the sandbox: `Complex`, `Matrix3x2`, `Matrix4x4`, `Plane`, `Quaternion`, `Vector3`, `Vector4`.
+
+
+## 222.3.0
+
+### New features
+
+* `ITileDefinition.EditorHidden` allows hiding a tile from the tile spawn panel.
+* Ordered event subscriptions now take child types into account, so ordering based on a shared type will work.
+
+### Bugfixes
+
+* Cross-map BUI range checks now work.
+* Paused entities update on prototype reload.
+
+### Other
+
+* Fixed build compatibility with .NET 8.0.300 SDK, due to changes in how Central Package Management behaves.
+* Physics component has delta states to reduce network usage.
+
+
+## 222.2.0
+
+### New features
+
+* Added `EntityQuery.Comp()` (abbreviation of `GetComponent()`)
+
+### Bugfixes
+
+* Fix `SerializationManager.TryGetVariableType` checking the wrong property.
+* Fixed GrammarSystem mispredicting a character's gender
+
+### Other
+
+* User interface system now performs range checks in parallel
+
+
+## 222.1.1
+
+### Bugfixes
+
+* Fixed never setting BoundUserInterface.State.
+
+### Other
+
+* Add truncate for filesaving.
+* Add method for getting the type of a data field by name from ISerializationManager.
+
+
+## 222.1.0
+
+### New features
+
+* Added `BoundKeyEventArgs.IsRepeat`.
+* Added `net.lidgren_log_warning` and `net.lidgren_log_error` CVars.
+
+### Bugfixes
+
+* Fix assert trip when holding repeatable keybinds.
+
+### Other
+
+* Updated Lidgren to v0.3.1. This should provide performance improvements if warning/error logs are disabled.
+
+
+## 222.0.0
+
+### Breaking changes
+
+* Mark IComponentFactory argument in EntityPrototype as mandatory.
+
+### New features
+
+* Add `EntProtoId<T>` to check for components on the attached entity as well.
+
+### Bugfixes
+
+* Fix PVS iterating duplicate chunks for multiple viewsubscriptions.
+
+### Other
+
+* Defer clientside BUI opens if it's the first state that comes in.
+
+
+## 221.2.0
+
+### New features
+
+* Add SetMapAudio helper to SharedAudioSystem to setup map-wide audio entities.
+* Add SetWorldRotNoLerp method to SharedTransformSystem to avoid client lerping.
+
+### Bugfixes
+
+* `SpriteComponent.CopyFrom` now copies `CopyToShaderParameters` configuration.
+
+
+## 221.1.0
+
+
+## 221.0.0
+
+### Breaking changes
+
+* `EntParentChangedMessage.OldMapId` is now an `EntityUid` instead of `MapId`
+* `TransformSystem.DetachParentToNull()` is being renamed to `DetachEntity`
+* The order in which `MoveEvent` handlers are invoked has been changed to prioritise engine subscriptions
+
+### New features
+
+* Added `UpdateHovered()` and `SetHovered()` to `IUserInterfaceManager`, for updating or modifying the currently hovered control.
+* Add SwapPositions to TransformSystem to swap two entity's transforms.
+
+### Bugfixes
+
+* Improve client gamestate exception tolerance.
+
+### Other
+
+* If the currently hovered control is disposed, `UserInterfaceManager` will now look for a new control, rather than just setting the hovered control to null.
+
+### Internal
+
+* Use more `EntityQuery<T>` internally in EntityManager and PhysicsSystem.
+
+
 ## 220.2.0
 
 ### New features
@@ -79,7 +258,7 @@ END TEMPLATE-->
 
 ### Breaking changes
 
-* Refactor UserInterfaceSystem. 
+* Refactor UserInterfaceSystem.
   - The API has been significantly cleaned up and standardised, most noticeably callers don't need to worry about TryGetUi and can rely on either HasUi, SetUiState, CloseUi, or OpenUi to handle their code as appropriate.
   - Interface data is now stored via key rather than as a flat list which is a breaking change for YAML.
   - BoundUserInterfaces can now be completely handled via Shared code. Existing Server-side callers will behave similarly to before.

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

@@ -6,6 +6,7 @@ using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Robust.Roslyn.Shared;
+using Robust.Shared.Serialization.Manager.Definition;
 
 namespace Robust.Analyzers;
 
@@ -56,8 +57,18 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "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 override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
-        DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule
+        DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule,
+        DataFieldRedundantTagRule
     );
 
     public override void Initialize(AnalysisContext context)
@@ -125,6 +136,11 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
             {
                 context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, context.Node.GetLocation(), fieldSymbol.Name, type.Name));
             }
+
+            if (HasRedundantTag(fieldSymbol))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, context.Node.GetLocation(), fieldSymbol.Name, type.Name));
+            }
         }
     }
 
@@ -149,6 +165,11 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         {
             context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, context.Node.GetLocation(), propertySymbol.Name, type.Name));
         }
+
+        if (HasRedundantTag(propertySymbol))
+        {
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldRedundantTagRule, context.Node.GetLocation(), propertySymbol.Name, type.Name));
+        }
     }
 
     private static bool IsReadOnlyDataField(ITypeSymbol type, ISymbol field)
@@ -248,6 +269,29 @@ 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 IsImplicitDataDefinition(ITypeSymbol type)
     {
         if (HasAttribute(type, ImplicitDataDefinitionNamespace))

Robust.Analyzers/DataDefinitionFixer.cs

@@ -1,8 +1,5 @@
 #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;
@@ -16,8 +13,11 @@ namespace Robust.Analyzers;
 [ExportCodeFixProvider(LanguageNames.CSharp)]
 public sealed class DefinitionFixer : CodeFixProvider
 {
+    private const string DataFieldAttributeName = "DataField";
+
     public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
-        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable
+        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable,
+        IdDataFieldRedundantTag
     );
 
     public override Task RegisterCodeFixesAsync(CodeFixContext context)
@@ -34,6 +34,8 @@ public sealed class DefinitionFixer : CodeFixProvider
                     return RegisterDataFieldFix(context, diagnostic);
                 case IdDataFieldPropertyWritable:
                     return RegisterDataFieldPropertyFix(context, diagnostic);
+                case IdDataFieldRedundantTag:
+                    return RegisterRedundantTagFix(context, diagnostic);
             }
         }
 
@@ -72,6 +74,68 @@ 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 RegisterDataFieldFix(CodeFixContext context, Diagnostic diagnostic)
     {
         var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);

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/Robust.Analyzers.csproj

@@ -16,6 +16,11 @@
     <Compile Include="..\Robust.Shared\Analyzers\PreferGenericVariantAttribute.cs" LinkBase="Implementations" />
   </ItemGroup>
 
+  <ItemGroup>
+    <!-- Needed for DataDefinitionAnalyzer. -->
+    <Compile Include="..\Robust.Shared\Serialization\Manager\Definition\DataDefinitionUtility.cs" LinkBase="Implementations" />
+  </ItemGroup>
+
   <Import Project="../Robust.Roslyn.Shared/Robust.Roslyn.Shared.props" />
 
   <PropertyGroup>

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/Debugging/DebugPhysicsSystem.cs

@@ -225,7 +225,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)
             {
@@ -373,7 +373,7 @@ namespace Robust.Client.Debugging
 
         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)

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

@@ -1681,6 +1681,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()
@@ -2155,6 +2157,12 @@ namespace Robust.Client.GameObjects
             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)

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -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);
                 }
 

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

@@ -70,7 +70,7 @@ namespace Robust.Client.GameObjects
 
         protected internal override void Draw(in OverlayDrawArgs args)
         {
-            var currentMap = _eyeManager.CurrentMap;
+            var currentMap = args.MapId;
             var viewport = args.WorldBounds;
             var worldHandle = args.WorldHandle;
 

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(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(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);
                 }
             }
@@ -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.
@@ -1144,7 +1177,7 @@ namespace Robust.Client.GameStates
                     }
 
                     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,6 +1357,9 @@ namespace Robust.Client.GameStates
 
             foreach (var (comp, cur, next) in _compStateWork.Values)
             {
+                if (cur == null && next == null)
+                    continue;
+
                 var handleState = new ComponentHandleState(cur, next);
                 bus.RaiseComponentEvent(comp, ref handleState);
             }
@@ -1402,7 +1433,7 @@ namespace Robust.Client.GameStates
                     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);
@@ -1481,6 +1512,9 @@ 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);
             }

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;
 

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>
@@ -43,7 +47,7 @@ namespace Robust.Client.Graphics
         void GetScreenProjectionMatrix(out Matrix3 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.HLR.cs

@@ -480,7 +480,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"))
@@ -544,9 +544,12 @@ namespace Robust.Client.Graphics.Clyde
                         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;

Robust.Client/Graphics/Clyde/Clyde.Textures.cs

@@ -664,7 +664,7 @@ namespace Robust.Client.Graphics.Clyde
 
                 fixed (byte* p = buffer)
                 {
-                    GL.GetnTexImage(TextureTarget.Texture2D, 0, PF.Rgba, PT.UnsignedByte, bufSize, (IntPtr) p);
+                    GL.GetTexImage(TextureTarget.Texture2D, 0, PF.Rgba, PT.UnsignedByte, (IntPtr) p);
                 }
 
                 GL.BindTexture(TextureTarget.Texture2D, curTexture2D);

Robust.Client/Input/InputManager.cs

@@ -346,7 +346,7 @@ namespace Robust.Client.Input
                 {
                     if (binding.CanRepeat)
                     {
-                        return SetBindState(binding, BoundKeyState.Down, uiOnly);
+                        return SetBindState(binding, BoundKeyState.Down, uiOnly, isRepeat);
                     }
 
                     return true;
@@ -375,7 +375,7 @@ namespace Robust.Client.Input
             SetBindState(binding, BoundKeyState.Up);
         }
 
-        private bool SetBindState(KeyBinding binding, BoundKeyState state, bool uiOnly = false)
+        private bool SetBindState(KeyBinding binding, BoundKeyState state, bool uiOnly = false, bool isRepeat = false)
         {
             if (binding.BindingType == KeyBindingType.Command && state == BoundKeyState.Down)
             {
@@ -387,6 +387,7 @@ namespace Robust.Client.Input
             // I honestly have no idea what the best solution here is.
             // note from the future: context switches won't cause re-entrancy anymore because InputContextContainer defers context switches
             DebugTools.Assert(!_currentlyFindingViewport, "Re-entrant key events??");
+            DebugTools.Assert(!isRepeat || binding.CanRepeat);
 
             try
             {
@@ -399,7 +400,7 @@ namespace Robust.Client.Input
                 binding.State = state;
 
                 var eventArgs = new BoundKeyEventArgs(binding.Function, binding.State,
-                    MouseScreenPosition, binding.CanFocus);
+                    MouseScreenPosition, binding.CanFocus, isRepeat);
 
                 // UI returns true here into blockPass if it wants to prevent us from giving input events
                 // to the viewport, but doesn't want it hard-handled so we keep processing possible key actions.

Robust.Client/Placement/Modes/AlignSnapgridCenter.cs

@@ -19,7 +19,7 @@ namespace Robust.Client.Placement.Modes
 
         public SnapgridCenter(PlacementManager pMan) : base(pMan) { }
 
-        public override void Render(DrawingHandleWorld handle)
+        public override void Render(in OverlayDrawArgs args)
         {
             if (Grid != null)
             {
@@ -34,18 +34,18 @@ namespace Robust.Client.Placement.Modes
                 {
                     var from = ScreenToWorld(new Vector2(a, 0));
                     var to = ScreenToWorld(new Vector2(a, viewportSize.Y));
-                    handle.DrawLine(from, to, new Color(0, 0, 1f));
+                    args.WorldHandle.DrawLine(from, to, new Color(0, 0, 1f));
                 }
                 for (var a = gridstart.Y; a < viewportSize.Y; a += SnapSize * EyeManager.PixelsPerMeter)
                 {
                     var from = ScreenToWorld(new Vector2(0, a));
                     var to = ScreenToWorld(new Vector2(viewportSize.X, a));
-                    handle.DrawLine(from, to, new Color(0, 0, 1f));
+                    args.WorldHandle.DrawLine(from, to, new Color(0, 0, 1f));
                 }
             }
 
             // Draw grid BELOW the ghost thing.
-            base.Render(handle);
+            base.Render(args);
         }
 
         public override void AlignPlacementMode(ScreenCoordinates mouseScreen)

Robust.Client/Placement/PlacementManager.cs

@@ -628,20 +628,20 @@ namespace Robust.Client.Placement
             return true;
         }
 
-        private void Render(DrawingHandleWorld handle)
+        private void Render(in OverlayDrawArgs args)
         {
             if (CurrentMode == null || !IsActive)
             {
                 if (EraserRect.HasValue)
                 {
-                    handle.UseShader(_drawingShader);
-                    handle.DrawRect(EraserRect.Value, new Color(255, 0, 0, 50));
-                    handle.UseShader(null);
+                    args.WorldHandle.UseShader(_drawingShader);
+                    args.WorldHandle.DrawRect(EraserRect.Value, new Color(255, 0, 0, 50));
+                    args.WorldHandle.UseShader(null);
                 }
                 return;
             }
 
-            CurrentMode.Render(handle);
+            CurrentMode.Render(args);
 
             if (CurrentPermission is not {Range: > 0} ||
                 !CurrentMode.RangeRequired ||
@@ -650,7 +650,7 @@ namespace Robust.Client.Placement
 
             var worldPos = EntityManager.GetComponent<TransformComponent>(controlled).WorldPosition;
 
-            handle.DrawCircle(worldPos, CurrentPermission.Range, new Color(1, 1, 1, 0.25f));
+            args.WorldHandle.DrawCircle(worldPos, CurrentPermission.Range, new Color(1, 1, 1, 0.25f));
         }
 
         private void HandleStartPlacement(MsgPlacement msg)

Robust.Client/Placement/PlacementMode.cs

@@ -88,7 +88,7 @@ namespace Robust.Client.Placement
         /// <returns></returns>
         public abstract bool IsValidPosition(EntityCoordinates position);
 
-        public virtual void Render(DrawingHandleWorld handle)
+        public virtual void Render(in OverlayDrawArgs args)
         {
             var uid = pManager.CurrentPlacementOverlayEntity;
             if (!pManager.EntityManager.TryGetComponent(uid, out SpriteComponent? sprite) || !sprite.Visible)
@@ -125,7 +125,8 @@ namespace Robust.Client.Placement
                 var worldRot = pManager.EntityManager.GetComponent<TransformComponent>(coordinate.EntityId).WorldRotation + dirAng;
 
                 sprite.Color = IsValidPosition(coordinate) ? ValidPlaceColor : InvalidPlaceColor;
-                spriteSys.Render(uid.Value, sprite, handle, pManager.EyeManager.CurrentEye.Rotation, worldRot, worldPos);
+                var rot = args.Viewport.Eye?.Rotation ?? default;
+                spriteSys.Render(uid.Value, sprite, args.WorldHandle, rot, worldRot, worldPos);
             }
         }
 

Robust.Client/Placement/PlacementOverlay.cs

@@ -19,7 +19,7 @@ namespace Robust.Client.Placement
 
             protected internal override void Draw(in OverlayDrawArgs args)
             {
-                _manager.Render(args.WorldHandle);
+                _manager.Render(args);
             }
         }
     }

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

@@ -133,6 +133,11 @@ public sealed partial class ReplayLoadManager
         var spawnedTracker = 0;
         var stateTracker = 0;
         var curState = state0;
+
+        var stats_due_ticks = 0;
+        var stats_due_spawned = 0;
+        var stats_due_state = 0;
+
         for (var i = 1; i < states.Count; i++)
         {
             if (i % 10 == 0)
@@ -150,11 +155,28 @@ public sealed partial class ReplayLoadManager
             serverTime[i] = GetTime(curState.ToSequence) - initialTime;
             ticksSinceLastCheckpoint++;
 
+            // Don't create checkpoints too frequently no matter the circumstance
+            if (ticksSinceLastCheckpoint < _checkpointMinInterval)
+                continue;
+
+            // Check if enough time, spawned entities or changed states have occurred.
             if (ticksSinceLastCheckpoint < _checkpointInterval
                 && spawnedTracker < _checkpointEntitySpawnThreshold
                 && stateTracker < _checkpointEntityStateThreshold)
-            {
                 continue;
+
+            // Track and update statistics about why checkpoints are getting created:
+            if (ticksSinceLastCheckpoint >= _checkpointInterval)
+            {
+                stats_due_ticks += 1;
+            }
+            else if (spawnedTracker >= _checkpointEntitySpawnThreshold)
+            {
+                stats_due_spawned += 1;
+            }
+            else if (stateTracker >= _checkpointEntityStateThreshold)
+            {
+                stats_due_state += 1;
             }
 
             ticksSinceLastCheckpoint = 0;
@@ -169,7 +191,8 @@ public sealed partial class ReplayLoadManager
             checkPoints.Add(new CheckpointState(newState, timeBase, cvars, i, detached));
         }
 
-        _sawmill.Info($"Finished generating checkpoints. Elapsed time: {st.Elapsed}");
+        _sawmill.Info($"Finished generating {checkPoints.Count} checkpoints. Elapsed time: {st.Elapsed}. Checkpoint every {(float)states.Count / checkPoints.Count} ticks on average");
+        _sawmill.Info($"Checkpoint stats - Spawning: {stats_due_spawned} StateChanges: {stats_due_state} Ticks: {stats_due_ticks}. ");
         await callback(states.Count, states.Count, LoadingState.ProcessingFiles, false);
         return (checkPoints.ToArray(), serverTime);
     }
@@ -340,7 +363,7 @@ public sealed partial class ReplayLoadManager
 #if DEBUG
                 foreach (var state in modifiedState.ComponentChanges.Value)
                 {
-                    DebugTools.Assert(state.State is not IComponentDeltaState delta || delta.FullState);
+                    DebugTools.Assert(state.State is not IComponentDeltaState delta);
                 }
 #endif
                 continue;
@@ -353,7 +376,7 @@ public sealed partial class ReplayLoadManager
 #if DEBUG
             foreach (var state in entStates[entState.NetEntity].ComponentChanges.Span)
             {
-                DebugTools.Assert(state.State is not IComponentDeltaState delta || delta.FullState);
+                DebugTools.Assert(state.State is not IComponentDeltaState delta);
             }
 #endif
         }
@@ -384,20 +407,20 @@ public sealed partial class ReplayLoadManager
             if (!newCompStates.Remove(existing.NetID, out var newCompState))
                 continue;
 
-            if (newCompState.State is not IComponentDeltaState delta || delta.FullState)
+            if (newCompState.State is not IComponentDeltaState delta)
             {
                 combined[index] = newCompState;
                 continue;
             }
 
-            DebugTools.Assert(existing.State is IComponentDeltaState fullDelta && fullDelta.FullState);
-            combined[index] = new ComponentChange(existing.NetID, delta.CreateNewFullState(existing.State), newCompState.LastModifiedTick);
+            DebugTools.Assert(existing.State != null && existing.State is not IComponentDeltaState);
+            combined[index] = new ComponentChange(existing.NetID, delta.CreateNewFullState(existing.State!), newCompState.LastModifiedTick);
         }
 
         foreach (var compChange in newCompStates.Values)
         {
             // I'm not 100% sure about this, but I think delta states should always be full states here?
-            DebugTools.Assert(compChange.State is not IComponentDeltaState delta || delta.FullState);
+            DebugTools.Assert(compChange.State is not IComponentDeltaState delta);
             combined.Add(compChange);
         }
 

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

@@ -45,7 +45,7 @@ public sealed partial class ReplayLoadManager
                 continue;
 
             var state = _entMan.GetComponentState(_entMan.EventBus, component, null, GameTick.Zero);
-            DebugTools.Assert(state is not IComponentDeltaState delta || delta.FullState);
+            DebugTools.Assert(state is not IComponentDeltaState);
             list.Add(new ComponentChange(netId, state, GameTick.Zero));
             set.Add(netId);
         }
@@ -61,7 +61,7 @@ public sealed partial class ReplayLoadManager
         {
             if (comp.NetID == _metaId)
             {
-                var state = (MetaDataComponentState) comp.State;
+                var state = (MetaDataComponentState) comp.State!;
                 return state.PrototypeId;
             }
         }

Robust.Client/Replays/Loading/ReplayLoadManager.cs

@@ -34,6 +34,7 @@ public sealed partial class ReplayLoadManager : IReplayLoadManager
     private ushort _metaId;
     private bool _initialized;
     private int _checkpointInterval;
+    private int _checkpointMinInterval;
     private int _checkpointEntitySpawnThreshold;
     private int _checkpointEntityStateThreshold;
     private ISawmill _sawmill = default!;
@@ -45,6 +46,7 @@ public sealed partial class ReplayLoadManager : IReplayLoadManager
 
         _initialized = true;
         _confMan.OnValueChanged(CVars.CheckpointInterval, value => _checkpointInterval = value, true);
+        _confMan.OnValueChanged(CVars.CheckpointMinInterval, value => _checkpointMinInterval = value, true);
         _confMan.OnValueChanged(CVars.CheckpointEntitySpawnThreshold, value => _checkpointEntitySpawnThreshold = value,
             true);
         _confMan.OnValueChanged(CVars.CheckpointEntityStateThreshold, value => _checkpointEntityStateThreshold = value,

Robust.Client/Replays/Playback/ReplayPlaybackManager.Time.cs

@@ -41,12 +41,12 @@ internal sealed partial class ReplayPlaybackManager
             skipEffectEvents = true;
             ResetToNearestCheckpoint(value, false);
         }
-        else if (value > Replay.CurrentIndex + _checkpointInterval)
+        else if (value > Replay.CurrentIndex + _checkpointMinInterval)
         {
             // If we are skipping many ticks into the future, we try to skip directly to a checkpoint instead of
             // applying every tick.
             var nextCheckpoint = GetNextCheckpoint(Replay, Replay.CurrentIndex);
-            if (nextCheckpoint.Index < value)
+            if (nextCheckpoint.Index < value && nextCheckpoint.Index > Replay.CurrentIndex)
                 ResetToNearestCheckpoint(value, false);
         }
 

Robust.Client/Replays/Playback/ReplayPlaybackManager.cs

@@ -51,7 +51,7 @@ internal sealed partial class ReplayPlaybackManager : IReplayPlaybackManager
 
     public ReplayData? Replay { get; private set; }
     public NetUserId? Recorder => Replay?.Recorder;
-    private int _checkpointInterval;
+    private int _checkpointMinInterval;
     private int _visualEventThreshold;
     public uint? AutoPauseCountdown { get; set; }
     public int? ScrubbingTarget { get; set; }
@@ -93,7 +93,7 @@ internal sealed partial class ReplayPlaybackManager : IReplayPlaybackManager
         _initialized = true;
         _sawmill = _logMan.GetSawmill("replay");
         _metaId = _factory.GetRegistration(typeof(MetaDataComponent)).NetID!.Value;
-        _confMan.OnValueChanged(CVars.CheckpointInterval, (value) => _checkpointInterval = value, true);
+        _confMan.OnValueChanged(CVars.CheckpointMinInterval, (value) => _checkpointMinInterval = value, true);
         _confMan.OnValueChanged(CVars.ReplaySkipThreshold, (value) => _visualEventThreshold = value, true);
         _client.RunLevelChanged += OnRunLevelChanged;
     }

Robust.Client/UserInterface/Control.Layout.cs

@@ -52,6 +52,10 @@ namespace Robust.Client.UserInterface
         [ViewVariables] public bool IsMeasureValid { get; private set; }
         [ViewVariables] public bool IsArrangeValid { get; private set; }
 
+        /// <summary>
+        /// Controls the amount of empty space in virtual pixels around the control.
+        /// </summary>
+        /// <remarks>Values can be provided as "All" or "Horizontal, Vertical" or "Left, Top, Right, Bottom"</remarks>
         [ViewVariables]
         public Thickness Margin
         {

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

@@ -130,7 +130,7 @@ public sealed class TileSpawningUIController : UIController
 
         _window.TileList.Clear();
 
-        IEnumerable<ITileDefinition> tileDefs = _tiles;
+        IEnumerable<ITileDefinition> tileDefs = _tiles.Where(def => !def.EditorHidden);
 
         if (!string.IsNullOrEmpty(searchStr))
         {

Robust.Client/UserInterface/Controls/LineEdit.cs

@@ -53,7 +53,7 @@ namespace Robust.Client.UserInterface.Controls
         private TimeSpan? _lastClickTime;
         private Vector2? _lastClickPosition;
 
-        private bool IsPlaceHolderVisible => string.IsNullOrEmpty(_text) && _placeHolder != null;
+        private bool IsPlaceHolderVisible => !(HidePlaceHolderOnFocus && HasKeyboardFocus()) && string.IsNullOrEmpty(_text) && _placeHolder != null;
 
         public event Action<LineEditEventArgs>? OnTextChanged;
         public event Action<LineEditEventArgs>? OnTextEntered;
@@ -186,6 +186,8 @@ namespace Robust.Client.UserInterface.Controls
         public int SelectionLower => Math.Min(_selectionStart, _cursorPosition);
         public int SelectionUpper => Math.Max(_selectionStart, _cursorPosition);
 
+        public bool HidePlaceHolderOnFocus { get; set; }
+
         public bool IgnoreNext { get; set; }
 
         private (int start, int length)? _imeData;

Robust.Client/UserInterface/DummyFileDialogManager.cs

@@ -13,7 +13,7 @@ namespace Robust.Client.UserInterface
             return Task.FromResult<Stream?>(null);
         }
 
-        public Task<(Stream fileStream, bool alreadyExisted)?> SaveFile(FileDialogFilters? filters = null)
+        public Task<(Stream fileStream, bool alreadyExisted)?> SaveFile(FileDialogFilters? filters = null, bool truncate = true)
         {
             return Task.FromResult<(Stream fileStream, bool alreadyExisted)?>(null);
         }

Robust.Client/UserInterface/FileDialogManager.cs

@@ -51,7 +51,7 @@ namespace Robust.Client.UserInterface
             return await OpenFileNfd(filters);
         }
 
-        public async Task<(Stream, bool)?> SaveFile(FileDialogFilters? filters)
+        public async Task<(Stream, bool)?> SaveFile(FileDialogFilters? filters, bool truncate = true)
         {
             var name = await GetSaveFileName(filters);
             if (name == null)
@@ -61,7 +61,7 @@ namespace Robust.Client.UserInterface
 
             try
             {
-                return (File.Open(name, FileMode.Open), true);
+                return (File.Open(name, truncate ? FileMode.Truncate : FileMode.Open), true);
             }
             catch (FileNotFoundException)
             {

Robust.Client/UserInterface/IFileDialogManager.cs

@@ -28,6 +28,7 @@ namespace Robust.Client.UserInterface
         /// The file stream the user chose to save to, and whether the file already existed.
         /// Null if the user cancelled the action.
         /// </returns>
-        Task<(Stream fileStream, bool alreadyExisted)?> SaveFile(FileDialogFilters? filters = null);
+        /// <param name="truncate">Should we truncate an existing file to 0-size then write or append.</param>
+        Task<(Stream fileStream, bool alreadyExisted)?> SaveFile(FileDialogFilters? filters = null, bool truncate = true);
     }
 }

Robust.Client/UserInterface/IUserInterfaceManager.cs

@@ -135,6 +135,17 @@ namespace Robust.Client.UserInterface
         /// Plays the UI hover sound if relevant.
         /// </summary>
         void HoverSound();
+
+        /// <summary>
+        /// Sets <see cref="CurrentlyHovered"/> to the given control.
+        /// </summary>
+        void SetHovered(Control? control);
+
+        /// <summary>
+        /// Forces <see cref="CurrentlyHovered"/> to get updated. This is done automatically when the mouse is moved,
+        /// but not necessarily a new or existing control is rearranged.
+        /// </summary>
+        void UpdateHovered();
     }
 
     public readonly struct PostDrawUIRootEventArgs

Robust.Client/UserInterface/UserInterfaceManager.Input.cs

@@ -9,6 +9,7 @@ using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.Input;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
+using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.UserInterface;
@@ -20,9 +21,10 @@ internal partial class UserInterfaceManager
     private bool _needUpdateActiveCursor;
     [ViewVariables] public Control? KeyboardFocused { get; private set; }
 
-    [ViewVariables] public Control? CurrentlyHovered { get; private set; } = default!;
+    [ViewVariables] public Control? CurrentlyHovered { get; private set; }
 
     private Control? _controlFocused;
+
     [ViewVariables]
     public Control? ControlFocused
     {
@@ -100,6 +102,7 @@ internal partial class UserInterfaceManager
             return;
         }
 
+
         var guiArgs = new GUIBoundKeyEventArgs(args.Function, args.State, args.PointerLocation, args.CanFocus,
             args.PointerLocation.Position / control.UIScale - control.GlobalPosition,
             args.PointerLocation.Position - control.GlobalPixelPosition);
@@ -111,16 +114,20 @@ internal partial class UserInterfaceManager
             args.Handle();
         }
 
+        // Attempt to ensure that keybind-up events get raised after a keybind-down.
+        DebugTools.Assert(!_focusedControls.TryGetValue(args.Function, out var existing)
+                          || !existing.VisibleInTree
+                          || args.IsRepeat && existing == control);
         _focusedControls[args.Function] = control;
+
         OnKeyBindDown?.Invoke(control);
     }
 
     public void KeyBindUp(BoundKeyEventArgs args)
     {
-        if (!_focusedControls.TryGetValue(args.Function, out var control))
-        {
+        // Only raise keybind-up for the control on which we previously raised keybind-down
+        if (!_focusedControls.Remove(args.Function, out var control) || !control.VisibleInTree)
             return;
-        }
 
         var guiArgs = new GUIBoundKeyEventArgs(args.Function, args.State, args.PointerLocation, args.CanFocus,
             args.PointerLocation.Position / control.UIScale - control.GlobalPosition,
@@ -131,7 +138,6 @@ internal partial class UserInterfaceManager
         // Always mark this as handled.
         // The only case it should not be is if we do not have a control to click on,
         // in which case we never reach this.
-        _focusedControls.Remove(args.Function);
         args.Handle();
     }
 
@@ -140,23 +146,7 @@ internal partial class UserInterfaceManager
         _resetTooltipTimer();
         // Update which control is considered hovered.
         var newHovered = MouseGetControl(mouseMoveEventArgs.Position);
-        if (newHovered != CurrentlyHovered)
-        {
-            _clearTooltip();
-            CurrentlyHovered?.MouseExited();
-            CurrentlyHovered = newHovered;
-            CurrentlyHovered?.MouseEntered();
-            if (CurrentlyHovered != null)
-            {
-                _tooltipDelay = CurrentlyHovered.TooltipDelay ?? TooltipDelay;
-            }
-            else
-            {
-                _tooltipDelay = null;
-            }
-
-            _needUpdateActiveCursor = true;
-        }
+        SetHovered(newHovered);
 
         var target = ControlFocused ?? newHovered;
         if (target != null)
@@ -172,6 +162,33 @@ internal partial class UserInterfaceManager
         }
     }
 
+    public void UpdateHovered()
+    {
+        var ctrl =  MouseGetControl(_inputManager.MouseScreenPosition);
+        SetHovered(ctrl);
+    }
+
+    public void SetHovered(Control? control)
+    {
+        if (control == CurrentlyHovered)
+            return;
+
+        _clearTooltip();
+        CurrentlyHovered?.MouseExited();
+        CurrentlyHovered = control;
+        CurrentlyHovered?.MouseEntered();
+        if (CurrentlyHovered != null)
+        {
+            _tooltipDelay = CurrentlyHovered.TooltipDelay ?? TooltipDelay;
+        }
+        else
+        {
+            _tooltipDelay = null;
+        }
+
+        _needUpdateActiveCursor = true;
+    }
+
     private void UpdateActiveCursor()
     {
         // Consider mouse input focus first so that dragging windows don't act up etc.

Robust.Client/UserInterface/UserInterfaceManager.Layout.cs

@@ -77,15 +77,12 @@ internal sealed partial class UserInterfaceManager
 
             ReleaseKeyboardFocus(control);
             RemoveModal(control);
-            if (control == CurrentlyHovered)
-            {
-                control.MouseExited();
-                CurrentlyHovered = null;
-                _clearTooltip();
-            }
 
-            if (control != ControlFocused) return;
-            ControlFocused = null;
+            if (control == ControlFocused)
+                ControlFocused = null;
+
+            if (control == CurrentlyHovered)
+                UpdateHovered();
         }
 
         public void PushModal(Control modal)

Robust.Roslyn.Shared/Diagnostics.cs

@@ -29,6 +29,8 @@ public static class Diagnostics
     public const string IdComponentPauseNoParentAttribute = "RA0023";
     public const string IdComponentPauseWrongTypeAttribute = "RA0024";
     public const string IdDependencyFieldAssigned = "RA0025";
+    public const string IdUncachedRegex = "RA0026";
+    public const string IdDataFieldRedundantTag = "RA0027";
 
     public static SuppressionDescriptor MeansImplicitAssignment =>
         new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");

Robust.Serialization.Generator/Generator.cs

@@ -1,6 +1,4 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+using System.Text;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -36,6 +34,7 @@ public class Generator : IIncrementalGenerator
                 var (compilation, declarations) = source;
                 var builder = new StringBuilder();
                 var containingTypes = new Stack<INamedTypeSymbol>();
+                var declarationsGenerated = new HashSet<string>();
 
                 foreach (var declaration in declarations)
                 {
@@ -44,6 +43,14 @@ public class Generator : IIncrementalGenerator
 
                     var type = compilation.GetSemanticModel(declaration.SyntaxTree).GetDeclaredSymbol(declaration)!;
 
+                    var symbolName = type
+                        .ToDisplayString()
+                        .Replace('<', '{')
+                        .Replace('>', '}');
+
+                    if (!declarationsGenerated.Add(symbolName))
+                        continue;
+
                     var nonPartial = !IsPartial(declaration);
 
                     var namespaceString = type.ContainingNamespace.IsGlobalNamespace
@@ -107,11 +114,6 @@ using Robust.Shared.Serialization.TypeSerializers.Interfaces;
 {{containingTypesEnd}}
 """);
 
-                    var symbolName = type
-                        .ToDisplayString()
-                        .Replace('<', '{')
-                        .Replace('>', '}');
-
                     var sourceText = CSharpSyntaxTree
                         .ParseText(builder.ToString())
                         .GetRoot()

Robust.Server/Audio/AudioSystem.cs

@@ -42,6 +42,17 @@ public sealed partial class AudioSystem : SharedAudioSystem
         component.Source = new DummyAudioSource();
     }
 
+    public override void SetMapAudio(Entity<AudioComponent>? audio)
+    {
+        if (audio == null)
+            return;
+
+        base.SetMapAudio(audio);
+
+        // Also need a global override because clients not near 0,0 won't get the audio.
+        _pvs.AddGlobalOverride(audio.Value);
+    }
+
     private void AddAudioFilter(EntityUid uid, AudioComponent component, Filter filter)
     {
         var count = filter.Count;

Robust.Server/GameStates/PvsData.cs

@@ -51,10 +51,15 @@ internal sealed class PvsSession(ICommonSession session, ResizableMemoryRegion<P
     public (GameTick ToTick, List<PvsIndex> PreviouslySent)? LastSent;
 
     /// <summary>
-    /// Visible chunks, sorted by proximity to the clients's viewers;
+    /// Visible chunks, sorted by proximity to the client's viewers.
     /// </summary>
     public readonly List<(PvsChunk Chunk, float ChebyshevDistance)> Chunks = new();
 
+    /// <summary>
+    /// Unsorted set of visible chunks. Used to construct the <see cref="Chunks"/> list.
+    /// </summary>
+    public readonly HashSet<PvsChunk> ChunkSet = new();
+
     /// <summary>
     /// Squared distance ta all of the visible chunks.
     /// </summary>
@@ -117,6 +122,7 @@ internal sealed class PvsSession(ICommonSession session, ResizableMemoryRegion<P
     {
         PlayerStates.Clear();
         Chunks.Clear();
+        ChunkSet.Clear();
         States.Clear();
         State = null;
     }

Robust.Server/GameStates/PvsSystem.Chunks.cs

@@ -90,15 +90,13 @@ internal sealed partial class PvsSystem
         foreach (var session in _sessions)
         {
             session.Chunks.Clear();
+            session.ChunkSet.Clear();
             GetSessionViewers(session);
 
             foreach (var eye in session.Viewers)
             {
-                GetVisibleChunks(eye, session.Chunks);
+                GetVisibleChunks(eye, session.ChunkSet);
             }
-
-            // The list of visible chunks should be unique.
-            DebugTools.Assert(session.Chunks.Select(x => x.Chunk).ToHashSet().Count == session.Chunks.Count);
         }
         DebugTools.Assert(_dirtyChunks.ToHashSet().Count == _dirtyChunks.Count);
         DebugTools.Assert(_cleanChunks.ToHashSet().Count == _cleanChunks.Count);
@@ -108,7 +106,7 @@ internal sealed partial class PvsSystem
     /// Get the chunks visible to a single entity and add them to a player's set of visible chunks.
     /// </summary>
     private void GetVisibleChunks(Entity<TransformComponent, EyeComponent?> eye,
-        List<(PvsChunk Chunk, float ChebyshevDistance)> playerChunks)
+        HashSet<PvsChunk> chunks)
     {
         var (viewPos, range, mapUid) = CalcViewBounds(eye);
         if (mapUid is not {} map)
@@ -121,7 +119,7 @@ internal sealed partial class PvsSystem
             if (!_chunks.TryGetValue(loc, out var chunk))
                 continue;
 
-            playerChunks.Add((chunk, default));
+            chunks.Add(chunk);
             if (chunk.UpdateQueued)
                 continue;
 
@@ -147,7 +145,7 @@ internal sealed partial class PvsSystem
                 if (!_chunks.TryGetValue(loc, out var chunk))
                     continue;
 
-                playerChunks.Add((chunk, default));
+                chunks.Add(chunk);
                 if (chunk.UpdateQueued)
                     continue;
 

Robust.Server/GameStates/PvsSystem.Entity.cs

@@ -55,13 +55,10 @@ internal sealed partial class PvsSystem
             return;
         }
 
-        var root = (xform.GridUid ?? xform.MapUid);
-        DebugTools.AssertNotNull(root);
-
-        if (xform.ParentUid != root)
+        if (xform.ParentUid != xform.GridUid && xform.ParentUid != xform.MapUid)
             return;
 
-        var location = new PvsChunkLocation(root.Value, GetChunkIndices(xform._localPosition));
+        var location = new PvsChunkLocation(xform.ParentUid, GetChunkIndices(xform._localPosition));
         if (meta.LastPvsLocation == location)
             return;
 

Robust.Server/GameStates/PvsSystem.GetStates.cs

@@ -50,9 +50,11 @@ internal sealed partial class PvsSystem
                 continue;
 
             var state = EntityManager.GetComponentState(bus, component, player, fromTick);
-            DebugTools.Assert(fromTick > component.CreationTick || state is not IComponentDeltaState delta || delta.FullState);
             changed.Add(new ComponentChange(netId, state, component.LastModifiedTick));
 
+            if (state != null)
+                DebugTools.Assert(fromTick > component.CreationTick || state is not IComponentDeltaState);
+
             if (sendCompList)
                 netComps!.Add(netId);
         }
@@ -85,7 +87,7 @@ internal sealed partial class PvsSystem
                 continue;
 
             var state = EntityManager.GetComponentState(bus, component, player, GameTick.Zero);
-            DebugTools.Assert(state is not IComponentDeltaState delta || delta.FullState);
+            DebugTools.Assert(state is not IComponentDeltaState);
             changed.Add(new ComponentChange(netId, state, component.LastModifiedTick));
             netComps.Add(netId);
         }

Robust.Server/GameStates/PvsSystem.Session.cs

@@ -137,15 +137,19 @@ internal sealed partial class PvsSystem
         if (!CullingEnabled || session.DisableCulling)
             return;
 
+        var chunkSet = session.ChunkSet;
         var chunks = session.Chunks;
         var distances = session.ChunkDistanceSq;
+
+        DebugTools.AssertEqual(chunks.Count, 0);
+
         distances.Clear();
-        distances.EnsureCapacity(chunks.Count);
+        distances.EnsureCapacity(chunkSet.Count);
+        chunks.EnsureCapacity(chunkSet.Count);
 
         // Assemble list of chunks and their distances to the nearest eye.
-        foreach (ref var tuple in CollectionsMarshal.AsSpan(chunks))
+        foreach(var chunk in chunkSet)
         {
-            var chunk = tuple.Chunk;
             var dist = float.MaxValue;
             var chebDist = float.MaxValue;
 
@@ -165,7 +169,7 @@ internal sealed partial class PvsSystem
             }
 
             distances.Add(dist);
-            tuple.ChebyshevDistance = chebDist;
+            chunks.Add((chunk, chebDist));
         }
 
         // Sort chunks based on distances

Robust.Server/GameStates/PvsSystem.cs

@@ -134,7 +134,7 @@ internal sealed partial class PvsSystem : EntitySystem
         SubscribeLocalEvent<TransformComponent, TransformStartupEvent>(OnTransformStartup);
 
         _playerManager.PlayerStatusChanged += OnPlayerStatusChanged;
-        _transform.OnGlobalMoveEvent += OnEntityMove;
+        _transform.OnBeforeMoveEvent += OnEntityMove;
         EntityManager.EntityAdded += OnEntityAdded;
         EntityManager.EntityDeleted += OnEntityDeleted;
         EntityManager.AfterEntityFlush += AfterEntityFlush;
@@ -159,7 +159,7 @@ internal sealed partial class PvsSystem : EntitySystem
         base.Shutdown();
 
         _playerManager.PlayerStatusChanged -= OnPlayerStatusChanged;
-        _transform.OnGlobalMoveEvent -= OnEntityMove;
+        _transform.OnBeforeMoveEvent -= OnEntityMove;
         EntityManager.EntityAdded -= OnEntityAdded;
         EntityManager.EntityDeleted -= OnEntityDeleted;
         EntityManager.AfterEntityFlush -= AfterEntityFlush;

Robust.Server/Robust.Server.csproj

@@ -43,6 +43,9 @@
     <Content Include="server_config.toml">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="run_server.bat">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <EmbeddedResource Include="ExtraMappedSerializerStrings.txt">
       <LogicalName>Robust.Server.ExtraMappedSerializerStrings.txt</LogicalName>
     </EmbeddedResource>

Robust.Server/ServerStatus/WatchdogApi.cs

@@ -68,7 +68,7 @@ namespace Robust.Server.ServerStatus
             if (auth != _watchdogToken)
             {
                 // Holy shit nobody read these logs please.
-                _sawmill.Info(@"Failed auth: ""{0}"" vs ""{1}""", auth, _watchdogToken);
+                _sawmill.Verbose(@"Failed auth: ""{0}"" vs ""{1}""", auth, _watchdogToken);
                 await context.RespondErrorAsync(HttpStatusCode.Unauthorized);
                 return true;
             }
@@ -105,7 +105,7 @@ namespace Robust.Server.ServerStatus
 
             if (auth != _watchdogToken)
             {
-                _sawmill.Warning(
+                _sawmill.Verbose(
                     "received POST /shutdown with invalid authentication token. Ignoring {0}, {1}", auth,
                     _watchdogToken);
                 await context.RespondErrorAsync(HttpStatusCode.Unauthorized);

Robust.Server/run_server.bat

@@ -0,0 +1,2 @@
+Robust.Server.exe
+pause

Robust.Server/server_config.toml

@@ -52,7 +52,7 @@ tags = ""
 # Must be in the form of an ss14:// or ss14s:// URI pointing to the status API.
 server_url = ""
 # Comma-separated list of URLs of hub servers to advertise to.
-hub_urls = "https://central.spacestation14.io/hub/"
+hub_urls = "https://hub.spacestation14.com/"
 
 [build]
 # *Absolutely all of these can be supplied using a "build.json" file*
@@ -98,5 +98,5 @@ hub_urls = "https://central.spacestation14.io/hub/"
 
 # You should probably never EVER need to touch this, but if you need a custom auth server,
 # (the auth server being the one which manages Space Station 14 accounts), you change it here.
-# server = https://central.spacestation14.io/auth/
+# server = https://auth.spacestation14.com/
 

Robust.Shared/Audio/Systems/SharedAudioSystem.cs

@@ -8,6 +8,7 @@ using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
 using Robust.Shared.Network;
 using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
@@ -32,11 +33,12 @@ public abstract partial class SharedAudioSystem : EntitySystem
     [Dependency] private   readonly INetManager _netManager = default!;
     [Dependency] protected readonly IPrototypeManager ProtoMan = default!;
     [Dependency] protected readonly IRobustRandom RandMan = default!;
+    [Dependency] protected readonly MetaDataSystem MetadataSys = default!;
 
     /// <summary>
     /// Default max range at which the sound can be heard.
     /// </summary>
-    public const float DefaultSoundRange = 20;
+    public const float DefaultSoundRange = 15;
 
     /// <summary>
     /// Used in the PAS to designate the physics collision mask of occluders.
@@ -131,6 +133,18 @@ public abstract partial class SharedAudioSystem : EntitySystem
         return (float) (Timing.CurTime - (component.PauseTime ?? TimeSpan.Zero) - component.AudioStart).TotalSeconds;
     }
 
+    /// <summary>
+    /// Marks this audio as being map-based.
+    /// </summary>
+    public virtual void SetMapAudio(Entity<AudioComponent>? audio)
+    {
+        if (audio == null)
+            return;
+
+        audio.Value.Comp.Global = true;
+        MetadataSys.AddFlag(audio.Value.Owner, MetaDataFlags.Undetachable);
+    }
+
     /// <summary>
     /// Sets the shared state for an audio entity.
     /// </summary>

Robust.Shared/CVars.cs

@@ -368,6 +368,21 @@ namespace Robust.Shared
         public static readonly CVarDef<float> NetHappyEyeballsDelay =
             CVarDef.Create("net.happy_eyeballs_delay", 0.025f, CVar.CLIENTONLY);
 
+        /// <summary>
+        /// Controls whether the networking library will log warning messages.
+        /// </summary>
+        /// <remarks>
+        /// Disabling this should make the networking layer more resilient against some DDoS attacks.
+        /// </remarks>
+        public static readonly CVarDef<bool> NetLidgrenLogWarning =
+            CVarDef.Create("net.lidgren_log_warning", true);
+
+        /// <summary>
+        /// Controls whether the networking library will log error messages.
+        /// </summary>
+        public static readonly CVarDef<bool> NetLidgrenLogError =
+            CVarDef.Create("net.lidgren_log_error", true);
+
         /**
          * SUS
          */
@@ -884,7 +899,7 @@ namespace Robust.Shared
             CVarDef.Create("render.sprite_direction_bias", -0.05, CVar.ARCHIVE | CVar.CLIENTONLY);
 
         public static readonly CVarDef<string> RenderFOVColor =
-            CVarDef.Create("render.fov_color", Color.Black.ToHex(), CVar.ARCHIVE | CVar.CLIENTONLY);
+            CVarDef.Create("render.fov_color", Color.Black.ToHex(), CVar.REPLICATED | CVar.SERVER);
 
         /*
          *  CONTROLS
@@ -1632,15 +1647,20 @@ namespace Robust.Shared
         /// </summary>
         public static readonly CVarDef<int> ReplaySkipThreshold = CVarDef.Create("replay.skip_threshold", 30);
 
+        /// <summary>
+        /// Minimum number of ticks before a new checkpoint tick is generated (overrides SpawnThreshold and StateThreshold)
+        /// </summary>
+        public static readonly CVarDef<int> CheckpointMinInterval = CVarDef.Create("replay.checkpoint_min_interval", 60);
+
         /// <summary>
         /// Maximum number of ticks before a new checkpoint tick is generated.
         /// </summary>
-        public static readonly CVarDef<int> CheckpointInterval = CVarDef.Create("replay.checkpoint_interval", 200);
+        public static readonly CVarDef<int> CheckpointInterval = CVarDef.Create("replay.checkpoint_interval", 500);
 
         /// <summary>
         /// Maximum number of entities that can be spawned before a new checkpoint tick is generated.
         /// </summary>
-        public static readonly CVarDef<int> CheckpointEntitySpawnThreshold = CVarDef.Create("replay.checkpoint_entity_spawn_threshold", 100);
+        public static readonly CVarDef<int> CheckpointEntitySpawnThreshold = CVarDef.Create("replay.checkpoint_entity_spawn_threshold", 1000);
 
         /// <summary>
         /// Maximum number of entity states that can be applied before a new checkpoint tick is generated.

Robust.Shared/Collections/ValueList.cs

@@ -294,6 +294,9 @@ public struct ValueList<T> : IEnumerable<T>
         if (Capacity < capacity)
             Grow(capacity);
 
+        if (capacity == 0)
+            return capacity;
+
         return _items!.Length;
     }
 

Robust.Shared/ComponentTrees/ComponentTreeSystem.cs

@@ -71,6 +71,8 @@ public abstract class ComponentTreeSystem<TTreeComp, TComp> : EntitySystem
         }
         else
         {
+            // TODO EXCEPTION TOLERANCE
+            // Ensure lookup trees update before content code handles move events.
             SubscribeLocalEvent<TComp, MoveEvent>(HandleMove);
         }
 

Robust.Shared/ComponentTrees/RecursiveMoveSystem.cs

@@ -33,7 +33,7 @@ internal sealed class RecursiveMoveSystem : EntitySystem
     public override void Shutdown()
     {
         if (_subscribed)
-            _transform.OnGlobalMoveEvent -= AnythingMoved;
+            _transform.OnBeforeMoveEvent -= AnythingMoved;
 
         _subscribed = false;
     }
@@ -44,7 +44,7 @@ internal sealed class RecursiveMoveSystem : EntitySystem
             return;
 
         _subscribed = true;
-        _transform.OnGlobalMoveEvent += AnythingMoved;
+        _transform.OnBeforeMoveEvent += AnythingMoved;
     }
 
     private void AnythingMoved(ref MoveEvent args)

Robust.Shared/Configuration/ConfigurationManager.cs

@@ -32,6 +32,8 @@ namespace Robust.Shared.Configuration
 
         private ISawmill _sawmill = default!;
 
+        public event Action<CVarChangeInfo>? OnCVarValueChanged;
+
         /// <summary>
         ///     Constructs a new ConfigurationManager.
         /// </summary>
@@ -94,15 +96,15 @@ namespace Robust.Shared.Configuration
             if (_configVars.TryGetValue(cvar, out var cfgVar))
             {
                 // overwrite the value with the saved one
+                var oldValue = GetConfigVarValue(cfgVar);
+                changedInvokes.Add(SetupInvokeValueChanged(cfgVar, value, oldValue));
                 cfgVar.Value = value;
-                if (SetupInvokeValueChanged(cfgVar, value) is { } invoke)
-                    changedInvokes.Add(invoke);
             }
             else
             {
                 //or add another unregistered CVar
-                //Note: the defaultValue is arbitrarily 0, it will get overwritten when the cvar is registered.
-                cfgVar = new ConfigVar(cvar, 0, CVar.NONE) { Value = value };
+                //Note: the initial defaultValue is null, but it will get overwritten when the cvar is registered.
+                cfgVar = new ConfigVar(cvar, null!, CVar.NONE) { Value = value };
                 _configVars.Add(cvar, cfgVar);
             }
 
@@ -127,26 +129,26 @@ namespace Robust.Shared.Configuration
                     }
 
                     var convertedValue = value;
-                    if (!cVar.DefaultValue.GetType().IsEnum && cVar.DefaultValue.GetType() != value.GetType())
+                    if (cVar.Type != value.GetType())
                     {
                         try
                         {
-                            convertedValue = ConvertToCVarType(value, cVar.DefaultValue.GetType());
+                            convertedValue = ConvertToCVarType(value, cVar.Type!);
                         }
                         catch
                         {
-                            _sawmill.Error($"Override TOML parsed cvar does not match registered cvar type. Name: {cVarName}. Code Type: {cVar.DefaultValue.GetType()}. Toml type: {value.GetType()}");
+                            _sawmill.Error($"Override TOML parsed cvar does not match registered cvar type. Name: {cVarName}. Code Type: {cVar.Type}. Toml type: {value.GetType()}");
                             continue;
                         }
                     }
 
-                    cVar.DefaultValue = value;
-
                     if (cVar.OverrideValue == null && cVar.Value == null)
                     {
-                        if (SetupInvokeValueChanged(cVar, convertedValue) is { } invoke)
-                            callbackEvents.Add(invoke);
+                        var oldValue = GetConfigVarValue(cVar);
+                        callbackEvents.Add(SetupInvokeValueChanged(cVar, convertedValue, oldValue));
                     }
+
+                    cVar.DefaultValue = convertedValue;
                 }
             }
 
@@ -317,6 +319,7 @@ namespace Robust.Shared.Configuration
 
         private void RegisterCVar(string name, Type type, object defaultValue, CVar flags)
         {
+            DebugTools.AssertEqual(defaultValue.GetType(), type);
             DebugTools.Assert(!type.IsEnum || type.GetEnumUnderlyingType() == typeof(int),
                 $"{name}: Enum cvars must have int as underlying type.");
 
@@ -335,7 +338,7 @@ namespace Robust.Shared.Configuration
                 if (cVar.Registered)
                     _sawmill.Error($"The variable '{name}' has already been registered.");
 
-                if (!type.IsEnum && cVar.Value != null && !type.IsAssignableFrom(cVar.Value.GetType()))
+                if (cVar.Value != null && type != cVar.Value.GetType())
                 {
                     try
                     {
@@ -350,7 +353,7 @@ namespace Robust.Shared.Configuration
 
                 cVar.DefaultValue = defaultValue;
                 cVar.Flags = flags;
-                cVar.Registered = true;
+                cVar.Register();
 
                 if (cVar.OverrideValue != null)
                 {
@@ -360,10 +363,9 @@ namespace Robust.Shared.Configuration
                 return;
             }
 
-            _configVars.Add(name, new ConfigVar(name, defaultValue, flags)
-            {
-                Registered = true
-            });
+            var cvar = new ConfigVar(name, defaultValue, flags);
+            cvar.Register();
+            _configVars.Add(name, cvar);
         }
 
         public void OnValueChanged<T>(CVarDef<T> cVar, Action<T> onValueChanged, bool invokeImmediately = false)
@@ -412,10 +414,11 @@ namespace Robust.Shared.Configuration
         public void OnValueChanged<T>(string name, CVarChanged<T> onValueChanged, bool invokeImmediately = false)
             where T : notnull
         {
+            object value;
             using (Lock.WriteGuard())
             {
                 var reg = _configVars[name];
-
+                value = GetConfigVarValue(reg);
                 reg.ValueChanged.AddInPlace(
                     (object value, in CVarChangeInfo info) => onValueChanged((T)value, info),
                     onValueChanged);
@@ -423,7 +426,7 @@ namespace Robust.Shared.Configuration
 
             if (invokeImmediately)
             {
-                onValueChanged(GetCVar<T>(name), new CVarChangeInfo(_gameTiming.CurTick));
+                onValueChanged(GetCVar<T>(name), new CVarChangeInfo(name, _gameTiming.CurTick, value, value));
             }
         }
 
@@ -512,12 +515,13 @@ namespace Robust.Shared.Configuration
                 {
                     if (!Equals(cVar.OverrideValueParsed ?? cVar.Value, value))
                     {
+                        var oldValue = GetConfigVarValue(cVar);
+                        invoke = SetupInvokeValueChanged(cVar, value, oldValue, intendedTick);
+
                         // Setting an overriden var just turns off the override, basically.
                         cVar.OverrideValue = null;
                         cVar.OverrideValueParsed = null;
-
                         cVar.Value = value;
-                        invoke = SetupInvokeValueChanged(cVar, value, intendedTick);
                     }
                 }
                 else
@@ -543,10 +547,14 @@ namespace Robust.Shared.Configuration
                 if (!_configVars.TryGetValue(name, out var cVar) || !cVar.Registered)
                     throw new InvalidConfigurationException($"Trying to set unregistered variable '{name}'");
 
+                if (cVar.OverrideValue == null && cVar.Value == null)
+                {
+                    var oldValue = GetConfigVarValue(cVar);
+                    invoke = SetupInvokeValueChanged(cVar, value, oldValue);
+                }
+
                 cVar.DefaultValue = value;
 
-                if (cVar.OverrideValue == null && cVar.Value == null)
-                    invoke = SetupInvokeValueChanged(cVar, value);
             }
 
             if (invoke != null)
@@ -587,7 +595,7 @@ namespace Robust.Shared.Configuration
             }
 
             // If it's null it's a string, since the rest is primitives which aren't null.
-            return cVar.DefaultValue.GetType();
+            return cVar.Type!;
         }
 
         protected static object GetConfigVarValue(ConfigVar cVar)
@@ -606,18 +614,19 @@ namespace Robust.Shared.Configuration
                     if (_configVars.TryGetValue(key, out var cfgVar))
                     {
                         cfgVar.OverrideValue = value;
-                        if (cfgVar.Registered)
-                        {
-                            cfgVar.OverrideValueParsed = ParseOverrideValue(value, cfgVar.DefaultValue?.GetType());
-                            if (SetupInvokeValueChanged(cfgVar, cfgVar.OverrideValueParsed) is { } invoke)
-                                invokes.Add(invoke);
-                        }
+                        if (!cfgVar.Registered)
+                            continue;
+
+                        var newValue = ParseOverrideValue(value, cfgVar.Type!);
+                        var oldValue = GetConfigVarValue(cfgVar);
+                        invokes.Add(SetupInvokeValueChanged(cfgVar, newValue, oldValue));
+                        cfgVar.OverrideValueParsed = newValue;
                     }
                     else
                     {
                         //or add another unregistered CVar
-                        //Note: the defaultValue is arbitrarily 0, it will get overwritten when the cvar is registered.
-                        var cVar = new ConfigVar(key, 0, CVar.NONE) { OverrideValue = value };
+                        //Note: the initial defaultValue is null, but it will get overwritten when the cvar is registered.
+                        var cVar = new ConfigVar(key, null!, CVar.NONE) { OverrideValue = value };
                         _configVars.Add(key, cVar);
                     }
                 }
@@ -696,25 +705,20 @@ namespace Robust.Shared.Configuration
             }
         }
 
-        private static void InvokeValueChanged(in ValueChangedInvoke invoke)
+        private void InvokeValueChanged(in ValueChangedInvoke invoke)
         {
+            OnCVarValueChanged?.Invoke(invoke.Info);
             foreach (var entry in invoke.Invoke.Entries)
             {
                 entry.Value!.Invoke(invoke.Value, in invoke.Info);
             }
         }
 
-        private ValueChangedInvoke? SetupInvokeValueChanged(ConfigVar var, object value, GameTick? tick = null)
+        private ValueChangedInvoke SetupInvokeValueChanged(ConfigVar var, object newValue, object oldValue, GameTick? tick = null)
         {
-            if (var.ValueChanged.Count == 0)
-                return null;
-
-            return new ValueChangedInvoke
-            {
-                Info = new CVarChangeInfo(tick ?? _gameTiming.CurTick),
-                Invoke = var.ValueChanged,
-                Value = value
-            };
+            tick ??= _gameTiming.CurTick;
+            var info = new CVarChangeInfo(var.Name, tick.Value, newValue, oldValue);
+            return new ValueChangedInvoke(info, var.ValueChanged);
         }
 
         private IEnumerable<(string cvar, object value)> ParseCVarValuesFromToml(Stream stream)
@@ -767,6 +771,9 @@ namespace Robust.Shared.Configuration
         /// <returns></returns>
         private static object ConvertToCVarType(object value, Type cVar)
         {
+            if (cVar.IsEnum)
+                return Enum.Parse(cVar, value.ToString() ?? string.Empty);
+
             return Convert.ChangeType(value, cVar);
         }
 
@@ -786,10 +793,15 @@ namespace Robust.Shared.Configuration
             public ConfigVar(string name, object defaultValue, CVar flags)
             {
                 Name = name;
-                DefaultValue = defaultValue;
                 Flags = flags;
+                _defaultValue = defaultValue;
             }
 
+            /// <summary>
+            ///     The type of the cvar's value. This may be null until the cvar is registered.
+            /// </summary>
+            public Type? Type { get; internal set; }
+
             /// <summary>
             ///     The name of the CVar.
             /// </summary>
@@ -798,7 +810,16 @@ namespace Robust.Shared.Configuration
             /// <summary>
             ///     The default value of this CVar.
             /// </summary>
-            public object DefaultValue { get; set; }
+            public object DefaultValue
+            {
+                get => _defaultValue;
+                set
+                {
+                    if (Registered)
+                        DebugTools.AssertEqual(value.GetType(), Type);
+                    _defaultValue = value;
+                }
+            }
 
             /// <summary>
             ///     Optional flags to modify the behavior of this CVar.
@@ -808,12 +829,45 @@ namespace Robust.Shared.Configuration
             /// <summary>
             ///     The current value of this CVar.
             /// </summary>
-            public object? Value { get; set; }
+            public object? Value
+            {
+                get => _value;
+                set
+                {
+                    if (value != null && Registered)
+                        DebugTools.AssertEqual(value.GetType(), Type);
+                    _value = value;
+                }
+            }
 
             /// <summary>
             ///     Has this CVar been registered in code?
             /// </summary>
-            public bool Registered { get; set; }
+            public bool Registered { get; private set; }
+
+            public void Register()
+            {
+                if (Registered)
+                {
+                    DebugTools.AssertNotNull(DefaultValue);
+                    DebugTools.AssertEqual(DefaultValue.GetType(), Type);
+                    DebugTools.Assert(Value == null || Value.GetType() == Type);
+                    DebugTools.Assert(OverrideValueParsed == null || OverrideValueParsed.GetType() == Type);
+                    return;
+                }
+
+                if (_defaultValue == null)
+                    throw new NullReferenceException("Must specify default value before registering");
+
+                if (Value != null && DefaultValue.GetType() != Value.GetType())
+                    throw new Exception($"The cvar value & default value must be of the same type");
+
+                if (OverrideValueParsed != null && DefaultValue.GetType() != OverrideValueParsed.GetType())
+                    throw new Exception($"The cvar override value & default value must be of the same type");
+
+                Type = DefaultValue.GetType();
+                Registered = true;
+            }
 
             /// <summary>
             ///     Was the CVar present in the config file?
@@ -822,12 +876,25 @@ namespace Robust.Shared.Configuration
             public bool ConfigModified;
 
             public InvokeList<ValueChangedDelegate> ValueChanged;
+            private object _defaultValue;
+            private object? _value;
+            private object? _overrideValueParsed;
 
             // We don't know what the type of the var is until it's registered.
             // So we can't actually parse them until then.
             // So we keep the raw string around.
             public string? OverrideValue { get; set; }
-            public object? OverrideValueParsed { get; set; }
+
+            public object? OverrideValueParsed
+            {
+                get => _overrideValueParsed;
+                set
+                {
+                    if (value != null && Registered)
+                        DebugTools.AssertEqual(value.GetType(), Type);
+                    _overrideValueParsed = value;
+                }
+            }
         }
 
         /// <summary>
@@ -836,8 +903,14 @@ namespace Robust.Shared.Configuration
         private struct ValueChangedInvoke
         {
             public InvokeList<ValueChangedDelegate> Invoke;
-            public object Value;
+            public object Value => Info.NewValue;
             public CVarChangeInfo Info;
+
+            public ValueChangedInvoke(CVarChangeInfo info, InvokeList<ValueChangedDelegate> invoke) : this()
+            {
+                Info = info;
+                Invoke = invoke;
+            }
         }
 
         protected delegate void ValueChangedDelegate(object value, in CVarChangeInfo info);

Robust.Shared/Configuration/IConfigurationManager.cs

@@ -10,6 +10,11 @@ namespace Robust.Shared.Configuration
     /// </summary>
     public readonly struct CVarChangeInfo
     {
+        /// <summary>
+        /// The name of the cvar that was changed.
+        /// </summary>
+        public readonly string Name;
+
         /// <summary>
         /// The tick this CVar changed at.
         /// </summary>
@@ -20,9 +25,22 @@ namespace Robust.Shared.Configuration
         /// </remarks>
         public readonly GameTick TickChanged;
 
-        internal CVarChangeInfo(GameTick tickChanged)
+        /// <summary>
+        /// The new value.
+        /// </summary>
+        public readonly object NewValue;
+
+        /// <summary>
+        /// The previous value.
+        /// </summary>
+        public readonly object OldValue;
+
+        internal CVarChangeInfo(string name, GameTick tickChanged, object newValue, object oldValue)
         {
+            Name = name;
             TickChanged = tickChanged;
+            NewValue = newValue;
+            OldValue = oldValue;
         }
     }
 
@@ -252,5 +270,7 @@ namespace Robust.Shared.Configuration
         /// <typeparam name="T">The type of value contained in this CVar.</typeparam>
         void UnsubValueChanged<T>(string name, CVarChanged<T> onValueChanged)
             where T : notnull;
+
+        public event Action<CVarChangeInfo>? OnCVarValueChanged;
     }
 }

Robust.Shared/Containers/BaseContainer.cs

@@ -1,16 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Numerics;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
-using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Network;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Components;
-using Robust.Shared.Physics.Systems;
 using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
@@ -23,6 +15,19 @@ namespace Robust.Shared.Containers
     [ImplicitDataDefinitionForInheritors]
     public abstract partial class BaseContainer
     {
+        // Will be null until after the component has been initialized.
+        protected SharedContainerSystem? System;
+
+        [Access(typeof(SharedContainerSystem), typeof(ContainerManagerComponent))]
+        internal void Init(SharedContainerSystem system, string id, Entity<ContainerManagerComponent> owner)
+        {
+            DebugTools.Assert(ID == null || ID == id);
+            ID = id;
+            Owner = owner;
+            Manager = owner;
+            System = system;
+        }
+
         /// <summary>
         /// Readonly collection of all the entities contained within this specific container
         /// </summary>

Robust.Shared/Containers/Container.cs

@@ -2,10 +2,8 @@ using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager.Attributes;
-using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.Containers
@@ -51,14 +49,7 @@ namespace Robust.Shared.Containers
             if (!_containerList.Contains(contained))
                 return false;
 
-#if DEBUG
-            if (IoCManager.Resolve<IGameTiming>().ApplyingState)
-                return true;
-
-            var entMan = IoCManager.Resolve<IEntityManager>();
-            var flags = entMan.GetComponent<MetaDataComponent>(contained).Flags;
-            DebugTools.Assert((flags & MetaDataFlags.InContainer) != 0, $"Entity has bad container flags. Ent: {entMan.ToPrettyString(contained)}. Container: {ID}, Owner: {entMan.ToPrettyString(Owner)}");
-#endif
+            System?.AssertInContainer(contained, this);
             return true;
         }
 

Robust.Shared/Containers/ContainerManagerComponent.cs

@@ -30,9 +30,7 @@ namespace Robust.Shared.Containers
         {
             foreach (var (id, container) in Containers)
             {
-                container.ID = id;
-                container.Owner = Owner;
-                container.Manager = this;
+                container.Init(default!, id, (Owner, this));
             }
         }
 

Robust.Shared/Containers/ContainerSlot.cs

@@ -2,11 +2,9 @@ using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager.Attributes;
-using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.Containers
@@ -59,14 +57,7 @@ namespace Robust.Shared.Containers
             if (contained != ContainedEntity)
                 return false;
 
-#if DEBUG
-            if (IoCManager.Resolve<IGameTiming>().ApplyingState)
-                return true;
-
-            var entMan = IoCManager.Resolve<IEntityManager>();
-            var flags = entMan.GetComponent<MetaDataComponent>(contained).Flags;
-            DebugTools.Assert((flags & MetaDataFlags.InContainer) != 0, $"Entity has bad container flags. Ent: {entMan.ToPrettyString(contained)}. Container: {ID}, Owner: {entMan.ToPrettyString(Owner)}");
-#endif
+            System?.AssertInContainer(contained, this);
             return true;
         }
 

Robust.Shared/Containers/SharedContainerSystem.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Robust.Shared.GameObjects;
@@ -12,6 +13,7 @@ using Robust.Shared.Network;
 using Robust.Shared.Physics;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Systems;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.Containers
@@ -24,6 +26,7 @@ namespace Robust.Shared.Containers
         [Dependency] private readonly EntityLookupSystem _lookup = default!;
         [Dependency] private readonly SharedTransformSystem _transform = default!;
         [Dependency] private readonly SharedJointSystem _joint = default!;
+        [Dependency] private readonly IGameTiming _timing = default!;
 
         private EntityQuery<ContainerManagerComponent> _managerQuery;
         private EntityQuery<MapGridComponent> _gridQuery;
@@ -39,6 +42,7 @@ namespace Robust.Shared.Containers
             base.Initialize();
 
             SubscribeLocalEvent<EntParentChangedMessage>(OnParentChanged);
+            SubscribeLocalEvent<ContainerManagerComponent, ComponentInit>(OnInit);
             SubscribeLocalEvent<ContainerManagerComponent, ComponentStartup>(OnStartupValidation);
             SubscribeLocalEvent<ContainerManagerComponent, ComponentGetState>(OnContainerGetState);
             SubscribeLocalEvent<ContainerManagerComponent, ComponentRemove>(OnContainerManagerRemove);
@@ -52,9 +56,18 @@ namespace Robust.Shared.Containers
             TransformQuery = GetEntityQuery<TransformComponent>();
         }
 
+        private void OnInit(Entity<ContainerManagerComponent> ent, ref ComponentInit args)
+        {
+            foreach (var (id, container) in ent.Comp.Containers)
+            {
+                container.Init(this, id, ent);
+            }
+        }
+
         private void OnContainerGetState(EntityUid uid, ContainerManagerComponent component, ref ComponentGetState args)
         {
-            Dictionary<string, ContainerManagerComponent.ContainerManagerComponentState.ContainerData> containerSet = new(component.Containers.Count);
+            Dictionary<string, ContainerManagerComponent.ContainerManagerComponentState.ContainerData> containerSet =
+                new(component.Containers.Count);
 
             foreach (var container in component.Containers.Values)
             {
@@ -65,7 +78,11 @@ namespace Robust.Shared.Containers
                     uidArr[index] = GetNetEntity(container.ContainedEntities[index]);
                 }
 
-                var sContainer = new ContainerManagerComponent.ContainerManagerComponentState.ContainerData(container.GetType().Name, container.ShowContents, container.OccludesLight, uidArr);
+                var sContainer =
+                    new ContainerManagerComponent.ContainerManagerComponentState.ContainerData(container.GetType().Name,
+                        container.ShowContents,
+                        container.OccludesLight,
+                        uidArr);
                 containerSet.Add(container.ID, sContainer);
             }
 
@@ -96,18 +113,12 @@ namespace Robust.Shared.Containers
                 throw new ArgumentException($"Container with specified ID already exists: '{id}'");
 
             var container = _dynFactory.CreateInstanceUnchecked<T>(typeof(T), inject: false);
-            InitContainer(container, (uid, containerManager), id);
+            container.Init(this, id, (uid, containerManager));
             containerManager.Containers[id] = container;
             Dirty(uid, containerManager);
             return container;
         }
 
-        protected void InitContainer(BaseContainer container, Entity<ContainerManagerComponent> containerEnt, string id)
-        {
-            DebugTools.AssertNull(container.ID);
-            ((container.Owner, container.Manager), container.ID) = (containerEnt, id);
-        }
-
         public virtual void ShutdownContainer(BaseContainer container)
         {
             container.InternalShutdown(EntityManager, this, _net.IsClient);
@@ -115,7 +126,11 @@ namespace Robust.Shared.Containers
             container.ExpectedEntities.Clear();
         }
 
-        public T EnsureContainer<T>(EntityUid uid, string id, out bool alreadyExisted, ContainerManagerComponent? containerManager = null)
+        public T EnsureContainer<T>(
+            EntityUid uid,
+            string id,
+            out bool alreadyExisted,
+            ContainerManagerComponent? containerManager = null)
             where T : BaseContainer
         {
             if (!Resolve(uid, ref containerManager, false))
@@ -136,7 +151,7 @@ namespace Robust.Shared.Containers
         }
 
         public T EnsureContainer<T>(EntityUid uid, string id, ContainerManagerComponent? containerManager = null)
-           where T : BaseContainer
+            where T : BaseContainer
         {
             return EnsureContainer<T>(uid, id, out _, containerManager);
         }
@@ -157,7 +172,11 @@ namespace Robust.Shared.Containers
             return containerManager.Containers.ContainsKey(id);
         }
 
-        public bool TryGetContainer(EntityUid uid, string id, [NotNullWhen(true)] out BaseContainer? container, ContainerManagerComponent? containerManager = null)
+        public bool TryGetContainer(
+            EntityUid uid,
+            string id,
+            [NotNullWhen(true)] out BaseContainer? container,
+            ContainerManagerComponent? containerManager = null)
         {
             if (!Resolve(uid, ref containerManager, false))
             {
@@ -165,16 +184,30 @@ namespace Robust.Shared.Containers
                 return false;
             }
 
-            return containerManager.Containers.TryGetValue(id, out container);
+            if (!containerManager.Containers.TryGetValue(id, out container))
+                return false;
+
+            DebugTools.AssertEqual(container.ID, id);
+            DebugTools.AssertNotNull(container.Manager);
+            DebugTools.AssertNotEqual(container.Owner, EntityUid.Invalid);
+            return true;
         }
 
         [Obsolete("Use variant without skipExistCheck argument")]
-        public bool TryGetContainingContainer(EntityUid uid, EntityUid containedUid, [NotNullWhen(true)] out BaseContainer? container, bool skipExistCheck)
+        public bool TryGetContainingContainer(
+            EntityUid uid,
+            EntityUid containedUid,
+            [NotNullWhen(true)] out BaseContainer? container,
+            bool skipExistCheck)
         {
             return TryGetContainingContainer(uid, containedUid, out container);
         }
 
-        public bool TryGetContainingContainer(EntityUid uid, EntityUid containedUid, [NotNullWhen(true)] out BaseContainer? container, ContainerManagerComponent? containerManager = null)
+        public bool TryGetContainingContainer(
+            EntityUid uid,
+            EntityUid containedUid,
+            [NotNullWhen(true)] out BaseContainer? container,
+            ContainerManagerComponent? containerManager = null)
         {
             DebugTools.Assert(Exists(containedUid));
             if (!Resolve(uid, ref containerManager, false))
@@ -196,7 +229,10 @@ namespace Robust.Shared.Containers
             return false;
         }
 
-        public bool ContainsEntity(EntityUid uid, EntityUid containedUid, ContainerManagerComponent? containerManager = null)
+        public bool ContainsEntity(
+            EntityUid uid,
+            EntityUid containedUid,
+            ContainerManagerComponent? containerManager = null)
         {
             DebugTools.Assert(Exists(containedUid));
             if (!Resolve(uid, ref containerManager, false))
@@ -228,13 +264,20 @@ namespace Robust.Shared.Containers
             foreach (var containers in containerManager.Containers.Values)
             {
                 if (containers.Contains(toremove))
-                    return Remove((toremove, containedXform, containedMeta), containers, reparent, force, destination, localRotation);
+                    return Remove((toremove, containedXform, containedMeta),
+                        containers,
+                        reparent,
+                        force,
+                        destination,
+                        localRotation);
             }
 
             return true; // If we don't contain the entity, it will always be removed
         }
 
-        public ContainerManagerComponent.AllContainersEnumerable GetAllContainers(EntityUid uid, ContainerManagerComponent? containerManager = null)
+        public ContainerManagerComponent.AllContainersEnumerable GetAllContainers(
+            EntityUid uid,
+            ContainerManagerComponent? containerManager = null)
         {
             if (!Resolve(uid, ref containerManager))
                 return new ContainerManagerComponent.AllContainersEnumerable();
@@ -246,20 +289,32 @@ namespace Robust.Shared.Containers
 
         #region Container Helpers
 
-        public bool TryGetContainingContainer(EntityUid uid, [NotNullWhen(true)] out BaseContainer? container, MetaDataComponent? meta = null, TransformComponent? transform = null)
+        [Obsolete("Use Entity<T> variant")]
+        public bool TryGetContainingContainer(
+            EntityUid uid,
+            [NotNullWhen(true)] out BaseContainer? container,
+            MetaDataComponent? meta = null,
+            TransformComponent? transform = null)
+        {
+            return TryGetContainingContainer((uid, transform, meta), out container);
+        }
+
+        public bool TryGetContainingContainer(
+            Entity<TransformComponent?, MetaDataComponent?> ent,
+            [NotNullWhen(true)] out BaseContainer? container)
         {
             container = null;
 
-            if (!Resolve(uid, ref meta, false))
+            if (!Resolve(ent, ref ent.Comp2, false))
                 return false;
 
-            if ((meta.Flags & MetaDataFlags.InContainer) == MetaDataFlags.None)
+            if ((ent.Comp2.Flags & MetaDataFlags.InContainer) == MetaDataFlags.None)
                 return false;
 
-            if (!Resolve(uid, ref transform, false))
+            if (!Resolve(ent, ref ent.Comp1, false))
                 return false;
 
-            return TryGetContainingContainer(transform.ParentUid, uid, out container);
+            return TryGetContainingContainer(ent.Comp1.ParentUid, ent, out container);
         }
 
         /// <summary>
@@ -356,10 +411,19 @@ namespace Robust.Shared.Containers
             return TryFindComponentsOnEntityContainerOrParent(xform.ParentUid, entityQuery, foundComponents);
         }
 
+
+        [Obsolete("Use Entity<T> variant")]
+        public bool IsInSameOrNoContainer(EntityUid user, EntityUid other)
+        {
+            return IsInSameOrNoContainer((user, null, null), (other, null, null));
+        }
+
         /// <summary>
         ///     Returns true if the two entities are not contained, or are contained in the same container.
         /// </summary>
-        public bool IsInSameOrNoContainer(EntityUid user, EntityUid other)
+        public bool IsInSameOrNoContainer(
+            Entity<TransformComponent?, MetaDataComponent?> user,
+            Entity<TransformComponent?, MetaDataComponent?> other)
         {
             var isUserContained = TryGetContainingContainer(user, out var userContainer);
             var isOtherContained = TryGetContainingContainer(other, out var otherContainer);
@@ -374,14 +438,33 @@ namespace Robust.Shared.Containers
             return userContainer == otherContainer;
         }
 
+
+        [Obsolete("Use Entity<T> variant")]
+        public bool IsInSameOrParentContainer(EntityUid user, EntityUid other)
+        {
+            return IsInSameOrParentContainer((user, null), other);
+        }
+
         /// <summary>
         ///     Returns true if the two entities are not contained, or are contained in the same container, or if one
         ///     entity contains the other (i.e., is the parent).
         /// </summary>
-        public bool IsInSameOrParentContainer(EntityUid user, EntityUid other)
+        public bool IsInSameOrParentContainer(
+            Entity<TransformComponent?, MetaDataComponent?> user,
+            Entity<TransformComponent?, MetaDataComponent?> other)
         {
-            var isUserContained = TryGetContainingContainer(user, out var userContainer);
-            var isOtherContained = TryGetContainingContainer(other, out var otherContainer);
+            return IsInSameOrParentContainer(user, other, out _, out _);
+        }
+
+        /// <inheritdoc cref="IsInSameOrParentContainer(Robust.Shared.GameObjects.Entity{Robust.Shared.GameObjects.TransformComponent?},Robust.Shared.GameObjects.Entity{Robust.Shared.GameObjects.TransformComponent?})"/>
+        public bool IsInSameOrParentContainer(
+            Entity<TransformComponent?, MetaDataComponent?> user,
+            Entity<TransformComponent?, MetaDataComponent?> other,
+            out BaseContainer? userContainer,
+            out BaseContainer? otherContainer)
+        {
+            var isUserContained = TryGetContainingContainer(user, out userContainer);
+            var isOtherContained = TryGetContainingContainer(other, out otherContainer);
 
             // Both entities are not in a container
             if (!isUserContained && !isOtherContained) return true;
@@ -396,6 +479,21 @@ namespace Robust.Shared.Containers
             return userContainer == otherContainer;
         }
 
+        [Obsolete("Use Entity<T> variant")]
+        public bool IsInSameOrTransparentContainer(
+            EntityUid user,
+            EntityUid other,
+            BaseContainer? userContainer = null,
+            BaseContainer? otherContainer = null,
+            bool userSeeInsideSelf = false)
+        {
+            return IsInSameOrTransparentContainer((user, null),
+                other,
+                userContainer,
+                otherContainer,
+                userSeeInsideSelf);
+        }
+
         /// <summary>
         ///     Check whether a given entity can see another entity despite whatever containers they may be in.
         /// </summary>
@@ -407,8 +505,8 @@ namespace Robust.Shared.Containers
         ///     this means that the two entity arguments are NOT interchangeable.
         /// </remarks>
         public bool IsInSameOrTransparentContainer(
-            EntityUid user,
-            EntityUid other,
+            Entity<TransformComponent?, MetaDataComponent?> user,
+            Entity<TransformComponent?, MetaDataComponent?> other,
             BaseContainer? userContainer = null,
             BaseContainer? otherContainer = null,
             bool userSeeInsideSelf = false)
@@ -433,11 +531,11 @@ namespace Robust.Shared.Containers
 
             // Is the user in a see-through container?
             if (userContainer?.ShowContents ?? false)
-                return IsInSameOrTransparentContainer(userContainer.Owner, other, otherContainer: otherContainer);
+                return IsInSameOrTransparentContainer((userContainer.Owner, null, null), other, otherContainer: otherContainer);
 
             // Is the other entity in a see-through container?
             if (otherContainer?.ShowContents ?? false)
-                return IsInSameOrTransparentContainer(user, otherContainer.Owner, userContainer: userContainer, userSeeInsideSelf: userSeeInsideSelf);
+                return IsInSameOrTransparentContainer(user, (otherContainer.Owner, null, null), userContainer: userContainer, userSeeInsideSelf: userSeeInsideSelf);
 
             return false;
         }
@@ -603,5 +701,16 @@ namespace Robust.Shared.Containers
             if (TryComp(message.OldParent, out ContainerManagerComponent? containerManager))
                 RemoveEntity(message.OldParent.Value, message.Entity, containerManager, message.Transform, meta,  reparent: false, force: true);
         }
+
+        [Conditional("DEBUG"), Access(typeof(BaseContainer))]
+        public void AssertInContainer(EntityUid uid, BaseContainer container)
+        {
+            if (_timing.ApplyingState)
+                return; // Entity might not yet have had its state updated.
+
+            var flags = MetaData(uid).Flags;
+            DebugTools.Assert((flags & MetaDataFlags.InContainer) != 0,
+                $"Entity has bad container flags. Ent: {ToPrettyString(uid)}. Container: {container.ID}, Owner: {ToPrettyString(container.Owner)}");
+        }
     }
 }

Robust.Shared/ContentPack/Sandbox.yml

@@ -442,7 +442,14 @@ Types:
     AddressFamily: { }
   System.Numerics:
     BitOperations: { All: True }
+    Complex: { All: True }
+    Matrix3x2: { All: True }
+    Matrix4x4: { All: True }
+    Plane: { All: True }
+    Quaternion: { All: True }
     Vector2: { All: True }
+    Vector3: { All: True }
+    Vector4: { All: True }
   System.Reflection:
     Assembly:
       Methods:
@@ -770,7 +777,7 @@ Types:
     Array:
       Methods:
       - "!!0 Find<>(!!0[], System.Predicate`1<!!0>)"
-      - "!!0 Resize<>(!!0[], int)"
+      - "void Resize<>(ref !!0[], int)"
       - "!!1 ConvertAll<,>(!!0[], System.Converter`2<!!0, !!1>)"
       - "!!0[] Empty<>()"
       - "!!0[] FindAll<>(!!0[], System.Predicate`1<!!0>)"

Robust.Shared/GameObjects/ComponentFactory.cs

@@ -289,6 +289,12 @@ namespace Robust.Shared.GameObjects
             return GetRegistration(componentType).Name;
         }
 
+        [Pure]
+        public string GetComponentName<T>() where T : IComponent, new()
+        {
+            return GetRegistration<T>().Name;
+        }
+
         [Pure]
         public string GetComponentName(ushort netID)
         {
@@ -324,7 +330,7 @@ namespace Robust.Shared.GameObjects
 
         public ComponentRegistration GetRegistration<T>() where T : IComponent, new()
         {
-            return GetRegistration(typeof(T));
+            return GetRegistration(CompIdx.Index<T>());
         }
 
         public ComponentRegistration GetRegistration(IComponent component)

Robust.Shared/GameObjects/ComponentState.cs

@@ -1,43 +1,56 @@
 using System;
 using Robust.Shared.Serialization;
 
-namespace Robust.Shared.GameObjects
+namespace Robust.Shared.GameObjects;
+
+[RequiresSerializable]
+[Serializable, NetSerializable]
+[Virtual]
+public abstract class ComponentState : IComponentState;
+
+/// <summary>
+/// Represents the state of a component for networking purposes.
+/// </summary>
+public interface IComponentState;
+
+public interface IComponentDeltaState : IComponentState
 {
-    [RequiresSerializable]
-    [Serializable, NetSerializable]
-    [Virtual]
-    public class ComponentState : IComponentState
-    {
+    public void ApplyToFullState(IComponentState fullState);
 
-    }
+    public IComponentState CreateNewFullState(IComponentState fullState);
+}
+
+/// <summary>
+/// Interface for component states that only contain partial state data. The actual delta state class should be a
+/// separate class from the full component states.
+/// </summary>
+/// <typeparam name="TState">The full-state class associated with this partial state</typeparam>
+public interface IComponentDeltaState<TState> : IComponentDeltaState where TState: IComponentState
+{
+    /// <summary>
+    /// This function will apply the current delta state to the provided full state, modifying it in the process.
+    /// </summary>
+    public void ApplyToFullState(TState fullState);
 
     /// <summary>
-    /// Represents the state of a component for networking purposes.
+    /// This function should take in a full state and return a new full state with the current delta applied, WITHOUT
+    /// modifying the original input state.
     /// </summary>
-    public interface IComponentState
-    {
+    public TState CreateNewFullState(TState fullState);
 
+    void IComponentDeltaState.ApplyToFullState(IComponentState fullState)
+    {
+        if (fullState is TState state)
+            ApplyToFullState(state);
+        else
+            throw new Exception($"Unexpected type. Expected {nameof(TState)} but got {fullState.GetType().Name}");
     }
 
-    /// <summary>
-    ///     Interface for components that support delta-states.
-    /// </summary>
-    public interface IComponentDeltaState
+    IComponentState IComponentDeltaState.CreateNewFullState(IComponentState fullState)
     {
-        /// <summary>
-        ///     Whether this state is a delta or full state.
-        /// </summary>
-        bool FullState { get; }
-
-        /// <summary>
-        ///     This function will apply the current delta state to the provided full state, modifying it in the process.
-        /// </summary>
-        public void ApplyToFullState(IComponentState fullState);
-
-        /// <summary>
-        ///     This function should take in a full state and return a new full state with the current delta applied,
-        ///     WITHOUT modifying the original input state.
-        /// </summary>
-        public IComponentState CreateNewFullState(IComponentState fullState);
+        if (fullState is TState state)
+            return CreateNewFullState(state);
+        else
+            throw new Exception($"Unexpected type. Expected {nameof(TState)} but got {fullState.GetType().Name}");
     }
 }

Robust.Shared/GameObjects/Components/Localization/GrammarComponent.cs

@@ -2,45 +2,35 @@ using System;
 using System.Collections.Generic;
 using Robust.Shared.Enums;
 using Robust.Shared.GameStates;
+using Robust.Shared.IoC;
 using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
-namespace Robust.Shared.GameObjects.Components.Localization
+namespace Robust.Shared.GameObjects.Components.Localization;
+
+/// <summary>
+///     Overrides grammar attributes specified in prototypes or localization files.
+/// </summary>
+[RegisterComponent, NetworkedComponent, AutoGenerateComponentState]
+// [Access(typeof(GrammarSystem))] TODO access
+public sealed partial class GrammarComponent : Component
 {
-    /// <summary>
-    ///     Overrides grammar attributes specified in prototypes or localization files.
-    /// </summary>
-    [RegisterComponent]
-    [NetworkedComponent()]
-    public sealed partial class GrammarComponent : Component
+    [DataField, AutoNetworkedField]
+    public Dictionary<string, string> Attributes = new();
+
+    [ViewVariables]
+    public Gender? Gender
     {
-        [DataField("attributes")]
-        public Dictionary<string, string> Attributes { get; private set; } = new();
+        get => Attributes.TryGetValue("gender", out var g) ? Enum.Parse<Gender>(g, true) : null;
+        [Obsolete("Use GrammarSystem.SetGender instead")]
+        set => IoCManager.Resolve<IEntityManager>().System<GrammarSystem>().SetGender((Owner, this), value);
+    }
 
-        [ViewVariables]
-        public Gender? Gender
-        {
-            get => Attributes.TryGetValue("gender", out var g) ? Enum.Parse<Gender>(g, true) : null;
-            set
-            {
-                if (value.HasValue)
-                    Attributes["gender"] = value.Value.ToString();
-                else
-                    Attributes.Remove("gender");
-            }
-        }
-
-        [ViewVariables]
-        public bool? ProperNoun
-        {
-            get => Attributes.TryGetValue("proper", out var g) ? bool.Parse(g) : null;
-            set
-            {
-                if (value.HasValue)
-                    Attributes["proper"] = value.Value.ToString();
-                else
-                    Attributes.Remove("proper");
-            }
-        }
+    [ViewVariables]
+    public bool? ProperNoun
+    {
+        get => Attributes.TryGetValue("proper", out var g) ? bool.Parse(g) : null;
+        [Obsolete("Use GrammarSystem.SetProperNoun instead")]
+        set => IoCManager.Resolve<IEntityManager>().System<GrammarSystem>().SetProperNoun((Owner, this), value);
     }
 }

Robust.Shared/GameObjects/Components/Localization/GrammarSystem.cs

@@ -0,0 +1,39 @@
+using System.Diagnostics.CodeAnalysis;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects.Components.Localization;
+
+namespace Robust.Shared.GameObjects;
+
+public sealed class GrammarSystem : EntitySystem
+{
+    public void Clear(Entity<GrammarComponent> grammar)
+    {
+        grammar.Comp.Attributes.Clear();
+        Dirty(grammar);
+    }
+
+    public bool TryGet(Entity<GrammarComponent> grammar, string key, [NotNullWhen(true)] out string? value)
+    {
+        return grammar.Comp.Attributes.TryGetValue(key, out value);
+    }
+
+    public void Set(Entity<GrammarComponent> grammar, string key, string? value)
+    {
+        if (value == null)
+            grammar.Comp.Attributes.Remove(key);
+        else
+            grammar.Comp.Attributes[key] = value;
+
+        Dirty(grammar);
+    }
+
+    public void SetGender(Entity<GrammarComponent> grammar, Gender? gender)
+    {
+        Set(grammar, "gender", gender?.ToString());
+    }
+
+    public void SetProperNoun(Entity<GrammarComponent> grammar, bool? proper)
+    {
+        Set(grammar, "proper", proper?.ToString());
+    }
+}

Robust.Shared/GameObjects/Components/Transform/TransformComponent.cs

@@ -157,9 +157,7 @@ namespace Robust.Shared.GameObjects
                 if (!Initialized)
                     return;
 
-                var moveEvent = new MoveEvent((Owner, this, meta), Coordinates, Coordinates, oldRotation, _localRotation, _gameTiming.ApplyingState);
-                _entMan.EventBus.RaiseLocalEvent(Owner, ref moveEvent);
-                _entMan.System<SharedTransformSystem>().InvokeGlobalMoveEvent(ref moveEvent);
+                _entMan.System<SharedTransformSystem>().RaiseMoveEvent((Owner, this, meta), _parent, _localPosition, oldRotation, MapUid);
             }
         }
 
@@ -334,7 +332,9 @@ namespace Robust.Shared.GameObjects
                 if (_localPosition.EqualsApprox(value))
                     return;
 
-                var oldGridPos = Coordinates;
+                var oldParent = _parent;
+                var oldPos = _localPosition;
+
                 _localPosition = value;
                 var meta = _entMan.GetComponent<MetaDataComponent>(Owner);
                 _entMan.Dirty(Owner, this, meta);
@@ -343,9 +343,7 @@ namespace Robust.Shared.GameObjects
                 if (!Initialized)
                     return;
 
-                var moveEvent = new MoveEvent((Owner, this, meta), oldGridPos, Coordinates, _localRotation, _localRotation, _gameTiming.ApplyingState);
-                _entMan.EventBus.RaiseLocalEvent(Owner, ref moveEvent);
-                _entMan.System<SharedTransformSystem>().InvokeGlobalMoveEvent(ref moveEvent);
+                _entMan.System<SharedTransformSystem>().RaiseMoveEvent((Owner, this, meta), oldParent, oldPos, _localRotation, MapUid);
             }
         }
 
@@ -602,8 +600,12 @@ namespace Robust.Shared.GameObjects
     /// move events, subscribe to the <see cref="SharedTransformSystem.OnGlobalMoveEvent"/>.
     /// </summary>
     [ByRefEvent]
-    public readonly struct MoveEvent(Entity<TransformComponent, MetaDataComponent> entity, EntityCoordinates oldPos,
-        EntityCoordinates newPos, Angle oldRotation, Angle newRotation, bool stateHandling = false)
+    public readonly struct MoveEvent(
+        Entity<TransformComponent, MetaDataComponent> entity,
+        EntityCoordinates oldPos,
+        EntityCoordinates newPos,
+        Angle oldRotation,
+        Angle newRotation)
     {
         public readonly Entity<TransformComponent, MetaDataComponent> Entity = entity;
         public readonly EntityCoordinates OldPosition = oldPos;
@@ -615,15 +617,6 @@ namespace Robust.Shared.GameObjects
         public TransformComponent Component => Entity.Comp1;
 
         public bool ParentChanged => NewPosition.EntityId != OldPosition.EntityId;
-
-        [Obsolete("Check IGameTiming.ApplyingState")]
-        public readonly bool FromStateHandling = stateHandling;
-
-        [Obsolete]
-        public MoveEvent(EntityUid uid, EntityCoordinates oldPos, EntityCoordinates newPos, Angle oldRot, Angle newRot, TransformComponent xform, bool state)
-            : this((uid, xform, default!), oldPos, newPos, oldRot, newRot)
-        {
-        }
     }
 
     public struct TransformChildrenEnumerator : IDisposable

Robust.Shared/GameObjects/Components/UserInterface/BoundUserInterface.cs

@@ -19,7 +19,7 @@ namespace Robust.Shared.GameObjects
         /// <summary>
         ///     The last received state object sent from the server.
         /// </summary>
-        protected BoundUserInterfaceState? State { get; private set; }
+        protected internal BoundUserInterfaceState? State { get; internal set; }
 
         protected BoundUserInterface(EntityUid owner, Enum uiKey)
         {

Robust.Shared/GameObjects/Components/UserInterface/UserInterfaceComponent.cs

@@ -71,12 +71,17 @@ namespace Robust.Shared.GameObjects
     ///     Raised whenever the server receives a BUI message from a client relating to a UI that requires input
     ///     validation.
     /// </summary>
-    public sealed class BoundUserInterfaceMessageAttempt(EntityUid actor, EntityUid target, Enum uiKey)
+    public sealed class BoundUserInterfaceMessageAttempt(
+        EntityUid actor,
+        EntityUid target,
+        Enum uiKey,
+        BoundUserInterfaceMessage message)
         : CancellableEntityEventArgs
     {
         public readonly EntityUid Actor = actor;
         public readonly EntityUid Target = target;
         public readonly Enum UiKey = uiKey;
+        public readonly BoundUserInterfaceMessage Message = message;
     }
 
     [NetSerializable, Serializable]
@@ -130,12 +135,12 @@ namespace Robust.Shared.GameObjects
     }
 
     [NetSerializable, Serializable]
-    internal sealed class OpenBoundInterfaceMessage : BoundUserInterfaceMessage
+    public sealed class OpenBoundInterfaceMessage : BoundUserInterfaceMessage
     {
     }
 
     [NetSerializable, Serializable]
-    internal sealed class CloseBoundInterfaceMessage : BoundUserInterfaceMessage
+    public sealed class CloseBoundInterfaceMessage : BoundUserInterfaceMessage
     {
     }
 

Robust.Shared/GameObjects/EntityEventBus.Broadcast.cs

@@ -167,7 +167,7 @@ namespace Robust.Shared.GameObjects
             if (eventHandler == null)
                 throw new ArgumentNullException(nameof(eventHandler));
 
-            var order = new OrderingData(orderType, before ?? Array.Empty<Type>(), after ?? Array.Empty<Type>());
+            var order = CreateOrderingData(orderType, before, after);
 
             SubscribeEventCommon<T>(source, subscriber,
                 (ref Unit ev) => eventHandler(Unsafe.As<Unit, T>(ref ev)), eventHandler, order, false);
@@ -187,7 +187,7 @@ namespace Robust.Shared.GameObjects
             EntityEventRefHandler<T> eventHandler,
             Type orderType, Type[]? before = null, Type[]? after = null) where T : notnull
         {
-            var order = new OrderingData(orderType, before ?? Array.Empty<Type>(), after ?? Array.Empty<Type>());
+            var order = CreateOrderingData(orderType, before, after);
 
             SubscribeEventCommon<T>(source, subscriber, (ref Unit ev) =>
             {

Robust.Shared/GameObjects/EntityEventBus.Common.cs

@@ -5,6 +5,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using JetBrains.Annotations;
 using Robust.Shared.Collections;
+using Robust.Shared.Reflection;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.GameObjects;
@@ -13,6 +14,7 @@ internal sealed partial class EntityEventBus : IEventBus
 {
     private IEntityManager _entMan;
     private IComponentFactory _comFac;
+    private IReflectionManager _reflection;
 
     // Data on individual events. Used to check ordering info and fire broadcast events.
     private FrozenDictionary<Type, EventData> _eventData = FrozenDictionary<Type, EventData>.Empty;
@@ -29,26 +31,36 @@ internal sealed partial class EntityEventBus : IEventBus
     // See EventTable declaration for layout details
     internal Dictionary<EntityUid, EventTable> _entEventTables = new();
 
-    // CompType -> EventType -> Handler
-    internal FrozenDictionary<Type, DirectedRegistration>?[] _entSubscriptions = default!;
+    /// <summary>
+    /// Array of component events and their handlers. The array is indexed by a component's
+    /// <see cref="CompIdx.Value"/>, while the dictionary is indexed by the event type. This does not include events
+    /// with the <see cref="ComponentEventAttribute"/>
+    /// </summary>
+    internal FrozenDictionary<Type, DirectedRegistration>[] _eventSubs = default!;
 
-    // Variant of _entSubscriptions that omits any events with the ComponentEventAttribute
-    internal FrozenDictionary<Type, DirectedRegistration>?[] _entSubscriptionsNoCompEv = default!;
+    /// <summary>
+    /// Variant of <see cref="_eventSubs"/> that also includes events with the <see cref="ComponentEventAttribute"/>
+    /// </summary>
+    internal FrozenDictionary<Type, DirectedRegistration>[] _compEventSubs = default!;
 
-    // pre-freeze _entSubscriptions data
-    internal Dictionary<Type, DirectedRegistration>?[] _entSubscriptionsUnfrozen =
-        Array.Empty<Dictionary<Type, DirectedRegistration>?>();
+    // pre-freeze event subscription data
+    internal Dictionary<Type, DirectedRegistration>?[] _eventSubsUnfrozen =
+        Array.Empty<Dictionary<Type, DirectedRegistration>>();
 
-    // EventType -> { CompType1, ... CompType N }
+    /// <summary>
+    /// Inverse of <see cref="_eventSubs"/>, mapping event types to sets of components.
+    /// </summary>
+    private Dictionary<Type, HashSet<CompIdx>> _eventSubsInv = new();
     // Only required to sort ordered subscriptions, which only happens during initialization
     // so doesn't need to be a frozen dictionary.
-    private Dictionary<Type, HashSet<CompIdx>> _entSubscriptionsInv = new();
 
     // prevents shitcode, get your subscriptions figured out before you start spawning entities
     private bool _subscriptionLock;
 
     public bool IgnoreUnregisteredComponents;
 
+    private readonly List<Type> _childrenTypesTemp = [];
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private static ref Unit ExtractUnitRef(ref object obj, Type objType)
     {

Robust.Shared/GameObjects/EntityEventBus.Directed.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Robust.Shared.Collections;
+using Robust.Shared.Reflection;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.GameObjects
@@ -117,10 +118,12 @@ namespace Robust.Shared.GameObjects
         /// Constructs a new instance of <see cref="EntityEventBus"/>.
         /// </summary>
         /// <param name="entMan">The entity manager to watch for entity/component events.</param>
-        public EntityEventBus(IEntityManager entMan)
+        /// <param name="reflection">The reflection manager to use when finding derived types.</param>
+        public EntityEventBus(IEntityManager entMan, IReflectionManager reflection)
         {
             _entMan = entMan;
             _comFac = entMan.ComponentFactory;
+            _reflection = reflection;
 
             // Dynamic handling of components is only for RobustUnitTest compatibility spaghetti.
             _comFac.ComponentsAdded += ComFacOnComponentsAdded;
@@ -248,7 +251,7 @@ namespace Robust.Shared.GameObjects
             void EventHandler(EntityUid uid, IComponent comp, ref TEvent args)
                 => handler(uid, (TComp)comp, args);
 
-            var orderData = new OrderingData(orderType, before ?? Array.Empty<Type>(), after ?? Array.Empty<Type>());
+            var orderData = CreateOrderingData(orderType, before, after);
 
             EntSubscribe<TEvent>(
                 CompIdx.Index<TComp>(),
@@ -281,7 +284,7 @@ namespace Robust.Shared.GameObjects
             void EventHandler(EntityUid uid, IComponent comp, ref TEvent args)
                 => handler(uid, (TComp)comp, ref args);
 
-            var orderData = new OrderingData(orderType, before ?? Array.Empty<Type>(), after ?? Array.Empty<Type>());
+            var orderData = CreateOrderingData(orderType, before, after);
 
             EntSubscribe<TEvent>(
                 CompIdx.Index<TComp>(),
@@ -300,7 +303,7 @@ namespace Robust.Shared.GameObjects
             void EventHandler(EntityUid uid, IComponent comp, ref TEvent args)
                 => handler(new Entity<TComp>(uid, (TComp) comp), ref args);
 
-            var orderData = new OrderingData(orderType, before ?? Array.Empty<Type>(), after ?? Array.Empty<Type>());
+            var orderData = CreateOrderingData(orderType, before, after);
 
             EntSubscribe<TEvent>(
                 CompIdx.Index<TComp>(),
@@ -327,7 +330,7 @@ namespace Robust.Shared.GameObjects
 
             foreach (var reg in regs)
             {
-                CompIdx.RefArray(ref _entSubscriptionsUnfrozen, reg.Idx) ??= new();
+                CompIdx.RefArray(ref _eventSubsUnfrozen, reg.Idx) ??= new();
             }
         }
 
@@ -351,29 +354,33 @@ namespace Robust.Shared.GameObjects
             _subscriptionLock = true;
             _eventData = _eventDataUnfrozen.ToFrozenDictionary();
 
-            _entSubscriptions = _entSubscriptionsUnfrozen
-                .Select(x => x?.ToFrozenDictionary())
+            // Find last non-null entry.
+            var last = 0;
+            for (var i = 0; i < _eventSubsUnfrozen.Length; i++)
+            {
+                var entry = _eventSubsUnfrozen[i];
+                if (entry != null)
+                    last = i;
+            }
+
+            // TODO PERFORMANCE
+            // make this only contain events that actually use comp-events
+            // Assuming it makes the frozen dictionaries more specialized and thus faster.
+            // AFAIK currently only MapInit is both a comp-event and a general event.
+            // It should probably be changed to just be a comp event.
+            _compEventSubs = _eventSubsUnfrozen
+                .Take(last+1)
+                .Select(dict => dict?.ToFrozenDictionary()!)
                 .ToArray();
 
-            _entSubscriptionsNoCompEv = _entSubscriptionsUnfrozen.Select(FreezeWithoutComponentEvent).ToArray();
+            _eventSubs = _eventSubsUnfrozen
+                .Take(last+1)
+                .Select(dict => dict?.Where(x => !IsComponentEvent(x.Key)).ToFrozenDictionary()!)
+                .ToArray();
 
             CalcOrdering();
         }
 
-        /// <summary>
-        /// Freezes a dictionary while committing events with the <see cref="ComponentEventAttribute"/>.
-        /// This avoids unnecessarily adding one-off events to the list of subscriptions.
-        /// </summary>
-        private FrozenDictionary<Type, DirectedRegistration>? FreezeWithoutComponentEvent(
-            Dictionary<Type, DirectedRegistration>? input)
-        {
-            if (input == null)
-                return null;
-
-            return input.Where(x => !IsComponentEvent(x.Key))
-                .ToFrozenDictionary();
-        }
-
         private bool IsComponentEvent(Type t)
         {
             var isCompEv = _eventData[t].ComponentEvent;
@@ -395,8 +402,8 @@ namespace Robust.Shared.GameObjects
             if (_subscriptionLock)
                 throw new InvalidOperationException("Subscription locked.");
 
-            if (compType.Value >= _entSubscriptionsUnfrozen.Length
-                || _entSubscriptionsUnfrozen[compType.Value] is not { } compSubs)
+            if (compType.Value >= _eventSubsUnfrozen.Length
+                || _eventSubsUnfrozen[compType.Value] is not { } compSubs)
             {
                 if (IgnoreUnregisteredComponents)
                     return;
@@ -411,10 +418,11 @@ namespace Robust.Shared.GameObjects
             }
 
             compSubs.Add(eventType, registration);
-            _entSubscriptionsInv.GetOrNew(eventType).Add(compType);
 
             RegisterCommon(eventType, registration.Ordering, out var data);
             data.ComponentEvent = eventType.HasCustomAttribute<ComponentEventAttribute>();
+            if (!data.ComponentEvent)
+                _eventSubsInv.GetOrNew(eventType).Add(compType);
         }
 
         private void EntSubscribe<TEvent>(
@@ -438,8 +446,8 @@ namespace Robust.Shared.GameObjects
             if (_subscriptionLock)
                 throw new InvalidOperationException("Subscription locked.");
 
-            if (compType.Value >= _entSubscriptionsUnfrozen.Length
-                || _entSubscriptionsUnfrozen[compType.Value] is not { } compSubs)
+            if (compType.Value >= _eventSubsUnfrozen.Length
+                || _eventSubsUnfrozen[compType.Value] is not { } compSubs)
             {
                 if (IgnoreUnregisteredComponents)
                     return;
@@ -449,7 +457,7 @@ namespace Robust.Shared.GameObjects
 
             var removed = compSubs.Remove(eventType);
             if (removed)
-                _entSubscriptionsInv[eventType].Remove(compType);
+                _eventSubsInv[eventType].Remove(compType);
         }
 
         private void EntAddEntity(EntityUid euid)
@@ -469,7 +477,7 @@ namespace Robust.Shared.GameObjects
             DebugTools.Assert(_subscriptionLock);
 
             var eventTable = _entEventTables[euid];
-            var compSubs = _entSubscriptionsNoCompEv[compType.Value]!;
+            var compSubs = _eventSubs[compType.Value];
 
             foreach (var evType in compSubs.Keys)
             {
@@ -528,13 +536,17 @@ namespace Robust.Shared.GameObjects
         private void EntRemoveComponent(EntityUid euid, CompIdx compType)
         {
             var eventTable = _entEventTables[euid];
-            var compSubs = _entSubscriptions[compType.Value]!;
+            var compSubs = _eventSubs[compType.Value];
 
             foreach (var evType in compSubs.Keys)
             {
+                DebugTools.Assert(!_eventData[evType].ComponentEvent);
                 ref var dictIdx = ref CollectionsMarshal.GetValueRefOrNullRef(eventTable.EventIndices, evType);
                 if (Unsafe.IsNullRef(ref dictIdx))
+                {
+                    DebugTools.Assert("This should not be possible. Were the events for this component never added?");
                     continue;
+                }
 
                 ref var updateNext = ref dictIdx;
 
@@ -610,9 +622,7 @@ namespace Robust.Shared.GameObjects
             ref Unit args)
             where TEvent : notnull
         {
-            var compSubs = _entSubscriptions[baseType.Value]!;
-
-            if (compSubs.TryGetValue(typeof(TEvent), out var reg))
+            if (_compEventSubs[baseType.Value].TryGetValue(typeof(TEvent), out var reg))
                 reg.Handler(euid, component, ref args);
         }
 
@@ -634,7 +644,7 @@ namespace Robust.Shared.GameObjects
                 return false;
             }
 
-            enumerator = new(eventType, startEntry, eventTable.ComponentLists, _entSubscriptions, euid, _entMan);
+            enumerator = new(eventType, startEntry, eventTable.ComponentLists, _eventSubs, euid, _entMan);
             return true;
         }
 
@@ -644,10 +654,10 @@ namespace Robust.Shared.GameObjects
             _eventDataUnfrozen.Clear();
             _entEventTables.Clear();
             _inverseEventSubscriptions.Clear();
-            _entSubscriptions = default!;
-            _entSubscriptionsNoCompEv = default!;
+            _compEventSubs = default!;
+            _eventSubs = default!;
             _eventData = FrozenDictionary<Type, EventData>.Empty;
-            foreach (var sub in _entSubscriptionsUnfrozen)
+            foreach (var sub in _eventSubsUnfrozen)
             {
                 sub?.Clear();
             }
@@ -660,18 +670,19 @@ namespace Robust.Shared.GameObjects
             // punishment for use-after-free
             _entMan = null!;
             _comFac = null!;
+            _reflection = null!;
             _entEventTables = null!;
-            _entSubscriptions = null!;
-            _entSubscriptionsNoCompEv = null!;
-            _entSubscriptionsUnfrozen = null!;
-            _entSubscriptionsInv = null!;
+            _compEventSubs = null!;
+            _eventSubs = null!;
+            _eventSubsUnfrozen = null!;
+            _eventSubsInv = null!;
         }
 
         private struct SubscriptionsEnumerator
         {
             private readonly Type _eventType;
             private readonly EntityUid _uid;
-            private readonly FrozenDictionary<Type, DirectedRegistration>?[] _subscriptions;
+            private readonly FrozenDictionary<Type, DirectedRegistration>[] _subscriptions;
             private readonly IEntityManager _entityManager;
             private readonly EventTableListEntry[] _list;
             private int _idx;
@@ -680,7 +691,7 @@ namespace Robust.Shared.GameObjects
                 Type eventType,
                 int startEntry,
                 EventTableListEntry[] list,
-                FrozenDictionary<Type, DirectedRegistration>?[] subscriptions,
+                FrozenDictionary<Type, DirectedRegistration>[] subscriptions,
                 EntityUid uid,
                 IEntityManager entityManager)
             {
@@ -707,7 +718,7 @@ namespace Robust.Shared.GameObjects
                 _idx = entry.Next;
 
                 var compType = entry.Component;
-                var compSubs = _subscriptions[compType.Value]!;
+                var compSubs = _subscriptions[compType.Value];
 
                 if (!compSubs.TryGetValue(_eventType, out registration))
                 {

Robust.Shared/GameObjects/EntityEventBus.Ordering.cs

@@ -59,10 +59,10 @@ namespace Robust.Shared.GameObjects
 
             // Collect all subscriptions, broadcast and ordered.
             IEnumerable<OrderedRegistration> regs = sub.BroadcastRegistrations;
-            if (_entSubscriptionsInv.TryGetValue(eventType, out var comps))
+            if (_eventSubsInv.TryGetValue(eventType, out var comps))
             {
                 regs = regs.Concat(comps
-                    .Select(c => _entSubscriptions[c.Value])
+                    .Select(c => _eventSubs[c.Value])
                     .Where(c => c != null)
                     .Select(c => c![eventType]));
             }
@@ -200,5 +200,33 @@ namespace Robust.Shared.GameObjects
                 }
             }
         }
+
+        private OrderingData CreateOrderingData(Type orderType, Type[]? before, Type[]? after)
+        {
+            AddChildrenTypes(ref before);
+            AddChildrenTypes(ref after);
+            return new OrderingData(orderType, before ?? [], after ?? []);
+        }
+
+        private void AddChildrenTypes(ref Type[]? original)
+        {
+            if (original == null || original.Length == 0)
+                return;
+
+            _childrenTypesTemp.Clear();
+            foreach (var beforeType in original)
+            {
+                foreach (var child in _reflection.GetAllChildren(beforeType))
+                {
+                    _childrenTypesTemp.Add(child);
+                }
+            }
+
+            if (_childrenTypesTemp.Count > 0)
+            {
+                Array.Resize(ref original, original.Length + _childrenTypesTemp.Count);
+                _childrenTypesTemp.CopyTo(original, original.Length - _childrenTypesTemp.Count);
+            }
+        }
     }
 }

Robust.Shared/GameObjects/EntityManager.Components.cs

@@ -36,8 +36,6 @@ namespace Robust.Shared.GameObjects
         private const int EntityCapacity = 1024;
         private const int NetComponentCapacity = 8;
 
-        private static readonly IComponentState DefaultComponentState = new ComponentState();
-
         private FrozenDictionary<Type, Dictionary<EntityUid, IComponent>> _entTraitDict
             = FrozenDictionary<Type, Dictionary<EntityUid, IComponent>>.Empty;
 
@@ -114,7 +112,7 @@ namespace Robust.Shared.GameObjects
         public void InitializeComponents(EntityUid uid, MetaDataComponent? metadata = null)
         {
             DebugTools.AssertOwner(uid, metadata);
-            metadata ??= GetComponent<MetaDataComponent>(uid);
+            metadata ??= MetaQuery.GetComponent(uid);
             DebugTools.Assert(metadata.EntityLifeStage == EntityLifeStage.PreInit);
             SetLifeStage(metadata, EntityLifeStage.Initializing);
 
@@ -158,13 +156,12 @@ namespace Robust.Shared.GameObjects
             // TODO: please for the love of god remove these initialization order hacks.
 
             // Init transform first, we always have it.
-            var transform = GetComponent<TransformComponent>(uid);
+            var transform = TransformQuery.GetComponent(uid);
             if (transform.LifeStage == ComponentLifeStage.Initialized)
                 LifeStartup(transform);
 
             // Init physics second if it exists.
-            if (TryGetComponent<PhysicsComponent>(uid, out var phys)
-                && phys.LifeStage == ComponentLifeStage.Initialized)
+            if (_physicsQuery.TryComp(uid, out var phys) && phys.LifeStage == ComponentLifeStage.Initialized)
             {
                 LifeStartup(phys);
             }
@@ -294,7 +291,7 @@ namespace Robust.Shared.GameObjects
             if (!uid.IsValid() || !EntityExists(uid))
                 throw new ArgumentException($"Entity {uid} is not valid.", nameof(uid));
 
-            AddComponentInternal(uid, newComponent, false, true);
+            AddComponentInternal(uid, newComponent, false, true, null);
 
             return new CompInitializeHandle<T>(this, uid, newComponent, reg.Idx);
         }
@@ -302,10 +299,11 @@ namespace Robust.Shared.GameObjects
         /// <inheritdoc />
         public void AddComponent<T>(EntityUid uid, T component, bool overwrite = false, MetaDataComponent? metadata = null) where T : IComponent
         {
-            if (!uid.IsValid() || !EntityExists(uid))
+            if (!MetaQuery.Resolve(uid, ref metadata, false))
                 throw new ArgumentException($"Entity {uid} is not valid.", nameof(uid));
 
-            if (component == null) throw new ArgumentNullException(nameof(component));
+            if (component == null)
+                throw new ArgumentNullException(nameof(component));
 
 #pragma warning disable CS0618 // Type or member is obsolete
             if (component.Owner == default)
@@ -321,14 +319,17 @@ namespace Robust.Shared.GameObjects
             AddComponentInternal(uid, component, overwrite, false, metadata);
         }
 
-        private void AddComponentInternal<T>(EntityUid uid, T component, bool overwrite, bool skipInit, MetaDataComponent? metadata = null) where T : IComponent
+        private void AddComponentInternal<T>(EntityUid uid, T component, bool overwrite, bool skipInit, MetaDataComponent? metadata) where T : IComponent
         {
+            if (!MetaQuery.ResolveInternal(uid, ref metadata, false))
+                throw new ArgumentException($"Entity {uid} is not valid.", nameof(uid));
+
             // get interface aliases for mapping
             var reg = _componentFactory.GetRegistration(component);
             AddComponentInternal(uid, component, reg, overwrite, skipInit, metadata);
         }
 
-        private void AddComponentInternal<T>(EntityUid uid, T component, ComponentRegistration reg, bool overwrite, bool skipInit, MetaDataComponent? metadata = null) where T : IComponent
+        private void AddComponentInternal<T>(EntityUid uid, T component, ComponentRegistration reg, bool overwrite, bool skipInit, MetaDataComponent metadata) where T : IComponent
         {
             // We can't use typeof(T) here in case T is just Component
             DebugTools.Assert(component is MetaDataComponent ||
@@ -642,13 +643,14 @@ namespace Robust.Shared.GameObjects
                 _runtimeLog.LogException(e, nameof(CullRemovedComponents));
             }
 #endif
-                DeleteComponent(uid, component, false);
+                var meta = MetaQuery.GetComponent(uid);
+                DeleteComponent(uid, component, false, meta);
             }
 
             _deleteSet.Clear();
         }
 
-        private void DeleteComponent(EntityUid entityUid, IComponent component, bool terminating, MetaDataComponent? metadata = null)
+        private void DeleteComponent(EntityUid entityUid, IComponent component, bool terminating, MetaDataComponent? metadata)
         {
             if (!MetaQuery.ResolveInternal(entityUid, ref metadata))
                 return;
@@ -1400,13 +1402,13 @@ namespace Robust.Shared.GameObjects
         }
 
         /// <inheritdoc />
-        public IComponentState GetComponentState(IEventBus eventBus, IComponent component, ICommonSession? session, GameTick fromTick)
+        public IComponentState? GetComponentState(IEventBus eventBus, IComponent component, ICommonSession? session, GameTick fromTick)
         {
             DebugTools.Assert(component.NetSyncEnabled, $"Attempting to get component state for an un-synced component: {component.GetType()}");
             var getState = new ComponentGetState(session, fromTick);
             eventBus.RaiseComponentEvent(component, ref getState);
 
-            return getState.State ?? DefaultComponentState;
+            return getState.State;
         }
 
         public bool CanGetComponentState(IEventBus eventBus, IComponent component, ICommonSession player)
@@ -1519,7 +1521,7 @@ namespace Robust.Shared.GameObjects
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         [Pure]
-        public bool TryComp(EntityUid? uid, [NotNullWhen(true)] out TComp1? component)
+        public bool TryComp([NotNullWhen(true)] EntityUid? uid, [NotNullWhen(true)] out TComp1? component)
             => TryGetComponent(uid, out component);
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -1582,6 +1584,13 @@ namespace Robust.Shared.GameObjects
             return default;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        [Pure]
+        public TComp1 Comp(EntityUid uid)
+        {
+            return GetComponent(uid);
+        }
+
         #region Internal
 
         /// <summary>

Robust.Shared/GameObjects/EntityManager.cs

@@ -11,9 +11,11 @@ using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Maths;
 using Robust.Shared.Network;
+using Robust.Shared.Physics.Components;
 using Robust.Shared.Player;
 using Robust.Shared.Profiling;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Reflection;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Timing;
@@ -39,6 +41,7 @@ namespace Robust.Shared.GameObjects
         [IoC.Dependency] private readonly ISerializationManager _serManager = default!;
         [IoC.Dependency] private readonly ProfManager _prof = default!;
         [IoC.Dependency] private readonly INetManager _netMan = default!;
+        [IoC.Dependency] private readonly IReflectionManager _reflection = default!;
 
         // I feel like PJB might shed me for putting a system dependency here, but its required for setting entity
         // positions on spawn....
@@ -47,6 +50,7 @@ namespace Robust.Shared.GameObjects
 
         public EntityQuery<MetaDataComponent> MetaQuery;
         public EntityQuery<TransformComponent> TransformQuery;
+        private EntityQuery<PhysicsComponent> _physicsQuery;
         private EntityQuery<ActorComponent> _actorQuery;
 
         #endregion Dependencies
@@ -123,7 +127,7 @@ namespace Robust.Shared.GameObjects
             if (Initialized)
                 throw new InvalidOperationException("Initialize() called multiple times");
 
-            _eventBus = new EntityEventBus(this);
+            _eventBus = new EntityEventBus(this, _reflection);
 
             InitializeComponents();
             _metaReg = _componentFactory.GetRegistration(typeof(MetaDataComponent));
@@ -210,6 +214,7 @@ namespace Robust.Shared.GameObjects
             _containers = System<SharedContainerSystem>();
             MetaQuery = GetEntityQuery<MetaDataComponent>();
             TransformQuery = GetEntityQuery<TransformComponent>();
+            _physicsQuery = GetEntityQuery<PhysicsComponent>();
             _actorQuery = GetEntityQuery<ActorComponent>();
         }
 
@@ -278,6 +283,7 @@ namespace Robust.Shared.GameObjects
 
         #region Entity Management
 
+        /// <inheritdoc />
         public EntityUid CreateEntityUninitialized(string? prototypeName, EntityUid euid, ComponentRegistry? overrides = null)
         {
             return CreateEntity(prototypeName, out _, overrides);
@@ -318,7 +324,7 @@ namespace Robust.Shared.GameObjects
             if (transform.Anchored && _mapManager.TryFindGridAt(coordinates, out var gridUid, out var grid))
             {
                 coords = new EntityCoordinates(gridUid, _mapSystem.WorldToLocal(gridUid, grid, coordinates.Position));
-                _xforms.SetCoordinates(newEntity, transform, coords, unanchor: false);
+                _xforms.SetCoordinates(newEntity, transform, coords, rotation, unanchor: false);
             }
             else
             {
@@ -551,17 +557,7 @@ namespace Robust.Shared.GameObjects
 
             // Detach the base entity to null before iterating over children
             // This also ensures that the entity-lookup updates don't have to be re-run for every child (which recurses up the transform hierarchy).
-            if (transform.ParentUid != EntityUid.Invalid)
-            {
-                try
-                {
-                    _xforms.DetachParentToNull((uid, transform, metadata), parentXform, true);
-                }
-                catch (Exception e)
-                {
-                    _sawmill.Error($"Caught exception while trying to detach parent of entity '{ToPrettyString(uid, metadata)}' to null.\n{e}");
-                }
-            }
+            _xforms.DetachEntity(uid, transform, metadata, parentXform, true);
 
             foreach (var child in transform._children)
             {

Robust.Shared/GameObjects/EntityState.cs

@@ -38,11 +38,10 @@ namespace Robust.Shared.GameObjects
     [Serializable, NetSerializable]
     public readonly struct ComponentChange
     {
-        // 15ish bytes to create a component (strings are big), 5 bytes to remove one
-
+        /// <summary>
         /// State data for the created/modified component, if any.
         /// </summary>
-        public readonly IComponentState State;
+        public readonly IComponentState? State;
 
         /// <summary>
         ///     The Network ID of the component to remove.
@@ -51,7 +50,7 @@ namespace Robust.Shared.GameObjects
 
         public readonly GameTick LastModifiedTick;
 
-        public ComponentChange(ushort netId, IComponentState state, GameTick lastModifiedTick)
+        public ComponentChange(ushort netId, IComponentState? state, GameTick lastModifiedTick)
         {
             State = state;
             NetID = netId;

Robust.Shared/GameObjects/EntitySystem.Subscriptions.cs

@@ -109,6 +109,17 @@ namespace Robust.Shared.GameObjects
             _subscriptions.Add(new SubBroadcast<EntitySessionMessage<T>>(src));
         }
 
+        protected void SubscribeLocalEvent<TComp, TEvent>(
+            EntityEventRefHandler<TComp, TEvent> handler,
+            Type[]? before = null, Type[]? after = null)
+            where TComp : IComponent
+            where TEvent : notnull
+        {
+            EntityManager.EventBus.SubscribeLocalEvent(handler, GetType(), before, after);
+
+            _subscriptions.Add(new SubLocal<TComp, TEvent>());
+        }
+
         /// <seealso cref="SubscribeLocalEvent{TComp, TEvent}(ComponentEventRefHandler{TComp, TEvent}, Type[], Type[])"/>
         // [Obsolete("Subscribe to the event by ref instead (ComponentEventRefHandler)")]
         protected void SubscribeLocalEvent<TComp, TEvent>(
@@ -133,17 +144,6 @@ namespace Robust.Shared.GameObjects
             _subscriptions.Add(new SubLocal<TComp, TEvent>());
         }
 
-        protected void SubscribeLocalEvent<TComp, TEvent>(
-            EntityEventRefHandler<TComp, TEvent> handler,
-            Type[]? before = null, Type[]? after = null)
-            where TComp : IComponent
-            where TEvent : notnull
-        {
-            EntityManager.EventBus.SubscribeLocalEvent(handler, GetType(), before, after);
-
-            _subscriptions.Add(new SubLocal<TComp, TEvent>());
-        }
-
         private void ShutdownSubscriptions()
         {
             foreach (var sub in _subscriptions)

Robust.Shared/GameObjects/EntitySystemMessages/EntParentChangedMessage.cs

@@ -19,26 +19,26 @@ namespace Robust.Shared.GameObjects
         public EntityUid? OldParent { get; }
 
         /// <summary>
-        ///     The map Id that the entity was on before its parent changed.
+        ///     The map that the entity was on before its parent changed.
         /// </summary>
         /// <remarks>
         ///     If the old parent was detached to null without manually updating the map ID of its children, then this
         ///     is required as we cannot simply use the old parent's map ID. Also avoids having to fetch the old
         ///     parent's transform component.
         /// </remarks>
-        public MapId OldMapId { get; }
+        public readonly EntityUid? OldMapId;
 
         public TransformComponent Transform { get; }
 
         /// <summary>
         ///     Creates a new instance of <see cref="EntParentChangedMessage"/>.
         /// </summary>
-        public EntParentChangedMessage(EntityUid entity, EntityUid? oldParent, MapId oldMapId, TransformComponent xform)
+        public EntParentChangedMessage(EntityUid entity, EntityUid? oldParent, EntityUid? oldMapId, TransformComponent xform)
         {
             Entity = entity;
             OldParent = oldParent;
-            OldMapId = oldMapId;
             Transform = xform;
+            OldMapId = oldMapId;
         }
     }
 }

Robust.Shared/GameObjects/IComponentFactory.cs

@@ -160,6 +160,9 @@ namespace Robust.Shared.GameObjects
         [Pure]
         string GetComponentName(Type componentType);
 
+        [Pure]
+        string GetComponentName<T>() where T : IComponent, new();
+
         /// <summary>
         ///     Gets the name of a component, throwing an exception if it does not exist.
         /// </summary>

Robust.Shared/GameObjects/IEntityManager.Components.cs

@@ -404,7 +404,7 @@ namespace Robust.Shared.GameObjects
         /// <param name="player">The player that is going to receive this state. Null implies that this state is for a replay.</param>
         /// <param name="fromTick">The from tick, which indicates the range of data that must be included for delta-states.</param>
         /// <returns>The component state of the component.</returns>
-        IComponentState GetComponentState(IEventBus eventBus, IComponent component, ICommonSession? player, GameTick fromTick);
+        IComponentState? GetComponentState(IEventBus eventBus, IComponent component, ICommonSession? player, GameTick fromTick);
 
         /// <summary>
         ///     Checks if a certain player should get a component state.

Robust.Shared/GameObjects/IEntityManager.cs

@@ -71,12 +71,43 @@ namespace Robust.Shared.GameObjects
         /// </summary>
         public event Action? AfterEntityFlush;
 
+        /// <summary>
+        /// Creates an uninitialized entity.
+        /// </summary>
+        /// <param name="prototypeName"><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></param>
+        /// <param name="euid">Does nothing. Used to be the forced EntityUid of the new entity.</param>
+        /// <param name="overrides"><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></param>
+        /// <returns><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></returns>
+        [Obsolete($"Use one of the other {nameof(CreateEntityUninitialized)} overloads. euid no longer does anything.")]
         EntityUid CreateEntityUninitialized(string? prototypeName, EntityUid euid, ComponentRegistry? overrides = null);
 
+        /// <summary>
+        /// Creates an uninitialized entity.
+        /// </summary>
+        /// <param name="prototypeName"><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></param>
+        /// <param name="overrides"><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></param>
+        /// <returns><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></returns>
         EntityUid CreateEntityUninitialized(string? prototypeName, ComponentRegistry? overrides = null);
 
+        /// <summary>
+        /// Creates an uninitialized entity and sets its position to the EntityCoordinates provided.
+        /// </summary>
+        /// <param name="prototypeName"><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></param>
+        /// <param name="coordinates">Coordinates to set position and parent of the newly spawned entity to.</param>
+        /// <param name="overrides"><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></param>
+        /// <returns><inheritdoc cref="CreateEntityUninitialized(string?, MapCoordinates , ComponentRegistry?, Angle)"/></returns>
         EntityUid CreateEntityUninitialized(string? prototypeName, EntityCoordinates coordinates, ComponentRegistry? overrides = null);
 
+        /// <summary>
+        /// Creates an uninitialized entity and puts it on the grid or map at the MapCoordinates provided.
+        /// </summary>
+        /// <param name="prototypeName">Name of the <see cref="EntityPrototype"/> to spawn.</param>
+        /// <param name="coordinates">Coordinates to place the newly spawned entity.</param>
+        /// <param name="overrides">Overrides to add or remove components that differ from the prototype.</param>
+        /// <param name="rotation">Map rotation to set the newly spawned entity to.</param>
+        /// <returns>A new uninitialized entity.</returns>
+        /// <remarks>If there is a grid at the <paramref name="coordinates"/>, the entity will be parented to the grid.
+        /// Otherwise, it will be parented to the map.</remarks>
         EntityUid CreateEntityUninitialized(string? prototypeName, MapCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default!);
 
         void InitializeAndStartEntity(EntityUid entity, MapId? mapId = null);

Robust.Shared/GameObjects/Systems/EntityLookupSystem.cs

@@ -125,7 +125,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
         SubscribeLocalEvent<GridAddEvent>(OnGridAdd);
         SubscribeLocalEvent<MapChangedEvent>(OnMapChange);
 
-        _transform.OnGlobalMoveEvent += OnMove;
+        _transform.OnBeforeMoveEvent += OnMove;
         EntityManager.EntityInitialized += OnEntityInit;
 
         SubscribeLocalEvent<TransformComponent, PhysicsBodyTypeChangedEvent>(OnBodyTypeChange);
@@ -142,7 +142,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
     {
         base.Shutdown();
         EntityManager.EntityInitialized -= OnEntityInit;
-        _transform.OnGlobalMoveEvent -= OnMove;
+        _transform.OnBeforeMoveEvent -= OnMove;
     }
 
     #region DynamicTree

Robust.Shared/GameObjects/Systems/PrototypeReloadSystem.cs

@@ -24,7 +24,7 @@ internal sealed class PrototypeReloadSystem : EntitySystem
         if (!eventArgs.ByType.TryGetValue(typeof(EntityPrototype), out var set))
             return;
 
-        var query = EntityQueryEnumerator<MetaDataComponent>();
+        var query = AllEntityQuery<MetaDataComponent>();
         while (query.MoveNext(out var uid, out var metadata))
         {
             var id = metadata.EntityPrototype?.ID;

Robust.Shared/GameObjects/Systems/SharedGridTraversalSystem.cs

@@ -26,7 +26,6 @@ internal sealed class SharedGridTraversalSystem : EntitySystem
     {
         base.Initialize();
         SubscribeLocalEvent<TransformStartupEvent>(OnStartup);
-        _transform.OnGlobalMoveEvent += OnMove;
     }
 
     private void OnStartup(ref TransformStartupEvent ev)
@@ -34,17 +33,6 @@ internal sealed class SharedGridTraversalSystem : EntitySystem
         CheckTraverse(ev.Entity.Owner, ev.Entity.Comp);
     }
 
-    public override void Shutdown()
-    {
-        _transform.OnGlobalMoveEvent -= OnMove;
-    }
-
-    private void OnMove(ref MoveEvent moveEv)
-    {
-        CheckTraverse(moveEv.Sender, moveEv.Component);
-    }
-
-
     internal void CheckTraverse(EntityUid uid, TransformComponent xform)
     {
         if (!Enabled || _timing.ApplyingState)

Robust.Shared/GameObjects/Systems/SharedMapSystem.Grid.cs

@@ -244,40 +244,51 @@ public abstract partial class SharedMapSystem
 
     private void OnGridHandleState(EntityUid uid, MapGridComponent component, ref ComponentHandleState args)
     {
-        if (args.Current is not MapGridComponentState state)
-            return;
-
-        DebugTools.Assert(component.ChunkSize == state.ChunkSize || component.Chunks.Count == 0,
-            "Can't modify chunk size of an existing grid.");
-
-        component.ChunkSize = state.ChunkSize;
-        if (state.ChunkData == null && state.FullGridData == null)
-            return;
-
-        var modifiedChunks = new HashSet<MapChunk>();
-
-        // delta state
-        if (state.ChunkData != null)
+        HashSet<MapChunk> modifiedChunks;
+        switch (args.Current)
         {
-            foreach (var chunkData in state.ChunkData)
+            case MapGridComponentDeltaState delta:
             {
-                ApplyChunkData(uid, component, chunkData, modifiedChunks);
-            }
-        }
+                modifiedChunks = new();
+                DebugTools.Assert(component.ChunkSize == delta.ChunkSize || component.Chunks.Count == 0,
+                    "Can't modify chunk size of an existing grid.");
 
-        // full state
-        if (state.FullGridData != null)
-        {
-            foreach (var index in component.Chunks.Keys)
-            {
-                if (!state.FullGridData.ContainsKey(index))
-                    ApplyChunkData(uid, component, ChunkDatum.CreateDeleted(index), modifiedChunks);
-            }
+                component.ChunkSize = delta.ChunkSize;
+                if (delta.ChunkData == null)
+                    return;
 
-            foreach (var (index, tiles) in state.FullGridData)
-            {
-                ApplyChunkData(uid, component, ChunkDatum.CreateModified(index, tiles), modifiedChunks);
+                foreach (var chunkData in delta.ChunkData)
+                {
+                    ApplyChunkData(uid, component, chunkData, modifiedChunks);
+                }
+
+                component.LastTileModifiedTick = delta.LastTileModifiedTick;
+                break;
             }
+            case MapGridComponentState state:
+            {
+                modifiedChunks = new();
+                DebugTools.Assert(component.ChunkSize == state.ChunkSize || component.Chunks.Count == 0,
+                    "Can't modify chunk size of an existing grid.");
+
+                component.LastTileModifiedTick = state.LastTileModifiedTick;
+                component.ChunkSize = state.ChunkSize;
+
+                foreach (var index in component.Chunks.Keys)
+                {
+                    if (!state.FullGridData.ContainsKey(index))
+                        ApplyChunkData(uid, component, ChunkDatum.CreateDeleted(index), modifiedChunks);
+                }
+
+                foreach (var (index, tiles) in state.FullGridData)
+                {
+                    ApplyChunkData(uid, component, ChunkDatum.CreateModified(index, tiles), modifiedChunks);
+                }
+
+                break;
+            }
+            default:
+                return;
         }
 
         var count = component.Chunks.Count;
@@ -409,7 +420,7 @@ public abstract partial class SharedMapSystem
             }
         }
 
-        args.State = new MapGridComponentState(component.ChunkSize, chunkData);
+        args.State = new MapGridComponentDeltaState(component.ChunkSize, chunkData, component.LastTileModifiedTick);
 
 #if DEBUG
         if (chunkData == null)
@@ -445,7 +456,7 @@ public abstract partial class SharedMapSystem
             chunkData.Add(index, tileBuffer);
         }
 
-        args.State = new MapGridComponentState(component.ChunkSize, chunkData);
+        args.State = new MapGridComponentState(component.ChunkSize, chunkData, component.LastTileModifiedTick);
 
 #if DEBUG
         foreach (var chunk in chunkData.Values)

Robust.Shared/GameObjects/Systems/SharedMapSystem.cs

@@ -145,6 +145,11 @@ namespace Robust.Shared.GameObjects
             ChunkIndex = chunkIndex;
         }
 
+        /// <summary>
+        /// Was the tile previously empty or is it now empty.
+        /// </summary>
+        public bool EmptyChanged => OldTile.IsEmpty != NewTile.Tile.IsEmpty;
+
         /// <summary>
         ///     EntityUid of the grid with the tile-change. TileRef stores the GridId.
         /// </summary>

Robust.Shared/GameObjects/Systems/SharedTransformSystem.Component.cs

@@ -5,6 +5,7 @@ using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Utility;
 using System;
+using System.Diagnostics;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using Robust.Shared.Map.Components;
@@ -43,21 +44,13 @@ public abstract partial class SharedTransformSystem
         xform._anchored = true;
         var oldPos = xform._localPosition;
         var oldRot = xform._localRotation;
+        var oldMap = xform.MapUid;
         xform._localPosition = tilePos + newGrid.TileSizeHalfVector;
         xform._localRotation += rotation;
 
         SetGridId(uid, xform, newGridUid, XformQuery);
-        var reParent = new EntParentChangedMessage(uid, oldGridUid, xform.MapID, xform);
-        RaiseLocalEvent(uid, ref reParent, true);
         var meta = MetaData(uid);
-        var movEevee = new MoveEvent((uid, xform, meta),
-            new EntityCoordinates(oldGridUid, oldPos),
-            new EntityCoordinates(newGridUid, xform._localPosition),
-            oldRot,
-            xform.LocalRotation,
-            _gameTiming.ApplyingState);
-        RaiseLocalEvent(uid, ref movEevee);
-        InvokeGlobalMoveEvent(ref movEevee);
+        RaiseMoveEvent((uid, xform, meta), oldGridUid, oldPos, oldRot, oldMap);
 
         DebugTools.Assert(XformQuery.GetComponent(oldGridUid).MapID == XformQuery.GetComponent(newGridUid).MapID);
         DebugTools.Assert(xform._anchored);
@@ -321,7 +314,7 @@ public abstract partial class SharedTransformSystem
 
         // I hate this too. Once again, required for shit like containers because they CBF doing their own init logic
         // and rely on parent changed messages instead. Might also be used by broadphase stuff?
-        var parentEv = new EntParentChangedMessage(uid, null, MapId.Nullspace, xform);
+        var parentEv = new EntParentChangedMessage(uid, null, null, xform);
         RaiseLocalEvent(uid, ref parentEv, true);
 
         var ev = new TransformStartupEvent((uid, xform));
@@ -449,9 +442,6 @@ public abstract partial class SharedTransformSystem
             return;
         }
 
-        var oldPosition = xform._parent.IsValid() ? new EntityCoordinates(xform._parent, xform._localPosition) : default;
-        var oldRotation = xform._localRotation;
-
         if (xform.Anchored && unanchor)
             Unanchor(uid, xform);
 
@@ -470,6 +460,11 @@ public abstract partial class SharedTransformSystem
             }
         }
 
+        var oldParentUid = xform._parent;
+        var oldPosition = xform._localPosition;
+        var oldRotation = xform._localRotation;
+        var oldMap = xform.MapUid;
+
         // Set new values
         Dirty(uid, xform, meta);
         xform.MatricesDirty = true;
@@ -485,7 +480,7 @@ public abstract partial class SharedTransformSystem
         {
             if (value.EntityId == uid)
             {
-                DetachParentToNull(uid, xform);
+                DetachEntity(uid, xform);
                 if (_netMan.IsServer || IsClientSide(uid))
                     QueueDel(uid);
                 throw new InvalidOperationException($"Attempted to parent an entity to itself: {ToPrettyString(uid)}");
@@ -495,7 +490,7 @@ public abstract partial class SharedTransformSystem
             {
                 if (!XformQuery.Resolve(value.EntityId, ref newParent, false))
                 {
-                    DetachParentToNull(uid, xform);
+                    DetachEntity(uid, xform);
                     if (_netMan.IsServer || IsClientSide(uid))
                         QueueDel(uid);
                     throw new InvalidOperationException($"Attempted to parent entity {ToPrettyString(uid)} to non-existent entity {value.EntityId}");
@@ -503,7 +498,7 @@ public abstract partial class SharedTransformSystem
 
                 if (newParent.LifeStage >= ComponentLifeStage.Stopping || LifeStage(value.EntityId) >= EntityLifeStage.Terminating)
                 {
-                    DetachParentToNull(uid, xform);
+                    DetachEntity(uid, xform);
                     if (_netMan.IsServer || IsClientSide(uid))
                         QueueDel(uid);
                     throw new InvalidOperationException($"Attempted to re-parent to a terminating object. Entity: {ToPrettyString(uid)}, new parent: {ToPrettyString(value.EntityId)}");
@@ -528,7 +523,7 @@ public abstract partial class SharedTransformSystem
                             // Even though its temporary, this can still cause the client to get stuck in infinite loops while applying the game state.
                             // So we will just break the loop by detaching to null and just trusting that the loop wasn't actually a real feature of the server state.
                             Log.Warning($"Encountered circular transform hierarchy while applying state for entity: {ToPrettyString(uid)}. Detaching child to null: {ToPrettyString(recursiveUid)}");
-                            DetachParentToNull(recursiveUid, recursiveXform);
+                            DetachEntity(recursiveUid, recursiveXform);
                             break;
                         }
 
@@ -545,7 +540,6 @@ public abstract partial class SharedTransformSystem
             newParent?._children.Add(uid);
 
             xform._parent = value.EntityId;
-            var oldMapId = xform.MapID;
 
             if (newParent != null)
             {
@@ -576,24 +570,18 @@ public abstract partial class SharedTransformSystem
                     xform._localRotation += GetWorldRotation(oldParent) - GetWorldRotation(newParent);
 
                 DebugTools.Assert(!xform.NoLocalRotation || xform.LocalRotation == 0);
-
-                var entParentChangedMessage = new EntParentChangedMessage(uid, oldParent?.Owner, oldMapId, xform);
-                RaiseLocalEvent(uid, ref entParentChangedMessage, true);
             }
         }
 
         if (!xform.Initialized)
             return;
 
-        var newPosition = xform._parent.IsValid() ? new EntityCoordinates(xform._parent, xform._localPosition) : default;
 #if DEBUG
         // If an entity is parented to the map, its grid uid should be null (unless it is itself a grid or we have a map-grid)
         if (xform.ParentUid == xform.MapUid)
             DebugTools.Assert(xform.GridUid == null || xform.GridUid == uid || xform.GridUid == xform.MapUid);
 #endif
-        var moveEvent = new MoveEvent((uid, xform, meta), oldPosition, newPosition, oldRotation, xform._localRotation, _gameTiming.ApplyingState);
-        RaiseLocalEvent(uid, ref moveEvent);
-        InvokeGlobalMoveEvent(ref moveEvent);
+        RaiseMoveEvent(entity, oldParentUid, oldPosition, oldRotation, oldMap);
     }
 
     public void SetCoordinates(
@@ -668,13 +656,13 @@ public abstract partial class SharedTransformSystem
 
     public void SetParent(EntityUid uid, TransformComponent xform, EntityUid parent, EntityQuery<TransformComponent> xformQuery, TransformComponent? parentXform = null)
     {
-        DebugTools.Assert(uid == xform.Owner);
+        DebugTools.AssertOwner(uid, xform);
         if (xform.ParentUid == parent)
             return;
 
         if (!parent.IsValid())
         {
-            DetachParentToNull(uid, xform);
+            DetachEntity(uid, xform);
             return;
         }
 
@@ -976,7 +964,7 @@ public abstract partial class SharedTransformSystem
             // Entity was not actually in the transform hierarchy. This is probably a sign that something is wrong, or that the function is being misused.
             Log.Warning($"Target entity ({ToPrettyString(relative)}) not in transform hierarchy while calling {nameof(GetRelativePositionRotation)}.");
             var relXform = query.GetComponent(relative);
-            pos = relXform.InvWorldMatrix.Transform(pos);
+            pos = GetInvWorldMatrix(relXform).Transform(pos);
             break;
         }
 
@@ -990,7 +978,6 @@ public abstract partial class SharedTransformSystem
         SetWorldPosition(xform, worldPos);
     }
 
-
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetWorldPosition(TransformComponent component, Vector2 worldPos)
     {
@@ -1048,6 +1035,16 @@ public abstract partial class SharedTransformSystem
         return rotation;
     }
 
+    public void SetWorldRotationNoLerp(Entity<TransformComponent?> entity, Angle angle)
+    {
+        if (!XformQuery.Resolve(entity.Owner, ref entity.Comp))
+            return;
+
+        var current = GetWorldRotation(entity.Comp);
+        var diff = angle - current;
+        SetLocalRotationNoLerp(entity, entity.Comp.LocalRotation + diff);
+    }
+
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public void SetWorldRotation(EntityUid uid, Angle angle)
     {
@@ -1143,7 +1140,8 @@ public abstract partial class SharedTransformSystem
         if (xform._localPosition.EqualsApprox(pos) && xform.LocalRotation.EqualsApprox(rot))
             return;
 
-        var oldPosition = xform.Coordinates;
+        var oldParent = xform._parent;
+        var oldPosition = xform._localPosition;
         var oldRotation = xform.LocalRotation;
 
         if (!xform.Anchored)
@@ -1161,9 +1159,7 @@ public abstract partial class SharedTransformSystem
         if (!xform.Initialized)
             return;
 
-        var moveEvent = new MoveEvent((uid, xform, meta), oldPosition, xform.Coordinates, oldRotation, rot, _gameTiming.ApplyingState);
-        RaiseLocalEvent(uid, ref moveEvent);
-        InvokeGlobalMoveEvent(ref moveEvent);
+        RaiseMoveEvent((uid, xform, meta), oldParent, oldPosition, oldRotation, xform.MapUid);
     }
 
     #endregion
@@ -1326,7 +1322,7 @@ public abstract partial class SharedTransformSystem
             if (!_mapManager.IsMap(uid))
                 Log.Warning($"Failed to attach entity to map or grid. Entity: ({ToPrettyString(uid)}). Trace: {Environment.StackTrace}");
 
-            DetachParentToNull(uid, xform);
+            DetachEntity(uid, xform);
             return;
         }
 
@@ -1362,21 +1358,50 @@ public abstract partial class SharedTransformSystem
 
     #region State Handling
 
+    [Obsolete("Use DetachEntity")]
     public void DetachParentToNull(EntityUid uid, TransformComponent xform)
+        => DetachEntity(uid, xform);
+
+    /// <inheritdoc cref="DetachEntityInternal"/>
+    public void DetachEntity(EntityUid uid, TransformComponent xform)
     {
         XformQuery.TryGetComponent(xform.ParentUid, out var oldXform);
-        DetachParentToNull(uid, xform, oldXform);
+        DetachEntity(uid, xform, MetaData(uid), oldXform);
     }
 
-    public void DetachParentToNull(EntityUid uid, TransformComponent xform, TransformComponent? oldXform)
+    /// <inheritdoc cref="DetachEntityInternal"/>
+    public void DetachEntity(
+        EntityUid uid,
+        TransformComponent xform,
+        MetaDataComponent meta,
+        TransformComponent? oldXform,
+        bool terminating = false)
     {
-        DetachParentToNull((uid, xform, MetaData(uid)), oldXform);
+#if !EXCEPTION_TOLERANCE
+        DetachEntityInternal(uid, xform, meta, oldXform, terminating);
+#else
+        try
+        {
+            DetachEntityInternal(uid, xform, meta, oldXform, terminating);
+        }
+        catch (Exception e)
+        {
+            Log.Error($"Caught exception while attempting to detach an entity to nullspace. Entity: {ToPrettyString(uid, meta)}. Exception: {e}");
+            // TODO detach without content event handling.
+        }
+#endif
     }
 
-    public void DetachParentToNull(Entity<TransformComponent,MetaDataComponent> entity, TransformComponent? oldXform, bool terminating = false)
+    /// <summary>
+    /// Remove an entity from the transform hierarchy and send it to null space
+    /// </summary>
+    internal void DetachEntityInternal(
+        EntityUid uid,
+        TransformComponent xform,
+        MetaDataComponent meta,
+        TransformComponent? oldXform,
+        bool terminating = false)
     {
-        var (uid, xform, meta) = entity;
-
         if (!terminating && meta.EntityLifeStage >= EntityLifeStage.Terminating)
         {
             // Something is attempting to remove the entity from this entity's parent while it is in the process of being deleted.
@@ -1393,15 +1418,14 @@ public abstract partial class SharedTransformSystem
             DebugTools.Assert((MetaData(uid).Flags & MetaDataFlags.InContainer) == 0x0,
                 $"Entity is in a container but has no parent? Entity: {ToPrettyString(uid)}");
 
-            if (xform.Broadphase != null)
-            {
-                DebugTools.Assert(
-                    xform.Broadphase == BroadphaseData.Invalid
-                    || xform.Broadphase.Value.Uid == uid
-                    || Deleted(xform.Broadphase.Value.Uid)
-                    || Terminating(xform.Broadphase.Value.Uid),
-                $"Entity has no parent but is on some broadphase? Entity: {ToPrettyString(uid)}. Broadphase: {ToPrettyString(xform.Broadphase.Value.Uid)}");
-            }
+            DebugTools.Assert(
+                xform.Broadphase == null
+                || xform.Broadphase == BroadphaseData.Invalid
+                || xform.Broadphase.Value.Uid == uid
+                || Deleted(xform.Broadphase.Value.Uid)
+                || Terminating(xform.Broadphase.Value.Uid),
+                $"Entity has no parent but is on some broadphase? Entity: {ToPrettyString(uid)}. Broadphase: {ToPrettyString(xform.Broadphase!.Value.Uid)}");
+
             return;
         }
 
@@ -1425,7 +1449,7 @@ public abstract partial class SharedTransformSystem
             RaiseLocalEvent(uid, ref anchorStateChangedEvent, true);
         }
 
-        SetCoordinates(entity, default, Angle.Zero, oldParent: oldXform);
+        SetCoordinates((uid, xform, meta), default, Angle.Zero, oldParent: oldXform);
 
         DebugTools.Assert((meta.Flags & MetaDataFlags.InContainer) == 0x0,
             $"Entity is in a container after having been detached to null-space? Entity: {ToPrettyString(uid)}");
@@ -1460,7 +1484,7 @@ public abstract partial class SharedTransformSystem
         var targetXform = target.Comp;
         if (!XformQuery.Resolve(target, ref targetXform) || !targetXform.ParentUid.IsValid())
         {
-            DetachParentToNull(entity, xform);
+            DetachEntity(entity, xform);
             return;
         }
 
@@ -1498,7 +1522,7 @@ public abstract partial class SharedTransformSystem
         var targetXform = target.Comp;
         if (!XformQuery.Resolve(target, ref targetXform) || !targetXform.ParentUid.IsValid())
         {
-            DetachParentToNull(entity, xform);
+            DetachEntity(entity, xform);
             return;
         }
 
@@ -1518,4 +1542,90 @@ public abstract partial class SharedTransformSystem
                 PlaceNextTo((entity, xform), targetXform.ParentUid);
         }
     }
+
+    /// <summary>
+    /// Swaps the position of two entities, placing them inside of containers when applicable.
+    /// </summary>
+    /// <returns>Returns if the entities can have their positions swapped. Fails if the entities are parented to one another</returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    public bool SwapPositions(Entity<TransformComponent?> entity1, Entity<TransformComponent?> entity2)
+    {
+        if (!XformQuery.Resolve(entity1, ref entity1.Comp) || !XformQuery.Resolve(entity2, ref entity2.Comp))
+            return false;
+
+        // save ourselves the hassle and just don't move anything.
+        if (entity1 == entity2)
+            return true;
+
+        // don't parent things to each other by accident
+        if (IsParentOf(entity1.Comp, entity2) || IsParentOf(entity2.Comp, entity1))
+            return false;
+
+        MapCoordinates? pos1 = null;
+        MapCoordinates? pos2 = null;
+
+        if (_container.TryGetContainingContainer(entity1, out var container1))
+            _container.Remove(entity1, container1, force: true);
+        else
+            pos1 = GetMapCoordinates(entity1.Comp);
+
+        if (_container.TryGetContainingContainer(entity2, out var container2))
+            _container.Remove(entity2, container2, force: true);
+        else
+            pos2 = GetMapCoordinates(entity2.Comp);
+
+        // making sure we don't accidentally place something inside of itself
+        if (container1 != null && container1.Owner == entity2.Owner)
+            return false;
+        if (container2 != null && container2.Owner == entity1.Owner)
+            return false;
+
+        if (container2 != null)
+        {
+            _container.Insert(entity1, container2);
+        }
+        else if (pos2 != null)
+        {
+            var mapUid = _mapManager.GetMapEntityId(pos2.Value.MapId);
+
+            if (!_gridQuery.HasComponent(entity1) && _mapManager.TryFindGridAt(mapUid, pos2.Value.Position, out var targetGrid, out _))
+            {
+                var invWorldMatrix = GetInvWorldMatrix(targetGrid);
+                SetCoordinates(entity1, new EntityCoordinates(targetGrid, invWorldMatrix.Transform(pos2.Value.Position)));
+            }
+            else
+            {
+                SetCoordinates(entity1, new EntityCoordinates(mapUid, pos2.Value.Position));
+            }
+        }
+        else
+        {
+            throw new InvalidOperationException();
+        }
+
+        if (container1 != null)
+        {
+            _container.Insert(entity2, container1);
+        }
+        else if (pos1 != null)
+        {
+            var mapUid = _mapManager.GetMapEntityId(pos1.Value.MapId);
+
+            if (!_gridQuery.HasComponent(entity1) && _mapManager.TryFindGridAt(mapUid, pos1.Value.Position, out var targetGrid, out _))
+            {
+                var invWorldMatrix = GetInvWorldMatrix(targetGrid);
+                SetCoordinates(entity2, new EntityCoordinates(targetGrid, invWorldMatrix.Transform(pos1.Value.Position)));
+            }
+            else
+            {
+                SetCoordinates(entity2, new EntityCoordinates(mapUid, pos1.Value.Position));
+            }
+        }
+        else
+        {
+            throw new InvalidOperationException();
+        }
+
+        return true;
+    }
 }

Robust.Shared/GameObjects/Systems/SharedTransformSystem.Coordinates.cs

@@ -1,5 +1,3 @@
-using System;
-using System.Numerics;
 using System.Runtime.CompilerServices;
 using Robust.Shared.Map;
 
@@ -36,34 +34,23 @@ public abstract partial class SharedTransformSystem
     /// <returns>A new set of EntityCoordinates local to a new entity.</returns>
     public EntityCoordinates WithEntityId(EntityCoordinates coordinates, EntityUid entity)
     {
-        var mapPos = ToMapCoordinates(coordinates);
-
-        // You'd think this would throw like ToCoordinates does but TODO check that.
-        if (mapPos.MapId == MapId.Nullspace)
-        {
-            return new EntityCoordinates(entity, Vector2.Zero);
-        }
-
-        var xform = XformQuery.GetComponent(entity);
-
-        if (xform.MapID != mapPos.MapId)
-        {
-            return new EntityCoordinates(entity, Vector2.Zero);
-        }
-
-        var localPos = GetInvWorldMatrix(xform).Transform(mapPos.Position);
-        return new EntityCoordinates(entity, localPos);
+        return entity == coordinates.EntityId
+            ? coordinates
+            : ToCoordinates(entity, ToMapCoordinates(coordinates));
     }
 
     /// <summary>
     /// Converts entity-local coordinates into map terms.
     /// </summary>
-    public MapCoordinates ToMapCoordinates(EntityCoordinates coordinates)
+    public MapCoordinates ToMapCoordinates(EntityCoordinates coordinates, bool logError = true)
     {
-        if (!IsValid(coordinates))
+        if (!TryComp(coordinates.EntityId, out TransformComponent? xform))
+        {
+            if (logError)
+                Log.Error($"Attempted to convert coordinates with invalid entity: {coordinates}");
             return MapCoordinates.Nullspace;
+        }
 
-        var xform = XformQuery.GetComponent(coordinates.EntityId);
         var worldPos = GetWorldMatrix(xform).Transform(coordinates.Position);
         return new MapCoordinates(worldPos, xform.MapID);
     }
@@ -79,17 +66,129 @@ public abstract partial class SharedTransformSystem
     }
 
     /// <summary>
-    ///    Creates EntityCoordinates given an entity and some MapCoordinates.
+    /// Creates EntityCoordinates given an entity and some MapCoordinates.
     /// </summary>
-    /// <exception cref="InvalidOperationException">If <see cref="entity"/> is not on the same map as the <see cref="coordinates"/>.</exception>
-    public EntityCoordinates ToCoordinates(EntityUid entity, MapCoordinates coordinates)
+    public EntityCoordinates ToCoordinates(Entity<TransformComponent?> entity, MapCoordinates coordinates)
     {
-        var xform = XformQuery.GetComponent(entity);
+        if (!Resolve(entity, ref entity.Comp, false))
+        {
+            Log.Error($"Attempted to convert coordinates with invalid entity: {coordinates}");
+            return default;
+        }
 
-        if (xform.MapID != coordinates.MapId)
-            throw new InvalidOperationException("Entity is not on the same map!");
+        if (entity.Comp.MapID != coordinates.MapId)
+        {
+            Log.Error($"Attempted to convert map coordinates {coordinates} to entity coordinates on a different map. Entity: {ToPrettyString(entity)}");
+            return default;
+        }
 
-        var localPos = GetInvWorldMatrix(xform).Transform(coordinates.Position);
+        var localPos = GetInvWorldMatrix(entity.Comp).Transform(coordinates.Position);
         return new EntityCoordinates(entity, localPos);
     }
+
+    /// <summary>
+    /// Creates map-relative <see cref="EntityCoordinates"/> given some <see cref="MapCoordinates"/>.
+    /// </summary>
+    public EntityCoordinates ToCoordinates(MapCoordinates coordinates)
+    {
+        if (_map.TryGetMap(coordinates.MapId, out var uid))
+            return ToCoordinates(uid.Value, coordinates);
+
+        Log.Error($"Attempted to convert map coordinates with unknown map id: {coordinates}");
+        return default;
+
+    }
+
+    /// <summary>
+    /// Returns the grid that the entity whose position the coordinates are relative to is on.
+    /// </summary>
+    public EntityUid? GetGrid(EntityCoordinates coordinates)
+    {
+        return GetGrid(coordinates.EntityId);
+    }
+
+    public EntityUid? GetGrid(Entity<TransformComponent?> entity)
+    {
+        return !Resolve(entity, ref entity.Comp) ? null : entity.Comp.GridUid;
+    }
+
+    /// <summary>
+    /// Returns the Map Id these coordinates are on.
+    /// </summary>
+    public MapId GetMapId(EntityCoordinates coordinates)
+    {
+        return GetMapId(coordinates.EntityId);
+    }
+
+    public MapId GetMapId(Entity<TransformComponent?> entity)
+    {
+        return !Resolve(entity, ref entity.Comp) ? MapId.Nullspace : entity.Comp.MapID;
+    }
+
+    /// <summary>
+    /// Returns the Map that these coordinates are on.
+    /// </summary>
+    public EntityUid? GetMap(EntityCoordinates coordinates)
+    {
+        return GetMap(coordinates.EntityId);
+    }
+
+    public EntityUid? GetMap(Entity<TransformComponent?> entity)
+    {
+        return !Resolve(entity, ref entity.Comp) ? null : entity.Comp.MapUid;
+    }
+
+    /// <summary>
+    ///     Compares two sets of coordinates to see if they are in range of each other.
+    /// </summary>
+    /// <param name="range">maximum distance between the two sets of coordinates.</param>
+    /// <returns>True if the two points are within a given range.</returns>
+    public bool InRange(EntityCoordinates coordA, EntityCoordinates coordB,  float range)
+    {
+        if (!coordA.EntityId.IsValid() || !coordB.EntityId.IsValid())
+            return false;
+
+        if (coordA.EntityId == coordB.EntityId)
+            return (coordA.Position - coordB.Position).LengthSquared() < range * range;
+
+        var mapA = ToMapCoordinates(coordA, logError:false);
+        var mapB = ToMapCoordinates(coordB, logError:false);
+
+        if (mapA.MapId != mapB.MapId || mapA.MapId == MapId.Nullspace)
+            return false;
+
+        return mapA.InRange(mapB, range);
+    }
+
+    /// <summary>
+    ///     Compares the positions of two entities to see if they are within some specified distance of each other.
+    /// </summary>
+    public bool InRange(Entity<TransformComponent?> entA, Entity<TransformComponent?> entB,  float range)
+    {
+        if (!Resolve(entA, ref entA.Comp))
+            return false;
+
+        if (!Resolve(entB, ref entB.Comp))
+            return false;
+
+        if (!entA.Comp.ParentUid.IsValid() || !entB.Comp.ParentUid.IsValid())
+            return false;
+
+        if (entA.Comp.ParentUid == entB.Comp.ParentUid)
+            return (entA.Comp.LocalPosition - entB.Comp.LocalPosition).LengthSquared() < range * range;
+
+        if (entA.Comp.ParentUid == entB.Owner)
+            return entA.Comp.LocalPosition.LengthSquared() < range * range;
+
+        if (entB.Comp.ParentUid == entA.Owner)
+            return entB.Comp.LocalPosition.LengthSquared() < range * range;
+
+        var mapA = GetMapCoordinates(entA!);
+        var mapB = GetMapCoordinates(entB!);
+
+        if (mapA.MapId != mapB.MapId || mapA.MapId == MapId.Nullspace)
+            return false;
+
+        return mapA.InRange(mapB, range);
+    }
 }

Robust.Shared/GameObjects/Systems/SharedTransformSystem.cs

@@ -25,6 +25,7 @@ namespace Robust.Shared.GameObjects
         [Dependency] private readonly SharedPhysicsSystem _physics = default!;
         [Dependency] private readonly INetManager _netMan = default!;
         [Dependency] private readonly SharedContainerSystem _container = default!;
+        [Dependency] private readonly SharedGridTraversalSystem _traversal = default!;
 
         private EntityQuery<MapComponent> _mapQuery;
         private EntityQuery<MapGridComponent> _gridQuery;
@@ -40,10 +41,12 @@ namespace Robust.Shared.GameObjects
         /// </summary>
         public event MoveEventHandler? OnGlobalMoveEvent;
 
-        public void InvokeGlobalMoveEvent(ref MoveEvent ev)
-        {
-            OnGlobalMoveEvent?.Invoke(ref ev);
-        }
+        /// <summary>
+        ///     Internal move event handlers. This gets invoked before the global & directed move events. This is mainly
+        ///     for exception tolerance, we want to ensure that PVS, physics & entity lookups get updated before some
+        ///     content code throws an exception.
+        /// </summary>
+        internal event MoveEventHandler? OnBeforeMoveEvent;
 
         public override void Initialize()
         {
@@ -104,7 +107,7 @@ namespace Robust.Shared.GameObjects
                 // If a tile is being removed due to an explosion or somesuch, some entities are likely being deleted.
                 // Avoid unnecessary entity updates.
                 if (EntityManager.IsQueuedForDeletion(entity))
-                    DetachParentToNull(entity, xform, gridXform);
+                    DetachEntity(entity, xform, MetaData(entity), gridXform);
                 else
                     SetParent(entity, xform, gridXform.MapUid.Value, mapTransform);
             }
@@ -255,6 +258,44 @@ namespace Robust.Shared.GameObjects
             indices = _map.CoordinatesToTile(xform.GridUid.Value, grid, xform.Coordinates);
             return true;
         }
+
+        public void RaiseMoveEvent(
+            Entity<TransformComponent, MetaDataComponent> ent,
+            EntityUid oldParent,
+            Vector2 oldPosition,
+            Angle oldRotation,
+            EntityUid? oldMap)
+        {
+            var pos = ent.Comp1._parent == EntityUid.Invalid
+                ? default
+                : new EntityCoordinates(ent.Comp1._parent, ent.Comp1._localPosition);
+
+            var oldPos = oldParent == EntityUid.Invalid
+                ? default
+                : new EntityCoordinates(oldParent, oldPosition);
+
+            var ev = new MoveEvent(ent, oldPos, pos, oldRotation, ent.Comp1._localRotation);
+
+            if (oldParent != ent.Comp1._parent)
+            {
+                _physics.OnParentChange(ent, oldParent, oldMap);
+                OnBeforeMoveEvent?.Invoke(ref ev);
+                var entParentChangedMessage = new EntParentChangedMessage(ev.Sender, oldParent, oldMap, ev.Component);
+                RaiseLocalEvent(ev.Sender, ref entParentChangedMessage, true);
+            }
+            else
+            {
+                OnBeforeMoveEvent?.Invoke(ref ev);
+            }
+
+            RaiseLocalEvent(ev.Sender, ref ev);
+            OnGlobalMoveEvent?.Invoke(ref ev);
+
+            // Finally, handle grid traversal. This is handled separately to avoid out-of-order move events.
+            // I.e., if the traversal raises its own move event, this ensures that all the old move event handlers
+            // have finished running first. Ideally this shouldn't be required, but this is here just in case
+            _traversal.CheckTraverse(ent.Owner, ent.Comp1);
+        }
     }
 
     [ByRefEvent]

Robust.Shared/GameObjects/Systems/SharedUserInterfaceSystem.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Runtime.InteropServices;
 using JetBrains.Annotations;
 using Robust.Shared.Collections;
@@ -11,6 +10,7 @@ using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Player;
 using Robust.Shared.Reflection;
+using Robust.Shared.Threading;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -21,6 +21,7 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
     [Dependency] private readonly IDynamicTypeFactory _factory = default!;
     [Dependency] private readonly IGameTiming _timing = default!;
     [Dependency] private readonly INetManager _netManager = default!;
+    [Dependency] private readonly IParallelManager _parallel = default!;
     [Dependency] private readonly IReflectionManager _reflection = default!;
     [Dependency] private readonly ISharedPlayerManager _player = default!;
     [Dependency] private readonly SharedTransformSystem _transforms = default!;
@@ -30,6 +31,8 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
     private EntityQuery<UserInterfaceComponent> _uiQuery;
     private EntityQuery<UserInterfaceUserComponent> _userQuery;
 
+    private ActorRangeCheckJob _rangeJob;
+
     public override void Initialize()
     {
         base.Initialize();
@@ -39,6 +42,12 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         _uiQuery = GetEntityQuery<UserInterfaceComponent>();
         _userQuery = GetEntityQuery<UserInterfaceUserComponent>();
 
+        _rangeJob = new()
+        {
+            System = this,
+            XformQuery = _xformQuery,
+        };
+
         SubscribeAllEvent<BoundUIWrapMessage>((msg, args) =>
         {
             if (args.SenderSession.AttachedEntity is not { } player)
@@ -49,6 +58,7 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
 
         SubscribeLocalEvent<UserInterfaceComponent, OpenBoundInterfaceMessage>(OnUserInterfaceOpen);
         SubscribeLocalEvent<UserInterfaceComponent, CloseBoundInterfaceMessage>(OnUserInterfaceClosed);
+        SubscribeLocalEvent<UserInterfaceComponent, ComponentStartup>(OnUserInterfaceStartup);
         SubscribeLocalEvent<UserInterfaceComponent, ComponentShutdown>(OnUserInterfaceShutdown);
         SubscribeLocalEvent<UserInterfaceComponent, ComponentGetState>(OnUserInterfaceGetState);
         SubscribeLocalEvent<UserInterfaceComponent, ComponentHandleState>(OnUserInterfaceHandleState);
@@ -56,28 +66,10 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         SubscribeLocalEvent<PlayerAttachedEvent>(OnPlayerAttached);
         SubscribeLocalEvent<PlayerDetachedEvent>(OnPlayerDetached);
 
+        SubscribeLocalEvent<UserInterfaceUserComponent, ComponentShutdown>(OnActorShutdown);
         SubscribeLocalEvent<UserInterfaceUserComponent, ComponentGetStateAttemptEvent>(OnGetStateAttempt);
         SubscribeLocalEvent<UserInterfaceUserComponent, ComponentGetState>(OnActorGetState);
         SubscribeLocalEvent<UserInterfaceUserComponent, ComponentHandleState>(OnActorHandleState);
-
-        _player.PlayerStatusChanged += OnStatusChange;
-    }
-
-    private void OnStatusChange(object? sender, SessionStatusEventArgs e)
-    {
-        var attachedEnt = e.Session.AttachedEntity;
-
-        if (attachedEnt == null)
-            return;
-
-        // Content can't handle it yet sadly :(
-        CloseUserUis(attachedEnt.Value);
-    }
-
-    public override void Shutdown()
-    {
-        base.Shutdown();
-        _player.PlayerStatusChanged -= OnStatusChange;
     }
 
     /// <summary>
@@ -113,7 +105,7 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         // If it's a close message something else might try to cancel it but we want to force it.
         if (msg.Message is not CloseBoundInterfaceMessage && ui.RequireInputValidation)
         {
-            var attempt = new BoundUserInterfaceMessageAttempt(sender, uid, msg.UiKey);
+            var attempt = new BoundUserInterfaceMessageAttempt(sender, uid, msg.UiKey, msg.Message);
             RaiseLocalEvent(attempt);
             if (attempt.Cancelled)
                 return;
@@ -136,6 +128,11 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
 
     #region User
 
+    private void OnActorShutdown(Entity<UserInterfaceUserComponent> ent, ref ComponentShutdown args)
+    {
+        CloseUserUis((ent.Owner, ent.Comp));
+    }
+
     private void OnGetStateAttempt(Entity<UserInterfaceUserComponent> ent, ref ComponentGetStateAttemptEvent args)
     {
         if (args.Cancelled || args.Player?.AttachedEntity != ent.Owner)
@@ -208,11 +205,10 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
 
             foreach (var key in keys)
             {
-                if (!uiComp.ClientOpenInterfaces.TryGetValue(key, out var cBui))
+                if (!uiComp.ClientOpenInterfaces.Remove(key, out var cBui))
                     continue;
 
                 cBui.Dispose();
-                uiComp.ClientOpenInterfaces.Remove(key);
             }
         }
     }
@@ -234,10 +230,8 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         Dirty(ent);
 
         // If the actor is also deleting then don't worry about updating what they have open.
-        if (!TerminatingOrDeleted(actor))
+        if (!TerminatingOrDeleted(actor) && _userQuery.TryComp(actor, out var actorComp))
         {
-            var actorComp = EnsureComp<UserInterfaceUserComponent>(actor);
-
             if (actorComp.OpenInterfaces.TryGetValue(ent.Owner, out var keys))
             {
                 keys.Remove(args.UiKey);
@@ -283,6 +277,20 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         EnsureClientBui(ent, args.UiKey, ent.Comp.Interfaces[args.UiKey]);
     }
 
+    private void OnUserInterfaceStartup(Entity<UserInterfaceComponent> ent, ref ComponentStartup args)
+    {
+        // PlayerAttachedEvent will catch some of these.
+        foreach (var (key, bui) in ent.Comp.ClientOpenInterfaces)
+        {
+            bui.Open();
+
+            if (ent.Comp.States.TryGetValue(key, out var state))
+            {
+                bui.UpdateState(state);
+            }
+        }
+    }
+
     private void OnUserInterfaceShutdown(EntityUid uid, UserInterfaceComponent component, ComponentShutdown args)
     {
         foreach (var bui in component.ClientOpenInterfaces.Values)
@@ -388,17 +396,21 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
             if (!ent.Comp.ClientOpenInterfaces.TryGetValue(key, out var cBui))
                 continue;
 
+            cBui.State = buiState;
             cBui.UpdateState(buiState);
         }
 
         // If UI not open then open it
         var attachedEnt = _player.LocalEntity;
 
+        // If we get the first state for an ent coming in then don't open BUIs yet, just defer it until later.
+        var open = ent.Comp.LifeStage > ComponentLifeStage.Added;
+
         if (attachedEnt != null)
         {
             foreach (var (key, value) in ent.Comp.Interfaces)
             {
-                EnsureClientBui(ent, key, value);
+                EnsureClientBui(ent, key, value, open);
             }
         }
     }
@@ -406,7 +418,7 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
     /// <summary>
     /// Opens a client's BUI if not already open and applies the state to it.
     /// </summary>
-    private void EnsureClientBui(Entity<UserInterfaceComponent> entity, Enum key, InterfaceData data)
+    private void EnsureClientBui(Entity<UserInterfaceComponent> entity, Enum key, InterfaceData data, bool open = true)
     {
         // If it's out BUI open it up and apply the state, otherwise do nothing.
         var player = _player.LocalEntity;
@@ -429,10 +441,16 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         var boundUserInterface = (BoundUserInterface) _factory.CreateInstance(type, [entity.Owner, key]);
 
         entity.Comp.ClientOpenInterfaces[key] = boundUserInterface;
+
+        // This is just so we don't open while applying UI states.
+        if (!open)
+            return;
+
         boundUserInterface.Open();
 
         if (entity.Comp.States.TryGetValue(key, out var buiState))
         {
+            boundUserInterface.State = buiState;
             boundUserInterface.UpdateState(buiState);
         }
     }
@@ -874,12 +892,31 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         RaisePredictiveEvent(new BoundUIWrapMessage(GetNetEntity(bui.Owner), msg, bui.UiKey));
     }
 
+    public bool TryGetInterfaceData(Entity<UserInterfaceComponent?> entity,
+        Enum key,
+        [NotNullWhen(true)] out InterfaceData? data)
+    {
+        data = null;
+        return Resolve(entity, ref entity.Comp, false) && entity.Comp.Interfaces.TryGetValue(key, out data);
+    }
+
+    public float GetUiRange(Entity<UserInterfaceComponent?> entity, Enum key)
+    {
+        TryGetInterfaceData(entity, key, out var data);
+        return data?.InteractionRange ?? 0;
+    }
+
     /// <inheritdoc />
     public override void Update(float frameTime)
     {
         var query = AllEntityQuery<ActiveUserInterfaceComponent, UserInterfaceComponent>();
+        // Run these in parallel because it's expensive.
+        _rangeJob.ActorRanges.Clear();
 
         // Handles closing the BUI if actors move out of range of them.
+        // TODO iterate over BUI users, not BUI entities.
+        // I.e., a user may have more than one BUI open, but its rare for a bui to be open by more than one user.
+        // This means we won't have to fetch the user's transform as frequently.
         while (query.MoveNext(out var uid, out _, out var uiComp))
         {
             foreach (var (key, actors) in uiComp.Actors)
@@ -888,106 +925,124 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
                 var data = uiComp.Interfaces[key];
 
                 // Short-circuit
-                if (data.InteractionRange <= 0f || actors.Count == 0)
+                if (data.InteractionRange <= 0f)
                     continue;
 
-                // Okay so somehow UISystem is high up on the server profile
-                // If that's actually still a problem turn this into an IParallelRobustJob and slam all the UIs in parallel.
-                var xform = _xformQuery.GetComponent(uid);
-                var coordinates = xform.Coordinates;
-                var mapId = xform.MapID;
-
-                for (var i = actors.Count - 1; i >= 0; i--)
+                foreach (var actor in actors)
                 {
-                    var actor = actors[i];
-
-                    if (CheckRange(uid, key, data, actor, coordinates, mapId))
-                        continue;
-
-                    // Using the non-predicted one here seems fine?
-                    CloseUi((uid, uiComp), key, actor);
+                    _rangeJob.ActorRanges.Add((uid, key, data, actor, false));
                 }
             }
         }
+
+        _parallel.ProcessNow(_rangeJob, _rangeJob.ActorRanges.Count);
+
+        foreach (var data in _rangeJob.ActorRanges)
+        {
+            var uid = data.Ui;
+            var actor = data.Actor;
+            var key = data.Key;
+
+            if (data.Result || Deleted(uid) || Deleted(actor) || !_uiQuery.TryComp(uid, out var uiComp))
+                continue;
+
+            CloseUi((uid, uiComp), key, actor);
+        }
     }
 
     /// <summary>
     ///     Verify that the subscribed clients are still in range of the interface.
     /// </summary>
     private bool CheckRange(
-        EntityUid uid,
+        Entity<TransformComponent> UiEnt,
         Enum key,
         InterfaceData data,
-        EntityUid actor,
-        EntityCoordinates uiCoordinates,
-        MapId uiMap)
+        Entity<TransformComponent?> actor)
     {
-        if (_ignoreUIRangeQuery.HasComponent(actor))
-            return true;
-
-        if (!_xformQuery.TryGetComponent(actor, out var actorXform))
+        if (!_xformQuery.Resolve(actor, ref actor.Comp) || actor.Comp.MapID != UiEnt.Comp.MapID)
             return false;
 
         // Handle pluggable BoundUserInterfaceCheckRangeEvent
-        var checkRangeEvent = new BoundUserInterfaceCheckRangeEvent(uid, key, data, actor);
-        RaiseLocalEvent(uid, ref checkRangeEvent, broadcast: true);
+        var checkRangeEvent = new BoundUserInterfaceCheckRangeEvent(UiEnt, key, data, actor!);
+        RaiseLocalEvent(UiEnt.Owner, ref checkRangeEvent, true);
 
         if (checkRangeEvent.Result == BoundUserInterfaceRangeResult.Pass)
             return true;
 
+        // We only check if the range check should be ignored if it did not pass.
+        // The majority of the time the check will be passing and users generally do not have this component.
+        if (_ignoreUIRangeQuery.HasComponent(actor))
+            return true;
+
         if (checkRangeEvent.Result == BoundUserInterfaceRangeResult.Fail)
             return false;
 
         DebugTools.Assert(checkRangeEvent.Result == BoundUserInterfaceRangeResult.Default);
 
-        if (uiMap != actorXform.MapID)
-            return false;
+        return _transforms.InRange(UiEnt!, actor, data.InteractionRange);
+    }
 
-        return uiCoordinates.InRange(EntityManager, _transforms, actorXform.Coordinates, data.InteractionRange);
+    /// <summary>
+    /// Used for running UI raycast checks in parallel.
+    /// </summary>
+    private record struct ActorRangeCheckJob() : IParallelRobustJob
+    {
+        public EntityQuery<TransformComponent> XformQuery;
+        public SharedUserInterfaceSystem System;
+        public readonly List<(EntityUid Ui, Enum Key, InterfaceData Data, EntityUid Actor, bool Result)> ActorRanges = new();
+
+        public void Execute(int index)
+        {
+            var data = ActorRanges[index];
+
+            if (!XformQuery.TryComp(data.Ui, out var uiXform))
+            {
+                data.Result = false;
+            }
+            else
+            {
+                data.Result = System.CheckRange((data.Ui, uiXform), data.Key, data.Data, data.Actor);
+            }
+
+            ActorRanges[index] = data;
+        }
     }
 }
 
 /// <summary>
 /// Raised by <see cref="UserInterfaceSystem"/> to check whether an interface is still accessible by its user.
+/// The event is raised directed at the entity that owns the interface.
 /// </summary>
 [ByRefEvent]
 [PublicAPI]
-public struct BoundUserInterfaceCheckRangeEvent
+public struct BoundUserInterfaceCheckRangeEvent(
+    Entity<TransformComponent> target,
+    Enum uiKey,
+    InterfaceData data,
+    Entity<TransformComponent> actor)
 {
     /// <summary>
     /// The entity owning the UI being checked for.
     /// </summary>
-    public readonly EntityUid Target;
+    public readonly EntityUid Target = target;
 
     /// <summary>
     /// The UI itself.
     /// </summary>
     /// <returns></returns>
-    public readonly Enum UiKey;
+    public readonly Enum UiKey = uiKey;
 
-    public readonly InterfaceData Data;
+    public readonly InterfaceData Data = data;
 
     /// <summary>
     /// The player for which the UI is being checked.
     /// </summary>
-    public readonly EntityUid Actor;
+    public readonly Entity<TransformComponent> Actor = actor;
 
     /// <summary>
     /// The result of the range check.
     /// </summary>
     public BoundUserInterfaceRangeResult Result;
-
-    public BoundUserInterfaceCheckRangeEvent(
-        EntityUid target,
-        Enum uiKey,
-        InterfaceData data,
-        EntityUid actor)
-    {
-        Target = target;
-        UiKey = uiKey;
-        Data = data;
-        Actor = actor;
-    }
 }
 
 /// <summary>