Version: 255.0.2

(cherry picked from commit 51bbc5dc45)

Directory.Packages.props

@@ -57,7 +57,7 @@
     <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
     <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.7" />
     <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
-    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
+    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.2.2" />
     <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
     <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
     <PackageVersion Include="TerraFX.Interop.Windows" Version="10.0.26100.1" />

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

@@ -1,4 +1,4 @@
-# Release notes for RobustToolbox.
+# Release notes for RobustToolbox.
 
 <!--
 NOTE: automatically updated sometimes by version.py.
@@ -54,6 +54,101 @@ END TEMPLATE-->
 *None yet*
 
 
+## 255.0.2
+
+
+## 255.0.1
+
+
+## 255.0.0
+
+### Breaking changes
+
+* `RobustIntegrationTest` now pools server/client instances by default. If a custom settings class is provided, it will still disable pooling unless explicitly enabled.
+  * Server/Client instances that are returned to the pool should be disconnected. This might require you to update some tests.
+  * Pooled instances also require you to use `RobustIntegrationTest` methods like `WaitPost()` to ensure the correct thread is used.
+
+### Bugfixes
+
+* Fix `EntityDeserializer` improperly setting entity lifestages when loading a post-mapinit map.
+* Fix `EntityManager.PredictedDeleteEntity()` not deleting pure client-side entities.
+* Fix grid fixtures using a locale dependent id. This could cause some clients to crash/freeze when connected to a server with a different locale.
+
+### Other
+
+* Add logic to block cycles in master MIDI renderers, which could otherwise cause client freezes.
+
+
+## 254.1.0
+
+### New features
+
+* Add CC ND licences to the RGA validator.
+* Add entity spawn prediction and entity deletion prediction. This is currently limited as you are unable to predict interactions with these entities. These are done via the new methods prefixed with "Predicted". You can also manually flag an entity as a predicted spawn with the `FlagPredicted` method which will clean it up when prediction is reset.
+
+### Bugfixes
+
+* Fix tile edge rendering for neighbor tiles being the same priority.
+
+### Other
+
+* Fix SpawnAttachedTo's system proxy method not the rotation arg like EntityManager.
+
+
+## 254.0.0
+
+### Breaking changes
+
+* Yaml mappings/dictionaries now only support string keys instead of generic nodes
+  * Several MappingDataNode method arguments or return values now use strings instead of a DataNode object
+  * The MappingDataNode class has various helper methods that still accept a ValueDataNode, but these methods are marked as obsolete and may be removed in the future.
+  * yaml validators should use `MappingDataNode.GetKeyNode()` when validating mapping keys, so that errors can print node start & end information
+* ValueTuple yaml serialization has changed
+  * Previously they would get serialized into a single mapping with one entry (i.e., `{foo : bar }`)
+  * Now they serialize into a sequence (i.e., `[foo, bar]`)
+  * The ValueTuple serializer will still try to read mappings, but due to the MappingDataNode this may fail if the previously serialized "key" can't be read as a simple string
+
+### New features
+
+* Add cvar to disable tile edges.
+* Add GetContainingContainers method to ContainerSystem to recursively get containers upwards on an entity.
+
+### Internal
+
+* Make component lifecycle methods use generics.
+
+
+## 253.0.0
+
+### New features
+
+* Add a new `SerializationManager.PushComposition()` overload that takes in a single parent instead of an array of parents.
+* `BoundUserInterfaceMessageAttempt` once again gets raised as a broadcast event, in addition to being directed.
+  * This effectively reverts the breaking part of the changes made in v252.0.0
+* Fix CreateDistanceJoint using an int instead of a float for minimum distance.
+
+### Bugfixes
+
+* Fix deferred component removal not setting the component's life stage to `ComponentLifeStage.Stopped` if the component has not yet been initialised.
+* Fix some `EntitySystem.Resolve()` overloads not respecting the optional `logMissing` argument.
+* Fix screen-space overlays not being useable without first initializing/starting entity manager & systems
+* ItemList is now significantly optimized. VV's `AddComponent` window in particular should be much faster.
+* Fix some more MapValidator fields.
+* Fix popup text overflowing the sides of the screen.
+* Improve location reporting for non-writeable datafields via analyzer.
+
+### Other
+
+* TestPoint now uses generics rather than IPhysShape directly.
+
+
+## 252.0.0
+
+### Breaking changes
+
+* BoundUserInterfaceMessageAttempt is raised directed against entities and no longer broadcast.
+
+
 ## 251.0.0
 
 ### Breaking changes

Resources/Locale/en-US/commands.ftl

@@ -1,5 +1,7 @@
 ### Localization for engine console commands
 
+cmd-hint-float = [float]
+
 ## generic command errors
 
 cmd-invalid-arg-number-error = Invalid number of arguments.

Robust.Analyzers.Tests/DataDefinitionAnalyzerTest.cs

@@ -87,4 +87,66 @@ public sealed class DataDefinitionAnalyzerTest
             VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldNoVVReadWriteRule).WithSpan(35, 17, 35, 50).WithArguments("Bad", "Foo")
         );
     }
+
+    [Test]
+    public async Task ReadOnlyFieldTest()
+    {
+        const string code = """
+            using System;
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            namespace Robust.Shared.Serialization.Manager.Attributes
+            {
+                public class DataFieldBaseAttribute : Attribute;
+                public class DataFieldAttribute : DataFieldBaseAttribute;
+                public sealed class DataDefinitionAttribute : Attribute;
+            }
+
+            [DataDefinition]
+            public sealed partial class Foo
+            {
+                [DataField]
+                public readonly int Bad;
+
+                [DataField]
+                public int Good;
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(15,12): error RA0019: Data field Bad in data definition Foo is readonly
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldWritableRule).WithSpan(15, 12, 15, 20).WithArguments("Bad", "Foo")
+        );
+    }
+
+    [Test]
+    public async Task ReadOnlyPropertyTest()
+    {
+        const string code = """
+            using System;
+            using Robust.Shared.Serialization.Manager.Attributes;
+
+            namespace Robust.Shared.Serialization.Manager.Attributes
+            {
+                public class DataFieldBaseAttribute : Attribute;
+                public class DataFieldAttribute : DataFieldBaseAttribute;
+                public sealed class DataDefinitionAttribute : Attribute;
+            }
+
+            [DataDefinition]
+            public sealed partial class Foo
+            {
+                [DataField]
+                public int Bad { get; }
+
+                [DataField]
+                public int Good { get; private set; }
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(15,20): error RA0020: Data field property Bad in data definition Foo does not have a setter
+            VerifyCS.Diagnostic(DataDefinitionAnalyzer.DataFieldPropertyWritableRule).WithSpan(15, 20, 15, 28).WithArguments("Bad", "Foo")
+        );
+    }
 }

Robust.Analyzers.Tests/ObsoleteInheritanceAnalyzerTest.cs

@@ -0,0 +1,86 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<Robust.Analyzers.ObsoleteInheritanceAnalyzer, Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
+
+namespace Robust.Analyzers.Tests;
+
+/// <summary>
+/// Analyzer that implements <c>[ObsoleteInheritance]</c> checking, to give obsoletion warnings for inheriting types
+/// that should never have been virtual.
+/// </summary>
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+public sealed class ObsoleteInheritanceAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<ObsoleteInheritanceAnalyzer, DefaultVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code },
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.Analyzers.ObsoleteInheritanceAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task TestBasic()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            [ObsoleteInheritance]
+            public class Base;
+
+            public class NotAllowed : Base;
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(6,14): warning RA0034: Type 'NotAllowed' inherits from 'Base', which has obsoleted inheriting from itself
+            VerifyCS.Diagnostic(ObsoleteInheritanceAnalyzer.Rule).WithSpan(6, 14, 6, 24).WithArguments("NotAllowed", "Base")
+            );
+    }
+
+    [Test]
+    public async Task TestMessage()
+    {
+        const string code = """
+            using Robust.Shared.Analyzers;
+
+            [ObsoleteInheritance("Sus")]
+            public class Base;
+
+            public class NotAllowed : Base;
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(6,14): warning RA0034: Type 'NotAllowed' inherits from 'Base', which has obsoleted inheriting from itself: "Sus"
+            VerifyCS.Diagnostic(ObsoleteInheritanceAnalyzer.RuleWithMessage).WithSpan(6, 14, 6, 24).WithArguments("NotAllowed", "Base", "Sus")
+        );
+    }
+
+    [Test]
+    public async Task TestNormal()
+    {
+        const string code = """
+            public class Base;
+
+            public class AllowedAllowed : Base;
+            """;
+
+        await Verifier(code);
+    }
+}

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

@@ -14,6 +14,7 @@
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferNonGenericVariantForAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferOtherTypeAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\ForbidLiteralAttribute.cs" LogicalName="Robust.Shared.Analyzers.ForbidLiteralAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\Analyzers\ObsoleteInheritanceAttribute.cs" LogicalName="Robust.Shared.Analyzers.ObsoleteInheritanceAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\IoC\DependencyAttribute.cs" LogicalName="Robust.Shared.IoC.DependencyAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\GameObjects\EventBusAttributes.cs" LogicalName="Robust.Shared.GameObjects.EventBusAttributes.cs" LinkBase="Implementations" />
   </ItemGroup>

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -41,7 +41,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to mark any type containing a nested data definition as partial."
     );
 
-    private static readonly DiagnosticDescriptor DataFieldWritableRule = new(
+    public static readonly DiagnosticDescriptor DataFieldWritableRule = new(
         Diagnostics.IdDataFieldWritable,
         "Data field must not be readonly",
         "Data field {0} in data definition {1} is readonly",
@@ -51,7 +51,7 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         "Make sure to remove the readonly modifier."
     );
 
-    private static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
+    public static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
         Diagnostics.IdDataFieldPropertyWritable,
         "Data field property must have a setter",
         "Data field property {0} in data definition {1} does not have a setter",
@@ -149,7 +149,8 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
 
             if (IsReadOnlyDataField(type, fieldSymbol))
             {
-                context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, context.Node.GetLocation(), fieldSymbol.Name, type.Name));
+                TryGetModifierLocation(field, SyntaxKind.ReadOnlyKeyword, out var location);
+                context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, location, fieldSymbol.Name, type.Name));
             }
 
             if (HasRedundantTag(fieldSymbol))
@@ -185,7 +186,8 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
 
         if (IsReadOnlyDataField(type, propertySymbol))
         {
-            context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, context.Node.GetLocation(), propertySymbol.Name, type.Name));
+            var location = property.AccessorList != null ? property.AccessorList.GetLocation() : property.GetLocation();
+            context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, location, propertySymbol.Name, type.Name));
         }
 
         if (HasRedundantTag(propertySymbol))
@@ -285,6 +287,20 @@ public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
         return false;
     }
 
+    private static bool TryGetModifierLocation(MemberDeclarationSyntax syntax, SyntaxKind modifierKind, out Location location)
+    {
+        foreach (var modifier in syntax.Modifiers)
+        {
+            if (modifier.IsKind(modifierKind))
+            {
+                location = modifier.GetLocation();
+                return true;
+            }
+        }
+        location = syntax.GetLocation();
+        return false;
+    }
+
     private static bool IsReadOnlyMember(ITypeSymbol type, ISymbol member)
     {
         if (member is IFieldSymbol field)

Robust.Analyzers/ObsoleteInheritanceAnalyzer.cs

@@ -0,0 +1,75 @@
+#nullable enable
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class ObsoleteInheritanceAnalyzer : DiagnosticAnalyzer
+{
+    private const string Attribute = "Robust.Shared.Analyzers.ObsoleteInheritanceAttribute";
+
+    public static readonly DiagnosticDescriptor Rule = new(
+        Diagnostics.IdObsoleteInheritance,
+        "Parent type has obsoleted inheritance",
+        "Type '{0}' inherits from '{1}', which has obsoleted inheriting from itself",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public static readonly DiagnosticDescriptor RuleWithMessage = new(
+        Diagnostics.IdObsoleteInheritanceWithMessage,
+        "Parent type has obsoleted inheritance",
+        "Type '{0}' inherits from '{1}', which has obsoleted inheriting from itself: \"{2}\"",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => [Rule, RuleWithMessage];
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSymbolAction(CheckClass, SymbolKind.NamedType);
+    }
+
+    private static void CheckClass(SymbolAnalysisContext context)
+    {
+        if (context.Symbol is not INamedTypeSymbol typeSymbol)
+            return;
+
+        if (typeSymbol.IsValueType || typeSymbol.BaseType is not { } baseType)
+            return;
+
+        if (!AttributeHelper.HasAttribute(baseType, Attribute, out var data))
+            return;
+
+        var location = context.Symbol.Locations[0];
+
+        if (GetMessageFromAttributeData(data) is { } message)
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                RuleWithMessage,
+                location,
+                [typeSymbol.Name, baseType.Name, message]));
+        }
+        else
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                Rule,
+                location,
+                [typeSymbol.Name, baseType.Name]));
+        }
+    }
+
+    private static string? GetMessageFromAttributeData(AttributeData data)
+    {
+        if (data.ConstructorArguments is not [var message, ..])
+            return null;
+
+        return message.Value as string;
+    }
+}

Robust.Benchmarks/Transform/RecursiveMoveBenchmark.cs

@@ -42,8 +42,8 @@ public class RecursiveMoveBenchmark : RobustIntegrationTest
     public void GlobalSetup()
     {
         ProgramShared.PathOffset = "../../../../";
-        var server = StartServer();
-        var client = StartClient();
+        var server = StartServer(new() {Pool = false});
+        var client = StartClient(new() {Pool = false});
 
         Task.WhenAll(client.WaitIdleAsync(), server.WaitIdleAsync()).Wait();
 

Robust.Client.WebView/Cef/Program.cs

@@ -6,7 +6,7 @@ using Xilium.CefGlue;
 
 namespace Robust.Client.WebView.Cef
 {
-    public static class Program
+    internal static class Program
     {
         // This was supposed to be the main entry for the subprocess program... It doesn't work.
         public static int Main(string[] args)

Robust.Client.WebView/Cef/WebViewManagerCef.cs

@@ -5,6 +5,7 @@ using System.Net;
 using System.Reflection;
 using System.Text;
 using Robust.Client.Console;
+using Robust.Client.Utility;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
@@ -24,6 +25,7 @@ namespace Robust.Client.WebView.Cef
 
         [Dependency] private readonly IDependencyCollection _dependencyCollection = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly IGameControllerInternal _gameController = default!;
         [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
         [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
         [Dependency] private readonly IConfigurationManager _cfg = default!;
@@ -61,7 +63,10 @@ namespace Robust.Client.WebView.Cef
 
             var cachePath = "";
             if (_resourceManager.UserData is WritableDirProvider userData)
-                cachePath = userData.GetFullPath(new ResPath("/cef_cache"));
+            {
+                var rootDir = UserDataDir.GetRootUserDataDir(_gameController);
+                cachePath = Path.Combine(rootDir, "cef_cache", "0");
+            }
 
             var settings = new CefSettings()
             {

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -226,6 +226,9 @@ internal sealed class MidiRenderer : IMidiRenderer
             if (value == _master)
                 return;
 
+            if (CheckMasterCycle(value))
+                throw new InvalidOperationException("Tried to set master to a child of this renderer!");
+
             if (_master is { Disposed: false })
             {
                 try
@@ -729,4 +732,22 @@ internal sealed class MidiRenderer : IMidiRenderer
         _synth?.Dispose();
         _player?.Dispose();
     }
+
+    /// <summary>
+    /// Check that a given renderer is not already a child of this renderer, i.e. it would introduce a cycle if set as master of this renderer.
+    /// </summary>
+    private bool CheckMasterCycle(IMidiRenderer? otherRenderer)
+    {
+        // Doesn't inside drift, cringe.
+
+        while (otherRenderer != null)
+        {
+            if (otherRenderer == this)
+                return true;
+
+            otherRenderer = otherRenderer.Master;
+        }
+
+        return false;
+    }
 }

Robust.Client/Console/Commands/DebugAnchoredCommand.cs

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

Robust.Client/Console/Commands/LightBBCommand.cs

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

Robust.Client/Console/Commands/ShowPlayerVelocityCommand.cs

@@ -1,19 +1,18 @@
 using Robust.Client.GameObjects;
 using Robust.Shared.Console;
-using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 
 namespace Robust.Client.Console.Commands
 {
-    public sealed class ShowPlayerVelocityCommand : LocalizedCommands
+    public sealed class ShowPlayerVelocityCommand : LocalizedEntityCommands
     {
-        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
+        [Dependency] private readonly ShowPlayerVelocityDebugSystem _system = default!;
 
         public override string Command => "showplayervelocity";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            _entitySystems.GetEntitySystem<ShowPlayerVelocityDebugSystem>().Enabled ^= true;
+            _system.Enabled ^= true;
         }
     }
 }

Robust.Client/GameController/GameController.cs

@@ -384,7 +384,7 @@ namespace Robust.Client
 
             _prof.Initialize();
 
-            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
+            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null, hideUserDataDir: true);
 
             var mountOptions = _commandLineArgs != null
                 ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions)

Robust.Client/GameObjects/ClientEntityManager.Spawn.cs

@@ -0,0 +1,123 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.GameObjects;
+
+public sealed partial class ClientEntityManager
+{
+    public override EntityUid PredictedSpawnAttachedTo(string? protoName, EntityCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default)
+    {
+        var ent = SpawnAttachedTo(protoName, coordinates, overrides, rotation);
+        FlagPredicted(ent);
+        return ent;
+    }
+
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    public override EntityUid PredictedSpawn(string? protoName = null, ComponentRegistry? overrides = null, bool doMapInit = true)
+    {
+        var ent = Spawn(protoName, overrides, doMapInit);
+        FlagPredicted(ent);
+        return ent;
+    }
+
+    public override EntityUid PredictedSpawn(string? protoName, MapCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default!)
+    {
+        var ent = Spawn(protoName, coordinates, overrides, rotation);
+        FlagPredicted(ent);
+        return ent;
+    }
+
+    public override EntityUid PredictedSpawnAtPosition(string? protoName, EntityCoordinates coordinates, ComponentRegistry? overrides = null)
+    {
+        var ent = SpawnAtPosition(protoName, coordinates, overrides);
+        FlagPredicted(ent);
+        return ent;
+    }
+
+    public override bool PredictedTrySpawnNextTo(
+        string? protoName,
+        EntityUid target,
+        [NotNullWhen(true)] out EntityUid? uid,
+        TransformComponent? xform = null,
+        ComponentRegistry? overrides = null)
+    {
+        if (!TrySpawnNextTo(protoName, target, out uid, xform, overrides))
+            return false;
+
+        FlagPredicted(uid.Value);
+        return true;
+    }
+
+    public override bool PredictedTrySpawnInContainer(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        [NotNullWhen(true)] out EntityUid? uid,
+        ContainerManagerComponent? containerComp = null,
+        ComponentRegistry? overrides = null)
+    {
+        if (!TrySpawnInContainer(protoName, containerUid, containerId, out uid, containerComp, overrides))
+            return false;
+
+        FlagPredicted(uid.Value);
+        return true;
+    }
+
+    public override EntityUid PredictedSpawnNextToOrDrop(string? protoName, EntityUid target, TransformComponent? xform = null, ComponentRegistry? overrides = null)
+    {
+        var ent = SpawnNextToOrDrop(protoName, target, xform, overrides);
+        FlagPredicted(ent);
+        return ent;
+    }
+
+    public override EntityUid PredictedSpawnInContainerOrDrop(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        TransformComponent? xform = null,
+        ContainerManagerComponent? containerComp = null,
+        ComponentRegistry? overrides = null)
+    {
+        var ent = SpawnInContainerOrDrop(protoName, containerUid, containerId, xform, containerComp, overrides);
+        FlagPredicted(ent);
+        return ent;
+    }
+
+    public override EntityUid PredictedSpawnInContainerOrDrop(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        out bool inserted,
+        TransformComponent? xform = null,
+        ContainerManagerComponent? containerComp = null,
+        ComponentRegistry? overrides = null)
+    {
+        var ent = SpawnInContainerOrDrop(protoName,
+            containerUid,
+            containerId,
+            out inserted,
+            xform,
+            containerComp,
+            overrides);
+
+        FlagPredicted(ent);
+        return ent;
+    }
+
+    public override void FlagPredicted(Entity<MetaDataComponent?> ent)
+    {
+        if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp))
+            return;
+
+        DebugTools.Assert(IsClientSide(ent.Owner, ent.Comp));
+        EnsureComponent<PredictedSpawnComponent>(ent.Owner);
+
+        // TODO: Need to map call site or something, needs to be consistent between client and server.
+    }
+}

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -291,5 +291,54 @@ namespace Robust.Client.GameObjects
             }
         }
         #endregion
+
+        /// <inheritdoc />
+        public override void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
+        {
+            if (!MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
+                || ent.Comp1.EntityDeleted
+                || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
+            {
+                return;
+            }
+
+            // So there's 3 scenarios:
+            // 1. Networked entity we just move to nullspace and rely on state handling.
+            // 2. Clientside predicted entity we delete and rely on state handling.
+            // 3. Clientside only entity that actually needs deleting here.
+
+            if (ent.Comp1.NetEntity.IsClientSide())
+            {
+                DeleteEntity(ent, ent.Comp1, ent.Comp2);
+            }
+            else
+            {
+                _xforms.DetachEntity(ent, ent.Comp2);
+            }
+        }
+
+        /// <inheritdoc />
+        public override void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
+        {
+            if (IsQueuedForDeletion(ent.Owner)
+                || !MetaQuery.Resolve(ent.Owner, ref ent.Comp1)
+                || ent.Comp1.EntityDeleted
+                || !TransformQuery.Resolve(ent.Owner, ref ent.Comp2))
+            {
+                return;
+            }
+
+            if (ent.Comp1.NetEntity.IsClientSide())
+            {
+                // client-side QueueDeleteEntity re-fetches MetadataComp and checks IsClientSide().
+                // base call to skip that.
+                // TODO create override that takes in metadata comp
+                base.QueueDeleteEntity(ent);
+            }
+            else
+            {
+                _xforms.DetachEntity(ent.Owner, ent.Comp2);
+            }
+        }
     }
 }

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

@@ -10,19 +10,21 @@ using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
-    public sealed class ShowSpriteBBCommand : LocalizedCommands
+    public sealed class ShowSpriteBBCommand : LocalizedEntityCommands
     {
+        [Dependency] private readonly SpriteBoundsSystem _system = default!;
+
         public override string Command => "showspritebb";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            EntitySystem.Get<SpriteBoundsSystem>().Enabled ^= true;
+            _system.Enabled ^= true;
         }
     }
 
     public sealed class SpriteBoundsSystem : EntitySystem
     {
-        [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly SharedTransformSystem _xformSystem = default!;
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
         [Dependency] private readonly SpriteTreeSystem _spriteTree = default!;
 
@@ -40,7 +42,7 @@ namespace Robust.Client.GameObjects
                 if (_enabled)
                 {
                     DebugTools.AssertNull(_overlay);
-                    _overlay = new SpriteBoundsOverlay(_spriteTree, _entityManager);
+                    _overlay = new SpriteBoundsOverlay(_spriteTree, _xformSystem);
                     _overlayManager.AddOverlay(_overlay);
                 }
                 else
@@ -59,13 +61,13 @@ namespace Robust.Client.GameObjects
     {
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-        private readonly IEntityManager _entityManager;
+        private readonly SharedTransformSystem _xformSystem;
         private SpriteTreeSystem _renderTree;
 
-        public SpriteBoundsOverlay(SpriteTreeSystem renderTree, IEntityManager entityManager)
+        public SpriteBoundsOverlay(SpriteTreeSystem renderTree, SharedTransformSystem xformSystem)
         {
             _renderTree = renderTree;
-            _entityManager = entityManager;
+            _xformSystem = xformSystem;
         }
 
         protected internal override void Draw(in OverlayDrawArgs args)
@@ -76,7 +78,7 @@ namespace Robust.Client.GameObjects
 
             foreach (var (sprite, xform) in _renderTree.QueryAabb(currentMap, viewport))
             {
-                var (worldPos, worldRot) = xform.GetWorldPositionRotation();
+                var (worldPos, worldRot) = _xformSystem.GetWorldPositionRotation(xform);
                 var bounds = sprite.CalculateRotatedBoundingBox(worldPos, worldRot, args.Viewport.Eye?.Rotation ?? default);
 
                 // Get scaled down bounds used to indicate the "south" of a sprite.

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -303,7 +303,7 @@ namespace Robust.Client.GameObjects
             while (parent.IsValid() && (!spriteOccluded || !lightOccluded))
             {
                 var parentXform = TransformQuery.GetComponent(parent);
-                if (TryComp<ContainerManagerComponent>(parent, out var manager) && manager.TryGetContainer(child, out var container))
+                if (TryComp<ContainerManagerComponent>(parent, out var manager) && TryGetContainingContainer(parent, child, out var container, manager))
                 {
                     spriteOccluded = spriteOccluded || !container.ShowContents;
                     lightOccluded = lightOccluded || container.OccludesLight;
@@ -344,7 +344,7 @@ namespace Robust.Client.GameObjects
                     var childLightOccluded = lightOccluded;
 
                     // We already know either sprite or light is not occluding so need to check container.
-                    if (manager.TryGetContainer(child, out var container))
+                    if (TryGetContainingContainer(entity, child, out var container, manager))
                     {
                         childSpriteOccluded = childSpriteOccluded || !container.ShowContents;
                         childLightOccluded = childLightOccluded || container.OccludesLight;

Robust.Client/GameObjects/EntitySystems/DebugEntityLookupSystem.cs

@@ -2,24 +2,24 @@ using System.Collections.Generic;
 using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Shared.Console;
-using Robust.Shared.Containers;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics.Dynamics;
-using Robust.Shared.Utility;
 using Color = Robust.Shared.Maths.Color;
 
 namespace Robust.Client.GameObjects;
 
-public sealed class DebugEntityLookupCommand : LocalizedCommands
+public sealed class DebugEntityLookupCommand : LocalizedEntityCommands
 {
+    [Dependency] private readonly DebugEntityLookupSystem _system = default!;
+
     public override string Command => "togglelookup";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        EntitySystem.Get<DebugEntityLookupSystem>().Enabled ^= true;
+        _system.Enabled ^= true;
     }
 }
 

Robust.Client/GameObjects/EntitySystems/DebugLightTreeSystem.cs

@@ -26,10 +26,10 @@ namespace Robust.Client.GameObjects
                 if (_enabled)
                 {
                     _lightOverlay = new DebugLightOverlay(
-                        EntitySystem.Get<EntityLookupSystem>(),
+                        EntityManager.System<EntityLookupSystem>(),
                         IoCManager.Resolve<IEyeManager>(),
                         IoCManager.Resolve<IMapManager>(),
-                        Get<LightTreeSystem>());
+                        EntityManager.System<LightTreeSystem>());
 
                     overlayManager.AddOverlay(_lightOverlay);
                 }

Robust.Client/GameObjects/EntitySystems/EyeSystem.cs

@@ -62,7 +62,7 @@ public sealed class EyeSystem : SharedEyeSystem
                 eyeComponent.Target = null;
             }
 
-            eyeComponent.Eye.Position = xform.MapPosition;
+            eyeComponent.Eye.Position = TransformSystem.GetMapCoordinates(xform);
         }
     }
 }

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -13,6 +13,7 @@ using Robust.Client.Physics;
 using Robust.Client.Player;
 using Robust.Client.Timing;
 using Robust.Shared;
+using Robust.Shared.Collections;
 using Robust.Shared.Configuration;
 using Robust.Shared.Console;
 using Robust.Shared.Containers;
@@ -563,6 +564,21 @@ namespace Robust.Client.GameStates
             var metaQuery = _entities.GetEntityQuery<MetaDataComponent>();
             RemQueue<IComponent> toRemove = new();
 
+            // Handle predicted entity spawns.
+            var predicted = new ValueList<EntityUid>();
+            var predictedQuery = _entities.AllEntityQueryEnumerator<PredictedSpawnComponent>();
+
+            while (predictedQuery.MoveNext(out var uid, out var _))
+            {
+                predicted.Add(uid);
+            }
+
+            // Entity will get re-created as part of the tick.
+            foreach (var ent in predicted)
+            {
+                _entities.DeleteEntity(ent);
+            }
+
             foreach (var entity in system.DirtyEntities)
             {
                 DebugTools.Assert(toRemove.Count == 0);

Robust.Client/Graphics/ClientEye/EyeManager.cs

@@ -123,7 +123,8 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public ScreenCoordinates CoordinatesToScreen(EntityCoordinates point)
         {
-            return MapToScreen(point.ToMap(_entityManager, _entityManager.System<SharedTransformSystem>()));
+            var transformSystem = _entityManager.System<SharedTransformSystem>();
+            return MapToScreen(transformSystem.ToMapCoordinates(point));
         }
 
         public ScreenCoordinates MapToScreen(MapCoordinates point)

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

@@ -30,6 +30,23 @@ namespace Robust.Client.Graphics.Clyde
         private int _indicesPerChunk(MapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * GetQuadBatchIndexCount();
 
         private List<Entity<MapGridComponent>> _grids = new();
+        private bool _drawTileEdges;
+
+        private void RenderTileEdgesChanges(bool value)
+        {
+            _drawTileEdges = value;
+            if (!value)
+                return;
+
+            // Dirty all Edges
+            foreach (var gridData in _mapChunkData.Values)
+            {
+                foreach (var chunk in gridData.Values)
+                {
+                    chunk.EdgeDirty = true;
+                }
+            }
+        }
 
         private void _drawGrids(Viewport viewport, Box2 worldAABB, Box2Rotated worldBounds, IEye eye)
         {
@@ -81,6 +98,9 @@ namespace Robust.Client.Graphics.Clyde
 
                     _updateChunkMesh(mapGrid, chunk, datum);
 
+                    if (!_drawTileEdges)
+                        continue;
+
                     // Dirty edge tiles for next step.
                     datum.EdgeDirty = true;
 
@@ -99,17 +119,16 @@ namespace Robust.Client.Graphics.Clyde
                     }
                 }
 
-                enumerator = mapSystem.GetMapChunks(mapGrid.Owner, mapGrid.Comp, worldBounds);
-
                 // Handle edge sprites.
-                while (enumerator.MoveNext(out var chunk))
+                if (_drawTileEdges)
                 {
-                    var datum = data[chunk.Indices];
-
-                    if (!datum.EdgeDirty)
-                        continue;
-
-                    _updateChunkEdges(mapGrid, chunk, datum);
+                    enumerator = mapSystem.GetMapChunks(mapGrid.Owner, mapGrid.Comp, worldBounds);
+                    while (enumerator.MoveNext(out var chunk))
+                    {
+                        var datum = data[chunk.Indices];
+                        if (datum.EdgeDirty)
+                            _updateChunkEdges(mapGrid, chunk, datum);
+                    }
                 }
 
                 enumerator = mapSystem.GetMapChunks(mapGrid.Owner, mapGrid.Comp, worldBounds);
@@ -129,7 +148,7 @@ namespace Robust.Client.Graphics.Clyde
                         CheckGlError();
                     }
 
-                    if (datum.EdgeCount > 0)
+                    if (_drawTileEdges && datum.EdgeCount > 0)
                     {
                         BindVertexArray(datum.EdgeVAO);
                         CheckGlError();
@@ -138,7 +157,6 @@ namespace Robust.Client.Graphics.Clyde
                         GL.DrawElements(GetQuadGLPrimitiveType(), datum.EdgeCount * GetQuadBatchIndexCount(), DrawElementsType.UnsignedShort, 0);
                         CheckGlError();
                     }
-
                 }
 
                 requiresFlush = false;
@@ -274,7 +292,8 @@ namespace Robust.Client.Graphics.Clyde
                     var gridX = x + chunkOriginScaled.X;
                     var gridY = y + chunkOriginScaled.Y;
                     var tile = chunk.GetTile(x, y);
-                    var tileDef = _tileDefinitionManager[tile.TypeId];
+                    if (!_tileDefinitionManager.TryGetDefinition(tile.TypeId, out var tileDef))
+                        continue;
 
                     // Edge render
                     for (var nx = -1; nx <= 1; nx++)
@@ -288,14 +307,15 @@ namespace Robust.Client.Graphics.Clyde
                             if (!maps.TryGetTile(grid.Comp, neighborIndices, out var neighborTile))
                                 continue;
 
-                            var neighborDef = _tileDefinitionManager[neighborTile.TypeId];
+                            if (!_tileDefinitionManager.TryGetDefinition(neighborTile.TypeId, out var neighborDef))
+                                continue;
 
                             // If it's the same tile then no edge to be drawn.
                             if (tile.TypeId == neighborTile.TypeId || neighborDef.EdgeSprites.Count == 0)
                                 continue;
 
-                            // If neighbor is a lower priority then us then don't draw on our tile.
-                            if (neighborDef.EdgeSpritePriority < tileDef.EdgeSpritePriority)
+                            // If neighbor is a lower or same priority then us then don't draw on our tile.
+                            if (neighborDef.EdgeSpritePriority <= tileDef.EdgeSpritePriority)
                                 continue;
 
                             var direction = new Vector2i(nx, ny).AsDirection().GetOpposite();

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

@@ -123,9 +123,13 @@ namespace Robust.Client.Graphics.Clyde
 
         private void RenderSingleWorldOverlay(Overlay overlay, Viewport vp, OverlaySpace space, in Box2 worldBox, in Box2Rotated worldBounds)
         {
+            // Check that entity manager has started.
+            // This is required for us to be able to use MapSystem.
+            DebugTools.Assert(_entityManager.Started, "Entity manager should be started/initialized before rendering world-space overlays");
+
             DebugTools.Assert(space != OverlaySpace.ScreenSpaceBelowWorld && space != OverlaySpace.ScreenSpace);
 
-            var mapId = vp.Eye!.Position.MapId;
+            var mapId = vp.Eye?.Position.MapId ?? MapId.Nullspace;
             var args = new OverlayDrawArgs(space, null, vp, _renderHandle, new UIBox2i((0, 0), vp.Size), _mapSystem.GetMapOrInvalid(mapId), mapId, worldBox, worldBounds);
 
             if (!overlay.BeforeDraw(args))
@@ -152,6 +156,7 @@ namespace Robust.Client.Graphics.Clyde
 
         private void RenderOverlays(Viewport vp, OverlaySpace space, in Box2 worldBox, in Box2Rotated worldBounds)
         {
+            DebugTools.Assert(space != OverlaySpace.ScreenSpaceBelowWorld && space != OverlaySpace.ScreenSpace);
             using (DebugGroup($"Overlays: {space}"))
             {
                 foreach (var overlay in GetOverlaysForSpace(space))
@@ -176,9 +181,18 @@ namespace Robust.Client.Graphics.Clyde
 
             var worldBounds = CalcWorldBounds(vp);
             var worldAABB = worldBounds.CalcBoundingBox();
-            var mapId = vp.Eye!.Position.MapId;
+            var mapId = vp.Eye?.Position.MapId ?? MapId.Nullspace;
+            var mapUid = EntityUid.Invalid;
 
-            var args = new OverlayDrawArgs(space, vpControl, vp, handle, bounds, _mapSystem.GetMapOrInvalid(mapId), mapId, worldAABB, worldBounds);
+            // Screen space overlays may be getting used before entity manager & entity systems have been initialized.
+            // This might mean that _mapSystem is currently null.
+            // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
+            if (_entityManager.Started && _mapSystem != null)
+                mapUid = _mapSystem.GetMapOrInvalid(mapId);
+
+            DebugTools.Assert(_mapSystem != null || !_entityManager.Started);
+
+            var args = new OverlayDrawArgs(space, vpControl, vp, handle, bounds, mapUid, mapId, worldAABB, worldBounds);
 
             foreach (var overlay in list)
             {

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -121,6 +121,7 @@ namespace Robust.Client.Graphics.Clyde
             _cfg.OnValueChanged(CVars.LightSoftShadows, SoftShadowsChanged, true);
             _cfg.OnValueChanged(CVars.MaxLightCount, MaxLightsChanged, true);
             _cfg.OnValueChanged(CVars.MaxOccluderCount, MaxOccludersChanged, true);
+            _cfg.OnValueChanged(CVars.RenderTileEdges, RenderTileEdgesChanges, true);
             // I can't be bothered to tear down and set these threads up in a cvar change handler.
 
             // Windows and Linux can be trusted to not explode with threaded windowing,

Robust.Client/Input/InputManager.cs

@@ -48,6 +48,7 @@ namespace Robust.Client.Input
         [Dependency] private readonly IUserInterfaceManagerInternal _uiMgr = default!;
         [Dependency] private readonly IConsoleHost _console = default!;
         [Dependency] private readonly ISerializationManager _serialization = default!;
+        private ISawmill _logger = default!;
 
         private bool _currentlyFindingViewport;
 
@@ -114,6 +115,8 @@ namespace Robust.Client.Input
         /// <inheritdoc />
         public void Initialize()
         {
+            _logger = Logger.GetSawmill("input");
+
             NetworkBindMap = new BoundKeyMap(_reflectionManager);
             NetworkBindMap.PopulateKeyFunctionsMap();
 
@@ -130,7 +133,7 @@ namespace Robust.Client.Input
                 }
                 catch (Exception e)
                 {
-                    Logger.ErrorS("input", "Failed to load user keybindings: " + e);
+                    _logger.Error("Failed to load user keybindings: " + e);
                 }
             }
 
@@ -531,8 +534,7 @@ namespace Robust.Client.Input
 
                     if (reg.Type != KeyBindingType.Command && !NetworkBindMap.FunctionExists(reg.Function.FunctionName))
                     {
-                        Logger.DebugS("input", "Key function in {0} does not exist: '{1}'.", file,
-                            reg.Function);
+                        _logger.Debug("Key function in {0} does not exist: '{1}'.", file, reg.Function);
                         invalid = true;
                     }
 

Robust.Client/Placement/Modes/AlignSimilar.cs

@@ -30,11 +30,13 @@ namespace Robust.Client.Placement.Modes
                 return;
             }
 
-            var mapId = MouseCoords.GetMapId(pManager.EntityManager);
+            var transformSys = pManager.EntityManager.System<SharedTransformSystem>();
+            var mapId = transformSys.GetMapId(MouseCoords);
 
-            var snapToEntities = EntitySystem.Get<EntityLookupSystem>().GetEntitiesInRange(MouseCoords, SnapToRange)
+            var snapToEntities = pManager.EntityManager.System<EntityLookupSystem>()
+                .GetEntitiesInRange(MouseCoords, SnapToRange)
                 .Where(entity => pManager.EntityManager.GetComponent<MetaDataComponent>(entity).EntityPrototype == pManager.CurrentPrototype && pManager.EntityManager.GetComponent<TransformComponent>(entity).MapID == mapId)
-                .OrderBy(entity => (pManager.EntityManager.GetComponent<TransformComponent>(entity).WorldPosition - MouseCoords.ToMapPos(pManager.EntityManager, pManager.EntityManager.System<SharedTransformSystem>())).LengthSquared())
+                .OrderBy(entity => (transformSys.GetWorldPosition(entity) - transformSys.ToMapCoordinates(MouseCoords).Position).LengthSquared())
                 .ToList();
 
             if (snapToEntities.Count == 0)
@@ -51,10 +53,11 @@ namespace Robust.Client.Placement.Modes
 
             var closestBounds = component.BaseRSI.Size;
 
+            var closestPos = transformSys.GetWorldPosition(closestTransform);
             var closestRect =
                 Box2.FromDimensions(
-                    closestTransform.WorldPosition.X - closestBounds.X / 2f,
-                    closestTransform.WorldPosition.Y - closestBounds.Y / 2f,
+                    closestPos.X - closestBounds.X / 2f,
+                    closestPos.Y - closestBounds.Y / 2f,
                     closestBounds.X, closestBounds.Y);
 
             var sides = new[]

Robust.Client/Placement/Modes/AlignSnapgridBorder.cs

@@ -21,7 +21,8 @@ namespace Robust.Client.Placement.Modes
         {
             MouseCoords = ScreenToCursorGrid(mouseScreen);
 
-            var gridIdOpt = MouseCoords.GetGridUid(pManager.EntityManager);
+            var transformSys = pManager.EntityManager.System<SharedTransformSystem>();
+            var gridIdOpt = transformSys.GetGrid(MouseCoords);
             SnapSize = 1f;
             if (gridIdOpt is EntityUid gridId && gridId.IsValid())
             {

Robust.Client/Placement/Modes/AlignTileDense.cs

@@ -16,8 +16,10 @@ namespace Robust.Client.Placement.Modes
         {
             MouseCoords = ScreenToCursorGrid(mouseScreen);
 
+            var transformSys = pManager.EntityManager.System<SharedTransformSystem>();
+
             var tileSize = 1f;
-            var gridIdOpt = MouseCoords.GetGridUid(pManager.EntityManager);
+            var gridIdOpt = transformSys.GetGrid(MouseCoords);
 
             if (gridIdOpt is EntityUid gridId && gridId.IsValid())
             {

Robust.Client/Placement/Modes/AlignTileNonDense.cs

@@ -16,9 +16,11 @@ namespace Robust.Client.Placement.Modes
         {
             MouseCoords = ScreenToCursorGrid(mouseScreen);
 
+            var transformSys = pManager.EntityManager.System<SharedTransformSystem>();
+
             var tileSize = 1f;
 
-            var gridIdOpt = MouseCoords.GetGridUid(pManager.EntityManager);
+            var gridIdOpt = transformSys.GetGrid(MouseCoords);
             if (gridIdOpt is EntityUid gridId && gridId.IsValid())
             {
                 var mapGrid = pManager.EntityManager.GetComponent<MapGridComponent>(gridId);

Robust.Client/Placement/PlacementMode.cs

@@ -121,8 +121,8 @@ namespace Robust.Client.Placement
             {
                 if (!coordinate.IsValid(pManager.EntityManager))
                     return; // Just some paranoia just in case
-                var worldPos = coordinate.ToMapPos(pManager.EntityManager, transformSys);
-                var worldRot = pManager.EntityManager.GetComponent<TransformComponent>(coordinate.EntityId).WorldRotation + dirAng;
+                var worldPos = transformSys.ToMapCoordinates(coordinate).Position;
+                var worldRot = transformSys.GetWorldRotation(coordinate.EntityId) + dirAng;
 
                 sprite.Color = IsValidPosition(coordinate) ? ValidPlaceColor : InvalidPlaceColor;
                 var rot = args.Viewport.Eye?.Rotation ?? default;
@@ -230,7 +230,7 @@ namespace Robust.Client.Placement
 
             var range = pManager.CurrentPermission!.Range;
             var transformSys = pManager.EntityManager.System<SharedTransformSystem>();
-            if (range > 0 && !pManager.EntityManager.GetComponent<TransformComponent>(controlled).Coordinates.InRange(pManager.EntityManager, transformSys, coordinates, range))
+            if (range > 0 && !transformSys.InRange(pManager.EntityManager.GetComponent<TransformComponent>(controlled).Coordinates, coordinates, range))
                 return false;
             return true;
         }
@@ -239,7 +239,7 @@ namespace Robust.Client.Placement
         {
             var bounds = pManager.ColliderAABB;
             var transformSys = pManager.EntityManager.System<SharedTransformSystem>();
-            var mapCoords = coordinates.ToMap(pManager.EntityManager, transformSys);
+            var mapCoords = transformSys.ToMapCoordinates(coordinates);
             var (x, y) = mapCoords.Position;
 
             var collisionBox = Box2.FromDimensions(
@@ -248,7 +248,9 @@ namespace Robust.Client.Placement
                 bounds.Width,
                 bounds.Height);
 
-            return EntitySystem.Get<SharedPhysicsSystem>().TryCollideRect(collisionBox, mapCoords.MapId);
+            return pManager.EntityManager
+                .System<SharedPhysicsSystem>()
+                .TryCollideRect(collisionBox, mapCoords.MapId);
         }
 
         protected Vector2 ScreenToWorld(Vector2 point)
@@ -265,10 +267,8 @@ namespace Robust.Client.Placement
         {
             var mapCoords = pManager.EyeManager.PixelToMap(coords.Position);
             var transformSys = pManager.EntityManager.System<SharedTransformSystem>();
-
-            if (!pManager.MapManager.TryFindGridAt(mapCoords, out var gridUid, out var grid))
+            if (!pManager.MapManager.TryFindGridAt(mapCoords, out var gridUid, out _))
             {
-
                 return transformSys.ToCoordinates(mapCoords);
             }
 

Robust.Client/Prototypes/ClientPrototypeManager.cs

@@ -2,9 +2,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using Robust.Client.Timing;
-using Robust.Client.Utility;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
 using Robust.Shared.Prototypes;
@@ -56,7 +54,7 @@ namespace Robust.Client.Prototypes
             using var _ = _timing.StartStateApplicationArea();
             ReloadPrototypes([file]);
 
-            Logger.Info($"Reloaded prototypes in {sw.ElapsedMilliseconds} ms");
+            Sawmill.Info($"Reloaded prototypes in {sw.ElapsedMilliseconds} ms");
 #endif
         }
     }

Robust.Client/UserInterface/Controls/ItemList.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 using System.Numerics;
 using Robust.Client.Graphics;
+using Robust.Shared.Collections;
 using Robust.Shared.Graphics;
 using Robust.Shared.Input;
 using Robust.Shared.Maths;
@@ -83,9 +84,23 @@ namespace Robust.Client.UserInterface.Controls
             _updateScrollbarVisibility();
         }
 
+        public void Add(IEnumerable<Item> items)
+        {
+            foreach (var item in items)
+            {
+                if(item.Owner != this) throw new ArgumentException("Item is owned by another ItemList!");
+
+                _itemList.Add(item);
+
+                item.OnSelected += Select;
+                item.OnDeselected += Deselect;
+            }
+
+            Recalculate();
+        }
+
         public void Add(Item item)
         {
-            if (item == null) return;
             if(item.Owner != this) throw new ArgumentException("Item is owned by another ItemList!");
 
             _itemList.Add(item);
@@ -93,9 +108,19 @@ namespace Robust.Client.UserInterface.Controls
             item.OnSelected += Select;
             item.OnDeselected += Deselect;
 
-            RecalculateContentHeight();
-            if (_isAtBottom && ScrollFollowing)
-                _scrollBar.MoveToEnd();
+            Recalculate();
+        }
+
+        public void AddItems(IEnumerable<string> texts, Texture? icon = null, bool selectable = true, object? metadata = null)
+        {
+            var items = new ValueList<Item>();
+
+            foreach (var text in texts)
+            {
+                items.Add(new Item(this) {Text = text, Icon = icon, Selectable = selectable, Metadata = metadata});
+            }
+
+            Add(items);
         }
 
         public Item AddItem(string text, Texture? icon = null, bool selectable = true, object? metadata = null)
@@ -107,11 +132,15 @@ namespace Robust.Client.UserInterface.Controls
 
         public void Clear()
         {
-            foreach (var item in _itemList.ToArray())
+            // Handle this manually so we can just clear all at once.
+            foreach (var item in _itemList)
             {
-                Remove(item);
+                item.OnSelected -= Select;
+                item.OnDeselected -= Deselect;
             }
 
+            _itemList.Clear();
+            Recalculate();
             _totalContentHeight = 0;
         }
 
@@ -125,25 +154,35 @@ namespace Robust.Client.UserInterface.Controls
             _itemList.CopyTo(array, arrayIndex);
         }
 
+        private void InternalRemoveAt(int index)
+        {
+            if (_itemList.Count <= index)
+                return;
+
+            // If you modify this then also make sure to update Clear!
+            var item = _itemList[index];
+            _itemList.RemoveAt(index);
+
+            item.OnSelected -= Select;
+            item.OnDeselected -= Deselect;
+        }
+
         public bool Remove(Item item)
         {
-            if (item == null) return false;
-
             var value =  _itemList.Remove(item);
 
             item.OnSelected -= Select;
             item.OnDeselected -= Deselect;
 
-            RecalculateContentHeight();
-            if (_isAtBottom && ScrollFollowing)
-                _scrollBar.MoveToEnd();
+            Recalculate();
 
             return value;
         }
 
         public void RemoveAt(int index)
         {
-            Remove(this[index]);
+            InternalRemoveAt(index);
+            Recalculate();
         }
 
         public IEnumerator<Item> GetEnumerator()
@@ -161,16 +200,24 @@ namespace Robust.Client.UserInterface.Controls
             return _itemList.IndexOf(item);
         }
 
-        public void Insert(int index, Item item)
+        private void InternalInsert(int index, Item item)
         {
-            if (item == null) return;
             if(item.Owner != this) throw new ArgumentException("Item is owned by another ItemList!");
 
             _itemList.Insert(index, item);
 
             item.OnSelected += Select;
             item.OnDeselected += Deselect;
+        }
 
+        public void Insert(int index, Item item)
+        {
+            InternalInsert(index, item);
+            Recalculate();
+        }
+
+        private void Recalculate()
+        {
             RecalculateContentHeight();
             if (_isAtBottom && ScrollFollowing)
                 _scrollBar.MoveToEnd();
@@ -191,7 +238,6 @@ namespace Robust.Client.UserInterface.Controls
             SetItems(newItems, (a,b) => string.Compare(a.Text, b.Text));
         }
 
-        /// <inheritdoc />
         /// <summary>
         /// This variant allows for a custom equality operator to compare items, when
         /// comparing the Item text is not desired.
@@ -215,13 +261,13 @@ namespace Robust.Client.UserInterface.Controls
                 else if (cmpResult > 0)
                 {
                     // Item exists in our list, but not in `newItems`. Remove it.
-                    RemoveAt(i);
+                    InternalRemoveAt(i);
                     i--;
                 }
                 else if (cmpResult < 0)
                 {
                     // A new entry which doesn't exist in our list. Insert it.
-                    Insert(i + 1, newItems[j]);
+                    InternalInsert(i + 1, newItems[j]);
                     j--;
                 }
             }
@@ -229,16 +275,18 @@ namespace Robust.Client.UserInterface.Controls
             // Any remaining items in our list don't exist in `newItems` so remove them
             while (i >= 0)
             {
-                RemoveAt(i);
+                InternalRemoveAt(i);
                 i--;
             }
 
             // And finally, any remaining items in `newItems` don't exist in our list. Create them.
             while (j >= 0)
             {
-                Insert(0, newItems[j]);
+                InternalInsert(0, newItems[j]);
                 j--;
             }
+
+            Recalculate();
         }
 
         // Without this attribute, this would compile into a property called "Item", causing problems with the Item class.
@@ -290,9 +338,12 @@ namespace Robust.Client.UserInterface.Controls
 
         public void ClearSelected(int? except = null)
         {
-            foreach (var item in GetSelected())
+            for (var i = 0; i < _itemList.Count; i++)
             {
-                if(IndexOf(item) == except) continue;
+                if (i == except)
+                    continue;
+
+                var item = _itemList[i];
                 item.Selected = false;
             }
         }

Robust.Client/UserInterface/UIConstants.cs

@@ -0,0 +1,7 @@
+namespace Robust.Client.UserInterface;
+
+internal static class UIConstants
+{
+    public const string ObsoleteInheritanceMessage =
+        "Do not inherit from standard UI controls, compose via nesting instead";
+}

Robust.Client/UserInterface/UserInterfaceManager.Input.cs

@@ -103,7 +103,6 @@ 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);
@@ -115,10 +114,6 @@ 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);

Robust.Client/UserInterface/UserInterfaceManager.Layout.cs

@@ -5,9 +5,9 @@ using Robust.Client.Graphics;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.Localization;
-using Robust.Shared.Log;
 using Robust.Shared.Maths;
 using Robust.Shared.Profiling;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.UserInterface;
 internal sealed partial class UserInterfaceManager
@@ -61,7 +61,7 @@ internal sealed partial class UserInterfaceManager
                 Title = string.IsNullOrEmpty(title) ? Loc.GetString("popup-title") : title,
             };
 
-            var label = new Label { Text = contents };
+            var label = new RichTextLabel { Text = $"[color=white]{FormattedMessage.EscapeText(contents)}[/color]" };
 
             var vBox = new BoxContainer
             {

Robust.Client/ViewVariables/ViewVariablesAddWindow.xaml.cs

@@ -2,11 +2,15 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
+using System.Threading;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Collections;
 using Robust.Shared.Localization;
+using Robust.Shared.Log;
+using Robust.Shared.Timing;
 
 namespace Robust.Client.ViewVariables
 {
@@ -51,15 +55,19 @@ namespace Robust.Client.ViewVariables
             _lastSearch = search;
             EntryItemList.ClearSelected();
             EntryItemList.Clear();
+
             AddButton.Disabled = true;
+            var items = new ValueList<string>();
 
             foreach (var component in _entries)
             {
                 if(!string.IsNullOrEmpty(search) && !component.Contains(search, StringComparison.InvariantCultureIgnoreCase))
                     continue;
 
-                EntryItemList.AddItem(component);
+                items.Add(component);
             }
+
+            EntryItemList.AddItems(items);
         }
 
         private void OnSearchTextChanged(LineEdit.LineEditEventArgs obj)

Robust.Roslyn.Shared/Diagnostics.cs

@@ -37,6 +37,8 @@ public static class Diagnostics
     public const string IdPreferOtherType = "RA0031";
     public const string IdDuplicateDependency = "RA0032";
     public const string IdForbidLiteral = "RA0033";
+    public const string IdObsoleteInheritance = "RA0034";
+    public const string IdObsoleteInheritanceWithMessage = "RA0035";
 
     public static SuppressionDescriptor MeansImplicitAssignment =>
         new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");

Robust.Server/BaseServer.cs

@@ -297,7 +297,7 @@ namespace Robust.Server
                 : null;
 
             // Set up the VFS
-            _resources.Initialize(dataDir);
+            _resources.Initialize(dataDir, hideUserDataDir: false);
 
             var mountOptions = _commandLineArgs != null
                 ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions) : Options.MountOptions;

Robust.Server/Console/Commands/ScaleCommand.cs

@@ -4,6 +4,7 @@ using Robust.Server.GameObjects;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Localization;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Physics.Collision.Shapes;
@@ -16,6 +17,20 @@ public sealed class ScaleCommand : LocalizedCommands
     [Dependency] private readonly IEntityManager _entityManager = default!;
 
     public override string Command => "scale";
+
+    public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+    {
+        switch (args.Length)
+        {
+            case 1:
+                return CompletionResult.FromOptions(CompletionHelper.NetEntities(args[0], entManager: _entityManager));
+            case 2:
+                return CompletionResult.FromHint(Loc.GetString("cmd-hint-float"));
+            default:
+                return CompletionResult.Empty;
+        }
+    }
+
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
         if (args.Length != 2)

Robust.Server/GameStates/PvsData.cs

@@ -204,7 +204,7 @@ internal struct PvsMetadata
     {
         DebugTools.AssertEqual(NetEntity, comp.NetEntity);
         DebugTools.AssertEqual(VisMask, comp.VisibilityMask);
-        DebugTools.Assert(LifeStage == comp.EntityLifeStage);
+        DebugTools.AssertEqual(LifeStage, comp.EntityLifeStage);
         DebugTools.Assert(LastModifiedTick == comp.EntityLastModifiedTick || LastModifiedTick.Value == 0);
     }
 }

Robust.Server/Physics/GridFixtureSystem.cs

@@ -268,7 +268,6 @@ namespace Robust.Server.Physics
                     newGrids[i] = newGridUid;
 
                     // Keep same origin / velocity etc; this makes updating a lot faster and easier.
-                    _xformSystem.SetWorldPosition(newGridXform, gridPos);
                     _xformSystem.SetWorldPositionRotation(newGridUid, gridPos, gridRot, newGridXform);
                     var splitBody = _bodyQuery.GetComponent(newGridUid);
                     _physics.SetLinearVelocity(newGridUid, mapBody.LinearVelocity, body: splitBody);
@@ -290,7 +289,7 @@ namespace Robust.Server.Physics
                     }
 
                     _maps.SetTiles(newGrid.Owner, newGrid.Comp, tileData);
-                    DebugTools.Assert(_mapManager.IsGrid(newGridUid), "A split grid had no tiles?");
+                    DebugTools.Assert(_gridQuery.HasComp(newGridUid), "A split grid had no tiles?");
 
                     // Set tiles on new grid + update anchored entities
                     foreach (var node in group)

Robust.Shared/Analyzers/ObsoleteInheritanceAttribute.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace Robust.Shared.Analyzers;
+
+/// <summary>
+/// Indicates that the ability to <i>inherit</i> this type is obsolete, and attempting to do so should give a warning.
+/// </summary>
+/// <remarks>
+/// This is useful to gracefully deal with types that should never have had <see cref="VirtualAttribute"/>.
+/// </remarks>
+/// <seealso cref="VirtualAttribute"/>
+[AttributeUsage(AttributeTargets.Class, Inherited = false)]
+public sealed class ObsoleteInheritanceAttribute : Attribute
+{
+    /// <summary>
+    /// An optional message provided alongside this obsoletion.
+    /// </summary>
+    public string? Message { get; }
+
+    public ObsoleteInheritanceAttribute()
+    {
+    }
+
+    public ObsoleteInheritanceAttribute(string message)
+    {
+        Message = message;
+    }
+}

Robust.Shared/Analyzers/VirtualAttribute.cs

@@ -9,6 +9,7 @@ namespace Robust.Shared.Analyzers;
 /// Robust uses analyzers to prevent accidental usage of non-sealed classes:
 /// a class must be either marked [Virtual], abstract, or sealed.
 /// </remarks>
+/// <seealso cref="ObsoleteInheritanceAttribute"/>
 [AttributeUsage(AttributeTargets.Class, Inherited = false)]
 public sealed class VirtualAttribute : Attribute
 {

Robust.Shared/CVars.cs

@@ -968,6 +968,13 @@ namespace Robust.Shared
         public static readonly CVarDef<string> RenderFOVColor =
             CVarDef.Create("render.fov_color", Color.Black.ToHex(), CVar.REPLICATED | CVar.SERVER);
 
+        /// <summary>
+        /// Whether to render tile edges, which is where some tiles can partially overlap other adjacent tiles on a grid.
+        /// E.g., snow tiles partly extending beyond their own tile to blend together with different adjacent tiles types.
+        /// </summary>
+        public static readonly CVarDef<bool> RenderTileEdges =
+            CVarDef.Create("render.tile_edges", true, CVar.CLIENTONLY);
+
         /*
          *  CONTROLS
          */

Robust.Shared/ComponentTrees/RecursiveMoveSystem.cs

@@ -1,6 +1,7 @@
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.ComponentTrees;
@@ -13,20 +14,23 @@ namespace Robust.Shared.ComponentTrees;
 /// </remarks>
 internal sealed class RecursiveMoveSystem : EntitySystem
 {
-    [Dependency] private readonly IMapManager _mapManager = default!;
     [Dependency] private readonly SharedTransformSystem _transform = default!;
 
     public delegate void TreeRecursiveMoveEventHandler(EntityUid uid, TransformComponent xform);
 
     public event TreeRecursiveMoveEventHandler? OnTreeRecursiveMove;
 
+    private EntityQuery<MapComponent> _mapQuery;
+    private EntityQuery<MapGridComponent> _gridQuery;
     private EntityQuery<TransformComponent> _xformQuery;
 
-    bool _subscribed = false;
+    private bool _subscribed = false;
 
     public override void Initialize()
     {
         base.Initialize();
+        _gridQuery = GetEntityQuery<MapGridComponent>();
+        _mapQuery = GetEntityQuery<MapComponent>();
         _xformQuery = GetEntityQuery<TransformComponent>();
     }
 
@@ -52,8 +56,8 @@ internal sealed class RecursiveMoveSystem : EntitySystem
         if (args.Component.MapUid == args.Sender || args.Component.GridUid == args.Sender)
             return;
 
-        DebugTools.Assert(!_mapManager.IsMap(args.Sender));
-        DebugTools.Assert(!_mapManager.IsGrid(args.Sender));
+        DebugTools.Assert(!_mapQuery.HasComp(args.Sender));
+        DebugTools.Assert(!_gridQuery.HasComp(args.Sender));
 
         AnythingMovedSubHandler(args.Sender, args.Component);
     }

Robust.Shared/Console/Commands/MapCommands.cs

@@ -37,7 +37,7 @@ sealed class AddMapCommand : LocalizedEntityCommands
 
 sealed class RemoveMapCommand : LocalizedCommands
 {
-    [Dependency] private readonly IMapManager _map = default!;
+    [Dependency] private readonly IEntitySystemManager _systems = default!;
 
     public override string Command => "rmmap";
     public override bool RequireServerOrSingleplayer => true;
@@ -51,14 +51,15 @@ sealed class RemoveMapCommand : LocalizedCommands
         }
 
         var mapId = new MapId(int.Parse(args[0]));
+        var mapSystem = _systems.GetEntitySystem<SharedMapSystem>();
 
-        if (!_map.MapExists(mapId))
+        if (!mapSystem.MapExists(mapId))
         {
             shell.WriteError($"Map {mapId.Value} does not exist.");
             return;
         }
 
-        _map.DeleteMap(mapId);
+        mapSystem.DeleteMap(mapId);
         shell.WriteLine($"Map {mapId.Value} was removed.");
     }
 }

Robust.Shared/Console/Commands/TeleportCommands.cs

@@ -20,6 +20,7 @@ internal sealed class TeleportCommand : LocalizedEntityCommands
     [Dependency] private readonly IMapManager _map = default!;
     [Dependency] private readonly IEntityManager _entityManager = default!;
     [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly SharedMapSystem _mapSystem = default!;
 
     public override string Command => "tp";
     public override bool RequireServerOrSingleplayer => true;
@@ -46,7 +47,7 @@ internal sealed class TeleportCommand : LocalizedEntityCommands
         else
             mapId = transform.MapID;
 
-        if (!_map.MapExists(mapId))
+        if (!_mapSystem.MapExists(mapId))
         {
             shell.WriteError($"Map {mapId} doesn't exist!");
             return;
@@ -60,9 +61,11 @@ internal sealed class TeleportCommand : LocalizedEntityCommands
         }
         else
         {
-            var mapEnt = _map.GetMapEntityIdOrThrow(mapId);
-            _transform.SetWorldPosition((entity, transform), position);
-            _transform.SetParent(entity, transform, mapEnt);
+            if (_mapSystem.TryGetMap(mapId, out var mapEnt))
+            {
+                _transform.SetWorldPosition((entity, transform), position);
+                _transform.SetParent(entity, transform, mapEnt.Value);
+            }
         }
 
         shell.WriteLine($"Teleported {shell.Player} to {mapId}:{posX},{posY}.");

Robust.Shared/Containers/ContainerSlot.cs

@@ -71,7 +71,7 @@ namespace Robust.Shared.Containers
 
             #if DEBUG
             // TODO make this a proper debug assert when gun code no longer fudges client-side spawn prediction.
-            if (entMan.IsClientSide(toInsert) && !entMan.IsClientSide(Owner) && Manager.NetSyncEnabled)
+            if (entMan.IsClientSide(toInsert) && !entMan.IsClientSide(Owner) && Manager.NetSyncEnabled && !entMan.HasComponent<PredictedSpawnComponent>(toInsert))
                 Logger.Warning("Inserting a client-side entity into a networked container slot. This will block the container slot and may cause issues.");
             #endif
             ContainedEntity = toInsert;

Robust.Shared/Containers/SharedContainerSystem.cs

@@ -530,6 +530,39 @@ namespace Robust.Shared.Containers
             return false;
         }
 
+        /// <summary>
+        /// Returns the full chain of containers containing the entity passed in, from innermost to outermost.
+        /// </summary>
+        /// <remarks>
+        /// The resulting collection includes the container directly containing the entity (if any),
+        /// the container containing that container, and so on until reaching the outermost container.
+        /// </remarks>
+        public IEnumerable<BaseContainer> GetContainingContainers(Entity<TransformComponent?> ent)
+        {
+            if (!ent.Owner.IsValid())
+                yield break;
+
+            if (!Resolve(ent, ref ent.Comp))
+                yield break;
+
+            var child = ent.Owner;
+            var parent = ent.Comp.ParentUid;
+
+            while (parent.IsValid())
+            {
+                if (((MetaQuery.GetComponent(child).Flags & MetaDataFlags.InContainer) == MetaDataFlags.InContainer) &&
+                    _managerQuery.TryGetComponent(parent, out var conManager) &&
+                    TryGetContainingContainer(parent, child, out var parentContainer, conManager))
+                {
+                    yield return parentContainer;
+                }
+
+                var parentXform = TransformQuery.GetComponent(parent);
+                child = parent;
+                parent = parentXform.ParentUid;
+            }
+        }
+
         /// <summary>
         /// Gets the top-most container in the hierarchy for this entity, if it exists.
         /// </summary>

Robust.Shared/ContentPack/DirLoader.cs

@@ -60,9 +60,7 @@ namespace Robust.Shared.ContentPack
 
             internal string GetPath(ResPath relPath)
             {
-                return Path.GetFullPath(Path.Combine(_directory.FullName, relPath.ToRelativeSystemPath()))
-                    // Sanitise platform-specific path and standardize it for engine use.
-                    .Replace(Path.DirectorySeparatorChar, '/');
+                return PathHelpers.SafeGetResourcePath(_directory.FullName, relPath);
             }
 
             /// <inheritdoc />

Robust.Shared/ContentPack/IResourceManagerInternal.cs

@@ -14,7 +14,11 @@ namespace Robust.Shared.ContentPack
         /// The directory to use for user data.
         /// If null, a virtual temporary file system is used instead.
         /// </param>
-        void Initialize(string? userData);
+        /// <param name="hideUserDataDir">
+        /// If true, <see cref="IWritableDirProvider.RootDir"/> will be hidden on
+        /// <see cref="IResourceManager.UserData"/>.
+        /// </param>
+        void Initialize(string? userData, bool hideUserDataDir);
 
         /// <summary>
         ///     Mounts a single stream as a content file. Useful for unit testing.

Robust.Shared/ContentPack/IWritableDirProvider.cs

@@ -13,7 +13,7 @@ namespace Robust.Shared.ContentPack
     {
         /// <summary>
         /// The root path of this provider.
-        /// Can be null if it's a virtual provider.
+        /// Can be null if it's a virtual provider or the path is protected (e.g. on the client).
         /// </summary>
         string? RootDir { get; }
 

Robust.Shared/ContentPack/PathHelpers.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
+using Robust.Shared.Utility;
 
 namespace Robust.Shared.ContentPack
 {
@@ -63,5 +64,27 @@ namespace Robust.Shared.ContentPack
             !OperatingSystem.IsWindows()
             && !OperatingSystem.IsMacOS();
 
+
+        internal static string SafeGetResourcePath(string baseDir, ResPath path)
+        {
+            var relSysPath = path.ToRelativeSystemPath();
+            if (relSysPath.Contains("\\..") || relSysPath.Contains("/.."))
+            {
+                // Hard cap on any exploit smuggling a .. in there.
+                // Since that could allow leaving sandbox.
+                throw new InvalidOperationException($"This branch should never be reached. Path: {path}");
+            }
+
+            var retPath = Path.GetFullPath(Path.Join(baseDir, relSysPath));
+            // better safe than sorry check
+            if (!retPath.StartsWith(baseDir))
+            {
+                // Allow path to match if it's just missing the directory separator at the end.
+                if (retPath != baseDir.TrimEnd(Path.DirectorySeparatorChar))
+                    throw new InvalidOperationException($"This branch should never be reached. Path: {path}");
+            }
+
+            return retPath;
+        }
     }
 }

Robust.Shared/ContentPack/ResourceManager.cs

@@ -41,13 +41,13 @@ namespace Robust.Shared.ContentPack
         public IWritableDirProvider UserData { get; private set; } = default!;
 
         /// <inheritdoc />
-        public virtual void Initialize(string? userData)
+        public virtual void Initialize(string? userData, bool hideRootDir)
         {
             Sawmill = _logManager.GetSawmill("res");
 
             if (userData != null)
             {
-                UserData = new WritableDirProvider(Directory.CreateDirectory(userData));
+                UserData = new WritableDirProvider(Directory.CreateDirectory(userData), hideRootDir);
             }
             else
             {
@@ -273,8 +273,6 @@ namespace Robust.Shared.ContentPack
 
         public IEnumerable<string> ContentGetDirectoryEntries(ResPath path)
         {
-            ArgumentNullException.ThrowIfNull(path, nameof(path));
-
             if (!path.IsRooted)
                 throw new ArgumentException("Path is not rooted", nameof(path));
 
@@ -381,6 +379,10 @@ namespace Robust.Shared.ContentPack
                 {
                     var rootDir = loader.GetPath(new ResPath(@"/"));
 
+                    // TODO: GET RID OF THIS.
+                    // This code shouldn't be passing OS disk paths through ResPath.
+                    rootDir = rootDir.Replace(Path.DirectorySeparatorChar, '/');
+
                     yield return new ResPath(rootDir);
                 }
             }

Robust.Shared/ContentPack/Sandbox.yml

@@ -497,6 +497,23 @@ Types:
     DebuggerVisualizerAttribute: { All: True }
     Stopwatch: { All: True }
   System.Globalization:
+  # all the calendars are here, screw making our own.
+    Calendar: { All: True }
+    ChineseLunisolarCalendar: { All: True }
+    GregorianCalendar: { All: True }
+    HebrewCalendar: { All: True }
+    HijriCalendar: { All: True }
+    JapaneseCalendar: { All: True }
+    JapaneseLunisolarCalendar:  { All: True }
+    JulianCalendar: { All: True }
+    KoreanCalendar: { All: True }
+    KoreanLunisolarCalendar: { All: True }
+    PersianCalendar: { All: True }
+    TaiwanCalendar: { All: True }
+    TaiwanLunisolarCalendar: { All: True }
+    ThaiBuddhistCalendar: { All: True }
+    UmAlQuraCalendar: { All: True }
+ #end calendars
     CompareOptions: { }
     CultureInfo: { All: True }
     DateTimeStyles: { All: True } # Enum
@@ -1071,6 +1088,7 @@ Types:
     DateTime: { All: True }
     DateTimeKind: { } # Enum
     DateTimeOffset: { All: True }
+    DayOfWeek: { } # Enum
     Decimal: { All: True }
     Delegate:
       Methods:

Robust.Shared/ContentPack/WritableDirProvider.cs

@@ -10,17 +10,22 @@ namespace Robust.Shared.ContentPack
     /// <inheritdoc />
     internal sealed class WritableDirProvider : IWritableDirProvider
     {
-        /// <inheritdoc />
+        private readonly bool _hideRootDir;
+
         public string RootDir { get; }
 
+        string? IWritableDirProvider.RootDir => _hideRootDir ? null : RootDir;
+
         /// <summary>
         /// Constructs an instance of <see cref="WritableDirProvider"/>.
         /// </summary>
         /// <param name="rootDir">Root file system directory to allow writing.</param>
-        public WritableDirProvider(DirectoryInfo rootDir)
+        /// <param name="hideRootDir">If true, <see cref="IWritableDirProvider.RootDir"/> is reported as null.</param>
+        public WritableDirProvider(DirectoryInfo rootDir, bool hideRootDir)
         {
             // FullName does not have a trailing separator, and we MUST have a separator.
             RootDir = rootDir.FullName + Path.DirectorySeparatorChar.ToString();
+            _hideRootDir = hideRootDir;
         }
 
         #region File Access
@@ -119,7 +124,7 @@ namespace Robust.Shared.ContentPack
                 throw new FileNotFoundException();
 
             var dirInfo = new DirectoryInfo(GetFullPath(path));
-            return new WritableDirProvider(dirInfo);
+            return new WritableDirProvider(dirInfo, _hideRootDir);
         }
 
         /// <inheritdoc />
@@ -180,20 +185,7 @@ namespace Robust.Shared.ContentPack
 
             path = path.Clean();
 
-            return GetFullPath(RootDir, path);
-        }
-
-        private static string GetFullPath(string root, ResPath path)
-        {
-            var relPath = path.ToRelativeSystemPath();
-            if (relPath.Contains("\\..") || relPath.Contains("/.."))
-            {
-                // Hard cap on any exploit smuggling a .. in there.
-                // Since that could allow leaving sandbox.
-                throw new InvalidOperationException($"This branch should never be reached. Path: {path}");
-            }
-
-            return Path.GetFullPath(Path.Combine(root, relPath));
+            return PathHelpers.SafeGetResourcePath(RootDir, path);
         }
     }
 }

Robust.Shared/EntitySerialization/EntityDeserializer.cs

@@ -475,7 +475,7 @@ public sealed class EntityDeserializer :
 
         foreach (var (key, value) in tileMap.Children)
         {
-            var yamlTileId = ((ValueDataNode) key).AsInt();
+            var yamlTileId = int.Parse(key, CultureInfo.InvariantCulture);
             var tileName = ((ValueDataNode) value).Value;
             if (migrations.TryGetValue(tileName, out var @new))
                 tileName = @new;
@@ -1000,7 +1000,7 @@ public sealed class EntityDeserializer :
                 continue;
 
             DebugTools.Assert(meta.EntityLifeStage == EntityLifeStage.Initialized);
-            meta.EntityLifeStage = EntityLifeStage.MapInitialized;
+            EntMan.SetLifeStage(meta, EntityLifeStage.MapInitialized);
         }
 
         _log.Debug($"Finished flagging mapinit in {_stopwatch.Elapsed}");

Robust.Shared/EntitySerialization/EntitySerializer.cs

@@ -155,9 +155,9 @@ public sealed class EntitySerializer : ISerializationContext,
     public event IsSerializableDelegate? OnIsSerializeable;
     public delegate void IsSerializableDelegate(Entity<MetaDataComponent> ent, ref bool serializable);
 
-    public EntitySerializer(IDependencyCollection _dependency, SerializationOptions options)
+    public EntitySerializer(IDependencyCollection dependency, SerializationOptions options)
     {
-        _dependency.InjectDependencies(this);
+        dependency.InjectDependencies(this);
 
         _log = _logMan.GetSawmill("entity_serializer");
         SerializerProvider.RegisterSerializer(this);

Robust.Shared/EntitySerialization/MapChunkSerializer.cs

@@ -69,7 +69,7 @@ internal sealed class MapChunkSerializer : ITypeSerializer<MapChunk, MappingData
 
         var tileDefinitionManager = dependencies.Resolve<ITileDefinitionManager>();
 
-        node.TryGetValue(new ValueDataNode("version"), out var versionNode);
+        node.TryGetValue("version", out var versionNode);
         var version = ((ValueDataNode?) versionNode)?.AsInt() ?? 1;
 
         for (ushort y = 0; y < chunk.ChunkSize; y++)

Robust.Shared/GameObjects/Components/MetaDataComponent.cs

@@ -147,7 +147,7 @@ namespace Robust.Shared.GameObjects
         ///     The current lifetime stage of this entity. You can use this to check
         ///     if the entity is initialized or being deleted.
         /// </summary>
-        [ViewVariables]
+        [ViewVariables, Access(typeof(EntityManager), Other = AccessPermissions.ReadExecute)]
         public EntityLifeStage EntityLifeStage { get; internal set; }
 
         public MetaDataFlags Flags

Robust.Shared/GameObjects/Components/PredictedSpawnComponent.cs

@@ -0,0 +1,7 @@
+namespace Robust.Shared.GameObjects;
+
+/// <summary>
+/// Indicates the attached entity was spawn predicted and should be reconciled when the server states comes in.
+/// </summary>
+[RegisterComponent]
+public sealed partial class PredictedSpawnComponent : Component;

Robust.Shared/GameObjects/EntityManager.Components.cs

@@ -595,12 +595,23 @@ namespace Robust.Shared.GameObjects
 
             if (!_deleteSet.Add(component))
             {
-                // already deferred deletion
+                // Already deferring deletion
+                DebugTools.Assert(component.LifeStage >= ComponentLifeStage.Stopped);
                 return;
             }
 
-            if (component.LifeStage >= ComponentLifeStage.Initialized && component.LifeStage <= ComponentLifeStage.Running)
+            DebugTools.Assert(component.LifeStage >= ComponentLifeStage.Added);
+
+            if (component.LifeStage is >= ComponentLifeStage.Initialized and < ComponentLifeStage.Stopping)
                 LifeShutdown(uid, component, _componentFactory.GetIndex(component.GetType()));
+            else if (component.LifeStage == ComponentLifeStage.Added)
+            {
+                // The component was added, but never initialized or started. It's kinda weird to add and then
+                // immediately defer-remove a component, but oh well. Let's just set the life stage directly and not
+                // raise shutdown events? The removal events will still get called later.
+                // This is also what LifeShutdown() would also do, albeit behind a DebugAssert.
+                component.LifeStage = ComponentLifeStage.Stopped;
+            }
 #if EXCEPTION_TOLERANCE
             }
             catch (Exception e)

Robust.Shared/GameObjects/EntityManager.LifeCycle.cs

@@ -14,8 +14,9 @@ public partial class EntityManager
     /// Increases the life stage from <see cref="ComponentLifeStage.PreAdd" /> to <see cref="ComponentLifeStage.Added" />,
     /// after raising a <see cref="ComponentAdd"/> event.
     /// </summary>
-    internal void LifeAddToEntity(EntityUid uid, IComponent component, CompIdx idx)
+    internal void LifeAddToEntity<T>(EntityUid uid, T component, CompIdx idx) where T : IComponent
     {
+        DebugTools.Assert(!_deleteSet.Contains(component));
         DebugTools.Assert(component.LifeStage == ComponentLifeStage.PreAdd);
 
 #pragma warning disable CS0618 // Type or member is obsolete
@@ -32,8 +33,9 @@ public partial class EntityManager
     /// Increases the life stage from <see cref="ComponentLifeStage.Added" /> to <see cref="ComponentLifeStage.Initialized" />,
     /// calling <see cref="Initialize" />.
     /// </summary>
-    internal void LifeInitialize(EntityUid uid, IComponent component, CompIdx idx)
+    internal void LifeInitialize<T>(EntityUid uid, T component, CompIdx idx) where T : IComponent
     {
+        DebugTools.Assert(!_deleteSet.Contains(component));
         DebugTools.Assert(component.LifeStage == ComponentLifeStage.Added);
 
         component.LifeStage = ComponentLifeStage.Initializing;
@@ -45,8 +47,9 @@ public partial class EntityManager
     /// Increases the life stage from <see cref="ComponentLifeStage.Initialized" /> to
     /// <see cref="ComponentLifeStage.Running" />, calling <see cref="Startup" />.
     /// </summary>
-    internal void LifeStartup(EntityUid uid, IComponent component, CompIdx idx)
+    internal void LifeStartup<T>(EntityUid uid, T component, CompIdx idx) where T : IComponent
     {
+        DebugTools.Assert(!_deleteSet.Contains(component));
         DebugTools.Assert(component.LifeStage == ComponentLifeStage.Initialized);
 
         component.LifeStage = ComponentLifeStage.Starting;
@@ -61,7 +64,7 @@ public partial class EntityManager
     /// <remarks>
     /// Components are allowed to remove themselves in their own Startup function.
     /// </remarks>
-    internal void LifeShutdown(EntityUid uid, IComponent component, CompIdx idx)
+    internal void LifeShutdown<T>(EntityUid uid, T component, CompIdx idx) where T : IComponent
     {
         DebugTools.Assert(component.LifeStage is >= ComponentLifeStage.Initializing and < ComponentLifeStage.Stopping);
 
@@ -81,7 +84,7 @@ public partial class EntityManager
     /// Increases the life stage from <see cref="ComponentLifeStage.Stopped" /> to <see cref="ComponentLifeStage.Deleted" />,
     /// calling <see cref="Component.OnRemove" />.
     /// </summary>
-    internal void LifeRemoveFromEntity(EntityUid uid, IComponent component, CompIdx idx)
+    internal void LifeRemoveFromEntity<T>(EntityUid uid, T component, CompIdx idx) where T : IComponent
     {
         // can be called at any time after PreAdd, including inside other life stage events.
         DebugTools.Assert(component.LifeStage != ComponentLifeStage.PreAdd);

Robust.Shared/GameObjects/EntityManager.Spawn.cs

@@ -6,6 +6,7 @@ using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using Robust.Shared.Containers;
 using Robust.Shared.Maths;
+using Robust.Shared.Serialization;
 
 namespace Robust.Shared.GameObjects;
 
@@ -79,7 +80,7 @@ public partial class EntityManager
             throw new InvalidOperationException($"Tried to spawn entity {protoName} on invalid coordinates {coordinates}.");
 
         var entity = CreateEntityUninitialized(protoName, coordinates, overrides, rotation);
-        InitializeAndStartEntity(entity, coordinates.GetMapId(this));
+        InitializeAndStartEntity(entity, _xforms.GetMapId(coordinates));
         return entity;
     }
 
@@ -100,7 +101,7 @@ public partial class EntityManager
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public EntityUid SpawnAtPosition(string? protoName, EntityCoordinates coordinates, ComponentRegistry? overrides = null)
-        => Spawn(protoName, coordinates.ToMap(this, _xforms), overrides);
+        => Spawn(protoName, _xforms.ToMapCoordinates(coordinates), overrides);
 
     public bool TrySpawnNextTo(
         string? protoName,
@@ -206,4 +207,91 @@ public partial class EntityManager
 
         return uid;
     }
+
+    #region Prediction
+
+    public virtual EntityUid PredictedSpawnAttachedTo(string? protoName, EntityCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default)
+    {
+        return SpawnAttachedTo(protoName, coordinates, overrides, rotation);
+    }
+
+    public virtual EntityUid PredictedSpawn(string? protoName = null, ComponentRegistry? overrides = null, bool doMapInit = true)
+    {
+        return Spawn(protoName, overrides, doMapInit);
+    }
+
+    public virtual EntityUid PredictedSpawn(string? protoName, MapCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default!)
+    {
+        return Spawn(protoName, coordinates, overrides, rotation);
+    }
+
+    public virtual EntityUid PredictedSpawnAtPosition(string? protoName, EntityCoordinates coordinates, ComponentRegistry? overrides = null)
+    {
+        return SpawnAtPosition(protoName, coordinates, overrides);
+    }
+
+    public virtual bool PredictedTrySpawnNextTo(
+        string? protoName,
+        EntityUid target,
+        [NotNullWhen(true)] out EntityUid? uid,
+        TransformComponent? xform = null,
+        ComponentRegistry? overrides = null)
+    {
+        return TrySpawnNextTo(protoName, target, out uid, xform, overrides);
+    }
+
+    public virtual bool PredictedTrySpawnInContainer(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        [NotNullWhen(true)] out EntityUid? uid,
+        ContainerManagerComponent? containerComp = null,
+        ComponentRegistry? overrides = null)
+    {
+        return TrySpawnInContainer(protoName, containerUid, containerId, out uid, containerComp, overrides);
+    }
+
+    public virtual EntityUid PredictedSpawnNextToOrDrop(string? protoName, EntityUid target, TransformComponent? xform = null, ComponentRegistry? overrides = null)
+    {
+        return SpawnNextToOrDrop(protoName, target, xform, overrides);
+    }
+
+    public virtual EntityUid PredictedSpawnInContainerOrDrop(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        TransformComponent? xform = null,
+        ContainerManagerComponent? containerComp = null,
+        ComponentRegistry? overrides = null)
+    {
+        return SpawnInContainerOrDrop(protoName, containerUid, containerId, xform, containerComp, overrides);
+    }
+
+    public virtual EntityUid PredictedSpawnInContainerOrDrop(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        out bool inserted,
+        TransformComponent? xform = null,
+        ContainerManagerComponent? containerComp = null,
+        ComponentRegistry? overrides = null)
+    {
+        return SpawnInContainerOrDrop(protoName,
+            containerUid,
+            containerId,
+            out inserted,
+            xform,
+            containerComp,
+            overrides);
+    }
+
+    /// <summary>
+    /// Flags an entity as being a predicted spawn and should be deleted when its corresponding tick comes in.
+    /// </summary>
+    public virtual void FlagPredicted(Entity<MetaDataComponent?> ent)
+    {
+
+    }
+
+    #endregion
 }

Robust.Shared/GameObjects/EntityManager.cs

@@ -48,7 +48,7 @@ namespace Robust.Shared.GameObjects
 
         // I feel like PJB might shed me for putting a system dependency here, but its required for setting entity
         // positions on spawn....
-        private SharedTransformSystem _xforms = default!;
+        protected SharedTransformSystem _xforms = default!;
         private SharedContainerSystem _containers = default!;
 
         public EntityQuery<MetaDataComponent> MetaQuery;
@@ -693,6 +693,36 @@ namespace Robust.Shared.GameObjects
 
         public bool IsQueuedForDeletion(EntityUid uid) => QueuedDeletionsSet.Contains(uid);
 
+        /// <inheritdoc />
+        public virtual void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
+        {
+            DeleteEntity(ent.Owner);
+        }
+
+        /// <inheritdoc />
+        public void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?>? ent)
+        {
+            if (ent == null)
+                return;
+
+            PredictedDeleteEntity(ent.Value);
+        }
+
+        /// <inheritdoc />
+        public virtual void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent)
+        {
+            QueueDeleteEntity(ent.Owner);
+        }
+
+        /// <inheritdoc />
+        public virtual void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?>? ent)
+        {
+            if (ent == null)
+                return;
+
+            PredictedQueueDeleteEntity(ent.Value);
+        }
+
         public bool EntityExists(EntityUid uid)
         {
             return MetaQuery.HasComponentInternal(uid);

Robust.Shared/GameObjects/EntitySystem.Proxy.cs

@@ -782,6 +782,34 @@ public partial class EntitySystem
         EntityManager.QueueDeleteEntity(uid);
     }
 
+    /// <inheritdoc cref="IEntityManager.DeleteEntity(EntityUid?)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected void PredictedDel(Entity<MetaDataComponent?, TransformComponent?> ent)
+    {
+        EntityManager.PredictedDeleteEntity(ent);
+    }
+
+    /// <inheritdoc cref="IEntityManager.DeleteEntity(EntityUid?)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected void PredictedDel(Entity<MetaDataComponent?, TransformComponent?>? ent)
+    {
+        EntityManager.PredictedDeleteEntity(ent);
+    }
+
+    /// <inheritdoc cref="IEntityManager.QueueDeleteEntity(EntityUid)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected void PredictedQueueDel(Entity<MetaDataComponent?, TransformComponent?> ent)
+    {
+        EntityManager.PredictedQueueDeleteEntity(ent);
+    }
+
+    /// <inheritdoc cref="IEntityManager.QueueDeleteEntity(EntityUid?)" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected void PredictedQueueDel(Entity<MetaDataComponent?, TransformComponent?>? ent)
+    {
+        EntityManager.PredictedQueueDeleteEntity(ent);
+    }
+
     /// <inheritdoc cref="IEntityManager.TryQueueDeleteEntity(EntityUid?)" />
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     protected bool TryQueueDel(EntityUid? uid)
@@ -812,8 +840,8 @@ public partial class EntitySystem
 
     /// <inheritdoc cref="IEntityManager.SpawnAttachedTo" />
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-    protected EntityUid SpawnAttachedTo(string? prototype, EntityCoordinates coordinates, ComponentRegistry? overrides = null)
-        => EntityManager.SpawnAttachedTo(prototype, coordinates, overrides);
+    protected EntityUid SpawnAttachedTo(string? prototype, EntityCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default)
+        => EntityManager.SpawnAttachedTo(prototype, coordinates, overrides, rotation);
 
     /// <inheritdoc cref="IEntityManager.SpawnAtPosition" />
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -871,6 +899,74 @@ public partial class EntitySystem
 
     #endregion
 
+    #region PredictedSpawning
+
+    protected void FlagPredicted(Entity<MetaDataComponent?> ent)
+    {
+        EntityManager.FlagPredicted(ent);
+    }
+
+    /// <inheritdoc cref="IEntityManager.SpawnAttachedTo" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected EntityUid PredictedSpawnAttachedTo(string? prototype, EntityCoordinates coordinates, ComponentRegistry? overrides = null, Angle rotation = default)
+        => EntityManager.PredictedSpawnAttachedTo(prototype, coordinates, overrides, rotation);
+
+    /// <inheritdoc cref="IEntityManager.SpawnAtPosition" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected EntityUid PredictedSpawnAtPosition(string? prototype, EntityCoordinates coordinates, ComponentRegistry? overrides = null)
+        => EntityManager.PredictedSpawnAtPosition(prototype, coordinates, overrides);
+
+    /// <inheritdoc cref="IEntityManager.TrySpawnInContainer" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected bool PredictedTrySpawnInContainer(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        [NotNullWhen(true)] out EntityUid? uid,
+        ContainerManagerComponent? containerComp = null,
+        ComponentRegistry? overrides = null)
+    {
+        return EntityManager.PredictedTrySpawnInContainer(protoName, containerUid, containerId, out uid, containerComp, overrides);
+    }
+
+    /// <inheritdoc cref="IEntityManager.TrySpawnNextTo" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected bool PredictedTrySpawnNextTo(
+        string? protoName,
+        EntityUid target,
+        [NotNullWhen(true)] out EntityUid? uid,
+        TransformComponent? xform = null,
+        ComponentRegistry? overrides = null)
+    {
+        return EntityManager.PredictedTrySpawnNextTo(protoName, target, out uid, xform, overrides);
+    }
+
+    /// <inheritdoc cref="IEntityManager.SpawnNextToOrDrop" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected EntityUid PredictedSpawnNextToOrDrop(
+        string? protoName,
+        EntityUid target,
+        TransformComponent? xform = null,
+        ComponentRegistry? overrides = null)
+    {
+        return EntityManager.PredictedSpawnNextToOrDrop(protoName, target, xform, overrides);
+    }
+
+    /// <inheritdoc cref="IEntityManager.SpawnInContainerOrDrop" />
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    protected EntityUid PredictedSpawnInContainerOrDrop(
+        string? protoName,
+        EntityUid containerUid,
+        string containerId,
+        TransformComponent? xform = null,
+        ContainerManagerComponent? container = null,
+        ComponentRegistry? overrides = null)
+    {
+        return EntityManager.PredictedSpawnInContainerOrDrop(protoName, containerUid, containerId, xform, container, overrides);
+    }
+
+    #endregion
+
     #region Utils
 
     /// <summary>

Robust.Shared/GameObjects/EntitySystem.Resolve.cs

@@ -37,18 +37,22 @@ namespace Robust.Shared.GameObjects
 
         /// <inheritdoc cref="Resolve{TComp}(Robust.Shared.GameObjects.EntityUid,ref TComp?,bool)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected bool Resolve(EntityUid uid, [NotNullWhen(true)] ref MetaDataComponent? component,
+        protected bool Resolve(
+            EntityUid uid,
+            [NotNullWhen(true)] ref MetaDataComponent? component,
             bool logMissing = true)
         {
-            return EntityManager.MetaQuery.Resolve(uid, ref component);
+            return EntityManager.MetaQuery.Resolve(uid, ref component, logMissing);
         }
 
         /// <inheritdoc cref="Resolve{TComp}(Robust.Shared.GameObjects.EntityUid,ref TComp?,bool)"/>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        protected bool Resolve(EntityUid uid, [NotNullWhen(true)] ref TransformComponent? component,
+        protected bool Resolve(
+            EntityUid uid,
+            [NotNullWhen(true)] ref TransformComponent? component,
             bool logMissing = true)
         {
-            return EntityManager.TransformQuery.Resolve(uid, ref component);
+            return EntityManager.TransformQuery.Resolve(uid, ref component, logMissing);
         }
 
         /// <summary>

Robust.Shared/GameObjects/IEntityManager.cs

@@ -162,6 +162,26 @@ namespace Robust.Shared.GameObjects
 
         public bool IsQueuedForDeletion(EntityUid uid);
 
+        /// <summary>
+        /// Tries to predict entity deletion. On the server it runs the normal code path and on the client the entity is detached.
+        /// </summary>
+        void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent);
+
+        /// <summary>
+        /// <see cref="PredictedDeleteEntity(Robust.Shared.GameObjects.Entity{Robust.Shared.GameObjects.MetaDataComponent?,Robust.Shared.GameObjects.TransformComponent?})"/>
+        /// </summary>
+        void PredictedDeleteEntity(Entity<MetaDataComponent?, TransformComponent?>? ent);
+
+        /// <summary>
+        /// Tries to predict entity deletion. On the server it runs the normal code path and on the client the entity is detached.
+        /// </summary>
+        void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?> ent);
+
+        /// <summary>
+        /// <see cref="PredictedQueueDeleteEntity(Robust.Shared.GameObjects.Entity{Robust.Shared.GameObjects.MetaDataComponent?,Robust.Shared.GameObjects.TransformComponent?})"/>
+        /// </summary>
+        void PredictedQueueDeleteEntity(Entity<MetaDataComponent?, TransformComponent?>? ent);
+
         /// <summary>
         /// Shuts-down and removes the entity with the given <see cref="Robust.Shared.GameObjects.EntityUid"/>. This is also broadcast to all clients.
         /// </summary>

Robust.Shared/GameObjects/Systems/EntityLookup.Queries.cs

@@ -429,7 +429,7 @@ public sealed partial class EntityLookupSystem
         float arcWidth,
         LookupFlags flags = DefaultFlags)
     {
-        var position = coordinates.ToMap(EntityManager, _transform);
+        var position = _transform.ToMapCoordinates(coordinates);
 
         return GetEntitiesInArc(position, range, direction, arcWidth, flags);
     }
@@ -628,7 +628,7 @@ public sealed partial class EntityLookupSystem
         if (!coordinates.IsValid(EntityManager))
             return false;
 
-        var mapPos = coordinates.ToMap(EntityManager, _transform);
+        var mapPos = _transform.ToMapCoordinates(coordinates);
         return AnyEntitiesIntersecting(mapPos, flags);
     }
 
@@ -637,13 +637,13 @@ public sealed partial class EntityLookupSystem
         if (!coordinates.IsValid(EntityManager))
             return false;
 
-        var mapPos = coordinates.ToMap(EntityManager, _transform);
+        var mapPos = _transform.ToMapCoordinates(coordinates);
         return AnyEntitiesInRange(mapPos, range, flags);
     }
 
     public HashSet<EntityUid> GetEntitiesIntersecting(EntityCoordinates coordinates, LookupFlags flags = DefaultFlags)
     {
-        var mapPos = coordinates.ToMap(EntityManager, _transform);
+        var mapPos = _transform.ToMapCoordinates(coordinates);
         return GetEntitiesIntersecting(mapPos, flags);
     }
 
@@ -656,7 +656,7 @@ public sealed partial class EntityLookupSystem
 
     public void GetEntitiesInRange(EntityCoordinates coordinates, float range, HashSet<EntityUid> entities, LookupFlags flags = DefaultFlags)
     {
-        var mapPos = coordinates.ToMap(EntityManager, _transform);
+        var mapPos = _transform.ToMapCoordinates(coordinates);
 
         if (mapPos.MapId == MapId.Nullspace)
             return;

Robust.Shared/GameObjects/Systems/EntityLookupSystem.ComponentQueries.cs

@@ -621,7 +621,7 @@ public sealed partial class EntityLookupSystem
 
     public void GetEntitiesInRange<T>(EntityCoordinates coordinates, float range, HashSet<Entity<T>> entities, LookupFlags flags = DefaultFlags) where T : IComponent
     {
-        var mapPos = coordinates.ToMap(EntityManager, _transform);
+        var mapPos = _transform.ToMapCoordinates(coordinates);
         GetEntitiesInRange(mapPos, range, entities, flags);
     }
 

Robust.Shared/GameObjects/Systems/EntityLookupSystem.cs

@@ -85,11 +85,11 @@ public sealed partial class EntityLookupSystem : EntitySystem
     private EntityQuery<BroadphaseComponent> _broadQuery;
     private EntityQuery<ContainerManagerComponent> _containerQuery;
     private EntityQuery<FixturesComponent> _fixturesQuery;
-
+    private EntityQuery<MapComponent> _mapQuery;
     private EntityQuery<MapGridComponent> _gridQuery;
     private EntityQuery<MetaDataComponent> _metaQuery;
     private EntityQuery<PhysicsComponent> _physicsQuery;
-    private EntityQuery<PhysicsMapComponent> _mapQuery;
+    private EntityQuery<PhysicsMapComponent> _physMapQuery;
     private EntityQuery<TransformComponent> _xformQuery;
 
     /// <summary>
@@ -115,10 +115,11 @@ public sealed partial class EntityLookupSystem : EntitySystem
         _broadQuery = GetEntityQuery<BroadphaseComponent>();
         _containerQuery = GetEntityQuery<ContainerManagerComponent>();
         _fixturesQuery = GetEntityQuery<FixturesComponent>();
+        _mapQuery = GetEntityQuery<MapComponent>();
         _gridQuery = GetEntityQuery<MapGridComponent>();
         _metaQuery = GetEntityQuery<MetaDataComponent>();
         _physicsQuery = GetEntityQuery<PhysicsComponent>();
-        _mapQuery = GetEntityQuery<PhysicsMapComponent>();
+        _physMapQuery = GetEntityQuery<PhysicsMapComponent>();
         _xformQuery = GetEntityQuery<TransformComponent>();
 
         SubscribeLocalEvent<BroadphaseComponent, EntityTerminatingEvent>(OnBroadphaseTerminating);
@@ -153,7 +154,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
     {
         var xform = _xformQuery.GetComponent(uid);
         var map = xform.MapUid;
-        _mapQuery.TryGetComponent(map, out var physMap);
+        _physMapQuery.TryGetComponent(map, out var physMap);
         RemoveChildrenFromTerminatingBroadphase(xform, component, physMap);
         RemComp(uid, component);
     }
@@ -174,12 +175,12 @@ public sealed partial class EntityLookupSystem : EntitySystem
                 continue;
 
             DebugTools.Assert(childXform.Broadphase.Value.Uid == component.Owner);
-            DebugTools.Assert(!_mapManager.IsGrid(child));
+            DebugTools.Assert(!_gridQuery.HasComp(child));
 
             if (childXform.Broadphase.Value.CanCollide && _fixturesQuery.TryGetComponent(child, out var fixtures))
             {
                 if (map == null)
-                    _mapQuery.TryGetComponent(childXform.Broadphase.Value.PhysicsMap, out map);
+                    _physMapQuery.TryGetComponent(childXform.Broadphase.Value.PhysicsMap, out map);
 
                 DebugTools.Assert(map == null || childXform.Broadphase.Value.PhysicsMap == map.Owner);
                 var tree = childXform.Broadphase.Value.Static ? component.StaticTree : component.DynamicTree;
@@ -226,7 +227,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
         if (xform.MapUid == null)
             return;
 
-        if (!_mapQuery.TryGetComponent(xform.MapUid, out var physMap))
+        if (!_physMapQuery.TryGetComponent(xform.MapUid, out var physMap))
         {
             throw new InvalidOperationException(
                 $"Broadphase's map is missing a physics map comp. Broadphase: {ToPrettyString(broadphase.Owner)}");
@@ -257,7 +258,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
             if (!xform.Broadphase.Value.IsValid())
                 return; // Entity is intentionally not on a broadphase (deferred updating?).
 
-            _mapQuery.TryGetComponent(xform.Broadphase.Value.PhysicsMap, out var oldPhysMap);
+            _physMapQuery.TryGetComponent(xform.Broadphase.Value.PhysicsMap, out var oldPhysMap);
             if (!_broadQuery.TryGetComponent(xform.Broadphase.Value.Uid, out var oldBroadphase))
             {
                 DebugTools.Assert("Encountered deleted broadphase.");
@@ -314,7 +315,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
         if (!TryGetCurrentBroadphase(xform, out var broadphase))
             return;
 
-        if (!_mapQuery.TryGetComponent(xform.MapUid, out var physMap))
+        if (!_physMapQuery.TryGetComponent(xform.MapUid, out var physMap))
             throw new InvalidOperationException();
 
         var (worldPos, worldRot) = _transform.GetWorldPositionRotation(xform);
@@ -380,7 +381,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
 
         if (xform.GridUid == uid)
             return;
-        DebugTools.Assert(!_mapManager.IsGrid(uid));
+        DebugTools.Assert(!HasComp<MapGridComponent>(uid));
 
         if (xform.Broadphase is not { Valid: true } old)
             return; // entity is not on any broadphase
@@ -394,7 +395,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
         var fixtures = Comp<FixturesComponent>(uid);
         if (old.CanCollide)
         {
-            _mapQuery.TryGetComponent(old.PhysicsMap, out var physicsMap);
+            _physMapQuery.TryGetComponent(old.PhysicsMap, out var physicsMap);
             RemoveBroadTree(broadphase, fixtures, old.Static, physicsMap);
         }
         else
@@ -437,7 +438,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
         if (broadphaseXform.MapID == MapId.Nullspace)
             return;
 
-        if (!_mapQuery.TryGetComponent(broadphaseXform.MapUid, out var physMap))
+        if (!_physMapQuery.TryGetComponent(broadphaseXform.MapUid, out var physMap))
             throw new InvalidOperationException($"Physics Broadphase is missing physics map. {ToPrettyString(broadUid)}");
 
         AddOrUpdatePhysicsTree(uid, broadUid, broadphase, broadphaseXform, physMap, xform, body, fixtures);
@@ -525,7 +526,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
 
     private void OnEntityInit(Entity<MetaDataComponent> uid)
     {
-        if (_container.IsEntityOrParentInContainer(uid, uid) || _mapManager.IsMap(uid) || _mapManager.IsGrid(uid))
+        if (_container.IsEntityOrParentInContainer(uid, uid) || _mapQuery.HasComp(uid) || _gridQuery.HasComp(uid))
             return;
 
         // TODO can this just be done implicitly via transform startup?
@@ -541,11 +542,11 @@ public sealed partial class EntityLookupSystem : EntitySystem
                 OnGridChangedMap(args);
             return;
         }
-        DebugTools.Assert(!_mapManager.IsGrid(args.Sender));
+        DebugTools.Assert(!_gridQuery.HasComp(args.Sender));
 
         if (args.Component.MapUid == args.Sender)
             return;
-        DebugTools.Assert(!_mapManager.IsMap(args.Sender));
+        DebugTools.Assert(!_mapQuery.HasComp(args.Sender));
 
         if (args.ParentChanged)
             UpdateParent(args.Sender, args.Component);
@@ -562,12 +563,12 @@ public sealed partial class EntityLookupSystem : EntitySystem
             return;
 
         // We need to recursively update the cached data and remove children from the move buffer
-        DebugTools.Assert(HasComp<MapGridComponent>(args.Sender));
-        DebugTools.Assert(!newMap.IsValid() || HasComp<MapComponent>(newMap));
-        DebugTools.Assert(!oldMap.IsValid() || HasComp<MapComponent>(oldMap));
+        DebugTools.Assert(_gridQuery.HasComp(args.Sender));
+        DebugTools.Assert(!newMap.IsValid() || _mapQuery.HasComp(newMap));
+        DebugTools.Assert(!oldMap.IsValid() || _mapQuery.HasComp(oldMap));
 
-        var oldBuffer = _mapQuery.CompOrNull(oldMap)?.MoveBuffer;
-        var newBuffer = _mapQuery.CompOrNull(newMap)?.MoveBuffer;
+        var oldBuffer = _physMapQuery.CompOrNull(oldMap)?.MoveBuffer;
+        var newBuffer = _physMapQuery.CompOrNull(newMap)?.MoveBuffer;
 
         foreach (var child in args.Component._children)
         {
@@ -635,7 +636,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
             if (!xform.Broadphase.Value.IsValid())
                 return; // Entity is intentionally not on a broadphase (deferred updating?).
 
-            _mapQuery.TryGetComponent(xform.Broadphase.Value.PhysicsMap, out oldPhysMap);
+            _physMapQuery.TryGetComponent(xform.Broadphase.Value.PhysicsMap, out oldPhysMap);
 
             if (!_broadQuery.TryGetComponent(xform.Broadphase.Value.Uid, out oldBroadphase))
             {
@@ -667,7 +668,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
             return;
 
         var newBroadphaseXform = _xformQuery.GetComponent(newBroadphase.Owner);
-        if (!_mapQuery.TryGetComponent(newBroadphaseXform.MapUid, out var physMap))
+        if (!_physMapQuery.TryGetComponent(newBroadphaseXform.MapUid, out var physMap))
         {
             throw new InvalidOperationException(
                 $"Broadphase's map is missing a physics map comp. Broadphase: {ToPrettyString(newBroadphase.Owner)}");
@@ -712,7 +713,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
         bool recursive = true)
     {
         var broadphaseXform = _xformQuery.GetComponent(broadphase.Owner);
-        if (!_mapQuery.TryGetComponent(broadphaseXform.MapUid, out var physMap))
+        if (!_physMapQuery.TryGetComponent(broadphaseXform.MapUid, out var physMap))
         {
             throw new InvalidOperationException(
                 $"Broadphase's map is missing a physics map comp. Broadphase: {ToPrettyString(broadphase.Owner)}");
@@ -793,10 +794,10 @@ public sealed partial class EntityLookupSystem : EntitySystem
         if (!TryGetCurrentBroadphase(xform, out var broadphase))
             return;
 
-        DebugTools.Assert(!HasComp<MapGridComponent>(uid));
-        DebugTools.Assert(!HasComp<MapComponent>(uid));
+        DebugTools.Assert(!_gridQuery.HasComp(uid));
+        DebugTools.Assert(!_mapQuery.HasComp(uid));
         PhysicsMapComponent? physMap = null;
-        if (xform.Broadphase!.Value.PhysicsMap is { Valid: true } map && !_mapQuery.TryGetComponent(map, out physMap))
+        if (xform.Broadphase!.Value.PhysicsMap is { Valid: true } map && !_physMapQuery.TryGetComponent(map, out physMap))
         {
             throw new InvalidOperationException(
                 $"Broadphase's map is missing a physics map comp. Broadphase: {ToPrettyString(broadphase.Owner)}");
@@ -834,7 +835,7 @@ public sealed partial class EntityLookupSystem : EntitySystem
 
         if (old.PhysicsMap.IsValid() && physicsMap?.Owner != old.PhysicsMap)
         {
-            if (!_mapQuery.TryGetComponent(old.PhysicsMap, out physicsMap))
+            if (!_physMapQuery.TryGetComponent(old.PhysicsMap, out physicsMap))
                 Log.Error($"Entity {ToPrettyString(uid)} has missing physics map?");
         }
 

Robust.Shared/GameObjects/Systems/SharedEyeSystem.cs

@@ -9,6 +9,7 @@ namespace Robust.Shared.GameObjects;
 public abstract class SharedEyeSystem : EntitySystem
 {
     [Dependency] private readonly SharedViewSubscriberSystem _views = default!;
+    [Dependency] protected readonly SharedTransformSystem TransformSystem = default!;
 
     public override void Initialize()
     {

Robust.Shared/GameObjects/Systems/SharedGridFixtureSystem.cs

@@ -1,11 +1,11 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Numerics;
 using Robust.Shared.Collections;
 using Robust.Shared.Configuration;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Map.Events;
@@ -16,7 +16,6 @@ using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Dynamics;
 using Robust.Shared.Physics.Systems;
 using Robust.Shared.Serialization;
-using Robust.Shared.Utility;
 
 namespace Robust.Shared.GameObjects
 {
@@ -150,7 +149,8 @@ namespace Robust.Shared.GameObjects
                 };
 #pragma warning restore CS0618
 
-                newFixtures.Add(($"grid_chunk-{bounds.Left}-{bounds.Bottom}", newFixture));
+                var key = string.Create(CultureInfo.InvariantCulture, $"grid_chunk-{bounds.Left}-{bounds.Bottom}");
+                newFixtures.Add((key, newFixture));
             }
 
             // Check if we even need to issue an eventbus event

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

@@ -23,7 +23,7 @@ public abstract partial class SharedMapSystem
         }
 
         // Check if mappos intersects a grid.
-        var mapPos = coordinates.ToMap(EntityManager, _transform);
+        var mapPos = _transform.ToMapCoordinates(coordinates);
 
         if (_mapInternal.TryFindGridAt(mapPos, out var gridUid, out gridComponent))
         {

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

@@ -1222,7 +1222,7 @@ public abstract partial class SharedMapSystem
     {
 #if DEBUG
         var mapId = _xformQuery.GetComponent(uid).MapID;
-        DebugTools.Assert(mapId == coords.GetMapId(EntityManager));
+        DebugTools.Assert(mapId == _transform.GetMapId(coords));
 #endif
 
         return SnapGridLocalCellFor(uid, grid, LocalToGrid(uid, grid, coords));
@@ -1432,7 +1432,7 @@ public abstract partial class SharedMapSystem
     {
 #if DEBUG
         var mapId = _xformQuery.GetComponent(uid).MapID;
-        DebugTools.Assert(mapId == coords.GetMapId(EntityManager));
+        DebugTools.Assert(mapId == _transform.GetMapId(coords));
 #endif
         var local = LocalToGrid(uid, grid, coords);
 
@@ -1454,7 +1454,7 @@ public abstract partial class SharedMapSystem
     {
         return position.EntityId == uid
             ? position.Position
-            : WorldToLocal(uid, grid, position.ToMapPos(EntityManager, _transform));
+            : WorldToLocal(uid, grid, _transform.ToMapCoordinates(position).Position);
     }
 
     public bool CollidesWithGrid(EntityUid uid, MapGridComponent grid, Vector2i indices)

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

@@ -5,7 +5,6 @@ using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Utility;
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using Robust.Shared.Map.Components;
@@ -1361,7 +1360,7 @@ public abstract partial class SharedTransformSystem
         }
         else
         {
-            if (!_mapManager.IsMap(uid))
+            if (!_mapQuery.HasComp(uid))
                 Log.Warning($"Failed to attach entity to map or grid. Entity: ({ToPrettyString(uid)}). Trace: {Environment.StackTrace}");
 
             DetachEntity(uid, xform);

Robust.Shared/GameObjects/Systems/SharedTransformSystem.cs

@@ -133,7 +133,7 @@ namespace Robust.Shared.GameObjects
             if (xform.GridUid == xform.ParentUid)
                 return xform.Coordinates;
 
-            DebugTools.Assert(!_mapManager.IsGrid(uid) && !_mapManager.IsMap(uid));
+            DebugTools.Assert(!_gridQuery.HasComp(uid) && !_mapQuery.HasComp(uid));
 
             // Not parented to grid so convert their pos back to the grid.
             var worldPos = GetWorldPosition(xform, XformQuery);
@@ -174,7 +174,7 @@ namespace Robust.Shared.GameObjects
             if (mapId == parentUid)
                 return coordinates;
 
-            DebugTools.Assert(!_mapManager.IsGrid(parentUid) && !_mapManager.IsMap(parentUid));
+            DebugTools.Assert(!HasComp<MapGridComponent>(parentUid) && !HasComp<MapComponent>(parentUid));
 
             // Not parented to grid so convert their pos back to the grid.
             var worldPos = Vector2.Transform(coordinates.Position, GetWorldMatrix(parentXform, XformQuery));

Robust.Shared/GameObjects/Systems/SharedUserInterfaceSystem.cs

@@ -121,9 +121,14 @@ public abstract class SharedUserInterfaceSystem : EntitySystem
         if (msg.Message is not CloseBoundInterfaceMessage && ui.RequireInputValidation)
         {
             var attempt = new BoundUserInterfaceMessageAttempt(sender, uid, msg.UiKey, msg.Message);
+
             RaiseLocalEvent(attempt);
             if (attempt.Cancelled)
                 return;
+
+            RaiseLocalEvent(uid, attempt);
+            if (attempt.Cancelled)
+                return;
         }
 
         // get the wrapped message and populate it with the sender & UI key information.

Robust.Shared/Map/Commands/AmbientLightCommand.cs

@@ -11,7 +11,6 @@ namespace Robust.Shared.Map.Commands;
 /// </summary>
 public sealed class AmbientLightCommand : IConsoleCommand
 {
-    [Dependency] private readonly IMapManager _mapManager = default!;
     [Dependency] private readonly IEntitySystemManager _systems = default!;
 
     public string Command => $"setambientlight";
@@ -32,10 +31,11 @@ public sealed class AmbientLightCommand : IConsoleCommand
         }
 
         var mapId = new MapId(mapInt);
+        var mapSystem = _systems.GetEntitySystem<SharedMapSystem>();
 
-        if (!_mapManager.MapExists(mapId))
+        if (!mapSystem.MapExists(mapId))
         {
-            shell.WriteError(Loc.GetString("cmd-parse-failure-mapid"));
+            shell.WriteError(Loc.GetString("cmd-parse-failure-mapid", ("arg", mapId.Value)));
             return;
         }
 
@@ -49,7 +49,6 @@ public sealed class AmbientLightCommand : IConsoleCommand
         }
 
         var color = Color.FromSrgb(new Color(r, g, b, a));
-        var mapSystem = _systems.GetEntitySystem<SharedMapSystem>();
         mapSystem.SetAmbientLight(mapId, color);
     }
 }

Robust.Shared/Physics/FixtureSerializer.cs

@@ -29,11 +29,9 @@ public sealed class FixtureSerializer : ITypeSerializer<Dictionary<string, Fixtu
 
         foreach (var subNode in node)
         {
-            var key = (ValueDataNode)subNode.Key;
-
-            if (!keys.Add(key.Value))
+            if (!keys.Add(subNode.Key))
             {
-                seq.Add(new ErrorNode(subNode.Key, $"Found duplicate fixture ID {key.Value}"));
+                seq.Add(new ErrorNode(new ValueDataNode(subNode.Key), $"Found duplicate fixture ID {subNode.Key}"));
                 continue;
             }
 
@@ -50,10 +48,8 @@ public sealed class FixtureSerializer : ITypeSerializer<Dictionary<string, Fixtu
 
         foreach (var subNode in node)
         {
-            var key = (ValueDataNode)subNode.Key;
-
             var fixture = serializationManager.Read<Fixture>(subNode.Value, hookCtx, context, notNullableOverride: true);
-            value.Add(key.Value, fixture);
+            value.Add(subNode.Key, fixture);
         }
 
         return value;

Robust.Shared/Physics/Systems/FixtureSystem.Shapes.cs

@@ -13,7 +13,7 @@ namespace Robust.Shared.Physics.Systems
         /// <summary>
         /// Tests whether a particular point is contained in the shape.
         /// </summary>
-        public bool TestPoint(IPhysShape shape, Transform xform, Vector2 worldPoint)
+        public bool TestPoint<T>(T shape, Transform xform, Vector2 worldPoint) where T : IPhysShape
         {
             switch (shape)
             {

Robust.Shared/Physics/Systems/FixtureSystem.cs

@@ -22,6 +22,7 @@ namespace Robust.Shared.Physics.Systems
     public sealed partial class FixtureSystem : EntitySystem
     {
         [Dependency] private readonly EntityLookupSystem _lookup = default!;
+        [Dependency] private readonly SharedBroadphaseSystem _broadphase = default!;
         [Dependency] private readonly SharedPhysicsSystem _physics = default!;
         [Dependency] private readonly IGameTiming _timing = default!;
         private EntityQuery<PhysicsMapComponent> _mapQuery;
@@ -239,25 +240,31 @@ namespace Robust.Shared.Physics.Systems
 
         private void OnGetState(EntityUid uid, FixturesComponent component, ref ComponentGetState args)
         {
-            args.State = new FixtureManagerComponentState
+            var copied = new Dictionary<string, Fixture>(component.Fixtures.Count);
+
+            foreach (var (id, fixture) in component.Fixtures)
             {
-                Fixtures = component.Fixtures,
+                var copy = new Fixture();
+                fixture.CopyTo(copy);
+                copied[id] = copy;
+            }
+
+            args.State = new FixtureManagerComponentState()
+            {
+                Fixtures = copied,
             };
         }
 
         private void OnHandleState(EntityUid uid, FixturesComponent component, ref ComponentHandleState args)
         {
-            if (args.Current is not FixtureManagerComponentState state) return;
+            if (args.Current is not FixtureManagerComponentState state)
+                return;
 
             if (!EntityManager.TryGetComponent(uid, out PhysicsComponent? physics))
             {
                 Log.Error($"Tried to apply fixture state for an entity without physics: {ToPrettyString(uid)}");
                 return;
             }
-            foreach (var fixture in component.Fixtures.Values)
-            {
-                fixture.Owner = uid;
-            }
 
             var toAddFixtures = new ValueList<(string Id, Fixture Fixture)>();
             var toRemoveFixtures = new ValueList<(string Id, Fixture Fixture)>();
@@ -275,6 +282,7 @@ namespace Robust.Shared.Physics.Systems
             }
 
             TransformComponent? xform = null;
+            var regenerate = false;
 
             // Add / update new fixtures
             // FUTURE SLOTH
@@ -287,10 +295,12 @@ namespace Robust.Shared.Physics.Systems
                 {
                     toAddFixtures.Add((id, fixture));
                 }
+                // Retained fixture but new data
                 else if (!existing.Equivalent(fixture))
                 {
-                    toRemoveFixtures.Add((id, existing));
-                    toAddFixtures.Add((id, fixture));
+                    fixture.CopyTo(existing);
+                    computeProperties = true;
+                    regenerate = true;
                 }
             }
 
@@ -324,6 +334,11 @@ namespace Robust.Shared.Physics.Systems
             {
                 FixtureUpdate(uid, manager: component, body: physics);
             }
+
+            if (regenerate)
+            {
+                _broadphase.RegenerateContacts((uid, physics, component, xform));
+            }
         }
 
         #region Restitution

Robust.Shared/Physics/Systems/SharedJointSystem.cs

@@ -19,11 +19,11 @@ public abstract partial class SharedJointSystem : EntitySystem
     [Dependency] private readonly SharedContainerSystem _container = default!;
     [Dependency] private readonly SharedPhysicsSystem _physics = default!;
     [Dependency] private readonly IGameTiming _gameTiming = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
 
     private EntityQuery<JointComponent> _jointsQuery;
     private EntityQuery<PhysicsComponent> _physicsQuery;
     private EntityQuery<JointRelayTargetComponent> _relayQuery;
-    private EntityQuery<TransformComponent> _xformQuery;
 
     // To avoid issues with component states we'll queue up all dirty joints and check it every tick to see if
     // we can delete the component.
@@ -37,7 +37,6 @@ public abstract partial class SharedJointSystem : EntitySystem
 
         _jointsQuery = GetEntityQuery<JointComponent>();
         _relayQuery = GetEntityQuery<JointRelayTargetComponent>();
-        _xformQuery = GetEntityQuery<TransformComponent>();
         _physicsQuery = GetEntityQuery<PhysicsComponent>();
         UpdatesOutsidePrediction = true;
 
@@ -237,7 +236,7 @@ public abstract partial class SharedJointSystem : EntitySystem
         string? id = null,
         TransformComponent? xformA = null,
         TransformComponent? xformB = null,
-        int? minimumDistance = null)
+        float? minimumDistance = null)
     {
         if (!Resolve(bodyA, ref xformA) || !Resolve(bodyB, ref xformB))
         {
@@ -247,8 +246,8 @@ public abstract partial class SharedJointSystem : EntitySystem
         anchorA ??= Vector2.Zero;
         anchorB ??= Vector2.Zero;
 
-        var vecA = Vector2.Transform(anchorA.Value, xformA.WorldMatrix);
-        var vecB = Vector2.Transform(anchorB.Value, xformB.WorldMatrix);
+        var vecA = Vector2.Transform(anchorA.Value, _transform.GetWorldMatrix(xformA));
+        var vecB = Vector2.Transform(anchorB.Value, _transform.GetWorldMatrix(xformB));
         var length = (vecA - vecB).Length();
         if (minimumDistance != null)
             length = Math.Max(minimumDistance.Value, length);
@@ -347,7 +346,7 @@ public abstract partial class SharedJointSystem : EntitySystem
         if (!Resolve(uid, ref xform))
             return Vector2.Zero;
 
-        return Physics.Transform.MulT(new Quaternion2D((float) xform.WorldRotation.Theta), worldVector);
+        return Physics.Transform.MulT(new Quaternion2D((float) _transform.GetWorldRotation(xform).Theta), worldVector);
     }
 
     #endregion

Robust.Shared/Physics/Systems/SharedPhysicsSystem.Components.cs

@@ -30,6 +30,7 @@ using Robust.Shared.Collections;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
 using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Dynamics;
@@ -535,7 +536,7 @@ public partial class SharedPhysicsSystem
             DirtyFields(uid, body, null, nameof(PhysicsComponent.Force), nameof(PhysicsComponent.Torque));
         }
 
-        _broadphase.RegenerateContacts(uid, body, manager, xform);
+        _broadphase.RegenerateContacts((uid, body, manager, xform));
 
         if (body.Initialized)
         {
@@ -581,13 +582,13 @@ public partial class SharedPhysicsSystem
                 if (_containerSystem.IsEntityOrParentInContainer(uid))
                     return false;
 
-                if (!_fixturesQuery.Resolve(uid, ref manager) || manager.FixtureCount == 0 && !_mapManager.IsGrid(uid))
+                if (!_fixturesQuery.Resolve(uid, ref manager) || manager.FixtureCount == 0 && !_gridQuery.HasComp(uid))
                     return false;
             }
             else
             {
                 DebugTools.Assert(!_containerSystem.IsEntityOrParentInContainer(uid));
-                DebugTools.Assert((Resolve(uid, ref manager) && manager.FixtureCount > 0) || _mapManager.IsGrid(uid));
+                DebugTools.Assert((Resolve(uid, ref manager) && manager.FixtureCount > 0) || _gridQuery.HasComp(uid));
             }
         }
 

Robust.Shared/Physics/Systems/SharedPhysicsSystem.Contacts.cs

@@ -30,12 +30,12 @@
 using System;
 using System.Buffers;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Numerics;
 using JetBrains.Annotations;
 using Microsoft.Extensions.ObjectPool;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics.Collision;
 using Robust.Shared.Physics.Collision.Shapes;
@@ -424,6 +424,12 @@ public abstract partial class SharedPhysicsSystem
             var xformA = _xformQuery.GetComponent(uidA);
             var xformB = _xformQuery.GetComponent(uidB);
 
+            if (xformA.MapID == MapId.Nullspace || xformB.MapID == MapId.Nullspace)
+            {
+                DestroyContact(contact);
+                continue;
+            }
+
             // Is this contact flagged for filtering?
             if ((contact.Flags & ContactFlags.Filter) != 0x0)
             {
@@ -661,8 +667,8 @@ public abstract partial class SharedPhysicsSystem
             var aUid = contact.EntityA;
             var bUid = contact.EntityB;
 
-            SetAwake(aUid, bodyA, true);
-            SetAwake(bUid, bodyB, true);
+            SetAwake((aUid, bodyA), true);
+            SetAwake((bUid, bodyB), true);
         }
 
         ArrayPool<bool>.Shared.Return(wake);
@@ -788,7 +794,7 @@ public abstract partial class SharedPhysicsSystem
         if (!PhysicsQuery.Resolve(entity.Owner, ref entity.Comp))
             return;
 
-        _broadphase.RegenerateContacts(entity.Owner, entity.Comp);
+        _broadphase.RegenerateContacts(entity);
     }
 
     /// <summary>

Robust.Shared/Physics/Systems/SharedPhysicsSystem.Island.cs

@@ -1045,7 +1045,10 @@ public abstract partial class SharedPhysicsSystem
             // May reparent object and change body's velocity.
             if (!float.IsNaN(position.X) && !float.IsNaN(position.Y))
             {
-                _transform.SetLocalPositionRotation(xform, xform.LocalPosition + position, xform.LocalRotation + angle);
+                _transform.SetLocalPositionRotation(uid,
+                    xform.LocalPosition + position,
+                    xform.LocalRotation + angle,
+                    xform);
             }
 
             if (physicsDirtied)

Robust.Shared/Physics/Systems/SharedPhysicsSystem.Queries.cs

@@ -137,6 +137,7 @@ namespace Robust.Shared.Physics.Systems
         /// <summary>
         /// Get all entities colliding with a certain body.
         /// </summary>
+        [Obsolete("Use EntityLookupSystem")]
         public IEnumerable<PhysicsComponent> GetCollidingEntities(MapId mapId, in Box2 worldAABB)
         {
             if (mapId == MapId.Nullspace) return Array.Empty<PhysicsComponent>();
@@ -169,6 +170,7 @@ namespace Robust.Shared.Physics.Systems
         /// <summary>
         /// Get all entities colliding with a certain body.
         /// </summary>
+        [Obsolete("Use EntityLookupSystem")]
         public IEnumerable<Entity<PhysicsComponent>> GetCollidingEntities(MapId mapId, in Box2Rotated worldBounds)
         {
             if (mapId == MapId.Nullspace)

Robust.Shared/Physics/Systems/SharedPhysicsSystem.Velocities.cs

@@ -45,7 +45,7 @@ public abstract partial class SharedPhysicsSystem
         if (!coordinates.IsValid(EntityManager))
             return Vector2.Zero;
 
-        var mapUid = coordinates.GetMapUid(EntityManager);
+        var mapUid = _transform.GetMap(coordinates);
         var parent = coordinates.EntityId;
         var localPos = coordinates.Position;
 

Robust.Shared/Physics/Systems/SharedPhysicsSystem.cs

@@ -43,7 +43,6 @@ namespace Robust.Shared.Physics.Systems
             });
 
         [Dependency] private readonly IManifoldManager _manifoldManager = default!;
-        [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IParallelManager _parallel = default!;
         [Dependency] private readonly IConfigurationManager _cfg = default!;
         [Dependency] private readonly IDependencyCollection _deps = default!;
@@ -66,11 +65,12 @@ namespace Robust.Shared.Physics.Systems
 
         public bool MetricsEnabled { get; protected set; }
 
-        private EntityQuery<FixturesComponent> _fixturesQuery;
+        private   EntityQuery<FixturesComponent> _fixturesQuery;
         protected EntityQuery<PhysicsComponent> PhysicsQuery;
-        private EntityQuery<TransformComponent> _xformQuery;
-        private EntityQuery<CollideOnAnchorComponent> _anchorQuery;
+        private   EntityQuery<TransformComponent> _xformQuery;
+        private   EntityQuery<CollideOnAnchorComponent> _anchorQuery;
         protected EntityQuery<PhysicsMapComponent> PhysMapQuery;
+        private   EntityQuery<MapGridComponent> _gridQuery;
         protected EntityQuery<MapComponent> MapQuery;
 
         private ComponentRegistration _physicsReg = default!;
@@ -111,6 +111,7 @@ namespace Robust.Shared.Physics.Systems
             _xformQuery = GetEntityQuery<TransformComponent>();
             _anchorQuery = GetEntityQuery<CollideOnAnchorComponent>();
             PhysMapQuery = GetEntityQuery<PhysicsMapComponent>();
+            _gridQuery = GetEntityQuery<MapGridComponent>();
             MapQuery = GetEntityQuery<MapComponent>();
 
             SubscribeLocalEvent<GridAddEvent>(OnGridAdd);

Robust.Shared/Prototypes/PrototypeManager.YamlLoad.cs

@@ -342,8 +342,7 @@ public partial class PrototypeManager
         {
             if (abstractNode is not ValueDataNode abstractValueNode)
             {
-                mapping.Remove(abstractNode);
-                mapping.Add("abstract", "true");
+                mapping["abstract"] = new ValueDataNode("true");
                 return;
             }
 

Robust.Shared/Prototypes/PrototypeManager.cs

@@ -408,16 +408,26 @@ namespace Robust.Shared.Prototypes
                             if (nonPushedParent)
                                 continue;
 
-                            var parentMaps = new MappingDataNode[parents.Length];
-                            for (var i = 0; i < parentMaps.Length; i++)
+                            if (parents.Length == 1)
                             {
-                                parentMaps[i] = kindData.Results[parents[i]];
+                                kindData.Results[id] = _serializationManager.PushCompositionWithGenericNode(
+                                    kind,
+                                    kindData.Results[parents[0]],
+                                    kindData.RawResults[id]);
                             }
+                            else
+                            {
+                                var parentMaps = new MappingDataNode[parents.Length];
+                                for (var i = 0; i < parentMaps.Length; i++)
+                                {
+                                    parentMaps[i] = kindData.Results[parents[i]];
+                                }
 
-                            kindData.Results[id] = _serializationManager.PushCompositionWithGenericNode(
-                                kind,
-                                parentMaps,
-                                kindData.RawResults[id]);
+                                kindData.Results[id] = _serializationManager.PushCompositionWithGenericNode(
+                                    kind,
+                                    parentMaps,
+                                    kindData.RawResults[id]);
+                            }
                         }
                         else
                         {
@@ -629,16 +639,26 @@ namespace Robust.Shared.Prototypes
                 {
                     if (tree.TryGetParents(id, out var parents))
                     {
-                        var parentNodes = new MappingDataNode[parents.Length];
-                        for (var i = 0; i < parents.Length; i++)
+                        if (parents.Length == 1)
                         {
-                            parentNodes[i] = results[parents[i]].Result;
+                            datum.Result = _serializationManager.PushCompositionWithGenericNode(
+                                kind,
+                                results[parents[0]].Result,
+                                datum.Result);
                         }
+                        else
+                        {
+                            var parentNodes = new MappingDataNode[parents.Length];
+                            for (var i = 0; i < parents.Length; i++)
+                            {
+                                parentNodes[i] = results[parents[i]].Result;
+                            }
 
-                        datum.Result = _serializationManager.PushCompositionWithGenericNode(
-                            kind,
-                            parentNodes,
-                            datum.Result);
+                            datum.Result = _serializationManager.PushCompositionWithGenericNode(
+                                kind,
+                                parentNodes,
+                                datum.Result);
+                        }
                     }
 
                     if (tree.TryGetChildren(id, out var children))

Robust.Shared/Replays/ReplayData.cs

@@ -112,7 +112,7 @@ public sealed class ReplayData
         ClientSideRecording = clientSideRecording;
         YamlData = yamlData;
 
-        if (YamlData.TryGet(new ValueDataNode(ReplayConstants.MetaKeyRecordedBy), out ValueDataNode? node)
+        if (YamlData.TryGet(ReplayConstants.MetaKeyRecordedBy, out ValueDataNode? node)
             && Guid.TryParse(node.Value, out var guid))
         {
             Recorder = new NetUserId(guid);

Robust.Shared/Serialization/Manager/Definition/DataDefinition.cs

@@ -266,27 +266,21 @@ namespace Robust.Shared.Serialization.Manager.Definition
 
             foreach (var (key, val) in mapping.Children)
             {
-                if (key is not ValueDataNode valueDataNode)
+                if (!TryGetIndex(key, out var idx))
                 {
-                    validatedMapping.Add(new ErrorNode(key, "Key not ValueDataNode."), new InconclusiveNode(val));
-                    continue;
-                }
-
-                if (!TryGetIndex(valueDataNode.Value, out var idx))
-                {
-                    if (TryGetIncludeMappingPair(includeValidations, valueDataNode.Value, out var validatedNotFoundPair))
+                    if (TryGetIncludeMappingPair(includeValidations, key, out var validatedNotFoundPair))
                     {
                         validatedMapping.Add(validatedNotFoundPair.Key, validatedNotFoundPair.Value);
                         continue;
                     }
 
-                    var error = new FieldNotFoundErrorNode(valueDataNode, typeof(T));
+                    var error = new FieldNotFoundErrorNode(mapping.GetKeyNode(key), typeof(T));
 
                     validatedMapping.Add(error, new InconclusiveNode(val));
                     continue;
                 }
 
-                var keyValidated = serialization.ValidateNode<string>(key, context);
+                var keyValidated = serialization.ValidateNode<string>(mapping.GetKeyNode(key), context);
 
                 ValidationNode valNode;
                 if (IsNull(val))
@@ -295,7 +289,7 @@ namespace Robust.Shared.Serialization.Manager.Definition
                     {
                         var error = new ErrorNode(
                             val,
-                            $"Field \"{valueDataNode.Value}\" had null value despite not being annotated as nullable.");
+                            $"Field \"{key}\" had null value despite not being annotated as nullable.");
 
                         validatedMapping.Add(keyValidated, error);
                         continue;
@@ -309,7 +303,7 @@ namespace Robust.Shared.Serialization.Manager.Definition
                 }
 
                 //include node errors override successful nodes on the main datadef
-                if (valNode is not ErrorNode && TryGetIncludeMappingPair(includeValidations, valueDataNode.Value, out var validatedPair))
+                if (valNode is not ErrorNode && TryGetIncludeMappingPair(includeValidations, key, out var validatedPair))
                 {
                     if (validatedPair.Value is ErrorNode)
                     {

Robust.Shared/Serialization/Manager/ISerializationManager.cs

@@ -421,6 +421,7 @@ namespace Robust.Shared.Serialization.Manager
         #region Composition
 
         DataNode PushComposition(Type type, DataNode[] parents, DataNode child, ISerializationContext? context = null);
+        DataNode PushComposition(Type type, DataNode parent, DataNode child, ISerializationContext? context = null);
 
         public TNode PushComposition<TType, TNode>(TNode[] parents, TNode child, ISerializationContext? context = null) where TNode : DataNode
         {
@@ -428,6 +429,12 @@ namespace Robust.Shared.Serialization.Manager
             return (TNode)PushComposition(typeof(TType), parents, child, context);
         }
 
+        public TNode PushComposition<TType, TNode>(TNode parent, TNode child, ISerializationContext? context = null)
+            where TNode : DataNode
+        {
+            return (TNode) PushComposition(typeof(TType), parent, child, context);
+        }
+
         TNode PushInheritance<TType, TNode>(ITypeInheritanceHandler<TType, TNode> inheritanceHandler, TNode parent, TNode child,
             ISerializationContext? context = null) where TNode : DataNode;
 
@@ -441,6 +448,12 @@ namespace Robust.Shared.Serialization.Manager
             return (TNode) PushComposition(type, parents, child, context);
         }
 
+        public TNode PushCompositionWithGenericNode<TNode>(Type type, TNode parent, TNode child, ISerializationContext? context = null)
+            where TNode : DataNode
+        {
+            return (TNode) PushComposition(type, parent, child, context);
+        }
+
         /// <summary>
         /// Simple <see cref="MappingDataNode"/> inheritance pusher clones data and overrides a parent's values with
         /// the child's.

Robust.Shared/Serialization/Manager/SerializationManager.Composition.cs

@@ -24,27 +24,23 @@ public partial class SerializationManager
 
     private readonly ConcurrentDictionary<(Type value, Type node), PushCompositionDelegate> _compositionPushers = new();
 
-    public DataNode PushComposition(Type type, DataNode[] parents, DataNode child, ISerializationContext? context = null)
+    public DataNode PushComposition(
+        Type type,
+        DataNode[] parents,
+        DataNode child,
+        ISerializationContext? context = null)
     {
-        // TODO SERIALIZATION
-        // Add variant that doesn't require a parent array.
-
         // TODO SERIALIZATION
         // Change inheritance pushing so that it modifies the passed in child. This avoids re-creating the child
-        // multiple times when there are multiple children.
+        // multiple times when there are multiple parents.
         //
         // I.e., change the PushCompositionDelegate signature to not have a return value, and also add an override
-        // of this method that modified the given child.
+        // of this method that modifies the given child.
 
         if (parents.Length == 0)
             return child.Copy();
 
         DebugTools.Assert(parents.All(x => x.GetType() == child.GetType()));
-
-
-        // the child.Clone() statement to the beginning here, then make the delegate modify the clone.
-        // Currently pusing more than one parent requires multiple unnecessary clones.
-
         var pusher = GetOrCreatePushCompositionDelegate(type, child);
 
         var node = child;
@@ -61,6 +57,22 @@ public partial class SerializationManager
         return node;
     }
 
+    public DataNode PushComposition(
+        Type type,
+        DataNode parent,
+        DataNode child,
+        ISerializationContext? context = null)
+    {
+        DebugTools.AssertEqual(parent.GetType(), child.GetType());
+        var pusher = GetOrCreatePushCompositionDelegate(type, child);
+
+        var newNode = pusher(type, parent, child, context);
+
+        // Currently delegate pusher should be returning a new instance, and not modifying the passed in child.
+        DebugTools.Assert(!ReferenceEquals(newNode, child));
+        return newNode;
+    }
+
     private PushCompositionDelegate GetOrCreatePushCompositionDelegate(Type type, DataNode node)
     {
         return _compositionPushers.GetOrAdd((type, node.GetType()), static (tuple, vfArgument) =>
@@ -178,14 +190,15 @@ public partial class SerializationManager
             {
                 // tag is set on data definition creation
                 if(!processedTags.Add(dfa.Tag!)) continue; //tag was already processed, probably because we are using the same tag in an include
-                var key = new ValueDataNode(dfa.Tag);
+
+                var key = dfa.Tag!;
                 if (parent.TryGetValue(key, out var parentValue))
                 {
                     if (newMapping.TryGetValue(key, out var childValue))
                     {
                         if (field.InheritanceBehavior == InheritanceBehavior.Always)
                         {
-                            newMapping[key] = PushComposition(field.FieldType, new[] { parentValue }, childValue, context);
+                            newMapping[key] = PushComposition(field.FieldType, parentValue, childValue, context);
                         }
                     }
                     else