Version: 237.2.5

Apparently NetSerializer treats IDynamicTypeSerializer and IStaticTypeSerializer differently for sealed types??

(cherry-picked from 6bbeaeeba6, without the test changes)

(cherry picked from commit d187018834dfa1cdead9ce5a7b72c38b07f8c81f)

Directory.Packages.props

@@ -58,7 +58,7 @@
     <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
     <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.5" />
     <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
-    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
+    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.2.2" />
     <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
     <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
     <PackageVersion Include="System.Numerics.Vectors" Version="4.5.0" />

MSBuild/Robust.Engine.Version.props

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

RELEASE-NOTES.md

@@ -54,6 +54,272 @@ END TEMPLATE-->
 *None yet*
 
 
+## 237.2.5
+
+
+## 237.2.4
+
+
+## 237.2.3
+
+
+## 237.2.2
+
+
+## 237.2.1
+
+
+## 237.2.0
+
+### Breaking changes
+
+* `SharedEyeSystem..SetTarget()` will now also automatically remove the old target from the session's ViewSubscriptions
+
+### New features
+
+* `ImmutableArray<T>` can now be serialized by `RobustSerializer`.
+* `RequiresLocationAttribute`, used by `ref readonly`, is now allowed by the sandbox.
+* Added `DAT-OBJ()` localization function, for the dative case in certain languages.
+* Client builds for FreeBSD are now made.
+* Added `FormattedMessage.TrimEnd()`.
+* Added Toolshed `with` for `ProtoId<T>`.
+
+### Bugfixes
+
+* Fix `UniqueIndex<,>.RemoveRange()` and`UniqueIndexHkm<,>.RemoveRange()` clearing the whole set instead of just removing the specified values.
+* Avoid server crashes on some weird console setups (notably Pterodactyl).
+* Avoid unhandled exceptions during server shutdown getting swallowed due logging into a disposed logger.
+* Fix sandbox definitions for `Regex` functions returning `MatchCollection`.
+* Fix minor layout bugs with `SplitContainer` and `BoxContainer`.
+
+### Other
+
+* Changed how multi-window rendering presents to the screen with a new CVar `display.thread_unlock_before_swap`. This is an experiment to see if it solves some synchronization issues.
+* View Variables no longer clears the window on refresh while waiting on response from server.
+* `SpinBox` buttons now have a `+` prefix for the positive ones.
+* Improve Toolshed type intersection mechanism
+
+### Internal
+
+* Warning cleanup.
+
+## 237.1.0
+
+### New features
+
+* csi's auto import-system can now handle generic types.
+* csi's reflection helpers (like `fld()`) handle private members up the inheritance chain.
+
+### Bugfixes
+
+* Fix `UniqueIndexHkm<,>` and, by extension, entity data storage memory leaking.
+* Fix bugs related to UIScale on `OSWindow`s.
+
+
+## 237.0.0
+
+### Breaking changes
+
+* `IClydeWindow.Size` is now settable, allowing window sizes to be changed after creation.
+
+### New features
+
+* The game server's `/update` endpoint now supports passing more information on why an update is available.
+  * This information is accessible via `IWatchdogApi.RestartRequested`.
+  * Information can be specified by passing a JSON object with a `Reason` code and `Message` field.
+* Added an "Erase" button to the tile spawn menu.
+* Added `OSWindow.Create()`, which allows OS windows to be created & initialised without immediately opening/showing them.
+
+### Other
+
+* Made `WatchdogApi` and some members of `IWatchdogApi` private. These symbols should never have been accessed by content.
+
+
+## 236.1.0
+
+### New features
+
+* `RequiredMemberAttribute` and `SetsRequiredMembersAttribute` have been added to the sandbox whitelist. I.e., you can now use the `required` keyword in client/shared code.
+* Added `SwitchExpressionException` to sandbox. This type gets used if you have a `switch` expression with no default case.
+* Added `LineEdit.SelectAllOnFocus`.
+* `GameTitle`, `WindowIconSet` and `SplashLogo` are exposed in `IGameController`. These will return said information set in game options or whatever is set in `manifest.yml`.
+* `BoundUserInterface` inheritors now have access to `PlayerManager`.
+* Added `MuteSounds` bool to `BaseButton`.
+* The engine has a new future-proof HWID system.
+  * The auth server now manages HWIDs. This avoids HWID impersonation attacks.
+  * The auth server can return multiple HWIDs. They are accessible in `NetUserData.ModernHWIds`.
+  * The auth server also returns a trust score factor, accessible as `NetUserData.Trust`.
+  * HWID can be disabled client side (`ROBUST_AUTH_ALLOW_HWID` env var) or server side (`net.hwid` cvar).
+  * The old HWID system is still in place. It is intended that content switches to placing new bans against the new HWIDs.
+  * Old HWIDs no longer work if the connection is not authenticated.
+* `launchauth` command now recognizes `SS14_LAUNCHER_APPDATA_NAME`.
+* Added new overload to `EntityLookupSystem.GetEntitiesIntersecting`.
+* Added `Control.RemoveChild(int childIndex)`.
+* `build.entities_category_filter` allows filtering the entity spawn panel to a specific category.
+
+### Bugfixes
+
+* Fixed `SpriteView` offset calculations when scaled.
+
+### Other
+
+* Sprite flicks are applied immediately when started.
+* More warning fixes.
+* If the server gets shut down before finishing startup, the reason is now logged properly.
+
+
+## 236.0.0
+
+### Breaking changes
+
+* Revert IsTouching only being set to true if the contact were laready touching in clientside physics prediction.
+* Don't touch IsTouching if both bodies are asleep for clientside physics contacts. This change and the one above should fix a lot of clientside contact issues, particularly around repeated incorrect clientside contact events.
+
+### New features
+
+* Added an analyzer to detect duplicate Dependency fields.
+
+### Bugfixes
+
+* Auto-networked dictionaries now use `TryAdd()` to avoid duplicate key errors when a dictionary contains multiple unknown networked entities.
+* Fixed `ICommonSession.Ping` always returning zero instead of the ping. Note that this will still return zero for client-side code when trying to get the ping of other players.
+* Hot reload XAML files on rename to fix them potentially not being reloaded with Visual Studio.
+* Fix TabContainer click detection for non-1.0 UI scales.
+
+### Other
+
+* Obsolete some static localization methods.
+* Tried to improve PVS tolerance to exceptions occurring.
+
+
+## 235.0.0
+
+### Breaking changes
+
+* Several different `AudioSystem` methods were incorrectly given a `[return: NotNullIfNotNull]` attribute. Content code that uses these methods needs to be updated to perform null checks.
+* noSpawn is no longer obsolete and is now removed in lieu of the EntityCategory HideSpawnMenu.
+
+### Bugfixes
+
+* physics.maxlinvelocity is now a replicated cvar.
+* Fix DistanceJoint debug drawing in physics not using the local anchors.
+* Fixed filtered AudioSystem methods playing a sound for all players when given an empty filter.
+* Fixed equality checks for `MarkupNode` not properly handling attributes.
+* Fixed `MarkupNode` not having a `GetHashCode()` implementation.
+* Fixed a PVS error that could occur when trying to delete the first entity that gets created in a round.
+* Fixed the "to" and "take" toolshed commands not working as intended.
+* Rich text controls within an `OutputPanel` control will now become invisible when they are out of view.
+
+### Other
+
+* Improve precision for Quaternion2D constructor from angles.
+
+
+## 234.1.0
+
+### New features
+
+* SharedAudioSystem now has PlayLocal which only runs audio locally on the client.
+
+### Bugfixes
+
+* Fix AudioParams not being passed through on PlayGlobal methods.
+
+
+## 234.0.0
+
+### Breaking changes
+
+* Remove a lot of obsoleted code that has been obsoleted for a while.
+
+### New features
+
+* Add another GetLocalEntitiesIntersecting override.
+
+### Other
+
+* Mark large replays as requiring Server GC.
+* Obsolete some IResourceCache proxies.
+
+
+## 233.1.0
+
+### New features
+
+* Add GetGridEntities and another GetEntitiesIntersecting overload to EntityLookupSystem.
+* `MarkupNode` is now `IEquatable<MarkupNode>`. It already supported equality checks, now it implements the interface.
+* Added `Entity<T>` overloads to the following `SharedMapSystem` methods: `GetTileRef`, `GetAnchoredEntities`, `TileIndicesFor`.
+* Added `EntityUid`-only overloads to the following `SharedTransformSystem` methods: `AnchorEntity`, `Unanchor`.
+
+### Bugfixes
+
+* Fixed equality checks for `MarkupNode` not properly handling attributes.
+* Fixed toolshed commands failing to generate error messages when working with array types
+* Fixed `MarkupNode` not having a `GetHashCode()` implementation.
+
+### Other
+
+* If `EntityManager.FlushEntities()` fails to delete all entities, it will now attempt to do so a second time before throwing an exception.
+
+
+## 233.0.2
+
+### Bugfixes
+
+* Fix exceptions in client game state handling for grids. Now they will rely upon the networked fixture data and not try to rebuild in the grid state handler.
+
+
+## 233.0.1
+
+### Bugfixes
+
+* Fix IsHardCollidable component to EntityUid references.
+
+
+## 233.0.0
+
+### Breaking changes
+
+* Made EntityRenamed a broadcast event & added additional args.
+* Made test runs parallelizable.
+* Added a debug assert that other threads aren't touching entities.
+
+### Bugfixes
+
+* Fix some entitylookup method transformations and add more tests.
+* Fix mousehover not updating if new controls showed up under the mouse.
+
+### Internal
+
+* `ClientGameStateManager` now only initialises or starts entities after their parents have already been initialized. There are also some new debug asserts to try ensure that this rule isn't broken elsewhere.
+* Engine version script now supports dashes.
+
+
+## 232.0.0
+
+### Breaking changes
+
+* Obsolete method `AppearanceComponent.TryGetData` is now access-restricted to `SharedAppearanceSystem`; use `SharedAppearanceSystem.TryGetData` instead.
+
+### New features
+
+* Added `SharedAppearanceSystem.AppendData`, which appends non-existing `AppearanceData` from one `AppearanceComponent` to another.
+* Added `AppearanceComponent.AppearanceDataInit`, which can be used to set initial `AppearanceData` entries in .yaml.
+
+### Bugfixes
+
+* Fix BUI interfaces not deep-copying in state handling.
+* Add Robust.Xaml.csproj to the solution to fix some XAML issues.
+
+### Other
+
+* Serialization will now add type tags (`!type:<T>`) for necessary `NodeData` when writing (currently only for `object` nodes).
+
+### Internal
+
+* Added `ObjectSerializer`, which handles serialization of the generic `object` type.
+
+
 ## 231.1.1
 
 ### Bugfixes

Resources/EnginePrototypes/entityCategory.yml

@@ -18,3 +18,9 @@
   description: entity-category-desc-hide
   hideSpawnMenu: true
   inheritable: false
+
+# Entity prototypes added by the fork. With CVar you can hide all entities without this category
+- type: entityCategory
+  id: ForkFiltered
+  name: entity-category-name-fork
+  description: entity-category-desc-fork

Resources/Locale/en-US/_engine_lib.ftl

@@ -20,6 +20,15 @@ zzzz-object-pronoun = { GENDER($ent) ->
    *[neuter] it
    }
 
+# Used internally by the DAT-OBJ() function.
+# Not used in en-US. Created for supporting other languages.
+zzzz-dat-object = { GENDER($ent) ->
+    [male] him
+    [female] her
+    [epicene] them
+   *[neuter] it
+   }
+
 # Used internally by the POSS-PRONOUN() function.
 zzzz-possessive-pronoun = { GENDER($ent) ->
     [male] his

Resources/Locale/en-US/custom-controls.ftl

@@ -4,9 +4,16 @@ entity-spawn-window-title = Entity Spawn Panel
 entity-spawn-window-search-bar-placeholder = search
 entity-spawn-window-clear-button = Clear
 entity-spawn-window-replace-button-text = Replace
-entity-spawn-window-erase-button-text = Erase Mode
 entity-spawn-window-override-menu-tooltip = Override placement
 
+## TileSpawnWindow
+
+tile-spawn-window-title = Place Tiles
+
 ## Console
 
 console-line-edit-placeholder = Command Here
+
+## Common Used
+
+window-erase-button-text = Erase Mode

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

@@ -7,3 +7,6 @@ entity-category-desc-spawner = Entity prototypes that spawn other entities.
 
 entity-category-name-hide = Hidden
 entity-category-desc-hide = Entity prototypes that should be hidden from entity spawn menus
+
+entity-category-name-fork = Fork Filtered
+entity-category-desc-fork = Entity prototypes added by the fork. With CVar you can hide all entities without this category

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

@@ -219,9 +219,9 @@ command-description-MulVecCommand =
 command-description-DivVecCommand =
     Divides every element in the input by a scalar (single value).
 command-description-rng-to =
-    Returns a number from its input to its argument (i.e. n..m inclusive)
+    Returns a number between the input (inclusive) and the argument (exclusive).
 command-description-rng-from =
-    Returns a number to its input from its argument (i.e. m..n inclusive)
+    Returns a number between the argument (inclusive) and the input (exclusive))
 command-description-rng-prob =
     Returns a boolean based on the input probability/chance (from 0 to 1)
 command-description-sum =

Robust.Analyzers.Tests/DuplicateDependencyAnalyzerTest.cs

@@ -0,0 +1,63 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using Microsoft.CodeAnalysis.Testing.Verifiers;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.NUnit.AnalyzerVerifier<Robust.Analyzers.DuplicateDependencyAnalyzer>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture]
+[TestOf(typeof(DuplicateDependencyAnalyzer))]
+public sealed class DuplicateDependencyAnalyzerTest
+{
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<DuplicateDependencyAnalyzer, NUnitVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.IoC.DependencyAttribute.cs"
+        );
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task Test()
+    {
+        const string code = """
+            using Robust.Shared.IoC;
+
+            public sealed class Foo
+            {
+                [Dependency]
+                private object? Field;
+
+                [Dependency]
+                private object? Field2;
+
+                [Dependency]
+                private string? DifferentField;
+
+                private string? NonDependency1;
+                private string? NonDependency2;
+            }
+            """;
+
+        await Verifier(code,
+            // /0/Test0.cs(9,21): warning RA0032: Another [Dependency] field of type 'object?' already exists in this type as field 'Field'
+            VerifyCS.Diagnostic().WithSpan(9, 21, 9, 27).WithArguments("object?", "Field"));
+    }
+}

Robust.Analyzers/DuplicateDependencyAnalyzer.cs

@@ -0,0 +1,126 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Roslyn.Shared;
+
+namespace Robust.Analyzers;
+
+#nullable enable
+
+/// <summary>
+/// Analyzer that detects duplicate <c>[Dependency]</c> fields inside a single type.
+/// </summary>
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public sealed class DuplicateDependencyAnalyzer : DiagnosticAnalyzer
+{
+    private const string DependencyAttributeType = "Robust.Shared.IoC.DependencyAttribute";
+
+    private static readonly DiagnosticDescriptor Rule = new(
+        Diagnostics.IdDuplicateDependency,
+        "Duplicate dependency field",
+        "Another [Dependency] field of type '{0}' already exists in this type with field '{1}'",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var dependencyAttributeType = compilationContext.Compilation.GetTypeByMetadataName(DependencyAttributeType);
+            if (dependencyAttributeType == null)
+                return;
+
+            compilationContext.RegisterSymbolStartAction(symbolContext =>
+                {
+                    var typeSymbol = (INamedTypeSymbol)symbolContext.Symbol;
+                    // Only deal with non-static classes, doesn't make sense to have dependencies in anything else.
+                    if (typeSymbol.TypeKind != TypeKind.Class || typeSymbol.IsStatic)
+                        return;
+
+                    var state = new AnalyzerState(dependencyAttributeType);
+                    symbolContext.RegisterSyntaxNodeAction(state.AnalyzeField, SyntaxKind.FieldDeclaration);
+                    symbolContext.RegisterSymbolEndAction(state.End);
+                },
+                SymbolKind.NamedType);
+        });
+    }
+
+    private sealed class AnalyzerState(INamedTypeSymbol dependencyAttributeType)
+    {
+        private readonly Dictionary<ITypeSymbol, List<IFieldSymbol>> _dependencyFields = new(SymbolEqualityComparer.Default);
+
+        public void AnalyzeField(SyntaxNodeAnalysisContext context)
+        {
+            var field = (FieldDeclarationSyntax)context.Node;
+            if (field.AttributeLists.Count == 0)
+                return;
+
+            if (context.ContainingSymbol is not IFieldSymbol fieldSymbol)
+                return;
+
+            // Can't have [Dependency]s for non-reference types.
+            if (!fieldSymbol.Type.IsReferenceType)
+                return;
+
+            if (!IsDependency(context.ContainingSymbol))
+                return;
+
+            lock (_dependencyFields)
+            {
+                if (!_dependencyFields.TryGetValue(fieldSymbol.Type, out var dependencyFields))
+                {
+                    dependencyFields = [];
+                    _dependencyFields.Add(fieldSymbol.Type, dependencyFields);
+                }
+
+                dependencyFields.Add(fieldSymbol);
+            }
+        }
+
+        private bool IsDependency(ISymbol symbol)
+        {
+            foreach (var attributeData in symbol.GetAttributes())
+            {
+                if (SymbolEqualityComparer.Default.Equals(attributeData.AttributeClass, dependencyAttributeType))
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void End(SymbolAnalysisContext context)
+        {
+            lock (_dependencyFields)
+            {
+                foreach (var pair in _dependencyFields)
+                {
+                    var fieldType = pair.Key;
+                    var fields = pair.Value;
+                    if (fields.Count <= 1)
+                        continue;
+
+                    // Sort so we can have deterministic order to skip reporting for a single field.
+                    // Whichever sorts first doesn't get reported.
+                    fields.Sort(static (a, b) => string.Compare(a.Name, b.Name, StringComparison.Ordinal));
+
+                    // Start at index 1 to skip first field.
+                    var firstField = fields[0];
+                    for (var i = 1; i < fields.Count; i++)
+                    {
+                        var field = fields[i];
+
+                        context.ReportDiagnostic(
+                            Diagnostic.Create(Rule, field.Locations[0], fieldType.ToDisplayString(), firstField.Name));
+                    }
+                }
+            }
+        }
+    }
+}

Robust.Benchmarks/Physics/BoxStackBenchmark.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.Configuration;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Collision.Shapes;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Physics.Systems;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.Physics;
+
+[Virtual]
+[MediumRunJob]
+public class PhysicsBoxStackBenchmark
+{
+    private ISimulation _sim = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _sim = RobustServerSimulation.NewSimulation().InitializeInstance();
+
+        var entManager = _sim.Resolve<IEntityManager>();
+        entManager.System<SharedMapSystem>().CreateMap(out var mapId);
+        SetupTumbler(entManager, mapId);
+
+        for (var i = 0; i < 30; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+        }
+    }
+
+    [Benchmark]
+    public void BoxStack()
+    {
+        var entManager = _sim.Resolve<IEntityManager>();
+
+        for (var i = 0; i < 10000; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+        }
+    }
+
+    private void SetupTumbler(IEntityManager entManager, MapId mapId)
+    {
+        var physics = entManager.System<SharedPhysicsSystem>();
+        var fixtures = entManager.System<FixtureSystem>();
+
+        var groundUid = entManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
+        var ground = entManager.AddComponent<PhysicsComponent>(groundUid);
+
+        var horizontal = new EdgeShape(new Vector2(-40, 0), new Vector2(40, 0));
+        fixtures.CreateFixture(groundUid, "fix1", new Fixture(horizontal, 2, 2, true), body: ground);
+
+        var vertical = new EdgeShape(new Vector2(10, 0), new Vector2(10, 10));
+        fixtures.CreateFixture(groundUid, "fix2", new Fixture(vertical, 2, 2, true), body: ground);
+
+        var xs = new[]
+        {
+            0.0f, -10.0f, -5.0f, 5.0f, 10.0f
+        };
+
+        var columnCount = 1;
+        var rowCount = 15;
+        PolygonShape shape;
+
+        for (var j = 0; j < columnCount; j++)
+        {
+            for (var i = 0; i < rowCount; i++)
+            {
+                var x = 0.0f;
+
+                var boxUid = entManager.SpawnEntity(null,
+                    new MapCoordinates(new Vector2(xs[j] + x, 0.55f + 1.1f * i), mapId));
+                var box = entManager.AddComponent<PhysicsComponent>(boxUid);
+
+                physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
+
+                shape = new PolygonShape();
+                shape.SetAsBox(0.5f, 0.5f);
+                physics.SetFixedRotation(boxUid, false, body: box);
+                fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true), body: box);
+
+                physics.WakeBody(boxUid, body: box);
+                physics.SetSleepingAllowed(boxUid, box, false);
+            }
+        }
+
+        physics.WakeBody(groundUid, body: ground);
+    }
+}

Robust.Benchmarks/Physics/CircleStackBenchmark.cs

@@ -0,0 +1,92 @@
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Collision.Shapes;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Physics.Systems;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.Physics;
+
+[Virtual]
+public class PhysicsCircleStackBenchmark
+{
+    private ISimulation _sim = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _sim = RobustServerSimulation.NewSimulation().InitializeInstance();
+
+        var entManager = _sim.Resolve<IEntityManager>();
+        entManager.System<SharedMapSystem>().CreateMap(out var mapId);
+        SetupTumbler(entManager, mapId);
+
+        for (var i = 0; i < 30; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+        }
+    }
+
+    [Benchmark]
+    public void CircleStack()
+    {
+        var entManager = _sim.Resolve<IEntityManager>();
+
+        for (var i = 0; i < 10000; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+        }
+    }
+
+    private void SetupTumbler(IEntityManager entManager, MapId mapId)
+    {
+        var physics = entManager.System<SharedPhysicsSystem>();
+        var fixtures = entManager.System<FixtureSystem>();
+
+        var groundUid = entManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
+        var ground = entManager.AddComponent<PhysicsComponent>(groundUid);
+
+        var horizontal = new EdgeShape(new Vector2(-40, 0), new Vector2(40, 0));
+        fixtures.CreateFixture(groundUid, "fix1", new Fixture(horizontal, 2, 2, true), body: ground);
+
+        var vertical = new EdgeShape(new Vector2(20, 0), new Vector2(20, 20));
+        fixtures.CreateFixture(groundUid, "fix2", new Fixture(vertical, 2, 2, true), body: ground);
+
+        var xs = new[]
+        {
+            0.0f, -10.0f, -5.0f, 5.0f, 10.0f
+        };
+
+        var columnCount = 1;
+        var rowCount = 15;
+        PhysShapeCircle shape;
+
+        for (var j = 0; j < columnCount; j++)
+        {
+            for (var i = 0; i < rowCount; i++)
+            {
+                var x = 0.0f;
+
+                var boxUid = entManager.SpawnEntity(null,
+                    new MapCoordinates(new Vector2(xs[j] + x, 0.55f + 2.1f * i), mapId));
+                var box = entManager.AddComponent<PhysicsComponent>(boxUid);
+
+                physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
+                shape = new PhysShapeCircle(0.5f);
+                physics.SetFixedRotation(boxUid, false, body: box);
+                // TODO: Need to detect shape and work out if we need to use fixedrotation
+
+                fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true, 5f));
+                physics.WakeBody(boxUid, body: box);
+                physics.SetSleepingAllowed(boxUid, box, false);
+            }
+        }
+
+        physics.WakeBody(groundUid, body: ground);
+    }
+}

Robust.Benchmarks/Physics/PyramidBenchmark.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Collision.Shapes;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Physics.Systems;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.Physics;
+
+[Virtual]
+public class PhysicsPyramidBenchmark
+{
+    private ISimulation _sim = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _sim = RobustServerSimulation.NewSimulation().InitializeInstance();
+
+        var entManager = _sim.Resolve<IEntityManager>();
+        entManager.System<SharedMapSystem>().CreateMap(out var mapId);
+        SetupTumbler(entManager, mapId);
+
+        for (var i = 0; i < 300; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+        }
+    }
+
+    [Benchmark]
+    public void Pyramid()
+    {
+        var entManager = _sim.Resolve<IEntityManager>();
+
+        for (var i = 0; i < 5000; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+        }
+    }
+
+    private void SetupTumbler(IEntityManager entManager, MapId mapId)
+    {
+        const byte count = 20;
+
+        // Setup ground
+        var physics = entManager.System<SharedPhysicsSystem>();
+        var fixtures = entManager.System<FixtureSystem>();
+        var groundUid = entManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
+        var ground = entManager.AddComponent<PhysicsComponent>(groundUid);
+
+        var horizontal = new EdgeShape(new Vector2(40, 0), new Vector2(-40, 0));
+        fixtures.CreateFixture(groundUid, "fix1", new Fixture(horizontal, 2, 2, true), body: ground);
+        physics.WakeBody(groundUid, body: ground);
+
+        // Setup boxes
+        float a = 0.5f;
+        PolygonShape shape = new();
+        shape.SetAsBox(a, a);
+
+        var x = new Vector2(-7.0f, 0.75f);
+        Vector2 y;
+        Vector2 deltaX = new Vector2(0.5625f, 1.25f);
+        Vector2 deltaY = new Vector2(1.125f, 0.0f);
+
+        for (var i = 0; i < count; ++i)
+        {
+            y = x;
+
+            for (var j = i; j < count; ++j)
+            {
+                var boxUid = entManager.SpawnEntity(null, new MapCoordinates(y, mapId));
+                var box = entManager.AddComponent<PhysicsComponent>(boxUid);
+                physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
+
+                fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true, 5f), body: box);
+                y += deltaY;
+
+                physics.WakeBody(boxUid, body: box);
+                physics.SetSleepingAllowed(boxUid, box, false);
+            }
+
+            x += deltaX;
+        }
+    }
+}

Robust.Benchmarks/Physics/TumblerBenchmark.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Numerics;
+using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Collision.Shapes;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Physics.Systems;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.Physics;
+
+[Virtual]
+public class PhysicsTumblerBenchmark
+{
+    private ISimulation _sim = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _sim = RobustServerSimulation.NewSimulation().InitializeInstance();
+
+        var entManager = _sim.Resolve<IEntityManager>();
+        var physics = entManager.System<SharedPhysicsSystem>();
+        var fixtures = entManager.System<FixtureSystem>();
+        entManager.System<SharedMapSystem>().CreateMap(out var mapId);
+        SetupTumbler(entManager, mapId);
+
+        for (var i = 0; i < 800; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+            var boxUid = entManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
+            var box = entManager.AddComponent<PhysicsComponent>(boxUid);
+            physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
+            physics.SetFixedRotation(boxUid, false, body: box);
+            var shape = new PolygonShape();
+            shape.SetAsBox(0.125f, 0.125f);
+            fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true, 0.0625f), body: box);
+            physics.WakeBody(boxUid, body: box);
+            physics.SetSleepingAllowed(boxUid, box, false);
+        }
+    }
+
+    [Benchmark]
+    public void Tumbler()
+    {
+        var entManager = _sim.Resolve<IEntityManager>();
+
+        for (var i = 0; i < 5000; i++)
+        {
+            entManager.TickUpdate(0.016f, false);
+        }
+    }
+
+    private void SetupTumbler(IEntityManager entManager, MapId mapId)
+    {
+        var physics = entManager.System<SharedPhysicsSystem>();
+        var fixtures = entManager.System<FixtureSystem>();
+        var joints = entManager.System<SharedJointSystem>();
+
+        var groundUid = entManager.SpawnEntity(null, new MapCoordinates(0f, 0f, mapId));
+        var ground = entManager.AddComponent<PhysicsComponent>(groundUid);
+        // Due to lookup changes fixtureless bodies are invalid, so
+        var cShape = new PhysShapeCircle(1f);
+        fixtures.CreateFixture(groundUid, "fix1", new Fixture(cShape, 0, 0, false));
+
+        var bodyUid = entManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
+        var body = entManager.AddComponent<PhysicsComponent>(bodyUid);
+
+        physics.SetBodyType(bodyUid, BodyType.Dynamic, body: body);
+        physics.SetSleepingAllowed(bodyUid, body, false);
+        physics.SetFixedRotation(bodyUid, false, body: body);
+
+
+        // TODO: Box2D just deref, bleh shape structs someday
+        var shape1 = new PolygonShape();
+        shape1.SetAsBox(0.5f, 10.0f, new Vector2(10.0f, 0.0f), 0.0f);
+        fixtures.CreateFixture(bodyUid, "fix1", new Fixture(shape1, 2, 0, true, 20f));
+
+        var shape2 = new PolygonShape();
+        shape2.SetAsBox(0.5f, 10.0f, new Vector2(-10.0f, 0.0f), 0f);
+        fixtures.CreateFixture(bodyUid, "fix2", new Fixture(shape2, 2, 0, true, 20f));
+
+        var shape3 = new PolygonShape();
+        shape3.SetAsBox(10.0f, 0.5f, new Vector2(0.0f, 10.0f), 0f);
+        fixtures.CreateFixture(bodyUid, "fix3", new Fixture(shape3, 2, 0, true, 20f));
+
+        var shape4 = new PolygonShape();
+        shape4.SetAsBox(10.0f, 0.5f, new Vector2(0.0f, -10.0f), 0f);
+        fixtures.CreateFixture(bodyUid, "fix4", new Fixture(shape4, 2, 0, true, 20f));
+
+        physics.WakeBody(groundUid, body: ground);
+        physics.WakeBody(bodyUid, body: body);
+        var revolute = joints.CreateRevoluteJoint(groundUid, bodyUid);
+        revolute.LocalAnchorA = new Vector2(0f, 10f);
+        revolute.LocalAnchorB = new Vector2(0f, 0f);
+        revolute.ReferenceAngle = 0f;
+        revolute.MotorSpeed = 0.05f * MathF.PI;
+        revolute.MaxMotorTorque = 100000000f;
+        revolute.EnableMotor = true;
+    }
+}

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

@@ -453,6 +453,17 @@ public sealed partial class AudioSystem : SharedAudioSystem
         return null; // uhh Lets hope predicted audio never needs to somehow store the playing audio....
     }
 
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayLocal(
+        SoundSpecifier? sound,
+        EntityUid source,
+        EntityUid? soundInitiator,
+        AudioParams? audioParams = null
+    )
+    {
+        return PlayPredicted(sound, source, soundInitiator, audioParams);
+    }
+
     public override (EntityUid Entity, AudioComponent Component)? PlayPredicted(SoundSpecifier? sound, EntityCoordinates coordinates, EntityUid? user, AudioParams? audioParams = null)
     {
         if (Timing.IsFirstTimePredicted && sound != null)
@@ -658,7 +669,8 @@ public sealed partial class AudioSystem : SharedAudioSystem
 
         // TODO clamp the offset inside of SetPlaybackPosition() itself.
         var offset = audioP.PlayOffsetSeconds;
-        offset = Math.Clamp(offset, 0f, (float) stream.Length.TotalSeconds - 0.01f);
+        var maxOffset = Math.Max((float) stream.Length.TotalSeconds - 0.01f, 0f);
+        offset = Math.Clamp(offset, 0f, maxOffset);
         source.PlaybackPosition = offset;
 
         // For server we will rely on the adjusted one but locally we will have to adjust it ourselves.

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -33,12 +33,6 @@ public interface IMidiRenderer : IDisposable
     /// </summary>
     bool LoopMidi { get; set; }
 
-    /// <summary>
-    ///     This increases all note on velocities to 127.
-    /// </summary>
-    [Obsolete($"Use {nameof(VelocityOverride)} instead, you can set it to 127 to achieve the same effect.")]
-    bool VolumeBoost { get; set; }
-
     /// <summary>
     ///     The midi program (instrument) the renderer is using.
     /// </summary>

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -205,14 +205,6 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
-    [ViewVariables(VVAccess.ReadWrite)]
-    [Obsolete($"Use {nameof(VelocityOverride)} instead, you can set it to 127 to achieve the same effect.")]
-    public bool VolumeBoost
-    {
-        get => VelocityOverride == 127;
-        set => VelocityOverride = value ? 127 : null;
-    }
-
     [ViewVariables(VVAccess.ReadWrite)]
     public EntityUid? TrackingEntity { get; set; } = null;
 

Robust.Client/ClientIoC.cs

@@ -8,6 +8,7 @@ using Robust.Client.GameObjects;
 using Robust.Client.GameStates;
 using Robust.Client.Graphics;
 using Robust.Client.Graphics.Clyde;
+using Robust.Client.HWId;
 using Robust.Client.Input;
 using Robust.Client.Map;
 using Robust.Client.Placement;
@@ -158,6 +159,7 @@ namespace Robust.Client
 
             deps.Register<IXamlProxyHelper, XamlProxyHelper>();
             deps.Register<MarkupTagManager>();
+            deps.Register<IHWId, BasicHWId>();
         }
     }
 }

Robust.Client/Console/Commands/LauncherAuthCommand.cs

@@ -20,8 +20,9 @@ namespace Robust.Client.Console.Commands
         {
             var wantName = args.Length > 0 ? args[0] : null;
 
-            var basePath = Path.GetDirectoryName(UserDataDir.GetUserDataDir(_gameController))!;
-            var dbPath = Path.Combine(basePath, "launcher", "settings.db");
+            var basePath = UserDataDir.GetRootUserDataDir(_gameController);
+            var launcherDirName = Environment.GetEnvironmentVariable("SS14_LAUNCHER_APPDATA_NAME") ?? "launcher";
+            var dbPath = Path.Combine(basePath, launcherDirName, "settings.db");
 
 #if USE_SYSTEM_SQLITE
             SQLitePCL.raw.SetProvider(new SQLitePCL.SQLite3Provider_sqlite3());

Robust.Client/Credits/CreditsManager.cs

@@ -14,15 +14,6 @@ namespace Robust.Client.Credits
     /// </summary>
     public static class CreditsManager
     {
-        /// <summary>
-        ///     Gets a list of open source software used in the engine and their license.
-        /// </summary>
-        [Obsolete("Use overload that takes in an explicit resource manager instead.")]
-        public static IEnumerable<LicenseEntry> GetLicenses()
-        {
-            return GetLicenses(IoCManager.Resolve<IResourceManager>());
-        }
-
         /// <summary>
         ///     Gets a list of open source software used in the engine and their license.
         /// </summary>

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -544,7 +544,7 @@ namespace Robust.Client.Debugging
             switch (joint)
             {
                 case DistanceJoint:
-                    worldHandle.DrawLine(xf1, xf2, JointColor);
+                    worldHandle.DrawLine(p1, p2, JointColor);
                     break;
                 case PrismaticJoint prisma:
                     var pA = Transform.Mul(xfa, joint.LocalAnchorA);

Robust.Client/GameController/GameController.cs

@@ -112,14 +112,28 @@ namespace Robust.Client
             _commandLineArgs = args;
         }
 
+        public string GameTitle()
+        {
+            return Options.DefaultWindowTitle ?? _resourceManifest!.DefaultWindowTitle ?? "RobustToolbox";
+        }
+
+        public string WindowIconSet()
+        {
+            return Options.WindowIconSet?.ToString() ?? _resourceManifest!.WindowIconSet ?? "";
+        }
+
+        public string SplashLogo()
+        {
+            return Options.SplashLogo?.ToString() ?? _resourceManifest!.SplashLogo ?? "";
+        }
+
         internal bool StartupContinue(DisplayMode displayMode)
         {
             DebugTools.AssertNotNull(_resourceManifest);
 
             _clyde.InitializePostWindowing();
             _audio.InitializePostWindowing();
-            _clyde.SetWindowTitle(
-                Options.DefaultWindowTitle ?? _resourceManifest!.DefaultWindowTitle ?? "RobustToolbox");
+            _clyde.SetWindowTitle(GameTitle());
 
             _taskManager.Initialize();
             _parallelMgr.Initialize();
@@ -368,7 +382,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)
@@ -399,10 +413,8 @@ namespace Robust.Client
                 // Handle GameControllerOptions implicit CVar overrides.
                 _configurationManager.OverrideConVars(new[]
                 {
-                    (CVars.DisplayWindowIconSet.Name,
-                        options.WindowIconSet?.ToString() ?? _resourceManifest.WindowIconSet ?? ""),
-                    (CVars.DisplaySplashLogo.Name,
-                        options.SplashLogo?.ToString() ?? _resourceManifest.SplashLogo ?? "")
+                    (CVars.DisplayWindowIconSet.Name, WindowIconSet()),
+                    (CVars.DisplaySplashLogo.Name, SplashLogo())
                 });
             }
 

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -99,15 +99,6 @@ namespace Robust.Client.GameObjects
             Play(new Entity<AnimationPlayerComponent>(uid, component), animation, key);
         }
 
-        /// <summary>
-        ///     Start playing an animation.
-        /// </summary>
-        [Obsolete("Use Play(EntityUid<AnimationPlayerComponent> ent, Animation animation, string key) instead")]
-        public void Play(AnimationPlayerComponent component, Animation animation, string key)
-        {
-            Play(new Entity<AnimationPlayerComponent>(component.Owner, component), animation, key);
-        }
-
         public void Play(Entity<AnimationPlayerComponent> ent, Animation animation, string key)
         {
             AddComponent(ent);
@@ -152,6 +143,14 @@ namespace Robust.Client.GameObjects
             }
 #endif
 
+            foreach (var track in animation.AnimationTracks)
+            {
+                if (track is not AnimationTrackSpriteFlick)
+                    continue;
+
+                track.AdvancePlayback(ent.Owner, 0, 0, 0f);
+            }
+
             ent.Comp.PlayingAnimations.Add(key, playback);
         }
 

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -17,7 +17,6 @@ namespace Robust.Client.GameObjects
 {
     public sealed class ContainerSystem : SharedContainerSystem
     {
-        [Dependency] private readonly INetManager _netMan = default!;
         [Dependency] private readonly IRobustSerializer _serializer = default!;
         [Dependency] private readonly IDynamicTypeFactoryInternal _dynFactory = default!;
         [Dependency] private readonly PointLightSystem _lightSys = default!;

Robust.Client/GameObjects/EntitySystems/GridChunkBoundsDebugSystem.cs

@@ -82,6 +82,7 @@ namespace Robust.Client.GameObjects
             var viewport = args.WorldBounds;
             var worldHandle = args.WorldHandle;
 
+            var fixturesQuery = _entityManager.GetEntityQuery<FixturesComponent>();
             _grids.Clear();
             _mapManager.FindGridsIntersecting(currentMap, viewport, ref _grids);
             foreach (var grid in _grids)
@@ -89,13 +90,15 @@ namespace Robust.Client.GameObjects
                 var worldMatrix = _transformSystem.GetWorldMatrix(grid);
                 worldHandle.SetTransform(worldMatrix);
                 var transform = new Transform(Vector2.Zero, Angle.Zero);
+                var fixtures = fixturesQuery.Comp(grid.Owner);
 
                 var chunkEnumerator = _mapSystem.GetMapChunks(grid.Owner, grid.Comp, viewport);
 
                 while (chunkEnumerator.MoveNext(out var chunk))
                 {
-                    foreach (var fixture in chunk.Fixtures.Values)
+                    foreach (var id in chunk.Fixtures)
                     {
+                        var fixture = fixtures.Fixtures[id];
                         var poly = (PolygonShape) fixture.Shape;
 
                         var verts = new Vector2[poly.VertexCount];

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -20,7 +20,6 @@ namespace Robust.Client.GameObjects
     /// </summary>
     public sealed class InputSystem : SharedInputSystem, IPostInjectInit
     {
-        [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IClientGameStateManager _stateManager = default!;

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -960,7 +960,7 @@ namespace Robust.Client.GameStates
 
             // Initialize and start the newly created entities.
             if (_toCreate.Count > 0)
-                InitializeAndStart(_toCreate);
+                InitializeAndStart(_toCreate, metas, xforms);
 
             _prof.WriteValue("State Size", ProfData.Int32(curSpan.Length));
             _prof.WriteValue("Entered PVS", ProfData.Int32(enteringPvs));
@@ -1188,7 +1188,10 @@ namespace Robust.Client.GameStates
             }
         }
 
-        private void InitializeAndStart(Dictionary<NetEntity, EntityState> toCreate)
+        private void InitializeAndStart(
+            Dictionary<NetEntity, EntityState> toCreate,
+            EntityQuery<MetaDataComponent> metas,
+            EntityQuery<TransformComponent> xforms)
         {
             _toStart.Clear();
 
@@ -1197,22 +1200,8 @@ namespace Robust.Client.GameStates
                 EntityUid entity = default;
                 foreach (var netEntity in toCreate.Keys)
                 {
-                    try
-                    {
-                        (entity, var meta) = _entityManager.GetEntityData(netEntity);
-                        _entities.InitializeEntity(entity, meta);
-                        _toStart.Add((entity, netEntity));
-                    }
-                    catch (Exception e)
-                    {
-                        _sawmill.Error($"Server entity threw in Init: nent={netEntity}, ent={_entities.ToPrettyString(entity)}");
-                        _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(InitializeAndStart)}");
-                        _toCreate.Remove(netEntity);
-                        _brokenEnts.Add(entity);
-#if !EXCEPTION_TOLERANCE
-                        throw;
-#endif
-                    }
+                    (entity, var meta) = _entityManager.GetEntityData(netEntity);
+                    InitializeRecursive(entity, meta, metas, xforms);
                 }
             }
 
@@ -1244,6 +1233,44 @@ namespace Robust.Client.GameStates
             _brokenEnts.Clear();
         }
 
+        private void InitializeRecursive(
+            EntityUid entity,
+            MetaDataComponent meta,
+            EntityQuery<MetaDataComponent> metas,
+            EntityQuery<TransformComponent> xforms)
+        {
+            var xform = xforms.GetComponent(entity);
+            if (xform.ParentUid is {Valid: true} parent)
+            {
+                var parentMeta = metas.GetComponent(parent);
+                if (parentMeta.EntityLifeStage < EntityLifeStage.Initialized)
+                    InitializeRecursive(parent, parentMeta, metas, xforms);
+            }
+
+            if (meta.EntityLifeStage >= EntityLifeStage.Initialized)
+            {
+                // Was probably already initialized because one of its children appeared earlier in the list.
+                DebugTools.AssertEqual(_toStart.Count(x => x.Item1 == entity), 1);
+                return;
+            }
+
+            try
+            {
+                _entities.InitializeEntity(entity, meta);
+                _toStart.Add((entity, meta.NetEntity));
+            }
+            catch (Exception e)
+            {
+                _sawmill.Error($"Server entity threw in Init: nent={meta.NetEntity}, ent={_entities.ToPrettyString(entity)}");
+                _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(InitializeAndStart)}");
+                _toCreate.Remove(meta.NetEntity);
+                _brokenEnts.Add(entity);
+#if !EXCEPTION_TOLERANCE
+                throw;
+#endif
+            }
+        }
+
         private void HandleEntityState(EntityUid uid, NetEntity netEntity, MetaDataComponent meta, IEventBus bus, EntityState? curState,
             EntityState? nextState, GameTick lastApplied, GameTick toTick, bool enteringPvs)
         {

Robust.Client/GameStates/IClientGameStateManager.cs

@@ -34,9 +34,6 @@ namespace Robust.Client.GameStates
         /// </summary>
         int GetApplicableStateCount();
 
-        [Obsolete("use GetApplicableStateCount()")]
-        int CurrentBufferSize => GetApplicableStateCount();
-
         /// <summary>
         ///     Total number of game states currently in the state buffer.
         /// </summary>

Robust.Client/GameStates/NetGraphOverlay.cs

@@ -46,7 +46,6 @@ namespace Robust.Client.GameStates
 
         // sum of all data point sizes in bytes
         private int _totalHistoryPayload;
-        private int _totalUncompressed;
 
         public EntityUid WatchEntId { get; set; }
 

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -15,7 +15,6 @@ namespace Robust.Client.GameStates
     {
         [Dependency] private readonly IGameTiming _timing = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
-        [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         private readonly EntityLookupSystem _lookup;
 

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

@@ -109,6 +109,9 @@ namespace Robust.Client.Graphics.Clyde
 
         private void SendWindowResized(WindowReg reg, Vector2i oldSize)
         {
+            if (!reg.IsVisible) // Only send this for open windows
+                return;
+
             var loaded = RtToLoaded(reg.RenderTarget);
             loaded.Size = reg.FramebufferSize;
 

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

@@ -343,6 +343,8 @@ namespace Robust.Client.Graphics.Clyde
                 if (isMain)
                     _mainWindow = reg;
 
+                reg.IsVisible = parameters.Visible;
+
                 _windows.Add(reg);
                 _windowHandles.Add(reg.Handle);
 
@@ -444,6 +446,12 @@ namespace Robust.Client.Graphics.Clyde
             _windowing!.CursorSet(_mainWindow!, cursor);
         }
 
+        private void SetWindowSize(WindowReg reg, Vector2i size)
+        {
+            DebugTools.AssertNotNull(_windowing);
+
+            _windowing!.WindowSetSize(reg, size);
+        }
 
         private void SetWindowVisible(WindowReg reg, bool visible)
         {
@@ -533,7 +541,11 @@ namespace Robust.Client.Graphics.Clyde
                 _clyde.DoDestroyWindow(Reg);
             }
 
-            public Vector2i Size => Reg.FramebufferSize;
+            public Vector2i Size
+            {
+                get => Reg.FramebufferSize;
+                set => _clyde.SetWindowSize(Reg, value);
+            }
 
             public IRenderTarget RenderTarget => Reg.RenderTarget;
 

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -32,7 +32,6 @@ namespace Robust.Client.Graphics.Clyde
     internal sealed partial class Clyde : IClydeInternal, IPostInjectInit, IEntityEventSubscriber
     {
         [Dependency] private readonly IClydeTileDefinitionManager _tileDefinitionManager = default!;
-        [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly ILightManager _lightManager = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;

Robust.Client/Graphics/Clyde/ClydeHeadless.cs

@@ -517,7 +517,7 @@ namespace Robust.Client.Graphics.Clyde
                 RenderTarget = renderTarget;
             }
 
-            public Vector2i Size { get; } = default;
+            public Vector2i Size { get; set; } = default;
             public bool IsDisposed { get; private set; }
             public WindowId Id { get; set; }
             public IRenderTarget RenderTarget { get; }

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

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Channels;
@@ -176,6 +176,7 @@ namespace Robust.Client.Graphics.Clyde
                         window.BlitDoneEvent!.Reset();
                         window.BlitStartEvent!.Set();
                         window.BlitDoneEvent.Wait();
+                        window.UnlockBeforeSwap = Clyde._cfg.GetCVar(CVars.DisplayThreadUnlockBeforeSwap);
                     }
                 }
                 else
@@ -212,8 +213,15 @@ namespace Robust.Client.Graphics.Clyde
                 GL.DrawArrays(PrimitiveType.TriangleStrip, 0, 4);
                 Clyde.CheckGlError();
 
-                window.BlitDoneEvent?.Set();
+                if (window.UnlockBeforeSwap)
+                {
+                    window.BlitDoneEvent?.Set();
+                }
                 Clyde._windowing!.WindowSwapBuffers(window.Reg);
+                if (!window.UnlockBeforeSwap)
+                {
+                    window.BlitDoneEvent?.Set();
+                }
             }
 
             private unsafe void BlitThreadInit(WindowData reg)
@@ -336,6 +344,7 @@ namespace Robust.Client.Graphics.Clyde
                 public Thread? BlitThread;
                 public ManualResetEventSlim? BlitStartEvent;
                 public ManualResetEventSlim? BlitDoneEvent;
+                public bool UnlockBeforeSwap;
             }
         }
     }

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

@@ -85,6 +85,10 @@ namespace Robust.Client.Graphics.Clyde
                         WinThreadWinSetMonitor(cmd);
                         break;
 
+                    case CmdWinSetSize cmd:
+                        WinThreadWinSetSize(cmd);
+                        break;
+
                     case CmdWinSetVisible cmd:
                         WinThreadWinSetVisible(cmd);
                         break;
@@ -234,6 +238,11 @@ namespace Robust.Client.Graphics.Clyde
                 nint Window
             ) : CmdBase;
 
+            private sealed record CmdWinSetSize(
+                nint Window,
+                int W, int H
+            ) : CmdBase;
+
             private sealed record CmdWinSetVisible(
                 nint Window,
                 bool Visible

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

@@ -84,6 +84,13 @@ namespace Robust.Client.Graphics.Clyde
                 );
             }
 
+            public void WindowSetSize(WindowReg window, Vector2i size)
+            {
+                var reg = (GlfwWindowReg) window;
+
+                SendCmd(new CmdWinSetSize((nint) reg.GlfwWindow, size.X, size.Y));
+            }
+
             public void WindowSetVisible(WindowReg window, bool visible)
             {
                 var reg = (GlfwWindowReg) window;
@@ -92,6 +99,13 @@ namespace Robust.Client.Graphics.Clyde
                 SendCmd(new CmdWinSetVisible((nint) reg.GlfwWindow, visible));
             }
 
+            private void WinThreadWinSetSize(CmdWinSetSize cmd)
+            {
+                var win = (Window*) cmd.Window;
+
+                GLFW.SetWindowSize(win, cmd.W, cmd.H);
+            }
+
             private void WinThreadWinSetVisible(CmdWinSetVisible cmd)
             {
                 var win = (Window*) cmd.Window;

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

@@ -39,6 +39,7 @@ namespace Robust.Client.Graphics.Clyde
             void WindowDestroy(WindowReg reg);
             void WindowSetTitle(WindowReg window, string title);
             void WindowSetMonitor(WindowReg window, IClydeMonitor monitor);
+            void WindowSetSize(WindowReg window, Vector2i size);
             void WindowSetVisible(WindowReg window, bool visible);
             void WindowRequestAttention(WindowReg window);
             void WindowSwapBuffers(WindowReg window);

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

@@ -93,6 +93,10 @@ internal partial class Clyde
                     WinThreadWinRequestAttention(cmd);
                     break;
 
+                case CmdWinSetSize cmd:
+                    WinThreadWinSetSize(cmd);
+                    break;
+
                 case CmdWinSetVisible cmd:
                     WinThreadWinSetVisible(cmd);
                     break;
@@ -246,6 +250,11 @@ internal partial class Clyde
             nint Window
         ) : CmdBase;
 
+        private sealed record CmdWinSetSize(
+            nint Window,
+            int W, int H
+        ) : CmdBase;
+
         private sealed record CmdWinSetVisible(
             nint Window,
             bool Visible

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

@@ -336,11 +336,22 @@ internal partial class Clyde
             _sawmill.Warning("WindowSetMonitor not implemented on SDL2");
         }
 
+        public void WindowSetSize(WindowReg window, Vector2i size)
+        {
+            SendCmd(new CmdWinSetSize(WinPtr(window), size.X, size.Y));
+        }
+
         public void WindowSetVisible(WindowReg window, bool visible)
         {
+            window.IsVisible = visible;
             SendCmd(new CmdWinSetVisible(WinPtr(window), visible));
         }
 
+        private static void WinThreadWinSetSize(CmdWinSetSize cmd)
+        {
+            SDL_SetWindowSize(cmd.Window, cmd.W, cmd.H);
+        }
+
         private static void WinThreadWinSetVisible(CmdWinSetVisible cmd)
         {
             if (cmd.Visible)

Robust.Client/Graphics/IClydeWindow.cs

@@ -14,7 +14,7 @@ namespace Robust.Client.Graphics
         WindowId Id { get; }
         IRenderTarget RenderTarget { get; }
         string Title { get; set; }
-        Vector2i Size { get; }
+        Vector2i Size { get; set; }
         bool IsFocused { get; }
         bool IsMinimized { get; }
         bool IsVisible { get; set; }

Robust.Client/HWId/BasicHWId.cs

@@ -0,0 +1,86 @@
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using Microsoft.Win32;
+using Robust.Client.Utility;
+using Robust.Shared.IoC;
+using Robust.Shared.Network;
+
+namespace Robust.Client.HWId;
+
+internal sealed class BasicHWId : IHWId
+{
+    [Dependency] private readonly IGameControllerInternal _gameController = default!;
+
+    public const int LengthHwid = 32;
+
+    public byte[] GetLegacy()
+    {
+        if (OperatingSystem.IsWindows())
+            return GetWindowsHWid("Hwid");
+
+        return [];
+    }
+
+    public byte[] GetModern()
+    {
+        byte[] raw;
+
+        if (OperatingSystem.IsWindows())
+            raw = GetWindowsHWid("Hwid2");
+        else
+            raw = GetFileHWid();
+
+        return [0, ..raw];
+    }
+
+    private static byte[] GetWindowsHWid(string keyName)
+    {
+        const string keyPath = @"HKEY_CURRENT_USER\SOFTWARE\Space Wizards\Robust";
+
+        var regKey = Registry.GetValue(keyPath, keyName, null);
+        if (regKey is byte[] { Length: LengthHwid } bytes)
+            return bytes;
+
+        var newId = new byte[LengthHwid];
+        RandomNumberGenerator.Fill(newId);
+        Registry.SetValue(
+            keyPath,
+            keyName,
+            newId,
+            RegistryValueKind.Binary);
+
+        return newId;
+    }
+
+    private byte[] GetFileHWid()
+    {
+        var path = UserDataDir.GetRootUserDataDir(_gameController);
+        var hwidPath = Path.Combine(path, ".hwid");
+
+        var value = ReadHWidFile(hwidPath);
+        if (value != null)
+            return value;
+
+        value = RandomNumberGenerator.GetBytes(LengthHwid);
+        File.WriteAllBytes(hwidPath, value);
+
+        return value;
+    }
+
+    private static byte[]? ReadHWidFile(string path)
+    {
+        try
+        {
+            var value = File.ReadAllBytes(path);
+            if (value.Length == LengthHwid)
+                return value;
+        }
+        catch (FileNotFoundException)
+        {
+            // First time the file won't exist.
+        }
+
+        return null;
+    }
+}

Robust.Client/IGameController.cs

@@ -26,5 +26,20 @@ public interface IGameController
     ///     This exists to give content module more control over tick updating.
     /// </summary>
     event Action<FrameEventArgs>? TickUpdateOverride;
+
+    /// <summary>
+    ///     Get the games Title, if Options.DefaultWindowTitle or if defaultWindowTitle is not set in the manifest.yml, it will default to RobustToolbox.
+    /// </summary>
+    string GameTitle();
+
+    /// <summary>
+    ///     Get the games Window Icon set, if Options.WindowIconSet or if windowIconSet is not set in the manifest.yml, it will default to an empty string.
+    /// </summary>
+    string WindowIconSet();
+
+    /// <summary>
+    ///     Get the games Splash Logo, if Options.SplashLogo or if splashLogo is not set in the manifest.yml, it will default to an empty string.
+    /// </summary>
+    string SplashLogo();
 }
 

Robust.Client/Physics/PhysicsSystem.Predict.cs

@@ -156,7 +156,6 @@ public sealed partial class PhysicsSystem
 
             if (activeA == false && activeB == false)
             {
-                contact.IsTouching = false;
                 continue;
             }
 

Robust.Client/Placement/Modes/AlignTileAny.cs

@@ -1,4 +1,5 @@
 using System.Numerics;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 
@@ -14,16 +15,16 @@ namespace Robust.Client.Placement.Modes
         public override void AlignPlacementMode(ScreenCoordinates mouseScreen)
         {
             // Go over diagonal size so when placing in a line it doesn't stop snapping.
-            const float SearchBoxSize = 2f; // size of search box in meters
+            const float searchBoxSize = 2f; // size of search box in meters
 
-            MouseCoords = ScreenToCursorGrid(mouseScreen).AlignWithClosestGridTile(SearchBoxSize, pManager.EntityManager, pManager.MapManager);
+            MouseCoords = ScreenToCursorGrid(mouseScreen).AlignWithClosestGridTile(searchBoxSize, pManager.EntityManager, pManager.MapManager);
 
-            var gridId = MouseCoords.GetGridUid(pManager.EntityManager);
+            var gridId = pManager.EntityManager.System<SharedTransformSystem>().GetGrid(MouseCoords);
 
             if (!pManager.EntityManager.TryGetComponent<MapGridComponent>(gridId, out var mapGrid))
                 return;
 
-            CurrentTile = mapGrid.GetTileRef(MouseCoords);
+            CurrentTile = pManager.EntityManager.System<SharedMapSystem>().GetTileRef(gridId.Value, mapGrid, MouseCoords);
             float tileSize = mapGrid.TileSize; //convert from ushort to float
             GridDistancing = tileSize;
 

Robust.Client/Placement/Modes/AlignTileEmpty.cs

@@ -1,6 +1,5 @@
 using System.Numerics;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Maths;
@@ -19,12 +18,12 @@ namespace Robust.Client.Placement.Modes
             MouseCoords = ScreenToCursorGrid(mouseScreen);
 
             var tileSize = 1f;
-            var gridIdOpt = MouseCoords.GetGridUid(pManager.EntityManager);
+            var gridIdOpt = pManager.EntityManager.System<SharedTransformSystem>().GetGrid(MouseCoords);
 
-            if (gridIdOpt is EntityUid gridId && gridId.IsValid())
+            if (gridIdOpt is { } gridId && gridId.IsValid())
             {
                 var mapGrid = pManager.EntityManager.GetComponent<MapGridComponent>(gridId);
-                CurrentTile = mapGrid.GetTileRef(MouseCoords);
+                CurrentTile = pManager.EntityManager.System<SharedMapSystem>().GetTileRef(gridId, mapGrid ,MouseCoords);
                 tileSize = mapGrid.TileSize; //convert from ushort to float
             }
 
@@ -50,12 +49,12 @@ namespace Robust.Client.Placement.Modes
                 return false;
             }
 
-            var map = MouseCoords.GetMapId(pManager.EntityManager);
+            var map = pManager.EntityManager.System<SharedTransformSystem>().GetMapId(MouseCoords);
             var bottomLeft = new Vector2(CurrentTile.X, CurrentTile.Y);
             var topRight = new Vector2(CurrentTile.X + 0.99f, CurrentTile.Y + 0.99f);
             var box = new Box2(bottomLeft, topRight);
 
-            return !EntitySystem.Get<EntityLookupSystem>().AnyEntitiesIntersecting(map, box);
+            return !pManager.EntityManager.System<EntityLookupSystem>().AnyEntitiesIntersecting(map, box);
         }
     }
 }

Robust.Client/Placement/PlacementManager.cs

@@ -754,14 +754,14 @@ namespace Robust.Client.Placement
 
             if (CurrentPermission.IsTile)
             {
-                var gridIdOpt = coordinates.GetGridUid(EntityManager);
+                var gridIdOpt = EntityManager.System<SharedTransformSystem>().GetGrid(coordinates);
                 // If we have actually placed something on a valid grid...
-                if (gridIdOpt is EntityUid gridId && gridId.IsValid())
+                if (gridIdOpt is { } gridId && gridId.IsValid())
                 {
                     var grid = EntityManager.GetComponent<MapGridComponent>(gridId);
 
                     // no point changing the tile to the same thing.
-                    if (grid.GetTileRef(coordinates).Tile.TypeId == CurrentPermission.TileType)
+                    if (EntityManager.System<SharedMapSystem>().GetTileRef(gridId, grid, coordinates).Tile.TypeId == CurrentPermission.TileType)
                         return;
                 }
 

Robust.Client/Placement/PlacementMode.cs

@@ -197,8 +197,9 @@ namespace Robust.Client.Placement
         /// </summary>
         public TileRef GetTileRef(EntityCoordinates coordinates)
         {
-            var gridUidOpt = coordinates.GetGridUid(pManager.EntityManager);
-            return gridUidOpt is EntityUid gridUid && gridUid.IsValid() ? pManager.EntityManager.GetComponent<MapGridComponent>(gridUid).GetTileRef(MouseCoords)
+            var gridUidOpt = pManager.EntityManager.System<SharedTransformSystem>().GetGrid(coordinates);
+            return gridUidOpt is { } gridUid && gridUid.IsValid()
+                ? pManager.EntityManager.System<SharedMapSystem>().GetTileRef(gridUid, pManager.EntityManager.GetComponent<MapGridComponent>(gridUid), MouseCoords)
                 : new TileRef(gridUidOpt ?? EntityUid.Invalid,
                     MouseCoords.ToVector2i(pManager.EntityManager, pManager.MapManager, pManager.EntityManager.System<SharedTransformSystem>()), Tile.Empty);
         }

Robust.Client/Player/PlayerManager.cs

@@ -261,7 +261,6 @@ namespace Robust.Client.Player
                     // This is a new userid, so we create a new session.
                     DebugTools.Assert(state.UserId != LocalPlayer?.UserId);
                     var newSession = (ICommonSessionInternal)CreateAndAddSession(state.UserId, state.Name);
-                    newSession.SetPing(state.Ping);
                     SetStatus(newSession, state.Status);
                     SetAttachedEntity(newSession, controlled, out _, true);
                     dirty = true;
@@ -271,7 +270,6 @@ namespace Robust.Client.Player
                 // Check if the data is actually different
                 if (session.Name == state.Name
                     && session.Status == state.Status
-                    && session.Ping == state.Ping
                     && session.AttachedEntity == controlled)
                 {
                     continue;
@@ -280,7 +278,6 @@ namespace Robust.Client.Player
                 dirty = true;
                 var local = (ICommonSessionInternal)session;
                 local.SetName(state.Name);
-                local.SetPing(state.Ping);
                 SetStatus(local, state.Status);
                 SetAttachedEntity(local, controlled, out _, true);
             }

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

@@ -23,7 +23,7 @@ public sealed partial class ReplayLoadManager
     // Scratch data used by UpdateEntityStates.
     // Avoids copying changes for every change to an entity between checkpoints, instead copies once per checkpoint on
     // first change. We can also use this to avoid building a dictionary of ComponentChange inside the inner loop.
-    private class UpdateScratchData
+    private sealed class UpdateScratchData
     {
         public Dictionary<ushort, ComponentChange> Changes;
         public EntityState lastChange;

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

@@ -52,7 +52,7 @@ public sealed partial class ReplayLoadManager
             var uncompressedSize = BitConverter.ToInt32(intBuf);
 
             var decompressedStream = new MemoryStream(uncompressedSize);
-            decompressStream.CopyTo(decompressedStream, uncompressedSize);
+            decompressStream.CopyTo(decompressedStream);
             decompressedStream.Position = 0;
             DebugTools.Assert(uncompressedSize == decompressedStream.Length);
 

Robust.Client/ResourceManagement/IResourceCache.cs

@@ -48,7 +48,10 @@ public interface IResourceCache : IResourceManager
     event Action<TextureLoadedEventArgs> OnRawTextureLoaded;
     event Action<RsiLoadedEventArgs> OnRsiLoaded;
 
+    [Obsolete("Fetch these through IoC directly instead")]
     IClyde Clyde { get; }
+
+    [Obsolete("Fetch these through IoC directly instead")]
     IFontManager FontManager { get; }
 }
 

Robust.Client/UserInterface/Control.cs

@@ -762,7 +762,23 @@ namespace Robust.Client.UserInterface
                 throw new InvalidOperationException("The provided control is not a direct child of this control.");
             }
 
-            _orderedChildren.Remove(child);
+            var childIndex = _orderedChildren.IndexOf(child);
+            RemoveChild(childIndex);
+        }
+
+        /// <summary>
+        ///     Removes the child at a specific index from this control.
+        /// </summary>
+        /// <param name="childIndex">The index of the child to remove.</param>
+        /// <exception cref="ArgumentOutOfRangeException">
+        ///     Thrown if the provided child index is out of range
+        /// </exception>
+        public void RemoveChild(int childIndex)
+        {
+            DebugTools.Assert(!Disposed, "Control has been disposed.");
+
+            var child = _orderedChildren[childIndex];
+            _orderedChildren.RemoveAt(childIndex);
 
             child.Parent = null;
 

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

@@ -7,6 +7,8 @@ using Robust.Client.Placement;
 using Robust.Client.ResourceManagement;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared;
+using Robust.Shared.Configuration;
 using Robust.Shared.Enums;
 using Robust.Shared.IoC;
 using Robust.Shared.Prototypes;
@@ -19,9 +21,9 @@ namespace Robust.Client.UserInterface.Controllers.Implementations;
 
 public sealed class EntitySpawningUIController : UIController
 {
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
     [Dependency] private readonly IPlacementManager _placement = default!;
     [Dependency] private readonly IPrototypeManager _prototypes = default!;
-    [Dependency] private readonly IResourceCache _resources = default!;
 
     private EntitySpawnWindow? _window;
     private readonly List<EntityPrototype> _shownEntities = new();
@@ -193,6 +195,9 @@ public sealed class EntitySpawningUIController : UIController
         _window.SelectedButton = null;
         searchStr = searchStr?.ToLowerInvariant();
 
+        var categoryFilter = _cfg.GetCVar(CVars.EntitiesCategoryFilter);
+        _prototypes.TryIndex<EntityCategoryPrototype>(categoryFilter, out var filter);
+
         foreach (var prototype in _prototypes.EnumeratePrototypes<EntityPrototype>())
         {
             if (prototype.Abstract)
@@ -205,6 +210,11 @@ public sealed class EntitySpawningUIController : UIController
                 continue;
             }
 
+            if (filter is not null && !prototype.Categories.Contains(filter))
+            {
+                continue;
+            }
+
             if (searchStr != null && !DoesEntityMatchSearch(prototype, searchStr))
             {
                 continue;

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

@@ -27,6 +27,7 @@ public sealed class TileSpawningUIController : UIController
 
     private readonly List<ITileDefinition> _shownTiles = new();
     private bool _clearingTileSelections;
+    private bool _eraseTile;
 
     public override void Initialize()
     {
@@ -35,6 +36,37 @@ public sealed class TileSpawningUIController : UIController
         _placement.PlacementChanged += ClearTileSelection;
     }
 
+    private void StartTilePlacement(int tileType)
+    {
+        var newObjInfo = new PlacementInformation
+        {
+            PlacementOption = "AlignTileAny",
+            TileType = tileType,
+            Range = 400,
+            IsTile = true
+        };
+
+        _placement.BeginPlacing(newObjInfo);
+    }
+
+    private void OnTileEraseToggled(ButtonToggledEventArgs args)
+    {
+        if (_window == null || _window.Disposed)
+            return;
+
+        _placement.Clear();
+
+        if (args.Pressed)
+        {
+            _eraseTile = true;
+            StartTilePlacement(0);
+        }
+        else
+            _eraseTile = false;
+
+        args.Button.Pressed = args.Pressed;
+    }
+
     public void ToggleWindow()
     {
         EnsureWindow();
@@ -60,6 +92,8 @@ public sealed class TileSpawningUIController : UIController
         _window.SearchBar.OnTextChanged += OnTileSearchChanged;
         _window.TileList.OnItemSelected += OnTileItemSelected;
         _window.TileList.OnItemDeselected += OnTileItemDeselected;
+        _window.EraseButton.Pressed = _eraseTile;
+        _window.EraseButton.OnToggled += OnTileEraseToggled;
         BuildTileList();
     }
 
@@ -76,6 +110,7 @@ public sealed class TileSpawningUIController : UIController
         _clearingTileSelections = true;
         _window.TileList.ClearSelected();
         _clearingTileSelections = false;
+        _window.EraseButton.Pressed = false;
     }
 
     private void OnTileClearPressed(ButtonEventArgs args)
@@ -102,16 +137,7 @@ public sealed class TileSpawningUIController : UIController
     private void OnTileItemSelected(ItemList.ItemListSelectedEventArgs args)
     {
         var definition = _shownTiles[args.ItemIndex];
-
-        var newObjInfo = new PlacementInformation
-        {
-            PlacementOption = "AlignTileAny",
-            TileType = definition.TileId,
-            Range = 400,
-            IsTile = true
-        };
-
-        _placement.BeginPlacing(newObjInfo);
+        StartTilePlacement(definition.TileId);
     }
 
     private void OnTileItemDeselected(ItemList.ItemListDeselectedEventArgs args)

Robust.Client/UserInterface/Controls/BaseButton.cs

@@ -26,6 +26,7 @@ namespace Robust.Client.UserInterface.Controls
         private bool _enableAllKeybinds;
         private ButtonGroup? _group;
         private bool _toggleMode;
+        private bool _muteSounds;
 
         /// <summary>
         ///     Specifies the group this button belongs to.
@@ -135,7 +136,8 @@ namespace Robust.Client.UserInterface.Controls
             if (Pressed != value)
                 return;
 
-            UserInterfaceManager.ClickSound();
+            if (!MuteSounds)
+                UserInterfaceManager.ClickSound();
         }
 
         /// <summary>
@@ -199,6 +201,16 @@ namespace Robust.Client.UserInterface.Controls
             }
         }
 
+        /// <summary>
+        ///     If <c>true</c>, this button will not emit sounds when the mouse is pressed or hovered over.
+        /// </summary>
+        [ViewVariables]
+        public bool MuteSounds
+        {
+            get => _muteSounds;
+            set => _muteSounds = value;
+        }
+
         /// <summary>
         ///     Fired when the button is pushed down by the mouse.
         /// </summary>
@@ -298,7 +310,8 @@ namespace Robust.Client.UserInterface.Controls
                     }
                     else
                     {
-                        UserInterfaceManager.ClickSound();
+                        if (!MuteSounds)
+                            UserInterfaceManager.ClickSound();
                     }
 
                     OnPressed?.Invoke(buttonEventArgs);
@@ -353,7 +366,7 @@ namespace Robust.Client.UserInterface.Controls
         {
             base.MouseEntered();
 
-            if (!Disabled)
+            if (!Disabled && !MuteSounds)
             {
                 UserInterfaceManager.HoverSound();
             }

Robust.Client/UserInterface/Controls/BoxContainer.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Numerics;
 using Robust.Shared.Maths;
 
@@ -56,7 +57,7 @@ namespace Robust.Client.UserInterface.Controls
         protected override Vector2 MeasureOverride(Vector2 availableSize)
         {
             // Account for separation.
-            var separation = ActualSeparation * (ChildCount - 1);
+            var separation = ActualSeparation * (Children.Where(c => c.Visible).Count() - 1);
             var desiredSize = Vector2.Zero;
             if (Vertical)
             {
@@ -136,13 +137,14 @@ namespace Robust.Client.UserInterface.Controls
         protected override Vector2 ArrangeOverride(Vector2 finalSize)
         {
             var separation = ActualSeparation;
+            var visibleChildCount = Children.Where(c => c.Visible).Count();
 
             var stretchAvail = Vertical ? finalSize.Y : finalSize.X;
-            stretchAvail -= separation * (ChildCount - 1);
+            stretchAvail -= separation * (visibleChildCount - 1);
             stretchAvail = Math.Max(0, stretchAvail);
 
             // Step one: figure out the sizes of all our children and whether they want to stretch.
-            var sizeList = new List<(Control control, float size, bool stretch)>(ChildCount);
+            var sizeList = new List<(Control control, float size, bool stretch)>(visibleChildCount);
             var totalStretchRatio = 0f;
             foreach (var child in Children)
             {

Robust.Client/UserInterface/Controls/LineEdit.cs

@@ -53,6 +53,15 @@ namespace Robust.Client.UserInterface.Controls
         private TimeSpan? _lastClickTime;
         private Vector2? _lastClickPosition;
 
+        // Keep track of the frame on which we got focus, so we can implement SelectAllOnFocus properly.
+        // Otherwise, there's no way to keep track of whether the KeyDown is the one that focused the text box,
+        // to avoid text selection stomping on the behavior.
+        // This isn't a great way to do it.
+        // A better fix would be to annotate all input events with some unique sequence ID,
+        // and expose the input event that focused the control in KeyboardFocusEntered.
+        // But that sounds like a refactor I'm not doing today.
+        private uint _focusedOnFrame;
+
         private bool IsPlaceHolderVisible => !(HidePlaceHolderOnFocus && HasKeyboardFocus()) && string.IsNullOrEmpty(_text) && _placeHolder != null;
 
         public event Action<LineEditEventArgs>? OnTextChanged;
@@ -190,6 +199,11 @@ namespace Robust.Client.UserInterface.Controls
 
         public bool IgnoreNext { get; set; }
 
+        /// <summary>
+        /// If true, all the text in the LineEdit will be automatically selected whenever it is focused.
+        /// </summary>
+        public bool SelectAllOnFocus { get; set; }
+
         private (int start, int length)? _imeData;
 
 
@@ -709,7 +723,7 @@ namespace Robust.Client.UserInterface.Controls
 
                 args.Handle();
             }
-            else
+            else if (!(SelectAllOnFocus && _focusedOnFrame == _timing.CurFrame))
             {
                 _lastClickTime = _timing.RealTime;
                 _lastClickPosition = args.PointerLocation.Position;
@@ -868,6 +882,13 @@ namespace Robust.Client.UserInterface.Controls
             {
                 _clyde.TextInputStart();
             }
+
+            _focusedOnFrame = _timing.CurFrame;
+            if (SelectAllOnFocus)
+            {
+                CursorPosition = _text.Length;
+                SelectionStart = 0;
+            }
         }
 
         protected internal override void KeyboardFocusExited()

Robust.Client/UserInterface/Controls/OSWindow.cs

@@ -1,6 +1,5 @@
 using System;
 using System.ComponentModel;
-using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.IoC;
@@ -33,9 +32,9 @@ namespace Robust.Client.UserInterface.Controls
         public IClydeWindow? Owner { get; set; }
 
         /// <summary>
-        /// Whether the window is currently open.
+        /// Whether the window is created and currently open.
         /// </summary>
-        public bool IsOpen => ClydeWindow != null;
+        public bool IsOpen => ClydeWindow?.IsVisible ?? false;
 
         /// <summary>
         /// The title of the window.
@@ -97,12 +96,13 @@ namespace Robust.Client.UserInterface.Controls
         }
 
         /// <summary>
-        /// Show the window to the user.
+        /// Create the window if not already created.
+        /// This window is not visible by default, call <see cref="Show"/> to display it.
         /// </summary>
-        public void Show()
+        public IClydeWindow Create()
         {
-            if (IsOpen)
-                return;
+            if (ClydeWindow != null)
+                return ClydeWindow;
 
             var parameters = new WindowCreateParameters();
 
@@ -127,6 +127,7 @@ namespace Robust.Client.UserInterface.Controls
             parameters.Styles = WindowStyles;
             parameters.Owner = Owner;
             parameters.StartupLocation = StartupLocation;
+            parameters.Visible = false;
 
             ClydeWindow = _clyde.CreateWindow(parameters);
             ClydeWindow.RequestClosed += OnWindowRequestClosed;
@@ -136,6 +137,19 @@ namespace Robust.Client.UserInterface.Controls
             _root = UserInterfaceManager.CreateWindowRoot(ClydeWindow);
             _root.AddChild(this);
 
+            // Resize the window by our UIScale
+            ClydeWindow.Size = new((int)(ClydeWindow.Size.X * UIScale), (int)(ClydeWindow.Size.Y * UIScale));
+            return ClydeWindow;
+        }
+
+        /// <summary>
+        /// Show the window to the user, creating it if necessary
+        /// </summary>
+        public void Show()
+        {
+            ClydeWindow = Create();
+            ClydeWindow.IsVisible = true;
+
             Shown();
         }
 
@@ -179,7 +193,7 @@ namespace Robust.Client.UserInterface.Controls
 
         private void OnWindowResized(WindowResizedEventArgs obj)
         {
-            SetSize = obj.NewSize;
+            SetSize = obj.NewSize / UIScale;
         }
 
         private void RealClosed()

Robust.Client/UserInterface/Controls/OutputPanel.cs

@@ -127,6 +127,7 @@ namespace Robust.Client.UserInterface.Controls
 
             var style = _getStyleBox();
             var font = _getFont();
+            var lineSeparation = font.GetLineSeparation(UIScale);
             style?.Draw(handle, PixelSizeBox, UIScale);
             var contentBox = _getContentBox();
 
@@ -141,18 +142,26 @@ namespace Robust.Client.UserInterface.Controls
             {
                 if (entryOffset + entry.Height < 0)
                 {
-                    entryOffset += entry.Height + font.GetLineSeparation(UIScale);
+                    // Controls within the entry are the children of this control, which means they are drawn separately
+                    // after this Draw call, so we have to mark them as invisible to prevent them from being drawn.
+                    //
+                    // An alternative option is to ensure that the control position updating logic in entry.Draw is always
+                    // run, and then setting RectClipContent = true to use scissor box testing to handle the controls
+                    // visibility
+                    entry.HideControls();
+                    entryOffset += entry.Height + lineSeparation;
                     continue;
                 }
 
                 if (entryOffset > contentBox.Height)
                 {
-                    break;
+                    entry.HideControls();
+                    continue;
                 }
 
                 entry.Draw(_tagManager, handle, font, contentBox, entryOffset, context, UIScale);
 
-                entryOffset += entry.Height + font.GetLineSeparation(UIScale);
+                entryOffset += entry.Height + lineSeparation;
             }
         }
 

Robust.Client/UserInterface/Controls/RichTextLabel.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Numerics;
 using JetBrains.Annotations;
 using Robust.Client.Graphics;

Robust.Client/UserInterface/Controls/SpinBox.cs

@@ -127,11 +127,11 @@ namespace Robust.Client.UserInterface.Controls
             ClearButtons();
             foreach (var num in leftButtons)
             {
-                AddLeftButton(num, num.ToString());
+                AddLeftButton(num, num.ToString("+#;-#;0"));
             }
             foreach (var num in rightButtons)
             {
-                AddRightButton(num, num.ToString());
+                AddRightButton(num, num.ToString("+#;-#;0"));
             }
         }
 

Robust.Client/UserInterface/Controls/SplitContainer.cs

@@ -268,12 +268,15 @@ namespace Robust.Client.UserInterface.Controls
                 var first = GetChild(0);
                 var second = GetChild(1);
 
-                firstMinSize ??= (Vertical ? first.DesiredSize.Y : first.DesiredSize.X);
-                secondMinSize ??= (Vertical ? second.DesiredSize.Y : second.DesiredSize.X);
-                var size = Vertical ? controlSize.Y : controlSize.X;
+                if (first.IsMeasureValid && second.IsMeasureValid)
+                {
+                    firstMinSize ??= (Vertical ? first.DesiredSize.Y : first.DesiredSize.X);
+                    secondMinSize ??= (Vertical ? second.DesiredSize.Y : second.DesiredSize.X);
+                    var size = Vertical ? controlSize.Y : controlSize.X;
 
-                _splitStart = MathHelper.Clamp(_splitStart, firstMinSize.Value,
-                    size - (secondMinSize.Value + _splitWidth));
+                    _splitStart = MathHelper.Clamp(_splitStart, firstMinSize.Value,
+                        size - (secondMinSize.Value + _splitWidth));
+                }
             }
         }
 

Robust.Client/UserInterface/Controls/SpriteView.cs

@@ -245,7 +245,7 @@ namespace Robust.Client.UserInterface.Controls
 
             var offset = SpriteOffset
                 ? Vector2.Zero
-                : - (-_eyeRotation).RotateVec(sprite.Offset) * new Vector2(1, -1) * EyeManager.PixelsPerMeter;
+                : - (-_eyeRotation).RotateVec(sprite.Offset * _scale) * new Vector2(1, -1) * EyeManager.PixelsPerMeter;
 
             var position = PixelSize / 2 + offset * stretch * UIScale;
             var scale = Scale * UIScale * stretch;

Robust.Client/UserInterface/Controls/TabContainer.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Shared.Input;
@@ -21,6 +22,8 @@ namespace Robust.Client.UserInterface.Controls
 
         private int _currentTab;
         private bool _tabsVisible = true;
+        // The right-most coordinate of each tab header
+        private List<float> _tabRight = new();
 
         public int CurrentTab
         {
@@ -157,11 +160,14 @@ namespace Robust.Client.UserInterface.Controls
 
             var headerOffset = 0f;
 
+            _tabRight.Clear();
+
             // Then, draw the tabs.
             for (var i = 0; i < ChildCount; i++)
             {
                 if (!GetTabVisible(i))
                 {
+                    _tabRight.Add(headerOffset);
                     continue;
                 }
 
@@ -214,6 +220,8 @@ namespace Robust.Client.UserInterface.Controls
                 }
 
                 headerOffset += boxAdvance;
+                // Remember the right-most point of this tab, for testing clicked areas
+                _tabRight.Add(headerOffset);
             }
         }
 
@@ -283,46 +291,17 @@ namespace Robust.Client.UserInterface.Controls
             args.Handle();
 
             var relX = args.RelativePixelPosition.X;
-
-            var font = _getFont();
-            var boxActive = _getTabBoxActive();
-            var boxInactive = _getTabBoxInactive();
-
-            var headerOffset = 0f;
-
+            float tabLeft = 0;
             for (var i = 0; i < ChildCount; i++)
             {
-                if (!GetTabVisible(i))
+                if (relX > tabLeft && relX <= _tabRight[i])
                 {
-                    continue;
-                }
-
-                var title = GetActualTabTitle(i);
-
-                var titleLength = 0;
-                // Get string length.
-                foreach (var rune in title.EnumerateRunes())
-                {
-                    if (!font.TryGetCharMetrics(rune, UIScale, out var metrics))
-                    {
-                        continue;
-                    }
-
-                    titleLength += metrics.Advance;
-                }
-
-                var active = _currentTab == i;
-                var box = active ? boxActive : boxInactive;
-                var boxAdvance = titleLength + (box?.MinimumSize.X ?? 0);
-
-                if (headerOffset < relX && headerOffset + boxAdvance > relX)
-                {
-                    // Got em.
                     CurrentTab = i;
                     return;
                 }
 
-                headerOffset += boxAdvance;
+                // Next tab starts here
+                tabLeft = _tabRight[i];
             }
         }
 

Robust.Client/UserInterface/CustomControls/EntitySpawnWindow.xaml

@@ -13,7 +13,7 @@
         </ScrollContainer>
         <BoxContainer Orientation="Horizontal">
             <Button Name="ReplaceButton" Access="Public" ToggleMode="True" Text="{Loc entity-spawn-window-replace-button-text}"/>
-            <Button Name="EraseButton" Access="Public" ToggleMode="True" Text="{Loc entity-spawn-window-erase-button-text}"/>
+            <Button Name="EraseButton" Access="Public" ToggleMode="True" Text="{Loc window-erase-button-text}"/>
             <OptionButton Name="OverrideMenu" Access="Public" HorizontalExpand="True" ToolTip="{Loc entity-spawn-window-override-menu-tooltip}" />
         </BoxContainer>
         <Label Name="RotationLabel" Access="Public"/>

Robust.Client/UserInterface/CustomControls/SS14Window.cs

@@ -1,10 +0,0 @@
-using System;
-
-namespace Robust.Client.UserInterface.CustomControls;
-
-[Obsolete("Use DefaultWindow instead")]
-[Virtual]
-public class SS14Window : DefaultWindow
-{
-
-}

Robust.Client/UserInterface/CustomControls/TextEditRopeViz.cs

@@ -131,11 +131,6 @@ internal sealed class TextEditRopeViz : OSWindow
                     throw new ArgumentOutOfRangeException(nameof(node));
             }
         }
-
-        static UIBox2 Around(Vector2 vec, float size)
-        {
-            return new UIBox2(vec - new Vector2(size, size), vec + new Vector2(size, size));
-        }
     }
 
     private static Color[] CalcLeafColors()

Robust.Client/UserInterface/CustomControls/TileSpawnWindow.xaml

@@ -1,6 +1,6 @@
 <TileSpawnWindow
     xmlns="https://spacestation14.io"
-    Title="Place Tiles"
+    Title="{Loc tile-spawn-window-title}"
     SetSize="300 300"
     MinSize="300 200">
     <BoxContainer Orientation="Vertical">
@@ -9,5 +9,8 @@
             <Button Name="ClearButton" Access="Public" Text="Clear"/>
         </BoxContainer>
         <ItemList Name="TileList" Access="Public" VerticalExpand="True"/>
+        <BoxContainer Orientation="Horizontal">
+            <Button Name="EraseButton" Access="Public" ToggleMode="True" Text="{Loc window-erase-button-text}"/>
+        </BoxContainer>
     </BoxContainer>
 </TileSpawnWindow>

Robust.Client/UserInterface/RichTextEntry.cs

@@ -118,9 +118,6 @@ namespace Robust.Client.UserInterface
                 if (_tagControls == null || !_tagControls.TryGetValue(nodeIndex, out var control))
                     continue;
 
-                if (ProcessRune(ref this, new Rune(' '), out breakLine))
-                    continue;
-
                 control.Measure(new Vector2(Width, Height));
 
                 var desiredSize = control.DesiredPixelSize;
@@ -167,6 +164,16 @@ namespace Robust.Client.UserInterface
             }
         }
 
+        internal readonly void HideControls()
+        {
+            if (_tagControls == null)
+                return;
+            foreach (var control in _tagControls.Values)
+            {
+                control.Visible = false;
+            }
+        }
+
         public readonly void Draw(
             MarkupTagManager tagManager,
             DrawingHandleScreen handle,
@@ -216,8 +223,11 @@ namespace Robust.Client.UserInterface
                 if (_tagControls == null || !_tagControls.TryGetValue(nodeIndex, out var control))
                     continue;
 
-                var invertedScale = 1f / uiScale;
+                // Controls may have been previously hidden via HideControls due to being "out-of frame".
+                // If this ever gets replaced with RectClipContents / scissor box testing, this can be removed.
+                control.Visible = true;
 
+                var invertedScale = 1f / uiScale;
                 control.Position = new Vector2(baseLine.X * invertedScale, (baseLine.Y - defaultFont.GetAscent(uiScale)) * invertedScale);
                 control.Measure(new Vector2(Width, Height));
                 var advanceX = control.DesiredPixelSize.X;

Robust.Client/UserInterface/UserInterfaceManager.Input.cs

@@ -35,6 +35,7 @@ internal partial class UserInterfaceManager
                 return;
             _controlFocused?.ControlFocusExited();
             _controlFocused = value;
+            _needUpdateActiveCursor = true;
         }
     }
 
@@ -148,7 +149,7 @@ internal partial class UserInterfaceManager
         var newHovered = MouseGetControl(mouseMoveEventArgs.Position);
         SetHovered(newHovered);
 
-        var target = ControlFocused ?? newHovered;
+        var target = ControlFocused ?? CurrentlyHovered;
         if (target != null)
         {
             var pos = mouseMoveEventArgs.Position.Position;
@@ -164,7 +165,7 @@ internal partial class UserInterfaceManager
 
     public void UpdateHovered()
     {
-        var ctrl =  MouseGetControl(_inputManager.MouseScreenPosition);
+        var ctrl = MouseGetControl(_inputManager.MouseScreenPosition);
         SetHovered(ctrl);
     }
 

Robust.Client/UserInterface/UserInterfaceManager.Roots.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Client.UserInterface.Controls;
+using Robust.Shared;
 using Robust.Shared.Map;
 using Robust.Shared.Utility;
 
@@ -28,10 +29,11 @@ internal sealed partial class UserInterfaceManager
         {
             MouseFilter = Control.MouseFilterMode.Ignore,
             HorizontalAlignment = Control.HAlignment.Stretch,
-            VerticalAlignment = Control.VAlignment.Stretch,
-            UIScaleSet = window.ContentScale.X
+            VerticalAlignment = Control.VAlignment.Stretch
         };
 
+        newRoot.UIScaleSet = CalculateAutoScale(newRoot);
+
         _roots.Add(newRoot);
         _windowsToRoot.Add(window.Id, newRoot);
 

Robust.Client/UserInterface/UserInterfaceManager.cs

@@ -215,6 +215,9 @@ namespace Robust.Client.UserInterface
         {
             using (_prof.Group("Update"))
             {
+                // Update hovered. Can't rely upon mouse movement due to New controls potentially coming up.
+                UpdateHovered();
+
                 foreach (var root in _roots)
                 {
                     CheckRootUIScaleUpdate(root);

Robust.Client/UserInterface/XAML/Proxy/XamlHotReloadManager.cs

@@ -58,16 +58,16 @@ internal sealed class XamlHotReloadManager : IXamlHotReloadManager
         var watcher = new FileSystemWatcher(location)
         {
             IncludeSubdirectories = true,
-            NotifyFilter = NotifyFilters.LastWrite,
+            NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName,
         };
 
-        watcher.Changed += (_, args) =>
+        void OnWatcherEvent(object sender, FileSystemEventArgs args)
         {
             switch (args.ChangeType)
             {
-                case WatcherChangeTypes.Renamed:
                 case WatcherChangeTypes.Deleted:
                     return;
+                case WatcherChangeTypes.Renamed:
                 case WatcherChangeTypes.Created:
                 case WatcherChangeTypes.Changed:
                 case WatcherChangeTypes.All:
@@ -98,7 +98,10 @@ internal sealed class XamlHotReloadManager : IXamlHotReloadManager
 
                 _xamlProxyManager.SetImplementation(resourceFileName, newText);
             });
-        };
+        }
+
+        watcher.Changed += OnWatcherEvent;
+        watcher.Renamed += OnWatcherEvent;
         watcher.EnableRaisingEvents = true;
         return watcher;
     }

Robust.Client/Utility/UserDataDir.cs

@@ -1,7 +1,6 @@
 using System;
 using System.IO;
 using JetBrains.Annotations;
-using Robust.Shared.IoC;
 
 namespace Robust.Client.Utility
 {
@@ -9,6 +8,12 @@ namespace Robust.Client.Utility
     {
         [Pure]
         public static string GetUserDataDir(IGameControllerInternal gameController)
+        {
+            return Path.Combine(GetRootUserDataDir(gameController), "data");
+        }
+
+        [Pure]
+        public static string GetRootUserDataDir(IGameControllerInternal gameController)
         {
             string appDataDir;
 
@@ -30,8 +35,7 @@ namespace Robust.Client.Utility
             appDataDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
 #endif
 
-            return Path.Combine(appDataDir, gameController.Options.UserDataDirectoryName, "data");
+            return Path.Combine(appDataDir, gameController.Options.UserDataDirectoryName);
         }
-
     }
 }

Robust.Client/ViewVariables/Traits/ViewVariablesTraitMembers.cs

@@ -1,4 +1,5 @@
-using System.Numerics;
+using System.Collections.Generic;
+using System.Numerics;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.ViewVariables.Instances;
@@ -36,7 +37,7 @@ namespace Robust.Client.ViewVariables.Traits
 
         public override async void Refresh()
         {
-            _memberList.DisposeAllChildren();
+            List<Control> replacementControls = [];
 
             if (Instance.Object != null)
             {
@@ -51,7 +52,7 @@ namespace Robust.Client.ViewVariables.Traits
 
                     foreach (var control in group)
                     {
-                        _memberList.AddChild(control);
+                        replacementControls.Add(control);
                     }
                 }
             }
@@ -82,10 +83,16 @@ namespace Robust.Client.ViewVariables.Traits
                                 selectorChain, o, r);
                         };
 
-                        _memberList.AddChild(propertyEdit);
+                        replacementControls.Add(propertyEdit);
                     }
                 }
             }
+
+            _memberList.DisposeAllChildren();
+            foreach (var item in replacementControls)
+            {
+                _memberList.AddChild(item);
+            }
         }
 
         internal static void CreateMemberGroupHeader(ref bool first, string groupName, Control container)

Robust.Roslyn.Shared/Diagnostics.cs

@@ -35,6 +35,7 @@ public static class Diagnostics
     public const string IdDataFieldNoVVReadWrite = "RA0029";
     public const string IdUseNonGenericVariant = "RA0030";
     public const string IdPreferOtherType = "RA0031";
+    public const string IdDuplicateDependency = "RA0032";
 
     public static SuppressionDescriptor MeansImplicitAssignment =>
         new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");

Robust.Server/Audio/AudioSystem.cs

@@ -66,32 +66,26 @@ public sealed partial class AudioSystem : SharedAudioSystem
 
     private void AddAudioFilter(EntityUid uid, AudioComponent component, Filter filter)
     {
-        var count = filter.Count;
+        DebugTools.Assert(component.IncludedEntities == null);
+        component.IncludedEntities = new();
 
-        if (count == 0)
+        if (filter.Count == 0)
             return;
 
         _pvs.AddSessionOverrides(uid, filter);
-
-        var ents = new HashSet<EntityUid>(count);
-
         foreach (var session in filter.Recipients)
         {
-            var ent = session.AttachedEntity;
-
-            if (ent == null)
-                continue;
-
-            ents.Add(ent.Value);
+            if (session.AttachedEntity is {} ent)
+                component.IncludedEntities.Add(ent);
         }
-
-        DebugTools.Assert(component.IncludedEntities == null);
-        component.IncludedEntities = ents;
     }
 
     /// <inheritdoc />
     public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string? filename, Filter playerFilter, bool recordReplay, AudioParams? audioParams = null)
     {
+        if (string.IsNullOrEmpty(filename))
+            return null;
+
         var entity = SetupAudio(filename, audioParams);
         AddAudioFilter(entity, entity.Comp, playerFilter);
         entity.Comp.Global = true;
@@ -175,6 +169,17 @@ public sealed partial class AudioSystem : SharedAudioSystem
         return (entity, entity.Comp);
     }
 
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayLocal(
+        SoundSpecifier? sound,
+        EntityUid source,
+        EntityUid? soundInitiator,
+        AudioParams? audioParams = null
+    )
+    {
+        return null;
+    }
+
     /// <inheritdoc />
     public override (EntityUid Entity, AudioComponent Component)? PlayPredicted(SoundSpecifier? sound, EntityUid source, EntityUid? user, AudioParams? audioParams = null)
     {

Robust.Server/BaseServer.cs

@@ -86,7 +86,7 @@ namespace Robust.Server
         [Dependency] private readonly ITaskManager _taskManager = default!;
         [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
         [Dependency] private readonly IModLoaderInternal _modLoader = default!;
-        [Dependency] private readonly IWatchdogApi _watchdogApi = default!;
+        [Dependency] private readonly IWatchdogApiInternal _watchdogApi = default!;
         [Dependency] private readonly HubManager _hubManager = default!;
         [Dependency] private readonly IScriptHost _scriptHost = default!;
         [Dependency] private readonly IMetricsManagerInternal _metricsManager = default!;
@@ -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;
@@ -566,7 +566,7 @@ namespace Robust.Server
             // Don't start the main loop. This only works if a reason is passed to Shutdown(...)
             if (_shutdownReason != null)
             {
-                _logger.Fatal("Shutdown has been requested before the main loop has been started, complying.");
+                _logger.Fatal("Shutdown has been requested before the main loop has been started, complying. Reason: {0}", _shutdownReason);
             }
             else _mainLoop.Run();
 

Robust.Server/Console/Commands/TestbedCommand.cs

@@ -1,335 +0,0 @@
-// MIT License
-
-// Copyright (c) 2019 Erin Catto
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-
-using System;
-using System.Numerics;
-using Robust.Server.Player;
-using Robust.Shared.Console;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Collision.Shapes;
-using Robust.Shared.Physics.Components;
-using Robust.Shared.Physics.Controllers;
-using Robust.Shared.Physics.Dynamics;
-using Robust.Shared.Physics.Dynamics.Joints;
-using Robust.Shared.Physics.Systems;
-using Robust.Shared.Timing;
-
-namespace Robust.Server.Console.Commands
-{
-    /*
-     * I didn't use blueprints because this is way easier to iterate upon as I can shit out testbed upon testbed on new maps
-     * and never have to leave my debugger.
-     */
-
-    /// <summary>
-    ///     Copies of Box2D's physics testbed for debugging.
-    /// </summary>
-    public sealed class TestbedCommand : LocalizedCommands
-    {
-        [Dependency] private readonly IEntityManager _ent = default!;
-        [Dependency] private readonly IMapManager _map = default!;
-
-        public override string Command => "testbed";
-
-        public override void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            if (args.Length != 2)
-            {
-                shell.WriteError("Require 2 args for testbed!");
-                return;
-            }
-
-            if (!int.TryParse(args[0], out var mapInt))
-            {
-                shell.WriteError($"Unable to parse map {args[0]}");
-                return;
-            }
-
-            var mapId = new MapId(mapInt);
-            if (!_map.MapExists(mapId))
-            {
-                shell.WriteError($"map {args[0]} does not exist");
-                return;
-            }
-
-            if (shell.Player == null)
-            {
-                shell.WriteError("No player found");
-                return;
-            }
-
-            Action testbed;
-            SetupPlayer(mapId, shell);
-
-            switch (args[1])
-            {
-                case "boxstack":
-                    testbed = () => CreateBoxStack(mapId);
-                    break;
-                case "circlestack":
-                    testbed = () => CreateCircleStack(mapId);
-                    break;
-                case "pyramid":
-                    testbed = () => CreatePyramid(mapId);
-                    break;
-                case "tumbler":
-                    testbed = () => CreateTumbler(mapId);
-                    break;
-                default:
-                    shell.WriteError($"testbed {args[0]} not found!");
-                    return;
-            }
-
-            Timer.Spawn(1000, () =>
-            {
-                if (!_map.MapExists(mapId)) return;
-                testbed();
-            });
-
-            shell.WriteLine($"Testbed on map {mapId}");
-        }
-
-        private void SetupPlayer(MapId mapId, IConsoleShell shell)
-        {
-            _map.SetMapPaused(mapId, false);
-            var mapUid = _map.GetMapEntityIdOrThrow(mapId);
-            _ent.System<Gravity2DController>().SetGravity(mapUid, new Vector2(0, -9.8f));
-
-            shell.ExecuteCommand("aghost");
-            shell.ExecuteCommand($"tp 0 0 {mapId}");
-            shell.RemoteExecuteCommand($"physics shapes");
-
-            return;
-        }
-
-        private void CreateBoxStack(MapId mapId)
-        {
-            var physics = _ent.System<SharedPhysicsSystem>();
-            var fixtures = _ent.System<FixtureSystem>();
-
-            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
-            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
-
-            var horizontal = new EdgeShape(new Vector2(-40, 0), new Vector2(40, 0));
-            fixtures.CreateFixture(groundUid, "fix1", new Fixture(horizontal, 2, 2, true), body: ground);
-
-            var vertical = new EdgeShape(new Vector2(10, 0), new Vector2(10, 10));
-            fixtures.CreateFixture(groundUid, "fix2", new Fixture(vertical, 2, 2, true), body: ground);
-
-            var xs = new[]
-            {
-                0.0f, -10.0f, -5.0f, 5.0f, 10.0f
-            };
-
-            var columnCount = 1;
-            var rowCount = 15;
-            PolygonShape shape;
-
-            for (var j = 0; j < columnCount; j++)
-            {
-                for (var i = 0; i < rowCount; i++)
-                {
-                    var x = 0.0f;
-
-                    var boxUid = _ent.SpawnEntity(null,
-                        new MapCoordinates(new Vector2(xs[j] + x, 0.55f + 1.1f * i), mapId));
-                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
-
-                    physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
-
-                    shape = new PolygonShape();
-                    shape.SetAsBox(0.5f, 0.5f);
-                    physics.SetFixedRotation(boxUid, false, body: box);
-                    fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true), body: box);
-
-                    physics.WakeBody(boxUid, body: box);
-                }
-            }
-
-            physics.WakeBody(groundUid, body: ground);
-        }
-
-        private void CreateCircleStack(MapId mapId)
-        {
-            var physics = _ent.System<SharedPhysicsSystem>();
-            var fixtures = _ent.System<FixtureSystem>();
-
-            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
-            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
-
-            var horizontal = new EdgeShape(new Vector2(-40, 0), new Vector2(40, 0));
-            fixtures.CreateFixture(groundUid, "fix1", new Fixture(horizontal, 2, 2, true), body: ground);
-
-            var vertical = new EdgeShape(new Vector2(20, 0), new Vector2(20, 20));
-            fixtures.CreateFixture(groundUid, "fix2", new Fixture(vertical, 2, 2, true), body: ground);
-
-            var xs = new[]
-            {
-                0.0f, -10.0f, -5.0f, 5.0f, 10.0f
-            };
-
-            var columnCount = 1;
-            var rowCount = 15;
-            PhysShapeCircle shape;
-
-            for (var j = 0; j < columnCount; j++)
-            {
-                for (var i = 0; i < rowCount; i++)
-                {
-                    var x = 0.0f;
-
-                    var boxUid = _ent.SpawnEntity(null,
-                        new MapCoordinates(new Vector2(xs[j] + x, 0.55f + 2.1f * i), mapId));
-                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
-
-                    physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
-                    shape = new PhysShapeCircle(0.5f);
-                    physics.SetFixedRotation(boxUid, false, body: box);
-                    // TODO: Need to detect shape and work out if we need to use fixedrotation
-
-                    fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true, 5f));
-                    physics.WakeBody(boxUid, body: box);
-                }
-            }
-
-            physics.WakeBody(groundUid, body: ground);
-        }
-
-        private void CreatePyramid(MapId mapId)
-        {
-            const byte count = 20;
-
-            // Setup ground
-            var physics = _ent.System<SharedPhysicsSystem>();
-            var fixtures = _ent.System<FixtureSystem>();
-            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
-            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
-
-            var horizontal = new EdgeShape(new Vector2(40, 0), new Vector2(-40, 0));
-            fixtures.CreateFixture(groundUid, "fix1", new Fixture(horizontal, 2, 2, true), body: ground);
-            physics.WakeBody(groundUid, body: ground);
-
-            // Setup boxes
-            float a = 0.5f;
-            PolygonShape shape = new();
-            shape.SetAsBox(a, a);
-
-            var x = new Vector2(-7.0f, 0.75f);
-            Vector2 y;
-            Vector2 deltaX = new Vector2(0.5625f, 1.25f);
-            Vector2 deltaY = new Vector2(1.125f, 0.0f);
-
-            for (var i = 0; i < count; ++i)
-            {
-                y = x;
-
-                for (var j = i; j < count; ++j)
-                {
-                    var boxUid = _ent.SpawnEntity(null, new MapCoordinates(y, mapId));
-                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
-                    physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
-
-                    fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true, 5f), body: box);
-                    y += deltaY;
-
-                    physics.WakeBody(boxUid, body: box);
-                }
-
-                x += deltaX;
-            }
-        }
-
-        private void CreateTumbler(MapId mapId)
-        {
-            var physics = _ent.System<SharedPhysicsSystem>();
-            var fixtures = _ent.System<FixtureSystem>();
-            var joints = _ent.System<SharedJointSystem>();
-
-            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0f, 0f, mapId));
-            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
-            // Due to lookup changes fixtureless bodies are invalid, so
-            var cShape = new PhysShapeCircle(1f);
-            fixtures.CreateFixture(groundUid, "fix1", new Fixture(cShape, 0, 0, false));
-
-            var bodyUid = _ent.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
-            var body = _ent.AddComponent<PhysicsComponent>(bodyUid);
-
-            physics.SetBodyType(bodyUid, BodyType.Dynamic, body: body);
-            physics.SetSleepingAllowed(bodyUid, body, false);
-            physics.SetFixedRotation(bodyUid, false, body: body);
-
-
-            // TODO: Box2D just deref, bleh shape structs someday
-            var shape1 = new PolygonShape();
-            shape1.SetAsBox(0.5f, 10.0f, new Vector2(10.0f, 0.0f), 0.0f);
-            fixtures.CreateFixture(bodyUid, "fix1", new Fixture(shape1, 2, 0, true, 20f));
-
-            var shape2 = new PolygonShape();
-            shape2.SetAsBox(0.5f, 10.0f, new Vector2(-10.0f, 0.0f), 0f);
-            fixtures.CreateFixture(bodyUid, "fix2", new Fixture(shape2, 2, 0, true, 20f));
-
-            var shape3 = new PolygonShape();
-            shape3.SetAsBox(10.0f, 0.5f, new Vector2(0.0f, 10.0f), 0f);
-            fixtures.CreateFixture(bodyUid, "fix3", new Fixture(shape3, 2, 0, true, 20f));
-
-            var shape4 = new PolygonShape();
-            shape4.SetAsBox(10.0f, 0.5f, new Vector2(0.0f, -10.0f), 0f);
-            fixtures.CreateFixture(bodyUid, "fix4", new Fixture(shape4, 2, 0, true, 20f));
-
-            physics.WakeBody(groundUid, body: ground);
-            physics.WakeBody(bodyUid, body: body);
-            var revolute = joints.CreateRevoluteJoint(groundUid, bodyUid);
-            revolute.LocalAnchorA = new Vector2(0f, 10f);
-            revolute.LocalAnchorB = new Vector2(0f, 0f);
-            revolute.ReferenceAngle = 0f;
-            revolute.MotorSpeed = 0.05f * MathF.PI;
-            revolute.MaxMotorTorque = 100000000f;
-            revolute.EnableMotor = true;
-
-            // Box2D has this as 800 which is jesus christo.
-            // Wouldn't recommend higher than 100 in debug and higher than 300 on release unless
-            // you really want a profile.
-            var count = 300;
-
-            for (var i = 0; i < count; i++)
-            {
-                Timer.Spawn(i * 20, () =>
-                {
-                    if (!_map.MapExists(mapId)) return;
-                    var boxUid = _ent.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
-                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
-                    physics.SetBodyType(boxUid, BodyType.Dynamic, body: box);
-                    physics.SetFixedRotation(boxUid, false, body: box);
-                    var shape = new PolygonShape();
-                    shape.SetAsBox(0.125f, 0.125f);
-                    fixtures.CreateFixture(boxUid, "fix1", new Fixture(shape, 2, 2, true, 0.0625f), body: box);
-                    physics.WakeBody(boxUid, body: box);
-                });
-            }
-        }
-    }
-}

Robust.Server/Console/ServerConsoleHost.cs

@@ -162,7 +162,6 @@ namespace Robust.Server.Console
         {
             var message = new MsgConCmdReg();
 
-            var counter = 0;
             var toolshedCommands = _toolshed.DefaultEnvironment.AllCommands().ToArray();
             message.Commands = new List<MsgConCmdReg.Command>(AvailableCommands.Count + toolshedCommands.Length);
             var commands = new HashSet<string>();

Robust.Server/Console/SystemConsoleManager.cs

@@ -174,7 +174,8 @@ namespace Robust.Server.Console
             while (Con.KeyAvailable)
             {
                 ConsoleKeyInfo key = Con.ReadKey(true);
-                Con.SetCursorPosition(0, Con.CursorTop);
+                if (Con.WindowWidth > 0)
+               		Con.SetCursorPosition(0, Con.CursorTop);
                 if (!Char.IsControl(key.KeyChar))
                 {
                     currentBuffer = currentBuffer.Insert(internalCursor++, key.KeyChar.ToString());
@@ -277,6 +278,7 @@ namespace Robust.Server.Console
 
         public void DrawCommandLine()
         {
+            if (Con.WindowWidth <= 0) return;
             ClearCurrentLine();
             Con.SetCursorPosition(0, Con.CursorTop);
             Con.Write("> " + currentBuffer);

Robust.Server/GameObjects/EntitySystems/MapSystem.cs

@@ -53,20 +53,21 @@ namespace Robust.Server.GameObjects
                 var query = AllEntityQuery<MapGridComponent>();
                 while (query.MoveNext(out var uid, out var grid))
                 {
-                    if (!GridEmpty(grid)) continue;
+                    if (!GridEmpty((uid, grid)))
+                        continue;
                     toDelete.Add(uid);
                 }
 
                 foreach (var uid in toDelete)
                 {
-                    MapManager.DeleteGrid(uid);
+                    EntityManager.DeleteEntity(uid);
                 }
             }
         }
 
-        private bool GridEmpty(MapGridComponent grid)
+        private bool GridEmpty(Entity<MapGridComponent> entity)
         {
-            return !(grid.GetAllTiles().Any());
+            return !(GetAllTiles(entity, entity).Any());
         }
 
         private void HandleGridEmpty(EntityUid uid, MapGridComponent component, EmptyGridEvent args)
@@ -74,7 +75,7 @@ namespace Robust.Server.GameObjects
             if (!_deleteEmptyGrids || TerminatingOrDeleted(uid) || HasComp<MapComponent>(uid))
                 return;
 
-            MapManager.DeleteGrid(args.GridId);
+            EntityManager.DeleteEntity(args.GridId);
         }
     }
 }

Robust.Server/GameObjects/ServerEntityManager.cs

@@ -81,6 +81,7 @@ namespace Robust.Server.GameObjects
             InitializeEntity(entity, meta);
         }
 
+        [Obsolete("Use StartEntity")]
         void IServerEntityManagerInternal.FinishEntityStartup(EntityUid entity)
         {
             StartEntity(entity);

Robust.Server/GameStates/PvsChunk.cs

@@ -141,9 +141,10 @@ internal sealed class PvsChunk
         {
             // TODO ARCH multi-component queries
             if (!meta.TryGetComponent(child, out var childMeta)
-                || !xform.TryGetComponent(child, out var childXform))
+                || !xform.TryGetComponent(child, out var childXform)
+                || childMeta.EntityLifeStage >= EntityLifeStage.Terminating)
             {
-                DebugTools.Assert($"PVS chunk contains a deleted entity: {child}");
+                DebugTools.Assert($"PVS chunk contains a delete or terminating entity: {child}");
                 MarkDirty();
                 return false;
             }
@@ -188,9 +189,10 @@ internal sealed class PvsChunk
                 {
                     // TODO ARCH multi-component queries
                     if (!meta.TryGetComponent(child, out var childMeta)
-                        || !xform.TryGetComponent(child, out var childXform))
+                        || !xform.TryGetComponent(child, out var childXform)
+                        || childMeta.EntityLifeStage >= EntityLifeStage.Terminating)
                     {
-                        DebugTools.Assert($"PVS chunk contains a deleted entity: {child}");
+                        DebugTools.Assert($"PVS chunk contains a delete or terminating entity: {child}");
                         MarkDirty();
                         return false;
                     }

Robust.Server/GameStates/PvsData.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -190,6 +191,15 @@ internal struct PvsMetadata
     private byte Pad0;
     public uint Marker;
 #endif
+
+    [Conditional("DEBUG")]
+    public void Validate(MetaDataComponent comp)
+    {
+        DebugTools.AssertEqual(NetEntity, comp.NetEntity);
+        DebugTools.AssertEqual(VisMask, comp.VisibilityMask);
+        DebugTools.AssertEqual(LifeStage, comp.EntityLifeStage);
+        DebugTools.Assert(LastModifiedTick == comp.EntityLastModifiedTick || LastModifiedTick.Value == 0);
+    }
 }
 
 [StructLayout(LayoutKind.Sequential, Size = 16)]

Robust.Server/GameStates/PvsOverrideSystem.cs

@@ -250,13 +250,6 @@ public sealed class PvsOverrideSystem : EntitySystem
             AddSessionOverride(uid.Value, session);
     }
 
-    [Obsolete("Use variant that takes in an EntityUid")]
-    public void AddSessionOverrides(NetEntity entity, Filter filter, bool removeExistingOverride = true)
-    {
-        if (TryGetEntity(entity, out var uid))
-            AddSessionOverrides(uid.Value, filter);
-    }
-
     [Obsolete("Don't use this, clear specific overrides")]
     public void ClearOverride(NetEntity entity)
     {

Robust.Server/GameStates/PvsSystem.Chunks.cs

@@ -184,10 +184,9 @@ internal sealed partial class PvsSystem
             return;
         }
 
-        int i = 0;
+        var i = 0;
         if (session.AttachedEntity is { } local)
         {
-            DebugTools.Assert(!session.ViewSubscriptions.Contains(local));
             Array.Resize(ref pvsSession.Viewers, session.ViewSubscriptions.Count + 1);
             pvsSession.Viewers[i++] = (local, Transform(local), _eyeQuery.CompOrNull(local));
         }
@@ -198,7 +197,8 @@ internal sealed partial class PvsSystem
 
         foreach (var ent in session.ViewSubscriptions)
         {
-            pvsSession.Viewers[i++] =  (ent, Transform(ent), _eyeQuery.CompOrNull(ent));
+            if (ent != session.AttachedEntity)
+                pvsSession.Viewers[i++] =  (ent, Transform(ent), _eyeQuery.CompOrNull(ent));
         }
     }
 
@@ -232,6 +232,7 @@ internal sealed partial class PvsSystem
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     private void AddEntityToChunk(EntityUid uid, MetaDataComponent meta, PvsChunkLocation location)
     {
+        DebugTools.Assert(meta.EntityLifeStage < EntityLifeStage.Terminating);
         ref var chunk = ref CollectionsMarshal.GetValueRefOrAddDefault(_chunks, location, out var existing);
         if (!existing)
         {
@@ -240,7 +241,7 @@ internal sealed partial class PvsSystem
             {
                 chunk.Initialize(location, _metaQuery, _xformQuery);
             }
-            catch (Exception e)
+            catch (Exception)
             {
                 _chunks.Remove(location);
                 throw;

Robust.Server/GameStates/PvsSystem.DataStorage.cs

@@ -245,8 +245,6 @@ internal sealed partial class PvsSystem
 
     private void OnEntityAdded(Entity<MetaDataComponent> entity)
     {
-        DebugTools.Assert(entity.Comp.PvsData.Index == default);
-
         AssignEntityPointer(entity.Comp);
     }
 
@@ -255,6 +253,7 @@ internal sealed partial class PvsSystem
     /// </summary>
     private void AssignEntityPointer(MetaDataComponent meta)
     {
+        DebugTools.Assert(meta.PvsData == PvsIndex.Invalid);
         if (_dataFreeListHead == PvsIndex.Invalid)
         {
             ExpandEntityCapacity();
@@ -267,8 +266,6 @@ internal sealed partial class PvsSystem
         ref var freeLink = ref Unsafe.As<PvsMetadata, PvsMetadataFreeLink>(ref metadata);
         _dataFreeListHead = freeLink.NextFree;
 
-        // TODO: re-introduce this assert.
-        // DebugTools.AssertEqual(((PvsMetadata*) ptr)->NetEntity, NetEntity.Invalid);
         DebugTools.AssertNotEqual(meta.NetEntity, NetEntity.Invalid);
 
         meta.PvsData = index;
@@ -287,9 +284,9 @@ internal sealed partial class PvsSystem
     private void OnEntityDeleted(Entity<MetaDataComponent> entity)
     {
         var ptr = entity.Comp.PvsData;
-        entity.Comp.PvsData = default;
+        entity.Comp.PvsData = PvsIndex.Invalid;
 
-        if (ptr == default)
+        if (ptr == PvsIndex.Invalid)
             return;
 
         _incomingReturns.Add(ptr);
@@ -300,7 +297,8 @@ internal sealed partial class PvsSystem
     /// </summary>
     private void AfterEntityFlush()
     {
-        DebugTools.Assert(EntityManager.EntityCount == 0);
+        if (EntityManager.EntityCount > 0)
+            throw new Exception("Cannot reset PVS data without first deleting all entities.");
 
         ClearPvsData();
         ShrinkDataMemory();

Robust.Server/GameStates/PvsSystem.Dirty.cs

@@ -49,7 +49,7 @@ namespace Robust.Server.GameStates
 
         private void OnEntityDirty(Entity<MetaDataComponent> uid)
         {
-            if (uid.Comp.PvsData != default)
+            if (uid.Comp.PvsData != PvsIndex.Invalid)
             {
                 ref var meta = ref _metadataMemory.GetRef(uid.Comp.PvsData.Index);
                 meta.LastModifiedTick = uid.Comp.EntityLastModifiedTick;

Robust.Server/GameStates/PvsSystem.Entity.cs

@@ -107,7 +107,7 @@ internal sealed partial class PvsSystem
 
     internal void SyncMetadata(MetaDataComponent meta)
     {
-        if (meta.PvsData == default)
+        if (meta.PvsData == PvsIndex.Invalid)
             return;
 
         ref var ptr = ref _metadataMemory.GetRef(meta.PvsData.Index);

Robust.Server/GameStates/PvsSystem.Overrides.cs

@@ -3,6 +3,7 @@ using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 
 namespace Robust.Server.GameStates;
 
@@ -25,6 +26,7 @@ internal sealed partial class PvsSystem
         foreach (ref var ent in CollectionsMarshal.AsSpan(_cachedGlobalOverride))
         {
             ref var meta = ref _metadataMemory.GetRef(ent.Ptr.Index);
+            meta.Validate(ent.Meta);
             if ((mask & meta.VisMask) == meta.VisMask)
                 AddEntity(session, ref ent, ref meta, fromTick);
         }
@@ -51,6 +53,7 @@ internal sealed partial class PvsSystem
         foreach (ref var ent in CollectionsMarshal.AsSpan(_cachedForceOverride))
         {
             ref var meta = ref _metadataMemory.GetRef(ent.Ptr.Index);
+            meta.Validate(ent.Meta);
             if ((mask & meta.VisMask) == meta.VisMask)
                 AddEntity(session, ref ent, ref meta, fromTick);
         }

Robust.Server/GameStates/PvsSystem.ToSendSet.cs

@@ -57,6 +57,7 @@ internal sealed partial class PvsSystem
         foreach (ref var ent in span)
         {
             ref var meta = ref _metadataMemory.GetRef(ent.Ptr.Index);
+            meta.Validate(ent.Meta);
             if ((mask & meta.VisMask) == meta.VisMask)
                 AddEntity(session, ref ent, ref meta, fromTick);
         }
@@ -78,8 +79,7 @@ internal sealed partial class PvsSystem
 
         if (meta.LifeStage >= EntityLifeStage.Terminating)
         {
-            Log.Error($"Attempted to send deleted entity: {ToPrettyString(ent.Uid)}, lifestage is {meta.LifeStage}.\n{Environment.StackTrace}");
-            EntityManager.QueueDeleteEntity(ent.Uid);
+            Log.Error($"Attempted to send deleted entity: {ToPrettyString(ent.Uid)}, Meta lifestage: {ent.Meta.EntityLifeStage}, PVS lifestage: {meta.LifeStage}.\n{Environment.StackTrace}");
             return;
         }
 

Robust.Server/GameStates/PvsSystem.cs

@@ -129,7 +129,6 @@ internal sealed partial class PvsSystem : EntitySystem
 
         SubscribeLocalEvent<MapChangedEvent>(OnMapChanged);
         SubscribeLocalEvent<GridRemovalEvent>(OnGridRemoved);
-        SubscribeLocalEvent<EntityTerminatingEvent>(OnEntityTerminating);
         SubscribeLocalEvent<TransformComponent, TransformStartupEvent>(OnTransformStartup);
 
         _playerManager.PlayerStatusChanged += OnPlayerStatusChanged;
@@ -137,6 +136,7 @@ internal sealed partial class PvsSystem : EntitySystem
         EntityManager.EntityAdded += OnEntityAdded;
         EntityManager.EntityDeleted += OnEntityDeleted;
         EntityManager.AfterEntityFlush += AfterEntityFlush;
+        EntityManager.BeforeEntityTerminating += OnEntityTerminating;
 
         Subs.CVar(_configManager, CVars.NetPVS, SetPvs, true);
         Subs.CVar(_configManager, CVars.NetMaxUpdateRange, OnViewsizeChanged, true);
@@ -162,6 +162,7 @@ internal sealed partial class PvsSystem : EntitySystem
         EntityManager.EntityAdded -= OnEntityAdded;
         EntityManager.EntityDeleted -= OnEntityDeleted;
         EntityManager.AfterEntityFlush -= AfterEntityFlush;
+        EntityManager.BeforeEntityTerminating -= OnEntityTerminating;
 
         _parallelMgr.ParallelCountChanged -= ResetParallelism;
 

Robust.Server/Physics/GridFixtureSystem.cs

@@ -285,7 +285,7 @@ namespace Robust.Server.Physics
                         foreach (var index in node.Indices)
                         {
                             var tilePos = offset + index;
-                            tileData.Add((tilePos, oldGrid.GetTileRef(tilePos).Tile));
+                            tileData.Add((tilePos, _maps.GetTileRef(oldGridUid, oldGrid, tilePos).Tile));
                         }
                     }
 
@@ -355,7 +355,7 @@ namespace Robust.Server.Physics
                     }
 
                     // Set tiles on old grid
-                    oldGrid.SetTiles(tileData);
+                    _maps.SetTiles(oldGridUid, oldGrid, tileData);
                     GenerateSplitNodes(newGridUid, newGrid);
                     SendNodeDebug(newGridUid);
                 }
@@ -388,7 +388,7 @@ namespace Robust.Server.Physics
 
         private void GenerateSplitNodes(EntityUid gridUid, MapGridComponent grid)
         {
-            foreach (var chunk in grid.GetMapChunks().Values)
+            foreach (var chunk in _maps.GetMapChunks(gridUid, grid).Values)
             {
                 var group = CreateNodes(gridUid, grid, chunk);
                 _nodes[gridUid].Add(chunk.Indices, group);
@@ -479,7 +479,7 @@ namespace Robust.Server.Physics
                     if (index.X == 0)
                     {
                         // Check West
-                        if (grid.TryGetChunk(new Vector2i(chunk.Indices.X - 1, chunk.Indices.Y), out neighborChunk) &&
+                        if (_maps.TryGetChunk(gridEuid, grid, new Vector2i(chunk.Indices.X - 1, chunk.Indices.Y), out neighborChunk) &&
                             TryGetNode(gridEuid, neighborChunk, new Vector2i(chunk.ChunkSize - 1, index.Y), out neighborNode))
                         {
                             chunkNode.Neighbors.Add(neighborNode);
@@ -490,7 +490,7 @@ namespace Robust.Server.Physics
                     if (index.Y == 0)
                     {
                         // Check South
-                        if (grid.TryGetChunk(new Vector2i(chunk.Indices.X, chunk.Indices.Y - 1), out neighborChunk) &&
+                        if (_maps.TryGetChunk(gridEuid, grid, new Vector2i(chunk.Indices.X, chunk.Indices.Y - 1), out neighborChunk) &&
                             TryGetNode(gridEuid, neighborChunk, new Vector2i(index.X, chunk.ChunkSize - 1), out neighborNode))
                         {
                             chunkNode.Neighbors.Add(neighborNode);
@@ -501,7 +501,7 @@ namespace Robust.Server.Physics
                     if (index.X == chunk.ChunkSize - 1)
                     {
                         // Check East
-                        if (grid.TryGetChunk(new Vector2i(chunk.Indices.X + 1, chunk.Indices.Y), out neighborChunk) &&
+                        if (_maps.TryGetChunk(gridEuid, grid, new Vector2i(chunk.Indices.X + 1, chunk.Indices.Y), out neighborChunk) &&
                             TryGetNode(gridEuid, neighborChunk, new Vector2i(0, index.Y), out neighborNode))
                         {
                             chunkNode.Neighbors.Add(neighborNode);
@@ -512,7 +512,7 @@ namespace Robust.Server.Physics
                     if (index.Y == chunk.ChunkSize - 1)
                     {
                         // Check North
-                        if (grid.TryGetChunk(new Vector2i(chunk.Indices.X, chunk.Indices.Y + 1), out neighborChunk) &&
+                        if (_maps.TryGetChunk(gridEuid, grid, new Vector2i(chunk.Indices.X, chunk.Indices.Y + 1), out neighborChunk) &&
                             TryGetNode(gridEuid, neighborChunk, new Vector2i(index.X, 0), out neighborNode))
                         {
                             chunkNode.Neighbors.Add(neighborNode);

Robust.Server/Player/PlayerManager.cs

@@ -137,8 +137,7 @@ namespace Robust.Server.Player
                 {
                     UserId = client.UserId,
                     Name = client.Name,
-                    Status = client.Status,
-                    Ping = client.Channel!.Ping
+                    Status = client.Status
                 };
                 list.Add(info);
             }

Robust.Server/Program.cs

@@ -126,13 +126,29 @@ namespace Robust.Server
             AppDomain.CurrentDomain.UnhandledException += (sender, args) =>
             {
                 var message = ((Exception) args.ExceptionObject).ToString();
-                uh.Log(args.IsTerminating ? LogLevel.Fatal : LogLevel.Error, message);
+                try
+                {
+                    uh.Log(args.IsTerminating ? LogLevel.Fatal : LogLevel.Error, message);
+                }
+                catch (ObjectDisposedException)
+                {
+                    // Avoid eating the exception if it's during shutdown and the sawmill is already gone.
+                    System.Console.WriteLine($"UnhandledException but sawmill is disposed! {message}");
+                }
             };
 
             var uo = mgr.GetSawmill("unobserved");
             TaskScheduler.UnobservedTaskException += (sender, args) =>
             {
-                uo.Error(args.Exception!.ToString());
+                try
+                {
+                    uo.Error(args.Exception!.ToString());
+                }
+                catch (ObjectDisposedException)
+                {
+                    // Avoid eating the exception if it's during shutdown and the sawmill is already gone.
+                    System.Console.WriteLine($"UnobservedTaskException but sawmill is disposed! {args.Exception}");
+                }
 #if EXCEPTION_TOLERANCE
                 args.SetObserved(); // don't crash
 #endif