Version: 136.0.2

(cherry picked from commit 24d5c26fa6)
(cherry picked from commit b89d13d39ffa53b9ca687946c6b56e86449d50bd)

.github/CODEOWNERS

@@ -1,9 +1,18 @@
 # Last match in file takes precedence.
 
 # Ping for all PRs
-* @PJB3005 @DrSmugleaf
+* @Acruid @PJB3005 @ZoldorfTheWizard
 
-# commands commands commands commands
-**/Toolshed/** @moonheart08
-*Command.cs @moonheart08
-*Commands.cs @moonheart08
+/Robust.Client.NameGenerator @PaulRitter
+/Robust.Client.Injectors @PaulRitter
+/Robust.Generators @PaulRitter
+/Robust.Analyzers @PaulRitter
+/Robust.*/GameStates @PaulRitter
+/Robust.Shared/Analyzers @PaulRitter
+/Robust.*/Serialization @PaulRitter @DrSmugleaf
+/Robust.*/Prototypes @PaulRitter
+/Robust.Shared/GameObjects/ComponentDependencies @PaulRitter
+/Robust.*/Containers @PaulRitter
+
+# Be they Fluent translations or Freemarker templates, I know them both!
+*.ftl @RemieRichards

.github/workflows/build-docfx.yml

@@ -7,12 +7,12 @@ jobs:
   docfx:
    runs-on: ubuntu-latest
    steps:
-    - uses: actions/checkout@v3.6.0
+    - uses: actions/checkout@v2
       with:
         submodules: true
 
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v3.2.0
+      uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 7.0.x
 

.github/workflows/build-test.yml

@@ -15,12 +15,12 @@ jobs:
     runs-on: ${{ matrix.os }}
 
     steps:
-    - uses: actions/checkout@v3.6.0
+    - uses: actions/checkout@v2
       with:
         submodules: true
 
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v3.2.0
+      uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 7.0.x
     - name: Install dependencies

.github/workflows/codeql-analysis.yml

@@ -35,12 +35,12 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3.6.0
+      uses: actions/checkout@v2
       with:
         submodules: true
 
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v3.2.0
+      uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 7.0.x
 

.github/workflows/publish-client.yml

@@ -16,12 +16,12 @@ jobs:
         $ver = [regex]::Match($env:GITHUB_REF, "refs/tags/v?(.+)").Groups[1].Value
         echo ("::set-output name=version::{0}" -f $ver)
 
-    - uses: actions/checkout@v3.6.0
+    - uses: actions/checkout@v2
       with:
         submodules: true
 
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v3.2.0
+      uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 7.0.x
 

.github/workflows/test-content.yml

@@ -13,13 +13,13 @@ jobs:
 
     steps:
     - name: Check out content
-      uses: actions/checkout@v3.6.0
+      uses: actions/checkout@v2
       with:
         repository: space-wizards/space-station-14
         submodules: recursive
 
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v3.2.0
+      uses: actions/setup-dotnet@v1
       with:
         dotnet-version: 7.0.x
     - name: Disable submodule autoupdate

MSBuild/Robust.DefineConstants.targets

@@ -23,7 +23,7 @@
   <PropertyGroup Condition="'$(FullRelease)' != 'True'">
     <DefineConstants>$(DefineConstants);DEVELOPMENT</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)' == 'Release' Or '$(Configuration)' == 'Tools'">
+  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
     <DefineConstants>$(DefineConstants);EXCEPTION_TOLERANCE</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="'$(EnableClientScripting)' == 'True'">

MSBuild/Robust.Engine.Version.props

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

MSBuild/Robust.Properties.targets

@@ -25,7 +25,4 @@
 
   <!-- analyzer -->
   <Import Project="Robust.Analyzers.targets" Condition="'$(SkipRobustAnalyzer)' != 'true'" />
-
-  <!-- serialization generator -->
-  <Import Project="Robust.Serialization.Generator.targets" />
 </Project>

MSBuild/Robust.Serialization.Generator.targets

@@ -1,5 +0,0 @@
-<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
-  <ItemGroup>
-    <ProjectReference Include="$(MSBuildThisFileDirectory)\..\Robust.Serialization.Generator\Robust.Serialization.Generator.csproj" OutputItemType="Analyzer" ReferenceOutputAssembly="false"/>
-  </ItemGroup>
-</Project>

RELEASE-NOTES.md

@@ -54,746 +54,7 @@ END TEMPLATE-->
 *None yet*
 
 
-## 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
-
-* Fix PointLight state handling not queueing ComponentTree updates.
-
-
-## 159.0.1
-
-### Bugfixes
-
-* Fix pending entity states not being removed when coming in (only on entity deletion).
-
-### Internal
-
-* Remove PhysicsComponent ref from Fixture.
-
-
-## 159.0.0
-
-### Breaking changes
-
-* Remove ComponentReference from PointLights.
-* Move more of UserInterfaceSystem to shared.
-* Mark some EntitySystem proxy methods as protected instead of public.
-
-### New features
-
-* Make entity deletion take in a nullable EntityUid.
-* Added a method to send predicted messages via BUIs.
-
-### Other
-
-* Add Obsoletions to more sourcegen serv4 methods.
-* Remove inactive reviewers from CODEOWNERs.
-
-
-## 158.0.0
-
-### Breaking changes
-
-* Remove SharedEyeComponent.
-* Add Tile Overlay edge priority.
-
-
-## 157.1.0
-
-### New features
-
-* UI tooltips now use rich text labels.
-
-
-## 157.0.0
-
-### Breaking changes
-
-* Unrevert container changes from 155.0.0.
-* Added server-client EntityUid separation. A given EntityUid will no longer refer to the same entity on the server & client.
-* EntityUid is no longer net-serializable, use NetEntity instead, EntityManager & entity systems have helper methods for converting between the two,
-
-
-## 156.0.0
-
-### Breaking changes
-
-* Revert container changes from 155.0.0.
-
-
-## 155.0.0
-
-### Breaking changes
-
-* MapInitEvent now gets raised for components that get added to entities that have already been map-initialized.
-
-### New features
-
-* VirtualWritableDirProvider now supports file renaming/moving.
-* Added a new command for toggling the replay UI (`replay_toggleui`).
-
-### Bugfixes
-
-* Fixed formatting of localization file errors.
-* Directed event subscriptions will no longer error if the corresponding component is queued for deletion.
-
-
-## 154.2.0
-
-
-
-### New features
-
-* Added support for advertising to multiple hubs simultaneously.
-* Added new functions to ContainerSystem that recursively look for a component on a contained entity's parents.
-
-### Bugfixes
-
-* Fix Direction.TurnCw/TurnCcw to South returning Invalid.
-
-
-## 154.1.0
-
-### New features
-
-* Add MathHelper.Max for TimeSpans.
-
-### Bugfixes
-
-* Make joint initialisation only log under IsFirstTimePredicted on client.
-
-### Other
-
-* Mark the proxy Dirty(component) as obsolete in line with EntityManager (Dirty(EntityUid, Component) should be used in its place).
-
-
-## 154.0.0
-
-### Breaking changes
-
-* Change ignored prototypes to skip prototypes even if the prototype type is found.
-* Moved IPlayerData interface to shared.
-
-### New features
-
-* Added a multiline text submit keybind function.
-
-### Bugfixes
-
-* Fixed multiline edits scrollbar margins.
-
-### Internal
-
-* Added more event sources.
-* Made Toolshed types oneOff IoC injections.
-
-
-## 153.0.0
-
-### Breaking changes
-
-* Removed SharedUserInterfaceComponent component references.
-* Removed EntityDeletedMessage.
-
-### Other
-
-* Performance improvements for replay recording.
-* Lidgren has been updated to [v0.2.6](https://github.com/space-wizards/SpaceWizards.Lidgren.Network/blob/v0.2.6/RELEASE-NOTES.md).
-* Make EntityManager.AddComponent with a component instance set the owner if its default, add system proxy for it.
-
-### Internal
-
-* Added some `EventSource` providers for PVS and replay recording: `Robust.Pvs` and `Robust.ReplayRecording`.
-* Added RecursiveMoveBenchmark.
-* Removed redundant prototype resolving.
-* Removed CollisionWake component removal subscription.
-* Removed redundant DebugTools.AssertNotNull(netId) in ClientGameStateManager
-
-
-## 152.0.0
-
-### Breaking changes
-
-* `Robust.Server.GameObjects.BoundUserInterface.InteractionRangeSqrd` is now a get-only property. Modify `InteractionRange` instead if you want to change it on active UIs.
-* Remove IContainerManager.
-* Remove and obsolete ComponentExt methods.
-* Remove EntityStarted and ComponentDeleted C# events.
-* Convert Tile.TypeId to an int. Old maps that were saved with TypeId being an ushort will still be properly deserialized.
-
-### New features
-
-* `BoundUserInterfaceCheckRangeEvent` can be used to implement custom logic for BUI range checks.
-* Add support for long values in CVars.
-* Allow user code to implement own logic for bound user interface range checks.
-
-### Bugfixes
-
-* Fix timers counting down slower than real time and drifting.
-* Add missing System using statement to generated component states.
-* Fix build with USE_SYSTEM_SQLITE.
-* Fix prototype manager not being initialized in robust server simulation tests.
-* Fix not running serialization hooks when copying non-byref data definition fields without a custom type serializer.
-
-### Other
-
-* Remove warning for glibc 2.37.
-* Remove personally-identifiable file paths from client logs.
-
-### Internal
-
-* Disable obsoletion and inherited member hidden warnings in serialization source generated code.
-* Update CI workflows to use setup-dotnet 3.2.0 and checkout 3.6.0.
-* Fix entity spawn tests having instance per test lifecycle with a non static OneTimeTearDown method.
-* Add new PVS test to check that there is no issue with entity states referencing other entities that the client is not yet aware of.
-
-
-## 151.0.0
-
-
-## 150.0.1
-
-### Bugfixes
-
-* Fix some partial datadefs.
-
-
-## 150.0.0
-
-### Breaking changes
-
-* Remove the Id field from Fixtures as the Id is already stored on FixturesComponent.
-
-### New features
-
-* Add AbstractDictionarySerializer for abstract classes.
-* Add many new spawn functions for entities for common operations.
-
-
-## 149.0.1
-
-### Bugfixes
-
-* Fix serialization sharing instances when copying data definitions and not assigning null when the source is null.
-* Fixed resizing a window to be bigger than its set maxsize crashing the client.
-
-
-## 149.0.0
-
-### Breaking changes
-
-* Data definitions must now be partial, their data fields must not be readonly and their data field properties must have a setter.
-
-### Internal
-
-* Copying data definitions through the serialization manager is now faster and consumes less memory.
-
-
-## 148.4.0
-
-### New features
-
-* Add recursive PVS overrides and remove IsOverride()
-
-
-## 148.3.0
-
-### New features
-
-* Happy eyeballs delay can be configured.
-* Added more colors.
-* Allow pre-startup components to be shut down.
-* Added tile texture reload command.
-* Add implementation of Random.Pick(ValueList<T> ..).
-* Add IntegrationInstance fields for common dependencies.
-
-### Bugfixes
-
-* Prevent invalid prototypes from being spawned.
-* Change default value of EntityLastModifiedTick from zero to one.
-* Make DiscordRichPresence icon CVars server-side with replication.
-
-
-## 148.2.0
-
-### New features
-
-* `SpinBox.LineEditControl` exposes the underlying `LineEdit`.
-* Add VV attributes to various fields across overlay and sessions.
-* Add IsPaused to EntityManager to check if an entity is paused.
-
-### Bugfixes
-
-* Fix SetActiveTheme not updating the theme.
-
-
-## 148.1.0
-
-### New features
-
-* Added IgnoreUIChecksComponent that lets entities ignore bound user interface range checks which would normally close the UI.
-* Add support for F16-F24 keybinds.
-
-### Bugfixes
-
-* Fix gamestate bug where PVS is disabled.
-
-### Other
-
-* EntityQuery.HasComponent override for nullable entity uids.
-
-
-## 148.0.0
-
-### Breaking changes
-
-* Several NuGet dependencies are now private assets.
-* Added `IViewportControl.PixelToMap()` and `PixelToMapEvent`. These are variants of the existing screen-to-map functions that should account for distortion effects.
-
-### New features
-
-* Added several new rich-text tags, including italic and bold-italic.
-
-### Bugfixes
-
-* Fixed log messages for unknown components not working due to threaded IoC issues.
-* Replay recordings no longer record invalid prototype uploads.
-
-
-## 147.0.0
-
-### Breaking changes
-
-* Renamed one of the EntitySystem.Dirty() methods to `DirtyEntity()` to avoid confusion with the component-dirtying methods.
-
-### New features
-
-* Added debug commands that return the entity system update order.
-
-### Bugfixes
-
-* Fixed a bug in MetaDataSystem that was causing the metadata component to not be marked as dirty.
-
-
-## 146.0.0
-
-### Breaking changes
-
-* Remove readOnly for DataFields and rename some ShaderPrototype C# fields internally to align with the normal schema.
-
-### Bugfixes
-
-* Add InvariantCulture to angle validation.
-
-### Internal
-
-* Add some additional EntityQuery<T> usages and remove a redundant CanCollide call on fixture shutdown.
-
-
-## 145.0.0
-
-### Breaking changes
-
-* Removed some old SpriteComponent data-fields ("rsi", and "layerDatums").
-
-### New features
-
-* Added `ActorSystem.TryGetActorFromUserId()`.
-* Added IPrototypeManager.EnumerateKinds().
-
-### Bugfixes
-
-* Fixed SpriteSpecifierSerializer yaml validation not working properly.
-* Fixed IoC/Threading exceptions in `Resource.Load()`.
-* Fixed `TransformSystem.SetCoordinates()` throwing uninformative client-side errors.
-* Fixed `IResourceManager.ContentFileExists()` and `TryContentFileRead()` throwing exceptions on windows when trying to open a directory.
-
-
-## 144.0.1
-
-### Bugfixes
-
-* Fix some EntityLookup queries incorrectly being double transformed internally.
-* Shrink TileEnlargement even further for EntityLookup default queries.
-
-
-## 144.0.0
-
-### Breaking changes
-
-* Add new args to entitylookup methods to allow for shrinkage of tile-bounds checks. Default changed to shrink the grid-local AABB by the polygon skin to avoid clipping neighboring tile entities.
-* Non-hard fixtures will no longer count by default for EntityLookup.
-
-### New features
-
-* Added new EntityLookup flag to return non-hard fixtures or not.
-
-
-## 143.3.0
-
-### New features
-
-* Entity placement and spawn commands now raise informative events that content can handle.
-* Replay clients can now optionally ignore some errors instead of refusing to load the replay.
-
-### Bugfixes
-
-* `AudioParams.PlayOffsetSecond` will no longer apply an offset that is larger then the length of the audio stream.
-* Fixed yaml serialization of arrays of virtual/abstract objects.
-
-
-### Other
-
-* Removed an incorrect gamestate debug assert.
-
-
-## 143.2.0
-
-### New features
-
-* Add support for tests to load extra prototypes from multiple sources.
-
-### Bugfixes
-
-* Fix named toolshed command.
-* Unsubscribe from grid rendering events on shutdown.
-
-### Other
-
-* Remove unnecessary test prototypes.
-
-
-## 143.1.0
-
-### New features
-
-* Add locale support for grammatical measure words.
-
-### Bugfixes
-
-* Don't raise contact events for entities that were QueueDeleted during the tick.
-* Exception on duplicate broadcast subscriptions as this was unsupported behaviour.
-
-### Other
-
-* Add VV ReadWrite to PhysicsComponent BodyStatus.
-
-
-## 143.0.0
-
-### New features
-
-
-- Toolshed, a tacit shell language, has been introduced.
-  - Use Robust.Shared.ToolshedManager to invoke commands, with optional input and output.
-  - Implement IInvocationContext for custom invocation contexts i.e. scripting systems.
-
-
-## 142.1.2
-
-### Other
-
-* Don't log an error on failing to resolve for joint relay refreshing.
-
-
-## 142.1.1
-
-### Bugfixes
-
-* Fixed a bad debug assert in `DetachParentToNull()`
-
-
-## 142.1.0
-
-### New features
-
-* `IHttpClientHolder` holds a shared `HttpClient` for use by content. It has Happy Eyeballs fixed and an appropriate `User-Agent`.
-* Added `DataNode.ToString()`. Makes it easier to save yaml files and debug code.
-* Added some cvars to modify discord rich presence icons.
-* .ogg files now read the `Artist` and `Title` tags and make them available via new fields in `AudioStream`.
-* The default fragment shaders now have access to the local light level (`lowp vec3 lightSample`).
-* Added `IPrototypeManager.ValidateAllPrototypesSerializable()`, which can be used to check that all currently loaded prototypes can be serialised & deserialised.
-
-### Bugfixes
-
-* Fix certain debug commands and tools crashing on non-SS14 RobustToolbox games due to a missing font.
-* Discord rich presence strings are now truncated if they are too long.
-* Fixed a couple of broadphase/entity-lookup update bugs that were affecting containers and entities attached to other (non-grid/map) entities.
-* Fixed `INetChannel.Disconnect()` not properly disconnecting clients in integration tests.
-
-### Other
-
-* Outgoing HTTP requests now all use Happy Eyeballs to try to prioritize IPv6. This is necessary because .NET still does not support this critical feature itself.
-* Made various physics related component properties VV-editable.
-* The default EntitySystem sawmill log level now defaults to `Info` instead of `Verbose`. The level remains verbose when in debug mode.
-
-### Internal
-
-* The debug asserts in `DetachParentToNull()` are now more informative.
-
-
-## 142.0.1
-
-### Bugfixes
-
-* Fix Enum serialization.
-
-
-## 142.0.0
-
-### Breaking changes
-
-* `EntityManager.GetAllComponents()` now returns a (EntityUid, Component) tuple
-
-### New features
-
-* Added `IPrototypeManager.ValidateFields()`, which uses reflection to validate that the default values of c# string fields correspond to valid entity prototypes. Validates any fields with a `ValidatePrototypeIdAttribute`  and any data-field that uses the PrototypeIdSerializer custom type serializer.
-
-### Other
-
-* Replay playback will now log errors when encountering unhandled messages.
-* Made `GetAssemblyByName()` throw descriptive error messages.
-* Improved performance of various EntityLookupSystem functions
-
-
-## 141.2.1
-
-### Bugfixes
-
-* Fix component trait dictionaries not clearing on reconnect leading to bad GetComponent in areas (e.g. entire game looks black due to no entities).
-
-
-## 141.2.0
-
-### Other
-
-* Fix bug in `NetManager` that allowed exception spam through protocol abuse.
-
-
-## 141.1.0
-
-### New features
-
-* MapInitEvent is run clientside for placementmanager entities to predict entity appearances.
-* Add CollisionLayerChangeEvent for physics fixtures.
-
-
-## 141.0.0
-
-### Breaking changes
-
-* Component.Initialize has been fully replaced with the Eventbus.
-
-### Bugfixes
-
-* Fixed potential crashes if buffered audio sources (e.g. MIDI) fail to create due to running out of audio streams.
-
-### Other
-
-* Pressing `^C` twice on the server will now cause it to hard-exit immediately.
-* `Tools` now has `EXCEPTION_TOLERANCE` enabled.
-
-
-## 140.0.0
-
-### Breaking changes
-
-* `IReplayRecordingManager.RecordingFinished` now takes a `ReplayRecordingFinished` object as argument.
-* `IReplayRecordingManager.GetReplayStats` now returns a `ReplayRecordingStats` struct instead of a tuple. The units have also been normalized
-
-### New features
-
-* `IReplayRecordingManager` can now track a "state" object for an active recording.
-* If the path given to `IReplayRecordingManager.TryStartRecording` is rooted, the base replay directory is ignored.
-
-### Other
-
-* `IReplayRecordingManager` no longer considers itself recording inside `RecordingFinished`.
-* `IReplayRecordingManager.Initialize()` was moved to an engine-internal interface.
-
-
-## 139.0.0
-
-### Breaking changes
-
-* Remove Component.Startup(), fully replacing it with the Eventbus.
-
-
-## 138.1.0
-
-### New features
-
-* Add rotation methods to TransformSystem for no lerp.
-
-### Bugfixes
-
-* Fix AnimationCompleted ordering.
-
-
-## 138.0.0
-
-### Breaking changes
-
-* Obsoleted unused `IMidiRenderer.VolumeBoost` property. Use `IMidiRenderer.VelocityOverride` instead.
-* `IMidiRenderer.TrackedCoordinates` is now a `MapCoordinates`.
-
-### New features
-
-* Added `Master` property to `IMidiRenderer`, which allows it to copy all MIDI events from another renderer.
-* Added `FilteredChannels` property to `IMidiRenderer`, which allows it to filter out notes from certain channels.
-* Added `SystemReset` helper property to `IMidiRenderer`, which allows you to easily send it a SystemReset MIDI message.
-
-### Bugfixes
-
-* Fixed some cases were `MidiRenderer` would not respect the `MidiBank` and `MidiProgram.
-* Fixed user soundfonts not loading.
-* Fixed `ItemList` item selection unselecting everything when in `Multiple` mode.
-
-
-## 137.1.0
-
-### New features
-
-* Added BQL `paused` selector.
-* `ModUpdateLevel.PostInput` allows running content code after network and async task processing.
-
-### Other
-
-* BQL `with` now includes paused entities.
-* The game loop now times more accurately and avoids sleeping more than necessary.
-* Sandboxing (and thus, client startup) should be much faster when ran from the launcher.
-
-
-## 137.0.0
-
-### Breaking changes
-
-* Component network state handler methods have been fully deprecated and replaced with the eventbus event equivalents (ComponentGetState and ComponentHandleState).
+## 136.0.2
 
 
 ## 136.0.1

Resources/EnginePrototypes/Debug/rotation.yml

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

Resources/EnginePrototypes/UserInterface/uiThemes.yml

@@ -1,6 +1,6 @@
 - type: uiTheme
   id: Default
-  path: /Textures/Interface/Default/
+  path: /Textures/Interface/Default
   colors:
     # Root
     rootBackground: "#000000"

Resources/EnginePrototypes/entityCategory.yml

@@ -1,17 +0,0 @@
-# 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.
@@ -558,6 +558,3 @@ cmd-vfs_ls-help = Usage: vfs_list <path>
 
 cmd-vfs_ls-err-args = Need exactly 1 argument.
 cmd-vfs_ls-hint-path = <path>
-
-cmd-reloadtiletextures-desc = Reloads the tile texture atlas to allow hot reloading tile sprites
-cmd-reloadtiletextures-help = Usage: reloadtiletextures

Resources/Locale/en-US/discordRPC.ftl

@@ -1,5 +1,4 @@
 discord-rpc-in-main-menu = In Main Menu
-discord-rpc-in-main-menu-logo-text = I think coolsville SUCKS
 discord-rpc-character = Username: {$username}
 discord-rpc-on-server = On Server: {$servername}
-discord-rpc-players = Players: {$players}/{$maxplayers}
+discord-rpc-players = Players: {$players}/{$maxplayers}

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

@@ -1,8 +0,0 @@
-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/input.ftl

@@ -18,15 +18,6 @@ input-key-F12 = F12
 input-key-F13 = F13
 input-key-F14 = F14
 input-key-F15 = F15
-input-key-F16 = F16
-input-key-F17 = F17
-input-key-F18 = F18
-input-key-F19 = F19
-input-key-F20 = F20
-input-key-F21 = F21
-input-key-F22 = F22
-input-key-F23 = F23
-input-key-F24 = F24
 input-key-Pause = Pause
 input-key-Left = Left
 input-key-Up = Up

Resources/Locale/en-US/replays.ftl

@@ -22,7 +22,7 @@ cmd-replay-skip-hint = Ticks or timespan (HH:MM:SS).
 
 cmd-replay-set-time-desc = Jump forwards or backwards to some specific time.
 cmd-replay-set-time-help = replay_set <tick or time>
-cmd-replay-set-time-hint = Tick or timespan (HH:MM:SS), starting from
+cmd-replay-set-time-hint = Tick or timespan (HH:MM:SS), starting from 
 
 cmd-replay-error-time = "{$time}" is not an integer or timespan.
 cmd-replay-error-args = Wrong number of arguments.
@@ -33,7 +33,7 @@ cmd-replay-error-run-level = You cannot load a replay while connected to a serve
 # Recording commands
 
 cmd-replay-recording-start-desc = Starts a replay recording, optionally with some time limit.
-cmd-replay-recording-start-help = Usage: replay_recording_start [name] [overwrite] [time limit]
+cmd-replay-recording-start-help = Usage: replay_recording_start [name] [overwrite] [time limit] 
 cmd-replay-recording-start-success = Started recording a replay.
 cmd-replay-recording-start-already-recording = Already recording a replay.
 cmd-replay-recording-start-error = An error occurred while trying to start the recording.
@@ -48,7 +48,7 @@ cmd-replay-recording-stop-not-recording = Not currently recording a replay.
 
 cmd-replay-recording-stats-desc = Displays information about the current replay recording.
 cmd-replay-recording-stats-help = Usage: replay_recording_stats
-cmd-replay-recording-stats-result = Duration: {$time} min, Ticks: {$ticks}, Size: {$size} MB, rate: {$rate} MB/min.
+cmd-replay-recording-stats-result = Duration: {$time} min, Ticks: {$ticks}, Size: {$size} mb, rate: {$rate} mb/min.
 
 
 # Time Control UI
@@ -56,4 +56,4 @@ replay-time-box-scrubbing-label = Dynamic Scrubbing
 replay-time-box-replay-time-label = Recording Time: {$current} / {$end}  ({$percentage}%)
 replay-time-box-server-time-label = Server Time: {$current} / {$end}
 replay-time-box-index-label = Index: {$current} / {$total}
-replay-time-box-tick-label = Tick: {$current} / {$total}
+replay-time-box-tick-label = Tick: {$current} / {$total}

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

@@ -1,423 +0,0 @@
-command-description-tpto =
-    Teleport the given entities to some target entity.
-command-description-player-list =
-    Returns a list of all player sessions.
-command-description-player-self =
-    Returns the current player session.
-command-description-player-imm =
-    Returns the session associated with the player given as argument.
-command-description-player-entity =
-    Returns the entities of the input sessions.
-command-description-self =
-    Returns the current attached entity.
-command-description-physics-velocity =
-    Returns the velocity of the input entities.
-command-description-physics-angular-velocity =
-    Returns the angular velocity of the input entities.
-command-description-buildinfo =
-    Provides information about the build of the game.
-command-description-cmd-list =
-    Returns a list of all commands, for this side.
-command-description-explain =
-    Explains the given expression, providing command descriptions and signatures.
-command-description-search =
-    Searches through the input for the provided value.
-command-description-stopwatch =
-    Measures the execution time of the given expression.
-command-description-types-consumers =
-    Provides all commands that can consume the given type.
-command-description-types-tree =
-    Debug tool to return all types the command interpreter can downcast the input to.
-command-description-types-gettype =
-    Returns the type of the input.
-command-description-types-fullname =
-    Returns the full name of the input type according to CoreCLR.
-command-description-as =
-    Casts the input to the given type.
-    Effectively a type hint if you know the type but the interpreter does not.
-command-description-count =
-    Counts the amount of entries in it's input, returning an integer.
-command-description-map =
-    Maps the input over the given block, with the provided expected return type.
-    This command may be modified to not need an explicit return type in the future.
-command-description-select =
-    Selects N objects or N% of objects from the input.
-    One can additionally invert this command with not to make it select everything except N objects instead.
-command-description-comp =
-    Returns the given component from the input entities, discarding entities without that component.
-command-description-delete =
-    Deletes the input entities.
-command-description-ent =
-    Returns the provided entity ID.
-command-description-entities =
-    Returns all entities on the server.
-command-description-paused =
-    Filters the input entities by whether or not they are paused.
-    This command can be inverted with not.
-command-description-with =
-    Filters the input entities by whether or not they have the given component.
-    This command can be inverted with not.
-command-description-fuck =
-    Throws an exception.
-command-description-ecscomp-listty =
-    Lists every type of component registered.
-command-description-cd =
-    Changes the session's current directory to the given relative or absolute path.
-command-description-ls-here =
-    Lists the contents of the current directory.
-command-description-ls-in =
-    Lists the contents of the given relative or absolute path.
-command-description-methods-get =
-    Returns all methods associated with the input type.
-command-description-methods-overrides =
-    Returns all methods overriden on the input type.
-command-description-methods-overridesfrom =
-    Returns all methods overriden from the given type on the input type.
-command-description-cmd-moo =
-    Asks the important questions.
-command-description-cmd-descloc =
-    Returns the localization string for a command's description.
-command-description-cmd-getshim =
-    Returns a command's execution shim.
-command-description-help =
-    Provides a quick rundown of how to use toolshed.
-command-description-ioc-registered =
-    Returns all the types registered with IoCManager on the current thread (usually the game thread)
-command-description-ioc-get =
-    Gets an instance of an IoC registration.
-command-description-loc-tryloc =
-    Tries to get a localization string, returning null if unable.
-command-description-loc-loc =
-    Gets a localization string, returning the unlocalized string if unable.
-command-description-physics-angular_velocity =
-    Returns the angular velocity of the given entities.
-command-description-vars =
-    Provides a list of all variables set in this session.
-command-description-any =
-    Returns true if there's any values in the input, otherwise false.
-command-description-ArrowCommand =
-    Assigns the input to a variable.
-command-description-isempty =
-    Returns true if the input is empty, otherwise false.
-command-description-isnull =
-    Returns true if the input is null, otherwise false.
-command-description-unique =
-    Filters the input sequence for uniqueness, removing duplicate values.
-command-description-where =
-    Given some input sequence IEnumerable<T>, takes a block of signature T -> bool that decides if each input value should be included in the output sequence.
-command-description-do =
-    Backwards compatibility with BQL, applies the given old commands over the input sequence.
-command-description-named =
-    Filters the input entities by their name, with the regex ^selector$.
-command-description-prototyped =
-    Filters the input entities by their prototype.
-command-description-nearby =
-    Creates a new list of all entities nearby the inputs within the given range.
-command-description-first =
-    Returns the first entry of the given enumerable.
-command-description-splat =
-    "Splats" a block, value, or variable, creating N copies of it in a list.
-command-description-val =
-    Casts the given value, block, or variable to the given type. This is mostly a workaround for current limitations of variables.
-command-description-actor-controlled =
-    Filters entities by whether or not they're actively controlled.
-command-description-actor-session =
-    Returns the sessions associated with the input entities.
-command-description-physics-parent =
-    Returns the parent(s) of the input entities.
-command-description-emplace =
-    Runs the given block over it's inputs, with the input value placed into the variable $value within the block.
-    Additionally breaks out $wx, $wy, $proto, $desc, $name, and $paused for entities.
-    Can also have breakout values for other types, consult the documentation for that type for further info.
-command-description-AddCommand =
-    Performs numeric addition.
-command-description-SubtractCommand =
-    Performs numeric subtraction.
-command-description-MultiplyCommand =
-    Performs numeric multiplication.
-command-description-DivideCommand =
-    Performs numeric division.
-command-description-min =
-    Returns the minimum of two values.
-command-description-max =
-    Returns the maximum of two values.
-command-description-BitAndCommand =
-    Performs bitwise AND.
-command-description-BitOrCommand =
-    Performs bitwise OR.
-command-description-BitXorCommand =
-    Performs bitwise XOR.
-command-description-neg =
-    Negates the input.
-command-description-GreaterThanCommand =
-    Performs a greater-than comparison, x > y.
-command-description-LessThanCommand =
-    Performs a less-than comparison, x < y.
-command-description-GreaterThanOrEqualCommand =
-    Performs a greater-than-or-equal comparison, x >= y.
-command-description-LessThanOrEqualCommand =
-    Performs a less-than-or-equal comparison, x <= y.
-command-description-EqualCommand =
-    Performs an equality comparison, returning true if the inputs are equal.
-command-description-NotEqualCommand =
-    Performs an equality comparison, returning true if the inputs are not equal.
-command-description-append =
-    Appends a value to the input enumerable.
-command-description-DefaultIfNullCommand =
-    Replaces the input with the type's default value if it is null, albeit only for value types (not objects).
-command-description-OrValueCommand =
-    If the input is null, uses the provided alternate value.
-command-description-DebugPrintCommand =
-    Prints the given value transparently, for debug prints in a command run.
-command-description-i =
-    Integer constant.
-command-description-f =
-    Float constant.
-command-description-s =
-    String constant.
-command-description-b =
-    Bool constant.
-command-description-join =
-    Joins two sequences together into one sequence.
-command-description-reduce =
-    Given a block to use as a reducer, turns a sequence into a single value.
-    The left hand side of the block is implied, and the right hand is stored in $value.
-command-description-rep =
-    Repeats the input value N times to form a sequence.
-command-description-take =
-    Takes N values from the input sequence
-command-description-spawn-at =
-    Spawns an entity at the given coordinates.
-command-description-spawn-on =
-    Spawns an entity on the given entity, at it's coordinates.
-command-description-spawn-attached =
-    Spawns an entity attached to the given entity, at (0 0) relative to it.
-command-description-mappos =
-    Returns an entity's coordinates relative to it's current map.
-command-description-pos =
-    Returns an entity's coordinates.
-command-description-tp-coords =
-    Teleports the target to the given coordinates.
-command-description-tp-to =
-    Teleports the target to the given other entity.
-command-description-tp-into =
-    Teleports the target "into" the given other entity, attaching it at (0 0) relative to it.
-command-description-comp-get =
-    Gets the given component from the given entity.
-command-description-comp-add =
-    Adds the given component to the given entity.
-command-description-comp-ensure =
-    Ensures the given entity has the given component.
-command-description-comp-has =
-    Check if the given entity has the given component.
-command-description-AddVecCommand =
-    Adds a scalar (single value) to every element in the input.
-command-description-SubVecCommand =
-    Subtracts a scalar (single value) from every element in the input.
-command-description-MulVecCommand =
-    Multiplies a scalar (single value) by every element in the input.
-command-description-DivVecCommand =
-    Divides every element in the input by a scalar (single value).
-command-description-rng-to =
-    Returns a number from its input to its argument (i.e. n..m inclusive)
-command-description-rng-from =
-    Returns a number to its input from its argument (i.e. m..n inclusive)
-command-description-rng-prob =
-    Returns a boolean based on the input probability/chance (from 0 to 1)
-command-description-sum =
-    Computes the sum of the input.
-command-description-bin =
-    "Bins" the input, counting up how many times each unique element occurs.
-command-description-extremes =
-    Returns the two extreme ends of a list, interwoven.
-command-description-sortby =
-    Sorts the input least to greatest by the computed key.
-command-description-sortmapby =
-    Sorts the input least to greatest by the computed key, replacing the value with it's computed key afterward.
-command-description-sort =
-    Sorts the input least to greatest.
-command-description-sortdownby =
-    Sorts the input greatest to least by the computed key.
-command-description-sortmapdownby =
-    Sorts the input greatest to least by the computed key, replacing the value with it's computed key afterward.
-command-description-sortdown =
-    Sorts the input greatest to least.
-command-description-iota =
-    Returns a list of numbers 1 to N.
-command-description-to =
-    Returns a list of numbers N to M.
-command-description-curtick =
-    The current game tick.
-command-description-curtime =
-    The current game time (a TimeSpan)
-command-description-realtime =
-    The current realtime since startup (a TimeSpan)
-command-description-servertime =
-    The current server game time, or zero if we are the server (a TimeSpan)
-command-description-replace =
-    Replaces the input entities with the given prototype, preserving position and rotation (but nothing else)
-command-description-allcomps =
-    Returns all components on the given entity.
-command-description-entitysystemupdateorder-tick =
-    Lists the tick update order of entity systems.
-command-description-entitysystemupdateorder-frame =
-    Lists the frame update order of entity systems.
-command-description-more =
-    Prints the contents of $more, i.e. any extras that Toolshed didn't print from the last command.
-command-description-ModulusCommand =
-    Computes the modulus of two values.
-    This is usually remainder, check C#'s documentation for the type.
-command-description-ModVecCommand =
-    Performs the modulus operation over the input with the given constant right-hand value.
-command-description-BitAndNotCommand =
-    Performs bitwise AND-NOT over the input.
-command-description-BitOrNotCommand =
-    Performs bitwise OR-NOT over the input.
-command-description-BitXnorCommand =
-    Performs bitwise XNOR over the input.
-command-description-BitNotCommand =
-    Performs bitwise NOT on the input.
-command-description-abs =
-    Computes the absolute value of the input (removing the sign)
-command-description-average =
-    Computes the average (arithmetic mean) of the input.
-command-description-bibytecount =
-    Returns the size of the input in bytes, given that the input implements IBinaryInteger.
-    This is NOT sizeof.
-command-description-shortestbitlength =
-    Returns the minimum number of bits needed to represent the input value.
-command-description-countleadzeros =
-    Counts the number of leading binary zeros in the input value.
-command-description-counttrailingzeros =
-    Counts the number of trailing binary zeros in the input value.
-command-description-fpi =
-    pi (3.14159...) as a float.
-command-description-fe =
-    e (2.71828...) as a float.
-command-description-ftau =
-    tau (6.28318...) as a float.
-command-description-fepsilon =
-    The epsilon value for a float, exactly 1.4e-45.
-command-description-dpi =
-    pi (3.14159...) as a double.
-command-description-de =
-    e (2.71828...) as a double.
-command-description-dtau =
-    tau (6.28318...) as a double.
-command-description-depsilon =
-    The epsilon value for a double, exactly 4.9406564584124654E-324.
-command-description-hpi =
-    pi (3.14...) as a half.
-command-description-he =
-    e (2.71...) as a half.
-command-description-htau =
-    tau (6.28...) as a half.
-command-description-hepsilon =
-    The epsilon value for a half, exactly 5.9604645E-08.
-command-description-floor =
-    Returns the floor of the input value (rounding toward zero).
-command-description-ceil =
-    Returns the ceil of the input value (rounding away from zero).
-command-description-round =
-    Rounds the input value.
-command-description-trunc =
-    Truncates the input value.
-command-description-round2frac =
-    Rounds the input value to the specified number of fractional digits.
-command-description-exponentbytecount =
-    Returns the number of bytes required to store the exponent.
-command-description-significandbytecount =
-    Returns the number of bytes required to store the significand.
-command-description-significandbitcount =
-    Returns the exact bit length of the significand.
-command-description-exponentshortestbitcount =
-    Returns the minimum number of bits to store the exponent.
-command-description-stepnext =
-    Steps to the next float value, adding one to the significand with carry.
-command-description-stepprev =
-    Steps to the previous float value, subtracting one from the significand with carry.
-command-description-checkedto =
-    Converts from the input numeric type to the target, erroring if not possible.
-command-description-saturateto =
-    Converts from the input numeric type to the target, saturating if the value is out of range.
-    For example, converting 382 to a byte would saturate to 255 (the maximum value of a byte).
-command-description-truncto =
-    Converts from the input numeric type to the target, with truncation.
-    In the case of integers, this is a bit cast with sign extension.
-command-description-iscanonical =
-    Returns whether the input is in canonical form.
-command-description-iscomplex =
-    Returns whether the input is a complex number (by value, not by type)
-command-description-iseven =
-    Returns whether the input is even.
-    Not a javascript package.
-command-description-isodd =
-    Returns whether the input is odd.
-command-description-isfinite =
-    Returns whether the input is finite.
-command-description-isimaginary =
-    Returns whether the input is purely imaginary (no real part).
-command-description-isinfinite =
-    Returns whether the input is infinite.
-command-description-isinteger =
-    Returns whether the input is an integer (by value, not by type)
-command-description-isnan =
-    Returns whether the input is Not a Number (NaN).
-    This is a special floating point value, so this is by value, not by type.
-command-description-isnegative =
-    Returns whether the input is negative.
-command-description-ispositive =
-    Returns whether the input is positive.
-command-description-isreal =
-    Returns whether the input is purely real (no imaginary part).
-command-description-issubnormal =
-    Returns whether the input is in sub-normal form.
-command-description-iszero =
-    Returns whether the input is zero.
-command-description-pow =
-    Computes the power of its lefthand to its righthand. x^y.
-command-description-sqrt =
-    Computes the square root of its input.
-command-description-cbrt =
-    Computes the cube root of its input.
-command-description-root =
-    Computes the Nth root of its input.
-command-description-hypot =
-    Computes the hypotenuse of a triangle with the given sides A and B.
-command-description-sin =
-    Computes the sine of the input.
-command-description-sinpi =
-    Computes the sine of the input multiplied by pi.
-command-description-asin =
-    Computes the arcsine of the input.
-command-description-asinpi =
-    Computes the arcsine of the input multiplied by pi.
-command-description-cos =
-    Computes the cosine of the input.
-command-description-cospi =
-    Computes the cosine of the input multiplied by pi.
-command-description-acos =
-    Computes the arcosine of the input.
-command-description-acospi =
-    Computes the arcosine of the input multiplied by pi.
-command-description-tan =
-    Computes the tangent of the input.
-command-description-tanpi =
-    Computes the tangent of the input multiplied by pi.
-command-description-atan =
-    Computes the arctangent of the input.
-command-description-atanpi =
-    Computes the arctangent of the input multiplied by pi.
-command-description-iterate =
-    Iterates the given function over the input N times, returning a list of results.
-    Think of this like successively applying the function to a value, tracking all the intermediate values.
-command-description-pick =
-    Picks a random value from the input.
-command-description-tee =
-    Tees the input into the given block, ignoring the block's result.
-    This essentially lets you have a branch in your code to do multiple operations on one value.
-command-description-cmd-info =
-    Returns a CommandSpec for the given command.
-    On it's own, this means it'll print the comamnd's help message.
-command-description-comp-rm =
-    Removes the given component from the entity.

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

@@ -1,6 +1,5 @@
 ## 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
@@ -9,4 +8,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/DataDefinitionAnalyzer.cs

@@ -1,293 +0,0 @@
-#nullable enable
-using System.Collections.Generic;
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.Diagnostics;
-
-namespace Robust.Analyzers;
-
-[DiagnosticAnalyzer(LanguageNames.CSharp)]
-public sealed class DataDefinitionAnalyzer : DiagnosticAnalyzer
-{
-    private const string DataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataDefinitionAttribute";
-    private const string ImplicitDataDefinitionNamespace = "Robust.Shared.Serialization.Manager.Attributes.ImplicitDataDefinitionForInheritorsAttribute";
-    private const string DataFieldBaseNamespace = "Robust.Shared.Serialization.Manager.Attributes.DataFieldBaseAttribute";
-
-    private static readonly DiagnosticDescriptor DataDefinitionPartialRule = new(
-        Diagnostics.IdDataDefinitionPartial,
-        "Type must be partial",
-        "Type {0} is a DataDefinition but is not partial.",
-        "Usage",
-        DiagnosticSeverity.Error,
-        true,
-        "Make sure to mark any type that is a data definition as partial."
-    );
-
-    private static readonly DiagnosticDescriptor NestedDataDefinitionPartialRule = new(
-        Diagnostics.IdNestedDataDefinitionPartial,
-        "Type must be partial",
-        "Type {0} contains nested data definition {1} but is not partial.",
-        "Usage",
-        DiagnosticSeverity.Error,
-        true,
-        "Make sure to mark any type containing a nested data definition as partial."
-    );
-
-    private static readonly DiagnosticDescriptor DataFieldWritableRule = new(
-        Diagnostics.IdDataFieldWritable,
-        "Data field must not be readonly",
-        "Data field {0} in data definition {1} is readonly.",
-        "Usage",
-        DiagnosticSeverity.Error,
-        true,
-        "Make sure to remove the readonly modifier."
-    );
-
-    private static readonly DiagnosticDescriptor DataFieldPropertyWritableRule = new(
-        Diagnostics.IdDataFieldPropertyWritable,
-        "Data field property must have a setter",
-        "Data field property {0} in data definition {1} does not have a setter.",
-        "Usage",
-        DiagnosticSeverity.Error,
-        true,
-        "Make sure to add a setter."
-    );
-
-    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(
-        DataDefinitionPartialRule, NestedDataDefinitionPartialRule, DataFieldWritableRule, DataFieldPropertyWritableRule
-    );
-
-    public override void Initialize(AnalysisContext context)
-    {
-        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.None);
-        context.EnableConcurrentExecution();
-
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.ClassDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.StructDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.RecordStructDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataDefinition, SyntaxKind.InterfaceDeclaration);
-
-        context.RegisterSyntaxNodeAction(AnalyzeDataField, SyntaxKind.FieldDeclaration);
-        context.RegisterSyntaxNodeAction(AnalyzeDataFieldProperty, SyntaxKind.PropertyDeclaration);
-    }
-
-    private void AnalyzeDataDefinition(SyntaxNodeAnalysisContext context)
-    {
-        if (context.Node is not TypeDeclarationSyntax declaration)
-            return;
-
-        var type = context.SemanticModel.GetDeclaredSymbol(declaration)!;
-        if (!IsDataDefinition(type))
-            return;
-
-        if (!IsPartial(declaration))
-        {
-            context.ReportDiagnostic(Diagnostic.Create(DataDefinitionPartialRule, declaration.Keyword.GetLocation(), type.Name));
-        }
-
-        var containingType = type.ContainingType;
-        while (containingType != null)
-        {
-            var containingTypeDeclaration = (TypeDeclarationSyntax) containingType.DeclaringSyntaxReferences[0].GetSyntax();
-            if (!IsPartial(containingTypeDeclaration))
-            {
-                context.ReportDiagnostic(Diagnostic.Create(NestedDataDefinitionPartialRule, containingTypeDeclaration.Keyword.GetLocation(), containingType.Name, type.Name));
-            }
-
-            containingType = containingType.ContainingType;
-        }
-    }
-
-    private void AnalyzeDataField(SyntaxNodeAnalysisContext context)
-    {
-        if (context.Node is not FieldDeclarationSyntax field)
-            return;
-
-        var typeDeclaration = field.FirstAncestorOrSelf<TypeDeclarationSyntax>();
-        if (typeDeclaration == null)
-            return;
-
-        var type = context.SemanticModel.GetDeclaredSymbol(typeDeclaration)!;
-        if (!IsDataDefinition(type))
-            return;
-
-        foreach (var variable in field.Declaration.Variables)
-        {
-            var fieldSymbol = context.SemanticModel.GetDeclaredSymbol(variable);
-            if (fieldSymbol == null)
-                continue;
-
-            if (IsReadOnlyDataField(type, fieldSymbol))
-            {
-                context.ReportDiagnostic(Diagnostic.Create(DataFieldWritableRule, context.Node.GetLocation(), fieldSymbol.Name, type.Name));
-            }
-        }
-    }
-
-    private void AnalyzeDataFieldProperty(SyntaxNodeAnalysisContext context)
-    {
-        if (context.Node is not PropertyDeclarationSyntax property)
-            return;
-
-        var typeDeclaration = property.FirstAncestorOrSelf<TypeDeclarationSyntax>();
-        if (typeDeclaration == null)
-            return;
-
-        var type = context.SemanticModel.GetDeclaredSymbol(typeDeclaration)!;
-        if (!IsDataDefinition(type) || type.IsRecord || type.IsValueType)
-            return;
-
-        var propertySymbol = context.SemanticModel.GetDeclaredSymbol(property);
-        if (propertySymbol == null)
-            return;
-
-        if (IsReadOnlyDataField(type, propertySymbol))
-        {
-            context.ReportDiagnostic(Diagnostic.Create(DataFieldPropertyWritableRule, context.Node.GetLocation(), propertySymbol.Name, type.Name));
-        }
-    }
-
-    private static bool IsReadOnlyDataField(ITypeSymbol type, ISymbol field)
-    {
-        if (!IsDataField(field, out _, out _))
-            return false;
-
-        return IsReadOnlyMember(type, field);
-    }
-
-    private static bool IsPartial(TypeDeclarationSyntax type)
-    {
-        return type.Modifiers.IndexOf(SyntaxKind.PartialKeyword) != -1;
-    }
-
-    private static bool IsDataDefinition(ITypeSymbol? type)
-    {
-        if (type == null)
-            return false;
-
-        return HasAttribute(type, DataDefinitionNamespace) ||
-               IsImplicitDataDefinition(type);
-    }
-
-    private static bool IsDataField(ISymbol member, out ITypeSymbol type, out AttributeData attribute)
-    {
-        // TODO data records and other attributes
-        if (member is IFieldSymbol field)
-        {
-            foreach (var attr in field.GetAttributes())
-            {
-                if (attr.AttributeClass != null && Inherits(attr.AttributeClass, DataFieldBaseNamespace))
-                {
-                    type = field.Type;
-                    attribute = attr;
-                    return true;
-                }
-            }
-        }
-        else if (member is IPropertySymbol property)
-        {
-            foreach (var attr in property.GetAttributes())
-            {
-                if (attr.AttributeClass != null && Inherits(attr.AttributeClass, DataFieldBaseNamespace))
-                {
-                    type = property.Type;
-                    attribute = attr;
-                    return true;
-                }
-            }
-        }
-
-        type = null!;
-        attribute = null!;
-        return false;
-    }
-
-    private static bool Inherits(ITypeSymbol type, string parent)
-    {
-        foreach (var baseType in GetBaseTypes(type))
-        {
-            if (baseType.ToDisplayString() == parent)
-                return true;
-        }
-
-        return false;
-    }
-
-    private static bool IsReadOnlyMember(ITypeSymbol type, ISymbol member)
-    {
-        if (member is IFieldSymbol field)
-        {
-            return field.IsReadOnly;
-        }
-        else if (member is IPropertySymbol property)
-        {
-            if (property.SetMethod == null)
-                return true;
-
-            if (property.SetMethod.IsInitOnly)
-                return type.IsReferenceType;
-
-            return false;
-        }
-
-        return false;
-    }
-
-    private static bool HasAttribute(ITypeSymbol type, string attributeName)
-    {
-        foreach (var attribute in type.GetAttributes())
-        {
-            if (attribute.AttributeClass?.ToDisplayString() == attributeName)
-                return true;
-        }
-
-        return false;
-    }
-
-    private static bool IsImplicitDataDefinition(ITypeSymbol type)
-    {
-        if (HasAttribute(type, ImplicitDataDefinitionNamespace))
-            return true;
-
-        foreach (var baseType in GetBaseTypes(type))
-        {
-            if (HasAttribute(baseType, ImplicitDataDefinitionNamespace))
-                return true;
-        }
-
-        foreach (var @interface in type.AllInterfaces)
-        {
-            if (IsImplicitDataDefinitionInterface(@interface))
-                return true;
-        }
-
-        return false;
-    }
-
-    private static bool IsImplicitDataDefinitionInterface(ITypeSymbol @interface)
-    {
-        if (HasAttribute(@interface, ImplicitDataDefinitionNamespace))
-            return true;
-
-        foreach (var subInterface in @interface.AllInterfaces)
-        {
-            if (HasAttribute(subInterface, ImplicitDataDefinitionNamespace))
-                return true;
-        }
-
-        return false;
-    }
-
-    private static IEnumerable<ITypeSymbol> GetBaseTypes(ITypeSymbol type)
-    {
-        var baseType = type.BaseType;
-        while (baseType != null)
-        {
-            yield return baseType;
-            baseType = baseType.BaseType;
-        }
-    }
-}

Robust.Analyzers/DataDefinitionFixer.cs

@@ -1,168 +0,0 @@
-#nullable enable
-using System.Collections.Immutable;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CodeActions;
-using Microsoft.CodeAnalysis.CodeFixes;
-using Microsoft.CodeAnalysis.CSharp;
-using Microsoft.CodeAnalysis.CSharp.Syntax;
-using static Microsoft.CodeAnalysis.CSharp.SyntaxKind;
-using static Robust.Analyzers.Diagnostics;
-
-namespace Robust.Analyzers;
-
-[ExportCodeFixProvider(LanguageNames.CSharp)]
-public sealed class DefinitionFixer : CodeFixProvider
-{
-    public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(
-        IdDataDefinitionPartial, IdNestedDataDefinitionPartial, IdDataFieldWritable, IdDataFieldPropertyWritable
-    );
-
-    public override Task RegisterCodeFixesAsync(CodeFixContext context)
-    {
-        foreach (var diagnostic in context.Diagnostics)
-        {
-            switch (diagnostic.Id)
-            {
-                case IdDataDefinitionPartial:
-                    return RegisterPartialTypeFix(context, diagnostic);
-                case IdNestedDataDefinitionPartial:
-                    return RegisterPartialTypeFix(context, diagnostic);
-                case IdDataFieldWritable:
-                    return RegisterDataFieldFix(context, diagnostic);
-                case IdDataFieldPropertyWritable:
-                    return RegisterDataFieldPropertyFix(context, diagnostic);
-            }
-        }
-
-        return Task.CompletedTask;
-    }
-
-    public override FixAllProvider GetFixAllProvider()
-    {
-        return WellKnownFixAllProviders.BatchFixer;
-    }
-
-    private static async Task RegisterPartialTypeFix(CodeFixContext context, Diagnostic diagnostic)
-    {
-        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
-        var span = diagnostic.Location.SourceSpan;
-        var token = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<TypeDeclarationSyntax>().First();
-
-        if (token == null)
-            return;
-
-        context.RegisterCodeFix(CodeAction.Create(
-            "Make type partial",
-            c => MakeDataDefinitionPartial(context.Document, token, c),
-            "Make type partial"
-        ), diagnostic);
-    }
-
-    private static async Task<Document> MakeDataDefinitionPartial(Document document, TypeDeclarationSyntax declaration, CancellationToken cancellation)
-    {
-        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
-        var token = SyntaxFactory.Token(PartialKeyword);
-        var newDeclaration = declaration.AddModifiers(token);
-
-        root = root!.ReplaceNode(declaration, newDeclaration);
-
-        return document.WithSyntaxRoot(root);
-    }
-
-    private static async Task RegisterDataFieldFix(CodeFixContext context, Diagnostic diagnostic)
-    {
-        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
-        var span = diagnostic.Location.SourceSpan;
-        var field = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<FieldDeclarationSyntax>().FirstOrDefault();
-
-        if (field == null)
-            return;
-
-        context.RegisterCodeFix(CodeAction.Create(
-            "Make data field writable",
-            c => MakeFieldWritable(context.Document, field, c),
-            "Make data field writable"
-        ), diagnostic);
-    }
-
-    private static async Task RegisterDataFieldPropertyFix(CodeFixContext context, Diagnostic diagnostic)
-    {
-        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
-        var span = diagnostic.Location.SourceSpan;
-        var property = root?.FindToken(span.Start).Parent?.AncestorsAndSelf().OfType<PropertyDeclarationSyntax>().FirstOrDefault();
-
-        if (property == null)
-            return;
-
-        context.RegisterCodeFix(CodeAction.Create(
-            "Make data field writable",
-            c => MakePropertyWritable(context.Document, property, c),
-            "Make data field writable"
-        ), diagnostic);
-    }
-
-    private static async Task<Document> MakeFieldWritable(Document document, FieldDeclarationSyntax declaration, CancellationToken cancellation)
-    {
-        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
-        var token = declaration.Modifiers.First(t => t.IsKind(ReadOnlyKeyword));
-        var newDeclaration = declaration.WithModifiers(declaration.Modifiers.Remove(token));
-
-        root = root!.ReplaceNode(declaration, newDeclaration);
-
-        return document.WithSyntaxRoot(root);
-    }
-
-    private static async Task<Document> MakePropertyWritable(Document document, PropertyDeclarationSyntax declaration, CancellationToken cancellation)
-    {
-        var root = (CompilationUnitSyntax?) await document.GetSyntaxRootAsync(cancellation);
-        var newDeclaration = declaration;
-        var privateSet = newDeclaration
-            .AccessorList?
-            .Accessors
-            .FirstOrDefault(s => s.IsKind(SetAccessorDeclaration) || s.IsKind(InitAccessorDeclaration));
-
-        if (newDeclaration.AccessorList != null && privateSet != null)
-        {
-            newDeclaration = newDeclaration.WithAccessorList(
-                newDeclaration.AccessorList.WithAccessors(
-                    newDeclaration.AccessorList.Accessors.Remove(privateSet)
-                )
-            );
-        }
-
-        AccessorDeclarationSyntax setter;
-        if (declaration.Modifiers.Any(m => m.IsKind(PrivateKeyword)))
-        {
-            setter = SyntaxFactory.AccessorDeclaration(
-                SetAccessorDeclaration,
-                default,
-                default,
-                SyntaxFactory.Token(SetKeyword),
-                default,
-                default,
-                SyntaxFactory.Token(SemicolonToken)
-            );
-        }
-        else
-        {
-            setter = SyntaxFactory.AccessorDeclaration(
-                SetAccessorDeclaration,
-                default,
-                SyntaxFactory.TokenList(SyntaxFactory.Token(PrivateKeyword)),
-                SyntaxFactory.Token(SetKeyword),
-                default,
-                default,
-                SyntaxFactory.Token(SemicolonToken)
-            );
-        }
-
-        newDeclaration = newDeclaration.AddAccessorListAccessors(setter);
-
-        root = root!.ReplaceNode(declaration, newDeclaration);
-
-        return document.WithSyntaxRoot(root);
-    }
-}

Robust.Analyzers/Diagnostics.cs

@@ -21,10 +21,6 @@ public static class Diagnostics
     public const string IdValueEventSubscribedByRef = "RA0014";
     public const string IdByRefEventRaisedByValue = "RA0015";
     public const string IdValueEventRaisedByRef = "RA0016";
-    public const string IdDataDefinitionPartial = "RA0017";
-    public const string IdNestedDataDefinitionPartial = "RA0018";
-    public const string IdDataFieldWritable = "RA0019";
-    public const string IdDataFieldPropertyWritable = "RA0020";
 
     public static SuppressionDescriptor MeansImplicitAssignment =>
         new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");

Robust.Benchmarks/EntityManager/AddRemoveComponentBenchmark.cs

@@ -8,7 +8,7 @@ using Robust.UnitTesting.Server;
 namespace Robust.Benchmarks.EntityManager;
 
 [Virtual]
-public partial class AddRemoveComponentBenchmark
+public class AddRemoveComponentBenchmark
 {
     private ISimulation _simulation = default!;
     private IEntityManager _entityManager = default!;
@@ -48,7 +48,7 @@ public partial class AddRemoveComponentBenchmark
     }
 
     [ComponentProtoName("A")]
-    public sealed partial class A : Component
+    public sealed class A : Component
     {
     }
 }

Robust.Benchmarks/EntityManager/ComponentIteratorBenchmark.cs

@@ -1,75 +0,0 @@
-using BenchmarkDotNet.Attributes;
-using JetBrains.Annotations;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Map;
-using Robust.UnitTesting.Server;
-
-namespace Robust.Benchmarks.EntityManager;
-
-public partial class ComponentIteratorBenchmark
-{
-    private ISimulation _simulation = default!;
-    private IEntityManager _entityManager = default!;
-
-    [UsedImplicitly]
-    [Params(1, 10, 100, 1000)]
-    public int N;
-
-    public A[] Comps = default!;
-
-    [GlobalSetup]
-    public void GlobalSetup()
-    {
-        _simulation = RobustServerSimulation
-            .NewSimulation()
-            .RegisterComponents(f => f.RegisterClass<A>())
-            .InitializeInstance();
-
-        _entityManager = _simulation.Resolve<IEntityManager>();
-
-        Comps = new A[N+2];
-
-        var coords = new MapCoordinates(0, 0, new MapId(1));
-        _simulation.AddMap(coords.MapId);
-
-        for (var i = 0; i < N; i++)
-        {
-            var uid = _entityManager.SpawnEntity(null, coords);
-            _entityManager.AddComponent<A>(uid);
-        }
-    }
-
-    [Benchmark]
-    public A[] ComponentStructEnumerator()
-    {
-        var query = _entityManager.EntityQueryEnumerator<A>();
-        var i = 0;
-
-        while (query.MoveNext(out var comp))
-        {
-            Comps[i] = comp;
-            i++;
-        }
-
-        return Comps;
-    }
-
-    [Benchmark]
-    public A[] ComponentIEnumerable()
-    {
-        var i = 0;
-
-        foreach (var comp in _entityManager.EntityQuery<A>())
-        {
-            Comps[i] = comp;
-            i++;
-        }
-
-        return Comps;
-    }
-
-    [ComponentProtoName("A")]
-    public sealed partial class A : Component
-    {
-    }
-}

Robust.Benchmarks/EntityManager/GetComponentBenchmark.cs

@@ -1,3 +1,4 @@
+using System;
 using BenchmarkDotNet.Attributes;
 using JetBrains.Annotations;
 using Robust.Shared.Analyzers;
@@ -8,7 +9,7 @@ using Robust.UnitTesting.Server;
 namespace Robust.Benchmarks.EntityManager;
 
 [Virtual]
-public partial class GetComponentBenchmark
+public class GetComponentBenchmark
 {
     private ISimulation _simulation = default!;
     private IEntityManager _entityManager = default!;
@@ -54,7 +55,7 @@ public partial class GetComponentBenchmark
     }
 
     [ComponentProtoName("A")]
-    public sealed partial class A : Component
+    public sealed class A : Component
     {
     }
 }

Robust.Benchmarks/EntityManager/SpawnDeleteEntityBenchmark.cs

@@ -8,7 +8,7 @@ using Robust.UnitTesting.Server;
 namespace Robust.Benchmarks.EntityManager;
 
 [Virtual]
-public partial class SpawnDeleteEntityBenchmark
+public class SpawnDeleteEntityBenchmark
 {
     private ISimulation _simulation = default!;
     private IEntityManager _entityManager = default!;
@@ -56,7 +56,7 @@ public partial class SpawnDeleteEntityBenchmark
     }
 
     [ComponentProtoName("A")]
-    public sealed partial class A : Component
+    public sealed class A : Component
     {
     }
 }

Robust.Benchmarks/Serialization/Definitions/DataDefinitionWithString.cs

@@ -5,9 +5,9 @@ namespace Robust.Benchmarks.Serialization.Definitions
 {
     [DataDefinition]
     [Virtual]
-    public partial class DataDefinitionWithString
+    public class DataDefinitionWithString
     {
         [DataField("string")]
-        public string StringField { get; set; } = default!;
+        public string StringField { get; init; } = default!;
     }
 }

Robust.Benchmarks/Serialization/Definitions/SealedDataDefinitionWithString.cs

@@ -3,9 +3,9 @@
 namespace Robust.Benchmarks.Serialization.Definitions
 {
     [DataDefinition]
-    public sealed partial class SealedDataDefinitionWithString
+    public sealed class SealedDataDefinitionWithString
     {
         [DataField("string")]
-        public string StringField { get; private set; } = default!;
+        public string StringField { get; init; } = default!;
     }
 }

Robust.Benchmarks/Serialization/Definitions/SeedDataDefinition.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using Robust.Shared.GameObjects;
 using Robust.Shared.Maths;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.Manager.Attributes;
@@ -11,7 +10,8 @@ namespace Robust.Benchmarks.Serialization.Definitions
     ///     Arbitrarily large data definition for benchmarks.
     ///     Taken from content.
     /// </summary>
-    public sealed partial class SeedDataDefinition : Component
+    [Prototype("seed")]
+    public sealed class SeedDataDefinition : IPrototype
     {
         public const string Prototype = @"
 - type: seed
@@ -106,7 +106,7 @@ namespace Robust.Benchmarks.Serialization.Definitions
     }
 
     [DataDefinition]
-    public partial struct SeedChemQuantity
+    public struct SeedChemQuantity
     {
         [DataField("Min")]
         public int Min;

Robust.Benchmarks/Transform/RecursiveMoveBenchmark.cs

@@ -1,171 +0,0 @@
-using System;
-using System.Linq;
-using System.Numerics;
-using BenchmarkDotNet.Attributes;
-using Robust.Server.Containers;
-using Robust.Server.GameStates;
-using Robust.Shared;
-using Robust.Shared.Analyzers;
-using Robust.Shared.Configuration;
-using Robust.Shared.Containers;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.UnitTesting.Server;
-
-namespace Robust.Benchmarks.Transform;
-
-/// <summary>
-/// This benchmark tests various transform/move related functions with an entity that has many children.
-/// </summary>
-[Virtual, MemoryDiagnoser]
-public class RecursiveMoveBenchmark
-{
-    private ISimulation _simulation = default!;
-    private IEntityManager _entMan = default!;
-    private SharedTransformSystem _transform = default!;
-    private ContainerSystem _container = default!;
-    private PvsSystem _pvs = default!;
-    private EntityCoordinates _mapCoords;
-    private EntityCoordinates _gridCoords;
-    private EntityUid _ent;
-    private EntityUid _child;
-    private TransformComponent _childXform = default!;
-    private EntityQuery<TransformComponent> _query;
-
-    [GlobalSetup]
-    public void GlobalSetup()
-    {
-        _simulation = RobustServerSimulation
-            .NewSimulation()
-            .InitializeInstance();
-
-        if (!_simulation.Resolve<IConfigurationManager>().GetCVar(CVars.NetPVS))
-            throw new InvalidOperationException("PVS must be enabled");
-
-        _entMan = _simulation.Resolve<IEntityManager>();
-        _transform = _entMan.System<SharedTransformSystem>();
-        _container = _entMan.System<ContainerSystem>();
-        _pvs = _entMan.System<PvsSystem>();
-        _query = _entMan.GetEntityQuery<TransformComponent>();
-
-        // Create map & grid
-        var mapMan = _simulation.Resolve<IMapManager>();
-        var mapSys = _entMan.System<SharedMapSystem>();
-        var mapId = mapMan.CreateMap();
-        var map = mapMan.GetMapEntityId(mapId);
-        var gridComp = mapMan.CreateGrid(mapId);
-        var grid = gridComp.Owner;
-        _gridCoords = new EntityCoordinates(grid, .5f, .5f);
-        _mapCoords = new EntityCoordinates(map, 100, 100);
-        mapSys.SetTile(grid, gridComp, Vector2i.Zero, new Tile(1));
-
-        // Next, we will spawn our test entity. This entity will have a  complex transform/container hierarchy.
-        // This is intended to be representative of a typical SS14 player entity, with organs. clothing, and a full backpack.
-        _ent = _entMan.Spawn();
-
-        // Quick check that SetCoordinates actually changes the parent as expected
-        // I.e., ensure that grid-traversal code doesn't just dump the entity on the map.
-        _transform.SetCoordinates(_ent, _gridCoords);
-        if (_query.GetComponent(_ent).ParentUid != _gridCoords.EntityId)
-            throw new Exception("Grid traversal error.");
-
-        _transform.SetCoordinates(_ent, _mapCoords);
-        if (_query.GetComponent(_ent).ParentUid != _mapCoords.EntityId)
-            throw new Exception("Grid traversal error.");
-
-        // Add 5 direct children in slots to represent clothing.
-        for (var i = 0; i < 5; i++)
-        {
-            var id = $"inventory{i}";
-            _container.EnsureContainer<ContainerSlot>(_ent, id);
-            if (!_entMan.TrySpawnInContainer(null, _ent, id, out _))
-                throw new Exception($"Failed to setup entity");
-        }
-
-        // body parts
-        _container.EnsureContainer<Container>(_ent, "body");
-        for (var i = 0; i < 5; i++)
-        {
-            // Simple organ
-            if (!_entMan.TrySpawnInContainer(null, _ent, "body", out _))
-                throw new Exception($"Failed to setup entity");
-
-            // body part that has another body part / limb
-            if (!_entMan.TrySpawnInContainer(null, _ent, "body", out var limb))
-                throw new Exception($"Failed to setup entity");
-
-            _container.EnsureContainer<ContainerSlot>(limb.Value, "limb");
-            if (!_entMan.TrySpawnInContainer(null, limb.Value, "limb", out _))
-                throw new Exception($"Failed to setup entity");
-        }
-
-        // Backpack
-        _container.EnsureContainer<ContainerSlot>(_ent, "inventory-backpack");
-        if (!_entMan.TrySpawnInContainer(null, _ent, "inventory-backpack", out var backpack))
-            throw new Exception($"Failed to setup entity");
-
-        // Misc backpack contents.
-        var backpackStorage = _container.EnsureContainer<Container>(backpack.Value, "storage");
-        for (var i = 0; i < 10; i++)
-        {
-            if (!_entMan.TrySpawnInContainer(null, backpack.Value, "storage", out _))
-                throw new Exception($"Failed to setup entity");
-        }
-
-        // Emergency box inside of the backpack
-        var box = backpackStorage.ContainedEntities.First();
-        var boxContainer = _container.EnsureContainer<Container>(box, "storage");
-        for (var i = 0; i < 10; i++)
-        {
-            if (!_entMan.TrySpawnInContainer(null, box, "storage", out _))
-                throw new Exception($"Failed to setup entity");
-        }
-
-        // Deepest child.
-        _child = boxContainer.ContainedEntities.First();
-        _childXform = _query.GetComponent(_child);
-
-        _pvs.ProcessCollections();
-    }
-
-    /// <summary>
-    /// This implicitly measures move events, including PVS and entity lookups. Though given that most of the entities
-    /// are in containers, this will bias the entity lookup aspect.
-    /// </summary>
-    [Benchmark]
-    public void MoveEntity()
-    {
-        _transform.SetCoordinates(_ent, _gridCoords);
-        _transform.SetCoordinates(_ent, _mapCoords);
-    }
-
-    /// <summary>
-    /// Like <see cref="MoveEntity"/>, but also processes queued PVS chunk updates.
-    /// </summary>
-    [Benchmark]
-    public void MoveAndUpdateChunks()
-    {
-        _transform.SetCoordinates(_ent, _gridCoords);
-        _pvs.ProcessCollections();
-        _transform.SetCoordinates(_ent, _mapCoords);
-        _pvs.ProcessCollections();
-    }
-
-    [Benchmark]
-    public Vector2 GetWorldPos()
-    {
-        return _transform.GetWorldPosition(_childXform);
-    }
-
-    [Benchmark]
-    public EntityUid GetRootUid()
-    {
-        var xform = _childXform;
-        while (xform.ParentUid.IsValid())
-        {
-            xform = _query.GetComponent(xform.ParentUid);
-        }
-        return xform.ParentUid;
-    }
-}

Robust.Client/Audio/AudioStream.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Robust.Client.Graphics;
 
 namespace Robust.Client.Audio;
@@ -8,17 +8,13 @@ public sealed class AudioStream
     public TimeSpan Length { get; }
     internal ClydeHandle? ClydeHandle { get; }
     public string? Name { get; }
-    public string? Title { get; }
-    public string? Artist { get; }
     public int ChannelCount { get; }
 
-    internal AudioStream(ClydeHandle handle, TimeSpan length, int channelCount, string? name = null, string? title = null, string? artist = null)
+    internal AudioStream(ClydeHandle handle, TimeSpan length, int channelCount, string? name = null)
     {
         ClydeHandle = handle;
         Length = length;
         ChannelCount = channelCount;
         Name = name;
-        Title = title;
-        Artist = artist;
     }
 }

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Audio.Midi;
 using Robust.Shared.GameObjects;
@@ -17,6 +15,7 @@ public enum MidiRendererStatus : byte
 
 public interface IMidiRenderer : IDisposable
 {
+
     /// <summary>
     ///     The buffered audio source of this renderer.
     /// </summary>
@@ -35,7 +34,6 @@ public interface IMidiRenderer : IDisposable
     /// <summary>
     ///     This increases all note on velocities to 127.
     /// </summary>
-    [Obsolete($"Use {nameof(VelocityOverride)} instead, you can set it to 127 to achieve the same effect.")]
     bool VolumeBoost { get; set; }
 
     /// <summary>
@@ -96,27 +94,6 @@ public interface IMidiRenderer : IDisposable
     /// </summary>
     double SequencerTimeScale { get; }
 
-    /// <summary>
-    ///     Whether this renderer will subscribe to another and copy its events.
-    ///     See <see cref="FilteredChannels"/> to filter specific channels.
-    /// </summary>
-    IMidiRenderer? Master { get; set; }
-
-    // NOTE: Why is the properties below BitArray, you ask?
-    // Well see, MIDI 2.0 supports up to 256(!) channels as opposed to MIDI 1.0's meekly 16 channels...
-    // I'd like us to support MIDI 2.0 one day so I'm just future-proofing here. Also BitArray is cool!
-
-    /// <summary>
-    ///     Allows you to filter out note events from certain channels.
-    ///     Only NoteOn will be filtered.
-    /// </summary>
-    BitArray FilteredChannels { get; }
-
-    /// <summary>
-    ///     Allows you to override all NoteOn velocities. Set to null to disable.
-    /// </summary>
-    byte? VelocityOverride { get; set; }
-
     /// <summary>
     ///     Start listening for midi input.
     /// </summary>
@@ -143,11 +120,6 @@ public interface IMidiRenderer : IDisposable
     /// </summary>
     void StopAllNotes();
 
-    /// <summary>
-    ///     Reset renderer back to a clean state.
-    /// </summary>
-    void SystemReset();
-
     /// <summary>
     /// Clears all scheduled events.
     /// </summary>
@@ -184,7 +156,7 @@ public interface IMidiRenderer : IDisposable
     ///     This is only used if <see cref="Mono"/> is set to True
     ///     and <see cref="TrackingEntity"/> is null.
     /// </summary>
-    MapCoordinates? TrackingCoordinates { get; set; }
+    EntityCoordinates? TrackingCoordinates { get; set; }
 
     MidiRendererState RendererState { get; }
 
@@ -192,8 +164,7 @@ public interface IMidiRenderer : IDisposable
     ///     Send a midi event for the renderer to play.
     /// </summary>
     /// <param name="midiEvent">The midi event to be played</param>
-    /// <param name="raiseEvent">Whether to raise an event for this event.</param>
-    void SendMidiEvent(RobustMidiEvent midiEvent, bool raiseEvent = true);
+    void SendMidiEvent(RobustMidiEvent midiEvent);
 
     /// <summary>
     ///     Schedule a MIDI event to be played at a later time.
@@ -206,7 +177,7 @@ public interface IMidiRenderer : IDisposable
     /// <summary>
     ///     Apply a certain state to the renderer.
     /// </summary>
-    void ApplyState(MidiRendererState state, bool filterChannels = false);
+    void ApplyState(MidiRendererState state);
 
     /// <summary>
     ///     Actually disposes of this renderer. Do NOT use outside the MIDI thread.

Robust.Client/Audio/Midi/MidiManager.cs

@@ -3,27 +3,20 @@ using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
-using System.Threading.Tasks;
 using NFluidsynth;
-using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Shared;
 using Robust.Shared.Asynchronous;
-using Robust.Shared.Audio.Midi;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
-using Robust.Shared.Exceptions;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
-using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Systems;
-using Robust.Shared.Threading;
-using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 
@@ -33,13 +26,6 @@ internal sealed partial class MidiManager : IMidiManager
 {
     public const string SoundfontEnvironmentVariable = "ROBUST_SOUNDFONT_OVERRIDE";
 
-    private int _minRendererParallel;
-    private float _occlusionUpdateDelay;
-    private float _positionUpdateDelay;
-
-    [ViewVariables] private TimeSpan _nextOcclusionUpdate = TimeSpan.Zero;
-    [ViewVariables] private TimeSpan _nextPositionUpdate = TimeSpan.Zero;
-
     [Dependency] private readonly IEyeManager _eyeManager = default!;
     [Dependency] private readonly IResourceCacheInternal _resourceManager = default!;
     [Dependency] private readonly IEntityManager _entityManager = default!;
@@ -47,9 +33,6 @@ internal sealed partial class MidiManager : IMidiManager
     [Dependency] private readonly IClydeAudio _clydeAudio = default!;
     [Dependency] private readonly ITaskManager _taskManager = default!;
     [Dependency] private readonly ILogManager _logger = default!;
-    [Dependency] private readonly IParallelManager _parallel = default!;
-    [Dependency] private readonly IRuntimeLog _runtime = default!;
-    [Dependency] private readonly IGameTiming _timing = default!;
 
     private SharedPhysicsSystem _broadPhaseSystem = default!;
 
@@ -76,10 +59,11 @@ internal sealed partial class MidiManager : IMidiManager
         }
     }
 
-    [ViewVariables] private readonly List<IMidiRenderer> _renderers = new();
+    [ViewVariables]
+    private readonly List<IMidiRenderer> _renderers = new();
 
     private bool _alive = true;
-    [ViewVariables] private Settings? _settings;
+    private Settings? _settings;
     private Thread? _midiThread;
     private ISawmill _midiSawmill = default!;
     private float _volume = 0f;
@@ -131,7 +115,7 @@ internal sealed partial class MidiManager : IMidiManager
     private bool _failedInitialize;
 
     private NFluidsynth.Logger.LoggerDelegate _loggerDelegate = default!;
-    private ISawmill _fluidsynthSawmill = default!;
+    private ISawmill _sawmill = default!;
     private float _maxCastLength;
 
     [ViewVariables(VVAccess.ReadWrite)]
@@ -146,28 +130,20 @@ internal sealed partial class MidiManager : IMidiManager
     {
         if (FluidsynthInitialized || _failedInitialize) return;
 
+        _volume = _cfgMan.GetCVar(CVars.MidiVolume);
         _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
         {
             _volume = value;
             _volumeDirty = true;
         }, true);
 
-        _cfgMan.OnValueChanged(CVars.MidiMinRendererParallel,
-            value => _minRendererParallel = value, true);
-
-        _cfgMan.OnValueChanged(CVars.MidiOcclusionUpdateDelay,
-            value => _occlusionUpdateDelay = value, true);
-
-        _cfgMan.OnValueChanged(CVars.MidiPositionUpdateDelay,
-            value => _positionUpdateDelay = value, true);
-
         _midiSawmill = _logger.GetSawmill("midi");
 #if DEBUG
         _midiSawmill.Level = LogLevel.Debug;
 #else
         _midiSawmill.Level = LogLevel.Error;
 #endif
-        _fluidsynthSawmill = _logger.GetSawmill("midi.fluidsynth");
+        _sawmill = _logger.GetSawmill("midi.fluidsynth");
         _loggerDelegate = LoggerDelegate;
 
         if (!_resourceManager.UserData.Exists(CustomSoundfontDirectory))
@@ -191,6 +167,8 @@ internal sealed partial class MidiManager : IMidiManager
             _settings["synth.lock-memory"].IntValue = 0;
             _settings["synth.threadsafe-api"].IntValue = 1;
             _settings["synth.gain"].DoubleValue = 1.0d;
+            _settings["synth.polyphony"].IntValue = 1024;
+            _settings["synth.cpu-cores"].IntValue = 2;
             _settings["synth.midi-channels"].IntValue = 16;
             _settings["synth.overflow.age"].DoubleValue = 3000;
             _settings["audio.driver"].StringValue = "file";
@@ -198,11 +176,8 @@ internal sealed partial class MidiManager : IMidiManager
             _settings["audio.period-size"].IntValue = 4096;
             _settings["midi.autoconnect"].IntValue = 1;
             _settings["player.reset-synth"].IntValue = 0;
-            _settings["synth.midi-channels"].IntValue = Math.Clamp(RobustMidiEvent.MaxChannels, 16, 256);
             _settings["synth.midi-bank-select"].StringValue = "gm";
             //_settings["synth.verbose"].IntValue = 1; // Useful for debugging.
-
-            _parallel.AddAndInvokeParallelCountChanged(UpdateParallelCount);
         }
         catch (Exception e)
         {
@@ -220,18 +195,6 @@ internal sealed partial class MidiManager : IMidiManager
         FluidsynthInitialized = true;
     }
 
-    private void UpdateParallelCount()
-    {
-        if (_settings == null)
-            return;
-
-        _settings["synth.polyphony"].IntValue = Math.Clamp(1024 + (int)(Math.Log2(_parallel.ParallelProcessCount) * 2048), 1, 65535);
-        _settings["synth.cpu-cores"].IntValue = Math.Clamp(_parallel.ParallelProcessCount, 1, 256);
-
-        _midiSawmill.Debug($"Synth Cores: {_settings["synth.cpu-cores"].IntValue}");
-        _midiSawmill.Debug($"Synth Polyphony: {_settings["synth.polyphony"].IntValue}");
-    }
-
     private void OnRaycastLengthChanged(float value)
     {
         _maxCastLength = value;
@@ -248,7 +211,7 @@ internal sealed partial class MidiManager : IMidiManager
             NFluidsynth.Logger.LogLevel.Debug => LogLevel.Debug,
             _ => LogLevel.Debug
         };
-        _fluidsynthSawmill.Log(rLevel, message);
+        _sawmill.Log(rLevel, message);
     }
 
     public IMidiRenderer? GetNewRenderer(bool mono = true)
@@ -275,7 +238,7 @@ internal sealed partial class MidiManager : IMidiManager
 
             var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _clydeAudio, _taskManager, _midiSawmill);
 
-            _midiSawmill.Debug($"Loading fallback soundfont {FallbackSoundfont}");
+            _midiSawmill.Debug($"Loading soundfont {FallbackSoundfont}");
             // Since the last loaded soundfont takes priority, we load the fallback soundfont before the soundfont.
             renderer.LoadSoundfont(FallbackSoundfont);
 
@@ -289,8 +252,8 @@ internal sealed partial class MidiManager : IMidiManager
 
                     try
                     {
-                        _midiSawmill.Debug($"Loading OS soundfont {filepath}");
                         renderer.LoadSoundfont(filepath);
+                        _midiSawmill.Debug($"Loaded Linux soundfont {filepath}");
                     }
                     catch (Exception)
                     {
@@ -304,7 +267,7 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(OsxSoundfont) && SoundFont.IsSoundFont(OsxSoundfont))
                 {
-                    _midiSawmill.Debug($"Loading OS soundfont {OsxSoundfont}");
+                    _midiSawmill.Debug($"Loading soundfont {OsxSoundfont}");
                     renderer.LoadSoundfont(OsxSoundfont);
                 }
             }
@@ -312,7 +275,7 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(WindowsSoundfont) && SoundFont.IsSoundFont(WindowsSoundfont))
                 {
-                    _midiSawmill.Debug($"Loading OS soundfont {WindowsSoundfont}");
+                    _midiSawmill.Debug($"Loading soundfont {WindowsSoundfont}");
                     renderer.LoadSoundfont(WindowsSoundfont);
                 }
             }
@@ -323,31 +286,27 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(soundfontOverride) && SoundFont.IsSoundFont(soundfontOverride))
                 {
-                    _midiSawmill.Debug($"Loading environment variable soundfont {soundfontOverride}");
+                    _midiSawmill.Debug($"Loading soundfont {soundfontOverride} from environment variable.");
                     renderer.LoadSoundfont(soundfontOverride);
                 }
             }
 
             // Load content-specific custom soundfonts, which should override the system/fallback soundfont.
-            _midiSawmill.Debug($"Loading soundfonts from content directory {ContentCustomSoundfontDirectory}");
+            _midiSawmill.Debug($"Loading soundfonts from {ContentCustomSoundfontDirectory}");
             foreach (var file in _resourceManager.ContentFindFiles(ContentCustomSoundfontDirectory))
             {
                 if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
-                _midiSawmill.Debug($"Loading content soundfont {file}");
+                _midiSawmill.Debug($"Loading soundfont {file}");
                 renderer.LoadSoundfont(file.ToString());
             }
 
-            var userDataPath = _resourceManager.UserData.RootDir == null
-                ? CustomSoundfontDirectory
-                : new ResPath(_resourceManager.UserData.RootDir) / CustomSoundfontDirectory.ToRelativePath();
-
             // Load every soundfont from the user data directory last, since those may override any other soundfont.
-            _midiSawmill.Debug($"Loading soundfonts from user data directory {userDataPath}");
-            var enumerator = _resourceManager.UserData.Find($"{CustomSoundfontDirectory.ToRelativePath()}*").Item1;
+            _midiSawmill.Debug($"Loading soundfonts from {{USERDATA}} {CustomSoundfontDirectory}");
+            var enumerator = _resourceManager.UserData.Find($"{CustomSoundfontDirectory.ToRelativePath()}/*").Item1;
             foreach (var file in enumerator)
             {
                 if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
-                _midiSawmill.Debug($"Loading user soundfont {file}");
+                _midiSawmill.Debug($"Loading soundfont {{USERDATA}} {file}");
                 renderer.LoadSoundfont(file.ToString());
             }
 
@@ -377,108 +336,72 @@ internal sealed partial class MidiManager : IMidiManager
 
         lock (_renderers)
         {
-            if (_renderers.Count == 0)
-                return;
-
-            var transQuery = _entityManager.GetEntityQuery<TransformComponent>();
-            var physicsQuery = _entityManager.GetEntityQuery<PhysicsComponent>();
-            var opts = new ParallelOptions { MaxDegreeOfParallelism = _parallel.ParallelProcessCount };
-
-            if (_renderers.Count > _minRendererParallel)
+            foreach (var renderer in _renderers)
             {
-                Parallel.ForEach(_renderers, opts, renderer => UpdateRenderer(renderer, transQuery, physicsQuery));
-            }
-            else
-            {
-                foreach (var renderer in _renderers)
+                if (renderer.Disposed)
+                    continue;
+
+                if(_volumeDirty)
+                    renderer.Source.SetVolume(Volume);
+
+                if (!renderer.Mono)
                 {
-                    UpdateRenderer(renderer, transQuery, physicsQuery);
+                    renderer.Source.SetGlobal();
+                    continue;
+                }
+
+                MapCoordinates? mapPos = null;
+                var trackingEntity = renderer.TrackingEntity != null && !_entityManager.Deleted(renderer.TrackingEntity);
+                if (trackingEntity)
+                {
+                    renderer.TrackingCoordinates = _entityManager.GetComponent<TransformComponent>(renderer.TrackingEntity!.Value).Coordinates;
+                }
+
+                if (renderer.TrackingCoordinates != null)
+                {
+                    mapPos = renderer.TrackingCoordinates.Value.ToMap(_entityManager);
+                }
+
+                if (mapPos != null && mapPos.Value.MapId == _eyeManager.CurrentMap)
+                {
+                    var pos = mapPos.Value;
+
+                    var sourceRelative = pos.Position - _eyeManager.CurrentEye.Position.Position;
+                    var occlusion = 0f;
+                    if (sourceRelative.Length() > 0)
+                    {
+                        occlusion = _broadPhaseSystem.IntersectRayPenetration(
+                            pos.MapId,
+                            new CollisionRay(
+                                _eyeManager.CurrentEye.Position.Position,
+                                sourceRelative.Normalized(),
+                                OcclusionCollisionMask),
+                            MathF.Min(sourceRelative.Length(), _maxCastLength),
+                            renderer.TrackingEntity);
+                    }
+
+                    renderer.Source.SetOcclusion(occlusion);
+
+                    if (!renderer.Source.SetPosition(pos.Position))
+                    {
+                        return;
+                    }
+
+                    if (trackingEntity)
+                    {
+                        var vel = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity!.Value);
+                        renderer.Source.SetVelocity(vel);
+                    }
+                }
+                else
+                {
+                    renderer.Source.SetOcclusion(float.MaxValue);
                 }
             }
-
         }
 
-        if (_nextOcclusionUpdate < _timing.RealTime)
-            _nextOcclusionUpdate = _timing.RealTime.Add(TimeSpan.FromSeconds(_occlusionUpdateDelay));
-
-        if (_nextPositionUpdate < _timing.RealTime)
-            _nextPositionUpdate = _timing.RealTime.Add(TimeSpan.FromSeconds(_positionUpdateDelay));
-
         _volumeDirty = false;
     }
-    private void UpdateRenderer(IMidiRenderer renderer, EntityQuery<TransformComponent> transQuery,
-        EntityQuery<PhysicsComponent> physicsQuery)
-    {
-        try
-        {
-            if (renderer.Disposed)
-                return;
-
-            if (_volumeDirty)
-                renderer.Source.SetVolume(Volume);
-
-            if (!renderer.Mono)
-            {
-                renderer.Source.SetGlobal();
-                return;
-            }
-
-            if (_nextPositionUpdate < _timing.RealTime)
-            {
-                if (renderer.TrackingEntity is {} trackedEntity && !_entityManager.Deleted(trackedEntity))
-                {
-                    renderer.TrackingCoordinates = transQuery.GetComponent(renderer.TrackingEntity!.Value).MapPosition;
-                }
-                else if (renderer.TrackingCoordinates == null)
-                {
-                    return;
-                }
-
-                if (!renderer.Source.SetPosition(renderer.TrackingCoordinates.Value.Position))
-                {
-                    return;
-                }
-
-                var vel = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity!.Value,
-                    xformQuery: transQuery, physicsQuery: physicsQuery);
-                renderer.Source.SetVelocity(vel);
-            }
-
-            if (renderer.TrackingCoordinates != null && renderer.TrackingCoordinates.Value.MapId == _eyeManager.CurrentMap)
-            {
-                if (_nextOcclusionUpdate >= _timing.RealTime)
-                    return;
-
-                var pos = renderer.TrackingCoordinates.Value;
-
-                var sourceRelative = pos.Position - _eyeManager.CurrentEye.Position.Position;
-                var occlusion = 0f;
-                if (sourceRelative.Length() > 0)
-                {
-                    occlusion = _broadPhaseSystem.IntersectRayPenetration(
-                        pos.MapId,
-                        new CollisionRay(
-                            _eyeManager.CurrentEye.Position.Position,
-                            sourceRelative.Normalized(),
-                            OcclusionCollisionMask),
-                        MathF.Min(sourceRelative.Length(), _maxCastLength),
-                        renderer.TrackingEntity);
-                }
-
-                renderer.Source.SetOcclusion(occlusion);
-            }
-            else
-            {
-                renderer.Source.SetOcclusion(float.MaxValue);
-            }
-
-        }
-        catch (Exception ex)
-        {
-            _runtime.LogException(ex, _midiSawmill.Name);
-        }
-
-    }
 
     /// <summary>
     ///     Main method for the thread rendering the midi audio.
@@ -493,12 +416,7 @@ internal sealed partial class MidiManager : IMidiManager
                 {
                     var renderer = _renderers[i];
                     if (!renderer.Disposed)
-                    {
-                        if (renderer.Master is { Disposed: true })
-                            renderer.Master = null;
-
                         renderer.Render();
-                    }
                     else
                     {
                         renderer.InternalDispose();

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Collections;
-using JetBrains.Annotations;
 using NFluidsynth;
 using Robust.Client.Graphics;
 using Robust.Shared.Asynchronous;
@@ -11,6 +9,7 @@ using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
+using Logger = Robust.Shared.Log.Logger;
 
 namespace Robust.Client.Audio.Midi;
 
@@ -22,13 +21,14 @@ internal sealed class MidiRenderer : IMidiRenderer
     // TODO: Make this a replicated CVar in MidiManager
     private const int MidiSizeLimit = 2000000;
     private const double BytesToMegabytes = 0.000001d;
-    private const int ChannelCount = RobustMidiEvent.MaxChannels;
+    private const int ChannelCount = 16;
 
     private readonly ISawmill _midiSawmill;
 
     private readonly Settings _settings;
 
-    [ViewVariables(VVAccess.ReadWrite)] private bool _debugEvents = false;
+    [ViewVariables(VVAccess.ReadWrite)]
+    private bool _debugEvents = false;
 
     // Kept around to avoid the loader callbacks getting GC'd
     // ReSharper disable once NotAccessedField.Local
@@ -48,9 +48,8 @@ internal sealed class MidiRenderer : IMidiRenderer
     private readonly SequencerClientId _robustRegister;
     private readonly SequencerClientId _debugRegister;
 
-    [ViewVariables] private MidiRendererState _rendererState = new();
-
-    private IMidiRenderer? _master;
+    [ViewVariables]
+    private MidiRendererState _rendererState = new();
     public MidiRendererState RendererState => _rendererState;
     public IClydeBufferedAudioSource Source { get; set; }
     IClydeBufferedAudioSource IMidiRenderer.Source => Source;
@@ -71,8 +70,8 @@ internal sealed class MidiRenderer : IMidiRenderer
             {
                 for (byte i = 0; i < ChannelCount; i++)
                 {
-                    // Don't change percussion channel instrument.
-                    if (i == RobustMidiEvent.PercussionChannel)
+                    // Channel 9 is the percussion channel. Let's not change its instrument...
+                    if (i == 9)
                         continue;
 
                     SendMidiEvent(RobustMidiEvent.ProgramChange(i, value, SequencerTick));
@@ -97,14 +96,11 @@ internal sealed class MidiRenderer : IMidiRenderer
             {
                 for (byte i = 0; i < ChannelCount; i++)
                 {
-                    // Don't change percussion channel bank.
-                    if (i == RobustMidiEvent.PercussionChannel)
+                    // Channel 9 is the percussion channel. Let's not change its bank...
+                    if (i == 9)
                         continue;
 
                     SendMidiEvent(RobustMidiEvent.BankSelect(i, value, SequencerTick));
-
-                    // Re-select program.
-                    SendMidiEvent(RobustMidiEvent.ProgramChange(i, _midiProgram, SequencerTick));
                 }
             }
 
@@ -132,11 +128,7 @@ internal sealed class MidiRenderer : IMidiRenderer
     }
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public bool DisablePercussionChannel
-    {
-        get => FilteredChannels[RobustMidiEvent.PercussionChannel];
-        set => FilteredChannels[RobustMidiEvent.PercussionChannel] = value;
-    }
+    public bool DisablePercussionChannel { get; set; } = true;
 
     [ViewVariables(VVAccess.ReadWrite)]
     public bool DisableProgramChangeEvent { get; set; } = true;
@@ -189,62 +181,13 @@ internal sealed class MidiRenderer : IMidiRenderer
     }
 
     [ViewVariables(VVAccess.ReadWrite)]
-    [Obsolete($"Use {nameof(VelocityOverride)} instead, you can set it to 127 to achieve the same effect.")]
-    public bool VolumeBoost
-    {
-        get => VelocityOverride == 127;
-        set => VelocityOverride = value ? 127 : null;
-    }
+    public bool VolumeBoost { get; set; }
 
     [ViewVariables(VVAccess.ReadWrite)]
     public EntityUid? TrackingEntity { get; set; } = null;
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public MapCoordinates? TrackingCoordinates { get; set; } = null;
-
-    [ViewVariables]
-    public BitArray FilteredChannels { get; } = new(RobustMidiEvent.MaxChannels);
-
-    [ViewVariables(VVAccess.ReadWrite)]
-    public byte? VelocityOverride { get; set; } = null;
-
-    [ViewVariables(VVAccess.ReadWrite)]
-    public IMidiRenderer? Master
-    {
-        get => _master;
-        set
-        {
-            if (value == _master)
-                return;
-
-            if (_master is { Disposed: false })
-            {
-                try
-                {
-                    _master.OnMidiEvent -= SendMidiEvent;
-                }
-                catch
-                {
-                    // ignored
-                }
-            }
-
-            _master = value;
-
-            if (_master == null)
-                return;
-
-            _master.OnMidiEvent += SendMidiEvent;
-            ApplyState(_master.RendererState, true);
-            MidiBank = _midiBank;
-        }
-    }
-
-    [ViewVariables, UsedImplicitly]
-    private double CpuLoad => !_synth.Disposed ? _synth.CpuLoad : 0;
-
-    public event Action<RobustMidiEvent>? OnMidiEvent;
-    public event Action? OnMidiPlayerFinished;
+    public EntityCoordinates? TrackingCoordinates { get; set; } = null;
 
     internal MidiRenderer(Settings settings, SoundFontLoader soundFontLoader, bool mono,
         IMidiManager midiManager, IClydeAudio clydeAudio, ITaskManager taskManager, ISawmill midiSawmill)
@@ -411,11 +354,6 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
-    public void SystemReset()
-    {
-        SendMidiEvent(RobustMidiEvent.SystemReset(SequencerTick));
-    }
-
     public void ClearAllEvents()
     {
         _sequencer.RemoveEvents(SequencerClientId.Wildcard, SequencerClientId.Wildcard, -1);
@@ -430,6 +368,9 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
+    public event Action<RobustMidiEvent>? OnMidiEvent;
+    public event Action? OnMidiPlayerFinished;
+
     void IMidiRenderer.Render()
     {
         Render();
@@ -491,7 +432,7 @@ internal sealed class MidiRenderer : IMidiRenderer
         if (!Source.IsPlaying) Source.StartPlaying();
     }
 
-    public void ApplyState(MidiRendererState state, bool filterChannels = false)
+    public void ApplyState(MidiRendererState state)
     {
         lock (_playerStateLock)
         {
@@ -499,9 +440,6 @@ internal sealed class MidiRenderer : IMidiRenderer
 
             for (var channel = 0; channel < ChannelCount; channel++)
             {
-                if (filterChannels && !FilteredChannels[channel])
-                    continue;
-
                 _synth.AllNotesOff(channel);
 
                 _synth.PitchBend(channel, state.PitchBend.AsSpan[channel]);
@@ -524,8 +462,7 @@ internal sealed class MidiRenderer : IMidiRenderer
                     }
                 }
 
-                var program = DisableProgramChangeEvent ? MidiProgram : state.Program.AsSpan[channel];
-                _synth.ProgramChange(channel, program);
+                _synth.ProgramChange(channel, state.Program.AsSpan[channel]);
 
                 for (var key = 0; key < state.NoteVelocities.AsSpan[channel].AsSpan.Length; key++)
                 {
@@ -550,12 +487,7 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
-    private void SendMidiEvent(RobustMidiEvent midiEvent)
-    {
-        SendMidiEvent(midiEvent, true);
-    }
-
-    public void SendMidiEvent(RobustMidiEvent midiEvent, bool raiseEvent)
+    public void SendMidiEvent(RobustMidiEvent midiEvent)
     {
         if (Disposed)
             return;
@@ -573,10 +505,11 @@ internal sealed class MidiRenderer : IMidiRenderer
                         break;
 
                     case RobustMidiCommand.NoteOn:
-                        if (FilteredChannels[midiEvent.Channel])
-                            break;
+                        // Channel 9 is the percussion channel. We only block NoteOn events to it.
+                        if (DisablePercussionChannel && midiEvent.Channel == 9)
+                            return;
 
-                        var velocity = VelocityOverride ?? midiEvent.Velocity;
+                        var velocity = (byte)(VolumeBoost ? 127 : midiEvent.Velocity);
 
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = velocity;
                         _synth.NoteOn(midiEvent.Channel, midiEvent.Key, velocity);
@@ -590,7 +523,7 @@ internal sealed class MidiRenderer : IMidiRenderer
                     case RobustMidiCommand.ControlChange:
                         // CC0 is bank selection
                         if (midiEvent.Control == 0x0 && DisableProgramChangeEvent)
-                            break;
+                            return;
 
                         _rendererState.Controllers.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Control] = midiEvent.Value;
                         if(midiEvent.Control != 0x0)
@@ -601,7 +534,7 @@ internal sealed class MidiRenderer : IMidiRenderer
 
                     case RobustMidiCommand.ProgramChange:
                         if (DisableProgramChangeEvent)
-                            break;
+                            return;
 
                         _rendererState.Program.AsSpan[midiEvent.Channel] = midiEvent.Program;
                         _synth.ProgramChange(midiEvent.Channel, midiEvent.Program);
@@ -628,14 +561,14 @@ internal sealed class MidiRenderer : IMidiRenderer
                         switch (midiEvent.Control)
                         {
                             case 0x0 when midiEvent.Status == 0xFF:
-                                _rendererState = new MidiRendererState();
+                                _rendererState = new ();
                                 _synth.SystemReset();
 
                                 // Reset the instrument to the one we were using.
                                 if (DisableProgramChangeEvent)
                                 {
-                                    MidiBank = _midiBank;
                                     MidiProgram = _midiProgram;
+                                    MidiBank = _midiBank;
                                 }
 
                                 break;
@@ -664,10 +597,7 @@ internal sealed class MidiRenderer : IMidiRenderer
             //_midiSawmill.Error("Exception while sending midi event of type {0}: {1}", midiEvent.Type, e, midiEvent);
         }
 
-        if (raiseEvent)
-        {
-            _taskManager.RunOnMainThread(() => OnMidiEvent?.Invoke(midiEvent));
-        }
+        _taskManager.RunOnMainThread(() => OnMidiEvent?.Invoke(midiEvent));
     }
 
     public void ScheduleMidiEvent(RobustMidiEvent midiEvent, uint time, bool absolute = false)
@@ -703,9 +633,6 @@ internal sealed class MidiRenderer : IMidiRenderer
     /// <inheritdoc />
     void IMidiRenderer.InternalDispose()
     {
-        OnMidiEvent = null;
-        OnMidiPlayerFinished = null;
-
         Source?.Dispose();
         _driver?.Dispose();
 

Robust.Client/Audio/Midi/MidiRendererState.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
 using Robust.Shared.Utility;
-using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.Audio.Midi;
 
@@ -13,7 +12,7 @@ public struct MidiRendererState
     internal FixedArray16<byte> ChannelPressure;
     internal FixedArray16<ushort> PitchBend;
 
-    [ViewVariables] internal Span<byte> AsSpan => MemoryMarshal.CreateSpan(ref NoteVelocities._00._00, 4160);
+    internal Span<byte> AsSpan => MemoryMarshal.CreateSpan(ref NoteVelocities._00._00, 4160);
 
     static unsafe MidiRendererState()
     {

Robust.Client/ClientIoC.cs

@@ -68,7 +68,6 @@ namespace Robust.Client
             deps.Register<IComponentFactory, ComponentFactory>();
             deps.Register<ITileDefinitionManager, ClydeTileDefinitionManager>();
             deps.Register<IClydeTileDefinitionManager, ClydeTileDefinitionManager>();
-            deps.Register<ClydeTileDefinitionManager, ClydeTileDefinitionManager>();
             deps.Register<GameController, GameController>();
             deps.Register<IGameController, GameController>();
             deps.Register<IGameControllerInternal, GameController>();
@@ -85,7 +84,6 @@ namespace Robust.Client
             deps.Register<IReplayLoadManager, ReplayLoadManager>();
             deps.Register<IReplayPlaybackManager, ReplayPlaybackManager>();
             deps.Register<IReplayRecordingManager, ReplayRecordingManager>();
-            deps.Register<IReplayRecordingManagerInternal, ReplayRecordingManager>();
             deps.Register<IClientGameStateManager, ClientGameStateManager>();
             deps.Register<IBaseClient, BaseClient>();
             deps.Register<IPlayerManager, PlayerManager>();

Robust.Client/ComponentTrees/LightTreeComponent.cs

@@ -2,13 +2,11 @@ using Robust.Client.GameObjects;
 using Robust.Shared.ComponentTrees;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Physics;
-using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.ComponentTrees;
 
 [RegisterComponent]
-public sealed partial class LightTreeComponent: Component, IComponentTreeComponent<PointLightComponent>
+public sealed class LightTreeComponent: Component, IComponentTreeComponent<PointLightComponent>
 {
-    [ViewVariables]
     public DynamicTree<ComponentTreeEntry<PointLightComponent>> Tree { get; set; } = default!;
 }

Robust.Client/ComponentTrees/SpriteTreeComponent.cs

@@ -6,7 +6,7 @@ using Robust.Shared.Physics;
 namespace Robust.Client.ComponentTrees;
 
 [RegisterComponent]
-public sealed partial class SpriteTreeComponent: Component, IComponentTreeComponent<SpriteComponent>
+public sealed class SpriteTreeComponent: Component, IComponentTreeComponent<SpriteComponent>
 {
     public DynamicTree<ComponentTreeEntry<SpriteComponent>> Tree { get; set; } = default!;
 }

Robust.Client/Console/ClientConsoleHost.Completions.cs

@@ -14,7 +14,7 @@ internal sealed partial class ClientConsoleHost
     private int _completionSeq;
 
 
-    public async Task<CompletionResult> GetCompletions(List<string> args, string argStr, CancellationToken cancel)
+    public async Task<CompletionResult> GetCompletions(List<string> args, CancellationToken cancel)
     {
         // Last element is the command currently being typed. May be empty.
 
@@ -24,10 +24,10 @@ internal sealed partial class ClientConsoleHost
         if (delay > 0)
             await Task.Delay((int)(delay * 1000), cancel);
 
-        return await CalcCompletions(args, argStr, cancel);
+        return await CalcCompletions(args, cancel);
     }
 
-    private Task<CompletionResult> CalcCompletions(List<string> args, string argStr, CancellationToken cancel)
+    private Task<CompletionResult> CalcCompletions(List<string> args, CancellationToken cancel)
     {
         if (args.Count == 1)
         {
@@ -44,10 +44,10 @@ internal sealed partial class ClientConsoleHost
         if (!AvailableCommands.TryGetValue(args[0], out var cmd))
             return Task.FromResult(CompletionResult.Empty);
 
-        return cmd.GetCompletionAsync(LocalShell, args.ToArray()[1..], argStr, cancel).AsTask();
+        return cmd.GetCompletionAsync(LocalShell, args.ToArray()[1..], cancel).AsTask();
     }
 
-    private Task<CompletionResult> DoServerCompletions(List<string> args, string argStr, CancellationToken cancel)
+    private Task<CompletionResult> DoServerCompletions(List<string> args, CancellationToken cancel)
     {
         var tcs = new TaskCompletionSource<CompletionResult>();
         var cts = CancellationTokenSource.CreateLinkedTokenSource(cancel);
@@ -62,7 +62,6 @@ internal sealed partial class ClientConsoleHost
         var msg = new MsgConCompletion
         {
             Args = args.ToArray(),
-            ArgString = argStr,
             Seq = seq
         };
 

Robust.Client/Console/ClientConsoleHost.cs

@@ -10,7 +10,6 @@ using Robust.Shared.Console;
 using Robust.Shared.Enums;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
-using Robust.Shared.Maths;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
 using Robust.Shared.Players;
@@ -22,13 +21,13 @@ namespace Robust.Client.Console
 {
     public sealed class AddStringArgs : EventArgs
     {
-        public FormattedMessage Text { get; }
+        public string Text { get; }
 
         public bool Local { get; }
 
         public bool Error { get; }
 
-        public AddStringArgs(FormattedMessage text, bool local, bool error)
+        public AddStringArgs(string text, bool local, bool error)
         {
             Text = text;
             Local = local;
@@ -133,17 +132,10 @@ namespace Robust.Client.Console
             AddFormatted?.Invoke(this, new AddFormattedMessageArgs(message));
         }
 
-        public override void WriteLine(ICommonSession? session, FormattedMessage msg)
-        {
-            AddFormattedLine(msg);
-        }
-
         /// <inheritdoc />
         public override void WriteError(ICommonSession? session, string text)
         {
-            var msg = new FormattedMessage();
-            msg.AddText(text);
-            OutputText(msg, true, true);
+            OutputText(text, true, true);
         }
 
         public bool IsCmdServer(IConsoleCommand cmd)
@@ -159,13 +151,8 @@ namespace Robust.Client.Console
             if (string.IsNullOrWhiteSpace(command))
                 return;
 
-            WriteLine(null, "");
-            var msg = new FormattedMessage();
-            msg.PushColor(Color.Gold);
-            msg.AddText("> " + command);
-            msg.Pop();
             // echo the command locally
-            OutputText(msg, true, false);
+            WriteLine(null, "> " + command);
 
             //Commands are processed locally and then sent to the server to be processed there again.
             var args = new List<string>();
@@ -218,9 +205,7 @@ namespace Robust.Client.Console
         /// <inheritdoc />
         public override void WriteLine(ICommonSession? session, string text)
         {
-            var msg = new FormattedMessage();
-            msg.AddText(text);
-            OutputText(msg, true, false);
+            OutputText(text, true, false);
         }
 
         /// <inheritdoc />
@@ -229,12 +214,12 @@ namespace Robust.Client.Console
             // We don't have anything to dispose.
         }
 
-        private void OutputText(FormattedMessage text, bool local, bool error)
+        private void OutputText(string text, bool local, bool error)
         {
             AddString?.Invoke(this, new AddStringArgs(text, local, error));
 
             var level = error ? LogLevel.Warning : LogLevel.Info;
-            _conLogger.Log(level, text.ToString());
+            _conLogger.Log(level, text);
         }
 
         private void OnNetworkConnected(object? sender, NetChannelArgs netChannelArgs)
@@ -244,7 +229,7 @@ namespace Robust.Client.Console
 
         private void HandleConCmdAck(MsgConCmdAck msg)
         {
-            OutputText(msg.Text, false, msg.Error);
+            OutputText("< " + msg.Text, false, msg.Error);
         }
 
         private void HandleConCmdReg(MsgConCmdReg msg)
@@ -318,14 +303,13 @@ namespace Robust.Client.Console
             public async ValueTask<CompletionResult> GetCompletionAsync(
                 IConsoleShell shell,
                 string[] args,
-                string argStr,
                 CancellationToken cancel)
             {
                 var host = (ClientConsoleHost)shell.ConsoleHost;
                 var argsList = args.ToList();
                 argsList.Insert(0, Command);
 
-                return await host.DoServerCompletions(argsList, argStr, cancel);
+                return await host.DoServerCompletions(argsList, cancel);
             }
         }
 
@@ -343,11 +327,10 @@ namespace Robust.Client.Console
             public override async ValueTask<CompletionResult> GetCompletionAsync(
                 IConsoleShell shell,
                 string[] args,
-                string argStr,
                 CancellationToken cancel)
             {
                 var host = (ClientConsoleHost)shell.ConsoleHost;
-                return await host.DoServerCompletions(args.ToList(), argStr[">".Length..], cancel);
+                return await host.DoServerCompletions(args.ToList(), cancel);
             }
         }
     }

Robust.Client/Console/Commands/AddCompCommand.cs

@@ -22,8 +22,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var netEntity = NetEntity.Parse(args[0]);
-            var entity = _entityManager.GetEntity(netEntity);
+            var entity = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
             var component = (Component) _componentFactory.GetComponent(componentName);
@@ -50,8 +49,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var netEntity = NetEntity.Parse(args[0]);
-            var entityUid = _entityManager.GetEntity(netEntity);
+            var entityUid = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
             var registration = _componentFactory.GetRegistration(componentName);

Robust.Client/Console/Commands/Debug.cs

@@ -78,7 +78,14 @@ 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)
             {
@@ -289,7 +296,6 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class SnapGridGetCell : LocalizedCommands
     {
-        [Dependency] private readonly IEntityManager _entManager = default!;
         [Dependency] private readonly IMapManager _map = default!;
 
         public override string Command => "sggcell";
@@ -304,7 +310,7 @@ namespace Robust.Client.Console.Commands
 
             string indices = args[1];
 
-            if (!NetEntity.TryParse(args[0], out var gridNet))
+            if (!EntityUid.TryParse(args[0], out var gridUid))
             {
                 shell.WriteError($"{args[0]} is not a valid entity UID.");
                 return;
@@ -316,7 +322,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            if (_map.TryGetGrid(_entManager.GetEntity(gridNet), out var grid))
+            if (_map.TryGetGrid(gridUid, out var grid))
             {
                 foreach (var entity in grid.GetAnchoredEntities(new Vector2i(
                              int.Parse(indices.Split(',')[0], CultureInfo.InvariantCulture),
@@ -424,7 +430,6 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class GridTileCount : LocalizedCommands
     {
-        [Dependency] private readonly IEntityManager _entManager = default!;
         [Dependency] private readonly IMapManager _map = default!;
 
         public override string Command => "gridtc";
@@ -437,8 +442,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            if (!NetEntity.TryParse(args[0], out var gridUidNet) ||
-                !_entManager.TryGetEntity(gridUidNet, out var gridUid))
+            if (!EntityUid.TryParse(args[0], out var gridUid))
             {
                 shell.WriteLine($"{args[0]} is not a valid entity UID.");
                 return;
@@ -617,7 +621,6 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class ChunkInfoCommand : LocalizedCommands
     {
-        [Dependency] private readonly IEntityManager _entManager = default!;
         [Dependency] private readonly IMapManager _map = default!;
         [Dependency] private readonly IEyeManager _eye = default!;
         [Dependency] private readonly IInputManager _input = default!;
@@ -626,19 +629,18 @@ namespace Robust.Client.Console.Commands
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mousePos = _eye.PixelToMap(_input.MouseScreenPosition);
+            var mousePos = _eye.ScreenToMap(_input.MouseScreenPosition);
 
-            if (!_map.TryFindGridAt(mousePos, out var gridUid, out var grid))
+            if (!_map.TryFindGridAt(mousePos, out _, out var grid))
             {
                 shell.WriteLine("No grid under your mouse cursor.");
                 return;
             }
 
-            var mapSystem = _entManager.System<SharedMapSystem>();
-            var chunkIndex = mapSystem.LocalToChunkIndices(gridUid, grid, grid.MapToGrid(mousePos));
-            var chunk = mapSystem.GetOrAddChunk(gridUid, grid, chunkIndex);
+            var chunkIndex = grid.LocalToChunkIndices(grid.MapToGrid(mousePos));
+            var chunk = grid.GetOrAddChunk(chunkIndex);
 
-            shell.WriteLine($"worldBounds: {mapSystem.CalcWorldAABB(gridUid, grid, chunk)} localBounds: {chunk.CachedBounds}");
+            shell.WriteLine($"worldBounds: {grid.CalcWorldAABB(chunk)} localBounds: {chunk.CachedBounds}");
         }
     }
 

Robust.Client/Console/IClientConsoleHost.cs

@@ -19,6 +19,6 @@ namespace Robust.Client.Console
 
         void AddFormattedLine(FormattedMessage message);
 
-        Task<CompletionResult> GetCompletions(List<string> args, string argStr, CancellationToken cancel);
+        Task<CompletionResult> GetCompletions(List<string> args, CancellationToken cancel);
     }
 }

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -61,7 +61,7 @@ namespace Robust.Client.Debugging
             }
 
             var mouseSpot = _inputManager.MouseScreenPosition;
-            var spot = _eyeManager.PixelToMap(mouseSpot);
+            var spot = _eyeManager.ScreenToMap(mouseSpot);
 
             if (!_mapManager.TryFindGridAt(spot, out var gridUid, out var grid))
             {

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -218,7 +218,7 @@ namespace Robust.Client.Debugging
             _debugPhysicsSystem = system;
             _lookup = lookup;
             _physicsSystem = physicsSystem;
-            _font = new VectorFont(cache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
+            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
         }
 
         private void DrawWorld(DrawingHandleWorld worldHandle, OverlayDrawArgs args)
@@ -371,7 +371,7 @@ namespace Robust.Client.Debugging
             if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.ShapeInfo) != 0x0)
             {
                 var hoverBodies = new List<PhysicsComponent>();
-                var bounds = Box2.UnitCentered.Translated(_eyeManager.PixelToMap(mousePos.Position).Position);
+                var bounds = Box2.UnitCentered.Translated(_eyeManager.ScreenToMap(mousePos.Position).Position);
 
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, bounds))
                 {
@@ -404,7 +404,7 @@ namespace Robust.Client.Debugging
 
             if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.Distance) != 0x0)
             {
-                var mapPos = _eyeManager.PixelToMap(mousePos);
+                var mapPos = _eyeManager.ScreenToMap(mousePos);
 
                 if (mapPos.MapId != args.MapId)
                     return;

Robust.Client/GameController/GameController.cs

@@ -33,7 +33,6 @@ using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Profiling;
 using Robust.Shared.Prototypes;
-using Robust.Shared.Reflection;
 using Robust.Shared.Replays;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager;
@@ -85,8 +84,7 @@ namespace Robust.Client
         [Dependency] private readonly NetworkResourceManager _netResMan = default!;
         [Dependency] private readonly IReplayLoadManager _replayLoader = default!;
         [Dependency] private readonly IReplayPlaybackManager _replayPlayback = default!;
-        [Dependency] private readonly IReplayRecordingManagerInternal _replayRecording = default!;
-        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
+        [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
 
         private IWebViewManagerHook? _webViewHook;
 
@@ -164,9 +162,9 @@ namespace Robust.Client
             // before prototype load.
             ProgramShared.FinishCheckBadFileExtensions(checkBadExtensions);
 
-            _reflectionManager.Initialize();
             _prototypeManager.Initialize();
             _prototypeManager.LoadDefaultPrototypes();
+            _prototypeManager.ResolveResults();
             _userInterfaceManager.Initialize();
             _eyeManager.Initialize();
             _entityManager.Initialize();
@@ -202,12 +200,7 @@ namespace Robust.Client
             // Setup main loop
             if (_mainLoop == null)
             {
-                _mainLoop = new GameLoop(
-                    _gameTiming,
-                    _runtimeLog,
-                    _prof,
-                    _logManager.GetSawmill("eng"),
-                    GameLoopOptions.FromCVars(_configurationManager))
+                _mainLoop = new GameLoop(_gameTiming, _runtimeLog, _prof, _logManager.GetSawmill("eng"))
                 {
                     SleepMode = displayMode == DisplayMode.Headless ? SleepMode.Delay : SleepMode.None
                 };
@@ -567,11 +560,6 @@ namespace Robust.Client
             {
                 _taskManager.ProcessPendingTasks(); // tasks like connect
             }
-
-            using (_prof.Group("Content post engine"))
-            {
-                _modLoader.BroadcastUpdate(ModUpdateLevel.InputPostEngine, frameEventArgs);
-            }
         }
 
         private void Tick(FrameEventArgs frameEventArgs)
@@ -768,8 +756,6 @@ namespace Robust.Client
 
         internal void CleanupGameThread()
         {
-            _replayRecording.Shutdown();
-
             _modLoader.Shutdown();
 
             // CEF specifically makes a massive silent stink of it if we don't shut it down from the correct thread.

Robust.Client/GameObjects/ClientEntityManager.Network.cs

@@ -1,53 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Map;
-using Robust.Shared.Utility;
-
-namespace Robust.Client.GameObjects;
-
-public sealed partial class ClientEntityManager
-{
-    protected override NetEntity GenerateNetEntity() => new(NextNetworkId++ | NetEntity.ClientEntity);
-
-    /// <summary>
-    /// If the client fails to resolve a NetEntity then during component state handling or the likes we
-    /// flag that comp state as requiring re-running if that NetEntity comes in.
-    /// </summary>
-    /// <returns></returns>
-    internal readonly Dictionary<NetEntity, List<(Type type, EntityUid Owner)>> PendingNetEntityStates = new();
-
-    public override bool IsClientSide(EntityUid uid, MetaDataComponent? metadata = null)
-    {
-        // Can't log false because some content code relies on invalid UIDs.
-        if (!MetaQuery.Resolve(uid, ref metadata, false))
-            return false;
-
-        return metadata.NetEntity.IsClientSide();
-    }
-
-    public override EntityUid EnsureEntity<T>(NetEntity nEntity, EntityUid callerEntity)
-    {
-        if (!nEntity.Valid)
-        {
-            return EntityUid.Invalid;
-        }
-
-        if (NetEntityLookup.TryGetValue(nEntity, out var 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.Item1;
-    }
-
-    public override EntityCoordinates EnsureCoordinates<T>(NetCoordinates netCoordinates, EntityUid callerEntity)
-    {
-        var entity = EnsureEntity<T>(netCoordinates.NetEntity, callerEntity);
-        return new EntityCoordinates(entity, netCoordinates.Position);
-    }
-}

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -1,12 +1,13 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Prometheus;
 using Robust.Client.GameStates;
 using Robust.Client.Player;
 using Robust.Client.Timing;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
 using Robust.Shared.Replays;
@@ -17,7 +18,7 @@ namespace Robust.Client.GameObjects
     /// <summary>
     /// Manager for entities -- controls things like template loading and instantiation
     /// </summary>
-    public sealed partial class ClientEntityManager : EntityManager, IClientEntityManagerInternal
+    public sealed class ClientEntityManager : EntityManager, IClientEntityManagerInternal
     {
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IClientNetManager _networkManager = default!;
@@ -26,6 +27,8 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IBaseClient _client = default!;
         [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
 
+        protected override int NextEntityUid { get; set; } = EntityUid.ClientUid + 1;
+
         public override void Initialize()
         {
             SetupNetworking();
@@ -36,16 +39,13 @@ namespace Robust.Client.GameObjects
 
         public override void FlushEntities()
         {
-            // Server doesn't network deletions on client shutdown so we need to
-            // manually clear these out or risk stale data getting used.
-            PendingNetEntityStates.Clear();
             using var _ = _gameTiming.StartStateApplicationArea();
             base.FlushEntities();
         }
 
-        EntityUid IClientEntityManagerInternal.CreateEntity(string? prototypeName)
+        EntityUid IClientEntityManagerInternal.CreateEntity(string? prototypeName, EntityUid uid)
         {
-            return base.CreateEntity(prototypeName);
+            return base.CreateEntity(prototypeName, uid);
         }
 
         void IClientEntityManagerInternal.InitializeEntity(EntityUid entity, MetaDataComponent? meta)
@@ -66,12 +66,9 @@ namespace Robust.Client.GameObjects
                 base.DirtyEntity(uid, meta);
         }
 
-        public override void QueueDeleteEntity(EntityUid? uid)
+        public override void QueueDeleteEntity(EntityUid uid)
         {
-            if (uid == null)
-                return;
-
-            if (IsClientSide(uid.Value))
+            if (uid.IsClientSide())
             {
                 base.QueueDeleteEntity(uid);
                 return;
@@ -82,7 +79,7 @@ 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.Value)}. Trace: {Environment.StackTrace}");
+                LogManager.RootSawmill.Error($"Predicting the queued deletion of a networked entity: {ToPrettyString(uid)}. Trace: {Environment.StackTrace}");
         }
 
         /// <inheritdoc />
@@ -93,16 +90,12 @@ namespace Robust.Client.GameObjects
                 base.Dirty(uid, component, meta);
         }
 
-        [return: NotNullIfNotNull("uid")]
-        public override EntityStringRepresentation? ToPrettyString(EntityUid? uid)
+        public override EntityStringRepresentation ToPrettyString(EntityUid uid)
         {
-            if (uid == null)
-                return null;
-
             if (_playerManager.LocalPlayer?.ControlledEntity == uid)
-                return base.ToPrettyString(uid).Value with { Session = _playerManager.LocalPlayer.Session };
-
-            return base.ToPrettyString(uid);
+                return base.ToPrettyString(uid) with { Session = _playerManager.LocalPlayer.Session };
+            else
+                return base.ToPrettyString(uid);
         }
 
         public override void RaisePredictiveEvent<T>(T msg)

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

@@ -11,7 +11,7 @@ namespace Robust.Client.GameObjects
     ///     Plays back <see cref="Animation"/>s on entities.
     /// </summary>
     [RegisterComponent]
-    public sealed partial class AnimationPlayerComponent : Component
+    public sealed class AnimationPlayerComponent : Component
     {
         // TODO: Give this component a friend someday. Way too much content shit to change atm ._.
 

Robust.Client/GameObjects/Components/Appearance/GenericVisualizerComponent.cs

@@ -11,7 +11,7 @@ namespace Robust.Client.GameObjects;
 /// </summary>
 [RegisterComponent]
 [Access(typeof(GenericVisualizerSystem))]
-public sealed partial class GenericVisualizerComponent : Component
+public sealed class GenericVisualizerComponent : Component
 {
     /// <summary>
     ///     This is a nested dictionary that maps appearance data keys -> sprite layer keys -> appearance data values -> layer data.

Robust.Client/GameObjects/Components/Eye/EyeComponent.cs

@@ -0,0 +1,187 @@
+using System.Numerics;
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Robust.Client.GameObjects
+{
+    [RegisterComponent, ComponentReference(typeof(SharedEyeComponent))]
+    public sealed class EyeComponent : SharedEyeComponent
+    {
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
+        [ViewVariables]
+        private Eye? _eye = default!;
+
+        // Horrible hack to get around ordering issues.
+        private bool _setCurrentOnInitialize;
+        [DataField("drawFov")]
+        private bool _setDrawFovOnInitialize = true;
+        [DataField("zoom")]
+        private Vector2 _setZoomOnInitialize = Vector2.One;
+
+        /// <summary>
+        ///     If not null, this entity is used to update the eye's position instead of just using the component's owner.
+        /// </summary>
+        /// <remarks>
+        ///     This is useful for things like vehicles that effectively need to hijack the eye. This allows them to do
+        ///     that without messing with the main viewport's eye. This is important as there are some overlays that are
+        ///     only be drawn if that viewport's eye belongs to the currently controlled entity.
+        /// </remarks>
+        [ViewVariables]
+        public EntityUid? Target;
+
+        public IEye? Eye => _eye;
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool Current
+        {
+            get => _eyeManager.CurrentEye == _eye;
+            set
+            {
+                if (_eye == null)
+                {
+                    _setCurrentOnInitialize = value;
+                    return;
+                }
+
+                if (_eyeManager.CurrentEye == _eye == value)
+                    return;
+
+                if (value)
+                {
+                    _eyeManager.CurrentEye = _eye;
+                }
+                else
+                {
+                    _eyeManager.ClearCurrentEye();
+                }
+            }
+        }
+
+        public override Vector2 Zoom
+        {
+            get => _eye?.Zoom ?? _setZoomOnInitialize;
+            set
+            {
+                if (_eye == null)
+                {
+                    _setZoomOnInitialize = value;
+                }
+                else
+                {
+                    _eye.Zoom = value;
+                }
+            }
+        }
+
+        public override Angle Rotation
+        {
+            get => _eye?.Rotation ?? Angle.Zero;
+            set
+            {
+                if (_eye != null)
+                    _eye.Rotation = value;
+            }
+        }
+
+        public override Vector2 Offset
+        {
+            get => _eye?.Offset ?? default;
+            set
+            {
+                if (_eye != null)
+                    _eye.Offset = value;
+            }
+        }
+
+        public override bool DrawFov
+        {
+            get => _eye?.DrawFov ?? _setDrawFovOnInitialize;
+            set
+            {
+                if (_eye == null)
+                {
+                    _setDrawFovOnInitialize = value;
+                }
+                else
+                {
+                    _eye.DrawFov = value;
+                }
+            }
+        }
+
+        [ViewVariables]
+        public MapCoordinates? Position => _eye?.Position;
+
+        /// <inheritdoc />
+        protected override void Initialize()
+        {
+            base.Initialize();
+
+            _eye = new Eye
+            {
+                Position = _entityManager.GetComponent<TransformComponent>(Owner).MapPosition,
+                Zoom = _setZoomOnInitialize,
+                DrawFov = _setDrawFovOnInitialize
+            };
+
+            if ((_eyeManager.CurrentEye == _eye) != _setCurrentOnInitialize)
+            {
+                if (_setCurrentOnInitialize)
+                {
+                    _eyeManager.ClearCurrentEye();
+                }
+                else
+                {
+                    _eyeManager.CurrentEye = _eye;
+                }
+            }
+        }
+
+        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
+        {
+            base.HandleComponentState(curState, nextState);
+
+            if (curState is not EyeComponentState state)
+            {
+                return;
+            }
+
+            DrawFov = state.DrawFov;
+            // TODO: Should be a way for content to override lerping and lerp the zoom
+            Zoom = state.Zoom;
+            Offset = state.Offset;
+            VisibilityMask = state.VisibilityMask;
+        }
+
+        protected override void OnRemove()
+        {
+            base.OnRemove();
+
+            Current = false;
+        }
+
+        /// <summary>
+        /// Updates the Eye of this entity with the transform position. This has to be called every frame to
+        /// keep the view following the entity.
+        /// </summary>
+        public void UpdateEyePosition()
+        {
+            if (_eye == null) return;
+
+            if (!_entityManager.TryGetComponent(Target, out TransformComponent? xform))
+            {
+                xform = _entityManager.GetComponent<TransformComponent>(Owner);
+                Target = null;
+            }
+
+            _eye.Position = xform.MapPosition;
+        }
+    }
+}

Robust.Client/GameObjects/Components/Icon/IconComponent.cs

@@ -16,8 +16,8 @@ namespace Robust.Client.GameObjects;
 /// updated.
 /// </remarks>
 [RegisterComponent]
-public sealed partial class IconComponent : Component
+public sealed class IconComponent : Component
 {
     [IncludeDataField]
-    public SpriteSpecifier.Rsi Icon = default!;
+    public readonly SpriteSpecifier.Rsi Icon = default!;
 }

Robust.Client/GameObjects/Components/Input/InputComponent.cs

@@ -9,7 +9,7 @@ namespace Robust.Client.GameObjects
     ///     Defines data fields used in the <see cref="InputSystem"/>.
     /// </summary>
     [RegisterComponent]
-    public sealed partial class InputComponent : Component
+    public sealed class InputComponent : Component
     {
         /// <summary>
         ///     The context that will be made active for a client that attaches to this entity.

Robust.Client/GameObjects/Components/Light/PointLightComponent.cs

@@ -0,0 +1,85 @@
+using Robust.Client.Graphics;
+using Robust.Shared.Animations;
+using Robust.Shared.ComponentTrees;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Physics;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Robust.Client.GameObjects
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(SharedPointLightComponent))]
+    public sealed class PointLightComponent : SharedPointLightComponent, IComponentTreeEntry<PointLightComponent>
+    {
+        public EntityUid? TreeUid { get; set; }
+
+        public DynamicTree<ComponentTreeEntry<PointLightComponent>>? Tree { get; set; }
+
+        public bool AddToTree => Enabled && !ContainerOccluded;
+        public bool TreeUpdateQueued { get; set; }
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        [Animatable]
+        public override Color Color
+        {
+            get => _color;
+            set => base.Color = value;
+        }
+
+        [Access(typeof(PointLightSystem))]
+        public bool ContainerOccluded;
+
+        /// <summary>
+        ///     Determines if the light mask should automatically rotate with the entity. (like a flashlight)
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool MaskAutoRotate
+        {
+            get => _maskAutoRotate;
+            set => _maskAutoRotate = value;
+        }
+
+        /// <summary>
+        ///     Local rotation of the light mask around the center origin
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [Animatable]
+        public Angle Rotation
+        {
+            get => _rotation;
+            set => _rotation = value;
+        }
+
+        /// <summary>
+        /// The resource path to the mask texture the light will use.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public string? MaskPath
+        {
+            get => _maskPath;
+            set
+            {
+                if (_maskPath?.Equals(value) != false) return;
+                _maskPath = value;
+                EntitySystem.Get<PointLightSystem>().UpdateMask(this);
+            }
+        }
+
+        /// <summary>
+        ///     Set a mask texture that will be applied to the light while rendering.
+        ///     The mask's red channel will be linearly multiplied.p
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public Texture? Mask { get; set; }
+
+        [DataField("autoRot")]
+        private bool _maskAutoRotate;
+        private Angle _rotation;
+
+        [DataField("mask")]
+        internal string? _maskPath;
+    }
+}

Robust.Client/GameObjects/Components/PointLightComponent.cs

@@ -1,38 +0,0 @@
-using Robust.Client.Graphics;
-using Robust.Shared.ComponentTrees;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Physics;
-using Robust.Shared.ViewVariables;
-
-namespace Robust.Client.GameObjects;
-
-[RegisterComponent]
-public sealed partial class PointLightComponent : SharedPointLightComponent, IComponentTreeEntry<PointLightComponent>
-{
-    #region Component Tree
-
-    /// <inheritdoc />
-    [ViewVariables]
-    public EntityUid? TreeUid { get; set; }
-
-    /// <inheritdoc />
-    [ViewVariables]
-    public DynamicTree<ComponentTreeEntry<PointLightComponent>>? Tree { get; set; }
-
-    /// <inheritdoc />
-    [ViewVariables]
-    public bool AddToTree => Enabled && !ContainerOccluded;
-
-    /// <inheritdoc />
-    [ViewVariables]
-    public bool TreeUpdateQueued { get; set; }
-
-    #endregion
-
-    /// <summary>
-    ///     Set a mask texture that will be applied to the light while rendering.
-    ///     The mask's red channel will be linearly multiplied.
-    /// </summary>
-    [ViewVariables(VVAccess.ReadWrite)]
-    internal Texture? Mask;
-}

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

@@ -4,7 +4,7 @@ using Robust.Shared.Maths;
 
 namespace Robust.Client.GameObjects
 {
-    public partial interface IRenderableComponent : IComponent
+    public interface IRenderableComponent : IComponent
     {
         int DrawDepth { get; set; }
         float Bottom { get; }

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

@@ -1,7 +1,5 @@
 using System.Numerics;
 using Robust.Client.Graphics;
-using Robust.Shared.Graphics;
-using Robust.Shared.Graphics.RSI;
 using Robust.Shared.Maths;
 
 namespace Robust.Client.GameObjects
@@ -26,7 +24,7 @@ namespace Robust.Client.GameObjects
         int AnimationFrame { get; }
         bool AutoAnimated { get; set; }
 
-        RsiDirection EffectiveDirection(Angle worldRotation);
+        RSI.State.Direction EffectiveDirection(Angle worldRotation);
 
         /// <summary>
         ///     Layer size in pixels.

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

@@ -12,8 +12,6 @@ using Robust.Shared;
 using Robust.Shared.Animations;
 using Robust.Shared.ComponentTrees;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Graphics;
-using Robust.Shared.Graphics.RSI;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
@@ -28,13 +26,13 @@ using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 using static Robust.Client.ComponentTrees.SpriteTreeSystem;
 using DrawDepthTag = Robust.Shared.GameObjects.DrawDepth;
+using RSIDirection = Robust.Client.Graphics.RSI.State.Direction;
 using static Robust.Shared.Serialization.TypeSerializers.Implementations.SpriteSpecifierSerializer;
-using Direction = Robust.Shared.Maths.Direction;
 
 namespace Robust.Client.GameObjects
 {
     [RegisterComponent]
-    public sealed partial class SpriteComponent : Component, IComponentDebug, ISerializationHooks, IComponentTreeEntry<SpriteComponent>, IAnimationProperties
+    public sealed class SpriteComponent : Component, IComponentDebug, ISerializationHooks, IComponentTreeEntry<SpriteComponent>, IAnimationProperties
     {
         [Dependency] private readonly IResourceCache resourceCache = default!;
         [Dependency] private readonly IPrototypeManager prototypes = default!;
@@ -169,9 +167,40 @@ namespace Robust.Client.GameObjects
 
         public bool TreeUpdateQueued { get; set; }
 
+        [DataField("layerDatums")]
+        private List<PrototypeLayerData> LayerDatums
+        {
+            get
+            {
+                var layerDatums = new List<PrototypeLayerData>();
+                foreach (var layer in Layers)
+                {
+                    layerDatums.Add(layer.ToPrototypeData());
+                }
+
+                return layerDatums;
+            }
+            set
+            {
+                if (value == null) return;
+
+                Layers.Clear();
+                foreach (var layerDatum in value)
+                {
+                    AddLayer(layerDatum);
+                }
+
+                _layerMapShared = true;
+
+                QueueUpdateRenderTree();
+                QueueUpdateIsInert();
+            }
+        }
+
         private RSI? _baseRsi;
 
         [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("rsi", priority: 2)]
         public RSI? BaseRSI
         {
             get => _baseRsi;
@@ -328,16 +357,7 @@ namespace Robust.Client.GameObjects
             if (layerDatums.Count != 0)
             {
                 LayerMap.Clear();
-                Layers.Clear();
-                foreach (var datum in layerDatums)
-                {
-                    AddLayer(datum);
-                }
-
-                _layerMapShared = true;
-
-                QueueUpdateRenderTree();
-                QueueUpdateIsInert();
+                LayerDatums = layerDatums;
             }
 
             UpdateLocalMatrix();
@@ -1349,11 +1369,11 @@ namespace Robust.Client.GameObjects
                 state = GetFallbackState(resourceCache);
             }
 
-            return state.RsiDirections switch
+            return state.Directions switch
             {
-                RsiDirectionType.Dir1 => 1,
-                RsiDirectionType.Dir4 => 4,
-                RsiDirectionType.Dir8 => 8,
+                RSI.State.DirectionType.Dir1 => 1,
+                RSI.State.DirectionType.Dir4 => 4,
+                RSI.State.DirectionType.Dir8 => 8,
                 _ => throw new ArgumentOutOfRangeException()
             };
         }
@@ -1391,7 +1411,7 @@ namespace Robust.Client.GameObjects
             builder.AppendFormat(
                 "vis/depth/scl/rot/ofs/col/norot/override/dir: {0}/{1}/{2}/{3}/{4}/{5}/{6}/{8}/{7}\n",
                 Visible, DrawDepth, Scale, Rotation, Offset,
-                Color, NoRotation, entities.GetComponent<TransformComponent>(Owner).WorldRotation.ToRsiDirection(RsiDirectionType.Dir8),
+                Color, NoRotation, entities.GetComponent<TransformComponent>(Owner).WorldRotation.ToRsiDirection(RSI.State.DirectionType.Dir8),
                 DirectionOverride
             );
 
@@ -1691,7 +1711,7 @@ namespace Robust.Client.GameObjects
 
             int ISpriteLayer.AnimationFrame => AnimationFrame;
 
-            public RsiDirection EffectiveDirection(Angle worldRotation)
+            public RSIDirection EffectiveDirection(Angle worldRotation)
             {
                 if (State == default)
                 {
@@ -1712,23 +1732,23 @@ namespace Robust.Client.GameObjects
                 return default;
             }
 
-            public RsiDirection EffectiveDirection(RSI.State state, Angle worldRotation,
+            public RSIDirection EffectiveDirection(RSI.State state, Angle worldRotation,
                 Direction? overrideDirection)
             {
-                if (state.RsiDirections == RsiDirectionType.Dir1)
+                if (state.Directions == RSI.State.DirectionType.Dir1)
                 {
-                    return RsiDirection.South;
+                    return RSIDirection.South;
                 }
                 else
                 {
-                    RsiDirection dir;
+                    RSIDirection dir;
                     if (overrideDirection != null)
                     {
-                        dir = overrideDirection.Value.Convert(state.RsiDirections);
+                        dir = overrideDirection.Value.Convert(state.Directions);
                     }
                     else
                     {
-                        dir = worldRotation.ToRsiDirection(state.RsiDirections);
+                        dir = worldRotation.ToRsiDirection(state.Directions);
                     }
 
                     return dir.OffsetRsiDir(DirOffset);
@@ -1884,20 +1904,20 @@ namespace Robust.Client.GameObjects
                 else if (_parent.SnapCardinals && (!_parent.GranularLayersRendering || RenderingStrategy == LayerRenderingStrategy.UseSpriteStrategy)
                          || _parent.GranularLayersRendering && RenderingStrategy == LayerRenderingStrategy.SnapToCardinals)
                 {
-                    DebugTools.Assert(_actualState == null || _actualState.RsiDirections == RsiDirectionType.Dir1);
+                    DebugTools.Assert(_actualState == null || _actualState.Directions == RSI.State.DirectionType.Dir1);
                     size = new Vector2(longestSide, longestSide);
                 }
                 else
                 {
                     // Build the bounding box based on how many directions the sprite has
-                    size = (_actualState?.RsiDirections) switch
+                    size = (_actualState?.Directions) switch
                     {
                         // If we have four cardinal directions, take the longest side of our texture and square it, then turn that into our bounding box.
                         // This accounts for all possible rotations.
-                        RsiDirectionType.Dir4 => new Vector2(longestSide, longestSide),
+                        RSI.State.DirectionType.Dir4 => new Vector2(longestSide, longestSide),
 
                         // If we have eight directions, find the maximum length of the texture (accounting for rotation), then square it to make
-                        RsiDirectionType.Dir8 => new Vector2(longestRotatedSide, longestRotatedSide),
+                        RSI.State.DirectionType.Dir8 => new Vector2(longestRotatedSide, longestRotatedSide),
 
                         // If we have only one direction or an invalid RSI state, create a simple bounding box with the size of the texture.
                         _ => textureSize
@@ -1931,9 +1951,9 @@ namespace Robust.Client.GameObjects
             ///     Given the apparent rotation of an entity on screen (world + eye rotation), get layer's matrix for drawing &
             ///     relevant RSI direction.
             /// </summary>
-            public void GetLayerDrawMatrix(RsiDirection dir, out Matrix3 layerDrawMatrix)
+            public void GetLayerDrawMatrix(RSIDirection dir, out Matrix3 layerDrawMatrix)
             {
-                if (_parent.NoRotation || dir == RsiDirection.South)
+                if (_parent.NoRotation || dir == RSIDirection.South)
                     layerDrawMatrix = LocalMatrix;
                 else
                 {
@@ -1958,11 +1978,11 @@ namespace Robust.Client.GameObjects
             ///     Converts an angle (between 0 and 2pi) to an RSI direction. This will slightly bias the angle to avoid flickering for
             ///     4-directional sprites.
             /// </summary>
-            public static RsiDirection GetDirection(RsiDirectionType dirType, Angle angle)
+            public static RSIDirection GetDirection(RSI.State.DirectionType dirType, Angle angle)
             {
-                if (dirType == RsiDirectionType.Dir1)
-                    return RsiDirection.South;
-                else if (dirType == RsiDirectionType.Dir8)
+                if (dirType == RSI.State.DirectionType.Dir1)
+                    return RSIDirection.South;
+                else if (dirType == RSI.State.DirectionType.Dir8)
                     return angle.GetDir().Convert(dirType);
 
                 // For 4-directional sprites, as entities are often moving & facing diagonally, we will slightly bias the
@@ -1975,10 +1995,10 @@ namespace Robust.Client.GameObjects
 
                 return ((int)Math.Round(modTheta / MathHelper.PiOver2) % 4) switch
                 {
-                    0 => RsiDirection.South,
-                    1 => RsiDirection.East,
-                    2 => RsiDirection.North,
-                    _ => RsiDirection.West,
+                    0 => RSIDirection.South,
+                    1 => RSIDirection.East,
+                    2 => RSIDirection.North,
+                    _ => RSIDirection.West,
                 };
             }
 
@@ -1990,7 +2010,7 @@ namespace Robust.Client.GameObjects
                 if (!Visible || Blank)
                     return;
 
-                var dir = _actualState == null ? RsiDirection.South : GetDirection(_actualState.RsiDirections, angle);
+                var dir = _actualState == null ? RSIDirection.South : GetDirection(_actualState.Directions, angle);
 
                 // Set the drawing transform for this layer
                 GetLayerDrawMatrix(dir, out var layerMatrix);
@@ -2000,7 +2020,7 @@ namespace Robust.Client.GameObjects
                 // The direction used to draw the sprite can differ from the one that the angle would naively suggest,
                 // due to direction overrides or offsets.
                 if (overrideDirection != null && _actualState != null)
-                    dir = overrideDirection.Value.Convert(_actualState.RsiDirections);
+                    dir = overrideDirection.Value.Convert(_actualState.Directions);
                 dir = dir.OffsetRsiDir(DirOffset);
 
                 // Get the correct directional texture from the state, and draw it!
@@ -2023,7 +2043,7 @@ namespace Robust.Client.GameObjects
                     drawingHandle.UseShader(null);
             }
 
-            private Texture GetRenderTexture(RSI.State? state, RsiDirection dir)
+            private Texture GetRenderTexture(RSI.State? state, RSIDirection dir)
             {
                 if (state == null)
                     return Texture ?? _parent.resourceCache.GetFallback<TextureResource>().Texture;

Robust.Client/GameObjects/Components/UserInterface/ClientUserInterfaceComponent.cs

@@ -1,17 +1,28 @@
 using System;
+using System.Collections.Generic;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Players;
+using Robust.Shared.ViewVariables;
 
-namespace Robust.Shared.GameObjects
+namespace Robust.Client.GameObjects
 {
+    [RegisterComponent, ComponentReference(typeof(SharedUserInterfaceComponent))]
+    public sealed class ClientUserInterfaceComponent : SharedUserInterfaceComponent
+    {
+        [ViewVariables]
+        internal readonly Dictionary<Enum, PrototypeData> _interfaces = new();
+
+        [ViewVariables]
+        public readonly Dictionary<Enum, BoundUserInterface> OpenInterfaces = new();
+    }
+
     /// <summary>
     ///     An abstract class to override to implement bound user interfaces.
     /// </summary>
     public abstract class BoundUserInterface : IDisposable
     {
         [Dependency] protected readonly IEntityManager EntMan = default!;
-        [Dependency] private readonly ISharedPlayerManager _playerManager = default!;
-        protected readonly SharedUserInterfaceSystem UiSystem;
+        protected readonly UserInterfaceSystem UiSystem = default!;
 
         public readonly Enum UiKey;
         public EntityUid Owner { get; }
@@ -24,7 +35,7 @@ namespace Robust.Shared.GameObjects
         protected BoundUserInterface(EntityUid owner, Enum uiKey)
         {
             IoCManager.InjectDependencies(this);
-            UiSystem = EntMan.System<SharedUserInterfaceSystem>();
+            UiSystem = EntMan.System<UserInterfaceSystem>();
 
             Owner = owner;
             UiKey = uiKey;
@@ -57,7 +68,7 @@ namespace Robust.Shared.GameObjects
         /// </summary>
         public void Close()
         {
-            UiSystem.TryCloseUi(_playerManager.LocalSession, Owner, UiKey);
+            UiSystem.TryCloseUi(Owner, UiKey);
         }
 
         /// <summary>
@@ -68,11 +79,6 @@ namespace Robust.Shared.GameObjects
             UiSystem.SendUiMessage(this, message);
         }
 
-        public void SendPredictedMessage(BoundUserInterfaceMessage message)
-        {
-            UiSystem.SendPredictedUiMessage(this, message);
-        }
-
         internal void InternalReceiveMessage(BoundUserInterfaceMessage message)
         {
             switch (message)

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -128,7 +128,7 @@ namespace Robust.Client.GameObjects
                     return;
                 }
 
-                if (IsClientSide(component.Owner) || !animatedComp.NetSyncEnabled)
+                if (component.Owner.IsClientSide() || !animatedComp.NetSyncEnabled)
                     continue;
 
                 var reg = _compFact.GetRegistration(animatedComp);

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -81,13 +81,9 @@ public sealed class AudioSystem : SharedAudioSystem
     #region Event Handlers
     private void PlayAudioEntityHandler(PlayAudioEntityMessage ev)
     {
-        var uid = GetEntity(ev.NetEntity);
-        var coords = GetCoordinates(ev.Coordinates);
-        var fallback = GetCoordinates(ev.FallbackCoordinates);
-
-        var stream = EntityManager.EntityExists(uid)
-            ? (PlayingStream?) Play(ev.FileName, uid, fallback, ev.AudioParams, false)
-            : (PlayingStream?) Play(ev.FileName, coords, fallback, ev.AudioParams, false);
+        var stream = EntityManager.EntityExists(ev.EntityUid)
+            ? (PlayingStream?) Play(ev.FileName, ev.EntityUid, ev.FallbackCoordinates, ev.AudioParams, false)
+            : (PlayingStream?) Play(ev.FileName, ev.Coordinates, ev.FallbackCoordinates, ev.AudioParams, false);
 
         if (stream != null)
             stream.NetIdentifier = ev.Identifier;
@@ -102,10 +98,7 @@ public sealed class AudioSystem : SharedAudioSystem
 
     private void PlayAudioPositionalHandler(PlayAudioPositionalMessage ev)
     {
-        var coords = GetCoordinates(ev.Coordinates);
-        var fallback = GetCoordinates(ev.FallbackCoordinates);
-
-        var stream = (PlayingStream?) Play(ev.FileName, coords, fallback, ev.AudioParams, false);
+        var stream = (PlayingStream?) Play(ev.FileName, ev.Coordinates, ev.FallbackCoordinates, ev.AudioParams, false);
         if (stream != null)
             stream.NetIdentifier = ev.Identifier;
     }
@@ -321,9 +314,9 @@ public sealed class AudioSystem : SharedAudioSystem
         return source != null;
     }
 
-    private PlayingStream CreateAndStartPlayingStream(IClydeAudioSource source, AudioParams? audioParams, AudioStream stream)
+    private PlayingStream CreateAndStartPlayingStream(IClydeAudioSource source, AudioParams? audioParams)
     {
-        ApplyAudioParams(audioParams, source, stream);
+        ApplyAudioParams(audioParams, source);
         source.StartPlaying();
         var playing = new PlayingStream
         {
@@ -372,7 +365,7 @@ public sealed class AudioSystem : SharedAudioSystem
 
         source.SetGlobal();
 
-        return CreateAndStartPlayingStream(source, audioParams, stream);
+        return CreateAndStartPlayingStream(source, audioParams);
     }
 
     /// <summary>
@@ -390,8 +383,8 @@ public sealed class AudioSystem : SharedAudioSystem
             _replayRecording.RecordReplayMessage(new PlayAudioEntityMessage
             {
                 FileName = filename,
-                NetEntity = GetNetEntity(entity),
-                FallbackCoordinates = GetNetCoordinates(fallbackCoordinates) ?? default,
+                EntityUid = entity,
+                FallbackCoordinates = fallbackCoordinates ?? default,
                 AudioParams = audioParams ?? AudioParams.Default
             });
         }
@@ -423,7 +416,7 @@ public sealed class AudioSystem : SharedAudioSystem
         if (!source.SetPosition(worldPos))
             return Play(stream, fallbackCoordinates.Value, fallbackCoordinates.Value, audioParams);
 
-        var playing = CreateAndStartPlayingStream(source, audioParams, stream);
+        var playing = CreateAndStartPlayingStream(source, audioParams);
         playing.TrackingEntity = entity;
         playing.TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null;
         return playing;
@@ -444,8 +437,8 @@ public sealed class AudioSystem : SharedAudioSystem
             _replayRecording.RecordReplayMessage(new PlayAudioPositionalMessage
             {
                 FileName = filename,
-                Coordinates = GetNetCoordinates(coordinates),
-                FallbackCoordinates = GetNetCoordinates(fallbackCoordinates),
+                Coordinates = coordinates,
+                FallbackCoordinates = fallbackCoordinates,
                 AudioParams = audioParams ?? AudioParams.Default
             });
         }
@@ -476,7 +469,7 @@ public sealed class AudioSystem : SharedAudioSystem
             return null;
         }
 
-        var playing = CreateAndStartPlayingStream(source, audioParams, stream);
+        var playing = CreateAndStartPlayingStream(source, audioParams);
         playing.TrackingCoordinates = coordinates;
         playing.TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null;
         return playing;
@@ -500,7 +493,7 @@ public sealed class AudioSystem : SharedAudioSystem
         return null;
     }
 
-    private void ApplyAudioParams(AudioParams? audioParams, IClydeAudioSource source, AudioStream audio)
+    private void ApplyAudioParams(AudioParams? audioParams, IClydeAudioSource source)
     {
         if (!audioParams.HasValue)
             return;
@@ -515,12 +508,8 @@ public sealed class AudioSystem : SharedAudioSystem
         source.SetRolloffFactor(audioParams.Value.RolloffFactor);
         source.SetMaxDistance(audioParams.Value.MaxDistance);
         source.SetReferenceDistance(audioParams.Value.ReferenceDistance);
+        source.SetPlaybackPosition(audioParams.Value.PlayOffsetSeconds);
         source.IsLooping = audioParams.Value.Loop;
-
-        // TODO clamp the offset inside of SetPlaybackPosition() itself.
-        var offset = audioParams.Value.PlayOffsetSeconds;
-        offset = Math.Clamp(offset, 0f, (float) audio.Length.TotalSeconds);
-        source.SetPlaybackPosition(offset);
     }
 
     public sealed class PlayingStream : IPlayingAudioStream

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -40,7 +40,7 @@ internal sealed class ClientOccluderSystem : OccluderSystem
             return;
 
         comp.Enabled = enabled;
-        Dirty(uid, comp);
+        Dirty(comp);
 
         var xform = Transform(uid);
         QueueTreeUpdate(uid, comp, xform);

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -1,4 +1,3 @@
-using System;
 using Robust.Shared.Collections;
 using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
@@ -6,11 +5,13 @@ using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using Robust.Shared.Serialization;
+using Robust.Shared.Physics.Components;
 using static Robust.Shared.Containers.ContainerManagerComponent;
 
 namespace Robust.Client.GameObjects
@@ -22,20 +23,14 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IDynamicTypeFactoryInternal _dynFactory = default!;
         [Dependency] private readonly PointLightSystem _lightSys = default!;
 
-        private EntityQuery<PointLightComponent> _pointLightQuery;
-        private EntityQuery<SpriteComponent> _spriteQuery;
-
         private readonly HashSet<EntityUid> _updateQueue = new();
 
-        public readonly Dictionary<NetEntity, BaseContainer> ExpectedEntities = new();
+        public readonly Dictionary<EntityUid, IContainer> ExpectedEntities = new();
 
         public override void Initialize()
         {
             base.Initialize();
 
-            _pointLightQuery = GetEntityQuery<PointLightComponent>();
-            _spriteQuery = GetEntityQuery<SpriteComponent>();
-
             EntityManager.EntityInitialized += HandleEntityInitialized;
             SubscribeLocalEvent<ContainerManagerComponent, ComponentHandleState>(HandleComponentState);
 
@@ -48,18 +43,20 @@ namespace Robust.Client.GameObjects
             base.Shutdown();
         }
 
-        protected override void ValidateMissingEntity(EntityUid uid, BaseContainer cont, EntityUid missing)
+        protected override void ValidateMissingEntity(EntityUid uid, IContainer cont, EntityUid missing)
         {
-            var netEntity = GetNetEntity(missing);
-            DebugTools.Assert(ExpectedEntities.TryGetValue(netEntity, out var expectedContainer) && expectedContainer == cont && cont.ExpectedEntities.Contains(netEntity));
+            DebugTools.Assert(ExpectedEntities.TryGetValue(missing, out var expectedContainer) && expectedContainer == cont && cont.ExpectedEntities.Contains(missing));
         }
 
         private void HandleEntityInitialized(EntityUid uid)
         {
-            if (!RemoveExpectedEntity(GetNetEntity(uid), out var container))
+            if (!RemoveExpectedEntity(uid, out var container))
                 return;
 
-            container.Insert(uid, EntityManager, transform: TransformQuery.GetComponent(uid), meta: MetaQuery.GetComponent(uid));
+            if (container.Deleted)
+                return;
+
+            container.Insert(uid);
         }
 
         private void HandleComponentState(EntityUid uid, ContainerManagerComponent component, ref ComponentHandleState args)
@@ -67,24 +64,23 @@ namespace Robust.Client.GameObjects
             if (args.Current is not ContainerManagerComponentState cast)
                 return;
 
-            var xform = TransformQuery.GetComponent(uid);
+            var metaQuery = GetEntityQuery<MetaDataComponent>();
+            var xformQuery = GetEntityQuery<TransformComponent>();
+            var xform = xformQuery.GetComponent(uid);
 
             // Delete now-gone containers.
             var toDelete = new ValueList<string>();
             foreach (var (id, container) in component.Containers)
             {
                 if (cast.Containers.ContainsKey(id))
-                {
-                    DebugTools.Assert(cast.Containers[id].ContainerType == container.GetType().Name);
                     continue;
-                }
 
                 foreach (var entity in container.ContainedEntities.ToArray())
                 {
                     container.Remove(entity,
                         EntityManager,
-                        TransformQuery.GetComponent(entity),
-                        MetaQuery.GetComponent(entity),
+                        xformQuery.GetComponent(entity),
+                        metaQuery.GetComponent(entity),
                         force: true,
                         reparent: false);
 
@@ -102,32 +98,26 @@ namespace Robust.Client.GameObjects
 
             // Add new containers and update existing contents.
 
-            foreach (var (id, data) in cast.Containers)
+            foreach (var (containerType, id, showEnts, occludesLight, entityUids) in cast.Containers.Values)
             {
                 if (!component.Containers.TryGetValue(id, out var container))
                 {
-                    var type = _serializer.FindSerializedType(typeof(BaseContainer), data.ContainerType);
-                    container = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type!, inject:false);
-                    container.Init(id, uid, component);
+                    container = ContainerFactory(component, containerType, id);
                     component.Containers.Add(id, container);
                 }
 
-                DebugTools.Assert(container.ID == id);
-                container.ShowContents = data.ShowContents;
-                container.OccludesLight = data.OccludesLight;
+                // sync show flag
+                container.ShowContents = showEnts;
+                container.OccludesLight = occludesLight;
 
                 // Remove gone entities.
                 var toRemove = new ValueList<EntityUid>();
-
-                DebugTools.Assert(!container.Contains(EntityUid.Invalid));
-
-                var stateNetEnts = data.ContainedEntities;
-                var stateEnts = GetEntityArray(stateNetEnts); // No need to ensure entities.
-
                 foreach (var entity in container.ContainedEntities)
                 {
-                    if (!stateEnts.Contains(entity))
+                    if (!entityUids.Contains(entity))
+                    {
                         toRemove.Add(entity);
+                    }
                 }
 
                 foreach (var entity in toRemove)
@@ -135,8 +125,8 @@ namespace Robust.Client.GameObjects
                     container.Remove(
                         entity,
                         EntityManager,
-                        TransformQuery.GetComponent(entity),
-                        MetaQuery.GetComponent(entity),
+                        xformQuery.GetComponent(entity),
+                        metaQuery.GetComponent(entity),
                         force: true,
                         reparent: false);
 
@@ -144,11 +134,13 @@ namespace Robust.Client.GameObjects
                 }
 
                 // Remove entities that were expected, but have been removed from the container.
-                var removedExpected = new ValueList<NetEntity>();
-                foreach (var netEntity in container.ExpectedEntities)
+                var removedExpected = new ValueList<EntityUid>();
+                foreach (var entityUid in container.ExpectedEntities)
                 {
-                    if (!stateNetEnts.Contains(netEntity))
-                        removedExpected.Add(netEntity);
+                    if (!entityUids.Contains(entityUid))
+                    {
+                        removedExpected.Add(entityUid);
+                    }
                 }
 
                 foreach (var entityUid in removedExpected)
@@ -157,20 +149,14 @@ namespace Robust.Client.GameObjects
                 }
 
                 // Add new entities.
-                for (var i = 0; i < stateNetEnts.Length; i++)
+                foreach (var entity in entityUids)
                 {
-                    var entity = stateEnts[i];
-                    var netEnt = stateNetEnts[i];
-                    if (!entity.IsValid())
+                    if (!EntityManager.TryGetComponent(entity, out MetaDataComponent? meta))
                     {
-                        DebugTools.Assert(netEnt.IsValid());
-                        AddExpectedEntity(netEnt, container);
+                        AddExpectedEntity(entity, container);
                         continue;
                     }
 
-                    var meta = MetaData(entity);
-                    DebugTools.Assert(meta.NetEntity == netEnt);
-
                     // If an entity is currently in the shadow realm, it means we probably left PVS and are now getting
                     // back into range. We do not want to directly insert this entity, as IF the container and entity
                     // transform states did not get sent simultaneously, the entity's transform will be modified by the
@@ -180,18 +166,18 @@ namespace Robust.Client.GameObjects
                     // containers/players.
                     if ((meta.Flags & MetaDataFlags.Detached) != 0)
                     {
-                        AddExpectedEntity(netEnt, container);
+                        AddExpectedEntity(entity, container);
                         continue;
                     }
 
                     if (container.Contains(entity))
                         continue;
 
-                    RemoveExpectedEntity(netEnt, out _);
+                    RemoveExpectedEntity(entity, out _);
                     container.Insert(entity, EntityManager,
-                        TransformQuery.GetComponent(entity),
+                        xformQuery.GetComponent(entity),
                         xform,
-                        MetaQuery.GetComponent(entity),
+                        metaQuery.GetComponent(entity),
                         force: true);
 
                     DebugTools.Assert(container.Contains(entity));
@@ -212,7 +198,7 @@ namespace Robust.Client.GameObjects
             if (message.OldParent != null && message.OldParent.Value.IsValid())
                 return;
 
-            if (!RemoveExpectedEntity(GetNetEntity(message.Entity), out var container))
+            if (!RemoveExpectedEntity(message.Entity, out var container))
                 return;
 
             if (xform.ParentUid != container.Owner)
@@ -222,69 +208,84 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
+            if (container.Deleted)
+                return;
+
             container.Insert(message.Entity, EntityManager);
         }
 
-        public void AddExpectedEntity(NetEntity netEntity, BaseContainer container)
+        private IContainer ContainerFactory(ContainerManagerComponent component, string containerType, string id)
         {
-#if DEBUG
-            var uid = GetEntity(netEntity);
+            var type = _serializer.FindSerializedType(typeof(IContainer), containerType);
+            if (type is null) throw new ArgumentException($"Container of type {containerType} for id {id} cannot be found.");
 
-            if (TryComp<MetaDataComponent>(uid, out var meta))
-            {
-                DebugTools.Assert((meta.Flags & ( MetaDataFlags.Detached | MetaDataFlags.InContainer) ) == MetaDataFlags.Detached,
-                    $"Adding entity {ToPrettyString(uid)} to list of expected entities for container {container.ID} in {ToPrettyString(container.Owner)}, despite it already being in a container.");
-            }
-#endif
+            var newContainer = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type);
+            newContainer.ID = id;
+            newContainer.Manager = component;
+            return newContainer;
+        }
 
-            if (!ExpectedEntities.TryAdd(netEntity, container))
+        public void AddExpectedEntity(EntityUid uid, IContainer container)
+        {
+            DebugTools.Assert(!TryComp(uid, out MetaDataComponent? meta) ||
+                (meta.Flags & ( MetaDataFlags.Detached | MetaDataFlags.InContainer) ) == MetaDataFlags.Detached,
+                $"Adding entity {ToPrettyString(uid)} to list of expected entities for container {container.ID} in {ToPrettyString(container.Owner)}, despite it already being in a container.");
+
+            if (!ExpectedEntities.TryAdd(uid, container))
             {
                 // It is possible that we were expecting this entity in one container, but it has now moved to another
                 // container, and this entity's state is just being applied before the old container is getting updated.
-                var oldContainer = ExpectedEntities[netEntity];
-                ExpectedEntities[netEntity] = container;
-                DebugTools.Assert(oldContainer.ExpectedEntities.Contains(netEntity),
-                    $"Entity {netEntity} is expected, but not expected in the given container? Container: {oldContainer.ID} in {ToPrettyString(oldContainer.Owner)}");
-                oldContainer.ExpectedEntities.Remove(netEntity);
+                var oldContainer = ExpectedEntities[uid];
+                ExpectedEntities[uid] = container;
+                DebugTools.Assert(oldContainer.ExpectedEntities.Contains(uid),
+                    $"Entity {ToPrettyString(uid)} is expected, but not expected in the given container? Container: {oldContainer.ID} in {ToPrettyString(oldContainer.Owner)}");
+                oldContainer.ExpectedEntities.Remove(uid);
             }
 
-            DebugTools.Assert(!container.ExpectedEntities.Contains(netEntity),
-                $"Contained entity {netEntity} was not yet expected by the system, but was already expected by the container: {container.ID} in {ToPrettyString(container.Owner)}");
-            container.ExpectedEntities.Add(netEntity);
+            DebugTools.Assert(!container.ExpectedEntities.Contains(uid),
+                $"Contained entity {ToPrettyString(uid)} was not yet expected by the system, but was already expected by the container: {container.ID} in {ToPrettyString(container.Owner)}");
+            container.ExpectedEntities.Add(uid);
         }
 
-        public bool RemoveExpectedEntity(NetEntity netEntity, [NotNullWhen(true)] out BaseContainer? container)
+        public bool RemoveExpectedEntity(EntityUid uid, [NotNullWhen(true)] out IContainer? container)
         {
-            if (!ExpectedEntities.Remove(netEntity, out container))
+            if (!ExpectedEntities.Remove(uid, out container))
                 return false;
 
-            DebugTools.Assert(container.ExpectedEntities.Contains(netEntity),
-                $"While removing expected contained entity {ToPrettyString(netEntity)}, the entity was missing from the container expected set. Container: {container.ID} in {ToPrettyString(container.Owner)}");
-            container.ExpectedEntities.Remove(netEntity);
+            DebugTools.Assert(container.ExpectedEntities.Contains(uid),
+                $"While removing expected contained entity {ToPrettyString(uid)}, the entity was missing from the container expected set. Container: {container.ID} in {ToPrettyString(container.Owner)}");
+            container.ExpectedEntities.Remove(uid);
             return true;
         }
 
         public override void FrameUpdate(float frameTime)
         {
             base.FrameUpdate(frameTime);
+            var pointQuery = EntityManager.GetEntityQuery<PointLightComponent>();
+            var spriteQuery = EntityManager.GetEntityQuery<SpriteComponent>();
+            var xformQuery = EntityManager.GetEntityQuery<TransformComponent>();
 
             foreach (var toUpdate in _updateQueue)
             {
                 if (Deleted(toUpdate))
                     continue;
 
-                UpdateEntityRecursively(toUpdate);
+                UpdateEntityRecursively(toUpdate, xformQuery, pointQuery, spriteQuery);
             }
 
             _updateQueue.Clear();
         }
 
-        private void UpdateEntityRecursively(EntityUid entity)
+        private void UpdateEntityRecursively(
+            EntityUid entity,
+            EntityQuery<TransformComponent> xformQuery,
+            EntityQuery<PointLightComponent> pointQuery,
+            EntityQuery<SpriteComponent> spriteQuery)
         {
             // Recursively go up parents and containers to see whether both sprites and lights need to be occluded
             // Could maybe optimise this more by checking nearest parent that has sprite / light and whether it's container
             // occluded but this probably isn't a big perf issue.
-            var xform = TransformQuery.GetComponent(entity);
+            var xform = xformQuery.GetComponent(entity);
             var parent = xform.ParentUid;
             var child = entity;
             var spriteOccluded = false;
@@ -292,7 +293,7 @@ namespace Robust.Client.GameObjects
 
             while (parent.IsValid() && (!spriteOccluded || !lightOccluded))
             {
-                var parentXform = TransformQuery.GetComponent(parent);
+                var parentXform = xformQuery.GetComponent(parent);
                 if (TryComp<ContainerManagerComponent>(parent, out var manager) && manager.TryGetContainer(child, out var container))
                 {
                     spriteOccluded = spriteOccluded || !container.ShowContents;
@@ -307,21 +308,24 @@ namespace Robust.Client.GameObjects
             // This is the CBT bit.
             // The issue is we need to go through the children and re-check whether they are or are not contained.
             // if they are contained then the occlusion values may need updating for all those children
-            UpdateEntity(entity, xform, spriteOccluded, lightOccluded);
+            UpdateEntity(entity, xform, xformQuery, pointQuery, spriteQuery, spriteOccluded, lightOccluded);
         }
 
         private void UpdateEntity(
             EntityUid entity,
             TransformComponent xform,
+            EntityQuery<TransformComponent> xformQuery,
+            EntityQuery<PointLightComponent> pointQuery,
+            EntityQuery<SpriteComponent> spriteQuery,
             bool spriteOccluded,
             bool lightOccluded)
         {
-            if (_spriteQuery.TryGetComponent(entity, out var sprite))
+            if (spriteQuery.TryGetComponent(entity, out var sprite))
             {
                 sprite.ContainerOccluded = spriteOccluded;
             }
 
-            if (_pointLightQuery.TryGetComponent(entity, out var light))
+            if (pointQuery.TryGetComponent(entity, out var light))
                 _lightSys.SetContainerOccluded(entity, lightOccluded, light);
 
             var childEnumerator = xform.ChildEnumerator;
@@ -342,14 +346,14 @@ namespace Robust.Client.GameObjects
                         childLightOccluded = childLightOccluded || container.OccludesLight;
                     }
 
-                    UpdateEntity(child.Value, TransformQuery.GetComponent(child.Value), childSpriteOccluded, childLightOccluded);
+                    UpdateEntity(child.Value, xformQuery.GetComponent(child.Value), xformQuery, pointQuery, spriteQuery, childSpriteOccluded, childLightOccluded);
                 }
             }
             else
             {
                 while (childEnumerator.MoveNext(out var child))
                 {
-                    UpdateEntity(child.Value, TransformQuery.GetComponent(child.Value), spriteOccluded, lightOccluded);
+                    UpdateEntity(child.Value, xformQuery.GetComponent(child.Value), xformQuery, pointQuery, spriteQuery, spriteOccluded, lightOccluded);
                 }
             }
         }

Robust.Client/GameObjects/EntitySystems/DebugEntityLookupSystem.cs

@@ -38,8 +38,7 @@ public sealed class DebugEntityLookupSystem : EntitySystem
                 IoCManager.Resolve<IOverlayManager>().AddOverlay(
                     new EntityLookupOverlay(
                         EntityManager,
-                        EntityManager.System<EntityLookupSystem>(),
-                        EntityManager.System<SharedTransformSystem>()));
+                        Get<EntityLookupSystem>()));
             }
             else
             {
@@ -53,35 +52,31 @@ public sealed class DebugEntityLookupSystem : EntitySystem
 
 public sealed class EntityLookupOverlay : Overlay
 {
-    private readonly IEntityManager _entityManager;
-    private readonly EntityLookupSystem _lookup;
-    private readonly SharedTransformSystem _transform;
-
-    private EntityQuery<TransformComponent> _xformQuery;
+    private IEntityManager _entityManager = default!;
+    private EntityLookupSystem _lookup = default!;
 
     public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-    public EntityLookupOverlay(IEntityManager entManager, EntityLookupSystem lookup, SharedTransformSystem transform)
+    public EntityLookupOverlay(IEntityManager entManager, EntityLookupSystem lookup)
     {
         _entityManager = entManager;
         _lookup = lookup;
-        _xformQuery = entManager.GetEntityQuery<TransformComponent>();
-        _transform = transform;
     }
 
     protected internal override void Draw(in OverlayDrawArgs args)
     {
         var worldHandle = args.WorldHandle;
-        var worldBounds = args.WorldBounds;
+        var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
 
-        // TODO: Static version
-        _lookup.FindLookupsIntersecting(args.MapId, worldBounds, (uid, lookup) =>
+        foreach (var lookup in _lookup.FindLookupsIntersecting(args.MapId, args.WorldBounds))
         {
-            var (_, rotation, matrix, invMatrix) = _transform.GetWorldPositionRotationMatrixWithInv(uid);
+            var lookupXform = xformQuery.GetComponent(lookup.Owner);
+
+            var (_, rotation, matrix, invMatrix) = lookupXform.GetWorldPositionRotationMatrixWithInv();
 
             worldHandle.SetTransform(matrix);
 
-            var lookupAABB = invMatrix.TransformBox(worldBounds);
+            var lookupAABB = invMatrix.TransformBox(args.WorldBounds);
             var ents = new List<EntityUid>();
 
             lookup.DynamicTree.QueryAabb(ref ents, static (ref List<EntityUid> state, in FixtureProxy value) =>
@@ -110,22 +105,20 @@ public sealed class EntityLookupOverlay : Overlay
 
             foreach (var ent in ents)
             {
-                if (_entityManager.Deleted(ent))
-                    continue;
-
-                var xform = _xformQuery.GetComponent(ent);
+                if (_entityManager.Deleted(ent)) continue;
+                var xform = xformQuery.GetComponent(ent);
 
                 //DebugTools.Assert(!ent.IsInContainer(_entityManager));
-                var (entPos, entRot) = _transform.GetWorldPositionRotation(ent);
+                var (entPos, entRot) = xform.GetWorldPositionRotation();
 
                 var lookupPos = invMatrix.Transform(entPos);
                 var lookupRot = entRot - rotation;
 
-                var aabb = _lookup.GetAABB(ent, lookupPos, lookupRot, xform, _xformQuery);
+                var aabb = _lookup.GetAABB(ent, lookupPos, lookupRot, xform, xformQuery);
 
                 worldHandle.DrawRect(aabb, Color.Blue.WithAlpha(0.2f));
             }
-        });
+        }
 
         worldHandle.SetTransform(Matrix3.Identity);
     }

Robust.Client/GameObjects/EntitySystems/EyeSystem.cs

@@ -1,85 +0,0 @@
-using Robust.Client.Graphics;
-using Robust.Client.Physics;
-using Robust.Shared.GameObjects;
-using Robust.Shared.GameStates;
-using Robust.Shared.Graphics;
-using Robust.Shared.IoC;
-
-namespace Robust.Client.GameObjects;
-
-public sealed class EyeSystem : SharedEyeSystem
-{
-    [Dependency] private readonly IEyeManager _eyeManager = default!;
-
-    public override void Initialize()
-    {
-        base.Initialize();
-        SubscribeLocalEvent<EyeComponent, ComponentInit>(OnInit);
-        SubscribeLocalEvent<EyeComponent, PlayerDetachedEvent>(OnEyeDetached);
-        SubscribeLocalEvent<EyeComponent, PlayerAttachedEvent>(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 OnEyeAutoState(EntityUid uid, EyeComponent component, ref AfterAutoHandleStateEvent args)
-    {
-        UpdateEye(component);
-    }
-
-    private void OnEyeAttached(EntityUid uid, EyeComponent component, PlayerAttachedEvent args)
-    {
-        // TODO: This probably shouldn't be nullable bruv.
-        if (component._eye != null)
-        {
-            _eyeManager.CurrentEye = component._eye;
-        }
-
-        var ev = new EyeAttachedEvent(uid, component);
-        RaiseLocalEvent(uid, ref ev, true);
-    }
-
-    private void OnEyeDetached(EntityUid uid, EyeComponent component, PlayerDetachedEvent args)
-    {
-        _eyeManager.ClearCurrentEye();
-    }
-
-    private void OnInit(EntityUid uid, EyeComponent component, ComponentInit args)
-    {
-        component._eye = new Eye
-        {
-            Position = Transform(uid).MapPosition,
-            Zoom = component.Zoom,
-            DrawFov = component.DrawFov,
-            Rotation = component.Rotation,
-        };
-    }
-
-    /// <inheritdoc />
-    public override void FrameUpdate(float frameTime)
-    {
-        var query = AllEntityQuery<EyeComponent>();
-
-        while (query.MoveNext(out var uid, out var eyeComponent))
-        {
-            if (eyeComponent._eye == null)
-                continue;
-
-            if (!TryComp<TransformComponent>(eyeComponent.Target, out var xform))
-            {
-                xform = Transform(uid);
-                eyeComponent.Target = null;
-            }
-
-            eyeComponent._eye.Position = xform.MapPosition;
-        }
-    }
-}
-
-/// <summary>
-/// Raised on an entity when it is attached to one with an <see cref="EyeComponent"/>
-/// </summary>
-[ByRefEvent]
-public readonly record struct EyeAttachedEvent(EntityUid Entity, EyeComponent Component);

Robust.Client/GameObjects/EntitySystems/EyeUpdateSystem.cs

@@ -0,0 +1,43 @@
+using System;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Client.Physics;
+using Robust.Client.Player;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Input;
+using Robust.Shared.Input.Binding;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Timing;
+
+#nullable enable
+
+namespace Robust.Client.GameObjects
+{
+    /// <summary>
+    /// Updates the position of every Eye every frame, so that the camera follows the player around.
+    /// </summary>
+    [UsedImplicitly]
+    public sealed class EyeUpdateSystem : EntitySystem
+    {
+        /// <inheritdoc />
+        public override void Initialize()
+        {
+            base.Initialize();
+            // Make sure this runs *after* entities have been moved by interpolation and movement.
+            UpdatesAfter.Add(typeof(TransformSystem));
+            UpdatesAfter.Add(typeof(PhysicsSystem));
+        }
+
+        /// <inheritdoc />
+        public override void FrameUpdate(float frameTime)
+        {
+            foreach (var eyeComponent in EntityManager.EntityQuery<EyeComponent>(true))
+            {
+                eyeComponent.UpdateEyePosition();
+            }
+        }
+    }
+}

Robust.Client/GameObjects/EntitySystems/GridChunkBoundsDebugSystem.cs

@@ -81,7 +81,7 @@ namespace Robust.Client.GameObjects
 
                 while (chunkEnumerator.MoveNext(out var chunk))
                 {
-                    foreach (var fixture in chunk.Fixtures.Values)
+                    foreach (var fixture in chunk.Fixtures)
                     {
                         var poly = (PolygonShape) fixture.Shape;
 

Robust.Client/GameObjects/EntitySystems/GridRenderingSystem.cs

@@ -16,9 +16,4 @@ internal sealed class GridRenderingSystem : EntitySystem
     {
         _clyde.RegisterGridEcsEvents();
     }
-
-    public override void Shutdown()
-    {
-        _clyde.ShutdownGridEcsEvents();
-    }
 }

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -52,7 +52,7 @@ namespace Robust.Client.GameObjects
         /// <param name="message">Arguments for this event.</param>
         /// <param name="replay">if true, current cmd state will not be checked or updated - use this for "replaying" an
         /// old input that was saved or buffered until further processing could be done</param>
-        public bool HandleInputCommand(ICommonSession? session, BoundKeyFunction function, IFullInputCmdMessage message, bool replay = false)
+        public bool HandleInputCommand(ICommonSession? session, BoundKeyFunction function, FullInputCmdMessage message, bool replay = false)
         {
             #if DEBUG
 
@@ -78,27 +78,14 @@ namespace Robust.Client.GameObjects
                     continue;
 
                 // local handlers can block sending over the network.
-                if (handler.HandleCmdMessage(EntityManager, session, message))
+                if (handler.HandleCmdMessage(session, message))
                 {
                     return true;
                 }
             }
 
             // send it off to the server
-            var clientMsg = (ClientFullInputCmdMessage)message;
-            var fullMsg = new FullInputCmdMessage(
-                clientMsg.Tick,
-                clientMsg.SubTick,
-                (int)clientMsg.InputSequence,
-                clientMsg.InputFunctionId,
-                clientMsg.State,
-                GetNetCoordinates(clientMsg.Coordinates),
-                clientMsg.ScreenCoordinates)
-            {
-                Uid = GetNetEntity(clientMsg.Uid)
-            };
-
-            DispatchInputCommand(clientMsg, fullMsg);
+            DispatchInputCommand(message);
             return false;
         }
 
@@ -106,7 +93,7 @@ namespace Robust.Client.GameObjects
         /// Handle a predicted input command.
         /// </summary>
         /// <param name="inputCmd">Input command to handle as predicted.</param>
-        public void PredictInputCommand(IFullInputCmdMessage inputCmd)
+        public void PredictInputCommand(FullInputCmdMessage inputCmd)
         {
             DebugTools.AssertNotNull(_playerManager.LocalPlayer);
 
@@ -116,16 +103,15 @@ namespace Robust.Client.GameObjects
             var session = _playerManager.LocalPlayer!.Session;
             foreach (var handler in BindRegistry.GetHandlers(keyFunc))
             {
-                if (handler.HandleCmdMessage(EntityManager, session, inputCmd))
-                    break;
+                if (handler.HandleCmdMessage(session, inputCmd)) break;
             }
             Predicted = false;
 
         }
 
-        private void DispatchInputCommand(ClientFullInputCmdMessage clientMsg, FullInputCmdMessage message)
+        private void DispatchInputCommand(FullInputCmdMessage message)
         {
-            _stateManager.InputCommandDispatched(clientMsg, message);
+            _stateManager.InputCommandDispatched(message);
             EntityManager.EntityNetManager?.SendSystemNetworkMessage(message, message.InputSequence);
         }
 
@@ -166,7 +152,7 @@ namespace Robust.Client.GameObjects
             var funcId = _inputManager.NetworkBindMap.KeyFunctionID(keyFunction);
 
             var message = new FullInputCmdMessage(_timing.CurTick, _timing.TickFraction, funcId, state,
-                GetNetCoordinates(coords), new ScreenCoordinates(0, 0, default), NetEntity.Invalid);
+                coords, new ScreenCoordinates(0, 0, default), EntityUid.Invalid);
 
             HandleInputCommand(localPlayer.Session, keyFunction, message);
         }
@@ -220,10 +206,8 @@ namespace Robust.Client.GameObjects
             SetEntityContextActive(_inputManager, controlled);
         }
 
-        protected override void PostInject()
+        void IPostInjectInit.PostInject()
         {
-            base.PostInject();
-
             _sawmillInputContext = _logManager.GetSawmill("input.context");
         }
     }

Robust.Client/GameObjects/EntitySystems/PointLightSystem.cs

@@ -1,8 +1,6 @@
-using System.Diagnostics.CodeAnalysis;
 using Robust.Client.ComponentTrees;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 
@@ -17,108 +15,59 @@ namespace Robust.Client.GameObjects
         {
             base.Initialize();
             SubscribeLocalEvent<PointLightComponent, ComponentInit>(HandleInit);
-            SubscribeLocalEvent<PointLightComponent, ComponentHandleState>(OnLightHandleState);
-        }
-
-        private void OnLightHandleState(EntityUid uid, PointLightComponent component, ref ComponentHandleState args)
-        {
-            if (args.Current is not PointLightComponentState state)
-                return;
-
-            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)
-        {
-            return EnsureComp<PointLightComponent>(uid);
-        }
-
-        public override bool ResolveLight(EntityUid uid, [NotNullWhen(true)] ref SharedPointLightComponent? component)
-        {
-            if (component is not null)
-                return true;
-
-            TryComp<PointLightComponent>(uid, out var comp);
-            component = comp;
-            return component != null;
-        }
-
-        public override bool TryGetLight(EntityUid uid, [NotNullWhen(true)] out SharedPointLightComponent? component)
-        {
-            if (TryComp<PointLightComponent>(uid, out var comp))
-            {
-                component = comp;
-                return true;
-            }
-
-            component = null;
-            return false;
-        }
-
-        public override bool RemoveLightDeferred(EntityUid uid)
-        {
-            return RemCompDeferred<PointLightComponent>(uid);
         }
 
         private void HandleInit(EntityUid uid, PointLightComponent component, ComponentInit args)
         {
-            SetMask(component.MaskPath, component);
+            UpdateMask(component);
         }
 
-        public void SetMask(string? maskPath, PointLightComponent component)
+        internal void UpdateMask(PointLightComponent component)
         {
-            if (maskPath is not null)
-                component.Mask = _resourceCache.GetResource<TextureResource>(maskPath);
+            if (component._maskPath is not null)
+                component.Mask = _resourceCache.GetResource<TextureResource>(component._maskPath);
             else
                 component.Mask = null;
         }
 
         #region Setters
-
-        public void SetContainerOccluded(EntityUid uid, bool occluded, SharedPointLightComponent? comp = null)
+        public void SetContainerOccluded(EntityUid uid, bool occluded, PointLightComponent? comp = null)
         {
-            if (!ResolveLight(uid, ref comp) || occluded == comp.ContainerOccluded || comp is not PointLightComponent clientComp)
+            if (!Resolve(uid, ref comp) || occluded == comp.ContainerOccluded)
                 return;
 
             comp.ContainerOccluded = occluded;
-            Dirty(uid, comp);
+            Dirty(comp);
 
             if (comp.Enabled)
-                _lightTree.QueueTreeUpdate(uid, clientComp);
+                _lightTree.QueueTreeUpdate(uid, comp);
         }
 
         public override void SetEnabled(EntityUid uid, bool enabled, SharedPointLightComponent? comp = null)
         {
-            if (!ResolveLight(uid, ref comp) || enabled == comp.Enabled || comp is not PointLightComponent clientComp)
+            if (!Resolve(uid, ref comp) || enabled == comp.Enabled)
                 return;
 
-            comp.Enabled = enabled;
+            comp._enabled = enabled;
             RaiseLocalEvent(uid, new PointLightToggleEvent(comp.Enabled));
-            Dirty(uid, comp);
+            Dirty(comp);
 
-            if (!comp.ContainerOccluded)
-                _lightTree.QueueTreeUpdate(uid, clientComp);
+            var cast = (PointLightComponent)comp;
+            if (!cast.ContainerOccluded)
+                _lightTree.QueueTreeUpdate(uid, cast);
         }
 
         public override void SetRadius(EntityUid uid, float radius, SharedPointLightComponent? comp = null)
         {
-            if (!ResolveLight(uid, ref comp) || MathHelper.CloseToPercent(radius, comp.Radius) ||
-                comp is not PointLightComponent clientComp)
+            if (!Resolve(uid, ref comp) || MathHelper.CloseToPercent(radius, comp.Radius))
                 return;
 
-            comp.Radius = radius;
-            Dirty(uid, comp);
+            comp._radius = radius;
+            Dirty(comp);
 
-            if (clientComp.TreeUid != null)
-                _lightTree.QueueTreeUpdate(uid, clientComp);
+            var cast = (PointLightComponent)comp;
+            if (cast.TreeUid != null)
+                _lightTree.QueueTreeUpdate(uid, cast);
         }
         #endregion
     }

Robust.Client/GameObjects/EntitySystems/SpriteSystem.Specifier.cs

@@ -4,7 +4,6 @@ using JetBrains.Annotations;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Client.Utility;
-using Robust.Shared.Graphics;
 using Robust.Shared.Map;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations;

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

@@ -22,13 +22,6 @@ public sealed partial class TransformSystem
         base.SetLocalPositionNoLerp(xform, value);
     }
 
-    public override void SetLocalRotationNoLerp(TransformComponent xform, Angle angle)
-    {
-        xform.NextRotation = null;
-        xform.LerpParent = EntityUid.Invalid;
-        base.SetLocalRotationNoLerp(xform, angle);
-    }
-
     public override void SetLocalRotation(TransformComponent xform, Angle angle)
     {
         xform.PrevRotation = xform._localRotation;

Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -1,12 +1,13 @@
+using JetBrains.Annotations;
 using Robust.Client.Player;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Reflection;
 using System;
-using UserInterfaceComponent = Robust.Shared.GameObjects.UserInterfaceComponent;
 
 namespace Robust.Client.GameObjects
 {
+    [UsedImplicitly]
     public sealed class UserInterfaceSystem : SharedUserInterfaceSystem
     {
         [Dependency] private readonly IDynamicTypeFactory _dynamicTypeFactory = default!;
@@ -18,22 +19,41 @@ namespace Robust.Client.GameObjects
             base.Initialize();
 
             SubscribeNetworkEvent<BoundUIWrapMessage>(MessageReceived);
+            SubscribeLocalEvent<ClientUserInterfaceComponent, ComponentInit>(OnUserInterfaceInit);
+            SubscribeLocalEvent<ClientUserInterfaceComponent, ComponentShutdown>(OnUserInterfaceShutdown);
+        }
+
+        private void OnUserInterfaceInit(EntityUid uid, ClientUserInterfaceComponent component, ComponentInit args)
+        {
+            component._interfaces.Clear();
+
+            foreach (var data in component._interfaceData)
+            {
+                component._interfaces[data.UiKey] = data;
+            }
+        }
+
+        private void OnUserInterfaceShutdown(EntityUid uid, ClientUserInterfaceComponent component, ComponentShutdown args)
+        {
+            foreach (var bui in component.OpenInterfaces.Values)
+            {
+                bui.Dispose();
+            }
         }
 
         private void MessageReceived(BoundUIWrapMessage ev)
         {
-            var uid = GetEntity(ev.Entity);
-
-            if (!TryComp<UserInterfaceComponent>(uid, out var cmp))
+            var uid = ev.Entity;
+            if (!TryComp<ClientUserInterfaceComponent>(uid, out var cmp))
                 return;
 
             var uiKey = ev.UiKey;
             var message = ev.Message;
             // This should probably not happen at this point, but better make extra sure!
-            if (_playerManager.LocalPlayer != null)
+            if(_playerManager.LocalPlayer != null)
                 message.Session = _playerManager.LocalPlayer.Session;
 
-            message.Entity = GetNetEntity(uid);
+            message.Entity = uid;
             message.UiKey = uiKey;
 
             // Raise as object so the correct type is used.
@@ -46,7 +66,7 @@ namespace Robust.Client.GameObjects
                     break;
 
                 case CloseBoundInterfaceMessage _:
-                    TryCloseUi(message.Session, uid, uiKey, remoteCall: true, uiComp: cmp);
+                    TryCloseUi(uid, uiKey, remoteCall: true, uiComp: cmp);
                     break;
 
                 default:
@@ -57,7 +77,7 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        private bool TryOpenUi(EntityUid uid, Enum uiKey, UserInterfaceComponent? uiComp = null)
+        private bool TryOpenUi(EntityUid uid, Enum uiKey, ClientUserInterfaceComponent? uiComp = null)
         {
             if (!Resolve(uid, ref uiComp))
                 return false;
@@ -65,7 +85,7 @@ namespace Robust.Client.GameObjects
             if (uiComp.OpenInterfaces.ContainsKey(uiKey))
                 return false;
 
-            var data = uiComp.MappedInterfaceData[uiKey];
+            var data = uiComp._interfaces[uiKey];
 
             // TODO: This type should be cached, but I'm too lazy.
             var type = _reflectionManager.LooseGetType(data.ClientType);
@@ -76,13 +96,36 @@ namespace Robust.Client.GameObjects
             uiComp.OpenInterfaces[uiKey] = boundInterface;
 
             var playerSession = _playerManager.LocalPlayer?.Session;
-            if (playerSession != null)
-            {
-                uiComp.Interfaces[uiKey]._subscribedSessions.Add(playerSession);
+            if(playerSession != null)
                 RaiseLocalEvent(uid, new BoundUIOpenedEvent(uiKey, uid, playerSession), true);
-            }
 
             return true;
         }
+
+        internal bool TryCloseUi(EntityUid uid, Enum uiKey, bool remoteCall = false, ClientUserInterfaceComponent? uiComp = null)
+        {
+            if (!Resolve(uid, ref uiComp))
+                return false;
+
+            if (!uiComp.OpenInterfaces.TryGetValue(uiKey, out var boundUserInterface))
+                return false;
+
+            if (!remoteCall)
+                SendUiMessage(boundUserInterface, new CloseBoundInterfaceMessage());
+
+            uiComp.OpenInterfaces.Remove(uiKey);
+            boundUserInterface.Dispose();
+
+            var playerSession = _playerManager.LocalPlayer?.Session;
+            if(playerSession != null)
+                RaiseLocalEvent(uid, new BoundUIClosedEvent(uiKey, uid, playerSession), true);
+
+            return true;
+        }
+
+        internal void SendUiMessage(BoundUserInterface bui, BoundUserInterfaceMessage msg)
+        {
+            RaiseNetworkEvent(new BoundUIWrapMessage(bui.Owner, msg, bui.UiKey));
+        }
     }
 }

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, EntityUid uid = default);
 
         void InitializeEntity(EntityUid entity, MetaDataComponent? meta = null);
 

Robust.Client/GameStates/ClientDirtySystem.cs

@@ -1,6 +1,7 @@
 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;
@@ -14,7 +15,7 @@ public sealed class ClientDirtySystem : EntitySystem
 {
     [Dependency] private readonly IClientGameTiming _timing = default!;
     [Dependency] private readonly IComponentFactory _compFact = default!;
-
+    
     // Entities that have removed networked components
     // could pool the ushort sets, but predicted component changes are rare... soo...
     internal readonly Dictionary<EntityUid, HashSet<ushort>> RemovedComponents = new();
@@ -39,11 +40,11 @@ public sealed class ClientDirtySystem : EntitySystem
 
     private void OnTerminate(ref EntityTerminatingEvent ev)
     {
-        if (!_timing.InPrediction || IsClientSide(ev.Entity))
+        if (!_timing.InPrediction || ev.Entity.IsClientSide())
             return;
 
         // Client-side entity deletion is not supported and will cause errors.
-        Log.Error($"Predicting the deletion of a networked entity: {ToPrettyString(ev.Entity)}. Trace: {Environment.StackTrace}");
+        Logger.Error($"Predicting the deletion of a networked entity: {ToPrettyString(ev.Entity)}. Trace: {Environment.StackTrace}");
     }
 
     private void OnCompRemoved(RemovedComponentEventArgs args)
@@ -51,9 +52,8 @@ public sealed class ClientDirtySystem : EntitySystem
         if (args.Terminating)
             return;
 
-        var uid = args.BaseArgs.Owner;
         var comp = args.BaseArgs.Component;
-        if (!_timing.InPrediction || !comp.NetSyncEnabled || IsClientSide(uid, args.Meta))
+        if (!_timing.InPrediction || comp.Owner.IsClientSide() || !comp.NetSyncEnabled)
             return;
 
         // Was this component added during prediction? If yes, then there is no need to re-add it when resetting.
@@ -62,7 +62,7 @@ public sealed class ClientDirtySystem : EntitySystem
 
         var netId = _compFact.GetRegistration(comp).NetID;
         if (netId != null)
-            RemovedComponents.GetOrNew(uid).Add(netId.Value);
+            RemovedComponents.GetOrNew(comp.Owner).Add(netId.Value);
     }
 
     public void Reset()
@@ -73,7 +73,7 @@ public sealed class ClientDirtySystem : EntitySystem
 
     private void OnEntityDirty(EntityUid e)
     {
-        if (_timing.InPrediction && !IsClientSide(e))
+        if (_timing.InPrediction && !e.IsClientSide())
             DirtyEntities.Add(e);
     }
 }

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -4,7 +4,6 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using System.Runtime.InteropServices;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
 using Robust.Client.Input;
@@ -48,10 +47,8 @@ namespace Robust.Client.GameStates
                 = new();
 
         // Game state dictionaries that get used every tick.
-        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 Dictionary<EntityUid, (bool EnteringPvs, GameTick LastApplied, EntityState? curState, EntityState?nextState)> _toApply = new();
+        private readonly Dictionary<EntityUid, EntityState> _toCreate = new();
 
         private uint _metaCompNetId;
 
@@ -160,7 +157,7 @@ namespace Robust.Client.GameStates
             }
         }
 
-        public void InputCommandDispatched(ClientFullInputCmdMessage clientMessage, FullInputCmdMessage message)
+        public void InputCommandDispatched(FullInputCmdMessage message)
         {
             if (!IsPredictionEnabled)
             {
@@ -204,7 +201,7 @@ namespace Robust.Client.GameStates
         public void UpdateFullRep(GameState state, bool cloneDelta = false)
             => _processor.UpdateFullRep(state, cloneDelta);
 
-        public Dictionary<NetEntity, Dictionary<ushort, ComponentState>> GetFullRep()
+        public Dictionary<EntityUid, Dictionary<ushort, ComponentState>> GetFullRep()
             => _processor.GetFullRep();
 
         private void HandlePvsLeaveMessage(MsgStateLeavePvs message)
@@ -213,7 +210,7 @@ namespace Robust.Client.GameStates
             PvsLeave?.Invoke(message);
         }
 
-        public void QueuePvsDetach(List<NetEntity> entities, GameTick tick)
+        public void QueuePvsDetach(List<EntityUid> entities, GameTick tick)
         {
             _processor.AddLeavePvsMessage(entities, tick);
             if (_replayRecording.IsRecording)
@@ -301,7 +298,7 @@ namespace Robust.Client.GameStates
                     _processor.UpdateFullRep(curState);
                 }
 
-                IEnumerable<NetEntity> createdEntities;
+                IEnumerable<EntityUid> createdEntities;
                 using (_prof.Group("ApplyGameState"))
                 {
                     if (_timing.LastProcessedTick < targetProcessedTick && nextState != null)
@@ -326,7 +323,7 @@ namespace Robust.Client.GameStates
                     catch (MissingMetadataException e)
                     {
                         // Something has gone wrong. Probably a missing meta-data component. Perhaps a full server state will fix it.
-                        RequestFullState(e.NetEntity);
+                        RequestFullState(e.Uid);
                         throw;
                     }
 #endif
@@ -395,10 +392,10 @@ namespace Robust.Client.GameStates
             }
         }
 
-        public void RequestFullState(NetEntity? missingEntity = null)
+        public void RequestFullState(EntityUid? missingEntity = null)
         {
             _sawmill.Info("Requesting full server state");
-            _network.ClientSendMessage(new MsgStateRequestFull { Tick = _timing.LastRealTick , MissingEntity = missingEntity ?? NetEntity.Invalid });
+            _network.ClientSendMessage(new MsgStateRequestFull { Tick = _timing.LastRealTick , MissingEntity = missingEntity ?? EntityUid.Invalid });
             _processor.RequestFullState();
         }
 
@@ -475,7 +472,7 @@ namespace Robust.Client.GameStates
 
             var countReset = 0;
             var system = _entitySystemManager.GetEntitySystem<ClientDirtySystem>();
-            var metaQuery = _entityManager.GetEntityQuery<MetaDataComponent>();
+            var query = _entityManager.GetEntityQuery<MetaDataComponent>();
             RemQueue<Component> toRemove = new();
 
             // This is terrible, and I hate it.
@@ -489,8 +486,7 @@ namespace Robust.Client.GameStates
                 if (_sawmill.Level <= LogLevel.Debug)
                     _sawmill.Debug($"Entity {entity} was made dirty.");
 
-                if (!metaQuery.TryGetComponent(entity, out var meta) ||
-                    !_processor.TryGetLastServerStates(meta.NetEntity, out var last))
+                if (!_processor.TryGetLastServerStates(entity, out var last))
                 {
                     // Entity was probably deleted on the server so do nothing.
                     continue;
@@ -498,8 +494,13 @@ namespace Robust.Client.GameStates
 
                 countReset += 1;
 
-                foreach (var (netId, comp) in meta.NetComponents)
+                var netComps = _entityManager.GetNetComponentsOrNull(entity);
+                if (netComps == null)
+                    continue;
+
+                foreach (var (netId, comp) in netComps.Value)
                 {
+                    DebugTools.AssertNotNull(netId);
                     if (!comp.NetSyncEnabled)
                         continue;
 
@@ -531,6 +532,7 @@ namespace Robust.Client.GameStates
 
                     var handleState = new ComponentHandleState(compState, null);
                     _entities.EventBus.RaiseComponentEvent(comp, ref handleState);
+                    comp.HandleComponentState(compState, null);
                     comp.LastModifiedTick = _timing.LastRealTick;
                 }
 
@@ -546,24 +548,26 @@ namespace Robust.Client.GameStates
                 {
                     foreach (var netId in netIds)
                     {
-                        if (meta.NetComponents.ContainsKey(netId))
+                        if (_entities.HasComponent(entity, netId))
                             continue;
 
                         if (!last.TryGetValue(netId, out var state))
                             continue;
 
-                        var comp = _entityManager.AddComponent(entity, netId, meta);
+                        var comp = _entityManager.AddComponent(entity, netId);
 
                         if (_sawmill.Level <= LogLevel.Debug)
                             _sawmill.Debug($"  A component was removed: {comp.GetType()}");
 
                         var stateEv = new ComponentHandleState(state, null);
                         _entities.EventBus.RaiseComponentEvent(comp, ref stateEv);
+                        comp.HandleComponentState(state, null);
                         comp.ClearCreationTick(); // don't undo the re-adding.
                         comp.LastModifiedTick = _timing.LastRealTick;
                     }
                 }
 
+                var meta = query.GetComponent(entity);
                 DebugTools.Assert(meta.EntityLastModifiedTick > _timing.LastRealTick);
                 meta.EntityLastModifiedTick = _timing.LastRealTick;
             }
@@ -587,18 +591,17 @@ namespace Robust.Client.GameStates
         ///     initial server state for any newly created entity. It does this by simply using the standard <see
         ///     cref="IEntityManager.GetComponentState(IEventBus, IComponent)"/>.
         /// </remarks>
-        private void MergeImplicitData(IEnumerable<NetEntity> createdEntities)
+        private void MergeImplicitData(IEnumerable<EntityUid> createdEntities)
         {
-            var outputData = new Dictionary<NetEntity, Dictionary<ushort, ComponentState>>();
+            var outputData = new Dictionary<EntityUid, Dictionary<ushort, ComponentState>>();
             var bus = _entityManager.EventBus;
 
-            foreach (var netEntity in createdEntities)
+            foreach (var createdEntity in createdEntities)
             {
-                var (createdEntity, meta) = _entityManager.GetEntityData(netEntity);
                 var compData = new Dictionary<ushort, ComponentState>();
-                outputData.Add(netEntity, compData);
+                outputData.Add(createdEntity, compData);
 
-                foreach (var (netId, component) in meta.NetComponents)
+                foreach (var (netId, component) in _entityManager.GetNetComponents(createdEntity))
                 {
                     if (!component.NetSyncEnabled)
                         continue;
@@ -617,7 +620,7 @@ namespace Robust.Client.GameStates
             _network.ClientSendMessage(new MsgStateAck() { Sequence = sequence });
         }
 
-        public IEnumerable<NetEntity> ApplyGameState(GameState curState, GameState? nextState)
+        public IEnumerable<EntityUid> ApplyGameState(GameState curState, GameState? nextState)
         {
             using var _ = _timing.StartStateApplicationArea();
 
@@ -637,7 +640,7 @@ namespace Robust.Client.GameStates
                 _config.TickProcessMessages();
             }
 
-            (IEnumerable<NetEntity> Created, List<NetEntity> Detached) output;
+            (IEnumerable<EntityUid> Created, List<EntityUid> Detached) output;
             using (_prof.Group("Entity"))
             {
                 output = ApplyEntityStates(curState, nextState);
@@ -656,7 +659,7 @@ namespace Robust.Client.GameStates
             return output.Created;
         }
 
-        private (IEnumerable<NetEntity> Created, List<NetEntity> Detached) ApplyEntityStates(GameState curState, GameState? nextState)
+        private (IEnumerable<EntityUid> Created, List<EntityUid> Detached) ApplyEntityStates(GameState curState, GameState? nextState)
         {
             var metas = _entities.GetEntityQuery<MetaDataComponent>();
             var xforms = _entities.GetEntityQuery<TransformComponent>();
@@ -665,7 +668,6 @@ namespace Robust.Client.GameStates
             var enteringPvs = 0;
             _toApply.Clear();
             _toCreate.Clear();
-            _pendingReapplyNetStates.Clear();
             var curSpan = curState.EntityStates.Span;
 
             // Create new entities
@@ -676,42 +678,21 @@ namespace Robust.Client.GameStates
 
                 foreach (var es in curSpan)
                 {
-                    if (_entityManager.TryGetEntity(es.NetEntity, out var nUid))
-                    {
-                        DebugTools.Assert(_entityManager.EntityExists(nUid));
+                    if (metas.HasComponent(es.Uid))
                         continue;
-                    }
 
                     count++;
+                    var uid = es.Uid;
                     var metaState = (MetaDataComponentState?)es.ComponentChanges.Value?.FirstOrDefault(c => c.NetID == _metaCompNetId).State;
                     if (metaState == null)
-                        throw new MissingMetadataException(es.NetEntity);
+                        throw new MissingMetadataException(uid);
+
+                    _entities.CreateEntity(metaState.PrototypeId, uid);
+                    _toCreate.Add(uid, es);
+                    _toApply.Add(uid, (false, GameTick.Zero, es, null));
 
-                    var uid = _entities.CreateEntity(metaState.PrototypeId);
-                    _toCreate.Add(es.NetEntity, es);
                     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.
-                    // TODO NetEntity Jank: prevent the client from creating this in the first place.
-                    _entityManager.ClearNetEntity(newMeta.NetEntity);
-
-                    _entityManager.SetNetEntity(uid, es.NetEntity, newMeta);
                     newMeta.LastStateApplied = curState.ToSequence;
-
-                    // Check if there's any component states awaiting this entity.
-                    if (_entityManager.PendingNetEntityStates.TryGetValue(es.NetEntity, out var value))
-                    {
-                        foreach (var (type, owner) in value)
-                        {
-                            var pending = _pendingReapplyNetStates.GetOrNew(owner);
-                            pending.Add(type);
-                        }
-
-                        _entityManager.PendingNetEntityStates.Remove(es.NetEntity);
-                    }
                 }
 
                 _prof.WriteValue("Count", ProfData.Int32(count));
@@ -719,13 +700,10 @@ namespace Robust.Client.GameStates
 
             foreach (var es in curSpan)
             {
-                if (_toCreate.ContainsKey(es.NetEntity))
-                    continue;
-
-                var uid = _entityManager.GetEntity(es.NetEntity);
-
-                if (!metas.TryGetComponent(uid, out var meta))
+                if (!metas.TryGetComponent(es.Uid, out var meta) || _toCreate.ContainsKey(es.Uid))
+                {
                     continue;
+                }
 
                 bool isEnteringPvs = (meta.Flags & MetaDataFlags.Detached) != 0;
                 if (isEnteringPvs)
@@ -739,7 +717,7 @@ namespace Robust.Client.GameStates
                     continue;
                 }
 
-                _toApply.Add(uid, (es.NetEntity, meta, isEnteringPvs, meta.LastStateApplied, es, null));
+                _toApply.Add(es.Uid, (isEnteringPvs, meta.LastStateApplied, es, null));
                 meta.LastStateApplied = curState.ToSequence;
             }
 
@@ -753,38 +731,26 @@ namespace Robust.Client.GameStates
             {
                 foreach (var es in nextState.EntityStates.Span)
                 {
-                    if (!_entityManager.TryGetEntityData(es.NetEntity, out var uid, out var meta))
+                    var uid = es.Uid;
+
+                    if (!metas.TryGetComponent(uid, out var meta))
                         continue;
 
                     // Does the next state actually have any future information about this entity that could be used for interpolation?
                     if (es.EntityLastModified != nextState.ToSequence)
                         continue;
 
-                    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);
+                    if (_toApply.TryGetValue(uid, out var state))
+                        _toApply[uid] = (state.EnteringPvs, state.LastApplied, state.curState, es);
                     else
-                        state = (es.NetEntity, meta, false, GameTick.Zero, null, es);
+                        _toApply[uid] = (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)
-            {
-                // Original entity referencing the NetEntity may have been deleted.
-                if (!metas.TryGetComponent(uid, out var meta))
-                    continue;
-
-                // 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 contQuery = _entities.GetEntityQuery<ContainerManagerComponent>();
+            var physicsQuery = _entities.GetEntityQuery<PhysicsComponent>();
+            var fixturesQuery = _entities.GetEntityQuery<FixturesComponent>();
+            var broadQuery = _entities.GetEntityQuery<BroadphaseComponent>();
             var queuedBroadphaseUpdates = new List<(EntityUid, TransformComponent)>(enteringPvs);
 
             // Apply entity states.
@@ -792,7 +758,7 @@ namespace Robust.Client.GameStates
             {
                 foreach (var (entity, data) in _toApply)
                 {
-                    HandleEntityState(entity, data.NetEntity, data.Meta, _entities.EventBus, data.curState,
+                    HandleEntityState(entity, _entities.EventBus, data.curState,
                         data.nextState, data.LastApplied, curState.ToSequence, data.EnteringPvs);
 
                     if (!data.EnteringPvs)
@@ -807,7 +773,6 @@ namespace Robust.Client.GameStates
                     if (!_toApply.TryGetValue(xform.ParentUid, out var parent) || !parent.EnteringPvs)
                         queuedBroadphaseUpdates.Add((entity, xform));
                 }
-
                 _prof.WriteValue("Count", ProfData.Int32(_toApply.Count));
             }
 
@@ -871,37 +836,37 @@ namespace Robust.Client.GameStates
 
             // Construct hashset for set.Contains() checks.
             var entityStates = state.EntityStates.Span;
-            var stateEnts = new HashSet<NetEntity>();
+            var stateEnts = new HashSet<EntityUid>(entityStates.Length);
             foreach (var entState in entityStates)
             {
-                stateEnts.Add(entState.NetEntity);
+                stateEnts.Add(entState.Uid);
             }
 
+            var metas = _entities.GetEntityQuery<MetaDataComponent>();
             var xforms = _entities.GetEntityQuery<TransformComponent>();
             var xformSys = _entitySystemManager.GetEntitySystem<SharedTransformSystem>();
 
+            var currentEnts = _entities.GetEntities();
             var toDelete = new List<EntityUid>(Math.Max(64, _entities.EntityCount - stateEnts.Count));
-
-            // Client side entities won't need the transform, but that should always be a tiny minority of entities
-            var metaQuery = _entityManager.AllEntityQueryEnumerator<MetaDataComponent, TransformComponent>();
-
-            while (metaQuery.MoveNext(out var ent, out var metadata, out var xform))
+            foreach (var ent in currentEnts)
             {
-                var netEnt = metadata.NetEntity;
-                if (metadata.NetEntity.IsClientSide())
+                if (ent.IsClientSide())
                 {
                     if (deleteClientEntities)
                         toDelete.Add(ent);
                     continue;
                 }
 
-                if (stateEnts.Contains(netEnt))
+                if (stateEnts.Contains(ent) && metas.TryGetComponent(ent, out var meta))
                 {
-                    if (resetAllEntities || metadata.LastStateApplied > state.ToSequence)
-                        metadata.LastStateApplied = GameTick.Zero; // TODO track last-state-applied for individual components? Is it even worth it?
+                    if (resetAllEntities || meta.LastStateApplied > state.ToSequence)
+                        meta.LastStateApplied = GameTick.Zero; // TODO track last-state-applied for individual components? Is it even worth it?
                     continue;
                 }
 
+                if (!xforms.TryGetComponent(ent, out var xform))
+                    continue;
+
                 // This entity is going to get deleted, but maybe some if its children won't be, so lets detach them to
                 // null. First we will detach the parent in order to reduce the number of broadphase/lookup updates.
                 xformSys.DetachParentToNull(ent, xform);
@@ -914,7 +879,7 @@ namespace Robust.Client.GameStates
 
                     if (deleteClientChildren
                         && !deleteClientEntities // don't add duplicates
-                        && _entities.IsClientSide(child.Value))
+                        && child.Value.IsClientSide())
                     {
                         toDelete.Add(child.Value);
                     }
@@ -929,7 +894,7 @@ namespace Robust.Client.GameStates
         }
 
         private void ProcessDeletions(
-            ReadOnlySpan<NetEntity> delSpan,
+            ReadOnlySpan<EntityUid> delSpan,
             EntityQuery<TransformComponent> xforms,
             EntityQuery<MetaDataComponent> metas,
             SharedTransformSystem xformSys)
@@ -946,19 +911,13 @@ namespace Robust.Client.GameStates
 
             using var _ = _prof.Group("Deletion");
 
-            foreach (var netEntity in delSpan)
+            foreach (var id in delSpan)
             {
-                // Don't worry about this for later.
-                _entityManager.PendingNetEntityStates.Remove(netEntity);
-
-                if (!_entityManager.TryGetEntity(netEntity, out var id))
-                    continue;
-
                 if (!xforms.TryGetComponent(id, out var xform))
                     continue; // Already deleted? or never sent to us?
 
                 // First, a single recursive map change
-                xformSys.DetachParentToNull(id.Value, xform);
+                xformSys.DetachParentToNull(id, xform);
 
                 // Then detach all children.
                 var childEnumerator = xform.ChildEnumerator;
@@ -968,12 +927,12 @@ namespace Robust.Client.GameStates
                 }
 
                 // Finally, delete the entity.
-                _entities.DeleteEntity(id.Value);
+                _entities.DeleteEntity(id);
             }
             _prof.WriteValue("Count", ProfData.Int32(delSpan.Length));
         }
 
-        public void DetachImmediate(List<NetEntity> entities)
+        public void DetachImmediate(List<EntityUid> entities)
         {
             var metas = _entities.GetEntityQuery<MetaDataComponent>();
             var xforms = _entities.GetEntityQuery<TransformComponent>();
@@ -983,7 +942,7 @@ namespace Robust.Client.GameStates
             Detach(GameTick.MaxValue, null, entities, metas, xforms, xformSys, containerSys, lookupSys);
         }
 
-        private List<NetEntity> ProcessPvsDeparture(
+        private List<EntityUid> ProcessPvsDeparture(
             GameTick toTick,
             EntityQuery<MetaDataComponent> metas,
             EntityQuery<TransformComponent> xforms,
@@ -992,7 +951,7 @@ namespace Robust.Client.GameStates
             EntityLookupSystem lookupSys)
         {
             var toDetach = _processor.GetEntitiesToDetach(toTick, _pvsDetachBudget);
-            var detached = new List<NetEntity>();
+            var detached = new List<EntityUid>();
 
             if (toDetach.Count == 0)
                 return detached;
@@ -1014,18 +973,16 @@ namespace Robust.Client.GameStates
 
         private void Detach(GameTick maxTick,
             GameTick? lastStateApplied,
-            List<NetEntity> entities,
+            List<EntityUid> entities,
             EntityQuery<MetaDataComponent> metas,
             EntityQuery<TransformComponent> xforms,
             SharedTransformSystem xformSys,
             ContainerSystem containerSys,
             EntityLookupSystem lookupSys,
-            List<NetEntity>? detached = null)
+            List<EntityUid>? detached = null)
         {
-            foreach (var netEntity in entities)
+            foreach (var ent in entities)
             {
-                var ent = _entityManager.GetEntity(netEntity);
-
                 if (!metas.TryGetComponent(ent, out var meta))
                     continue;
 
@@ -1050,7 +1007,7 @@ namespace Robust.Client.GameStates
 
                     // In some cursed scenarios an entity inside of a container can leave PVS without the container itself leaving PVS.
                     // In those situations, we need to add the entity back to the list of expected entities after detaching.
-                    BaseContainer? container = null;
+                    IContainer? container = null;
                     if ((meta.Flags & MetaDataFlags.InContainer) != 0 &&
                         metas.TryGetComponent(xform.ParentUid, out var containerMeta) &&
                         (containerMeta.Flags & MetaDataFlags.Detached) == 0 &&
@@ -1064,38 +1021,35 @@ namespace Robust.Client.GameStates
                     DebugTools.Assert((meta.Flags & MetaDataFlags.InContainer) == 0);
 
                     if (container != null)
-                        containerSys.AddExpectedEntity(netEntity, container);
+                        containerSys.AddExpectedEntity(ent, container);
                 }
 
-                detached?.Add(netEntity);
+                detached?.Add(ent);
             }
         }
 
-        private void InitializeAndStart(Dictionary<NetEntity, EntityState> toCreate)
+        private void InitializeAndStart(Dictionary<EntityUid, EntityState> toCreate)
         {
-            var metaQuery = _entityManager.GetEntityQuery<MetaDataComponent>();
-
 #if EXCEPTION_TOLERANCE
-            var brokenEnts = new List<EntityUid>();
+            HashSet<EntityUid> brokenEnts = new HashSet<EntityUid>();
 #endif
             using (_prof.Group("Initialize Entity"))
             {
-                foreach (var netEntity in toCreate.Keys)
+                foreach (var entity in toCreate.Keys)
                 {
-                    var entity = _entityManager.GetEntity(netEntity);
 #if EXCEPTION_TOLERANCE
                     try
                     {
 #endif
-                    _entities.InitializeEntity(entity, metaQuery.GetComponent(entity));
+                    _entities.InitializeEntity(entity);
 #if EXCEPTION_TOLERANCE
                     }
                     catch (Exception e)
                     {
-                        _sawmill.Error($"Server entity threw in Init: ent={_entities.ToPrettyString(entity)}");
+                        _sawmill.Error($"Server entity threw in Init: ent={_entityManager.ToPrettyString(entity)}");
                         _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(InitializeAndStart)}");
                         brokenEnts.Add(entity);
-                        toCreate.Remove(netEntity);
+                        toCreate.Remove(entity);
                     }
 #endif
                 }
@@ -1103,9 +1057,8 @@ namespace Robust.Client.GameStates
 
             using (_prof.Group("Start Entity"))
             {
-                foreach (var netEntity in toCreate.Keys)
+                foreach (var entity in toCreate.Keys)
                 {
-                    var entity = _entityManager.GetEntity(netEntity);
 #if EXCEPTION_TOLERANCE
                     try
                     {
@@ -1118,7 +1071,7 @@ namespace Robust.Client.GameStates
                         _sawmill.Error($"Server entity threw in Start: ent={_entityManager.ToPrettyString(entity)}");
                         _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(InitializeAndStart)}");
                         brokenEnts.Add(entity);
-                        toCreate.Remove(netEntity);
+                        toCreate.Remove(entity);
                     }
 #endif
                 }
@@ -1132,16 +1085,17 @@ namespace Robust.Client.GameStates
 #endif
         }
 
-        private void HandleEntityState(EntityUid uid, NetEntity netEntity, MetaDataComponent meta, IEventBus bus, EntityState? curState,
+        private void HandleEntityState(EntityUid uid, IEventBus bus, EntityState? curState,
             EntityState? nextState, GameTick lastApplied, GameTick toTick, bool enteringPvs)
         {
-            _compStateWork.Clear();
+            var size = (curState?.ComponentChanges.Span.Length ?? 0) + (nextState?.ComponentChanges.Span.Length ?? 0);
+            var compStateWork = new Dictionary<ushort, (IComponent Component, ComponentState? curState, ComponentState? nextState)>(size);
 
             // First remove any deleted components
             if (curState?.NetComponents != null)
             {
                 RemQueue<Component> toRemove = new();
-                foreach (var (id, comp) in meta.NetComponents)
+                foreach (var (id, comp) in _entities.GetNetComponents(uid))
                 {
                     if (comp.NetSyncEnabled && !curState.NetComponents.Contains(id))
                         toRemove.Add(comp);
@@ -1149,7 +1103,7 @@ namespace Robust.Client.GameStates
 
                 foreach (var comp in toRemove)
                 {
-                    _entities.RemoveComponent(uid, comp, meta);
+                    _entities.RemoveComponent(uid, comp);
                 }
             }
 
@@ -1160,32 +1114,34 @@ namespace Robust.Client.GameStates
                 //
                 // as to why we need to reset: because in the process of detaching to null-space, we will have dirtied
                 // the entity. most notably, all entities will have been ejected from their containers.
-                foreach (var (id, state) in _processor.GetLastServerStates(netEntity))
+                foreach (var (id, state) in _processor.GetLastServerStates(uid))
                 {
-                    if (!meta.NetComponents.TryGetValue(id, out var comp))
+                    if (!_entityManager.TryGetComponent(uid, id, out var comp))
                     {
-                        comp = (Component) _compFactory.GetComponent(id);
-                        comp.Owner = uid;
-                        _entityManager.AddComponent(uid, comp, true, metadata: meta);
+                        comp = _compFactory.GetComponent(id);
+                        var newComp = (Component)comp;
+                        newComp.Owner = uid;
+                        _entityManager.AddComponent(uid, newComp, true);
                     }
 
-                    _compStateWork[id] = (comp, state, null);
+                    compStateWork[id] = (comp, state, null);
                 }
             }
             else if (curState != null)
             {
                 foreach (var compChange in curState.ComponentChanges.Span)
                 {
-                    if (!meta.NetComponents.TryGetValue(compChange.NetID, out var comp))
+                    if (!_entityManager.TryGetComponent(uid, compChange.NetID, out var comp))
                     {
-                        comp = (Component) _compFactory.GetComponent(compChange.NetID);
-                        comp.Owner = uid;
-                        _entityManager.AddComponent(uid, comp, true, metadata:meta);
+                        comp = _compFactory.GetComponent(compChange.NetID);
+                        var newComp = (Component)comp;
+                        newComp.Owner = uid;
+                        _entityManager.AddComponent(uid, newComp, true);
                     }
                     else if (compChange.LastModifiedTick <= lastApplied && lastApplied != GameTick.Zero)
                         continue;
 
-                    _compStateWork[compChange.NetID] = (comp, compChange.State, null);
+                    compStateWork[compChange.NetID] = (comp, compChange.State, null);
                 }
             }
 
@@ -1196,66 +1152,35 @@ namespace Robust.Client.GameStates
                     if (compState.LastModifiedTick != toTick + 1)
                         continue;
 
-                    if (!meta.NetComponents.TryGetValue(compState.NetID, out var comp))
+                    if (!_entityManager.TryGetComponent(uid, 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;
                     }
 
-                    ref var state =
-                        ref CollectionsMarshal.GetValueRefOrAddDefault(_compStateWork, compState.NetID, out var exists);
-
-                    if (exists)
-                        state = (comp, state.curState, compState.State);
+                    if (compStateWork.TryGetValue(compState.NetID, out var state))
+                        compStateWork[compState.NetID] = (comp, state.curState, compState.State);
                     else
-                        state = (comp, null, compState.State);
+                        compStateWork[compState.NetID] = (comp, null, compState.State);
                 }
             }
 
-            // If we have a NetEntity we reference come in then apply their state.
-            if (_pendingReapplyNetStates.TryGetValue(uid, out var reapplyTypes))
-            {
-                var lastState = _processor.GetLastServerStates(netEntity);
-
-                foreach (var type in reapplyTypes)
-                {
-                    var compRef = _compFactory.GetRegistration(type);
-                    var netId = compRef.NetID;
-
-                    if (netId == null)
-                        continue;
-
-                    if (!meta.NetComponents.TryGetValue(netId.Value, out var comp) ||
-                        !lastState.TryGetValue(netId.Value, out var lastCompState))
-                    {
-                        continue;
-                    }
-
-                    ref var compState =
-                        ref CollectionsMarshal.GetValueRefOrAddDefault(_compStateWork, netId.Value, out var exists);
-
-                    if (exists)
-                        continue;
-
-                    compState = (comp, lastCompState, null);
-                }
-            }
-
-            foreach (var (comp, cur, next) in _compStateWork.Values)
+            foreach (var (comp, cur, next) in compStateWork.Values)
             {
                 try
                 {
                     var handleState = new ComponentHandleState(cur, next);
                     bus.RaiseComponentEvent(comp, ref handleState);
+                    comp.HandleComponentState(cur, next);
                 }
                 catch (Exception e)
                 {
 #if EXCEPTION_TOLERANCE
-                    _sawmill.Error($"Failed to apply comp state: entity={_entities.ToPrettyString(uid)}, comp={comp.GetType()}");
-                    _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(HandleEntityState)}");
+                        _sawmill.Error($"Failed to apply comp state: entity={comp.Owner}, comp={comp.GetType()}");
+                        _runtimeLog.LogException(e, $"{nameof(ClientGameStateManager)}.{nameof(HandleEntityState)}");
 #else
-                    _sawmill.Error($"Failed to apply comp state: entity={_entities.ToPrettyString(uid)}, comp={comp.GetType()}");
+                    _sawmill.Error($"Failed to apply comp state: entity={uid}, comp={comp.GetType()}");
                     throw;
 #endif
                 }
@@ -1263,7 +1188,6 @@ namespace Robust.Client.GameStates
         }
 
         #region Debug Commands
-
         private bool TryParseUid(IConsoleShell shell, string[] args, out EntityUid uid, [NotNullWhen(true)] out MetaDataComponent? meta)
         {
             if (args.Length != 1)
@@ -1299,7 +1223,7 @@ namespace Robust.Client.GameStates
                 return;
 
             using var _ = _timing.StartStateApplicationArea();
-            ResetEnt(uid, meta, false);
+            ResetEnt(meta, false);
         }
 
         /// <summary>
@@ -1322,7 +1246,7 @@ namespace Robust.Client.GameStates
             var xform = _entities.GetComponent<TransformComponent>(uid);
             if (xform.ParentUid.IsValid())
             {
-                BaseContainer? container = null;
+                IContainer? container = null;
                 if ((meta.Flags & MetaDataFlags.InContainer) != 0 &&
                     _entities.TryGetComponent(xform.ParentUid, out MetaDataComponent? containerMeta) &&
                     (containerMeta.Flags & MetaDataFlags.Detached) == 0)
@@ -1333,7 +1257,7 @@ namespace Robust.Client.GameStates
                 _entities.EntitySysManager.GetEntitySystem<TransformSystem>().DetachParentToNull(uid, xform);
 
                 if (container != null)
-                    containerSys.AddExpectedEntity(_entities.GetNetEntity(uid), container);
+                    containerSys.AddExpectedEntity(uid, container);
             }
         }
 
@@ -1350,21 +1274,18 @@ namespace Robust.Client.GameStates
 
             // If this is not a client-side entity, it also needs to be removed from the full-server state dictionary to
             // avoid errors. This has to be done recursively for all children.
-            void _recursiveRemoveState(NetEntity netEntity, TransformComponent xform, EntityQuery<MetaDataComponent> metaQuery, EntityQuery<TransformComponent> xformQuery)
+            void _recursiveRemoveState(TransformComponent xform, EntityQuery<TransformComponent> query)
             {
-                _processor._lastStateFullRep.Remove(netEntity);
+                _processor._lastStateFullRep.Remove(xform.Owner);
                 foreach (var child in xform.ChildEntities)
                 {
-                    if (xformQuery.TryGetComponent(child, out var childXform) &&
-                        metaQuery.TryGetComponent(child, out var childMeta))
-                    {
-                        _recursiveRemoveState(childMeta.NetEntity, childXform, metaQuery, xformQuery);
-                    }
+                    if (query.TryGetComponent(child, out var childXform))
+                        _recursiveRemoveState(childXform, query);
                 }
             }
 
-            if (!_entities.IsClientSide(uid) && _entities.TryGetComponent(uid, out TransformComponent? xform))
-                _recursiveRemoveState(meta.NetEntity, xform, _entities.GetEntityQuery<MetaDataComponent>(), _entities.GetEntityQuery<TransformComponent>());
+            if (!uid.IsClientSide() && _entities.TryGetComponent(uid, out TransformComponent? xform))
+                _recursiveRemoveState(xform, _entities.GetEntityQuery<TransformComponent>());
 
             // Set ApplyingState to true to avoid logging errors about predicting the deletion of networked entities.
             using (_timing.StartStateApplicationArea())
@@ -1380,43 +1301,45 @@ namespace Robust.Client.GameStates
         {
             using var _ = _timing.StartStateApplicationArea();
 
-            var query = _entityManager.AllEntityQueryEnumerator<MetaDataComponent>();
-
-            while (query.MoveNext(out var uid, out var meta))
+            foreach (var meta in _entities.EntityQuery<MetaDataComponent>(true))
             {
-                ResetEnt(uid, meta);
+                ResetEnt(meta);
             }
         }
 
         /// <summary>
         ///     Reset a given entity to the most recent server state.
         /// </summary>
-        private void ResetEnt(EntityUid uid, MetaDataComponent meta, bool skipDetached = true)
+        private void ResetEnt(MetaDataComponent meta, bool skipDetached = true)
         {
             if (skipDetached && (meta.Flags & MetaDataFlags.Detached) != 0)
                 return;
 
             meta.Flags &= ~MetaDataFlags.Detached;
 
-            if (!_processor.TryGetLastServerStates(meta.NetEntity, out var lastState))
+            var uid = meta.Owner;
+
+            if (!_processor.TryGetLastServerStates(uid, out var lastState))
                 return;
 
             foreach (var (id, state) in lastState)
             {
-                if (!meta.NetComponents.TryGetValue(id, out var comp))
+                if (!_entityManager.TryGetComponent(uid, id, out var comp))
                 {
-                    comp = (Component) _compFactory.GetComponent(id);
-                    comp.Owner = uid;
-                    _entityManager.AddComponent(uid, comp, true, meta);
+                    comp = _compFactory.GetComponent(id);
+                    var newComp = (Component)comp;
+                    newComp.Owner = uid;
+                    _entityManager.AddComponent(uid, newComp, true);
                 }
 
                 var handleState = new ComponentHandleState(state, null);
                 _entityManager.EventBus.RaiseComponentEvent(comp, ref handleState);
+                comp.HandleComponentState(state, null);
             }
 
             // ensure we don't have any extra components
             RemQueue<Component> toRemove = new();
-            foreach (var (id, comp) in meta.NetComponents)
+            foreach (var (id, comp) in _entities.GetNetComponents(uid))
             {
                 if (comp.NetSyncEnabled && !lastState.ContainsKey(id))
                     toRemove.Add(comp);
@@ -1438,9 +1361,9 @@ namespace Robust.Client.GameStates
     public sealed class GameStateAppliedArgs : EventArgs
     {
         public GameState AppliedState { get; }
-        public readonly List<NetEntity> Detached;
+        public readonly List<EntityUid> Detached;
 
-        public GameStateAppliedArgs(GameState appliedState, List<NetEntity> detached)
+        public GameStateAppliedArgs(GameState appliedState, List<EntityUid> detached)
         {
             AppliedState = appliedState;
             Detached = detached;
@@ -1449,12 +1372,12 @@ namespace Robust.Client.GameStates
 
     public sealed class MissingMetadataException : Exception
     {
-        public readonly NetEntity NetEntity;
+        public readonly EntityUid Uid;
 
-        public MissingMetadataException(NetEntity netEntity)
-            : base($"Server state is missing the metadata component for a new entity: {netEntity}.")
+        public MissingMetadataException(EntityUid uid)
+            : base($"Server state is missing the metadata component for a new entity: {uid}.")
         {
-            NetEntity = netEntity;
+            Uid = uid;
         }
     }
 }

Robust.Client/GameStates/GameStateProcessor.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Runtime.InteropServices;
 using Robust.Client.Timing;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
@@ -21,7 +20,7 @@ namespace Robust.Client.GameStates
 
         private readonly List<GameState> _stateBuffer = new();
 
-        private readonly Dictionary<GameTick, List<NetEntity>> _pvsDetachMessages = new();
+        private readonly Dictionary<GameTick, List<EntityUid>> _pvsDetachMessages = new();
 
         private ISawmill _logger = default!;
         private ISawmill _stateLogger = default!;
@@ -45,7 +44,7 @@ namespace Robust.Client.GameStates
         /// <summary>
         /// This dictionary stores the full most recently received server state of any entity. This is used whenever predicted entities get reset.
         /// </summary>
-        internal readonly Dictionary<NetEntity, Dictionary<ushort, ComponentState>> _lastStateFullRep
+        internal readonly Dictionary<EntityUid, Dictionary<ushort, ComponentState>> _lastStateFullRep
             = new();
 
         /// <inheritdoc />
@@ -179,10 +178,10 @@ namespace Robust.Client.GameStates
 
             foreach (var entityState in state.EntityStates.Span)
             {
-                if (!_lastStateFullRep.TryGetValue(entityState.NetEntity, out var compData))
+                if (!_lastStateFullRep.TryGetValue(entityState.Uid, out var compData))
                 {
                     compData = new Dictionary<ushort, ComponentState>();
-                    _lastStateFullRep.Add(entityState.NetEntity, compData);
+                    _lastStateFullRep.Add(entityState.Uid, compData);
                 }
 
                 foreach (var change in entityState.ComponentChanges.Span)
@@ -264,7 +263,7 @@ namespace Robust.Client.GameStates
             return false;
         }
 
-        internal void AddLeavePvsMessage(List<NetEntity> entities, GameTick tick)
+        internal void AddLeavePvsMessage(List<EntityUid> entities, GameTick tick)
         {
             // Late message may still need to be processed,
             DebugTools.Assert(entities.Count > 0);
@@ -273,9 +272,9 @@ namespace Robust.Client.GameStates
 
         public void ClearDetachQueue() => _pvsDetachMessages.Clear();
 
-        public List<(GameTick Tick, List<NetEntity> Entities)> GetEntitiesToDetach(GameTick toTick, int budget)
+        public List<(GameTick Tick, List<EntityUid> Entities)> GetEntitiesToDetach(GameTick toTick, int budget)
         {
-            var result = new List<(GameTick Tick, List<NetEntity> Entities)>();
+            var result = new List<(GameTick Tick, List<EntityUid> Entities)>();
             foreach (var (tick, entities) in _pvsDetachMessages)
             {
                 if (tick > toTick)
@@ -354,19 +353,17 @@ namespace Robust.Client.GameStates
             LastFullStateRequested = _timing.LastRealTick;
         }
 
-        public void MergeImplicitData(Dictionary<NetEntity, Dictionary<ushort, ComponentState>> implicitData)
+        public void MergeImplicitData(Dictionary<EntityUid, Dictionary<ushort, ComponentState>> implicitData)
         {
-            foreach (var (netEntity, implicitEntState) in implicitData)
+            foreach (var (uid, implicitEntState) in implicitData)
             {
-                var fullRep = _lastStateFullRep[netEntity];
+                var fullRep = _lastStateFullRep[uid];
 
                 foreach (var (netId, implicitCompState) in implicitEntState)
                 {
-                    ref var serverState = ref CollectionsMarshal.GetValueRefOrAddDefault(fullRep, netId, out var exists);
-
-                    if (!exists)
+                    if (!fullRep.TryGetValue(netId, out var serverState))
                     {
-                        serverState = implicitCompState;
+                        fullRep.Add(netId, implicitCompState);
                         continue;
                     }
 
@@ -377,28 +374,28 @@ namespace Robust.Client.GameStates
                     // state from the entity prototype.
                     if (implicitCompState is not IComponentDeltaState implicitDelta || !implicitDelta.FullState)
                     {
-                        _logger.Error($"Server sent delta state and client failed to construct an implicit full state for entity {netEntity}");
+                        _logger.Error($"Server sent delta state and client failed to construct an implicit full state for entity {uid}");
                         continue;
                     }
 
                     serverDelta.ApplyToFullState(implicitCompState);
-                    serverState = implicitCompState;
+                    fullRep[netId] = implicitCompState;
                     DebugTools.Assert(implicitCompState is IComponentDeltaState d && d.FullState);
                 }
             }
         }
 
-        public Dictionary<ushort, ComponentState> GetLastServerStates(NetEntity netEntity)
+        public Dictionary<ushort, ComponentState> GetLastServerStates(EntityUid entity)
         {
-            return _lastStateFullRep[netEntity];
+            return _lastStateFullRep[entity];
         }
 
-        public Dictionary<NetEntity, Dictionary<ushort, ComponentState>> GetFullRep()
+        public Dictionary<EntityUid, Dictionary<ushort, ComponentState>> GetFullRep()
         {
             return _lastStateFullRep;
         }
 
-        public bool TryGetLastServerStates(NetEntity entity,
+        public bool TryGetLastServerStates(EntityUid entity,
             [NotNullWhen(true)] out Dictionary<ushort, ComponentState>? dictionary)
         {
             return _lastStateFullRep.TryGetValue(entity, out dictionary);

Robust.Client/GameStates/IClientGameStateManager.cs

@@ -75,7 +75,7 @@ namespace Robust.Client.GameStates
         /// <summary>
         ///     Applies a given set of game states.
         /// </summary>
-        IEnumerable<NetEntity> ApplyGameState(GameState curState, GameState? nextState);
+        IEnumerable<EntityUid> ApplyGameState(GameState curState, GameState? nextState);
 
         /// <summary>
         ///     Resets any entities that have changed while predicting future ticks.
@@ -86,12 +86,12 @@ namespace Robust.Client.GameStates
         ///     An input command has been dispatched.
         /// </summary>
         /// <param name="message">Message being dispatched.</param>
-        void InputCommandDispatched(ClientFullInputCmdMessage clientMsg, FullInputCmdMessage message);
+        void InputCommandDispatched(FullInputCmdMessage message);
 
         /// <summary>
         ///     Requests a full state from the server. This should override even implicit entity data.
         /// </summary>
-        void RequestFullState(NetEntity? missingEntity = null);
+        void RequestFullState(EntityUid? missingEntity = null);
 
         uint SystemMessageDispatched<T>(T message) where T : EntityEventArgs;
 
@@ -105,7 +105,7 @@ namespace Robust.Client.GameStates
         /// <summary>
         /// Returns the full collection of cached game states that are used to reset predicted entities.
         /// </summary>
-        Dictionary<NetEntity, Dictionary<ushort, ComponentState>> GetFullRep();
+        Dictionary<EntityUid, Dictionary<ushort, ComponentState>> GetFullRep();
 
         /// <summary>
         /// This will perform some setup in order to reset the game to an earlier state. To fully reset the state
@@ -144,12 +144,12 @@ namespace Robust.Client.GameStates
         /// Queue a collection of entities that are to be detached to null-space & marked as PVS-detached.
         /// This store and modify the list given to it.
         /// </summary>
-        void QueuePvsDetach(List<NetEntity> entities, GameTick tick);
+        void QueuePvsDetach(List<EntityUid> entities, GameTick tick);
 
         /// <summary>
         /// Immediately detach several entities.
         /// </summary>
-        void DetachImmediate(List<NetEntity> entities);
+        void DetachImmediate(List<EntityUid> entities);
 
         /// <summary>
         /// Clears the PVS detach queue.

Robust.Client/GameStates/IGameStateProcessor.cs

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

Robust.Client/GameStates/NetEntityOverlay.cs

@@ -35,13 +35,13 @@ namespace Robust.Client.GameStates
 
         private readonly Font _font;
         private readonly int _lineHeight;
-        private readonly Dictionary<NetEntity, NetEntData> _netEnts = new();
+        private readonly Dictionary<EntityUid, NetEntData> _netEnts = new();
 
         public NetEntityOverlay()
         {
             IoCManager.InjectDependencies(this);
             var cache = IoCManager.Resolve<IResourceCache>();
-            _font = new VectorFont(cache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
+            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
             _lineHeight = _font.GetLineHeight(1);
 
             _gameStateManager.GameStateApplied += HandleGameStateApplied;
@@ -77,12 +77,12 @@ namespace Robust.Client.GameStates
 
             foreach (var entityState in gameState.EntityStates.Span)
             {
-                if (!_netEnts.TryGetValue(entityState.NetEntity, out var netEnt))
+                if (!_netEnts.TryGetValue(entityState.Uid, out var netEnt))
                 {
                     if (_netEnts.Count >= _maxEnts)
                         continue;
 
-                    _netEnts[entityState.NetEntity] = netEnt = new();
+                    _netEnts[entityState.Uid] = netEnt = new();
                 }
 
                 if (!netEnt.InPVS && netEnt.LastUpdate < gameState.ToSequence)
@@ -119,13 +119,11 @@ namespace Robust.Client.GameStates
             var screenHandle = args.ScreenHandle;
 
             int i = 0;
-            foreach (var (nent, netEnt) in _netEnts)
+            foreach (var (uid, netEnt) in _netEnts)
             {
-                var uid = _entityManager.GetEntity(nent);
-
                 if (!_entityManager.EntityExists(uid))
                 {
-                    _netEnts.Remove(nent);
+                    _netEnts.Remove(uid);
                     continue;
                 }
 

Robust.Client/GameStates/NetGraphOverlay.cs

@@ -26,7 +26,6 @@ namespace Robust.Client.GameStates
         [Dependency] private readonly IClientNetManager _netManager = default!;
         [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
         [Dependency] private readonly IComponentFactory _componentFactory = default!;
-        [Dependency] private readonly IEntityManager _entManager = default!;
 
         private const int HistorySize = 60 * 5; // number of ticks to keep in history.
         private const int TargetPayloadBps = 56000 / 8; // Target Payload size in Bytes per second. A mind-numbing fifty-six thousand bits per second, who would ever need more?
@@ -54,7 +53,7 @@ namespace Robust.Client.GameStates
         {
             IoCManager.InjectDependencies(this);
             var cache = IoCManager.Resolve<IResourceCache>();
-            _font = new VectorFont(cache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
+            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
 
             _gameStateManager.GameStateApplied += HandleGameStateApplied;
         }
@@ -74,7 +73,7 @@ namespace Robust.Client.GameStates
             _history.Add((toSeq, sz, lag, buffer));
 
             // not watching an ent
-            if(!WatchEntId.IsValid() || _entManager.IsClientSide(WatchEntId))
+            if(!WatchEntId.IsValid() || WatchEntId.IsClientSide())
                 return;
 
             string? entStateString = null;
@@ -87,9 +86,7 @@ namespace Robust.Client.GameStates
                 var sb = new StringBuilder();
                 foreach (var entState in entStates.Span)
                 {
-                    var uid = _entManager.GetEntity(entState.NetEntity);
-
-                    if (uid != WatchEntId)
+                    if (entState.Uid != WatchEntId)
                         continue;
 
                     if (!entState.ComponentChanges.HasContents)
@@ -118,9 +115,7 @@ namespace Robust.Client.GameStates
 
             foreach (var ent in args.Detached)
             {
-                var uid = _entManager.GetEntity(ent);
-
-                if (uid != WatchEntId)
+                if (ent != WatchEntId)
                     continue;
 
                 conShell.WriteLine($"watchEnt: Left PVS at tick {args.AppliedState.ToSequence}, eid={WatchEntId}" + "\n");
@@ -131,9 +126,7 @@ namespace Robust.Client.GameStates
             {
                 foreach (var entDelete in entDeletes.Span)
                 {
-                    var uid = _entManager.GetEntity(entDelete);
-
-                    if (uid == WatchEntId)
+                    if (entDelete == WatchEntId)
                         entDelString = "\n  Deleted";
                 }
             }
@@ -301,33 +294,30 @@ namespace Robust.Client.GameStates
 
         private sealed class NetWatchEntCommand : LocalizedCommands
         {
-            [Dependency] private readonly IEntityManager _entManager = default!;
-            [Dependency] private readonly IOverlayManager _overlayManager = default!;
-            [Dependency] private readonly IPlayerManager _playerManager = default!;
-
             public override string Command => "net_watchent";
 
             public override void Execute(IConsoleShell shell, string argStr, string[] args)
             {
-                EntityUid? entity;
-
+                EntityUid eValue;
                 if (args.Length == 0)
                 {
-                    entity = _playerManager.LocalPlayer?.ControlledEntity ?? EntityUid.Invalid;
+                    eValue = IoCManager.Resolve<IPlayerManager>().LocalPlayer?.ControlledEntity ?? EntityUid.Invalid;
                 }
-                else if (!NetEntity.TryParse(args[0], out var netEntity) || !_entManager.TryGetEntity(netEntity, out entity))
+                else if (!EntityUid.TryParse(args[0], out eValue))
                 {
                     shell.WriteError("Invalid argument: Needs to be 0 or an entityId.");
                     return;
                 }
 
-                if (!_overlayManager.TryGetOverlay(out NetGraphOverlay? overlay))
+                var overlayMan = IoCManager.Resolve<IOverlayManager>();
+
+                if (!overlayMan.TryGetOverlay(out NetGraphOverlay? overlay))
                 {
-                    overlay = new NetGraphOverlay();
-                    _overlayManager.AddOverlay(overlay);
+                    overlay = new();
+                    overlayMan.AddOverlay(overlay);
                 }
 
-                overlay.WatchEntId = entity.Value;
+                overlay.WatchEntId = eValue;
             }
         }
     }

Robust.Client/Graphics/AtlasTexture.cs

@@ -1,5 +1,4 @@
 using JetBrains.Annotations;
-using Robust.Shared.Graphics;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 

Robust.Client/Graphics/Audio/ClydeAudio.Formats.OggVorbis.cs

@@ -27,7 +27,7 @@ namespace Robust.Client.Graphics.Audio
                     readSamples += read;
                 }
 
-                return new OggVorbisData(totalSamples, sampleRate, channels, buffer, vorbis.Tags.Title, vorbis.Tags.Artist);
+                return new OggVorbisData(totalSamples, sampleRate, channels, buffer);
             }
         }
 
@@ -37,17 +37,13 @@ namespace Robust.Client.Graphics.Audio
             public readonly long SampleRate;
             public readonly long Channels;
             public readonly ReadOnlyMemory<float> Data;
-            public readonly string Title;
-            public readonly string Artist;
 
-            public OggVorbisData(long totalSamples, long sampleRate, long channels, ReadOnlyMemory<float> data, string title, string artist)
+            public OggVorbisData(long totalSamples, long sampleRate, long channels, ReadOnlyMemory<float> data)
             {
                 TotalSamples = totalSamples;
                 SampleRate = sampleRate;
                 Channels = channels;
                 Data = data;
-                Title = title;
-                Artist = artist;
             }
         }
     }

Robust.Client/Graphics/Audio/ClydeAudio.cs

@@ -261,9 +261,6 @@ namespace Robust.Client.Graphics.Audio
         {
             var source = AL.GenSource();
 
-            if (!AL.IsSource(source))
-                throw new Exception("Failed to generate source. Too many simultaneous audio streams?");
-
             // ReSharper disable once PossibleInvalidOperationException
 
             var audioSource = new BufferedAudioSource(this, source, AL.GenBuffers(buffers), floatAudio);
@@ -329,7 +326,7 @@ namespace Robust.Client.Graphics.Audio
             var handle = new ClydeHandle(_audioSampleBuffers.Count);
             _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
             var length = TimeSpan.FromSeconds(vorbis.TotalSamples / (double) vorbis.SampleRate);
-            return new AudioStream(handle, length, (int) vorbis.Channels, name, vorbis.Title, vorbis.Artist);
+            return new AudioStream(handle, length, (int) vorbis.Channels, name);
         }
 
         public AudioStream LoadAudioWav(Stream stream, string? name = null)

Robust.Client/Graphics/ClientEye/Eye.cs

@@ -1,17 +1,17 @@
-#nullable enable
-
 using System.Numerics;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.ViewVariables;
 
-namespace Robust.Shared.Graphics
+#nullable enable
+
+namespace Robust.Client.Graphics
 {
     /// <inheritdoc />
     [Virtual]
     public class Eye : IEye
     {
-        private Vector2 _scale = Vector2.One / 2f;
+        private Vector2 _scale = Vector2.One/2f;
         private Angle _rotation = Angle.Zero;
         private MapCoordinates _coords;
 

Robust.Client/Graphics/ClientEye/EyeManager.cs

@@ -2,7 +2,6 @@ using System.Numerics;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Graphics;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
@@ -25,7 +24,6 @@ namespace Robust.Client.Graphics
         [Dependency] private readonly IClyde _displayManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
-        private ISawmill _logMill = default!;
 
         // We default to this when we get set to a null eye.
         private readonly FixedEye _defaultEye = new();
@@ -55,7 +53,6 @@ namespace Robust.Client.Graphics
         void IEyeManager.Initialize()
         {
             MainViewport = _uiManager.MainViewport;
-            _logMill = IoCManager.Resolve<ILogManager>().RootSawmill;
         }
 
         /// <inheritdoc />
@@ -132,14 +129,14 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public ScreenCoordinates CoordinatesToScreen(EntityCoordinates point)
         {
-            return MapToScreen(point.ToMap(_entityManager, _entityManager.System<SharedTransformSystem>()));
+            return MapToScreen(point.ToMap(_entityManager));
         }
 
         public ScreenCoordinates MapToScreen(MapCoordinates point)
         {
             if (CurrentEye.Position.MapId != point.MapId)
             {
-                _logMill.Error($"Attempted to convert map coordinates ({point}) to screen coordinates with an eye on another map ({CurrentEye.Position.MapId})");
+                Logger.Error($"Attempted to convert map coordinates ({point}) to screen coordinates with an eye on another map ({CurrentEye.Position.MapId})");
                 return new(default, WindowId.Invalid);
             }
 
@@ -149,10 +146,12 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public MapCoordinates ScreenToMap(ScreenCoordinates point)
         {
+            var (pos, window) = point;
+
             if (_uiManager.MouseGetControl(point) is not IViewportControl viewport)
                 return default;
 
-            return viewport.ScreenToMap(point.Position);
+            return viewport.ScreenToMap(pos);
         }
 
         /// <inheritdoc />
@@ -160,21 +159,6 @@ namespace Robust.Client.Graphics
         {
             return MainViewport.ScreenToMap(point);
         }
-
-        /// <inheritdoc />
-        public MapCoordinates PixelToMap(ScreenCoordinates point)
-        {
-            if (_uiManager.MouseGetControl(point) is not IViewportControl viewport)
-                return default;
-
-            return viewport.PixelToMap(point.Position);
-        }
-
-        /// <inheritdoc />
-        public MapCoordinates PixelToMap(Vector2 point)
-        {
-            return MainViewport.PixelToMap(point);
-        }
     }
 
     public sealed class CurrentEyeChangedEvent : EntityEventArgs

Robust.Client/Graphics/ClientEye/FixedEye.cs

@@ -1,6 +1,4 @@
-using Robust.Shared.Graphics;
-
-namespace Robust.Client.Graphics
+namespace Robust.Client.Graphics
 {
     /// <summary>
     ///     A fixed eye is an eye which is fixed to one point, its position.

Robust.Client/Graphics/ClientEye/IEye.cs

@@ -1,9 +1,9 @@
-using System.Numerics;
+using System.Numerics;
 using JetBrains.Annotations;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
-namespace Robust.Shared.Graphics
+namespace Robust.Client.Graphics
 {
     /// <summary>
     /// An Eye is a point through which the player can view the world.

Robust.Client/Graphics/ClientEye/IEyeManager.cs

@@ -1,6 +1,5 @@
 using System.Numerics;
 using Robust.Client.UserInterface.CustomControls;
-using Robust.Shared.Graphics;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
@@ -80,16 +79,6 @@ namespace Robust.Client.Graphics
         /// <returns>Corresponding point in the world.</returns>
         MapCoordinates ScreenToMap(Vector2 point);
 
-        /// <summary>
-        /// Similar to <see cref="ScreenToMap(ScreenCoordinates)"/>, except it should compensate for the effects of shaders on viewports.
-        /// </summary>
-        MapCoordinates PixelToMap(ScreenCoordinates point);
-
-        /// <summary>
-        /// Similar to <see cref="ScreenToMap(Vector2)"/>, except it should compensate for the effects of shaders on viewports.
-        /// </summary>
-        MapCoordinates PixelToMap(Vector2 point);
-
         void ClearCurrentEye();
         void Initialize();
     }

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

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Graphics;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;

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

@@ -9,7 +9,6 @@ using Robust.Client.ResourceManagement;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared;
 using Robust.Shared.Enums;
-using Robust.Shared.Graphics;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Profiling;

Robust.Client/Graphics/Clyde/Clyde.Helpers.cs

@@ -3,7 +3,6 @@ using System.Numerics;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using OpenToolkit.Graphics.OpenGL4;
-using Robust.Shared.Graphics;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using ES20 = OpenToolkit.Graphics.ES20;

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

@@ -16,10 +16,8 @@ using OGLTextureWrapMode = OpenToolkit.Graphics.OpenGL.TextureWrapMode;
 using TKStencilOp = OpenToolkit.Graphics.OpenGL4.StencilOp;
 using Robust.Shared.Physics;
 using Robust.Client.ComponentTrees;
-using Robust.Shared.Graphics;
 using static Robust.Shared.GameObjects.OccluderComponent;
 using Robust.Shared.Utility;
-using TextureWrapMode = Robust.Shared.Graphics.TextureWrapMode;
 using Vector4 = Robust.Shared.Maths.Vector4;
 
 namespace Robust.Client.Graphics.Clyde

Robust.Client/Graphics/Clyde/Clyde.RenderHandle.cs

@@ -5,7 +5,6 @@ using Robust.Client.GameObjects;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Maths;
 using OpenToolkit.Graphics.OpenGL4;
-using Robust.Shared.Graphics;
 
 namespace Robust.Client.Graphics.Clyde
 {

Robust.Client/Graphics/Clyde/Clyde.RenderTargets.cs

@@ -3,7 +3,6 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using OpenToolkit.Graphics.OpenGL4;
-using Robust.Shared.Graphics;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;

Robust.Client/Graphics/Clyde/Clyde.Rendering.cs

@@ -7,7 +7,6 @@ using System.Runtime.InteropServices;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Client.GameObjects;
 using Robust.Client.Utility;
-using Robust.Shared.Graphics;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using TKStencilOp = OpenToolkit.Graphics.OpenGL4.StencilOp;