Version: 174.0.4

(cherry picked from commit 025d90d281)
(cherry picked from commit 799702b814)
(cherry picked from commit 4600ee8e5788891f1b610e2d5141fb4e1228d323)
(cherry picked from commit e5bce321669ec50c05b86bf3f5fa9dbd2dfe40ef)

.github/CODEOWNERS

@@ -7,3 +7,6 @@
 **/Toolshed/** @moonheart08
 *Command.cs @moonheart08
 *Commands.cs @moonheart08
+
+# Physics
+**/Robust.Shared/Physics/** @metalgearsloth

.github/workflows/publish-client.yml

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

Directory.Packages.props

@@ -0,0 +1,74 @@
+<Project>
+  <PropertyGroup>
+    <!--
+    We actually set ManagePackageVersionsCentrally manually in another import file.
+    Since .NET SDK 8.0.300, ManagePackageVersionsCentrally is automatically set if Directory.Packages.props exists.
+    https://github.com/NuGet/NuGet.Client/pull/5572
+    We actively negate this here, as we have some packages in tree we don't want such automatic behavior for.
+    We use Directory.Build.props to get copy the state *after* our MSBuild config but before Nuget's config.
+    -->
+    <ManagePackageVersionsCentrally />
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageVersion Include="BenchmarkDotNet" Version="0.13.12" />
+    <PackageVersion Include="DiscordRichPresence" Version="1.2.1.24" />
+    <PackageVersion Include="ILReader.Core" Version="1.0.0.4" />
+    <PackageVersion Include="JetBrains.Annotations" Version="2023.3.0" />
+    <PackageVersion Include="JetBrains.Profiler.Api" Version="1.4.0" />
+    <PackageVersion Include="Linguini.Bundle" Version="0.1.3" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzer.Testing" Version="1.1.1"/>
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing.NUnit" Version="1.1.1"/>
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.8.0" />
+    <PackageVersion Include="Microsoft.CodeCoverage" Version="17.8.0" />
+    <PackageVersion Include="Microsoft.Data.Sqlite.Core" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.DotNet.RemoteExecutor" Version="8.0.0-beta.24059.4" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.ObjectPool" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Primitives" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.ILVerification" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="3.0.0" />
+    <PackageVersion Include="Microsoft.NET.ILLink.Tasks" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageVersion Include="Microsoft.Win32.Registry" Version="5.0.0" />
+    <PackageVersion Include="Moq" Version="4.20.70" />
+    <PackageVersion Include="NUnit" Version="4.0.1" />
+    <PackageVersion Include="NUnit.Analyzers" Version="3.10.0" />
+    <PackageVersion Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageVersion Include="Nett" Version="0.15.0" />
+    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.4" />
+    <PackageVersion Include="OpenTK.OpenAL" Version="4.7.7" />
+    <PackageVersion Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" />
+    <PackageVersion Include="Pidgin" Version="3.2.2" />
+    <PackageVersion Include="Robust.Natives" Version="0.1.1" />
+    <PackageVersion Include="Robust.Natives.Cef" Version="120.1.9" />
+    <PackageVersion Include="Robust.Shared.AuthLib" Version="0.1.2" />
+    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.7" />
+    <PackageVersion Include="SQLitePCLRaw.provider.sqlite3" Version="2.1.7" />
+    <PackageVersion Include="Serilog" Version="3.1.1" />
+    <PackageVersion Include="Serilog.Sinks.Loki" Version="4.0.0-beta3" />
+    <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
+    <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.5" />
+    <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.0" />
+    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
+    <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
+    <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
+    <PackageVersion Include="System.Numerics.Vectors" Version="4.5.0" />
+    <PackageVersion Include="System.Memory" Version="4.5.5" />
+    <PackageVersion Include="System.Runtime.CompilerServices.Unsafe" Version="6.0.0" />
+    <PackageVersion Include="TerraFX.Interop.Windows" Version="10.0.22621.5" />
+    <PackageVersion Include="TerraFX.Interop.Xlib" Version="6.4.0" />
+    <PackageVersion Include="VorbisPizza" Version="1.3.0" />
+    <PackageVersion Include="YamlDotNet" Version="13.7.1" />
+    <PackageVersion Include="prometheus-net" Version="8.2.1" />
+    <PackageVersion Include="prometheus-net.DotNetRuntime" Version="4.4.0" />
+    <PackageVersion Include="PolySharp" Version="1.14.1" />
+  </ItemGroup>
+</Project>

MSBuild/Robust.Engine.Version.props

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

RELEASE-NOTES.md

@@ -54,6 +54,335 @@ END TEMPLATE-->
 *None yet*
 
 
+## 174.0.4
+
+
+## 174.0.3
+
+
+## 174.0.2
+
+
+## 174.0.1
+
+
+## 174.0.0
+
+### Breaking changes
+
+* ActorComponent has been moved to `Robust.Shared.Player` (namespace changed).
+
+### New features
+
+* Added `SpriteSystem.GetFrame()` method, which takes in an animated RSI and a time and returns a frame/texture.
+* Added `IRobustRandom.NextAngle()`
+
+
+## 173.1.0
+
+### New features
+
+* Add physics chain shapes from Box2D.
+
+
+## 173.0.0
+
+### Breaking changes
+
+* Remove GridModifiedEvent in favor of TileChangedEvent.
+
+### Bugfixes
+
+* Fix some grid rendering bugs where chunks don't get destroyed correctly.
+
+
+## 172.0.0
+
+### Breaking changes
+
+* Remove TryLifestage helper methods.
+* Refactor IPlayerManager to remove more IPlayerSession, changed PlayerAttachedEvent etc on client to have the Local prefix, and shuffled namespaces around.
+
+### New features
+
+* Add EnsureComponent(ref Entity<\T?>)
+
+### Bugfixes
+
+* Re-add force ask threshold and fix other PVS bugs.
+
+
+## 171.0.0
+
+### Breaking changes
+
+* Change PlaceNextTo method names to be more descriptive.
+* Rename RefreshRelay for joints to SetRelay to match its behaviour.
+
+### Bugfixes
+
+* Fix PVS error spam for joint relays not being cleaned up.
+
+### Other
+
+* Set EntityLastModifiedTick on entity spawn.
+
+
+## 170.0.0
+
+### Breaking changes
+
+* Removed obsolete methods and properties in VisibilitySystem, SharedContainerSystem and MetaDataComponent.
+
+### Bugfixes
+
+* Fixed duplicate command error.
+* Fixed not being able to delete individual entities with the delete command.
+
+### Other
+
+* FileLogHandler logs can now be deleted while the engine is running.
+
+
+## 169.0.1
+
+### Other
+
+* The client now knows about registered server-side toolshed commands.
+
+## 169.0.0
+
+### Breaking changes
+
+* Entity<T> has been introduced to hold a component and its owning entity. Some methods that returned and accepted components directly have been removed or obsoleted to reflect this.
+
+### Other
+
+* By-value events may now be subscribed to by-ref.
+* The manifest's assemblyPrefix value is now respected on the server.
+
+
+## 168.0.0
+
+### Breaking changes
+
+* The Component.OnRemove method has been removed. Use SubscribeLocalEvent<TComp, ComponentRemove>(OnRemove) from an EntitySystem instead.
+
+
+## 167.0.0
+
+### Breaking changes
+
+* Remove ComponentExtensions.
+* Remove ContainerHelpers.
+* Change some TransformSystem methods to fix clientside lerping.
+
+### Bugfixes
+
+* Fixed PVS bugs from dropped entity states.
+
+### Other
+
+* Add more joint debug asserts.
+
+
+## 166.0.0
+
+### Breaking changes
+
+* EntityUid-NetEntity conversion methods now return null when given a null value, rather than returning an invalid id.
+* ExpandPvsEvent now defaults to using null lists to reduce allocations.
+* Various component lifestage related methods have been moved from the `Component` class to `EntityManager`.
+* Session/client specific PVS overrides are now always recursive, which means that all children of the overriden entity will also get sent.
+
+### New features
+
+* Added a SortedSet yaml serializer.
+
+### Other
+
+* AddComponentUninitialized is now marked as obsolete and will be removed in the future.
+* DebugTools.AssertOwner() now accepts null components.
+
+
+## 165.0.0
+
+### Breaking changes
+
+* The arguments of `SplitContainer`s resize-finished event have changed.
+
+### New features
+
+* The YAML validator now checks the default values of ProtoId<T> and EntProtoId data fields.
+
+### Bugfixes
+
+* The minimum draggable area of split containers now blocks mouse inputs.
+
+
+## 164.0.0
+
+### Breaking changes
+
+* Make automatic component states infer cloneData.
+* Removed cloneData from AutoNetworkedFieldAttribute. This is now automatically inferred.
+
+### Internal
+
+* Reduce Transform GetComponents in RecursiveDeleteEntity.
+
+
+## 163.0.0
+
+### Breaking changes
+
+* Moved TimedDespawn to engine for a component that deletes the attached entity after a timer has elapsed.
+
+### New features
+
+* Add ExecuteCommand for integration tests.
+* Allow adding / removing widgets of cub-controls.
+* Give maps / grids a default name to help with debugging.
+* Use ToPrettyString in component resolve errors to help with debugging.
+
+### Bugfixes
+
+* Fix console backspace exception.
+* Fix rendering invalid maps spamming exceptions every frame.
+
+### Internal
+
+* Move ClientGameStatemanager local variables to fields to avoid re-allocating every tick.
+
+
+## 162.2.1
+
+
+## 162.2.0
+
+### New features
+
+* Add support for automatically networking entity lists and sets.
+* Add nullable conversion operators for ProtoIds.
+* Add LocId serializer for validation.
+
+### Bugfixes
+
+* Fix deleting a contact inside of collision events throwing.
+* Localize VV.
+
+### Internal
+
+* Use CollectionsMarshal in GameStateManager.
+
+
+## 162.1.1
+
+### Bugfixes
+
+* Fixes "NoSpawn" entities appearing in the spawn menu.
+
+
+## 162.1.0
+
+### New features
+
+* Mark ProtoId as NetSerializable.
+
+### Bugfixes
+
+* Temporarily revert NetForceAckThreshold change as it can lead to client stalling.
+* Fix eye visibility layers not updating on children when a parent changes.
+
+### Internal
+
+* Use CollectionsMarshal in RobustTree and AddComponentInternal.
+
+
+## 162.0.0
+
+### New features
+
+* Add entity categories for prototypes and deprecate the `noSpawn` tag.
+* Add missing proxy method for `TryGetEntityData`.
+* Add NetForceAckThreshold cvar to forcibly update acks for late clients.
+
+### Internal
+
+* Use CollectionMarshals in PVS and DynamicTree.
+* Make the proxy methods use MetaQuery / TransformQuery.
+
+
+## 161.1.0
+
+### New features
+
+* Add more DebugTools assert variations.
+
+### Bugfixes
+
+* Don't attempt to insert entities into deleted containers.
+* Try to fix oldestAck not being set correctly leading to deletion history getting bloated for pvs.
+
+
+## 161.0.0
+
+### Breaking changes
+
+* Point light animations now need to use different component fields in order to animate the lights. `Enabled` should be replaced with `AnimatedEnable` and `Radius` should be replaced with `AnimatedRadius`
+
+### New features
+
+* EntProtoId is now net-serializable
+* Added print_pvs_ack command to debug PVS issues.
+
+### Bugfixes
+
+* Fixes AngleTypeParser not using InvariantCulture
+* Fixed a bug that was causing `MetaDataComponent.LastComponentRemoved` to be updated improperly.
+
+### Other
+
+* The string representation of client-side entities now looks nicer and simply uses a 'c' prefix.
+
+
+## 160.1.0
+
+### New features
+
+* Add optional MetaDataComponent args to Entitymanager methods.
+
+### Internal
+
+* Move _netComponents onto MetaDataComponent.
+* Remove some component resolves internally on adding / removing components.
+
+
+## 160.0.2
+
+### Other
+
+* Transform component and containers have new convenience fields to make using VIewVariables easier.
+
+
+## 160.0.0
+
+### Breaking changes
+
+* ComponentReference has now been entirely removed.
+* Sensor / non-hard physics bodies are now included in EntityLookup by default.
+
+
+## 159.1.0
+
+
+## 159.0.3
+
+### Bugfixes
+
+* Fix potentially deleted entities having states re-applied when NetEntities come in.
+
+
 ## 159.0.2
 
 ### Bugfixes

Resources/EnginePrototypes/Debug/rotation.yml

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

Resources/EnginePrototypes/entityCategory.yml

@@ -0,0 +1,17 @@
+# debug related entities
+- type: entityCategory
+  id: debug
+  name: entity-category-name-debug
+  description: entity-category-desc-debug
+
+# entities that spawn other entities
+- type: entityCategory
+  id: spawner
+  name: entity-category-name-spawner
+  description: entity-category-desc-spawner
+
+# entities that should be hidden from the spawn menu
+- type: entityCategory
+  id: hideSpawnMenu
+  name: entity-category-name-hide
+  description: entity-category-desc-hide

Resources/Locale/en-US/commands.ftl

@@ -17,15 +17,15 @@ cmd-error-dir-not-found = Could not find directory: {$dir}.
 cmd-failure-no-attached-entity = There is no entity attached to this shell.
 
 ## 'help' command
-cmd-oldhelp-desc = Display general help or help text for a specific command
-cmd-oldhelp-help = Usage: help [command name]
+cmd-help-desc = Display general help or help text for a specific command
+cmd-help-help = Usage: help [command name]
     When no command name is provided, displays general-purpose help text. If a command name is provided, displays help text for that command.
 
-cmd-oldhelp-no-args = To display help for a specific command, write 'help <command>'. To list all available commands, write 'list'. To search for commands, use 'list <filter>'.
-cmd-oldhelp-unknown = Unknown command: { $command }
-cmd-oldhelp-top = { $command } - { $description }
-cmd-oldhelp-invalid-args = Invalid amount of arguments.
-cmd-oldhelp-arg-cmdname = [command name]
+cmd-help-no-args = To display help for a specific command, write 'help <command>'. To list all available commands, write 'list'. To search for commands, use 'list <filter>'.
+cmd-help-unknown = Unknown command: { $command }
+cmd-help-top = { $command } - { $description }
+cmd-help-invalid-args = Invalid amount of arguments.
+cmd-help-arg-cmdname = [command name]
 
 ## 'cvar' command
 cmd-cvar-desc = Gets or sets a CVar.

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

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

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

@@ -1,5 +1,6 @@
 ## ViewVariablesInstanceEntity
 
+view-variables = View Variables
 view-variable-instance-entity-server-components-add-component-button-placeholder = Add Component
 view-variable-instance-entity-client-variables-tab-title = Client Variables
 view-variable-instance-entity-client-components-tab-title = Client Components
@@ -8,4 +9,4 @@ view-variable-instance-entity-server-components-tab-title = Server Components
 view-variable-instance-entity-client-components-search-bar-placeholder = Search
 view-variable-instance-entity-server-components-search-bar-placeholder = Search
 view-variable-instance-entity-add-window-server-components = Add Component [S]
-view-variable-instance-entity-add-window-client-components = Add Component [C]
+view-variable-instance-entity-add-window-client-components = Add Component [C]

Robust.Analyzers/ByRefEventAnalyzer.cs

@@ -23,16 +23,6 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
         "Make sure that methods subscribing to a ref event have the ref keyword for the event argument."
     );
 
-    private static readonly DiagnosticDescriptor ByValueEventSubscribedByRefRule = new(
-        Diagnostics.IdValueEventRaisedByRef,
-        "Value event subscribed to by-ref",
-        "Tried to subscribe to a value event '{0}' by-ref.",
-        "Usage",
-        DiagnosticSeverity.Error,
-        true,
-        "Make sure that methods subscribing to value events do not have the ref keyword for the event argument."
-    );
-
     private static readonly DiagnosticDescriptor ByRefEventRaisedByValueRule = new(
         Diagnostics.IdByRefEventRaisedByValue,
         "By-ref event raised by value",
@@ -55,7 +45,6 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
 
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
         ByRefEventSubscribedByValueRule,
-        ByValueEventSubscribedByRefRule,
         ByRefEventRaisedByValueRule,
         ByValueEventRaisedByRefRule
     );
@@ -64,71 +53,9 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
         context.EnableConcurrentExecution();
-        context.RegisterOperationAction(CheckEventSubscription, OperationKind.Invocation);
         context.RegisterOperationAction(CheckEventRaise, OperationKind.Invocation);
     }
 
-    private void CheckEventSubscription(OperationAnalysisContext context)
-    {
-        if (context.Operation is not IInvocationOperation operation)
-            return;
-
-        var subscribeMethods = context.Compilation
-            .GetTypeByMetadataName("Robust.Shared.GameObjects.EntitySystem")?
-            .GetMembers()
-            .Where(m => m.Name.Contains("SubscribeLocalEvent"))
-            .Cast<IMethodSymbol>();
-
-        if (subscribeMethods == null)
-            return;
-
-        if (!subscribeMethods.Any(m => m.Equals(operation.TargetMethod.OriginalDefinition, Default)))
-            return;
-
-        var typeArguments = operation.TargetMethod.TypeArguments;
-        if (typeArguments.Length < 1 || typeArguments.Length > 2)
-            return;
-
-        if (operation.Arguments.First().Value is not IDelegateCreationOperation delegateCreation)
-            return;
-
-        if (delegateCreation.Target is not IMethodReferenceOperation methodReference)
-            return;
-
-        var eventParameter = methodReference.Method.Parameters.LastOrDefault();
-        if (eventParameter == null)
-            return;
-
-        ITypeSymbol eventArgument;
-        switch (typeArguments.Length)
-        {
-            case 1:
-                eventArgument = typeArguments[0];
-                break;
-            case 2:
-                eventArgument = typeArguments[1];
-                break;
-            default:
-                return;
-        }
-
-        var byRefAttribute = context.Compilation.GetTypeByMetadataName(ByRefAttribute);
-        if (byRefAttribute == null)
-            return;
-
-        var isByRefEventType = eventArgument
-            .GetAttributes()
-            .Any(attribute => attribute.AttributeClass?.Equals(byRefAttribute, Default) ?? false);
-        var parameterIsRef = eventParameter.RefKind == RefKind.Ref;
-
-        if (isByRefEventType != parameterIsRef)
-        {
-            var descriptor = isByRefEventType ? ByRefEventSubscribedByValueRule : ByValueEventSubscribedByRefRule;
-            var diagnostic = Diagnostic.Create(descriptor, operation.Syntax.GetLocation(), eventArgument);
-            context.ReportDiagnostic(diagnostic);
-        }
-    }
-
     private void CheckEventRaise(OperationAnalysisContext context)
     {
         if (context.Operation is not IInvocationOperation operation)

Robust.Analyzers/Diagnostics.cs

@@ -18,7 +18,6 @@ public static class Diagnostics
     public const string IdInvalidNotNullableFlagType = "RA0011";
     public const string IdNotNullableFlagValueType = "RA0012";
     public const string IdByRefEventSubscribedByValue = "RA0013";
-    public const string IdValueEventSubscribedByRef = "RA0014";
     public const string IdByRefEventRaisedByValue = "RA0015";
     public const string IdValueEventRaisedByRef = "RA0016";
     public const string IdDataDefinitionPartial = "RA0017";

Robust.Benchmarks/Transform/RecursiveMoveBenchmark.cs

@@ -54,7 +54,7 @@ public class RecursiveMoveBenchmark
         var mapSys = _entMan.System<SharedMapSystem>();
         var mapId = mapMan.CreateMap();
         var map = mapMan.GetMapEntityId(mapId);
-        var gridComp = mapMan.CreateGrid(mapId);
+        var gridComp = mapMan.CreateGridEntity(mapId);
         var grid = gridComp.Owner;
         _gridCoords = new EntityCoordinates(grid, .5f, .5f);
         _mapCoords = new EntityCoordinates(map, 100, 100);

Robust.Client/BaseClient.cs

@@ -1,8 +1,6 @@
 using System;
-using System.Linq;
 using System.Net;
 using Robust.Client.Configuration;
-using Robust.Client.Debugging;
 using Robust.Client.GameObjects;
 using Robust.Client.GameStates;
 using Robust.Client.Player;
@@ -10,13 +8,12 @@ using Robust.Client.Utility;
 using Robust.Shared;
 using Robust.Shared.Configuration;
 using Robust.Shared.Enums;
-using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -65,12 +62,12 @@ namespace Robust.Client
 
             _configManager.OnValueChanged(CVars.NetTickrate, TickRateChanged, invokeImmediately: true);
 
-            _playMan.Initialize();
+            _playMan.Initialize(0);
             _playMan.PlayerListUpdated += OnPlayerListUpdated;
             Reset();
         }
 
-        private void OnPlayerListUpdated(object? sender, EventArgs e)
+        private void OnPlayerListUpdated()
         {
             var serverPlayers = _playMan.PlayerCount;
             if (_net.ServerChannel != null && GameInfo != null && _net.IsConnected)
@@ -130,9 +127,10 @@ namespace Robust.Client
         {
             DebugTools.Assert(RunLevel < ClientRunLevel.Connecting);
             DebugTools.Assert(!_net.IsConnected);
-            _playMan.Startup();
-            _playMan.LocalPlayer!.Name = PlayerNameOverride ?? _configManager.GetCVar(CVars.PlayerName);
+            var name = PlayerNameOverride ?? _configManager.GetCVar(CVars.PlayerName);
+            _playMan.SetupSinglePlayer(name);
             OnRunLevelChanged(ClientRunLevel.SinglePlayerGame);
+            _playMan.JoinGame(_playMan.LocalSession!);
             GameStartedSetup();
         }
 
@@ -173,22 +171,14 @@ namespace Robust.Client
                 info.ServerName = serverName;
             }
 
-            var maxPlayers = _configManager.GetCVar<int>("game.maxplayers");
-            info.ServerMaxPlayers = maxPlayers;
-
-            var userName = _net.ServerChannel!.UserName;
-            var userId = _net.ServerChannel.UserId;
+            var channel = _net.ServerChannel!;
 
             // start up player management
-            _playMan.Startup();
-
-            _playMan.LocalPlayer!.UserId = userId;
-            _playMan.LocalPlayer.Name = userName;
-
-            _playMan.LocalPlayer.StatusChanged += OnLocalStatusChanged;
+            _playMan.SetupMultiplayer(channel);
+            _playMan.PlayerStatusChanged += OnStatusChanged;
 
             var serverPlayers = _playMan.PlayerCount;
-            _discord.Update(info.ServerName, userName, info.ServerMaxPlayers.ToString(), serverPlayers.ToString());
+            _discord.Update(info.ServerName, channel.UserName, info.ServerMaxPlayers.ToString(), serverPlayers.ToString());
 
         }
 
@@ -221,6 +211,8 @@ namespace Robust.Client
 
         private void Reset()
         {
+            _configManager.ReceivedInitialNwVars -= OnReceivedClientData;
+            _playMan.PlayerStatusChanged -= OnStatusChanged;
             _configManager.ClearReceivedInitialNwVars();
             OnRunLevelChanged(ClientRunLevel.Initialize);
         }
@@ -263,19 +255,17 @@ namespace Robust.Client
             Reset();
         }
 
-        private void OnLocalStatusChanged(object? obj, StatusEventArgs eventArgs)
+        private void OnStatusChanged(object? sender, SessionStatusEventArgs e)
         {
+            if (e.Session != _playMan.LocalSession)
+                return;
+
             // player finished fully connecting to the server.
             // OldStatus is used here because it can go from connecting-> connected or connecting-> ingame
-            if (eventArgs.OldStatus == SessionStatus.Connecting)
-            {
-                OnPlayerJoinedServer(_playMan.LocalPlayer!.Session);
-            }
-
-            if (eventArgs.NewStatus == SessionStatus.InGame)
-            {
-                OnPlayerJoinedGame(_playMan.LocalPlayer!.Session);
-            }
+            if (e.OldStatus == SessionStatus.Connecting)
+                OnPlayerJoinedServer(e.Session);
+            else if (e.NewStatus == SessionStatus.InGame)
+                OnPlayerJoinedGame(e.Session);
         }
 
         private void OnRunLevelChanged(ClientRunLevel newRunLevel)

Robust.Client/ClientIoC.cs

@@ -37,7 +37,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Physics;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Reflection;
 using Robust.Shared.Replays;

Robust.Client/Console/ClientConsoleHost.cs

@@ -13,7 +13,7 @@ using Robust.Shared.Log;
 using Robust.Shared.Maths;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Reflection;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;

Robust.Client/Console/Commands/AddCompCommand.cs

@@ -26,10 +26,7 @@ namespace Robust.Client.Console.Commands
             var entity = _entityManager.GetEntity(netEntity);
             var componentName = args[1];
 
-            var component = (Component) _componentFactory.GetComponent(componentName);
-
-            component.Owner = entity;
-
+            var component = _componentFactory.GetComponent(componentName);
             _entityManager.AddComponent(entity, component);
         }
     }

Robust.Client/Console/Commands/Debug.cs

@@ -78,14 +78,7 @@ namespace Robust.Client.Console.Commands
                     message.Append($"net ID: {registration.NetID}");
                 }
 
-                message.Append($", References:");
-
                 shell.WriteLine(message.ToString());
-
-                foreach (var type in registration.References)
-                {
-                    shell.WriteLine($"  {type}");
-                }
             }
             catch (UnknownComponentException)
             {

Robust.Client/Console/Commands/DumpMetadataMembersCommand.cs

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

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -1,6 +1,7 @@
 #if DEBUG
 using System.Numerics;
 using System.Text;
+using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
 using Robust.Client.UserInterface;
@@ -8,7 +9,6 @@ using Robust.Client.UserInterface.Controls;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.Debugging
@@ -19,6 +19,7 @@ namespace Robust.Client.Debugging
         [Dependency] private readonly IInputManager _inputManager = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IUserInterfaceManager _userInterface = default!;
+        [Dependency] private readonly MapSystem _mapSystem = default!;
 
         private Label? _label;
 
@@ -70,7 +71,7 @@ namespace Robust.Client.Debugging
                 return;
             }
 
-            var tile = grid.GetTileRef(spot);
+            var tile = _mapSystem.GetTileRef(gridUid, grid, spot);
             _label.Position = mouseSpot.Position + new Vector2(32, 0);
 
             if (_hovered?.GridId == gridUid && _hovered?.Tile == tile) return;
@@ -79,7 +80,7 @@ namespace Robust.Client.Debugging
 
             var text = new StringBuilder();
 
-            foreach (var ent in grid.GetAnchoredEntities(spot))
+            foreach (var ent in _mapSystem.GetAnchoredEntities(gridUid, grid, spot))
             {
                 if (EntityManager.TryGetComponent<MetaDataComponent>(ent, out var meta))
                 {

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -46,7 +46,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
@@ -207,6 +206,7 @@ namespace Robust.Client.Debugging
         private readonly Font _font;
 
         private HashSet<Joint> _drawnJoints = new();
+        private List<Entity<MapGridComponent>> _grids = new();
 
         public PhysicsDebugOverlay(IEntityManager entityManager, IEyeManager eyeManager, IInputManager inputManager, IMapManager mapManager, IPlayerManager playerManager, IResourceCache cache, DebugPhysicsSystem system, EntityLookupSystem lookup, SharedPhysicsSystem physicsSystem)
         {
@@ -231,32 +231,33 @@ namespace Robust.Client.Debugging
             {
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
                 {
-                    if (_entityManager.HasComponent<MapGridComponent>(physBody.Owner)) continue;
+                    if (_entityManager.HasComponent<MapGridComponent>(physBody)) continue;
 
-                    var xform = _physicsSystem.GetPhysicsTransform(physBody.Owner);
+                    var xform = _physicsSystem.GetPhysicsTransform(physBody);
+                    var comp = physBody.Comp;
 
                     const float AlphaModifier = 0.2f;
 
-                    foreach (var fixture in _entityManager.GetComponent<FixturesComponent>(physBody.Owner).Fixtures.Values)
+                    foreach (var fixture in _entityManager.GetComponent<FixturesComponent>(physBody).Fixtures.Values)
                     {
                         // Invalid shape - Box2D doesn't check for IsSensor but we will for sanity.
-                        if (physBody.BodyType == BodyType.Dynamic && fixture.Density == 0f && fixture.Hard)
+                        if (comp.BodyType == BodyType.Dynamic && fixture.Density == 0f && fixture.Hard)
                         {
                             DrawShape(worldHandle, fixture, xform, Color.Red.WithAlpha(AlphaModifier));
                         }
-                        else if (!physBody.CanCollide)
+                        else if (!comp.CanCollide)
                         {
                             DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.5f, 0.3f).WithAlpha(AlphaModifier));
                         }
-                        else if (physBody.BodyType == BodyType.Static)
+                        else if (comp.BodyType == BodyType.Static)
                         {
                             DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.9f, 0.5f).WithAlpha(AlphaModifier));
                         }
-                        else if ((physBody.BodyType & (BodyType.Kinematic | BodyType.KinematicController)) != 0x0)
+                        else if ((comp.BodyType & (BodyType.Kinematic | BodyType.KinematicController)) != 0x0)
                         {
                             DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.5f, 0.9f).WithAlpha(AlphaModifier));
                         }
-                        else if (!physBody.Awake)
+                        else if (!comp.Awake)
                         {
                             DrawShape(worldHandle, fixture, xform, new Color(0.6f, 0.6f, 0.6f).WithAlpha(AlphaModifier));
                         }
@@ -275,15 +276,18 @@ namespace Robust.Client.Debugging
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
                 {
                     var color = Color.Purple.WithAlpha(Alpha);
-                    var transform = _physicsSystem.GetPhysicsTransform(physBody.Owner);
-                    worldHandle.DrawCircle(Transform.Mul(transform, physBody.LocalCenter), 0.2f, color);
+                    var transform = _physicsSystem.GetPhysicsTransform(physBody);
+                    worldHandle.DrawCircle(Transform.Mul(transform, physBody.Comp.LocalCenter), 0.2f, color);
                 }
 
-                foreach (var grid in _mapManager.FindGridsIntersecting(mapId, viewBounds))
+                _grids.Clear();
+                _mapManager.FindGridsIntersecting(mapId, viewBounds, ref _grids);
+
+                foreach (var grid in _grids)
                 {
-                    var physBody = _entityManager.GetComponent<PhysicsComponent>(grid.Owner);
+                    var physBody = _entityManager.GetComponent<PhysicsComponent>(grid);
                     var color = Color.Orange.WithAlpha(Alpha);
-                    var transform = _physicsSystem.GetPhysicsTransform(grid.Owner);
+                    var transform = _physicsSystem.GetPhysicsTransform(grid);
                     worldHandle.DrawCircle(Transform.Mul(transform, physBody.LocalCenter), 1f, color);
                 }
             }
@@ -292,14 +296,14 @@ namespace Robust.Client.Debugging
             {
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
                 {
-                    if (_entityManager.HasComponent<MapGridComponent>(physBody.Owner)) continue;
+                    if (_entityManager.HasComponent<MapGridComponent>(physBody)) continue;
 
-                    var xform = _physicsSystem.GetPhysicsTransform(physBody.Owner);
+                    var xform = _physicsSystem.GetPhysicsTransform(physBody);
 
                     const float AlphaModifier = 0.2f;
                     Box2? aabb = null;
 
-                    foreach (var fixture in _entityManager.GetComponent<FixturesComponent>(physBody.Owner).Fixtures.Values)
+                    foreach (var fixture in _entityManager.GetComponent<FixturesComponent>(physBody).Fixtures.Values)
                     {
                         for (var i = 0; i < fixture.Shape.ChildCount; i++)
                         {
@@ -318,10 +322,11 @@ namespace Robust.Client.Debugging
             {
                 _drawnJoints.Clear();
 
-                foreach (var jointComponent in _entityManager.EntityQuery<JointComponent>(true))
+                var query = _entityManager.AllEntityQueryEnumerator<JointComponent>();
+                while (query.MoveNext(out var uid, out var jointComponent))
                 {
                     if (jointComponent.JointCount == 0 ||
-                        !_entityManager.TryGetComponent(jointComponent.Owner, out TransformComponent? xf1) ||
+                        !_entityManager.TryGetComponent(uid, out TransformComponent? xf1) ||
                         !viewAABB.Contains(xf1.WorldPosition)) continue;
 
                     foreach (var (_, joint) in jointComponent.Joints)
@@ -361,6 +366,9 @@ namespace Robust.Client.Debugging
 
                 _debugPhysicsSystem.PointCount = 0;
             }
+
+            worldHandle.UseShader(null);
+            worldHandle.SetTransform(Matrix3.Identity);
         }
 
         private void DrawScreen(DrawingHandleScreen screenHandle, OverlayDrawArgs args)
@@ -370,28 +378,31 @@ namespace Robust.Client.Debugging
 
             if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.ShapeInfo) != 0x0)
             {
-                var hoverBodies = new List<PhysicsComponent>();
+                var hoverBodies = new List<Entity<PhysicsComponent>>();
                 var bounds = Box2.UnitCentered.Translated(_eyeManager.PixelToMap(mousePos.Position).Position);
 
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, bounds))
                 {
-                    if (_entityManager.HasComponent<MapGridComponent>(physBody.Owner)) continue;
-                    hoverBodies.Add(physBody);
+                    var uid = physBody.Owner;
+                    if (_entityManager.HasComponent<MapGridComponent>(uid)) continue;
+                    hoverBodies.Add((uid, physBody));
                 }
 
                 var lineHeight = _font.GetLineHeight(1f);
                 var drawPos = mousePos.Position + new Vector2(20, 0) + new Vector2(0, -(hoverBodies.Count * 4 * lineHeight / 2f));
                 int row = 0;
 
-                foreach (var body in hoverBodies)
+                foreach (var bodyEnt in hoverBodies)
                 {
-                    if (body != hoverBodies[0])
+                    if (bodyEnt != hoverBodies[0])
                     {
                         screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), "------");
                         row++;
                     }
 
-                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {body.Owner}");
+                    var body = bodyEnt.Comp;
+
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {bodyEnt.Owner}");
                     row++;
                     screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Layer: {Convert.ToString(body.CollisionLayer, 2)}");
                     row++;
@@ -430,6 +441,9 @@ namespace Robust.Client.Debugging
                     }
                 }
             }
+
+            screenHandle.UseShader(null);
+            screenHandle.SetTransform(Matrix3.Identity);
         }
 
         protected internal override void Draw(in OverlayDrawArgs args)
@@ -451,11 +465,26 @@ namespace Robust.Client.Debugging
         {
             switch (fixture.Shape)
             {
+                case ChainShape cShape:
+                {
+                    var count = cShape.Count;
+                    var vertices = cShape.Vertices;
+
+                    var v1 = Transform.Mul(xform, vertices[0]);
+                    for (var i = 1; i < count; ++i)
+                    {
+                        var v2 = Transform.Mul(xform, vertices[i]);
+                        worldHandle.DrawLine(v1, v2, color);
+                        v1 = v2;
+                    }
+                }
+                    break;
                 case PhysShapeCircle circle:
                     var center = Transform.Mul(xform, circle.Position);
                     worldHandle.DrawCircle(center, circle.Radius, color);
                     break;
                 case EdgeShape edge:
+                {
                     var v1 = Transform.Mul(xform, edge.Vertex1);
                     var v2 = Transform.Mul(xform, edge.Vertex2);
                     worldHandle.DrawLine(v1, v2, color);
@@ -465,6 +494,7 @@ namespace Robust.Client.Debugging
                         worldHandle.DrawCircle(v1, 0.1f, color);
                         worldHandle.DrawCircle(v2, 0.1f, color);
                     }
+                }
 
                     break;
                 case PolygonShape poly:

Robust.Client/GameController/GameController.RobustModules.cs

@@ -3,6 +3,7 @@ using System.IO;
 using System.Reflection;
 using System.Runtime.Loader;
 using Robust.Client.WebViewHook;
+using Robust.Shared.ContentPack;
 using Robust.Shared.Log;
 using Robust.Shared.Utility;
 

Robust.Client/GameController/GameController.cs

@@ -287,78 +287,6 @@ namespace Robust.Client
             return true;
         }
 
-        private ResourceManifestData LoadResourceManifest()
-        {
-            // Parses /manifest.yml for game-specific settings that cannot be exclusively set up by content code.
-            if (!_resourceCache.TryContentFileRead("/manifest.yml", out var stream))
-                return ResourceManifestData.Default;
-
-            var yamlStream = new YamlStream();
-            using (stream)
-            {
-                using var streamReader = new StreamReader(stream, EncodingHelpers.UTF8);
-                yamlStream.Load(streamReader);
-            }
-
-            if (yamlStream.Documents.Count == 0)
-                return ResourceManifestData.Default;
-
-            if (yamlStream.Documents.Count != 1 || yamlStream.Documents[0].RootNode is not YamlMappingNode mapping)
-            {
-                throw new InvalidOperationException(
-                    "Expected a single YAML document with root mapping for /manifest.yml");
-            }
-
-            var modules = ReadStringArray(mapping, "modules") ?? Array.Empty<string>();
-
-            string? assemblyPrefix = null;
-            if (mapping.TryGetNode("assemblyPrefix", out var prefixNode))
-                assemblyPrefix = prefixNode.AsString();
-
-            string? defaultWindowTitle = null;
-            if (mapping.TryGetNode("defaultWindowTitle", out var winTitleNode))
-                defaultWindowTitle = winTitleNode.AsString();
-
-            string? windowIconSet = null;
-            if (mapping.TryGetNode("windowIconSet", out var iconSetNode))
-                windowIconSet = iconSetNode.AsString();
-
-            string? splashLogo = null;
-            if (mapping.TryGetNode("splashLogo", out var splashNode))
-                splashLogo = splashNode.AsString();
-
-            bool autoConnect = true;
-            if (mapping.TryGetNode("autoConnect", out var autoConnectNode))
-                autoConnect = autoConnectNode.AsBool();
-
-            var clientAssemblies = ReadStringArray(mapping, "clientAssemblies");
-
-            return new ResourceManifestData(
-                modules,
-                assemblyPrefix,
-                defaultWindowTitle,
-                windowIconSet,
-                splashLogo,
-                autoConnect,
-                clientAssemblies
-            );
-
-            static string[]? ReadStringArray(YamlMappingNode mapping, string key)
-            {
-                if (!mapping.TryGetNode(key, out var node))
-                    return null;
-
-                var sequence = (YamlSequenceNode)node;
-                var array = new string[sequence.Children.Count];
-                for (var i = 0; i < array.Length; i++)
-                {
-                    array[i] = sequence[i].AsString();
-                }
-
-                return array;
-            }
-        }
-
         internal bool StartupSystemSplash(
             GameControllerOptions options,
             Func<ILogHandler>? logHandlerFactory,
@@ -457,7 +385,7 @@ namespace Robust.Client
                 _modLoader.VerifierExtraLoadHandler = VerifierExtraLoadHandler;
             }
 
-            _resourceManifest = LoadResourceManifest();
+            _resourceManifest = ResourceManifestData.LoadResourceManifest(_resourceCache);
 
             {
                 // Handle GameControllerOptions implicit CVar overrides.
@@ -704,7 +632,6 @@ namespace Robust.Client
             logManager.GetSawmill("ogl.debug.other").Level = LogLevel.Warning;
             logManager.GetSawmill("gdparse").Level = LogLevel.Error;
             logManager.GetSawmill("discord").Level = LogLevel.Warning;
-            logManager.GetSawmill("net.predict").Level = LogLevel.Info;
             logManager.GetSawmill("szr").Level = LogLevel.Info;
             logManager.GetSawmill("loc").Level = LogLevel.Warning;
 
@@ -786,20 +713,6 @@ namespace Robust.Client
             _clydeAudio.Shutdown();
         }
 
-        private sealed record ResourceManifestData(
-            string[] Modules,
-            string? AssemblyPrefix,
-            string? DefaultWindowTitle,
-            string? WindowIconSet,
-            string? SplashLogo,
-            bool AutoConnect,
-            string[]? ClientAssemblies
-        )
-        {
-            public static readonly ResourceManifestData Default =
-                new ResourceManifestData(Array.Empty<string>(), null, null, null, null, true, null);
-        }
-
         public event Action<FrameEventArgs>? TickUpdateOverride;
     }
 }

Robust.Client/GameObjects/ClientEntityManager.Network.cs

@@ -35,14 +35,14 @@ public sealed partial class ClientEntityManager
 
         if (NetEntityLookup.TryGetValue(nEntity, out var entity))
         {
-            return entity;
+            return entity.Item1;
         }
 
         // Flag the callerEntity to have their state potentially re-run later.
         var pending = PendingNetEntityStates.GetOrNew(nEntity);
         pending.Add((typeof(T), callerEntity));
 
-        return entity;
+        return entity.Item1;
     }
 
     public override EntityCoordinates EnsureCoordinates<T>(NetCoordinates netCoordinates, EntityUid callerEntity)

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -42,9 +42,9 @@ namespace Robust.Client.GameObjects
             base.FlushEntities();
         }
 
-        EntityUid IClientEntityManagerInternal.CreateEntity(string? prototypeName)
+        EntityUid IClientEntityManagerInternal.CreateEntity(string? prototypeName, out MetaDataComponent metadata)
         {
-            return base.CreateEntity(prototypeName);
+            return base.CreateEntity(prototypeName, out metadata);
         }
 
         void IClientEntityManagerInternal.InitializeEntity(EntityUid entity, MetaDataComponent? meta)
@@ -65,9 +65,12 @@ namespace Robust.Client.GameObjects
                 base.DirtyEntity(uid, meta);
         }
 
-        public override void QueueDeleteEntity(EntityUid uid)
+        public override void QueueDeleteEntity(EntityUid? uid)
         {
-            if (IsClientSide(uid))
+            if (uid == null)
+                return;
+
+            if (IsClientSide(uid.Value))
             {
                 base.QueueDeleteEntity(uid);
                 return;
@@ -78,23 +81,29 @@ namespace Robust.Client.GameObjects
 
             // Client-side entity deletion is not supported and will cause errors.
             if (_client.RunLevel == ClientRunLevel.Connected || _client.RunLevel == ClientRunLevel.InGame)
-                LogManager.RootSawmill.Error($"Predicting the queued deletion of a networked entity: {ToPrettyString(uid)}. Trace: {Environment.StackTrace}");
+                LogManager.RootSawmill.Error($"Predicting the queued deletion of a networked entity: {ToPrettyString(uid.Value)}. Trace: {Environment.StackTrace}");
         }
 
         /// <inheritdoc />
-        public override void Dirty(EntityUid uid, Component component, MetaDataComponent? meta = null)
+        public override void Dirty(EntityUid uid, IComponent component, MetaDataComponent? meta = null)
+        {
+            Dirty(new Entity<IComponent>(uid, component), meta);
+        }
+
+        /// <inheritdoc />
+        public override void Dirty<T>(Entity<T> ent, MetaDataComponent? meta = null)
         {
             //  Client only dirties during prediction
             if (_gameTiming.InPrediction)
-                base.Dirty(uid, component, meta);
+                base.Dirty(ent, meta);
         }
 
-        public override EntityStringRepresentation ToPrettyString(EntityUid uid)
+        public override EntityStringRepresentation ToPrettyString(EntityUid uid, MetaDataComponent? metaDataComponent = null)
         {
             if (_playerManager.LocalPlayer?.ControlledEntity == uid)
                 return base.ToPrettyString(uid) with { Session = _playerManager.LocalPlayer.Session };
-            else
-                return base.ToPrettyString(uid);
+
+            return base.ToPrettyString(uid);
         }
 
         public override void RaisePredictiveEvent<T>(T msg)
@@ -161,7 +170,7 @@ namespace Robust.Client.GameObjects
         }
 
         /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntityEventArgs message, INetChannel channel)
+        public void SendSystemNetworkMessage(EntityEventArgs message, INetChannel? channel)
         {
             throw new NotSupportedException();
         }

Robust.Client/GameObjects/Components/Animations/AnimationPlayerComponent.cs

@@ -1,8 +1,6 @@
-using System;
 using System.Collections.Generic;
 using Robust.Client.Animations;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using static Robust.Client.Animations.AnimationPlaybackShared;
 
 namespace Robust.Client.GameObjects
@@ -21,42 +19,5 @@ namespace Robust.Client.GameObjects
             = new();
 
         internal bool HasPlayingAnimation = false;
-
-        /// <summary>
-        ///     Start playing an animation.
-        /// </summary>
-        /// <param name="animation">The animation to play.</param>
-        /// <param name="key">
-        ///     The key for this animation play. This key can be used to stop playback short later.
-        /// </param>
-        [Obsolete("Use AnimationPlayerSystem.Play() instead")]
-        public void Play(Animation animation, string key)
-        {
-            IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<AnimationPlayerSystem>().AddComponent(this);
-            var playback = new AnimationPlayback(animation);
-
-            PlayingAnimations.Add(key, playback);
-        }
-
-        [Obsolete("Use AnimationPlayerSystem.HasRunningAnimation() instead")]
-        public bool HasRunningAnimation(string key)
-        {
-            return PlayingAnimations.ContainsKey(key);
-        }
-
-        [Obsolete("Use AnimationPlayerSystem.Stop() instead")]
-        public void Stop(string key)
-        {
-            PlayingAnimations.Remove(key);
-        }
-
-        [Obsolete("Temporary method until the event is replaced with eventbus")]
-        internal void AnimationComplete(string key)
-        {
-            AnimationCompleted?.Invoke(key);
-        }
-
-        [Obsolete("Use AnimationCompletedEvent instead")]
-        public event Action<string>? AnimationCompleted;
     }
 }

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -1,23 +1,19 @@
+using System;
 using System.Collections.Generic;
 using Robust.Client.Animations;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Utility;
-using TerraFX.Interop.Windows;
 
 namespace Robust.Client.GameObjects
 {
-    public sealed class AnimationPlayerSystem : EntitySystem, IPostInjectInit
+    public sealed class AnimationPlayerSystem : EntitySystem
     {
-        private readonly List<AnimationPlayerComponent> _activeAnimations = new();
+        private readonly List<Entity<AnimationPlayerComponent>> _activeAnimations = new();
 
         private EntityQuery<MetaDataComponent> _metaQuery;
 
         [Dependency] private readonly IComponentFactory _compFact = default!;
-        [Dependency] private readonly ILogManager _logManager = default!;
-
-        private ISawmill _sawmill = default!;
 
         public override void Initialize()
         {
@@ -39,22 +35,22 @@ namespace Robust.Client.GameObjects
                     continue;
                 }
 
-                if (!Update(uid, anim, frameTime))
+                if (!Update(uid, anim.Comp, frameTime))
                 {
                     continue;
                 }
 
                 _activeAnimations.RemoveSwap(i);
                 i--;
-                anim.HasPlayingAnimation = false;
+                anim.Comp.HasPlayingAnimation = false;
             }
         }
 
-        internal void AddComponent(AnimationPlayerComponent component)
+        internal void AddComponent(Entity<AnimationPlayerComponent> ent)
         {
-            if (component.HasPlayingAnimation) return;
-            _activeAnimations.Add(component);
-            component.HasPlayingAnimation = true;
+            if (ent.Comp.HasPlayingAnimation) return;
+            _activeAnimations.Add(ent);
+            ent.Comp.HasPlayingAnimation = true;
         }
 
         private bool Update(EntityUid uid, AnimationPlayerComponent component, float frameTime)
@@ -79,7 +75,6 @@ namespace Robust.Client.GameObjects
             {
                 component.PlayingAnimations.Remove(key);
                 EntityManager.EventBus.RaiseLocalEvent(uid, new AnimationCompletedEvent {Uid = uid, Key = key}, true);
-                component.AnimationComplete(key);
             }
 
             return false;
@@ -90,22 +85,29 @@ namespace Robust.Client.GameObjects
         /// </summary>
         public void Play(EntityUid uid, Animation animation, string key)
         {
-            var component = EntityManager.EnsureComponent<AnimationPlayerComponent>(uid);
-            Play(component, animation, key);
+            var component = EnsureComp<AnimationPlayerComponent>(uid);
+            Play(new Entity<AnimationPlayerComponent>(uid, component), animation, key);
         }
 
+        [Obsolete("Use Play(EntityUid<AnimationPlayerComponent> ent, Animation animation, string key) instead")]
         public void Play(EntityUid uid, AnimationPlayerComponent? component, Animation animation, string key)
         {
             component ??= EntityManager.EnsureComponent<AnimationPlayerComponent>(uid);
-            Play(component, animation, key);
+            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)
         {
-            AddComponent(component);
+            Play(new Entity<AnimationPlayerComponent>(component.Owner, component), animation, key);
+        }
+
+        public void Play(Entity<AnimationPlayerComponent> ent, Animation animation, string key)
+        {
+            AddComponent(ent);
             var playback = new AnimationPlaybackShared.AnimationPlayback(animation);
 
 #if DEBUG
@@ -117,18 +119,18 @@ namespace Robust.Client.GameObjects
 
                 if (compTrack.ComponentType == null)
                 {
-                    _sawmill.Error($"Attempted to play a component animation without any component specified.");
+                    Log.Error("Attempted to play a component animation without any component specified.");
                     return;
                 }
 
-                if (!EntityManager.TryGetComponent(component.Owner, compTrack.ComponentType, out var animatedComp))
+                if (!EntityManager.TryGetComponent(ent, compTrack.ComponentType, out var animatedComp))
                 {
-                    _sawmill.Error(
-                        $"Attempted to play a component animation, but the entity {ToPrettyString(component.Owner)} does not have the component to be animated: {compTrack.ComponentType}.");
+                    Log.Error(
+                        $"Attempted to play a component animation, but the entity {ToPrettyString(ent)} does not have the component to be animated: {compTrack.ComponentType}.");
                     return;
                 }
 
-                if (IsClientSide(component.Owner) || !animatedComp.NetSyncEnabled)
+                if (IsClientSide(ent) || !animatedComp.NetSyncEnabled)
                     continue;
 
                 var reg = _compFact.GetRegistration(animatedComp);
@@ -136,12 +138,18 @@ namespace Robust.Client.GameObjects
                 // In principle there is nothing wrong with this, as long as the property of the component being
                 // animated is not part of the networked state and setting it does not dirty the component. Hence only a
                 // warning in debug mode.
-                if (reg.NetID != null)
-                    _sawmill.Warning($"Playing a component animation on a networked component {reg.Name} belonging to {ToPrettyString(component.Owner)}");
+                if (reg.NetID != null && compTrack.Property != null)
+                {
+                    if (animatedComp.GetType().GetProperty(compTrack.Property) is { } property &&
+                        property.HasCustomAttribute<AutoNetworkedFieldAttribute>())
+                    {
+                        Log.Warning($"Playing a component animation on a networked component {reg.Name} belonging to {ToPrettyString(ent)}");
+                    }
+                }
             }
 #endif
 
-            component.PlayingAnimations.Add(key, playback);
+            ent.Comp.PlayingAnimations.Add(key, playback);
         }
 
         public bool HasRunningAnimation(EntityUid uid, string key)
@@ -170,19 +178,18 @@ namespace Robust.Client.GameObjects
 
         public void Stop(EntityUid uid, string key)
         {
-            if (!TryComp<AnimationPlayerComponent>(uid, out var player)) return;
+            if (!TryComp<AnimationPlayerComponent>(uid, out var player))
+                return;
+
             player.PlayingAnimations.Remove(key);
         }
 
         public void Stop(EntityUid uid, AnimationPlayerComponent? component, string key)
         {
-            if (!Resolve(uid, ref component, false)) return;
-            component.PlayingAnimations.Remove(key);
-        }
+            if (!Resolve(uid, ref component, false))
+                return;
 
-        void IPostInjectInit.PostInject()
-        {
-            _sawmill = _logManager.GetSawmill("anim");
+            component.PlayingAnimations.Remove(key);
         }
     }
 

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -17,7 +17,6 @@ using Robust.Shared.Physics;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Systems;
 using Robust.Shared.Player;
-using Robust.Shared.Players;
 using Robust.Shared.Random;
 using Robust.Shared.Replays;
 using Robust.Shared.Threading;

Robust.Client/GameObjects/EntitySystems/EyeSystem.cs

@@ -1,7 +1,7 @@
 using Robust.Client.Graphics;
 using Robust.Client.Physics;
+using Robust.Client.Player;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameStates;
 using Robust.Shared.Graphics;
 using Robust.Shared.IoC;
 
@@ -15,15 +15,21 @@ public sealed class EyeSystem : SharedEyeSystem
     {
         base.Initialize();
         SubscribeLocalEvent<EyeComponent, ComponentInit>(OnInit);
-        SubscribeLocalEvent<EyeComponent, PlayerDetachedEvent>(OnEyeDetached);
-        SubscribeLocalEvent<EyeComponent, PlayerAttachedEvent>(OnEyeAttached);
+        SubscribeLocalEvent<EyeComponent, LocalPlayerDetachedEvent>(OnEyeDetached);
+        SubscribeLocalEvent<EyeComponent, LocalPlayerAttachedEvent>(OnEyeAttached);
+        SubscribeLocalEvent<EyeComponent, AfterAutoHandleStateEvent>(OnEyeAutoState);
 
         // Make sure this runs *after* entities have been moved by interpolation and movement.
         UpdatesAfter.Add(typeof(TransformSystem));
         UpdatesAfter.Add(typeof(PhysicsSystem));
     }
 
-    private void OnEyeAttached(EntityUid uid, EyeComponent component, PlayerAttachedEvent args)
+    private void OnEyeAutoState(EntityUid uid, EyeComponent component, ref AfterAutoHandleStateEvent args)
+    {
+        UpdateEye(component);
+    }
+
+    private void OnEyeAttached(EntityUid uid, EyeComponent component, LocalPlayerAttachedEvent args)
     {
         // TODO: This probably shouldn't be nullable bruv.
         if (component._eye != null)
@@ -35,7 +41,7 @@ public sealed class EyeSystem : SharedEyeSystem
         RaiseLocalEvent(uid, ref ev, true);
     }
 
-    private void OnEyeDetached(EntityUid uid, EyeComponent component, PlayerDetachedEvent args)
+    private void OnEyeDetached(EntityUid uid, EyeComponent component, LocalPlayerDetachedEvent args)
     {
         _eyeManager.ClearCurrentEye();
     }

Robust.Client/GameObjects/EntitySystems/GridChunkBoundsDebugSystem.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Shared.Enums;
@@ -58,6 +59,8 @@ namespace Robust.Client.GameObjects
 
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
+        private List<Entity<MapGridComponent>> _grids = new();
+
         public GridChunkBoundsOverlay(IEntityManager entManager, IEyeManager eyeManager, IMapManager mapManager)
         {
             _entityManager = entManager;
@@ -71,13 +74,15 @@ namespace Robust.Client.GameObjects
             var viewport = args.WorldBounds;
             var worldHandle = args.WorldHandle;
 
-            foreach (var grid in _mapManager.FindGridsIntersecting(currentMap, viewport))
+            _grids.Clear();
+            _mapManager.FindGridsIntersecting(currentMap, viewport, ref _grids);
+            foreach (var grid in _grids)
             {
-                var worldMatrix = _entityManager.GetComponent<TransformComponent>(grid.Owner).WorldMatrix;
+                var worldMatrix = _entityManager.GetComponent<TransformComponent>(grid).WorldMatrix;
                 worldHandle.SetTransform(worldMatrix);
                 var transform = new Transform(Vector2.Zero, Angle.Zero);
 
-                var chunkEnumerator = grid.GetMapChunks(viewport);
+                var chunkEnumerator = grid.Comp.GetMapChunks(viewport);
 
                 while (chunkEnumerator.MoveNext(out var chunk))
                 {

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -3,16 +3,13 @@ using System.Numerics;
 using Robust.Client.GameStates;
 using Robust.Client.Input;
 using Robust.Client.Player;
-using Robust.Shared;
-using Robust.Shared.Configuration;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -131,7 +128,7 @@ namespace Robust.Client.GameObjects
 
         public override void Initialize()
         {
-            SubscribeLocalEvent<PlayerAttachSysMessage>(OnAttachedEntityChanged);
+            SubscribeLocalEvent<LocalPlayerAttachedEvent>(OnAttachedEntityChanged);
 
             _conHost.RegisterCommand("incmd",
                 "Inserts an input command into the simulation",
@@ -171,11 +168,11 @@ namespace Robust.Client.GameObjects
             HandleInputCommand(localPlayer.Session, keyFunction, message);
         }
 
-        private void OnAttachedEntityChanged(PlayerAttachSysMessage message)
+        private void OnAttachedEntityChanged(LocalPlayerAttachedEvent message)
         {
-            if (message.AttachedEntity != default) // attach
+            if (message.Entity != default) // attach
             {
-                SetEntityContextActive(_inputManager, message.AttachedEntity);
+                SetEntityContextActive(_inputManager, message.Entity);
             }
             else // detach
             {
@@ -227,44 +224,4 @@ namespace Robust.Client.GameObjects
             _sawmillInputContext = _logManager.GetSawmill("input.context");
         }
     }
-
-    /// <summary>
-    ///     Entity system message that is raised when the player changes attached entities.
-    /// </summary>
-    public sealed class PlayerAttachSysMessage : EntityEventArgs
-    {
-        /// <summary>
-        ///     New entity the player is attached to.
-        /// </summary>
-        public EntityUid AttachedEntity { get; }
-
-        /// <summary>
-        ///     Creates a new instance of <see cref="PlayerAttachSysMessage"/>.
-        /// </summary>
-        /// <param name="attachedEntity">New entity the player is attached to.</param>
-        public PlayerAttachSysMessage(EntityUid attachedEntity)
-        {
-            AttachedEntity = attachedEntity;
-        }
-    }
-
-    public sealed class PlayerAttachedEvent : EntityEventArgs
-    {
-        public PlayerAttachedEvent(EntityUid entity)
-        {
-            Entity = entity;
-        }
-
-        public EntityUid Entity { get; }
-    }
-
-    public sealed class PlayerDetachedEvent : EntityEventArgs
-    {
-        public PlayerDetachedEvent(EntityUid entity)
-        {
-            Entity = entity;
-        }
-
-        public EntityUid Entity { get; }
-    }
 }

Robust.Client/GameObjects/EntitySystems/PointLightSystem.cs

@@ -25,13 +25,15 @@ namespace Robust.Client.GameObjects
             if (args.Current is not PointLightComponentState state)
                 return;
 
-            SetEnabled(uid, state.Enabled, component);
+            component.Enabled = state.Enabled;
             component.Offset = state.Offset;
             component.Softness = state.Softness;
             component.CastShadows = state.CastShadows;
             component.Energy = state.Energy;
             component.Radius = state.Radius;
             component.Color = state.Color;
+
+            _lightTree.QueueTreeUpdate(uid, component);
         }
 
         public override SharedPointLightComponent EnsureLight(EntityUid uid)

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -1,13 +1,16 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Numerics;
 using JetBrains.Annotations;
 using Robust.Client.ComponentTrees;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
+using Robust.Client.Utility;
 using Robust.Shared;
 using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Graphics.RSI;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
@@ -15,6 +18,7 @@ using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 using static Robust.Client.GameObjects.SpriteComponent;
 
 namespace Robust.Client.GameObjects
@@ -183,6 +187,48 @@ namespace Robust.Client.GameObjects
         {
             _queuedFrameUpdate.Add(uid);
         }
+
+        /// <summary>
+        /// Gets the specified frame for this sprite at the specified time.
+        /// </summary>
+        public Texture GetFrame(SpriteSpecifier spriteSpec, TimeSpan curTime)
+        {
+            Texture? sprite = null;
+
+            switch (spriteSpec)
+            {
+                case SpriteSpecifier.Rsi rsi:
+                    var rsiActual = _resourceCache.GetResource<RSIResource>(rsi.RsiPath).RSI;
+                    rsiActual.TryGetState(rsi.RsiState, out var state);
+                    var frames = state!.GetFrames(RsiDirection.South);
+                    var delays = state.GetDelays();
+                    var totalDelay = delays.Sum();
+                    var time = curTime.TotalSeconds % totalDelay;
+                    var delaySum = 0f;
+
+                    for (var i = 0; i < delays.Length; i++)
+                    {
+                        var delay = delays[i];
+                        delaySum += delay;
+
+                        if (time > delaySum)
+                            continue;
+
+                        sprite = frames[i];
+                        break;
+                    }
+
+                    sprite ??= Frame0(spriteSpec);
+                    break;
+                case SpriteSpecifier.Texture texture:
+                    sprite = texture.GetTexture(_resourceCache);
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
+
+            return sprite;
+        }
     }
 
     /// <summary>

Robust.Client/GameObjects/EntitySystems/TransformSystem.Component.cs

@@ -1,51 +1,41 @@
 using System.Numerics;
+using Robust.Client.Player;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 
 namespace Robust.Client.GameObjects;
 
 public sealed partial class TransformSystem
 {
-    public override void SetLocalPosition(TransformComponent xform, Vector2 value)
+    public override void SetLocalPosition(EntityUid uid, Vector2 value, TransformComponent? xform = null)
     {
-        xform.PrevPosition = xform._localPosition;
+        if (!XformQuery.Resolve(uid, ref xform))
+            return;
+
         xform.NextPosition = value;
-        xform.LerpParent = xform.ParentUid;
-        base.SetLocalPosition(xform, value);
-        ActivateLerp(xform);
+        ActivateLerp(uid, xform);
+        base.SetLocalPosition(uid, value, xform);
     }
 
-    public override void SetLocalPositionNoLerp(TransformComponent xform, Vector2 value)
+    public override void SetLocalRotation(EntityUid uid, Angle value, TransformComponent? xform = null)
     {
-        xform.NextPosition = null;
-        xform.LerpParent = EntityUid.Invalid;
-        base.SetLocalPositionNoLerp(xform, value);
+        if (!XformQuery.Resolve(uid, ref xform))
+            return;
+
+        xform.NextRotation = value;
+        ActivateLerp(uid, xform);
+        base.SetLocalRotation(uid, value, xform);
     }
 
-    public override void SetLocalRotationNoLerp(TransformComponent xform, Angle angle)
+    public override void SetLocalPositionRotation(EntityUid uid, Vector2 pos, Angle rot, TransformComponent? xform = null)
     {
-        xform.NextRotation = null;
-        xform.LerpParent = EntityUid.Invalid;
-        base.SetLocalRotationNoLerp(xform, angle);
-    }
+        if (!XformQuery.Resolve(uid, ref xform))
+            return;
 
-    public override void SetLocalRotation(TransformComponent xform, Angle angle)
-    {
-        xform.PrevRotation = xform._localRotation;
-        xform.NextRotation = angle;
-        xform.LerpParent = xform.ParentUid;
-        base.SetLocalRotation(xform, angle);
-        ActivateLerp(xform);
-    }
-
-    public override void SetLocalPositionRotation(TransformComponent xform, Vector2 pos, Angle rot)
-    {
-        xform.PrevPosition = xform._localPosition;
         xform.NextPosition = pos;
-        xform.PrevRotation = xform._localRotation;
         xform.NextRotation = rot;
-        xform.LerpParent = xform.ParentUid;
-        base.SetLocalPositionRotation(xform, pos, rot);
-        ActivateLerp(xform);
+        ActivateLerp(uid, xform);
+        base.SetLocalPositionRotation(uid, pos, rot, xform);
     }
 }

Robust.Client/GameObjects/EntitySystems/TransformSystem.cs

@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Generic;
 using System.Numerics;
 using JetBrains.Annotations;
@@ -25,20 +24,15 @@ namespace Robust.Client.GameObjects
         private const float MinInterpolationDistance = 0.001f;
         private const float MinInterpolationDistanceSquared = MinInterpolationDistance * MinInterpolationDistance;
 
-        private const double MinInterpolationAngle = Math.PI / 720;
-
-        // 45 degrees.
-        private const double MaxInterpolationAngle = Math.PI / 4;
-
         [Dependency] private readonly IGameTiming _gameTiming = default!;
 
         // Only keep track of transforms actively lerping.
         // Much faster than iterating 3000+ transforms every frame.
-        [ViewVariables] private readonly List<TransformComponent> _lerpingTransforms = new();
+        [ViewVariables] private readonly List<Entity<TransformComponent>> _lerpingTransforms = new();
 
         public void Reset()
         {
-            foreach (var xform in _lerpingTransforms)
+            foreach (var (_, xform) in _lerpingTransforms)
             {
                 xform.ActivelyLerping = false;
                 xform.NextPosition = null;
@@ -48,21 +42,77 @@ namespace Robust.Client.GameObjects
             _lerpingTransforms.Clear();
         }
 
-        public override void ActivateLerp(TransformComponent xform)
+        public override void ActivateLerp(EntityUid uid, TransformComponent xform)
         {
-            if (xform.ActivelyLerping)
+            // This lerping logic is pretty convoluted and generally assumes that the client does not mispredict.
+            // A more foolproof solution would be to just cache the coordinates at which any given entity was most
+            // recently rendered and using that as the lerp origin. However that'd require enumerating over all entities
+            // every tick which is pretty icky.
+
+            // The general considerations are:
+            // - If the client receives a server state for an entity moving from a->b and predicts nothing else, then it
+            //   should show the entity lerping.
+            // - If the client predicts an entity will move while already lerping due to a state-application, it should
+            //   clear the state's lerp, under the assumption that the client predicted the state and already rendered
+            //   the entity in the final position.
+            // - If the client predicts that an entity moves, then we only lerp if this is the first time that the tick
+            //   was predicted. I.e., we assume the entity was already rendered in it's final of that lerp.
+            // - If the client predicts that an entity should lerp twice in the same tick, then we need to combine them.
+            //   I.e. moving from a->b then b->c, the client should lerp from a->c.
+
+            // If the client predicts an entity moves while already lerping, it should clear the
+            // predict a->b, lerp a->b
+            // predicted a->b, then predict b->c. Lerp b->c
+            // predicted a->b, then predict b->c. Lerp b->c
+            // predicted a->b, predicted b->c, then predict c->d. Lerp c->d
+            // server state a->b, then predicted b->c, lerp b->c
+            // server state a->b, then predicted b->c, then predict d, lerp b->c
+
+            if (_gameTiming.ApplyingState)
+            {
+                if (xform.ActivelyLerping)
+                {
+                    // This should not happen, but can happen if some bad component state application code modifies an entity's coordinates.
+                    Log.Error($"Entity {(ToPrettyString(uid))} tried to lerp twice while applying component states.");
+                    return;
+                }
+
+                _lerpingTransforms.Add((uid, xform));
+                xform.ActivelyLerping = true;
+                xform.PredictedLerp = false;
+                xform.LerpParent = xform.ParentUid;
+                xform.PrevRotation = xform._localRotation;
+                xform.PrevPosition = xform._localPosition;
+                xform.LastLerp = _gameTiming.CurTick;
                 return;
+            }
 
-            xform.ActivelyLerping = true;
-            _lerpingTransforms.Add(xform);
-        }
+            xform.LastLerp = _gameTiming.CurTick;
+            if (!_gameTiming.IsFirstTimePredicted)
+            {
+                xform.ActivelyLerping = false;
+                return;
+            }
 
-        public override void DeactivateLerp(TransformComponent component)
-        {
-            // this should cause the lerp to do nothing
-            component.NextPosition = null;
-            component.NextRotation = null;
-            component.LerpParent = EntityUid.Invalid;
+            if (!xform.ActivelyLerping)
+            {
+                _lerpingTransforms.Add((uid, xform));
+                xform.ActivelyLerping = true;
+                xform.PredictedLerp = true;
+                xform.PrevRotation = xform._localRotation;
+                xform.PrevPosition = xform._localPosition;
+                xform.LerpParent = xform.ParentUid;
+                return;
+            }
+
+            if (!xform.PredictedLerp || xform.LerpParent != xform.ParentUid)
+            {
+                // Existing lerp was not due to prediction, but due to state application. That lerp should already
+                // have been rendered, so we will start a new lerp from the current position.
+                xform.PrevRotation = xform._localRotation;
+                xform.PrevPosition = xform._localPosition;
+                xform.LerpParent = xform.ParentUid;
+            }
         }
 
         public override void FrameUpdate(float frameTime)
@@ -73,12 +123,13 @@ namespace Robust.Client.GameObjects
 
             for (var i = 0; i < _lerpingTransforms.Count; i++)
             {
-                var transform = _lerpingTransforms[i];
+                var (uid, transform) = _lerpingTransforms[i];
                 var found = false;
 
                 // Only lerp if parent didn't change.
                 // E.g. entering lockers would do it.
-                if (transform.LerpParent == transform.ParentUid
+                if (transform.ActivelyLerping
+                    && transform.LerpParent == transform.ParentUid
                     && transform.ParentUid.IsValid()
                     && !transform.Deleted)
                 {
@@ -90,8 +141,7 @@ namespace Robust.Client.GameObjects
 
                         if (distance is > MinInterpolationDistanceSquared and < MaxInterpolationDistanceSquared)
                         {
-                            transform.LocalPosition = Vector2.Lerp(lerpSource, lerpDest, step);
-                            // Setting LocalPosition clears LerpPosition so fix that.
+                            SetLocalPositionNoLerp(uid, Vector2.Lerp(lerpSource, lerpDest, step), transform);
                             transform.NextPosition = lerpDest;
                             found = true;
                         }
@@ -101,15 +151,9 @@ namespace Robust.Client.GameObjects
                     {
                         var lerpDest = transform.NextRotation.Value;
                         var lerpSource = transform.PrevRotation;
-                        var distance = Math.Abs(Angle.ShortestDistance(lerpDest, lerpSource));
-
-                        if (distance is > MinInterpolationAngle and < MaxInterpolationAngle)
-                        {
-                            transform.LocalRotation = Angle.Lerp(lerpSource, lerpDest, step);
-                            // Setting LocalRotation clears LerpAngle so fix that.
-                            transform.NextRotation = lerpDest;
-                            found = true;
-                        }
+                        SetLocalRotationNoLerp(uid, Angle.Lerp(lerpSource, lerpDest, step), transform);
+                        transform.NextRotation = lerpDest;
+                        found = true;
                     }
                 }
 

Robust.Client/GameObjects/IClientEntityManagerInternal.cs

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

Robust.Client/GameStates/ClientDirtySystem.cs

@@ -1,7 +1,6 @@
 using Robust.Client.Timing;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Utility;
 using System;
 using System.Collections.Generic;
@@ -54,7 +53,7 @@ public sealed class ClientDirtySystem : EntitySystem
 
         var uid = args.BaseArgs.Owner;
         var comp = args.BaseArgs.Component;
-        if (!_timing.InPrediction || !comp.NetSyncEnabled || IsClientSide(uid))
+        if (!_timing.InPrediction || !comp.NetSyncEnabled || IsClientSide(uid, args.Meta))
             return;
 
         // Was this component added during prediction? If yes, then there is no need to re-add it when resetting.

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -4,7 +4,9 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using System.Runtime.InteropServices;
 using JetBrains.Annotations;
+using Microsoft.Extensions.ObjectPool;
 using Robust.Client.GameObjects;
 using Robust.Client.Input;
 using Robust.Client.Physics;
@@ -24,8 +26,6 @@ using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Components;
 using Robust.Shared.Profiling;
 using Robust.Shared.Replays;
 using Robust.Shared.Timing;
@@ -35,7 +35,7 @@ namespace Robust.Client.GameStates
 {
     /// <inheritdoc />
     [UsedImplicitly]
-    public sealed class ClientGameStateManager : IClientGameStateManager, IPostInjectInit
+    public sealed class ClientGameStateManager : IClientGameStateManager
     {
         private GameStateProcessor _processor = default!;
 
@@ -47,10 +47,18 @@ namespace Robust.Client.GameStates
                 = new();
 
         // Game state dictionaries that get used every tick.
-        private readonly Dictionary<EntityUid, (NetEntity NetEntity, bool EnteringPvs, GameTick LastApplied, EntityState? curState, EntityState? nextState)> _toApply = new();
+        private readonly Dictionary<EntityUid, (NetEntity NetEntity, MetaDataComponent Meta, bool EnteringPvs, GameTick LastApplied, EntityState? curState, EntityState? nextState)> _toApply = new();
         private readonly Dictionary<NetEntity, EntityState> _toCreate = new();
         private readonly Dictionary<ushort, (IComponent Component, ComponentState? curState, ComponentState? nextState)> _compStateWork = new();
         private readonly Dictionary<EntityUid, HashSet<Type>> _pendingReapplyNetStates = new();
+        private readonly HashSet<NetEntity> _stateEnts = new();
+        private readonly List<EntityUid> _toDelete = new();
+        private readonly List<IComponent> _toRemove = new();
+        private readonly Dictionary<NetEntity, Dictionary<ushort, ComponentState>> _outputData = new();
+        private readonly List<(EntityUid, TransformComponent)> _queuedBroadphaseUpdates = new();
+
+        private readonly ObjectPool<Dictionary<ushort, ComponentState>> _compDataPool =
+            new DefaultObjectPool<Dictionary<ushort, ComponentState>>(new DictPolicy<ushort, ComponentState>(), 256);
 
         private uint _metaCompNetId;
 
@@ -72,6 +80,13 @@ namespace Robust.Client.GameStates
 
         private ISawmill _sawmill = default!;
 
+        /// <summary>
+        /// If we are waiting for a full game state from the server, we will automatically re-send full state requests
+        /// if they do not arrive in time. Ideally this should never happen, this here just in case a client gets
+        /// stuck waiting for a full state that the server doesn't know the client even wants.
+        /// </summary>
+        public static readonly TimeSpan FullStateTimeout = TimeSpan.FromSeconds(10);
+
         /// <inheritdoc />
         public int MinBufferSize => _processor.MinBufferSize;
 
@@ -79,7 +94,8 @@ namespace Robust.Client.GameStates
         public int TargetBufferSize => _processor.TargetBufferSize;
 
         /// <inheritdoc />
-        public int CurrentBufferSize => _processor.CalculateBufferSize(_timing.LastRealTick);
+        public int GetApplicableStateCount() => _processor.GetApplicableStateCount();
+        public int StateCount => _processor.StateCount;
 
         public bool IsPredictionEnabled { get; private set; }
         public bool PredictionNeedsResetting { get; private set; }
@@ -101,10 +117,20 @@ namespace Robust.Client.GameStates
 
         public event Action<MsgStateLeavePvs>? PvsLeave;
 
+#if DEBUG
+        /// <summary>
+        /// If true, this will cause received game states to be ignored. Used by integration tests.
+        /// </summary>
+        public bool DropStates;
+#endif
+
         /// <inheritdoc />
         public void Initialize()
         {
-            _processor = new GameStateProcessor(_timing);
+            _sawmill = _logMan.GetSawmill("state");
+            _sawmill.Level = LogLevel.Info;
+
+            _processor = new GameStateProcessor(this, _timing, _sawmill);
 
             _network.RegisterNetMessage<MsgState>(HandleStateMessage);
             _network.RegisterNetMessage<MsgStateLeavePvs>(HandlePvsLeaveMessage);
@@ -193,6 +219,10 @@ namespace Robust.Client.GameStates
 
         private void HandleStateMessage(MsgState message)
         {
+#if DEBUG
+            if (DropStates)
+                return;
+#endif
             // We ONLY ack states that are definitely going to get applied. Otherwise the sever might assume that we
             // applied a state containing entity-creation information, which it would then no longer send to us when
             // we re-encounter this entity
@@ -224,9 +254,19 @@ namespace Robust.Client.GameStates
         /// <inheritdoc />
         public void ApplyGameState()
         {
+            // If we have been waiting for a full state for a long time, re-request a full state.
+            if (_processor.WaitingForFull
+                && _processor.LastFullStateRequested is {} last
+                && DateTime.UtcNow - last.Time > FullStateTimeout)
+            {
+                // Re-request a full state.
+                // We use the previous from-tick, just in case the full state is already on the way,
+                RequestFullState(null, last.Tick);
+            }
+
             // Calculate how many states we need to apply this tick.
             // Always at least one, but can be more based on StateBufferMergeThreshold.
-            var curBufSize = CurrentBufferSize;
+            var curBufSize = GetApplicableStateCount();
             var targetBufSize = TargetBufferSize;
 
             var bufferOverflow = curBufSize - targetBufSize - StateBufferMergeThreshold;
@@ -267,24 +307,21 @@ namespace Robust.Client.GameStates
                     continue;
                 }
 
-                if (PredictionNeedsResetting)
+                try
                 {
-                    try
-                    {
-                        ResetPredictedEntities();
-                    }
-                    catch (Exception e)
-                    {
-                        // avoid exception spam from repeatedly trying to reset the same entity.
-                        _entitySystemManager.GetEntitySystem<ClientDirtySystem>().Reset();
-                        _runtimeLog.LogException(e, "ResetPredictedEntities");
-                    }
+                    ResetPredictedEntities();
+                }
+                catch (Exception e)
+                {
+                    // avoid exception spam from repeatedly trying to reset the same entity.
+                    _entitySystemManager.GetEntitySystem<ClientDirtySystem>().Reset();
+                    _runtimeLog.LogException(e, "ResetPredictedEntities");
                 }
 
                 // If we were waiting for a new state, we are now applying it.
-                if (_processor.LastFullStateRequested.HasValue)
+                if (_processor.WaitingForFull)
                 {
-                    _processor.LastFullStateRequested = null;
+                    _processor.OnFullStateReceived();
                     _timing.LastProcessedTick = curState.ToSequence;
                     DebugTools.Assert(curState.FromSequence == GameTick.Zero);
                     PartialStateReset(curState, true);
@@ -349,7 +386,7 @@ namespace Robust.Client.GameStates
             if (_processor.WaitingForFull)
                 _timing.TickTimingAdjustment = 0f;
             else
-                _timing.TickTimingAdjustment = (CurrentBufferSize - (float)TargetBufferSize) * 0.10f;
+                _timing.TickTimingAdjustment = (GetApplicableStateCount() - (float)TargetBufferSize) * 0.10f;
 
             // If we are about to process an another tick in the same frame, lets not bother unnecessarily running prediction ticks
             // Really the main-loop ticking just needs to be more specialized for clients.
@@ -394,11 +431,11 @@ namespace Robust.Client.GameStates
             }
         }
 
-        public void RequestFullState(NetEntity? missingEntity = null)
+        public void RequestFullState(NetEntity? missingEntity = null, GameTick? tick = null)
         {
             _sawmill.Info("Requesting full server state");
             _network.ClientSendMessage(new MsgStateRequestFull { Tick = _timing.LastRealTick , MissingEntity = missingEntity ?? NetEntity.Invalid });
-            _processor.RequestFullState();
+            _processor.OnFullStateRequested(tick ?? _timing.LastRealTick);
         }
 
         public void PredictTicks(GameTick predictionTarget)
@@ -467,19 +504,21 @@ namespace Robust.Client.GameStates
 
         public void ResetPredictedEntities()
         {
-            PredictionNeedsResetting = false;
-
             using var _ = _prof.Group("ResetPredictedEntities");
             using var __ = _timing.StartStateApplicationArea();
 
+            // This is terrible, and I hate it. This also needs to run even when prediction is disabled.
+            _entitySystemManager.GetEntitySystem<SharedGridTraversalSystem>().QueuedEvents.Clear();
+            _entitySystemManager.GetEntitySystem<TransformSystem>().Reset();
+
+            if (!PredictionNeedsResetting)
+                return;
+
+            PredictionNeedsResetting = false;
             var countReset = 0;
             var system = _entitySystemManager.GetEntitySystem<ClientDirtySystem>();
             var metaQuery = _entityManager.GetEntityQuery<MetaDataComponent>();
-            RemQueue<Component> toRemove = new();
-
-            // This is terrible, and I hate it.
-            _entitySystemManager.GetEntitySystem<SharedGridTraversalSystem>().QueuedEvents.Clear();
-            _entitySystemManager.GetEntitySystem<TransformSystem>().Reset();
+            RemQueue<IComponent> toRemove = new();
 
             foreach (var entity in system.DirtyEntities)
             {
@@ -497,11 +536,7 @@ namespace Robust.Client.GameStates
 
                 countReset += 1;
 
-                var netComps = _entityManager.GetNetComponentsOrNull(entity);
-                if (netComps == null)
-                    continue;
-
-                foreach (var (netId, comp) in netComps.Value)
+                foreach (var (netId, comp) in meta.NetComponents)
                 {
                     if (!comp.NetSyncEnabled)
                         continue;
@@ -549,13 +584,13 @@ namespace Robust.Client.GameStates
                 {
                     foreach (var netId in netIds)
                     {
-                        if (_entities.HasComponent(entity, netId))
+                        if (meta.NetComponents.ContainsKey(netId))
                             continue;
 
                         if (!last.TryGetValue(netId, out var state))
                             continue;
 
-                        var comp = _entityManager.AddComponent(entity, netId);
+                        var comp = _entityManager.AddComponent(entity, netId, meta);
 
                         if (_sawmill.Level <= LogLevel.Debug)
                             _sawmill.Debug($"  A component was removed: {comp.GetType()}");
@@ -588,20 +623,19 @@ namespace Robust.Client.GameStates
         ///     Whenever a new entity is created, the server doesn't send full state data, given that much of the data
         ///     can simply be obtained from the entity prototype information. This function basically creates a fake
         ///     initial server state for any newly created entity. It does this by simply using the standard <see
-        ///     cref="IEntityManager.GetComponentState(IEventBus, IComponent)"/>.
+        ///     cref="IEntityManager.GetComponentState"/>.
         /// </remarks>
         private void MergeImplicitData(IEnumerable<NetEntity> createdEntities)
         {
-            var outputData = new Dictionary<NetEntity, Dictionary<ushort, ComponentState>>();
             var bus = _entityManager.EventBus;
 
             foreach (var netEntity in createdEntities)
             {
-                var createdEntity = _entityManager.GetEntity(netEntity);
-                var compData = new Dictionary<ushort, ComponentState>();
-                outputData.Add(netEntity, compData);
+                var (createdEntity, meta) = _entityManager.GetEntityData(netEntity);
+                var compData = _compDataPool.Get();
+                _outputData.Add(netEntity, compData);
 
-                foreach (var (netId, component) in _entityManager.GetNetComponents(createdEntity))
+                foreach (var (netId, component) in meta.NetComponents)
                 {
                     if (!component.NetSyncEnabled)
                         continue;
@@ -612,7 +646,14 @@ namespace Robust.Client.GameStates
                 }
             }
 
-            _processor.MergeImplicitData(outputData);
+            _processor.MergeImplicitData(_outputData);
+
+            foreach (var data in _outputData.Values)
+            {
+                _compDataPool.Return(data);
+            }
+
+            _outputData.Clear();
         }
 
         private void AckGameState(GameTick sequence)
@@ -648,7 +689,7 @@ namespace Robust.Client.GameStates
 
             using (_prof.Group("Player"))
             {
-                _players.ApplyPlayerStates(curState.PlayerStates.Value ?? Array.Empty<PlayerState>());
+                _players.ApplyPlayerStates(curState.PlayerStates.Value ?? Array.Empty<SessionState>());
             }
 
             using (_prof.Group("Callback"))
@@ -690,11 +731,9 @@ namespace Robust.Client.GameStates
                     if (metaState == null)
                         throw new MissingMetadataException(es.NetEntity);
 
-                    var uid = _entities.CreateEntity(metaState.PrototypeId);
+                    var uid = _entities.CreateEntity(metaState.PrototypeId, out var newMeta);
                     _toCreate.Add(es.NetEntity, es);
-                    _toApply.Add(uid, (es.NetEntity, false, GameTick.Zero, es, null));
-
-                    var newMeta = metas.GetComponent(uid);
+                    _toApply.Add(uid, (es.NetEntity, newMeta, false, GameTick.Zero, es, null));
 
                     // Client creates a client-side net entity for the newly created entity.
                     // We need to clear this mapping before assigning the real net id.
@@ -725,9 +764,7 @@ namespace Robust.Client.GameStates
                 if (_toCreate.ContainsKey(es.NetEntity))
                     continue;
 
-                var uid = _entityManager.GetEntity(es.NetEntity);
-
-                if (!metas.TryGetComponent(uid, out var meta))
+                if (!_entityManager.TryGetEntityData(es.NetEntity, out var uid, out var meta))
                     continue;
 
                 bool isEnteringPvs = (meta.Flags & MetaDataFlags.Detached) != 0;
@@ -742,7 +779,7 @@ namespace Robust.Client.GameStates
                     continue;
                 }
 
-                _toApply.Add(uid, (es.NetEntity, isEnteringPvs, meta.LastStateApplied, es, null));
+                _toApply.Add(uid.Value, (es.NetEntity, meta, isEnteringPvs, meta.LastStateApplied, es, null));
                 meta.LastStateApplied = curState.ToSequence;
             }
 
@@ -756,39 +793,46 @@ namespace Robust.Client.GameStates
             {
                 foreach (var es in nextState.EntityStates.Span)
                 {
-                    if (!_entityManager.TryGetEntity(es.NetEntity, out var uid))
+                    if (!_entityManager.TryGetEntityData(es.NetEntity, out var uid, out var meta))
                         continue;
 
-                    DebugTools.Assert(metas.HasComponent(uid));
-
                     // Does the next state actually have any future information about this entity that could be used for interpolation?
                     if (es.EntityLastModified != nextState.ToSequence)
                         continue;
 
-                    if (_toApply.TryGetValue(uid.Value, out var state))
-                        _toApply[uid.Value] = (es.NetEntity, state.EnteringPvs, state.LastApplied, state.curState, es);
+                    ref var state = ref CollectionsMarshal.GetValueRefOrAddDefault(_toApply, uid.Value, out var exists);
+
+                    if (exists)
+                        state = (es.NetEntity, meta, state.EnteringPvs, state.LastApplied, state.curState, es);
                     else
-                        _toApply[uid.Value] = (es.NetEntity, false, GameTick.Zero, null, es);
+                        state = (es.NetEntity, meta, false, GameTick.Zero, null, es);
                 }
             }
 
             // Check pending states and see if we need to force any entities to re-run component states.
             foreach (var uid in _pendingReapplyNetStates.Keys)
             {
-                if (_toApply.ContainsKey(uid))
+                // Original entity referencing the NetEntity may have been deleted.
+                if (!metas.TryGetComponent(uid, out var meta))
                     continue;
 
-                _toApply[uid] = (_entityManager.GetNetEntity(uid), false, GameTick.Zero, null, null);
+                // State already being re-applied so don't bulldoze it.
+                ref var state = ref CollectionsMarshal.GetValueRefOrAddDefault(_toApply, uid, out var exists);
+
+                if (exists)
+                    continue;
+
+                state = (meta.NetEntity, meta, false, GameTick.Zero, null, null);
             }
 
-            var queuedBroadphaseUpdates = new List<(EntityUid, TransformComponent)>(enteringPvs);
+            _queuedBroadphaseUpdates.Clear();
 
             // Apply entity states.
             using (_prof.Group("Apply States"))
             {
                 foreach (var (entity, data) in _toApply)
                 {
-                    HandleEntityState(entity, data.NetEntity, _entities.EventBus, data.curState,
+                    HandleEntityState(entity, data.NetEntity, data.Meta, _entities.EventBus, data.curState,
                         data.nextState, data.LastApplied, curState.ToSequence, data.EnteringPvs);
 
                     if (!data.EnteringPvs)
@@ -801,7 +845,7 @@ namespace Robust.Client.GameStates
                     DebugTools.Assert(xform.Broadphase == BroadphaseData.Invalid);
                     xform.Broadphase = null;
                     if (!_toApply.TryGetValue(xform.ParentUid, out var parent) || !parent.EnteringPvs)
-                        queuedBroadphaseUpdates.Add((entity, xform));
+                        _queuedBroadphaseUpdates.Add((entity, xform));
                 }
 
                 _prof.WriteValue("Count", ProfData.Int32(_toApply.Count));
@@ -812,7 +856,7 @@ namespace Robust.Client.GameStates
             {
                 try
                 {
-                    foreach (var (uid, xform) in queuedBroadphaseUpdates)
+                    foreach (var (uid, xform) in _queuedBroadphaseUpdates)
                     {
                         lookupSys.FindAndAddToEntityTree(uid, true, xform);
                     }
@@ -829,7 +873,7 @@ namespace Robust.Client.GameStates
             {
                 try
                 {
-                    ProcessDeletions(delSpan, xforms, metas, xformSys);
+                    ProcessDeletions(delSpan, xforms, xformSys);
                 }
                 catch (Exception e)
                 {
@@ -866,17 +910,17 @@ namespace Robust.Client.GameStates
             _sawmill.Info($"Resetting all entity states to tick {state.ToSequence}.");
 
             // Construct hashset for set.Contains() checks.
+            _stateEnts.Clear();
             var entityStates = state.EntityStates.Span;
-            var stateEnts = new HashSet<NetEntity>();
             foreach (var entState in entityStates)
             {
-                stateEnts.Add(entState.NetEntity);
+                _stateEnts.Add(entState.NetEntity);
             }
 
             var xforms = _entities.GetEntityQuery<TransformComponent>();
             var xformSys = _entitySystemManager.GetEntitySystem<SharedTransformSystem>();
 
-            var toDelete = new List<EntityUid>(Math.Max(64, _entities.EntityCount - stateEnts.Count));
+            _toDelete.Clear();
 
             // Client side entities won't need the transform, but that should always be a tiny minority of entities
             var metaQuery = _entityManager.AllEntityQueryEnumerator<MetaDataComponent, TransformComponent>();
@@ -887,14 +931,16 @@ namespace Robust.Client.GameStates
                 if (metadata.NetEntity.IsClientSide())
                 {
                     if (deleteClientEntities)
-                        toDelete.Add(ent);
+                        _toDelete.Add(ent);
+
                     continue;
                 }
 
-                if (stateEnts.Contains(netEnt))
+                if (_stateEnts.Contains(netEnt))
                 {
                     if (resetAllEntities || metadata.LastStateApplied > state.ToSequence)
                         metadata.LastStateApplied = GameTick.Zero; // TODO track last-state-applied for individual components? Is it even worth it?
+
                     continue;
                 }
 
@@ -912,13 +958,14 @@ namespace Robust.Client.GameStates
                         && !deleteClientEntities // don't add duplicates
                         && _entities.IsClientSide(child.Value))
                     {
-                        toDelete.Add(child.Value);
+                        _toDelete.Add(child.Value);
                     }
                 }
-                toDelete.Add(ent);
+
+                _toDelete.Add(ent);
             }
 
-            foreach (var ent in toDelete)
+            foreach (var ent in _toDelete)
             {
                 _entities.DeleteEntity(ent);
             }
@@ -927,7 +974,6 @@ namespace Robust.Client.GameStates
         private void ProcessDeletions(
             ReadOnlySpan<NetEntity> delSpan,
             EntityQuery<TransformComponent> xforms,
-            EntityQuery<MetaDataComponent> metas,
             SharedTransformSystem xformSys)
         {
             // Processing deletions is non-trivial, because by default deletions will also delete all child entities.
@@ -998,6 +1044,7 @@ namespace Robust.Client.GameStates
             // things like container insertion and ejection.
 
             using var _ = _prof.Group("Leave PVS");
+            detached.EnsureCapacity(toDetach.Count);
 
             foreach (var (tick, ents) in toDetach)
             {
@@ -1020,9 +1067,7 @@ namespace Robust.Client.GameStates
         {
             foreach (var netEntity in entities)
             {
-                var ent = _entityManager.GetEntity(netEntity);
-
-                if (!metas.TryGetComponent(ent, out var meta))
+                if (!_entityManager.TryGetEntityData(netEntity, out var ent, out var meta))
                     continue;
 
                 if (meta.LastStateApplied > maxTick)
@@ -1038,10 +1083,10 @@ namespace Robust.Client.GameStates
                 if (lastStateApplied.HasValue)
                     meta.LastStateApplied = lastStateApplied.Value;
 
-                var xform = xforms.GetComponent(ent);
+                var xform = xforms.GetComponent(ent.Value);
                 if (xform.ParentUid.IsValid())
                 {
-                    lookupSys.RemoveFromEntityTree(ent, xform);
+                    lookupSys.RemoveFromEntityTree(ent.Value, xform);
                     xform.Broadphase = BroadphaseData.Invalid;
 
                     // In some cursed scenarios an entity inside of a container can leave PVS without the container itself leaving PVS.
@@ -1050,13 +1095,13 @@ namespace Robust.Client.GameStates
                     if ((meta.Flags & MetaDataFlags.InContainer) != 0 &&
                         metas.TryGetComponent(xform.ParentUid, out var containerMeta) &&
                         (containerMeta.Flags & MetaDataFlags.Detached) == 0 &&
-                        containerSys.TryGetContainingContainer(xform.ParentUid, ent, out container, null, true))
+                        containerSys.TryGetContainingContainer(xform.ParentUid, ent.Value, out container, null, true))
                     {
-                        container.Remove(ent, _entities, xform, meta, false, true);
+                        container.Remove(ent.Value, _entities, xform, meta, false, true);
                     }
 
                     meta._flags |= MetaDataFlags.Detached;
-                    xformSys.DetachParentToNull(ent, xform);
+                    xformSys.DetachParentToNull(ent.Value, xform);
                     DebugTools.Assert((meta.Flags & MetaDataFlags.InContainer) == 0);
 
                     if (container != null)
@@ -1128,7 +1173,7 @@ namespace Robust.Client.GameStates
 #endif
         }
 
-        private void HandleEntityState(EntityUid uid, NetEntity netEntity, IEventBus bus, EntityState? curState,
+        private void HandleEntityState(EntityUid uid, NetEntity netEntity, MetaDataComponent meta, IEventBus bus, EntityState? curState,
             EntityState? nextState, GameTick lastApplied, GameTick toTick, bool enteringPvs)
         {
             _compStateWork.Clear();
@@ -1136,16 +1181,17 @@ namespace Robust.Client.GameStates
             // First remove any deleted components
             if (curState?.NetComponents != null)
             {
-                RemQueue<Component> toRemove = new();
-                foreach (var (id, comp) in _entities.GetNetComponents(uid))
+                _toRemove.Clear();
+
+                foreach (var (id, comp) in meta.NetComponents)
                 {
                     if (comp.NetSyncEnabled && !curState.NetComponents.Contains(id))
-                        toRemove.Add(comp);
+                        _toRemove.Add(comp);
                 }
 
-                foreach (var comp in toRemove)
+                foreach (var comp in _toRemove)
                 {
-                    _entities.RemoveComponent(uid, comp);
+                    _entities.RemoveComponent(uid, comp, meta);
                 }
             }
 
@@ -1158,12 +1204,10 @@ namespace Robust.Client.GameStates
                 // the entity. most notably, all entities will have been ejected from their containers.
                 foreach (var (id, state) in _processor.GetLastServerStates(netEntity))
                 {
-                    if (!_entityManager.TryGetComponent(uid, id, out var comp))
+                    if (!meta.NetComponents.TryGetValue(id, out var comp))
                     {
                         comp = _compFactory.GetComponent(id);
-                        var newComp = (Component)comp;
-                        newComp.Owner = uid;
-                        _entityManager.AddComponent(uid, newComp, true);
+                        _entityManager.AddComponent(uid, comp, true, metadata: meta);
                     }
 
                     _compStateWork[id] = (comp, state, null);
@@ -1173,12 +1217,10 @@ namespace Robust.Client.GameStates
             {
                 foreach (var compChange in curState.ComponentChanges.Span)
                 {
-                    if (!_entityManager.TryGetComponent(uid, compChange.NetID, out var comp))
+                    if (!meta.NetComponents.TryGetValue(compChange.NetID, out var comp))
                     {
                         comp = _compFactory.GetComponent(compChange.NetID);
-                        var newComp = (Component)comp;
-                        newComp.Owner = uid;
-                        _entityManager.AddComponent(uid, newComp, true);
+                        _entityManager.AddComponent(uid, comp, true, metadata:meta);
                     }
                     else if (compChange.LastModifiedTick <= lastApplied && lastApplied != GameTick.Zero)
                         continue;
@@ -1194,17 +1236,20 @@ namespace Robust.Client.GameStates
                     if (compState.LastModifiedTick != toTick + 1)
                         continue;
 
-                    if (!_entityManager.TryGetComponent(uid, compState.NetID, out var comp))
+                    if (!meta.NetComponents.TryGetValue(compState.NetID, out var comp))
                     {
                         // The component can be null here due to interp, because the NEXT state will have a new
                         // component, but the component does not yet exist.
                         continue;
                     }
 
-                    if (_compStateWork.TryGetValue(compState.NetID, out var state))
-                        _compStateWork[compState.NetID] = (comp, state.curState, compState.State);
+                    ref var state =
+                        ref CollectionsMarshal.GetValueRefOrAddDefault(_compStateWork, compState.NetID, out var exists);
+
+                    if (exists)
+                        state = (comp, state.curState, compState.State);
                     else
-                        _compStateWork[compState.NetID] = (comp, null, compState.State);
+                        state = (comp, null, compState.State);
                 }
             }
 
@@ -1221,14 +1266,19 @@ namespace Robust.Client.GameStates
                     if (netId == null)
                         continue;
 
-                    if (_compStateWork.ContainsKey(netId.Value) ||
-                        !_entityManager.TryGetComponent(uid, type, out var comp) ||
+                    if (!meta.NetComponents.TryGetValue(netId.Value, out var comp) ||
                         !lastState.TryGetValue(netId.Value, out var lastCompState))
                     {
                         continue;
                     }
 
-                    _compStateWork[netId.Value] = (comp, lastCompState, null);
+                    ref var compState =
+                        ref CollectionsMarshal.GetValueRefOrAddDefault(_compStateWork, netId.Value, out var exists);
+
+                    if (exists)
+                        continue;
+
+                    compState = (comp, lastCompState, null);
                 }
             }
 
@@ -1239,13 +1289,15 @@ namespace Robust.Client.GameStates
                     var handleState = new ComponentHandleState(cur, next);
                     bus.RaiseComponentEvent(comp, ref handleState);
                 }
+#pragma warning disable CS0168 // Variable is declared but never used
                 catch (Exception e)
+#pragma warning restore CS0168 // Variable is declared but never used
                 {
 #if EXCEPTION_TOLERANCE
-                        _sawmill.Error($"Failed to apply comp state: entity={comp.Owner}, comp={comp.GetType()}");
-                        _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(HandleEntityState)}");
+                    _sawmill.Error($"Failed to apply comp state: entity={_entities.ToPrettyString(uid)}, comp={comp.GetType()}");
+                    _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(HandleEntityState)}");
 #else
-                    _sawmill.Error($"Failed to apply comp state: entity={uid}, comp={comp.GetType()}");
+                    _sawmill.Error($"Failed to apply comp state: entity={_entities.ToPrettyString(uid)}, comp={comp.GetType()}");
                     throw;
 #endif
                 }
@@ -1393,12 +1445,10 @@ namespace Robust.Client.GameStates
 
             foreach (var (id, state) in lastState)
             {
-                if (!_entityManager.TryGetComponent(uid, id, out var comp))
+                if (!meta.NetComponents.TryGetValue(id, out var comp))
                 {
                     comp = _compFactory.GetComponent(id);
-                    var newComp = (Component)comp;
-                    newComp.Owner = uid;
-                    _entityManager.AddComponent(uid, newComp, true);
+                    _entityManager.AddComponent(uid, comp, true, meta);
                 }
 
                 var handleState = new ComponentHandleState(state, null);
@@ -1406,24 +1456,23 @@ namespace Robust.Client.GameStates
             }
 
             // ensure we don't have any extra components
-            RemQueue<Component> toRemove = new();
-            foreach (var (id, comp) in _entities.GetNetComponents(uid))
+            _toRemove.Clear();
+
+            foreach (var (id, comp) in meta.NetComponents)
             {
                 if (comp.NetSyncEnabled && !lastState.ContainsKey(id))
-                    toRemove.Add(comp);
+                    _toRemove.Add(comp);
             }
 
-            foreach (var comp in toRemove)
+            foreach (var comp in _toRemove)
             {
                 _entities.RemoveComponent(uid, comp);
             }
         }
         #endregion
 
-        void IPostInjectInit.PostInject()
-        {
-            _sawmill = _logMan.GetSawmill(CVars.NetPredict.Name);
-        }
+        public bool IsQueuedForDetach(NetEntity entity)
+            => _processor.IsQueuedForDetach(entity);
     }
 
     public sealed class GameStateAppliedArgs : EventArgs

Robust.Client/GameStates/GameStateProcessor.cs

@@ -1,43 +1,31 @@
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
 using Robust.Client.Timing;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
-using Robust.Shared.IoC;
 using Robust.Shared.Log;
-using Robust.Shared.Network.Messages;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameStates
 {
     /// <inheritdoc />
-    internal sealed class GameStateProcessor : IGameStateProcessor, IPostInjectInit
+    internal sealed class GameStateProcessor : IGameStateProcessor
     {
-        [Dependency] private ILogManager _logMan = default!;
+        public const int MaxBufferSize = 512;
 
         private readonly IClientGameTiming _timing;
+        private readonly IClientGameStateManager _state;
+        private readonly ISawmill _logger;
 
         private readonly List<GameState> _stateBuffer = new();
 
         private readonly Dictionary<GameTick, List<NetEntity>> _pvsDetachMessages = new();
-
-        private ISawmill _logger = default!;
-        private ISawmill _stateLogger = default!;
-
         public GameState? LastFullState { get; private set; }
         public bool WaitingForFull => LastFullStateRequested.HasValue;
-        public GameTick? LastFullStateRequested
-        {
-            get => _lastFullStateRequested;
-            set
-            {
-                _lastFullStateRequested = value;
-                LastFullState = null;
-            }
-        }
-
-        public GameTick? _lastFullStateRequested = GameTick.Zero;
+        public (GameTick Tick, DateTime Time)? LastFullStateRequested { get; private set; } = (GameTick.Zero, DateTime.MaxValue);
 
         private int _bufferSize;
 
@@ -70,9 +58,12 @@ namespace Robust.Client.GameStates
         ///     Constructs a new instance of <see cref="GameStateProcessor"/>.
         /// </summary>
         /// <param name="timing">Timing information of the current state.</param>
-        public GameStateProcessor(IClientGameTiming timing)
+        /// <param name="clientGameStateManager"></param>
+        public GameStateProcessor(IClientGameStateManager state, IClientGameTiming timing, ISawmill logger)
         {
             _timing = timing;
+            _state = state;
+            _logger = logger;
         }
 
         /// <inheritdoc />
@@ -82,7 +73,7 @@ namespace Robust.Client.GameStates
             if (state.ToSequence <= _timing.LastRealTick)
             {
                 if (Logging)
-                    _stateLogger.Debug($"Received Old GameState: lastRealTick={_timing.LastRealTick}, fSeq={state.FromSequence}, tSeq={state.ToSequence}, sz={state.PayloadSize}, buf={_stateBuffer.Count}");
+                    _logger.Debug($"Received Old GameState: lastRealTick={_timing.LastRealTick}, fSeq={state.FromSequence}, tSeq={state.ToSequence}, sz={state.PayloadSize}, buf={_stateBuffer.Count}");
 
                 return false;
             }
@@ -94,7 +85,7 @@ namespace Robust.Client.GameStates
                     continue;
 
                 if (Logging)
-                    _stateLogger.Debug($"Received Dupe GameState: lastRealTick={_timing.LastRealTick}, fSeq={state.FromSequence}, tSeq={state.ToSequence}, sz={state.PayloadSize}, buf={_stateBuffer.Count}");
+                    _logger.Debug($"Received Dupe GameState: lastRealTick={_timing.LastRealTick}, fSeq={state.FromSequence}, tSeq={state.ToSequence}, sz={state.PayloadSize}, buf={_stateBuffer.Count}");
 
                 return false;
             }
@@ -103,13 +94,13 @@ namespace Robust.Client.GameStates
             if (!WaitingForFull)
             {
                 // This is a good state that we will be using.
-                _stateBuffer.Add(state);
+                TryAdd(state);
                 if (Logging)
-                    _stateLogger.Debug($"Received New GameState: lastRealTick={_timing.LastRealTick}, fSeq={state.FromSequence}, tSeq={state.ToSequence}, sz={state.PayloadSize}, buf={_stateBuffer.Count}");
+                    _logger.Debug($"Received New GameState: lastRealTick={_timing.LastRealTick}, fSeq={state.FromSequence}, tSeq={state.ToSequence}, sz={state.PayloadSize}, buf={_stateBuffer.Count}");
                 return true;
             }
 
-            if (LastFullState == null && state.FromSequence == GameTick.Zero && state.ToSequence >= LastFullStateRequested!.Value)
+            if (LastFullState == null && state.FromSequence == GameTick.Zero && state.ToSequence >= LastFullStateRequested!.Value.Tick)
             {
                 LastFullState = state;
 
@@ -127,10 +118,44 @@ namespace Robust.Client.GameStates
                 return false;
             }
 
-            _stateBuffer.Add(state);
+            TryAdd(state);
             return true;
         }
 
+        public void TryAdd(GameState state)
+        {
+            if (_stateBuffer.Count <= MaxBufferSize)
+            {
+                _stateBuffer.Add(state);
+                return;
+            }
+
+            // This can happen if a required state gets dropped somehow and the client keeps receiving future
+            // game states that they can't apply. I.e., GetApplicableStateCount() is zero, even though there are many
+            // states in the list.
+            //
+            // This can seemingly happen when the server sends ""reliable"" game states while the client is paused?
+            // For example, when debugging the client, while the server is running:
+            // - The client stops sending acks for states that the server sends out.
+            // - Thus the client will exceed the net.force_ack_threshold cvar
+            // - The server starts sending some packets ""reliably"" and just force updates the clients last ack.
+            //
+            // What should happen is that when the client resumes, it receives the reliably sent states and can just
+            // resume. However, even though the packets are sent ""reliably"", they just seem to get dropped.
+            // I don't quite understand how/why yet, but this ensures the client doesn't get stuck.
+#if FULL_RELEASE
+            _logger.Warning(@$"Exceeded maximum state buffer size!
+Tick: {_timing.CurTick}/{_timing.LastProcessedTick}/{_timing.LastRealTick}
+Size: {_stateBuffer.Count}
+Applicable states: {GetApplicableStateCount()}
+Was waiting for full: {WaitingForFull} {LastFullStateRequested}
+Had full state: {LastFullState != null}"
+            );
+#endif
+
+            _state.RequestFullState();
+        }
+
         /// <summary>
         ///     Attempts to get the current and next states to apply.
         /// </summary>
@@ -151,7 +176,7 @@ namespace Robust.Client.GameStates
                     "Tried to apply a non-extrapolated state that has too high of a FromSequence!");
 
                 if (Logging)
-                    _stateLogger.Debug($"Applying State:  cTick={_timing.LastProcessedTick}, fSeq={curState.FromSequence}, tSeq={curState.ToSequence}, buf={_stateBuffer.Count}");
+                    _logger.Debug($"Applying State:  cTick={_timing.LastProcessedTick}, fSeq={curState.FromSequence}, tSeq={curState.ToSequence}, buf={_stateBuffer.Count}");
             }
 
             return applyNextState;
@@ -343,14 +368,20 @@ namespace Robust.Client.GameStates
         {
             _stateBuffer.Clear();
             LastFullState = null;
-            LastFullStateRequested = GameTick.Zero;
+            LastFullStateRequested = (GameTick.Zero, DateTime.MaxValue);
         }
 
-        public void RequestFullState()
+        public void OnFullStateRequested(GameTick tick)
         {
             _stateBuffer.Clear();
             LastFullState = null;
-            LastFullStateRequested = _timing.LastRealTick;
+            LastFullStateRequested = (tick, DateTime.UtcNow);
+        }
+
+        public void OnFullStateReceived()
+        {
+            LastFullState = null;
+            LastFullStateRequested = null;
         }
 
         public void MergeImplicitData(Dictionary<NetEntity, Dictionary<ushort, ComponentState>> implicitData)
@@ -361,9 +392,11 @@ namespace Robust.Client.GameStates
 
                 foreach (var (netId, implicitCompState) in implicitEntState)
                 {
-                    if (!fullRep.TryGetValue(netId, out var serverState))
+                    ref var serverState = ref CollectionsMarshal.GetValueRefOrAddDefault(fullRep, netId, out var exists);
+
+                    if (!exists)
                     {
-                        fullRep.Add(netId, implicitCompState);
+                        serverState = implicitCompState;
                         continue;
                     }
 
@@ -379,7 +412,7 @@ namespace Robust.Client.GameStates
                     }
 
                     serverDelta.ApplyToFullState(implicitCompState);
-                    fullRep[netId] = implicitCompState;
+                    serverState = implicitCompState;
                     DebugTools.Assert(implicitCompState is IComponentDeltaState d && d.FullState);
                 }
             }
@@ -401,10 +434,23 @@ namespace Robust.Client.GameStates
             return _lastStateFullRep.TryGetValue(entity, out dictionary);
         }
 
-        public int CalculateBufferSize(GameTick fromTick)
+        public bool IsQueuedForDetach(NetEntity entity)
         {
+            // This isn't fast, but its just meant for use in tests & debug asserts.
+            foreach (var msg in _pvsDetachMessages.Values)
+            {
+                if (msg.Contains(entity))
+                    return true;
+            }
+
+            return false;
+        }
+
+        public int GetApplicableStateCount(GameTick? fromTick = null)
+        {
+            fromTick ??= _timing.LastRealTick;
             bool foundState;
-            var nextTick = fromTick;
+            var nextTick = fromTick.Value;
 
             do
             {
@@ -422,13 +468,9 @@ namespace Robust.Client.GameStates
             }
             while (foundState);
 
-            return (int) (nextTick.Value - fromTick.Value);
+            return (int) (nextTick.Value - fromTick.Value.Value);
         }
 
-        void IPostInjectInit.PostInject()
-        {
-            _logger = _logMan.GetSawmill("net");
-            _stateLogger = _logMan.GetSawmill("net.state");
-        }
+        public int StateCount => _stateBuffer.Count;
     }
 }

Robust.Client/GameStates/IClientGameStateManager.cs

@@ -32,7 +32,15 @@ namespace Robust.Client.GameStates
         /// <summary>
         ///     Number of applicable game states currently in the state buffer.
         /// </summary>
-        int CurrentBufferSize { get; }
+        int GetApplicableStateCount();
+
+        [Obsolete("use GetApplicableStateCount()")]
+        int CurrentBufferSize => GetApplicableStateCount();
+
+        /// <summary>
+        ///     Total number of game states currently in the state buffer.
+        /// </summary>
+        int StateCount { get; }
 
         /// <summary>
         ///     If the buffer size is this many states larger than the target buffer size,
@@ -91,7 +99,7 @@ namespace Robust.Client.GameStates
         /// <summary>
         ///     Requests a full state from the server. This should override even implicit entity data.
         /// </summary>
-        void RequestFullState(NetEntity? missingEntity = null);
+        void RequestFullState(NetEntity? missingEntity = null, GameTick? tick = null);
 
         uint SystemMessageDispatched<T>(T message) where T : EntityEventArgs;
 

Robust.Client/GameStates/IGameStateProcessor.cs

@@ -96,7 +96,7 @@ namespace Robust.Client.GameStates
         ///     This includes only applicable states. If there is a gap, future buffers are not included.
         /// </summary>
         /// <param name="fromTick">The tick to calculate from.</param>
-        int CalculateBufferSize(GameTick fromTick);
+        int GetApplicableStateCount(GameTick? fromTick);
 
         bool TryGetLastServerStates(NetEntity entity,
             [NotNullWhen(true)] out Dictionary<ushort, ComponentState>? dictionary);

Robust.Client/GameStates/NetGraphOverlay.cs

@@ -68,7 +68,7 @@ namespace Robust.Client.GameStates
             var lag = _netManager.ServerChannel!.Ping;
 
             // calc interp info
-            var buffer = _gameStateManager.CurrentBufferSize;
+            var buffer = _gameStateManager.GetApplicableStateCount();
 
             _totalHistoryPayload += sz;
             _history.Add((toSeq, sz, lag, buffer));
@@ -268,7 +268,7 @@ namespace Robust.Client.GameStates
                 handle.DrawString(_font, new Vector2(LeftMargin + width, lastLagY), $"{lastLagMs.ToString()}ms");
 
             // buffer text
-            handle.DrawString(_font, new Vector2(LeftMargin, height + LowerGraphOffset), $"{_gameStateManager.CurrentBufferSize.ToString()} states");
+            handle.DrawString(_font, new Vector2(LeftMargin, height + LowerGraphOffset), $"{_gameStateManager.GetApplicableStateCount().ToString()} states");
         }
 
         protected override void DisposeBehavior()

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -1,19 +1,19 @@
+using System;
 using Robust.Shared.Enums;
 using Robust.Client.Graphics;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
-using Robust.Shared.Physics;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Containers;
-using Robust.Shared.Physics.Components;
 using Robust.Shared.Timing;
 
 namespace Robust.Client.GameStates
 {
     internal sealed class NetInterpOverlay : Overlay
     {
+        [Dependency] private readonly IGameTiming _timing = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
@@ -24,6 +24,11 @@ namespace Robust.Client.GameStates
         private readonly SharedContainerSystem _container;
         private readonly SharedTransformSystem _xform;
 
+        /// <summary>
+        /// When an entity stops lerping the overlay will continue to draw a box around the entity for this amount of time.
+        /// </summary>
+        public static readonly TimeSpan Delay = TimeSpan.FromSeconds(2f);
+
         public NetInterpOverlay(EntityLookupSystem lookup)
         {
             IoCManager.InjectDependencies(this);
@@ -40,8 +45,8 @@ namespace Robust.Client.GameStates
             var worldHandle = (DrawingHandleWorld) handle;
             var viewport = args.WorldAABB;
 
-            var query = _entityManager.AllEntityQueryEnumerator<PhysicsComponent, TransformComponent>();
-            while (query.MoveNext(out var uid, out var physics, out var transform))
+            var query = _entityManager.AllEntityQueryEnumerator<TransformComponent>();
+            while (query.MoveNext(out var uid, out var transform))
             {
                 // if not on the same map, continue
                 if (transform.MapID != _eyeManager.CurrentMap || _container.IsEntityInContainer(uid))
@@ -50,8 +55,8 @@ namespace Robust.Client.GameStates
                 if (transform.GridUid == uid)
                     continue;
 
-                // This entity isn't lerping, no need to draw debug info for it
-                if(transform.NextPosition == null)
+                var delta = (_timing.CurTick.Value - transform.LastLerp.Value) * _timing.TickPeriod;
+                if(!transform.ActivelyLerping && delta > Delay)
                     continue;
 
                 var aabb = _lookup.GetWorldAABB(uid);
@@ -61,7 +66,9 @@ namespace Robust.Client.GameStates
                     continue;
 
                 var (pos, rot) = _xform.GetWorldPositionRotation(transform, _entityManager.GetEntityQuery<TransformComponent>());
-                var boxOffset = transform.NextPosition.Value - transform.LocalPosition;
+                var boxOffset = transform.NextPosition != null
+                    ? transform.NextPosition.Value - transform.LocalPosition
+                    : default;
                 var worldOffset = (rot - transform.LocalRotation).RotateVec(boxOffset);
 
                 var nextPos = pos + worldOffset;

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

@@ -4,7 +4,6 @@ using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Graphics;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Maths;
@@ -41,22 +40,28 @@ namespace Robust.Client.Graphics.Clyde
             gridProgram.SetUniformTextureMaybe(UniILightTexture, TextureUnit.Texture1);
             gridProgram.SetUniform(UniIModUV, new Vector4(0, 0, 1, 1));
 
-            foreach (var mapGrid in _mapManager.FindGridsIntersecting(mapId, worldBounds))
+            var grids = new List<Entity<MapGridComponent>>();
+            _mapManager.FindGridsIntersecting(mapId, worldBounds, ref grids);
+            foreach (var mapGrid in grids)
             {
-                if (!_mapChunkData.ContainsKey(mapGrid.Owner))
+                if (!_mapChunkData.ContainsKey(mapGrid))
                     continue;
 
-                var transform = _entityManager.GetComponent<TransformComponent>(mapGrid.Owner);
+                var transform = _entityManager.GetComponent<TransformComponent>(mapGrid);
                 gridProgram.SetUniform(UniIModelMatrix, transform.WorldMatrix);
-                var enumerator = mapGrid.GetMapChunks(worldBounds);
+                var enumerator = mapGrid.Comp.GetMapChunks(worldBounds);
+                var data = _mapChunkData[mapGrid];
 
                 while (enumerator.MoveNext(out var chunk))
                 {
-                    if (_isChunkDirty(mapGrid, chunk))
-                        _updateChunkMesh(mapGrid, chunk);
+                    DebugTools.Assert(chunk.FilledTiles > 0);
+                    if (!data.TryGetValue(chunk.Indices, out MapChunkData? datum))
+                        data[chunk.Indices] = datum = _initChunkBuffers(mapGrid, chunk);
 
-                    var datum = _mapChunkData[mapGrid.Owner][chunk.Indices];
+                    if (datum.Dirty)
+                        _updateChunkMesh(mapGrid, chunk, datum);
 
+                    DebugTools.Assert(datum.TileCount > 0);
                     if (datum.TileCount == 0)
                         continue;
 
@@ -68,22 +73,36 @@ namespace Robust.Client.Graphics.Clyde
                     CheckGlError();
                 }
             }
+
+            CullEmptyChunks();
         }
 
-        private void _updateChunkMesh(MapGridComponent grid, MapChunk chunk)
+        private void CullEmptyChunks()
         {
-            var data = _mapChunkData[grid.Owner];
-
-            if (!data.TryGetValue(chunk.Indices, out var datum))
+            foreach (var (grid, chunks) in _mapChunkData)
             {
-                datum = _initChunkBuffers(grid, chunk);
-            }
+                var gridComp = _mapManager.GetGridComp(grid);
+                foreach (var (index, chunk) in chunks)
+                {
+                    if (!chunk.Dirty || gridComp.Chunks.ContainsKey(index))
+                    {
+                        DebugTools.Assert(gridComp.Chunks[index].FilledTiles > 0);
+                        continue;
+                    }
 
+                    DeleteChunk(chunk);
+                    chunks.Remove(index);
+                }
+            }
+        }
+
+        private void _updateChunkMesh(Entity<MapGridComponent> grid, MapChunk chunk, MapChunkData datum)
+        {
             Span<ushort> indexBuffer = stackalloc ushort[_indicesPerChunk(chunk)];
             Span<Vertex2D> vertexBuffer = stackalloc Vertex2D[_verticesPerChunk(chunk)];
 
             var i = 0;
-            var cSz = grid.ChunkSize;
+            var cSz = grid.Comp.ChunkSize;
             var cScaled = chunk.Indices * cSz;
             for (ushort x = 0; x < cSz; x++)
             {
@@ -130,7 +149,7 @@ namespace Robust.Client.Graphics.Clyde
             datum.TileCount = i;
         }
 
-        private unsafe MapChunkData _initChunkBuffers(MapGridComponent grid, MapChunk chunk)
+        private unsafe MapChunkData _initChunkBuffers(Entity<MapGridComponent> grid, MapChunk chunk)
         {
             var vao = GenVertexArray();
             BindVertexArray(vao);
@@ -158,41 +177,22 @@ namespace Robust.Client.Graphics.Clyde
                 Dirty = true
             };
 
-            _mapChunkData[grid.Owner].Add(chunk.Indices, datum);
             return datum;
         }
 
-        private bool _isChunkDirty(MapGridComponent grid, MapChunk chunk)
+        private void DeleteChunk(MapChunkData data)
         {
-            var data = _mapChunkData[grid.Owner];
-            return !data.TryGetValue(chunk.Indices, out var datum) || datum.Dirty;
-        }
-
-        public void _setChunkDirty(MapGridComponent grid, Vector2i chunk)
-        {
-            var data = _mapChunkData.GetOrNew(grid.Owner);
-            if (data.TryGetValue(chunk, out var datum))
-            {
-                datum.Dirty = true;
-            }
-            // Don't need to set it if we don't have an entry since lack of an entry is treated as dirty.
-        }
-
-        private void _updateOnGridModified(GridModifiedEvent args)
-        {
-            foreach (var (pos, _) in args.Modified)
-            {
-                var grid = args.Grid;
-                var chunk = grid.GridTileToChunkIndices(pos);
-                _setChunkDirty(grid, chunk);
-            }
+            DeleteVertexArray(data.VAO);
+            CheckGlError();
+            data.VBO.Delete();
+            data.EBO.Delete();
         }
 
         private void _updateTileMapOnUpdate(ref TileChangedEvent args)
         {
-            var grid = _mapManager.GetGrid(args.NewTile.GridUid);
-            var chunk = grid.GridTileToChunkIndices(new Vector2i(args.NewTile.X, args.NewTile.Y));
-            _setChunkDirty(grid, chunk);
+            var gridData = _mapChunkData.GetOrNew(args.Entity);
+            if (gridData.TryGetValue(args.ChunkIndex, out var data))
+                data.Dirty = true;
         }
 
         private void _updateOnGridCreated(GridStartupEvent ev)
@@ -208,10 +208,7 @@ namespace Robust.Client.Graphics.Clyde
             var data = _mapChunkData[gridId];
             foreach (var chunkDatum in data.Values)
             {
-                DeleteVertexArray(chunkDatum.VAO);
-                CheckGlError();
-                chunkDatum.VBO.Delete();
-                chunkDatum.EBO.Delete();
+                DeleteChunk(chunkDatum);
             }
 
             _mapChunkData.Remove(gridId);

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

@@ -350,7 +350,7 @@ namespace Robust.Client.Graphics.Clyde
                         _renderHandle.Viewport(Box2i.FromDimensions(-flippedPos, screenSize));
 
                         if (entry.Sprite.RaiseShaderEvent)
-                            _entityManager.EventBus.RaiseLocalEvent(entry.Sprite.Owner,
+                            _entityManager.EventBus.RaiseLocalEvent(entry.Uid,
                                 new BeforePostShaderRenderEvent(entry.Sprite, viewport), false);
                     }
                 }

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

@@ -338,10 +338,12 @@ namespace Robust.Client.Graphics.Clyde
             }
 
             var mapId = eye.Position.MapId;
+            if (mapId == MapId.Nullspace)
+                return;
 
             // If this map has lighting disabled, return
             var mapUid = _mapManager.GetMapEntityId(mapId);
-            if (!_entityManager.GetComponent<MapComponent>(mapUid).LightingEnabled)
+            if (!_entityManager.TryGetComponent<MapComponent>(mapUid, out var map) || !map.LightingEnabled)
             {
                 return;
             }

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

@@ -1,11 +1,3 @@
-using Robust.Client.ComponentTrees;
-using Robust.Client.GameObjects;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Physics;
-using Robust.Shared.Threading;
-using Robust.Shared.Utility;
 using System;
 using System.Buffers;
 using System.Collections.Generic;
@@ -14,7 +6,15 @@ using System.Runtime.CompilerServices;
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 using System.Threading.Tasks;
+using Robust.Client.ComponentTrees;
+using Robust.Client.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Graphics;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Physics;
+using Robust.Shared.Threading;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.Graphics.Clyde;
 
@@ -260,7 +260,7 @@ internal partial class Clyde
             if (cmp != 0)
                 return cmp;
 
-            return a.Sprite.Owner.CompareTo(b.Sprite.Owner);
+            return a.Uid.CompareTo(b.Uid);
         }
     }
 }

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -17,11 +17,9 @@ using Robust.Shared.IoC;
 using Robust.Shared.Localization;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
+using Robust.Shared.Maths;
 using Robust.Shared.Profiling;
 using Robust.Shared.Timing;
-using SixLabors.ImageSharp;
-using Color = Robust.Shared.Maths.Color;
-using DependencyAttribute = Robust.Shared.IoC.DependencyAttribute;
 using TextureWrapMode = Robust.Shared.Graphics.TextureWrapMode;
 
 namespace Robust.Client.Graphics.Clyde
@@ -175,7 +173,6 @@ namespace Robust.Client.Graphics.Clyde
             _entityManager.EventBus.SubscribeEvent<TileChangedEvent>(EventSource.Local, this, _updateTileMapOnUpdate);
             _entityManager.EventBus.SubscribeEvent<GridStartupEvent>(EventSource.Local, this, _updateOnGridCreated);
             _entityManager.EventBus.SubscribeEvent<GridRemovalEvent>(EventSource.Local, this, _updateOnGridRemoved);
-            _entityManager.EventBus.SubscribeEvent<GridModifiedEvent>(EventSource.Local, this, _updateOnGridModified);
         }
 
         public void ShutdownGridEcsEvents()
@@ -183,7 +180,6 @@ namespace Robust.Client.Graphics.Clyde
             _entityManager.EventBus.UnsubscribeEvent<TileChangedEvent>(EventSource.Local, this);
             _entityManager.EventBus.UnsubscribeEvent<GridStartupEvent>(EventSource.Local, this);
             _entityManager.EventBus.UnsubscribeEvent<GridRemovalEvent>(EventSource.Local, this);
-            _entityManager.EventBus.UnsubscribeEvent<GridModifiedEvent>(EventSource.Local, this);
         }
 
         private void GLInitBindings(bool gles)

Robust.Client/Graphics/IClydeWindow.cs

@@ -38,8 +38,7 @@ namespace Robust.Client.Graphics
         event Action<WindowDestroyedEventArgs> Destroyed;
 
         /// <summary>
-        /// Raised when the window has been definitively closed.
-        /// This means the window must not be used anymore (it is disposed).
+        /// Raised when the window has been resized.
         /// </summary>
         event Action<WindowResizedEventArgs> Resized;
     }

Robust.Client/Map/TileEdgeOverlay.cs

@@ -1,12 +1,13 @@
 using System;
+using System.Collections.Generic;
 using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
 using Robust.Shared.Maths;
-using Direction = Robust.Shared.Maths.Direction;
 
 namespace Robust.Client.Map;
 
@@ -22,6 +23,8 @@ public sealed class TileEdgeOverlay : Overlay
 
     public override OverlaySpace Space => OverlaySpace.WorldSpaceBelowEntities;
 
+    private List<Entity<MapGridComponent>> _grids = new();
+
     public TileEdgeOverlay(IEntityManager entManager, IMapManager mapManager, IResourceCache resource, ITileDefinitionManager tileDefManager)
     {
         _entManager = entManager;
@@ -36,16 +39,18 @@ public sealed class TileEdgeOverlay : Overlay
         if (args.MapId == MapId.Nullspace)
             return;
 
-        var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
+        _grids.Clear();
+        _mapManager.FindGridsIntersecting(args.MapId, args.WorldBounds, ref _grids);
 
-        foreach (var grid in _mapManager.FindGridsIntersecting(args.MapId, args.WorldBounds))
+        var xformQuery = _entManager.GetEntityQuery<TransformComponent>();
+        foreach (var grid in _grids)
         {
-            var tileSize = grid.TileSize;
+            var tileSize = grid.Comp.TileSize;
             var tileDimensions = new Vector2(tileSize, tileSize);
-            var xform = xformQuery.GetComponent(grid.Owner);
+            var xform = xformQuery.GetComponent(grid);
             args.WorldHandle.SetTransform(xform.WorldMatrix);
 
-            foreach (var tileRef in grid.GetTilesIntersecting(args.WorldBounds, false))
+            foreach (var tileRef in grid.Comp.GetTilesIntersecting(args.WorldBounds, false))
             {
                 var tileDef = _tileDefManager[tileRef.Tile.TypeId];
 
@@ -61,7 +66,7 @@ public sealed class TileEdgeOverlay : Overlay
                             continue;
 
                         var neighborIndices = new Vector2i(tileRef.GridIndices.X + x, tileRef.GridIndices.Y + y);
-                        var neighborTile = grid.GetTileRef(neighborIndices);
+                        var neighborTile = grid.Comp.GetTileRef(neighborIndices);
                         var neighborDef = _tileDefManager[neighborTile.Tile.TypeId];
 
                         // If it's the same tile then no edge to be drawn.

Robust.Client/Physics/PhysicsSystem.Predict.cs

@@ -1,6 +1,6 @@
 using System.Buffers;
 using System.Collections.Generic;
-using Robust.Client.GameObjects;
+using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Physics;
@@ -20,8 +20,8 @@ public sealed partial class PhysicsSystem
     public override void Initialize()
     {
         base.Initialize();
-        SubscribeLocalEvent<PlayerAttachedEvent>(OnAttach);
-        SubscribeLocalEvent<PlayerDetachedEvent>(OnDetach);
+        SubscribeLocalEvent<LocalPlayerAttachedEvent>(OnAttach);
+        SubscribeLocalEvent<LocalPlayerDetachedEvent>(OnDetach);
         SubscribeLocalEvent<PhysicsComponent, JointAddedEvent>(OnJointAdded);
         SubscribeLocalEvent<PhysicsComponent, JointRemovedEvent>(OnJointRemoved);
     }
@@ -63,12 +63,12 @@ public sealed partial class PhysicsSystem
         UpdateIsPredicted(args.Joint.BodyBUid);
     }
 
-    private void OnAttach(PlayerAttachedEvent ev)
+    private void OnAttach(LocalPlayerAttachedEvent ev)
     {
         UpdateIsPredicted(ev.Entity);
     }
 
-    private void OnDetach(PlayerDetachedEvent ev)
+    private void OnDetach(LocalPlayerDetachedEvent ev)
     {
         UpdateIsPredicted(ev.Entity);
     }

Robust.Client/Physics/PhysicsSystem.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using JetBrains.Annotations;
-using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Physics;
@@ -26,7 +25,7 @@ namespace Robust.Client.Physics
 
         protected override void Cleanup(PhysicsMapComponent component, float frameTime)
         {
-            var toRemove = new List<PhysicsComponent>();
+            var toRemove = new List<Entity<PhysicsComponent>>();
 
             // Because we're not predicting 99% of bodies its sleep timer never gets incremented so we'll just do it ourselves.
             // (and serializing it over the network isn't necessary?)
@@ -38,13 +37,13 @@ namespace Robust.Client.Physics
                 body.SleepTime += frameTime;
                 if (body.SleepTime > TimeToSleep)
                 {
-                    toRemove.Add(body);
+                    toRemove.Add(new Entity<PhysicsComponent>(body.Owner, body));
                 }
             }
 
             foreach (var body in toRemove)
             {
-                SetAwake(body.Owner, body, false);
+                SetAwake(body, false);
             }
 
             base.Cleanup(component, frameTime);
@@ -82,11 +81,8 @@ namespace Robust.Client.Physics
                     continue;
                 }
 
-                xform.PrevPosition = position;
-                xform.PrevRotation = rotation;
-                xform.LerpParent = parentUid;
-                xform.NextPosition = xform.LocalPosition;
-                xform.NextRotation = xform.LocalRotation;
+                // Transform system will handle lerping.
+                _transform.SetLocalPositionRotation(uid, xform.LocalPosition, xform.LocalRotation, xform);
             }
 
             component.LerpData.Clear();

Robust.Client/Placement/PlacementManager.cs

@@ -8,7 +8,6 @@ using Robust.Client.Player;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Graphics;
 using Robust.Shared.Input;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.IoC;
@@ -287,23 +286,17 @@ namespace Robust.Client.Placement
                     }, outsidePrediction: true))
                 .Register<PlacementManager>();
 
-            var localPlayer = PlayerManager.LocalPlayer;
-            localPlayer!.EntityAttached += OnEntityAttached;
+            PlayerManager.LocalPlayerDetached += OnDetached;
         }
 
         private void TearDownInput()
         {
             CommandBinds.Unregister<PlacementManager>();
-
-            if (PlayerManager.LocalPlayer != null)
-            {
-                PlayerManager.LocalPlayer.EntityAttached -= OnEntityAttached;
-            }
+            PlayerManager.LocalPlayerDetached -= OnDetached;
         }
 
-        private void OnEntityAttached(EntityAttachedEventArgs eventArgs)
+        private void OnDetached(EntityUid obj)
         {
-            // player attached to a new entity, basically disable the editor
             Clear();
         }
 

Robust.Client/Player/IPlayerManager.cs

@@ -1,44 +1,71 @@
 using System;
 using System.Collections.Generic;
+using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
 using Robust.Shared.Network;
-using Robust.Shared.Players;
-using Robust.Shared.ViewVariables;
+using Robust.Shared.Player;
 
-namespace Robust.Client.Player
+namespace Robust.Client.Player;
+
+public interface IPlayerManager : ISharedPlayerManager
 {
-    public interface IPlayerManager : ISharedPlayerManager
-    {
-        new IEnumerable<ICommonSession> Sessions { get; }
+    /// <summary>
+    /// Invoked when the list of sessions/players gets updated.
+    /// </summary>
+    event Action? PlayerListUpdated;
 
-        [ViewVariables]
-        IReadOnlyDictionary<NetUserId, ICommonSession> SessionsDict { get; }
+    /// <summary>
+    /// Invoked when <see cref="ISharedPlayerManager.LocalSession"/> gets attached to a new entity. See also <see cref="LocalPlayerAttachedEvent"/>
+    /// </summary>
+    event Action<EntityUid>? LocalPlayerAttached;
 
-        [ViewVariables]
-        LocalPlayer? LocalPlayer { get; }
+    /// <summary>
+    /// Invoked when <see cref="ISharedPlayerManager.LocalSession"/> gets detached from new entity. See also <see cref="LocalPlayerDetachedEvent"/>
+    /// </summary>
+    event Action<EntityUid>? LocalPlayerDetached;
 
-        /// <summary>
-        /// Invoked after LocalPlayer is changed
-        /// </summary>
-        event Action<LocalPlayerChangedEventArgs>? LocalPlayerChanged;
+    void ApplyPlayerStates(IReadOnlyCollection<SessionState> list);
 
-        event EventHandler PlayerListUpdated;
+    /// <summary>
+    /// Sets up a single player game. This creates a dummy <see cref="ISharedPlayerManager.LocalSession"/>  without an
+    /// <see cref="INetChannel"/>.
+    /// </summary>
+    void SetupSinglePlayer(string name);
 
-        void Initialize();
-        void Startup();
-        void Shutdown();
+    /// <summary>
+    /// Sets up the manager for a multiplayer game. This creates a <see cref="ISharedPlayerManager.LocalSession"/>
+    /// using the given <see cref="INetChannel"/>.
+    /// </summary>
+    void SetupMultiplayer(INetChannel channel);
 
-        void ApplyPlayerStates(IReadOnlyCollection<PlayerState> list);
-    }
-
-    public sealed class LocalPlayerChangedEventArgs : EventArgs
-    {
-        public readonly LocalPlayer? OldPlayer;
-        public readonly LocalPlayer? NewPlayer;
-        public LocalPlayerChangedEventArgs(LocalPlayer? oldPlayer, LocalPlayer? newPlayer)
-        {
-            OldPlayer = oldPlayer;
-            NewPlayer = newPlayer;
-        }
-    }
+    [Obsolete("Use LocalSession instead")]
+    LocalPlayer? LocalPlayer { get;}
 }
+
+/// <summary>
+/// ECS event that gets raised when the local player gets attached to a new entity. The event is both broadcast and
+/// raised directed at the new entity.
+/// </summary>
+public sealed class LocalPlayerAttachedEvent : EntityEventArgs
+{
+    public LocalPlayerAttachedEvent(EntityUid entity)
+    {
+        Entity = entity;
+    }
+
+    public EntityUid Entity { get; }
+}
+
+/// <summary>
+/// ECS event that gets raised when the local player gets detached from an entity. The event is both broadcast and
+/// raised directed at the new entity.
+/// </summary>
+public sealed class LocalPlayerDetachedEvent : EntityEventArgs
+{
+    public LocalPlayerDetachedEvent(EntityUid entity)
+    {
+        Entity = entity;
+    }
+
+    public EntityUid Entity { get; }
+}

Robust.Client/Player/LocalPlayer.cs

@@ -1,11 +1,6 @@
-using System;
-using Robust.Client.GameObjects;
-using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Network;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.Player
@@ -15,163 +10,30 @@ namespace Robust.Client.Player
     /// </summary>
     public sealed class LocalPlayer
     {
-        /// <summary>
-        ///     An entity has been attached to the local player.
-        /// </summary>
-        public event Action<EntityAttachedEventArgs>? EntityAttached;
-
-        /// <summary>
-        ///     An entity has been detached from the local player.
-        /// </summary>
-        public event Action<EntityDetachedEventArgs>? EntityDetached;
+        public LocalPlayer(ICommonSession session)
+        {
+            Session = session;
+        }
 
         /// <summary>
         ///     Game entity that the local player is controlling. If this is default, the player is not attached to any
         ///     entity at all.
         /// </summary>
-        [ViewVariables] public EntityUid? ControlledEntity { get; private set; }
-
-        [ViewVariables] public NetUserId UserId { get; set; }
-
-        /// <summary>
-        ///     Session of the local client.
-        /// </summary>
         [ViewVariables]
-        public ICommonSession Session => InternalSession;
+        public EntityUid? ControlledEntity => Session.AttachedEntity;
 
-        internal PlayerSession InternalSession { get; set; } = default!;
+        [ViewVariables]
+        public NetUserId UserId => Session.UserId;
 
         /// <summary>
         ///     OOC name of the local player.
         /// </summary>
         [ViewVariables]
-        public string Name { get; set; } = default!;
+        public string Name => Session.Name;
 
         /// <summary>
-        ///     The status of the client's session has changed.
+        ///     Session of the local client.
         /// </summary>
-        public event EventHandler<StatusEventArgs>? StatusChanged;
-
-        /// <summary>
-        ///     Attaches a client to an entity.
-        /// </summary>
-        /// <param name="entity">Entity to attach the client to.</param>
-        public void AttachEntity(EntityUid entity, IEntityManager entMan, IBaseClient client)
-        {
-            if (ControlledEntity == entity)
-                return;
-
-            // Detach and cleanup first
-            DetachEntity();
-
-            if (!entMan.EntityExists(entity))
-            {
-                Logger.Error($"Attempting to attach player to non-existent entity {entity}!");
-                return;
-            }
-
-            ControlledEntity = entity;
-            InternalSession.AttachedEntity = entity;
-
-            if (!entMan.TryGetComponent<EyeComponent?>(entity, out var eye))
-            {
-                eye = entMan.AddComponent<EyeComponent>(entity);
-
-                if (client.RunLevel != ClientRunLevel.SinglePlayerGame)
-                {
-                    Logger.Warning($"Attaching local player to an entity {entMan.ToPrettyString(entity)} without an eye. This eye will not be netsynced and may cause issues.");
-                }
-                eye.NetSyncEnabled = false;
-            }
-
-            EntityAttached?.Invoke(new EntityAttachedEventArgs(entity));
-
-            // notify ECS Systems
-            var eventBus = entMan.EventBus;
-            eventBus.RaiseEvent(EventSource.Local, new PlayerAttachSysMessage(entity));
-            eventBus.RaiseLocalEvent(entity, new PlayerAttachedEvent(entity), true);
-        }
-
-        /// <summary>
-        ///     Detaches the client from an entity.
-        /// </summary>
-        public void DetachEntity()
-        {
-            var entMan = IoCManager.Resolve<IEntityManager>();
-            var previous = ControlledEntity;
-
-            ControlledEntity = null;
-            InternalSession.AttachedEntity = null;
-
-            if (previous != null)
-            {
-                entMan.EventBus.RaiseEvent(EventSource.Local, new PlayerAttachSysMessage(default));
-                entMan.EventBus.RaiseLocalEvent(previous.Value, new PlayerDetachedEvent(previous.Value), true);
-                EntityDetached?.Invoke(new EntityDetachedEventArgs(previous.Value));
-            }
-        }
-
-        /// <summary>
-        ///     Changes the state of the session.
-        /// </summary>
-        public void SwitchState(SessionStatus newStatus)
-        {
-            SwitchState(Session.Status, newStatus);
-        }
-
-        /// <summary>
-        ///     Changes the state of the session. This overload allows you to spoof the oldStatus, use with caution.
-        /// </summary>
-        public void SwitchState(SessionStatus oldStatus, SessionStatus newStatus)
-        {
-            var args = new StatusEventArgs(oldStatus, newStatus);
-            Session.Status = newStatus;
-            StatusChanged?.Invoke(this, args);
-        }
-    }
-
-    /// <summary>
-    ///     Event arguments for when the status of a session changes.
-    /// </summary>
-    public sealed class StatusEventArgs : EventArgs
-    {
-        /// <summary>
-        ///     Status that the session switched from.
-        /// </summary>
-        public SessionStatus OldStatus { get; }
-
-        /// <summary>
-        ///     Status that the session switched to.
-        /// </summary>
-        public SessionStatus NewStatus { get; }
-
-        /// <summary>
-        ///     Constructs a new instance of the class.
-        /// </summary>
-        public StatusEventArgs(SessionStatus oldStatus, SessionStatus newStatus)
-        {
-            OldStatus = oldStatus;
-            NewStatus = newStatus;
-        }
-    }
-
-    public sealed class EntityDetachedEventArgs : EventArgs
-    {
-        public EntityDetachedEventArgs(EntityUid oldEntity)
-        {
-            OldEntity = oldEntity;
-        }
-
-        public EntityUid OldEntity { get; }
-    }
-
-    public sealed class EntityAttachedEventArgs : EventArgs
-    {
-        public EntityAttachedEventArgs(EntityUid newEntity)
-        {
-            NewEntity = newEntity;
-        }
-
-        public EntityUid NewEntity { get; }
+        public  ICommonSession Session;
     }
 }

Robust.Client/Player/PlayerManager.cs

@@ -2,16 +2,13 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Utility;
-using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.Player
 {
@@ -20,154 +17,187 @@ namespace Robust.Client.Player
     ///     Why not just attach the inputs directly? It's messy! This makes the whole thing nicely encapsulated.
     ///     This class also communicates with the server to let the server control what entity it is attached to.
     /// </summary>
-    public sealed class PlayerManager : IPlayerManager
+    internal sealed class PlayerManager : SharedPlayerManager, IPlayerManager
     {
         [Dependency] private readonly IClientNetManager _network = default!;
         [Dependency] private readonly IBaseClient _client = default!;
-        [Dependency] private readonly IEntityManager _entManager = default!;
-        [Dependency] private readonly ILogManager _logMan = default!;
 
         /// <summary>
-        ///     Active sessions of connected clients to the server.
+        /// Received player states that had an unknown <see cref="NetEntity"/>.
         /// </summary>
-        private readonly Dictionary<NetUserId, ICommonSession> _sessions = new();
+        private Dictionary<NetUserId, SessionState> _pendingStates = new ();
+        private List<SessionState> _pending = new();
 
         /// <inheritdoc />
-        public IEnumerable<ICommonSession> NetworkedSessions
+        public override ICommonSession[] NetworkedSessions
         {
             get
             {
-                if (LocalPlayer is not null)
-                    return new[] {LocalPlayer.Session};
-
-                return Enumerable.Empty<ICommonSession>();
+                return LocalSession != null
+                    ? new [] { LocalSession }
+                    : Array.Empty<ICommonSession>();
             }
         }
 
         /// <inheritdoc />
-        IEnumerable<ICommonSession> ISharedPlayerManager.Sessions => _sessions.Values;
+        public override int MaxPlayers => _client.GameInfo?.ServerMaxPlayers ?? -1;
+
+        public LocalPlayer? LocalPlayer { get; set; }
+
+        public event Action<SessionStatusEventArgs>? LocalStatusChanged;
+        public event Action? PlayerListUpdated;
+        public event Action<EntityUid>? LocalPlayerDetached;
+        public event Action<EntityUid>? LocalPlayerAttached;
 
         /// <inheritdoc />
-        public int PlayerCount => _sessions.Values.Count;
-
-        /// <inheritdoc />
-        public int MaxPlayers => _client.GameInfo?.ServerMaxPlayers ?? 0;
-
-        public ICommonSession? LocalSession => LocalPlayer?.Session;
-
-        /// <inheritdoc />
-        [ViewVariables]
-        public LocalPlayer? LocalPlayer
+        public override void Initialize(int maxPlayers)
         {
-            get => _localPlayer;
-            private set
-            {
-                if (_localPlayer == value) return;
-                var oldValue = _localPlayer;
-                _localPlayer = value;
-                LocalPlayerChanged?.Invoke(new LocalPlayerChangedEventArgs(oldValue, _localPlayer));
-            }
-        }
-        private LocalPlayer? _localPlayer;
-        private ISawmill _sawmill = default!;
-
-        public event Action<LocalPlayerChangedEventArgs>? LocalPlayerChanged;
-
-        /// <inheritdoc />
-        [ViewVariables]
-        IEnumerable<ICommonSession> IPlayerManager.Sessions => _sessions.Values;
-
-        /// <inheritdoc />
-        public IReadOnlyDictionary<NetUserId, ICommonSession> SessionsDict => _sessions;
-
-        /// <inheritdoc />
-        public event EventHandler? PlayerListUpdated;
-
-        /// <inheritdoc />
-        public void Initialize()
-        {
-            _client.RunLevelChanged += OnRunLevelChanged;
-
-            _sawmill = _logMan.GetSawmill("player");
+            base.Initialize(maxPlayers);
             _network.RegisterNetMessage<MsgPlayerListReq>();
             _network.RegisterNetMessage<MsgPlayerList>(HandlePlayerList);
+            PlayerStatusChanged += StatusChanged;
+        }
+
+        private void StatusChanged(object? sender, SessionStatusEventArgs e)
+        {
+            if (e.Session == LocalPlayer?.Session)
+                LocalStatusChanged?.Invoke(e);
         }
 
         /// <inheritdoc />
-        public void Startup()
+        public override void Startup()
         {
-            DebugTools.Assert(LocalPlayer == null);
-            LocalPlayer = new LocalPlayer();
+            if (LocalSession == null)
+                throw new InvalidOperationException("LocalSession cannot be null");
 
-            var msgList = new MsgPlayerListReq();
-            // message is empty
-            _network.ClientSendMessage(msgList);
+            LocalPlayer = new LocalPlayer(LocalSession);
+            base.Startup();
+        }
+
+        public void SetupSinglePlayer(string name)
+        {
+            if (LocalSession != null)
+                throw new InvalidOperationException($"Player manager already running?");
+
+            LocalSession = CreateAndAddSession(default, name);
+            Startup();
+            PlayerListUpdated?.Invoke();
+        }
+
+        public void SetupMultiplayer(INetChannel channel)
+        {
+            if (LocalSession != null)
+                throw new InvalidOperationException($"Player manager already running?");
+
+            var session = CreateAndAddSession(channel.UserId, channel.UserName);
+            session.Channel = channel;
+            LocalSession = session;
+            Startup();
+            _network.ClientSendMessage(new MsgPlayerListReq());
         }
 
         /// <inheritdoc />
-        public void Shutdown()
+        public override void Shutdown()
         {
-            LocalPlayer?.DetachEntity();
+            if (LocalSession != null)
+                SetAttachedEntity(LocalSession, null);
             LocalPlayer = null;
-            _sessions.Clear();
+            LocalSession = null;
+            _pendingStates.Clear();
+            base.Shutdown();
+            PlayerListUpdated?.Invoke();
         }
 
-        /// <inheritdoc />
-        public void ApplyPlayerStates(IReadOnlyCollection<PlayerState> list)
+        public override void SetAttachedEntity(ICommonSession session, EntityUid? uid)
+        {
+            if (session.AttachedEntity == uid)
+                return;
+
+            var old = session.AttachedEntity;
+            base.SetAttachedEntity(session, uid);
+
+            if (session != LocalSession)
+                return;
+
+            if (old.HasValue)
+            {
+                Sawmill.Info($"Detaching local player from {EntManager.ToPrettyString(old)}.");
+                EntManager.EventBus.RaiseLocalEvent(old.Value, new LocalPlayerDetachedEvent(old.Value), true);
+                LocalPlayerDetached?.Invoke(old.Value);
+            }
+
+            if (uid == null)
+            {
+                Sawmill.Info($"Local player is no longer attached to any entity.");
+                return;
+            }
+
+            if (!EntManager.EntityExists(uid))
+            {
+                Sawmill.Error($"Attempted to attach player to non-existent entity {uid}!");
+                return;
+            }
+
+            if (!EntManager.EnsureComponent(uid.Value, out EyeComponent eye))
+            {
+                if (_client.RunLevel != ClientRunLevel.SinglePlayerGame)
+                    Sawmill.Warning($"Attaching local player to an entity {EntManager.ToPrettyString(uid)} without an eye. This eye will not be netsynced and may cause issues.");
+                eye.NetSyncEnabled = false;
+            }
+
+            Sawmill.Info($"Attaching local player to {EntManager.ToPrettyString(uid)}.");
+            EntManager.EventBus.RaiseLocalEvent(uid.Value, new LocalPlayerAttachedEvent(uid.Value), true);
+            LocalPlayerAttached?.Invoke(uid.Value);
+        }
+
+        public void ApplyPlayerStates(IReadOnlyCollection<SessionState> list)
+        {
+            var dirty = ApplyStates(list, true);
+
+            if (_pendingStates.Count == 0)
+            {
+                // This is somewhat inefficient as it might try to re-apply states that failed just a moment ago.
+                _pending.Clear();
+                _pending.AddRange(_pendingStates.Values);
+                _pendingStates.Clear();
+                dirty |= ApplyStates(_pending, false);
+            }
+
+            if (dirty)
+                PlayerListUpdated?.Invoke();
+        }
+
+        private bool ApplyStates(IReadOnlyCollection<SessionState> list, bool fullList)
         {
             if (list.Count == 0)
-            {
-                // This happens when the server says "nothing changed!"
-                return;
-            }
+                return false;
+
             DebugTools.Assert(_network.IsConnected ||  _client.RunLevel == ClientRunLevel.SinglePlayerGame // replays use state application.
                 , "Received player state without being connected?");
-            DebugTools.Assert(LocalPlayer != null, "Call Startup()");
-            DebugTools.Assert(LocalPlayer!.Session != null, "Received player state before Session finished setup.");
+            DebugTools.Assert(LocalSession != null, "Received player state before Session finished setup.");
 
-            var myState = list.FirstOrDefault(s => s.UserId == LocalPlayer.UserId);
+            var state = list.FirstOrDefault(s => s.UserId == LocalSession.UserId);
 
-            if (myState != null)
+            bool dirty = false;
+            if (state != null)
             {
-                var uid = _entManager.GetEntity(myState.ControlledEntity);
-                if (myState.ControlledEntity is {Valid: true} && !_entManager.EntityExists(uid))
+                dirty = true;
+                if (!EntManager.TryGetEntity(state.ControlledEntity, out var uid)
+                    && state.ControlledEntity is { Valid:true } )
                 {
-                    _sawmill.Error($"Received player state for local player with an unknown net entity!");
+                    Sawmill.Error($"Received player state for local player with an unknown net entity!");
+                    _pendingStates[state.UserId] = state;
+                }
+                else
+                {
+                    _pendingStates.Remove(state.UserId);
                 }
 
-                UpdateAttachedEntity(uid);
-                UpdateSessionStatus(myState.Status);
+                SetAttachedEntity(LocalSession, uid);
+                SetStatus(LocalSession, state.Status);
             }
 
-            UpdatePlayerList(list);
-        }
-
-        /// <summary>
-        ///     Compares the server sessionStatus to the client one, and updates if needed.
-        /// </summary>
-        private void UpdateSessionStatus(SessionStatus myStateStatus)
-        {
-            if (LocalPlayer!.Session.Status != myStateStatus)
-                LocalPlayer.SwitchState(myStateStatus);
-        }
-
-        /// <summary>
-        ///     Compares the server attachedEntity to the client one, and updates if needed.
-        /// </summary>
-        /// <param name="entity">AttachedEntity in the server session.</param>
-        private void UpdateAttachedEntity(EntityUid? entity)
-        {
-            if (LocalPlayer!.ControlledEntity == entity)
-            {
-                return;
-            }
-            if (entity == null)
-            {
-                LocalPlayer.DetachEntity();
-                return;
-            }
-
-            LocalPlayer.AttachEntity(entity.Value, _entManager, _client);
+            return UpdatePlayerList(list, fullList) || dirty;
         }
 
         /// <summary>
@@ -175,117 +205,87 @@ namespace Robust.Client.Player
         /// </summary>
         private void HandlePlayerList(MsgPlayerList msg)
         {
-            UpdatePlayerList(msg.Plyrs);
+            ApplyPlayerStates(msg.Plyrs);
         }
 
         /// <summary>
         ///     Compares the server player list to the client one, and updates if needed.
         /// </summary>
-        private void UpdatePlayerList(IEnumerable<PlayerState> remotePlayers)
+        private bool UpdatePlayerList(IEnumerable<SessionState> remotePlayers, bool fullList)
         {
             var dirty = false;
-
-            var hitSet = new List<NetUserId>();
-
+            var users = new List<NetUserId>();
             foreach (var state in remotePlayers)
             {
-                hitSet.Add(state.UserId);
+                users.Add(state.UserId);
 
-                if (_sessions.TryGetValue(state.UserId, out var session))
+                if (!EntManager.TryGetEntity(state.ControlledEntity, out var controlled)
+                    && state.ControlledEntity is {Valid: true})
                 {
-                    var local = (PlayerSession) session;
-                    var controlled = _entManager.GetEntity(state.ControlledEntity);
-
-                    // Exists, update data.
-                    if (local.Name == state.Name
-                        && local.Status == state.Status
-                        && local.Ping == state.Ping
-                        && local.AttachedEntity == controlled)
-                    {
-                        continue;
-                    }
-
-                    dirty = true;
-                    local.Name = state.Name;
-                    local.Status = state.Status;
-                    local.Ping = state.Ping;
-                    local.AttachedEntity = controlled;
+                    _pendingStates[state.UserId] = state;
                 }
                 else
                 {
-                    // New, give him a slot.
-                    dirty = true;
-
-                    var newSession = new PlayerSession(state.UserId)
-                    {
-                        Name = state.Name,
-                        Status = state.Status,
-                        Ping = state.Ping,
-                        AttachedEntity = _entManager.GetEntity(state.ControlledEntity),
-                    };
-                    _sessions.Add(state.UserId, newSession);
-                    if (state.UserId == LocalPlayer!.UserId)
-                    {
-                        LocalPlayer.InternalSession = newSession;
-                        newSession.ConnectedClient = _network.ServerChannel!;
-                        // We just connected to the server, hurray!
-                        LocalPlayer.SwitchState(SessionStatus.Connecting, newSession.Status);
-                    }
+                    _pendingStates.Remove(state.UserId);
                 }
-            }
 
-            foreach (var existing in _sessions.Keys.ToArray())
-            {
-                // clear slot, player left
-                if (!hitSet.Contains(existing))
+                if (!InternalSessions.TryGetValue(state.UserId, out var session))
                 {
-                    DebugTools.Assert(LocalPlayer!.UserId != existing || _client.RunLevel == ClientRunLevel.SinglePlayerGame, // replays apply player states.
-                        "I'm still connected to the server, but i left?");
-                    _sessions.Remove(existing);
+                    // This is a new userid, so we create a new session.
+                    DebugTools.Assert(state.UserId != LocalPlayer?.UserId);
+                    var newSession = CreateAndAddSession(state.UserId, state.Name);
+                    newSession.Ping = state.Ping;
+                    newSession.Name = state.Name;
+                    SetStatus(newSession, state.Status);
+                    SetAttachedEntity(newSession, controlled);
+                    dirty = true;
+                    continue;
+                }
+
+                // Check if the data is actually different
+                if (session.Name == state.Name
+                    && session.Status == state.Status
+                    && session.Ping == state.Ping
+                    && session.AttachedEntity == controlled)
+                {
+                    continue;
+                }
+
+                dirty = true;
+                var local = (CommonSession) session;
+                local.Name = state.Name;
+                local.Ping = state.Ping;
+                SetStatus(local, state.Status);
+                SetAttachedEntity(local, controlled);
+            }
+
+            // Remove old users. This only works if the provided state is a list of all players
+            if (fullList)
+            {
+                foreach (var oldUser in InternalSessions.Keys.ToArray())
+                {
+                    // clear slot, player left
+                    if (users.Contains(oldUser))
+                        continue;
+
+                    DebugTools.Assert(oldUser != LocalUser
+                                      || LocalUser == null
+                                      || LocalUser == default(NetUserId),
+                        "Client is still connected to the server but not in the list of players?");
+                    RemoveSession(oldUser);
+                    _pendingStates.Remove(oldUser);
                     dirty = true;
                 }
             }
 
-            if (dirty)
-            {
-                PlayerListUpdated?.Invoke(this, EventArgs.Empty);
-            }
+            return dirty;
         }
 
-        private void OnRunLevelChanged(object? sender, RunLevelChangedEventArgs e)
+        public override bool TryGetSessionByEntity(EntityUid uid, [NotNullWhen(true)] out ICommonSession? session)
         {
-            if (e.NewLevel != ClientRunLevel.SinglePlayerGame)
-                return;
-
-            DebugTools.AssertNotNull(LocalPlayer);
-
-            // We do some further setup steps for singleplayer here...
-
-            // The local player's GUID in singleplayer will always be the default.
-            var guid = default(NetUserId);
-
-            var session = new PlayerSession(guid)
+            if (LocalEntity == uid)
             {
-                Name = LocalPlayer!.Name,
-                Ping = 0,
-            };
-
-            LocalPlayer.UserId = guid;
-            LocalPlayer.InternalSession = session;
-
-            // Add the local session to the list.
-            _sessions.Add(guid, session);
-
-            LocalPlayer.SwitchState(SessionStatus.InGame);
-
-            PlayerListUpdated?.Invoke(this, EventArgs.Empty);
-        }
-
-        public bool TryGetSessionByEntity(EntityUid uid, [NotNullWhen(true)] out ICommonSession? session)
-        {
-            if (LocalPlayer?.ControlledEntity == uid)
-            {
-                session = LocalPlayer.Session;
+                session = LocalSession!;
                 return true;
             }
 

Robust.Client/Player/PlayerSession.cs

@@ -1,60 +0,0 @@
-using Robust.Shared.Enums;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Network;
-using Robust.Shared.Players;
-using Robust.Shared.ViewVariables;
-
-namespace Robust.Client.Player
-{
-    internal sealed class PlayerSession : ICommonSession
-    {
-        internal SessionStatus Status { get; set; } = SessionStatus.Connecting;
-
-        /// <inheritdoc />
-        SessionStatus ICommonSession.Status
-        {
-            get => this.Status;
-            set => this.Status = value;
-        }
-
-        /// <inheritdoc />
-        [ViewVariables]
-        public EntityUid? AttachedEntity { get; set; }
-
-        /// <inheritdoc />
-        [ViewVariables]
-        public NetUserId UserId { get; }
-
-        [ViewVariables]
-        internal string Name { get; set; } = "<Unknown>";
-
-        /// <inheritdoc />
-        string ICommonSession.Name
-        {
-            get => this.Name;
-            set => this.Name = value;
-        }
-
-        [ViewVariables]
-        internal short Ping { get; set; }
-
-        /// <inheritdoc />
-        [ViewVariables]
-        public INetChannel ConnectedClient { get; internal set; } = null!;
-
-        /// <inheritdoc />
-        short ICommonSession.Ping
-        {
-            get => this.Ping;
-            set => this.Ping = value;
-        }
-
-        /// <summary>
-        ///     Creates an instance of a PlayerSession.
-        /// </summary>
-        public PlayerSession(NetUserId user)
-        {
-            UserId = user;
-        }
-    }
-}

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

@@ -7,7 +7,6 @@ using Robust.Shared.Network;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using System.Threading.Tasks;
-using Robust.Client.Upload.Commands;
 using Robust.Shared;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Replays;
@@ -101,7 +100,7 @@ public sealed partial class ReplayLoadManager
 
         await callback(0, states.Count, LoadingState.ProcessingFiles, true);
         var playerSpan = state0.PlayerStates.Value;
-        Dictionary<NetUserId, PlayerState> playerStates = new(playerSpan.Count);
+        Dictionary<NetUserId, SessionState> playerStates = new(playerSpan.Count);
         foreach (var player in playerSpan)
         {
             playerStates.Add(player.UserId, player);
@@ -391,7 +390,7 @@ public sealed partial class ReplayLoadManager
         return new EntityState(newState.NetEntity, combined, newState.EntityLastModified, newState.NetComponents ?? oldNetComps);
     }
 
-    private void UpdatePlayerStates(ReadOnlySpan<PlayerState> span, Dictionary<NetUserId, PlayerState> playerStates)
+    private void UpdatePlayerStates(ReadOnlySpan<SessionState> span, Dictionary<NetUserId, SessionState> playerStates)
     {
         foreach (var player in span)
         {

Robust.Client/Replays/ReplayRecordingManager.cs

@@ -9,7 +9,7 @@ using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Replays;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Value;
@@ -138,9 +138,9 @@ internal sealed class ReplayRecordingManager : SharedReplayRecordingManager
         return (state, detachMsg);
     }
 
-    private PlayerState GetPlayerState(ICommonSession session)
+    private SessionState GetPlayerState(ICommonSession session)
     {
-        return new PlayerState
+        return new SessionState
         {
             UserId = session.UserId,
             Status = session.Status,

Robust.Client/Robust.Client.csproj

@@ -17,7 +17,7 @@
     <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.2" Condition="'$(UseSystemSqlite)' != 'True'" PrivateAssets="compile" />
     <PackageReference Include="SpaceWizards.NFluidsynth" Version="0.1.1" PrivateAssets="compile" />
     <PackageReference Include="NVorbis" Version="0.10.1" PrivateAssets="compile" />
-    <PackageReference Include="SixLabors.ImageSharp" Version="2.1.3" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="2.1.9" />
     <PackageReference Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" PrivateAssets="compile" />
     <PackageReference Include="OpenTK.OpenAL" Version="4.7.5" PrivateAssets="compile" />
     <PackageReference Include="SpaceWizards.SharpFont" Version="1.0.1" PrivateAssets="compile" />

Robust.Client/Spawners/TimedDespawnSystem.cs

@@ -0,0 +1,12 @@
+using Robust.Shared.GameObjects;
+using Robust.Shared.Spawners;
+
+namespace Robust.Client.Spawners;
+
+public sealed class TimedDespawnSystem : SharedTimedDespawnSystem
+{
+    protected override bool CanDelete(EntityUid uid)
+    {
+        return IsClientSide(uid);
+    }
+}

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

@@ -10,6 +10,7 @@ using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.Enums;
 using Robust.Shared.IoC;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Utility;
 using static Robust.Client.UserInterface.Controls.BaseButton;
 using static Robust.Client.UserInterface.Controls.LineEdit;
@@ -199,7 +200,7 @@ public sealed class EntitySpawningUIController : UIController
                 continue;
             }
 
-            if (prototype.NoSpawn)
+            if (prototype.HideSpawnMenu)
             {
                 continue;
             }

Robust.Client/UserInterface/Controls/LineEdit.cs

@@ -98,6 +98,11 @@ namespace Robust.Client.UserInterface.Controls
                 OnTextChanged?.Invoke(new LineEditEventArgs(this, _text));
         }
 
+        public void ForceSubmitText()
+        {
+            OnTextEntered?.Invoke(new LineEditEventArgs(this, _text));
+        }
+
         /// <summary>
         ///     The text
         /// </summary>
@@ -607,7 +612,7 @@ namespace Robust.Client.UserInterface.Controls
                 {
                     if (Editable)
                     {
-                        OnTextEntered?.Invoke(new LineEditEventArgs(this, _text));
+                        ForceSubmitText();
                     }
 
                     args.Handle();

Robust.Client/UserInterface/Controls/ScrollContainer.cs

@@ -50,13 +50,13 @@ namespace Robust.Client.UserInterface.Controls
             Action<Range> ev = _scrollValueChanged;
             _hScrollBar = new HScrollBar
             {
-                Visible = false,
+                Visible = _hScrollEnabled,
                 VerticalAlignment = VAlignment.Bottom,
                 HorizontalAlignment = HAlignment.Stretch
             };
             _vScrollBar = new VScrollBar
             {
-                Visible = false,
+                Visible = _vScrollEnabled,
                 VerticalAlignment = VAlignment.Stretch,
                 HorizontalAlignment = HAlignment.Right
             };

Robust.Client/UserInterface/Controls/SplitContainer.cs

@@ -2,6 +2,7 @@ using System;
 using System.Numerics;
 using Robust.Shared.Input;
 using Robust.Shared.Maths;
+using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.UserInterface.Controls
@@ -14,7 +15,17 @@ namespace Robust.Client.UserInterface.Controls
         /// for each enum value to see how the different options work.
         /// </summary>
         [ViewVariables(VVAccess.ReadWrite)]
-        public SplitResizeMode ResizeMode { get; set; }
+        public SplitResizeMode ResizeMode
+        {
+            get => _resizeMode;
+            set
+            {
+                _resizeMode = value;
+                _splitDragArea.Visible = value != SplitResizeMode.NotResizable;
+            }
+        }
+
+        private SplitResizeMode _resizeMode = SplitResizeMode.RespectChildrenMinSize;
 
         /// <summary>
         /// Width of the split in virtual pixels
@@ -30,7 +41,7 @@ namespace Robust.Client.UserInterface.Controls
             }
         }
 
-        private float _splitWidth;
+        private float _splitWidth = 10;
 
         /// <summary>
         ///     This width determines the minimum size of the draggable area around the split. This has no effect if it
@@ -38,11 +49,13 @@ namespace Robust.Client.UserInterface.Controls
         /// </summary>
         public float MinDraggableWidth = 10f;
 
+        public float DraggableWidth => MathF.Max(MinDraggableWidth, _splitWidth);
+
         /// <summary>
         /// Virtual pixel offset from the edge beyond which the split cannot be moved.
         /// </summary>
         [ViewVariables(VVAccess.ReadWrite)]
-        public float SplitEdgeSeparation { get; set; }
+        public float SplitEdgeSeparation { get; set; } = 10;
 
         private float _splitStart;
 
@@ -58,6 +71,7 @@ namespace Robust.Client.UserInterface.Controls
                 _splitStart = value - _splitWidth / 2;
                 ClampSplitCenter();
                 InvalidateMeasure();
+                OnSplitResized?.Invoke();
             }
         }
 
@@ -81,13 +95,51 @@ namespace Robust.Client.UserInterface.Controls
             }
         }
 
-        private SplitState _splitState;
-        private bool _dragging;
+        private SplitState _splitState = SplitState.Auto;
         private SplitOrientation _orientation;
-        private SplitStretchDirection _stretchDirection;
+        private SplitStretchDirection _stretchDirection = SplitStretchDirection.BottomRight;
+        private bool _dragging;
+        private float _dragOffset;
 
         private bool Vertical => Orientation == SplitOrientation.Vertical;
 
+        private readonly SplitDragControl _splitDragArea = new();
+
+        /// <summary>
+        /// The upper/left control in the split container.
+        /// </summary>
+        public Control? First
+        {
+            get
+            {
+                if (ChildCount < 3)
+                    return null;
+
+                DebugTools.AssertNotEqual(GetChild(0), _splitDragArea);
+                return GetChild(0);
+            }
+        }
+
+        /// <summary>
+        /// The lower/right control in the split container.
+        /// </summary>
+        public Control? Second
+        {
+            get
+            {
+                if (ChildCount < 3)
+                    return null;
+
+                DebugTools.AssertNotEqual(GetChild(1), _splitDragArea);
+                return GetChild(1);
+            }
+        }
+
+        public (Control First, Control Second)? Splits => ChildCount < 3 ? null : (GetChild(0), GetChild(1));
+
+        public event Action? OnSplitResizeFinished;
+        public event Action? OnSplitResized;
+
         /// <summary>
         /// Whether the split position should be set manually or automatically.
         /// </summary>
@@ -131,73 +183,53 @@ namespace Robust.Client.UserInterface.Controls
         public SplitContainer()
         {
             MouseFilter = MouseFilterMode.Stop;
-            _splitState = SplitState.Auto;
-            _stretchDirection = SplitStretchDirection.BottomRight;
-            _dragging = false;
-            ResizeMode = SplitResizeMode.RespectChildrenMinSize;
-            SplitWidth = 10;
-            SplitEdgeSeparation = 10;
+            AddChild(_splitDragArea);
+            _splitDragArea.Visible = _resizeMode != SplitResizeMode.NotResizable;
+            _splitDragArea.DefaultCursorShape =  Vertical ? CursorShape.VResize : CursorShape.HResize;
+            _splitDragArea.OnMouseUp += StopDragging;
+            _splitDragArea.OnMouseDown += StartDragging;
+            _splitDragArea.OnMouseMove += OnMove;
         }
 
-        protected internal override void MouseMove(GUIMouseMoveEventArgs args)
+        private void OnMove(GUIMouseMoveEventArgs args)
         {
-            base.MouseMove(args);
+            if (ResizeMode == SplitResizeMode.NotResizable)
+                return;
 
-            if (ResizeMode == SplitResizeMode.NotResizable) return;
+            if (!_dragging)
+                return;
 
-            if (_dragging)
-            {
-                var newOffset = Vertical ? args.RelativePosition.Y : args.RelativePosition.X;
-
-                SplitCenter = newOffset;
-                DefaultCursorShape = Vertical ? CursorShape.VResize : CursorShape.HResize;
-            }
-            else
-            {
-                // on mouseover, check if they are over the split and change the cursor accordingly
-                var cursor = CursorShape.Arrow;
-                if (CanDragAt(args.RelativePosition))
-                {
-                    cursor = Vertical ? CursorShape.VResize : CursorShape.HResize;
-                }
-
-                DefaultCursorShape = cursor;
-            }
+            // Source control might be either the container, or the separator.
+            // So we manually calculate the relative coordinates wrt the container.
+            var relative = args.GlobalPosition - GlobalPosition;
+            SplitCenter = Vertical ? relative.Y - _dragOffset : relative.X + _dragOffset;
         }
 
-
-        protected internal override void KeyBindDown(GUIBoundKeyEventArgs args)
+        protected override void ChildAdded(Control newChild)
         {
-            base.KeyBindDown(args);
-
-            if (ResizeMode == SplitResizeMode.NotResizable) return;
-
-            if (_dragging || args.Function != EngineKeyFunctions.UIClick) return;
-
-            if (CanDragAt(args.RelativePosition))
-            {
-                _dragging = true;
-                _splitState = SplitState.Manual;
-            }
+            base.ChildAdded(newChild);
+            _splitDragArea.SetPositionLast();
         }
 
-        protected internal override void KeyBindUp(GUIBoundKeyEventArgs args)
+        public void StartDragging(GUIBoundKeyEventArgs args)
         {
-            base.KeyBindUp(args);
+            if (ResizeMode == SplitResizeMode.NotResizable || _dragging)
+                return;
 
-            if (args.Function != EngineKeyFunctions.UIClick) return;
+            _dragging = true;
+            _dragOffset = DraggableWidth / 2 - (Vertical ? args.RelativePosition.Y : args.RelativePosition.X);
+            _splitState = SplitState.Manual;
+            DefaultCursorShape = Vertical ? CursorShape.VResize : CursorShape.HResize;
+        }
+
+        private void StopDragging(GUIBoundKeyEventArgs args)
+        {
+            if (!_dragging)
+                return;
 
             _dragging = false;
             DefaultCursorShape = CursorShape.Arrow;
-        }
-
-        private bool CanDragAt(Vector2 relativePosition)
-        {
-            var distance = Vertical
-                ? Math.Abs(relativePosition.Y - SplitCenter)
-                : Math.Abs(relativePosition.X - SplitCenter);
-
-            return distance <= _splitWidth || distance <= MinDraggableWidth;
+            OnSplitResizeFinished?.Invoke();
         }
 
         /// <summary>
@@ -218,7 +250,7 @@ namespace Robust.Client.UserInterface.Controls
                 desiredSplit += Vertical ? desiredSize.Value.Y - Size.Y : desiredSize.Value.X - Size.X;
             _splitStart = MathHelper.Clamp(desiredSplit, SplitEdgeSeparation, splitMax);
 
-            if (ResizeMode == SplitResizeMode.RespectChildrenMinSize && ChildCount == 2)
+            if (ResizeMode == SplitResizeMode.RespectChildrenMinSize && ChildCount == 3)
             {
                 var first = GetChild(0);
                 var second = GetChild(1);
@@ -234,7 +266,7 @@ namespace Robust.Client.UserInterface.Controls
 
         protected override Vector2 ArrangeOverride(Vector2 finalSize)
         {
-            if (ChildCount != 2)
+            if (ChildCount < 3)
             {
                 return finalSize;
             }
@@ -287,15 +319,23 @@ namespace Robust.Client.UserInterface.Controls
                 }
             }
 
+            // location & size of the draggable area may be larger than the split area.
+            var dragCenter = _splitStart + _splitWidth / 2;
+            var dragWidth = DraggableWidth;
+            var dragStart = dragCenter - dragWidth / 2;
+            var dragEnd = dragCenter + dragWidth / 2;
+
             if (Vertical)
             {
                 first.Arrange(new UIBox2(0, 0, finalSize.X, _splitStart));
                 second.Arrange(new UIBox2(0, _splitStart + _splitWidth, finalSize.X, finalSize.Y));
+                _splitDragArea.Arrange(new UIBox2(0, dragStart, finalSize.X, dragEnd));
             }
             else
             {
                 first.Arrange(new UIBox2(0, 0, _splitStart, finalSize.Y));
                 second.Arrange(new UIBox2(_splitStart + _splitWidth, 0, finalSize.X, finalSize.Y));
+                _splitDragArea.Arrange(new UIBox2(dragStart, 0, dragEnd, finalSize.Y));
             }
 
             return finalSize;
@@ -303,7 +343,7 @@ namespace Robust.Client.UserInterface.Controls
 
         protected override Vector2 MeasureOverride(Vector2 availableSize)
         {
-            if (ChildCount != 2)
+            if (ChildCount < 3)
             {
                 return Vector2.Zero;
             }
@@ -420,5 +460,40 @@ namespace Robust.Client.UserInterface.Controls
             /// </summary>
             TopLeft,
         }
+
+        /// <summary>
+        /// Simple control to intercept mous events and redirect them to the parent.
+        /// </summary>
+        private sealed class SplitDragControl : Control
+        {
+            public event Action<GUIBoundKeyEventArgs>? OnMouseDown;
+            public event Action<GUIBoundKeyEventArgs>? OnMouseUp;
+            public event Action<GUIMouseMoveEventArgs>? OnMouseMove;
+
+            public SplitDragControl()
+            {
+                MouseFilter = MouseFilterMode.Stop;
+            }
+
+            protected internal override void MouseMove(GUIMouseMoveEventArgs args)
+            {
+                base.MouseMove(args);
+                OnMouseMove?.Invoke(args);
+            }
+
+            protected internal override void KeyBindDown(GUIBoundKeyEventArgs args)
+            {
+                base.KeyBindDown(args);
+                if (args.Function == EngineKeyFunctions.UIClick)
+                    OnMouseDown?.Invoke(args);
+            }
+
+            protected internal override void KeyBindUp(GUIBoundKeyEventArgs args)
+            {
+                base.KeyBindUp(args);
+                if (args.Function == EngineKeyFunctions.UIClick)
+                    OnMouseUp?.Invoke(args);
+            }
+        }
     }
 }

Robust.Client/UserInterface/Controls/SpriteView.cs

@@ -7,7 +7,6 @@ using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
-using Direction = Robust.Shared.Maths.Direction;
 
 namespace Robust.Client.UserInterface.Controls
 {
@@ -18,18 +17,14 @@ namespace Robust.Client.UserInterface.Controls
         IEntityManager _entMan;
 
         [ViewVariables]
-        private SpriteComponent? _sprite;
-        public SpriteComponent? Sprite
-        {
-            get => _sprite;
-            [Obsolete("Use SetEntity()")]
-            set => SetEntity(value?.Owner);
-        }
+        public SpriteComponent? Sprite { get; private set; }
 
 
         [ViewVariables]
         public EntityUid? Entity { get; private set; }
 
+        public Entity<SpriteComponent>? Ent => Entity == null || Sprite == null ? null : (Entity.Value, Sprite);
+
         /// <summary>
         /// This field configures automatic scaling of the sprite. This automatic scaling is done before
         /// applying the explicitly set scale <see cref="SpriteView.Scale"/>.
@@ -124,14 +119,22 @@ namespace Robust.Client.UserInterface.Controls
         public SpriteView()
         {
             _entMan = IoCManager.Resolve<IEntityManager>();
-            _entMan.TryGetComponent(Entity, out _sprite);
+            if (_entMan.TryGetComponent(Entity, out SpriteComponent? sprite))
+            {
+                Sprite = sprite;
+            }
+
             RectClipContent = true;
         }
 
         public void SetEntity(EntityUid? uid)
         {
             Entity = uid;
-            _entMan.TryGetComponent(Entity, out _sprite);
+
+            if (_entMan.TryGetComponent(Entity, out SpriteComponent? sprite))
+            {
+                Sprite = sprite;
+            }
         }
 
         protected override Vector2 MeasureOverride(Vector2 availableSize)
@@ -143,13 +146,13 @@ namespace Robust.Client.UserInterface.Controls
 
         private void UpdateSize()
         {
-            if (Entity == null || _sprite == null)
+            if (Entity == null || Sprite == null)
             {
                 _spriteSize = default;
                 return;
             }
 
-            var spriteBox = _sprite.CalculateRotatedBoundingBox(default,  _worldRotation ?? Angle.Zero, _eyeRotation)
+            var spriteBox = Sprite.CalculateRotatedBoundingBox(default,  _worldRotation ?? Angle.Zero, _eyeRotation)
                 .CalcBoundingBox();
 
             if (!SpriteOffset)
@@ -191,10 +194,10 @@ namespace Robust.Client.UserInterface.Controls
 
         internal override void DrawInternal(IRenderHandle renderHandle)
         {
-            if (Entity is not {} uid || _sprite == null)
+            if (Entity is not {} uid || Sprite == null)
                 return;
 
-            if (_sprite.Deleted)
+            if (Sprite.Deleted)
             {
                 SetEntity(null);
                 return;
@@ -214,11 +217,11 @@ namespace Robust.Client.UserInterface.Controls
 
             var offset = SpriteOffset
                 ? Vector2.Zero
-                : - (-_eyeRotation).RotateVec(_sprite.Offset) * new Vector2(1, -1) * EyeManager.PixelsPerMeter;
+                : - (-_eyeRotation).RotateVec(Sprite.Offset) * new Vector2(1, -1) * EyeManager.PixelsPerMeter;
 
             var position = PixelSize / 2 + offset * stretch * UIScale;
             var scale = Scale * UIScale * stretch;
-            renderHandle.DrawEntity(uid, position, scale, _worldRotation, _eyeRotation, OverrideDirection, _sprite);
+            renderHandle.DrawEntity(uid, position, scale, _worldRotation, _eyeRotation, OverrideDirection, Sprite);
         }
     }
 }

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

@@ -117,7 +117,7 @@ Mouse Pos:
     {playerWorldOffset}
     {playerCoordinates}
     Rotation: {playerRotation.Degrees:F2}°
-    EntId: {entityTransform.Owner}
+    EntId: {controlledEntity}
     GridUid: {entityTransform.GridUid}
     Grid Rotation: {gridRotation.Degrees:F2}°");
             }

Robust.Client/UserInterface/Tooltips.cs

@@ -44,7 +44,7 @@ namespace Robust.Client.UserInterface
             LayoutContainer.SetPosition(tooltip, new Vector2(screenPosition.X, screenPosition.Y - combinedMinSize.Y));
 
             var right = tooltip.Position.X + combinedMinSize.X;
-            var top = tooltip.Position.Y - combinedMinSize.Y;
+            var top = tooltip.Position.Y;
 
             if (right > screenBounds.X)
             {

Robust.Client/UserInterface/UIScreen.cs

@@ -69,12 +69,11 @@ public abstract class UIScreen : LayoutContainer
 
     public void RemoveWidget<T>() where T : UIWidget, new()
     {
-        if (_widgets.TryGetValue(typeof(T), out var widget))
-        {
-            RemoveChild(widget);
-        }
+        if (!_widgets.Remove(typeof(T), out var widget))
+            return;
 
-        _widgets.Remove(typeof(T));
+        widget.Parent?.RemoveChild(widget);
+        RemoveChildren(widget);
     }
 
     internal void OnRemoved()
@@ -103,6 +102,14 @@ public abstract class UIScreen : LayoutContainer
         AddChild(widget);
     }
 
+    public void AddWidgetDirect(UIWidget widget)
+    {
+        if (!_widgets.TryAdd(widget.GetType(), widget))
+            throw new Exception("Tried to add duplicate widget to screen!");
+
+        RegisterChildren(widget);
+    }
+
     public T? GetWidget<T>() where T : UIWidget, new()
     {
         return (T?) _widgets.GetValueOrDefault(typeof(T));

Robust.Client/ViewVariables/ClientViewVariablesManager.cs

@@ -10,11 +10,12 @@ using Robust.Client.ViewVariables.Editors;
 using Robust.Client.ViewVariables.Instances;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Localization;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
@@ -190,6 +191,11 @@ namespace Robust.Client.ViewVariables
                 return new VVPropEditorEntityUid();
             }
 
+            if (type == typeof(NetEntity))
+            {
+                return new VVPropEditorNetEntity();
+            }
+
             if (type == typeof(Color))
             {
                 return new VVPropEditorColor();
@@ -227,7 +233,7 @@ namespace Robust.Client.ViewVariables
                 instance = new ViewVariablesInstanceObject(this, _robustSerializer);
             }
 
-            var window = new DefaultWindow {Title = "View Variables"};
+            var window = new DefaultWindow {Title = Loc.GetString("view-variables")};
             instance.Initialize(window, obj);
             window.OnClose += () => _closeInstance(instance, false);
             _windows.Add(instance, window);
@@ -245,7 +251,7 @@ namespace Robust.Client.ViewVariables
         {
             var window = new DefaultWindow
             {
-                Title = "View Variables",
+                Title = Loc.GetString("view-variables"),
                 SetSize = _defaultWindowSize
             };
             var loadingLabel = new Label {Text = "Retrieving remote object data from server..."};

Robust.Client/ViewVariables/Editors/VVPropEditorEntityCoordinates.cs

@@ -5,7 +5,7 @@ using Robust.Client.UserInterface.Controls;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
+using Robust.Shared.Map.Components;
 using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.ViewVariables.Editors
@@ -67,13 +67,13 @@ namespace Robust.Client.ViewVariables.Editors
                 var xVal = float.Parse(x.Text, CultureInfo.InvariantCulture);
                 var yVal = float.Parse(y.Text, CultureInfo.InvariantCulture);
 
-                if (!mapManager.TryGetGrid(gridVal, out var grid))
+                if (!entityManager.HasComponent<MapGridComponent>(gridVal))
                 {
                     ValueChanged(new EntityCoordinates(EntityUid.Invalid, new(xVal, yVal)));
                     return;
                 }
 
-                ValueChanged(new EntityCoordinates(grid.Owner, new(xVal, yVal)));
+                ValueChanged(new EntityCoordinates(gridVal, new(xVal, yVal)));
             }
 
             if (!ReadOnly)

Robust.Client/ViewVariables/Editors/VVPropEditorEntityUid.cs

@@ -4,7 +4,6 @@ using Robust.Client.UserInterface.Controls;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Maths;
 using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.ViewVariables.Editors
@@ -39,7 +38,8 @@ namespace Robust.Client.ViewVariables.Editors
 
             vvButton.OnPressed += e =>
             {
-                IoCManager.Resolve<IConsoleHost>().ExecuteCommand($"vv {uid}");
+                var id = IoCManager.Resolve<IEntityManager>().GetNetEntity(uid);
+                IoCManager.Resolve<IConsoleHost>().ExecuteCommand($"vv {id}");
             };
 
             hBox.AddChild(lineEdit);

Robust.Client/ViewVariables/Editors/VVPropEditorNetEntity.cs

@@ -0,0 +1,48 @@
+using System.Numerics;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
+
+namespace Robust.Client.ViewVariables.Editors;
+
+public sealed class VVPropEditorNetEntity : VVPropEditor
+{
+    protected override Control MakeUI(object? value)
+    {
+        var hBox = new BoxContainer
+        {
+            Orientation = LayoutOrientation.Horizontal,
+            MinSize = new Vector2(200, 0)
+        };
+
+        var nuid = (NetEntity)value!;
+        var lineEdit = new LineEdit
+        {
+            Text = nuid.ToString(),
+            Editable = !ReadOnly,
+            HorizontalExpand = true,
+        };
+        if (!ReadOnly)
+        {
+            lineEdit.OnTextEntered += e =>
+                ValueChanged(NetEntity.Parse(e.Text));
+        }
+
+        var vvButton = new Button()
+        {
+            Text = "View",
+        };
+
+        vvButton.OnPressed += e =>
+        {
+            IoCManager.Resolve<IConsoleHost>().ExecuteCommand($"vv {nuid}");
+        };
+
+        hBox.AddChild(lineEdit);
+        hBox.AddChild(vvButton);
+        return hBox;
+    }
+}

Robust.Client/ViewVariables/Instances/ViewVariablesInstanceEntity.cs

@@ -120,7 +120,11 @@ namespace Robust.Client.ViewVariables.Instances
                     };
                     top.HorizontalExpand = true;
                     hBox.AddChild(top);
-                    hBox.AddChild(new SpriteView {Sprite = sprite, OverrideDirection = Direction.South});
+
+                    var view = new SpriteView { OverrideDirection = Direction.South };
+                    view.SetEntity(_entity);
+                    hBox.AddChild(view);
+
                     vBoxContainer.AddChild(hBox);
                 }
                 else
@@ -270,7 +274,7 @@ namespace Robust.Client.ViewVariables.Instances
                 button.OnPressed += _ =>
                 {
                     ViewVariablesManager.OpenVV(
-                        new ViewVariablesComponentSelector(_entityManager.GetNetEntity(_entity), componentType.FullName));
+                        new ViewVariablesComponentSelector(_netEntity, componentType.FullName));
                 };
                 removeButton.OnPressed += _ =>
                 {
@@ -431,8 +435,7 @@ namespace Robust.Client.ViewVariables.Instances
 
             try
             {
-                var comp = (Component) componentFactory.GetComponent(registration.Type);
-                comp.Owner = _entity;
+                var comp = componentFactory.GetComponent(registration.Type);
                 _entityManager.AddComponent(_entity, comp);
             }
             catch (Exception e)
@@ -469,8 +472,7 @@ namespace Robust.Client.ViewVariables.Instances
             _entitySession = session;
 
             _membersBlob = await ViewVariablesManager.RequestData<ViewVariablesBlobMembers>(session, new ViewVariablesRequestMembers());
-
-            var uid = (EntityUid) _membersBlob.MemberGroups.SelectMany(p => p.Item2).Single(p => p.Name == "Uid").Value;
+            var uid = (NetEntity) _membersBlob.MemberGroups.SelectMany(p => p.Item2).First(p => p.Value is NetEntity).Value;
 
             Initialize(window, uid);
         }

Robust.Server/BaseServer.cs

@@ -28,6 +28,7 @@ using Robust.Shared.Localization;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Player;
 using Robust.Shared.Profiling;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Reflection;
@@ -306,7 +307,9 @@ namespace Robust.Server
             _modLoader.SetUseLoadContext(!ContentStart);
             _modLoader.SetEnableSandboxing(Options.Sandboxing);
 
-            if (!_modLoader.TryLoadModulesFrom(Options.AssemblyDirectory, Options.ContentModulePrefix))
+            var resourceManifest = ResourceManifestData.LoadResourceManifest(_resources);
+
+            if (!_modLoader.TryLoadModulesFrom(Options.AssemblyDirectory, resourceManifest.AssemblyPrefix ?? Options.ContentModulePrefix))
             {
                 _logger.Fatal("Errors while loading content assemblies.");
                 return true;

Robust.Server/Console/Commands/AddComponentCommand.cs

@@ -1,5 +1,4 @@
-using System;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
@@ -47,11 +46,7 @@ namespace Robust.Server.Console.Commands
                 shell.WriteLine($"Entity {_entityManager.GetComponent<MetaDataComponent>(uid.Value).EntityName} already has a {componentName} component.");
             }
 
-            var component = (Component) _componentFactory.GetComponent(registration.Type);
-
-#pragma warning disable CS0618
-            component.Owner = uid.Value;
-#pragma warning restore CS0618
+            var component = _componentFactory.GetComponent(registration.Type);
             _entityManager.AddComponent(uid.Value, component);
 
             shell.WriteLine($"Added {componentName} component to entity {_entityManager.GetComponent<MetaDataComponent>(uid.Value).EntityName}.");

Robust.Server/Console/Commands/DeleteCommand.cs

@@ -1,37 +0,0 @@
-using Robust.Server.GameObjects;
-using Robust.Shared.Console;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-
-namespace Robust.Server.Console.Commands
-{
-    public sealed class DeleteCommand : LocalizedCommands
-    {
-        [Dependency] private readonly IEntityManager _entityManager = default!;
-
-        public override string Command => "delete";
-
-        public override void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            if (args.Length != 1)
-            {
-                shell.WriteLine("You should provide exactly one argument.");
-                return;
-            }
-
-            if (!NetEntity.TryParse(args[0], out var entityNet))
-            {
-                shell.WriteLine("Invalid entity UID.");
-                return;
-            }
-
-            if (!_entityManager.TryGetEntity(entityNet, out var entity) || !_entityManager.EntityExists(entity))
-            {
-                shell.WriteLine("That entity does not exist.");
-                return;
-            }
-
-            _entityManager.DeleteEntity(entity.Value);
-        }
-    }
-}

Robust.Server/Console/Commands/PlayerCommands.cs

@@ -21,7 +21,7 @@ namespace Robust.Server.Console.Commands
 
             var sb = new StringBuilder();
 
-            var players = _players.ServerSessions;
+            var players = _players.Sessions;
             sb.AppendLine($"{"Player Name",20} {"Status",12} {"Playing Time",14} {"Ping",9} {"IP EndPoint",20}");
             sb.AppendLine("-------------------------------------------------------------------------------");
 
@@ -50,8 +50,8 @@ namespace Robust.Server.Console.Commands
         {
             if (args.Length < 1)
             {
-                var player = shell.Player as IPlayerSession;
-                var toKickPlayer = player ?? _players.ServerSessions.FirstOrDefault();
+                var player = shell.Player;
+                var toKickPlayer = player ?? _players.Sessions.FirstOrDefault();
                 if (toKickPlayer == null)
                 {
                     shell.WriteLine("You need to provide a player to kick.");
@@ -79,7 +79,7 @@ namespace Robust.Server.Console.Commands
         {
             if (args.Length == 1)
             {
-                var options = _players.ServerSessions.OrderBy(c => c.Name).Select(c => c.Name).ToArray();
+                var options = _players.Sessions.OrderBy(c => c.Name).Select(c => c.Name).ToArray();
 
                 return CompletionResult.FromHintOptions(options, "<PlayerIndex>");
             }

Robust.Server/Console/Commands/ViewSubscriberCommand.cs

@@ -1,9 +1,8 @@
 using Robust.Server.GameObjects;
-using Robust.Server.Player;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 
 namespace Robust.Server.Console.Commands
 {
@@ -17,7 +16,7 @@ namespace Robust.Server.Console.Commands
         {
             var session = shell.Player;
 
-            if (session is not IPlayerSession playerSession)
+            if (session is not { } playerSession)
             {
                 shell.WriteError($"Unable to find {nameof(ICommonSession)} for shell");
                 return;
@@ -54,7 +53,7 @@ namespace Robust.Server.Console.Commands
             {
                 var session = shell.Player;
 
-                if (session is not IPlayerSession playerSession)
+                if (session is not { } playerSession)
                 {
                     shell.WriteError($"Unable to find {nameof(ICommonSession)} for shell");
                     return;

Robust.Server/Console/ConGroupController.cs

@@ -1,6 +1,4 @@
-using Robust.Server.Player;
-using Robust.Shared.Map;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Toolshed;
 using Robust.Shared.Toolshed.Errors;
 
@@ -10,27 +8,27 @@ namespace Robust.Server.Console
     {
         public IConGroupControllerImplementation? Implementation { get; set; }
 
-        public bool CanCommand(IPlayerSession session, string cmdName)
+        public bool CanCommand(ICommonSession session, string cmdName)
         {
             return Implementation?.CanCommand(session, cmdName) ?? false;
         }
 
-        public bool CanAdminPlace(IPlayerSession session)
+        public bool CanAdminPlace(ICommonSession session)
         {
             return Implementation?.CanAdminPlace(session) ?? false;
         }
 
-        public bool CanScript(IPlayerSession session)
+        public bool CanScript(ICommonSession session)
         {
             return Implementation?.CanScript(session) ?? false;
         }
 
-        public bool CanAdminMenu(IPlayerSession session)
+        public bool CanAdminMenu(ICommonSession session)
         {
             return Implementation?.CanAdminMenu(session) ?? false;
         }
 
-        public bool CanAdminReloadPrototypes(IPlayerSession session)
+        public bool CanAdminReloadPrototypes(ICommonSession session)
         {
             return Implementation?.CanAdminReloadPrototypes(session) ?? false;
         }

Robust.Server/Console/IConGroupControllerImplementation.cs

@@ -1,14 +1,14 @@
-using Robust.Server.Player;
+using Robust.Shared.Player;
 using Robust.Shared.Toolshed;
 
 namespace Robust.Server.Console
 {
     public interface IConGroupControllerImplementation : IPermissionController
     {
-        bool CanCommand(IPlayerSession session, string cmdName);
-        bool CanAdminPlace(IPlayerSession session);
-        bool CanScript(IPlayerSession session);
-        bool CanAdminMenu(IPlayerSession session);
-        bool CanAdminReloadPrototypes(IPlayerSession session);
+        bool CanCommand(ICommonSession session, string cmdName);
+        bool CanAdminPlace(ICommonSession session);
+        bool CanScript(ICommonSession session);
+        bool CanAdminMenu(ICommonSession session);
+        bool CanAdminReloadPrototypes(ICommonSession session);
     }
 }

Robust.Server/Console/ServerConsoleHost.cs

@@ -5,10 +5,9 @@ using System.Threading.Tasks;
 using Robust.Server.Player;
 using Robust.Shared.Console;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Toolshed;
 using Robust.Shared.Toolshed.Syntax;
 using Robust.Shared.Utility;
@@ -42,7 +41,7 @@ namespace Robust.Server.Console
 
             var msg = new MsgConCmd();
             msg.Text = command;
-            NetManager.ServerSendMessage(msg, ((IPlayerSession)session).ConnectedClient);
+            NetManager.ServerSendMessage(msg, session.Channel);
         }
 
         /// <inheritdoc />
@@ -50,18 +49,12 @@ namespace Robust.Server.Console
         {
             var msg = new FormattedMessage();
             msg.AddText(text);
-            if (session is IPlayerSession playerSession)
-                OutputText(playerSession, msg, false);
-            else
-                OutputText(null, msg, false);
+            OutputText(session, msg, false);
         }
 
         public override void WriteLine(ICommonSession? session, FormattedMessage msg)
         {
-            if (session is IPlayerSession playerSession)
-                OutputText(playerSession, msg, false);
-            else
-                OutputText(null, msg, false);
+            OutputText(session, msg, false);
         }
 
         /// <inheritdoc />
@@ -69,10 +62,7 @@ namespace Robust.Server.Console
         {
             var msg = new FormattedMessage();
             msg.AddText(text);
-            if (session is IPlayerSession playerSession)
-                OutputText(playerSession, msg, true);
-            else
-                OutputText(null, msg, true);
+            OutputText(session, msg, true);
         }
 
         public bool IsCmdServer(IConsoleCommand cmd) => true;
@@ -156,7 +146,7 @@ namespace Robust.Server.Console
 
         private bool ShellCanExecute(IConsoleShell shell, string cmdName)
         {
-            return shell.Player == null || _groupController.CanCommand((IPlayerSession)shell.Player, cmdName);
+            return shell.Player == null || _groupController.CanCommand(shell.Player, cmdName);
         }
 
         private void HandleRegistrationRequest(INetChannel senderConnection)
@@ -164,16 +154,40 @@ namespace Robust.Server.Console
             var message = new MsgConCmdReg();
 
             var counter = 0;
-            message.Commands = new MsgConCmdReg.Command[AvailableCommands.Count];
+            var toolshedCommands = _toolshed.DefaultEnvironment.AllCommands().ToArray();
+            message.Commands = new List<MsgConCmdReg.Command>(AvailableCommands.Count + toolshedCommands.Length);
+            var commands = new HashSet<string>();
 
             foreach (var command in AvailableCommands.Values)
             {
-                message.Commands[counter++] = new MsgConCmdReg.Command
+                if (!commands.Add(command.Command))
+                {
+                    Sawmill.Error($"Duplicate command: {command.Command}");
+                    continue;
+                }
+                message.Commands.Add(new MsgConCmdReg.Command
                 {
                     Name = command.Command,
                     Description = command.Description,
                     Help = command.Help
-                };
+                });
+            }
+
+            foreach (var spec in toolshedCommands)
+            {
+                var name = spec.FullName();
+                if (!commands.Add(name))
+                {
+                    Sawmill.Warning($"Duplicate toolshed command: {name}");
+                    continue;
+                }
+
+                message.Commands.Add(new MsgConCmdReg.Command
+                {
+                    Name = name,
+                    Description = spec.Cmd.Description(spec.SubCommand),
+                    Help = spec.Cmd.GetHelp(spec.SubCommand)
+                });
             }
 
             NetManager.ServerSendMessage(message, senderConnection);
@@ -190,7 +204,7 @@ namespace Robust.Server.Console
             ExecuteCommand(session, text);
         }
 
-        private void OutputText(IPlayerSession? session, FormattedMessage text, bool error)
+        private void OutputText(ICommonSession? session, FormattedMessage text, bool error)
         {
             if (session != null)
             {

Robust.Server/Console/SystemConsoleManager.cs

@@ -196,7 +196,7 @@ namespace Robust.Server.Console
                             break;
 
                         case ConsoleKey.Backspace:
-                            if (currentBuffer.Length > 0)
+                            if (currentBuffer.Length > 0 && internalCursor > 0)
                             {
                                 currentBuffer = currentBuffer.Remove(internalCursor - 1, 1);
                                 internalCursor--;

Robust.Server/GameObjects/Components/Actor/ActorComponent.cs

@@ -1,13 +0,0 @@
-using Robust.Server.Player;
-using Robust.Shared.GameObjects;
-using Robust.Shared.ViewVariables;
-
-namespace Robust.Server.GameObjects
-{
-    [RegisterComponent]
-    public sealed partial class ActorComponent : Component
-    {
-        [ViewVariables]
-        public IPlayerSession PlayerSession { get; internal set; } = default!;
-    }
-}

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

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

Robust.Server/GameObjects/Components/VisibilityComponent.cs

@@ -1,8 +1,5 @@
-using System;
-using Robust.Shared.Analyzers;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Serialization.Manager.Attributes;
-using Robust.Shared.ViewVariables;
 
 namespace Robust.Server.GameObjects
 {
@@ -16,13 +13,5 @@ namespace Robust.Server.GameObjects
         /// </summary>
         [DataField("layer")]
         public int Layer = 1;
-
-        [ViewVariables(VVAccess.ReadWrite)]
-        [Obsolete("Do not access directly, only exists for VV")]
-        public int LayerVV
-        {
-            get => Layer;
-            set => EntitySystem.Get<VisibilitySystem>().SetLayer(this, value);
-        }
     }
 }

Robust.Server/GameObjects/EntitySystems/ActorSystem.cs

@@ -4,6 +4,7 @@ using Robust.Server.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Network;
+using Robust.Shared.Player;
 using Robust.Shared.Utility;
 
 namespace Robust.Server.GameObjects
@@ -30,7 +31,7 @@ namespace Robust.Server.GameObjects
         /// <param name="player">The player to attach to the entity</param>
         /// <param name="force">Whether to kick any existing players from the entity</param>
         /// <returns>Whether the attach succeeded, or not.</returns>
-        public bool Attach(EntityUid? uid, IPlayerSession player, bool force = false)
+        public bool Attach(EntityUid? uid, ICommonSession player, bool force = false)
         {
             return Attach(uid, player, false, out _);
         }
@@ -43,25 +44,26 @@ namespace Robust.Server.GameObjects
         /// <param name="force">Whether to kick any existing players from the entity</param>
         /// <param name="forceKicked">The player that was forcefully kicked, or null.</param>
         /// <returns>Whether the attach succeeded, or not.</returns>
-        public bool Attach(EntityUid? entity, IPlayerSession player, bool force, out IPlayerSession? forceKicked)
+        public bool Attach(EntityUid? entity, ICommonSession player, bool force, out ICommonSession? forceKicked)
         {
             // Null by default.
             forceKicked = null;
 
             if (player.AttachedEntity == entity)
+            {
+                DebugTools.Assert(entity == null || HasComp<ActorComponent>(entity));
                 return true;
+            }
 
             if (entity is not { } uid)
                 return Detach(player);
 
             // Cannot attach to a deleted, nonexisting or terminating entity.
-            if (!TryComp(uid, out MetaDataComponent? meta) || meta.EntityLifeStage > EntityLifeStage.MapInitialized)
-            {
+            if (TerminatingOrDeleted(uid))
                 return false;
-            }
 
             // Check if there was a player attached to the entity already...
-            if (EntityManager.TryGetComponent(uid, out ActorComponent? actor))
+            if (TryComp(uid, out ActorComponent? actor))
             {
                 // If we're not forcing the attach, this fails.
                 if (!force)
@@ -69,22 +71,22 @@ namespace Robust.Server.GameObjects
 
                 // Set the event's force-kicked session before detaching it.
                 forceKicked = actor.PlayerSession;
-                Detach(uid, actor);
+                RemComp(uid, actor);
+                DebugTools.AssertNull(forceKicked.AttachedEntity);
             }
 
             // Detach from the currently attached entity.
-            if (!Detach(player))
-                return false;
+            Detach(player);
 
             // We add the actor component.
             actor = EntityManager.AddComponent<ActorComponent>(uid);
             EntityManager.EnsureComponent<EyeComponent>(uid);
             actor.PlayerSession = player;
-            player.SetAttachedEntity(uid);
+            _playerManager.SetAttachedEntity(player, uid);
+            DebugTools.Assert(player.AttachedEntity == entity);
 
             // The player is fully attached now, raise an event!
             RaiseLocalEvent(uid, new PlayerAttachedEvent(uid, player, forceKicked), true);
-            DebugTools.Assert(player.AttachedEntity == entity);
             return true;
         }
 
@@ -108,21 +110,33 @@ namespace Robust.Server.GameObjects
         /// <param name="player">The player session that will be detached from any attached entities.</param>
         /// <returns>Whether the player is now detached from any entities.
         /// This returns true if the player wasn't attached to any entity.</returns>
-        public bool Detach(IPlayerSession player)
+        public bool Detach(ICommonSession player, ActorComponent? actor = null)
         {
             var uid = player.AttachedEntity;
-            return uid == null || Detach(uid.Value);
+            if (uid == null)
+                return true;
+
+            if (!Resolve(uid.Value, ref actor, false))
+            {
+                Log.Error($"Player {player} was attached to a deleted entity?");
+                ((CommonSession) player).AttachedEntity = null;
+                return true;
+            }
+
+            RemComp(uid.Value, actor);
+            DebugTools.AssertNull(player.AttachedEntity);
+            return false;
         }
 
         private void OnActorShutdown(EntityUid entity, ActorComponent component, ComponentShutdown args)
         {
-            component.PlayerSession.SetAttachedEntity(null);
+            _playerManager.SetAttachedEntity(component.PlayerSession, null);
 
             // The player is fully detached now that the component has shut down.
             RaiseLocalEvent(entity, new PlayerDetachedEvent(entity, component.PlayerSession), true);
         }
 
-        public bool TryGetActorFromUserId(NetUserId? userId, [NotNullWhen(true)] out IPlayerSession? actor, [MaybeNullWhen(true)] out EntityUid? actorEntity)
+        public bool TryGetActorFromUserId(NetUserId? userId, [NotNullWhen(true)] out ICommonSession? actor, out EntityUid? actorEntity)
         {
             actor = null;
             actorEntity = null;
@@ -143,14 +157,14 @@ namespace Robust.Server.GameObjects
     public sealed class PlayerAttachedEvent : EntityEventArgs
     {
         public EntityUid Entity { get; }
-        public IPlayerSession Player { get; }
+        public ICommonSession Player { get; }
 
         /// <summary>
         ///     The player session that was forcefully kicked from the entity, if any.
         /// </summary>
-        public IPlayerSession? Kicked { get; }
+        public ICommonSession? Kicked { get; }
 
-        public PlayerAttachedEvent(EntityUid entity, IPlayerSession player, IPlayerSession? kicked = null)
+        public PlayerAttachedEvent(EntityUid entity, ICommonSession player, ICommonSession? kicked = null)
         {
             Entity = entity;
             Player = player;
@@ -164,9 +178,9 @@ namespace Robust.Server.GameObjects
     public sealed class PlayerDetachedEvent : EntityEventArgs
     {
         public EntityUid Entity { get; }
-        public IPlayerSession Player { get; }
+        public ICommonSession Player { get; }
 
-        public PlayerDetachedEvent(EntityUid entity, IPlayerSession player)
+        public PlayerDetachedEvent(EntityUid entity, ICommonSession player)
         {
             Entity = entity;
             Player = player;

Robust.Server/GameObjects/EntitySystems/AudioSystem.cs

@@ -6,7 +6,6 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Player;
-using Robust.Shared.Players;
 
 namespace Robust.Server.GameObjects;
 [UsedImplicitly]

Robust.Server/GameObjects/EntitySystems/InputSystem.cs

@@ -5,6 +5,7 @@ using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.IoC;
+using Robust.Shared.Player;
 
 namespace Robust.Server.GameObjects
 {
@@ -15,10 +16,10 @@ namespace Robust.Server.GameObjects
     {
         [Dependency] private readonly IPlayerManager _playerManager = default!;
 
-        private readonly Dictionary<IPlayerSession, IPlayerCommandStates> _playerInputs = new();
+        private readonly Dictionary<ICommonSession, IPlayerCommandStates> _playerInputs = new();
 
 
-        private readonly Dictionary<IPlayerSession, uint> _lastProcessedInputCmd = new();
+        private readonly Dictionary<ICommonSession, uint> _lastProcessedInputCmd = new();
 
         /// <inheritdoc />
         public override void Initialize()
@@ -48,7 +49,7 @@ namespace Robust.Server.GameObjects
             if (!Enum.IsDefined(typeof(BoundKeyState), msg.State))
                 return;
 
-            var session = (IPlayerSession) eventArgs.SenderSession;
+            var session = eventArgs.SenderSession;
 
             if (_lastProcessedInputCmd[session] < msg.InputSequence)
                 _lastProcessedInputCmd[session] = msg.InputSequence;
@@ -65,12 +66,12 @@ namespace Robust.Server.GameObjects
             }
         }
 
-        public IPlayerCommandStates GetInputStates(IPlayerSession session)
+        public IPlayerCommandStates GetInputStates(ICommonSession session)
         {
             return _playerInputs[session];
         }
 
-        public uint GetLastInputCommand(IPlayerSession session)
+        public uint GetLastInputCommand(ICommonSession session)
         {
             return _lastProcessedInputCmd[session];
         }

Robust.Server/GameObjects/EntitySystems/MapLoaderSystem.cs

@@ -6,7 +6,6 @@ using System.IO;
 using System.Linq;
 using System.Numerics;
 using Robust.Server.Maps;
-using Robust.Shared.Collections;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
@@ -733,7 +732,7 @@ public sealed class MapLoaderSystem : EntitySystem
             return;
 
         // get ents that the grids will bind to
-        var gridComps = new MapGridComponent[yamlGrids.Count];
+        var gridComps = new Entity<MapGridComponent>[yamlGrids.Count];
         var gridQuery = _serverEntityManager.GetEntityQuery<MapGridComponent>();
 
         // linear search for new grid comps
@@ -745,7 +744,7 @@ public sealed class MapLoaderSystem : EntitySystem
             // These should actually be new, pre-init
             DebugTools.Assert(gridComp.LifeStage == ComponentLifeStage.Added);
 
-            gridComps[gridComp.GridIndex] = gridComp;
+            gridComps[gridComp.GridIndex] = new Entity<MapGridComponent>(uid, gridComp);
         }
 
         for (var index = 0; index < yamlGrids.Count; index++)
@@ -764,18 +763,18 @@ public sealed class MapLoaderSystem : EntitySystem
             MappingDataNode yamlGridInfo = (MappingDataNode)yamlGrid["settings"];
             SequenceDataNode yamlGridChunks = (SequenceDataNode)yamlGrid["chunks"];
 
-            var grid = AllocateMapGrid(gridComp, yamlGridInfo);
-            var gridUid = grid.Owner;
+            AllocateMapGrid(gridComp, yamlGridInfo);
+            var gridUid = gridComp.Owner;
 
             foreach (var chunkNode in yamlGridChunks.Cast<MappingDataNode>())
             {
                 var (chunkOffsetX, chunkOffsetY) = _serManager.Read<Vector2i>(chunkNode["ind"]);
-                _serManager.Read(chunkNode, _context, instanceProvider: () => _mapSystem.GetOrAddChunk(gridUid, grid, chunkOffsetX, chunkOffsetY), notNullableOverride: true);
+                _serManager.Read(chunkNode, _context, instanceProvider: () => _mapSystem.GetOrAddChunk(gridUid, gridComp, chunkOffsetX, chunkOffsetY), notNullableOverride: true);
             }
         }
     }
 
-    private static MapGridComponent AllocateMapGrid(MapGridComponent gridComp, MappingDataNode yamlGridInfo)
+    private static void AllocateMapGrid(MapGridComponent gridComp, MappingDataNode yamlGridInfo)
     {
         // sane defaults
         ushort csz = 16;
@@ -795,8 +794,6 @@ public sealed class MapLoaderSystem : EntitySystem
 
         gridComp.ChunkSize = csz;
         gridComp.TileSize = tsz;
-
-        return gridComp;
     }
 
     private void StartupEntities(MapData data)
@@ -879,7 +876,7 @@ public sealed class MapLoaderSystem : EntitySystem
             return;
         }
 
-        foreach (var (netId, component) in EntityManager.GetNetComponents(entity))
+        foreach (var component in metadata.NetComponents.Values)
         {
             var compName = _factory.GetComponentName(component.GetType());
 

Robust.Server/GameObjects/EntitySystems/ServerMetaDataSystem.cs

@@ -7,6 +7,7 @@ namespace Robust.Server.GameObjects;
 public sealed class ServerMetaDataSystem : MetaDataSystem
 {
     [Dependency] private readonly PvsSystem _pvsSystem = default!;
+    private EntityQuery<MetaDataComponent> _mQuery;
 
     public override void Initialize()
     {
@@ -16,6 +17,7 @@ public sealed class ServerMetaDataSystem : MetaDataSystem
 
         EntityManager.ComponentAdded += OnComponentAdded;
         EntityManager.ComponentRemoved += OnComponentRemoved;
+        _mQuery = GetEntityQuery<MetaDataComponent>();
     }
 
     public override void Shutdown()
@@ -45,7 +47,7 @@ public sealed class ServerMetaDataSystem : MetaDataSystem
         if (obj.Terminating || !removed.NetSyncEnabled || (!removed.SessionSpecific && !removed.SendOnlyToOwner))
             return;
 
-        foreach (var (_, comp) in EntityManager.GetNetComponents(obj.BaseArgs.Owner))
+        foreach (var comp in obj.Meta.NetComponents.Values)
         {
             if (comp.LifeStage >= ComponentLifeStage.Removing)
                 continue;
@@ -55,7 +57,7 @@ public sealed class ServerMetaDataSystem : MetaDataSystem
         }
 
         // remove the flag
-        MetaData(obj.BaseArgs.Owner).Flags &= ~MetaDataFlags.SessionSpecific;
+        obj.Meta.Flags &= ~MetaDataFlags.SessionSpecific;
     }
 
     /// <summary>
@@ -67,19 +69,10 @@ public sealed class ServerMetaDataSystem : MetaDataSystem
         if ((meta.Flags & MetaDataFlags.SessionSpecific) == 0)
             return;
 
-        foreach (var (_, comp) in EntityManager.GetNetComponents(uid))
+        foreach (var (_, comp) in meta.NetComponents)
         {
             if (comp.SessionSpecific || comp.SendOnlyToOwner)
                 Dirty(uid, comp);
         }
     }
-
-    public override void SetVisibilityMask(EntityUid uid, int value, MetaDataComponent? meta = null)
-    {
-        if (!Resolve(uid, ref meta) || meta.VisibilityMask == value)
-            return;
-
-        base.SetVisibilityMask(uid, value, meta);
-        _pvsSystem.MarkDirty(uid);
-    }
 }

Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -7,7 +7,7 @@ using Robust.Server.Player;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Utility;
 
 namespace Robust.Server.GameObjects
@@ -194,7 +194,7 @@ namespace Robust.Server.GameObjects
             return bui.SubscribedSessions.Count > 0;
         }
 
-        public bool SessionHasOpenUi(EntityUid uid, Enum uiKey, IPlayerSession session, UserInterfaceComponent? ui = null)
+        public bool SessionHasOpenUi(EntityUid uid, Enum uiKey, ICommonSession session, UserInterfaceComponent? ui = null)
         {
             if (!TryGetUi(uid, uiKey, out var bui, ui))
                 return false;
@@ -218,7 +218,7 @@ namespace Robust.Server.GameObjects
         public bool TrySetUiState(EntityUid uid,
             Enum uiKey,
             BoundUserInterfaceState state,
-            IPlayerSession? session = null,
+            ICommonSession? session = null,
             UserInterfaceComponent? ui = null,
             bool clearOverrides = true)
         {
@@ -284,7 +284,7 @@ namespace Robust.Server.GameObjects
 
         #region Open
 
-        public bool TryOpen(EntityUid uid, Enum uiKey, IPlayerSession session, UserInterfaceComponent? ui = null)
+        public bool TryOpen(EntityUid uid, Enum uiKey, ICommonSession session, UserInterfaceComponent? ui = null)
         {
             if (!TryGetUi(uid, uiKey, out var bui, ui))
                 return false;
@@ -319,7 +319,7 @@ namespace Robust.Server.GameObjects
         #endregion
 
         #region Close
-        public bool TryClose(EntityUid uid, Enum uiKey, IPlayerSession session, UserInterfaceComponent? ui = null)
+        public bool TryClose(EntityUid uid, Enum uiKey, ICommonSession session, UserInterfaceComponent? ui = null)
         {
             if (!TryGetUi(uid, uiKey, out var bui, ui))
                 return false;

Robust.Server/GameObjects/EntitySystems/ViewSubscriberSystem.cs

@@ -1,5 +1,5 @@
-using Robust.Server.Player;
 using Robust.Shared.GameObjects;
+using Robust.Shared.Player;
 
 namespace Robust.Server.GameObjects
 {
@@ -18,7 +18,7 @@ namespace Robust.Server.GameObjects
         /// <summary>
         ///     Subscribes the session to get PVS updates from the point of view of the specified entity.
         /// </summary>
-        public void AddViewSubscriber(EntityUid uid, IPlayerSession session)
+        public void AddViewSubscriber(EntityUid uid, ICommonSession session)
         {
             // If the entity doesn't have the component, it will be added.
             var viewSubscriber = EntityManager.EnsureComponent<ViewSubscriberComponent>(uid);
@@ -27,7 +27,7 @@ namespace Robust.Server.GameObjects
                 return; // Already subscribed, do nothing else.
 
             viewSubscriber.SubscribedSessions.Add(session);
-            session.AddViewSubscription(uid);
+            session.ViewSubscriptions.Add(uid);
 
             RaiseLocalEvent(uid, new ViewSubscriberAddedEvent(uid, session), true);
         }
@@ -35,7 +35,7 @@ namespace Robust.Server.GameObjects
         /// <summary>
         ///     Unsubscribes the session from getting PVS updates from the point of view of the specified entity.
         /// </summary>
-        public void RemoveViewSubscriber(EntityUid uid, IPlayerSession session)
+        public void RemoveViewSubscriber(EntityUid uid, ICommonSession session)
         {
             if(!EntityManager.TryGetComponent(uid, out ViewSubscriberComponent? viewSubscriber))
                 return; // Entity didn't have any subscriptions, do nothing.
@@ -43,7 +43,7 @@ namespace Robust.Server.GameObjects
             if (!viewSubscriber.SubscribedSessions.Remove(session))
                 return; // Session wasn't subscribed, do nothing.
 
-            session.RemoveViewSubscription(uid);
+            session.ViewSubscriptions.Remove(uid);
             RaiseLocalEvent(uid, new ViewSubscriberRemovedEvent(uid, session), true);
         }
 
@@ -51,7 +51,7 @@ namespace Robust.Server.GameObjects
         {
             foreach (var session in component.SubscribedSessions)
             {
-                session.RemoveViewSubscription(uid);
+                session.ViewSubscriptions.Remove(uid);
             }
         }
     }
@@ -62,9 +62,9 @@ namespace Robust.Server.GameObjects
     public sealed class ViewSubscriberAddedEvent : EntityEventArgs
     {
         public EntityUid View { get; }
-        public IPlayerSession Subscriber { get; }
+        public ICommonSession Subscriber { get; }
 
-        public ViewSubscriberAddedEvent(EntityUid view, IPlayerSession subscriber)
+        public ViewSubscriberAddedEvent(EntityUid view, ICommonSession subscriber)
         {
             View = view;
             Subscriber = subscriber;
@@ -78,9 +78,9 @@ namespace Robust.Server.GameObjects
     public sealed class ViewSubscriberRemovedEvent : EntityEventArgs
     {
         public EntityUid View { get; }
-        public IPlayerSession Subscriber { get; }
+        public ICommonSession Subscriber { get; }
 
-        public ViewSubscriberRemovedEvent(EntityUid view, IPlayerSession subscriber)
+        public ViewSubscriberRemovedEvent(EntityUid view, ICommonSession subscriber)
         {
             View = view;
             Subscriber = subscriber;

Robust.Server/GameObjects/EntitySystems/VisibilitySystem.cs

@@ -1,18 +1,36 @@
-using System;
+using Robust.Server.GameStates;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.ViewVariables;
 
 namespace Robust.Server.GameObjects
 {
     public sealed class VisibilitySystem : EntitySystem
     {
-        [Dependency] private readonly MetaDataSystem _metaSys = default!;
+        [Dependency] private readonly PvsSystem _pvs = default!;
+        [Dependency] private readonly IViewVariablesManager _vvManager = default!;
+
+        private EntityQuery<TransformComponent> _xformQuery;
+        private EntityQuery<MetaDataComponent> _metaQuery;
+        private EntityQuery<VisibilityComponent> _visiblityQuery;
 
         public override void Initialize()
         {
             base.Initialize();
+            _xformQuery = GetEntityQuery<TransformComponent>();
+            _metaQuery = GetEntityQuery<MetaDataComponent>();
+            _visiblityQuery = GetEntityQuery<VisibilityComponent>();
             SubscribeLocalEvent<EntParentChangedMessage>(OnParentChange);
             EntityManager.EntityInitialized += OnEntityInit;
+
+            _vvManager.GetTypeHandler<VisibilityComponent>()
+                .AddPath(nameof(VisibilityComponent.Layer), (_, comp) => comp.Layer, (uid, value, comp) =>
+                {
+                    if (!Resolve(uid, ref comp))
+                        return;
+
+                    SetLayer(uid, comp, value);
+                });
         }
 
         public override void Shutdown()
@@ -32,12 +50,6 @@ namespace Robust.Server.GameObjects
                 RefreshVisibility(uid, visibilityComponent: component);
         }
 
-        [Obsolete("Use overload that takes an EntityUid instead")]
-        public void AddLayer(VisibilityComponent component, int layer, bool refresh = true)
-        {
-            AddLayer(component.Owner, component, layer, refresh);
-        }
-
         public void RemoveLayer(EntityUid uid, VisibilityComponent component, int layer, bool refresh = true)
         {
             if ((layer & component.Layer) != layer)
@@ -49,12 +61,6 @@ namespace Robust.Server.GameObjects
                 RefreshVisibility(uid, visibilityComponent: component);
         }
 
-        [Obsolete("Use overload that takes an EntityUid instead")]
-        public void RemoveLayer(VisibilityComponent component, int layer, bool refresh = true)
-        {
-            RemoveLayer(component.Owner, component, layer, refresh);
-        }
-
         public void SetLayer(EntityUid uid, VisibilityComponent component, int layer, bool refresh = true)
         {
             if (component.Layer == layer)
@@ -66,12 +72,6 @@ namespace Robust.Server.GameObjects
                 RefreshVisibility(uid, visibilityComponent: component);
         }
 
-        [Obsolete("Use overload that takes an EntityUid instead")]
-        public void SetLayer(VisibilityComponent component, int layer, bool refresh = true)
-        {
-            SetLayer(component.Owner, component, layer, refresh);
-        }
-
         private void OnParentChange(ref EntParentChangedMessage ev)
         {
             RefreshVisibility(ev.Entity);
@@ -82,27 +82,52 @@ namespace Robust.Server.GameObjects
             RefreshVisibility(uid);
         }
 
-        public void RefreshVisibility(EntityUid uid, MetaDataComponent? metaDataComponent = null, VisibilityComponent? visibilityComponent = null)
+        public void RefreshVisibility(EntityUid uid,
+            VisibilityComponent? visibilityComponent = null,
+            MetaDataComponent? meta = null)
         {
-            if (Resolve(uid, ref metaDataComponent, false))
-                _metaSys.SetVisibilityMask(uid, GetVisibilityMask(uid, visibilityComponent), metaDataComponent);
+            if (!_metaQuery.Resolve(uid, ref meta, false))
+                return;
+
+            // Iterate up through parents and calculate the cumulative visibility mask.
+            var mask = GetParentVisibilityMask(uid, visibilityComponent);
+
+            // Iterate down through children and propagate mask changes.
+            RecursivelyApplyVisibility(uid, mask, meta);
         }
 
-        [Obsolete("Use overload that takes an EntityUid instead")]
-        public void RefreshVisibility(VisibilityComponent visibilityComponent)
+        private void RecursivelyApplyVisibility(EntityUid uid, int mask, MetaDataComponent meta)
         {
-            RefreshVisibility(visibilityComponent.Owner, null, visibilityComponent);
+            if (meta.VisibilityMask == mask)
+                return;
+
+            var xform = _xformQuery.GetComponent(uid);
+            meta.VisibilityMask = mask;
+            _pvs.MarkDirty(uid, xform);
+
+            foreach (var child in xform.ChildEntities)
+            {
+                if (!_metaQuery.TryGetComponent(child, out var childMeta))
+                    continue;
+
+                var childMask = mask;
+
+                if (_visiblityQuery.TryGetComponent(child, out VisibilityComponent? hildVis))
+                    childMask |= hildVis.Layer;
+
+                RecursivelyApplyVisibility(child, childMask, childMeta);
+            }
         }
 
-        private int GetVisibilityMask(EntityUid uid, VisibilityComponent? visibilityComponent = null, TransformComponent? xform = null)
+        private int GetParentVisibilityMask(EntityUid uid, VisibilityComponent? visibilityComponent = null)
         {
             int visMask = 1; // apparently some content expects everything to have the first bit/flag set to true.
-            if (Resolve(uid, ref visibilityComponent, false))
+            if (_visiblityQuery.Resolve(uid, ref visibilityComponent, false))
                 visMask |= visibilityComponent.Layer;
 
             // Include parent vis masks
-            if (Resolve(uid, ref xform) && xform.ParentUid.IsValid())
-                visMask |= GetVisibilityMask(xform.ParentUid);
+            if (_xformQuery.TryGetComponent(uid, out var xform) && xform.ParentUid.IsValid())
+                visMask |= GetParentVisibilityMask(xform.ParentUid);
 
             return visMask;
         }

Robust.Server/GameObjects/IServerEntityNetworkManager.cs

@@ -1,12 +1,10 @@
-using System.Collections.Generic;
-using Robust.Server.Player;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Timing;
+using Robust.Shared.Player;
 
 namespace Robust.Server.GameObjects
 {
     public interface IServerEntityNetworkManager : IEntityNetworkManager
     {
-        uint GetLastMessageSequence(IPlayerSession session);
+        uint GetLastMessageSequence(ICommonSession session);
     }
 }

Robust.Server/GameObjects/ServerEntityManager.cs

@@ -14,6 +14,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
+using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Replays;
 using Robust.Shared.Timing;
@@ -41,6 +42,7 @@ namespace Robust.Server.GameObjects
 #endif
 
         private ISawmill _netEntSawmill = default!;
+        private EntityQuery<ActorComponent> _actorQuery;
 
         public override void Initialize()
         {
@@ -52,6 +54,12 @@ namespace Robust.Server.GameObjects
             base.Initialize();
         }
 
+        public override void Startup()
+        {
+            base.Startup();
+            _actorQuery = GetEntityQuery<ActorComponent>();
+        }
+
         EntityUid IServerEntityManagerInternal.AllocEntity(EntityPrototype? prototype)
         {
             return AllocEntity(prototype, out _);
@@ -77,15 +85,15 @@ namespace Robust.Server.GameObjects
             StartEntity(entity);
         }
 
-        private protected override EntityUid CreateEntity(string? prototypeName, IEntityLoadContext? context = null)
+        private protected override EntityUid CreateEntity(string? prototypeName, out MetaDataComponent metadata, IEntityLoadContext? context = null)
         {
             if (prototypeName == null)
-                return base.CreateEntity(prototypeName, context);
+                return base.CreateEntity(prototypeName, out metadata, context);
 
             if (!PrototypeManager.TryIndex<EntityPrototype>(prototypeName, out var prototype))
                 throw new EntityCreationException($"Attempted to spawn an entity with an invalid prototype: {prototypeName}");
 
-            var entity = base.CreateEntity(prototype, context);
+            var entity = base.CreateEntity(prototype, out metadata, context);
 
             // At this point in time, all data configure on the entity *should* be purely from the prototype.
             // As such, we can reset the modified ticks to Zero,
@@ -108,10 +116,9 @@ namespace Robust.Server.GameObjects
             }
         }
 
-        public override EntityStringRepresentation ToPrettyString(EntityUid uid)
+        public override EntityStringRepresentation ToPrettyString(EntityUid uid, MetaDataComponent? metadata = null)
         {
-            TryGetComponent(uid, out ActorComponent? actor);
-
+            _actorQuery.TryGetComponent(uid, out ActorComponent? actor);
             return base.ToPrettyString(uid) with { Session = actor?.PlayerSession };
         }
 
@@ -124,7 +131,7 @@ namespace Robust.Server.GameObjects
 
         private readonly PriorityQueue<MsgEntity> _queue = new(new MessageSequenceComparer());
 
-        private readonly Dictionary<IPlayerSession, uint> _lastProcessedSequencesCmd =
+        private readonly Dictionary<ICommonSession, uint> _lastProcessedSequencesCmd =
             new();
 
         private bool _logLateMsgs;
@@ -134,9 +141,6 @@ namespace Robust.Server.GameObjects
         {
             _networkManager.RegisterNetMessage<MsgEntity>(HandleEntityNetworkMessage);
 
-            // For syncing component deletions.
-            ComponentRemoved += OnComponentRemoved;
-
             _playerManager.PlayerStatusChanged += OnPlayerStatusChanged;
 
             _configurationManager.OnValueChanged(CVars.NetLogLateMsg, b => _logLateMsgs = b, true);
@@ -158,20 +162,11 @@ namespace Robust.Server.GameObjects
             EntitiesCount.Set(Entities.Count);
         }
 
-        public uint GetLastMessageSequence(IPlayerSession session)
+        public uint GetLastMessageSequence(ICommonSession session)
         {
             return _lastProcessedSequencesCmd[session];
         }
 
-        private void OnComponentRemoved(RemovedComponentEventArgs e)
-        {
-            if (e.Terminating || !e.BaseArgs.Component.NetSyncEnabled)
-                return;
-
-            if (TryGetComponent(e.BaseArgs.Owner, out MetaDataComponent? meta))
-                meta.LastComponentRemoved = _gameTiming.CurTick;
-        }
-
         /// <inheritdoc />
         public void SendSystemNetworkMessage(EntityEventArgs message, bool recordReplay = true)
         {

Robust.Server/GameStates/IServerGameStateManager.cs

@@ -1,6 +1,6 @@
 using System;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Timing;
 
 namespace Robust.Server.GameStates

Robust.Server/GameStates/PvsCollection.cs

@@ -8,7 +8,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -95,7 +95,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
     /// <summary>
     /// List of <see cref="TIndex"/> that should always get sent to a certain <see cref="ICommonSession"/>.
     /// </summary>
-    private readonly Dictionary<ICommonSession, HashSet<TIndex>> _localOverrides = new();
+    private readonly Dictionary<ICommonSession, HashSet<TIndex>> _sessionOverrides = new();
 
     /// <summary>
     /// Which <see cref="TIndex"/> where last seen/sent to a certain <see cref="ICommonSession"/>.
@@ -207,7 +207,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
     public bool TryGetChunk(EntityUid gridId, Vector2i chunkIndices, [NotNullWhen(true)] out HashSet<TIndex>? indices) =>
         _gridChunkContents[gridId].TryGetValue(chunkIndices, out indices);
 
-    public HashSet<TIndex>.Enumerator GetElementsForSession(ICommonSession session) => _localOverrides[session].GetEnumerator();
+    public HashSet<TIndex>.Enumerator GetSessionOverrides(ICommonSession session) => _sessionOverrides[session].GetEnumerator();
 
     private void AddIndexInternal(TIndex index, IIndexLocation location, HashSet<IChunkIndexLocation> dirtyChunks)
     {
@@ -226,10 +226,10 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
                 gridLoc.Add(index);
                 dirtyChunks.Add(gridChunkLocation);
                 break;
-            case LocalOverride localOverride:
-                // might be gone due to disconnects
-                if(!_localOverrides.ContainsKey(localOverride.Session)) return;
-                _localOverrides[localOverride.Session].Add(index);
+            case SessionOverride sessionOverride:
+                if (!_sessionOverrides.TryGetValue(sessionOverride.Session, out var set))
+                    return;
+                set.Add(index);
                 break;
             case MapChunkLocation mapChunkLocation:
                 // might be gone due to map-deletions
@@ -253,16 +253,14 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         switch (location)
         {
             case GlobalOverride global:
-                if (global.Recursive)
-                    _globalRecursiveOverrides.Remove(index);
-                else
-                    _globalOverrides.Remove(index);
+                var set = global.Recursive ? _globalRecursiveOverrides : _globalOverrides;
+                set.Remove(index);
                 break;
             case GridChunkLocation gridChunkLocation:
                 _gridChunkContents[gridChunkLocation.GridId][gridChunkLocation.ChunkIndices].Remove(index);
                 break;
-            case LocalOverride localOverride:
-                _localOverrides[localOverride.Session].Remove(index);
+            case SessionOverride sessionOverride:
+                _sessionOverrides.GetValueOrDefault(sessionOverride.Session)?.Remove(index);
                 break;
             case MapChunkLocation mapChunkLocation:
                 _mapChunkContents[mapChunkLocation.MapId][mapChunkLocation.ChunkIndices].Remove(index);
@@ -276,7 +274,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
     /// <inheritdoc />
     public bool AddPlayer(ICommonSession session)
     {
-        return _localOverrides.TryAdd(session, new()) & _lastSeen.TryAdd(session, new());
+        return _sessionOverrides.TryAdd(session, new()) & _lastSeen.TryAdd(session, new());
     }
 
     /// <inheritdoc />
@@ -292,7 +290,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
     /// <inheritdoc />
     public bool RemovePlayer(ICommonSession session)
     {
-        if (_localOverrides.Remove(session, out var indices))
+        if (_sessionOverrides.Remove(session, out var indices))
         {
             foreach (var index in indices)
             {
@@ -412,7 +410,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
             return;
         }
 
-        if (!removeFromOverride && oldLocation is LocalOverride)
+        if (!removeFromOverride && oldLocation is SessionOverride)
             return;
 
         if (oldLocation is GlobalOverride global &&
@@ -426,28 +424,29 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
 
     /// <summary>
     /// Updates an <see cref="TIndex"/> to be sent to a specific <see cref="ICommonSession"/> at all times.
+    /// This will always also send all children of the given entity.
     /// </summary>
     /// <param name="index">The <see cref="TIndex"/> to update.</param>
     /// <param name="session">The <see cref="ICommonSession"/> receiving the object.</param>
     /// <param name="removeFromOverride">An index at an override position will not be updated unless you set this flag.</param>
-    public void UpdateIndex(TIndex index, ICommonSession session, bool removeFromOverride = false)
+    public void AddSessionOverride(TIndex index, ICommonSession session, bool removeFromOverride)
     {
         if (!TryGetLocation(index, out var oldLocation))
         {
-            RegisterUpdate(index, new LocalOverride(session));
+            RegisterUpdate(index, new SessionOverride(session));
             return;
         }
 
-        if (!removeFromOverride || oldLocation is GlobalOverride)
+        if (!removeFromOverride && oldLocation is GlobalOverride)
             return;
 
-        if (oldLocation is LocalOverride local &&
+        if (oldLocation is SessionOverride local &&
             (!removeFromOverride || local.Session == session))
         {
             return;
         }
 
-        RegisterUpdate(index, new LocalOverride(session));
+        RegisterUpdate(index, new SessionOverride(session));
     }
 
     /// <summary>
@@ -460,7 +459,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
     {
         if (!removeFromOverride
             && TryGetLocation(index, out var oldLocation)
-            && oldLocation is GlobalOverride or LocalOverride)
+            && oldLocation is GlobalOverride or SessionOverride)
         {
             return;
         }
@@ -510,7 +509,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         _indexLocations.TryGetValue(index, out var oldLocation);
 
         //removeFromOverride is false 99% of the time.
-        if ((bufferedLocation ?? oldLocation) is GlobalOverride or LocalOverride && !removeFromOverride)
+        if ((bufferedLocation ?? oldLocation) is GlobalOverride or SessionOverride && !removeFromOverride)
             return;
 
         if (oldLocation is GridChunkLocation oldGrid &&
@@ -541,7 +540,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         _indexLocations.TryGetValue(index, out var oldLocation);
 
         //removeFromOverride is false 99% of the time.
-        if ((bufferedLocation ?? oldLocation) is GlobalOverride or LocalOverride && !removeFromOverride)
+        if ((bufferedLocation ?? oldLocation) is GlobalOverride or SessionOverride && !removeFromOverride)
             return;
 
         // Is this entity just returning to its old location?
@@ -641,14 +640,14 @@ public struct GlobalOverride : IIndexLocation
     }
 }
 
-public struct LocalOverride : IIndexLocation
+public struct SessionOverride : IIndexLocation
 {
-    public LocalOverride(ICommonSession session)
+    public SessionOverride(ICommonSession session)
     {
         Session = session;
     }
 
-    public ICommonSession Session { get; init; }
+    public readonly ICommonSession Session;
 }
 
 #endregion

Robust.Server/GameStates/PvsOverrideSystem.cs

@@ -1,5 +1,5 @@
 using Robust.Shared.GameObjects;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 
 namespace Robust.Server.GameStates;
 
@@ -22,13 +22,14 @@ public sealed class PvsOverrideSystem : EntitySystem
     }
 
     /// <summary>
-    ///     Used to ensure that an entity is always sent to a specific client. Overrides any global or pre-existing
-    ///     client-specific overrides.
+    ///     Used to ensure that an entity is always sent to a specific client. By default this overrides any global or pre-existing
+    ///     client-specific overrides. Unlike global overrides, this is always recursive.
     /// </summary>
     /// <param name="removeExistingOverride">Whether or not to supersede existing overrides.</param>
-    public void AddSessionOverride(EntityUid uid, ICommonSession session,bool removeExistingOverride = true)
+    /// <param name="recursive">If true, this will also recursively send any children of the given index.</param>
+    public void AddSessionOverride(EntityUid uid, ICommonSession session, bool removeExistingOverride = true)
     {
-        _pvs.EntityPVSCollection.UpdateIndex(GetNetEntity(uid), session, removeExistingOverride);
+        _pvs.EntityPVSCollection.AddSessionOverride(GetNetEntity(uid), session, removeExistingOverride);
     }
 
     /// <summary>

Robust.Server/GameStates/PvsSystem.Ack.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;