Replace Lidgren encryption stuff with Libsodium (#2646)

Co-authored-by: Paul <ritter.paul1@googlemail.com>

.github/CODEOWNERS

@@ -1,7 +1,20 @@
 # Last match in file takes precedence.
 
+# Ping for all PRs
+* @Acruid @PJB3005 @Silvertorch5
+
+/Robust.*/Audio/Midi/ @Zumorica
+
+/Robust.Client.NameGenerator @PaulRitter
+/Robust.Client.Injectors @PaulRitter
+/Robust.Generators @PaulRitter
+/Robust.Analyzers @PaulRitter
+/Robust.*/GameStates @PaulRitter
+/Robust.Shared/Analyzers @PaulRitter
+/Robust.*/Serialization @PaulRitter @DrSmugleaf
+/Robust.*/Prototypes @PaulRitter
+/Robust.Shared/GameObjects/ComponentDependencies @PaulRitter
+/Robust.*/Containers @PaulRitter
+
 # Be they Fluent translations or Freemarker templates, I know them both!
 *.ftl @RemieRichards
-
-# Ping for all PRs
-* @Acruid @PJB3005 @Silvertorch5

.github/workflows/benchmarks.yml

@@ -0,0 +1,33 @@
+name: Benchmarks
+#on:
+#  push
+  #schedule:
+  #  - cron: '0 5 * * *'
+  #push:
+  #  tags:
+  #    - 'v*'
+
+env:
+  ROBUST_BENCHMARKS_ENABLE_SQL: 1
+  ROBUST_BENCHMARKS_SQL_ADDRESS: ${{ secrets.BENCHMARKS_WRITE_ADDRESS }}
+  ROBUST_BENCHMARKS_SQL_PORT: ${{ secrets.BENCHMARKS_WRITE_PORT }}
+  ROBUST_BENCHMARKS_SQL_USER: ${{ secrets.BENCHMARKS_WRITE_USER }}
+  ROBUST_BENCHMARKS_SQL_PASSWORD: ${{ secrets.BENCHMARKS_WRITE_PASSWORD }}
+  ROBUST_BENCHMARKS_SQL_DATABASE: benchmarks
+
+jobs:
+  benchmark:
+    name: Run Benchmarks
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: true
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v1
+        with:
+          dotnet-version: 6.0.x
+      - name: Install dependencies
+        run: dotnet restore
+      - name: Run benchmark
+        run: cd Robust.Benchmarks && sudo dotnet run --filter '*' --configuration Release

.github/workflows/build-docfx.yml

@@ -0,0 +1,34 @@
+name: Build & Publish DocFX
+
+on:
+  schedule:
+    - cron: "0 0 * * 0"
+jobs:
+  docfx:
+   runs-on: ubuntu-latest
+   steps: 
+    - uses: actions/checkout@v2
+      with:
+        submodules: true
+
+    - name: Setup .NET Core
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: 6.0.x
+        
+    - name: Install dependencies
+      run: dotnet restore
+      
+    - name: Build Project
+      run: dotnet build --no-restore /p:WarningsAsErrors=nullable
+
+    - name: Build DocFX
+      uses: nikeee/docfx-action@v1.0.0      
+      with:
+        args: Robust.Docfx/docfx.json
+    
+    - name: Publish Docfx Documentation on GitHub Pages
+      uses: maxheld83/ghpages@master
+      env:
+        BUILD_DIR: Robust.Docfx/_robust-site 
+        GH_PAT: ${{ secrets.GH_PAT }} 

.github/workflows/build-test.yml

@@ -22,10 +22,12 @@ jobs:
     - name: Setup .NET Core
       uses: actions/setup-dotnet@v1
       with:
-        dotnet-version: 6.0.100
+        dotnet-version: 6.0.x
     - name: Install dependencies
       run: dotnet restore
     - name: Build
       run: dotnet build --no-restore /p:WarningsAsErrors=nullable
     - name: Test Engine
       run: dotnet test --no-build Robust.UnitTesting/Robust.UnitTesting.csproj -v n
+ 
+

.gitignore

@@ -41,18 +41,6 @@ _ReSharper*/
 
 # Resources
 *.resources
-/Resources/textures/Animations/*.*
-/Resources/ResourcePack.zip
-/Resources/textures/*_Animations.png
-/Resources/textures/*_Decals.png
-/Resources/textures/*_Effects.png
-/Resources/textures/*_Items.png
-/Resources/textures/*_Objects.png
-/Resources/textures/*_Tiles.png
-/Resources/textures/*_UserInterface.png
-/Resources/textures/*.TAI
-/Resources/SpriteRenderer/Ogre.log
-/Resources/Spriterenderer/output
 /Media
 /setenv.bat
 
@@ -78,16 +66,6 @@ project.lock.json
 # Created by NUnit.
 TestResult.xml
 
-NetSerializerDebug.dll
-
-# We're not gonna ship Mac extlibs with the repo due to size. (11 MB)
-Third-Party/extlibs/Mac/
-# Or the automatically-fetched Windows natives, for that matter.
-Third-Party/extlibs/Windows/
-
-# Actually I'll make this folder because SS14.Shared.Bsdiff isn't third-party is it?
-Dependencies/
-
 # Python stuff
 __pycache__
 .mypy_cache
@@ -98,3 +76,5 @@ MSBuild/Robust.Custom.targets
 
 
 release/
+Robust.Docfx/*-site
+Robust.Docfx/api

.gitmodules

@@ -13,9 +13,6 @@
 [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

MSBuild/Robust.Engine.Version.props

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

MSBuild/Robust.Engine.props

@@ -6,4 +6,5 @@
         <Nullable>enable</Nullable>
         <WarningsAsErrors>nullable</WarningsAsErrors>
     </PropertyGroup>
+    <Import Project="Robust.Engine.Version.props" />
 </Project>

MSBuild/Robust.Trimming.targets

@@ -0,0 +1,122 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
+  <!--
+  Stuff for using ILLink trimming without self-contained deployments.
+  This is not something officially supported by the .NET SDK currently, but we can simply run ILLink ourselves.
+  -->
+
+  <!--
+  A lot of stuff taken from Microsoft.NET.ILLink.targets in the SDK files.
+  -->
+
+  <ItemDefinitionGroup>
+    <RobustLinkRoots>
+      <Visible>false</Visible>
+    </RobustLinkRoots>
+    <RobustLinkAssemblies>
+      <Visible>false</Visible>
+    </RobustLinkAssemblies>
+  </ItemDefinitionGroup>
+
+  <Target Name="RobustILLink"
+          BeforeTargets="ILLink"
+          Condition="'$(PublishTrimmed)' != 'true' And
+                       '$(RobustILLink)' == 'true'"
+          DependsOnTargets="_ComputeAssembliesToPostprocessOnPublish">
+
+    <ComputeManagedAssemblies Assemblies="@(ResolvedFileToPublish)">
+      <Output TaskParameter="ManagedAssemblies" ItemName="_ResolvedFileToPublishFiltered" />
+    </ComputeManagedAssemblies>
+
+    <JoinItems Left="@(_ResolvedFileToPublishFiltered)" LeftKey="FileName" LeftMetadata="*"
+               Right="@(RobustLinkRoots)"
+               ItemSpecToUse="Left">
+      <Output TaskParameter="JoinResult" ItemName="_RobustLinkRootsJoined" />
+    </JoinItems>
+
+    <JoinItems Left="@(_ResolvedFileToPublishFiltered)" LeftKey="FileName" LeftMetadata="*"
+               Right="@(RobustLinkAssemblies)"
+               ItemSpecToUse="Left">
+      <Output TaskParameter="JoinResult" ItemName="_RobustLinkAssembliesJoined" />
+    </JoinItems>
+
+    <PropertyGroup>
+      <TrimMode Condition=" '$(TrimMode)' == '' ">link</TrimMode>
+      <TrimmerDefaultAction Condition=" '$(TrimmerDefaultAction)' == '' ">copy</TrimmerDefaultAction>
+      <_ExtraTrimmerArgs>--skip-unresolved true $(_ExtraTrimmerArgs)</_ExtraTrimmerArgs>
+      <ILLinkTreatWarningsAsErrors Condition=" '$(ILLinkTreatWarningsAsErrors)' == '' ">$(TreatWarningsAsErrors)</ILLinkTreatWarningsAsErrors>
+      <TrimmerSingleWarn Condition=" '$(TrimmerSingleWarn)' == '' ">true</TrimmerSingleWarn>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <RobustAssemblyToLink Include="@(_RobustLinkRootsJoined)">
+        <TrimMode>Copy</TrimMode>
+      </RobustAssemblyToLink>
+      <RobustAssemblyToLink Include="@(_RobustLinkAssembliesJoined)">
+        <TrimMode>Link</TrimMode>
+      </RobustAssemblyToLink>
+    </ItemGroup>
+
+    <ItemGroup>
+      <!-- The linker implicitly picks up PDBs next to input assemblies. We will filter these out of the publish set. -->
+      <__PDBToLink Include="@(ResolvedFileToPublish)" Exclude="@(RobustAssemblyToLink->'%(RelativeDir)%(Filename).pdb')" />
+      <_PDBToLink Include="@(ResolvedFileToPublish)" Exclude="@(__PDBToLink)" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <_LinkedResolvedFileToPublishCandidate Include="@(RobustAssemblyToLink->'$(IntermediateLinkDir)%(Filename)%(Extension)')" />
+      <_LinkedResolvedFileToPublishCandidate Include="@(_PDBToLink->'$(IntermediateLinkDir)%(Filename)%(Extension)')" />
+    </ItemGroup>
+
+    <!--<Message Text="@(ResolvedFileToPublish)" Importance="high" />-->
+
+    <ItemGroup>
+      <_TrimmerFeatureSettings Include="@(RuntimeHostConfigurationOption)"
+                               Condition="'%(RuntimeHostConfigurationOption.Trim)' == 'true'" />
+    </ItemGroup>
+
+    <Delete Files="@(_LinkedResolvedFileToPublishCandidate)" />
+    <ILLink AssemblyPaths="@(RobustAssemblyToLink)"
+            ReferenceAssemblyPaths="@(ReferencePath)"
+            RootAssemblyNames="@(RobustLinkRoots)"
+            TrimMode="Skip"
+            DefaultAction="$(TrimmerDefaultAction)"
+            RemoveSymbols="false"
+            FeatureSettings="@(_TrimmerFeatureSettings)"
+            CustomData="@(_TrimmerCustomData)"
+
+            BeforeFieldInit="$(_TrimmerBeforeFieldInit)"
+            OverrideRemoval="$(_TrimmerOverrideRemoval)"
+            UnreachableBodies="$(_TrimmerUnreachableBodies)"
+            UnusedInterfaces="$(_TrimmerUnusedInterfaces)"
+            IPConstProp="$(_TrimmerIPConstProp)"
+            Sealer="$(_TrimmerSealer)"
+
+            Warn="$(ILLinkWarningLevel)"
+            NoWarn="$(NoWarn)"
+            TreatWarningsAsErrors="$(ILLinkTreatWarningsAsErrors)"
+            WarningsAsErrors="$(WarningsAsErrors)"
+            WarningsNotAsErrors="$(WarningsNotAsErrors)"
+            SingleWarn="$(TrimmerSingleWarn)"
+
+            CustomSteps="@(_TrimmerCustomSteps)"
+            RootDescriptorFiles="@(TrimmerRootDescriptor)"
+            OutputDirectory="$(IntermediateLinkDir)"
+            DumpDependencies="$(_TrimmerDumpDependencies)"
+            ExtraArgs="$(_ExtraTrimmerArgs)"
+            ToolExe="$(_DotNetHostFileName)"
+            ToolPath="$(_DotNetHostDirectory)"
+            ContinueOnError="ErrorAndContinue">
+      <Output TaskParameter="ExitCode" PropertyName="_ILLinkExitCode" />
+    </ILLink>
+
+    <Touch Files="$(_LinkSemaphore)" AlwaysCreate="true" Condition=" '$(_ILLinkExitCode)' == '0' " />
+
+    <ItemGroup>
+      <_LinkedResolvedFileToPublish Include="@(_LinkedResolvedFileToPublishCandidate)" Condition="Exists('%(Identity)')" />
+      <ResolvedFileToPublish Remove="@(RobustAssemblyToLink)" />
+      <ResolvedFileToPublish Remove="@(_PDBToLink)" />
+      <ResolvedFileToPublish Include="@(_LinkedResolvedFileToPublish)" />
+    </ItemGroup>
+  </Target>
+
+</Project>

OpenToolkit.GraphicsLibraryFramework/GLFWNative.cs

@@ -18,20 +18,18 @@ namespace OpenToolkit.GraphicsLibraryFramework
             NativeLibrary.SetDllImportResolver(typeof(GLFWNative).Assembly, (name, assembly, path) =>
             {
                 // Please keep in sync with what Robust.Shared/DllMapHelper.cs does.
+
                 if (name != "glfw3.dll")
                 {
                     return IntPtr.Zero;
                 }
 
-                if (OperatingSystem.IsLinux())
-                {
-                    return NativeLibrary.Load("libglfw.so.3", assembly, path);
-                }
+                string rName = null;
+                if (OperatingSystem.IsLinux()) rName = "libglfw.so.3";
+                else if (OperatingSystem.IsMacOS()) rName = "libglfw.3.dylib";
 
-                if (OperatingSystem.IsMacOS())
-                {
-                    return NativeLibrary.Load("libglfw.3.dylib", assembly, path);
-                }
+                if ((rName != null) && NativeLibrary.TryLoad(rName, assembly, path, out var handle))
+                    return handle;
 
                 return IntPtr.Zero;
             });

README.md

@@ -10,7 +10,7 @@ Use the [content repo](https://github.com/space-wizards/space-station-14) for ac
 
 ## Documentation/Wiki
 
-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.
+The [wiki](https://docs.spacestation14.io/) has documentation on SS14s content, engine, game design and more. We also have lots of resources for new contributors to the project.
 
 ## Contributing
 

Resources/.gitignore

@@ -1,8 +0,0 @@
-# .import files are made by Godot because the assets are exposed if using symlinks.
-# IF you need to persist a .import file because of something used Godot-side (GUI-side),
-# you can do a negation with !.
-*.import
-# Negation would be like this:
-#!/Textures/UserInterface/1pxwhite.png.import
-!/Scenes/SS14Window/closewindow.png.import
-/I_MADE_THE_SYMLINK

Resources/Locale/en-US/defaultwindow.ftl

@@ -0,0 +1 @@
+defaultwindow-placeholder-title = Exemplary Window Title Here

Resources/Locale/en-US/ss14window.ftl

@@ -1 +0,0 @@
-ss14window-placeholder-title = Exemplary Window Title Here

Resources/Prototypes/Shaders/stockshaders.yml

@@ -7,3 +7,8 @@
 - type: shader
   id: shaded
   kind: canvas
+
+- type: shader
+  id: bgra
+  kind: source
+  path: "/Shaders/Internal/bgra.swsl"

Resources/Shaders/Internal/bgra.swsl

@@ -0,0 +1,6 @@
+// Swaps B and R channel so you can render BGRA stuff without swizzling at upload time.
+// Currently used by CEF.
+
+void fragment() {
+    COLOR = zTexture(UV).bgra;
+}

Resources/Textures/Logo/logo.png.yml

@@ -1,2 +0,0 @@
-sample:
-  filter: true

Resources/Textures/Logo/logo.svg

@@ -1,152 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!-- Created with Inkscape (http://www.inkscape.org/) -->
-
-<svg
-   xmlns:dc="http://purl.org/dc/elements/1.1/"
-   xmlns:cc="http://creativecommons.org/ns#"
-   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
-   xmlns:svg="http://www.w3.org/2000/svg"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
-   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
-   width="113.67364mm"
-   height="56.37999mm"
-   viewBox="0 0 113.67364 56.37999"
-   version="1.1"
-   id="svg3223"
-   inkscape:version="0.92.4 5da689c313, 2019-01-14"
-   sodipodi:docname="logo.svg"
-   inkscape:export-filename="/home/pj/Projects/space-station-14/RobustToolbox/Resources/Textures/Logo/logo.png"
-   inkscape:export-xdpi="67.034012"
-   inkscape:export-ydpi="67.034012">
-  <defs
-     id="defs3217" />
-  <sodipodi:namedview
-     id="base"
-     pagecolor="#ffffff"
-     bordercolor="#666666"
-     borderopacity="1.0"
-     inkscape:pageopacity="0.0"
-     inkscape:pageshadow="2"
-     inkscape:zoom="0.98994949"
-     inkscape:cx="159.25688"
-     inkscape:cy="149.8376"
-     inkscape:document-units="mm"
-     inkscape:current-layer="layer1"
-     showgrid="false"
-     inkscape:pagecheckerboard="true"
-     inkscape:window-width="1920"
-     inkscape:window-height="1043"
-     inkscape:window-x="0"
-     inkscape:window-y="0"
-     inkscape:window-maximized="1" />
-  <metadata
-     id="metadata3220">
-    <rdf:RDF>
-      <cc:Work
-         rdf:about="">
-        <dc:format>image/svg+xml</dc:format>
-        <dc:type
-           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
-        <dc:title></dc:title>
-      </cc:Work>
-    </rdf:RDF>
-  </metadata>
-  <g
-     inkscape:label="Layer 1"
-     inkscape:groupmode="layer"
-     id="layer1"
-     transform="translate(-56.556041,-109.30405)">
-    <g
-       transform="translate(-3.7799155,-23.482217)"
-       id="g2559">
-      <path
-         inkscape:connector-curvature="0"
-         id="path148"
-         style="fill:#e23229;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 143.44393,145.03077 0.1484,-0.70241 5.14257,-0.35974 -6.23062,29.75753 -0.69199,0.0483 6.08255,-29.05476 z m 1.18682,31.16724 7.31835,-35.07438 -10.43302,0.72923 -1.28514,6.12249 4.45021,-0.31125 -6.03235,28.95253 z" />
-      <path
-         sodipodi:nodetypes="cccccccccccccccccccccc"
-         inkscape:connector-curvature="0"
-         id="path152"
-         style="fill:#e23229;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 169.25392,142.53363 -3.53672,16.8925 4.79124,-0.32874 -0.15681,0.75402 -4.79234,0.32881 -2.53549,12.11072 -0.75405,0.052 2.53724,-12.11108 -11.37332,0.78724 z m -18.98495,21.327 11.37324,-0.78724 -2.5247,12.11146 5.98312,-0.41839 2.52513,-12.10406 4.82658,-0.33116 1.26721,-6.07903 -4.82564,0.33109 3.52398,-16.89101 -4.56014,0.33565 -16.70168,19.60839 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path156"
-         style="fill:#fefefe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 88.591903,151.83158 -2.595368,0.18103 0.741705,-3.62685 2.595079,-0.182 z m -4.581719,-6.72375 -3.99857,19.05572 3.468889,-0.24195 1.774487,-8.38766 6.064403,-0.42299 2.224789,-10.66981 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path160"
-         style="fill:#fefefe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 100.85029,147.82177 2.83371,-0.19837 -0.74166,3.60045 -2.83371,0.19836 z m -6.726869,15.77696 3.469312,-0.24198 1.774487,-8.38695 2.8337,-0.19837 -1.77453,8.38695 3.46938,-0.24296 3.99895,-19.05608 -9.771974,0.68329 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path164"
-         style="fill:#fefefe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 108.80467,162.68768 9.74554,-0.68118 1.377,-6.50502 -3.4693,0.24296 -0.63527,2.9832 -2.80718,0.19654 2.51548,-12.01379 2.80731,-0.19754 -0.50239,2.4195 3.46902,-0.24294 1.24513,-5.93998 -9.74589,0.68119 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path168"
-         style="fill:#fefefe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 135.66767,145.61788 0.7409,-3.5211 -8.95132,0.6259 -3.99824,19.0564 8.95097,-0.62626 0.74082,-3.52077 -5.4816,0.383 1.03272,-4.89224 3.78675,-0.26474 0.74189,-3.52113 -3.78675,0.26474 0.74081,-3.6011 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path172"
-         style="fill:#d5d5d5;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 71.070134,172.95255 -4.734664,0.33077 0.57447,-2.73456 2.139294,-0.14973 -0.376241,1.80924 2.595442,-0.18103 0.930868,-4.44332 -7.330114,0.5118 -1.66358,8.00131 4.734672,-0.33077 -0.773014,3.62025 -2.119829,0.1484 0.475696,-2.23174 -2.614982,0.18237 -1.030327,4.86616 7.330104,-0.5118 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path176"
-         style="fill:#d5d5d5;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 74.794828,169.99754 2.496095,-0.17422 -2.436556,11.62085 2.595151,-0.182 2.436903,-11.62086 2.496023,-0.17421 0.554678,-2.63441 -7.587516,0.53064 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path180"
-         style="fill:#d5d5d5;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 87.573322,171.75893 0.554606,-2.69318 2.119754,-0.1484 -0.554978,2.69354 z m 2.832629,8.59803 2.991888,-14.25529 -7.310379,0.51154 -2.99153,14.25493 2.595227,-0.18201 1.327293,-6.27378 2.11968,-0.14839 -1.327288,6.27414 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path184"
-         style="fill:#d5d5d5;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 98.977684,179.78056 2.436926,-11.62086 2.49608,-0.1752 0.55493,-2.63374 -7.587518,0.53065 -0.554634,2.63373 2.495947,-0.17421 -2.436599,11.6212 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path188"
-         style="fill:#d5d5d5;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 104.62426,179.38562 2.5951,-0.18101 2.9915,-14.25528 -2.59522,0.182 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path192"
-         style="fill:#d5d5d5;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 115.73198,167.18138 2.11975,-0.14839 -1.88236,8.98749 -2.11949,0.14838 z m -5.03203,11.80203 7.31001,-0.51042 2.99153,-14.25494 -7.31028,0.51044 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path196"
-         style="fill:#d5d5d5;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 124.08538,178.07141 1.36653,-6.47511 1.18856,6.29603 2.25853,-0.15792 2.99192,-14.25493 -2.59522,0.18201 -1.36734,6.57353 -1.18854,-6.39514 -2.25854,0.15791 -2.99084,14.25493 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path200"
-         style="fill:#fefefe;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 66.677649,158.65784 -1.377018,6.50538 9.798398,-0.68471 2.489415,-11.87958 -6.329111,0.44214 0.767747,-3.65465 2.860076,-0.20018 -0.503204,2.41917 3.469299,-0.24297 1.244526,-5.93996 -4.328229,0.30289 -8.728772,0.56991 2.909827,1.489 -1.87565,9.01912 6.329037,-0.44213 -1.032406,4.83973 -2.833645,0.19738 0.635302,-2.98354 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path204"
-         style="fill:#e23229;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 70.519326,139.92277 -0.277457,1.36553 103.473271,-7.11317 0.29445,-1.38886 z" />
-      <path
-         inkscape:connector-curvature="0"
-         id="path208"
-         style="fill:#e23229;fill-opacity:1;fill-rule:nonzero;stroke:none;stroke-width:0.34773216"
-         d="m 60.335956,189.16626 103.473274,-7.11356 0.29444,-1.38885 -103.489968,7.13649 z" />
-      <path
-         sodipodi:nodetypes="cccccccc"
-         inkscape:connector-curvature="0"
-         id="path1772"
-         d="m 167.92741,145.26275 -12.87687,14.89523 9.91366,-0.68019 z m -3.743,7.27758 -1.02896,4.93612 -3.51544,0.2412 z"
-         style="fill:#e23229;fill-opacity:1;stroke:none;stroke-width:0.2626844px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1" />
-    </g>
-  </g>
-</svg>

Robust.Analyzers/Diagnostics.cs

@@ -1,10 +1,14 @@
 using Microsoft.CodeAnalysis;
 
-namespace Robust.Generators
+namespace Robust.Analyzers;
+
+public static class Diagnostics
 {
-    public static class Diagnostics
-    {
-        public static SuppressionDescriptor MeansImplicitAssignment =>
-            new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");
-    }
+    public const string IdExplicitInterface = "RA0000";
+    public const string IdSerializable = "RA0001";
+    public const string IdFriend = "RA0002";
+    public const string IdExplicitVirtual = "RA0003";
+
+    public static SuppressionDescriptor MeansImplicitAssignment =>
+        new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");
 }

Robust.Analyzers/ExplicitInterfaceAnalyzer.cs

@@ -24,14 +24,14 @@ namespace Robust.Analyzers
             SyntaxKind.OverrideKeyword
         };
 
-        public const string DiagnosticId = "RA0000";
-
-        private const string Title = "No explicit interface specified";
-        private const string MessageFormat = "No explicit interface specified";
-        private const string Description = "Make sure to specify the interface in your method-declaration.";
-        private const string Category = "Usage";
-
-        [SuppressMessage("ReSharper", "RS2008")] private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, description: Description);
+        [SuppressMessage("ReSharper", "RS2008")] private static readonly DiagnosticDescriptor Rule = new(
+            Diagnostics.IdExplicitInterface,
+            "No explicit interface specified",
+            "No explicit interface specified",
+            "Usage",
+            DiagnosticSeverity.Warning,
+            isEnabledByDefault: true,
+            description: "Make sure to specify the interface in your method-declaration.");
 
         private const string RequiresExplicitImplementationAttributeMetadataName =
             "Robust.Shared.Analyzers.RequiresExplicitImplementationAttribute";

Robust.Analyzers/ExplicitVirtualAnalyzer.cs

@@ -0,0 +1,176 @@
+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 sealed class ExplicitVirtualAnalyzer : DiagnosticAnalyzer
+{
+    internal const string Attribute = "Robust.Shared.Analyzers.VirtualAttribute";
+
+    [SuppressMessage("ReSharper", "RS2008")]
+    private static readonly DiagnosticDescriptor Rule = new(
+        Diagnostics.IdExplicitVirtual,
+        "Class must be explicitly marked as [Virtual], abstract, static or sealed",
+        "Class must be explicitly marked as [Virtual], abstract, static or sealed",
+        "Usage",
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        description: "Class must be explicitly marked as [Virtual], abstract, static or sealed.");
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.ClassDeclaration);
+    }
+
+    private static bool HasAttribute(INamedTypeSymbol namedTypeSymbol, INamedTypeSymbol attrSymbol)
+    {
+        return namedTypeSymbol.GetAttributes()
+            .Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attrSymbol));
+    }
+
+    private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
+    {
+        var attrSymbol = context.Compilation.GetTypeByMetadataName(Attribute);
+        var classDecl = (ClassDeclarationSyntax)context.Node;
+        var classSymbol = context.SemanticModel.GetDeclaredSymbol(classDecl);
+        if (classSymbol == null)
+            return;
+
+        if (classSymbol.IsSealed || classSymbol.IsAbstract || classSymbol.IsStatic)
+            return;
+
+        if (HasAttribute(classSymbol, attrSymbol))
+            return;
+
+        var diag = Diagnostic.Create(Rule, classDecl.Keyword.GetLocation());
+        context.ReportDiagnostic(diag);
+    }
+}
+
+// Doesn't work as I'd hoped: Roslyn doesn't provide an API for global usings and I can't get batch changes to work.
+/*
+[ExportCodeFixProvider(LanguageNames.CSharp)]
+public sealed class ExplicitVirtualCodeFixProvider : CodeFixProvider
+{
+    private const string TitleSealed = "Annotate class as sealed.";
+    private const string TitleVirtual = "Annotate class as [Virtual].";
+    private const string TitleAbstract = "Annotate class as abstract.";
+    private const string TitleStatic = "Annotate class as static.";
+
+    public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+
+        foreach (var diagnostic in context.Diagnostics)
+        {
+            var span = diagnostic.Location.SourceSpan;
+            var classDecl = root.FindToken(span.Start).Parent.AncestorsAndSelf().OfType<ClassDeclarationSyntax>()
+                .First();
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    TitleVirtual,
+                    c => FixVirtualAsync(context.Document, classDecl, c),
+                    TitleVirtual),
+                diagnostic);
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    TitleStatic,
+                    c => FixStaticAsync(context.Document, classDecl, c),
+                    TitleStatic),
+                diagnostic);
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    TitleSealed,
+                    c => FixSealedAsync(context.Document, classDecl, c),
+                    TitleSealed),
+                diagnostic);
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    TitleAbstract,
+                    c => FixAbstractAsync(context.Document, classDecl, c),
+                    TitleAbstract),
+                diagnostic);
+        }
+    }
+
+    private async Task<Document> FixVirtualAsync(
+        Document document,
+        ClassDeclarationSyntax classDecl,
+        CancellationToken cancellationToken)
+    {
+        var ns = "Robust.Shared.Analyzers";
+        var attrib = SyntaxFactory.Attribute(SyntaxFactory.ParseName("Virtual"));
+
+        var newClassDecl = classDecl.AddAttributeLists(
+            SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList(new[] { attrib })));
+
+        var root = (CompilationUnitSyntax)await document.GetSyntaxRootAsync(cancellationToken);
+        root = root.ReplaceNode(classDecl, newClassDecl);
+
+        var options = await document.GetOptionsAsync(cancellationToken);
+
+        if (root.Usings.All(u => u.Name.ToString() != ns))
+        {
+            root = root.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(ns)));
+        }
+
+        return document.WithSyntaxRoot(root);
+    }
+
+    private async Task<Document> FixStaticAsync(
+        Document document,
+        ClassDeclarationSyntax classDecl,
+        CancellationToken cancellationToken)
+    {
+        var newClassDecl = classDecl.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword));
+
+        var root = (CompilationUnitSyntax)await document.GetSyntaxRootAsync(cancellationToken);
+        root = root.ReplaceNode(classDecl, newClassDecl);
+
+        return document.WithSyntaxRoot(root);
+    }
+
+    private async Task<Document> FixAbstractAsync(
+        Document document,
+        ClassDeclarationSyntax classDecl,
+        CancellationToken cancellationToken)
+    {
+        var newClassDecl = classDecl.AddModifiers(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
+
+        var root = (CompilationUnitSyntax)await document.GetSyntaxRootAsync(cancellationToken);
+        root = root.ReplaceNode(classDecl, newClassDecl);
+
+        return document.WithSyntaxRoot(root);
+    }
+
+    private async Task<Document> FixSealedAsync(
+        Document document,
+        ClassDeclarationSyntax classDecl,
+        CancellationToken cancellationToken)
+    {
+        var newClassDecl = classDecl.AddModifiers(SyntaxFactory.Token(SyntaxKind.SealedKeyword));
+
+        var root = (CompilationUnitSyntax)await document.GetSyntaxRootAsync(cancellationToken);
+        root = root.ReplaceNode(classDecl, newClassDecl);
+
+        return document.WithSyntaxRoot(root);
+    }
+
+    public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+    public override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(Diagnostics.IdExplicitVirtual);
+}
+*/

Robust.Analyzers/FriendAnalyzer.cs

@@ -14,15 +14,15 @@ namespace Robust.Analyzers
     {
         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);
+        private static readonly DiagnosticDescriptor Rule = new (
+            Diagnostics.IdFriend,
+            "Tried to access friend-only member",
+            "Tried to access member \"{0}\" in class \"{1}\" which can only be accessed by friend classes",
+            "Usage",
+            DiagnosticSeverity.Error,
+            true,
+            "Make sure to specify the accessing class in the friends attribute.");
 
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 

Robust.Analyzers/MeansImplicitAssigmentSuppressor.cs

@@ -1,9 +1,7 @@
-using System;
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Robust.Generators;
 
 namespace Robust.Analyzers
 {

Robust.Analyzers/Robust.Analyzers.csproj

@@ -2,13 +2,13 @@
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
-    <LangVersion>9</LangVersion>
+    <LangVersion>10</LangVersion>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="3.8.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.0.1" />
   </ItemGroup>
 
 </Project>

Robust.Analyzers/SerializableAnalyzer.cs

@@ -17,19 +17,21 @@ namespace Robust.Analyzers
     public class SerializableAnalyzer : DiagnosticAnalyzer
     {
         // Metadata of the analyzer
-        public const string DiagnosticId = "RA0001";
 
         // You could use LocalizedString but it's a little more complicated for this sample
-        private const string Title = "Class not marked as (Net)Serializable";
-        private const string MessageFormat = "Class not marked as (Net)Serializable";
-        private const string Description = "The class should be marked as (Net)Serializable.";
-        private const string Category = "Usage";
 
         private const string RequiresSerializableAttributeMetadataName = "Robust.Shared.Analyzers.RequiresSerializableAttribute";
         private const string SerializableAttributeMetadataName = "System.SerializableAttribute";
         private const string NetSerializableAttributeMetadataName = "Robust.Shared.Serialization.NetSerializableAttribute";
 
-        [SuppressMessage("ReSharper", "RS2008")] private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, description: Description);
+        [SuppressMessage("ReSharper", "RS2008")] private static readonly DiagnosticDescriptor Rule = new(
+            Diagnostics.IdSerializable,
+            "Class not marked as (Net)Serializable",
+            "Class not marked as (Net)Serializable",
+            "Usage",
+            DiagnosticSeverity.Warning,
+            isEnabledByDefault: true,
+            description: "The class should be marked as (Net)Serializable.");
 
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
@@ -139,7 +141,8 @@ namespace Robust.Analyzers
             return document.WithSyntaxRoot(root);
         }
 
-        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(SerializableAnalyzer.DiagnosticId);
+        public sealed override ImmutableArray<string> FixableDiagnosticIds
+            => ImmutableArray.Create(Diagnostics.IdSerializable);
 
         public override FixAllProvider GetFixAllProvider()
         {

Robust.Benchmarks/Configs/DefaultSQLConfig.cs

@@ -0,0 +1,53 @@
+using System.Collections.Generic;
+using System.Globalization;
+using BenchmarkDotNet.Analysers;
+using BenchmarkDotNet.Columns;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Diagnosers;
+using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Filters;
+using BenchmarkDotNet.Jobs;
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Order;
+using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Validators;
+using Robust.Benchmarks.Exporters;
+
+namespace Robust.Benchmarks.Configs;
+
+public sealed class DefaultSQLConfig : IConfig
+{
+    public static readonly IConfig Instance = new DefaultSQLConfig();
+
+    private DefaultSQLConfig(){}
+
+    public IEnumerable<IExporter> GetExporters()
+    {
+        yield return SQLExporter.Default;
+    }
+
+    public IEnumerable<IColumnProvider> GetColumnProviders() => DefaultConfig.Instance.GetColumnProviders();
+
+    public IEnumerable<ILogger> GetLoggers() => DefaultConfig.Instance.GetLoggers();
+
+    public IEnumerable<IDiagnoser> GetDiagnosers() => DefaultConfig.Instance.GetDiagnosers();
+
+    public IEnumerable<IAnalyser> GetAnalysers() => DefaultConfig.Instance.GetAnalysers();
+
+    public IEnumerable<Job> GetJobs() => DefaultConfig.Instance.GetJobs();
+
+    public IEnumerable<IValidator> GetValidators() => DefaultConfig.Instance.GetValidators();
+
+    public IEnumerable<HardwareCounter> GetHardwareCounters() => DefaultConfig.Instance.GetHardwareCounters();
+
+    public IEnumerable<IFilter> GetFilters() => DefaultConfig.Instance.GetFilters();
+
+    public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => DefaultConfig.Instance.GetLogicalGroupRules();
+
+    public IOrderer Orderer => DefaultConfig.Instance.Orderer!;
+    public SummaryStyle SummaryStyle => DefaultConfig.Instance.SummaryStyle;
+    public ConfigUnionRule UnionRule => DefaultConfig.Instance.UnionRule;
+    public string ArtifactsPath => DefaultConfig.Instance.ArtifactsPath;
+    public CultureInfo CultureInfo => DefaultConfig.Instance.CultureInfo!;
+    public ConfigOptions Options => DefaultConfig.Instance.Options;
+}

Robust.Benchmarks/EntityManager/AddRemoveComponentBenchmark.cs

@@ -0,0 +1,54 @@
+using BenchmarkDotNet.Attributes;
+using JetBrains.Annotations;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.EntityManager;
+
+[Virtual]
+public class AddRemoveComponentBenchmark
+{
+    private ISimulation _simulation = default!;
+    private IEntityManager _entityManager = default!;
+
+    [UsedImplicitly]
+    [Params(1, 10, 100, 1000)]
+    public int N;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _simulation = RobustServerSimulation
+            .NewSimulation()
+            .RegisterComponents(f => f.RegisterClass<A>())
+            .InitializeInstance();
+
+        _entityManager = _simulation.Resolve<IEntityManager>();
+
+        var coords = new MapCoordinates(0, 0, new MapId(1));
+        _simulation.AddMap(coords.MapId);
+
+        for (var i = 0; i < N; i++)
+        {
+            _entityManager.SpawnEntity(null, coords);
+        }
+    }
+
+    [Benchmark]
+    public void AddRemoveComponent()
+    {
+        for (var i = 2; i <= N+1; i++)
+        {
+            var uid = new EntityUid(i);
+            _entityManager.AddComponent<A>(uid);
+            _entityManager.RemoveComponent<A>(uid);
+        }
+    }
+
+    [ComponentProtoName("A")]
+    public sealed class A : Component
+    {
+    }
+}

Robust.Benchmarks/EntityManager/GetComponentBenchmark.cs

@@ -0,0 +1,61 @@
+using System;
+using BenchmarkDotNet.Attributes;
+using JetBrains.Annotations;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.EntityManager;
+
+[Virtual]
+public class GetComponentBenchmark
+{
+    private ISimulation _simulation = default!;
+    private IEntityManager _entityManager = default!;
+
+    [UsedImplicitly]
+    [Params(1, 10, 100, 1000)]
+    public int N;
+
+    public A[] Comps = default!;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _simulation = RobustServerSimulation
+            .NewSimulation()
+            .RegisterComponents(f => f.RegisterClass<A>())
+            .InitializeInstance();
+
+        _entityManager = _simulation.Resolve<IEntityManager>();
+
+        Comps = new A[N+2];
+
+        var coords = new MapCoordinates(0, 0, new MapId(1));
+        _simulation.AddMap(coords.MapId);
+
+        for (var i = 0; i < N; i++)
+        {
+            var uid = _entityManager.SpawnEntity(null, coords);
+            _entityManager.AddComponent<A>(uid);
+        }
+    }
+
+    [Benchmark]
+    public A[] GetComponent()
+    {
+        for (var i = 2; i <= N+1; i++)
+        {
+            Comps[i] = _entityManager.GetComponent<A>(new EntityUid(i));
+        }
+
+        // Return something so the JIT doesn't optimize out all the GetComponent calls.
+        return Comps;
+    }
+
+    [ComponentProtoName("A")]
+    public sealed class A : Component
+    {
+    }
+}

Robust.Benchmarks/EntityManager/SpawnDeleteEntityBenchmark.cs

@@ -0,0 +1,62 @@
+using BenchmarkDotNet.Attributes;
+using JetBrains.Annotations;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.EntityManager;
+
+[Virtual]
+public class SpawnDeleteEntityBenchmark
+{
+    private ISimulation _simulation = default!;
+    private IEntityManager _entityManager = default!;
+
+    private MapCoordinates _mapCoords = MapCoordinates.Nullspace;
+    private EntityCoordinates _entCoords = EntityCoordinates.Invalid;
+
+    [UsedImplicitly]
+    [Params(1, 10, 100, 1000)]
+    public int N;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _simulation = RobustServerSimulation
+            .NewSimulation()
+            .RegisterComponents(f => f.RegisterClass<A>())
+            .InitializeInstance();
+
+        _entityManager = _simulation.Resolve<IEntityManager>();
+
+        _mapCoords = new MapCoordinates(0, 0, new MapId(1));
+        var uid = _simulation.AddMap(_mapCoords.MapId);
+        _entCoords = new EntityCoordinates(uid, 0, 0);
+    }
+
+    [Benchmark(Baseline = true)]
+    public void SpawnDeleteEntityMapCoords()
+    {
+        for (var i = 0; i < N; i++)
+        {
+            var uid = _entityManager.SpawnEntity(null, _mapCoords);
+            _entityManager.DeleteEntity(uid);
+        }
+    }
+
+    [Benchmark]
+    public void SpawnDeleteEntityEntCoords()
+    {
+        for (var i = 0; i < N; i++)
+        {
+            var uid = _entityManager.SpawnEntity(null, _entCoords);
+            _entityManager.DeleteEntity(uid);
+        }
+    }
+
+    [ComponentProtoName("A")]
+    public sealed class A : Component
+    {
+    }
+}

Robust.Benchmarks/Exporters/SQLExporter.cs

@@ -0,0 +1,143 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using BenchmarkDotNet.Exporters;
+using BenchmarkDotNet.Loggers;
+using BenchmarkDotNet.Mathematics;
+using BenchmarkDotNet.Reports;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Design;
+using Npgsql;
+
+namespace Robust.Benchmarks.Exporters;
+
+public sealed class SQLExporter : IExporter
+{
+    public static readonly IExporter Default = new SQLExporter();
+
+    private SQLExporter(){}
+
+    public void ExportToLog(Summary summary, ILogger logger)
+    {
+        Export(summary, logger);
+    }
+
+    public IEnumerable<string> ExportToFiles(Summary summary, ILogger consoleLogger)
+    {
+        Export(summary, consoleLogger);
+        return Array.Empty<string>();
+    }
+
+    private bool TryGetEnvironmentVariable(string name, ILogger logger, [NotNullWhen(true)] out string? value)
+    {
+        value = Environment.GetEnvironmentVariable(name);
+        if (value == null)
+            logger.WriteError($"ROBUST_BENCHMARKS_ENABLE_SQL is set, but {name} is missing.");
+        return value != null;
+    }
+
+    private void Export(Summary summary, ILogger logger)
+    {
+        if (!TryGetEnvironmentVariable("ROBUST_BENCHMARKS_SQL_ADDRESS", logger, out var address) ||
+            !TryGetEnvironmentVariable("ROBUST_BENCHMARKS_SQL_PORT", logger, out var rawPort) ||
+            !TryGetEnvironmentVariable("ROBUST_BENCHMARKS_SQL_USER", logger, out var user) ||
+            !TryGetEnvironmentVariable("ROBUST_BENCHMARKS_SQL_PASSWORD", logger, out var password) ||
+            !TryGetEnvironmentVariable("ROBUST_BENCHMARKS_SQL_DATABASE", logger, out var db) ||
+            !TryGetEnvironmentVariable("GITHUB_SHA", logger, out var gitHash))
+            return;
+
+        if (!int.TryParse(rawPort, out var port))
+        {
+            logger.WriteError("Failed parsing ROBUST_BENCHMARKS_SQL_PORT to int.");
+            return;
+        }
+
+        var builder = new DbContextOptionsBuilder<BenchmarkContext>();
+        var connectionString = new NpgsqlConnectionStringBuilder
+        {
+            Host = address,
+            Port = port,
+            Database = db,
+            Username = user,
+            Password = password
+        }.ConnectionString;
+        builder.UseNpgsql(connectionString);
+        using var ctx = new BenchmarkContext(builder.Options);
+        try
+        {
+            ctx.Database.Migrate();
+            ctx.BenchmarkRuns.Add(BenchmarkRun.FromSummary(summary, gitHash));
+            ctx.SaveChanges();
+        }
+        finally
+        {
+            ctx.Dispose();
+        }
+    }
+
+    public string Name => "sql";
+}
+
+public sealed class DesignTimeContextFactoryPostgres : IDesignTimeDbContextFactory<BenchmarkContext>
+{
+    public BenchmarkContext CreateDbContext(string[] args)
+    {
+        var optionsBuilder = new DbContextOptionsBuilder<BenchmarkContext>();
+        optionsBuilder.UseNpgsql("Server=localhost");
+        return new BenchmarkContext(optionsBuilder.Options);
+    }
+}
+
+public class BenchmarkContext : DbContext
+{
+    public DbSet<BenchmarkRun> BenchmarkRuns { get; set; } = default!;
+
+    public BenchmarkContext() { }
+    public BenchmarkContext(DbContextOptions<BenchmarkContext> options) : base(options) { }
+}
+
+public class BenchmarkRun
+{
+    [Key, DatabaseGenerated(DatabaseGeneratedOption.Identity)]
+    public ulong Id { get; set; }
+    public string GitHash { get; set; } = string.Empty;
+    [Column(TypeName = "timestamptz")]
+    public DateTime RunDate { get; set; }
+    public string Name { get; set; } = string.Empty;
+    [Column(TypeName = "jsonb")]
+    public BenchmarkRunReport[] Reports { get; set; } = Array.Empty<BenchmarkRunReport>();
+
+    public static BenchmarkRun FromSummary(Summary summary, string gitHash)
+    {
+        return new BenchmarkRun
+        {
+            Reports = summary.Reports.Select(r => new BenchmarkRunReport
+            {
+                Parameters = r.BenchmarkCase.Parameters.Items.Select(p => new BenchmarkRunParameter
+                {
+                    Name = p.Name,
+                    Value = p.Value
+                }).ToArray(),
+                Statistics = r.ResultStatistics
+            }).ToArray(),
+            Name = summary.BenchmarksCases.First().FolderInfo,
+            RunDate = DateTime.UtcNow,
+            GitHash = gitHash
+        };
+    }
+}
+
+public class BenchmarkRunReport
+{
+    public BenchmarkRunParameter[] Parameters { get; set; } = Array.Empty<BenchmarkRunParameter>();
+    public Statistics Statistics { get; set; } = default!;
+}
+
+public class BenchmarkRunParameter
+{
+    public string Name { get; set; } = string.Empty;
+    public object Value { get; set; } = default!;
+}

Robust.Benchmarks/Migrations/20220328231938_InitialCreate.Designer.cs

@@ -0,0 +1,55 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Robust.Benchmarks.Exporters;
+
+#nullable disable
+
+namespace Robust.Benchmarks.Migrations
+{
+    [DbContext(typeof(BenchmarkContext))]
+    [Migration("20220328231938_InitialCreate")]
+    partial class InitialCreate
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Robust.Benchmarks.Exporters.BenchmarkRun", b =>
+                {
+                    b.Property<decimal>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<string>("GitHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<BenchmarkRunReport[]>("Reports")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("RunDate")
+                        .HasColumnType("Date");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("BenchmarkRuns");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Robust.Benchmarks/Migrations/20220328231938_InitialCreate.cs

@@ -0,0 +1,35 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Robust.Benchmarks.Exporters;
+
+#nullable disable
+
+namespace Robust.Benchmarks.Migrations
+{
+    public partial class InitialCreate : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "BenchmarkRuns",
+                columns: table => new
+                {
+                    Id = table.Column<decimal>(type: "numeric(20,0)", nullable: false),
+                    GitHash = table.Column<string>(type: "text", nullable: false),
+                    RunDate = table.Column<DateTime>(type: "Date", nullable: false),
+                    Name = table.Column<string>(type: "text", nullable: false),
+                    Reports = table.Column<BenchmarkRunReport[]>(type: "jsonb", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_BenchmarkRuns", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "BenchmarkRuns");
+        }
+    }
+}

Robust.Benchmarks/Migrations/BenchmarkContextModelSnapshot.cs

@@ -0,0 +1,53 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Robust.Benchmarks.Exporters;
+
+#nullable disable
+
+namespace Robust.Benchmarks.Migrations
+{
+    [DbContext(typeof(BenchmarkContext))]
+    partial class BenchmarkContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "6.0.0")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("Robust.Benchmarks.Exporters.BenchmarkRun", b =>
+                {
+                    b.Property<decimal>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("numeric(20,0)");
+
+                    b.Property<string>("GitHash")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<BenchmarkRunReport[]>("Reports")
+                        .IsRequired()
+                        .HasColumnType("jsonb");
+
+                    b.Property<DateTime>("RunDate")
+                        .HasColumnType("Date");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("BenchmarkRuns");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

Robust.Benchmarks/NumericsHelpers/AddBenchmark.cs

@@ -1,12 +1,17 @@
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 
 namespace Robust.Benchmarks.NumericsHelpers
 {
+    [Virtual]
     public class AddBenchmark
     {
         [Params(32, 128)]
         public int N { get; set; }
 
+        [Params(1,2)]
+        public int T { get; set; }
+
         private float[] _inputA = default!;
         private float[] _inputB = default!;
         private float[] _output = default!;

Robust.Benchmarks/Program.cs

@@ -1,14 +1,26 @@
-using BenchmarkDotNet.Running;
+using BenchmarkDotNet.Configs;
+using BenchmarkDotNet.Running;
+using System;
+using Robust.Benchmarks.Configs;
+using Robust.Benchmarks.Exporters;
 
 namespace Robust.Benchmarks
 {
-    internal class Program
+    internal static class Program
     {
         // --allCategories=ctg1,ctg2
         // --anyCategories=ctg1,ctg2
         public static void Main(string[] args)
         {
-            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+#if DEBUG
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("\nWARNING: YOU ARE RUNNING A DEBUG BUILD, USE A RELEASE BUILD FOR AN ACCURATE BENCHMARK");
+            Console.WriteLine("THE DEBUG BUILD IS ONLY GOOD FOR FIXING A CRASHING BENCHMARK\n");
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, new DebugInProcessConfig());
+#else
+            var config = Environment.GetEnvironmentVariable("ROBUST_BENCHMARKS_ENABLE_SQL") != null ? DefaultSQLConfig.Instance : null;
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
+#endif
         }
     }
 }

Robust.Benchmarks/Robust.Benchmarks.csproj

@@ -10,9 +10,15 @@
     <ItemGroup>
       <ProjectReference Include="..\Robust.Server\Robust.Server.csproj" />
       <ProjectReference Include="..\Robust.Shared\Robust.Shared.csproj" />
+      <ProjectReference Include="..\Robust.UnitTesting\Robust.UnitTesting.csproj" />
     </ItemGroup>
     <ItemGroup>
       <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+      <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="6.0.0">
+        <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        <PrivateAssets>all</PrivateAssets>
+      </PackageReference>
+      <PackageReference Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="6.0.0-rc.2" />
     </ItemGroup>
     <Import Project="..\MSBuild\Robust.Engine.targets" />
 </Project>

Robust.Benchmarks/Serialization/BenchmarkIntSerializer.cs

@@ -9,7 +9,7 @@ using Robust.Shared.Serialization.TypeSerializers.Interfaces;
 
 namespace Robust.Benchmarks.Serialization
 {
-    public class BenchmarkIntSerializer : ITypeSerializer<int, ValueDataNode>
+    public sealed class BenchmarkIntSerializer : ITypeSerializer<int, ValueDataNode>
     {
         public ValidationNode Validate(ISerializationManager serializationManager, ValueDataNode node,
             IDependencyCollection dependencies, ISerializationContext? context = null)

Robust.Benchmarks/Serialization/Copy/SerializationCopyBenchmark.cs

@@ -2,6 +2,7 @@
 using System.Linq;
 using BenchmarkDotNet.Attributes;
 using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
@@ -13,6 +14,7 @@ using YamlDotNet.RepresentationModel;
 namespace Robust.Benchmarks.Serialization.Copy
 {
     [MemoryDiagnoser]
+    [Virtual]
     public class SerializationCopyBenchmark : SerializationBenchmark
     {
         public SerializationCopyBenchmark()

Robust.Benchmarks/Serialization/Definitions/BenchmarkFlags.cs

@@ -3,7 +3,7 @@ using Robust.Shared.Serialization;
 
 namespace Robust.Benchmarks.Serialization.Definitions
 {
-    public class BenchmarkFlags
+    public sealed class BenchmarkFlags
     {
         public const int Zero = 1 << 0;
         public const int ThirtyOne = 1 << 31;

Robust.Benchmarks/Serialization/Definitions/DataDefinitionWithString.cs

@@ -1,8 +1,10 @@
-using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.Analyzers;
+using Robust.Shared.Serialization.Manager.Attributes;
 
 namespace Robust.Benchmarks.Serialization.Definitions
 {
     [DataDefinition]
+    [Virtual]
     public class DataDefinitionWithString
     {
         [DataField("string")]

Robust.Benchmarks/Serialization/Definitions/SeedDataDefinition.cs

@@ -11,7 +11,7 @@ namespace Robust.Benchmarks.Serialization.Definitions
     ///     Taken from content.
     /// </summary>
     [Prototype("seed")]
-    public class SeedDataDefinition : IPrototype
+    public sealed class SeedDataDefinition : IPrototype
     {
         public const string Prototype = @"
 - type: seed

Robust.Benchmarks/Serialization/Initialize/SerializationInitializeBenchmark.cs

@@ -1,9 +1,11 @@
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Serialization.Manager;
 
 namespace Robust.Benchmarks.Serialization.Initialize
 {
     [MemoryDiagnoser]
+    [Virtual]
     public class SerializationInitializeBenchmark : SerializationBenchmark
     {
         [IterationCleanup]

Robust.Benchmarks/Serialization/Read/SerializationReadBenchmark.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using BenchmarkDotNet.Attributes;
 using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Serialization.Manager.Result;
 using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
@@ -12,6 +13,7 @@ using YamlDotNet.RepresentationModel;
 namespace Robust.Benchmarks.Serialization.Read
 {
     [MemoryDiagnoser]
+    [Virtual]
     public class SerializationReadBenchmark : SerializationBenchmark
     {
         public SerializationReadBenchmark()

Robust.Benchmarks/Serialization/SerializationArrayBenchmark.cs

@@ -1,5 +1,6 @@
 using BenchmarkDotNet.Attributes;
 using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Sequence;
 using Robust.Shared.Serialization.Markdown.Value;
@@ -7,6 +8,7 @@ using Robust.Shared.Serialization.Markdown.Value;
 namespace Robust.Benchmarks.Serialization
 {
     [MemoryDiagnoser]
+    [Virtual]
     public class SerializationArrayBenchmark : SerializationBenchmark
     {
         public SerializationArrayBenchmark()

Robust.Benchmarks/Serialization/Write/SerializationWriteBenchmark.cs

@@ -2,6 +2,7 @@
 using System.IO;
 using BenchmarkDotNet.Attributes;
 using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
@@ -13,6 +14,7 @@ using YamlDotNet.RepresentationModel;
 namespace Robust.Benchmarks.Serialization.Write
 {
     [MemoryDiagnoser]
+    [Virtual]
     public class SerializationWriteBenchmark : SerializationBenchmark
     {
         public SerializationWriteBenchmark()

Robust.Benchmarks/add-migration.ps1

@@ -0,0 +1,11 @@
+#!/usr/bin/env pwsh
+
+param([String]$name)
+
+if ($name -eq "")
+{
+    Write-Error "must specify migration name"
+    exit
+}
+
+dotnet ef migrations add --context BenchmarkContext -o Migrations $name

Robust.Benchmarks/add-migration.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+
+if [ -z "$1" ] ; then
+    echo "Must specify migration name"
+    exit 1
+fi
+
+dotnet ef migrations add --context BenchmarkContext -o Migrations "$1"

Robust.Client.Injectors/Robust.Client.Injectors.csproj

@@ -6,7 +6,7 @@
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="Microsoft.Build.Framework" Version="16.8.0" />
+      <PackageReference Include="Microsoft.Build.Framework" Version="17.0.0" />
       <PackageReference Include="Mono.Cecil" Version="0.11.3" />
       <PackageReference Include="Pidgin" Version="2.5.0" />
     </ItemGroup>

Robust.Client.NameGenerator/Robust.Client.NameGenerator.csproj

@@ -5,8 +5,8 @@
     </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" PrivateAssets="all" />
   </ItemGroup>
 
   <ItemGroup>

Robust.Client.NameGenerator/XamlUiPartialClassGenerator.cs

@@ -301,7 +301,7 @@ namespace {nameSpace}
             foreach (var candidateClass in receiver.CandidateClasses)
             {
                 var model = compilation.GetSemanticModel(candidateClass.SyntaxTree);
-                var typeSymbol = (INamedTypeSymbol) model.GetDeclaredSymbol(candidateClass);
+                var typeSymbol = model.GetDeclaredSymbol(candidateClass);
                 var relevantAttribute = typeSymbol.GetAttributes().FirstOrDefault(attr =>
                     attr.AttributeClass != null &&
                     attr.AttributeClass.Equals(attributeSymbol, SymbolEqualityComparer.Default));

Robust.Client.WebView/Cef/ImageBuffer.cs

@@ -9,14 +9,16 @@ namespace Robust.Client.WebView.Cef
 {
     internal sealed class ImageBuffer
     {
-        public Image<Bgra32> Buffer { get; private set; } = new(1, 1);
+        public Image<Rgba32> 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);
+            // NOTE: Image data from CEF is actually BGRA32, not RGBA32.
+            // OpenGL ES does not allow uploading BGRA data, so we pretend it's RGBA32 and use a shader to swizzle it.
+            var span = new ReadOnlySpan<Rgba32>((void*) buffer, width * height);
 
             ImageSharpExt.Blit(
                 span,
@@ -28,7 +30,7 @@ namespace Robust.Client.WebView.Cef
 
         private void UpdateSize(int width, int height)
         {
-            Buffer = new Image<Bgra32>(width, height);
+            Buffer = new Image<Rgba32>(width, height);
         }
     }
 }

Robust.Client.WebView/Cef/WebViewManagerCef.Control.cs

@@ -18,7 +18,9 @@ namespace Robust.Client.WebView.Cef
     {
         public IWebViewControlImpl MakeControlImpl(WebViewControl owner)
         {
-            var impl =  new ControlImpl(owner);
+            var shader = _prototypeManager.Index<ShaderPrototype>("bgra");
+            var shaderInstance = shader.Instance();
+            var impl =  new ControlImpl(owner, shaderInstance);
             _dependencyCollection.InjectDependencies(impl);
             return impl;
         }
@@ -131,10 +133,12 @@ namespace Robust.Client.WebView.Cef
             [Dependency] private readonly IInputManager _inputMgr = default!;
 
             public readonly WebViewControl Owner;
+            private readonly ShaderInstance _shaderInstance;
 
-            public ControlImpl(WebViewControl owner)
+            public ControlImpl(WebViewControl owner, ShaderInstance shaderInstance)
             {
                 Owner = owner;
+                _shaderInstance = shaderInstance;
             }
 
             private const int ScrollSpeed = 50;
@@ -183,7 +187,7 @@ namespace Robust.Client.WebView.Cef
                 // 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);
+                var texture = _clyde.CreateBlankTexture<Rgba32>(Vector2i.One);
 
                 _data = new LiveData(texture, client, browser, renderer);
             }
@@ -386,7 +390,7 @@ namespace Robust.Client.WebView.Cef
                 _data.Browser.GetHost().NotifyMoveOrResizeStarted();
                 _data.Browser.GetHost().WasResized();
                 _data.Texture.Dispose();
-                _data.Texture = _clyde.CreateBlankTexture<Bgra32>((Owner.PixelWidth, Owner.PixelHeight));
+                _data.Texture = _clyde.CreateBlankTexture<Rgba32>((Owner.PixelWidth, Owner.PixelHeight));
             }
 
             public void Draw(DrawingHandleScreen handle)
@@ -404,6 +408,7 @@ namespace Robust.Client.WebView.Cef
                         Math.Min(Owner.PixelWidth, bufImg.Width),
                         Math.Min(Owner.PixelHeight, bufImg.Height)));
 
+                handle.UseShader(_shaderInstance);
                 handle.DrawTexture(_data.Texture, Vector2.Zero);
             }
 
@@ -533,8 +538,7 @@ namespace Robust.Client.WebView.Cef
                 if (_control.Owner.Disposed)
                     return false;
 
-                // TODO CEF: Get actual scale factor?
-                screenInfo.DeviceScaleFactor = 1.0f;
+                screenInfo.DeviceScaleFactor = _control.Owner.UIScale;
 
                 return true;
             }

Robust.Client.WebView/Cef/WebViewManagerCef.cs

@@ -1,17 +1,22 @@
 using System;
 using System.IO;
+using System.Reflection;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Prototypes;
 using Xilium.CefGlue;
 
 namespace Robust.Client.WebView.Cef
 {
     internal partial class WebViewManagerCef : IWebViewManagerImpl
     {
+        private static readonly string BasePath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location!)!;
+
         private CefApp _app = default!;
 
         [Dependency] private readonly IDependencyCollection _dependencyCollection = default!;
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
 
         public void Initialize()
         {
@@ -25,7 +30,7 @@ namespace Robust.Client.WebView.Cef
             else
                 throw new NotSupportedException("Unsupported platform for CEF!");
 
-            var subProcessPath = PathHelpers.ExecutableRelativeFile(subProcessName);
+            var subProcessPath = Path.Combine(BasePath, subProcessName);
             var cefResourcesPath = LocateCefResources();
 
             // System.Console.WriteLine(AppContext.GetData("NATIVE_DLL_SEARCH_DIRECTORIES"));
@@ -58,7 +63,7 @@ namespace Robust.Client.WebView.Cef
 
         private static string? LocateCefResources()
         {
-            if (ProbeDir(PathHelpers.GetExecutableDirectory(), out var path))
+            if (ProbeDir(BasePath, out var path))
                 return path;
 
 

Robust.Client.WebView/Robust.Client.WebView.csproj

@@ -3,8 +3,7 @@
   <Import Project="..\MSBuild\Robust.Engine.props" />
 
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
-    <PlatformTarget>x64</PlatformTarget>
+    <TargetFramework>net6.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <OutputType>WinExe</OutputType>
   </PropertyGroup>
@@ -15,7 +14,6 @@
 
   <ItemGroup>
     <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" />
-    <PackageReference Include="System.Drawing.Common" Version="5.0.2" />
     <PackageReference Include="Robust.Natives.Cef" Version="95.7.14" />
   </ItemGroup>
 

Robust.Client/Animations/AnimationTrackComponentProperty.cs

@@ -2,6 +2,7 @@ using System;
 using JetBrains.Annotations;
 using Robust.Shared.Animations;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 
 namespace Robust.Client.Animations
 {
@@ -18,8 +19,8 @@ namespace Robust.Client.Animations
                 throw new InvalidOperationException("Must set parameters to non-null values.");
             }
 
-            var entity = (IEntity) context;
-            var component = entity.GetComponent(ComponentType);
+            var entity = (EntityUid) context;
+            var component = IoCManager.Resolve<IEntityManager>().GetComponent(entity, ComponentType);
 
             if (component is IAnimationProperties properties)
             {

Robust.Client/Animations/AnimationTrackControlProperty.cs

@@ -3,7 +3,7 @@ using Robust.Shared.Animations;
 
 namespace Robust.Client.Animations
 {
-    public class AnimationTrackControlProperty : AnimationTrackProperty
+    public sealed class AnimationTrackControlProperty : AnimationTrackProperty
     {
         public string? Property { get; set; }
 

Robust.Client/Animations/AnimationTrackPlaySound.cs

@@ -25,7 +25,7 @@ namespace Robust.Client.Animations
         public override (int KeyFrameIndex, float FramePlayingTime)
             AdvancePlayback(object context, int prevKeyFrameIndex, float prevPlayingTime, float frameTime)
         {
-            var entity = (IEntity) context;
+            var entity = (EntityUid) context;
 
             var playingTime = prevPlayingTime + frameTime;
             var keyFrameIndex = prevKeyFrameIndex;

Robust.Client/Animations/AnimationTrackSpriteFlick.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.Animations
@@ -38,8 +39,8 @@ namespace Robust.Client.Animations
         {
             DebugTools.AssertNotNull(LayerKey);
 
-            var entity = (IEntity) context;
-            var sprite = entity.GetComponent<ISpriteComponent>();
+            var entity = (EntityUid) context;
+            var sprite = IoCManager.Resolve<IEntityManager>().GetComponent<ISpriteComponent>(entity);
 
             var playingTime = prevPlayingTime + frameTime;
             var keyFrameIndex = prevKeyFrameIndex;

Robust.Client/Audio/Midi/MidiManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
@@ -58,7 +58,7 @@ namespace Robust.Client.Audio.Midi
         void Shutdown();
     }
 
-    internal class MidiManager : IMidiManager
+    internal sealed class MidiManager : IMidiManager
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
@@ -293,60 +293,50 @@ namespace Robust.Client.Audio.Midi
                 }
 
                 MapCoordinates? mapPos = null;
+                var trackingEntity = renderer.TrackingEntity != null && !_entityManager.Deleted(renderer.TrackingEntity);
+                if (trackingEntity)
+                {
+                    renderer.TrackingCoordinates = _entityManager.GetComponent<TransformComponent>(renderer.TrackingEntity!.Value).Coordinates;
+                }
+
                 if (renderer.TrackingCoordinates != null)
                 {
                     mapPos = renderer.TrackingCoordinates.Value.ToMap(_entityManager);
                 }
-                else if (renderer.TrackingEntity != null)
-                {
-                    mapPos = renderer.TrackingEntity.Transform.MapPosition;
-                }
 
-                if (mapPos != null)
+                if (mapPos != null && mapPos.Value.MapId == _eyeManager.CurrentMap)
                 {
                     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);
+                    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);
                     }
 
-                    if (renderer.Source.SetPosition(pos.Position))
+                    renderer.Source.SetOcclusion(occlusion);
+
+                    if (!renderer.Source.SetPosition(pos.Position))
                     {
-                        continue;
+                        return;
                     }
 
-                    if (renderer.TrackingEntity != null)
+                    if (trackingEntity)
                     {
-                        renderer.Source.SetVelocity(renderer.TrackingEntity.GlobalLinearVelocity());
+                        renderer.Source.SetVelocity(renderer.TrackingEntity!.Value.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();
+                }
+                else
+                {
+                    renderer.Source.SetOcclusion(float.MaxValue);
                 }
             }
 
@@ -402,7 +392,7 @@ namespace Robust.Client.Audio.Midi
         /// <summary>
         ///     This class is used to load soundfonts.
         /// </summary>
-        private class ResourceLoaderCallbacks : SoundFontLoaderCallbacks
+        private sealed class ResourceLoaderCallbacks : SoundFontLoaderCallbacks
         {
             private readonly Dictionary<int, Stream> _openStreams = new();
             private int _nextStreamId = 1;

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -150,7 +150,7 @@ namespace Robust.Client.Audio.Midi
         ///     The entity whose position will be used for positional audio.
         ///     This is only used if <see cref="Mono"/> is set to True.
         /// </summary>
-        IEntity? TrackingEntity { get; set; }
+        EntityUid? TrackingEntity { get; set; }
 
         /// <summary>
         ///     The position that will be used for positional audio.
@@ -180,7 +180,7 @@ namespace Robust.Client.Audio.Midi
         internal void InternalDispose();
     }
 
-    internal class MidiRenderer : IMidiRenderer
+    internal sealed class MidiRenderer : IMidiRenderer
     {
         [Dependency] private readonly IClydeAudio _clydeAudio = default!;
         [Dependency] private readonly ITaskManager _taskManager = default!;
@@ -297,7 +297,7 @@ namespace Robust.Client.Audio.Midi
             set
             {
                 lock (_playerStateLock)
-                    _player?.SetLoop(value ? -1 : 1);
+                    _player?.SetLoop(value ? -1 : 0);
                 _loopMidi = value;
             }
         }
@@ -306,7 +306,7 @@ namespace Robust.Client.Audio.Midi
         public bool VolumeBoost { get; set; }
 
         [ViewVariables(VVAccess.ReadWrite)]
-        public IEntity? TrackingEntity { get; set; } = null;
+        public EntityUid? TrackingEntity { get; set; } = null;
 
         [ViewVariables(VVAccess.ReadWrite)]
         public EntityCoordinates? TrackingCoordinates { get; set; } = null;
@@ -619,6 +619,7 @@ namespace Robust.Client.Audio.Midi
             var seqEv = (SequencerEvent) midiEvent;
             seqEv.Dest = _debugEvents ? _debugRegister : _synthRegister;
             _sequencer.SendAt(seqEv, time, absolute);
+            seqEv.Dispose();
         }
 
         public void Dispose()

Robust.Client/BaseClient.cs

@@ -20,13 +20,12 @@ using Robust.Shared.Utility;
 namespace Robust.Client
 {
     /// <inheritdoc />
-    public class BaseClient : IBaseClient
+    public sealed class BaseClient : IBaseClient
     {
         [Dependency] private readonly IClientNetManager _net = default!;
         [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!;
@@ -213,7 +212,6 @@ namespace Robust.Client
         {
             _entityManager.Startup();
             _mapManager.Startup();
-            _entityLookup.Startup();
 
             _timing.ResetSimTime();
             _timing.Paused = false;
@@ -224,7 +222,6 @@ namespace Robust.Client
             IoCManager.Resolve<INetConfigurationManager>().FlushMessages();
             _gameStates.Reset();
             _playMan.Shutdown();
-            _entityLookup.Shutdown();
             _entityManager.Shutdown();
             _mapManager.Shutdown();
             _discord.ClearPresence();
@@ -291,7 +288,7 @@ namespace Robust.Client
     /// <summary>
     ///     Event arguments for when something changed with the player.
     /// </summary>
-    public class PlayerEventArgs : EventArgs
+    public sealed class PlayerEventArgs : EventArgs
     {
         /// <summary>
         ///     The session that triggered the event.
@@ -310,7 +307,7 @@ namespace Robust.Client
     /// <summary>
     ///     Event arguments for when the RunLevel has changed in the BaseClient.
     /// </summary>
-    public class RunLevelChangedEventArgs : EventArgs
+    public sealed class RunLevelChangedEventArgs : EventArgs
     {
         /// <summary>
         ///     RunLevel that the BaseClient switched from.
@@ -335,7 +332,7 @@ namespace Robust.Client
     /// <summary>
     ///     Info about the server and player that is sent to the client while connecting.
     /// </summary>
-    public class ServerInfo
+    public sealed class ServerInfo
     {
         public ServerInfo(string serverName)
         {

Robust.Client/ClientIoC.cs

@@ -5,6 +5,7 @@ using Robust.Client.Debugging;
 using Robust.Client.GameObjects;
 using Robust.Client.GameStates;
 using Robust.Client.Graphics;
+using Robust.Client.Graphics.Audio;
 using Robust.Client.Graphics.Clyde;
 using Robust.Client.Input;
 using Robust.Client.Map;
@@ -42,11 +43,10 @@ namespace Robust.Client
             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<IMapManager, NetworkedMapManager>();
+            IoCManager.Register<IMapManagerInternal, NetworkedMapManager>();
+            IoCManager.Register<INetworkedMapManager, NetworkedMapManager>();
             IoCManager.Register<IEntityManager, ClientEntityManager>();
-            IoCManager.Register<IEntityLookup, EntityLookup>();
             IoCManager.Register<IReflectionManager, ClientReflectionManager>();
             IoCManager.Register<IConsoleHost, ClientConsoleHost>();
             IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
@@ -71,7 +71,6 @@ namespace Robust.Client
             IoCManager.Register<IStateManager, StateManager>();
             IoCManager.Register<IUserInterfaceManager, UserInterfaceManager>();
             IoCManager.Register<IUserInterfaceManagerInternal, UserInterfaceManager>();
-            IoCManager.Register<IDebugDrawing, DebugDrawing>();
             IoCManager.Register<ILightManager, LightManager>();
             IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
             IoCManager.Register<IMidiManager, MidiManager>();
@@ -82,8 +81,9 @@ namespace Robust.Client
                 case GameController.DisplayMode.Headless:
                     IoCManager.Register<IClyde, ClydeHeadless>();
                     IoCManager.Register<IClipboardManager, ClydeHeadless>();
-                    IoCManager.Register<IClydeAudio, ClydeHeadless>();
                     IoCManager.Register<IClydeInternal, ClydeHeadless>();
+                    IoCManager.Register<IClydeAudio, ClydeAudioHeadless>();
+                    IoCManager.Register<IClydeAudioInternal, ClydeAudioHeadless>();
                     IoCManager.Register<IInputManager, InputManager>();
                     IoCManager.Register<IFileDialogManager, DummyFileDialogManager>();
                     IoCManager.Register<IUriOpener, UriOpenerDummy>();
@@ -91,8 +91,9 @@ namespace Robust.Client
                 case GameController.DisplayMode.Clyde:
                     IoCManager.Register<IClyde, Clyde>();
                     IoCManager.Register<IClipboardManager, Clyde>();
-                    IoCManager.Register<IClydeAudio, Clyde>();
                     IoCManager.Register<IClydeInternal, Clyde>();
+                    IoCManager.Register<IClydeAudio, FallbackProxyClydeAudio>();
+                    IoCManager.Register<IClydeAudioInternal, FallbackProxyClydeAudio>();
                     IoCManager.Register<IInputManager, ClydeInputManager>();
                     IoCManager.Register<IFileDialogManager, FileDialogManager>();
                     IoCManager.Register<IUriOpener, UriOpener>();

Robust.Client/CommandLineArgs.cs

@@ -4,177 +4,186 @@ using Robust.Shared;
 using Robust.Shared.Utility;
 using C = System.Console;
 
-namespace Robust.Client
+namespace Robust.Client;
+
+internal sealed class CommandLineArgs
 {
-    internal sealed class CommandLineArgs
+    public MountOptions MountOptions { get; }
+    public bool Headless { get; }
+    public bool SelfContained { get; }
+    public bool Connect { get; }
+    public string ConnectAddress { get; }
+    public string? Ss14Address { get; }
+    public bool Launcher { get; }
+    public string? Username { get; }
+    public IReadOnlyCollection<(string key, string value)> CVars { get; }
+    public IReadOnlyCollection<(string key, string value)> LogLevels { get; }
+    public IReadOnlyList<string> ExecCommands { get; set; }
+
+    // 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?
+    public static bool TryParse(IReadOnlyList<string> args, [NotNullWhen(true)] out CommandLineArgs? parsed)
     {
-        public MountOptions MountOptions { get; }
-        public bool Headless { get; }
-        public bool SelfContained { get; }
-        public bool Connect { get; }
-        public string ConnectAddress { get; }
-        public string? Ss14Address { get; }
-        public bool Launcher { get; }
-        public string? Username { get; }
-        public IReadOnlyCollection<(string key, string value)> CVars { get; }
-        public IReadOnlyCollection<(string key, string value)> LogLevels { get; }
+        parsed = null;
+        var headless = false;
+        var selfContained = false;
+        var connect = false;
+        var connectAddress = "localhost";
+        string? ss14Address = null;
+        var launcher = false;
+        string? username = null;
+        var cvars = new List<(string, string)>();
+        var logLevels = new List<(string, string)>();
+        var mountOptions = new MountOptions();
+        var execCommands = new List<string>();
 
-        // 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?
-        public static bool TryParse(IReadOnlyList<string> args, [NotNullWhen(true)] out CommandLineArgs? parsed)
+        using var enumerator = args.GetEnumerator();
+
+        while (enumerator.MoveNext())
         {
-            parsed = null;
-            var headless = false;
-            var selfContained = false;
-            var connect = false;
-            var connectAddress = "localhost";
-            string? ss14Address = null;
-            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();
-
-            while (enumerator.MoveNext())
+            var arg = enumerator.Current;
+            if (arg == "--connect")
             {
-                var arg = enumerator.Current;
-                if (arg == "--connect")
+                connect = true;
+            }
+            else if (arg == "--connect-address")
+            {
+                if (!enumerator.MoveNext())
                 {
-                    connect = true;
-                }
-                else if (arg == "--connect-address")
-                {
-                    if (!enumerator.MoveNext())
-                    {
-                        C.WriteLine("Missing connection address.");
-                        return false;
-                    }
-
-                    connectAddress = enumerator.Current;
-                }
-                else if (arg == "--ss14-address")
-                {
-                    if (!enumerator.MoveNext())
-                    {
-                        C.WriteLine("Missing SS14 address.");
-                        return false;
-                    }
-
-                    ss14Address = enumerator.Current;
-                }
-                else if (arg == "--self-contained")
-                {
-                    selfContained = true;
-                }
-                else if (arg == "--launcher")
-                {
-                    launcher = true;
-                }
-                else if (arg == "--headless")
-                {
-                    headless = true;
-                }
-                else if (arg == "--username")
-                {
-                    if (!enumerator.MoveNext())
-                    {
-                        C.WriteLine("Missing username.");
-                        return false;
-                    }
-
-                    username = enumerator.Current;
-                }
-                else if (arg == "--cvar")
-                {
-                    if (!enumerator.MoveNext())
-                    {
-                        C.WriteLine("Missing cvar value.");
-                        return false;
-                    }
-
-                    var cvar = enumerator.Current;
-                    DebugTools.AssertNotNull(cvar);
-                    var pos = cvar.IndexOf('=');
-
-                    if (pos == -1)
-                    {
-                        C.WriteLine("Expected = in cvar.");
-                        return false;
-                    }
-
-                    cvars.Add((cvar[..pos], cvar[(pos + 1)..]));
-                }
-                else if (arg == "--mount-zip")
-                {
-                    if (!enumerator.MoveNext())
-                    {
-                        C.WriteLine("Missing mount path");
-                        return false;
-                    }
-
-                    mountOptions.ZipMounts.Add(enumerator.Current);
-                }
-                else if (arg == "--mount-dir")
-                {
-                    if (!enumerator.MoveNext())
-                    {
-                        C.WriteLine("Missing mount path");
-                        return false;
-                    }
-
-                    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();
+                    C.WriteLine("Missing connection address.");
                     return false;
                 }
-                else
-                {
-                    C.WriteLine("Unknown argument: {0}", arg);
-                }
+
+                connectAddress = enumerator.Current;
             }
+            else if (arg == "--ss14-address")
+            {
+                if (!enumerator.MoveNext())
+                {
+                    C.WriteLine("Missing SS14 address.");
+                    return false;
+                }
 
-            parsed = new CommandLineArgs(
-                headless,
-                selfContained,
-                connect,
-                launcher,
-                username,
-                cvars,
-                logLevels,
-                connectAddress,
-                ss14Address,
-                mountOptions);
+                ss14Address = enumerator.Current;
+            }
+            else if (arg == "--self-contained")
+            {
+                selfContained = true;
+            }
+            else if (arg == "--launcher")
+            {
+                launcher = true;
+            }
+            else if (arg == "--headless")
+            {
+                headless = true;
+            }
+            else if (arg == "--username")
+            {
+                if (!enumerator.MoveNext())
+                {
+                    C.WriteLine("Missing username.");
+                    return false;
+                }
 
-            return true;
+                username = enumerator.Current;
+            }
+            else if (arg == "--cvar")
+            {
+                if (!enumerator.MoveNext())
+                {
+                    C.WriteLine("Missing cvar value.");
+                    return false;
+                }
+
+                var cvar = enumerator.Current;
+                DebugTools.AssertNotNull(cvar);
+                var pos = cvar.IndexOf('=');
+
+                if (pos == -1)
+                {
+                    C.WriteLine("Expected = in cvar.");
+                    return false;
+                }
+
+                cvars.Add((cvar[..pos], cvar[(pos + 1)..]));
+            }
+            else if (arg == "--mount-zip")
+            {
+                if (!enumerator.MoveNext())
+                {
+                    C.WriteLine("Missing mount path");
+                    return false;
+                }
+
+                mountOptions.ZipMounts.Add(enumerator.Current);
+            }
+            else if (arg == "--mount-dir")
+            {
+                if (!enumerator.MoveNext())
+                {
+                    C.WriteLine("Missing mount path");
+                    return false;
+                }
+
+                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();
+                return false;
+            }
+            else if (arg.StartsWith("+"))
+            {
+                execCommands.Add(arg[1..]);
+            }
+            else
+            {
+                C.WriteLine("Unknown argument: {0}", arg);
+            }
         }
 
-        private static void PrintHelp()
-        {
-            C.WriteLine(@"
+        parsed = new CommandLineArgs(
+            headless,
+            selfContained,
+            connect,
+            launcher,
+            username,
+            cvars,
+            logLevels,
+            connectAddress,
+            ss14Address,
+            mountOptions,
+            execCommands);
+
+        return true;
+    }
+
+    private static void PrintHelp()
+    {
+        C.WriteLine(@"
+Usage: Robust.Client [options] [+command [+command]]
+
 Options:
   --headless          Run without graphics/audio/input.
   --self-contained    Store data relative to executable instead of user-global locations.
@@ -189,30 +198,34 @@ Options:
   --mount-dir         Resource directory to mount.
   --mount-zip         Resource zip to mount.
   --help              Display this help text and exit.
-");
-        }
 
-        private CommandLineArgs(
-            bool headless,
-            bool selfContained,
-            bool connect,
-            bool launcher,
-            string? username,
-            IReadOnlyCollection<(string key, string value)> cVars,
-            IReadOnlyCollection<(string key, string value)> logLevels,
-            string connectAddress, string? ss14Address,
-            MountOptions mountOptions)
-        {
-            Headless = headless;
-            SelfContained = selfContained;
-            Connect = connect;
-            Launcher = launcher;
-            Username = username;
-            CVars = cVars;
-            LogLevels = logLevels;
-            ConnectAddress = connectAddress;
-            Ss14Address = ss14Address;
-            MountOptions = mountOptions;
-        }
++command:             You can pass a set of commands, prefixed by +,
+                      to be executed in the console in order after the game has finished initializing.
+");
+    }
+
+    private CommandLineArgs(
+        bool headless,
+        bool selfContained,
+        bool connect,
+        bool launcher,
+        string? username,
+        IReadOnlyCollection<(string key, string value)> cVars,
+        IReadOnlyCollection<(string key, string value)> logLevels,
+        string connectAddress, string? ss14Address,
+        MountOptions mountOptions,
+        IReadOnlyList<string> execCommands)
+    {
+        Headless = headless;
+        SelfContained = selfContained;
+        Connect = connect;
+        Launcher = launcher;
+        Username = username;
+        CVars = cVars;
+        LogLevels = logLevels;
+        ConnectAddress = connectAddress;
+        Ss14Address = ss14Address;
+        MountOptions = mountOptions;
+        ExecCommands = execCommands;
     }
 }

Robust.Client/Console/ClientConGroupController.cs

@@ -2,7 +2,7 @@
 
 namespace Robust.Client.Console
 {
-    public class ClientConGroupController : IClientConGroupController
+    public sealed class ClientConGroupController : IClientConGroupController
     {
         private IClientConGroupImplementation? _implementation;
         public event Action? ConGroupUpdated;
@@ -23,7 +23,7 @@ namespace Robust.Client.Console
 
         public bool CanCommand(string cmdName)
         {
-            return _implementation?.CanCommand(cmdName) ?? false;
+            return _implementation?.CanCommand(cmdName) ?? true;
         }
 
         public bool CanViewVar()

Robust.Client/Console/ClientConsoleHost.cs

@@ -1,7 +1,10 @@
 using System;
 using System.Collections.Generic;
 using Robust.Client.Log;
+using Robust.Client.Player;
 using Robust.Shared.Console;
+using Robust.Shared.Enums;
+using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
@@ -11,7 +14,7 @@ using Robust.Shared.Utility;
 
 namespace Robust.Client.Console
 {
-    public class AddStringArgs : EventArgs
+    public sealed class AddStringArgs : EventArgs
     {
         public string Text { get; }
 
@@ -27,7 +30,7 @@ namespace Robust.Client.Console
         }
     }
 
-    public class AddFormattedMessageArgs : EventArgs
+    public sealed class AddFormattedMessageArgs : EventArgs
     {
         public readonly FormattedMessage Message;
 
@@ -38,8 +41,10 @@ namespace Robust.Client.Console
     }
 
     /// <inheritdoc cref="IClientConsoleHost" />
-    internal class ClientConsoleHost : ConsoleHost, IClientConsoleHost
+    internal sealed class ClientConsoleHost : ConsoleHost, IClientConsoleHost
     {
+        [Dependency] private readonly IClientConGroupController _conGroup = default!;
+
         private bool _requestedCommands;
 
         /// <inheritdoc />
@@ -103,6 +108,14 @@ namespace Robust.Client.Console
 
             if (AvailableCommands.ContainsKey(commandName))
             {
+                var playerManager = IoCManager.Resolve<IPlayerManager>();
+#if !DEBUG
+                if (!_conGroup.CanCommand(commandName) && playerManager.LocalPlayer?.Session.Status > SessionStatus.Connecting)
+                {
+                    WriteError(null, $"Insufficient perms for command: {commandName}");
+                    return;
+                }
+#endif
                 var command1 = AvailableCommands[commandName];
                 args.RemoveAt(0);
                 var shell = new ConsoleShell(this, null);
@@ -196,7 +209,7 @@ namespace Robust.Client.Console
     /// These dummies are made purely so list and help can list server-side commands.
     /// </summary>
     [Reflect(false)]
-    internal class ServerDummyCommand : IConsoleCommand
+    internal sealed class ServerDummyCommand : IConsoleCommand
     {
         internal ServerDummyCommand(string command, string help, string description)
         {

Robust.Client/Console/Commands/AddCompCommand.cs

@@ -21,13 +21,12 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var entityUid = EntityUid.Parse(args[0]);
+            var entity = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
             var compFactory = IoCManager.Resolve<IComponentFactory>();
             var entityManager = IoCManager.Resolve<IEntityManager>();
 
-            var entity = entityManager.GetEntity(entityUid);
             var component = (Component) compFactory.GetComponent(componentName);
 
             component.Owner = entity;

Robust.Client/Console/Commands/ClientSpawnCommand.cs

@@ -15,15 +15,15 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var player = IoCManager.Resolve<IPlayerManager>().LocalPlayer;
-            if (player?.ControlledEntity == null)
+            var controlled = IoCManager.Resolve<IPlayerManager>().LocalPlayer?.ControlledEntity ?? EntityUid.Invalid;
+            if (controlled == EntityUid.Invalid)
             {
                 shell.WriteLine("You don't have an attached entity.");
                 return;
             }
 
             var entityManager = IoCManager.Resolve<IEntityManager>();
-            entityManager.SpawnEntity(args[0], player.ControlledEntity.Transform.Coordinates);
+            entityManager.SpawnEntity(args[0], entityManager.GetComponent<TransformComponent>(controlled).Coordinates);
         }
     }
 }

Robust.Client/Console/Commands/ConfigurationCommands.cs

@@ -59,7 +59,7 @@ namespace Robust.Client.Console.Commands
     }
 
     [UsedImplicitly]
-    public class SaveConfig : IConsoleCommand
+    public sealed class SaveConfig : IConsoleCommand
     {
         public string Command => "saveconfig";
         public string Description => "Saves the client configuration to the config file";

Robust.Client/Console/Commands/ConsoleCommands.cs

@@ -6,7 +6,7 @@ using Robust.Shared.Console;
 
 namespace Robust.Client.Console.Commands
 {
-    class ClearCommand : IConsoleCommand
+    sealed class ClearCommand : IConsoleCommand
     {
         public string Command => "cls";
         public string Help => "Clears the debug console of all messages.";
@@ -18,7 +18,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    class FillCommand : IConsoleCommand
+    sealed class FillCommand : IConsoleCommand
     {
         public string Command => "fill";
         public string Help => "Fills the console with some nonsense for debugging.";

Robust.Client/Console/Commands/Debug.cs

@@ -4,13 +4,12 @@ using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Runtime;
 using System.Text;
 using System.Text.RegularExpressions;
-using Robust.Client.Input;
 using Robust.Client.Debugging;
 using Robust.Client.Graphics;
+using Robust.Client.Input;
 using Robust.Client.ResourceManagement;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
@@ -31,7 +30,7 @@ using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.Console.Commands
 {
-    internal class DumpEntitiesCommand : IConsoleCommand
+    internal sealed class DumpEntitiesCommand : IConsoleCommand
     {
         public string Command => "dumpentities";
         public string Help => "Dump entity list";
@@ -41,14 +40,14 @@ namespace Robust.Client.Console.Commands
         {
             var entityManager = IoCManager.Resolve<IEntityManager>();
 
-            foreach (var e in entityManager.GetEntities().OrderBy(e => e.Uid))
+            foreach (var e in entityManager.GetEntities().OrderBy(e => e))
             {
-                shell.WriteLine($"entity {e.Uid}, {e.Prototype?.ID}, {e.Transform.Coordinates}.");
+                shell.WriteLine($"entity {e}, {entityManager.GetComponent<MetaDataComponent>(e).EntityPrototype?.ID}, {entityManager.GetComponent<TransformComponent>(e).Coordinates}.");
             }
         }
     }
 
-    internal class GetComponentRegistrationCommand : IConsoleCommand
+    internal sealed class GetComponentRegistrationCommand : IConsoleCommand
     {
         public string Command => "getcomponentregistration";
         public string Help => "Usage: getcomponentregistration <componentName>";
@@ -94,7 +93,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ToggleMonitorCommand : IConsoleCommand
+    internal sealed class ToggleMonitorCommand : IConsoleCommand
     {
         public string Command => "monitor";
 
@@ -149,7 +148,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ExceptionCommand : IConsoleCommand
+    internal sealed class ExceptionCommand : IConsoleCommand
     {
         public string Command => "fuck";
         public string Help => "Throws an exception";
@@ -161,7 +160,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ShowPositionsCommand : IConsoleCommand
+    internal sealed class ShowPositionsCommand : IConsoleCommand
     {
         public string Command => "showpos";
         public string Help => "";
@@ -169,12 +168,12 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<IDebugDrawing>();
+            var mgr = EntitySystem.Get<DebugDrawingSystem>();
             mgr.DebugPositions = !mgr.DebugPositions;
         }
     }
 
-    internal class ShowRayCommand : IConsoleCommand
+    internal sealed class ShowRayCommand : IConsoleCommand
     {
         public string Command => "showrays";
         public string Help => "Usage: showrays <raylifetime>";
@@ -201,7 +200,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class DisconnectCommand : IConsoleCommand
+    internal sealed class DisconnectCommand : IConsoleCommand
     {
         public string Command => "disconnect";
         public string Help => "";
@@ -213,7 +212,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class EntityInfoCommand : IConsoleCommand
+    internal sealed class EntityInfoCommand : IConsoleCommand
     {
         public string Command => "entfo";
 
@@ -238,15 +237,15 @@ namespace Robust.Client.Console.Commands
 
             var uid = EntityUid.Parse(args[0]);
             var entmgr = IoCManager.Resolve<IEntityManager>();
-            if (!entmgr.TryGetEntity(uid, out var entity))
+            if (!entmgr.EntityExists(uid))
             {
                 shell.WriteError("That entity does not exist. Sorry lad.");
                 return;
             }
-
-            shell.WriteLine($"{entity.Uid}: {entity.Prototype?.ID}/{entity.Name}");
-            shell.WriteLine($"init/del/lmt: {entity.Initialized}/{entity.Deleted}/{entity.LastModifiedTick}");
-            foreach (var component in entity.GetAllComponents())
+            var meta = entmgr.GetComponent<MetaDataComponent>(uid);
+            shell.WriteLine($"{uid}: {meta.EntityPrototype?.ID}/{meta.EntityName}");
+            shell.WriteLine($"init/del/lmt: {meta.EntityInitialized}/{meta.EntityDeleted}/{meta.EntityLastModifiedTick}");
+            foreach (var component in entmgr.GetComponents(uid))
             {
                 shell.WriteLine(component.ToString() ?? "");
                 if (component is IComponentDebug debug)
@@ -265,7 +264,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class SnapGridGetCell : IConsoleCommand
+    internal sealed class SnapGridGetCell : IConsoleCommand
     {
         public string Command => "sggcell";
         public string Help => "sggcell <gridID> <vector2i>\nThat vector2i param is in the form x<int>,y<int>.";
@@ -314,7 +313,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class SetPlayerName : IConsoleCommand
+    internal sealed class SetPlayerName : IConsoleCommand
     {
         public string Command => "overrideplayername";
         public string Description => "Changes the name used when attempting to connect to the server.";
@@ -334,7 +333,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class LoadResource : IConsoleCommand
+    internal sealed class LoadResource : IConsoleCommand
     {
         public string Command => "ldrsc";
         public string Description => "Pre-caches a resource.";
@@ -371,7 +370,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ReloadResource : IConsoleCommand
+    internal sealed class ReloadResource : IConsoleCommand
     {
         public string Command => "rldrsc";
         public string Description => "Reloads a resource.";
@@ -405,7 +404,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class GridTileCount : IConsoleCommand
+    internal sealed class GridTileCount : IConsoleCommand
     {
         public string Command => "gridtc";
         public string Description => "Gets the tile count of a grid";
@@ -439,7 +438,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class GuiDumpCommand : IConsoleCommand
+    internal sealed class GuiDumpCommand : IConsoleCommand
     {
         public string Command => "guidump";
         public string Description => "Dump GUI tree to /guidump.txt in user data.";
@@ -450,15 +449,13 @@ namespace Robust.Client.Console.Commands
             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))
+            using var writer = res.UserData.OpenWriteText(new ResourcePath("/guidump.txt"));
+
+            foreach (var root in uiMgr.AllRoots)
             {
-                foreach (var root in uiMgr.AllRoots)
-                {
-                    writer.WriteLine($"ROOT: {root}");
-                    _writeNode(root, 0, writer);
-                    writer.WriteLine("---------------");
-                }
+                writer.WriteLine($"ROOT: {root}");
+                _writeNode(root, 0, writer);
+                writer.WriteLine("---------------");
             }
 
             shell.WriteLine("Saved guidump");
@@ -515,7 +512,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class UITestCommand : IConsoleCommand
+    internal sealed class UITestCommand : IConsoleCommand
     {
         public string Command => "uitest";
         public string Description => "Open a dummy UI testing window";
@@ -523,7 +520,7 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var window = new SS14Window { MinSize = (500, 400)};
+            var window = new DefaultWindow { MinSize = (500, 400)};
             var tabContainer = new TabContainer();
             window.Contents.AddChild(tabContainer);
             var scroll = new ScrollContainer();
@@ -647,7 +644,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class SetClipboardCommand : IConsoleCommand
+    internal sealed class SetClipboardCommand : IConsoleCommand
     {
         public string Command => "setclipboard";
         public string Description => "Sets the system clipboard";
@@ -660,7 +657,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class GetClipboardCommand : IConsoleCommand
+    internal sealed class GetClipboardCommand : IConsoleCommand
     {
         public string Command => "getclipboard";
         public string Description => "Gets the system clipboard";
@@ -673,7 +670,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ToggleLight : IConsoleCommand
+    internal sealed class ToggleLight : IConsoleCommand
     {
         public string Command => "togglelight";
         public string Description => "Toggles light rendering.";
@@ -687,7 +684,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ToggleFOV : IConsoleCommand
+    internal sealed class ToggleFOV : IConsoleCommand
     {
         public string Command => "togglefov";
         public string Description => "Toggles fov for client.";
@@ -701,7 +698,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ToggleHardFOV : IConsoleCommand
+    internal sealed class ToggleHardFOV : IConsoleCommand
     {
         public string Command => "togglehardfov";
         public string Description => "Toggles hard fov for client (for debugging space-station-14#2353).";
@@ -715,7 +712,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class ToggleShadows : IConsoleCommand
+    internal sealed class ToggleShadows : IConsoleCommand
     {
         public string Command => "toggleshadows";
         public string Description => "Toggles shadow rendering.";
@@ -728,7 +725,7 @@ namespace Robust.Client.Console.Commands
                 mgr.DrawShadows = !mgr.DrawShadows;
         }
     }
-    internal class ToggleLightBuf : IConsoleCommand
+    internal sealed class ToggleLightBuf : IConsoleCommand
     {
         public string Command => "togglelightbuf";
         public string Description => "Toggles lighting rendering. This includes shadows but not FOV.";
@@ -742,7 +739,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class GcCommand : IConsoleCommand
+    internal sealed class GcCommand : IConsoleCommand
     {
         public string Command => "gc";
         public string Description => "Run the GC.";
@@ -764,7 +761,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class GcFullCommand : IConsoleCommand
+    internal sealed class GcFullCommand : IConsoleCommand
     {
         public string Command => "gcf";
         public string Description => "Run the GC, fully, compacting LOH and everything.";
@@ -777,7 +774,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class GcModeCommand : IConsoleCommand
+    internal sealed class GcModeCommand : IConsoleCommand
     {
 
         public string Command => "gc_mode";
@@ -819,7 +816,7 @@ namespace Robust.Client.Console.Commands
 
     }
 
-    internal class SerializeStatsCommand : IConsoleCommand
+    internal sealed class SerializeStatsCommand : IConsoleCommand
     {
 
         public string Command => "szr_stats";
@@ -839,7 +836,7 @@ namespace Robust.Client.Console.Commands
 
     }
 
-    internal class ChunkInfoCommand : IConsoleCommand
+    internal sealed class ChunkInfoCommand : IConsoleCommand
     {
         public string Command => "chunkinfo";
         public string Description => "Gets info about a chunk under your mouse cursor.";
@@ -864,11 +861,11 @@ namespace Robust.Client.Console.Commands
             var chunkIndex = grid.LocalToChunkIndices(grid.MapToGrid(mousePos));
             var chunk = internalGrid.GetChunk(chunkIndex);
 
-            shell.WriteLine($"worldBounds: {chunk.CalcWorldAABB()} localBounds: {chunk.CalcLocalBounds()}");
+            shell.WriteLine($"worldBounds: {internalGrid.CalcWorldAABB(chunk)} localBounds: {chunk.CachedBounds}");
         }
     }
 
-    internal class ReloadShadersCommand : IConsoleCommand
+    internal sealed class ReloadShadersCommand : IConsoleCommand
     {
 
         public string Command => "rldshader";
@@ -1039,7 +1036,7 @@ namespace Robust.Client.Console.Commands
 
     }
 
-    internal class ClydeDebugLayerCommand : IConsoleCommand
+    internal sealed class ClydeDebugLayerCommand : IConsoleCommand
     {
         public string Command => "cldbglyr";
         public string Description => "Toggle fov and light debug layers";
@@ -1064,7 +1061,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    internal class GetKeyInfoCommand : IConsoleCommand
+    internal sealed class GetKeyInfoCommand : IConsoleCommand
     {
         public string Command => "keyinfo";
         public string Description => "Keys key info for a key";

Robust.Client/Console/Commands/GridChunkBBCommand.cs

@@ -4,7 +4,7 @@ using Robust.Shared.GameObjects;
 
 namespace Robust.Client.Console.Commands
 {
-    public class GridChunkBBCommand : IConsoleCommand
+    public sealed class GridChunkBBCommand : IConsoleCommand
     {
         public string Command => "showchunkbb";
         public string Description => "Displays chunk bounds for the purposes of rendering";

Robust.Client/Console/Commands/HelpCommands.cs

@@ -5,7 +5,7 @@ using Robust.Shared.Network;
 
 namespace Robust.Client.Console.Commands
 {
-    class HelpCommand : IConsoleCommand
+    sealed class HelpCommand : IConsoleCommand
     {
         public string Command => "help";
         public string Help => "When no arguments are provided, displays a generic help text. When an argument is passed, display the help text for the command with that name.";
@@ -44,7 +44,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    class ListCommand : IConsoleCommand
+    sealed class ListCommand : IConsoleCommand
     {
         public string Command => "list";
         public string Help => "Usage: list [filter]\n" +

Robust.Client/Console/Commands/LauncherAuthCommand.cs

@@ -1,9 +1,7 @@
 #if !FULL_RELEASE
 using System;
 using System.IO;
-using System.Linq;
-using System.Text.Json;
-using System.Text.Json.Serialization;
+using Microsoft.Data.Sqlite;
 using Robust.Client.Utility;
 using Robust.Shared.Console;
 using Robust.Shared.IoC;
@@ -22,44 +20,38 @@ namespace Robust.Client.Console.Commands
             var wantName = args.Length > 0 ? args[0] : null;
 
             var basePath = Path.GetDirectoryName(UserDataDir.GetUserDataDir())!;
-            var cfgPath = Path.Combine(basePath, "launcher", "launcher_config.json");
+            var dbPath = Path.Combine(basePath, "launcher", "settings.db");
 
-            var data = JsonSerializer.Deserialize<LauncherConfig>(File.ReadAllText(cfgPath))!;
+            using var con = new SqliteConnection($"Data Source={dbPath};Mode=ReadOnly");
+            con.Open();
+            using var cmd = con.CreateCommand();
+            cmd.CommandText = "SELECT UserId, UserName, Token FROM Login WHERE Expires > datetime('NOW')";
 
-            var login = wantName != null
-                ? data.Logins.FirstOrDefault(p => p.Username == wantName)
-                : data.Logins.FirstOrDefault();
+            if (wantName != null)
+            {
+                cmd.CommandText += " AND UserName = @userName";
+                cmd.Parameters.AddWithValue("@userName", wantName);
+            }
 
-            if (login == null)
+            cmd.CommandText += " LIMIT 1;";
+
+            using var reader = cmd.ExecuteReader();
+
+            if (!reader.Read())
             {
                 shell.WriteLine("Unable to find a matching login");
                 return;
             }
 
-            var token = login.Token.Token;
-            var userId = login.UserId;
+            var userId = Guid.Parse(reader.GetString(0));
+            var userName = reader.GetString(1);
+            var token = reader.GetString(2);
 
             var cfg = IoCManager.Resolve<IAuthManager>();
             cfg.Token = token;
-            cfg.UserId = new NetUserId(Guid.Parse(userId));
-        }
+            cfg.UserId = new NetUserId(userId);
 
-        private sealed class LauncherConfig
-        {
-            [JsonInclude] [JsonPropertyName("logins")]
-            public LauncherLogin[] Logins = default!;
-        }
-
-        private sealed class LauncherLogin
-        {
-            [JsonInclude] public string Username = default!;
-            [JsonInclude] public string UserId = default!;
-            [JsonInclude] public LauncherToken Token = default!;
-        }
-
-        private sealed class LauncherToken
-        {
-            [JsonInclude] public string Token = default!;
+            shell.WriteLine($"Logged into account {userName}");
         }
     }
 }

Robust.Client/Console/Commands/LogCommands.cs

@@ -4,7 +4,7 @@ using Robust.Shared.Console;
 
 namespace Robust.Client.Console.Commands
 {
-    class LogSetLevelCommand : IConsoleCommand
+    sealed class LogSetLevelCommand : IConsoleCommand
     {
         public string Command => "loglevel";
         public string Description => "Changes the log level for a provided sawmill.";
@@ -40,7 +40,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    class TestLog : IConsoleCommand
+    sealed class TestLog : IConsoleCommand
     {
         public string Command => "testlog";
         public string Description => "Writes a test log to a sawmill.";

Robust.Client/Console/Commands/PhysicsOverlayCommands.cs

@@ -24,6 +24,9 @@ namespace Robust.Client.Console.Commands
                 case "aabbs":
                     system.Flags ^= PhysicsDebugFlags.AABBs;
                     break;
+                case "com":
+                    system.Flags ^= PhysicsDebugFlags.COM;
+                    break;
                 case "contactnormals":
                     system.Flags ^= PhysicsDebugFlags.ContactNormals;
                     break;

Robust.Client/Console/Commands/QuitCommand.cs

@@ -4,7 +4,7 @@ using Robust.Shared.IoC;
 
 namespace Robust.Client.Console.Commands
 {
-    class HardQuitCommand : IConsoleCommand
+    sealed class HardQuitCommand : IConsoleCommand
     {
         public string Command => "hardquit";
         public string Description => "Kills the game client instantly.";
@@ -16,7 +16,7 @@ namespace Robust.Client.Console.Commands
         }
     }
 
-    class QuitCommand : IConsoleCommand
+    sealed class QuitCommand : IConsoleCommand
     {
         public string Command => "quit";
         public string Description => "Shuts down the game client gracefully.";

Robust.Client/Console/Commands/SetInputContextCommand.cs

@@ -6,7 +6,7 @@ using Robust.Shared.IoC;
 namespace Robust.Client.Console.Commands
 {
     [UsedImplicitly]
-    public class SetInputContextCommand : IConsoleCommand
+    public sealed class SetInputContextCommand : IConsoleCommand
     {
         public string Command => "setinputcontext";
         public string Description => "Sets the active input context.";

Robust.Client/Console/Commands/VelocitiesCommand.cs

@@ -4,7 +4,7 @@ using Robust.Shared.GameObjects;
 
 namespace Robust.Client.Console.Commands
 {
-    public class VelocitiesCommand : IConsoleCommand
+    public sealed class VelocitiesCommand : IConsoleCommand
     {
         public string Command => "showvelocities";
         public string Description => "Displays your angular and linear velocities";

Robust.Client/Console/Completions.cs

@@ -11,7 +11,7 @@ using static Robust.Shared.Network.Messages.MsgScriptCompletionResponse;
 
 namespace Robust.Client.Console
 {
-    public class Completions : SS14Window
+    public sealed class Completions : DefaultWindow
     {
         private HistoryLineEdit _textBar;
         private ScrollContainer _suggestPanel = new()
@@ -75,7 +75,7 @@ namespace Robust.Client.Console
         }
 
         // Label and ghetto button.
-        public class Entry : RichTextLabel
+        public sealed class Entry : RichTextLabel
         {
             public readonly LiteResult Result;
 

Robust.Client/Console/ScriptClient.cs

@@ -6,7 +6,7 @@ using Robust.Shared.Network.Messages;
 
 namespace Robust.Client.Console
 {
-    public partial class ScriptClient : IScriptClient
+    public sealed partial class ScriptClient : IScriptClient
     {
         [Dependency] private readonly IClientConGroupController _conGroupController = default!;
         [Dependency] private readonly IClientNetManager _netManager = default!;

Robust.Client/Console/ScriptConsoleClient.cs

@@ -210,6 +210,23 @@ namespace Robust.Client.Console
                 vvm.OpenVV(a);
             }
 
+            protected override void WriteSyntax(object toString)
+            {
+                var code = toString.ToString();
+
+                if (code == null)
+                    return;
+
+                var options = ScriptInstanceShared.GetScriptOptions(_owner._reflectionManager).AddReferences(typeof(Image).Assembly);
+                var script = CSharpScript.Create(code, options, typeof(ScriptGlobals));
+                script.Compile();
+
+                var syntax = new FormattedMessage();
+                ScriptInstanceShared.AddWithSyntaxHighlighting(script, syntax, code, _owner._highlightWorkspace);
+
+                _owner.OutputPanel.AddMessage(syntax);
+            }
+
             public override void write(object toString)
             {
                 _owner.OutputPanel.AddText(toString?.ToString() ?? "");

Robust.Client/Console/WatchWindow.cs

@@ -15,7 +15,7 @@ using static Robust.Client.UserInterface.Controls.BoxContainer;
 
 namespace Robust.Client.Console
 {
-    public class WatchWindow : SS14Window
+    public sealed class WatchWindow : DefaultWindow
     {
         private readonly IReflectionManager _reflectionManager;
 
@@ -155,6 +155,11 @@ namespace Robust.Client.Console
                 IoCManager.InjectDependencies(this);
             }
 
+            protected override void WriteSyntax(object toString)
+            {
+                // No-op: nothing to write to.
+            }
+
             public override void write(object toString)
             {
                 // No-op: nothing to write to.

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -79,13 +79,13 @@ namespace Robust.Client.Debugging
 
             foreach (var ent in grid.GetAnchoredEntities(spot))
             {
-                if (!EntityManager.TryGetEntity(ent, out var entity))
+                if (EntityManager.TryGetComponent<MetaDataComponent>(ent, out var meta))
                 {
-                    text.AppendLine($"uid: {ent}, invalid");
+                    text.AppendLine($"uid: {ent}, {meta.EntityName}");
                 }
                 else
                 {
-                    text.AppendLine($"uid: {ent}, {entity.Name}");
+                    text.AppendLine($"uid: {ent}, invalid");
                 }
             }
 

Robust.Client/Debugging/DebugDrawingSystem.cs

@@ -6,16 +6,21 @@ using Robust.Shared.Maths;
 
 namespace Robust.Client.Debugging
 {
-    /// <inheritdoc />
-    public class DebugDrawing : IDebugDrawing
+    /// <summary>
+    /// A collection of visual debug overlays for the client game.
+    /// </summary>
+    public sealed class DebugDrawingSystem : EntitySystem
     {
         [Dependency] private readonly IOverlayManager _overlayManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
-        [Dependency] private readonly IEntityLookup _lookup = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly EntityLookupSystem _lookup = default!;
 
         private bool _debugPositions;
 
-        /// <inheritdoc />
+        /// <summary>
+        /// Toggles the visual overlay of the local origin for each entity on screen.
+        /// </summary>
         public bool DebugPositions
         {
             get => _debugPositions;
@@ -30,7 +35,7 @@ namespace Robust.Client.Debugging
 
                 if (value && !_overlayManager.HasOverlay<EntityPositionOverlay>())
                 {
-                    _overlayManager.AddOverlay(new EntityPositionOverlay(_lookup, _eyeManager));
+                    _overlayManager.AddOverlay(new EntityPositionOverlay(_lookup, _eyeManager, _entityManager));
                 }
                 else
                 {
@@ -41,15 +46,17 @@ namespace Robust.Client.Debugging
 
         private sealed class EntityPositionOverlay : Overlay
         {
-            private readonly IEntityLookup _lookup;
+            private readonly EntityLookupSystem _lookup;
             private readonly IEyeManager _eyeManager;
+            private readonly IEntityManager _entityManager;
 
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public EntityPositionOverlay(IEntityLookup lookup, IEyeManager eyeManager)
+            public EntityPositionOverlay(EntityLookupSystem lookup, IEyeManager eyeManager, IEntityManager entityManager)
             {
                 _lookup = lookup;
                 _eyeManager = eyeManager;
+                _entityManager = entityManager;
             }
 
             protected internal override void Draw(in OverlayDrawArgs args)
@@ -58,13 +65,11 @@ namespace Robust.Client.Debugging
 
                 var worldHandle = (DrawingHandleWorld) args.DrawingHandle;
                 var viewport = _eyeManager.GetWorldViewport();
+                var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
 
                 foreach (var entity in _lookup.GetEntitiesIntersecting(_eyeManager.CurrentMap, viewport))
                 {
-                    var transform = entity.Transform;
-
-                    var center = transform.WorldPosition;
-                    var worldRotation = transform.WorldRotation;
+                    var (center, worldRotation) = xformQuery.GetComponent(entity).GetWorldPositionRotation();
 
                     var xLine = worldRotation.RotateVec(Vector2.UnitX);
                     var yLine = worldRotation.RotateVec(Vector2.UnitY);

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -162,6 +162,7 @@ namespace Robust.Client.Debugging
         ShapeInfo = 1 << 3,
         Joints = 1 << 4,
         AABBs = 1 << 5,
+        COM = 1 << 6,
     }
 
     internal sealed class PhysicsDebugOverlay : Overlay
@@ -190,26 +191,26 @@ namespace Robust.Client.Debugging
             _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
         }
 
-        private void DrawWorld(DrawingHandleWorld worldHandle)
+        private void DrawWorld(DrawingHandleWorld worldHandle, OverlayDrawArgs args)
         {
-            var viewport = _eyeManager.GetWorldViewport();
-            var viewBounds = _eyeManager.GetWorldViewbounds();
+            var viewBounds = args.WorldBounds;
+            var viewAABB = args.WorldAABB;
             var mapId = _eyeManager.CurrentMap;
 
-            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.Shapes) != 0 && !viewport.IsEmpty())
+            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.Shapes) != 0)
             {
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
                 {
-                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+                    if (_entityManager.HasComponent<MapGridComponent>(physBody.Owner)) continue;
 
                     var xform = physBody.GetTransform();
 
                     const float AlphaModifier = 0.2f;
 
-                    foreach (var fixture in physBody.Fixtures)
+                    foreach (var fixture in _entityManager.GetComponent<FixturesComponent>(physBody.Owner).Fixtures.Values)
                     {
-                        // Invalid shape - Box2D doesn't check for IsSensor
-                        if (physBody.BodyType == BodyType.Dynamic && fixture.Mass == 0f)
+                        // Invalid shape - Box2D doesn't check for IsSensor but we will for sanity.
+                        if (physBody.BodyType == BodyType.Dynamic && fixture.Mass == 0f && fixture.Hard)
                         {
                             DrawShape(worldHandle, fixture, xform, Color.Red.WithAlpha(AlphaModifier));
                         }
@@ -237,18 +238,43 @@ namespace Robust.Client.Debugging
                 }
             }
 
-            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.AABBs) != 0 && !viewport.IsEmpty())
+            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.COM) != 0)
             {
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
                 {
-                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+                    Color color;
+                    const float Alpha = 0.25f;
+                    float size;
+
+                    if (_entityManager.HasComponent<MapGridComponent>(physBody.Owner))
+                    {
+                        color = Color.Orange.WithAlpha(Alpha);
+                        size = 1f;
+                    }
+                    else
+                    {
+                        color = Color.Purple.WithAlpha(Alpha);
+                        size = 0.2f;
+                    }
+
+                    var transform = physBody.GetTransform();
+
+                    worldHandle.DrawCircle(Transform.Mul(transform, physBody.LocalCenter), size, color);
+                }
+            }
+
+            if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.AABBs) != 0)
+            {
+                foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, viewBounds))
+                {
+                    if (_entityManager.HasComponent<MapGridComponent>(physBody.Owner)) continue;
 
                     var xform = physBody.GetTransform();
 
                     const float AlphaModifier = 0.2f;
                     Box2? aabb = null;
 
-                    foreach (var fixture in physBody.Fixtures)
+                    foreach (var fixture in _entityManager.GetComponent<FixturesComponent>(physBody.Owner).Fixtures.Values)
                     {
                         for (var i = 0; i < fixture.Shape.ChildCount; i++)
                         {
@@ -270,8 +296,8 @@ namespace Robust.Client.Debugging
                 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;
+                        !_entityManager.TryGetComponent(jointComponent.Owner, out TransformComponent? xf1) ||
+                        !viewAABB.Contains(xf1.WorldPosition)) continue;
 
                     foreach (var (_, joint) in jointComponent.Joints)
                     {
@@ -312,7 +338,7 @@ namespace Robust.Client.Debugging
             }
         }
 
-        private void DrawScreen(DrawingHandleScreen screenHandle)
+        private void DrawScreen(DrawingHandleScreen screenHandle, OverlayDrawArgs args)
         {
             var mapId = _eyeManager.CurrentMap;
             var mousePos = _inputManager.MouseScreenPosition;
@@ -324,7 +350,7 @@ namespace Robust.Client.Debugging
 
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, bounds))
                 {
-                    if (physBody.Owner.HasComponent<MapGridComponent>()) continue;
+                    if (_entityManager.HasComponent<MapGridComponent>(physBody.Owner)) continue;
                     hoverBodies.Add(physBody);
                 }
 
@@ -359,10 +385,10 @@ namespace Robust.Client.Debugging
             switch (args.Space)
             {
                 case OverlaySpace.ScreenSpace:
-                    DrawScreen((DrawingHandleScreen) args.DrawingHandle);
+                    DrawScreen((DrawingHandleScreen) args.DrawingHandle, args);
                     break;
                 case OverlaySpace.WorldSpace:
-                    DrawWorld((DrawingHandleWorld) args.DrawingHandle);
+                    DrawWorld((DrawingHandleWorld) args.DrawingHandle, args);
                     break;
             }
         }
@@ -382,8 +408,8 @@ namespace Robust.Client.Debugging
 
                     if (edge.OneSided)
                     {
-                        worldHandle.DrawCircle(v1, 0.5f, color);
-                        worldHandle.DrawCircle(v2, 0.5f, color);
+                        worldHandle.DrawCircle(v1, 0.1f, color);
+                        worldHandle.DrawCircle(v2, 0.1f, color);
                     }
 
                     break;
@@ -416,11 +442,45 @@ namespace Robust.Client.Debugging
             var p1 = matrix1.Transform(joint.LocalAnchorA);
             var p2 = matrix2.Transform(joint.LocalAnchorB);
 
+            var xfa = new Transform(xf1, xform1.WorldRotation);
+            var xfb = new Transform(xf2, xform2.WorldRotation);
+
             switch (joint)
             {
                 case DistanceJoint:
                     worldHandle.DrawLine(xf1, xf2, JointColor);
                     break;
+                case PrismaticJoint prisma:
+                    var pA = Transform.Mul(xfa, joint.LocalAnchorA);
+                    var pB = Transform.Mul(xfb, joint.LocalAnchorB);
+
+                    var axis = Transform.Mul(xfa.Quaternion2D, prisma._localXAxisA);
+
+                    Color c1 = new(0.7f, 0.7f, 0.7f);
+                    Color c2 = new(0.3f, 0.9f, 0.3f);
+                    Color c3 = new(0.9f, 0.3f, 0.3f);
+                    Color c4 = new(0.3f, 0.3f, 0.9f);
+                    Color c5 = new(0.4f, 0.4f, 0.4f);
+
+                    worldHandle.DrawLine(pA, pB, c5);
+
+                    if (prisma.EnableLimit)
+                    {
+                        var lower = pA + axis * prisma.LowerTranslation;
+                        var upper = pA + axis * prisma.UpperTranslation;
+                        var perp = Transform.Mul(xfa.Quaternion2D, prisma._localYAxisA);
+                        worldHandle.DrawLine(lower, upper, c1);
+                        worldHandle.DrawLine(lower - perp * 0.5f, lower + perp * 0.5f, c2);
+                        worldHandle.DrawLine(upper - perp * 0.5f, upper + perp * 0.5f, c3);
+                    }
+                    else
+                    {
+                        worldHandle.DrawLine(pA - axis * 1.0f, pA + axis * 1.0f, c1);
+                    }
+
+                    worldHandle.DrawCircle(pA, 0.5f, c1);
+                    worldHandle.DrawCircle(pB, 0.5f, c4);
+                    break;
                 default:
                     worldHandle.DrawLine(xf1, p1, JointColor);
                     worldHandle.DrawLine(p1, p2, JointColor);

Robust.Client/Debugging/IDebugDrawing.cs

@@ -1,13 +0,0 @@
-namespace Robust.Client.Debugging
-{
-    /// <summary>
-    /// A collection of visual debug overlays for the client game.
-    /// </summary>
-    public interface IDebugDrawing
-    {
-        /// <summary>
-        /// Toggles the visual overlay of the local origin for each entity on screen.
-        /// </summary>
-        bool DebugPositions { get; set; }
-    }
-}