Changes cefglue to use our fork (#2097)

Co-authored-by: ike709 <ike709@github.com>

.github/workflows/build-test.yml

@@ -10,7 +10,7 @@ jobs:
   build:
     strategy:
       matrix:
-        os: [ubuntu-latest, windows-latest]
+        os: [ubuntu-latest, windows-latest, macos-latest]
 
     runs-on: ${{ matrix.os }}
 

.github/workflows/test-content.yml

@@ -38,4 +38,4 @@ jobs:
     - name: Content.Tests
       run: dotnet test --no-build Content.Tests/Content.Tests.csproj -v n
     - name: Content.IntegrationTests
-      run: dotnet test --no-build Content.IntegrationTests/Content.IntegrationTests.csproj -v n
+      run: COMPlus_gcServer=1 dotnet test --no-build Content.IntegrationTests/Content.IntegrationTests.csproj -v n

.gitmodules

@@ -13,3 +13,9 @@
 [submodule "ManagedHttpListener"]
 	path = ManagedHttpListener
 	url = https://github.com/space-wizards/ManagedHttpListener.git
+[submodule "Linguini"]
+	path = Linguini
+	url = https://github.com/space-wizards/Linguini
+[submodule "cefglue"]
+	path = cefglue
+	url = https://github.com/space-wizards/cefglue.git

Avalonia.Base/Avalonia.Base.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <TargetFramework>net5.0</TargetFramework>
+    </PropertyGroup>
+
+</Project>

Avalonia.Base/README.md

@@ -0,0 +1,2 @@
+See `Robust.Client/UserInterface/XAML/RiderNotes.md` for why this project exists.
+We are not actually using Avalonia (yet).

MSBuild/Robust.Engine.props

@@ -4,5 +4,6 @@
         <TargetFramework>net5.0</TargetFramework>
         <LangVersion>9</LangVersion>
         <Nullable>enable</Nullable>
+        <WarningsAsErrors>nullable</WarningsAsErrors>
     </PropertyGroup>
 </Project>

OpenToolkit.GraphicsLibraryFramework/Enums/WindowHintBool.cs

@@ -129,5 +129,7 @@ namespace OpenToolkit.GraphicsLibraryFramework
         /// for controlling sRGB rendering and a created OpenGL ES context will always have sRGB rendering enabled.
         /// </summary>
         SrgbCapable = 0x0002100E,
+
+        ScaleToMonitor = 0x0002200C,
     }
 }

OpenToolkit.GraphicsLibraryFramework/GLFW.cs

@@ -5551,5 +5551,15 @@ namespace OpenToolkit.GraphicsLibraryFramework
         {
             return glfwGetX11Window(window);
         }
+
+        public static unsafe IntPtr GetX11Display(Window* window)
+        {
+            return glfwGetX11Display(window);
+        }
+
+        public static unsafe IntPtr GetWin32Window(Window* window)
+        {
+            return glfwGetWin32Window(window);
+        }
     }
 }

OpenToolkit.GraphicsLibraryFramework/GLFWNative.cs

@@ -23,12 +23,12 @@ namespace OpenToolkit.GraphicsLibraryFramework
                     return IntPtr.Zero;
                 }
 
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                if (OperatingSystem.IsLinux())
                 {
                     return NativeLibrary.Load("libglfw.so.3", assembly, path);
                 }
 
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                if (OperatingSystem.IsMacOS())
                 {
                     return NativeLibrary.Load("libglfw.3.dylib", assembly, path);
                 }
@@ -406,5 +406,11 @@ namespace OpenToolkit.GraphicsLibraryFramework
 
         [DllImport(LibraryName)]
         public static extern uint glfwGetX11Window(Window* window);
+
+        [DllImport(LibraryName)]
+        public static extern IntPtr glfwGetX11Display(Window* window);
+
+        [DllImport(LibraryName)]
+        public static extern IntPtr glfwGetWin32Window(Window* window);
     }
 }

OpenToolkit.GraphicsLibraryFramework/OpenToolkit.GraphicsLibraryFramework.csproj

@@ -14,12 +14,6 @@
     <PackageReference Condition="'$(TargetFramework)' == 'net472'" Include="System.Memory" Version="4.5.3" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Content Include="OpenToolkit.GraphicsLibraryFramework.dll.config">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </Content>
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\Robust.Shared\Robust.Shared.csproj" />
   </ItemGroup>

OpenToolkit.GraphicsLibraryFramework/OpenToolkit.GraphicsLibraryFramework.dll.config

@@ -1,5 +0,0 @@
-<configuration>
-    <!-- I actually have no idea whether this works on FreeBSD but it can't hurt to set it as such. -->
-    <dllmap os="linux,freebsd" dll="glfw3.dll" target="glfw.so.3" />
-    <dllmap os="osx" dll="glfw3.dll" target="glfw.3.dylib" />
-</configuration>

README.md

@@ -1,25 +1,16 @@
 ![Robust Toolbox](https://raw.githubusercontent.com/space-wizards/asset-dump/3dd3078e49e3a7e06709a6e0fc6e3223d8d44ca2/robust.png)
 
-[![Build status](https://ci.appveyor.com/api/projects/status/ygb7t8hsj3wt7pnm/branch/master?svg=true)](https://ci.appveyor.com/project/Silvertorch5/space-station-14/branch/master)
-[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=ss14&metric=coverage)](https://sonarcloud.io/dashboard?id=ss14)
+Robust Toolbox is an engine primarily being developed for [Space Station 14](https://github.com/space-wizards/space-station-14), although we're working on making it usable for both [singleplayer](https://github.com/space-wizards/RobustToolboxTemplateSingleplayer) and [multiplayer](https://github.com/space-wizards/RobustToolboxTemplate) projects.
 
-Robust Toolbox is a client/server backend for [Space Station 14](https://github.com/space-wizards/space-station-14).
+Use the [content repo](https://github.com/space-wizards/space-station-14) for actual development, even if you're modifying the engine itself.
 
-### *This repository is the *engine* section of SS14. This is the base engine all SS14 servers will be built on. As such, it does not start on its own: it needs the [content repo](https://github.com/space-wizards/space-station-14). Use said repo for actual development, even if you're modifying the engine itself. Think of Robust Toolbox as BYOND in the context of Spacestation 13.*
+## Project Links
 
-## Getting in Touch
+[Website](https://spacestation14.io/) | [Discord](https://discord.gg/t2jac3p) | [Forum](https://forum.spacestation14.io/) | [Steam](https://store.steampowered.com/app/1255460/Space_Station_14/) | [Standalone Download](https://spacestation14.io/about/nightlies/)
 
-* Website: [spacestation14.io](https://spacestation14.io/)
-* Discord: [Invite Link](https://discord.gg/t2jac3p)
-* IRC: `irc.rizon.net#spacebus`
-* Code Analysis: [Sonar Cloud](https://sonarcloud.io/dashboard?id=ss14)
-* Automatic Content Builds: [builds.spacestation14.io](https://builds.spacestation14.io/jenkins/)
+## Documentation/Wiki
 
-The IRC is setup to relay back and forth to the Discord server so [IRC nerds](https://xkcd.com/1782/) will not be left out.
-
-## Documentation
-
-We have various technical documentation articles on the [HackMD Wiki](https://hackmd.io/@ss14/docs/%2F%40ss14%2Ftechnical-documentation-overview).
+The [HackMD Wiki](https://hackmd.io/@ss14/docs/wiki) has documentation on SS14s content, engine, game design and more. We also have lots of resources for new contributors to the project.
 
 ## Contributing
 
@@ -27,8 +18,8 @@ We are happy to accept contributions from anybody. Get in Discord or IRC if you
 
 ## Building
 
-**In practice, you usually don't build this repository directly.**
+This repository is the **engine** part of SS14. It's the base engine all SS14 servers will be built on. As such, it does not start on its own: it needs the [content repo](https://github.com/space-wizards/space-station-14). Think of Robust Toolbox as BYOND in the context of Spacestation 13.
 
 ## Legal Info
 
-See `legal.md` for licenses and copyright.
+See [legal.md](https://github.com/space-wizards/RobustToolbox/blob/master/legal.md) for licenses and copyright.

Resources/EngineCredits/Libraries.yml

@@ -23,6 +23,48 @@
     OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
     WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+- name: Box2D
+  license: |
+    MIT License
+
+    Copyright (c) 2019 Erin Catto
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
+
+- name: Bullet Physics SDK
+  license: |
+    The files in this repository are licensed under the zlib license, except for the files under 'Extras' and examples/ThirdPartyLibs.
+
+    Bullet Continuous Collision Detection and Physics Library
+    http://bulletphysics.org
+
+    This software is provided 'as-is', without any express or implied warranty.
+    In no event will the authors be held liable for any damages arising from the use of this software.
+    Permission is granted to anyone to use this software for any purpose,
+    including commercial applications, and to alter it and redistribute it freely,
+    subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software.
+    If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
+    2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
+    3. This notice may not be removed or altered from any source distribution.
+
 - name: Castle Core
   license: |
     Copyright 2004-2016 Castle Project - http://www.castleproject.org/
@@ -317,6 +359,43 @@
     See the License for the specific language governing permissions and
     limitations under the License.
 
+- name: Farseer Physics Engine
+  license: |
+    Microsoft Permissive License (Ms-PL)
+
+    This license governs use of the accompanying software.
+    If you use the software, you accept this license.
+    If you do not accept the license, do not use the software.
+
+    1. Definitions
+    The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under U.S. copyright law.
+    A "contribution" is the original software, or any additions or changes to the software.
+    A "contributor" is any person that distributes its contribution under this license.
+    "Licensed patents" are a contributor's patent claims that read directly on its contribution.
+
+    2. Grant of Rights
+    (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,
+    each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution,
+    prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.
+    (B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3,
+    each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to
+    make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or
+    derivative works of the contribution in the software.
+
+    3. Conditions and Limitations
+    (A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.
+    (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software,
+    your patent license from such contributor to the software ends automatically.
+    (C) If you distribute any portion of the software, you must retain all copyright, patent, trademark,
+    and attribution notices that are present in the software.
+    (D) If you distribute any portion of the software in source code form, you may do so only under this license by
+    including a complete copy of this license with your distribution. If you distribute any portion of the software in
+    compiled or object code form, you may only do so under a license that complies with this license.
+    (E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties,
+    guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change.
+    To the extent permitted under your local laws, the contributors exclude the implied warranties of
+    merchantability, fitness for a particular purpose and non-infringement.
+
 - name: Mono.Cecil
   license: |
     Copyright (c) 2008 - 2015 Jb Evain

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

@@ -0,0 +1,11 @@
+## EntitySpawnWindow
+
+entity-spawn-window-title = Entity Spawn Panel
+entity-spawn-window-search-bar-placeholder = search
+entity-spawn-window-clear-button = Clear
+entity-spawn-window-erase-button-text = Erase Mode
+entity-spawn-window-override-menu-tooltip = Override placement
+
+## Console
+
+console-line-edit-placeholder = Command Here

Resources/Locale/en-US/input.ftl

@@ -0,0 +1,54 @@
+input-key-Escape = Escape
+input-key-Control = Control
+input-key-Shift = Shift
+input-key-Alt = Alt
+input-key-Menu = Menu
+input-key-F1 = F1
+input-key-F2 = F2
+input-key-F3 = F3
+input-key-F4 = F4
+input-key-F5 = F5
+input-key-F6 = F6
+input-key-F7 = F7
+input-key-F8 = F8
+input-key-F9 = F9
+input-key-F10 = F10
+input-key-F11 = F11
+input-key-F12 = F12
+input-key-F13 = F13
+input-key-F14 = F14
+input-key-F15 = F15
+input-key-Pause = Pause
+input-key-Left = Left
+input-key-Up = Up
+input-key-Down = Down
+input-key-Right = Right
+input-key-Space = Space
+input-key-Return = Return
+input-key-NumpadEnter = Num Enter
+input-key-BackSpace = Backspace
+input-key-Tab = Tab
+input-key-PageUp = Page Up
+input-key-PageDown = Page Down
+input-key-End = End
+input-key-Home = Home
+input-key-Insert = Insert
+input-key-Delete = Delete
+input-key-MouseLeft = Mouse Left
+input-key-MouseRight = Mouse Right
+input-key-MouseMiddle = Mouse Middle
+input-key-MouseButton4 = Mouse 4
+input-key-MouseButton5 = Mouse 5
+input-key-MouseButton6 = Mouse 6
+input-key-MouseButton7 = Mouse 7
+input-key-MouseButton8 = Mouse 8
+input-key-MouseButton9 = Mouse 9
+
+input-key-LSystem-win = Left Win
+input-key-RSystem-win = Right Win
+input-key-LSystem-mac = Left Cmd
+input-key-RSystem-mac = Right Cmd
+input-key-LSystem-linux = Left Meta
+input-key-RSystem-linux = Right Meta
+
+input-key-unknown = <unknown key>

Resources/Locale/en-US/tab-container.ftl

@@ -0,0 +1 @@
+tab-container-not-tab-title-provided = No title

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

@@ -0,0 +1,11 @@
+## ViewVariablesInstanceEntity
+
+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
+view-variable-instance-entity-server-variables-tab-title = Server Variables
+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]

Resources/Prototypes/dbg_rotationMarker.yml

@@ -1,40 +0,0 @@
-- type: entity
-  id: debugRotation1
-  name: dbg_rotation1
-  components:
-  - type: Clickable
-  - type: InteractionOutline
-  - type: Sprite
-    netsync: false
-    visible: true
-    sprite: debugRotation.rsi
-    state: direction1
-  placement:
-    mode: AlignTileAny
-
-- type: entity
-  id: debugRotation4
-  name: dbg_rotation4
-  components:
-  - type: Clickable
-  - type: InteractionOutline
-  - type: Sprite
-    netsync: false
-    visible: true
-    sprite: debugRotation.rsi
-    state: direction4
-  placement:
-    mode: AlignTileAny
-
-- type: entity
-  id: debugRotationTex
-  name: dbg_rotationTex
-  components:
-  - type: Clickable
-  - type: InteractionOutline
-  - type: Sprite
-    netsync: false
-    visible: true
-    texture: debugRotation.rsi/direction1.png
-  placement:
-    mode: AlignTileAny

Resources/Prototypes/dummy_entity.yml

@@ -1,4 +0,0 @@
-- type: entity
-  name: blank entity
-  id: BlankEntity
-  abstract: true

Resources/Shaders/Internal/fov-lighting.swsl

@@ -28,5 +28,10 @@ void fragment()
 
     highp float occlusion = ChebyshevUpperBound(occlDist, ourDist);
 
+    if (occlusion >= 1.0)
+    {
+        discard;
+    }
+
     COLOR = vec4(0.0, 0.0, 0.0, 1.0 - occlusion);
 }

Resources/Shaders/Internal/light-blur.swsl

@@ -0,0 +1,41 @@
+preset raw;
+
+uniform highp vec2 direction;
+uniform highp vec2 size;
+uniform highp float radius;
+
+varying highp vec2 pos;
+varying highp vec4 blurPos1;
+varying highp vec4 blurPos2;
+
+
+void vertex()
+{
+    highp float aspect = size.y / size.x;
+    highp float horRadius = aspect * radius;
+
+    highp vec2 offset = vec2(horRadius, radius) * direction;
+
+    VERTEX = apply_mvp(VERTEX);
+
+    pos = (VERTEX + vec2(1.0)) / 2.0;
+
+    blurPos1.xy = pos + offset;
+    blurPos1.zw = pos - offset;
+    blurPos2.xy = pos + offset * 2.0;
+    blurPos2.zw = pos - offset * 2.0;
+}
+
+
+void fragment()
+{
+    // Very simple gaussian blur.
+    highp vec4 sum = zTexture(pos) * 0.375;
+
+    sum += zTexture(blurPos1.xy) * 0.25;
+    sum += zTexture(blurPos1.zw) * 0.25;
+    sum += zTexture(blurPos2.xy) * 0.0625;
+    sum += zTexture(blurPos2.zw) * 0.0625;
+
+    COLOR = sum;
+}

Resources/Shaders/Internal/light-soft.swsl

@@ -1,5 +1,11 @@
 #include "/Shaders/Internal/light_shared.swsl"
 
+highp vec4 calcGaussianWeights(highp float sigma, highp vec4 offset)
+{
+    highp vec4 eExp = offset * offset / (2.0 * sigma * sigma);
+    return exp(-eExp) / (sigma * sqrt(2.0 * PI));
+}
+
 highp float createOcclusion(highp vec2 diff)
 {
     // Calculate vector perpendicular to light vector.
@@ -8,23 +14,57 @@ highp float createOcclusion(highp vec2 diff)
 
     highp float ourDist = length(diff);
 
-    highp vec2 occlDist = occludeDepth(diff, shadowMap, lightIndex);
+    // Sample 7 points on a line perpendicular to the light source.
+    // Depending on the closest point, we change the gaussian weights down below
+    // to change the "narrowness" of the samples.
+    perpendicular *= lightSoftness * 1.5;
+
+    // Get all the samples we need.
+    highp vec2 sample1 = occludeDepth(diff, shadowMap, lightIndex);
+    highp vec2 sample2 = occludeDepth(diff + perpendicular, shadowMap, lightIndex);
+    highp vec2 sample3 = occludeDepth(diff - perpendicular, shadowMap, lightIndex);
+    highp vec2 sample4 = occludeDepth(diff + perpendicular * 2.0, shadowMap, lightIndex);
+    highp vec2 sample5 = occludeDepth(diff - perpendicular * 2.0, shadowMap, lightIndex);
+    highp vec2 sample6 = occludeDepth(diff + perpendicular * 3.0, shadowMap, lightIndex);
+    highp vec2 sample7 = occludeDepth(diff - perpendicular * 3.0, shadowMap, lightIndex);
+
+    highp float mindist =
+        min(sample1.x,
+        min(sample2.x,
+        min(sample3.x,
+        min(sample4.x,
+        min(sample5.x,
+        min(sample6.x,
+            sample7.x))))));
+
+    mindist = max(0.001, mindist);
 
     // Change soft shadow size based on distance from primary occluder.
-    highp float distRatio = (ourDist - occlDist.x) / occlDist.x / 2.0;
+    highp float distRatio = (ourDist - mindist);
 
-    perpendicular *= distRatio * lightSoftness;
+    // Sigma can never be zero so make sure to clamp.
+    // TODO: Scaling the dist ratio here in a more sane way might make shadows look better buuuut I'm lazy.
+    // Shadows look pretty nice already.
+    highp float sigma = max(0.001, distRatio * 0.75);
+    highp vec4 weights = calcGaussianWeights(sigma, vec4(0.0, 1.0, 2.0, 3.0));
 
-    // Totally not hacky PCF on top of VSM.
-    highp float occlusion = smoothstep(0.1, 1.0, ChebyshevUpperBound(occlDist, ourDist));
+    // Calculation of gaussian weights here is broken because it doesn't add up to 1.
+    // Fixing this is hard and if I had to guess too expensive for GPU shaders.
+    // So instead we add up the total weights and scale the result with that,
+    // so that we still end up with 0-1.
+    highp float totalWeigths = weights.x + weights.y * 2.0 + weights.z * 2.0 + weights.w * 2.0;
 
-    occlusion += shadowContrib(diff + perpendicular);
-    occlusion += shadowContrib(diff - perpendicular);
-    occlusion += shadowContrib(diff + perpendicular * 2.0);
-    occlusion += shadowContrib(diff - perpendicular * 2.0);
-    occlusion += shadowContrib(diff + perpendicular * 3.0);
-    occlusion += shadowContrib(diff - perpendicular * 3.0);
+    highp float occlusion = 0.0;
 
-    return occlusion / 7.0;
+    // Calculate actual occlusion with new weights.
+    occlusion += ChebyshevUpperBound(sample1, ourDist) * weights.x;
+    occlusion += ChebyshevUpperBound(sample2, ourDist) * weights.y;
+    occlusion += ChebyshevUpperBound(sample3, ourDist) * weights.y;
+    occlusion += ChebyshevUpperBound(sample4, ourDist) * weights.z;
+    occlusion += ChebyshevUpperBound(sample5, ourDist) * weights.z;
+    occlusion += ChebyshevUpperBound(sample6, ourDist) * weights.w;
+    occlusion += ChebyshevUpperBound(sample7, ourDist) * weights.w;
+
+    return occlusion / totalWeigths;
 }
 

Robust.Analyzers/FriendAnalyzer.cs

@@ -0,0 +1,107 @@
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Robust.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class FriendAnalyzer : DiagnosticAnalyzer
+    {
+        const string FriendAttribute = "Robust.Shared.Analyzers.FriendAttribute";
+
+        public const string DiagnosticId = "RA0002";
+
+        private const string Title = "Tried to access friend-only member";
+        private const string MessageFormat = "Tried to access member \"{0}\" in class \"{1}\" which can only be accessed by friend classes";
+        private const string Description = "Make sure to specify the accessing class in the friends attribute.";
+        private const string Category = "Usage";
+
+        [SuppressMessage("ReSharper", "RS2008")]
+        private static readonly DiagnosticDescriptor Rule = new (DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Error, true, Description);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
+            context.EnableConcurrentExecution();
+            context.RegisterSyntaxNodeAction(CheckFriendship, SyntaxKind.SimpleMemberAccessExpression);
+        }
+
+        private void CheckFriendship(SyntaxNodeAnalysisContext context)
+        {
+            if (context.Node is not MemberAccessExpressionSyntax memberAccess)
+                return;
+
+            // We only do something if our parent is one of a few types.
+            switch (context.Node.Parent)
+            {
+                // If we're being assigned...
+                case AssignmentExpressionSyntax assignParent:
+                {
+                    if (assignParent.Left != memberAccess)
+                        return;
+                    break;
+                }
+
+                // If we're being invoked...
+                case InvocationExpressionSyntax:
+                    break;
+
+                // Otherwise, do nothing.
+                default:
+                    return;
+            }
+
+            // Get the friend attribute
+            var friendAttr = context.Compilation.GetTypeByMetadataName(FriendAttribute);
+
+            // Get the type that is containing this expression, or, the class where this is happening.
+            if (context.ContainingSymbol?.ContainingType is not { } containingType)
+                return;
+
+            // We check all of our children and get only the identifiers.
+            foreach (var identifier in memberAccess.ChildNodes().Select(node => node as IdentifierNameSyntax))
+            {
+                if (identifier == null) continue;
+
+                // Get the type info of the identifier, so we can check the attributes...
+                if (context.SemanticModel.GetTypeInfo(identifier).ConvertedType is not { } type)
+                    continue;
+
+                // Same-type access is always fine.
+                if (SymbolEqualityComparer.Default.Equals(type, containingType))
+                    continue;
+
+                // Finally, get all attributes of the type, to check if we have any friend classes.
+                foreach (var attribute in type.GetAttributes())
+                {
+                    // If the attribute isn't the friend attribute, continue.
+                    if (!SymbolEqualityComparer.Default.Equals(attribute.AttributeClass, friendAttr))
+                        continue;
+
+                    // Check all types allowed in the friend attribute. (We assume there's only one constructor arg.)
+                    foreach (var constant in attribute.ConstructorArguments[0].Values)
+                    {
+                        // Check if the value is a type...
+                        if (constant.Value is not INamedTypeSymbol t)
+                            continue;
+
+                        // If we find that the containing class is specified in the attribute, return! All is good.
+                        if (SymbolEqualityComparer.Default.Equals(containingType, t))
+                            return;
+                    }
+
+                    // Not in a friend class! Report an error.
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(Rule, context.Node.GetLocation(),
+                            $"{context.Node.ToString().Split('.').LastOrDefault()}", $"{type.Name}"));
+                }
+            }
+        }
+    }
+}

Robust.Analyzers/Robust.Analyzers.csproj

@@ -2,6 +2,7 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
+    <LangVersion>9</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>

Robust.Benchmarks/NumericsHelpers/AddBenchmark.cs

@@ -0,0 +1,28 @@
+using BenchmarkDotNet.Attributes;
+
+namespace Robust.Benchmarks.NumericsHelpers
+{
+    public class AddBenchmark
+    {
+        [Params(32, 128)]
+        public int N { get; set; }
+
+        private float[] _inputA = default!;
+        private float[] _inputB = default!;
+        private float[] _output = default!;
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            _inputA = new float[N];
+            _inputB = new float[N];
+            _output = new float[N];
+        }
+
+        [Benchmark]
+        public void Bench()
+        {
+            Shared.Maths.NumericsHelpers.Add(_inputA, _inputB, _output);
+        }
+    }
+}

Robust.Benchmarks/Program.cs

@@ -0,0 +1,14 @@
+using BenchmarkDotNet.Running;
+
+namespace Robust.Benchmarks
+{
+    internal class Program
+    {
+        // --allCategories=ctg1,ctg2
+        // --anyCategories=ctg1,ctg2
+        public static void Main(string[] args)
+        {
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+        }
+    }
+}

Robust.Benchmarks/Robust.Benchmarks.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <Import Project="..\MSBuild\Robust.Properties.targets" />
+    <Import Project="..\MSBuild\Robust.Engine.props" />
+    <PropertyGroup>
+        <IsPackable>false</IsPackable>
+        <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+        <OutputPath>../bin/Benchmarks</OutputPath>
+        <OutputType>Exe</OutputType>
+    </PropertyGroup>
+    <ItemGroup>
+      <ProjectReference Include="..\Robust.Server\Robust.Server.csproj" />
+      <ProjectReference Include="..\Robust.Shared\Robust.Shared.csproj" />
+    </ItemGroup>
+    <ItemGroup>
+      <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+    </ItemGroup>
+    <Import Project="..\MSBuild\Robust.Engine.targets" />
+</Project>

Robust.Benchmarks/Serialization/BenchmarkIntSerializer.cs

@@ -0,0 +1,40 @@
+using System.Globalization;
+using Robust.Shared.IoC;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Manager.Result;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Validation;
+using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Serialization.TypeSerializers.Interfaces;
+
+namespace Robust.Benchmarks.Serialization
+{
+    public class BenchmarkIntSerializer : ITypeSerializer<int, ValueDataNode>
+    {
+        public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
+            IDependencyCollection dependencies, ISerializationContext? context = null)
+        {
+            return int.TryParse(node.Value, out _)
+                ? new ValidatedValueNode(node)
+                : new ErrorNode(node, $"Failed parsing int value: {node.Value}");
+        }
+
+        public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node,
+            IDependencyCollection dependencies, bool skipHook, ISerializationContext? context = null)
+        {
+            return new DeserializedValue<int>(int.Parse(node.Value, CultureInfo.InvariantCulture));
+        }
+
+        public DataNode Write(ISerializationManager serializationManager, int value, bool alwaysWrite = false,
+            ISerializationContext? context = null)
+        {
+            return new ValueDataNode(value.ToString(CultureInfo.InvariantCulture));
+        }
+
+        public int Copy(ISerializationManager serializationManager, int source, int target, bool skipHook,
+            ISerializationContext? context = null)
+        {
+            return source;
+        }
+    }
+}

Robust.Benchmarks/Serialization/Copy/SerializationCopyBenchmark.cs

@@ -0,0 +1,151 @@
+using System.IO;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using Robust.Shared.Utility;
+using YamlDotNet.RepresentationModel;
+
+namespace Robust.Benchmarks.Serialization.Copy
+{
+    [MemoryDiagnoser]
+    public class SerializationCopyBenchmark : SerializationBenchmark
+    {
+        public SerializationCopyBenchmark()
+        {
+            InitializeSerialization();
+
+            DataDefinitionWithString = new DataDefinitionWithString {StringField = "ABC"};
+
+            var yamlStream = new YamlStream();
+            yamlStream.Load(new StringReader(SeedDataDefinition.Prototype));
+
+            var seedMapping = yamlStream.Documents[0].RootNode.ToDataNodeCast<SequenceDataNode>().Cast<MappingDataNode>(0);
+
+            Seed = SerializationManager.ReadValueOrThrow<SeedDataDefinition>(seedMapping);
+        }
+
+        private const string String = "ABC";
+
+        private const int Integer = 1;
+
+        private DataDefinitionWithString DataDefinitionWithString { get; }
+
+        private SeedDataDefinition Seed { get; }
+
+        private BenchmarkFlagsEnum FlagZero = BenchmarkFlagsEnum.Zero;
+
+        private BenchmarkFlagsEnum FlagThirtyOne = BenchmarkFlagsEnum.ThirtyOne;
+
+        [Benchmark]
+        public string? CreateCopyString()
+        {
+            return SerializationManager.CreateCopy(String);
+        }
+
+        [Benchmark]
+        public int? CreateCopyInteger()
+        {
+            return SerializationManager.CreateCopy(Integer);
+        }
+
+        [Benchmark]
+        public DataDefinitionWithString? CreateCopyDataDefinitionWithString()
+        {
+            return SerializationManager.CreateCopy(DataDefinitionWithString);
+        }
+
+        [Benchmark]
+        public SeedDataDefinition? CreateCopySeedDataDefinition()
+        {
+            return SerializationManager.CreateCopy(Seed);
+        }
+
+        [Benchmark]
+        public SeedDataDefinition BaselineCreateCopySeedDataDefinition()
+        {
+            // ReSharper disable once UseObjectOrCollectionInitializer
+            var copy = new SeedDataDefinition();
+
+            copy.ID = Seed.ID;
+            copy.Name = Seed.Name;
+            copy.SeedName = Seed.SeedName;
+            copy.SeedNoun = Seed.SeedNoun;
+            copy.DisplayName = Seed.DisplayName;
+            copy.RoundStart = Seed.RoundStart;
+            copy.Mysterious = Seed.Mysterious;
+            copy.Immutable = Seed.Immutable;
+
+            copy.ProductPrototypes = Seed.ProductPrototypes.ToList();
+            copy.Chemicals = Seed.Chemicals.ToDictionary(p => p.Key, p => p.Value);
+            copy.ConsumeGasses = Seed.ConsumeGasses.ToDictionary(p => p.Key, p => p.Value);
+            copy.ExudeGasses = Seed.ExudeGasses.ToDictionary(p => p.Key, p => p.Value);
+
+            copy.NutrientConsumption = Seed.NutrientConsumption;
+            copy.WaterConsumption = Seed.WaterConsumption;
+            copy.IdealHeat = Seed.IdealHeat;
+            copy.HeatTolerance = Seed.HeatTolerance;
+            copy.IdealLight = Seed.IdealLight;
+            copy.LightTolerance = Seed.LightTolerance;
+            copy.ToxinsTolerance = Seed.ToxinsTolerance;
+            copy.LowPressureTolerance = Seed.LowPressureTolerance;
+            copy.HighPressureTolerance = Seed.HighPressureTolerance;
+            copy.PestTolerance = Seed.PestTolerance;
+            copy.WeedTolerance = Seed.WeedTolerance;
+
+            copy.Endurance = Seed.Endurance;
+            copy.Yield = Seed.Yield;
+            copy.Lifespan = Seed.Lifespan;
+            copy.Maturation = Seed.Maturation;
+            copy.Production = Seed.Production;
+            copy.GrowthStages = Seed.GrowthStages;
+            copy.HarvestRepeat = Seed.HarvestRepeat;
+            copy.Potency = Seed.Potency;
+            copy.Ligneous = Seed.Ligneous;
+
+            copy.PlantRsi = Seed.PlantRsi == null
+                ? null!
+                : new ResourcePath(Seed.PlantRsi.ToString(), Seed.PlantRsi.Separator);
+            copy.PlantIconState = Seed.PlantIconState;
+            copy.Bioluminescent = Seed.Bioluminescent;
+            copy.BioluminescentColor = Seed.BioluminescentColor;
+            copy.SplatPrototype = Seed.SplatPrototype;
+
+            return copy;
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public object? CopyFlagZero()
+        {
+            return SerializationManager.CopyWithTypeSerializer(
+                typeof(FlagSerializer<BenchmarkFlags>),
+                (int) FlagZero,
+                (int) FlagZero);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public object? CopyFlagThirtyOne()
+        {
+            return SerializationManager.CopyWithTypeSerializer(
+                typeof(FlagSerializer<BenchmarkFlags>),
+                (int) FlagThirtyOne,
+                (int) FlagThirtyOne);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("customTypeSerializer")]
+        public object? CopyIntegerCustomSerializer()
+        {
+            return SerializationManager.CopyWithTypeSerializer(
+                typeof(BenchmarkIntSerializer),
+                Integer,
+                Integer);
+        }
+    }
+}

Robust.Benchmarks/Serialization/Definitions/BenchmarkFlags.cs

@@ -0,0 +1,19 @@
+using System;
+using Robust.Shared.Serialization;
+
+namespace Robust.Benchmarks.Serialization.Definitions
+{
+    public class BenchmarkFlags
+    {
+        public const int Zero = 1 << 0;
+        public const int ThirtyOne = 1 << 31;
+    }
+
+    [Flags]
+    [FlagsFor(typeof(BenchmarkFlags))]
+    public enum BenchmarkFlagsEnum
+    {
+        Zero = BenchmarkFlags.Zero,
+        ThirtyOne = BenchmarkFlags.ThirtyOne
+    }
+}

Robust.Benchmarks/Serialization/Definitions/DataDefinitionWithString.cs

@@ -0,0 +1,11 @@
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Robust.Benchmarks.Serialization.Definitions
+{
+    [DataDefinition]
+    public class DataDefinitionWithString
+    {
+        [DataField("string")]
+        public string StringField { get; init; } = default!;
+    }
+}

Robust.Benchmarks/Serialization/Definitions/SealedDataDefinitionWithString.cs

@@ -0,0 +1,11 @@
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Robust.Benchmarks.Serialization.Definitions
+{
+    [DataDefinition]
+    public sealed class SealedDataDefinitionWithString
+    {
+        [DataField("string")]
+        public string StringField { get; init; } = default!;
+    }
+}

Robust.Benchmarks/Serialization/Definitions/SeedDataDefinition.cs

@@ -0,0 +1,119 @@
+using System.Collections.Generic;
+using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.Utility;
+
+namespace Robust.Benchmarks.Serialization.Definitions
+{
+    /// <summary>
+    ///     Arbitrarily large data definition for benchmarks.
+    ///     Taken from content.
+    /// </summary>
+    [Prototype("seed")]
+    public class SeedDataDefinition : IPrototype
+    {
+        public const string Prototype = @"
+- type: seed
+  id: tobacco
+  name: tobacco
+  seedName: tobacco
+  displayName: tobacco plant
+  productPrototypes:
+    - LeavesTobacco
+  harvestRepeat: Repeat
+  lifespan: 75
+  maturation: 5
+  production: 5
+  yield: 2
+  potency: 20
+  growthStages: 3
+  idealLight: 9
+  idealHeat: 298
+  chemicals:
+    chem.Nicotine:
+      Min: 1
+      Max: 10
+      PotencyDivisor: 10";
+
+        [DataField("id", required: true)] public string ID { get; set; } = default!;
+
+        #region Tracking
+        [DataField("name")] public string Name { get; set; } = string.Empty;
+        [DataField("seedName")] public string SeedName { get; set; } = string.Empty;
+        [DataField("seedNoun")] public string SeedNoun { get; set; } = "seeds";
+        [DataField("displayName")] public string DisplayName { get; set; } = string.Empty;
+        [DataField("roundStart")] public bool RoundStart { get; set; } = true;
+        [DataField("mysterious")] public bool Mysterious { get; set; }
+        [DataField("immutable")] public bool Immutable { get; set; }
+        #endregion
+
+        #region Output
+        [DataField("productPrototypes")]
+        public List<string> ProductPrototypes { get; set; } = new();
+        [DataField("chemicals")]
+        public Dictionary<string, SeedChemQuantity> Chemicals { get; set; } = new();
+        [DataField("consumeGasses")]
+        public Dictionary<Gas, float> ConsumeGasses { get; set; } = new();
+        [DataField("exudeGasses")]
+        public Dictionary<Gas, float> ExudeGasses { get; set; } = new();
+        #endregion
+
+        #region Tolerances
+        [DataField("nutrientConsumption")] public float NutrientConsumption { get; set; } = 0.25f;
+        [DataField("waterConsumption")] public float WaterConsumption { get; set; } = 3f;
+        [DataField("idealHeat")] public float IdealHeat { get; set; } = 293f;
+        [DataField("heatTolerance")] public float HeatTolerance { get; set; } = 20f;
+        [DataField("idealLight")] public float IdealLight { get; set; } = 7f;
+        [DataField("lightTolerance")] public float LightTolerance { get; set; } = 5f;
+        [DataField("toxinsTolerance")] public float ToxinsTolerance { get; set; } = 4f;
+        [DataField("lowPressureTolerance")] public float LowPressureTolerance { get; set; } = 25f;
+        [DataField("highPressureTolerance")] public float HighPressureTolerance { get; set; } = 200f;
+        [DataField("pestTolerance")] public float PestTolerance { get; set; } = 5f;
+        [DataField("weedTolerance")] public float WeedTolerance { get; set; } = 5f;
+        #endregion
+
+        #region General traits
+        [DataField("endurance")] public float Endurance { get; set; } = 100f;
+        [DataField("yield")] public int Yield { get; set; }
+        [DataField("lifespan")] public float Lifespan { get; set; }
+        [DataField("maturation")] public float Maturation { get; set; }
+        [DataField("production")] public float Production { get; set; }
+        [DataField("growthStages")] public int GrowthStages { get; set; } = 6;
+        [DataField("harvestRepeat")] public HarvestType HarvestRepeat { get; set; } = HarvestType.NoRepeat;
+        [DataField("potency")] public float Potency { get; set; } = 1f;
+        [DataField("ligneous")] public bool Ligneous { get; set; }
+        #endregion
+
+        #region Cosmetics
+        [DataField("plantRsi", required: true)] public ResourcePath PlantRsi { get; set; } = default!;
+        [DataField("plantIconState")] public string PlantIconState { get; set; } = "produce";
+        [DataField("bioluminescent")] public bool Bioluminescent { get; set; }
+        [DataField("bioluminescentColor")] public Color BioluminescentColor { get; set; } = Color.White;
+        [DataField("splatPrototype")] public string? SplatPrototype { get; set; }
+        #endregion
+    }
+
+    public enum HarvestType
+    {
+        NoRepeat,
+        Repeat
+    }
+
+    public enum Gas
+    {
+    }
+
+    [DataDefinition]
+    public struct SeedChemQuantity
+    {
+        [DataField("Min")]
+        public int Min;
+
+        [DataField("Max")]
+        public int Max;
+
+        [DataField("PotencyDivisor")]
+        public int PotencyDivisor;
+    }
+}

Robust.Benchmarks/Serialization/Initialize/SerializationInitializeBenchmark.cs

@@ -0,0 +1,22 @@
+using BenchmarkDotNet.Attributes;
+using Robust.Shared.Serialization.Manager;
+
+namespace Robust.Benchmarks.Serialization.Initialize
+{
+    [MemoryDiagnoser]
+    public class SerializationInitializeBenchmark : SerializationBenchmark
+    {
+        [IterationCleanup]
+        public void IterationCleanup()
+        {
+            SerializationManager.Shutdown();
+        }
+
+        [Benchmark]
+        public ISerializationManager Initialize()
+        {
+            InitializeSerialization();
+            return SerializationManager;
+        }
+    }
+}

Robust.Benchmarks/Serialization/Read/SerializationReadBenchmark.cs

@@ -0,0 +1,96 @@
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Serialization.Manager.Result;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using YamlDotNet.RepresentationModel;
+
+namespace Robust.Benchmarks.Serialization.Read
+{
+    [MemoryDiagnoser]
+    public class SerializationReadBenchmark : SerializationBenchmark
+    {
+        public SerializationReadBenchmark()
+        {
+            InitializeSerialization();
+
+            StringDataDefNode = new MappingDataNode();
+            StringDataDefNode.Add(new ValueDataNode("string"), new ValueDataNode("ABC"));
+
+            var yamlStream = new YamlStream();
+            yamlStream.Load(new StringReader(SeedDataDefinition.Prototype));
+
+            SeedNode = yamlStream.Documents[0].RootNode.ToDataNodeCast<SequenceDataNode>().Cast<MappingDataNode>(0);
+        }
+
+        private ValueDataNode StringNode { get; } = new("ABC");
+
+        private ValueDataNode IntNode { get; } = new("1");
+
+        private MappingDataNode StringDataDefNode { get; }
+
+        private MappingDataNode SeedNode { get; }
+
+        private ValueDataNode FlagZero { get; } = new("Zero");
+
+        private ValueDataNode FlagThirtyOne { get; } = new("ThirtyOne");
+
+        [Benchmark]
+        public string? ReadString()
+        {
+            return SerializationManager.ReadValue<string>(StringNode);
+        }
+
+        [Benchmark]
+        public int? ReadInteger()
+        {
+            return SerializationManager.ReadValue<int>(IntNode);
+        }
+
+        [Benchmark]
+        public DataDefinitionWithString? ReadDataDefinitionWithString()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString>(StringDataDefNode);
+        }
+
+        [Benchmark]
+        public SeedDataDefinition? ReadSeedDataDefinition()
+        {
+            return SerializationManager.ReadValue<SeedDataDefinition>(SeedNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DeserializationResult ReadFlagZero()
+        {
+            return SerializationManager.ReadWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagZero);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DeserializationResult ReadThirtyOne()
+        {
+            return SerializationManager.ReadWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagThirtyOne);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("customTypeSerializer")]
+        public DeserializationResult ReadIntegerCustomSerializer()
+        {
+            return SerializationManager.ReadWithTypeSerializer(
+                typeof(int),
+                typeof(BenchmarkIntSerializer),
+                IntNode);
+        }
+    }
+}

Robust.Benchmarks/Serialization/SerializationArrayBenchmark.cs

@@ -0,0 +1,127 @@
+using BenchmarkDotNet.Attributes;
+using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.Markdown.Value;
+
+namespace Robust.Benchmarks.Serialization
+{
+    [MemoryDiagnoser]
+    public class SerializationArrayBenchmark : SerializationBenchmark
+    {
+        public SerializationArrayBenchmark()
+        {
+            InitializeSerialization();
+
+            OneStringDefNode = new SequenceDataNode();
+            OneStringDefNode.Add(new MappingDataNode
+            {
+                ["string"] = new ValueDataNode("ABC")
+            });
+
+            TenStringDefsNode = new SequenceDataNode();
+
+            for (var i = 0; i < 10; i++)
+            {
+                TenStringDefsNode.Add(new MappingDataNode
+                {
+                    ["string"] = new ValueDataNode("ABC")
+                });
+            }
+        }
+
+        private SequenceDataNode EmptyNode { get; } = new();
+
+        private SequenceDataNode OneIntNode { get; } = new("1");
+
+        private SequenceDataNode TenIntsNode { get; } = new("1", "2", "3", "4", "5", "6", "7", "8", "9", "10");
+
+        private SequenceDataNode OneStringDefNode { get; }
+
+        private SequenceDataNode TenStringDefsNode { get; }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public string[]? ReadEmptyString()
+        {
+            return SerializationManager.ReadValue<string[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public string[]? ReadOneString()
+        {
+            return SerializationManager.ReadValue<string[]>(OneIntNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public string[]? ReadTenStrings()
+        {
+            return SerializationManager.ReadValue<string[]>(TenIntsNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public int[]? ReadEmptyInt()
+        {
+            return SerializationManager.ReadValue<int[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public int[]? ReadOneInt()
+        {
+            return SerializationManager.ReadValue<int[]>(OneIntNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public int[]? ReadTenInts()
+        {
+            return SerializationManager.ReadValue<int[]>(TenIntsNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public DataDefinitionWithString[]? ReadEmptyStringDataDef()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public DataDefinitionWithString[]? ReadOneStringDataDef()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString[]>(OneStringDefNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public DataDefinitionWithString[]? ReadTenStringDataDefs()
+        {
+            return SerializationManager.ReadValue<DataDefinitionWithString[]>(TenStringDefsNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public SealedDataDefinitionWithString[]? ReadEmptySealedStringDataDef()
+        {
+            return SerializationManager.ReadValue<SealedDataDefinitionWithString[]>(EmptyNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public SealedDataDefinitionWithString[]? ReadOneSealedStringDataDef()
+        {
+            return SerializationManager.ReadValue<SealedDataDefinitionWithString[]>(OneStringDefNode);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("read")]
+        public SealedDataDefinitionWithString[]? ReadTenSealedStringDataDefs()
+        {
+            return SerializationManager.ReadValue<SealedDataDefinitionWithString[]>(TenStringDefsNode);
+        }
+    }
+}

Robust.Benchmarks/Serialization/SerializationBenchmark.cs

@@ -0,0 +1,43 @@
+using System;
+using Robust.Server;
+using Robust.Shared.Configuration;
+using Robust.Shared.ContentPack;
+using Robust.Shared.IoC;
+using Robust.Shared.Reflection;
+using Robust.Shared.Serialization.Manager;
+
+namespace Robust.Benchmarks.Serialization
+{
+    public abstract class SerializationBenchmark
+    {
+        public SerializationBenchmark()
+        {
+            IoCManager.InitThread();
+            ServerIoC.RegisterIoC();
+            IoCManager.BuildGraph();
+
+            var assemblies = new[]
+            {
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Shared"),
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Server"),
+                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Benchmarks")
+            };
+
+            foreach (var assembly in assemblies)
+            {
+                IoCManager.Resolve<IConfigurationManagerInternal>().LoadCVarsFromAssembly(assembly);
+            }
+
+            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
+
+            SerializationManager = IoCManager.Resolve<ISerializationManager>();
+        }
+
+        protected ISerializationManager SerializationManager { get; }
+
+        public void InitializeSerialization()
+        {
+            SerializationManager.Initialize();
+        }
+    }
+}

Robust.Benchmarks/Serialization/Write/SerializationWriteBenchmark.cs

@@ -0,0 +1,134 @@
+using System.Globalization;
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.Markdown.Value;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+using YamlDotNet.RepresentationModel;
+
+namespace Robust.Benchmarks.Serialization.Write
+{
+    [MemoryDiagnoser]
+    public class SerializationWriteBenchmark : SerializationBenchmark
+    {
+        public SerializationWriteBenchmark()
+        {
+            InitializeSerialization();
+
+            DataDefinitionWithString = new DataDefinitionWithString {StringField = "ABC"};
+
+            var yamlStream = new YamlStream();
+            yamlStream.Load(new StringReader(SeedDataDefinition.Prototype));
+
+            var seedMapping = yamlStream.Documents[0].RootNode.ToDataNodeCast<SequenceDataNode>().Cast<MappingDataNode>(0);
+
+            Seed = SerializationManager.ReadValueOrThrow<SeedDataDefinition>(seedMapping);
+        }
+
+        private const string String = "ABC";
+
+        private const int Integer = 1;
+
+        private DataDefinitionWithString DataDefinitionWithString { get; }
+
+        private SeedDataDefinition Seed { get; }
+
+        private BenchmarkFlagsEnum FlagZero = BenchmarkFlagsEnum.Zero;
+
+        private BenchmarkFlagsEnum FlagThirtyOne = BenchmarkFlagsEnum.ThirtyOne;
+
+        [Benchmark]
+        public DataNode WriteString()
+        {
+            return SerializationManager.WriteValue(String);
+        }
+
+        [Benchmark]
+        public DataNode WriteInteger()
+        {
+            return SerializationManager.WriteValue(Integer);
+        }
+
+        [Benchmark]
+        public DataNode WriteDataDefinitionWithString()
+        {
+            return SerializationManager.WriteValue(DataDefinitionWithString);
+        }
+
+        [Benchmark]
+        public DataNode WriteSeedDataDefinition()
+        {
+            return SerializationManager.WriteValue(Seed);
+        }
+
+        [Benchmark]
+        public DataNode BaselineWriteSeedDataDefinition()
+        {
+            var mapping = new MappingDataNode();
+
+            mapping.Add("id", Seed.ID);
+            mapping.Add("name", Seed.Name);
+            mapping.Add("seedName", Seed.SeedName);
+            mapping.Add("displayName", Seed.DisplayName);
+            mapping.Add("productPrototypes", Seed.ProductPrototypes);
+            mapping.Add("harvestRepeat", Seed.HarvestRepeat.ToString());
+            mapping.Add("lifespan", Seed.Lifespan.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("maturation", Seed.Maturation.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("production", Seed.Production.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("yield", Seed.Yield.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("potency", Seed.Potency.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("growthStages", Seed.GrowthStages.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("idealLight", Seed.IdealLight.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("idealHeat", Seed.IdealHeat.ToString(CultureInfo.InvariantCulture));
+
+            var chemicals = new MappingDataNode();
+            foreach (var (name, quantity) in Seed.Chemicals)
+            {
+                chemicals.Add(name, new MappingDataNode
+                {
+                    ["Min"] = new ValueDataNode(quantity.Min.ToString(CultureInfo.InvariantCulture)),
+                    ["Max"] = new ValueDataNode(quantity.Max.ToString(CultureInfo.InvariantCulture)),
+                    ["PotencyDivisor"] = new ValueDataNode(quantity.PotencyDivisor.ToString(CultureInfo.InvariantCulture))
+                });
+            }
+
+            mapping.Add("chemicals", chemicals);
+
+            return mapping;
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DataNode WriteFlagZero()
+        {
+            return SerializationManager.WriteWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagZero);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("flag")]
+        public DataNode WriteThirtyOne()
+        {
+            return SerializationManager.WriteWithTypeSerializer(
+                typeof(int),
+                typeof(FlagSerializer<BenchmarkFlags>),
+                FlagThirtyOne);
+        }
+
+        [Benchmark]
+        [BenchmarkCategory("customTypeSerializer")]
+        public DataNode WriteIntegerCustomSerializer()
+        {
+            return SerializationManager.WriteWithTypeSerializer(
+                typeof(int),
+                typeof(BenchmarkIntSerializer),
+                Integer);
+        }
+    }
+}

Robust.Client.CEF/BeforeBrowseContext.cs

@@ -0,0 +1,32 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public sealed class BeforeBrowseContext
+    {
+        internal readonly CefRequest CefRequest;
+
+        public string Url => CefRequest.Url;
+        public string Method => CefRequest.Method;
+
+        public bool IsRedirect { get; }
+        public bool UserGesture { get; }
+
+        public bool IsCancelled { get; private set; }
+
+        internal BeforeBrowseContext(
+            bool isRedirect,
+            bool userGesture,
+            CefRequest cefRequest)
+        {
+            CefRequest = cefRequest;
+            IsRedirect = isRedirect;
+            UserGesture = userGesture;
+        }
+
+        public void DoCancel()
+        {
+            IsCancelled = true;
+        }
+    }
+}

Robust.Client.CEF/BrowserControl.cs

@@ -0,0 +1,593 @@
+using System;
+using System.Collections.Generic;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.UserInterface;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.Maths;
+using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
+using SixLabors.ImageSharp.PixelFormats;
+using Xilium.CefGlue;
+using static Robust.Client.CEF.CefKeyCodes;
+using static Robust.Client.CEF.CefKeyCodes.ChromiumKeyboardCode;
+using static Robust.Client.Input.Keyboard;
+
+namespace Robust.Client.CEF
+{
+    // Funny browser control to integrate in UI.
+    public class BrowserControl : Control, IBrowserControl, IRawInputControl
+    {
+        private const int ScrollSpeed = 50;
+
+        [Dependency] private readonly IClyde _clyde = default!;
+        [Dependency] private readonly IInputManager _inputMgr = default!;
+        [Dependency] private readonly CefManager _cef = default!;
+
+        private RobustRequestHandler _requestHandler = new RobustRequestHandler(Logger.GetSawmill("root"));
+        private LiveData? _data;
+        private string _startUrl = "about:blank";
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        public string Url
+        {
+            get => _data == null ? _startUrl : _data.Browser.GetMainFrame().Url;
+            set
+            {
+                if (_data == null)
+                    _startUrl = value;
+                else
+                    _data.Browser.GetMainFrame().LoadUrl(value);
+            }
+        }
+
+        [ViewVariables] public bool IsLoading => _data?.Browser.IsLoading ?? false;
+
+        private readonly Dictionary<Key, ChromiumKeyboardCode> _keyMap = new()
+        {
+            [Key.A] = VKEY_A,
+            [Key.B] = VKEY_B,
+            [Key.C] = VKEY_C,
+            [Key.D] = VKEY_D,
+            [Key.E] = VKEY_E,
+            [Key.F] = VKEY_F,
+            [Key.G] = VKEY_G,
+            [Key.H] = VKEY_H,
+            [Key.I] = VKEY_I,
+            [Key.J] = VKEY_J,
+            [Key.K] = VKEY_K,
+            [Key.L] = VKEY_L,
+            [Key.M] = VKEY_M,
+            [Key.N] = VKEY_N,
+            [Key.O] = VKEY_O,
+            [Key.P] = VKEY_P,
+            [Key.Q] = VKEY_Q,
+            [Key.R] = VKEY_R,
+            [Key.S] = VKEY_S,
+            [Key.T] = VKEY_T,
+            [Key.U] = VKEY_U,
+            [Key.V] = VKEY_V,
+            [Key.W] = VKEY_W,
+            [Key.X] = VKEY_X,
+            [Key.Y] = VKEY_Y,
+            [Key.Z] = VKEY_Z,
+            [Key.Num0] = VKEY_0,
+            [Key.Num1] = VKEY_1,
+            [Key.Num2] = VKEY_2,
+            [Key.Num3] = VKEY_3,
+            [Key.Num4] = VKEY_4,
+            [Key.Num5] = VKEY_5,
+            [Key.Num6] = VKEY_6,
+            [Key.Num7] = VKEY_7,
+            [Key.Num8] = VKEY_8,
+            [Key.Num9] = VKEY_9,
+            [Key.NumpadNum0] = VKEY_NUMPAD0,
+            [Key.NumpadNum1] = VKEY_NUMPAD1,
+            [Key.NumpadNum2] = VKEY_NUMPAD2,
+            [Key.NumpadNum3] = VKEY_NUMPAD3,
+            [Key.NumpadNum4] = VKEY_NUMPAD4,
+            [Key.NumpadNum5] = VKEY_NUMPAD5,
+            [Key.NumpadNum6] = VKEY_NUMPAD6,
+            [Key.NumpadNum7] = VKEY_NUMPAD7,
+            [Key.NumpadNum8] = VKEY_NUMPAD8,
+            [Key.NumpadNum9] = VKEY_NUMPAD9,
+            [Key.Escape] = VKEY_ESCAPE,
+            [Key.Control] = VKEY_CONTROL,
+            [Key.Shift] = VKEY_SHIFT,
+            [Key.Alt] = VKEY_MENU,
+            [Key.LSystem] = VKEY_LWIN,
+            [Key.RSystem] = VKEY_RWIN,
+            [Key.LBracket] = VKEY_OEM_4,
+            [Key.RBracket] = VKEY_OEM_6,
+            [Key.SemiColon] = VKEY_OEM_1,
+            [Key.Comma] = VKEY_OEM_COMMA,
+            [Key.Period] = VKEY_OEM_PERIOD,
+            [Key.Apostrophe] = VKEY_OEM_7,
+            [Key.Slash] = VKEY_OEM_2,
+            [Key.BackSlash] = VKEY_OEM_5,
+            [Key.Tilde] = VKEY_OEM_3,
+            [Key.Equal] = VKEY_OEM_PLUS,
+            [Key.Space] = VKEY_SPACE,
+            [Key.Return] = VKEY_RETURN,
+            [Key.BackSpace] = VKEY_BACK,
+            [Key.Tab] = VKEY_TAB,
+            [Key.PageUp] = VKEY_PRIOR,
+            [Key.PageDown] = VKEY_NEXT,
+            [Key.End] = VKEY_END,
+            [Key.Home] = VKEY_HOME,
+            [Key.Insert] = VKEY_INSERT,
+            [Key.Delete] = VKEY_DELETE,
+            [Key.Minus] = VKEY_OEM_MINUS,
+            [Key.NumpadAdd] = VKEY_ADD,
+            [Key.NumpadSubtract] = VKEY_SUBTRACT,
+            [Key.NumpadDivide] = VKEY_DIVIDE,
+            [Key.NumpadMultiply] = VKEY_MULTIPLY,
+            [Key.NumpadDecimal] = VKEY_DECIMAL,
+            [Key.Left] = VKEY_LEFT,
+            [Key.Right] = VKEY_RIGHT,
+            [Key.Up] = VKEY_UP,
+            [Key.Down] = VKEY_DOWN,
+            [Key.F1] = VKEY_F1,
+            [Key.F2] = VKEY_F2,
+            [Key.F3] = VKEY_F3,
+            [Key.F4] = VKEY_F4,
+            [Key.F5] = VKEY_F5,
+            [Key.F6] = VKEY_F6,
+            [Key.F7] = VKEY_F7,
+            [Key.F8] = VKEY_F8,
+            [Key.F9] = VKEY_F9,
+            [Key.F10] = VKEY_F10,
+            [Key.F11] = VKEY_F11,
+            [Key.F12] = VKEY_F12,
+            [Key.F13] = VKEY_F13,
+            [Key.F14] = VKEY_F14,
+            [Key.F15] = VKEY_F15,
+            [Key.Pause] = VKEY_PAUSE,
+        };
+
+        public BrowserControl()
+        {
+            CanKeyboardFocus = true;
+            KeyboardFocusOnClick = true;
+            MouseFilter = MouseFilterMode.Stop;
+
+            IoCManager.InjectDependencies(this);
+        }
+
+        protected override void EnteredTree()
+        {
+            base.EnteredTree();
+
+            _cef.CheckInitialized();
+
+            DebugTools.AssertNull(_data);
+
+            // A funny render handler that will allow us to render to the control.
+            var renderer = new ControlRenderHandler(this);
+
+            // A funny web cef client. This can actually be shared by multiple browsers, but I'm not sure how the
+            // rendering would work in that case? TODO CEF: Investigate a way to share the web client?
+            var client = new RobustCefClient(renderer, _requestHandler, new RobustLoadHandler());
+
+            var info = CefWindowInfo.Create();
+
+            // FUNFACT: If you DO NOT set these below and set info.Width/info.Height instead, you get an external window
+            // Good to know, huh? Setup is the same, except you can pass a dummy render handler to the CEF client.
+            info.SetAsWindowless(IntPtr.Zero, false); // TODO CEF: Pass parent handle?
+            info.WindowlessRenderingEnabled = true;
+
+            var settings = new CefBrowserSettings()
+            {
+                WindowlessFrameRate = 60
+            };
+
+            // Create the web browser! And by default, we go to about:blank.
+            var browser = CefBrowserHost.CreateBrowserSync(info, client, settings, _startUrl);
+
+            var texture = _clyde.CreateBlankTexture<Bgra32>(Vector2i.One);
+
+            _data = new LiveData(texture, client, browser, renderer);
+        }
+
+        protected override void ExitedTree()
+        {
+            base.ExitedTree();
+
+            DebugTools.AssertNotNull(_data);
+
+            _data!.Texture.Dispose();
+            _data.Browser.GetHost().CloseBrowser(true);
+            _data = null;
+        }
+
+        protected internal override void MouseMove(GUIMouseMoveEventArgs args)
+        {
+            base.MouseMove(args);
+
+            if (_data == null)
+                return;
+
+            // Logger.Debug();
+            var modifiers = CalcMouseModifiers();
+            var mouseEvent = new CefMouseEvent(
+                (int) args.RelativePosition.X, (int) args.RelativePosition.Y,
+                modifiers);
+
+            _data.Browser.GetHost().SendMouseMoveEvent(mouseEvent, false);
+        }
+
+        protected internal override void MouseExited()
+        {
+            base.MouseExited();
+
+            if (_data == null)
+                return;
+
+            var modifiers = CalcMouseModifiers();
+
+            _data.Browser.GetHost().SendMouseMoveEvent(new CefMouseEvent(0, 0, modifiers), true);
+        }
+
+        protected internal override void MouseWheel(GUIMouseWheelEventArgs args)
+        {
+            base.MouseWheel(args);
+
+            if (_data == null)
+                return;
+
+            var modifiers = CalcMouseModifiers();
+            var mouseEvent = new CefMouseEvent(
+                (int) args.RelativePosition.X, (int) args.RelativePosition.Y,
+                modifiers);
+
+            _data.Browser.GetHost().SendMouseWheelEvent(
+                mouseEvent,
+                (int) args.Delta.X * ScrollSpeed,
+                (int) args.Delta.Y * ScrollSpeed);
+        }
+
+        bool IRawInputControl.RawKeyEvent(in GuiRawKeyEvent guiRawEvent)
+        {
+            if (_data == null)
+                return false;
+
+            var host = _data.Browser.GetHost();
+
+            if (guiRawEvent.Key is Key.MouseLeft or Key.MouseMiddle or Key.MouseRight)
+            {
+                var key = guiRawEvent.Key switch
+                {
+                    Key.MouseLeft => CefMouseButtonType.Left,
+                    Key.MouseMiddle => CefMouseButtonType.Middle,
+                    Key.MouseRight => CefMouseButtonType.Right,
+                    _ => default // not possible
+                };
+
+                var mouseEvent = new CefMouseEvent(
+                    guiRawEvent.MouseRelative.X, guiRawEvent.MouseRelative.Y,
+                    CefEventFlags.None);
+
+                // Logger.Debug($"MOUSE: {guiRawEvent.Action} {guiRawEvent.Key} {guiRawEvent.ScanCode} {key}");
+
+                // TODO: double click support?
+                host.SendMouseClickEvent(mouseEvent, key, guiRawEvent.Action == RawKeyAction.Up, 1);
+            }
+            else
+            {
+                // TODO: Handle left/right modifier keys??
+                if (!_keyMap.TryGetValue(guiRawEvent.Key, out var vkKey))
+                    vkKey = default;
+
+                // Logger.Debug($"{guiRawEvent.Action} {guiRawEvent.Key} {guiRawEvent.ScanCode} {vkKey}");
+
+                var lParam = 0;
+                lParam |= (guiRawEvent.ScanCode & 0xFF) << 16;
+                if (guiRawEvent.Action != RawKeyAction.Down)
+                    lParam |= 1 << 30;
+
+                if (guiRawEvent.Action == RawKeyAction.Up)
+                    lParam |= 1 << 31;
+
+                var modifiers = CalcModifiers(guiRawEvent.Key);
+
+                host.SendKeyEvent(new CefKeyEvent
+                {
+                    // Repeats are sent as key downs, I guess?
+                    EventType = guiRawEvent.Action == RawKeyAction.Up
+                        ? CefKeyEventType.KeyUp
+                        : CefKeyEventType.RawKeyDown,
+                    NativeKeyCode = lParam,
+                    // NativeKeyCode = guiRawEvent.ScanCode,
+                    WindowsKeyCode = (int) vkKey,
+                    IsSystemKey = false, // TODO
+                    Modifiers = modifiers
+                });
+
+                if (guiRawEvent.Action != RawKeyAction.Up && guiRawEvent.Key == Key.Return)
+                {
+                    host.SendKeyEvent(new CefKeyEvent
+                    {
+                        EventType = CefKeyEventType.Char,
+                        WindowsKeyCode = '\r',
+                        NativeKeyCode = lParam,
+                        Modifiers = modifiers
+                    });
+                }
+            }
+
+            return true;
+        }
+
+        private CefEventFlags CalcModifiers(Key key)
+        {
+            CefEventFlags modifiers = default;
+
+            if (_inputMgr.IsKeyDown(Key.Control))
+                modifiers |= CefEventFlags.ControlDown;
+
+            if (_inputMgr.IsKeyDown(Key.Alt))
+                modifiers |= CefEventFlags.AltDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            return modifiers;
+        }
+
+        private CefEventFlags CalcMouseModifiers()
+        {
+            CefEventFlags modifiers = default;
+
+            if (_inputMgr.IsKeyDown(Key.Control))
+                modifiers |= CefEventFlags.ControlDown;
+
+            if (_inputMgr.IsKeyDown(Key.Alt))
+                modifiers |= CefEventFlags.AltDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            if (_inputMgr.IsKeyDown(Key.Shift))
+                modifiers |= CefEventFlags.ShiftDown;
+
+            if (_inputMgr.IsKeyDown(Key.MouseLeft))
+                modifiers |= CefEventFlags.LeftMouseButton;
+
+            if (_inputMgr.IsKeyDown(Key.MouseMiddle))
+                modifiers |= CefEventFlags.MiddleMouseButton;
+
+            if (_inputMgr.IsKeyDown(Key.MouseRight))
+                modifiers |= CefEventFlags.RightMouseButton;
+
+            return modifiers;
+        }
+
+        protected internal override void TextEntered(GUITextEventArgs args)
+        {
+            base.TextEntered(args);
+
+            if (_data == null)
+                return;
+
+            var host = _data.Browser.GetHost();
+
+            Span<char> buf = stackalloc char[2];
+            var written = args.AsRune.EncodeToUtf16(buf);
+
+            for (var i = 0; i < written; i++)
+            {
+                host.SendKeyEvent(new CefKeyEvent
+                {
+                    EventType = CefKeyEventType.Char,
+                    WindowsKeyCode = buf[i],
+                    Character = buf[i],
+                    UnmodifiedCharacter = buf[i]
+                });
+            }
+        }
+
+        protected override void Resized()
+        {
+            base.Resized();
+
+            if (_data == null)
+                return;
+
+            _data.Browser.GetHost().NotifyMoveOrResizeStarted();
+            _data.Browser.GetHost().WasResized();
+            _data.Texture.Dispose();
+            _data.Texture = _clyde.CreateBlankTexture<Bgra32>((PixelWidth, PixelHeight));
+        }
+
+        protected internal override void Draw(DrawingHandleScreen handle)
+        {
+            base.Draw(handle);
+
+            if (_data == null)
+                return;
+
+            var bufImg = _data.Renderer.Buffer.Buffer;
+
+            _data.Texture.SetSubImage(
+                Vector2i.Zero,
+                bufImg,
+                new UIBox2i(
+                    0, 0,
+                    Math.Min(PixelWidth, bufImg.Width),
+                    Math.Min(PixelHeight, bufImg.Height)));
+
+            handle.DrawTexture(_data.Texture, Vector2.Zero);
+        }
+
+        public void StopLoad()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            _data.Browser.StopLoad();
+        }
+
+        public void Reload()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            _data.Browser.Reload();
+        }
+
+        public bool GoBack()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            if (!_data.Browser.CanGoBack)
+                return false;
+
+            _data.Browser.GoBack();
+            return true;
+        }
+
+        public bool GoForward()
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            if (!_data.Browser.CanGoForward)
+                return false;
+
+            _data.Browser.GoForward();
+            return true;
+        }
+
+        public void ExecuteJavaScript(string code)
+        {
+            if (_data == null)
+                throw new InvalidOperationException();
+
+            // TODO: this should not run until the browser is done loading seriously does this even work?
+            _data.Browser.GetMainFrame().ExecuteJavaScript(code, string.Empty, 1);
+        }
+
+        public void AddResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            _requestHandler.AddResourceRequestHandler(handler);
+        }
+
+        public void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            _requestHandler.RemoveResourceRequestHandler(handler);
+        }
+
+        public void AddBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            _requestHandler.AddBeforeBrowseHandler(handler);
+        }
+
+        public void RemoveBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            _requestHandler.RemoveBeforeBrowseHandler(handler);
+        }
+
+        private sealed class LiveData
+        {
+            public OwnedTexture Texture;
+            public readonly RobustCefClient Client;
+            public readonly CefBrowser Browser;
+            public readonly ControlRenderHandler Renderer;
+
+            public LiveData(
+                OwnedTexture texture,
+                RobustCefClient client,
+                CefBrowser browser,
+                ControlRenderHandler renderer)
+            {
+                Texture = texture;
+                Client = client;
+                Browser = browser;
+                Renderer = renderer;
+            }
+        }
+    }
+
+    internal class ControlRenderHandler : CefRenderHandler
+    {
+        public ImageBuffer Buffer { get; }
+        private Control _control;
+
+        internal ControlRenderHandler(Control control)
+        {
+            Buffer = new ImageBuffer(control);
+            _control = control;
+        }
+
+        protected override CefAccessibilityHandler? GetAccessibilityHandler() => null;
+
+        protected override void GetViewRect(CefBrowser browser, out CefRectangle rect)
+        {
+            if (_control.Disposed)
+            {
+                rect = new CefRectangle();
+                return;
+            }
+
+            // TODO CEF: Do we need to pass real screen coords? Cause what we do already works...
+            //var screenCoords = _control.ScreenCoordinates;
+            //rect = new CefRectangle((int) screenCoords.X, (int) screenCoords.Y, (int)Math.Max(_control.Size.X, 1), (int)Math.Max(_control.Size.Y, 1));
+
+            // We do the max between size and 1 because it will LITERALLY CRASH WITHOUT AN ERROR otherwise.
+            rect = new CefRectangle(0, 0, (int) Math.Max(_control.Size.X, 1), (int) Math.Max(_control.Size.Y, 1));
+        }
+
+        protected override bool GetScreenInfo(CefBrowser browser, CefScreenInfo screenInfo)
+        {
+            if (_control.Disposed)
+                return false;
+
+            // TODO CEF: Get actual scale factor?
+            screenInfo.DeviceScaleFactor = 1.0f;
+
+            return true;
+        }
+
+        protected override void OnPopupSize(CefBrowser browser, CefRectangle rect)
+        {
+            if (_control.Disposed)
+                return;
+        }
+
+        protected override void OnPaint(CefBrowser browser, CefPaintElementType type, CefRectangle[] dirtyRects,
+            IntPtr buffer, int width, int height)
+        {
+            if (_control.Disposed)
+                return;
+
+            foreach (var dirtyRect in dirtyRects)
+            {
+                Buffer.UpdateBuffer(width, height, buffer, dirtyRect);
+            }
+        }
+
+        protected override void OnAcceleratedPaint(CefBrowser browser, CefPaintElementType type,
+            CefRectangle[] dirtyRects, IntPtr sharedHandle)
+        {
+            // Unused, but we're forced to implement it so.. NOOP.
+        }
+
+        protected override void OnScrollOffsetChanged(CefBrowser browser, double x, double y)
+        {
+            if (_control.Disposed)
+                return;
+        }
+
+        protected override void OnImeCompositionRangeChanged(CefBrowser browser, CefRange selectedRange,
+            CefRectangle[] characterBounds)
+        {
+            if (_control.Disposed)
+                return;
+        }
+    }
+}

Robust.Client.CEF/BrowserWindowCreateParameters.cs

@@ -0,0 +1,16 @@
+namespace Robust.Client.CEF
+{
+    public sealed class BrowserWindowCreateParameters
+    {
+        public int Width { get; set; }
+        public int Height { get; set; }
+
+        public string Url { get; set; } = "about:blank";
+
+        public BrowserWindowCreateParameters(int width, int height)
+        {
+            Width = width;
+            Height = height;
+        }
+    }
+}

Robust.Client.CEF/CefKeyCodes.cs

@@ -0,0 +1,225 @@
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Robust.Client.CEF
+{
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
+    [SuppressMessage("ReSharper", "UnusedMember.Global")]
+    [SuppressMessage("ReSharper", "IdentifierTypo")]
+    [SuppressMessage("ReSharper", "CA1069")]
+    [SuppressMessage("ReSharper", "CommentTypo")]
+    internal static class CefKeyCodes
+    {
+        // Taken from https://chromium.googlesource.com/chromium/src/+/refs/heads/main/ui/events/keycodes/keyboard_codes_posix.h
+        // See also https://docs.microsoft.com/en-us/windows/win32/inputdev/virtual-key-codes
+        public enum ChromiumKeyboardCode
+        {
+            VKEY_CANCEL = 0x03,
+            VKEY_BACK = 0x08,
+            VKEY_TAB = 0x09,
+            VKEY_BACKTAB = 0x0A,
+            VKEY_CLEAR = 0x0C,
+            VKEY_RETURN = 0x0D,
+            VKEY_SHIFT = 0x10,
+            VKEY_CONTROL = 0x11,
+            VKEY_MENU = 0x12,
+            VKEY_PAUSE = 0x13,
+            VKEY_CAPITAL = 0x14,
+            VKEY_KANA = 0x15,
+            VKEY_HANGUL = 0x15,
+            VKEY_PASTE = 0x16,
+            VKEY_JUNJA = 0x17,
+            VKEY_FINAL = 0x18,
+            VKEY_HANJA = 0x19,
+            VKEY_KANJI = 0x19,
+            VKEY_ESCAPE = 0x1B,
+            VKEY_CONVERT = 0x1C,
+            VKEY_NONCONVERT = 0x1D,
+            VKEY_ACCEPT = 0x1E,
+            VKEY_MODECHANGE = 0x1F,
+            VKEY_SPACE = 0x20,
+            VKEY_PRIOR = 0x21,
+            VKEY_NEXT = 0x22,
+            VKEY_END = 0x23,
+            VKEY_HOME = 0x24,
+            VKEY_LEFT = 0x25,
+            VKEY_UP = 0x26,
+            VKEY_RIGHT = 0x27,
+            VKEY_DOWN = 0x28,
+            VKEY_SELECT = 0x29,
+            VKEY_PRINT = 0x2A,
+            VKEY_EXECUTE = 0x2B,
+            VKEY_SNAPSHOT = 0x2C, // Print Screen / SysRq
+            VKEY_INSERT = 0x2D,
+            VKEY_DELETE = 0x2E,
+            VKEY_HELP = 0x2F,
+            VKEY_0 = 0x30,
+            VKEY_1 = 0x31,
+            VKEY_2 = 0x32,
+            VKEY_3 = 0x33,
+            VKEY_4 = 0x34,
+            VKEY_5 = 0x35,
+            VKEY_6 = 0x36,
+            VKEY_7 = 0x37,
+            VKEY_8 = 0x38,
+            VKEY_9 = 0x39,
+            VKEY_A = 0x41,
+            VKEY_B = 0x42,
+            VKEY_C = 0x43,
+            VKEY_D = 0x44,
+            VKEY_E = 0x45,
+            VKEY_F = 0x46,
+            VKEY_G = 0x47,
+            VKEY_H = 0x48,
+            VKEY_I = 0x49,
+            VKEY_J = 0x4A,
+            VKEY_K = 0x4B,
+            VKEY_L = 0x4C,
+            VKEY_M = 0x4D,
+            VKEY_N = 0x4E,
+            VKEY_O = 0x4F,
+            VKEY_P = 0x50,
+            VKEY_Q = 0x51,
+            VKEY_R = 0x52,
+            VKEY_S = 0x53,
+            VKEY_T = 0x54,
+            VKEY_U = 0x55,
+            VKEY_V = 0x56,
+            VKEY_W = 0x57,
+            VKEY_X = 0x58,
+            VKEY_Y = 0x59,
+            VKEY_Z = 0x5A,
+            VKEY_LWIN = 0x5B,
+            VKEY_COMMAND = VKEY_LWIN, // Provide the Mac name for convenience.
+            VKEY_RWIN = 0x5C,
+            VKEY_APPS = 0x5D,
+            VKEY_SLEEP = 0x5F,
+            VKEY_NUMPAD0 = 0x60,
+            VKEY_NUMPAD1 = 0x61,
+            VKEY_NUMPAD2 = 0x62,
+            VKEY_NUMPAD3 = 0x63,
+            VKEY_NUMPAD4 = 0x64,
+            VKEY_NUMPAD5 = 0x65,
+            VKEY_NUMPAD6 = 0x66,
+            VKEY_NUMPAD7 = 0x67,
+            VKEY_NUMPAD8 = 0x68,
+            VKEY_NUMPAD9 = 0x69,
+            VKEY_MULTIPLY = 0x6A,
+            VKEY_ADD = 0x6B,
+            VKEY_SEPARATOR = 0x6C,
+            VKEY_SUBTRACT = 0x6D,
+            VKEY_DECIMAL = 0x6E,
+            VKEY_DIVIDE = 0x6F,
+            VKEY_F1 = 0x70,
+            VKEY_F2 = 0x71,
+            VKEY_F3 = 0x72,
+            VKEY_F4 = 0x73,
+            VKEY_F5 = 0x74,
+            VKEY_F6 = 0x75,
+            VKEY_F7 = 0x76,
+            VKEY_F8 = 0x77,
+            VKEY_F9 = 0x78,
+            VKEY_F10 = 0x79,
+            VKEY_F11 = 0x7A,
+            VKEY_F12 = 0x7B,
+            VKEY_F13 = 0x7C,
+            VKEY_F14 = 0x7D,
+            VKEY_F15 = 0x7E,
+            VKEY_F16 = 0x7F,
+            VKEY_F17 = 0x80,
+            VKEY_F18 = 0x81,
+            VKEY_F19 = 0x82,
+            VKEY_F20 = 0x83,
+            VKEY_F21 = 0x84,
+            VKEY_F22 = 0x85,
+            VKEY_F23 = 0x86,
+            VKEY_F24 = 0x87,
+            VKEY_NUMLOCK = 0x90,
+            VKEY_SCROLL = 0x91,
+            VKEY_LSHIFT = 0xA0,
+            VKEY_RSHIFT = 0xA1,
+            VKEY_LCONTROL = 0xA2,
+            VKEY_RCONTROL = 0xA3,
+            VKEY_LMENU = 0xA4,
+            VKEY_RMENU = 0xA5,
+            VKEY_BROWSER_BACK = 0xA6,
+            VKEY_BROWSER_FORWARD = 0xA7,
+            VKEY_BROWSER_REFRESH = 0xA8,
+            VKEY_BROWSER_STOP = 0xA9,
+            VKEY_BROWSER_SEARCH = 0xAA,
+            VKEY_BROWSER_FAVORITES = 0xAB,
+            VKEY_BROWSER_HOME = 0xAC,
+            VKEY_VOLUME_MUTE = 0xAD,
+            VKEY_VOLUME_DOWN = 0xAE,
+            VKEY_VOLUME_UP = 0xAF,
+            VKEY_MEDIA_NEXT_TRACK = 0xB0,
+            VKEY_MEDIA_PREV_TRACK = 0xB1,
+            VKEY_MEDIA_STOP = 0xB2,
+            VKEY_MEDIA_PLAY_PAUSE = 0xB3,
+            VKEY_MEDIA_LAUNCH_MAIL = 0xB4,
+            VKEY_MEDIA_LAUNCH_MEDIA_SELECT = 0xB5,
+            VKEY_MEDIA_LAUNCH_APP1 = 0xB6,
+            VKEY_MEDIA_LAUNCH_APP2 = 0xB7,
+            VKEY_OEM_1 = 0xBA,
+            VKEY_OEM_PLUS = 0xBB,
+            VKEY_OEM_COMMA = 0xBC,
+            VKEY_OEM_MINUS = 0xBD,
+            VKEY_OEM_PERIOD = 0xBE,
+            VKEY_OEM_2 = 0xBF,
+            VKEY_OEM_3 = 0xC0,
+            VKEY_OEM_4 = 0xDB,
+            VKEY_OEM_5 = 0xDC,
+            VKEY_OEM_6 = 0xDD,
+            VKEY_OEM_7 = 0xDE,
+            VKEY_OEM_8 = 0xDF,
+            VKEY_OEM_102 = 0xE2,
+            VKEY_OEM_103 = 0xE3, // GTV KEYCODE_MEDIA_REWIND
+            VKEY_OEM_104 = 0xE4, // GTV KEYCODE_MEDIA_FAST_FORWARD
+            VKEY_PROCESSKEY = 0xE5,
+            VKEY_PACKET = 0xE7,
+            VKEY_OEM_ATTN = 0xF0, // JIS DomKey::ALPHANUMERIC
+            VKEY_OEM_FINISH = 0xF1, // JIS DomKey::KATAKANA
+            VKEY_OEM_COPY = 0xF2, // JIS DomKey::HIRAGANA
+            VKEY_DBE_SBCSCHAR = 0xF3, // JIS DomKey::HANKAKU
+            VKEY_DBE_DBCSCHAR = 0xF4, // JIS DomKey::ZENKAKU
+            VKEY_OEM_BACKTAB = 0xF5, // JIS DomKey::ROMAJI
+            VKEY_ATTN = 0xF6, // DomKey::ATTN or JIS DomKey::KANA_MODE
+            VKEY_CRSEL = 0xF7,
+            VKEY_EXSEL = 0xF8,
+            VKEY_EREOF = 0xF9,
+            VKEY_PLAY = 0xFA,
+            VKEY_ZOOM = 0xFB,
+            VKEY_NONAME = 0xFC,
+            VKEY_PA1 = 0xFD,
+            VKEY_OEM_CLEAR = 0xFE,
+            VKEY_UNKNOWN = 0,
+
+            // POSIX specific VKEYs. Note that as of Windows SDK 7.1, 0x97-9F, 0xD8-DA,
+            // and 0xE8 are unassigned.
+            VKEY_WLAN = 0x97,
+            VKEY_POWER = 0x98,
+            VKEY_ASSISTANT = 0x99,
+            VKEY_SETTINGS = 0x9A,
+            VKEY_PRIVACY_SCREEN_TOGGLE = 0x9B,
+            VKEY_BRIGHTNESS_DOWN = 0xD8,
+            VKEY_BRIGHTNESS_UP = 0xD9,
+            VKEY_KBD_BRIGHTNESS_DOWN = 0xDA,
+            VKEY_KBD_BRIGHTNESS_UP = 0xE8,
+
+            // Windows does not have a specific key code for AltGr. We use the unused 0xE1
+            // (VK_OEM_AX) code to represent AltGr, matching the behaviour of Firefox on
+            // Linux.
+            VKEY_ALTGR = 0xE1,
+
+            // Windows does not have a specific key code for Compose. We use the unused
+            // 0xE6 (VK_ICO_CLEAR) code to represent Compose.
+            VKEY_COMPOSE = 0xE6,
+
+            // Windows does not have specific key codes for Media Play and Media Pause. We
+            // use the unused 0xE9 (VK_OEM_RESET) and 0xEA (VK_OEM_JUMP) codes to
+            // represent them.
+            VKEY_MEDIA_PLAY = 0xE9,
+            VKEY_MEDIA_PAUSE = 0xEA,
+        };
+    }
+}

Robust.Client.CEF/CefManager.BrowserWindow.cs

@@ -0,0 +1,186 @@
+using System;
+using System.Collections.Generic;
+using Robust.Client.Graphics;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Robust.Shared.ViewVariables;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public partial class CefManager
+    {
+        [Dependency] private readonly IClydeInternal _clyde = default!;
+
+        private readonly List<BrowserWindowImpl> _browserWindows = new();
+
+        public IEnumerable<IBrowserWindow> AllBrowserWindows => _browserWindows;
+
+        public IBrowserWindow CreateBrowserWindow(BrowserWindowCreateParameters createParams)
+        {
+            var mainHWnd = (_clyde.MainWindow as IClydeWindowInternal)?.WindowsHWnd ?? 0;
+
+            var info = CefWindowInfo.Create();
+            info.Width = createParams.Width;
+            info.Height = createParams.Height;
+            info.SetAsPopup(mainHWnd, "ss14cef");
+
+            var impl = new BrowserWindowImpl(this);
+
+            var lifeSpanHandler = new WindowLifeSpanHandler(impl);
+            var reqHandler = new RobustRequestHandler(Logger.GetSawmill("root"));
+            var client = new WindowCefClient(lifeSpanHandler, reqHandler);
+            var settings = new CefBrowserSettings();
+
+            impl.Browser = CefBrowserHost.CreateBrowserSync(info, client, settings, createParams.Url);
+            impl.RequestHandler = reqHandler;
+
+            _browserWindows.Add(impl);
+
+            return impl;
+        }
+
+        private sealed class BrowserWindowImpl : IBrowserWindow
+        {
+            private readonly CefManager _manager;
+            internal CefBrowser Browser = default!;
+            internal RobustRequestHandler RequestHandler = default!;
+
+            public Action<RequestHandlerContext>? OnResourceRequest { get; set; }
+
+            [ViewVariables(VVAccess.ReadWrite)]
+            public string Url
+            {
+                get
+                {
+                    CheckClosed();
+                    return Browser.GetMainFrame().Url;
+                }
+                set
+                {
+                    CheckClosed();
+                    Browser.GetMainFrame().LoadUrl(value);
+                }
+            }
+
+            [ViewVariables]
+            public bool IsLoading
+            {
+                get
+                {
+                    CheckClosed();
+                    return Browser.IsLoading;
+                }
+            }
+
+            public BrowserWindowImpl(CefManager manager)
+            {
+                _manager = manager;
+            }
+
+            public void StopLoad()
+            {
+                CheckClosed();
+                Browser.StopLoad();
+            }
+
+            public void Reload()
+            {
+                CheckClosed();
+                Browser.Reload();
+            }
+
+            public bool GoBack()
+            {
+                CheckClosed();
+                if (!Browser.CanGoBack)
+                    return false;
+
+                Browser.GoBack();
+                return true;
+            }
+
+            public bool GoForward()
+            {
+                CheckClosed();
+                if (!Browser.CanGoForward)
+                    return false;
+
+                Browser.GoForward();
+                return true;
+            }
+
+            public void ExecuteJavaScript(string code)
+            {
+                CheckClosed();
+                Browser.GetMainFrame().ExecuteJavaScript(code, string.Empty, 1);
+            }
+
+            public void AddResourceRequestHandler(Action<RequestHandlerContext> handler)
+            {
+                RequestHandler.AddResourceRequestHandler(handler);
+            }
+
+            public void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler)
+            {
+                RequestHandler.RemoveResourceRequestHandler(handler);
+            }
+
+            public void Dispose()
+            {
+                if (Closed)
+                    return;
+
+                Browser.GetHost().CloseBrowser(true);
+                Closed = true;
+            }
+
+            public bool Closed { get; private set; }
+
+            public void OnClose()
+            {
+                Closed = true;
+                _manager._browserWindows.Remove(this);
+                Logger.Debug("Removing window");
+            }
+
+            private void CheckClosed()
+            {
+                if (Closed)
+                    throw new ObjectDisposedException("BrowserWindow");
+            }
+        }
+
+        private sealed class WindowCefClient : CefClient
+        {
+            private readonly CefLifeSpanHandler _lifeSpanHandler;
+            private readonly CefRequestHandler _requestHandler;
+
+            public WindowCefClient(CefLifeSpanHandler lifeSpanHandler, CefRequestHandler requestHandler)
+            {
+                _lifeSpanHandler = lifeSpanHandler;
+                _requestHandler = requestHandler;
+            }
+
+            protected override CefLifeSpanHandler GetLifeSpanHandler() => _lifeSpanHandler;
+            protected override CefRequestHandler GetRequestHandler() => _requestHandler;
+        }
+
+        private sealed class WindowLifeSpanHandler : CefLifeSpanHandler
+        {
+            private readonly BrowserWindowImpl _windowImpl;
+
+            public WindowLifeSpanHandler(BrowserWindowImpl windowImpl)
+            {
+                _windowImpl = windowImpl;
+            }
+
+            protected override void OnBeforeClose(CefBrowser browser)
+            {
+                base.OnBeforeClose(browser);
+
+                _windowImpl.OnClose();
+            }
+        }
+    }
+}

Robust.Client.CEF/CefManager.cs

@@ -0,0 +1,101 @@
+using System;
+using System.IO;
+using JetBrains.Annotations;
+using Robust.Shared.ContentPack;
+using Robust.Shared.Log;
+using Robust.Shared.Utility;
+
+// The library we're using right now. TODO CEF: Do we want to use something else? We will need to ship it ourselves if so.
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    // Register this with IoC.
+    // TODO CEF: think if making this inherit CefApp is a good idea...
+    // TODO CEF: A way to handle external window browsers...
+    [UsedImplicitly]
+    public partial class CefManager
+    {
+        private CefApp _app = default!;
+        private bool _initialized = false;
+
+        /// <summary>
+        ///     Call this to initialize CEF.
+        /// </summary>
+        public void Initialize()
+        {
+            DebugTools.Assert(!_initialized);
+
+            string subProcessName;
+            if (OperatingSystem.IsWindows())
+                subProcessName = "Robust.Client.CEF.exe";
+            else if (OperatingSystem.IsLinux())
+                subProcessName = "Robust.Client.CEF";
+            else
+                throw new NotSupportedException("Unsupported platform for CEF!");
+
+            var subProcessPath = PathHelpers.ExecutableRelativeFile(subProcessName);
+
+            var settings = new CefSettings()
+            {
+                WindowlessRenderingEnabled = true, // So we can render to our UI controls.
+                ExternalMessagePump = false, // Unsure, honestly. TODO CEF: Research this?
+                NoSandbox = true, // Not disabling the sandbox crashes CEF.
+                BrowserSubprocessPath = subProcessPath,
+                LocalesDirPath = Path.Combine(PathHelpers.GetExecutableDirectory(), "locales"),
+                ResourcesDirPath = PathHelpers.GetExecutableDirectory(),
+                RemoteDebuggingPort = 9222
+            };
+
+            Logger.Info($"CEF Version: {CefRuntime.ChromeVersion}");
+
+            // --------------------------- README --------------------------------------------------
+            // By the way! You're gonna need the CEF binaries in your client's bin folder.
+            // More specifically, version cef_binary_94.4.1+g4b61a8c+chromium-94.0.4606.54
+            // Windows: https://cef-builds.spotifycdn.com/cef_binary_94.4.1%2Bg4b61a8c%2Bchromium-94.0.4606.54_windows64_minimal.tar.bz2
+            // Linux: https://cef-builds.spotifycdn.com/cef_binary_94.4.1%2Bg4b61a8c%2Bchromium-94.0.4606.54_linux64_minimal.tar.bz2
+            // Here's how to get it to work:
+            // 1. Copy all the contents of "Release" to the bin/Content.Client folder.
+            // 2. Copy all the contents of "Resources" to the bin/Content.Client folder.
+            // -------------------------------------------------------------------------------------
+
+            _app = new RobustCefApp();
+
+            // We pass no main arguments...
+            CefRuntime.Initialize(new CefMainArgs(null), settings, _app, IntPtr.Zero);
+
+            // TODO CEF: After this point, debugging breaks. No, literally. My client crashes but ONLY with the debugger.
+            // I have tried using the DEBUG and RELEASE versions of libcef.so, stripped or non-stripped...
+            // And nothing seemed to work. Odd.
+
+            _initialized = true;
+        }
+
+        public void CheckInitialized()
+        {
+            if (!_initialized)
+                throw new InvalidOperationException("CefManager has not been initialized!");
+        }
+
+        /// <summary>
+        ///     Needs to be called regularly for CEF to keep working.
+        /// </summary>
+        public void Update()
+        {
+            DebugTools.Assert(_initialized);
+
+            // Calling this makes CEF do its work, without using its own update loop.
+            CefRuntime.DoMessageLoopWork();
+        }
+
+        /// <summary>
+        ///     Call before program shutdown.
+        /// </summary>
+        public void Shutdown()
+        {
+            DebugTools.Assert(_initialized);
+
+            CefRuntime.Shutdown();
+        }
+    }
+}

Robust.Client.CEF/IBrowserControl.cs

@@ -0,0 +1,48 @@
+using System;
+
+namespace Robust.Client.CEF
+{
+    public interface IBrowserControl
+    {
+        /// <summary>
+        ///     Current URL of the browser. Set to load a new page.
+        /// </summary>
+        string Url { get; set; }
+
+        /// <summary>
+        ///     Whether the browser is currently loading a page.
+        /// </summary>
+        bool IsLoading { get; }
+
+        /// <summary>
+        ///     Stops loading the current page.
+        /// </summary>
+        void StopLoad();
+
+        /// <summary>
+        ///     Reload the current page.
+        /// </summary>
+        void Reload();
+
+        /// <summary>
+        ///     Navigate back.
+        /// </summary>
+        /// <returns>Whether the browser could navigate back.</returns>
+        bool GoBack();
+
+        /// <summary>
+        ///     Navigate forward.
+        /// </summary>
+        /// <returns>Whether the browser could navigate forward.</returns>
+        bool GoForward();
+
+        /// <summary>
+        ///     Execute arbitrary JavaScript on the current page.
+        /// </summary>
+        /// <param name="code">JavaScript code.</param>
+        void ExecuteJavaScript(string code);
+
+        void AddResourceRequestHandler(Action<RequestHandlerContext> handler);
+        void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler);
+    }
+}

Robust.Client.CEF/IBrowserWindow.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Robust.Client.CEF
+{
+    public interface IBrowserWindow : IBrowserControl, IDisposable
+    {
+        bool Closed { get; }
+    }
+}

Robust.Client.CEF/ImageBuffer.cs

@@ -0,0 +1,42 @@
+using System;
+using Robust.Client.UserInterface;
+using Robust.Client.Utility;
+using Robust.Shared.Maths;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.PixelFormats;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal sealed class ImageBuffer
+    {
+        private readonly Control _control;
+
+        public ImageBuffer(Control control)
+        {
+            _control = control;
+        }
+
+        public Image<Bgra32> Buffer { get; private set; } = new(1, 1);
+
+        public unsafe void UpdateBuffer(int width, int height, IntPtr buffer, CefRectangle dirtyRect)
+        {
+            if (width != Buffer.Width || height != Buffer.Height)
+                UpdateSize(width, height);
+
+            var span = new ReadOnlySpan<Bgra32>((void*) buffer, width * height);
+
+            ImageSharpExt.Blit(
+                span,
+                width,
+                UIBox2i.FromDimensions(dirtyRect.X, dirtyRect.Y, dirtyRect.Width, dirtyRect.Height),
+                Buffer,
+                (dirtyRect.X, dirtyRect.Y));
+        }
+
+        private void UpdateSize(int width, int height)
+        {
+            Buffer = new Image<Bgra32>(width, height);
+        }
+    }
+}

Robust.Client.CEF/Program.cs

@@ -0,0 +1,33 @@
+using System;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public static class Program
+    {
+        // This was supposed to be the main entry for the subprocess program... It doesn't work.
+        public static int Main(string[] args)
+        {
+            // This is a workaround for this to work on UNIX.
+            var argv = args;
+            if (CefRuntime.Platform != CefRuntimePlatform.Windows)
+            {
+                argv = new string[args.Length + 1];
+                Array.Copy(args, 0, argv, 1, args.Length);
+                argv[0] = "-";
+            }
+
+            var mainArgs = new CefMainArgs(argv);
+
+            // This will block executing until the subprocess is shut down.
+            var code = CefRuntime.ExecuteProcess(mainArgs, null, IntPtr.Zero);
+
+            if (code != 0)
+            {
+                System.Console.WriteLine($"CEF Subprocess exited unsuccessfully with exit code {code}! Arguments: {string.Join(' ', argv)}");
+            }
+
+            return code;
+        }
+    }
+}

Robust.Client.CEF/RequestHandlerContext.cs

@@ -0,0 +1,56 @@
+using System;
+using System.IO;
+using System.Net;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public sealed class RequestHandlerContext
+    {
+        internal readonly CefRequest CefRequest;
+
+        public bool IsNavigation { get; }
+        public bool IsDownload { get; }
+        public string RequestInitiator { get; }
+
+        public string Url => CefRequest.Url;
+        public string Method => CefRequest.Method;
+
+        public bool IsHandled { get; private set; }
+
+        public bool IsCancelled { get; private set; }
+
+        internal IRequestResult? Result { get; private set; }
+
+        internal RequestHandlerContext(
+            bool isNavigation,
+            bool isDownload,
+            string requestInitiator,
+            CefRequest cefRequest)
+        {
+            CefRequest = cefRequest;
+            IsNavigation = isNavigation;
+            IsDownload = isDownload;
+            RequestInitiator = requestInitiator;
+        }
+
+        public void DoCancel()
+        {
+            CheckNotHandled();
+
+            IsHandled = true;
+            IsCancelled = true;
+        }
+
+        public void DoRespondStream(Stream stream, string contentType, HttpStatusCode code = HttpStatusCode.OK)
+        {
+            Result = new RequestResultStream(stream, contentType, code);
+        }
+
+        private void CheckNotHandled()
+        {
+            if (IsHandled)
+                throw new InvalidOperationException("Request has already been handled");
+        }
+    }
+}

Robust.Client.CEF/RequestResults.cs

@@ -0,0 +1,93 @@
+using System;
+using System.IO;
+using System.Net;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal interface IRequestResult
+    {
+        CefResourceHandler MakeHandler();
+    }
+
+    internal sealed class RequestResultStream : IRequestResult
+    {
+        private readonly Stream _stream;
+        private readonly HttpStatusCode _code;
+        private readonly string _contentType;
+
+        public RequestResultStream(Stream stream, string contentType, HttpStatusCode code)
+        {
+            _stream = stream;
+            _code = code;
+            _contentType = contentType;
+        }
+
+        public CefResourceHandler MakeHandler()
+        {
+            return new Handler(_stream, _contentType, _code);
+        }
+
+        private sealed class Handler : CefResourceHandler
+        {
+            // TODO: async
+            // TODO: exception handling
+
+            private readonly Stream _stream;
+            private readonly HttpStatusCode _code;
+            private readonly string _contentType;
+
+            public Handler(Stream stream, string contentType, HttpStatusCode code)
+            {
+                _stream = stream;
+                _code = code;
+                _contentType = contentType;
+            }
+
+            protected override bool Open(CefRequest request, out bool handleRequest, CefCallback callback)
+            {
+                handleRequest = true;
+                return true;
+            }
+
+            protected override void GetResponseHeaders(CefResponse response, out long responseLength, out string? redirectUrl)
+            {
+                response.Status = (int) _code;
+                response.StatusText = _code.ToString();
+                response.MimeType = _contentType;
+
+                if (_stream.CanSeek)
+                    responseLength = _stream.Length;
+                else
+                    responseLength = -1;
+
+                redirectUrl = default;
+            }
+
+            protected override bool Skip(long bytesToSkip, out long bytesSkipped, CefResourceSkipCallback callback)
+            {
+                if (!_stream.CanSeek)
+                {
+                    bytesSkipped = -2;
+                    return false;
+                }
+
+                bytesSkipped = _stream.Seek(bytesToSkip, SeekOrigin.Begin);
+                return true;
+            }
+
+            protected override unsafe bool Read(IntPtr dataOut, int bytesToRead, out int bytesRead, CefResourceReadCallback callback)
+            {
+                var byteSpan = new Span<byte>((void*) dataOut, bytesToRead);
+
+                bytesRead = _stream.Read(byteSpan);
+
+                return bytesRead != 0;
+            }
+
+            protected override void Cancel()
+            {
+            }
+        }
+    }
+}

Robust.Client.CEF/Robust.Client.CEF.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <Import Project="..\MSBuild\Robust.Properties.targets" />
+    <Import Project="..\MSBuild\Robust.Engine.props" />
+    <PropertyGroup>
+        <TargetFramework>net5.0</TargetFramework>
+        <PlatformTarget>x64</PlatformTarget>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+        <OutputType>WinExe</OutputType>
+    </PropertyGroup>
+
+    <Import Project="..\MSBuild\Robust.DefineConstants.targets" />
+    <Target Name="RobustAfterBuild" AfterTargets="Build" />
+    <Import Project="..\MSBuild\Robust.Engine.targets" />
+
+    <ItemGroup>
+      <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" />
+      <PackageReference Include="System.Drawing.Common" Version="5.0.2" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <ProjectReference Include="..\cefglue\CefGlue\CefGlue.csproj" />
+      <ProjectReference Include="..\Robust.Client\Robust.Client.csproj" />
+    </ItemGroup>
+
+</Project>

Robust.Client.CEF/RobustCefApp.cs

@@ -0,0 +1,48 @@
+using System;
+using Robust.Shared.IoC;
+using Robust.Shared.Log;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal class RobustCefApp : CefApp
+    {
+        private readonly BrowserProcessHandler _browserProcessHandler = new();
+        private readonly RenderProcessHandler _renderProcessHandler = new();
+
+        protected override CefBrowserProcessHandler GetBrowserProcessHandler()
+        {
+            return _browserProcessHandler;
+        }
+
+        protected override CefRenderProcessHandler GetRenderProcessHandler()
+        {
+            return _renderProcessHandler;
+        }
+
+        protected override void OnBeforeCommandLineProcessing(string processType, CefCommandLine commandLine)
+        {
+            // Disable zygote on Linux.
+            commandLine.AppendSwitch("--no-zygote");
+
+            //commandLine.AppendSwitch("--disable-gpu");
+            //commandLine.AppendSwitch("--disable-gpu-compositing");
+            //commandLine.AppendSwitch("--in-process-gpu");
+
+            commandLine.AppendSwitch("disable-threaded-scrolling", "1");
+            commandLine.AppendSwitch("disable-features", "TouchpadAndWheelScrollLatching,AsyncWheelEvents");
+
+            if(IoCManager.Instance != null)
+                Logger.Debug($"{commandLine}");
+        }
+
+        private class BrowserProcessHandler : CefBrowserProcessHandler
+        {
+        }
+
+        // TODO CEF: Research - Is this even needed?
+        private class RenderProcessHandler : CefRenderProcessHandler
+        {
+        }
+    }
+}

Robust.Client.CEF/RobustCefClient.cs

@@ -0,0 +1,23 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    // Simple CEF client.
+    internal class RobustCefClient : CefClient
+    {
+        private readonly CefRenderHandler _renderHandler;
+        private readonly CefRequestHandler _requestHandler;
+        private readonly CefLoadHandler _loadHandler;
+
+        internal RobustCefClient(CefRenderHandler handler, CefRequestHandler requestHandler, CefLoadHandler loadHandler)
+        {
+            _renderHandler = handler;
+            _requestHandler = requestHandler;
+            _loadHandler = loadHandler;
+        }
+
+        protected override CefRenderHandler GetRenderHandler() => _renderHandler;
+        protected override CefRequestHandler GetRequestHandler() => _requestHandler;
+        protected override CefLoadHandler GetLoadHandler() => _loadHandler;
+    }
+}

Robust.Client.CEF/RobustLoadHandler.cs

@@ -0,0 +1,17 @@
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    public sealed class RobustLoadHandler : CefLoadHandler
+    {
+        protected override void OnLoadStart(CefBrowser browser, CefFrame frame, CefTransitionType transitionType)
+        {
+            base.OnLoadStart(browser, frame, transitionType);
+        }
+
+        protected override void OnLoadEnd(CefBrowser browser, CefFrame frame, int httpStatusCode)
+        {
+            base.OnLoadEnd(browser, frame, httpStatusCode);
+        }
+    }
+}

Robust.Client.CEF/RobustRequestHandler.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using Robust.Shared.Log;
+using Xilium.CefGlue;
+
+namespace Robust.Client.CEF
+{
+    internal sealed class RobustRequestHandler : CefRequestHandler
+    {
+        private readonly ISawmill _sawmill;
+        private readonly List<Action<RequestHandlerContext>> _resourceRequestHandlers = new();
+        private readonly List<Action<BeforeBrowseContext>> _beforeBrowseHandlers = new();
+
+        public RobustRequestHandler(ISawmill sawmill)
+        {
+            _sawmill = sawmill;
+        }
+
+        public void AddResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            lock (_resourceRequestHandlers)
+            {
+                _resourceRequestHandlers.Add(handler);
+            }
+        }
+
+        public void RemoveResourceRequestHandler(Action<RequestHandlerContext> handler)
+        {
+            lock (_resourceRequestHandlers)
+            {
+                _resourceRequestHandlers.Remove(handler);
+            }
+        }
+
+        public void AddBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            lock (_beforeBrowseHandlers)
+            {
+                _beforeBrowseHandlers.Add(handler);
+            }
+        }
+
+        public void RemoveBeforeBrowseHandler(Action<BeforeBrowseContext> handler)
+        {
+            lock (_beforeBrowseHandlers)
+            {
+                _beforeBrowseHandlers.Remove(handler);
+            }
+        }
+
+        protected override CefResourceRequestHandler? GetResourceRequestHandler(
+            CefBrowser browser,
+            CefFrame frame,
+            CefRequest request,
+            bool isNavigation,
+            bool isDownload,
+            string requestInitiator,
+            ref bool disableDefaultHandling)
+        {
+            lock (_resourceRequestHandlers)
+            {
+                _sawmill.Debug($"HANDLING REQUEST: {request.Url}");
+
+                var context = new RequestHandlerContext(isNavigation, isDownload, requestInitiator, request);
+
+                foreach (var handler in _resourceRequestHandlers)
+                {
+                    handler(context);
+
+                    if (context.IsHandled)
+                        disableDefaultHandling = true;
+
+                    if (context.IsCancelled)
+                        return null;
+
+                    if (context.Result != null)
+                        return new WrapReaderResourceHandler(context.Result.MakeHandler());
+                }
+            }
+
+            return null;
+        }
+
+        protected override bool OnBeforeBrowse(CefBrowser browser, CefFrame frame, CefRequest request, bool userGesture, bool isRedirect)
+        {
+            lock (_beforeBrowseHandlers)
+            {
+                var context = new BeforeBrowseContext(isRedirect, userGesture, request);
+
+                foreach (var handler in _beforeBrowseHandlers)
+                {
+                    handler(context);
+
+                    if (context.IsCancelled)
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
+        private sealed class WrapReaderResourceHandler : CefResourceRequestHandler
+        {
+            private readonly CefResourceHandler _handler;
+
+            public WrapReaderResourceHandler(CefResourceHandler handler)
+            {
+                _handler = handler;
+            }
+
+            protected override CefCookieAccessFilter? GetCookieAccessFilter(
+                CefBrowser browser,
+                CefFrame frame,
+                CefRequest request)
+            {
+                return null;
+            }
+
+            protected override CefResourceHandler GetResourceHandler(
+                CefBrowser browser,
+                CefFrame frame,
+                CefRequest request)
+            {
+                return _handler;
+            }
+        }
+    }
+}

Robust.Client.Injectors/Program.cs

@@ -29,26 +29,27 @@ namespace Robust.Build.Tasks
         }
     }
 
+    //formatted according to https://github.com/dotnet/msbuild/blob/main/src/Shared/CanonicalError.cs#L57
     class ConsoleBuildEngine : IBuildEngine
     {
         public void LogErrorEvent(BuildErrorEventArgs e)
         {
-            Console.WriteLine($"ERROR: {e.Code} {e.Message} in {e.File} {e.LineNumber}:{e.ColumnNumber}-{e.EndLineNumber}:{e.EndColumnNumber}");
+            Console.WriteLine($"{e.File} ({e.LineNumber},{e.ColumnNumber},{e.EndLineNumber},{e.EndColumnNumber}): XAMLIL ERROR {e.Code}: {e.Message}");
         }
 
         public void LogWarningEvent(BuildWarningEventArgs e)
         {
-            Console.WriteLine($"WARNING: {e.Code} {e.Message} in {e.File} {e.LineNumber}:{e.ColumnNumber}-{e.EndLineNumber}:{e.EndColumnNumber}");
+            Console.WriteLine($"{e.File} ({e.LineNumber},{e.ColumnNumber},{e.EndLineNumber},{e.EndColumnNumber}): XAMLIL WARNING {e.Code}: {e.Message}");
         }
 
         public void LogMessageEvent(BuildMessageEventArgs e)
         {
-            Console.WriteLine($"MESSAGE: {e.Code} {e.Message} in {e.File} {e.LineNumber}:{e.ColumnNumber}-{e.EndLineNumber}:{e.EndColumnNumber}");
+            Console.WriteLine($"{e.File} ({e.LineNumber},{e.ColumnNumber},{e.EndLineNumber},{e.EndColumnNumber}): XAMLIL MESSAGE {e.Code}: {e.Message}");
         }
 
         public void LogCustomEvent(CustomBuildEventArgs e)
         {
-            Console.WriteLine($"CUSTOM: {e.Message}");
+            Console.WriteLine(e.Message);
         }
 
         public bool BuildProjectFile(string projectFileName, string[] targetNames, IDictionary globalProperties,

Robust.Client.Injectors/RobustXamlILCompiler.cs

@@ -1,4 +1,6 @@
-using System.Linq;
+using System.Diagnostics;
+using System.Linq;
+using XamlX;
 using XamlX.Ast;
 using XamlX.Emit;
 using XamlX.IL;
@@ -11,11 +13,14 @@ namespace Robust.Build.Tasks
     /// Emitters & Transformers based on:
     /// - https://github.com/AvaloniaUI/Avalonia/blob/c85fa2b9977d251a31886c2534613b4730fbaeaf/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/AvaloniaXamlIlRootObjectScopeTransformer.cs
     /// - https://github.com/AvaloniaUI/Avalonia/blob/c85fa2b9977d251a31886c2534613b4730fbaeaf/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/AddNameScopeRegistration.cs
+    /// - https://github.com/AvaloniaUI/Avalonia/blob/afb8ae6f3c517dae912729511483995b16cb31af/src/Markup/Avalonia.Markup.Xaml.Loader/CompilerExtensions/Transformers/IgnoredDirectivesTransformer.cs
     /// </summary>
     public class RobustXamlILCompiler : XamlILCompiler
     {
         public RobustXamlILCompiler(TransformerConfiguration configuration, XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult> emitMappings, bool fillWithDefaults) : base(configuration, emitMappings, fillWithDefaults)
         {
+            Transformers.Insert(0, new IgnoredDirectivesTransformer());
+
             Transformers.Add(new AddNameScopeRegistration());
             Transformers.Add(new RobustMarkRootObjectScopeNode());
 
@@ -197,5 +202,24 @@ namespace Robust.Build.Tasks
                 }
             }
         }
+
+        class IgnoredDirectivesTransformer : IXamlAstTransformer
+        {
+            public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node)
+            {
+                if (node is XamlAstObjectNode astNode)
+                {
+                    astNode.Children.RemoveAll(n =>
+                        n is XamlAstXmlDirective dir &&
+                        dir.Namespace == XamlNamespaces.Xaml2006 &&
+                        (dir.Name == "Class" ||
+                         dir.Name == "Precompile" ||
+                         dir.Name == "FieldModifier" ||
+                         dir.Name == "ClassModifier"));
+                }
+
+                return node;
+            }
+        }
     }
 }

Robust.Client.Injectors/XamlCompiler.cs

@@ -280,8 +280,8 @@ namespace Robust.Build.Tasks
                     }
                     catch (Exception e)
                     {
-                        engine.LogWarningEvent(new BuildWarningEventArgs("XAMLIL", "", res.Uri, 0, 0, 0, 0,
-                            e.ToString(), "", "CompileRobustXaml"));
+                        engine.LogErrorEvent(new BuildErrorEventArgs("XAMLIL", "", res.FilePath, 0, 0, 0, 0,
+                            $"{res.FilePath}: {e.Message}", "", "CompileRobustXaml"));
                     }
                 }
                 return true;

Robust.Client.NameGenerator/InvalidXamlRootTypeException.cs

@@ -0,0 +1,19 @@
+using System;
+using Microsoft.CodeAnalysis;
+
+namespace Robust.Client.NameGenerator
+{
+    public class InvalidXamlRootTypeException : Exception
+    {
+        public readonly INamedTypeSymbol ExpectedType;
+        public readonly INamedTypeSymbol ExpectedBaseType;
+        public readonly INamedTypeSymbol Actual;
+
+        public InvalidXamlRootTypeException(INamedTypeSymbol actual, INamedTypeSymbol expectedType, INamedTypeSymbol expectedBaseType)
+        {
+            Actual = actual;
+            ExpectedType = expectedType;
+            ExpectedBaseType = expectedBaseType;
+        }
+    }
+}

Robust.Client.NameGenerator/XamlUiPartialClassGenerator.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using Microsoft.CodeAnalysis;
@@ -111,6 +112,12 @@ namespace Robust.Client.AutoGenerated
             compiler.Transform(parsed);
             var initialRoot = (XamlAstObjectNode) parsed.Root;
             var names = NameVisitor.GetNames(initialRoot);
+
+            var rootType = (INamedTypeSymbol)initialRoot.Type.GetClrType().Id;
+            var rootTypeString = rootType.ToString();
+            if (classSymbol.ToString() != rootTypeString && classSymbol.BaseType?.ToString() != rootTypeString)
+                throw new InvalidXamlRootTypeException(rootType, classSymbol, classSymbol.BaseType);
+
             var fieldAccess = classSymbol.IsSealed ? "private" : "protected";
             //var names = NameVisitor.GetNames((XamlAstObjectNode)XDocumentXamlParser.Parse(xamlFile).Root);
             var namedControls = names.Select(info => "        " +
@@ -147,9 +154,10 @@ namespace {nameSpace}
             foreach (var typeSymbol in symbols)
             {
                 var xamlFileName = $"{typeSymbol.Name}.xaml";
-                var relevantXamlFile = context.AdditionalFiles.FirstOrDefault(t => t.Path.EndsWith(xamlFileName));
+                var xamlFileNameSep = $"{Path.DirectorySeparatorChar}{xamlFileName}";
+                var relevantXamlFiles = context.AdditionalFiles.Where(t => t.Path.EndsWith(xamlFileNameSep)).ToArray();
 
-                if (relevantXamlFile == null)
+                if (relevantXamlFiles.Length == 0)
                 {
                     context.ReportDiagnostic(
                         Diagnostic.Create(
@@ -165,13 +173,28 @@ namespace {nameSpace}
                     continue;
                 }
 
-                var txt = relevantXamlFile.GetText()?.ToString();
-                if (txt == null)
+                if (relevantXamlFiles.Length > 1)
                 {
                     context.ReportDiagnostic(
                         Diagnostic.Create(
                             new DiagnosticDescriptor(
                                 "RXN0002",
+                                $"Found multiple candidate XAML files for {typeSymbol}",
+                                $"Multiple files exist with name {xamlFileName}",
+                                "Usage",
+                                DiagnosticSeverity.Error,
+                                true),
+                            typeSymbol.Locations[0]));
+                    continue;
+                }
+
+                var txt = relevantXamlFiles[0].GetText()?.ToString();
+                if (txt == null)
+                {
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(
+                            new DiagnosticDescriptor(
+                                "RXN0004",
                                 $"Unexpected empty Xaml-File was found at {xamlFileName}",
                                 "Expected Content due to a Class with the same name being annotated with [GenerateTypedNameReferences].",
                                 "Usage",
@@ -187,12 +210,27 @@ namespace {nameSpace}
                     var sourceCode = GenerateSourceCode(typeSymbol, txt, comp);
                     context.AddSource($"{typeSymbol.Name}.g.cs", SourceText.From(sourceCode, Encoding.UTF8));
                 }
+                catch (InvalidXamlRootTypeException invRootType)
+                {
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(
+                            new DiagnosticDescriptor(
+                                "RXN0005",
+                                $"XAML-File {xamlFileName} has the wrong root type!",
+                                $"{xamlFileName}: Expected root type '{invRootType.ExpectedType}' or '{invRootType.ExpectedBaseType}', but got '{invRootType.Actual}'.",
+                                "Usage",
+                                DiagnosticSeverity.Error,
+                                true),
+                            Location.Create(xamlFileName, new TextSpan(0, 0),
+                                new LinePositionSpan(new LinePosition(0, 0), new LinePosition(0, 0)))));
+                    continue;
+                }
                 catch (Exception e)
                 {
                     context.ReportDiagnostic(
                         Diagnostic.Create(
                             new DiagnosticDescriptor(
-                                "AXN0003",
+                                "RXN0003",
                                 "Unhandled exception occured while generating typed Name references.",
                                 $"Unhandled exception occured while generating typed Name references: {e}",
                                 "Usage",
@@ -240,14 +278,13 @@ namespace {nameSpace}
                     context.ReportDiagnostic(
                         Diagnostic.Create(
                             new DiagnosticDescriptor(
-                                "RXN0004",
+                                "RXN0006",
                                 missingPartialKeywordMessage,
                                 missingPartialKeywordMessage,
                                 "Usage",
                                 DiagnosticSeverity.Error,
                                 true),
                             Location.None));
-                    return null;
                 }
             }
 

Robust.Client/Audio/Midi/MidiManager.cs

@@ -6,6 +6,8 @@ using System.Threading;
 using NFluidsynth;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
+using Robust.Shared;
+using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
@@ -15,6 +17,7 @@ using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Physics.Broadphase;
 using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
 using Logger = Robust.Shared.Log.Logger;
 
 namespace Robust.Client.Audio.Midi
@@ -33,24 +36,6 @@ namespace Robust.Client.Audio.Midi
         /// </returns>
         IMidiRenderer? GetNewRenderer();
 
-        /*
-        /// <summary>
-        ///     Checks whether the file at the given path is a valid midi file or not.
-        /// </summary>
-        /// <remarks>
-        ///     We add this here so content doesn't need to reference NFluidsynth.
-        /// </remarks>
-        bool IsMidiFile(string filename);
-
-        /// <summary>
-        ///     Checks whether the file at the given path is a valid midi file or not.
-        /// </summary>
-        /// <remarks>
-        ///     We add this here so content doesn't need to reference NFluidsynth.
-        /// </remarks>
-        bool IsSoundfontFile(string filename);
-        */
-
         /// <summary>
         ///     Method called every frame.
         ///     Should be used to update positional audio.
@@ -58,6 +43,11 @@ namespace Robust.Client.Audio.Midi
         /// <param name="frameTime"></param>
         void FrameUpdate(float frameTime);
 
+        /// <summary>
+        ///     Volume, in db.
+        /// </summary>
+        float Volume { get; set; }
+
         /// <summary>
         ///     If true, MIDI support is available.
         /// </summary>
@@ -73,9 +63,11 @@ namespace Robust.Client.Audio.Midi
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IConfigurationManager _cfgMan = default!;
 
-        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
+        private SharedBroadphaseSystem _broadPhaseSystem = default!;
 
+        [ViewVariables]
         public bool IsAvailable
         {
             get
@@ -86,12 +78,29 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
-        private readonly List<MidiRenderer> _renderers = new();
+        [ViewVariables]
+        private readonly List<IMidiRenderer> _renderers = new();
 
         private bool _alive = true;
         private Settings? _settings;
         private Thread? _midiThread;
         private ISawmill _midiSawmill = default!;
+        private float _volume = 0f;
+        private bool _volumeDirty = true;
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float Volume
+        {
+            get => _volume;
+            set
+            {
+                if (MathHelper.CloseToPercent(_volume, value))
+                    return;
+
+                _cfgMan.SetCVar(CVars.MidiVolume, value);
+                _volumeDirty = true;
+            }
+        }
 
         private static readonly string[] LinuxSoundfonts =
         {
@@ -118,12 +127,19 @@ namespace Robust.Client.Audio.Midi
         private NFluidsynth.Logger.LoggerDelegate _loggerDelegate = default!;
         private ISawmill _sawmill = default!;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public int OcclusionCollisionMask { get; set; }
 
         private void InitializeFluidsynth()
         {
             if (FluidsynthInitialized || _failedInitialize) return;
 
+            _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
+            {
+                _volume = value;
+                _volumeDirty = true;
+            }, true);
+
             _midiSawmill = Logger.GetSawmill("midi");
             _sawmill = Logger.GetSawmill("midi.fluidsynth");
             _loggerDelegate = LoggerDelegate;
@@ -159,7 +175,7 @@ namespace Robust.Client.Audio.Midi
             _midiThread = new Thread(ThreadUpdate);
             _midiThread.Start();
 
-            _broadPhaseSystem = EntitySystem.Get<SharedBroadPhaseSystem>();
+            _broadPhaseSystem = EntitySystem.Get<SharedBroadphaseSystem>();
             FluidsynthInitialized = true;
         }
 
@@ -176,18 +192,6 @@ namespace Robust.Client.Audio.Midi
             _sawmill.Log(rLevel, message);
         }
 
-        /*
-        public bool IsMidiFile(string filename)
-        {
-            return SoundFont.IsMidiFile(filename);
-        }
-
-        public bool IsSoundfontFile(string filename)
-        {
-            return SoundFont.IsSoundFont(filename);
-        }
-        */
-
         public IMidiRenderer? GetNewRenderer()
         {
             if (!FluidsynthInitialized)
@@ -221,7 +225,7 @@ namespace Robust.Client.Audio.Midi
                 // Since the last loaded soundfont takes priority, we load the fallback soundfont before the soundfont.
                 renderer.LoadSoundfont(FallbackSoundfont);
 
-                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                if (OperatingSystem.IsLinux())
                 {
                     foreach (var filepath in LinuxSoundfonts)
                     {
@@ -239,19 +243,21 @@ namespace Robust.Client.Audio.Midi
                         break;
                     }
                 }
-                else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
+                else if (OperatingSystem.IsMacOS())
                 {
                     if (File.Exists(OsxSoundfont) && SoundFont.IsSoundFont(OsxSoundfont))
                         renderer.LoadSoundfont(OsxSoundfont, true);
                 }
-                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                else if (OperatingSystem.IsWindows())
                 {
                     if (File.Exists(WindowsSoundfont) && SoundFont.IsSoundFont(WindowsSoundfont))
                         renderer.LoadSoundfont(WindowsSoundfont, true);
                 }
 
                 lock (_renderers)
+                {
                     _renderers.Add(renderer);
+                }
 
                 return renderer;
             }
@@ -269,69 +275,79 @@ namespace Robust.Client.Audio.Midi
             }
 
             // Update positions of streams every frame.
-            lock (_renderers)
-                foreach (var renderer in _renderers)
+            foreach (var renderer in _renderers)
+            {
+                if (renderer.Disposed)
+                    continue;
+
+                if(_volumeDirty)
+                    renderer.Source.SetVolume(Volume);
+
+                if (!renderer.Mono)
                 {
-                    if (renderer.Disposed)
-                        continue;
-
-                    if (!renderer.Mono)
-                    {
-                        renderer.Source.SetGlobal();
-                        continue;
-                    }
-
-                    MapCoordinates? mapPos = null;
-                    if (renderer.TrackingCoordinates != null)
-                    {
-                        mapPos = renderer.TrackingCoordinates.Value.ToMap(_entityManager);
-                    }
-                    else if (renderer.TrackingEntity != null)
-                    {
-                        mapPos = renderer.TrackingEntity.Transform.MapPosition;
-                    }
-
-                    if (mapPos != null)
-                    {
-                        var pos = mapPos.Value;
-                        if (pos.MapId != _eyeManager.CurrentMap)
-                        {
-                            renderer.Source.SetVolume(-10000000);
-                        }
-                        else
-                        {
-                            var sourceRelative = _eyeManager.CurrentEye.Position.Position - pos.Position;
-                            var occlusion = 0f;
-                            if (sourceRelative.Length > 0)
-                            {
-                                occlusion = _broadPhaseSystem.IntersectRayPenetration(
-                                    pos.MapId,
-                                    new CollisionRay(
-                                        pos.Position,
-                                        sourceRelative.Normalized,
-                                        OcclusionCollisionMask),
-                                    sourceRelative.Length,
-                                    renderer.TrackingEntity);
-                            }
-                            renderer.Source.SetOcclusion(occlusion);
-                        }
-
-                        if (renderer.Source.SetPosition(pos.Position))
-                        {
-                            continue;
-                        }
-
-                        if (float.IsNaN(pos.Position.X) || float.IsNaN(pos.Position.Y))
-                        {
-                            // just duck out instead of move to NaN
-                            renderer.Source.SetOcclusion(float.MaxValue);
-                            continue;
-                        }
-
-                        _midiSawmill?.Warning("Interrupting positional audio, can't set position.");
-                        renderer.Source.StopPlaying();
-                    }
+                    renderer.Source.SetGlobal();
+                    continue;
                 }
+
+                MapCoordinates? mapPos = null;
+                if (renderer.TrackingCoordinates != null)
+                {
+                    mapPos = renderer.TrackingCoordinates.Value.ToMap(_entityManager);
+                }
+                else if (renderer.TrackingEntity != null)
+                {
+                    mapPos = renderer.TrackingEntity.Transform.MapPosition;
+                }
+
+                if (mapPos != null)
+                {
+                    var pos = mapPos.Value;
+                    if (pos.MapId != _eyeManager.CurrentMap)
+                    {
+                        renderer.Source.SetVolume(-10000000);
+                    }
+                    else
+                    {
+                        var sourceRelative = _eyeManager.CurrentEye.Position.Position - pos.Position;
+                        var occlusion = 0f;
+                        if (sourceRelative.Length > 0)
+                        {
+                            occlusion = _broadPhaseSystem.IntersectRayPenetration(
+                                pos.MapId,
+                                new CollisionRay(
+                                    pos.Position,
+                                    sourceRelative.Normalized,
+                                    OcclusionCollisionMask),
+                                sourceRelative.Length,
+                                renderer.TrackingEntity);
+                        }
+
+                        renderer.Source.SetOcclusion(occlusion);
+                    }
+
+                    if (renderer.Source.SetPosition(pos.Position))
+                    {
+                        continue;
+                    }
+
+                    if (renderer.TrackingEntity != null)
+                    {
+                        renderer.Source.SetVelocity(renderer.TrackingEntity.GlobalLinearVelocity());
+                    }
+
+                    if (float.IsNaN(pos.Position.X) || float.IsNaN(pos.Position.Y))
+                    {
+                        // just duck out instead of move to NaN
+                        renderer.Source.SetOcclusion(float.MaxValue);
+                        continue;
+                    }
+
+                    _midiSawmill?.Warning("Interrupting positional audio, can't set position.");
+                    renderer.Source.StopPlaying();
+                }
+            }
+
+            _volumeDirty = false;
         }
 
         /// <summary>
@@ -342,6 +358,7 @@ namespace Robust.Client.Audio.Midi
             while (_alive)
             {
                 lock (_renderers)
+                {
                     for (var i = 0; i < _renderers.Count; i++)
                     {
                         var renderer = _renderers[i];
@@ -349,10 +366,11 @@ namespace Robust.Client.Audio.Midi
                             renderer.Render();
                         else
                         {
-                            ((IMidiRenderer)renderer).InternalDispose();
+                            renderer.InternalDispose();
                             _renderers.Remove(renderer);
                         }
                     }
+                }
 
                 Thread.Sleep(1);
             }
@@ -363,9 +381,13 @@ namespace Robust.Client.Audio.Midi
             _alive = false;
             _midiThread?.Join();
             _settings?.Dispose();
-            foreach (var renderer in _renderers)
+
+            lock (_renderers)
             {
-                renderer?.Dispose();
+                foreach (var renderer in _renderers)
+                {
+                    renderer?.Dispose();
+                }
             }
 
             if (FluidsynthInitialized && !_failedInitialize)
@@ -420,6 +442,7 @@ namespace Robust.Client.Audio.Midi
                 var span = new Span<byte>(buf.ToPointer(), length);
                 var stream = _openStreams[(int) sfHandle];
 
+                // Fluidsynth's docs state that this method should leave the buffer unmodified if it fails. (returns -1)
                 try
                 {
                     // Fluidsynth does a LOT of tiny allocations (frankly, way too much).
@@ -443,6 +466,7 @@ namespace Robust.Client.Audio.Midi
                 {
                     return -1;
                 }
+
                 return 0;
             }
 
@@ -464,10 +488,12 @@ namespace Robust.Client.Audio.Midi
 
             public override int Close(IntPtr sfHandle)
             {
-                var stream = _openStreams[(int) sfHandle];
+                if (!_openStreams.Remove((int) sfHandle, out var stream))
+                    return -1;
+
                 stream.Dispose();
-                _openStreams.Remove((int) sfHandle);
                 return 0;
+
             }
         }
     }

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Runtime.Intrinsics.X86;
 using NFluidsynth;
 using Robust.Client.Graphics;
 using Robust.Shared.Asynchronous;
@@ -7,7 +6,8 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
-using Robust.Shared.Utility;
+using Robust.Shared.Maths;
+using Robust.Shared.ViewVariables;
 using MidiEvent = NFluidsynth.MidiEvent;
 
 namespace Robust.Client.Audio.Midi
@@ -21,6 +21,17 @@ namespace Robust.Client.Audio.Midi
 
     public interface IMidiRenderer : IDisposable
     {
+
+        /// <summary>
+        ///     The buffered audio source of this renderer.
+        /// </summary>
+        internal IClydeBufferedAudioSource Source { get; }
+
+        /// <summary>
+        ///     Whether this renderer has been disposed or not.
+        /// </summary>
+        bool Disposed { get; }
+
         /// <summary>
         ///     This controls whether the midi file being played will loop or not.
         /// </summary>
@@ -110,6 +121,11 @@ namespace Robust.Client.Audio.Midi
         /// </summary>
         void StopAllNotes();
 
+        /// <summary>
+        ///     Render and play MIDI to the audio source.
+        /// </summary>
+        internal void Render();
+
         /// <summary>
         ///     Loads a new soundfont into the renderer.
         /// </summary>
@@ -159,7 +175,7 @@ namespace Robust.Client.Audio.Midi
         internal void InternalDispose();
     }
 
-    public class MidiRenderer : IMidiRenderer
+    internal class MidiRenderer : IMidiRenderer
     {
         [Dependency] private readonly IClydeAudio _clydeAudio = default!;
         [Dependency] private readonly ITaskManager _taskManager = default!;
@@ -186,53 +202,67 @@ namespace Robust.Client.Audio.Midi
         private const int SampleRate = 44100;
         private const int Buffers = SampleRate / 2205;
         private readonly object _playerStateLock = new();
+        private bool _debugEvents = false;
         private SequencerClientId _synthRegister;
+        private SequencerClientId _debugRegister;
         public IClydeBufferedAudioSource Source { get; set; }
+        IClydeBufferedAudioSource IMidiRenderer.Source => Source;
+
+        [ViewVariables]
         public bool Disposed { get; private set; } = false;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public byte MidiProgram
         {
             get => _midiProgram;
             set
             {
                 lock (_playerStateLock)
-                    for (var i = 0; i < 16; i++)
+                    for (var i = 0; i < _synth.MidiChannelCount; i++)
                         _synth.ProgramChange(i, value);
 
                 _midiProgram = value;
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public byte MidiBank
         {
             get => _midiBank;
             set
             {
                 lock (_playerStateLock)
-                    for (var i = 0; i < 16; i++)
+                    for (var i = 0; i < _synth.MidiChannelCount; i++)
                         _synth.BankSelect(i, value);
 
                 _midiBank = value;
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public uint MidiSoundfont
         {
             get => _midiSoundfont;
             set
             {
                 lock (_playerStateLock)
-                    for (var i = 0; i < 16; i++)
+                    for (var i = 0; i < _synth.MidiChannelCount; i++)
                         _synth.SoundFontSelect(i, value);
 
                 _midiSoundfont = value;
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool DisablePercussionChannel { get; set; } = true;
+
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool DisableProgramChangeEvent { get; set; } = true;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public int PlayerTotalTick => _player?.GetTotalTicks ?? 0;
+
+        [ViewVariables(VVAccess.ReadWrite)]
         public int PlayerTick
         {
             get => _player?.CurrentTick ?? 0;
@@ -243,12 +273,19 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public uint SequencerTick => _sequencer?.Tick ?? 0;
+
+        [ViewVariables(VVAccess.ReadWrite)]
         public double SequencerTimeScale => _sequencer?.TimeScale ?? 0;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool Mono { get; set; }
+
+        [ViewVariables]
         public MidiRendererStatus Status { get; private set; } = MidiRendererStatus.None;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool LoopMidi
         {
             get => _loopMidi;
@@ -260,10 +297,11 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public IEntity? TrackingEntity { get; set; } = null;
-        public EntityCoordinates? TrackingCoordinates { get; set; } = null;
 
-        internal bool Free { get; set; } = false;
+        [ViewVariables(VVAccess.ReadWrite)]
+        public EntityCoordinates? TrackingCoordinates { get; set; } = null;
 
         internal MidiRenderer(Settings settings, SoundFontLoader soundFontLoader, bool mono = true)
         {
@@ -276,6 +314,7 @@ namespace Robust.Client.Audio.Midi
             _soundFontLoader = soundFontLoader;
             _synth = new Synth(_settings);
             _sequencer = new Sequencer(false);
+            _debugRegister = _sequencer.RegisterClient("honk", DumpSequencerEvent);
             _synthRegister = _sequencer.RegisterFluidsynth(_synth);
 
             _synth.AddSoundFontLoader(soundFontLoader);
@@ -285,6 +324,27 @@ namespace Robust.Client.Audio.Midi
             Source.StartPlaying();
         }
 
+        private void DumpSequencerEvent(uint time, SequencerEvent @event)
+        {
+            // ReSharper disable once UseStringInterpolation
+            _midiSawmill.Debug(string.Format(
+                "{0:D8}: {1} chan:{2:D2} key:{3:D5} bank:{4:D2} ctrl:{5:D5} dur:{6:D5} pitch:{7:D5} prog:{8:D3} val:{9:D5} vel:{10:D5}",
+                time,
+                @event.Type.ToString().PadLeft(22),
+                @event.Channel,
+                @event.Key,
+                @event.Bank,
+                @event.Control,
+                @event.Duration,
+                @event.Pitch,
+                @event.Program,
+                @event.Value,
+                @event.Velocity));
+
+            @event.Dest = _synthRegister;
+            _sequencer.SendNow(@event);
+        }
+
         public bool OpenInput()
         {
             if (Disposed)
@@ -294,7 +354,11 @@ namespace Robust.Client.Audio.Midi
             Status = MidiRendererStatus.Input;
             StopAllNotes();
 
-            _driver = new MidiDriver(_settings, MidiDriverEventHandler);
+            lock (_playerStateLock)
+            {
+                _driver = new MidiDriver(_settings, MidiDriverEventHandler);
+            }
+
             return true;
         }
 
@@ -332,8 +396,13 @@ namespace Robust.Client.Audio.Midi
         {
             if (Status != MidiRendererStatus.Input) return false;
             Status = MidiRendererStatus.None;
-            _driver?.Dispose();
-            _driver = null;
+
+            lock (_playerStateLock)
+            {
+                _driver?.Dispose();
+                _driver = null;
+            }
+
             StopAllNotes();
             return true;
         }
@@ -357,7 +426,8 @@ namespace Robust.Client.Audio.Midi
 
         public void StopAllNotes()
         {
-            _synth.AllNotesOff(-1);
+            lock(_playerStateLock)
+                _synth.AllNotesOff(-1);
         }
 
         public void LoadSoundfont(string filename, bool resetPresets = false)
@@ -372,13 +442,15 @@ namespace Robust.Client.Audio.Midi
         public event Action<Shared.Audio.Midi.MidiEvent>? OnMidiEvent;
         public event Action? OnMidiPlayerFinished;
 
-        internal void Render(int length = SampleRate / 250)
+        void IMidiRenderer.Render()
+        {
+            Render();
+        }
+
+        private void Render(int length = SampleRate / 250)
         {
             if (Disposed) return;
 
-            // SSE needs this.
-            DebugTools.Assert(length % 4 == 0, "Sample length must be multiple of 4");
-
             var buffersProcessed = Source.GetNumberOfBuffersProcessed();
             if(buffersProcessed == Buffers) _midiSawmill.Warning("MIDI buffer overflow!");
             if (buffersProcessed == 0) return;
@@ -393,36 +465,16 @@ namespace Robust.Client.Audio.Midi
                 Source.GetBuffersProcessed(buffers);
 
                 lock (_playerStateLock)
+                {
+                    // _sequencer.Process(10);
                     _synth?.WriteSampleFloat(length * buffers.Length, audio, 0, Mono ? 1 : 2,
                         audio, Mono ? length * buffers.Length : 1, Mono ? 1 : 2);
-
+                }
                 if (Mono) // Turn audio to mono
                 {
                     var l = length * buffers.Length;
 
-                    if (Sse.IsSupported)
-                    {
-                        fixed (float* ptr = audio)
-                        {
-                            for (var j = 0; j < l; j += 4)
-                            {
-                                var k = j + l;
-
-                                var jV = Sse.LoadVector128(ptr + j);
-                                var kV = Sse.LoadVector128(ptr + k);
-
-                                Sse.Store(j + ptr, Sse.Add(jV, kV));
-                            }
-                        }
-                    }
-                    else
-                    {
-                        for (var j = 0; j < l; j++)
-                        {
-                            var k = j + l;
-                            audio[j] = ((audio[k] + audio[j]));
-                        }
-                    }
+                    NumericsHelpers.Add(audio[..l], audio[l..]);
                 }
 
                 for (var i = 0; i < buffers.Length; i++)
@@ -452,6 +504,7 @@ namespace Robust.Client.Audio.Midi
             var timestamp = SequencerTick;
             var midiEv = (Shared.Audio.Midi.MidiEvent) midiEvent;
             midiEv.Tick = timestamp;
+            midiEvent.Dispose();
             SendMidiEvent(midiEv);
             return 0;
         }
@@ -462,6 +515,7 @@ namespace Robust.Client.Audio.Midi
             var timestamp = SequencerTick;
             var midiEv = (Shared.Audio.Midi.MidiEvent) midiEvent;
             midiEv.Tick = timestamp;
+            midiEvent.Dispose();
             SendMidiEvent(midiEv);
             return 0;
         }
@@ -478,16 +532,16 @@ namespace Robust.Client.Audio.Midi
                 lock(_playerStateLock)
                     switch (midiEvent.Type)
                     {
-                        // Note On 0x80
-                        case 144:
-                            _synth.NoteOn(midiEvent.Channel, midiEvent.Key, midiEvent.Velocity);
-                            break;
-
-                        // Note Off - 0x90
+                        // Note Off - 0x80
                         case 128:
                             _synth.NoteOff(midiEvent.Channel, midiEvent.Key);
                             break;
 
+                        // Note On 0x90
+                        case 144:
+                            _synth.NoteOn(midiEvent.Channel, midiEvent.Key, midiEvent.Velocity);
+                            break;
+
                         // After Touch - 0xA
                         case 160:
                             _synth.KeyPressure(midiEvent.Channel, midiEvent.Key, midiEvent.Value);
@@ -519,10 +573,20 @@ namespace Robust.Client.Audio.Midi
                         // Sometimes MIDI files spam these for no good reason and I can't find any info on what they are.
                         case 1:
                         case 5:
+                        // MetaEvent -- SetTempo - 0x51
                         case 81:
+                            // Already handled by the player.
+                            return;
                         // System Messages - 0xF0
                         case 240:
-                            return;
+                            switch ((byte)midiEvent.Control)
+                            {
+                                case 11:
+                                    _synth.AllNotesOff(midiEvent.Channel);
+                                    break;
+                            }
+
+                            break;
 
                         default:
                             _midiSawmill.Warning("Unhandled midi event of type {0}", midiEvent.Type, midiEvent);
@@ -543,7 +607,7 @@ namespace Robust.Client.Audio.Midi
             if (Disposed) return;
 
             var seqEv = (SequencerEvent) midiEvent;
-            seqEv.Dest = _synthRegister;
+            seqEv.Dest = _debugEvents ? _debugRegister : _synthRegister;
             _sequencer.SendAt(seqEv, time, absolute);
         }
 
@@ -566,10 +630,15 @@ namespace Robust.Client.Audio.Midi
         void IMidiRenderer.InternalDispose()
         {
             Source?.Dispose();
+            _driver?.Dispose();
+
+            // Do NOT dispose of the sequencer after the synth or it'll cause a segfault for some fucking reason.
+            _sequencer?.UnregisterClient(_debugRegister);
+            _sequencer?.UnregisterClient(_synthRegister);
+            _sequencer?.Dispose();
+
             _synth?.Dispose();
             _player?.Dispose();
-            _driver?.Dispose();
-            _sequencer?.Dispose();
         }
     }
 }

Robust.Client/BaseClient.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Net;
 using Robust.Client.Debugging;
 using Robust.Client.GameObjects;
@@ -8,10 +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.Players;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -24,6 +26,7 @@ namespace Robust.Client
         [Dependency] private readonly IPlayerManager _playMan = default!;
         [Dependency] private readonly INetConfigurationManager _configManager = default!;
         [Dependency] private readonly IClientEntityManager _entityManager = default!;
+        [Dependency] private readonly IEntityLookup _entityLookup = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IDiscordRichPresence _discord = default!;
         [Dependency] private readonly IGameTiming _timing = default!;
@@ -96,6 +99,25 @@ namespace Robust.Client
             _net.ClientDisconnect(reason);
         }
 
+        /// <inheritdoc />
+        public void StartSinglePlayer()
+        {
+            DebugTools.Assert(RunLevel < ClientRunLevel.Connecting);
+            DebugTools.Assert(!_net.IsConnected);
+            _playMan.Startup();
+            _playMan.LocalPlayer!.Name = PlayerNameOverride ?? _configManager.GetCVar(CVars.PlayerName);
+            OnRunLevelChanged(ClientRunLevel.SinglePlayerGame);
+            GameStartedSetup();
+        }
+
+        /// <inheritdoc />
+        public void StopSinglePlayer()
+        {
+            DebugTools.Assert(RunLevel == ClientRunLevel.SinglePlayerGame);
+            DebugTools.Assert(!_net.IsConnected);
+            GameStoppedReset();
+        }
+
         /// <inheritdoc />
         public event EventHandler<RunLevelChangedEventArgs>? RunLevelChanged;
 
@@ -132,7 +154,7 @@ namespace Robust.Client
             var userId = _net.ServerChannel.UserId;
             _discord.Update(info.ServerName, userName, info.ServerMaxPlayers.ToString());
             // start up player management
-            _playMan.Startup(_net.ServerChannel!);
+            _playMan.Startup();
 
             _playMan.LocalPlayer!.UserId = userId;
             _playMan.LocalPlayer.Name = userName;
@@ -145,16 +167,13 @@ namespace Robust.Client
         ///     receiving states when they join the lobby.
         /// </summary>
         /// <param name="session">Session of the player.</param>
-        private void OnPlayerJoinedServer(IPlayerSession session)
+        private void OnPlayerJoinedServer(ICommonSession session)
         {
             DebugTools.Assert(RunLevel < ClientRunLevel.Connected);
             OnRunLevelChanged(ClientRunLevel.Connected);
 
-            _entityManager.Startup();
-            _mapManager.Startup();
+            GameStartedSetup();
 
-            _timing.ResetSimTime();
-            _timing.Paused = false;
             PlayerJoinedServer?.Invoke(this, new PlayerEventArgs(session));
         }
 
@@ -162,7 +181,7 @@ namespace Robust.Client
         ///     Player is joining the game
         /// </summary>
         /// <param name="session">Session of the player.</param>
-        private void OnPlayerJoinedGame(IPlayerSession session)
+        private void OnPlayerJoinedGame(ICommonSession session)
         {
             DebugTools.Assert(RunLevel >= ClientRunLevel.Connected);
             OnRunLevelChanged(ClientRunLevel.InGame);
@@ -189,10 +208,25 @@ namespace Robust.Client
             PlayerLeaveServer?.Invoke(this, new PlayerEventArgs(_playMan.LocalPlayer?.Session));
 
             LastDisconnectReason = args.Reason;
+            GameStoppedReset();
+        }
 
+        private void GameStartedSetup()
+        {
+            _entityManager.Startup();
+            _mapManager.Startup();
+            _entityLookup.Startup();
+
+            _timing.ResetSimTime();
+            _timing.Paused = false;
+        }
+
+        private void GameStoppedReset()
+        {
             IoCManager.Resolve<INetConfigurationManager>().FlushMessages();
             _gameStates.Reset();
             _playMan.Shutdown();
+            _entityLookup.Shutdown();
             _entityManager.Shutdown();
             _mapManager.Shutdown();
             _discord.ClearPresence();
@@ -249,6 +283,11 @@ namespace Robust.Client
         ///     The client is now in the game, moving around.
         /// </summary>
         InGame,
+
+        /// <summary>
+        ///     The client is now in singleplayer mode, in-game.
+        /// </summary>
+        SinglePlayerGame,
     }
 
     /// <summary>
@@ -259,12 +298,12 @@ namespace Robust.Client
         /// <summary>
         ///     The session that triggered the event.
         /// </summary>
-        private IPlayerSession? Session { get; }
+        private ICommonSession? Session { get; }
 
         /// <summary>
         ///     Constructs a new instance of the class.
         /// </summary>
-        public PlayerEventArgs(IPlayerSession? session)
+        public PlayerEventArgs(ICommonSession? session)
         {
             Session = session;
         }

Robust.Client/ClientIoC.cs

@@ -14,6 +14,7 @@ using Robust.Client.Prototypes;
 using Robust.Client.Reflection;
 using Robust.Client.ResourceManagement;
 using Robust.Client.State;
+using Robust.Client.Timing;
 using Robust.Client.UserInterface;
 using Robust.Client.Utility;
 using Robust.Client.ViewVariables;
@@ -24,11 +25,11 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Physics;
 using Robust.Shared.Players;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Reflection;
-using Robust.Shared.Serialization;
-using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Timing;
 
 namespace Robust.Client
 {
@@ -38,21 +39,31 @@ namespace Robust.Client
         {
             SharedIoC.RegisterIoC();
 
+            IoCManager.Register<IGameTiming, ClientGameTiming>();
+            IoCManager.Register<IClientGameTiming, ClientGameTiming>();
             IoCManager.Register<IPrototypeManager, ClientPrototypeManager>();
+            IoCManager.Register<IMapManager, ClientMapManager>();
+            IoCManager.Register<IMapManagerInternal, ClientMapManager>();
+            IoCManager.Register<IClientMapManager, ClientMapManager>();
             IoCManager.Register<IEntityManager, ClientEntityManager>();
+            IoCManager.Register<IEntityLookup, EntityLookup>();
+            IoCManager.Register<IReflectionManager, ClientReflectionManager>();
+            IoCManager.Register<IConsoleHost, ClientConsoleHost>();
+            IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
             IoCManager.Register<IComponentFactory, ClientComponentFactory>();
             IoCManager.Register<ITileDefinitionManager, ClydeTileDefinitionManager>();
             IoCManager.Register<IClydeTileDefinitionManager, ClydeTileDefinitionManager>();
+            IoCManager.Register<GameController, GameController>();
             IoCManager.Register<IGameController, GameController>();
             IoCManager.Register<IGameControllerInternal, GameController>();
-            IoCManager.Register<IReflectionManager, ClientReflectionManager>();
             IoCManager.Register<IResourceManager, ResourceCache>();
             IoCManager.Register<IResourceManagerInternal, ResourceCache>();
             IoCManager.Register<IResourceCache, ResourceCache>();
             IoCManager.Register<IResourceCacheInternal, ResourceCache>();
             IoCManager.Register<IClientNetManager, NetManager>();
             IoCManager.Register<IClientEntityManager, ClientEntityManager>();
-            IoCManager.Register<IEntityNetworkManager, ClientEntityNetworkManager>();
+            IoCManager.Register<IClientEntityManagerInternal, ClientEntityManager>();
+            IoCManager.Register<IEntityNetworkManager, ClientEntityManager>();
             IoCManager.Register<IClientGameStateManager, ClientGameStateManager>();
             IoCManager.Register<IBaseClient, BaseClient>();
             IoCManager.Register<IPlayerManager, PlayerManager>();
@@ -64,12 +75,9 @@ namespace Robust.Client
             IoCManager.Register<IDebugDrawingManager, DebugDrawingManager>();
             IoCManager.Register<ILightManager, LightManager>();
             IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
-            IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
-            IoCManager.Register<IConsoleHost, ClientConsoleHost>();
-            IoCManager.Register<IFontManager, FontManager>();
-            IoCManager.Register<IFontManagerInternal, FontManager>();
             IoCManager.Register<IMidiManager, MidiManager>();
             IoCManager.Register<IAuthManager, AuthManager>();
+            IoCManager.Register<IPhysicsManager, PhysicsManager>();
             switch (mode)
             {
                 case GameController.DisplayMode.Headless:
@@ -94,8 +102,9 @@ namespace Robust.Client
                     throw new ArgumentOutOfRangeException();
             }
 
+            IoCManager.Register<IFontManager, FontManager>();
+            IoCManager.Register<IFontManagerInternal, FontManager>();
             IoCManager.Register<IEyeManager, EyeManager>();
-
             IoCManager.Register<IPlacementManager, PlacementManager>();
             IoCManager.Register<IOverlayManager, OverlayManager>();
             IoCManager.Register<IOverlayManagerInternal, OverlayManager>();

Robust.Client/CommandLineArgs.cs

@@ -17,6 +17,7 @@ namespace Robust.Client
         public bool Launcher { get; }
         public string? Username { get; }
         public IReadOnlyCollection<(string key, string value)> CVars { get; }
+        public IReadOnlyCollection<(string key, string value)> LogLevels { get; }
 
         // Manual parser because C# has no good command line parsing libraries. Also dependencies bad.
         // Also I don't like spending 100ms parsing command line args. Do you?
@@ -31,6 +32,7 @@ namespace Robust.Client
             var launcher = false;
             string? username = null;
             var cvars = new List<(string, string)>();
+            var logLevels = new List<(string, string)>();
             var mountOptions = new MountOptions();
 
             using var enumerator = args.GetEnumerator();
@@ -124,6 +126,26 @@ namespace Robust.Client
 
                     mountOptions.DirMounts.Add(enumerator.Current);
                 }
+                else if (arg == "--loglevel")
+                {
+                    if (!enumerator.MoveNext())
+                    {
+                        C.WriteLine("Missing loglevel sawmill.");
+                        return false;
+                    }
+
+                    var loglevel = enumerator.Current;
+                    DebugTools.AssertNotNull(loglevel);
+                    var pos = loglevel.IndexOf('=');
+
+                    if (pos == -1)
+                    {
+                        C.WriteLine("Expected = in loglevel.");
+                        return false;
+                    }
+
+                    logLevels.Add((loglevel[..pos], loglevel[(pos + 1)..]));
+                }
                 else if (arg == "--help")
                 {
                     PrintHelp();
@@ -142,6 +164,7 @@ namespace Robust.Client
                 launcher,
                 username,
                 cvars,
+                logLevels,
                 connectAddress,
                 ss14Address,
                 mountOptions);
@@ -162,6 +185,7 @@ Options:
   --launcher          Run in launcher mode (no main menu, auto connect).
   --username          Override username.
   --cvar              Specifies an additional cvar overriding the config file. Syntax is <key>=<value>
+  --loglevel          Specifies an additional sawmill log level overriding the default values. Syntax is <key>=<value>
   --mount-dir         Resource directory to mount.
   --mount-zip         Resource zip to mount.
   --help              Display this help text and exit.
@@ -175,6 +199,7 @@ Options:
             bool launcher,
             string? username,
             IReadOnlyCollection<(string key, string value)> cVars,
+            IReadOnlyCollection<(string key, string value)> logLevels,
             string connectAddress, string? ss14Address,
             MountOptions mountOptions)
         {
@@ -184,6 +209,7 @@ Options:
             Launcher = launcher;
             Username = username;
             CVars = cVars;
+            LogLevels = logLevels;
             ConnectAddress = connectAddress;
             Ss14Address = ss14Address;
             MountOptions = mountOptions;

Robust.Client/Console/ClientConsoleHost.cs

@@ -36,7 +36,7 @@ namespace Robust.Client.Console
             Message = message;
         }
     }
-    
+
     /// <inheritdoc cref="IClientConsoleHost" />
     internal class ClientConsoleHost : ConsoleHost, IClientConsoleHost
     {
@@ -45,11 +45,15 @@ namespace Robust.Client.Console
         /// <inheritdoc />
         public void Initialize()
         {
-            NetManager.RegisterNetMessage<MsgConCmdReg>(MsgConCmdReg.NAME, HandleConCmdReg);
-            NetManager.RegisterNetMessage<MsgConCmdAck>(MsgConCmdAck.NAME, HandleConCmdAck);
-            NetManager.RegisterNetMessage<MsgConCmd>(MsgConCmd.NAME, ProcessCommand);
+            NetManager.RegisterNetMessage<MsgConCmdReg>(HandleConCmdReg);
+            NetManager.RegisterNetMessage<MsgConCmdAck>(HandleConCmdAck);
+            NetManager.RegisterNetMessage<MsgConCmd>(ProcessCommand);
 
-            Reset();
+            _requestedCommands = false;
+            NetManager.Connected += OnNetworkConnected;
+
+            LoadConsoleCommands();
+            SendServerCommandRequest();
             LogManager.RootSawmill.AddHandler(new DebugConsoleLogHandler(this));
         }
 
@@ -61,17 +65,6 @@ namespace Robust.Client.Console
             ExecuteCommand(null, text);
         }
 
-        /// <inheritdoc />
-        public void Reset()
-        {
-            AvailableCommands.Clear();
-            _requestedCommands = false;
-            NetManager.Connected += OnNetworkConnected;
-
-            LoadConsoleCommands();
-            SendServerCommandRequest();
-        }
-
         /// <inheritdoc />
         public event EventHandler<AddStringArgs>? AddString;
 
@@ -90,6 +83,8 @@ namespace Robust.Client.Console
             OutputText(text, true, true);
         }
 
+        public override event ConAnyCommandCallback? AnyCommandExecuted;
+
         /// <inheritdoc />
         public override void ExecuteCommand(ICommonSession? session, string command)
         {
@@ -97,7 +92,7 @@ namespace Robust.Client.Console
                 return;
 
             // echo the command locally
-            WriteError(null, "> " + command);
+            WriteLine(null, "> " + command);
 
             //Commands are processed locally and then sent to the server to be processed there again.
             var args = new List<string>();
@@ -110,7 +105,11 @@ namespace Robust.Client.Console
             {
                 var command1 = AvailableCommands[commandName];
                 args.RemoveAt(0);
-                command1.Execute(new ConsoleShell(this, null), command, args.ToArray());
+                var shell = new ConsoleShell(this, null);
+                var cmdArgs = args.ToArray();
+
+                AnyCommandExecuted?.Invoke(shell, commandName, command, cmdArgs);
+                command1.Execute(shell, command, cmdArgs);
             }
             else
                 WriteError(null, "Unknown command: " + commandName);
@@ -142,6 +141,9 @@ namespace Robust.Client.Console
         private void OutputText(string text, bool local, bool error)
         {
             AddString?.Invoke(this, new AddStringArgs(text, local, error));
+
+            var level = error ? LogLevel.Warning : LogLevel.Info;
+            Logger.LogS(level, "CON", text);
         }
 
         private void OnNetworkConnected(object? sender, NetChannelArgs netChannelArgs)

Robust.Client/Console/Commands/AddCompCommand.cs

@@ -24,7 +24,6 @@ namespace Robust.Client.Console.Commands
             var entityUid = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
-            var compManager = IoCManager.Resolve<IComponentManager>();
             var compFactory = IoCManager.Resolve<IComponentFactory>();
             var entityManager = IoCManager.Resolve<IEntityManager>();
 
@@ -33,7 +32,7 @@ namespace Robust.Client.Console.Commands
 
             component.Owner = entity;
 
-            compManager.AddComponent(entity, component);
+            entityManager.AddComponent(entity, component);
         }
     }
 
@@ -55,12 +54,12 @@ namespace Robust.Client.Console.Commands
             var entityUid = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
-            var compManager = IoCManager.Resolve<IComponentManager>();
+            var entManager = IoCManager.Resolve<IEntityManager>();
             var compFactory = IoCManager.Resolve<IComponentFactory>();
 
             var registration = compFactory.GetRegistration(componentName);
 
-            compManager.RemoveComponent(entityUid, registration.Type);
+            entManager.RemoveComponent(entityUid, registration.Type);
         }
     }
 }

Robust.Client/Console/Commands/Debug.cs

@@ -27,6 +27,7 @@ using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.Console.Commands
 {
@@ -77,7 +78,7 @@ namespace Robust.Client.Console.Commands
                     message.Append($"net ID: {registration.NetID}");
                 }
 
-                message.Append($", NSE: {registration.NetworkSynchronizeExistence}, references:");
+                message.Append($", References:");
 
                 shell.WriteLine(message.ToString());
 
@@ -160,19 +161,6 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ShowBoundingBoxesCommand : IConsoleCommand
-    {
-        public string Command => "showbb";
-        public string Help => "";
-        public string Description => "Enables debug drawing over all bounding boxes in the game, showing their size.";
-
-        public void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            var mgr = IoCManager.Resolve<IDebugDrawing>();
-            mgr.DebugColliders = !mgr.DebugColliders;
-        }
-    }
-
     internal class ShowPositionsCommand : IConsoleCommand
     {
         public string Command => "showpos";
@@ -280,12 +268,12 @@ namespace Robust.Client.Console.Commands
     internal class SnapGridGetCell : IConsoleCommand
     {
         public string Command => "sggcell";
-        public string Help => "sggcell <gridID> <vector2i> [offset]\nThat vector2i param is in the form x<int>,y<int>.";
+        public string Help => "sggcell <gridID> <vector2i>\nThat vector2i param is in the form x<int>,y<int>.";
         public string Description => "Lists entities on a snap grid cell.";
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            if (args.Length != 2 && args.Length != 3)
+            if (args.Length != 2)
             {
                 shell.WriteLine(Help);
                 return;
@@ -293,7 +281,6 @@ namespace Robust.Client.Console.Commands
 
             string gridId = args[0];
             string indices = args[1];
-            string offset = args.Length == 3 ? args[2] : "Center";
 
             if (!int.TryParse(args[0], out var id))
             {
@@ -307,29 +294,17 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            SnapGridOffset selectedOffset;
-            if (Enum.IsDefined(typeof(SnapGridOffset), offset))
-            {
-                    selectedOffset = (SnapGridOffset)Enum.Parse(typeof(SnapGridOffset), offset);
-            }
-            else
-            {
-                shell.WriteError("given offset type is not defined");
-                return;
-            }
-
             var mapMan = IoCManager.Resolve<IMapManager>();
 
             if (mapMan.GridExists(new GridId(int.Parse(gridId, CultureInfo.InvariantCulture))))
             {
                 foreach (var entity in
-                    mapMan.GetGrid(new GridId(int.Parse(gridId, CultureInfo.InvariantCulture))).GetSnapGridCell(
+                    mapMan.GetGrid(new GridId(int.Parse(gridId, CultureInfo.InvariantCulture))).GetAnchoredEntities(
                         new Vector2i(
                             int.Parse(indices.Split(',')[0], CultureInfo.InvariantCulture),
-                            int.Parse(indices.Split(',')[1], CultureInfo.InvariantCulture)),
-                        selectedOffset))
+                            int.Parse(indices.Split(',')[1], CultureInfo.InvariantCulture))))
                 {
-                    shell.WriteLine(entity.Owner.Uid.ToString());
+                    shell.WriteLine(entity.ToString());
                 }
             }
             else
@@ -472,13 +447,18 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var root = IoCManager.Resolve<IUserInterfaceManager>().RootControl;
+            var uiMgr = IoCManager.Resolve<IUserInterfaceManager>();
             var res = IoCManager.Resolve<IResourceManager>();
 
             using (var stream = res.UserData.Create(new ResourcePath("/guidump.txt")))
             using (var writer = new StreamWriter(stream, EncodingHelpers.UTF8))
             {
-                _writeNode(root, 0, writer);
+                foreach (var root in uiMgr.AllRoots)
+                {
+                    writer.WriteLine($"ROOT: {root}");
+                    _writeNode(root, 0, writer);
+                    writer.WriteLine("---------------");
+                }
             }
 
             shell.WriteLine("Saved guidump");
@@ -488,7 +468,7 @@ namespace Robust.Client.Console.Commands
         {
             var indentation = new string(' ', indents * 2);
             writer.WriteLine("{0}{1}", indentation, control);
-            foreach (var (key, value) in _propertyValuesFor(control))
+            foreach (var (key, value) in PropertyValuesFor(control))
             {
                 writer.WriteLine("{2} * {0}: {1}", key, value, indentation);
             }
@@ -499,14 +479,14 @@ namespace Robust.Client.Console.Commands
             }
         }
 
-        private static List<(string, string)> _propertyValuesFor(Control control)
+        internal static List<(string, string)> PropertyValuesFor(Control control)
         {
             var members = new List<(string, string)>();
             var type = control.GetType();
 
             foreach (var fieldInfo in type.GetAllFields())
             {
-                if (fieldInfo.GetCustomAttribute<ViewVariablesAttribute>() == null)
+                if (!ViewVariablesUtility.TryGetViewVariablesAccess(fieldInfo, out _))
                 {
                     continue;
                 }
@@ -516,7 +496,7 @@ namespace Robust.Client.Console.Commands
 
             foreach (var propertyInfo in type.GetAllProperties())
             {
-                if (propertyInfo.GetCustomAttribute<ViewVariablesAttribute>() == null)
+                if (!ViewVariablesUtility.TryGetViewVariablesAccess(propertyInfo, out _))
                 {
                     continue;
                 }
@@ -549,7 +529,10 @@ namespace Robust.Client.Console.Commands
             var scroll = new ScrollContainer();
             tabContainer.AddChild(scroll);
             //scroll.SetAnchorAndMarginPreset(Control.LayoutPreset.Wide);
-            var vBox = new VBoxContainer();
+            var vBox = new BoxContainer
+            {
+                Orientation = LayoutOrientation.Vertical
+            };
             scroll.AddChild(vBox);
 
             var progressBar = new ProgressBar { MaxValue = 10, Value = 5 };
@@ -607,7 +590,10 @@ namespace Robust.Client.Console.Commands
             }
 
             var group = new ButtonGroup();
-            var vBoxRadioButtons = new VBoxContainer();
+            var vBoxRadioButtons = new BoxContainer
+            {
+                Orientation = LayoutOrientation.Vertical
+            };
             for (var i = 0; i < 10; i++)
             {
                 vBoxRadioButtons.AddChild(new Button
@@ -623,8 +609,9 @@ namespace Robust.Client.Console.Commands
 
             TabContainer.SetTabTitle(vBoxRadioButtons, "Radio buttons!!");
 
-            tabContainer.AddChild(new VBoxContainer
+            tabContainer.AddChild(new BoxContainer
             {
+                Orientation = LayoutOrientation.Vertical,
                 Name = "Slider",
                 Children =
                 {
@@ -632,8 +619,9 @@ namespace Robust.Client.Console.Commands
                 }
             });
 
-            tabContainer.AddChild(new HSplitContainer
+            tabContainer.AddChild(new SplitContainer
             {
+                Orientation = SplitContainer.SplitOrientation.Horizontal,
                 Children =
                 {
                     new PanelContainer
@@ -678,10 +666,10 @@ namespace Robust.Client.Console.Commands
         public string Description => "Gets the system clipboard";
         public string Help => "getclipboard";
 
-        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        public async void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             var mgr = IoCManager.Resolve<IClipboardManager>();
-            shell.WriteLine(mgr.GetText());
+            shell.WriteLine(await mgr.GetText());
         }
     }
 
@@ -876,7 +864,7 @@ namespace Robust.Client.Console.Commands
             var chunkIndex = grid.LocalToChunkIndices(grid.MapToGrid(mousePos));
             var chunk = internalGrid.GetChunk(chunkIndex);
 
-            shell.WriteLine($"worldBounds: {chunk.CalcWorldBounds()} localBounds: {chunk.CalcLocalBounds()}");
+            shell.WriteLine($"worldBounds: {chunk.CalcWorldAABB()} localBounds: {chunk.CalcLocalBounds()}");
         }
     }
 
@@ -1097,15 +1085,8 @@ namespace Robust.Client.Console.Commands
                 var key = (Keyboard.Key) parsed!;
 
                 var name = clyde.GetKeyName(key);
-                var scanCode = clyde.GetKeyScanCode(key);
-                var nameScanCode = clyde.GetKeyNameScanCode(scanCode);
 
-                shell.WriteLine($"name: '{name}' scan code: '{scanCode}' name via scan code: '{nameScanCode}'");
-            }
-            else if (int.TryParse(args[0], out var scanCode))
-            {
-                var nameScanCode = clyde.GetKeyNameScanCode(scanCode);
-                shell.WriteLine($"name via scan code: '{nameScanCode}'");
+                shell.WriteLine($"name: '{name}' ");
             }
         }
     }

Robust.Client/Console/Commands/DebugAnchoredCommand.cs

@@ -0,0 +1,19 @@
+#if DEBUG
+using Robust.Client.Debugging;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public sealed class DebugAnchoredCommand : IConsoleCommand
+    {
+        public string Command => "showanchored";
+        public string Description => $"Shows anchored entities on a particular tile";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<DebugAnchoringSystem>().Enabled ^= true;
+        }
+    }
+}
+#endif

Robust.Client/Console/Commands/GridChunkBBCommand.cs

@@ -0,0 +1,17 @@
+using Robust.Client.GameObjects;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public class GridChunkBBCommand : IConsoleCommand
+    {
+        public string Command => "showchunkbb";
+        public string Description => "Displays chunk bounds for the purposes of rendering";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<GridChunkBoundsDebugSystem>().Enabled ^= true;
+        }
+    }
+}

Robust.Client/Console/Commands/LightBBCommand.cs

@@ -0,0 +1,19 @@
+#if DEBUG
+using Robust.Client.GameObjects;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    internal sealed class LightDebugCommand : IConsoleCommand
+    {
+        public string Command => "lightbb";
+        public string Description => "Toggles whether to show light bounding boxes";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<DebugLightTreeSystem>().Enabled ^= true;
+        }
+    }
+}
+#endif

Robust.Client/Console/Commands/MonitorCommands.cs

@@ -0,0 +1,72 @@
+using System.Linq;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Shared.Console;
+using Robust.Shared.IoC;
+
+namespace Robust.Client.Console.Commands
+{
+    [UsedImplicitly]
+    public sealed class LsMonitorCommand : IConsoleCommand
+    {
+        public string Command => "lsmonitor";
+        public string Description => "";
+        public string Help => "";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            var clyde = IoCManager.Resolve<IClyde>();
+
+            foreach (var monitor in clyde.EnumerateMonitors())
+            {
+                shell.WriteLine(
+                    $"[{monitor.Id}] {monitor.Name}: {monitor.Size.X}x{monitor.Size.Y}@{monitor.RefreshRate}Hz");
+            }
+        }
+    }
+
+    [UsedImplicitly]
+    public sealed class MonitorInfoCommand : IConsoleCommand
+    {
+        public string Command => "monitorinfo";
+        public string Description => "";
+        public string Help => "Usage: monitorinfo <id>";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            if (args.Length < 1)
+            {
+                shell.WriteError("Expected one argument.");
+                return;
+            }
+
+            var clyde = IoCManager.Resolve<IClyde>();
+            var monitor = clyde.EnumerateMonitors().Single(c => c.Id == int.Parse(args[0]));
+
+            shell.WriteLine($"{monitor.Id}: {monitor.Name}");
+            shell.WriteLine($"Video modes:");
+
+            foreach (var mode in monitor.VideoModes)
+            {
+                shell.WriteLine($"  {mode.Width}x{mode.Height} {mode.RefreshRate} Hz {mode.RedBits}/{mode.GreenBits}/{mode.BlueBits}");
+            }
+        }
+    }
+
+    [UsedImplicitly]
+    public sealed class SetMonitorCommand : IConsoleCommand
+    {
+        public string Command => "setmonitor";
+        public string Description => "";
+        public string Help => "Usage: setmonitor <id>";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            var clyde = IoCManager.Resolve<IClyde>();
+
+            var id = int.Parse(args[0]);
+            var monitor = clyde.EnumerateMonitors().Single(m => m.Id == id);
+            clyde.SetWindowMonitor(monitor);
+        }
+    }
+}

Robust.Client/Console/Commands/PhysicsOverlayCommands.cs

@@ -7,8 +7,8 @@ namespace Robust.Client.Console.Commands
     public sealed class PhysicsOverlayCommands : IConsoleCommand
     {
         public string Command => "physics";
-        public string Description => $"{Command} <contactnormals / contactpoints / shapes>";
-        public string Help => $"{Command} <overlay>";
+        public string Description => $"Shows a debug physics overlay. The arg supplied specifies the overlay.";
+        public string Help => $"{Command} <contactnormals / contactpoints / joints / shapeinfo / shapes>";
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             if (args.Length != 1)
@@ -27,6 +27,12 @@ namespace Robust.Client.Console.Commands
                 case "contactpoints":
                     system.Flags ^= PhysicsDebugFlags.ContactPoints;
                     break;
+                case "joints":
+                    system.Flags ^= PhysicsDebugFlags.Joints;
+                    break;
+                case "shapeinfo":
+                    system.Flags ^= PhysicsDebugFlags.ShapeInfo;
+                    break;
                 case "shapes":
                     system.Flags ^= PhysicsDebugFlags.Shapes;
                     break;

Robust.Client/Console/Commands/QuitCommand.cs

@@ -1,11 +1,12 @@
 using System;
 using Robust.Shared.Console;
+using Robust.Shared.IoC;
 
 namespace Robust.Client.Console.Commands
 {
-    class QuitCommand : IConsoleCommand
+    class HardQuitCommand : IConsoleCommand
     {
-        public string Command => "quit";
+        public string Command => "hardquit";
         public string Description => "Kills the game client instantly.";
         public string Help => "Kills the game client instantly, leaving no traces. No telling the server goodbye";
 
@@ -14,4 +15,16 @@ namespace Robust.Client.Console.Commands
             Environment.Exit(0);
         }
     }
+
+    class QuitCommand : IConsoleCommand
+    {
+        public string Command => "quit";
+        public string Description => "Shuts down the game client gracefully.";
+        public string Help => "Properly shuts down the game client, notifying the connected server and such.";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            IoCManager.Resolve<IGameController>().Shutdown("quit command used");
+        }
+    }
 }

Robust.Client/Console/Commands/Scripting.cs

@@ -1,6 +1,5 @@
 using Robust.Shared.Console;
 using Robust.Shared.IoC;
-using Robust.Shared.Localization;
 
 namespace Robust.Client.Console.Commands
 {
@@ -41,7 +40,7 @@ namespace Robust.Client.Console.Commands
             var mgr = IoCManager.Resolve<IScriptClient>();
             if (!mgr.CanScript)
             {
-                shell.WriteError(Loc.GetString("You do not have server side scripting permission."));
+                shell.WriteError("You do not have server side scripting permission.");
                 return;
             }
 

Robust.Client/Console/IClientConsoleHost.cs

@@ -11,11 +11,6 @@ namespace Robust.Client.Console
         /// </summary>
         void Initialize();
 
-        /// <summary>
-        /// Resets the console to a post-initialized state.
-        /// </summary>
-        void Reset();
-
         event EventHandler<AddStringArgs> AddString;
         event EventHandler<AddFormattedMessageArgs> AddFormatted;
 

Robust.Client/Console/ScriptClient.cs

@@ -17,11 +17,11 @@ namespace Robust.Client.Console
 
         public void Initialize()
         {
-            _netManager.RegisterNetMessage<MsgScriptStop>(MsgScriptStop.NAME);
-            _netManager.RegisterNetMessage<MsgScriptEval>(MsgScriptEval.NAME);
-            _netManager.RegisterNetMessage<MsgScriptStart>(MsgScriptStart.NAME);
-            _netManager.RegisterNetMessage<MsgScriptResponse>(MsgScriptResponse.NAME, ReceiveScriptResponse);
-            _netManager.RegisterNetMessage<MsgScriptStartAck>(MsgScriptStartAck.NAME, ReceiveScriptStartAckResponse);
+            _netManager.RegisterNetMessage<MsgScriptStop>();
+            _netManager.RegisterNetMessage<MsgScriptEval>();
+            _netManager.RegisterNetMessage<MsgScriptStart>();
+            _netManager.RegisterNetMessage<MsgScriptResponse>(ReceiveScriptResponse);
+            _netManager.RegisterNetMessage<MsgScriptStartAck>(ReceiveScriptStartAckResponse);
         }
 
         private void ReceiveScriptStartAckResponse(MsgScriptStartAck message)
@@ -30,7 +30,8 @@ namespace Robust.Client.Console
 
             var console = new ScriptConsoleServer(this, session);
             _activeConsoles.Add(session, console);
-            console.Open();
+            // FIXME: When this is Open(), resizing the window will cause its position to get NaN'd.
+            console.OpenCentered();
         }
 
         private void ReceiveScriptResponse(MsgScriptResponse message)

Robust.Client/Console/ScriptConsoleClient.cs

@@ -1,5 +1,4 @@
 #if CLIENT_SCRIPTING
-using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
@@ -14,11 +13,11 @@ using Microsoft.CodeAnalysis.Text;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.ViewVariables;
 using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Maths;
 using Robust.Shared.Reflection;
 using Robust.Shared.Scripting;
 using Robust.Shared.Utility;
+using SixLabors.ImageSharp;
+using Color = Robust.Shared.Maths.Color;
 
 #nullable enable
 
@@ -43,14 +42,14 @@ namespace Robust.Client.Console
 
         public ScriptConsoleClient()
         {
-            Title = Loc.GetString("Robust C# Interactive (CLIENT)");
+            Title = "Robust C# Interactive (CLIENT)";
             ScriptInstanceShared.InitDummy();
 
             _globals = new ScriptGlobalsImpl(this);
 
             IoCManager.InjectDependencies(this);
 
-            OutputPanel.AddText(Loc.GetString(@"Robust C# interactive console (CLIENT)."));
+            OutputPanel.AddText("Robust C# interactive console (CLIENT).");
             OutputPanel.AddText(">");
         }
 
@@ -118,7 +117,7 @@ namespace Robust.Client.Console
             }
             else
             {
-                var options = ScriptInstanceShared.GetScriptOptions(_reflectionManager);
+                var options = ScriptInstanceShared.GetScriptOptions(_reflectionManager).AddReferences(typeof(Image).Assembly);
                 newScript = CSharpScript.Create(code, options, typeof(ScriptGlobals));
             }
 

Robust.Client/Console/WatchWindow.cs

@@ -8,11 +8,10 @@ using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Maths;
 using Robust.Shared.Reflection;
 using Robust.Shared.Scripting;
 using Robust.Shared.Timing;
+using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.Console
 {
@@ -20,7 +19,7 @@ namespace Robust.Client.Console
     {
         private readonly IReflectionManager _reflectionManager;
 
-        private readonly VBoxContainer _watchesVBox;
+        private readonly BoxContainer _watchesVBox;
         private readonly LineEdit _addWatchEdit;
         private readonly Button _addWatchButton;
 
@@ -31,29 +30,32 @@ namespace Robust.Client.Console
 
             ScriptInstanceShared.InitDummy();
 
-            Title = Loc.GetString("Watch Window");
+            Title = "Watch Window";
 
-            var mainVBox = new VBoxContainer
+            var mainVBox = new BoxContainer
             {
+                Orientation = LayoutOrientation.Vertical,
                 MinSize = (500, 300),
                 Children =
                 {
-                    (_watchesVBox = new VBoxContainer
+                    (_watchesVBox = new BoxContainer
                     {
+                        Orientation = LayoutOrientation.Vertical,
                         VerticalExpand = true
                     }),
-                    new HBoxContainer
+                    new BoxContainer
                     {
+                        Orientation = LayoutOrientation.Horizontal,
                         Children =
                         {
                             (_addWatchEdit = new HistoryLineEdit
                             {
                                 HorizontalExpand = true,
-                                PlaceHolder = Loc.GetString("Add watch (C# interactive)")
+                                PlaceHolder = "Add watch (C# interactive)"
                             }),
                             (_addWatchButton = new Button
                             {
-                                Text = Loc.GetString("Add")
+                                Text = "Add"
                             })
                         }
                     }
@@ -107,8 +109,9 @@ namespace Robust.Client.Console
                 Button delButton;
                 _runner = runner;
 
-                AddChild(new HBoxContainer
+                AddChild(new BoxContainer
                 {
+                    Orientation = LayoutOrientation.Horizontal,
                     Children =
                     {
                         (_outputLabel = new Label
@@ -118,7 +121,7 @@ namespace Robust.Client.Console
                         }),
                         (delButton = new Button
                         {
-                            Text = Loc.GetString("Remove")
+                            Text = "Remove"
                         }),
                     }
                 });
@@ -168,8 +171,9 @@ namespace Robust.Client.Console
             public CompilationErrorControl(string message)
             {
                 Button delButton;
-                AddChild(new HBoxContainer
+                AddChild(new BoxContainer
                 {
+                    Orientation = LayoutOrientation.Horizontal,
                     Children =
                     {
                         new Label
@@ -178,7 +182,7 @@ namespace Robust.Client.Console
                             ClipText = true,
                             HorizontalExpand = true
                         },
-                        (delButton = new Button {Text = Loc.GetString("Remove")})
+                        (delButton = new Button {Text = "Remove"})
                     }
                 });
 

Robust.Client/ContentStart.cs

@@ -5,10 +5,15 @@ namespace Robust.Client
         public static void Start(string[] args)
         {
 #if FULL_RELEASE
-            throw new System.InvalidOperationException("ContentStart is not available on a full release.");
+            throw new System.InvalidOperationException("ContentStart.Start is not available on a full release.");
 #else
-            GameController.Start(args, true);
+            GameController.Start(args, new GameControllerOptions(), true);
 #endif
         }
+
+        public static void StartLibrary(string[] args, GameControllerOptions options)
+        {
+            GameController.Start(args, options, true, null);
+        }
     }
 }

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -0,0 +1,96 @@
+#if DEBUG
+using System.Text;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.UserInterface;
+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
+{
+    public sealed class DebugAnchoringSystem : EntitySystem
+    {
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IInputManager _inputManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
+
+        private Label? _label;
+
+        private (GridId GridId, TileRef Tile)? _hovered;
+
+        public bool Enabled
+        {
+            get => _enabled;
+            set
+            {
+                if (_enabled == value) return;
+
+                _enabled = value;
+
+                if (_enabled)
+                {
+                    _label = new Label();
+                    IoCManager.Resolve<IUserInterfaceManager>().StateRoot.AddChild(_label);
+                }
+                else
+                {
+                    IoCManager.Resolve<IUserInterfaceManager>().StateRoot.RemoveChild(_label!);
+                    _label = null;
+                    _hovered = null;
+                }
+            }
+        }
+
+        private bool _enabled;
+
+        public override void FrameUpdate(float frameTime)
+        {
+            base.FrameUpdate(frameTime);
+            if (!Enabled) return;
+
+            if (_label == null)
+            {
+                DebugTools.Assert($"Debug Label for {nameof(DebugAnchoringSystem)} is null!");
+                return;
+            }
+
+            var mouseSpot = _inputManager.MouseScreenPosition;
+            var spot = _eyeManager.ScreenToMap(mouseSpot);
+
+            if (!_mapManager.TryFindGridAt(spot, out var grid))
+            {
+                _label.Text = string.Empty;
+                _hovered = null;
+                return;
+            }
+
+            var tile = grid.GetTileRef(spot);
+            _label.Position = mouseSpot.Position + new Vector2(32, 0);
+
+            if (_hovered?.GridId == grid.Index && _hovered?.Tile == tile) return;
+
+            _hovered = (grid.Index, tile);
+
+            var text = new StringBuilder();
+
+            foreach (var ent in grid.GetAnchoredEntities(spot))
+            {
+                if (!EntityManager.TryGetEntity(ent, out var entity))
+                {
+                    text.AppendLine($"uid: {ent}, invalid");
+                }
+                else
+                {
+                    text.AppendLine($"uid: {ent}, {entity.Name}");
+                }
+            }
+
+            _label.Text = text.ToString();
+        }
+    }
+}
+#endif

Robust.Client/Debugging/DebugDrawing.cs

@@ -1,16 +1,8 @@
-using System;
-using System.Collections.Generic;
 using Robust.Client.Graphics;
-using Robust.Client.Input;
-using Robust.Client.ResourceManagement;
-using Robust.Shared;
-using Robust.Shared.Configuration;
+using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
-using Robust.Shared.Physics;
-using Robust.Shared.Physics.Broadphase;
-using Robust.Shared.Prototypes;
 
 namespace Robust.Client.Debugging
 {
@@ -18,41 +10,11 @@ namespace Robust.Client.Debugging
     public class DebugDrawing : IDebugDrawing
     {
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
-        [Dependency] private readonly IComponentManager _componentManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
-        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-        [Dependency] private readonly IPhysicsManager _physicsManager = default!;
-        [Dependency] private readonly IEntityManager _entityManager = default!;
-        [Dependency] private readonly IInputManager _inputManager = default!;
+        [Dependency] private readonly IEntityLookup _lookup = default!;
 
-        private bool _debugColliders;
         private bool _debugPositions;
 
-        /// <inheritdoc />
-        public bool DebugColliders
-        {
-            get => _debugColliders;
-            set
-            {
-                if (value == DebugColliders)
-                {
-                    return;
-                }
-
-                _debugColliders = value;
-
-                if (value)
-                {
-                    _overlayManager.AddOverlay(new PhysicsOverlay(_componentManager, _eyeManager,
-                        _prototypeManager, _inputManager, _physicsManager));
-                }
-                else
-                {
-                    _overlayManager.RemoveOverlay(nameof(PhysicsOverlay));
-                }
-            }
-        }
-
         /// <inheritdoc />
         public bool DebugPositions
         {
@@ -66,228 +28,46 @@ namespace Robust.Client.Debugging
 
                 _debugPositions = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<EntityPositionOverlay>())
                 {
-                    _overlayManager.AddOverlay(new EntityPositionOverlay(_entityManager, _eyeManager));
+                    _overlayManager.AddOverlay(new EntityPositionOverlay(_lookup, _eyeManager));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(EntityPositionOverlay));
+                    _overlayManager.RemoveOverlay<EntityPositionOverlay>();
                 }
             }
         }
 
-        private class PhysicsOverlay : Overlay
-        {
-            private readonly IComponentManager _componentManager;
-            private readonly IEyeManager _eyeManager;
-            private readonly IInputManager _inputManager;
-            private readonly IPhysicsManager _physicsManager;
-
-            public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
-            private readonly ShaderInstance _shader;
-            private readonly Font _font;
-
-            private Vector2 _hoverStartScreen = Vector2.Zero;
-            private List<IPhysBody> _hoverBodies = new();
-
-            public PhysicsOverlay(IComponentManager compMan, IEyeManager eyeMan, IPrototypeManager protoMan, IInputManager inputManager, IPhysicsManager physicsManager)
-                : base(nameof(PhysicsOverlay))
-            {
-                _componentManager = compMan;
-                _eyeManager = eyeMan;
-                _inputManager = inputManager;
-                _physicsManager = physicsManager;
-
-                _shader = protoMan.Index<ShaderPrototype>("unshaded").Instance();
-                var cache = IoCManager.Resolve<IResourceCache>();
-                _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
-            }
-
-            /// <inheritdoc />
-            protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
-            {
-                switch (currentSpace)
-                {
-                    case OverlaySpace.ScreenSpace:
-                        DrawScreen((DrawingHandleScreen) handle);
-                        break;
-                    case OverlaySpace.WorldSpace:
-                        DrawWorld((DrawingHandleWorld) handle);
-                        break;
-                }
-
-            }
-
-            private void DrawScreen(DrawingHandleScreen screenHandle)
-            {
-                var lineHeight = _font.GetLineHeight(1f);
-                Vector2 drawPos = _hoverStartScreen + new Vector2(20, 0) + new Vector2(0, -(_hoverBodies.Count * 4 * lineHeight / 2f));
-                int row = 0;
-
-                foreach (var body in _hoverBodies)
-                {
-                    if (body != _hoverBodies[0])
-                    {
-                        DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), "------");
-                        row++;
-                    }
-
-                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {body.Entity}");
-                    row++;
-                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Layer: {Convert.ToString(body.CollisionLayer, 2)}");
-                    row++;
-                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Mask: {Convert.ToString(body.CollisionMask, 2)}");
-                    row++;
-                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {(body).BodyType == BodyType.Static}");
-                    row++;
-                }
-
-            }
-
-            private void DrawWorld(DrawingHandleWorld worldHandle)
-            {
-                worldHandle.UseShader(_shader);
-                var drawing = new PhysDrawingAdapter(worldHandle);
-
-                _hoverBodies.Clear();
-                var mouseScreenPos = _inputManager.MouseScreenPosition;
-                var mouseWorldPos = _eyeManager.ScreenToMap(mouseScreenPos).Position;
-                _hoverStartScreen = mouseScreenPos;
-
-                var viewport = _eyeManager.GetWorldViewport();
-
-                if (viewport.IsEmpty()) return;
-
-                var mapId = _eyeManager.CurrentMap;
-
-                foreach (var physBody in EntitySystem.Get<SharedBroadPhaseSystem>().GetCollidingEntities(mapId, viewport))
-                {
-                    // all entities have a TransformComponent
-                    var transform = physBody.Entity.Transform;
-
-                    var worldBox = physBody.GetWorldAABB();
-                    if (worldBox.IsEmpty()) continue;
-
-                    var colorEdge = Color.Red.WithAlpha(0.33f);
-                    var sleepThreshold = IoCManager.Resolve<IConfigurationManager>().GetCVar(CVars.TimeToSleep);
-
-                    foreach (var fixture in physBody.Fixtures)
-                    {
-                        var shape = fixture.Shape;
-                        var sleepPercent = physBody.Awake ? physBody.SleepTime / sleepThreshold : 1.0f;
-                        shape.DebugDraw(drawing, transform.WorldMatrix, in viewport,  sleepPercent);
-                    }
-
-                    if (worldBox.Contains(mouseWorldPos))
-                    {
-                        _hoverBodies.Add(physBody);
-                    }
-
-                    // draw AABB
-                    worldHandle.DrawRect(worldBox, colorEdge, false);
-                }
-            }
-
-            private static void DrawString(DrawingHandleScreen handle, Font font, Vector2 pos, string str)
-            {
-                var baseLine = new Vector2(pos.X, font.GetAscent(1) + pos.Y);
-
-                foreach (var chr in str)
-                {
-                    var advance = font.DrawChar(handle, chr, baseLine, 1, Color.White);
-                    baseLine += new Vector2(advance, 0);
-                }
-            }
-
-            private class PhysDrawingAdapter : DebugDrawingHandle
-            {
-                private readonly DrawingHandleWorld _handle;
-
-                public PhysDrawingAdapter(DrawingHandleWorld worldHandle)
-                {
-                    _handle = worldHandle;
-                }
-
-                public override Color WakeMixColor => Color.White;
-                public override Color GridFillColor => Color.Blue.WithAlpha(0.05f);
-                public override Color RectFillColor => Color.Green.WithAlpha(0.25f);
-
-                public override Color CalcWakeColor(Color color, float wakePercent)
-                {
-                    var percent = MathHelper.Clamp(wakePercent, 0, 1);
-
-                    var r = 1 - (percent * (1 - color.R));
-                    var g = 1 - (percent * (1 - color.G));
-                    var b = 1 - (percent * (1 - color.B));
-
-                    return new Color(r, g, b, color.A);
-                }
-
-                public override void DrawRect(in Box2 box, in Color color)
-                {
-                    _handle.DrawRect(box, color);
-                }
-
-                public override void DrawRect(in Box2Rotated box, in Color color)
-                {
-                    _handle.DrawRect(box, color);
-                }
-
-                public override void DrawCircle(Vector2 origin, float radius, in Color color)
-                {
-                    _handle.DrawCircle(origin, radius, color);
-                }
-
-                public override void DrawPolygonShape(Vector2[] vertices, in Color color)
-                {
-                    _handle.DrawPrimitives(DrawPrimitiveTopology.TriangleFan, vertices, color);
-                }
-
-                public override void DrawLine(Vector2 start, Vector2 end, in Color color)
-                {
-                    _handle.DrawLine(start, end, color);
-                }
-
-                public override void SetTransform(in Matrix3 transform)
-                {
-                    _handle.SetTransform(transform);
-                }
-
-
-            }
-        }
-
         private sealed class EntityPositionOverlay : Overlay
         {
-            private readonly IEntityManager _entityManager;
+            private readonly IEntityLookup _lookup;
             private readonly IEyeManager _eyeManager;
 
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public EntityPositionOverlay(IEntityManager entityManager, IEyeManager eyeManager) : base(nameof(EntityPositionOverlay))
+            public EntityPositionOverlay(IEntityLookup lookup, IEyeManager eyeManager)
             {
-                _entityManager = entityManager;
+                _lookup = lookup;
                 _eyeManager = eyeManager;
             }
 
-            protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+            protected internal override void Draw(in OverlayDrawArgs args)
             {
                 const float stubLength = 0.25f;
 
-                var worldHandle = (DrawingHandleWorld) handle;
-                foreach (var entity in _entityManager.GetEntities())
+                var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
+                var viewport = _eyeManager.GetWorldViewport();
+
+                foreach (var entity in _lookup.GetEntitiesIntersecting(_eyeManager.CurrentMap, viewport))
                 {
                     var transform = entity.Transform;
-                    if (transform.MapID != _eyeManager.CurrentMap ||
-                        !_eyeManager.GetWorldViewport().Contains(transform.WorldPosition))
-                    {
-                        continue;
-                    }
 
                     var center = transform.WorldPosition;
-                    var xLine = transform.WorldRotation.RotateVec(Vector2.UnitX);
-                    var yLine = transform.WorldRotation.RotateVec(Vector2.UnitY);
+                    var worldRotation = transform.WorldRotation;
+
+                    var xLine = worldRotation.RotateVec(Vector2.UnitX);
+                    var yLine = worldRotation.RotateVec(Vector2.UnitY);
 
                     worldHandle.DrawLine(center, center + xLine * stubLength, Color.Red);
                     worldHandle.DrawLine(center, center + yLine * stubLength, Color.Green);

Robust.Client/Debugging/DebugDrawingManager.cs

@@ -1,11 +1,12 @@
-using Robust.Shared.IoC;
-using Robust.Shared.Network.Messages;
 using System;
 using System.Collections.Generic;
 using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.IoC;
 using Robust.Shared.Maths;
-using Robust.Shared.Timing;
 using Robust.Shared.Network;
+using Robust.Shared.Network.Messages;
+using Robust.Shared.Timing;
 
 namespace Robust.Client.Debugging
 {
@@ -38,13 +39,13 @@ namespace Robust.Client.Debugging
 
                 _debugDrawRays = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<DebugDrawRayOverlay>())
                 {
                     _overlayManager.AddOverlay(new DebugDrawRayOverlay(this));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(DebugDrawRayOverlay));
+                    _overlayManager.RemoveOverlay<DebugDrawRayOverlay>();
                 }
             }
         }
@@ -53,7 +54,7 @@ namespace Robust.Client.Debugging
 
         public void Initialize()
         {
-            _net.RegisterNetMessage<MsgRay>(MsgRay.NAME, HandleDrawRay);
+            _net.RegisterNetMessage<MsgRay>(HandleDrawRay);
         }
 
         private void HandleDrawRay(MsgRay msg)
@@ -81,13 +82,14 @@ namespace Robust.Client.Debugging
             private readonly DebugDrawingManager _owner;
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public DebugDrawRayOverlay(DebugDrawingManager owner) : base(nameof(DebugDrawRayOverlay))
+            public DebugDrawRayOverlay(DebugDrawingManager owner)
             {
                 _owner = owner;
             }
 
-            protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+            protected internal override void Draw(in OverlayDrawArgs args)
             {
+                var handle = args.WorldHandle;
                 foreach (var ray in _owner.raysWithLifeTime)
                 {
                     handle.DrawLine(

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -20,29 +20,60 @@
 * 3. This notice may not be removed or altered from any source distribution.
 */
 
+// MIT License
+
+// Copyright (c) 2019 Erin Catto
+
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
 /* Heavily inspired by Farseer */
 
 using System;
+using System.Collections.Generic;
 using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
+using Robust.Shared.Physics;
 using Robust.Shared.Physics.Collision;
+using Robust.Shared.Physics.Collision.Shapes;
 using Robust.Shared.Physics.Dynamics;
 using Robust.Shared.Physics.Dynamics.Contacts;
+using Robust.Shared.Physics.Dynamics.Joints;
 
 namespace Robust.Client.Debugging
 {
-    internal sealed class DebugPhysicsSystem : SharedDebugPhysicsSystem
+    public sealed class DebugPhysicsSystem : SharedDebugPhysicsSystem
     {
         /*
          * Used for debugging shapes, controllers, joints, contacts
          */
 
+        [Dependency] private readonly IPhysicsManager _physicsManager = default!;
+
         private const int MaxContactPoints = 2048;
         internal int PointCount;
 
-        internal ContactPoint[] _points = new ContactPoint[MaxContactPoints];
+        internal ContactPoint[] Points = new ContactPoint[MaxContactPoints];
 
         public PhysicsDebugFlags Flags
         {
@@ -52,10 +83,17 @@ namespace Robust.Client.Debugging
                 if (value == _flags) return;
 
                 if (_flags == PhysicsDebugFlags.None)
-                    IoCManager.Resolve<IOverlayManager>().AddOverlay(new PhysicsDebugOverlay(this));
+                    IoCManager.Resolve<IOverlayManager>().AddOverlay(
+                        new PhysicsDebugOverlay(
+                            EntityManager,
+                            IoCManager.Resolve<IEyeManager>(),
+                            IoCManager.Resolve<IInputManager>(),
+                            IoCManager.Resolve<IResourceCache>(),
+                            this,
+                            Get<SharedBroadphaseSystem>()));
 
                 if (value == PhysicsDebugFlags.None)
-                    IoCManager.Resolve<IOverlayManager>().RemoveOverlay(nameof(PhysicsDebugOverlay));
+                    IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsDebugOverlay));
 
                 _flags = value;
             }
@@ -65,7 +103,7 @@ namespace Robust.Client.Debugging
 
         public override void HandlePreSolve(Contact contact, in Manifold oldManifold)
         {
-            if ((Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            if ((Flags & (PhysicsDebugFlags.ContactPoints | PhysicsDebugFlags.ContactNormals)) != 0)
             {
                 Manifold manifold = contact.Manifold;
 
@@ -74,23 +112,24 @@ namespace Robust.Client.Debugging
 
                 Fixture fixtureA = contact.FixtureA!;
 
-                PointState[] state1, state2;
-                CollisionManager.GetPointStates(out state1, out state2, oldManifold, manifold);
+                var state1 = new PointState[2];
+                var state2 = new PointState[2];
+
+                CollisionManager.GetPointStates(ref state1, ref state2, oldManifold, manifold);
 
                 Span<Vector2> points = stackalloc Vector2[2];
-                Vector2 normal;
-                contact.GetWorldManifold(out normal, points);
+                contact.GetWorldManifold(_physicsManager, out var normal, points);
 
-                for (int i = 0; i < manifold.PointCount && PointCount < MaxContactPoints; ++i)
+                ContactPoint cp = Points[PointCount];
+                for (var i = 0; i < manifold.PointCount && PointCount < MaxContactPoints; ++i)
                 {
                     if (fixtureA == null)
-                        _points[i] = new ContactPoint();
+                        Points[i] = new ContactPoint();
 
-                    ContactPoint cp = _points[PointCount];
                     cp.Position = points[i];
                     cp.Normal = normal;
                     cp.State = state2[i];
-                    _points[PointCount] = cp;
+                    Points[PointCount] = cp;
                     ++PointCount;
                 }
             }
@@ -105,59 +144,262 @@ namespace Robust.Client.Debugging
     }
 
     [Flags]
-    internal enum PhysicsDebugFlags : byte
+    public enum PhysicsDebugFlags : byte
     {
         None = 0,
+        /// <summary>
+        /// Shows the world point for each contact in the viewport.
+        /// </summary>
         ContactPoints = 1 << 0,
+        /// <summary>
+        /// Shows the world normal for each contact in the viewport.
+        /// </summary>
         ContactNormals = 1 << 1,
+        /// <summary>
+        /// Shows all physics shapes in the viewport.
+        /// </summary>
         Shapes = 1 << 2,
+        ShapeInfo = 1 << 3,
+        Joints = 1 << 4,
     }
 
     internal sealed class PhysicsDebugOverlay : Overlay
     {
+        private IEntityManager _entityManager = default!;
+        private IEyeManager _eyeManager = default!;
+        private IInputManager _inputManager = default!;
         private DebugPhysicsSystem _physics = default!;
+        private SharedBroadphaseSystem _broadphaseSystem = default!;
 
-        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+        public override OverlaySpace Space => OverlaySpace.WorldSpace | OverlaySpace.ScreenSpace;
 
-        public PhysicsDebugOverlay(DebugPhysicsSystem system) : base(nameof(PhysicsDebugOverlay))
+        private static readonly Color JointColor = new(0.5f, 0.8f, 0.8f);
+
+        private readonly Font _font;
+
+        private HashSet<Joint> _drawnJoints = new();
+
+        public PhysicsDebugOverlay(IEntityManager entityManager, IEyeManager eyeManager, IInputManager inputManager, IResourceCache cache, DebugPhysicsSystem system, SharedBroadphaseSystem broadphaseSystem)
         {
+            _entityManager = entityManager;
+            _eyeManager = eyeManager;
+            _inputManager = inputManager;
             _physics = system;
+            _broadphaseSystem = broadphaseSystem;
+            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
         }
 
-        protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+        private void DrawWorld(DrawingHandleWorld worldHandle)
         {
-            if (_physics.Flags == PhysicsDebugFlags.None) return;
+            var viewport = _eyeManager.GetWorldViewport();
+            var viewBounds = _eyeManager.GetWorldViewbounds();
+            var mapId = _eyeManager.CurrentMap;
 
-            var worldHandle = (DrawingHandleWorld) handle;
-
-            if ((_physics.Flags & PhysicsDebugFlags.Shapes) != 0)
+            if ((_physics.Flags & PhysicsDebugFlags.Shapes) != 0 && !viewport.IsEmpty())
             {
-                // Port DebugDrawing over.
+                foreach (var physBody in _broadphaseSystem.GetCollidingEntities(mapId, viewBounds))
+                {
+                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+
+                    var xform = physBody.GetTransform();
+
+                    const float AlphaModifier = 0.2f;
+
+                    foreach (var fixture in physBody.Fixtures)
+                    {
+                        // Invalid shape - Box2D doesn't check for IsSensor
+                        if (physBody.BodyType == BodyType.Dynamic && fixture.Mass == 0f)
+                        {
+                            DrawShape(worldHandle, fixture, xform, Color.Red.WithAlpha(AlphaModifier));
+                        }
+                        else if (!physBody.CanCollide)
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.5f, 0.3f).WithAlpha(AlphaModifier));
+                        }
+                        else if (physBody.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)
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.5f, 0.5f, 0.9f).WithAlpha(AlphaModifier));
+                        }
+                        else if (!physBody.Awake)
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.6f, 0.6f, 0.6f).WithAlpha(AlphaModifier));
+                        }
+                        else
+                        {
+                            DrawShape(worldHandle, fixture, xform, new Color(0.9f, 0.7f, 0.7f).WithAlpha(AlphaModifier));
+                        }
+                    }
+                }
             }
 
-            if ((_physics.Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            if ((_physics.Flags & PhysicsDebugFlags.Joints) != 0x0)
+            {
+                _drawnJoints.Clear();
+
+                foreach (var jointComponent in _entityManager.EntityQuery<JointComponent>(true))
+                {
+                    if (jointComponent.JointCount == 0 ||
+                        !_entityManager.TryGetComponent(jointComponent.Owner.Uid, out TransformComponent? xf1) ||
+                        !viewport.Contains(xf1.WorldPosition)) continue;
+
+                    foreach (var (_, joint) in jointComponent.Joints)
+                    {
+                        if (_drawnJoints.Contains(joint)) continue;
+                        DrawJoint(worldHandle, joint);
+                        _drawnJoints.Add(joint);
+                    }
+                }
+            }
+
+            if ((_physics.Flags & (PhysicsDebugFlags.ContactPoints | PhysicsDebugFlags.ContactNormals)) != 0)
             {
                 const float axisScale = 0.3f;
 
-                for (int i = 0; i < _physics.PointCount; ++i)
+                for (var i = 0; i < _physics.PointCount; ++i)
                 {
-                    DebugPhysicsSystem.ContactPoint point = _physics._points[i];
+                    var point = _physics.Points[i];
 
-                    if (point.State == PointState.Add)
-                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 243, 77));
-                    else if (point.State == PointState.Persist)
-                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 77, 77));
+                    const float radius = 0.1f;
+
+                    if ((_physics.Flags & PhysicsDebugFlags.ContactPoints) != 0)
+                    {
+                        if (point.State == PointState.Add)
+                            worldHandle.DrawCircle(point.Position, radius, new Color(255, 77, 243, 255));
+                        else if (point.State == PointState.Persist)
+                            worldHandle.DrawCircle(point.Position, radius, new Color(255, 77, 77, 255));
+                    }
 
                     if ((_physics.Flags & PhysicsDebugFlags.ContactNormals) != 0)
                     {
                         Vector2 p1 = point.Position;
                         Vector2 p2 = p1 + point.Normal * axisScale;
-                        worldHandle.DrawLine(p1, p2, new Color(255, 102, 230, 102));
+                        worldHandle.DrawLine(p1, p2, new Color(255, 102, 230, 255));
                     }
                 }
 
                 _physics.PointCount = 0;
             }
         }
+
+        private void DrawScreen(DrawingHandleScreen screenHandle)
+        {
+            var mapId = _eyeManager.CurrentMap;
+            var mousePos = _inputManager.MouseScreenPosition;
+
+            if ((_physics.Flags & PhysicsDebugFlags.ShapeInfo) != 0x0)
+            {
+                var hoverBodies = new List<PhysicsComponent>();
+                var bounds = Box2.UnitCentered.Translated(_eyeManager.ScreenToMap(mousePos.Position).Position);
+
+                foreach (var physBody in _broadphaseSystem.GetCollidingEntities(mapId, bounds))
+                {
+                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+                    hoverBodies.Add(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)
+                {
+                    if (body != hoverBodies[0])
+                    {
+                        screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), "------");
+                        row++;
+                    }
+
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Ent: {body.Owner}");
+                    row++;
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Layer: {Convert.ToString(body.CollisionLayer, 2)}");
+                    row++;
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Mask: {Convert.ToString(body.CollisionMask, 2)}");
+                    row++;
+                    screenHandle.DrawString(_font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {(body).BodyType == BodyType.Static}");
+                    row++;
+                }
+            }
+        }
+
+        protected internal override void Draw(in OverlayDrawArgs args)
+        {
+            if (_physics.Flags == PhysicsDebugFlags.None) return;
+
+            switch (args.Space)
+            {
+                case OverlaySpace.ScreenSpace:
+                    DrawScreen((DrawingHandleScreen) args.DrawingHandle);
+                    break;
+                case OverlaySpace.WorldSpace:
+                    DrawWorld((DrawingHandleWorld) args.DrawingHandle);
+                    break;
+            }
+        }
+
+        private void DrawShape(DrawingHandleWorld worldHandle, Fixture fixture, Transform xform, Color color)
+        {
+            switch (fixture.Shape)
+            {
+                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);
+
+                    if (edge.OneSided)
+                    {
+                        worldHandle.DrawCircle(v1, 0.5f, color);
+                        worldHandle.DrawCircle(v2, 0.5f, color);
+                    }
+
+                    break;
+                case PolygonShape poly:
+                    Span<Vector2> verts = stackalloc Vector2[poly.Vertices.Length];
+
+                    for (var i = 0; i < verts.Length; i++)
+                    {
+                        verts[i] = Transform.Mul(xform, poly.Vertices[i]);
+                    }
+
+                    worldHandle.DrawPrimitives(DrawPrimitiveTopology.TriangleFan, verts, color);
+                    break;
+                default:
+                    return;
+            }
+        }
+
+        private void DrawJoint(DrawingHandleWorld worldHandle, Joint joint)
+        {
+            if (!_entityManager.TryGetComponent(joint.BodyAUid, out TransformComponent? xform1) ||
+                !_entityManager.TryGetComponent(joint.BodyBUid, out TransformComponent? xform2)) return;
+
+            var matrix1 = xform1.WorldMatrix;
+            var matrix2 = xform2.WorldMatrix;
+
+            var xf1 = new Vector2(matrix1.R0C2, matrix1.R1C2);
+            var xf2 = new Vector2(matrix2.R0C2, matrix2.R1C2);
+
+            var p1 = matrix1.Transform(joint.LocalAnchorA);
+            var p2 = matrix2.Transform(joint.LocalAnchorB);
+
+            switch (joint)
+            {
+                case DistanceJoint:
+                    worldHandle.DrawLine(xf1, xf2, JointColor);
+                    break;
+                default:
+                    worldHandle.DrawLine(xf1, p1, JointColor);
+                    worldHandle.DrawLine(p1, p2, JointColor);
+                    worldHandle.DrawLine(xf2, p2, JointColor);
+                    break;
+            }
+        }
     }
 }

Robust.Client/Debugging/IDebugDrawing.cs

@@ -5,11 +5,6 @@
     /// </summary>
     public interface IDebugDrawing
     {
-        /// <summary>
-        /// Toggles the visual overlay of physics bodies for each entity on screen.
-        /// </summary>
-        bool DebugColliders { get; set; }
-
         /// <summary>
         /// Toggles the visual overlay of the local origin for each entity on screen.
         /// </summary>

Robust.Client/GameController/GameController.Loader.cs

@@ -11,7 +11,7 @@ namespace Robust.Client
         {
             public void Main(IMainArgs args)
             {
-                Start(args.Args, contentStart: false, args);
+                Start(args.Args, new GameControllerOptions(), contentStart: false, args);
             }
         }
     }

Robust.Client/GameController/GameController.Standalone.cs

@@ -1,25 +1,31 @@
 using System;
+using System.Threading;
 using Robust.LoaderApi;
+using Robust.Shared;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 
 namespace Robust.Client
 {
     internal partial class GameController
     {
-        private IGameLoop _mainLoop = default!;
+        private IGameLoop? _mainLoop;
 
         [Dependency] private readonly IGameTiming _gameTiming = default!;
+        [Dependency] private readonly IDependencyCollection _dependencyCollection = default!;
 
         private static bool _hasStarted;
 
+        private Thread? _gameThread;
+
         public static void Main(string[] args)
         {
-            Start(args);
+            Start(args, new GameControllerOptions());
         }
 
-        public static void Start(string[] args, bool contentStart = false, IMainArgs? loaderArgs=null)
+        public static void Start(string[] args, GameControllerOptions options, bool contentStart = false, IMainArgs? loaderArgs=null)
         {
             if (_hasStarted)
             {
@@ -30,11 +36,11 @@ namespace Robust.Client
 
             if (CommandLineArgs.TryParse(args, out var parsed))
             {
-                ParsedMain(parsed, contentStart, loaderArgs);
+                ParsedMain(parsed, contentStart, loaderArgs, options);
             }
         }
 
-        private static void ParsedMain(CommandLineArgs args, bool contentStart, IMainArgs? loaderArgs)
+        private static void ParsedMain(CommandLineArgs args, bool contentStart, IMainArgs? loaderArgs, GameControllerOptions options)
         {
             IoCManager.InitThread();
 
@@ -42,23 +48,16 @@ namespace Robust.Client
 
             InitIoC(mode);
 
-            var gc = (GameController) IoCManager.Resolve<IGameController>();
+            var gc = IoCManager.Resolve<GameController>();
             gc.SetCommandLineArgs(args);
             gc._loaderArgs = loaderArgs;
 
             // When the game is ran with the startup executable being content,
             // we have to disable the separate load context.
             // Otherwise the content assemblies will be loaded twice which causes *many* fun bugs.
-            gc._disableAssemblyLoadContext = contentStart;
-            if (!gc.Startup())
-            {
-                Logger.Fatal("Failed to start game controller!");
-                return;
-            }
-            gc.MainLoop(mode);
+            gc.ContentStart = contentStart;
 
-            Logger.Debug("Goodbye");
-            IoCManager.Clear();
+            gc.Run(mode, options);
         }
 
         public void OverrideMainLoop(IGameLoop gameLoop)
@@ -66,52 +65,68 @@ namespace Robust.Client
             _mainLoop = gameLoop;
         }
 
-        public void MainLoop(DisplayMode mode)
+        public void Run(DisplayMode mode, GameControllerOptions options, Func<ILogHandler>? logHandlerFactory = null)
         {
-            if (_mainLoop == null)
+            if (!StartupSystemSplash(options, logHandlerFactory))
             {
-                _mainLoop = new GameLoop(_gameTiming)
-                {
-                    SleepMode = mode == DisplayMode.Headless ? SleepMode.Delay : SleepMode.None
-                };
+                Logger.Fatal("Failed to start game controller!");
+                return;
             }
 
-            _mainLoop.Tick += (sender, args) =>
+            if (_clyde.SeparateWindowThread)
             {
-                if (_mainLoop.Running)
-                {
-                    Tick(args);
-                }
-            };
+                var stackSize = _configurationManager.GetCVar(CVars.SysGameThreadStackSize);
+                var priority = (ThreadPriority) _configurationManager.GetCVar(CVars.SysGameThreadPriority);
 
-            _mainLoop.Render += (sender, args) =>
-            {
-                if (_mainLoop.Running)
+                _gameThread = new Thread(() => GameThreadMain(mode), stackSize)
                 {
-                    _gameTiming.CurFrame++;
-                    _clyde.Render();
-                }
-            };
-            _mainLoop.Input += (sender, args) =>
-            {
-                if (_mainLoop.Running)
-                {
-                    Input(args);
-                }
-            };
+                    IsBackground = false,
+                    Priority = priority,
+                    Name = "Game thread",
+                };
 
-            _mainLoop.Update += (sender, args) =>
-            {
-                if (_mainLoop.Running)
-                {
-                    Update(args);
-                }
-            };
+                _gameThread.Start();
 
-            // set GameLoop.Running to false to return from this function.
-            _mainLoop.Run();
+                // Will block until game exit
+                _clyde.EnterWindowLoop();
+
+                if (_gameThread.IsAlive)
+                {
+                    Logger.Debug("Window loop exited; waiting for game thread to exit");
+                    _gameThread.Join();
+                }
+            }
+            else
+            {
+                ContinueStartupAndLoop(mode);
+            }
 
             Cleanup();
+
+            Logger.Debug("Goodbye");
+            IoCManager.Clear();
+        }
+
+        private void GameThreadMain(DisplayMode mode)
+        {
+            IoCManager.InitThread(_dependencyCollection);
+
+            ContinueStartupAndLoop(mode);
+
+            // Game thread exited, make sure window thread unblocks to finish shutdown.
+            _clyde.TerminateWindowLoop();
+        }
+
+        private void ContinueStartupAndLoop(DisplayMode mode)
+        {
+            if (!StartupContinue(mode))
+            {
+                Logger.Fatal("Failed to start game controller!");
+                return;
+            }
+
+            DebugTools.AssertNotNull(_mainLoop);
+            _mainLoop!.Run();
         }
     }
 }

Robust.Client/GameController/GameController.cs

@@ -1,6 +1,8 @@
-using System;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Net;
+using System.Runtime;
 using System.Threading.Tasks;
 using Robust.Client.Audio.Midi;
 using Robust.Client.Console;
@@ -48,6 +50,7 @@ namespace Robust.Client
         [Dependency] private readonly IClientConsoleHost _console = default!;
         [Dependency] private readonly ITimerManager _timerManager = default!;
         [Dependency] private readonly IClientEntityManager _entityManager = default!;
+        [Dependency] private readonly IEntityLookup _lookup = default!;
         [Dependency] private readonly IPlacementManager _placementManager = default!;
         [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
         [Dependency] private readonly IOverlayManagerInternal _overlayManager = default!;
@@ -59,92 +62,39 @@ namespace Robust.Client
         [Dependency] private readonly IFontManagerInternal _fontManager = default!;
         [Dependency] private readonly IModLoaderInternal _modLoader = default!;
         [Dependency] private readonly IScriptClient _scriptClient = default!;
-        [Dependency] private readonly IComponentManager _componentManager = default!;
-        [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IRobustMappedStringSerializer _stringSerializer = default!;
         [Dependency] private readonly IAuthManager _authManager = default!;
         [Dependency] private readonly IMidiManager _midiManager = default!;
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
 
         private CommandLineArgs? _commandLineArgs;
-        private bool _disableAssemblyLoadContext;
+
         // Arguments for loader-load. Not used otherwise.
         private IMainArgs? _loaderArgs;
 
+        public bool ContentStart { get; set; } = false;
+        public GameControllerOptions Options { get; private set; } = new();
         public InitialLaunchState LaunchState { get; private set; } = default!;
 
-        public bool LoadConfigAndUserData { get; set; } = true;
-
         public void SetCommandLineArgs(CommandLineArgs args)
         {
             _commandLineArgs = args;
         }
 
-        public bool Startup(Func<ILogHandler>? logHandlerFactory = null)
+        internal bool StartupContinue(DisplayMode displayMode)
         {
-            ReadInitialLaunchState();
-
-            SetupLogging(_logManager, logHandlerFactory ?? (() => new ConsoleLogHandler()));
+            _clyde.InitializePostWindowing();
+            _clyde.SetWindowTitle(Options.DefaultWindowTitle);
 
             _taskManager.Initialize();
-
-            // Figure out user data directory.
-            var userDataDir = GetUserDataDir();
-
-            _configurationManager.Initialize(false);
-
-            // MUST load cvars before loading from config file so the cfg manager is aware of secure cvars.
-            // So SECURE CVars are blacklisted from config.
-            _configurationManager.LoadCVarsFromAssembly(typeof(GameController).Assembly); // Client
-            _configurationManager.LoadCVarsFromAssembly(typeof(IConfigurationManager).Assembly); // Shared
-
-            if (LoadConfigAndUserData)
-            {
-                var configFile = Path.Combine(userDataDir, "client_config.toml");
-                if (File.Exists(configFile))
-                {
-                    // Load config from user data if available.
-                    _configurationManager.LoadFromFile(configFile);
-                }
-                else
-                {
-                    // Else we just use code-defined defaults and let it save to file when the user changes things.
-                    _configurationManager.SetSaveFile(configFile);
-                }
-            }
-
-            _configurationManager.OverrideConVars(EnvironmentVariables.GetEnvironmentCVars());
-
-            if (_commandLineArgs != null)
-            {
-                _configurationManager.OverrideConVars(_commandLineArgs.CVars);
-            }
-
-            _resourceCache.Initialize(LoadConfigAndUserData ? userDataDir : null);
-
-            ProgramShared.DoMounts(_resourceCache, _commandLineArgs?.MountOptions, "Content.Client", _loaderArgs != null);
-            if (_loaderArgs != null)
-            {
-                _stringSerializer.EnableCaching = false;
-                _resourceCache.MountLoaderApi(_loaderArgs.FileApi, "Resources/");
-                _modLoader.VerifierExtraLoadHandler = VerifierExtraLoadHandler;
-            }
-
-            // Bring display up as soon as resources are mounted.
-            if (!_clyde.Initialize())
-            {
-                return false;
-            }
-
-            _clyde.SetWindowTitle("Space Station 14");
-
-            _fontManager.Initialize();
+            _fontManager.SetFontDpi((uint) _configurationManager.GetCVar(CVars.DisplayFontDpi));
 
             // Disable load context usage on content start.
             // This prevents Content.Client being loaded twice and things like csi blowing up because of it.
-            _modLoader.SetUseLoadContext(!_disableAssemblyLoadContext);
-            _modLoader.SetEnableSandboxing(true);
+            _modLoader.SetUseLoadContext(!ContentStart);
+            _modLoader.SetEnableSandboxing(Options.Sandboxing);
 
-            if (!_modLoader.TryLoadModulesFrom(new ResourcePath("/Assemblies/"), "Content."))
+            if (!_modLoader.TryLoadModulesFrom(Options.AssemblyDirectory, Options.ContentModulePrefix))
             {
                 Logger.Fatal("Errors while loading content assemblies.");
                 return false;
@@ -161,14 +111,16 @@ namespace Robust.Client
             _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
             _modLoader.BroadcastRunLevel(ModRunLevel.Init);
 
+            _resourceCache.PreloadTextures();
             _userInterfaceManager.Initialize();
+            _eyeManager.Initialize();
             _networkManager.Initialize(false);
             IoCManager.Resolve<INetConfigurationManager>().SetupNetworking();
             _serializer.Initialize();
             _inputManager.Initialize();
             _console.Initialize();
             _prototypeManager.Initialize();
-            _prototypeManager.LoadDirectory(new ResourcePath(@"/Prototypes/"));
+            _prototypeManager.LoadDirectory(Options.PrototypeDirectory);
             _prototypeManager.Resync();
             _mapManager.Initialize();
             _entityManager.Initialize();
@@ -188,9 +140,54 @@ namespace Robust.Client
 
             _authManager.LoadFromEnv();
 
+            GCSettings.LargeObjectHeapCompactionMode = GCLargeObjectHeapCompactionMode.CompactOnce;
+            GC.Collect();
+
+            // Setup main loop
+            if (_mainLoop == null)
+            {
+                _mainLoop = new GameLoop(_gameTiming)
+                {
+                    SleepMode = displayMode == DisplayMode.Headless ? SleepMode.Delay : SleepMode.None
+                };
+            }
+
+            _mainLoop.Tick += (sender, args) =>
+            {
+                if (_mainLoop.Running)
+                {
+                    Tick(args);
+                }
+            };
+
+            _mainLoop.Render += (sender, args) =>
+            {
+                if (_mainLoop.Running)
+                {
+                    _gameTiming.CurFrame++;
+                    _clyde.Render();
+                }
+            };
+            _mainLoop.Input += (sender, args) =>
+            {
+                if (_mainLoop.Running)
+                {
+                    Input(args);
+                }
+            };
+
+            _mainLoop.Update += (sender, args) =>
+            {
+                if (_mainLoop.Running)
+                {
+                    Update(args);
+                }
+            };
+
             _clyde.Ready();
 
-            if ((_commandLineArgs?.Connect == true || _commandLineArgs?.Launcher == true)
+            if (!Options.DisableCommandLineConnect &&
+                (_commandLineArgs?.Connect == true || _commandLineArgs?.Launcher == true)
                 && LaunchState.ConnectEndpoint != null)
             {
                 _client.ConnectToServer(LaunchState.ConnectEndpoint);
@@ -199,6 +196,110 @@ namespace Robust.Client
             return true;
         }
 
+        internal bool StartupSystemSplash(GameControllerOptions options, Func<ILogHandler>? logHandlerFactory)
+        {
+            Options = options;
+            ReadInitialLaunchState();
+
+            SetupLogging(_logManager, logHandlerFactory ?? (() => new ConsoleLogHandler()));
+
+            if (_commandLineArgs != null)
+            {
+                foreach (var (sawmill, level) in _commandLineArgs.LogLevels)
+                {
+                    LogLevel? logLevel;
+                    if (level == "null")
+                        logLevel = null;
+                    else
+                    {
+                        if (!Enum.TryParse<LogLevel>(level, out var result))
+                        {
+                            System.Console.WriteLine($"LogLevel {level} does not exist!");
+                            continue;
+                        }
+                        logLevel = result;
+                    }
+                    _logManager.GetSawmill(sawmill).Level = logLevel;
+                }
+            }
+
+            ProgramShared.PrintRuntimeInfo(_logManager.RootSawmill);
+
+            // Figure out user data directory.
+            var userDataDir = GetUserDataDir();
+
+            _configurationManager.Initialize(false);
+
+            // MUST load cvars before loading from config file so the cfg manager is aware of secure cvars.
+            // So SECURE CVars are blacklisted from config.
+            _configurationManager.LoadCVarsFromAssembly(typeof(GameController).Assembly); // Client
+            _configurationManager.LoadCVarsFromAssembly(typeof(IConfigurationManager).Assembly); // Shared
+
+            if (Options.LoadConfigAndUserData)
+            {
+                var configFile = Path.Combine(userDataDir, Options.ConfigFileName);
+                if (File.Exists(configFile))
+                {
+                    // Load config from user data if available.
+                    _configurationManager.LoadFromFile(configFile);
+                }
+                else
+                {
+                    // Else we just use code-defined defaults and let it save to file when the user changes things.
+                    _configurationManager.SetSaveFile(configFile);
+                }
+            }
+
+            _configurationManager.OverrideConVars(EnvironmentVariables.GetEnvironmentCVars());
+
+            if (_commandLineArgs != null)
+            {
+                _configurationManager.OverrideConVars(_commandLineArgs.CVars);
+            }
+
+            {
+                // Handle GameControllerOptions implicit CVar overrides.
+                _configurationManager.OverrideConVars(new []
+                {
+                    (CVars.DisplayWindowIconSet.Name, options.WindowIconSet.ToString()),
+                    (CVars.DisplaySplashLogo.Name, options.SplashLogo.ToString())
+                });
+            }
+
+            ProfileOptSetup.Setup(_configurationManager);
+
+            _resourceCache.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
+
+            var mountOptions = _commandLineArgs != null
+                ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions) : Options.MountOptions;
+
+            ProgramShared.DoMounts(_resourceCache, mountOptions, Options.ContentBuildDirectory, Options.AssemblyDirectory,
+                Options.LoadContentResources, _loaderArgs != null && !Options.ResourceMountDisabled, ContentStart);
+
+            if (_loaderArgs != null)
+            {
+                _stringSerializer.EnableCaching = false;
+                _resourceCache.MountLoaderApi(_loaderArgs.FileApi, "Resources/");
+                _modLoader.VerifierExtraLoadHandler = VerifierExtraLoadHandler;
+            }
+
+            _clyde.TextEntered += TextEntered;
+            _clyde.MouseMove += MouseMove;
+            _clyde.KeyUp += KeyUp;
+            _clyde.KeyDown += KeyDown;
+            _clyde.MouseWheel += MouseWheel;
+            _clyde.CloseWindow += args =>
+            {
+                if (args.Window == _clyde.MainWindow)
+                {
+                    Shutdown("Main window closed");
+                }
+            };
+
+            // Bring display up as soon as resources are mounted.
+            return _clyde.InitializePreWindowing();
+        }
+
         private Stream? VerifierExtraLoadHandler(string arg)
         {
             DebugTools.AssertNotNull(_loaderArgs);
@@ -242,8 +343,10 @@ namespace Robust.Client
 
         public void Shutdown(string? reason = null)
         {
+            DebugTools.AssertNotNull(_mainLoop);
+
             // Already got shut down I assume,
-            if (!_mainLoop.Running)
+            if (!_mainLoop!.Running)
             {
                 return;
             }
@@ -272,17 +375,20 @@ namespace Robust.Client
             _modLoader.BroadcastUpdate(ModUpdateLevel.PreEngine, frameEventArgs);
             _timerManager.UpdateTimers(frameEventArgs);
             _taskManager.ProcessPendingTasks();
-            _userInterfaceManager.Update(frameEventArgs);
 
-            if (_client.RunLevel >= ClientRunLevel.Connected)
+            // GameStateManager is in full control of the simulation update in multiplayer.
+            if (_client.RunLevel == ClientRunLevel.InGame || _client.RunLevel == ClientRunLevel.Connected)
             {
-                _componentManager.CullRemovedComponents();
                 _gameStateManager.ApplyGameState();
-                _entityManager.Update(frameEventArgs.DeltaSeconds);
-                _playerManager.Update(frameEventArgs.DeltaSeconds);
             }
 
-            _stateManager.Update(frameEventArgs);
+            // In singleplayer, however, we're in full control instead.
+            else if (_client.RunLevel == ClientRunLevel.SinglePlayerGame)
+            {
+                _entityManager.TickUpdate(frameEventArgs.DeltaSeconds);
+                _lookup.Update();
+            }
+
             _modLoader.BroadcastUpdate(ModUpdateLevel.PostEngine, frameEventArgs);
         }
 
@@ -303,11 +409,6 @@ namespace Robust.Client
             _modLoader.BroadcastUpdate(ModUpdateLevel.FramePostEngine, frameEventArgs);
         }
 
-        private void Render()
-        {
-
-        }
-
         internal static void SetupLogging(ILogManager logManager, Func<ILogHandler> logHandlerFactory)
         {
             logManager.RootSawmill.AddHandler(logHandlerFactory());
@@ -380,10 +481,13 @@ namespace Robust.Client
             Clyde,
         }
 
-        private void Cleanup()
+        internal void Cleanup()
         {
+            _modLoader.Shutdown();
+
             _networkManager.Shutdown("Client shutting down");
             _midiManager.Shutdown();
+            IoCManager.Resolve<IEntityLookup>().Shutdown();
             _entityManager.Shutdown();
             _clyde.Shutdown();
         }

Robust.Client/GameControllerOptions.cs

@@ -0,0 +1,85 @@
+using Robust.Shared;
+using Robust.Shared.Utility;
+
+namespace Robust.Client
+{
+    public class GameControllerOptions
+    {
+        /// <summary>
+        ///     Whether content sandboxing will be enabled & enforced.
+        /// </summary>
+        public bool Sandboxing { get; init; } = true;
+
+        // TODO: Expose mounting methods to games using Robust as a library.
+        /// <summary>
+        ///     Lists of mount options to mount.
+        /// </summary>
+        public MountOptions MountOptions { get; init; } = new();
+
+        /// <summary>
+        ///     Name the userdata directory will have.
+        /// </summary>
+        public string UserDataDirectoryName { get; init; } = "Space Station 14";
+
+        /// <summary>
+        ///     Name of the configuration file in the user data directory.
+        /// </summary>
+        public string ConfigFileName { get; init; } = "client_config.toml";
+
+        // TODO: Define engine branding from json file in resources.
+        /// <summary>
+        ///     Default window title.
+        /// </summary>
+        public string DefaultWindowTitle { get; init; } = "Space Station 14";
+
+        /// <summary>
+        ///     Assemblies with this prefix will be loaded.
+        /// </summary>
+        public string ContentModulePrefix { get; init; } = "Content.";
+
+        /// <summary>
+        ///     Name of the content build directory, for game pack mounting purposes.
+        /// </summary>
+        public string ContentBuildDirectory { get; init; } = "Content.Client";
+
+        /// <summary>
+        ///     Directory to load all assemblies from.
+        /// </summary>
+        public ResourcePath AssemblyDirectory { get; init; } = new(@"/Assemblies/");
+
+        /// <summary>
+        ///     Directory to load all prototypes from.
+        /// </summary>
+        public ResourcePath PrototypeDirectory { get; init; } = new(@"/Prototypes/");
+
+        /// <summary>
+        /// Directory resource path containing window icons to load.
+        /// </summary>
+        public ResourcePath WindowIconSet { get; init; } = new("/Textures/Logo/icon");
+
+        /// <summary>
+        /// Resource path for splash image to show when the game starts up.
+        /// </summary>
+        public ResourcePath SplashLogo { get; init; } = new("/Textures/Logo/logo.png");
+
+        /// <summary>
+        ///     Whether to disable mounting the "Resources/" folder on FULL_RELEASE.
+        /// </summary>
+        public bool ResourceMountDisabled { get; init; } = false;
+
+        /// <summary>
+        ///     Whether to mount content resources when not on FULL_RELEASE.
+        /// </summary>
+        public bool LoadContentResources { get; init; } = true;
+
+        /// <summary>
+        ///     Whether to load config and user data.
+        /// </summary>
+        public bool LoadConfigAndUserData { get; init; } = true;
+
+        /// <summary>
+        ///     Whether to disable command line args server auto-connecting.
+        /// </summary>
+        public bool DisableCommandLineConnect { get; init; } = false;
+    }
+}

Robust.Client/GameObjects/ClientComponentFactory.cs

@@ -1,66 +1,40 @@
+using Robust.Shared.Console;
 using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Physics;
+using Robust.Shared.IoC;
+using Robust.Shared.Reflection;
 
 namespace Robust.Client.GameObjects
 {
-    public class ClientComponentFactory : ComponentFactory
+    internal class ClientComponentFactory : ComponentFactory
     {
-        public ClientComponentFactory()
+        public ClientComponentFactory(IDynamicTypeFactoryInternal typeFactory, IReflectionManager reflectionManager, IConsoleHost conHost)
+            : base(typeFactory, reflectionManager, conHost)
         {
             // Required for the engine to work
-            Register<MetaDataComponent>();
-            RegisterReference<MetaDataComponent, IMetaDataComponent>();
-
-            // Required for the engine to work
-            Register<TransformComponent>();
-            RegisterReference<TransformComponent, ITransformComponent>();
-
-            Register<MapComponent>();
-            RegisterReference<MapComponent, IMapComponent>();
-
-            Register<MapGridComponent>();
-            RegisterReference<MapGridComponent, IMapGridComponent>();
-
-            Register<PhysicsComponent>();
-            RegisterReference<PhysicsComponent, IPhysBody>();
-
-            Register<CollisionWakeComponent>();
-
-            Register<ContainerManagerComponent>();
-            RegisterReference<ContainerManagerComponent, IContainerManager>();
-
             RegisterIgnore("KeyBindingInput");
 
-            Register<InputComponent>();
-
-            Register<SpriteComponent>();
-            RegisterReference<SpriteComponent, SharedSpriteComponent>();
-            RegisterReference<SpriteComponent, ISpriteComponent>();
-
-            Register<ClientOccluderComponent>();
-            RegisterReference<ClientOccluderComponent, OccluderComponent>();
-
-            Register<EyeComponent>();
-            RegisterReference<EyeComponent, SharedEyeComponent>();
-
-            Register<AppearanceComponent>();
-            RegisterReference<AppearanceComponent, SharedAppearanceComponent>();
-
-            Register<AppearanceTestComponent>();
-            Register<SnapGridComponent>();
-
-            Register<ClientUserInterfaceComponent>();
-            RegisterReference<ClientUserInterfaceComponent, SharedUserInterfaceComponent>();
-
-            Register<AnimationPlayerComponent>();
-
-            Register<TimerComponent>();
+            RegisterClass<MetaDataComponent>();
+            RegisterClass<TransformComponent>();
+            RegisterClass<MapComponent>();
+            RegisterClass<MapGridComponent>();
+            RegisterClass<PhysicsComponent>();
+            RegisterClass<CollisionWakeComponent>();
+            RegisterClass<ClientUserInterfaceComponent>();
+            RegisterClass<ContainerManagerComponent>();
+            RegisterClass<InputComponent>();
+            RegisterClass<SpriteComponent>();
+            RegisterClass<ClientOccluderComponent>();
+            RegisterClass<OccluderTreeComponent>();
+            RegisterClass<EyeComponent>();
+            RegisterClass<AppearanceComponent>();
+            RegisterClass<AnimationPlayerComponent>();
+            RegisterClass<TimerComponent>();
 
 #if DEBUG
-            Register<DebugExceptionOnAddComponent>();
-            Register<DebugExceptionInitializeComponent>();
-            Register<DebugExceptionStartupComponent>();
+            RegisterClass<DebugExceptionOnAddComponent>();
+            RegisterClass<DebugExceptionInitializeComponent>();
+            RegisterClass<DebugExceptionStartupComponent>();
 #endif
 
         }

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -1,11 +1,13 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using Robust.Shared.Exceptions;
+using Prometheus;
+using Robust.Client.GameStates;
+using Robust.Client.Player;
 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.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
@@ -13,303 +15,160 @@ namespace Robust.Client.GameObjects
     /// <summary>
     /// Manager for entities -- controls things like template loading and instantiation
     /// </summary>
-    public sealed class ClientEntityManager : EntityManager, IClientEntityManager
+    public sealed class ClientEntityManager : EntityManager, IClientEntityManagerInternal
     {
-        [Dependency] private readonly IMapManager _mapManager = default!;
-        [Dependency] private readonly IComponentFactory _compFactory = default!;
-#if EXCEPTION_TOLERANCE
-        [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
-#endif
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly IClientNetManager _networkManager = default!;
+        [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
+        [Dependency] private readonly IGameTiming _gameTiming = default!;
 
-        private int _nextClientEntityUid = EntityUid.ClientUid + 1;
+        protected override int NextEntityUid { get; set; } = EntityUid.ClientUid + 1;
 
-        public override void Startup()
+        public override void Initialize()
         {
-            base.Startup();
+            SetupNetworking();
+            ReceivedComponentMessage += (_, compMsg) => DispatchComponentMessage(compMsg);
+            ReceivedSystemMessage += (_, systemMsg) => EventBus.RaiseEvent(EventSource.Network, systemMsg);
 
-            if (Started)
-            {
-                throw new InvalidOperationException("Startup() called multiple times");
-            }
-
-            EntitySystemManager.Initialize();
-            Started = true;
+            base.Initialize();
         }
 
-        public List<EntityUid> ApplyEntityStates(EntityState[]? curEntStates, IEnumerable<EntityUid>? deletions,
-            EntityState[]? nextEntStates)
+        IEntity IClientEntityManagerInternal.CreateEntity(string? prototypeName, EntityUid? uid)
         {
-            var toApply = new Dictionary<IEntity, (EntityState?, EntityState?)>();
-            var toInitialize = new List<Entity>();
-            var created = new List<EntityUid>();
-            deletions ??= new EntityUid[0];
+            return base.CreateEntity(prototypeName, uid);
+        }
 
-            if (curEntStates != null && curEntStates.Length != 0)
+        void IClientEntityManagerInternal.InitializeEntity(IEntity entity)
+        {
+            base.InitializeEntity((Entity)entity);
+        }
+
+        void IClientEntityManagerInternal.StartEntity(IEntity entity)
+        {
+            base.StartEntity((Entity)entity);
+        }
+
+        #region IEntityNetworkManager impl
+
+        public override IEntityNetworkManager EntityNetManager => this;
+
+        /// <inheritdoc />
+        public event EventHandler<NetworkComponentMessage>? ReceivedComponentMessage;
+
+        /// <inheritdoc />
+        public event EventHandler<object>? ReceivedSystemMessage;
+
+        private readonly PriorityQueue<(uint seq, MsgEntity msg)> _queue = new(new MessageTickComparer());
+        private uint _incomingMsgSequence = 0;
+
+        /// <inheritdoc />
+        public void SetupNetworking()
+        {
+            _networkManager.RegisterNetMessage<MsgEntity>(HandleEntityNetworkMessage);
+        }
+
+        public override void TickUpdate(float frameTime, Histogram? histogram)
+        {
+            using (histogram?.WithLabels("EntityNet").NewTimer())
             {
-                foreach (var es in curEntStates)
+                while (_queue.Count != 0 && _queue.Peek().msg.SourceTick <= _gameStateManager.CurServerTick)
                 {
-                    //Known entities
-                    if (Entities.TryGetValue(es.Uid, out var entity))
-                    {
-                        toApply.Add(entity, (es, null));
-                    }
-                    else //Unknown entities
-                    {
-                        var metaState = (MetaDataComponentState?) es.ComponentStates
-                            ?.FirstOrDefault(c => c.NetID == NetIDs.META_DATA);
-                        if (metaState == null)
-                        {
-                            throw new InvalidOperationException($"Server sent new entity state for {es.Uid} without metadata component!");
-                        }
-                        var newEntity = CreateEntity(metaState.PrototypeId, es.Uid);
-                        toApply.Add(newEntity, (es, null));
-                        toInitialize.Add(newEntity);
-                        created.Add(newEntity.Uid);
-                    }
+                    var (_, msg) = _queue.Take();
+                    // Logger.DebugS("net.ent", "Dispatching: {0}: {1}", seq, msg);
+                    DispatchMsgEntity(msg);
                 }
             }
 
-            if (nextEntStates != null && nextEntStates.Length != 0)
-            {
-                foreach (var es in nextEntStates)
-                {
-                    if (Entities.TryGetValue(es.Uid, out var entity))
-                    {
-                        if (toApply.TryGetValue(entity, out var state))
-                        {
-                            toApply[entity] = (state.Item1, es);
-                        }
-                        else
-                        {
-                            toApply[entity] = (null, es);
-                        }
-                    }
-                }
-            }
-
-            // Make sure this is done after all entities have been instantiated.
-            foreach (var kvStates in toApply)
-            {
-                var ent = kvStates.Key;
-                var entity = (Entity) ent;
-                HandleEntityState(entity.EntityManager.ComponentManager, entity, kvStates.Value.Item1,
-                    kvStates.Value.Item2);
-            }
-
-            foreach (var kvp in toApply)
-            {
-                UpdateEntityTree(kvp.Key);
-            }
-
-            foreach (var id in deletions)
-            {
-                DeleteEntity(id);
-            }
-
-#if EXCEPTION_TOLERANCE
-            HashSet<Entity> brokenEnts = new HashSet<Entity>();
-#endif
-
-            foreach (var entity in toInitialize)
-            {
-#if EXCEPTION_TOLERANCE
-                try
-                {
-#endif
-                    InitializeEntity(entity);
-#if EXCEPTION_TOLERANCE
-                }
-                catch (Exception e)
-                {
-                    Logger.ErrorS("state", $"Server entity threw in Init: uid={entity.Uid}, proto={entity.Prototype}\n{e}");
-                    brokenEnts.Add(entity);
-                }
-#endif
-            }
-
-            foreach (var entity in toInitialize)
-            {
-#if EXCEPTION_TOLERANCE
-                if(brokenEnts.Contains(entity))
-                    continue;
-
-                try
-                {
-#endif
-                    StartEntity(entity);
-#if EXCEPTION_TOLERANCE
-                }
-                catch (Exception e)
-                {
-                    Logger.ErrorS("state", $"Server entity threw in Start: uid={entity.Uid}, proto={entity.Prototype}\n{e}");
-                    brokenEnts.Add(entity);
-                }
-#endif
-            }
-
-            foreach (var entity in toInitialize)
-            {
-#if EXCEPTION_TOLERANCE
-                if(brokenEnts.Contains(entity))
-                    continue;
-#endif
-                UpdateEntityTree(entity);
-            }
-#if EXCEPTION_TOLERANCE
-            foreach (var entity in brokenEnts)
-            {
-                entity.Delete();
-            }
-#endif
-
-            return created;
+            base.TickUpdate(frameTime, histogram);
         }
 
         /// <inheritdoc />
-        public override IEntity CreateEntityUninitialized(string? prototypeName)
+        public void SendSystemNetworkMessage(EntityEventArgs message)
         {
-            return CreateEntity(prototypeName);
+            SendSystemNetworkMessage(message, default(uint));
+        }
+
+        public void SendSystemNetworkMessage(EntityEventArgs message, uint sequence)
+        {
+            var msg = _networkManager.CreateNetMessage<MsgEntity>();
+            msg.Type = EntityMessageType.SystemMessage;
+            msg.SystemMessage = message;
+            msg.SourceTick = _gameTiming.CurTick;
+            msg.Sequence = sequence;
+
+            _networkManager.ClientSendMessage(msg);
         }
 
         /// <inheritdoc />
-        public override IEntity CreateEntityUninitialized(string? prototypeName, EntityCoordinates coordinates)
+        public void SendSystemNetworkMessage(EntityEventArgs message, INetChannel channel)
         {
-            var newEntity = CreateEntity(prototypeName, GenerateEntityUid());
-
-            if (TryGetEntity(coordinates.EntityId, out var entity))
-            {
-                newEntity.Transform.AttachParent(entity);
-                newEntity.Transform.Coordinates = coordinates;
-            }
-
-            return newEntity;
+            throw new NotSupportedException();
         }
 
         /// <inheritdoc />
-        public override IEntity CreateEntityUninitialized(string? prototypeName, MapCoordinates coordinates)
+        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
+        public void SendComponentNetworkMessage(INetChannel? channel, IEntity entity, IComponent component, ComponentMessage message)
         {
-            var newEntity = CreateEntity(prototypeName, GenerateEntityUid());
-            newEntity.Transform.AttachParent(_mapManager.GetMapEntity(coordinates.MapId));
-            newEntity.Transform.WorldPosition = coordinates.Position;
-            return newEntity;
+            var netId = ComponentFactory.GetRegistration(component.GetType()).NetID;
+
+            if (!netId.HasValue)
+                throw new ArgumentException($"Component {component.Name} does not have a NetID.", nameof(component));
+
+            var msg = _networkManager.CreateNetMessage<MsgEntity>();
+            msg.Type = EntityMessageType.ComponentMessage;
+            msg.EntityUid = entity.Uid;
+            msg.NetId = netId.Value;
+            msg.ComponentMessage = message;
+            msg.SourceTick = _gameTiming.CurTick;
+
+            _networkManager.ClientSendMessage(msg);
         }
 
-        /// <inheritdoc />
-        public override IEntity SpawnEntity(string? protoName, EntityCoordinates coordinates)
+        private void HandleEntityNetworkMessage(MsgEntity message)
         {
-            var newEnt = CreateEntityUninitialized(protoName, coordinates);
-            InitializeAndStartEntity((Entity) newEnt);
-            UpdateEntityTree(newEnt);
-            return newEnt;
-        }
-
-        /// <inheritdoc />
-        public override IEntity SpawnEntity(string? protoName, MapCoordinates coordinates)
-        {
-            var entity = CreateEntityUninitialized(protoName, coordinates);
-            InitializeAndStartEntity((Entity) entity);
-            UpdateEntityTree(entity);
-            return entity;
-        }
-
-        /// <inheritdoc />
-        public override IEntity SpawnEntityNoMapInit(string? protoName, EntityCoordinates coordinates)
-        {
-            return SpawnEntity(protoName, coordinates);
-        }
-
-        protected override EntityUid GenerateEntityUid()
-        {
-            return new(_nextClientEntityUid++);
-        }
-
-        private void HandleEntityState(IComponentManager compMan, IEntity entity, EntityState? curState,
-            EntityState? nextState)
-        {
-            var compStateWork = new Dictionary<uint, (ComponentState? curState, ComponentState? nextState)>();
-            var entityUid = entity.Uid;
-
-            if (curState?.ComponentChanges != null)
+            if (message.SourceTick <= _gameStateManager.CurServerTick)
             {
-                foreach (var compChange in curState.ComponentChanges)
-                {
-                    if (compChange.Deleted)
-                    {
-                        if (compMan.TryGetComponent(entityUid, compChange.NetID, out var comp))
-                        {
-                            compMan.RemoveComponent(entityUid, comp);
-                        }
-                    }
-                    else
-                    {
-                        if (compMan.HasComponent(entityUid, compChange.NetID))
-                            continue;
-
-                        var newComp = (Component) _compFactory.GetComponent(compChange.ComponentName!);
-                        newComp.Owner = entity;
-                        compMan.AddComponent(entity, newComp, true);
-                    }
-                }
+                DispatchMsgEntity(message);
+                return;
             }
 
-            if (curState?.ComponentStates != null)
-            {
-                foreach (var compState in curState.ComponentStates)
-                {
-                    compStateWork[compState.NetID] = (compState, null);
-                }
-            }
+            // MsgEntity is sent with ReliableOrdered so Lidgren guarantees ordering of incoming messages.
+            // We still need to store a sequence input number to ensure ordering remains consistent in
+            // the priority queue.
+            _queue.Add((++_incomingMsgSequence, message));
+        }
 
-            if (nextState?.ComponentStates != null)
+        private void DispatchMsgEntity(MsgEntity message)
+        {
+            switch (message.Type)
             {
-                foreach (var compState in nextState.ComponentStates)
-                {
-                    if (compStateWork.TryGetValue(compState.NetID, out var state))
-                    {
-                        compStateWork[compState.NetID] = (state.curState, compState);
-                    }
-                    else
-                    {
-                        compStateWork[compState.NetID] = (null, compState);
-                    }
-                }
-            }
+                case EntityMessageType.ComponentMessage:
+                    ReceivedComponentMessage?.Invoke(this, new NetworkComponentMessage(message));
+                    return;
 
-            foreach (var (netId, (cur, next)) in compStateWork)
-            {
-                if (compMan.TryGetComponent(entityUid, netId, out var component))
-                {
-                    try
-                    {
-                        component.HandleComponentState(cur, next);
-                    }
-                    catch (Exception e)
-                    {
-                        var wrapper = new ComponentStateApplyException(
-                            $"Failed to apply comp state: entity={component.Owner}, comp={component.Name}", e);
-#if EXCEPTION_TOLERANCE
-                    _runtimeLog.LogException(wrapper, "Component state apply");
-#else
-                        throw wrapper;
-#endif
-                    }
-                }
-                else
-                {
-                    // The component can be null here due to interp.
-                    // Because the NEXT state will have a new component, but this one doesn't yet.
-                    // That's fine though.
-                    if (cur == null)
-                    {
-                        continue;
-                    }
-
-                    var eUid = entityUid;
-                    var eRegisteredNetUidName = _compFactory.GetRegistration(netId).Name;
-                    DebugTools.Assert(
-                        $"Component does not exist for state: entUid={eUid}, expectedNetId={netId}, expectedName={eRegisteredNetUidName}");
-                }
+                case EntityMessageType.SystemMessage:
+                    var msg = message.SystemMessage;
+                    var sessionType = typeof(EntitySessionMessage<>).MakeGenericType(msg.GetType());
+                    var sessionMsg = Activator.CreateInstance(sessionType, new EntitySessionEventArgs(_playerManager.LocalPlayer!.Session), msg)!;
+                    ReceivedSystemMessage?.Invoke(this, msg);
+                    ReceivedSystemMessage?.Invoke(this, sessionMsg);
+                    return;
             }
         }
+
+        private sealed class MessageTickComparer : IComparer<(uint seq, MsgEntity msg)>
+        {
+            public int Compare((uint seq, MsgEntity msg) x, (uint seq, MsgEntity msg) y)
+            {
+                var cmp = y.msg.SourceTick.CompareTo(x.msg.SourceTick);
+                if (cmp != 0)
+                {
+                    return cmp;
+                }
+
+                return y.seq.CompareTo(x.seq);
+            }
+        }
+        #endregion
     }
 }

Robust.Client/GameObjects/ClientEntityNetworkManager.cs

@@ -1,128 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Robust.Client.GameStates;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Network;
-using Robust.Shared.Network.Messages;
-using Robust.Shared.Timing;
-using Robust.Shared.Utility;
-
-namespace Robust.Client.GameObjects
-{
-    /// <summary>
-    /// The client implementation of the Entity Network Manager.
-    /// </summary>
-    public class ClientEntityNetworkManager : IEntityNetworkManager
-    {
-        [Dependency] private readonly IClientNetManager _networkManager = default!;
-        [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
-        [Dependency] private readonly IGameTiming _gameTiming = default!;
-
-        /// <inheritdoc />
-        public event EventHandler<NetworkComponentMessage>? ReceivedComponentMessage;
-
-        /// <inheritdoc />
-        public event EventHandler<object>? ReceivedSystemMessage;
-
-        private readonly PriorityQueue<(uint seq, MsgEntity msg)> _queue = new(new MessageTickComparer());
-        private uint _incomingMsgSequence = 0;
-
-        /// <inheritdoc />
-        public void SetupNetworking()
-        {
-            _networkManager.RegisterNetMessage<MsgEntity>(MsgEntity.NAME, HandleEntityNetworkMessage);
-        }
-
-        public void Update()
-        {
-            while (_queue.Count != 0 && _queue.Peek().msg.SourceTick <= _gameStateManager.CurServerTick)
-            {
-                var (_, msg) = _queue.Take();
-                // Logger.DebugS("net.ent", "Dispatching: {0}: {1}", seq, msg);
-                DispatchMsgEntity(msg);
-            }
-        }
-
-        /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntitySystemMessage message)
-        {
-            SendSystemNetworkMessage(message, default(uint));
-        }
-
-        public void SendSystemNetworkMessage(EntitySystemMessage message, uint sequence)
-        {
-            var msg = _networkManager.CreateNetMessage<MsgEntity>();
-            msg.Type = EntityMessageType.SystemMessage;
-            msg.SystemMessage = message;
-            msg.SourceTick = _gameTiming.CurTick;
-            msg.Sequence = sequence;
-
-            _networkManager.ClientSendMessage(msg);
-        }
-
-        /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntitySystemMessage message, INetChannel channel)
-        {
-            throw new NotSupportedException();
-        }
-
-        /// <inheritdoc />
-        public void SendComponentNetworkMessage(INetChannel? channel, IEntity entity, IComponent component, ComponentMessage message)
-        {
-            if (!component.NetID.HasValue)
-                throw new ArgumentException($"Component {component.Name} does not have a NetID.", nameof(component));
-
-            var msg = _networkManager.CreateNetMessage<MsgEntity>();
-            msg.Type = EntityMessageType.ComponentMessage;
-            msg.EntityUid = entity.Uid;
-            msg.NetId = component.NetID.Value;
-            msg.ComponentMessage = message;
-            msg.SourceTick = _gameTiming.CurTick;
-
-            _networkManager.ClientSendMessage(msg);
-        }
-
-        private void HandleEntityNetworkMessage(MsgEntity message)
-        {
-            if (message.SourceTick <= _gameStateManager.CurServerTick)
-            {
-                DispatchMsgEntity(message);
-                return;
-            }
-
-            // MsgEntity is sent with ReliableOrdered so Lidgren guarantees ordering of incoming messages.
-            // We still need to store a sequence input number to ensure ordering remains consistent in
-            // the priority queue.
-            _queue.Add((++_incomingMsgSequence, message));
-        }
-
-        private void DispatchMsgEntity(MsgEntity message)
-        {
-            switch (message.Type)
-            {
-                case EntityMessageType.ComponentMessage:
-                    ReceivedComponentMessage?.Invoke(this, new NetworkComponentMessage(message));
-                    return;
-
-                case EntityMessageType.SystemMessage:
-                    ReceivedSystemMessage?.Invoke(this, message.SystemMessage);
-                    return;
-            }
-        }
-
-        private sealed class MessageTickComparer : IComparer<(uint seq, MsgEntity msg)>
-        {
-            public int Compare((uint seq, MsgEntity msg) x, (uint seq, MsgEntity msg) y)
-            {
-                var cmp = y.msg.SourceTick.CompareTo(x.msg.SourceTick);
-                if (cmp != 0)
-                {
-                    return cmp;
-                }
-
-                return y.seq.CompareTo(x.seq);
-            }
-        }
-    }
-}

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

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using Robust.Client.Animations;
 using Robust.Shared.GameObjects;
 using static Robust.Client.Animations.AnimationPlaybackShared;
@@ -12,11 +11,17 @@ namespace Robust.Client.GameObjects
     /// </summary>
     public sealed class AnimationPlayerComponent : Component
     {
+        // TODO: Give this component a friend someday. Way too much content shit to change atm ._.
+
         public override string Name => "AnimationPlayer";
 
-        private readonly Dictionary<string, AnimationPlayback> _playingAnimations
+        public int PlayingAnimationCount => PlayingAnimations.Count;
+
+        internal readonly Dictionary<string, AnimationPlayback> PlayingAnimations
             = new();
 
+        internal bool HasPlayingAnimation = false;
+
         /// <summary>
         ///     Start playing an animation.
         /// </summary>
@@ -26,50 +31,31 @@ namespace Robust.Client.GameObjects
         /// </param>
         public void Play(Animation animation, string key)
         {
+            EntitySystem.Get<AnimationPlayerSystem>().AddComponent(this);
             var playback = new AnimationPlayback(animation);
 
-            _playingAnimations.Add(key, playback);
+            PlayingAnimations.Add(key, playback);
         }
 
         public bool HasRunningAnimation(string key)
         {
-            return _playingAnimations.ContainsKey(key);
+            return PlayingAnimations.ContainsKey(key);
         }
 
         public void Stop(string key)
         {
-            _playingAnimations.Remove(key);
+            PlayingAnimations.Remove(key);
         }
 
-        internal void Update(float frameTime)
+        /// <summary>
+        /// Temporary method until the event is replaced with eventbus.
+        /// </summary>
+        internal void AnimationComplete(string key)
         {
-            if (_playingAnimations.Count == 0)
-            {
-                return;
-            }
-
-            List<string>? toRemove = null;
-            // TODO: Get rid of this ToArray() allocation.
-            foreach (var (key, playback) in _playingAnimations.ToArray())
-            {
-                var keep = UpdatePlayback(Owner, playback, frameTime);
-                if (!keep)
-                {
-                    toRemove ??= new List<string>();
-                    toRemove.Add(key);
-                }
-            }
-
-            if (toRemove != null)
-            {
-                foreach (var key in toRemove)
-                {
-                    _playingAnimations.Remove(key);
-                    AnimationCompleted?.Invoke(key);
-                }
-            }
+            AnimationCompleted?.Invoke(key);
         }
 
+        [Obsolete("Use AnimationCompletedEvent instead")]
         public event Action<string>? AnimationCompleted;
     }
 }

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

@@ -10,6 +10,7 @@ using YamlDotNet.RepresentationModel;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(SharedAppearanceComponent))]
     public sealed class AppearanceComponent : SharedAppearanceComponent
     {
         [ViewVariables]
@@ -83,6 +84,23 @@ namespace Robust.Client.GameObjects
             if (curState is not AppearanceComponentState actualState)
                 return;
 
+            var stateDiff = data.Count != actualState.Data.Count;
+
+            if (!stateDiff)
+            {
+                foreach (var (key, value) in data)
+                {
+                    if (!actualState.Data.TryGetValue(key, out var stateValue) ||
+                        !value.Equals(stateValue))
+                    {
+                        stateDiff = true;
+                        break;
+                    }
+                }
+            }
+
+            if (!stateDiff) return;
+
             data = actualState.Data;
             MarkDirty();
         }
@@ -94,8 +112,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            EntitySystem.Get<AppearanceSystem>()
-                .EnqueueAppearanceUpdate(this);
+            EntitySystem.Get<AppearanceSystem>().EnqueueUpdate(this);
             _appearanceDirty = true;
         }
 
@@ -104,7 +121,7 @@ namespace Robust.Client.GameObjects
             _appearanceDirty = false;
         }
 
-        public override void Initialize()
+        protected override void Initialize()
         {
             base.Initialize();
 
@@ -115,21 +132,6 @@ namespace Robust.Client.GameObjects
 
             MarkDirty();
         }
-
-
-        internal class SpriteLayerToggle : AppearanceVisualizer
-        {
-            public const string NAME = "sprite_layer_toggle";
-
-            public readonly object Key;
-            public readonly int SpriteLayer;
-
-            public SpriteLayerToggle(object key, int spriteLayer)
-            {
-                Key = key;
-                SpriteLayer = spriteLayer;
-            }
-        }
     }
 
     /// <summary>
@@ -156,22 +158,4 @@ namespace Robust.Client.GameObjects
         {
         }
     }
-
-    sealed class AppearanceTestComponent : Component
-    {
-        public override string Name => "AppearanceTest";
-
-        float time;
-        bool state;
-
-        public void OnUpdate(float frameTime)
-        {
-            time += frameTime;
-            if (time > 1)
-            {
-                time -= 1;
-                Owner.GetComponent<AppearanceComponent>().SetData("test", state = !state);
-            }
-        }
-    }
 }

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

@@ -1,4 +1,4 @@
-using Robust.Client.Graphics;
+using Robust.Client.Graphics;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
@@ -10,6 +10,7 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(SharedEyeComponent))]
     public class EyeComponent : SharedEyeComponent
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;
@@ -25,7 +26,7 @@ namespace Robust.Client.GameObjects
         [DataField("drawFov")]
         private bool _setDrawFovOnInitialize = true;
         [DataField("zoom")]
-        private Vector2 _setZoomOnInitialize = Vector2.One/2f;
+        private Vector2 _setZoomOnInitialize = Vector2.One;
         private Vector2 _offset = Vector2.Zero;
 
         public IEye? Eye => _eye;
@@ -115,7 +116,7 @@ namespace Robust.Client.GameObjects
         public MapCoordinates? Position => _eye?.Position;
 
         /// <inheritdoc />
-        public override void Initialize()
+        protected override void Initialize()
         {
             base.Initialize();
 
@@ -152,9 +153,10 @@ namespace Robust.Client.GameObjects
             Zoom = state.Zoom;
             Offset = state.Offset;
             Rotation = state.Rotation;
+            VisibilityMask = state.VisibilityMask;
         }
 
-        public override void OnRemove()
+        protected override void OnRemove()
         {
             base.OnRemove();
 

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

@@ -1,7 +1,5 @@
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
@@ -10,7 +8,7 @@ namespace Robust.Client.GameObjects
     /// <summary>
     ///     Defines data fields used in the <see cref="InputSystem"/>.
     /// </summary>
-    class InputComponent : Component
+    public class InputComponent : Component
     {
         /// <inheritdoc />
         public override string Name => "Input";

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

@@ -1,14 +1,17 @@
 using System;
+using System.Collections.Generic;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(OccluderComponent))]
     internal sealed class ClientOccluderComponent : OccluderComponent
     {
-        internal SnapGridComponent? SnapGrid { get; private set; }
+        [Dependency] private readonly IMapManager _mapManager = default!;
 
         [ViewVariables] private (GridId, Vector2i) _lastPosition;
         [ViewVariables] internal OccluderDir Occluding { get; private set; }
@@ -29,39 +32,36 @@ namespace Robust.Client.GameObjects
         {
             base.Startup();
 
-            if (Owner.TryGetComponent(out SnapGridComponent? snap))
+            if (Owner.Transform.Anchored)
             {
-                SnapGrid = snap;
-                SnapGrid.OnPositionChanged += SnapGridOnPositionChanged;
-
-                SnapGridOnPositionChanged();
+                AnchorStateChanged();
             }
         }
 
-        private void SnapGridOnPositionChanged()
+        public void AnchorStateChanged()
         {
             SendDirty();
-            _lastPosition = (Owner.Transform.GridID, SnapGrid!.Position);
+
+            if(!Owner.Transform.Anchored)
+                return;
+
+            var grid = _mapManager.GetGrid(Owner.Transform.GridID);
+            _lastPosition = (Owner.Transform.GridID, grid.TileIndicesFor(Owner.Transform.Coordinates));
         }
 
         protected override void Shutdown()
         {
             base.Shutdown();
 
-            if (SnapGrid != null)
-            {
-                SnapGrid.OnPositionChanged -= SnapGridOnPositionChanged;
-            }
-
             SendDirty();
         }
 
         private void SendDirty()
         {
-            if (SnapGrid != null)
+            if (Owner.Transform.Anchored)
             {
                 Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local,
-                    new OccluderDirtyEvent(Owner, _lastPosition, SnapGrid.Offset));
+                    new OccluderDirtyEvent(Owner, _lastPosition));
             }
         }
 
@@ -69,16 +69,18 @@ namespace Robust.Client.GameObjects
         {
             Occluding = OccluderDir.None;
 
-            if (Deleted || SnapGrid == null)
+            if (Deleted || !Owner.Transform.Anchored)
             {
                 return;
             }
 
             void CheckDir(Direction dir, OccluderDir oclDir)
             {
-                foreach (var neighbor in SnapGrid.GetInDir(dir))
+                var grid = _mapManager.GetGrid(Owner.Transform.GridID);
+                var position = Owner.Transform.Coordinates;
+                foreach (var neighbor in grid.GetInDir(position, dir))
                 {
-                    if (neighbor.TryGetComponent(out ClientOccluderComponent? comp) && comp.Enabled)
+                    if (Owner.EntityManager.TryGetComponent(neighbor, out ClientOccluderComponent? comp) && comp.Enabled)
                     {
                         Occluding |= oclDir;
                         break;