Version: 194.0.2

* Turn EntityData struct into a class

* Stop overbudget dictionary removals

* Merge additional logs

* More logging

.github/CODEOWNERS

@@ -1,18 +1,12 @@
 # Last match in file takes precedence.
 
 # Ping for all PRs
-* @Acruid @PJB3005 @ZoldorfTheWizard
+* @PJB3005 @DrSmugleaf
 
-/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
+# commands commands commands commands
+**/Toolshed/** @moonheart08
+*Command.cs @moonheart08
+*Commands.cs @moonheart08
 
-# Be they Fluent translations or Freemarker templates, I know them both!
-*.ftl @RemieRichards
+# Physics
+**/Robust.Shared/Physics/** @metalgearsloth

.github/workflows/build-docfx.yml

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

.github/workflows/build-test.yml

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

.github/workflows/codeql-analysis.yml

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

.github/workflows/publish-client.yml

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

.github/workflows/test-content.yml

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

Lidgren.Network/Lidgren.Network.csproj

@@ -10,6 +10,9 @@
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
 
     <SkipRobustAnalyzer>true</SkipRobustAnalyzer>
+
+    <Nullable>enable</Nullable>
+    <LangVersion>12.0</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

MSBuild/Robust.DefineConstants.targets

@@ -23,7 +23,7 @@
   <PropertyGroup Condition="'$(FullRelease)' != 'True'">
     <DefineConstants>$(DefineConstants);DEVELOPMENT</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
+  <PropertyGroup Condition="'$(Configuration)' == 'Release' Or '$(Configuration)' == 'Tools'">
     <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 -->
-    <PropertyGroup><Version>136.0.1</Version></PropertyGroup>
-</Project>
+<Project>
+
+    <!-- This file automatically reset by Tools/version.py -->
+

MSBuild/Robust.Engine.props

@@ -1,8 +1,8 @@
 <Project>
     <!-- Engine-specific properties. Content should not use this file. -->
     <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
-        <LangVersion>11</LangVersion>
+        <TargetFramework>net8.0</TargetFramework>
+        <LangVersion>12</LangVersion>
         <Nullable>enable</Nullable>
         <WarningsAsErrors>nullable</WarningsAsErrors>
     </PropertyGroup>

MSBuild/Robust.Properties.targets

@@ -3,7 +3,7 @@
   <!-- Import this at the end of any project files in Robust and Content. -->
 
   <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 
   <Import Project="Robust.Custom.targets" Condition="Exists('Robust.Custom.targets')"/>
@@ -25,4 +25,7 @@
 
   <!-- analyzer -->
   <Import Project="Robust.Analyzers.targets" Condition="'$(SkipRobustAnalyzer)' != 'true'" />
+
+  <!-- serialization generator -->
+  <Import Project="Robust.Serialization.Generator.targets" />
 </Project>

MSBuild/Robust.Serialization.Generator.targets

@@ -0,0 +1,5 @@
+<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>

OpenToolkit.GraphicsLibraryFramework/GLFWException.cs

@@ -61,18 +61,5 @@ namespace OpenToolkit.GraphicsLibraryFramework
             : base(message, innerException)
         {
         }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="GLFWException"/> class with the specified context
-        /// and the serialization information.
-        /// </summary>
-        /// <param name="info">The <see cref="SerializationInfo"/> associated with this exception.</param>
-        /// <param name="context">
-        /// A <see cref="StreamingContext"/> that represents the context of this exception.
-        /// </param>
-        protected GLFWException(SerializationInfo info, StreamingContext context)
-            : base(info, context)
-        {
-        }
     }
 }

Resources/EnginePrototypes/Audio/audio_entities.yml

@@ -0,0 +1,5 @@
+- type: entity
+  id: Audio
+  name: Audio
+  description: Audio entity used by engine
+  save: false

Resources/EnginePrototypes/Debug/rotation.yml

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

Resources/EnginePrototypes/Shaders/stockshaders.yml

@@ -12,3 +12,8 @@
   id: bgra
   kind: source
   path: "/Shaders/Internal/bgra.swsl"
+
+- type: shader
+  id: ColorPicker
+  kind: source
+  path: "/Shaders/color_picker.swsl"

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

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

Resources/Locale/en-US/commands.ftl

@@ -558,3 +558,10 @@ 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
+
+cmd-audio_length-desc = Shows the length of an audio file
+cmd-audio_length-help = Usage: audio_length { cmd-audio_length-arg-file-name }
+cmd-audio_length-arg-file-name = <file name>

Resources/Locale/en-US/discordRPC.ftl

@@ -1,4 +1,5 @@
 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

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

Resources/Locale/en-US/input.ftl

@@ -18,6 +18,15 @@ 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

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

Resources/Shaders/color_picker.swsl

@@ -0,0 +1,46 @@
+// Simple shader for creating a box with colours varying along the x and y axes.
+
+uniform highp vec2 size;
+uniform highp vec2 offset;
+
+uniform highp vec4 xAxis;
+uniform highp vec4 yAxis;
+uniform highp vec4 baseColor;
+
+uniform bool hsv;
+
+void fragment() 
+{
+    // Calculate local uv coordinates.
+    // I.e., if using this shader to draw a box to the screen, (0,0) is the bottom left of the box.
+    
+    highp float yCoords = 1.0/SCREEN_PIXEL_SIZE.y - FRAGCOORD.y;
+    highp vec2 uv = vec2(FRAGCOORD.x - offset.x,  yCoords - offset.y);
+    uv /= size;
+    uv.y = 1.0 - uv.y;
+    
+    highp vec4 modulate = baseColor + uv.x * xAxis + uv.y * yAxis;
+    
+    if (hsv)
+    {
+        modulate.xyz = hsv2rgb(modulate.xyz);
+    }
+    
+    // The UV used for the texture lookup is the TEXTURE UV coordinate, which is different from the coordinates computed above.
+	COLOR = zTexture(UV) * modulate;
+}
+
+
+// hsv to RGB conversion taken from www.shadertoy.com/view/MsS3Wc
+
+// The MIT License
+// Copyright © 2014 Inigo Quilez
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// https://www.youtube.com/c/InigoQuilez
+// https://iquilezles.org
+
+highp vec3 hsv2rgb( in highp vec3 c )
+{
+    highp vec3 rgb = clamp( abs(mod(c.x*6.0+vec3(0.0,4.0,2.0),6.0)-3.0)-1.0, 0.0, 1.0 );
+	return c.z * mix( vec3(1.0), rgb, c.y);
+}

Robust.Analyzers/ByRefEventAnalyzer.cs

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

Robust.Analyzers/DataDefinitionAnalyzer.cs

@@ -0,0 +1,293 @@
+#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

@@ -0,0 +1,168 @@
+#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

@@ -18,9 +18,12 @@ public static class Diagnostics
     public const string IdInvalidNotNullableFlagType = "RA0011";
     public const string IdNotNullableFlagValueType = "RA0012";
     public const string IdByRefEventSubscribedByValue = "RA0013";
-    public const string IdValueEventSubscribedByRef = "RA0014";
     public const string IdByRefEventRaisedByValue = "RA0015";
     public const string IdValueEventRaisedByRef = "RA0016";
+    public const string IdDataDefinitionPartial = "RA0017";
+    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 class AddRemoveComponentBenchmark
+public partial class AddRemoveComponentBenchmark
 {
     private ISimulation _simulation = default!;
     private IEntityManager _entityManager = default!;
@@ -48,7 +48,7 @@ public class AddRemoveComponentBenchmark
     }
 
     [ComponentProtoName("A")]
-    public sealed class A : Component
+    public sealed partial class A : Component
     {
     }
 }

Robust.Benchmarks/EntityManager/ComponentIteratorBenchmark.cs

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

Robust.Benchmarks/EntityManager/SpawnDeleteEntityBenchmark.cs

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

Robust.Benchmarks/Serialization/Definitions/DataDefinitionWithString.cs

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

Robust.Benchmarks/Serialization/Definitions/SealedDataDefinitionWithString.cs

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

Robust.Benchmarks/Serialization/Definitions/SeedDataDefinition.cs

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

Robust.Benchmarks/Transform/RecursiveMoveBenchmark.cs

@@ -0,0 +1,171 @@
+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.CreateGridEntity(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/Animations/AnimationTrackPlaySound.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Collections.Generic;
+using Robust.Client.Audio;
 using Robust.Client.GameObjects;
 using Robust.Shared.Audio;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 using Robust.Shared.Player;
 
 namespace Robust.Client.Animations
@@ -37,7 +39,12 @@ namespace Robust.Client.Animations
 
                 var keyFrame = KeyFrames[keyFrameIndex];
 
-                SoundSystem.Play(keyFrame.Resource, Filter.Local(), entity, keyFrame.AudioParamsFunc.Invoke());
+                var audioParams = keyFrame.AudioParamsFunc.Invoke();
+                var audio = new SoundPathSpecifier(keyFrame.Resource)
+                {
+                    Params = audioParams
+                };
+                IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<AudioSystem>().PlayEntity(audio, Filter.Local(), entity, true);
             }
 
             return (keyFrameIndex, playingTime);

Robust.Client/Audio/AudioManager.ALDisposeQueues.cs

@@ -0,0 +1,58 @@
+using System.Collections.Concurrent;
+using OpenTK.Audio.OpenAL;
+
+namespace Robust.Client.Audio;
+
+internal partial class AudioManager
+{
+    // Used to track audio sources that were disposed in the finalizer thread,
+    // so we need to properly send them off in the main thread.
+    private readonly ConcurrentQueue<(int sourceHandle, int filterHandle)> _sourceDisposeQueue = new();
+    private readonly ConcurrentQueue<(int sourceHandle, int filterHandle)> _bufferedSourceDisposeQueue = new();
+    private readonly ConcurrentQueue<int> _bufferDisposeQueue = new();
+
+    public void FlushALDisposeQueues()
+    {
+        // Clear out finalized audio sources.
+        while (_sourceDisposeQueue.TryDequeue(out var handles))
+        {
+            OpenALSawmill.Debug("Cleaning out source {0} which finalized in another thread.", handles.sourceHandle);
+            if (IsEfxSupported) RemoveEfx(handles);
+            AL.DeleteSource(handles.sourceHandle);
+            _checkAlError();
+            _audioSources.Remove(handles.sourceHandle);
+        }
+
+        // Clear out finalized buffered audio sources.
+        while (_bufferedSourceDisposeQueue.TryDequeue(out var handles))
+        {
+            OpenALSawmill.Debug("Cleaning out buffered source {0} which finalized in another thread.", handles.sourceHandle);
+            if (IsEfxSupported) RemoveEfx(handles);
+            AL.DeleteSource(handles.sourceHandle);
+            _checkAlError();
+            _bufferedAudioSources.Remove(handles.sourceHandle);
+        }
+
+        // Clear out finalized audio buffers.
+        while (_bufferDisposeQueue.TryDequeue(out var handle))
+        {
+            AL.DeleteBuffer(handle);
+            _checkAlError();
+        }
+    }
+
+    internal void DeleteSourceOnMainThread(int sourceHandle, int filterHandle)
+    {
+        _sourceDisposeQueue.Enqueue((sourceHandle, filterHandle));
+    }
+
+    internal void DeleteBufferedSourceOnMainThread(int bufferedSourceHandle, int filterHandle)
+    {
+        _bufferedSourceDisposeQueue.Enqueue((bufferedSourceHandle, filterHandle));
+    }
+
+    internal void DeleteAudioBufferOnMainThread(int bufferHandle)
+    {
+        _bufferDisposeQueue.Enqueue(bufferHandle);
+    }
+}

Robust.Client/Audio/AudioManager.Public.cs

@@ -0,0 +1,374 @@
+using System;
+using System.IO;
+using System.Numerics;
+using System.Threading;
+using OpenTK.Audio.OpenAL;
+using Robust.Client.Audio.Sources;
+using Robust.Client.Graphics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.AudioLoading;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio;
+
+internal partial class AudioManager
+{
+    private float _zOffset;
+
+    public void SetZOffset(float offset)
+    {
+        _zOffset = offset;
+    }
+
+    /// <inheritdoc />
+    public float GetAttenuationGain(float distance, float rolloffFactor, float referenceDistance, float maxDistance)
+    {
+        switch (_attenuation)
+        {
+            case Attenuation.LinearDistance:
+                return 1 - rolloffFactor * (distance - referenceDistance) / (maxDistance - referenceDistance);
+            case Attenuation.LinearDistanceClamped:
+                distance = MathF.Max(referenceDistance, MathF.Min(distance, maxDistance));
+                return 1 - rolloffFactor * (distance - referenceDistance) / (maxDistance - referenceDistance);
+            default:
+                // TODO: If you see this you can implement
+                throw new NotImplementedException();
+        }
+    }
+
+    public void InitializePostWindowing()
+    {
+        _gameThread = Thread.CurrentThread;
+        InitializeAudio();
+    }
+
+    public void Shutdown()
+    {
+        DisposeAllAudio();
+
+        if (_openALContext != ALContext.Null)
+        {
+            ALC.MakeContextCurrent(ALContext.Null);
+
+            ALC.DestroyContext(_openALContext);
+        }
+
+        if (_openALDevice != IntPtr.Zero)
+        {
+            ALC.CloseDevice(_openALDevice);
+        }
+    }
+
+    /// <inheritdoc/>
+    public void SetVelocity(Vector2 velocity)
+    {
+        AL.Listener(ALListener3f.Velocity, velocity.X, velocity.Y, 0f);
+    }
+
+    /// <inheritdoc/>
+    public void SetPosition(Vector2 position)
+    {
+        AL.Listener(ALListener3f.Position, position.X, position.Y, _zOffset);
+    }
+
+    /// <inheritdoc/>
+    public void SetRotation(Angle angle)
+    {
+        var vec = angle.ToVec();
+
+        // Default orientation: at: (0, 0, -1)  up: (0, 1, 0)
+        var at = new OpenTK.Mathematics.Vector3(0f, 0f, -1f);
+        var up = new OpenTK.Mathematics.Vector3(vec.Y, vec.X, 0f);
+        AL.Listener(ALListenerfv.Orientation, new []{0, 0, -1, vec.X, vec.Y, 0});
+        AL.Listener(ALListenerfv.Orientation, ref at, ref up);
+    }
+
+    /// <inheritdoc/>
+    public AudioStream LoadAudioOggVorbis(Stream stream, string? name = null)
+    {
+        var vorbis = AudioLoaderOgg.LoadAudioData(stream);
+
+        var buffer = AL.GenBuffer();
+
+        ALFormat format;
+        // NVorbis only supports loading into floats.
+        // If this becomes a problem due to missing extension support (doubt it but ok),
+        // check the git history, I originally used libvorbisfile which worked and loaded 16 bit LPCM.
+        if (vorbis.Channels == 1)
+        {
+            format = ALFormat.Mono16;
+        }
+        else if (vorbis.Channels == 2)
+        {
+            format = ALFormat.Stereo16;
+        }
+        else
+        {
+            throw new InvalidOperationException("Unable to load audio with more than 2 channels.");
+        }
+
+        unsafe
+        {
+            fixed (short* ptr = vorbis.Data.Span)
+            {
+                AL.BufferData(buffer, format, (IntPtr) ptr, vorbis.Data.Length * sizeof(short),
+                    (int) vorbis.SampleRate);
+            }
+        }
+
+        _checkAlError();
+
+        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);
+    }
+
+    /// <inheritdoc/>
+    public AudioStream LoadAudioWav(Stream stream, string? name = null)
+    {
+        var wav = AudioLoaderWav.LoadAudioData(stream);
+
+        var buffer = AL.GenBuffer();
+
+        ALFormat format;
+        if (wav.BitsPerSample == 16)
+        {
+            if (wav.NumChannels == 1)
+            {
+                format = ALFormat.Mono16;
+            }
+            else if (wav.NumChannels == 2)
+            {
+                format = ALFormat.Stereo16;
+            }
+            else
+            {
+                throw new InvalidOperationException("Unable to load audio with more than 2 channels.");
+            }
+        }
+        else if (wav.BitsPerSample == 8)
+        {
+            if (wav.NumChannels == 1)
+            {
+                format = ALFormat.Mono8;
+            }
+            else if (wav.NumChannels == 2)
+            {
+                format = ALFormat.Stereo8;
+            }
+            else
+            {
+                throw new InvalidOperationException("Unable to load audio with more than 2 channels.");
+            }
+        }
+        else
+        {
+            throw new InvalidOperationException("Unable to load wav with bits per sample different from 8 or 16");
+        }
+
+        unsafe
+        {
+            fixed (byte* ptr = wav.Data.Span)
+            {
+                AL.BufferData(buffer, format, (IntPtr) ptr, wav.Data.Length, wav.SampleRate);
+            }
+        }
+
+        _checkAlError();
+
+        var handle = new ClydeHandle(_audioSampleBuffers.Count);
+        _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
+        var length = TimeSpan.FromSeconds(wav.Data.Length / (double) wav.BlockAlign / wav.SampleRate);
+        return new AudioStream(handle, length, wav.NumChannels, name);
+    }
+
+    /// <inheritdoc/>
+    public AudioStream LoadAudioRaw(ReadOnlySpan<short> samples, int channels, int sampleRate, string? name = null)
+    {
+        var fmt = channels switch
+        {
+            1 => ALFormat.Mono16,
+            2 => ALFormat.Stereo16,
+            _ => throw new ArgumentOutOfRangeException(
+                nameof(channels), "Only stereo and mono is currently supported")
+        };
+
+        var buffer = AL.GenBuffer();
+        _checkAlError();
+
+        unsafe
+        {
+            fixed (short* ptr = samples)
+            {
+                AL.BufferData(buffer, fmt, (IntPtr) ptr, samples.Length * sizeof(short), sampleRate);
+            }
+        }
+
+        _checkAlError();
+
+        var handle = new ClydeHandle(_audioSampleBuffers.Count);
+        var length = TimeSpan.FromSeconds((double) samples.Length / channels / sampleRate);
+        _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
+        return new AudioStream(handle, length, channels, name);
+    }
+
+    public void SetMasterGain(float newGain)
+    {
+        if (newGain < 0f)
+        {
+            OpenALSawmill.Error("Tried to set master gain below 0, clamping to 0");
+            AL.Listener(ALListenerf.Gain, 0f);
+            return;
+        }
+
+
+        #region Platform hack for MacOS
+        // HACK/BUG: Apple's OpenAL implementation has a bug where values of 0f for listener gain don't actually
+        // HACK/BUG: prevent sound playback. Workaround is to cap the minimum gain at a value just above 0.
+        if (OperatingSystem.IsMacOS() && newGain == 0f)
+        {
+            OpenALSawmill.Verbose("Not setting gain to 0 because Apple can't write an OpenAL implementation");
+            AL.Listener(ALListenerf.Gain, float.Epsilon);
+            return;
+        }
+        #endregion Platform hack for MacOS
+
+        AL.Listener(ALListenerf.Gain, newGain);
+    }
+
+    public void SetAttenuation(Attenuation attenuation)
+    {
+        switch (attenuation)
+        {
+            case Attenuation.NoAttenuation:
+                AL.DistanceModel(ALDistanceModel.None);
+                break;
+            case Attenuation.InverseDistance:
+                AL.DistanceModel(ALDistanceModel.InverseDistance);
+                break;
+            case Attenuation.InverseDistanceClamped:
+                AL.DistanceModel(ALDistanceModel.InverseDistanceClamped);
+                break;
+            case Attenuation.LinearDistance:
+                AL.DistanceModel(ALDistanceModel.LinearDistance);
+                break;
+            case Attenuation.LinearDistanceClamped:
+                AL.DistanceModel(ALDistanceModel.LinearDistanceClamped);
+                break;
+            case Attenuation.ExponentDistance:
+                AL.DistanceModel(ALDistanceModel.ExponentDistance);
+                break;
+            case Attenuation.ExponentDistanceClamped:
+                AL.DistanceModel(ALDistanceModel.ExponentDistanceClamped);
+                break;
+            default:
+                throw new ArgumentOutOfRangeException($"No implementation to set {attenuation.ToString()} for DistanceModel!");
+        }
+
+        _attenuation = attenuation;
+        OpenALSawmill.Info($"Set audio attenuation to {attenuation.ToString()}");
+    }
+
+    internal void RemoveAudioSource(int handle)
+    {
+        _audioSources.Remove(handle);
+    }
+
+    internal void RemoveBufferedAudioSource(int handle)
+    {
+        _bufferedAudioSources.Remove(handle);
+    }
+
+    IAudioSource? IAudioInternal.CreateAudioSource(AudioStream stream)
+    {
+        var source = AL.GenSource();
+
+        if (!AL.IsSource(source))
+        {
+            OpenALSawmill.Error("Failed to generate source. Too many simultaneous audio streams? {0}", Environment.StackTrace);
+            return null;
+        }
+
+        // ReSharper disable once PossibleInvalidOperationException
+        // TODO: This really shouldn't be indexing based on the ClydeHandle...
+        AL.Source(source, ALSourcei.Buffer, _audioSampleBuffers[(int) stream.ClydeHandle!.Value].BufferHandle);
+
+        var audioSource = new AudioSource(this, source, stream);
+        _audioSources.Add(source, new WeakReference<BaseAudioSource>(audioSource));
+        ApplyDefaultParams(audioSource);
+        return audioSource;
+    }
+
+    /// <inheritdoc/>
+    IBufferedAudioSource? IAudioInternal.CreateBufferedAudioSource(int buffers, bool floatAudio=false)
+    {
+        var source = AL.GenSource();
+
+        if (!AL.IsSource(source))
+        {
+            OpenALSawmill.Error("Failed to generate source. Too many simultaneous audio streams? {0}", Environment.StackTrace);
+            return null;
+        }
+
+        // ReSharper disable once PossibleInvalidOperationException
+
+        var audioSource = new BufferedAudioSource(this, source, AL.GenBuffers(buffers), floatAudio);
+        _bufferedAudioSources.Add(source, new WeakReference<BufferedAudioSource>(audioSource));
+        ApplyDefaultParams(audioSource);
+        return audioSource;
+    }
+
+    private void ApplyDefaultParams(IAudioSource source)
+    {
+        source.MaxDistance = AudioParams.Default.MaxDistance;
+        source.Pitch = AudioParams.Default.Pitch;
+        source.ReferenceDistance = AudioParams.Default.ReferenceDistance;
+        source.RolloffFactor = AudioParams.Default.RolloffFactor;
+    }
+
+    /// <inheritdoc />
+    public void StopAllAudio()
+    {
+        foreach (var source in _audioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Playing = false;
+            }
+        }
+
+        foreach (var source in _bufferedAudioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Playing = false;
+            }
+        }
+    }
+
+    public void DisposeAllAudio()
+    {
+        // TODO: Do we even need to stop?
+        foreach (var source in _audioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Dispose();
+            }
+        }
+
+        _audioSources.Clear();
+
+        foreach (var source in _bufferedAudioSources.Values)
+        {
+            if (source.TryGetTarget(out var target))
+            {
+                target.Dispose();
+            }
+        }
+
+        _bufferedAudioSources.Clear();
+    }
+}

Robust.Client/Audio/AudioManager.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using OpenTK.Audio.OpenAL;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Client.Audio.Sources;
+using Robust.Shared;
+using Robust.Shared.Audio;
+using Robust.Shared.Configuration;
+using Robust.Shared.Log;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Audio;
+
+internal sealed partial class AudioManager : IAudioInternal
+{
+    [Shared.IoC.Dependency] private readonly IConfigurationManager _cfg = default!;
+    [Shared.IoC.Dependency] private readonly ILogManager _logMan = default!;
+
+    private Thread? _gameThread;
+
+    private ALDevice _openALDevice;
+    private ALContext _openALContext;
+
+    private readonly List<LoadedAudioSample> _audioSampleBuffers = new();
+
+    private readonly Dictionary<int, WeakReference<BaseAudioSource>> _audioSources =
+        new();
+
+    private readonly Dictionary<int, WeakReference<BufferedAudioSource>> _bufferedAudioSources =
+        new();
+
+    private readonly HashSet<string> _alcDeviceExtensions = new();
+    private readonly HashSet<string> _alContextExtensions = new();
+    private Attenuation _attenuation;
+
+    public bool HasAlDeviceExtension(string extension) => _alcDeviceExtensions.Contains(extension);
+    public bool HasAlContextExtension(string extension) => _alContextExtensions.Contains(extension);
+
+    internal bool IsEfxSupported;
+
+    internal ISawmill OpenALSawmill = default!;
+
+    private void _audioCreateContext()
+    {
+        unsafe
+        {
+            _openALContext = ALC.CreateContext(_openALDevice, (int*) 0);
+        }
+
+        ALC.MakeContextCurrent(_openALContext);
+        _checkAlcError(_openALDevice);
+        _checkAlError();
+
+        // Load up AL context extensions.
+        var s = ALC.GetString(ALDevice.Null, AlcGetString.Extensions) ?? "";
+        foreach (var extension in s.Split(' '))
+        {
+            _alContextExtensions.Add(extension);
+        }
+
+        OpenALSawmill.Debug("OpenAL Vendor: {0}", AL.Get(ALGetString.Vendor));
+        OpenALSawmill.Debug("OpenAL Renderer: {0}", AL.Get(ALGetString.Renderer));
+        OpenALSawmill.Debug("OpenAL Version: {0}", AL.Get(ALGetString.Version));
+    }
+
+    private bool _audioOpenDevice()
+    {
+        var preferredDevice = _cfg.GetCVar(CVars.AudioDevice);
+
+        // Open device.
+        if (!string.IsNullOrEmpty(preferredDevice))
+        {
+            _openALDevice = ALC.OpenDevice(preferredDevice);
+            if (_openALDevice == IntPtr.Zero)
+            {
+                OpenALSawmill.Warning("Unable to open preferred audio device '{0}': {1}. Falling back default.",
+                    preferredDevice, ALC.GetError(ALDevice.Null));
+
+                _openALDevice = ALC.OpenDevice(null);
+            }
+        }
+        else
+        {
+            _openALDevice = ALC.OpenDevice(null);
+        }
+
+        _checkAlcError(_openALDevice);
+
+        if (_openALDevice == IntPtr.Zero)
+        {
+            OpenALSawmill.Error("Unable to open OpenAL device! {1}", ALC.GetError(ALDevice.Null));
+            return false;
+        }
+
+        // Load up ALC extensions.
+        var s = ALC.GetString(_openALDevice, AlcGetString.Extensions) ?? "";
+        foreach (var extension in s.Split(' '))
+        {
+            _alcDeviceExtensions.Add(extension);
+        }
+        return true;
+    }
+
+    private void InitializeAudio()
+    {
+        OpenALSawmill = _logMan.GetSawmill("clyde.oal");
+
+        if (!_audioOpenDevice())
+            return;
+
+        // Create OpenAL context.
+        _audioCreateContext();
+
+        IsEfxSupported = HasAlDeviceExtension("ALC_EXT_EFX");
+
+        _cfg.OnValueChanged(CVars.AudioMasterVolume, SetMasterGain, true);
+    }
+
+    internal bool IsMainThread()
+    {
+        return Thread.CurrentThread == _gameThread;
+    }
+
+    private static void RemoveEfx((int sourceHandle, int filterHandle) handles)
+    {
+        if (handles.filterHandle != 0)
+            EFX.DeleteFilter(handles.filterHandle);
+    }
+
+    private void _checkAlcError(ALDevice device,
+        [CallerMemberName] string callerMember = "",
+        [CallerLineNumber] int callerLineNumber = -1)
+    {
+        var error = ALC.GetError(device);
+        if (error != AlcError.NoError)
+        {
+            OpenALSawmill.Error("[{0}:{1}] ALC error: {2}", callerMember, callerLineNumber, error);
+        }
+    }
+
+    /// <summary>
+    /// Like _checkAlError but allows custom data to be passed in as relevant.
+    /// </summary>
+    internal void LogALError(string message, [CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1)
+    {
+        var error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            OpenALSawmill.Error("[{0}:{1}] AL error: {2}, {3}", callerMember, callerLineNumber, error, message);
+        }
+    }
+
+    public void _checkAlError([CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1)
+    {
+        var error = AL.GetError();
+        if (error != ALError.NoError)
+        {
+            OpenALSawmill.Error("[{0}:{1}] AL error: {2}", callerMember, callerLineNumber, error);
+        }
+    }
+
+    private sealed class LoadedAudioSample
+    {
+        public readonly int BufferHandle;
+
+        public LoadedAudioSample(int bufferHandle)
+        {
+            BufferHandle = bufferHandle;
+        }
+    }
+}

Robust.Client/Audio/AudioOverlay.cs

@@ -0,0 +1,89 @@
+using System.Numerics;
+using System.Text;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Audio;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using AudioComponent = Robust.Shared.Audio.Components.AudioComponent;
+
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Debug overlay for audio.
+/// </summary>
+public sealed class AudioOverlay : Overlay
+{
+    public override OverlaySpace Space => OverlaySpace.ScreenSpace;
+
+    private IEntityManager _entManager;
+    private IPlayerManager _playerManager;
+    private AudioSystem _audio;
+    private SharedTransformSystem _transform;
+
+    private Font _font;
+
+    public AudioOverlay(IEntityManager entManager, IPlayerManager playerManager, IResourceCache cache, AudioSystem audio, SharedTransformSystem transform)
+    {
+        _entManager = entManager;
+        _playerManager = playerManager;
+        _audio = audio;
+        _transform = transform;
+
+        _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+    }
+
+    protected internal override void Draw(in OverlayDrawArgs args)
+    {
+        var localPlayer = _playerManager.LocalPlayer?.ControlledEntity;
+
+        if (args.ViewportControl == null || localPlayer == null)
+            return;
+
+        var screenHandle = args.ScreenHandle;
+        var output = new StringBuilder();
+        var listenerPos = _entManager.GetComponent<TransformComponent>(localPlayer.Value).MapPosition;
+
+        if (listenerPos.MapId != args.MapId)
+            return;
+
+        var query = _entManager.AllEntityQueryEnumerator<AudioComponent>();
+
+        while (query.MoveNext(out var uid, out var comp))
+        {
+            var mapId = MapId.Nullspace;
+            var audioPos = Vector2.Zero;
+
+            if (_entManager.TryGetComponent<TransformComponent>(uid, out var xform))
+            {
+                mapId = xform.MapID;
+                audioPos = _transform.GetWorldPosition(uid);
+            }
+
+            if (mapId != args.MapId)
+                continue;
+
+            var screenPos = args.ViewportControl.WorldToScreen(audioPos);
+            var distance = audioPos - listenerPos.Position;
+            var posOcclusion = _audio.GetOcclusion(listenerPos, distance, distance.Length(), uid);
+
+            output.Clear();
+            output.AppendLine("Audio Source");
+            output.AppendLine("Runtime:");
+            output.AppendLine($"- Occlusion: {posOcclusion:0.0000}");
+            output.AppendLine("Params:");
+            output.AppendLine($"- Volume: {comp.Volume:0.0000}");
+            output.AppendLine($"- Reference distance: {comp.ReferenceDistance}");
+            output.AppendLine($"- Max distance: {comp.MaxDistance}");
+            var outputText = output.ToString().Trim();
+            var dimensions = screenHandle.GetDimensions(_font, outputText, 1f);
+            var buffer = new Vector2(3f, 3f);
+            screenHandle.DrawRect(new UIBox2(screenPos - buffer, screenPos + dimensions + buffer), new Color(39, 39, 48));
+            screenHandle.DrawString(_font, screenPos, outputText);
+        }
+    }
+}

Robust.Client/Audio/AudioStream.cs

@@ -1,20 +1,27 @@
-using System;
-using Robust.Client.Graphics;
+using System;
+using Robust.Shared.Graphics;
 
 namespace Robust.Client.Audio;
 
+/// <summary>
+/// Has the metadata for a particular audio stream as well as the relevant internal handle to it.
+/// </summary>
 public sealed class AudioStream
 {
     public TimeSpan Length { get; }
-    internal ClydeHandle? ClydeHandle { get; }
+    internal IClydeHandle? 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)
+    internal AudioStream(IClydeHandle? handle, TimeSpan length, int channelCount, string? name = null, string? title = null, string? artist = null)
     {
         ClydeHandle = handle;
         Length = length;
         ChannelCount = channelCount;
         Name = name;
+        Title = title;
+        Artist = artist;
     }
 }

Robust.Client/Audio/AudioSystem.Effects.cs

@@ -0,0 +1,76 @@
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Client.Audio.Effects;
+using Robust.Shared.Audio.Components;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Audio;
+
+public sealed partial class AudioSystem
+{
+    protected override void InitializeEffect()
+    {
+        base.InitializeEffect();
+        SubscribeLocalEvent<AudioEffectComponent, ComponentAdd>(OnEffectAdd);
+        SubscribeLocalEvent<AudioEffectComponent, ComponentShutdown>(OnEffectShutdown);
+
+        SubscribeLocalEvent<AudioAuxiliaryComponent, ComponentAdd>(OnAuxiliaryAdd);
+        SubscribeLocalEvent<AudioAuxiliaryComponent, AfterAutoHandleStateEvent>(OnAuxiliaryAuto);
+    }
+
+    private void OnEffectAdd(EntityUid uid, AudioEffectComponent component, ComponentAdd args)
+    {
+        var effect = new AudioEffect(_audio);
+        component.Effect = effect;
+    }
+
+    private void OnEffectShutdown(EntityUid uid, AudioEffectComponent component, ComponentShutdown args)
+    {
+        if (component.Effect is AudioEffect effect)
+        {
+            effect.Dispose();
+        }
+    }
+
+    private void OnAuxiliaryAdd(EntityUid uid, AudioAuxiliaryComponent component, ComponentAdd args)
+    {
+        component.Auxiliary = new AuxiliaryAudio();
+    }
+
+    private void OnAuxiliaryAuto(EntityUid uid, AudioAuxiliaryComponent component, ref AfterAutoHandleStateEvent args)
+    {
+        if (TryComp<AudioEffectComponent>(component.Effect, out var effectComp))
+        {
+            component.Auxiliary.SetEffect(effectComp.Effect);
+        }
+        else
+        {
+            component.Auxiliary.SetEffect(null);
+        }
+    }
+
+    public override void SetAuxiliary(EntityUid uid, AudioComponent audio, EntityUid? auxUid)
+    {
+        base.SetAuxiliary(uid, audio, auxUid);
+        if (TryComp<AudioAuxiliaryComponent>(audio.Auxiliary, out var auxComp))
+        {
+            audio.Source.SetAuxiliary(auxComp.Auxiliary);
+        }
+        else
+        {
+            audio.Source.SetAuxiliary(null);
+        }
+    }
+
+    public override void SetEffect(EntityUid auxUid, AudioAuxiliaryComponent aux, EntityUid? effectUid)
+    {
+        base.SetEffect(auxUid, aux, effectUid);
+        if (TryComp<AudioEffectComponent>(aux.Effect, out var effectComp))
+        {
+            aux.Auxiliary.SetEffect(effectComp.Effect);
+        }
+        else
+        {
+            aux.Auxiliary.SetEffect(null);
+        }
+    }
+}

Robust.Client/Audio/AudioSystem.cs

@@ -0,0 +1,679 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Components;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Exceptions;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Map.Components;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Components;
+using Robust.Shared.Physics.Systems;
+using Robust.Shared.Player;
+using Robust.Shared.Replays;
+using Robust.Shared.Threading;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Audio;
+
+public sealed partial class AudioSystem : SharedAudioSystem
+{
+    /*
+     * There's still a lot more OpenAL can do in terms of filters, auxiliary slots, etc.
+     * but exposing the whole thing in an easy way is a lot of effort.
+     */
+
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+    [Dependency] private readonly IResourceCache _resourceCache = default!;
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IParallelManager _parMan = default!;
+    [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
+    [Dependency] private readonly IAudioInternal _audio = default!;
+    [Dependency] private readonly SharedTransformSystem _xformSys = default!;
+    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
+
+    /// <summary>
+    /// Per-tick cache of relevant streams.
+    /// </summary>
+    private readonly List<(EntityUid Entity, AudioComponent Component, TransformComponent Xform)> _streams = new();
+    private EntityUid? _listenerGrid;
+    private UpdateAudioJob _updateAudioJob;
+
+    private EntityQuery<PhysicsComponent> _physicsQuery;
+
+    private float _maxRayLength;
+
+    public override float ZOffset
+    {
+        get => _zOffset;
+        protected set
+        {
+            _zOffset = value;
+            _audio.SetZOffset(value);
+
+            var query = AllEntityQuery<AudioComponent>();
+
+            while (query.MoveNext(out var audio))
+            {
+                // Pythagoras back to normal then adjust.
+                var maxDistance = GetAudioDistance(audio.Params.MaxDistance);
+                var refDistance = GetAudioDistance(audio.Params.ReferenceDistance);
+
+                audio.MaxDistance = maxDistance;
+                audio.ReferenceDistance = refDistance;
+            }
+        }
+    }
+
+    private float _zOffset;
+
+    /// <inheritdoc />
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        _updateAudioJob = new UpdateAudioJob
+        {
+            System = this,
+            Streams = _streams,
+        };
+
+        UpdatesOutsidePrediction = true;
+        // Need to run after Eye updates so we have an accurate listener position.
+        UpdatesAfter.Add(typeof(EyeSystem));
+
+        _physicsQuery = GetEntityQuery<PhysicsComponent>();
+
+        SubscribeLocalEvent<AudioComponent, ComponentStartup>(OnAudioStartup);
+        SubscribeLocalEvent<AudioComponent, ComponentShutdown>(OnAudioShutdown);
+        SubscribeLocalEvent<AudioComponent, EntityPausedEvent>(OnAudioPaused);
+        SubscribeLocalEvent<AudioComponent, AfterAutoHandleStateEvent>(OnAudioState);
+
+        // Replay stuff
+        SubscribeNetworkEvent<PlayAudioGlobalMessage>(OnGlobalAudio);
+        SubscribeNetworkEvent<PlayAudioEntityMessage>(OnEntityAudio);
+        SubscribeNetworkEvent<PlayAudioPositionalMessage>(OnEntityCoordinates);
+
+        CfgManager.OnValueChanged(CVars.AudioAttenuation, OnAudioAttenuation, true);
+        CfgManager.OnValueChanged(CVars.AudioRaycastLength, OnRaycastLengthChanged, true);
+    }
+
+    private void OnAudioState(EntityUid uid, AudioComponent component, ref AfterAutoHandleStateEvent args)
+    {
+        ApplyAudioParams(component.Params, component);
+        component.Source.Global = component.Global;
+
+        if (TryComp<AudioAuxiliaryComponent>(component.Auxiliary, out var auxComp))
+        {
+            component.Source.SetAuxiliary(auxComp.Auxiliary);
+        }
+        else
+        {
+            component.Source.SetAuxiliary(null);
+        }
+    }
+
+    /// <summary>
+    /// Sets the volume for the entire game.
+    /// </summary>
+    public void SetMasterVolume(float value)
+    {
+        _audio.SetMasterGain(value);
+    }
+
+    public override void Shutdown()
+    {
+        CfgManager.UnsubValueChanged(CVars.AudioAttenuation, OnAudioAttenuation);
+        CfgManager.UnsubValueChanged(CVars.AudioRaycastLength, OnRaycastLengthChanged);
+        base.Shutdown();
+    }
+
+    private void OnAudioPaused(EntityUid uid, AudioComponent component, ref EntityPausedEvent args)
+    {
+        component.Pause();
+    }
+
+    protected override void OnAudioUnpaused(EntityUid uid, AudioComponent component, ref EntityUnpausedEvent args)
+    {
+        base.OnAudioUnpaused(uid, component, ref args);
+        component.StartPlaying();
+    }
+
+    private void OnAudioStartup(EntityUid uid, AudioComponent component, ComponentStartup args)
+    {
+        if (!Timing.ApplyingState && !Timing.IsFirstTimePredicted)
+        {
+            return;
+        }
+
+        if (!TryGetAudio(component.FileName, out var audioResource))
+        {
+            Log.Error($"Error creating audio source for {audioResource}, can't find file {component.FileName}");
+            return;
+        }
+
+        var source = _audio.CreateAudioSource(audioResource);
+
+        if (source == null)
+        {
+            Log.Error($"Error creating audio source for {audioResource}");
+            DebugTools.Assert(false);
+            source = component.Source;
+        }
+
+        component.Source = source;
+
+        // Need to set all initial data for first frame.
+        ApplyAudioParams(component.Params, component);
+        source.Global = component.Global;
+
+        // Don't play until first frame so occlusion etc. are correct.
+        component.Gain = 0f;
+
+        // If audio came into range then start playback at the correct position.
+        var offset = (Timing.CurTime - component.AudioStart).TotalSeconds % GetAudioLength(component.FileName).TotalSeconds;
+
+        if (offset > 0)
+        {
+            component.PlaybackPosition = (float) offset;
+        }
+    }
+
+    private void OnAudioShutdown(EntityUid uid, AudioComponent component, ComponentShutdown args)
+    {
+        // Breaks with prediction?
+        component.Source.Dispose();
+    }
+
+    private void OnAudioAttenuation(int obj)
+    {
+        _audio.SetAttenuation((Attenuation) obj);
+    }
+
+    private void OnRaycastLengthChanged(float value)
+    {
+        _maxRayLength = value;
+    }
+
+    public override void FrameUpdate(float frameTime)
+    {
+        var eye = _eyeManager.CurrentEye;
+        var localEntity = _playerManager.LocalEntity;
+        Vector2 listenerVelocity;
+
+        if (localEntity != null)
+            listenerVelocity = _physics.GetMapLinearVelocity(localEntity.Value);
+        else
+            listenerVelocity = Vector2.Zero;
+
+        _audio.SetVelocity(listenerVelocity);
+        _audio.SetRotation(eye.Rotation);
+        _audio.SetPosition(eye.Position.Position);
+
+        var ourPos = GetListenerCoordinates();
+
+        var query = AllEntityQuery<AudioComponent, TransformComponent>();
+        _streams.Clear();
+
+        while (query.MoveNext(out var uid, out var comp, out var xform))
+        {
+            _streams.Add((uid, comp, xform));
+        }
+
+        _mapManager.TryFindGridAt(ourPos, out var gridUid, out _);
+        _listenerGrid = gridUid == EntityUid.Invalid ? null : gridUid;
+
+        try
+        {
+            _updateAudioJob.OurPosition = ourPos;
+            _parMan.ProcessNow(_updateAudioJob, _streams.Count);
+        }
+        catch (Exception e)
+        {
+            Log.Error($"Caught exception while processing entity streams.");
+            _runtimeLog.LogException(e, $"{nameof(AudioSystem)}.{nameof(FrameUpdate)}");
+        }
+    }
+
+    public MapCoordinates GetListenerCoordinates()
+    {
+        return _eyeManager.CurrentEye.Position;
+    }
+
+    private void ProcessStream(EntityUid entity, AudioComponent component, TransformComponent xform, MapCoordinates listener)
+    {
+        // TODO:
+        // I Originally tried to be fancier here but it caused audio issues so just trying
+        // to replicate the old behaviour for now.
+        if (!component.Started)
+        {
+            component.Started = true;
+            component.StartPlaying();
+        }
+
+        // If it's global but on another map (that isn't nullspace) then stop playing it.
+        if (component.Global)
+        {
+            if (xform.MapID != MapId.Nullspace && listener.MapId != xform.MapID)
+            {
+                component.Gain = 0f;
+                return;
+            }
+
+            // Resume playing.
+            component.Volume = component.Params.Volume;
+            return;
+        }
+
+        // Non-global sounds, stop playing if on another map.
+        // Not relevant to us.
+        if (listener.MapId != xform.MapID)
+        {
+            component.Gain = 0f;
+            return;
+        }
+
+        Vector2 worldPos;
+        var gridUid = xform.ParentUid;
+
+        // Handle grid audio differently by using nearest-edge instead of entity centre.
+        if ((component.Flags & AudioFlags.GridAudio) != 0x0)
+        {
+            // It's our grid so max volume.
+            if (_listenerGrid == gridUid)
+            {
+                component.Volume = component.Params.Volume;
+                component.Occlusion = 0f;
+                component.Position = listener.Position;
+                return;
+            }
+
+            // TODO: Need a grid-optimised version because this is gonna be expensive.
+            // Just to avoid clipping on and off grid or nearestPoint changing we'll
+            // always set the sound to listener's pos, we'll just manually do gain ourselves.
+            if (_physics.TryGetNearest(gridUid, listener, out _, out var gridDistance))
+            {
+                // Out of range
+                if (gridDistance > component.MaxDistance)
+                {
+                    component.Gain = 0f;
+                    return;
+                }
+
+                var paramsGain = MathF.Pow(10, component.Params.Volume / 10);
+
+                // Thought I'd never have to manually calculate gain again but this is the least
+                // unpleasant audio I could get at the moment.
+                component.Gain = paramsGain * _audio.GetAttenuationGain(
+                    gridDistance,
+                    component.Params.RolloffFactor,
+                    component.Params.ReferenceDistance,
+                    component.Params.MaxDistance);
+                component.Position = listener.Position;
+                return;
+            }
+
+            // Can't get nearest point so don't play anymore.
+            component.Gain = 0f;
+            return;
+        }
+
+        worldPos = _xformSys.GetWorldPosition(entity);
+        component.Volume = component.Params.Volume;
+
+        // Max distance check
+        var delta = worldPos - listener.Position;
+        var distance = delta.Length();
+
+        // Out of range so just clip it for us.
+        if (distance > component.MaxDistance)
+        {
+            // Still keeps the source playing, just with no volume.
+            component.Gain = 0f;
+            return;
+        }
+
+        if (distance > 0f && distance < 0.01f)
+        {
+            worldPos = listener.Position;
+            delta = Vector2.Zero;
+            distance = 0f;
+        }
+
+        // Update audio occlusion
+        var occlusion = GetOcclusion(listener, delta, distance, entity);
+        component.Occlusion = occlusion;
+
+        // Update audio positions.
+        component.Position = worldPos;
+
+        // Make race cars go NYYEEOOOOOMMMMM
+        if (_physicsQuery.TryGetComponent(entity, out var physicsComp))
+        {
+            // This actually gets the tracked entity's xform & iterates up though the parents for the second time. Bit
+            // inefficient.
+            var velocity = _physics.GetMapLinearVelocity(entity, physicsComp, xform);
+            component.Velocity = velocity;
+        }
+    }
+
+    /// <summary>
+    /// Gets the audio occlusion from the target audio entity to the listener's position.
+    /// </summary>
+    public float GetOcclusion(MapCoordinates listener, Vector2 delta, float distance, EntityUid? ignoredEnt = null)
+    {
+        float occlusion = 0;
+
+        if (distance > 0.1)
+        {
+            var rayLength = MathF.Min(distance, _maxRayLength);
+            var ray = new CollisionRay(listener.Position, delta / distance, OcclusionCollisionMask);
+            occlusion = _physics.IntersectRayPenetration(listener.MapId, ray, rayLength, ignoredEnt);
+        }
+
+        return occlusion;
+    }
+
+    private bool TryGetAudio(string filename, [NotNullWhen(true)] out AudioResource? audio)
+    {
+        if (_resourceCache.TryGetResource(new ResPath(filename), out audio))
+            return true;
+
+        Log.Error($"Server tried to play audio file {filename} which does not exist.");
+        return false;
+    }
+
+    private bool TryCreateAudioSource(AudioStream stream, [NotNullWhen(true)] out IAudioSource? source)
+    {
+        if (!Timing.IsFirstTimePredicted)
+        {
+            source = null;
+            Log.Error($"Tried to create audio source outside of prediction!");
+            DebugTools.Assert(false);
+            return false;
+        }
+
+        source = _audio.CreateAudioSource(stream);
+        return source != null;
+    }
+
+    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string filename, EntityCoordinates coordinates,
+        AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, Filter.Local(), coordinates, true, audioParams);
+    }
+
+    public override (EntityUid Entity, AudioComponent Component)? PlayPvs(string filename, EntityUid uid, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, Filter.Local(), uid, true, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayPredicted(SoundSpecifier? sound, EntityUid source, EntityUid? user, AudioParams? audioParams = null)
+    {
+        if (Timing.IsFirstTimePredicted && sound != null)
+            return PlayEntity(sound, Filter.Local(), source, false, audioParams);
+
+        return null; // uhh Lets hope predicted audio never needs to somehow store the playing audio....
+    }
+
+    public override (EntityUid Entity, AudioComponent Component)? PlayPredicted(SoundSpecifier? sound, EntityCoordinates coordinates, EntityUid? user, AudioParams? audioParams = null)
+    {
+        if (Timing.IsFirstTimePredicted && sound != null)
+            return PlayStatic(sound, Filter.Local(), coordinates, false, audioParams);
+
+        return null;
+    }
+
+    /// <summary>
+    ///     Play an audio file globally, without position.
+    /// </summary>
+    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
+    /// <param name="audioParams"></param>
+    private (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, AudioParams? audioParams = null, bool recordReplay = true)
+    {
+        if (recordReplay && _replayRecording.IsRecording)
+        {
+            _replayRecording.RecordReplayMessage(new PlayAudioGlobalMessage
+            {
+                FileName = filename,
+                AudioParams = audioParams ?? AudioParams.Default
+            });
+        }
+
+        return TryGetAudio(filename, out var audio) ? PlayGlobal(audio, audioParams) : default;
+    }
+
+    /// <summary>
+    ///     Play an audio stream globally, without position.
+    /// </summary>
+    /// <param name="stream">The audio stream to play.</param>
+    /// <param name="audioParams"></param>
+    private (EntityUid Entity, AudioComponent Component)? PlayGlobal(AudioStream stream, AudioParams? audioParams = null)
+    {
+        var (entity, component) = CreateAndStartPlayingStream(audioParams, stream);
+        component.Global = true;
+        component.Source.Global = true;
+        Dirty(entity, component);
+        return (entity, component);
+    }
+
+    /// <summary>
+    ///     Play an audio file following an entity.
+    /// </summary>
+    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
+    /// <param name="entity">The entity "emitting" the audio.</param>
+    private (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, EntityUid entity, AudioParams? audioParams = null, bool recordReplay = true)
+    {
+        if (recordReplay && _replayRecording.IsRecording)
+        {
+            _replayRecording.RecordReplayMessage(new PlayAudioEntityMessage
+            {
+                FileName = filename,
+                NetEntity = GetNetEntity(entity),
+                AudioParams = audioParams ?? AudioParams.Default
+            });
+        }
+
+        return TryGetAudio(filename, out var audio) ? PlayEntity(audio, entity, audioParams) : default;
+    }
+
+    /// <summary>
+    ///     Play an audio stream following an entity.
+    /// </summary>
+    /// <param name="stream">The audio stream to play.</param>
+    /// <param name="entity">The entity "emitting" the audio.</param>
+    /// <param name="audioParams"></param>
+    private (EntityUid Entity, AudioComponent Component)? PlayEntity(AudioStream stream, EntityUid entity, AudioParams? audioParams = null)
+    {
+        if (TerminatingOrDeleted(entity))
+        {
+            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(entity)}");
+            return null;
+        }
+
+        var playing = CreateAndStartPlayingStream(audioParams, stream);
+        _xformSys.SetCoordinates(playing.Entity, new EntityCoordinates(entity, Vector2.Zero));
+
+        return playing;
+    }
+
+    /// <summary>
+    ///     Play an audio file at a static position.
+    /// </summary>
+    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
+    /// <param name="coordinates">The coordinates at which to play the audio.</param>
+    /// <param name="audioParams"></param>
+    private (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, EntityCoordinates coordinates, AudioParams? audioParams = null, bool recordReplay = true)
+    {
+        if (recordReplay && _replayRecording.IsRecording)
+        {
+            _replayRecording.RecordReplayMessage(new PlayAudioPositionalMessage
+            {
+                FileName = filename,
+                Coordinates = GetNetCoordinates(coordinates),
+                AudioParams = audioParams ?? AudioParams.Default
+            });
+        }
+
+        return TryGetAudio(filename, out var audio) ? PlayStatic(audio, coordinates, audioParams) : default;
+    }
+
+    /// <summary>
+    ///     Play an audio stream at a static position.
+    /// </summary>
+    /// <param name="stream">The audio stream to play.</param>
+    /// <param name="coordinates">The coordinates at which to play the audio.</param>
+    /// <param name="audioParams"></param>
+    private (EntityUid Entity, AudioComponent Component)? PlayStatic(AudioStream stream, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    {
+        if (TerminatingOrDeleted(coordinates.EntityId))
+        {
+            Log.Error($"Tried to play coordinates audio on a terminating / deleted entity {ToPrettyString(coordinates.EntityId)}");
+            return null;
+        }
+
+        var playing = CreateAndStartPlayingStream(audioParams, stream);
+        _xformSys.SetCoordinates(playing.Entity, coordinates);
+        return playing;
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, Filter playerFilter, bool recordReplay, AudioParams? audioParams = null)
+    {
+        return PlayGlobal(filename, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, Filter playerFilter, EntityUid entity, bool recordReplay, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, entity, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, Filter playerFilter, EntityCoordinates coordinates, bool recordReplay, AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, coordinates, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, ICommonSession recipient, AudioParams? audioParams = null)
+    {
+        return PlayGlobal(filename, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayGlobal(string filename, EntityUid recipient, AudioParams? audioParams = null)
+    {
+        return PlayGlobal(filename, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, ICommonSession recipient, EntityUid uid, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, uid, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayEntity(string filename, EntityUid recipient, EntityUid uid, AudioParams? audioParams = null)
+    {
+        return PlayEntity(filename, uid, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, ICommonSession recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, coordinates, audioParams);
+    }
+
+    /// <inheritdoc />
+    public override (EntityUid Entity, AudioComponent Component)? PlayStatic(string filename, EntityUid recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
+    {
+        return PlayStatic(filename, coordinates, audioParams);
+    }
+
+    private (EntityUid Entity, AudioComponent Component) CreateAndStartPlayingStream(AudioParams? audioParams, AudioStream stream)
+    {
+        var audioP = audioParams ?? AudioParams.Default;
+        var entity = EntityManager.CreateEntityUninitialized("Audio", MapCoordinates.Nullspace);
+        var comp = SetupAudio(entity, stream.Name!, audioP);
+        EntityManager.InitializeAndStartEntity(entity);
+        var source = comp.Source;
+
+        // TODO clamp the offset inside of SetPlaybackPosition() itself.
+        var offset = audioP.PlayOffsetSeconds;
+        offset = Math.Clamp(offset, 0f, (float) stream.Length.TotalSeconds - 0.01f);
+        source.PlaybackPosition = offset;
+
+        // For server we will rely on the adjusted one but locally we will have to adjust it ourselves.
+        ApplyAudioParams(comp.Params, comp);
+        source.StartPlaying();
+        return (entity, comp);
+    }
+
+    /// <summary>
+    /// Applies the audioparams to the underlying audio source.
+    /// </summary>
+    private void ApplyAudioParams(AudioParams audioParams, IAudioSource source)
+    {
+        source.Pitch = audioParams.Pitch;
+        source.Volume = audioParams.Volume;
+        source.RolloffFactor = audioParams.RolloffFactor;
+        source.MaxDistance = GetAudioDistance(audioParams.MaxDistance);
+        source.ReferenceDistance = GetAudioDistance(audioParams.ReferenceDistance);
+        source.Looping = audioParams.Loop;
+    }
+
+    private void OnEntityCoordinates(PlayAudioPositionalMessage ev)
+    {
+        PlayStatic(ev.FileName, GetCoordinates(ev.Coordinates), ev.AudioParams, false);
+    }
+
+    private void OnEntityAudio(PlayAudioEntityMessage ev)
+    {
+        PlayEntity(ev.FileName, GetEntity(ev.NetEntity), ev.AudioParams, false);
+    }
+
+    private void OnGlobalAudio(PlayAudioGlobalMessage ev)
+    {
+        PlayGlobal(ev.FileName, ev.AudioParams, false);
+    }
+
+    protected override TimeSpan GetAudioLengthImpl(string filename)
+    {
+        return _resourceCache.GetResource<AudioResource>(filename).AudioStream.Length;
+    }
+
+    #region Jobs
+
+    private record struct UpdateAudioJob : IParallelRobustJob
+    {
+        public int BatchSize => 2;
+
+        public AudioSystem System;
+
+        public MapCoordinates OurPosition;
+        public List<(EntityUid Entity, AudioComponent Component, TransformComponent Xform)> Streams;
+
+        public void Execute(int index)
+        {
+            var comp = Streams[index];
+
+            System.ProcessStream(comp.Entity, comp.Component, comp.Xform, OurPosition);
+        }
+    }
+
+    #endregion
+}

Robust.Client/Audio/Effects/AudioEffect.cs

@@ -0,0 +1,455 @@
+using System;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Effects;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio.Effects;
+
+/// <inheritdoc />
+internal sealed class AudioEffect : IAudioEffect
+{
+    internal int Handle;
+
+    private readonly IAudioInternal _master;
+
+    public AudioEffect(IAudioInternal manager)
+    {
+        Handle = EFX.GenEffect();
+        _master = manager;
+        EFX.Effect(Handle, EffectInteger.EffectType, (int) EffectType.EaxReverb);
+    }
+
+    public void Dispose()
+    {
+        if (Handle != 0)
+        {
+            EFX.DeleteEffect(Handle);
+            Handle = 0;
+        }
+    }
+
+    private void _checkDisposed()
+    {
+        if (Handle == -1)
+        {
+            throw new ObjectDisposedException(nameof(AudioEffect));
+        }
+    }
+
+    /// <inheritdoc />
+    public float Density
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDensity, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDensity, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float Diffusion
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDiffusion, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDiffusion, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float Gain
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGain, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbGain, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float GainHF
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainHF, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbGainHF, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float GainLF
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbGainLF, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbGainLF, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float DecayTime
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayTime, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayTime, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float DecayHFRatio
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayHFRatio, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayHFRatio, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float DecayLFRatio
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbDecayLFRatio, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbDecayLFRatio, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ReflectionsGain
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsGain, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsGain, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ReflectionsDelay
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbReflectionsDelay, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbReflectionsDelay, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public Vector3 ReflectionsPan
+    {
+        get
+        {
+            _checkDisposed();
+            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbReflectionsPan);
+            _master._checkAlError();
+            return new Vector3(value.X, value.Z, value.Y);
+        }
+        set
+        {
+            _checkDisposed();
+            var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
+            EFX.Effect(Handle, EffectVector3.EaxReverbReflectionsPan, ref openVec);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float LateReverbGain
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbGain, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbGain, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float LateReverbDelay
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLateReverbDelay, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbLateReverbDelay, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public Vector3 LateReverbPan
+    {
+        get
+        {
+            _checkDisposed();
+            var value = EFX.GetEffect(Handle, EffectVector3.EaxReverbLateReverbPan);
+            _master._checkAlError();
+            return new Vector3(value.X, value.Z, value.Y);
+        }
+        set
+        {
+            _checkDisposed();
+            var openVec = new OpenTK.Mathematics.Vector3(value.X, value.Y, value.Z);
+            EFX.Effect(Handle, EffectVector3.EaxReverbLateReverbPan, ref openVec);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float EchoTime
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoTime, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbEchoTime, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float EchoDepth
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbEchoDepth, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbEchoDepth, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ModulationTime
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationTime, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbModulationTime, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float ModulationDepth
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbModulationDepth, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbModulationDepth, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float AirAbsorptionGainHF
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbAirAbsorptionGainHF, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float HFReference
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbHFReference, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbHFReference, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float LFReference
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbLFReference, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbLFReference, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float RoomRolloffFactor
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectFloat.EaxReverbRoomRolloffFactor, value);
+            _master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public int DecayHFLimit
+    {
+        get
+        {
+            _checkDisposed();
+            EFX.GetEffect(Handle, EffectInteger.EaxReverbDecayHFLimit, out var value);
+            _master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            EFX.Effect(Handle, EffectInteger.EaxReverbDecayHFLimit, value);
+            _master._checkAlError();
+        }
+    }
+}

Robust.Client/Audio/Effects/AuxiliaryAudio.cs

@@ -0,0 +1,32 @@
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Shared.Audio.Effects;
+
+namespace Robust.Client.Audio.Effects;
+
+/// <inheritdoc />
+internal sealed class AuxiliaryAudio : IAuxiliaryAudio
+{
+    internal int Handle = EFX.GenAuxiliaryEffectSlot();
+
+    public void Dispose()
+    {
+        if (Handle != -1)
+        {
+            EFX.DeleteAuxiliaryEffectSlot(Handle);
+            Handle = -1;
+        }
+    }
+
+    /// <inheritdoc />
+    public void SetEffect(IAudioEffect? effect)
+    {
+        if (effect is AudioEffect audEffect)
+        {
+            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, audEffect.Handle);
+        }
+        else
+        {
+            EFX.AuxiliaryEffectSlot(Handle, EffectSlotInteger.Effect, 0);
+        }
+    }
+}

Robust.Client/Audio/HeadlessAudioManager.cs

@@ -0,0 +1,111 @@
+using System;
+using System.IO;
+using System.Numerics;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.AudioLoading;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Headless client audio.
+/// </summary>
+internal sealed class HeadlessAudioManager : IAudioInternal
+{
+    /// <inheritdoc />
+    public void InitializePostWindowing()
+    {
+    }
+
+    /// <inheritdoc />
+    public void Shutdown()
+    {
+    }
+
+    /// <inheritdoc />
+    public void FlushALDisposeQueues()
+    {
+    }
+
+    /// <inheritdoc />
+    public IAudioSource CreateAudioSource(AudioStream stream)
+    {
+        return DummyAudioSource.Instance;
+    }
+
+    /// <inheritdoc />
+    public IBufferedAudioSource? CreateBufferedAudioSource(int buffers, bool floatAudio = false)
+    {
+        return DummyBufferedAudioSource.Instance;
+    }
+
+    /// <inheritdoc />
+    public void SetVelocity(Vector2 velocity)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetPosition(Vector2 position)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetRotation(Angle angle)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetMasterGain(float newGain)
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetAttenuation(Attenuation attenuation)
+    {
+    }
+
+    /// <inheritdoc />
+    public void StopAllAudio()
+    {
+    }
+
+    /// <inheritdoc />
+    public void SetZOffset(float f)
+    {
+    }
+
+    /// <inheritdoc />
+    public void _checkAlError(string callerMember = "", int callerLineNumber = -1)
+    {
+    }
+
+    /// <inheritdoc />
+    public float GetAttenuationGain(float distance, float rolloffFactor, float referenceDistance, float maxDistance)
+    {
+        return 0f;
+    }
+
+    public AudioStream LoadAudioOggVorbis(Stream stream, string? name = null)
+    {
+        var metadata = AudioLoaderOgg.LoadAudioMetadata(stream);
+        return AudioStreamFromMetadata(metadata, name);
+    }
+
+    public AudioStream LoadAudioWav(Stream stream, string? name = null)
+    {
+        var metadata = AudioLoaderWav.LoadAudioMetadata(stream);
+        return AudioStreamFromMetadata(metadata, name);
+    }
+
+    public AudioStream LoadAudioRaw(ReadOnlySpan<short> samples, int channels, int sampleRate, string? name = null)
+    {
+        var length = TimeSpan.FromSeconds((double) samples.Length / channels / sampleRate);
+        return new AudioStream(null, length, channels, name);
+    }
+
+    private static AudioStream AudioStreamFromMetadata(AudioMetadata metadata, string? name)
+    {
+        return new AudioStream(null, metadata.Length, metadata.ChannelCount, name, metadata.Title, metadata.Artist);
+    }
+}

Robust.Client/Audio/IAudioInternal.cs

@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using Robust.Shared.Audio;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Handles clientside audio.
+/// </summary>
+internal interface IAudioInternal : IAudioManager
+{
+    void InitializePostWindowing();
+    void Shutdown();
+
+    /// <summary>
+    /// Flushes all pending queues for disposing of AL sources.
+    /// </summary>
+    void FlushALDisposeQueues();
+
+    IAudioSource? CreateAudioSource(AudioStream stream);
+
+    /// <summary>
+    /// Returns a buffered audio source.
+    /// </summary>
+    /// <returns>null if unable to create the source.</returns>
+    IBufferedAudioSource? CreateBufferedAudioSource(int buffers, bool floatAudio=false);
+
+    /// <summary>
+    /// Sets the velocity for the audio listener.
+    /// </summary>
+    void SetVelocity(Vector2 velocity);
+
+    /// <summary>
+    /// Sets position for the audio listener.
+    /// </summary>
+    void SetPosition(Vector2 position);
+
+    /// <summary>
+    /// Sets rotation for the audio listener.
+    /// </summary>
+    void SetRotation(Angle angle);
+
+    void SetAttenuation(Attenuation attenuation);
+
+    /// <summary>
+    /// Stops all audio from playing.
+    /// </summary>
+    void StopAllAudio();
+
+    /// <summary>
+    /// Sets the Z-offset for the audio listener.
+    /// </summary>
+    void SetZOffset(float f);
+
+    void _checkAlError([CallerMemberName] string callerMember = "", [CallerLineNumber] int callerLineNumber = -1);
+
+    /// <summary>
+    /// Manually calculates the specified gain for an attenuation source with the specified distance.
+    /// </summary>
+    float GetAttenuationGain(float distance, float rolloffFactor, float referenceDistance, float maxDistance);
+
+    AudioStream LoadAudioOggVorbis(Stream stream, string? name = null);
+
+    AudioStream LoadAudioWav(Stream stream, string? name = null);
+
+    AudioStream LoadAudioRaw(ReadOnlySpan<short> samples, int channels, int sampleRate, string? name = null);
+}

Robust.Client/Audio/IAudioManager.cs

@@ -0,0 +1,9 @@
+namespace Robust.Client.Audio;
+
+/// <summary>
+/// Public audio API for stuff that can't go through <see cref="AudioSystem"/>
+/// </summary>
+public interface IAudioManager
+{
+    void SetMasterGain(float gain);
+}

Robust.Client/Audio/Midi/IMidiManager.cs

@@ -17,11 +17,9 @@ public interface IMidiManager
     bool IsAvailable { get; }
 
     /// <summary>
-    ///     Volume, in db.
+    ///     Gain of audio.
     /// </summary>
-    float Volume { get; set; }
-
-    public int OcclusionCollisionMask { get; set; }
+    float Gain { get; set; }
 
     /// <summary>
     ///     This method tries to return a midi renderer ready to be used.

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Audio.Midi;
+using Robust.Shared.Audio.Sources;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
 
@@ -15,11 +18,10 @@ public enum MidiRendererStatus : byte
 
 public interface IMidiRenderer : IDisposable
 {
-
     /// <summary>
     ///     The buffered audio source of this renderer.
     /// </summary>
-    internal IClydeBufferedAudioSource Source { get; }
+    internal IBufferedAudioSource Source { get; }
 
     /// <summary>
     ///     Whether this renderer has been disposed or not.
@@ -34,6 +36,7 @@ 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>
@@ -94,6 +97,27 @@ 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>
@@ -120,6 +144,11 @@ public interface IMidiRenderer : IDisposable
     /// </summary>
     void StopAllNotes();
 
+    /// <summary>
+    ///     Reset renderer back to a clean state.
+    /// </summary>
+    void SystemReset();
+
     /// <summary>
     /// Clears all scheduled events.
     /// </summary>
@@ -156,7 +185,7 @@ public interface IMidiRenderer : IDisposable
     ///     This is only used if <see cref="Mono"/> is set to True
     ///     and <see cref="TrackingEntity"/> is null.
     /// </summary>
-    EntityCoordinates? TrackingCoordinates { get; set; }
+    MapCoordinates? TrackingCoordinates { get; set; }
 
     MidiRendererState RendererState { get; }
 
@@ -164,7 +193,8 @@ public interface IMidiRenderer : IDisposable
     ///     Send a midi event for the renderer to play.
     /// </summary>
     /// <param name="midiEvent">The midi event to be played</param>
-    void SendMidiEvent(RobustMidiEvent midiEvent);
+    /// <param name="raiseEvent">Whether to raise an event for this event.</param>
+    void SendMidiEvent(RobustMidiEvent midiEvent, bool raiseEvent = true);
 
     /// <summary>
     ///     Schedule a MIDI event to be played at a later time.
@@ -177,7 +207,7 @@ public interface IMidiRenderer : IDisposable
     /// <summary>
     ///     Apply a certain state to the renderer.
     /// </summary>
-    void ApplyState(MidiRendererState state);
+    void ApplyState(MidiRendererState state, bool filterChannels = false);
 
     /// <summary>
     ///     Actually disposes of this renderer. Do NOT use outside the MIDI thread.

Robust.Client/Audio/Midi/MidiManager.cs

@@ -1,22 +1,27 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Numerics;
 using System.Runtime.InteropServices;
 using System.Threading;
+using System.Threading.Tasks;
 using NFluidsynth;
-using Robust.Client.Graphics;
-using Robust.Client.ResourceManagement;
 using Robust.Shared;
 using Robust.Shared.Asynchronous;
+using Robust.Shared.Audio.Midi;
+using Robust.Shared.Collections;
 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;
 
@@ -26,15 +31,19 @@ internal sealed partial class MidiManager : IMidiManager
 {
     public const string SoundfontEnvironmentVariable = "ROBUST_SOUNDFONT_OVERRIDE";
 
-    [Dependency] private readonly IEyeManager _eyeManager = default!;
-    [Dependency] private readonly IResourceCacheInternal _resourceManager = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IResourceManager _resourceManager = default!;
     [Dependency] private readonly IEntityManager _entityManager = default!;
     [Dependency] private readonly IConfigurationManager _cfgMan = default!;
-    [Dependency] private readonly IClydeAudio _clydeAudio = default!;
+    [Dependency] private readonly IAudioInternal _audio = 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!;
 
+    private AudioSystem _audioSys = default!;
     private SharedPhysicsSystem _broadPhaseSystem = default!;
+    private SharedTransformSystem _xformSystem = default!;
 
     public IReadOnlyList<IMidiRenderer> Renderers
     {
@@ -59,27 +68,34 @@ internal sealed partial class MidiManager : IMidiManager
         }
     }
 
-    [ViewVariables]
-    private readonly List<IMidiRenderer> _renderers = new();
+    [ViewVariables] private readonly List<IMidiRenderer> _renderers = new();
+
+    // To avoid lock contention until some kind of MIDI refactor.
+    private TimeSpan _nextUpdate;
+    private TimeSpan _updateFrequency = TimeSpan.FromSeconds(0.1f);
+
+    private SemaphoreSlim _updateSemaphore = new(1);
 
     private bool _alive = true;
-    private Settings? _settings;
+    [ViewVariables] private Settings? _settings;
     private Thread? _midiThread;
     private ISawmill _midiSawmill = default!;
-    private float _volume = 0f;
+    private float _gain = 0f;
     private bool _volumeDirty = true;
 
     // Not reliable until Fluidsynth is initialized!
     [ViewVariables(VVAccess.ReadWrite)]
-    public float Volume
+    public float Gain
     {
-        get => _volume;
+        get => _gain;
         set
         {
-            if (MathHelper.CloseToPercent(_volume, value))
+            var clamped = Math.Clamp(value, 0f, 1f);
+
+            if (MathHelper.CloseToPercent(_gain, clamped))
                 return;
 
-            _cfgMan.SetCVar(CVars.MidiVolume, value);
+            _cfgMan.SetCVar(CVars.MidiVolume, clamped);
             _volumeDirty = true;
         }
     }
@@ -115,11 +131,10 @@ internal sealed partial class MidiManager : IMidiManager
     private bool _failedInitialize;
 
     private NFluidsynth.Logger.LoggerDelegate _loggerDelegate = default!;
-    private ISawmill _sawmill = default!;
-    private float _maxCastLength;
+    private ISawmill _fluidsynthSawmill = default!;
+
+    private MidiUpdateJob _updateJob;
 
-    [ViewVariables(VVAccess.ReadWrite)]
-    public int OcclusionCollisionMask { get; set; }
 
     public MidiManager()
     {
@@ -130,10 +145,9 @@ internal sealed partial class MidiManager : IMidiManager
     {
         if (FluidsynthInitialized || _failedInitialize) return;
 
-        _volume = _cfgMan.GetCVar(CVars.MidiVolume);
         _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
         {
-            _volume = value;
+            _gain = value;
             _volumeDirty = true;
         }, true);
 
@@ -143,7 +157,7 @@ internal sealed partial class MidiManager : IMidiManager
 #else
         _midiSawmill.Level = LogLevel.Error;
 #endif
-        _sawmill = _logger.GetSawmill("midi.fluidsynth");
+        _fluidsynthSawmill = _logger.GetSawmill("midi.fluidsynth");
         _loggerDelegate = LoggerDelegate;
 
         if (!_resourceManager.UserData.Exists(CustomSoundfontDirectory))
@@ -167,8 +181,6 @@ 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";
@@ -176,8 +188,11 @@ 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)
         {
@@ -189,15 +204,31 @@ internal sealed partial class MidiManager : IMidiManager
         _midiThread = new Thread(ThreadUpdate);
         _midiThread.Start();
 
+        _updateJob = new MidiUpdateJob()
+        {
+            Manager = this,
+            Renderers = _renderers,
+        };
+
+        _audioSys = _entityManager.EntitySysManager.GetEntitySystem<AudioSystem>();
         _broadPhaseSystem = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
-        _cfgMan.OnValueChanged(CVars.AudioRaycastLength, OnRaycastLengthChanged, true);
+        _xformSystem = _entityManager.System<SharedTransformSystem>();
+        _entityManager.GetEntityQuery<PhysicsComponent>();
+        _entityManager.GetEntityQuery<TransformComponent>();
 
         FluidsynthInitialized = true;
     }
 
-    private void OnRaycastLengthChanged(float value)
+    private void UpdateParallelCount()
     {
-        _maxCastLength = value;
+        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 LoggerDelegate(NFluidsynth.Logger.LogLevel level, string message, IntPtr data)
@@ -211,7 +242,7 @@ internal sealed partial class MidiManager : IMidiManager
             NFluidsynth.Logger.LogLevel.Debug => LogLevel.Debug,
             _ => LogLevel.Debug
         };
-        _sawmill.Log(rLevel, message);
+        _fluidsynthSawmill.Log(rLevel, message);
     }
 
     public IMidiRenderer? GetNewRenderer(bool mono = true)
@@ -236,9 +267,9 @@ internal sealed partial class MidiManager : IMidiManager
         {
             soundfontLoader.SetCallbacks(_soundfontLoaderCallbacks);
 
-            var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _clydeAudio, _taskManager, _midiSawmill);
+            var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _audio, _taskManager, _midiSawmill);
 
-            _midiSawmill.Debug($"Loading soundfont {FallbackSoundfont}");
+            _midiSawmill.Debug($"Loading fallback soundfont {FallbackSoundfont}");
             // Since the last loaded soundfont takes priority, we load the fallback soundfont before the soundfont.
             renderer.LoadSoundfont(FallbackSoundfont);
 
@@ -252,8 +283,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)
                     {
@@ -267,7 +298,7 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(OsxSoundfont) && SoundFont.IsSoundFont(OsxSoundfont))
                 {
-                    _midiSawmill.Debug($"Loading soundfont {OsxSoundfont}");
+                    _midiSawmill.Debug($"Loading OS soundfont {OsxSoundfont}");
                     renderer.LoadSoundfont(OsxSoundfont);
                 }
             }
@@ -275,7 +306,7 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(WindowsSoundfont) && SoundFont.IsSoundFont(WindowsSoundfont))
                 {
-                    _midiSawmill.Debug($"Loading soundfont {WindowsSoundfont}");
+                    _midiSawmill.Debug($"Loading OS soundfont {WindowsSoundfont}");
                     renderer.LoadSoundfont(WindowsSoundfont);
                 }
             }
@@ -286,31 +317,35 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(soundfontOverride) && SoundFont.IsSoundFont(soundfontOverride))
                 {
-                    _midiSawmill.Debug($"Loading soundfont {soundfontOverride} from environment variable.");
+                    _midiSawmill.Debug($"Loading environment variable soundfont {soundfontOverride}");
                     renderer.LoadSoundfont(soundfontOverride);
                 }
             }
 
             // Load content-specific custom soundfonts, which should override the system/fallback soundfont.
-            _midiSawmill.Debug($"Loading soundfonts from {ContentCustomSoundfontDirectory}");
+            _midiSawmill.Debug($"Loading soundfonts from content directory {ContentCustomSoundfontDirectory}");
             foreach (var file in _resourceManager.ContentFindFiles(ContentCustomSoundfontDirectory))
             {
                 if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
-                _midiSawmill.Debug($"Loading soundfont {file}");
+                _midiSawmill.Debug($"Loading content 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 {{USERDATA}} {CustomSoundfontDirectory}");
-            var enumerator = _resourceManager.UserData.Find($"{CustomSoundfontDirectory.ToRelativePath()}/*").Item1;
+            _midiSawmill.Debug($"Loading soundfonts from user data directory {userDataPath}");
+            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 soundfont {{USERDATA}} {file}");
+                _midiSawmill.Debug($"Loading user soundfont {file}");
                 renderer.LoadSoundfont(file.ToString());
             }
 
-            renderer.Source.SetVolume(Volume);
+            renderer.Source.Gain = _gain;
 
             lock (_renderers)
             {
@@ -331,78 +366,127 @@ internal sealed partial class MidiManager : IMidiManager
             return;
         }
 
-        // Update positions of streams every frame.
+        if (_nextUpdate > _timing.RealTime)
+            return;
+
+        _nextUpdate = _timing.RealTime + _updateFrequency;
+
+        // Update positions of streams occasionally.
         // This has a lot of code duplication with AudioSystem.FrameUpdate(), and they should probably be combined somehow.
+        // so TRUE
 
-        lock (_renderers)
-        {
-            foreach (var renderer in _renderers)
-            {
-                if (renderer.Disposed)
-                    continue;
+        _updateJob.OurPosition = _audioSys.GetListenerCoordinates();
 
-                if(_volumeDirty)
-                    renderer.Source.SetVolume(Volume);
+        // This semaphore is here to avoid lock contention as much as possible.
+        _updateSemaphore.Wait();
 
-                if (!renderer.Mono)
-                {
-                    renderer.Source.SetGlobal();
-                    continue;
-                }
+        // The ONLY time this should be contested is with ThreadUpdate.
+        // If that becomes NOT the case then just lock this, remove the semaphore, and drop the update frequency even harder.
+        // ReSharper disable once InconsistentlySynchronizedField
+        _parallel.ProcessNow(_updateJob, _renderers.Count);
 
-                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);
-                }
-            }
-        }
+        _updateSemaphore.Release();
 
         _volumeDirty = false;
     }
 
+    private void UpdateRenderer(IMidiRenderer renderer, MapCoordinates listener)
+    {
+        // TODO: This should be sharing more code with AudioSystem.
+        try
+        {
+            if (renderer.Disposed)
+                return;
+
+            if (_volumeDirty)
+            {
+                renderer.Source.Gain = Gain;
+            }
+
+            if (!renderer.Mono)
+            {
+                renderer.Source.Global = true;
+                return;
+            }
+
+            MapCoordinates mapPos;
+
+            if (renderer.TrackingEntity is {} trackedEntity && !_entityManager.Deleted(trackedEntity))
+            {
+                renderer.TrackingCoordinates = _xformSystem.GetMapCoordinates(renderer.TrackingEntity.Value);
+
+                // Pause it if the attached entity is paused.
+                if (_entityManager.IsPaused(renderer.TrackingEntity))
+                {
+                    renderer.Source.Pause();
+                    return;
+                }
+            }
+            else if (renderer.TrackingCoordinates == null)
+            {
+                renderer.Source.Pause();
+                return;
+            }
+
+            mapPos = renderer.TrackingCoordinates.Value;
+
+            // If it's on a different map then just mute it, not pause.
+            if (mapPos.MapId == MapId.Nullspace || mapPos.MapId != listener.MapId)
+            {
+                renderer.Source.Gain = 0f;
+                return;
+            }
+
+            // Was previously muted maybe so try unmuting it?
+            if (renderer.Source.Gain == 0f)
+            {
+                renderer.Source.Gain = Gain;
+            }
+
+            var worldPos = mapPos.Position;
+            var delta = worldPos - listener.Position;
+            var distance = delta.Length();
+
+            // Update position
+            // Out of range so just clip it for us.
+            if (distance > renderer.Source.MaxDistance)
+            {
+                // Still keeps the source playing, just with no volume.
+                renderer.Source.Gain = 0f;
+                return;
+            }
+
+            // Same imprecision suppression as audiosystem.
+            if (distance > 0f && distance < 0.01f)
+            {
+                worldPos = listener.Position;
+                delta = Vector2.Zero;
+                distance = 0f;
+            }
+
+            renderer.Source.Position = worldPos;
+
+            // Update velocity (doppler).
+            if (!_entityManager.Deleted(renderer.TrackingEntity))
+            {
+                var velocity = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity.Value);
+                renderer.Source.Velocity = velocity;
+            }
+            else
+            {
+                renderer.Source.Velocity = Vector2.Zero;
+            }
+
+            // Update occlusion
+            var occlusion = _audioSys.GetOcclusion(listener, delta, distance, renderer.TrackingEntity);
+            renderer.Source.Occlusion = occlusion;
+        }
+        catch (Exception ex)
+        {
+            _runtime.LogException(ex, _midiSawmill.Name);
+        }
+    }
+
     /// <summary>
     ///     Main method for the thread rendering the midi audio.
     /// </summary>
@@ -412,16 +496,39 @@ internal sealed partial class MidiManager : IMidiManager
         {
             lock (_renderers)
             {
+                var toRemove = new ValueList<IMidiRenderer>();
+
                 for (var i = 0; i < _renderers.Count; i++)
                 {
                     var renderer = _renderers[i];
-                    if (!renderer.Disposed)
-                        renderer.Render();
-                    else
+
+                    lock (renderer)
+                    {
+                        if (!renderer.Disposed)
+                        {
+                            if (renderer.Master is { Disposed: true })
+                                renderer.Master = null;
+
+                            renderer.Render();
+                        }
+                        else
+                        {
+                            toRemove.Add(renderer);
+                        }
+                    }
+                }
+
+                if (toRemove.Count > 0)
+                {
+                    _updateSemaphore.Wait();
+
+                    foreach (var renderer in toRemove)
                     {
                         renderer.InternalDispose();
                         _renderers.Remove(renderer);
                     }
+
+                    _updateSemaphore.Release();
                 }
             }
 
@@ -592,4 +699,31 @@ internal sealed partial class MidiManager : IMidiManager
 
         }
     }
+
+    #region Jobs
+
+    private record struct MidiUpdateJob : IParallelRobustJob
+    {
+        public int MinimumBatchParallel => 2;
+
+        public int BatchSize => 1;
+
+        public MidiManager Manager;
+
+        public MapCoordinates OurPosition;
+        public List<IMidiRenderer> Renderers;
+
+        public void Execute(int index)
+        {
+            // The indices shouldn't be able to be touched while this job is running, just the renderer itself getting locked.
+            var renderer = Renderers[index];
+
+            lock (renderer)
+            {
+                Manager.UpdateRenderer(renderer, OurPosition);
+            }
+        }
+    }
+
+    #endregion
 }

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -1,15 +1,18 @@
 using System;
+using System.Collections;
+using JetBrains.Annotations;
 using NFluidsynth;
 using Robust.Client.Graphics;
 using Robust.Shared.Asynchronous;
+using Robust.Shared.Audio;
 using Robust.Shared.Audio.Midi;
+using Robust.Shared.Audio.Sources;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Log;
 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;
 
@@ -21,14 +24,13 @@ 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 = 16;
+    private const int ChannelCount = RobustMidiEvent.MaxChannels;
 
     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,11 +50,12 @@ internal sealed class MidiRenderer : IMidiRenderer
     private readonly SequencerClientId _robustRegister;
     private readonly SequencerClientId _debugRegister;
 
-    [ViewVariables]
-    private MidiRendererState _rendererState = new();
+    [ViewVariables] private MidiRendererState _rendererState = new();
+
+    private IMidiRenderer? _master;
     public MidiRendererState RendererState => _rendererState;
-    public IClydeBufferedAudioSource Source { get; set; }
-    IClydeBufferedAudioSource IMidiRenderer.Source => Source;
+    public IBufferedAudioSource Source { get; set; }
+    IBufferedAudioSource IMidiRenderer.Source => Source;
 
     [ViewVariables]
     public bool Disposed { get; private set; } = false;
@@ -70,8 +73,8 @@ internal sealed class MidiRenderer : IMidiRenderer
             {
                 for (byte i = 0; i < ChannelCount; i++)
                 {
-                    // Channel 9 is the percussion channel. Let's not change its instrument...
-                    if (i == 9)
+                    // Don't change percussion channel instrument.
+                    if (i == RobustMidiEvent.PercussionChannel)
                         continue;
 
                     SendMidiEvent(RobustMidiEvent.ProgramChange(i, value, SequencerTick));
@@ -96,11 +99,14 @@ internal sealed class MidiRenderer : IMidiRenderer
             {
                 for (byte i = 0; i < ChannelCount; i++)
                 {
-                    // Channel 9 is the percussion channel. Let's not change its bank...
-                    if (i == 9)
+                    // Don't change percussion channel bank.
+                    if (i == RobustMidiEvent.PercussionChannel)
                         continue;
 
                     SendMidiEvent(RobustMidiEvent.BankSelect(i, value, SequencerTick));
+
+                    // Re-select program.
+                    SendMidiEvent(RobustMidiEvent.ProgramChange(i, _midiProgram, SequencerTick));
                 }
             }
 
@@ -128,7 +134,11 @@ internal sealed class MidiRenderer : IMidiRenderer
     }
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public bool DisablePercussionChannel { get; set; } = true;
+    public bool DisablePercussionChannel
+    {
+        get => FilteredChannels[RobustMidiEvent.PercussionChannel];
+        set => FilteredChannels[RobustMidiEvent.PercussionChannel] = value;
+    }
 
     [ViewVariables(VVAccess.ReadWrite)]
     public bool DisableProgramChangeEvent { get; set; } = true;
@@ -181,22 +191,71 @@ internal sealed class MidiRenderer : IMidiRenderer
     }
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public bool VolumeBoost { get; set; }
+    [Obsolete($"Use {nameof(VelocityOverride)} instead, you can set it to 127 to achieve the same effect.")]
+    public bool VolumeBoost
+    {
+        get => VelocityOverride == 127;
+        set => VelocityOverride = value ? 127 : null;
+    }
 
     [ViewVariables(VVAccess.ReadWrite)]
     public EntityUid? TrackingEntity { get; set; } = null;
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public EntityCoordinates? TrackingCoordinates { get; set; } = null;
+    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;
 
     internal MidiRenderer(Settings settings, SoundFontLoader soundFontLoader, bool mono,
-        IMidiManager midiManager, IClydeAudio clydeAudio, ITaskManager taskManager, ISawmill midiSawmill)
+        IMidiManager midiManager, IAudioInternal clydeAudio, ITaskManager taskManager, ISawmill midiSawmill)
     {
         _midiManager = midiManager;
         _taskManager = taskManager;
         _midiSawmill = midiSawmill;
 
-        Source = clydeAudio.CreateBufferedAudioSource(Buffers, true);
+        Source = clydeAudio.CreateBufferedAudioSource(Buffers, true) ?? DummyBufferedAudioSource.Instance;
         Source.SampleRate = SampleRate;
         _settings = settings;
         _soundFontLoader = soundFontLoader;
@@ -354,6 +413,11 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
+    public void SystemReset()
+    {
+        SendMidiEvent(RobustMidiEvent.SystemReset(SequencerTick));
+    }
+
     public void ClearAllEvents()
     {
         _sequencer.RemoveEvents(SequencerClientId.Wildcard, SequencerClientId.Wildcard, -1);
@@ -368,9 +432,6 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
-    public event Action<RobustMidiEvent>? OnMidiEvent;
-    public event Action? OnMidiPlayerFinished;
-
     void IMidiRenderer.Render()
     {
         Render();
@@ -429,10 +490,10 @@ internal sealed class MidiRenderer : IMidiRenderer
             }
         }
 
-        if (!Source.IsPlaying) Source.StartPlaying();
+        Source.StartPlaying();
     }
 
-    public void ApplyState(MidiRendererState state)
+    public void ApplyState(MidiRendererState state, bool filterChannels = false)
     {
         lock (_playerStateLock)
         {
@@ -440,6 +501,9 @@ 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]);
@@ -462,7 +526,8 @@ internal sealed class MidiRenderer : IMidiRenderer
                     }
                 }
 
-                _synth.ProgramChange(channel, state.Program.AsSpan[channel]);
+                var program = DisableProgramChangeEvent ? MidiProgram : state.Program.AsSpan[channel];
+                _synth.ProgramChange(channel, program);
 
                 for (var key = 0; key < state.NoteVelocities.AsSpan[channel].AsSpan.Length; key++)
                 {
@@ -487,7 +552,12 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
-    public void SendMidiEvent(RobustMidiEvent midiEvent)
+    private void SendMidiEvent(RobustMidiEvent midiEvent)
+    {
+        SendMidiEvent(midiEvent, true);
+    }
+
+    public void SendMidiEvent(RobustMidiEvent midiEvent, bool raiseEvent)
     {
         if (Disposed)
             return;
@@ -505,11 +575,10 @@ internal sealed class MidiRenderer : IMidiRenderer
                         break;
 
                     case RobustMidiCommand.NoteOn:
-                        // Channel 9 is the percussion channel. We only block NoteOn events to it.
-                        if (DisablePercussionChannel && midiEvent.Channel == 9)
-                            return;
+                        if (FilteredChannels[midiEvent.Channel])
+                            break;
 
-                        var velocity = (byte)(VolumeBoost ? 127 : midiEvent.Velocity);
+                        var velocity = VelocityOverride ?? midiEvent.Velocity;
 
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = velocity;
                         _synth.NoteOn(midiEvent.Channel, midiEvent.Key, velocity);
@@ -523,7 +592,7 @@ internal sealed class MidiRenderer : IMidiRenderer
                     case RobustMidiCommand.ControlChange:
                         // CC0 is bank selection
                         if (midiEvent.Control == 0x0 && DisableProgramChangeEvent)
-                            return;
+                            break;
 
                         _rendererState.Controllers.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Control] = midiEvent.Value;
                         if(midiEvent.Control != 0x0)
@@ -534,7 +603,7 @@ internal sealed class MidiRenderer : IMidiRenderer
 
                     case RobustMidiCommand.ProgramChange:
                         if (DisableProgramChangeEvent)
-                            return;
+                            break;
 
                         _rendererState.Program.AsSpan[midiEvent.Channel] = midiEvent.Program;
                         _synth.ProgramChange(midiEvent.Channel, midiEvent.Program);
@@ -561,14 +630,14 @@ internal sealed class MidiRenderer : IMidiRenderer
                         switch (midiEvent.Control)
                         {
                             case 0x0 when midiEvent.Status == 0xFF:
-                                _rendererState = new ();
+                                _rendererState = new MidiRendererState();
                                 _synth.SystemReset();
 
                                 // Reset the instrument to the one we were using.
                                 if (DisableProgramChangeEvent)
                                 {
-                                    MidiProgram = _midiProgram;
                                     MidiBank = _midiBank;
+                                    MidiProgram = _midiProgram;
                                 }
 
                                 break;
@@ -597,7 +666,10 @@ internal sealed class MidiRenderer : IMidiRenderer
             //_midiSawmill.Error("Exception while sending midi event of type {0}: {1}", midiEvent.Type, e, midiEvent);
         }
 
-        _taskManager.RunOnMainThread(() => OnMidiEvent?.Invoke(midiEvent));
+        if (raiseEvent)
+        {
+            _taskManager.RunOnMainThread(() => OnMidiEvent?.Invoke(midiEvent));
+        }
     }
 
     public void ScheduleMidiEvent(RobustMidiEvent midiEvent, uint time, bool absolute = false)
@@ -633,6 +705,9 @@ internal sealed class MidiRenderer : IMidiRenderer
     /// <inheritdoc />
     void IMidiRenderer.InternalDispose()
     {
+        OnMidiEvent = null;
+        OnMidiPlayerFinished = null;
+
         Source?.Dispose();
         _driver?.Dispose();
 

Robust.Client/Audio/Midi/MidiRendererState.cs

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

Robust.Client/Audio/ShowAudioCommand.cs

@@ -0,0 +1,34 @@
+using Robust.Client.Audio;
+using Robust.Client.GameObjects;
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+
+namespace Robust.Client.Commands;
+
+/// <summary>
+/// Shows a debug overlay for audio sources.
+/// </summary>
+public sealed class ShowAudioCommand : LocalizedCommands
+{
+    [Dependency] private readonly IResourceCache _client = default!;
+    [Dependency] private readonly IEntityManager _entManager = default!;
+    [Dependency] private readonly IOverlayManager _overlayManager = default!;
+    [Dependency] private readonly IPlayerManager _playerMgr = default!;
+    public override string Command => "showaudio";
+    public override void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        if (_overlayManager.HasOverlay<AudioOverlay>())
+            _overlayManager.RemoveOverlay<AudioOverlay>();
+        else
+            _overlayManager.AddOverlay(new AudioOverlay(
+                _entManager,
+                _playerMgr,
+                _client,
+                _entManager.System<AudioSystem>(),
+                _entManager.System<SharedTransformSystem>()));
+    }
+}

Robust.Client/Audio/Sources/AudioSource.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Numerics;
+using OpenTK.Audio.OpenAL;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Shared.Audio;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.Audio.Sources;
+
+internal sealed class AudioSource : BaseAudioSource
+{
+    /// <summary>
+    /// Underlying stream to the audio.
+    /// </summary>
+    private readonly AudioStream _sourceStream;
+
+#if DEBUG
+    private bool _didPositionWarning;
+#endif
+
+    public AudioSource(AudioManager master, int sourceHandle, AudioStream sourceStream) : base(master, sourceHandle)
+    {
+        _sourceStream = sourceStream;
+    }
+
+    /// <inheritdoc />
+    public override Vector2 Position
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSource3f.Position, out var x, out var y, out _);
+            Master._checkAlError();
+            return new Vector2(x, y);
+        }
+        set
+        {
+            _checkDisposed();
+
+            var (x, y) = value;
+
+            if (!AreFinite(x, y))
+            {
+                return;
+            }
+#if DEBUG
+            // OpenAL doesn't seem to want to play stereo positionally.
+            // Log a warning if people try to.
+            if (_sourceStream.ChannelCount > 1 && !_didPositionWarning)
+            {
+                _didPositionWarning = true;
+                Master.OpenALSawmill.Warning("Attempting to set position on audio source with multiple audio channels! Stream: '{0}'.  Make sure the audio is MONO, not stereo.",
+                    _sourceStream.Name);
+                // warning isn't enough, people just ignore it :(
+                DebugTools.Assert(false, $"Attempting to set position on audio source with multiple audio channels! Stream: '{_sourceStream.Name}'. Make sure the audio is MONO, not stereo.");
+            }
+#endif
+
+            AL.Source(SourceHandle, ALSource3f.Position, x, y, 0);
+            Master._checkAlError();
+        }
+    }
+
+    ~AudioSource()
+    {
+        Dispose(false);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (!disposing)
+        {
+            // We can't run this code inside the finalizer thread so tell Clyde to clear it up later.
+            Master.DeleteSourceOnMainThread(SourceHandle, FilterHandle);
+        }
+        else
+        {
+            if (FilterHandle != 0)
+                EFX.DeleteFilter(FilterHandle);
+
+            AL.DeleteSource(SourceHandle);
+            Master.RemoveAudioSource(SourceHandle);
+            Master._checkAlError();
+        }
+
+        FilterHandle = 0;
+        SourceHandle = -1;
+    }
+}

Robust.Client/Audio/Sources/BaseAudioSource.cs

@@ -0,0 +1,407 @@
+using System;
+using System.Numerics;
+using OpenTK.Audio.OpenAL;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Client.Audio.Effects;
+using Robust.Shared.Audio.Effects;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Audio.Systems;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio.Sources;
+
+internal abstract class BaseAudioSource : IAudioSource
+{
+    /*
+     * This may look weird having all these methods here however
+     * we need to handle disposing plus checking for errors hence we get this.
+     */
+
+    /// <summary>
+    /// Handle to the AL source.
+    /// </summary>
+    protected int SourceHandle;
+
+    /// <summary>
+    /// Source to the EFX filter if applicable.
+    /// </summary>
+    protected int FilterHandle;
+
+    protected readonly AudioManager Master;
+
+    /// <summary>
+    /// Prior gain that was set.
+    /// </summary>
+    private float _gain;
+
+    private float _occlusion;
+
+    private bool IsEfxSupported => Master.IsEfxSupported;
+
+    protected BaseAudioSource(AudioManager master, int sourceHandle)
+    {
+        Master = master;
+        SourceHandle = sourceHandle;
+        AL.GetSource(SourceHandle, ALSourcef.Gain, out _gain);
+    }
+
+    public void Pause()
+    {
+        AL.SourcePause(SourceHandle);
+    }
+
+    /// <inheritdoc />
+    public void StartPlaying()
+    {
+        if (Playing)
+            return;
+
+        Playing = true;
+    }
+
+    /// <inheritdoc />
+    public void StopPlaying()
+    {
+        if (!Playing)
+            return;
+
+        Playing = false;
+    }
+
+    /// <inheritdoc />
+    public virtual bool Playing
+    {
+        get
+        {
+            _checkDisposed();
+            var state = AL.GetSourceState(SourceHandle);
+            Master._checkAlError();
+            return state == ALSourceState.Playing;
+        }
+        set
+        {
+            _checkDisposed();
+
+            if (value)
+            {
+                AL.SourcePlay(SourceHandle);
+            }
+            else
+            {
+                AL.SourceStop(SourceHandle);
+            }
+
+
+            Master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public bool Looping
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourceb.Looping, out var ret);
+            Master._checkAlError();
+            return ret;
+        }
+        set
+        {
+            _checkDisposed();
+            AL.Source(SourceHandle, ALSourceb.Looping, value);
+            Master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public bool Global
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourceb.SourceRelative, out var value);
+            Master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            AL.Source(SourceHandle, ALSourceb.SourceRelative, value);
+            Master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public virtual Vector2 Position
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSource3f.Position, out var x, out var y, out _);
+            Master._checkAlError();
+            return new Vector2(x, y);
+        }
+        set
+        {
+            _checkDisposed();
+
+            var (x, y) = value;
+
+            if (!AreFinite(x, y))
+            {
+                return;
+            }
+
+            AL.Source(SourceHandle, ALSource3f.Position, x, y, 0);
+            Master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float Pitch
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourcef.Pitch, out var value);
+            Master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            AL.Source(SourceHandle, ALSourcef.Pitch, value);
+            Master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float Volume
+    {
+        get
+        {
+            var gain = Gain;
+            var volume = SharedAudioSystem.GainToVolume(gain);
+            return volume;
+        }
+        set => Gain = SharedAudioSystem.VolumeToGain(value);
+    }
+
+    /// <inheritdoc />
+    public float Gain
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourcef.Gain, out var gain);
+            Master._checkAlError();
+            return gain;
+        }
+        set
+        {
+            _checkDisposed();
+            var priorOcclusion = 1f;
+            if (!IsEfxSupported)
+            {
+                AL.GetSource(SourceHandle, ALSourcef.Gain, out var priorGain);
+                // Default to 0 to avoid spiking audio, just means it will be muted for a frame in this case.
+                priorOcclusion = _gain == 0 ? 1f : priorGain / _gain;
+            }
+
+            _gain = value;
+            AL.Source(SourceHandle, ALSourcef.Gain, _gain * priorOcclusion);
+            Master.LogALError($"Gain is {_gain:0.00} and priorOcclusion is {priorOcclusion:0.00}. EFX supported: {IsEfxSupported}");
+        }
+    }
+
+    /// <inheritdoc />
+    public float MaxDistance
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourcef.MaxDistance, out var value);
+            Master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            AL.Source(SourceHandle, ALSourcef.MaxDistance, value);
+            Master.LogALError($"MaxDistance is {value:0.00}");
+        }
+    }
+
+    /// <inheritdoc />
+    public float RolloffFactor
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourcef.RolloffFactor, out var value);
+            Master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            AL.Source(SourceHandle, ALSourcef.RolloffFactor, value);
+            Master.LogALError($"RolloffFactor is {value:0.00}");
+        }
+    }
+
+    /// <inheritdoc />
+    public float ReferenceDistance
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourcef.ReferenceDistance, out var value);
+            Master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            AL.Source(SourceHandle, ALSourcef.ReferenceDistance, value);
+            Master.LogALError($"ReferenceDistance is {value:0.00}");
+        }
+    }
+
+    /// <inheritdoc />
+    public float Occlusion
+    {
+        get => _occlusion;
+        set
+        {
+            _checkDisposed();
+            var cutoff = MathF.Exp(-value * 1);
+            var gain = MathF.Pow(cutoff, 0.1f);
+            if (IsEfxSupported)
+            {
+                SetOcclusionEfx(gain, cutoff);
+            }
+            else
+            {
+                gain *= gain * gain;
+                AL.Source(SourceHandle, ALSourcef.Gain, _gain * gain);
+            }
+
+            _occlusion = value;
+            Master._checkAlError();
+        }
+    }
+
+    /// <inheritdoc />
+    public float PlaybackPosition
+    {
+        get
+        {
+            _checkDisposed();
+            AL.GetSource(SourceHandle, ALSourcef.SecOffset, out var value);
+            Master._checkAlError();
+            return value;
+        }
+        set
+        {
+            _checkDisposed();
+            AL.Source(SourceHandle, ALSourcef.SecOffset, value);
+            Master._checkAlError($"Tried to set invalid playback position of {value:0.00}");
+        }
+    }
+
+    /// <inheritdoc />
+    public Vector2 Velocity
+    {
+        get
+        {
+            _checkDisposed();
+
+            AL.GetSource(SourceHandle, ALSource3f.Velocity, out var x, out var y, out _);
+            Master._checkAlError();
+            return new Vector2(x, y);
+        }
+        set
+        {
+            _checkDisposed();
+
+            var (x, y) = value;
+
+            if (!AreFinite(x, y))
+            {
+                return;
+            }
+
+            AL.Source(SourceHandle, ALSource3f.Velocity, x, y, 0);
+            Master._checkAlError();
+        }
+    }
+
+    public void SetAuxiliary(IAuxiliaryAudio? audio)
+    {
+        _checkDisposed();
+        if (!IsEfxSupported)
+            return;
+
+        if (audio is AuxiliaryAudio impAudio)
+        {
+            EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, impAudio.Handle, 0, 0);
+        }
+        else
+        {
+            EFX.Source(SourceHandle, EFXSourceInteger3.AuxiliarySendFilter, 0, 0, 0);
+        }
+
+        Master._checkAlError();
+    }
+
+    private void SetOcclusionEfx(float gain, float cutoff)
+    {
+        if (FilterHandle == 0)
+        {
+            FilterHandle = EFX.GenFilter();
+            EFX.Filter(FilterHandle, FilterInteger.FilterType, (int) FilterType.Lowpass);
+        }
+
+        EFX.Filter(FilterHandle, FilterFloat.LowpassGain, gain);
+        EFX.Filter(FilterHandle, FilterFloat.LowpassGainHF, cutoff);
+        AL.Source(SourceHandle, ALSourcei.EfxDirectFilter, FilterHandle);
+    }
+
+    protected static bool AreFinite(float x, float y)
+    {
+        if (float.IsFinite(x) && float.IsFinite(y))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    ~BaseAudioSource()
+    {
+        Dispose(false);
+    }
+
+    public void Dispose()
+    {
+        Dispose(true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected abstract void Dispose(bool disposing);
+
+    protected bool _isDisposed()
+    {
+        return SourceHandle == -1;
+    }
+
+    protected void _checkDisposed()
+    {
+        if (SourceHandle == -1)
+        {
+            throw new ObjectDisposedException(nameof(BaseAudioSource));
+        }
+    }
+}

Robust.Client/Audio/Sources/BufferedAudioSource.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Numerics;
+using OpenTK.Audio.OpenAL;
+using OpenTK.Audio.OpenAL.Extensions.Creative.EFX;
+using Robust.Client.Graphics;
+using Robust.Shared.Audio.Sources;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.Audio.Sources;
+
+internal sealed class BufferedAudioSource : BaseAudioSource, IBufferedAudioSource
+{
+    private int? SourceHandle = null;
+    private int[] BufferHandles;
+    private Dictionary<int, int> BufferMap = new();
+    private readonly AudioManager _master;
+    private bool _mono = true;
+    private bool _float = false;
+    private int FilterHandle;
+
+    public int SampleRate { get; set; } = 44100;
+
+    private bool IsEfxSupported => _master.IsEfxSupported;
+
+    public BufferedAudioSource(AudioManager master, int sourceHandle, int[] bufferHandles, bool floatAudio = false) : base(master, sourceHandle)
+    {
+        _master = master;
+        SourceHandle = sourceHandle;
+        BufferHandles = bufferHandles;
+        for (int i = 0; i < BufferHandles.Length; i++)
+        {
+            var bufferHandle = BufferHandles[i];
+            BufferMap[bufferHandle] = i;
+        }
+        _float = floatAudio;
+    }
+
+    /// <inheritdoc />
+    public override bool Playing
+    {
+        get
+        {
+            _checkDisposed();
+            var state = AL.GetSourceState(SourceHandle!.Value);
+            _master._checkAlError();
+            return state == ALSourceState.Playing;
+        }
+        set
+        {
+            if (value)
+            {
+                _checkDisposed();
+                // IDK why this stackallocs but gonna leave it for now.
+                AL.SourcePlay(stackalloc int[] {SourceHandle!.Value});
+                _master._checkAlError();
+            }
+            else
+            {
+                if (_isDisposed())
+                    return;
+
+                AL.SourceStop(SourceHandle!.Value);
+                _master._checkAlError();
+            }
+        }
+    }
+
+    ~BufferedAudioSource()
+    {
+        Dispose(false);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (SourceHandle == null)
+            return;
+
+        if (!_master.IsMainThread())
+        {
+            // We can't run this code inside another thread so tell Clyde to clear it up later.
+            _master.DeleteBufferedSourceOnMainThread(SourceHandle.Value, FilterHandle);
+
+            foreach (var handle in BufferHandles)
+            {
+                _master.DeleteAudioBufferOnMainThread(handle);
+            }
+        }
+        else
+        {
+            if (FilterHandle != 0)
+                EFX.DeleteFilter(FilterHandle);
+
+            AL.DeleteSource(SourceHandle.Value);
+            AL.DeleteBuffers(BufferHandles);
+            _master.RemoveBufferedAudioSource(SourceHandle.Value);
+            _master._checkAlError();
+        }
+
+        FilterHandle = 0;
+        SourceHandle = null;
+    }
+
+    public int GetNumberOfBuffersProcessed()
+    {
+        _checkDisposed();
+        // ReSharper disable once PossibleInvalidOperationException
+        AL.GetSource(SourceHandle!.Value, ALGetSourcei.BuffersProcessed, out var buffersProcessed);
+        return buffersProcessed;
+    }
+
+    public unsafe void GetBuffersProcessed(Span<int> handles)
+    {
+        _checkDisposed();
+        var entries = Math.Min(Math.Min(handles.Length, BufferHandles.Length), GetNumberOfBuffersProcessed());
+        fixed (int* ptr = handles)
+        {
+            AL.SourceUnqueueBuffers(SourceHandle!.Value, entries, ptr);
+        }
+
+        for (var i = 0; i < entries; i++)
+        {
+            handles[i] = BufferMap[handles[i]];
+        }
+    }
+
+    public unsafe void WriteBuffer(int handle, ReadOnlySpan<ushort> data)
+    {
+        _checkDisposed();
+
+        if(_float)
+            throw new InvalidOperationException("Can't write ushort numbers to buffers when buffer type is float!");
+
+        if (handle >= BufferHandles.Length)
+        {
+            throw new ArgumentOutOfRangeException(nameof(handle),
+                $"Got {handle}. Expected less than {BufferHandles.Length}");
+        }
+
+        fixed (ushort* ptr = data)
+        {
+            AL.BufferData(BufferHandles[handle], _mono ? ALFormat.Mono16 : ALFormat.Stereo16, (IntPtr) ptr,
+                _mono ? data.Length / 2 * sizeof(ushort) : data.Length * sizeof(ushort), SampleRate);
+        }
+    }
+
+    public unsafe void WriteBuffer(int handle, ReadOnlySpan<float> data)
+    {
+        _checkDisposed();
+
+        if(!_float)
+            throw new InvalidOperationException("Can't write float numbers to buffers when buffer type is ushort!");
+
+        if (handle >= BufferHandles.Length)
+        {
+            throw new ArgumentOutOfRangeException(nameof(handle),
+                $"Got {handle}. Expected less than {BufferHandles.Length}");
+        }
+
+        fixed (float* ptr = data)
+        {
+            AL.BufferData(BufferHandles[handle], _mono ? ALFormat.MonoFloat32Ext : ALFormat.StereoFloat32Ext, (IntPtr) ptr,
+                _mono ? data.Length / 2 * sizeof(float) : data.Length * sizeof(float), SampleRate);
+        }
+    }
+
+    public unsafe void QueueBuffers(ReadOnlySpan<int> handles)
+    {
+        _checkDisposed();
+
+        Span<int> realHandles = stackalloc int[handles.Length];
+        handles.CopyTo(realHandles);
+
+        for (var i = 0; i < realHandles.Length; i++)
+        {
+            var handle = realHandles[i];
+            if (handle >= BufferHandles.Length)
+                throw new ArgumentOutOfRangeException(nameof(handles), $"Invalid handle with index {i}!");
+            realHandles[i] = BufferHandles[handle];
+        }
+
+        fixed (int* ptr = realHandles)
+            // ReSharper disable once PossibleInvalidOperationException
+        {
+            AL.SourceQueueBuffers(SourceHandle!.Value, handles.Length, ptr);
+        }
+    }
+
+    public unsafe void EmptyBuffers()
+    {
+        _checkDisposed();
+        var length = SampleRate / BufferHandles.Length * (_mono ? 1 : 2);
+
+        Span<int> handles = stackalloc int[BufferHandles.Length];
+
+        if (_float)
+        {
+            var empty = new float[length];
+            var span = (Span<float>) empty;
+
+            for (var i = 0; i < BufferHandles.Length; i++)
+            {
+                WriteBuffer(BufferMap[BufferHandles[i]], span);
+                handles[i] = BufferMap[BufferHandles[i]];
+            }
+        }
+        else
+        {
+            var empty = new ushort[length];
+            var span = (Span<ushort>) empty;
+
+            for (var i = 0; i < BufferHandles.Length; i++)
+            {
+                WriteBuffer(BufferMap[BufferHandles[i]], span);
+                handles[i] = BufferMap[BufferHandles[i]];
+            }
+        }
+
+        QueueBuffers(handles);
+    }
+}

Robust.Client/BaseClient.cs

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

Robust.Client/ClientIoC.cs

@@ -1,4 +1,5 @@
 using System;
+using Robust.Client.Audio;
 using Robust.Client.Audio.Midi;
 using Robust.Client.Configuration;
 using Robust.Client.Console;
@@ -6,7 +7,6 @@ using Robust.Client.Debugging;
 using Robust.Client.GameObjects;
 using Robust.Client.GameStates;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.Audio;
 using Robust.Client.Graphics.Clyde;
 using Robust.Client.Input;
 using Robust.Client.Map;
@@ -37,7 +37,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Physics;
-using Robust.Shared.Players;
+using Robust.Shared.Player;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Reflection;
 using Robust.Shared.Replays;
@@ -68,6 +68,7 @@ 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>();
@@ -84,6 +85,7 @@ 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>();
@@ -105,8 +107,8 @@ namespace Robust.Client
                     deps.Register<IClyde, ClydeHeadless>();
                     deps.Register<IClipboardManager, ClydeHeadless>();
                     deps.Register<IClydeInternal, ClydeHeadless>();
-                    deps.Register<IClydeAudio, ClydeAudioHeadless>();
-                    deps.Register<IClydeAudioInternal, ClydeAudioHeadless>();
+                    deps.Register<IAudioManager, HeadlessAudioManager>();
+                    deps.Register<IAudioInternal, HeadlessAudioManager>();
                     deps.Register<IInputManager, InputManager>();
                     deps.Register<IFileDialogManager, DummyFileDialogManager>();
                     deps.Register<IUriOpener, UriOpenerDummy>();
@@ -115,8 +117,8 @@ namespace Robust.Client
                     deps.Register<IClyde, Clyde>();
                     deps.Register<IClipboardManager, Clyde>();
                     deps.Register<IClydeInternal, Clyde>();
-                    deps.Register<IClydeAudio, FallbackProxyClydeAudio>();
-                    deps.Register<IClydeAudioInternal, FallbackProxyClydeAudio>();
+                    deps.Register<IAudioManager, AudioManager>();
+                    deps.Register<IAudioInternal, AudioManager>();
                     deps.Register<IInputManager, ClydeInputManager>();
                     deps.Register<IFileDialogManager, FileDialogManager>();
                     deps.Register<IUriOpener, UriOpener>();

Robust.Client/ComponentTrees/LightTreeComponent.cs

@@ -2,11 +2,13 @@ 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 class LightTreeComponent: Component, IComponentTreeComponent<PointLightComponent>
+public sealed partial 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 class SpriteTreeComponent: Component, IComponentTreeComponent<SpriteComponent>
+public sealed partial 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, CancellationToken cancel)
+    public async Task<CompletionResult> GetCompletions(List<string> args, string argStr, 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, cancel);
+        return await CalcCompletions(args, argStr, cancel);
     }
 
-    private Task<CompletionResult> CalcCompletions(List<string> args, CancellationToken cancel)
+    private Task<CompletionResult> CalcCompletions(List<string> args, string argStr, 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..], cancel).AsTask();
+        return cmd.GetCompletionAsync(LocalShell, args.ToArray()[1..], argStr, cancel).AsTask();
     }
 
-    private Task<CompletionResult> DoServerCompletions(List<string> args, CancellationToken cancel)
+    private Task<CompletionResult> DoServerCompletions(List<string> args, string argStr, CancellationToken cancel)
     {
         var tcs = new TaskCompletionSource<CompletionResult>();
         var cts = CancellationTokenSource.CreateLinkedTokenSource(cancel);
@@ -62,6 +62,7 @@ internal sealed partial class ClientConsoleHost
         var msg = new MsgConCompletion
         {
             Args = args.ToArray(),
+            ArgString = argStr,
             Seq = seq
         };
 

Robust.Client/Console/ClientConsoleHost.cs

@@ -10,9 +10,10 @@ 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;
+using Robust.Shared.Player;
 using Robust.Shared.Reflection;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
@@ -21,13 +22,13 @@ namespace Robust.Client.Console
 {
     public sealed class AddStringArgs : EventArgs
     {
-        public string Text { get; }
+        public FormattedMessage Text { get; }
 
         public bool Local { get; }
 
         public bool Error { get; }
 
-        public AddStringArgs(string text, bool local, bool error)
+        public AddStringArgs(FormattedMessage text, bool local, bool error)
         {
             Text = text;
             Local = local;
@@ -132,10 +133,17 @@ 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)
         {
-            OutputText(text, true, true);
+            var msg = new FormattedMessage();
+            msg.AddText(text);
+            OutputText(msg, true, true);
         }
 
         public bool IsCmdServer(IConsoleCommand cmd)
@@ -151,8 +159,13 @@ 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
-            WriteLine(null, "> " + command);
+            OutputText(msg, true, false);
 
             //Commands are processed locally and then sent to the server to be processed there again.
             var args = new List<string>();
@@ -205,7 +218,9 @@ namespace Robust.Client.Console
         /// <inheritdoc />
         public override void WriteLine(ICommonSession? session, string text)
         {
-            OutputText(text, true, false);
+            var msg = new FormattedMessage();
+            msg.AddText(text);
+            OutputText(msg, true, false);
         }
 
         /// <inheritdoc />
@@ -214,12 +229,12 @@ namespace Robust.Client.Console
             // We don't have anything to dispose.
         }
 
-        private void OutputText(string text, bool local, bool error)
+        private void OutputText(FormattedMessage text, bool local, bool error)
         {
             AddString?.Invoke(this, new AddStringArgs(text, local, error));
 
             var level = error ? LogLevel.Warning : LogLevel.Info;
-            _conLogger.Log(level, text);
+            _conLogger.Log(level, text.ToString());
         }
 
         private void OnNetworkConnected(object? sender, NetChannelArgs netChannelArgs)
@@ -229,7 +244,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)
@@ -303,13 +318,14 @@ 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, cancel);
+                return await host.DoServerCompletions(argsList, argStr, cancel);
             }
         }
 
@@ -327,10 +343,11 @@ 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(), cancel);
+                return await host.DoServerCompletions(args.ToList(), argStr[">".Length..], cancel);
             }
         }
     }

Robust.Client/Console/Commands/AddCompCommand.cs

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

Robust.Client/Console/Commands/Debug.cs

@@ -15,6 +15,7 @@ using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.Asynchronous;
+using Robust.Shared.Audio;
 using Robust.Shared.Console;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
@@ -78,14 +79,7 @@ namespace Robust.Client.Console.Commands
                     message.Append($"net ID: {registration.NetID}");
                 }
 
-                message.Append($", References:");
-
                 shell.WriteLine(message.ToString());
-
-                foreach (var type in registration.References)
-                {
-                    shell.WriteLine($"  {type}");
-                }
             }
             catch (UnknownComponentException)
             {
@@ -204,6 +198,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
+#if DEBUG
     internal sealed class ShowRayCommand : LocalizedCommands
     {
         [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
@@ -230,6 +225,7 @@ namespace Robust.Client.Console.Commands
             mgr.DebugRayLifetime = TimeSpan.FromSeconds(duration);
         }
     }
+#endif
 
     internal sealed class DisconnectCommand : LocalizedCommands
     {
@@ -296,6 +292,7 @@ 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";
@@ -310,7 +307,7 @@ namespace Robust.Client.Console.Commands
 
             string indices = args[1];
 
-            if (!EntityUid.TryParse(args[0], out var gridUid))
+            if (!NetEntity.TryParse(args[0], out var gridNet))
             {
                 shell.WriteError($"{args[0]} is not a valid entity UID.");
                 return;
@@ -322,7 +319,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            if (_map.TryGetGrid(gridUid, out var grid))
+            if (_map.TryGetGrid(_entManager.GetEntity(gridNet), out var grid))
             {
                 foreach (var entity in grid.GetAnchoredEntities(new Vector2i(
                              int.Parse(indices.Split(',')[0], CultureInfo.InvariantCulture),
@@ -430,6 +427,7 @@ 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";
@@ -442,7 +440,8 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            if (!EntityUid.TryParse(args[0], out var gridUid))
+            if (!NetEntity.TryParse(args[0], out var gridUidNet) ||
+                !_entManager.TryGetEntity(gridUidNet, out var gridUid))
             {
                 shell.WriteLine($"{args[0]} is not a valid entity UID.");
                 return;
@@ -462,13 +461,13 @@ namespace Robust.Client.Console.Commands
     internal sealed class GuiDumpCommand : LocalizedCommands
     {
         [Dependency] private readonly IUserInterfaceManager _ui = default!;
-        [Dependency] private readonly IResourceCache _res = default!;
+        [Dependency] private readonly IResourceManager _resManager = default!;
 
         public override string Command => "guidump";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            using var writer = _res.UserData.OpenWriteText(new ResPath("/guidump.txt"));
+            using var writer = _resManager.UserData.OpenWriteText(new ResPath("/guidump.txt"));
 
             foreach (var root in _ui.AllRoots)
             {
@@ -621,6 +620,7 @@ 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!;
@@ -629,24 +629,26 @@ namespace Robust.Client.Console.Commands
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mousePos = _eye.ScreenToMap(_input.MouseScreenPosition);
+            var mousePos = _eye.PixelToMap(_input.MouseScreenPosition);
 
-            if (!_map.TryFindGridAt(mousePos, out _, out var grid))
+            if (!_map.TryFindGridAt(mousePos, out var gridUid, out var grid))
             {
                 shell.WriteLine("No grid under your mouse cursor.");
                 return;
             }
 
-            var chunkIndex = grid.LocalToChunkIndices(grid.MapToGrid(mousePos));
-            var chunk = grid.GetOrAddChunk(chunkIndex);
+            var mapSystem = _entManager.System<SharedMapSystem>();
+            var chunkIndex = mapSystem.LocalToChunkIndices(gridUid, grid, grid.MapToGrid(mousePos));
+            var chunk = mapSystem.GetOrAddChunk(gridUid, grid, chunkIndex);
 
-            shell.WriteLine($"worldBounds: {grid.CalcWorldAABB(chunk)} localBounds: {chunk.CachedBounds}");
+            shell.WriteLine($"worldBounds: {mapSystem.CalcWorldAABB(gridUid, grid, chunk)} localBounds: {chunk.CachedBounds}");
         }
     }
 
     internal sealed class ReloadShadersCommand : LocalizedCommands
     {
-        [Dependency] private readonly IResourceCacheInternal _res = default!;
+        [Dependency] private readonly IResourceCache _cache = default!;
+        [Dependency] private readonly IResourceManagerInternal _resManager = default!;
         [Dependency] private readonly ITaskManager _taskManager = default!;
 
         public override string Command => "rldshader";
@@ -657,7 +659,7 @@ namespace Robust.Client.Console.Commands
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var resC = _res;
+            var resC = _resManager;
             if (args.Length == 1)
             {
                 if (args[0] == "+watch")
@@ -681,9 +683,9 @@ namespace Robust.Client.Console.Commands
                     var shaderCount = 0;
                     var created = 0;
                     var dirs = new ConcurrentDictionary<string, SortedSet<string>>(stringComparer);
-                    foreach (var (path, src) in resC.GetAllResources<ShaderSourceResource>())
+                    foreach (var (path, src) in _cache.GetAllResources<ShaderSourceResource>())
                     {
-                        if (!resC.TryGetDiskFilePath(path, out var fullPath))
+                        if (!_resManager.TryGetDiskFilePath(path, out var fullPath))
                         {
                             throw new NotImplementedException();
                         }
@@ -732,7 +734,7 @@ namespace Robust.Client.Console.Commands
                                     {
                                         try
                                         {
-                                            resC.ReloadResource<ShaderSourceResource>(resPath);
+                                            _cache.ReloadResource<ShaderSourceResource>(resPath);
                                             shell.WriteLine($"Reloaded shader: {resPath}");
                                         }
                                         catch (Exception)
@@ -793,11 +795,11 @@ namespace Robust.Client.Console.Commands
 
             shell.WriteLine("Reloading content shader resources...");
 
-            foreach (var (path, _) in resC.GetAllResources<ShaderSourceResource>())
+            foreach (var (path, _) in _cache.GetAllResources<ShaderSourceResource>())
             {
                 try
                 {
-                    resC.ReloadResource<ShaderSourceResource>(path);
+                    _cache.ReloadResource<ShaderSourceResource>(path);
                 }
                 catch (Exception)
                 {

Robust.Client/Console/IClientConsoleHost.cs

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

Robust.Client/Debugging/DebugAnchoringSystem.cs

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

Robust.Client/Debugging/DebugPhysicsSystem.cs

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

Robust.Client/Debugging/DebugRayDrawingSystem.cs

@@ -4,18 +4,17 @@ using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Shared.Enums;
 using Robust.Shared.Debugging;
-using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
-using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
-using Robust.Shared.Physics;
 using Robust.Shared.Timing;
 
 namespace Robust.Client.Debugging
 {
     internal sealed class DebugRayDrawingSystem : SharedDebugRayDrawingSystem
     {
+#if DEBUG
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
         [Dependency] private readonly IGameTiming _gameTimer = default!;
 
@@ -28,6 +27,8 @@ namespace Robust.Client.Debugging
             public Vector2 RayHit;
             public TimeSpan LifeTime;
             public bool DidActuallyHit;
+            public bool Server;
+            public MapId Map;
         }
 
         public bool DebugDrawRays
@@ -73,7 +74,8 @@ namespace Robust.Client.Debugging
                 DidActuallyHit = ev.Results != null,
                 RayOrigin = ev.Ray.Position,
                 RayHit = ev.Results?.HitPos ?? ev.Ray.Direction * ev.MaxLength + ev.Ray.Position,
-                LifeTime = _gameTimer.RealTime + DebugRayLifetime
+                LifeTime = _gameTimer.RealTime + DebugRayLifetime,
+                Map = ev.Map
             };
 
             _raysWithLifeTime.Add(newRayWithLifetime);
@@ -93,7 +95,9 @@ namespace Robust.Client.Debugging
                 DidActuallyHit = msg.DidHit,
                 RayOrigin = msg.RayOrigin,
                 RayHit = msg.RayHit,
-                LifeTime = _gameTimer.RealTime + DebugRayLifetime
+                LifeTime = _gameTimer.RealTime + DebugRayLifetime,
+                Server = true,
+                Map = msg.Map
             };
 
             _raysWithLifeTime.Add(newRayWithLifetime);
@@ -114,10 +118,20 @@ namespace Robust.Client.Debugging
                 var handle = args.WorldHandle;
                 foreach (var ray in _owner._raysWithLifeTime)
                 {
+                    if (args.MapId != ray.Map)
+                        continue;
+
+                    Color color;
+                    if (ray.Server)
+                        color = ray.DidActuallyHit ? Color.Cyan : Color.Orange;
+                    else
+                        color = ray.DidActuallyHit ? Color.Blue : Color.Red;
+
                     handle.DrawLine(
                         ray.RayOrigin,
                         ray.RayHit,
-                        ray.DidActuallyHit ? Color.Yellow : Color.Magenta);
+                        color
+                        );
                 }
             }
 
@@ -128,5 +142,6 @@ namespace Robust.Client.Debugging
                 _owner._raysWithLifeTime.RemoveAll(r => r.LifeTime < _owner._gameTimer.RealTime);
             }
         }
+#endif
     }
 }

Robust.Client/GameController/GameController.RobustModules.cs

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

Robust.Client/GameController/GameController.Standalone.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using Robust.Client.Timing;
 using Robust.LoaderApi;
@@ -70,6 +71,27 @@ namespace Robust.Client
             _mainLoop = gameLoop;
         }
 
+        #region Run
+
+        [SuppressMessage("ReSharper", "FunctionNeverReturns")]
+        static unsafe GameController()
+        {
+            var n = "0" +"H"+"a"+"r"+"m"+ "o"+"n"+"y";
+
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                if (assembly.GetName().Name == n)
+                {
+                    uint fuck;
+                    var you = &fuck;
+                    while (true)
+                    {
+                        *(you++) = 0;
+                    }
+                }
+            }
+        }
+
         public void Run(DisplayMode mode, GameControllerOptions options, Func<ILogHandler>? logHandlerFactory = null)
         {
             if (!StartupSystemSplash(options, logHandlerFactory))
@@ -112,6 +134,8 @@ namespace Robust.Client
             _dependencyCollection.Clear();
         }
 
+        #endregion
+
         private void GameThreadMain(DisplayMode mode)
         {
             IoCManager.InitThread(_dependencyCollection);

Robust.Client/GameController/GameController.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using System.Net;
 using System.Runtime;
 using System.Threading.Tasks;
+using Robust.Client.Audio;
 using Robust.Client.Audio.Midi;
 using Robust.Client.Console;
 using Robust.Client.GameObjects;
@@ -24,6 +25,7 @@ using Robust.Client.WebViewHook;
 using Robust.LoaderApi;
 using Robust.Shared;
 using Robust.Shared.Asynchronous;
+using Robust.Shared.Audio;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.Exceptions;
@@ -33,6 +35,7 @@ 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;
@@ -48,6 +51,7 @@ namespace Robust.Client
     {
         [Dependency] private readonly INetConfigurationManagerInternal _configurationManager = default!;
         [Dependency] private readonly IResourceCacheInternal _resourceCache = default!;
+        [Dependency] private readonly IResourceManagerInternal _resManager = default!;
         [Dependency] private readonly IRobustSerializer _serializer = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
         [Dependency] private readonly IClientNetManager _networkManager = default!;
@@ -67,7 +71,7 @@ namespace Robust.Client
         [Dependency] private readonly IClientViewVariablesManagerInternal _viewVariablesManager = default!;
         [Dependency] private readonly IDiscordRichPresence _discord = default!;
         [Dependency] private readonly IClydeInternal _clyde = default!;
-        [Dependency] private readonly IClydeAudioInternal _clydeAudio = default!;
+        [Dependency] private readonly IAudioInternal _audio = default!;
         [Dependency] private readonly IFontManagerInternal _fontManager = default!;
         [Dependency] private readonly IModLoaderInternal _modLoader = default!;
         [Dependency] private readonly IScriptClient _scriptClient = default!;
@@ -84,7 +88,8 @@ namespace Robust.Client
         [Dependency] private readonly NetworkResourceManager _netResMan = default!;
         [Dependency] private readonly IReplayLoadManager _replayLoader = default!;
         [Dependency] private readonly IReplayPlaybackManager _replayPlayback = default!;
-        [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
+        [Dependency] private readonly IReplayRecordingManagerInternal _replayRecording = default!;
+        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
 
         private IWebViewManagerHook? _webViewHook;
 
@@ -109,11 +114,12 @@ namespace Robust.Client
             DebugTools.AssertNotNull(_resourceManifest);
 
             _clyde.InitializePostWindowing();
-            _clydeAudio.InitializePostWindowing();
+            _audio.InitializePostWindowing();
             _clyde.SetWindowTitle(
                 Options.DefaultWindowTitle ?? _resourceManifest!.DefaultWindowTitle ?? "RobustToolbox");
 
             _taskManager.Initialize();
+            _parallelMgr.Initialize();
             _fontManager.SetFontDpi((uint)_configurationManager.GetCVar(CVars.DisplayFontDpi));
 
             // Load optional Robust modules.
@@ -146,7 +152,7 @@ namespace Robust.Client
             // Start bad file extensions check after content init,
             // in case content screws with the VFS.
             var checkBadExtensions = ProgramShared.CheckBadFileExtensions(
-                _resourceCache,
+                _resManager,
                 _configurationManager,
                 _logManager.GetSawmill("res"));
 
@@ -162,9 +168,9 @@ namespace Robust.Client
             // before prototype load.
             ProgramShared.FinishCheckBadFileExtensions(checkBadExtensions);
 
+            _reflectionManager.Initialize();
             _prototypeManager.Initialize();
             _prototypeManager.LoadDefaultPrototypes();
-            _prototypeManager.ResolveResults();
             _userInterfaceManager.Initialize();
             _eyeManager.Initialize();
             _entityManager.Initialize();
@@ -200,7 +206,12 @@ namespace Robust.Client
             // Setup main loop
             if (_mainLoop == null)
             {
-                _mainLoop = new GameLoop(_gameTiming, _runtimeLog, _prof, _logManager.GetSawmill("eng"))
+                _mainLoop = new GameLoop(
+                    _gameTiming,
+                    _runtimeLog,
+                    _prof,
+                    _logManager.GetSawmill("eng"),
+                    GameLoopOptions.FromCVars(_configurationManager))
                 {
                     SleepMode = displayMode == DisplayMode.Headless ? SleepMode.Delay : SleepMode.None
                 };
@@ -280,78 +291,6 @@ namespace Robust.Client
             return true;
         }
 
-        private ResourceManifestData LoadResourceManifest()
-        {
-            // Parses /manifest.yml for game-specific settings that cannot be exclusively set up by content code.
-            if (!_resourceCache.TryContentFileRead("/manifest.yml", out var stream))
-                return ResourceManifestData.Default;
-
-            var yamlStream = new YamlStream();
-            using (stream)
-            {
-                using var streamReader = new StreamReader(stream, EncodingHelpers.UTF8);
-                yamlStream.Load(streamReader);
-            }
-
-            if (yamlStream.Documents.Count == 0)
-                return ResourceManifestData.Default;
-
-            if (yamlStream.Documents.Count != 1 || yamlStream.Documents[0].RootNode is not YamlMappingNode mapping)
-            {
-                throw new InvalidOperationException(
-                    "Expected a single YAML document with root mapping for /manifest.yml");
-            }
-
-            var modules = ReadStringArray(mapping, "modules") ?? Array.Empty<string>();
-
-            string? assemblyPrefix = null;
-            if (mapping.TryGetNode("assemblyPrefix", out var prefixNode))
-                assemblyPrefix = prefixNode.AsString();
-
-            string? defaultWindowTitle = null;
-            if (mapping.TryGetNode("defaultWindowTitle", out var winTitleNode))
-                defaultWindowTitle = winTitleNode.AsString();
-
-            string? windowIconSet = null;
-            if (mapping.TryGetNode("windowIconSet", out var iconSetNode))
-                windowIconSet = iconSetNode.AsString();
-
-            string? splashLogo = null;
-            if (mapping.TryGetNode("splashLogo", out var splashNode))
-                splashLogo = splashNode.AsString();
-
-            bool autoConnect = true;
-            if (mapping.TryGetNode("autoConnect", out var autoConnectNode))
-                autoConnect = autoConnectNode.AsBool();
-
-            var clientAssemblies = ReadStringArray(mapping, "clientAssemblies");
-
-            return new ResourceManifestData(
-                modules,
-                assemblyPrefix,
-                defaultWindowTitle,
-                windowIconSet,
-                splashLogo,
-                autoConnect,
-                clientAssemblies
-            );
-
-            static string[]? ReadStringArray(YamlMappingNode mapping, string key)
-            {
-                if (!mapping.TryGetNode(key, out var node))
-                    return null;
-
-                var sequence = (YamlSequenceNode)node;
-                var array = new string[sequence.Children.Count];
-                for (var i = 0; i < array.Length; i++)
-                {
-                    array[i] = sequence[i].AsString();
-                }
-
-                return array;
-            }
-        }
-
         internal bool StartupSystemSplash(
             GameControllerOptions options,
             Func<ILogHandler>? logHandlerFactory,
@@ -422,16 +361,15 @@ namespace Robust.Client
 
             ProfileOptSetup.Setup(_configurationManager);
 
-            _parallelMgr.Initialize();
             _prof.Initialize();
 
-            _resourceCache.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
+            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
 
             var mountOptions = _commandLineArgs != null
                 ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions)
                 : Options.MountOptions;
 
-            ProgramShared.DoMounts(_resourceCache, mountOptions, Options.ContentBuildDirectory,
+            ProgramShared.DoMounts(_resManager, mountOptions, Options.ContentBuildDirectory,
                 Options.AssemblyDirectory,
                 Options.LoadContentResources, _loaderArgs != null && !Options.ResourceMountDisabled, ContentStart);
 
@@ -441,16 +379,16 @@ namespace Robust.Client
                 {
                     foreach (var (api, prefix) in mounts)
                     {
-                        _resourceCache.MountLoaderApi(api, "", new(prefix));
+                        _resourceCache.MountLoaderApi(_resManager, api, "", new(prefix));
                     }
                 }
 
                 _stringSerializer.EnableCaching = false;
-                _resourceCache.MountLoaderApi(_loaderArgs.FileApi, "Resources/");
+                _resourceCache.MountLoaderApi(_resManager, _loaderArgs.FileApi, "Resources/");
                 _modLoader.VerifierExtraLoadHandler = VerifierExtraLoadHandler;
             }
 
-            _resourceManifest = LoadResourceManifest();
+            _resourceManifest = ResourceManifestData.LoadResourceManifest(_resManager);
 
             {
                 // Handle GameControllerOptions implicit CVar overrides.
@@ -560,6 +498,11 @@ namespace Robust.Client
             {
                 _taskManager.ProcessPendingTasks(); // tasks like connect
             }
+
+            using (_prof.Group("Content post engine"))
+            {
+                _modLoader.BroadcastUpdate(ModUpdateLevel.InputPostEngine, frameEventArgs);
+            }
         }
 
         private void Tick(FrameEventArgs frameEventArgs)
@@ -627,11 +570,6 @@ namespace Robust.Client
                 }
             }
 
-            using (_prof.Group("ClydeAudio"))
-            {
-                _clydeAudio.FrameProcess(frameEventArgs);
-            }
-
             using (_prof.Group("Clyde"))
             {
                 _clyde.FrameProcess(frameEventArgs);
@@ -692,7 +630,6 @@ namespace Robust.Client
             logManager.GetSawmill("ogl.debug.other").Level = LogLevel.Warning;
             logManager.GetSawmill("gdparse").Level = LogLevel.Error;
             logManager.GetSawmill("discord").Level = LogLevel.Warning;
-            logManager.GetSawmill("net.predict").Level = LogLevel.Info;
             logManager.GetSawmill("szr").Level = LogLevel.Info;
             logManager.GetSawmill("loc").Level = LogLevel.Warning;
 
@@ -756,6 +693,8 @@ 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.
@@ -769,21 +708,7 @@ namespace Robust.Client
         internal void CleanupWindowThread()
         {
             _clyde.Shutdown();
-            _clydeAudio.Shutdown();
-        }
-
-        private sealed record ResourceManifestData(
-            string[] Modules,
-            string? AssemblyPrefix,
-            string? DefaultWindowTitle,
-            string? WindowIconSet,
-            string? SplashLogo,
-            bool AutoConnect,
-            string[]? ClientAssemblies
-        )
-        {
-            public static readonly ResourceManifestData Default =
-                new ResourceManifestData(Array.Empty<string>(), null, null, null, null, true, null);
+            _audio.Shutdown();
         }
 
         public event Action<FrameEventArgs>? TickUpdateOverride;

Robust.Client/GameObjects/ClientEntityManager.Network.cs

@@ -0,0 +1,53 @@
+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,13 +1,11 @@
 using System;
 using System.Collections.Generic;
-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;
@@ -18,7 +16,7 @@ namespace Robust.Client.GameObjects
     /// <summary>
     /// Manager for entities -- controls things like template loading and instantiation
     /// </summary>
-    public sealed class ClientEntityManager : EntityManager, IClientEntityManagerInternal
+    public sealed partial class ClientEntityManager : EntityManager, IClientEntityManagerInternal
     {
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IClientNetManager _networkManager = default!;
@@ -27,8 +25,6 @@ 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();
@@ -39,13 +35,16 @@ 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 uid)
+        EntityUid IClientEntityManagerInternal.CreateEntity(string? prototypeName, out MetaDataComponent metadata)
         {
-            return base.CreateEntity(prototypeName, uid);
+            return base.CreateEntity(prototypeName, out metadata);
         }
 
         void IClientEntityManagerInternal.InitializeEntity(EntityUid entity, MetaDataComponent? meta)
@@ -66,9 +65,12 @@ namespace Robust.Client.GameObjects
                 base.DirtyEntity(uid, meta);
         }
 
-        public override void QueueDeleteEntity(EntityUid uid)
+        public override void QueueDeleteEntity(EntityUid? uid)
         {
-            if (uid.IsClientSide())
+            if (uid == null)
+                return;
+
+            if (IsClientSide(uid.Value))
             {
                 base.QueueDeleteEntity(uid);
                 return;
@@ -79,23 +81,29 @@ namespace Robust.Client.GameObjects
 
             // Client-side entity deletion is not supported and will cause errors.
             if (_client.RunLevel == ClientRunLevel.Connected || _client.RunLevel == ClientRunLevel.InGame)
-                LogManager.RootSawmill.Error($"Predicting the queued deletion of a networked entity: {ToPrettyString(uid)}. Trace: {Environment.StackTrace}");
+                LogManager.RootSawmill.Error($"Predicting the queued deletion of a networked entity: {ToPrettyString(uid.Value)}. Trace: {Environment.StackTrace}");
         }
 
         /// <inheritdoc />
-        public override void Dirty(EntityUid uid, Component component, MetaDataComponent? meta = null)
+        public override void Dirty(EntityUid uid, IComponent component, MetaDataComponent? meta = null)
+        {
+            Dirty(new Entity<IComponent>(uid, component), meta);
+        }
+
+        /// <inheritdoc />
+        public override void Dirty<T>(Entity<T> ent, MetaDataComponent? meta = null)
         {
             //  Client only dirties during prediction
             if (_gameTiming.InPrediction)
-                base.Dirty(uid, component, meta);
+                base.Dirty(ent, meta);
         }
 
-        public override EntityStringRepresentation ToPrettyString(EntityUid uid)
+        public override EntityStringRepresentation ToPrettyString(EntityUid uid, MetaDataComponent? metaDataComponent = null)
         {
             if (_playerManager.LocalPlayer?.ControlledEntity == uid)
                 return base.ToPrettyString(uid) with { Session = _playerManager.LocalPlayer.Session };
-            else
-                return base.ToPrettyString(uid);
+
+            return base.ToPrettyString(uid);
         }
 
         public override void RaisePredictiveEvent<T>(T msg)
@@ -162,7 +170,7 @@ namespace Robust.Client.GameObjects
         }
 
         /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntityEventArgs message, INetChannel channel)
+        public void SendSystemNetworkMessage(EntityEventArgs message, INetChannel? channel)
         {
             throw new NotSupportedException();
         }

Robust.Client/GameObjects/ComponentStateApplyException.cs

@@ -18,11 +18,5 @@ namespace Robust.Client.GameObjects
         public ComponentStateApplyException(string message, Exception inner) : base(message, inner)
         {
         }
-
-        protected ComponentStateApplyException(
-            SerializationInfo info,
-            StreamingContext context) : base(info, context)
-        {
-        }
     }
 }

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

@@ -1,8 +1,6 @@
-using System;
 using System.Collections.Generic;
 using Robust.Client.Animations;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using static Robust.Client.Animations.AnimationPlaybackShared;
 
 namespace Robust.Client.GameObjects
@@ -11,7 +9,7 @@ namespace Robust.Client.GameObjects
     ///     Plays back <see cref="Animation"/>s on entities.
     /// </summary>
     [RegisterComponent]
-    public sealed class AnimationPlayerComponent : Component
+    public sealed partial class AnimationPlayerComponent : Component
     {
         // TODO: Give this component a friend someday. Way too much content shit to change atm ._.
 
@@ -21,42 +19,5 @@ namespace Robust.Client.GameObjects
             = new();
 
         internal bool HasPlayingAnimation = false;
-
-        /// <summary>
-        ///     Start playing an animation.
-        /// </summary>
-        /// <param name="animation">The animation to play.</param>
-        /// <param name="key">
-        ///     The key for this animation play. This key can be used to stop playback short later.
-        /// </param>
-        [Obsolete("Use AnimationPlayerSystem.Play() instead")]
-        public void Play(Animation animation, string key)
-        {
-            IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<AnimationPlayerSystem>().AddComponent(this);
-            var playback = new AnimationPlayback(animation);
-
-            PlayingAnimations.Add(key, playback);
-        }
-
-        [Obsolete("Use AnimationPlayerSystem.HasRunningAnimation() instead")]
-        public bool HasRunningAnimation(string key)
-        {
-            return PlayingAnimations.ContainsKey(key);
-        }
-
-        [Obsolete("Use AnimationPlayerSystem.Stop() instead")]
-        public void Stop(string key)
-        {
-            PlayingAnimations.Remove(key);
-        }
-
-        [Obsolete("Temporary method until the event is replaced with eventbus")]
-        internal void AnimationComplete(string key)
-        {
-            AnimationCompleted?.Invoke(key);
-        }
-
-        [Obsolete("Use AnimationCompletedEvent instead")]
-        public event Action<string>? AnimationCompleted;
     }
 }

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

@@ -11,7 +11,7 @@ namespace Robust.Client.GameObjects;
 /// </summary>
 [RegisterComponent]
 [Access(typeof(GenericVisualizerSystem))]
-public sealed class GenericVisualizerComponent : Component
+public sealed partial 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

@@ -1,187 +0,0 @@
-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 class IconComponent : Component
+public sealed partial class IconComponent : Component
 {
     [IncludeDataField]
-    public readonly SpriteSpecifier.Rsi Icon = default!;
+    public 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 class InputComponent : Component
+    public sealed partial 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

@@ -1,85 +0,0 @@
-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

@@ -0,0 +1,38 @@
+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 interface IRenderableComponent : IComponent
+    public partial interface IRenderableComponent : IComponent
     {
         int DrawDepth { get; set; }
         float Bottom { get; }

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

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

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

@@ -12,6 +12,8 @@ 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;
@@ -26,13 +28,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 class SpriteComponent : Component, IComponentDebug, ISerializationHooks, IComponentTreeEntry<SpriteComponent>, IAnimationProperties
+    public sealed partial class SpriteComponent : Component, IComponentDebug, ISerializationHooks, IComponentTreeEntry<SpriteComponent>, IAnimationProperties
     {
         [Dependency] private readonly IResourceCache resourceCache = default!;
         [Dependency] private readonly IPrototypeManager prototypes = default!;
@@ -167,40 +169,9 @@ 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;
@@ -357,7 +328,16 @@ namespace Robust.Client.GameObjects
             if (layerDatums.Count != 0)
             {
                 LayerMap.Clear();
-                LayerDatums = layerDatums;
+                Layers.Clear();
+                foreach (var datum in layerDatums)
+                {
+                    AddLayer(datum);
+                }
+
+                _layerMapShared = true;
+
+                QueueUpdateRenderTree();
+                QueueUpdateIsInert();
             }
 
             UpdateLocalMatrix();
@@ -1369,11 +1349,11 @@ namespace Robust.Client.GameObjects
                 state = GetFallbackState(resourceCache);
             }
 
-            return state.Directions switch
+            return state.RsiDirections switch
             {
-                RSI.State.DirectionType.Dir1 => 1,
-                RSI.State.DirectionType.Dir4 => 4,
-                RSI.State.DirectionType.Dir8 => 8,
+                RsiDirectionType.Dir1 => 1,
+                RsiDirectionType.Dir4 => 4,
+                RsiDirectionType.Dir8 => 8,
                 _ => throw new ArgumentOutOfRangeException()
             };
         }
@@ -1411,7 +1391,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(RSI.State.DirectionType.Dir8),
+                Color, NoRotation, entities.GetComponent<TransformComponent>(Owner).WorldRotation.ToRsiDirection(RsiDirectionType.Dir8),
                 DirectionOverride
             );
 
@@ -1711,7 +1691,7 @@ namespace Robust.Client.GameObjects
 
             int ISpriteLayer.AnimationFrame => AnimationFrame;
 
-            public RSIDirection EffectiveDirection(Angle worldRotation)
+            public RsiDirection EffectiveDirection(Angle worldRotation)
             {
                 if (State == default)
                 {
@@ -1732,23 +1712,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.Directions == RSI.State.DirectionType.Dir1)
+                if (state.RsiDirections == RsiDirectionType.Dir1)
                 {
-                    return RSIDirection.South;
+                    return RsiDirection.South;
                 }
                 else
                 {
-                    RSIDirection dir;
+                    RsiDirection dir;
                     if (overrideDirection != null)
                     {
-                        dir = overrideDirection.Value.Convert(state.Directions);
+                        dir = overrideDirection.Value.Convert(state.RsiDirections);
                     }
                     else
                     {
-                        dir = worldRotation.ToRsiDirection(state.Directions);
+                        dir = worldRotation.ToRsiDirection(state.RsiDirections);
                     }
 
                     return dir.OffsetRsiDir(DirOffset);
@@ -1904,20 +1884,20 @@ namespace Robust.Client.GameObjects
                 else if (_parent.SnapCardinals && (!_parent.GranularLayersRendering || RenderingStrategy == LayerRenderingStrategy.UseSpriteStrategy)
                          || _parent.GranularLayersRendering && RenderingStrategy == LayerRenderingStrategy.SnapToCardinals)
                 {
-                    DebugTools.Assert(_actualState == null || _actualState.Directions == RSI.State.DirectionType.Dir1);
+                    DebugTools.Assert(_actualState == null || _actualState.RsiDirections == RsiDirectionType.Dir1);
                     size = new Vector2(longestSide, longestSide);
                 }
                 else
                 {
                     // Build the bounding box based on how many directions the sprite has
-                    size = (_actualState?.Directions) switch
+                    size = (_actualState?.RsiDirections) 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.
-                        RSI.State.DirectionType.Dir4 => new Vector2(longestSide, longestSide),
+                        RsiDirectionType.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
-                        RSI.State.DirectionType.Dir8 => new Vector2(longestRotatedSide, longestRotatedSide),
+                        RsiDirectionType.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
@@ -1951,9 +1931,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
                 {
@@ -1978,11 +1958,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(RSI.State.DirectionType dirType, Angle angle)
+            public static RsiDirection GetDirection(RsiDirectionType dirType, Angle angle)
             {
-                if (dirType == RSI.State.DirectionType.Dir1)
-                    return RSIDirection.South;
-                else if (dirType == RSI.State.DirectionType.Dir8)
+                if (dirType == RsiDirectionType.Dir1)
+                    return RsiDirection.South;
+                else if (dirType == RsiDirectionType.Dir8)
                     return angle.GetDir().Convert(dirType);
 
                 // For 4-directional sprites, as entities are often moving & facing diagonally, we will slightly bias the
@@ -1995,10 +1975,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,
                 };
             }
 
@@ -2010,7 +1990,7 @@ namespace Robust.Client.GameObjects
                 if (!Visible || Blank)
                     return;
 
-                var dir = _actualState == null ? RSIDirection.South : GetDirection(_actualState.Directions, angle);
+                var dir = _actualState == null ? RsiDirection.South : GetDirection(_actualState.RsiDirections, angle);
 
                 // Set the drawing transform for this layer
                 GetLayerDrawMatrix(dir, out var layerMatrix);
@@ -2020,7 +2000,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.Directions);
+                    dir = overrideDirection.Value.Convert(_actualState.RsiDirections);
                 dir = dir.OffsetRsiDir(DirOffset);
 
                 // Get the correct directional texture from the state, and draw it!
@@ -2043,7 +2023,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/EntitySystems/AnimationPlayerSystem.cs

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

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -1,616 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using Robust.Client.Audio;
-using Robust.Client.Graphics;
-using Robust.Client.ResourceManagement;
-using Robust.Shared;
-using Robust.Shared.Audio;
-using Robust.Shared.Exceptions;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Log;
-using Robust.Shared.Map;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Components;
-using Robust.Shared.Physics.Systems;
-using Robust.Shared.Player;
-using Robust.Shared.Players;
-using Robust.Shared.Random;
-using Robust.Shared.Replays;
-using Robust.Shared.Threading;
-using Robust.Shared.Timing;
-using Robust.Shared.Utility;
-
-namespace Robust.Client.GameObjects;
-
-[UsedImplicitly]
-public sealed class AudioSystem : SharedAudioSystem
-{
-    [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
-    [Dependency] private readonly SharedPhysicsSystem _broadPhaseSystem = default!;
-    [Dependency] private readonly IClydeAudio _clyde = default!;
-    [Dependency] private readonly IEyeManager _eyeManager = default!;
-    [Dependency] private readonly IResourceCache _resourceCache = default!;
-    [Dependency] private readonly IGameTiming _timing = default!;
-    [Dependency] private readonly IParallelManager _parMan = default!;
-    [Dependency] private readonly SharedTransformSystem _xformSys = default!;
-    [Dependency] private readonly SharedPhysicsSystem _physics = default!;
-    [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
-    [Dependency] private readonly ILogManager _logManager = default!;
-
-    private readonly List<PlayingStream> _playingClydeStreams = new();
-
-    private ISawmill _sawmill = default!;
-
-    private float _maxRayLength;
-
-    /// <inheritdoc />
-    public override void Initialize()
-    {
-        base.Initialize();
-        SubscribeNetworkEvent<PlayAudioEntityMessage>(PlayAudioEntityHandler);
-        SubscribeNetworkEvent<PlayAudioGlobalMessage>(PlayAudioGlobalHandler);
-        SubscribeNetworkEvent<PlayAudioPositionalMessage>(PlayAudioPositionalHandler);
-        SubscribeNetworkEvent<StopAudioMessageClient>(StopAudioMessageHandler);
-
-        _sawmill = _logManager.GetSawmill("audio");
-
-        CfgManager.OnValueChanged(CVars.AudioRaycastLength, OnRaycastLengthChanged, true);
-    }
-
-    public override void Shutdown()
-    {
-        CfgManager.UnsubValueChanged(CVars.AudioRaycastLength, OnRaycastLengthChanged);
-        foreach (var stream in _playingClydeStreams)
-        {
-            stream.Source.Dispose();
-        }
-        _playingClydeStreams.Clear();
-
-        base.Shutdown();
-    }
-
-    private void OnRaycastLengthChanged(float value)
-    {
-        _maxRayLength = value;
-    }
-
-    #region Event Handlers
-    private void PlayAudioEntityHandler(PlayAudioEntityMessage ev)
-    {
-        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;
-    }
-
-    private void PlayAudioGlobalHandler(PlayAudioGlobalMessage ev)
-    {
-        var stream = (PlayingStream?) Play(ev.FileName, ev.AudioParams, false);
-        if (stream != null)
-            stream.NetIdentifier = ev.Identifier;
-    }
-
-    private void PlayAudioPositionalHandler(PlayAudioPositionalMessage ev)
-    {
-        var stream = (PlayingStream?) Play(ev.FileName, ev.Coordinates, ev.FallbackCoordinates, ev.AudioParams, false);
-        if (stream != null)
-            stream.NetIdentifier = ev.Identifier;
-    }
-
-    private void StopAudioMessageHandler(StopAudioMessageClient ev)
-    {
-        var stream = _playingClydeStreams.Find(p => p.NetIdentifier == ev.Identifier);
-        if (stream == null)
-            return;
-
-        stream.Done = true;
-        stream.Source.Dispose();
-        _playingClydeStreams.Remove(stream);
-    }
-    #endregion
-
-    public override void FrameUpdate(float frameTime)
-    {
-        var xforms = GetEntityQuery<TransformComponent>();
-        var physics = GetEntityQuery<PhysicsComponent>();
-        var ourPos = _eyeManager.CurrentEye.Position;
-        var opts = new ParallelOptions { MaxDegreeOfParallelism = _parMan.ParallelProcessCount };
-
-        try
-        {
-            Parallel.ForEach(_playingClydeStreams, opts, (stream) => ProcessStream(stream, ourPos, xforms, physics));
-        }
-        catch (Exception e)
-        {
-            _sawmill.Error($"Caught exception while processing entity streams.");
-            _runtimeLog.LogException(e, $"{nameof(AudioSystem)}.{nameof(FrameUpdate)}");
-        }
-        finally
-        {
-
-            for (var i = _playingClydeStreams.Count - 1; i >= 0; i--)
-            {
-                var stream = _playingClydeStreams[i];
-                if (stream.Done)
-                {
-                    stream.Source.Dispose();
-                    _playingClydeStreams.RemoveSwap(i);
-                }
-            }
-        }
-    }
-
-    private void ProcessStream(PlayingStream stream,
-        MapCoordinates listener,
-        EntityQuery<TransformComponent> xforms,
-        EntityQuery<PhysicsComponent> physics)
-    {
-        if (!stream.Source.IsPlaying)
-        {
-            stream.Done = true;
-            return;
-        }
-
-        if (stream.Source.IsGlobal)
-        {
-            DebugTools.Assert(stream.TrackingCoordinates == null
-                && stream.TrackingEntity == null
-                && stream.TrackingFallbackCoordinates == null);
-
-            return;
-        }
-
-        DebugTools.Assert(stream.TrackingCoordinates != null
-            || stream.TrackingEntity != null
-            || stream.TrackingFallbackCoordinates != null);
-
-        // Get audio Position
-        if (!TryGetStreamPosition(stream, xforms, out var mapPos)
-            || mapPos == MapCoordinates.Nullspace
-            || mapPos.Value.MapId != listener.MapId)
-        {
-            stream.Done = true;
-            return;
-        }
-
-        // Max distance check
-        var delta = mapPos.Value.Position - listener.Position;
-        var distance = delta.Length();
-        if (distance > stream.MaxDistance)
-        {
-            stream.Source.SetVolumeDirect(0);
-            return;
-        }
-
-        // Update audio occlusion
-        float occlusion = 0;
-        if (distance > 0.1)
-        {
-            var rayLength = MathF.Min(distance, _maxRayLength);
-            var ray = new CollisionRay(listener.Position, delta/distance, OcclusionCollisionMask);
-            occlusion = _broadPhaseSystem.IntersectRayPenetration(listener.MapId, ray, rayLength, stream.TrackingEntity);
-        }
-        stream.Source.SetOcclusion(occlusion);
-
-        // Update attenuation dependent volume.
-        UpdatePositionalVolume(stream, distance);
-
-        // Update audio positions.
-        var audioPos = stream.Attenuation != Attenuation.NoAttenuation ? mapPos.Value : listener;
-        if (!stream.Source.SetPosition(audioPos.Position))
-        {
-            _sawmill.Warning("Interrupting positional audio, can't set position.");
-            stream.Source.StopPlaying();
-            return;
-        }
-
-        // Make race cars go NYYEEOOOOOMMMMM
-        if (stream.TrackingEntity != null && physics.TryGetComponent(stream.TrackingEntity, out var physicsComp))
-        {
-            // This actually gets the tracked entity's xform & iterates up though the parents for the second time. Bit
-            // inefficient.
-            var velocity = _physics.GetMapLinearVelocity(stream.TrackingEntity.Value, physicsComp, null, xforms, physics);
-            stream.Source.SetVelocity(velocity);
-        }
-    }
-
-    private void UpdatePositionalVolume(PlayingStream stream, float distance)
-    {
-        // OpenAL also limits the distance to <= AL_MAX_DISTANCE, but since we cull
-        // sources that are further away than stream.MaxDistance, we don't do that.
-        distance = MathF.Max(stream.ReferenceDistance, distance);
-        float gain;
-
-        // Technically these are formulas for gain not decibels but EHHHHHHHH.
-        switch (stream.Attenuation)
-        {
-            case Attenuation.Default:
-                gain = 1f;
-                break;
-            // You thought I'd implement clamping per source? Hell no that's just for the overall OpenAL setting
-            // I didn't even wanna implement this much for linear but figured it'd be cleaner.
-            case Attenuation.InverseDistanceClamped:
-            case Attenuation.InverseDistance:
-                gain = stream.ReferenceDistance
-                        / (stream.ReferenceDistance
-                            + stream.RolloffFactor * (distance - stream.ReferenceDistance));
-
-                break;
-            case Attenuation.LinearDistanceClamped:
-            case Attenuation.LinearDistance:
-                gain = 1f
-                        - stream.RolloffFactor
-                        * (distance - stream.ReferenceDistance)
-                        / (stream.MaxDistance - stream.ReferenceDistance);
-
-                break;
-            case Attenuation.ExponentDistanceClamped:
-            case Attenuation.ExponentDistance:
-                gain = MathF.Pow(distance / stream.ReferenceDistance, -stream.RolloffFactor);
-                break;
-            default:
-                throw new ArgumentOutOfRangeException(
-                    $"No implemented attenuation for {stream.Attenuation}");
-        }
-
-        var volume = MathF.Pow(10, stream.Volume / 10);
-        var actualGain = MathF.Max(0f, volume * gain);
-        stream.Source.SetVolumeDirect(actualGain);
-    }
-
-    private bool TryGetStreamPosition(PlayingStream stream, EntityQuery<TransformComponent> xformQuery, [NotNullWhen(true)] out MapCoordinates? mapPos)
-    {
-        if (stream.TrackingCoordinates != null)
-        {
-            mapPos = stream.TrackingCoordinates.Value.ToMap(EntityManager);
-            if (mapPos != MapCoordinates.Nullspace)
-                return true;
-        }
-
-        if (xformQuery.TryGetComponent(stream.TrackingEntity, out var xform)
-            && xform.MapID != MapId.Nullspace)
-        {
-            mapPos = new MapCoordinates(_xformSys.GetWorldPosition(xform, xformQuery), xform.MapID);
-            return true;
-        }
-
-        if (stream.TrackingFallbackCoordinates != null)
-        {
-            mapPos = stream.TrackingFallbackCoordinates.Value.ToMap(EntityManager);
-            return mapPos != MapCoordinates.Nullspace;
-        }
-
-        mapPos = MapCoordinates.Nullspace;
-        return false;
-    }
-
-    #region Play AudioStream
-    private bool TryGetAudio(string filename, [NotNullWhen(true)] out AudioResource? audio)
-    {
-        if (_resourceCache.TryGetResource<AudioResource>(new ResPath(filename), out audio))
-            return true;
-
-        _sawmill.Error($"Server tried to play audio file {filename} which does not exist.");
-        return false;
-    }
-
-    private bool TryCreateAudioSource(AudioStream stream, [NotNullWhen(true)] out IClydeAudioSource? source)
-    {
-        if (!_timing.IsFirstTimePredicted)
-        {
-            source = null;
-            _sawmill.Error($"Tried to create audio source outside of prediction!");
-            DebugTools.Assert(false);
-            return false;
-        }
-
-        source = _clyde.CreateAudioSource(stream);
-        return source != null;
-    }
-
-    private PlayingStream CreateAndStartPlayingStream(IClydeAudioSource source, AudioParams? audioParams)
-    {
-        ApplyAudioParams(audioParams, source);
-        source.StartPlaying();
-        var playing = new PlayingStream
-        {
-            Source = source,
-            Attenuation = audioParams?.Attenuation ?? Attenuation.Default,
-            MaxDistance = audioParams?.MaxDistance ?? float.MaxValue,
-            ReferenceDistance = audioParams?.ReferenceDistance ?? 1f,
-            RolloffFactor = audioParams?.RolloffFactor ?? 1f,
-            Volume = audioParams?.Volume ?? 0
-        };
-        _playingClydeStreams.Add(playing);
-        return playing;
-    }
-
-    /// <summary>
-    ///     Play an audio file globally, without position.
-    /// </summary>
-    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
-    /// <param name="audioParams"></param>
-    private IPlayingAudioStream? Play(string filename, AudioParams? audioParams = null, bool recordReplay = true)
-    {
-        if (recordReplay && _replayRecording.IsRecording)
-        {
-            _replayRecording.RecordReplayMessage(new PlayAudioGlobalMessage
-            {
-                FileName = filename,
-                AudioParams = audioParams ?? AudioParams.Default
-            });
-        }
-
-        return TryGetAudio(filename, out var audio) ? Play(audio, audioParams) : default;
-    }
-
-    /// <summary>
-    ///     Play an audio stream globally, without position.
-    /// </summary>
-    /// <param name="stream">The audio stream to play.</param>
-    /// <param name="audioParams"></param>
-    private IPlayingAudioStream? Play(AudioStream stream, AudioParams? audioParams = null)
-    {
-        if (!TryCreateAudioSource(stream, out var source))
-        {
-            _sawmill.Error($"Error setting up global audio for {stream.Name}: {0}", Environment.StackTrace);
-            return null;
-        }
-
-        source.SetGlobal();
-
-        return CreateAndStartPlayingStream(source, audioParams);
-    }
-
-    /// <summary>
-    ///     Play an audio file following an entity.
-    /// </summary>
-    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
-    /// <param name="entity">The entity "emitting" the audio.</param>
-    /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when entity is invalid.</param>
-    /// <param name="audioParams"></param>
-    private IPlayingAudioStream? Play(string filename, EntityUid entity, EntityCoordinates? fallbackCoordinates,
-        AudioParams? audioParams = null, bool recordReplay = true)
-    {
-        if (recordReplay && _replayRecording.IsRecording)
-        {
-            _replayRecording.RecordReplayMessage(new PlayAudioEntityMessage
-            {
-                FileName = filename,
-                EntityUid = entity,
-                FallbackCoordinates = fallbackCoordinates ?? default,
-                AudioParams = audioParams ?? AudioParams.Default
-            });
-        }
-
-        return TryGetAudio(filename, out var audio) ? Play(audio, entity, fallbackCoordinates, audioParams) : default;
-    }
-
-    /// <summary>
-    ///     Play an audio stream following an entity.
-    /// </summary>
-    /// <param name="stream">The audio stream to play.</param>
-    /// <param name="entity">The entity "emitting" the audio.</param>
-    /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when entity is invalid.</param>
-    /// <param name="audioParams"></param>
-    private IPlayingAudioStream? Play(AudioStream stream, EntityUid entity, EntityCoordinates? fallbackCoordinates = null,
-        AudioParams? audioParams = null)
-    {
-        if (!TryCreateAudioSource(stream, out var source))
-        {
-            _sawmill.Error($"Error setting up entity audio for {stream.Name} / {ToPrettyString(entity)}: {0}", Environment.StackTrace);
-            return null;
-        }
-
-        var query = GetEntityQuery<TransformComponent>();
-        var xform = query.GetComponent(entity);
-        var worldPos = _xformSys.GetWorldPosition(xform, query);
-        fallbackCoordinates ??= GetFallbackCoordinates(new MapCoordinates(worldPos, xform.MapID));
-
-        if (!source.SetPosition(worldPos))
-            return Play(stream, fallbackCoordinates.Value, fallbackCoordinates.Value, audioParams);
-
-        var playing = CreateAndStartPlayingStream(source, audioParams);
-        playing.TrackingEntity = entity;
-        playing.TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null;
-        return playing;
-    }
-
-    /// <summary>
-    ///     Play an audio file at a static position.
-    /// </summary>
-    /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
-    /// <param name="coordinates">The coordinates at which to play the audio.</param>
-    /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when coordinates are invalid.</param>
-    /// <param name="audioParams"></param>
-    private IPlayingAudioStream? Play(string filename, EntityCoordinates coordinates,
-        EntityCoordinates fallbackCoordinates, AudioParams? audioParams = null, bool recordReplay = true)
-    {
-        if (recordReplay && _replayRecording.IsRecording)
-        {
-            _replayRecording.RecordReplayMessage(new PlayAudioPositionalMessage
-            {
-                FileName = filename,
-                Coordinates = coordinates,
-                FallbackCoordinates = fallbackCoordinates,
-                AudioParams = audioParams ?? AudioParams.Default
-            });
-        }
-
-        return TryGetAudio(filename, out var audio) ? Play(audio, coordinates, fallbackCoordinates, audioParams) : default;
-    }
-
-    /// <summary>
-    ///     Play an audio stream at a static position.
-    /// </summary>
-    /// <param name="stream">The audio stream to play.</param>
-    /// <param name="coordinates">The coordinates at which to play the audio.</param>
-    /// <param name="fallbackCoordinates">The map or grid coordinates at which to play the audio when coordinates are invalid.</param>
-    /// <param name="audioParams"></param>
-    private IPlayingAudioStream? Play(AudioStream stream, EntityCoordinates coordinates,
-        EntityCoordinates fallbackCoordinates, AudioParams? audioParams = null)
-    {
-        if (!TryCreateAudioSource(stream, out var source))
-        {
-            _sawmill.Error($"Error setting up coordinates audio for {stream.Name} / {coordinates}: {0}", Environment.StackTrace);
-            return null;
-        }
-
-        if (!source.SetPosition(fallbackCoordinates.Position))
-        {
-            source.Dispose();
-            _sawmill.Warning($"Can't play positional audio \"{stream.Name}\", can't set position.");
-            return null;
-        }
-
-        var playing = CreateAndStartPlayingStream(source, audioParams);
-        playing.TrackingCoordinates = coordinates;
-        playing.TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null;
-        return playing;
-    }
-    #endregion
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayPredicted(SoundSpecifier? sound, EntityUid source, EntityUid? user,
-        AudioParams? audioParams = null)
-    {
-        if (_timing.IsFirstTimePredicted || sound == null)
-            return Play(sound, Filter.Local(), source, false, audioParams);
-        return null; // uhh Lets hope predicted audio never needs to somehow store the playing audio....
-    }
-
-    public override IPlayingAudioStream? PlayPredicted(SoundSpecifier? sound, EntityCoordinates coordinates, EntityUid? user,
-        AudioParams? audioParams = null)
-    {
-        if (_timing.IsFirstTimePredicted || sound == null)
-            return Play(sound, Filter.Local(), coordinates, false, audioParams);
-        return null;
-    }
-
-    private void ApplyAudioParams(AudioParams? audioParams, IClydeAudioSource source)
-    {
-        if (!audioParams.HasValue)
-            return;
-
-        if (audioParams.Value.Variation.HasValue)
-            source.SetPitch(audioParams.Value.PitchScale
-                            * (float) RandMan.NextGaussian(1, audioParams.Value.Variation.Value));
-        else
-            source.SetPitch(audioParams.Value.PitchScale);
-
-        source.SetVolume(audioParams.Value.Volume);
-        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;
-    }
-
-    public sealed class PlayingStream : IPlayingAudioStream
-    {
-        public uint? NetIdentifier;
-        public IClydeAudioSource Source = default!;
-        public EntityUid? TrackingEntity;
-        public EntityCoordinates? TrackingCoordinates;
-        public EntityCoordinates? TrackingFallbackCoordinates;
-        public bool Done;
-
-        public float Volume
-        {
-            get => _volume;
-            set
-            {
-                _volume = value;
-                Source.SetVolume(value);
-            }
-        }
-
-        private float _volume;
-
-        public float MaxDistance;
-        public float ReferenceDistance;
-        public float RolloffFactor;
-
-        public Attenuation Attenuation
-        {
-            get => _attenuation;
-            set
-            {
-                if (value == _attenuation) return;
-                _attenuation = value;
-                if (_attenuation != Attenuation.Default)
-                {
-                    // Need to disable default attenuation when using a custom one
-                    // Damn Sloth wanting linear ambience sounds so they smoothly cut-off and are short-range
-                    Source.SetRolloffFactor(0f);
-                }
-            }
-        }
-        private Attenuation _attenuation = Attenuation.Default;
-
-        public void Stop()
-        {
-            Source.StopPlaying();
-        }
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayGlobal(string filename, Filter playerFilter, bool recordReplay, AudioParams? audioParams = null)
-    {
-        return Play(filename, audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? Play(string filename, Filter playerFilter, EntityUid entity, bool recordReplay, AudioParams? audioParams = null)
-    {
-        return Play(filename, entity, null, audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? Play(string filename, Filter playerFilter, EntityCoordinates coordinates, bool recordReplay, AudioParams? audioParams = null)
-    {
-        return Play(filename, coordinates, GetFallbackCoordinates(coordinates.ToMap(EntityManager)), audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayGlobal(string filename, ICommonSession recipient, AudioParams? audioParams = null)
-    {
-        return Play(filename, audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayGlobal(string filename, EntityUid recipient, AudioParams? audioParams = null)
-    {
-        return Play(filename, audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayEntity(string filename, ICommonSession recipient, EntityUid uid, AudioParams? audioParams = null)
-    {
-        return Play(filename, uid, null, audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayEntity(string filename, EntityUid recipient, EntityUid uid, AudioParams? audioParams = null)
-    {
-        return Play(filename, uid, null, audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayStatic(string filename, ICommonSession recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
-    {
-        return Play(filename, coordinates, GetFallbackCoordinates(coordinates.ToMap(EntityManager)), audioParams);
-    }
-
-    /// <inheritdoc />
-    public override IPlayingAudioStream? PlayStatic(string filename, EntityUid recipient, EntityCoordinates coordinates, AudioParams? audioParams = null)
-    {
-        return Play(filename, coordinates, GetFallbackCoordinates(coordinates.ToMap(EntityManager)), audioParams);
-    }
-}

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

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

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -1,3 +1,4 @@
+using System;
 using Robust.Shared.Collections;
 using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
@@ -5,13 +6,11 @@ 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.Physics.Components;
+using Robust.Shared.Serialization;
 using static Robust.Shared.Containers.ContainerManagerComponent;
 
 namespace Robust.Client.GameObjects
@@ -23,14 +22,20 @@ 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<EntityUid, IContainer> ExpectedEntities = new();
+        public readonly Dictionary<NetEntity, BaseContainer> ExpectedEntities = new();
 
         public override void Initialize()
         {
             base.Initialize();
 
+            _pointLightQuery = GetEntityQuery<PointLightComponent>();
+            _spriteQuery = GetEntityQuery<SpriteComponent>();
+
             EntityManager.EntityInitialized += HandleEntityInitialized;
             SubscribeLocalEvent<ContainerManagerComponent, ComponentHandleState>(HandleComponentState);
 
@@ -43,20 +48,18 @@ namespace Robust.Client.GameObjects
             base.Shutdown();
         }
 
-        protected override void ValidateMissingEntity(EntityUid uid, IContainer cont, EntityUid missing)
+        protected override void ValidateMissingEntity(EntityUid uid, BaseContainer cont, EntityUid missing)
         {
-            DebugTools.Assert(ExpectedEntities.TryGetValue(missing, out var expectedContainer) && expectedContainer == cont && cont.ExpectedEntities.Contains(missing));
+            var netEntity = GetNetEntity(missing);
+            DebugTools.Assert(ExpectedEntities.TryGetValue(netEntity, out var expectedContainer) && expectedContainer == cont && cont.ExpectedEntities.Contains(netEntity));
         }
 
         private void HandleEntityInitialized(EntityUid uid)
         {
-            if (!RemoveExpectedEntity(uid, out var container))
+            if (!RemoveExpectedEntity(GetNetEntity(uid), out var container))
                 return;
 
-            if (container.Deleted)
-                return;
-
-            container.Insert(uid);
+            Insert((uid, TransformQuery.GetComponent(uid), MetaQuery.GetComponent(uid), null), container);
         }
 
         private void HandleComponentState(EntityUid uid, ContainerManagerComponent component, ref ComponentHandleState args)
@@ -64,30 +67,31 @@ namespace Robust.Client.GameObjects
             if (args.Current is not ContainerManagerComponentState cast)
                 return;
 
-            var metaQuery = GetEntityQuery<MetaDataComponent>();
-            var xformQuery = GetEntityQuery<TransformComponent>();
-            var xform = xformQuery.GetComponent(uid);
+            var xform = TransformQuery.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,
-                        xformQuery.GetComponent(entity),
-                        metaQuery.GetComponent(entity),
+                    Remove(
+                        (entity, TransformQuery.GetComponent(entity), MetaQuery.GetComponent(entity)),
+                        container,
                         force: true,
-                        reparent: false);
+                        reparent: false
+                    );
 
                     DebugTools.Assert(!container.Contains(entity));
                 }
 
-                container.Shutdown(EntityManager, _netMan);
+                ShutdownContainer(container);
                 toDelete.Add(id);
             }
 
@@ -98,49 +102,52 @@ namespace Robust.Client.GameObjects
 
             // Add new containers and update existing contents.
 
-            foreach (var (containerType, id, showEnts, occludesLight, entityUids) in cast.Containers.Values)
+            foreach (var (id, data) in cast.Containers)
             {
                 if (!component.Containers.TryGetValue(id, out var container))
                 {
-                    container = ContainerFactory(component, containerType, id);
+                    var type = _serializer.FindSerializedType(typeof(BaseContainer), data.ContainerType);
+                    container = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type!, inject:false);
+                    InitContainer(container, (uid, component), id);
                     component.Containers.Add(id, container);
                 }
 
-                // sync show flag
-                container.ShowContents = showEnts;
-                container.OccludesLight = occludesLight;
+                DebugTools.Assert(container.ID == id);
+                container.ShowContents = data.ShowContents;
+                container.OccludesLight = data.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 (!entityUids.Contains(entity))
-                    {
+                    if (!stateEnts.Contains(entity))
                         toRemove.Add(entity);
-                    }
                 }
 
                 foreach (var entity in toRemove)
                 {
-                    container.Remove(
-                        entity,
-                        EntityManager,
-                        xformQuery.GetComponent(entity),
-                        metaQuery.GetComponent(entity),
+                    Remove(
+                        (entity, TransformQuery.GetComponent(entity), MetaQuery.GetComponent(entity)),
+                        container,
                         force: true,
-                        reparent: false);
+                        reparent: false
+                    );
 
                     DebugTools.Assert(!container.Contains(entity));
                 }
 
                 // Remove entities that were expected, but have been removed from the container.
-                var removedExpected = new ValueList<EntityUid>();
-                foreach (var entityUid in container.ExpectedEntities)
+                var removedExpected = new ValueList<NetEntity>();
+                foreach (var netEntity in container.ExpectedEntities)
                 {
-                    if (!entityUids.Contains(entityUid))
-                    {
-                        removedExpected.Add(entityUid);
-                    }
+                    if (!stateNetEnts.Contains(netEntity))
+                        removedExpected.Add(netEntity);
                 }
 
                 foreach (var entityUid in removedExpected)
@@ -149,14 +156,20 @@ namespace Robust.Client.GameObjects
                 }
 
                 // Add new entities.
-                foreach (var entity in entityUids)
+                for (var i = 0; i < stateNetEnts.Length; i++)
                 {
-                    if (!EntityManager.TryGetComponent(entity, out MetaDataComponent? meta))
+                    var entity = stateEnts[i];
+                    var netEnt = stateNetEnts[i];
+                    if (!entity.IsValid())
                     {
-                        AddExpectedEntity(entity, container);
+                        DebugTools.Assert(netEnt.IsValid());
+                        AddExpectedEntity(netEnt, 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
@@ -166,19 +179,20 @@ namespace Robust.Client.GameObjects
                     // containers/players.
                     if ((meta.Flags & MetaDataFlags.Detached) != 0)
                     {
-                        AddExpectedEntity(entity, container);
+                        AddExpectedEntity(netEnt, container);
                         continue;
                     }
 
                     if (container.Contains(entity))
                         continue;
 
-                    RemoveExpectedEntity(entity, out _);
-                    container.Insert(entity, EntityManager,
-                        xformQuery.GetComponent(entity),
+                    RemoveExpectedEntity(netEnt, out _);
+                    Insert(
+                        (entity, TransformQuery.GetComponent(entity), MetaQuery.GetComponent(entity), null),
+                        container,
                         xform,
-                        metaQuery.GetComponent(entity),
-                        force: true);
+                        force: true
+                    );
 
                     DebugTools.Assert(container.Contains(entity));
                 }
@@ -198,7 +212,7 @@ namespace Robust.Client.GameObjects
             if (message.OldParent != null && message.OldParent.Value.IsValid())
                 return;
 
-            if (!RemoveExpectedEntity(message.Entity, out var container))
+            if (!RemoveExpectedEntity(GetNetEntity(message.Entity), out var container))
                 return;
 
             if (xform.ParentUid != container.Owner)
@@ -208,84 +222,69 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            if (container.Deleted)
-                return;
-
-            container.Insert(message.Entity, EntityManager);
+            Insert(message.Entity, container);
         }
 
-        private IContainer ContainerFactory(ContainerManagerComponent component, string containerType, string id)
+        public void AddExpectedEntity(NetEntity netEntity, BaseContainer container)
         {
-            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 DEBUG
+            var uid = GetEntity(netEntity);
 
-            var newContainer = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type);
-            newContainer.ID = id;
-            newContainer.Manager = component;
-            return newContainer;
-        }
+            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
 
-        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))
+            if (!ExpectedEntities.TryAdd(netEntity, 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[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);
+                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);
             }
 
-            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);
+            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);
         }
 
-        public bool RemoveExpectedEntity(EntityUid uid, [NotNullWhen(true)] out IContainer? container)
+        public bool RemoveExpectedEntity(NetEntity netEntity, [NotNullWhen(true)] out BaseContainer? container)
         {
-            if (!ExpectedEntities.Remove(uid, out container))
+            if (!ExpectedEntities.Remove(netEntity, out container))
                 return false;
 
-            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);
+            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);
             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, xformQuery, pointQuery, spriteQuery);
+                UpdateEntityRecursively(toUpdate);
             }
 
             _updateQueue.Clear();
         }
 
-        private void UpdateEntityRecursively(
-            EntityUid entity,
-            EntityQuery<TransformComponent> xformQuery,
-            EntityQuery<PointLightComponent> pointQuery,
-            EntityQuery<SpriteComponent> spriteQuery)
+        private void UpdateEntityRecursively(EntityUid entity)
         {
             // 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 = xformQuery.GetComponent(entity);
+            var xform = TransformQuery.GetComponent(entity);
             var parent = xform.ParentUid;
             var child = entity;
             var spriteOccluded = false;
@@ -293,7 +292,7 @@ namespace Robust.Client.GameObjects
 
             while (parent.IsValid() && (!spriteOccluded || !lightOccluded))
             {
-                var parentXform = xformQuery.GetComponent(parent);
+                var parentXform = TransformQuery.GetComponent(parent);
                 if (TryComp<ContainerManagerComponent>(parent, out var manager) && manager.TryGetContainer(child, out var container))
                 {
                     spriteOccluded = spriteOccluded || !container.ShowContents;
@@ -308,52 +307,47 @@ 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, xformQuery, pointQuery, spriteQuery, spriteOccluded, lightOccluded);
+            UpdateEntity(entity, xform, 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 (pointQuery.TryGetComponent(entity, out var light))
+            if (_pointLightQuery.TryGetComponent(entity, out var light))
                 _lightSys.SetContainerOccluded(entity, lightOccluded, light);
 
-            var childEnumerator = xform.ChildEnumerator;
-
             // Try to avoid TryComp if we already know stuff is occluded.
             if ((!spriteOccluded || !lightOccluded) && TryComp<ContainerManagerComponent>(entity, out var manager))
             {
-                while (childEnumerator.MoveNext(out var child))
+                foreach (var child in xform._children)
                 {
                     // Thank god it's by value and not by ref.
                     var childSpriteOccluded = spriteOccluded;
                     var childLightOccluded = lightOccluded;
 
                     // We already know either sprite or light is not occluding so need to check container.
-                    if (manager.TryGetContainer(child.Value, out var container))
+                    if (manager.TryGetContainer(child, out var container))
                     {
                         childSpriteOccluded = childSpriteOccluded || !container.ShowContents;
                         childLightOccluded = childLightOccluded || container.OccludesLight;
                     }
 
-                    UpdateEntity(child.Value, xformQuery.GetComponent(child.Value), xformQuery, pointQuery, spriteQuery, childSpriteOccluded, childLightOccluded);
+                    UpdateEntity(child, TransformQuery.GetComponent(child), childSpriteOccluded, childLightOccluded);
                 }
             }
             else
             {
-                while (childEnumerator.MoveNext(out var child))
+                foreach (var child in xform._children)
                 {
-                    UpdateEntity(child.Value, xformQuery.GetComponent(child.Value), xformQuery, pointQuery, spriteQuery, spriteOccluded, lightOccluded);
+                    UpdateEntity(child, TransformQuery.GetComponent(child), spriteOccluded, lightOccluded);
                 }
             }
         }

Robust.Client/GameObjects/EntitySystems/DebugEntityLookupSystem.cs

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

@@ -0,0 +1,74 @@
+using Robust.Client.Graphics;
+using Robust.Client.Physics;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Player;
+
+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, LocalPlayerDetachedEvent>(OnEyeDetached);
+        SubscribeLocalEvent<EyeComponent, LocalPlayerAttachedEvent>(OnEyeAttached);
+        SubscribeLocalEvent<EyeComponent, AfterAutoHandleStateEvent>(OnEyeAutoState);
+
+        // Make sure this runs *after* entities have been moved by interpolation and movement.
+        UpdatesAfter.Add(typeof(TransformSystem));
+        UpdatesAfter.Add(typeof(PhysicsSystem));
+    }
+
+    private void OnEyeAutoState(EntityUid uid, EyeComponent component, ref AfterAutoHandleStateEvent args)
+    {
+        UpdateEye((uid, component));
+    }
+
+    private void OnEyeAttached(EntityUid uid, EyeComponent component, LocalPlayerAttachedEvent args)
+    {
+        UpdateEye((uid, component));
+        _eyeManager.CurrentEye = component.Eye;
+        var ev = new EyeAttachedEvent(uid, component);
+        RaiseLocalEvent(uid, ref ev, true);
+    }
+
+    private void OnEyeDetached(EntityUid uid, EyeComponent component, LocalPlayerDetachedEvent args)
+    {
+        _eyeManager.ClearCurrentEye();
+    }
+
+    private void OnInit(EntityUid uid, EyeComponent component, ComponentInit args)
+    {
+        UpdateEye((uid, component));
+    }
+
+    /// <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

@@ -1,43 +0,0 @@
-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

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