Re-implement inertia (#1652)

* Implement inertia

* actual SPEEN

* Sync mass

* bitcoin miner

* I am le dumb

* also dis

Co-authored-by: Metal Gear Sloth <metalgearsloth@gmail.com>

.github/CODEOWNERS

@@ -1,14 +1,7 @@
-# Lines starting with '#' are comments.
-# Each line is a file pattern followed by one or more owners.
+# Last match in file takes precedence.
 
-# These owners will be the default owners for everything in the repo.
-# * @defunkt
-* @Acruid @PJB3005 @Silvertorch5
+# Be they Fluent translations or Freemarker templates, I know them both!
+*.ftl @RemieRichards
 
-# Order is important. The last matching pattern has the most precedence.
-# So if a pull request only touches javascript files, only these owners
-# will be requested to review.
-# *.js    @octocat @github/js
-
-# You can also use email addresses if you prefer.
-# docs/*  docs@example.com
+# Ping for all PRs
+* @Acruid @PJB3005 @Silvertorch5

Resources/EngineCredits/Libraries.yml

@@ -574,29 +574,22 @@
     OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
     SOFTWARE.
 
-- name: NGetText
+- name: Fluent.Net
   license: |
-    The MIT License (MIT)
+    blushingpenguin and Contributors
 
-    Copyright (c) 2012 Vitaly Zilnik
+    All rights reserved.
 
-    Permission is hereby granted, free of charge, to any person obtaining a copy
-    of this software and associated documentation files (the "Software"), to deal
-    in the Software without restriction, including without limitation the rights
-    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-    copies of the Software, and to permit persons to whom the Software is
-    furnished to do so, subject to the following conditions:
+    Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+    this file except in compliance with the License. You may obtain a copy of the
+    License at
 
-    The above copyright notice and this permission notice shall be included in all
-    copies or substantial portions of the Software.
+        http://www.apache.org/licenses/LICENSE-2.0
 
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-    SOFTWARE.
+    Unless required by applicable law or agreed to in writing, software distributed
+    under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+    CONDITIONS OF ANY KIND, either express or implied. See the License for the
+    specific language governing permissions and limitations under the License.
 
 - name: NetSerializer
   license: |

Resources/Locale/en-US/ss14window.ftl

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

Resources/Prototypes/dbg_rotationMarker.yml

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

Resources/Prototypes/dummy_entity.yml

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

Resources/Shaders/Internal/fov-lighting.swsl

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

Resources/Textures/debugRotation.rsi/meta.json

@@ -0,0 +1,17 @@
+{
+    "version": 1,
+    "size": {
+        "x": 32,
+        "y": 32
+    },
+    "states": [{
+            "name": "direction1",
+            "directions": 1,
+            "delays": [[1.0]]
+        }, {
+            "name": "direction4",
+            "directions": 4,
+            "delays": [[1.0], [1.0], [1.0], [1.0]]
+        }
+    ]
+}

Robust.Analyzers/Diagnostics.cs

@@ -0,0 +1,10 @@
+using Microsoft.CodeAnalysis;
+
+namespace Robust.Generators
+{
+    public static class Diagnostics
+    {
+        public static SuppressionDescriptor MeansImplicitAssignment =>
+            new SuppressionDescriptor("RADC1000", "CS0649", "Marked as implicitly assigned.");
+    }
+}

Robust.Analyzers/MeansImplicitAssigmentSuppressor.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Immutable;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Robust.Generators;
+
+namespace Robust.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class MeansImplicitAssigmentSuppressor : DiagnosticSuppressor
+    {
+        const string MeansImplicitAssignmentAttribute = "Robust.Shared.MeansImplicitAssignmentAttribute";
+
+        public override void ReportSuppressions(SuppressionAnalysisContext context)
+        {
+            var implAttr = context.Compilation.GetTypeByMetadataName(MeansImplicitAssignmentAttribute);
+            foreach (var reportedDiagnostic in context.ReportedDiagnostics)
+            {
+                if(reportedDiagnostic.Id != Diagnostics.MeansImplicitAssignment.SuppressedDiagnosticId) continue;
+
+                var node = reportedDiagnostic.Location.SourceTree?.GetRoot(context.CancellationToken).FindNode(reportedDiagnostic.Location.SourceSpan);
+                if (node == null) continue;
+
+                var symbol = context.GetSemanticModel(reportedDiagnostic.Location.SourceTree).GetDeclaredSymbol(node);
+
+                if (symbol == null || !symbol.GetAttributes().Any(a =>
+                    a.AttributeClass?.GetAttributes().Any(attr =>
+                        SymbolEqualityComparer.Default.Equals(attr.AttributeClass, implAttr)) == true))
+                {
+                    continue;
+                }
+
+                context.ReportSuppression(Suppression.Create(
+                    Diagnostics.MeansImplicitAssignment,
+                    reportedDiagnostic));
+            }
+        }
+
+        public override ImmutableArray<SuppressionDescriptor> SupportedSuppressions => ImmutableArray.Create(Diagnostics.MeansImplicitAssignment);
+    }
+}

Robust.Client.Injectors/MathParsing.cs

@@ -0,0 +1,37 @@
+using System.Linq;
+using Pidgin;
+using static Pidgin.Parser;
+
+
+namespace Robust.Build.Tasks
+{
+    public static class MathParsing
+    {
+        public static Parser<char, float> Single { get; } = Real.Select(c => (float) c);
+
+        public static Parser<char, float> Single1 { get; }
+            = Single.Between(SkipWhitespaces);
+
+        public static Parser<char, (float, float)> Single2 { get; }
+            = Single.Before(SkipWhitespaces).Repeat(2).Select(e =>
+            {
+                var arr = e.ToArray();
+                return (arr[0], arr[1]);
+            });
+
+        public static Parser<char, (float, float, float, float)> Single4 { get; }
+            = Single.Before(SkipWhitespaces).Repeat(4).Select(e =>
+            {
+                var arr = e.ToArray();
+                return (arr[0], arr[1], arr[2], arr[3]);
+            });
+
+        public static Parser<char, float[]> Thickness { get; }
+            = SkipWhitespaces.Then(
+                OneOf(
+                    Try(Single4.Select(c => new[] {c.Item1, c.Item2, c.Item3, c.Item4})),
+                    Try(Single2.Select(c => new[] {c.Item1, c.Item2})),
+                    Try(Single1.Select(c => new[] {c}))
+                ));
+    }
+}

Robust.Client.Injectors/RXamlColorAstNode.cs

@@ -0,0 +1,32 @@
+using System.Reflection.Emit;
+using XamlX.Ast;
+using XamlX.Emit;
+using XamlX.IL;
+using XamlX.TypeSystem;
+
+namespace Robust.Build.Tasks
+{
+    internal class RXamlColorAstNode
+        : XamlAstNode, IXamlAstValueNode, IXamlAstILEmitableNode
+    {
+        private readonly IXamlMethod _method;
+        private readonly string _color;
+
+        public RXamlColorAstNode(IXamlLineInfo lineInfo, RXamlWellKnownTypes types, string color) : base(lineInfo)
+        {
+            _color = color;
+            Type = new XamlAstClrTypeReference(lineInfo, types.Color, false);
+            _method = types.ColorFromXaml;
+        }
+
+        public IXamlAstTypeReference Type { get; }
+
+        public XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context, IXamlILEmitter codeGen)
+        {
+            codeGen.Ldstr(_color);
+            codeGen.EmitCall(_method);
+
+            return XamlILNodeEmitResult.Type(0, Type.GetClrType());
+        }
+    }
+}

Robust.Client.Injectors/RXamlVecLikeConstAstNode.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Linq;
+using System.Reflection.Emit;
+using XamlX.Ast;
+using XamlX.Emit;
+using XamlX.IL;
+using XamlX.TypeSystem;
+
+namespace Robust.Build.Tasks
+{
+    public abstract class RXamlVecLikeConstAstNode<T>
+        : XamlAstNode, IXamlAstValueNode, IXamlAstILEmitableNode
+        where T : unmanaged
+    {
+        private readonly IXamlConstructor _constructor;
+        protected readonly T[] Values;
+
+        public RXamlVecLikeConstAstNode(
+            IXamlLineInfo lineInfo,
+            IXamlType type, IXamlConstructor constructor,
+            IXamlType componentType, T[] values)
+            : base(lineInfo)
+        {
+            _constructor = constructor;
+            Values = values;
+
+            var @params = constructor.Parameters;
+
+            if (@params.Count != values.Length)
+                throw new ArgumentException("Invalid amount of parameters");
+
+            if (@params.Any(c => c != componentType))
+                throw new ArgumentException("Invalid constructor: not all parameters match component type");
+
+            Type = new XamlAstClrTypeReference(lineInfo, type, false);
+        }
+
+        public IXamlAstTypeReference Type { get; }
+
+        public virtual XamlILNodeEmitResult Emit(
+            XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context,
+            IXamlILEmitter codeGen)
+        {
+            codeGen.Newobj(_constructor);
+
+            return XamlILNodeEmitResult.Type(0, Type.GetClrType());
+        }
+    }
+
+    public sealed class RXamlSingleVecLikeConstAstNode : RXamlVecLikeConstAstNode<float>
+    {
+        public RXamlSingleVecLikeConstAstNode(
+            IXamlLineInfo lineInfo,
+            IXamlType type, IXamlConstructor constructor,
+            IXamlType componentType, float[] values)
+            : base(lineInfo, type, constructor, componentType, values)
+        {
+        }
+
+        public override XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context,
+            IXamlILEmitter codeGen)
+        {
+            foreach (var value in Values)
+            {
+                codeGen.Emit(OpCodes.Ldc_R4, value);
+            }
+
+            return base.Emit(context, codeGen);
+        }
+    }
+
+    public sealed class RXamlInt32VecLikeConstAstNode : RXamlVecLikeConstAstNode<int>
+    {
+        public RXamlInt32VecLikeConstAstNode(
+            IXamlLineInfo lineInfo,
+            IXamlType type, IXamlConstructor constructor,
+            IXamlType componentType, int[] values)
+            : base(lineInfo, type, constructor, componentType, values)
+        {
+        }
+
+        public override XamlILNodeEmitResult Emit(XamlEmitContext<IXamlILEmitter, XamlILNodeEmitResult> context,
+            IXamlILEmitter codeGen)
+        {
+            foreach (var value in Values)
+            {
+                codeGen.Emit(OpCodes.Ldc_I4, value);
+            }
+
+            return base.Emit(context, codeGen);
+        }
+    }
+}

Robust.Client.Injectors/RXamlWellKnownTypes.cs

@@ -0,0 +1,58 @@
+using System.Linq;
+using XamlX.Transform;
+using XamlX.TypeSystem;
+
+namespace Robust.Build.Tasks
+{
+    class RXamlWellKnownTypes
+    {
+        public XamlTypeWellKnownTypes XamlIlTypes { get; }
+        public IXamlType Single { get; }
+        public IXamlType Int32 { get; }
+        public IXamlType Vector2 { get; }
+        public IXamlConstructor Vector2ConstructorFull { get; }
+        public IXamlType Vector2i { get; }
+        public IXamlConstructor Vector2iConstructorFull { get; }
+        public IXamlType Thickness { get; }
+        public IXamlConstructor ThicknessConstructorFull { get; }
+        public IXamlType Color { get; }
+        public IXamlMethod ColorFromXaml { get; }
+
+        public RXamlWellKnownTypes(TransformerConfiguration cfg)
+        {
+            var ts = cfg.TypeSystem;
+            XamlIlTypes = cfg.WellKnownTypes;
+            Single = ts.GetType("System.Single");
+            Int32 = ts.GetType("System.Int32");
+
+            (Vector2, Vector2ConstructorFull) = GetNumericTypeInfo("Robust.Shared.Maths.Vector2", Single, 2);
+            (Vector2i, Vector2iConstructorFull) = GetNumericTypeInfo("Robust.Shared.Maths.Vector2i", Int32, 2);
+            (Thickness, ThicknessConstructorFull) = GetNumericTypeInfo("Robust.Shared.Maths.Thickness", Single, 4);
+
+            (IXamlType, IXamlConstructor) GetNumericTypeInfo(string name, IXamlType componentType, int componentCount)
+            {
+                var type = cfg.TypeSystem.GetType(name);
+                var ctor = type.GetConstructor(Enumerable.Repeat(componentType, componentCount).ToList());
+
+                return (type, ctor);
+            }
+
+            Color = cfg.TypeSystem.GetType("Robust.Shared.Maths.Color");
+            ColorFromXaml = Color.GetMethod(new FindMethodMethodSignature("FromXaml", Color, XamlIlTypes.String)
+            {
+                IsStatic = true
+            });
+        }
+    }
+
+    static class RXamlWellKnownTypesExtensions
+    {
+        public static RXamlWellKnownTypes GetRobustTypes(this AstTransformationContext ctx)
+        {
+            if (ctx.TryGetItem<RXamlWellKnownTypes>(out var rv))
+                return rv;
+            ctx.SetItem(rv = new RXamlWellKnownTypes(ctx.Configuration));
+            return rv;
+        }
+    }
+}

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

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

Robust.Client.Injectors/XamlCompiler.cs

@@ -6,6 +6,7 @@ using Microsoft.Build.Framework;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;
+using Pidgin;
 using XamlX;
 using XamlX.Ast;
 using XamlX.Emit;
@@ -70,7 +71,7 @@ namespace Robust.Build.Tasks
             {
                 XmlnsAttributes =
                 {
-                    typeSystem.GetType("Robust.Client.UserInterface.XAML.XmlnsDefinitionAttribute"),
+                    typeSystem.GetType("Avalonia.Metadata.XmlnsDefinitionAttribute"),
 
                 },
                 ContentAttributes =
@@ -98,7 +99,7 @@ namespace Robust.Build.Tasks
                 typeSystem,
                 typeSystem.TargetAssembly,
                 xamlLanguage,
-                XamlXmlnsMappings.Resolve(typeSystem, xamlLanguage));
+                XamlXmlnsMappings.Resolve(typeSystem, xamlLanguage), CustomValueConverter);
 
             var contextDef = new TypeDefinition("CompiledRobustXaml", "XamlIlContext",
                 TypeAttributes.Class, asm.MainModule.TypeSystem.Object);
@@ -297,6 +298,112 @@ namespace Robust.Build.Tasks
             return true;
         }
 
+        private static bool CustomValueConverter(
+            AstTransformationContext context,
+            IXamlAstValueNode node,
+            IXamlType type,
+            out IXamlAstValueNode result)
+        {
+            if (!(node is XamlAstTextNode textNode))
+            {
+                result = null;
+                return false;
+            }
+
+            var text = textNode.Text;
+            var types = context.GetRobustTypes();
+
+            if (type.Equals(types.Vector2))
+            {
+                var foo = MathParsing.Single2.Parse(text);
+
+                if (!foo.Success)
+                    throw new XamlLoadException($"Unable to parse \"{text}\" as a Vector2", node);
+
+                var (x, y) = foo.Value;
+
+                result = new RXamlSingleVecLikeConstAstNode(
+                    node,
+                    types.Vector2, types.Vector2ConstructorFull,
+                    types.Single, new[] {x, y});
+                return true;
+            }
+
+            if (type.Equals(types.Thickness))
+            {
+                var foo = MathParsing.Thickness.Parse(text);
+
+                if (!foo.Success)
+                    throw new XamlLoadException($"Unable to parse \"{text}\" as a Thickness", node);
+
+                var val = foo.Value;
+                float[] full;
+                if (val.Length == 1)
+                {
+                    var u = val[0];
+                    full = new[] {u, u, u, u};
+                }
+                else if (val.Length == 2)
+                {
+                    var h = val[0];
+                    var v = val[1];
+                    full = new[] {h, v, h, v};
+                }
+                else // 4
+                {
+                    full = val;
+                }
+
+                result = new RXamlSingleVecLikeConstAstNode(
+                    node,
+                    types.Thickness, types.ThicknessConstructorFull,
+                    types.Single, full);
+                return true;
+            }
+
+            if (type.Equals(types.Thickness))
+            {
+                var foo = MathParsing.Thickness.Parse(text);
+
+                if (!foo.Success)
+                    throw new XamlLoadException($"Unable to parse \"{text}\" as a Thickness", node);
+
+                var val = foo.Value;
+                float[] full;
+                if (val.Length == 1)
+                {
+                    var u = val[0];
+                    full = new[] {u, u, u, u};
+                }
+                else if (val.Length == 2)
+                {
+                    var h = val[0];
+                    var v = val[1];
+                    full = new[] {h, v, h, v};
+                }
+                else // 4
+                {
+                    full = val;
+                }
+
+                result = new RXamlSingleVecLikeConstAstNode(
+                    node,
+                    types.Thickness, types.ThicknessConstructorFull,
+                    types.Single, full);
+                return true;
+            }
+
+            if (type.Equals(types.Color))
+            {
+                // TODO: Interpret these colors at XAML compile time instead of at runtime.
+                result = new RXamlColorAstNode(node, types, text);
+                return true;
+            }
+
+            result = null;
+            return false;
+        }
+
         public const string ContextNameScopeFieldName = "RobustNameScope";
 
         private static void EmitNameScopeField(XamlLanguageTypeMappings xamlLanguage, CecilTypeSystem typeSystem, IXamlTypeBuilder<IXamlILEmitter> typeBuilder, IXamlILEmitter constructor)

Robust.Client.NameGenerator/XamlUiPartialClassGenerator.cs

@@ -24,6 +24,7 @@ namespace Robust.Client.NameGenerator
     {
         private const string AttributeName = "Robust.Client.AutoGenerated.GenerateTypedNameReferencesAttribute";
         private const string AttributeFile = "GenerateTypedNameReferencesAttribute";
+
         private const string AttributeCode = @"// <auto-generated />
 using System;
 namespace Robust.Client.AutoGenerated
@@ -54,8 +55,8 @@ namespace Robust.Client.AutoGenerated
                 {
                     var clrtype = objectNode.Type.GetClrType();
                     var isControl = IsControl(clrtype);
-                        //clrtype.Interfaces.Any(i =>
-                        //i.IsInterface && i.FullName == "Robust.Client.UserInterface.IControl");
+                    //clrtype.Interfaces.Any(i =>
+                    //i.IsInterface && i.FullName == "Robust.Client.UserInterface.IControl");
 
                     if (!isControl)
                         return node;
@@ -80,9 +81,13 @@ namespace Robust.Client.AutoGenerated
                 return node;
             }
 
-            public void Push(IXamlAstNode node) { }
+            public void Push(IXamlAstNode node)
+            {
+            }
 
-            public void Pop() { }
+            public void Pop()
+            {
+            }
         }
 
         private static string GenerateSourceCode(
@@ -97,16 +102,20 @@ namespace Robust.Client.AutoGenerated
             var compiler =
                 new XamlILCompiler(
                     new TransformerConfiguration(typeSystem, typeSystem.Assemblies[0],
-                        new XamlLanguageTypeMappings(typeSystem)),
+                        new XamlLanguageTypeMappings(typeSystem)
+                        {
+                            XmlnsAttributes = {typeSystem.GetType("Avalonia.Metadata.XmlnsDefinitionAttribute")}
+                        }),
                     new XamlLanguageEmitMappings<IXamlILEmitter, XamlILNodeEmitResult>(), false);
             compiler.Transformers.Add(new TypeReferenceResolver());
             compiler.Transform(parsed);
             var initialRoot = (XamlAstObjectNode) parsed.Root;
             var names = NameVisitor.GetNames(initialRoot);
+            var fieldAccess = classSymbol.IsSealed ? "private" : "protected";
             //var names = NameVisitor.GetNames((XamlAstObjectNode)XDocumentXamlParser.Parse(xamlFile).Root);
             var namedControls = names.Select(info => "        " +
-                                $"protected global::{info.type} {info.name} => " +
-                                $"this.FindControl<global::{info.type}>(\"{info.name}\");");
+                                                     $"{fieldAccess} global::{info.type} {info.name} => " +
+                                                     $"this.FindControl<global::{info.type}>(\"{info.name}\");");
             return $@"// <auto-generated />
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
@@ -124,7 +133,7 @@ namespace {nameSpace}
         public void Execute(GeneratorExecutionContext context)
         {
             var comp = (CSharpCompilation) context.Compilation;
-            if(comp.GetTypeByMetadataName(AttributeName) == null)
+            if (comp.GetTypeByMetadataName(AttributeName) == null)
                 context.AddSource(AttributeFile, SourceText.From(AttributeCode, Encoding.UTF8));
             if (!(context.SyntaxReceiver is NameReferenceSyntaxReceiver receiver))
             {
@@ -132,7 +141,7 @@ namespace {nameSpace}
             }
 
             var symbols = UnpackAnnotatedTypes(context, comp, receiver);
-            if(symbols == null)
+            if (symbols == null)
                 return;
 
             foreach (var typeSymbol in symbols)
@@ -168,7 +177,8 @@ namespace {nameSpace}
                                 "Usage",
                                 DiagnosticSeverity.Error,
                                 true),
-                            Location.Create(xamlFileName, new TextSpan(0,0), new LinePositionSpan(new LinePosition(0,0),new LinePosition(0,0)))));
+                            Location.Create(xamlFileName, new TextSpan(0, 0),
+                                new LinePositionSpan(new LinePosition(0, 0), new LinePosition(0, 0)))));
                     continue;
                 }
 
@@ -194,7 +204,8 @@ namespace {nameSpace}
             }
         }
 
-        private IReadOnlyList<INamedTypeSymbol> UnpackAnnotatedTypes(in GeneratorExecutionContext context, CSharpCompilation comp, NameReferenceSyntaxReceiver receiver)
+        private IReadOnlyList<INamedTypeSymbol> UnpackAnnotatedTypes(in GeneratorExecutionContext context,
+            CSharpCompilation comp, NameReferenceSyntaxReceiver receiver)
         {
             var options = (CSharpParseOptions) comp.SyntaxTrees[0].Options;
             var compilation =

Robust.Client/Animations/Animation.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Collections.Generic;
-using Robust.Client.GameObjects.Components.Animations;
+using Robust.Client.GameObjects;
 
 namespace Robust.Client.Animations
 {
@@ -13,7 +13,7 @@ namespace Robust.Client.Animations
     /// <seealso cref="AnimationPlayerComponent"/>
     public sealed class Animation
     {
-        public readonly List<AnimationTrack> AnimationTracks = new();
+        public List<AnimationTrack> AnimationTracks { get; private set; } = new();
 
         public TimeSpan Length { get; set; }
     }

Robust.Client/Animations/AnimationTrackComponentProperty.cs

@@ -1,7 +1,7 @@
 using System;
 using JetBrains.Annotations;
 using Robust.Shared.Animations;
-using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
 
 namespace Robust.Client.Animations
 {

Robust.Client/Animations/AnimationTrackControlProperty.cs

@@ -1,8 +1,7 @@
 using System;
-using Robust.Client.Animations;
 using Robust.Shared.Animations;
 
-namespace Content.Client.Animations
+namespace Robust.Client.Animations
 {
     public class AnimationTrackControlProperty : AnimationTrackProperty
     {

Robust.Client/Animations/AnimationTrackPlaySound.cs

@@ -1,11 +1,9 @@
 using System;
 using System.Collections.Generic;
-using Robust.Client.GameObjects.EntitySystems;
+using Robust.Client.GameObjects;
 using Robust.Shared.Audio;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Utility;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Player;
 
 namespace Robust.Client.Animations
 {
@@ -17,7 +15,7 @@ namespace Robust.Client.Animations
         /// <summary>
         ///     A list of key frames for when to fire flicks.
         /// </summary>
-        public readonly List<KeyFrame> KeyFrames = new();
+        public List<KeyFrame> KeyFrames { get; private set; } = new();
 
         public override (int KeyFrameIndex, float FramePlayingTime) InitPlayback()
         {
@@ -39,8 +37,7 @@ namespace Robust.Client.Animations
 
                 var keyFrame = KeyFrames[keyFrameIndex];
 
-                EntitySystem.Get<AudioSystem>()
-                    .Play(keyFrame.Resource, entity, keyFrame.AudioParamsFunc.Invoke());
+                SoundSystem.Play(Filter.Local(), keyFrame.Resource, entity, keyFrame.AudioParamsFunc.Invoke());
             }
 
             return (keyFrameIndex, playingTime);

Robust.Client/Animations/AnimationTrackProperty.cs

@@ -10,7 +10,7 @@ namespace Robust.Client.Animations
     /// </summary>
     public abstract class AnimationTrackProperty : AnimationTrack
     {
-        public readonly List<KeyFrame> KeyFrames = new();
+        public List<KeyFrame> KeyFrames { get; protected set; } = new();
 
         /// <summary>
         ///     How to interpolate values when between two keyframes.

Robust.Client/Animations/AnimationTrackSpriteFlick.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
+using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
-using Robust.Client.Interfaces.GameObjects.Components;
-using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.Animations
@@ -15,7 +15,7 @@ namespace Robust.Client.Animations
         /// <summary>
         ///     A list of key frames for when to fire flicks.
         /// </summary>
-        public readonly List<KeyFrame> KeyFrames = new();
+        public List<KeyFrame> KeyFrames { get; private set; } = new();
 
         // TODO: Should this layer key be per keyframe maybe?
         /// <summary>

Robust.Client/Audio/AudioStream.cs

@@ -1,6 +1,5 @@
 using System;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.Clyde;
 
 namespace Robust.Client.Audio
 {

Robust.Client/Audio/Midi/MidiManager.cs

@@ -4,16 +4,15 @@ using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
 using NFluidsynth;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.ResourceManagement;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Log;
-using Robust.Shared.Interfaces.Physics;
-using Robust.Shared.Interfaces.Resources;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.ContentPack;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Broadphase;
 using Robust.Shared.Utility;
 using Logger = Robust.Shared.Log.Logger;
 
@@ -64,14 +63,18 @@ namespace Robust.Client.Audio.Midi
         bool IsAvailable { get; }
 
         public int OcclusionCollisionMask { get; set; }
+
+        void Shutdown();
     }
 
-    internal class MidiManager : IDisposable, IMidiManager
+    internal class MidiManager : IMidiManager
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
 
+        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
+
         public bool IsAvailable
         {
             get
@@ -155,6 +158,7 @@ namespace Robust.Client.Audio.Midi
             _midiThread = new Thread(ThreadUpdate);
             _midiThread.Start();
 
+            _broadPhaseSystem = EntitySystem.Get<SharedBroadPhaseSystem>();
             FluidsynthInitialized = true;
         }
 
@@ -299,7 +303,7 @@ namespace Robust.Client.Audio.Midi
                             var occlusion = 0f;
                             if (sourceRelative.Length > 0)
                             {
-                                occlusion = IoCManager.Resolve<IPhysicsManager>().IntersectRayPenetration(
+                                occlusion = _broadPhaseSystem.IntersectRayPenetration(
                                     pos.MapId,
                                     new CollisionRay(
                                         pos.Position,
@@ -316,6 +320,11 @@ namespace Robust.Client.Audio.Midi
                             continue;
                         }
 
+                        if (renderer.TrackingEntity != null)
+                        {
+                            renderer.Source.SetVelocity(renderer.TrackingEntity.GlobalLinearVelocity());
+                        }
+
                         if (float.IsNaN(pos.Position.X) || float.IsNaN(pos.Position.Y))
                         {
                             // just duck out instead of move to NaN
@@ -353,7 +362,7 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
-        public void Dispose()
+        public void Shutdown()
         {
             _alive = false;
             _midiThread?.Join();

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -1,11 +1,9 @@
 using System;
-using System.IO;
 using System.Runtime.Intrinsics.X86;
 using NFluidsynth;
-using Robust.Client.Interfaces.Graphics;
+using Robust.Client.Graphics;
 using Robust.Shared.Asynchronous;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Log;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;

Robust.Client/BaseClient.cs

@@ -1,20 +1,18 @@
 using System;
 using System.Net;
-using Robust.Client.Interfaces;
-using Robust.Client.Interfaces.Debugging;
-using Robust.Client.Interfaces.GameObjects;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Utility;
+using Robust.Client.Debugging;
+using Robust.Client.GameObjects;
+using Robust.Client.GameStates;
 using Robust.Client.Player;
+using Robust.Client.Utility;
 using Robust.Shared;
 using Robust.Shared.Configuration;
 using Robust.Shared.Enums;
-using Robust.Shared.Interfaces.Map;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Client

Robust.Client/ClientIoC.cs

@@ -1,33 +1,16 @@
-using System;
+using System;
 using Robust.Client.Audio.Midi;
 using Robust.Client.Console;
 using Robust.Client.Debugging;
 using Robust.Client.GameObjects;
 using Robust.Client.GameStates;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.ClientEye;
 using Robust.Client.Graphics.Clyde;
-using Robust.Client.Graphics.Lighting;
-using Robust.Client.Graphics.Overlays;
 using Robust.Client.Input;
-using Robust.Client.Interfaces;
-using Robust.Client.Interfaces.Debugging;
-using Robust.Client.Interfaces.GameObjects;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Graphics;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.Graphics.Lighting;
-using Robust.Client.Interfaces.Graphics.Overlays;
-using Robust.Client.Interfaces.Input;
-using Robust.Client.Interfaces.Map;
-using Robust.Client.Interfaces.Placement;
-using Robust.Client.Interfaces.ResourceManagement;
-using Robust.Client.Interfaces.State;
-using Robust.Client.Interfaces.UserInterface;
-using Robust.Client.Interfaces.Utility;
 using Robust.Client.Map;
 using Robust.Client.Placement;
 using Robust.Client.Player;
+using Robust.Client.Prototypes;
 using Robust.Client.Reflection;
 using Robust.Client.ResourceManagement;
 using Robust.Client.State;
@@ -35,15 +18,15 @@ using Robust.Client.UserInterface;
 using Robust.Client.Utility;
 using Robust.Client.ViewVariables;
 using Robust.Shared;
+using Robust.Shared.Console;
+using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Map;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Reflection;
-using Robust.Shared.Interfaces.Resources;
 using Robust.Shared.IoC;
+using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Players;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Reflection;
 
 namespace Robust.Client
 {
@@ -53,7 +36,7 @@ namespace Robust.Client
         {
             SharedIoC.RegisterIoC();
 
-            IoCManager.Register<IPrototypeManager, PrototypeManager>();
+            IoCManager.Register<IPrototypeManager, ClientPrototypeManager>();
             IoCManager.Register<IEntityManager, ClientEntityManager>();
             IoCManager.Register<IComponentFactory, ClientComponentFactory>();
             IoCManager.Register<ITileDefinitionManager, ClydeTileDefinitionManager>();
@@ -71,6 +54,7 @@ namespace Robust.Client
             IoCManager.Register<IClientGameStateManager, ClientGameStateManager>();
             IoCManager.Register<IBaseClient, BaseClient>();
             IoCManager.Register<IPlayerManager, PlayerManager>();
+            IoCManager.Register<ISharedPlayerManager, PlayerManager>();
             IoCManager.Register<IStateManager, StateManager>();
             IoCManager.Register<IUserInterfaceManager, UserInterfaceManager>();
             IoCManager.Register<IUserInterfaceManagerInternal, UserInterfaceManager>();
@@ -79,8 +63,7 @@ namespace Robust.Client
             IoCManager.Register<ILightManager, LightManager>();
             IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
             IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
-            IoCManager.Register<IFontManager, FontManager>();
-            IoCManager.Register<IFontManagerInternal, FontManager>();
+            IoCManager.Register<IConsoleHost, ClientConsoleHost>();
             IoCManager.Register<IMidiManager, MidiManager>();
             IoCManager.Register<IAuthManager, AuthManager>();
             switch (mode)
@@ -107,8 +90,9 @@ namespace Robust.Client
                     throw new ArgumentOutOfRangeException();
             }
 
+            IoCManager.Register<IFontManager, FontManager>();
+            IoCManager.Register<IFontManagerInternal, FontManager>();
             IoCManager.Register<IEyeManager, EyeManager>();
-
             IoCManager.Register<IPlacementManager, PlacementManager>();
             IoCManager.Register<IOverlayManager, OverlayManager>();
             IoCManager.Register<IOverlayManagerInternal, OverlayManager>();
@@ -116,7 +100,6 @@ namespace Robust.Client
             IoCManager.Register<IViewVariablesManagerInternal, ViewVariablesManager>();
             IoCManager.Register<IClientConGroupController, ClientConGroupController>();
             IoCManager.Register<IScriptClient, ScriptClient>();
-            //IoCManager.Register<IXamlCompiler, XamlCompiler>();
         }
     }
 }

Robust.Client/Console/ClientConsoleHost.cs

@@ -36,7 +36,7 @@ namespace Robust.Client.Console
             Message = message;
         }
     }
-
+    
     /// <inheritdoc cref="IClientConsoleHost" />
     internal class ClientConsoleHost : ConsoleHost, IClientConsoleHost
     {
@@ -47,12 +47,20 @@ namespace Robust.Client.Console
         {
             NetManager.RegisterNetMessage<MsgConCmdReg>(MsgConCmdReg.NAME, HandleConCmdReg);
             NetManager.RegisterNetMessage<MsgConCmdAck>(MsgConCmdAck.NAME, HandleConCmdAck);
-            NetManager.RegisterNetMessage<MsgConCmd>(MsgConCmd.NAME);
+            NetManager.RegisterNetMessage<MsgConCmd>(MsgConCmd.NAME, ProcessCommand);
 
             Reset();
             LogManager.RootSawmill.AddHandler(new DebugConsoleLogHandler(this));
         }
 
+        private void ProcessCommand(MsgConCmd message)
+        {
+            string? text = message.Text;
+            LogManager.GetSawmill(SawmillName).Info($"SERVER:{text}");
+
+            ExecuteCommand(null, text);
+        }
+
         /// <inheritdoc />
         public void Reset()
         {
@@ -104,14 +112,14 @@ namespace Robust.Client.Console
                 args.RemoveAt(0);
                 command1.Execute(new ConsoleShell(this, null), command, args.ToArray());
             }
-            else if (!NetManager.IsConnected)
+            else
                 WriteError(null, "Unknown command: " + commandName);
         }
 
         /// <inheritdoc />
         public override void RemoteExecuteCommand(ICommonSession? session, string command)
         {
-            if (!NetManager.IsConnected)
+            if (!NetManager.IsConnected) // we don't care about session on client
                 return;
 
             var msg = NetManager.CreateNetMessage<MsgConCmd>();

Robust.Client/Console/Commands/AddCompCommand.cs

@@ -1,8 +1,6 @@
 using JetBrains.Annotations;
-using Robust.Client.Player;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 
 namespace Robust.Client.Console.Commands

Robust.Client/Console/Commands/ClientSpawnCommand.cs

@@ -1,7 +1,7 @@
 using JetBrains.Annotations;
 using Robust.Client.Player;
 using Robust.Shared.Console;
-using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 
 namespace Robust.Client.Console.Commands

Robust.Client/Console/Commands/ConfigurationCommands.cs

@@ -3,9 +3,7 @@ using System.Linq;
 using JetBrains.Annotations;
 using Robust.Shared.Configuration;
 using Robust.Shared.Console;
-using Robust.Shared.Interfaces.Configuration;
 using Robust.Shared.IoC;
-using Robust.Shared.Maths;
 
 namespace Robust.Client.Console.Commands
 {

Robust.Client/Console/Commands/ConsoleCommands.cs

@@ -2,11 +2,7 @@
 // Not some generic console command type.
 // Couldn't think of a better name sorry.
 
-using System;
 using Robust.Shared.Console;
-using Robust.Shared.Interfaces.Random;
-using Robust.Shared.IoC;
-using Robust.Shared.Maths;
 
 namespace Robust.Client.Console.Commands
 {

Robust.Client/Console/Commands/Debug.cs

@@ -6,21 +6,12 @@ using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Runtime;
-using System.Runtime.InteropServices;
 using System.Text;
 using System.Text.RegularExpressions;
 using Robust.Client.Input;
-using System.Threading;
-using Robust.Client.Interfaces;
-using Robust.Client.Interfaces.Debugging;
-using Robust.Client.Interfaces.Graphics;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.Graphics.Lighting;
-using Robust.Client.Interfaces.Input;
-using Robust.Client.Interfaces.ResourceManagement;
-using Robust.Client.Interfaces.State;
-using Robust.Client.Interfaces.UserInterface;
-using Robust.Client.ResourceManagement.ResourceTypes;
+using Robust.Client.Debugging;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
@@ -28,15 +19,11 @@ using Robust.Shared.Asynchronous;
 using Robust.Shared.Console;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.Transform;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Map;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Reflection;
-using Robust.Shared.Interfaces.Resources;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
+using Robust.Shared.Network;
+using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
@@ -493,6 +480,8 @@ namespace Robust.Client.Console.Commands
             {
                 _writeNode(root, 0, writer);
             }
+
+            shell.WriteLine("Saved guidump");
         }
 
         private static void _writeNode(Control control, int indents, TextWriter writer)
@@ -554,7 +543,7 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var window = new SS14Window { CustomMinimumSize = (500, 400)};
+            var window = new SS14Window { MinSize = (500, 400)};
             var tabContainer = new TabContainer();
             window.Contents.AddChild(tabContainer);
             var scroll = new ScrollContainer();
@@ -574,7 +563,7 @@ namespace Robust.Client.Console.Commands
             optionButton.OnItemSelected += eventArgs => optionButton.SelectId(eventArgs.Id);
             vBox.AddChild(optionButton);
 
-            var tree = new Tree { SizeFlagsVertical = Control.SizeFlags.FillExpand };
+            var tree = new Tree { VerticalExpand = true };
             var root = tree.CreateItem();
             root.Text = "Honk!";
             var child = tree.CreateItem();
@@ -611,7 +600,7 @@ namespace Robust.Client.Console.Commands
                 {
                     grid.AddChild(new Button
                     {
-                        CustomMinimumSize = (50, 50),
+                        MinSize = (50, 50),
                         Text = $"{x}, {y}"
                     });
                 }
@@ -643,6 +632,29 @@ namespace Robust.Client.Console.Commands
                 }
             });
 
+            tabContainer.AddChild(new HSplitContainer
+            {
+                Children =
+                {
+                    new PanelContainer
+                    {
+                        PanelOverride = new StyleBoxFlat {BackgroundColor = Color.Red},
+                        Children =
+                        {
+                            new Label{  Text = "FOOBARBAZ"},
+                        }
+                    },
+                    new PanelContainer
+                    {
+                        PanelOverride = new StyleBoxFlat {BackgroundColor = Color.Blue},
+                        Children =
+                        {
+                            new Label{  Text = "FOOBARBAZ"},
+                        }
+                    },
+                }
+            });
+
             window.OpenCentered();
         }
     }

Robust.Client/Console/Commands/DumpMetadataMembersCommand.cs

@@ -1,7 +1,6 @@
 using System;
 using Robust.Shared.Console;
 using Robust.Shared.ContentPack;
-using Robust.Shared.Maths;
 
 namespace Robust.Client.Console.Commands
 {

Robust.Client/Console/Commands/HelpCommands.cs

@@ -1,8 +1,7 @@
 using System.Linq;
 using Robust.Shared.Console;
-using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
-using Robust.Shared.Maths;
+using Robust.Shared.Network;
 
 namespace Robust.Client.Console.Commands
 {

Robust.Client/Console/Commands/ListAssembliesCommand.cs

@@ -1,6 +1,5 @@
 using System.Linq;
 using System.Runtime.Loader;
-using System.Text;
 using JetBrains.Annotations;
 using Robust.Shared.Console;
 

Robust.Client/Console/Commands/LogCommands.cs

@@ -1,5 +1,4 @@
 using Robust.Shared.Log;
-using Robust.Shared.Maths;
 using System;
 using Robust.Shared.Console;
 

Robust.Client/Console/Commands/MonitorCommands.cs

@@ -0,0 +1,44 @@
+using System.Linq;
+using JetBrains.Annotations;
+using Robust.Client.Graphics;
+using Robust.Shared.Console;
+using Robust.Shared.IoC;
+
+namespace Robust.Client.Console.Commands
+{
+    [UsedImplicitly]
+    public sealed class LsMonitorCommand : IConsoleCommand
+    {
+        public string Command => "lsmonitor";
+        public string Description => "";
+        public string Help => "";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            var clyde = IoCManager.Resolve<IClyde>();
+
+            foreach (var monitor in clyde.EnumerateMonitors())
+            {
+                shell.WriteLine(
+                    $"[{monitor.Id}] {monitor.Name}: {monitor.Size.X}x{monitor.Size.Y}@{monitor.RefreshRate}Hz");
+            }
+        }
+    }
+
+    [UsedImplicitly]
+    public sealed class SetMonitorCommand : IConsoleCommand
+    {
+        public string Command => "setmonitor";
+        public string Description => "";
+        public string Help => "Usage: setmonitor <id>";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            var clyde = IoCManager.Resolve<IClyde>();
+
+            var id = int.Parse(args[0]);
+            var monitor = clyde.EnumerateMonitors().Single(m => m.Id == id);
+            clyde.SetWindowMonitor(monitor);
+        }
+    }
+}

Robust.Client/Console/Commands/PhysicsOverlayCommands.cs

@@ -0,0 +1,41 @@
+using Robust.Client.Debugging;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public sealed class PhysicsOverlayCommands : IConsoleCommand
+    {
+        public string Command => "physics";
+        public string Description => $"{Command} <contactnormals / contactpoints / shapes>";
+        public string Help => $"{Command} <overlay>";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            if (args.Length != 1)
+            {
+                shell.WriteLine($"Invalid number of args supplied");
+                return;
+            }
+
+            var system = EntitySystem.Get<DebugPhysicsSystem>();
+
+            switch (args[0])
+            {
+                case "contactnormals":
+                    system.Flags ^= PhysicsDebugFlags.ContactNormals;
+                    break;
+                case "contactpoints":
+                    system.Flags ^= PhysicsDebugFlags.ContactPoints;
+                    break;
+                case "shapes":
+                    system.Flags ^= PhysicsDebugFlags.Shapes;
+                    break;
+                default:
+                    shell.WriteLine($"{args[0]} is not a recognised overlay");
+                    return;
+            }
+
+            return;
+        }
+    }
+}

Robust.Client/Console/Commands/ReloadLocalizationsCommand.cs

@@ -0,0 +1,20 @@
+using Robust.Shared.Console;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+
+namespace Robust.Client.Console.Commands
+{
+    internal sealed class ReloadLocalizationsCommand : IConsoleCommand
+    {
+        public string Command => "rldloc";
+        public string Description => "Reloads localization (client & server)";
+        public string Help => "Usage: rldloc";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            IoCManager.Resolve<ILocalizationManager>().ReloadLocalizations();
+
+            shell.RemoteExecuteCommand("sudo rldloc");
+        }
+    }
+}

Robust.Client/Console/Commands/Scripting.cs

@@ -1,7 +1,6 @@
 using Robust.Shared.Console;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
-using Robust.Shared.Maths;
 
 namespace Robust.Client.Console.Commands
 {

Robust.Client/Console/Commands/SendGarbageCommand.cs

@@ -1,5 +1,4 @@
 using Robust.Shared.Console;
-using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
 using Robust.Shared.Network;
 

Robust.Client/Console/Commands/SetInputContextCommand.cs

@@ -1,5 +1,5 @@
 using JetBrains.Annotations;
-using Robust.Client.Interfaces.Input;
+using Robust.Client.Input;
 using Robust.Shared.Console;
 using Robust.Shared.IoC;
 

Robust.Client/Console/Commands/VelocitiesCommand.cs

@@ -0,0 +1,17 @@
+using Robust.Client.GameObjects;
+using Robust.Shared.Console;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.Console.Commands
+{
+    public class VelocitiesCommand : IConsoleCommand
+    {
+        public string Command => "showvelocities";
+        public string Description => "Displays your angular and linear velocities";
+        public string Help => $"{Command}";
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            EntitySystem.Get<VelocityDebugSystem>().Enabled ^= true;
+        }
+    }
+}

Robust.Client/Console/IClientConGroupController.cs

@@ -1,6 +1,4 @@
-using System;
-
-namespace Robust.Client.Console
+namespace Robust.Client.Console
 {
     public interface IClientConGroupController : IClientConGroupImplementation
     {

Robust.Client/Console/ScriptClient.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
-using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
+using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
 
 namespace Robust.Client.Console

Robust.Client/Console/ScriptConsoleClient.cs

@@ -1,5 +1,8 @@
 #if CLIENT_SCRIPTING
+using System;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using System.Text;
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
@@ -10,10 +13,10 @@ using Microsoft.CodeAnalysis.Scripting;
 using Microsoft.CodeAnalysis.Text;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.ViewVariables;
-using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
 using Robust.Shared.Maths;
+using Robust.Shared.Reflection;
 using Robust.Shared.Scripting;
 using Robust.Shared.Utility;
 
@@ -36,6 +39,8 @@ namespace Robust.Client.Console
         private readonly ScriptGlobals _globals;
         private ScriptState? _state;
 
+        private (string[] imports, string code)? _autoImportRepeatBuffer;
+
         public ScriptConsoleClient()
         {
             Title = Loc.GetString("Robust C# Interactive (CLIENT)");
@@ -54,38 +59,56 @@ namespace Robust.Client.Console
             var code = InputBar.Text;
             InputBar.Clear();
 
-            // Remove > or . at the end of the output panel.
-            OutputPanel.RemoveEntry(^1);
-
-            _inputBuffer.AppendLine(code);
-            _linesEntered += 1;
-
-            var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(_inputBuffer.ToString()), ScriptInstanceShared.ParseOptions);
-
-            if (!SyntaxFactory.IsCompleteSubmission(tree))
+            if (_autoImportRepeatBuffer.HasValue && code == "y")
             {
-                if (_linesEntered == 1)
+                var (imports, repeatCode) = _autoImportRepeatBuffer.Value;
+                var sb = new StringBuilder();
+                foreach (var import in imports)
                 {
-                    OutputPanel.AddText($"> {code}");
+                    sb.AppendFormat("using {0};\n", import);
                 }
-                else
-                {
-                    OutputPanel.AddText($". {code}");
-                }
-                OutputPanel.AddText(".");
-                return;
+
+                sb.Append(repeatCode);
+
+                code = sb.ToString();
             }
-
-            code = _inputBuffer.ToString().Trim();
-
-            // Remove echo of partial submission from the output panel.
-            for (var i = 1; i < _linesEntered; i++)
+            else
             {
+                // Remove > or . at the end of the output panel.
                 OutputPanel.RemoveEntry(^1);
-            }
 
-            _inputBuffer.Clear();
-            _linesEntered = 0;
+                _inputBuffer.AppendLine(code);
+                _linesEntered += 1;
+
+                var tree = SyntaxFactory.ParseSyntaxTree(SourceText.From(_inputBuffer.ToString()),
+                    ScriptInstanceShared.ParseOptions);
+
+                if (!SyntaxFactory.IsCompleteSubmission(tree))
+                {
+                    if (_linesEntered == 1)
+                    {
+                        OutputPanel.AddText($"> {code}");
+                    }
+                    else
+                    {
+                        OutputPanel.AddText($". {code}");
+                    }
+
+                    OutputPanel.AddText(".");
+                    return;
+                }
+
+                code = _inputBuffer.ToString().Trim();
+
+                // Remove echo of partial submission from the output panel.
+                for (var i = 1; i < _linesEntered; i++)
+                {
+                    OutputPanel.RemoveEntry(^1);
+                }
+
+                _inputBuffer.Clear();
+                _linesEntered = 0;
+            }
 
             Script newScript;
 
@@ -135,6 +158,8 @@ namespace Robust.Client.Console
 
                 OutputPanel.AddMessage(msg);
                 OutputPanel.AddText(">");
+
+                PromptAutoImports(e.Diagnostics, code);
                 return;
             }
 
@@ -148,13 +173,23 @@ namespace Robust.Client.Console
             else if (ScriptInstanceShared.HasReturnValue(newScript))
             {
                 var msg = new FormattedMessage();
-                msg.AddText(CSharpObjectFormatter.Instance.FormatObject(_state.ReturnValue));
+                msg.AddText(ScriptInstanceShared.SafeFormat(_state.ReturnValue));
                 OutputPanel.AddMessage(msg);
             }
 
             OutputPanel.AddText(">");
         }
 
+        private void PromptAutoImports(IEnumerable<Diagnostic> diags, string code)
+        {
+            if (!ScriptInstanceShared.CalcAutoImports(_reflectionManager, diags, out var found))
+                return;
+
+            OutputPanel.AddText($"Auto-import {string.Join(", ", found)} (enter 'y')?");
+
+            _autoImportRepeatBuffer = (found.ToArray(), code);
+        }
+
         private sealed class ScriptGlobalsImpl : ScriptGlobals
         {
             private readonly ScriptConsoleClient _owner;
@@ -180,7 +215,7 @@ namespace Robust.Client.Console
 
             public override void show(object obj)
             {
-                write(CSharpObjectFormatter.Instance.FormatObject(obj));
+                write(ScriptInstanceShared.SafeFormat(obj));
             }
         }
     }

Robust.Client/Console/WatchWindow.cs

@@ -7,10 +7,10 @@ using Microsoft.CodeAnalysis.Scripting;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
-using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
 using Robust.Shared.Maths;
+using Robust.Shared.Reflection;
 using Robust.Shared.Scripting;
 using Robust.Shared.Timing;
 
@@ -20,8 +20,6 @@ namespace Robust.Client.Console
     {
         private readonly IReflectionManager _reflectionManager;
 
-        protected override Vector2? CustomSize => (300, 300);
-
         private readonly VBoxContainer _watchesVBox;
         private readonly LineEdit _addWatchEdit;
         private readonly Button _addWatchButton;
@@ -37,12 +35,12 @@ namespace Robust.Client.Console
 
             var mainVBox = new VBoxContainer
             {
-                CustomMinimumSize = (500, 300),
+                MinSize = (500, 300),
                 Children =
                 {
                     (_watchesVBox = new VBoxContainer
                     {
-                        SizeFlagsVertical = SizeFlags.FillExpand
+                        VerticalExpand = true
                     }),
                     new HBoxContainer
                     {
@@ -50,7 +48,7 @@ namespace Robust.Client.Console
                         {
                             (_addWatchEdit = new HistoryLineEdit
                             {
-                                SizeFlagsHorizontal = SizeFlags.FillExpand,
+                                HorizontalExpand = true,
                                 PlaceHolder = Loc.GetString("Add watch (C# interactive)")
                             }),
                             (_addWatchButton = new Button
@@ -66,6 +64,8 @@ namespace Robust.Client.Console
             _addWatchEdit.OnTextEntered += _ => AddWatch();
 
             Contents.AddChild(mainVBox);
+
+            SetSize = (300, 300);
         }
 
         private void AddWatch()
@@ -113,7 +113,7 @@ namespace Robust.Client.Console
                     {
                         (_outputLabel = new Label
                         {
-                            SizeFlagsHorizontal = SizeFlags.FillExpand,
+                            HorizontalExpand = true,
                             ClipText = true
                         }),
                         (delButton = new Button
@@ -176,7 +176,7 @@ namespace Robust.Client.Console
                         {
                             Text = message,
                             ClipText = true,
-                            SizeFlagsHorizontal = SizeFlags.FillExpand
+                            HorizontalExpand = true
                         },
                         (delButton = new Button {Text = Loc.GetString("Remove")})
                     }

Robust.Client/Credits/CreditsManager.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
 using System.IO;
-using Robust.Shared.Interfaces.Resources;
+using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
 using Robust.Shared.Utility;
 using YamlDotNet.RepresentationModel;

Robust.Client/Debugging/DebugDrawing.cs

@@ -1,21 +1,16 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.Drawing;
-using Robust.Client.Graphics.Overlays;
-using Robust.Client.Graphics.Shaders;
-using Robust.Client.Interfaces.Debugging;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.Graphics.Overlays;
-using Robust.Client.Interfaces.Input;
-using Robust.Client.Interfaces.ResourceManagement;
+using Robust.Client.Input;
 using Robust.Client.ResourceManagement;
-using Robust.Shared.GameObjects.Components;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Physics;
+using Robust.Shared.Enums;
+using Robust.Shared;
+using Robust.Shared.Configuration;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
+using Robust.Shared.Physics.Broadphase;
 using Robust.Shared.Prototypes;
 
 namespace Robust.Client.Debugging
@@ -47,14 +42,14 @@ namespace Robust.Client.Debugging
 
                 _debugColliders = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<PhysicsOverlay>())
                 {
                     _overlayManager.AddOverlay(new PhysicsOverlay(_componentManager, _eyeManager,
                         _prototypeManager, _inputManager, _physicsManager));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(PhysicsOverlay));
+                    _overlayManager.RemoveOverlay<PhysicsOverlay>();
                 }
             }
         }
@@ -72,13 +67,13 @@ namespace Robust.Client.Debugging
 
                 _debugPositions = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<EntityPositionOverlay>())
                 {
                     _overlayManager.AddOverlay(new EntityPositionOverlay(_entityManager, _eyeManager));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(EntityPositionOverlay));
+                    _overlayManager.RemoveOverlay<EntityPositionOverlay>();
                 }
             }
         }
@@ -97,8 +92,8 @@ namespace Robust.Client.Debugging
             private Vector2 _hoverStartScreen = Vector2.Zero;
             private List<IPhysBody> _hoverBodies = new();
 
+
             public PhysicsOverlay(IComponentManager compMan, IEyeManager eyeMan, IPrototypeManager protoMan, IInputManager inputManager, IPhysicsManager physicsManager)
-                : base(nameof(PhysicsOverlay))
             {
                 _componentManager = compMan;
                 _eyeManager = eyeMan;
@@ -145,7 +140,7 @@ namespace Robust.Client.Debugging
                     row++;
                     DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Mask: {Convert.ToString(body.CollisionMask, 2)}");
                     row++;
-                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {((IPhysicsComponent)body).Anchored}");
+                    DrawString(screenHandle, _font, drawPos + new Vector2(0, row * lineHeight), $"Enabled: {body.CanCollide}, Hard: {body.Hard}, Anchored: {(body).BodyType == BodyType.Static}");
                     row++;
                 }
 
@@ -166,20 +161,22 @@ namespace Robust.Client.Debugging
                 if (viewport.IsEmpty()) return;
 
                 var mapId = _eyeManager.CurrentMap;
+                var sleepThreshold = IoCManager.Resolve<IConfigurationManager>().GetCVar(CVars.TimeToSleep);
+                var colorEdge = Color.Red.WithAlpha(0.33f);
 
-                foreach (var physBody in _physicsManager.GetCollidingEntities(mapId, viewport))
+                foreach (var physBody in EntitySystem.Get<SharedBroadPhaseSystem>().GetCollidingEntities(mapId, viewport))
                 {
                     // all entities have a TransformComponent
                     var transform = physBody.Entity.Transform;
 
-                    var worldBox = physBody.WorldAABB;
+                    var worldBox = physBody.GetWorldAABB();
                     if (worldBox.IsEmpty()) continue;
 
-                    var colorEdge = Color.Red.WithAlpha(0.33f);
-
-                    foreach (var shape in physBody.PhysicsShapes)
+                    foreach (var fixture in physBody.Fixtures)
                     {
-                        shape.DebugDraw(drawing, transform.WorldMatrix, in viewport, physBody.SleepAccumulator / (float) physBody.SleepThreshold);
+                        var shape = fixture.Shape;
+                        var sleepPercent = physBody.Awake ? physBody.SleepTime / sleepThreshold : 1.0f;
+                        shape.DebugDraw(drawing, transform.WorldMatrix, in viewport,  sleepPercent);
                     }
 
                     if (worldBox.Contains(mouseWorldPos))
@@ -196,9 +193,9 @@ namespace Robust.Client.Debugging
             {
                 var baseLine = new Vector2(pos.X, font.GetAscent(1) + pos.Y);
 
-                foreach (var chr in str)
+                foreach (var rune in str.EnumerateRunes())
                 {
-                    var advance = font.DrawChar(handle, chr, baseLine, 1, Color.White);
+                    var advance = font.DrawChar(handle, rune, baseLine, 1, Color.White);
                     baseLine += new Vector2(advance, 0);
                 }
             }
@@ -242,6 +239,16 @@ namespace Robust.Client.Debugging
                     _handle.DrawCircle(origin, radius, color);
                 }
 
+                public override void DrawPolygonShape(Vector2[] vertices, in Color color)
+                {
+                    _handle.DrawPrimitives(DrawPrimitiveTopology.TriangleFan, vertices, color);
+                }
+
+                public override void DrawLine(Vector2 start, Vector2 end, in Color color)
+                {
+                    _handle.DrawLine(start, end, color);
+                }
+
                 public override void SetTransform(in Matrix3 transform)
                 {
                     _handle.SetTransform(transform);
@@ -258,7 +265,7 @@ namespace Robust.Client.Debugging
 
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public EntityPositionOverlay(IEntityManager entityManager, IEyeManager eyeManager) : base(nameof(EntityPositionOverlay))
+            public EntityPositionOverlay(IEntityManager entityManager, IEyeManager eyeManager)
             {
                 _entityManager = entityManager;
                 _eyeManager = eyeManager;

Robust.Client/Debugging/DebugDrawingManager.cs

@@ -1,15 +1,12 @@
-using Robust.Client.Interfaces.Debugging;
-using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
 using Robust.Shared.Network.Messages;
 using System;
 using System.Collections.Generic;
-using Robust.Client.Graphics.Overlays;
-using Robust.Client.Graphics.Drawing;
+using Robust.Client.Graphics;
 using Robust.Shared.Maths;
-using Robust.Client.Interfaces.Graphics.Overlays;
 using Robust.Shared.Timing;
-using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.Enums;
+using Robust.Shared.Network;
 
 namespace Robust.Client.Debugging
 {
@@ -42,13 +39,13 @@ namespace Robust.Client.Debugging
 
                 _debugDrawRays = value;
 
-                if (value)
+                if (value && !_overlayManager.HasOverlay<DebugDrawRayOverlay>())
                 {
                     _overlayManager.AddOverlay(new DebugDrawRayOverlay(this));
                 }
                 else
                 {
-                    _overlayManager.RemoveOverlay(nameof(DebugDrawRayOverlay));
+                    _overlayManager.RemoveOverlay<DebugDrawRayOverlay>();
                 }
             }
         }
@@ -85,7 +82,7 @@ namespace Robust.Client.Debugging
             private readonly DebugDrawingManager _owner;
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public DebugDrawRayOverlay(DebugDrawingManager owner) : base(nameof(DebugDrawRayOverlay))
+            public DebugDrawRayOverlay(DebugDrawingManager owner)
             {
                 _owner = owner;
             }

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -0,0 +1,164 @@
+/*
+* Farseer Physics Engine:
+* Copyright (c) 2012 Ian Qvist
+*
+* Original source Box2D:
+* Copyright (c) 2006-2011 Erin Catto http://www.box2d.org
+*
+* This software is provided 'as-is', without any express or implied
+* warranty.  In no event will the authors be held liable for any damages
+* arising from the use of this software.
+* Permission is granted to anyone to use this software for any purpose,
+* including commercial applications, and to alter it and redistribute it
+* freely, subject to the following restrictions:
+* 1. The origin of this software must not be misrepresented; you must not
+* claim that you wrote the original software. If you use this software
+* in a product, an acknowledgment in the product documentation would be
+* appreciated but is not required.
+* 2. Altered source versions must be plainly marked as such, and must not be
+* misrepresented as being the original software.
+* 3. This notice may not be removed or altered from any source distribution.
+*/
+
+/* Heavily inspired by Farseer */
+
+using System;
+using Robust.Client.Graphics;
+using Robust.Shared.Enums;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Physics.Collision;
+using Robust.Shared.Physics.Dynamics;
+using Robust.Shared.Physics.Dynamics.Contacts;
+
+namespace Robust.Client.Debugging
+{
+    internal sealed class DebugPhysicsSystem : SharedDebugPhysicsSystem
+    {
+        /*
+         * Used for debugging shapes, controllers, joints, contacts
+         */
+
+        private const int MaxContactPoints = 2048;
+        internal int PointCount;
+
+        internal ContactPoint[] _points = new ContactPoint[MaxContactPoints];
+
+        public PhysicsDebugFlags Flags
+        {
+            get => _flags;
+            set
+            {
+                if (value == _flags) return;
+
+                if (_flags == PhysicsDebugFlags.None)
+                    IoCManager.Resolve<IOverlayManager>().AddOverlay(new PhysicsDebugOverlay(this));
+
+                if (value == PhysicsDebugFlags.None)
+                    IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsDebugOverlay));
+
+                _flags = value;
+            }
+        }
+
+        private PhysicsDebugFlags _flags;
+
+        public override void HandlePreSolve(Contact contact, in Manifold oldManifold)
+        {
+            if ((Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            {
+                Manifold manifold = contact.Manifold;
+
+                if (manifold.PointCount == 0)
+                    return;
+
+                Fixture fixtureA = contact.FixtureA!;
+
+                PointState[] state1, state2;
+                CollisionManager.GetPointStates(out state1, out state2, oldManifold, manifold);
+
+                Span<Vector2> points = stackalloc Vector2[2];
+                Vector2 normal;
+                contact.GetWorldManifold(out normal, points);
+
+                for (int i = 0; i < manifold.PointCount && PointCount < MaxContactPoints; ++i)
+                {
+                    if (fixtureA == null)
+                        _points[i] = new ContactPoint();
+
+                    ContactPoint cp = _points[PointCount];
+                    cp.Position = points[i];
+                    cp.Normal = normal;
+                    cp.State = state2[i];
+                    _points[PointCount] = cp;
+                    ++PointCount;
+                }
+            }
+        }
+
+        internal struct ContactPoint
+        {
+            public Vector2 Normal;
+            public Vector2 Position;
+            public PointState State;
+        }
+    }
+
+    [Flags]
+    internal enum PhysicsDebugFlags : byte
+    {
+        None = 0,
+        ContactPoints = 1 << 0,
+        ContactNormals = 1 << 1,
+        Shapes = 1 << 2,
+    }
+
+    internal sealed class PhysicsDebugOverlay : Overlay
+    {
+        private DebugPhysicsSystem _physics = default!;
+
+        public override OverlaySpace Space => OverlaySpace.WorldSpace;
+
+        public PhysicsDebugOverlay(DebugPhysicsSystem system)
+        {
+            _physics = system;
+        }
+
+        protected override void Draw(DrawingHandleBase handle, OverlaySpace currentSpace)
+        {
+            if (_physics.Flags == PhysicsDebugFlags.None) return;
+
+            var worldHandle = (DrawingHandleWorld) handle;
+
+            if ((_physics.Flags & PhysicsDebugFlags.Shapes) != 0)
+            {
+                // Port DebugDrawing over.
+            }
+
+            if ((_physics.Flags & PhysicsDebugFlags.ContactPoints) != 0)
+            {
+                const float axisScale = 0.3f;
+
+                for (int i = 0; i < _physics.PointCount; ++i)
+                {
+                    DebugPhysicsSystem.ContactPoint point = _physics._points[i];
+
+                    if (point.State == PointState.Add)
+                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 243, 77));
+                    else if (point.State == PointState.Persist)
+                        worldHandle.DrawCircle(point.Position, 0.5f, new Color(255, 77, 77, 77));
+
+                    if ((_physics.Flags & PhysicsDebugFlags.ContactNormals) != 0)
+                    {
+                        Vector2 p1 = point.Position;
+                        Vector2 p2 = p1 + point.Normal * axisScale;
+                        worldHandle.DrawLine(p1, p2, new Color(255, 102, 230, 102));
+                    }
+                }
+
+                _physics.PointCount = 0;
+            }
+        }
+    }
+}

Robust.Client/Debugging/IDebugDrawing.cs

@@ -1,4 +1,4 @@
-namespace Robust.Client.Interfaces.Debugging
+namespace Robust.Client.Debugging
 {
     /// <summary>
     /// A collection of visual debug overlays for the client game.

Robust.Client/Debugging/IDebugDrawingManager.cs

@@ -1,11 +1,6 @@
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Robust.Shared.Timing;
 
-namespace Robust.Client.Interfaces.Debugging
+namespace Robust.Client.Debugging
 {
     public interface IDebugDrawingManager
     {

Robust.Client/GameController.cs

@@ -1,20 +1,19 @@
 using System;
 using System.IO;
+using System.Management;
 using System.Net;
 using System.Threading.Tasks;
+using Robust.Client.Audio.Midi;
 using Robust.Client.Console;
-using Robust.Client.Interfaces;
-using Robust.Client.Interfaces.GameObjects;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Graphics;
-using Robust.Client.Interfaces.Graphics.Overlays;
-using Robust.Client.Interfaces.Input;
-using Robust.Client.Interfaces.Placement;
-using Robust.Client.Interfaces.ResourceManagement;
-using Robust.Client.Interfaces.State;
-using Robust.Client.Interfaces.UserInterface;
-using Robust.Client.Interfaces.Utility;
+using Robust.Client.GameObjects;
+using Robust.Client.GameStates;
+using Robust.Client.Graphics;
+using Robust.Client.Input;
+using Robust.Client.Placement;
 using Robust.Client.Player;
+using Robust.Client.ResourceManagement;
+using Robust.Client.State;
+using Robust.Client.UserInterface;
 using Robust.Client.Utility;
 using Robust.Client.ViewVariables;
 using Robust.LoaderApi;
@@ -22,18 +21,14 @@ using Robust.Shared;
 using Robust.Shared.Asynchronous;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
-using Robust.Shared.Interfaces.Configuration;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Log;
-using Robust.Shared.Interfaces.Map;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Serialization;
-using Robust.Shared.Interfaces.Timers;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -51,7 +46,7 @@ namespace Robust.Client
         [Dependency] private readonly IUserInterfaceManagerInternal _userInterfaceManager = default!;
         [Dependency] private readonly IBaseClient _client = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
-        [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
+        [Dependency] private readonly IClientConsoleHost _console = default!;
         [Dependency] private readonly ITimerManager _timerManager = default!;
         [Dependency] private readonly IClientEntityManager _entityManager = default!;
         [Dependency] private readonly IPlacementManager _placementManager = default!;
@@ -69,6 +64,7 @@ namespace Robust.Client
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IRobustMappedStringSerializer _stringSerializer = default!;
         [Dependency] private readonly IAuthManager _authManager = default!;
+        [Dependency] private readonly IMidiManager _midiManager = default!;
 
         private CommandLineArgs? _commandLineArgs;
         private bool _disableAssemblyLoadContext;
@@ -85,6 +81,74 @@ namespace Robust.Client
         }
 
         public bool Startup(Func<ILogHandler>? logHandlerFactory = null)
+        {
+            if (!StartupSystemSplash(logHandlerFactory))
+                return false;
+
+            // Disable load context usage on content start.
+            // This prevents Content.Client being loaded twice and things like csi blowing up because of it.
+            _modLoader.SetUseLoadContext(!_disableAssemblyLoadContext);
+            _modLoader.SetEnableSandboxing(true);
+
+            if (!_modLoader.TryLoadModulesFrom(new ResourcePath("/Assemblies/"), "Content."))
+            {
+                Logger.Fatal("Errors while loading content assemblies.");
+                return false;
+            }
+
+            foreach (var loadedModule in _modLoader.LoadedModules)
+            {
+                _configurationManager.LoadCVarsFromAssembly(loadedModule);
+            }
+
+            IoCManager.Resolve<ISerializationManager>().Initialize();
+
+            // Call Init in game assemblies.
+            _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
+            _modLoader.BroadcastRunLevel(ModRunLevel.Init);
+
+            _resourceCache.PreloadTextures();
+            _userInterfaceManager.Initialize();
+            _networkManager.Initialize(false);
+            IoCManager.Resolve<INetConfigurationManager>().SetupNetworking();
+            _serializer.Initialize();
+            _inputManager.Initialize();
+            _console.Initialize();
+            _prototypeManager.Initialize();
+            _prototypeManager.LoadDirectory(new ResourcePath(@"/Prototypes/"));
+            _prototypeManager.Resync();
+            _mapManager.Initialize();
+            _entityManager.Initialize();
+            _gameStateManager.Initialize();
+            _placementManager.Initialize();
+            _viewVariablesManager.Initialize();
+            _scriptClient.Initialize();
+
+            _client.Initialize();
+            _discord.Initialize();
+            _modLoader.BroadcastRunLevel(ModRunLevel.PostInit);
+
+            if (_commandLineArgs?.Username != null)
+            {
+                _client.PlayerNameOverride = _commandLineArgs.Username;
+            }
+
+            _authManager.LoadFromEnv();
+
+            GC.Collect();
+
+            _clyde.Ready();
+
+            if ((_commandLineArgs?.Connect == true || _commandLineArgs?.Launcher == true)
+                && LaunchState.ConnectEndpoint != null)
+            {
+                _client.ConnectToServer(LaunchState.ConnectEndpoint);
+            }
+
+            return true;
+        }
+
+        private bool StartupSystemSplash(Func<ILogHandler>? logHandlerFactory)
         {
             ReadInitialLaunchState();
 
@@ -124,6 +188,8 @@ namespace Robust.Client
                 _configurationManager.OverrideConVars(_commandLineArgs.CVars);
             }
 
+            ProfileOptSetup.Setup(_configurationManager);
+
             _resourceCache.Initialize(LoadConfigAndUserData ? userDataDir : null);
 
             ProgramShared.DoMounts(_resourceCache, _commandLineArgs?.MountOptions, "Content.Client", _loaderArgs != null);
@@ -134,6 +200,13 @@ namespace Robust.Client
                 _modLoader.VerifierExtraLoadHandler = VerifierExtraLoadHandler;
             }
 
+            _clyde.TextEntered += TextEntered;
+            _clyde.MouseMove += MouseMove;
+            _clyde.KeyUp += KeyUp;
+            _clyde.KeyDown += KeyDown;
+            _clyde.MouseWheel += MouseWheel;
+            _clyde.CloseWindow += Shutdown;
+
             // Bring display up as soon as resources are mounted.
             if (!_clyde.Initialize())
             {
@@ -142,62 +215,7 @@ namespace Robust.Client
 
             _clyde.SetWindowTitle("Space Station 14");
 
-            _fontManager.Initialize();
-
-            // Disable load context usage on content start.
-            // This prevents Content.Client being loaded twice and things like csi blowing up because of it.
-            _modLoader.SetUseLoadContext(!_disableAssemblyLoadContext);
-            _modLoader.SetEnableSandboxing(true);
-
-            if (!_modLoader.TryLoadModulesFrom(new ResourcePath("/Assemblies/"), "Content."))
-            {
-                Logger.Fatal("Errors while loading content assemblies.");
-                return false;
-            }
-
-            foreach (var loadedModule in _modLoader.LoadedModules)
-            {
-                _configurationManager.LoadCVarsFromAssembly(loadedModule);
-            }
-
-            // Call Init in game assemblies.
-            _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
-            _modLoader.BroadcastRunLevel(ModRunLevel.Init);
-
-            _userInterfaceManager.Initialize();
-            _networkManager.Initialize(false);
-            IoCManager.Resolve<INetConfigurationManager>().SetupNetworking();
-            _serializer.Initialize();
-            _inputManager.Initialize();
-            _consoleHost.Initialize();
-            _prototypeManager.LoadDirectory(new ResourcePath(@"/Prototypes/"));
-            _prototypeManager.Resync();
-            _mapManager.Initialize();
-            _entityManager.Initialize();
-            _gameStateManager.Initialize();
-            _placementManager.Initialize();
-            _viewVariablesManager.Initialize();
-            _scriptClient.Initialize();
-
-            _client.Initialize();
-            _discord.Initialize();
-            _modLoader.BroadcastRunLevel(ModRunLevel.PostInit);
-
-            if (_commandLineArgs?.Username != null)
-            {
-                _client.PlayerNameOverride = _commandLineArgs.Username;
-            }
-
-            _authManager.LoadFromEnv();
-
-            _clyde.Ready();
-
-            if ((_commandLineArgs?.Connect == true || _commandLineArgs?.Launcher == true)
-                && LaunchState.ConnectEndpoint != null)
-            {
-                _client.ConnectToServer(LaunchState.ConnectEndpoint);
-            }
-
+            _fontManager.SetFontDpi((uint) _configurationManager.GetCVar(CVars.DisplayFontDpi));
             return true;
         }
 
@@ -274,17 +292,13 @@ namespace Robust.Client
             _modLoader.BroadcastUpdate(ModUpdateLevel.PreEngine, frameEventArgs);
             _timerManager.UpdateTimers(frameEventArgs);
             _taskManager.ProcessPendingTasks();
-            _userInterfaceManager.Update(frameEventArgs);
 
+            // GameStateManager is in full control of the simulation update.
             if (_client.RunLevel >= ClientRunLevel.Connected)
             {
-                _componentManager.CullRemovedComponents();
                 _gameStateManager.ApplyGameState();
-                _entityManager.Update(frameEventArgs.DeltaSeconds);
-                _playerManager.Update(frameEventArgs.DeltaSeconds);
             }
 
-            _stateManager.Update(frameEventArgs);
             _modLoader.BroadcastUpdate(ModUpdateLevel.PostEngine, frameEventArgs);
         }
 
@@ -325,6 +339,7 @@ namespace Robust.Client
             logManager.GetSawmill("discord").Level = LogLevel.Warning;
             logManager.GetSawmill("net.predict").Level = LogLevel.Info;
             logManager.GetSawmill("szr").Level = LogLevel.Info;
+            logManager.GetSawmill("loc").Level = LogLevel.Error;
 
 #if DEBUG_ONLY_FCE_INFO
 #if DEBUG_ONLY_FCE_LOG
@@ -383,6 +398,8 @@ namespace Robust.Client
 
         private void Cleanup()
         {
+            _networkManager.Shutdown("Client shutting down");
+            _midiManager.Shutdown();
             _entityManager.Shutdown();
             _clyde.Shutdown();
         }

Robust.Client/GameController/GameController.Input.cs

@@ -1,4 +1,4 @@
-using Robust.Client.Input;
+using Robust.Client.Input;
 
 namespace Robust.Client
 {

Robust.Client/GameController/GameController.IoC.cs

@@ -1,67 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using Robust.Client.Graphics.Clyde;
-using Robust.Client.Console;
-using Robust.Client.Debugging;
-using Robust.Client.GameObjects;
-using Robust.Client.GameStates;
-using Robust.Client.Graphics;
-using Robust.Client.Graphics.ClientEye;
-using Robust.Client.Graphics.Lighting;
-using Robust.Client.Graphics.Overlays;
-using Robust.Client.Input;
-using Robust.Client.Interfaces;
-using Robust.Client.Interfaces.Debugging;
-using Robust.Client.Interfaces.GameObjects;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Graphics;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.Graphics.Lighting;
-using Robust.Client.Interfaces.Graphics.Overlays;
-using Robust.Client.Interfaces.Input;
-using Robust.Client.Interfaces.Map;
-using Robust.Client.Interfaces.Placement;
-using Robust.Client.Interfaces.ResourceManagement;
-using Robust.Client.Interfaces.State;
-using Robust.Client.Interfaces.UserInterface;
-using Robust.Client.Interfaces.Utility;
-using Robust.Client.Map;
-using Robust.Client.Placement;
-using Robust.Client.Player;
-using Robust.Client.Reflection;
-using Robust.Client.ResourceManagement;
-using Robust.Client.State;
-using Robust.Client.UserInterface;
-using Robust.Client.Utility;
-using Robust.Client.ViewVariables;
-using Robust.Shared;
-using Robust.Shared.Asynchronous;
-using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
-using Robust.Shared.Exceptions;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.Configuration;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Log;
-using Robust.Shared.Interfaces.Map;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Physics;
-using Robust.Shared.Interfaces.Reflection;
-using Robust.Shared.Interfaces.Resources;
-using Robust.Shared.Interfaces.Serialization;
-using Robust.Shared.Interfaces.Timers;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Log;
-using Robust.Shared.Map;
-using Robust.Shared.Network;
-using Robust.Shared.Physics;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Serialization;
-using Robust.Shared.Timers;
-using Robust.Shared.Timing;
+using Robust.Shared.Reflection;
 
 namespace Robust.Client
 {
@@ -75,7 +17,6 @@ namespace Robust.Client
             RegisterReflection();
         }
 
-
         internal static void RegisterReflection()
         {
             // Gets a handle to the shared and the current (client) dll.

Robust.Client/GameController/GameController.Loader.cs

@@ -1,4 +1,4 @@
-using Robust.Client;
+using Robust.Client;
 using Robust.LoaderApi;
 
 [assembly: LoaderEntryPoint(typeof(GameController.LoaderEntryPoint))]
@@ -11,7 +11,7 @@ namespace Robust.Client
         {
             public void Main(IMainArgs args)
             {
-                GameController.Start(args.Args, contentStart: false, args);
+                Start(args.Args, contentStart: false, args);
             }
         }
     }

Robust.Client/GameController/GameController.Standalone.cs

@@ -1,7 +1,5 @@
-using System;
-using Robust.Client.Interfaces;
+using System;
 using Robust.LoaderApi;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Timing;

Robust.Client/GameObjects/!NO_FOLDER_NAMESPACES

@@ -0,0 +1,3 @@
+Everything in this folder and subfolders needs to be in:
+
+Robust.Client.GameObjects

Robust.Client/GameObjects/ClientComponentFactory.cs

@@ -1,18 +1,5 @@
-using Robust.Client.GameObjects.Components;
-using Robust.Client.GameObjects.Components.Animations;
-using Robust.Client.GameObjects.Components.Containers;
-using Robust.Client.GameObjects.Components.UserInterface;
-using Robust.Client.Interfaces.GameObjects.Components;
+using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components;
-using Robust.Shared.GameObjects.Components.Appearance;
-using Robust.Shared.GameObjects.Components.Eye;
-using Robust.Shared.GameObjects.Components.Map;
-using Robust.Shared.GameObjects.Components.Renderable;
-using Robust.Shared.GameObjects.Components.Timers;
-using Robust.Shared.GameObjects.Components.Transform;
-using Robust.Shared.GameObjects.Components.UserInterface;
-using Robust.Shared.Interfaces.GameObjects.Components;
 using Robust.Shared.Physics;
 
 namespace Robust.Client.GameObjects
@@ -37,9 +24,13 @@ namespace Robust.Client.GameObjects
 
             Register<PhysicsComponent>();
             RegisterReference<PhysicsComponent, IPhysBody>();
-            RegisterReference<PhysicsComponent, IPhysicsComponent>();
+
+            Register<CollisionWakeComponent>();
+
+            Register<ContainerManagerComponent>();
+            RegisterReference<ContainerManagerComponent, IContainerManager>();
+
             RegisterIgnore("KeyBindingInput");
-            Register<PointLightComponent>();
 
             Register<InputComponent>();
 
@@ -64,14 +55,10 @@ namespace Robust.Client.GameObjects
 
             Register<AnimationPlayerComponent>();
 
-            Register<ContainerManagerComponent>();
-            RegisterReference<ContainerManagerComponent, IContainerManager>();
-
             Register<TimerComponent>();
 
 #if DEBUG
             Register<DebugExceptionOnAddComponent>();
-            Register<DebugExceptionExposeDataComponent>();
             Register<DebugExceptionInitializeComponent>();
             Register<DebugExceptionStartupComponent>();
 #endif

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -1,11 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
-using Robust.Client.Interfaces.GameObjects;
 using Robust.Shared.Exceptions;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Map;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
@@ -215,12 +212,6 @@ namespace Robust.Client.GameObjects
             return entity;
         }
 
-        /// <inheritdoc />
-        public override IEntity SpawnEntityNoMapInit(string? protoName, EntityCoordinates coordinates)
-        {
-            return SpawnEntity(protoName, coordinates);
-        }
-
         protected override EntityUid GenerateEntityUid()
         {
             return new(_nextClientEntityUid++);

Robust.Client/GameObjects/ClientEntityNetworkManager.cs

@@ -1,13 +1,11 @@
 using System;
 using System.Collections.Generic;
-using Robust.Client.Interfaces.GameStates;
+using Robust.Client.GameStates;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
-using Robust.Shared.Log;
+using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
@@ -36,7 +34,7 @@ namespace Robust.Client.GameObjects
             _networkManager.RegisterNetMessage<MsgEntity>(MsgEntity.NAME, HandleEntityNetworkMessage);
         }
 
-        public void Update()
+        public void TickUpdate()
         {
             while (_queue.Count != 0 && _queue.Peek().msg.SourceTick <= _gameStateManager.CurServerTick)
             {
@@ -47,12 +45,12 @@ namespace Robust.Client.GameObjects
         }
 
         /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntitySystemMessage message)
+        public void SendSystemNetworkMessage(EntityEventArgs message)
         {
             SendSystemNetworkMessage(message, default(uint));
         }
 
-        public void SendSystemNetworkMessage(EntitySystemMessage message, uint sequence)
+        public void SendSystemNetworkMessage(EntityEventArgs message, uint sequence)
         {
             var msg = _networkManager.CreateNetMessage<MsgEntity>();
             msg.Type = EntityMessageType.SystemMessage;
@@ -64,7 +62,7 @@ namespace Robust.Client.GameObjects
         }
 
         /// <inheritdoc />
-        public void SendSystemNetworkMessage(EntitySystemMessage message, INetChannel channel)
+        public void SendSystemNetworkMessage(EntityEventArgs message, INetChannel channel)
         {
             throw new NotSupportedException();
         }

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

@@ -5,7 +5,7 @@ using Robust.Client.Animations;
 using Robust.Shared.GameObjects;
 using static Robust.Client.Animations.AnimationPlaybackShared;
 
-namespace Robust.Client.GameObjects.Components.Animations
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     ///     Plays back <see cref="Animation"/>s on entities.

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

@@ -1,15 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using Robust.Client.GameObjects.EntitySystems;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.Appearance;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.IoC;
-using Robust.Shared.Serialization;
-using Robust.Shared.Utility;
+using Robust.Shared.Reflection;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 using YamlDotNet.RepresentationModel;
 
@@ -19,13 +14,11 @@ namespace Robust.Client.GameObjects
     {
         [ViewVariables]
         private Dictionary<object, object> data = new();
+
         [ViewVariables]
+        [DataField("visuals")]
         internal List<AppearanceVisualizer> Visualizers = new();
 
-        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
-
-        private static bool _didRegisterSerializer;
-
         [ViewVariables]
         private bool _appearanceDirty;
 
@@ -78,6 +71,8 @@ namespace Robust.Client.GameObjects
 
         private void SetData(object key, object value)
         {
+            if (data.TryGetValue(key, out var existing) && existing.Equals(value)) return;
+
             data[key] = value;
 
             MarkDirty();
@@ -85,10 +80,9 @@ namespace Robust.Client.GameObjects
 
         public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
         {
-            if (curState == null)
+            if (curState is not AppearanceComponentState actualState)
                 return;
 
-            var actualState = (AppearanceComponentState) curState;
             data = actualState.Data;
             MarkDirty();
         }
@@ -110,18 +104,6 @@ namespace Robust.Client.GameObjects
             _appearanceDirty = false;
         }
 
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            if (!_didRegisterSerializer)
-            {
-                YamlObjectSerializer.RegisterTypeSerializer(typeof(AppearanceVisualizer),
-                    new VisualizerTypeSerializer(_reflectionManager));
-                _didRegisterSerializer = true;
-            }
-
-            serializer.DataField(ref Visualizers, "visuals", new List<AppearanceVisualizer>());
-        }
-
         public override void Initialize()
         {
             base.Initialize();
@@ -134,78 +116,6 @@ namespace Robust.Client.GameObjects
             MarkDirty();
         }
 
-        class VisualizerTypeSerializer : YamlObjectSerializer.TypeSerializer
-        {
-            private readonly IReflectionManager _reflectionManager;
-
-            public VisualizerTypeSerializer(IReflectionManager reflectionManager)
-            {
-                _reflectionManager = reflectionManager;
-            }
-
-            public override object NodeToType(Type type, YamlNode node, YamlObjectSerializer serializer)
-            {
-                var mapping = (YamlMappingNode) node;
-                var nodeType = mapping.GetNode("type");
-                switch (nodeType.AsString())
-                {
-                    case SpriteLayerToggle.NAME:
-                        var keyString = mapping.GetNode("key").AsString();
-                        object key;
-                        if (_reflectionManager.TryParseEnumReference(keyString, out var @enum))
-                        {
-                            key = @enum;
-                        }
-                        else
-                        {
-                            key = keyString;
-                        }
-
-                        var layer = mapping.GetNode("layer").AsInt();
-                        return new SpriteLayerToggle(key, layer);
-
-                    default:
-                        var visType = _reflectionManager.LooseGetType(nodeType.AsString());
-                        if (!typeof(AppearanceVisualizer).IsAssignableFrom(visType))
-                        {
-                            throw new InvalidOperationException();
-                        }
-
-                        var vis = (AppearanceVisualizer) Activator.CreateInstance(visType)!;
-                        vis.LoadData(mapping);
-                        return vis;
-                }
-            }
-
-            public override YamlNode TypeToNode(object obj, YamlObjectSerializer serializer)
-            {
-                switch (obj)
-                {
-                    case SpriteLayerToggle spriteLayerToggle:
-                        YamlScalarNode key;
-                        if (spriteLayerToggle.Key is Enum)
-                        {
-                            var name = spriteLayerToggle.Key.GetType().FullName;
-                            key = new YamlScalarNode($"{name}.{spriteLayerToggle.Key}");
-                        }
-                        else
-                        {
-                            key = new YamlScalarNode(spriteLayerToggle.Key.ToString());
-                        }
-
-                        return new YamlMappingNode
-                        {
-                            {new YamlScalarNode("type"), new YamlScalarNode(SpriteLayerToggle.NAME)},
-                            {new YamlScalarNode("key"), key},
-                            {new YamlScalarNode("layer"), new YamlScalarNode(spriteLayerToggle.SpriteLayer.ToString())},
-                        };
-                    default:
-                        // TODO: A proper way to do serialization here.
-                        // I can't use the ExposeData system here since that's specific to entity serializers.
-                        return new YamlMappingNode();
-                }
-            }
-        }
 
         internal class SpriteLayerToggle : AppearanceVisualizer
         {
@@ -226,15 +136,9 @@ namespace Robust.Client.GameObjects
     ///     Handles the visualization of data inside of an appearance component.
     ///     Implementations of this class are NOT bound to a specific entity, they are flyweighted across multiple.
     /// </summary>
+    [ImplicitDataDefinitionForInheritors]
     public abstract class AppearanceVisualizer
     {
-        /// <summary>
-        ///     Load data from the prototype declaring this visualizer, to configure settings and such.
-        /// </summary>
-        public virtual void LoadData(YamlMappingNode node)
-        {
-        }
-
         /// <summary>
         ///     Initializes an entity to be managed by this appearance controller.
         ///     DO NOT assume this is your only entity. Visualizers are shared.

Robust.Client/GameObjects/Components/Containers/ContainerManagerComponent.ClientContainer.cs

@@ -1,89 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using Robust.Client.GameObjects.EntitySystems;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.GameObjects.Components;
-using Robust.Shared.ViewVariables;
-
-namespace Robust.Client.GameObjects.Components.Containers
-{
-    public sealed partial class ContainerManagerComponent
-    {
-        [DebuggerDisplay("ClientContainer {Owner.Uid}/{ID}")]
-        private sealed class ClientContainer : IContainer
-        {
-            public List<IEntity> Entities { get; } = new List<IEntity>();
-
-            public ClientContainer(string id, ContainerManagerComponent manager)
-            {
-                ID = id;
-                Manager = manager;
-            }
-
-            [ViewVariables] public IContainerManager Manager { get; }
-            [ViewVariables] public string ID { get; }
-            [ViewVariables] public IEntity Owner => Manager.Owner;
-            [ViewVariables] public bool Deleted { get; private set; }
-            [ViewVariables] public IReadOnlyList<IEntity> ContainedEntities => Entities;
-            [ViewVariables]
-            public bool ShowContents { get; set; }
-            [ViewVariables]
-            public bool OccludesLight { get; set; }
-
-            public bool CanInsert(IEntity toinsert)
-            {
-                return false;
-            }
-
-            public bool Insert(IEntity toinsert)
-            {
-                return false;
-            }
-
-            public bool CanRemove(IEntity toremove)
-            {
-                return false;
-            }
-
-            public bool Remove(IEntity toremove)
-            {
-                return false;
-            }
-
-            public void ForceRemove(IEntity toRemove)
-            {
-                throw new NotSupportedException("Cannot directly modify containers on the client");
-            }
-
-            public bool Contains(IEntity contained)
-            {
-                return Entities.Contains(contained);
-            }
-
-            public void DoInsert(IEntity entity)
-            {
-                Entities.Add(entity);
-
-                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(entity));
-            }
-
-            public void DoRemove(IEntity entity)
-            {
-                Entities.Remove(entity);
-
-                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new UpdateContainerOcclusionMessage(entity));
-            }
-
-            public void Shutdown()
-            {
-                Deleted = true;
-            }
-        }
-
-        public override void InternalContainerShutdown(IContainer container)
-        {
-        }
-    }
-}

Robust.Client/GameObjects/Components/Containers/ContainerManagerComponent.cs

@@ -1,172 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using Robust.Client.GameObjects.EntitySystems;
-using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.Containers;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.GameObjects.Components;
-using Robust.Shared.ViewVariables;
-
-namespace Robust.Client.GameObjects.Components.Containers
-{
-    public sealed partial class ContainerManagerComponent : SharedContainerManagerComponent
-    {
-        [ViewVariables]
-        private readonly Dictionary<string, ClientContainer> _containers = new();
-
-        public override T MakeContainer<T>(string id)
-        {
-            throw new NotSupportedException("Cannot modify containers on the client.");
-        }
-
-        public override bool Remove(IEntity entity)
-        {
-            // TODO: This will probably need relaxing if we want to predict things like inventories.
-            throw new NotSupportedException("Cannot modify containers on the client.");
-        }
-
-        protected override IEnumerable<IContainer> GetAllContainersImpl()
-        {
-            return _containers.Values.Where(c => !c.Deleted);
-        }
-
-        public override IContainer GetContainer(string id)
-        {
-            return _containers[id];
-        }
-
-        public override bool HasContainer(string id)
-        {
-            return _containers.ContainsKey(id);
-        }
-
-        public override bool TryGetContainer(string id, [NotNullWhen(true)] out IContainer? container)
-        {
-            var ret = _containers.TryGetValue(id, out var cont);
-            container = cont!;
-            return ret;
-        }
-
-        /// <inheritdoc />
-        public override bool TryGetContainer(IEntity entity, [NotNullWhen(true)] out IContainer? container)
-        {
-            foreach (var contain in _containers.Values)
-            {
-                if (!contain.Deleted && contain.Contains(entity))
-                {
-                    container = contain;
-                    return true;
-                }
-            }
-
-            container = default;
-            return false;
-        }
-
-        public override bool ContainsEntity(IEntity entity)
-        {
-            foreach (var container in _containers.Values)
-            {
-                if (!container.Deleted && container.Contains(entity))
-                {
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        public override void ForceRemove(IEntity entity)
-        {
-            throw new NotSupportedException("Cannot modify containers on the client.");
-        }
-
-        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
-        {
-            if(!(curState is ContainerManagerComponentState cast))
-                return;
-
-            // Delete now-gone containers.
-            List<string>? toDelete = null;
-            foreach (var (id, container) in _containers)
-            {
-                if (!cast.Containers.ContainsKey(id))
-                {
-                    container.Shutdown();
-                    toDelete ??= new List<string>();
-                    toDelete.Add(id);
-                }
-            }
-
-            if (toDelete != null)
-            {
-                foreach (var dead in toDelete)
-                {
-                    _containers.Remove(dead);
-                }
-            }
-
-            // Add new containers and update existing contents.
-            foreach (var (id, data) in cast.Containers)
-            {
-
-                if (!_containers.TryGetValue(id, out var container))
-                {
-                    container = new ClientContainer(id, this);
-                    _containers.Add(id, container);
-                }
-
-                // sync show flag
-                container.ShowContents = data.ShowContents;
-                container.OccludesLight = data.OccludesLight;
-
-                // Remove gone entities.
-                List<IEntity>? toRemove = null;
-                foreach (var entity in container.Entities)
-                {
-                    if (!data.ContainedEntities.Contains(entity.Uid))
-                    {
-                        toRemove ??= new List<IEntity>();
-                        toRemove.Add(entity);
-                    }
-                }
-
-                if (toRemove != null)
-                {
-                    foreach (var goner in toRemove)
-                    {
-                        container.DoRemove(goner);
-                    }
-                }
-
-                // Add new entities.
-                foreach (var uid in data.ContainedEntities)
-                {
-                    var entity = Owner.EntityManager.GetEntity(uid);
-
-                    if (!container.Entities.Contains(entity))
-                    {
-                        container.DoInsert(entity);
-                    }
-                }
-            }
-        }
-
-        protected override void Shutdown()
-        {
-            base.Shutdown();
-
-            // On shutdown we won't get to process remove events in the containers so this has to be manually done.
-            foreach (var container in _containers.Values)
-            {
-                foreach (var containerEntity in container.Entities)
-                {
-                    Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local,
-                        new UpdateContainerOcclusionMessage(containerEntity));
-                }
-            }
-        }
-    }
-}

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

@@ -1,12 +1,11 @@
-using Robust.Client.Graphics.ClientEye;
-using Robust.Client.Interfaces.Graphics.ClientEye;
+using Robust.Client.Graphics;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.Eye;
-using Robust.Shared.Interfaces.GameObjects.Components;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
@@ -23,7 +22,9 @@ namespace Robust.Client.GameObjects
 
         // Horrible hack to get around ordering issues.
         private bool _setCurrentOnInitialize;
-        private bool _setDrawFovOnInitialize;
+        [DataField("drawFov")]
+        private bool _setDrawFovOnInitialize = true;
+        [DataField("zoom")]
         private Vector2 _setZoomOnInitialize = Vector2.One/2f;
         private Vector2 _offset = Vector2.Zero;
 
@@ -151,6 +152,7 @@ namespace Robust.Client.GameObjects
             Zoom = state.Zoom;
             Offset = state.Offset;
             Rotation = state.Rotation;
+            VisibilityMask = state.VisibilityMask;
         }
 
         public override void OnRemove()
@@ -160,15 +162,6 @@ namespace Robust.Client.GameObjects
             Current = false;
         }
 
-        /// <inheritdoc />
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            base.ExposeData(serializer);
-
-            serializer.DataFieldCached(ref _setZoomOnInitialize, "zoom", Vector2.One/2f);
-            serializer.DataFieldCached(ref _setDrawFovOnInitialize, "drawFov", true);
-        }
-
         /// <summary>
         /// Updates the Eye of this entity with the transform position. This has to be called every frame to
         /// keep the view following the entity.

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

@@ -1,105 +1,51 @@
 using Robust.Client.Graphics;
-using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.ResourceManagement;
+using Robust.Client.Utility;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
     [RegisterComponent]
-    public class IconComponent : Component
+    public class IconComponent : Component, ISerializationHooks
     {
         public override string Name => "Icon";
         public IDirectionalTextureProvider? Icon { get; private set; }
 
-        [Dependency] private readonly IResourceCache _resourceCache = default!;
+        [DataField("sprite")]
+        private ResourcePath? rsi;
+        [DataField("state")]
+        private string? stateID;
+
+        void ISerializationHooks.AfterDeserialization()
+        {
+            if (rsi != null && stateID != null)
+            {
+                Icon = new SpriteSpecifier.Rsi(rsi, stateID).Frame0();
+            }
+        }
 
         public const string LogCategory = "go.comp.icon";
         const string SerializationCache = "icon";
 
-        public override void ExposeData(ObjectSerializer serializer)
+        private static IRsiStateLike TextureForConfig(IconComponent compData, IResourceCache resourceCache)
         {
-            base.ExposeData(serializer);
-
-            // TODO: Does this need writing?
-            if (serializer.Reading)
-            {
-                Icon = TextureForConfig(serializer, _resourceCache);
-            }
-        }
-
-        private static IRsiStateLike TextureForConfig(ObjectSerializer serializer, IResourceCache resourceCache)
-        {
-            DebugTools.Assert(serializer.Reading);
-
-            if (serializer.TryGetCacheData<IRsiStateLike>(SerializationCache, out var dirTex))
-            {
-                return dirTex;
-            }
-
-            var tex = serializer.ReadDataField<string?>("texture", null);
-            if (!string.IsNullOrWhiteSpace(tex))
-            {
-                dirTex = resourceCache.GetResource<TextureResource>(SpriteComponent.TextureRoot / tex).Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            RSI rsi;
-
-            var rsiPath = serializer.ReadDataField<string?>("sprite", null);
-
-            if (string.IsNullOrWhiteSpace(rsiPath))
-            {
-                dirTex = resourceCache.GetFallback<TextureResource>().Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            var path = SpriteComponent.TextureRoot / rsiPath;
-
-            try
-            {
-                rsi = resourceCache.GetResource<RSIResource>(path).RSI;
-            }
-            catch
-            {
-                dirTex = resourceCache.GetFallback<TextureResource>().Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            var stateId = serializer.ReadDataField<string?>("state", null);
-            if (string.IsNullOrWhiteSpace(stateId))
-            {
-                Logger.ErrorS(LogCategory, "No state specified.");
-                dirTex = resourceCache.GetFallback<TextureResource>().Texture;
-                serializer.SetCacheData(SerializationCache, dirTex);
-                return dirTex;
-            }
-
-            if (rsi.TryGetState(stateId, out var state))
-            {
-                serializer.SetCacheData(SerializationCache, state);
-                return state;
-            }
-            else
-            {
-                Logger.ErrorS(LogCategory, "State '{0}' does not exist on RSI.", stateId);
-                return resourceCache.GetFallback<TextureResource>().Texture;
-            }
+            return compData.Icon?.Default ?? resourceCache.GetFallback<TextureResource>().Texture;
         }
 
         public static IRsiStateLike? GetPrototypeIcon(EntityPrototype prototype, IResourceCache resourceCache)
         {
-            if (!prototype.Components.TryGetValue("Icon", out var mapping))
+            if (!prototype.Components.TryGetValue("Icon", out var compData))
             {
                 return null;
             }
-            return TextureForConfig(YamlObjectSerializer.NewReader(mapping), resourceCache);
+
+            return TextureForConfig((IconComponent)compData, resourceCache);
         }
     }
 }

Robust.Client/GameObjects/Components/IgnorePauseComponent.cs

@@ -1,12 +0,0 @@
-using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components;
-
-namespace Robust.Client.GameObjects.Components
-{
-    [RegisterComponent]
-    [ComponentReference(typeof(SharedIgnorePauseComponent))]
-    public sealed class IgnorePauseComponent : SharedIgnorePauseComponent
-    {
-
-    }
-}

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

@@ -1,10 +1,11 @@
-using Robust.Client.GameObjects.EntitySystems;
-using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
-namespace Robust.Client.GameObjects.Components
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     ///     Defines data fields used in the <see cref="InputSystem"/>.
@@ -18,14 +19,7 @@ namespace Robust.Client.GameObjects.Components
         ///     The context that will be made active for a client that attaches to this entity.
         /// </summary>
         [ViewVariables(VVAccess.ReadWrite)]
-        public string ContextName { get; set; } = default!;
-
-        /// <inheritdoc />
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            base.ExposeData(serializer);
-
-            serializer.DataReadWriteFunction("context", InputContextContainer.DefaultContextName, value => ContextName = value, () => ContextName);
-        }
+        [DataField("context")]
+        public string ContextName { get; set; } = InputContextContainer.DefaultContextName;
     }
 }

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

@@ -1,7 +1,5 @@
 using System;
-using Robust.Client.GameObjects.EntitySystems;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.Transform;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.ViewVariables;

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

@@ -1,21 +1,23 @@
-using Robust.Client.GameObjects.EntitySystems;
+using System;
 using Robust.Client.Graphics;
-using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Animations;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Serialization;
+using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
-using System;
 
 namespace Robust.Client.GameObjects
 {
-    public class PointLightComponent : Component
+    [RegisterComponent]
+    [ComponentReference(typeof(IPointLightComponent))]
+    public class PointLightComponent : Component, IPointLightComponent, ISerializationHooks
     {
+        [Dependency] private readonly IResourceCache _resourceCache = default!;
+
         public override string Name => "PointLight";
         public override uint? NetID => NetIDs.POINT_LIGHT;
 
@@ -68,6 +70,21 @@ namespace Robust.Client.GameObjects
             set => _rotation = value;
         }
 
+        /// <inheritdoc />
+        /// <summary>
+        /// The resource path to the mask texture the light will use.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public string? MaskPath
+        {
+            get => _maskPath;
+            set
+            {
+                _maskPath = value;
+                UpdateMask();
+            }
+        }
+
         /// <summary>
         ///     Set a mask texture that will be applied to the light while rendering.
         ///     The mask's red channel will be linearly multiplied.p
@@ -118,16 +135,26 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        private float _radius = 5;
+        [DataField("radius")]
+        private float _radius = 5f;
+        [DataField("nestedvisible")]
         private bool _visibleNested = true;
-        private bool _lightOnParent = false;
+        private bool _lightOnParent;
+        [DataField("color")]
         private Color _color = Color.White;
-        private Vector2 _offset;
+        [DataField("offset")]
+        private Vector2 _offset = Vector2.Zero;
+        [DataField("enabled")]
         private bool _enabled = true;
+        [DataField("autoRot")]
         private bool _maskAutoRotate;
         private Angle _rotation;
-        private float _energy;
-        private float _softness;
+        [DataField("energy")]
+        private float _energy = 1f;
+        [DataField("softness")]
+        private float _softness = 1f;
+        [DataField("mask")]
+        private string? _maskPath;
 
         /// <summary>
         ///     Radius, in meters.
@@ -144,12 +171,34 @@ namespace Robust.Client.GameObjects
             }
         }
 
+        private void UpdateMask()
+        {
+            if (_maskPath is not null)
+                Mask = _resourceCache.GetResource<TextureResource>(_maskPath);
+            else
+                Mask = null;
+        }
+
+        void ISerializationHooks.AfterDeserialization()
+        {
+            if (_maskPath != null)
+            {
+                Mask = IoCManager.Resolve<IResourceCache>().GetResource<TextureResource>(_maskPath);
+            }
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            UpdateMask();
+        }
+
         /// <inheritdoc />
         public override void HandleMessage(ComponentMessage message, IComponent? component)
         {
             base.HandleMessage(message, component);
 
-            if ((message is ParentChangedMessage msg))
+            if (message is ParentChangedMessage msg)
             {
                 HandleTransformParentChanged(msg);
             }
@@ -173,23 +222,6 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        public override void ExposeData(ObjectSerializer serializer)
-        {
-            serializer.DataFieldCached(ref _offset, "offset", Vector2.Zero);
-            serializer.DataFieldCached(ref _radius, "radius", 5f);
-            serializer.DataFieldCached(ref _color, "color", Color.White);
-            serializer.DataFieldCached(ref _enabled, "enabled", true);
-            serializer.DataFieldCached(ref _energy, "energy", 1f);
-            serializer.DataFieldCached(ref _softness, "softness", 1f);
-            serializer.DataFieldCached(ref _maskAutoRotate, "autoRot", false);
-            serializer.DataFieldCached(ref _visibleNested, "nestedvisible", true);
-
-            if (serializer.Reading && serializer.TryReadDataField<string>("mask", out var value))
-            {
-                Mask = IoCManager.Resolve<IResourceCache>().GetResource<TextureResource>(value);
-            }
-        }
-
         public override void OnRemove()
         {
             base.OnRemove();

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

@@ -1,9 +1,8 @@
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
-namespace Robust.Client.Interfaces.GameObjects
+namespace Robust.Client.GameObjects
 {
     public interface IRenderableComponent : IComponent
     {

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

@@ -1,14 +1,12 @@
-using System;
+using System;
 using System.Collections.Generic;
-using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.Shaders;
 using Robust.Shared.Animations;
-using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 
-namespace Robust.Client.Interfaces.GameObjects.Components
+namespace Robust.Client.GameObjects
 {
     public interface ISpriteComponent : IComponent, IAnimationProperties
     {
@@ -51,8 +49,26 @@ namespace Robust.Client.Interfaces.GameObjects.Components
         ///     Rotation transformations on individual layers still apply.
         ///     If false, all layers get locked to south and rotation is a transformation.
         /// </summary>
+        [Obsolete("Use NoRotation and/or DirectionOverride")]
         bool Directional { get; set; }
 
+        /// <summary>
+        /// All sprite rotation is locked, and will always be drawn upright on
+        /// the screen, regardless of world or view orientation.
+        /// </summary>
+        bool NoRotation {get; set; }
+
+        /// <summary>
+        /// Enables overriding the calculated directional RSI state for this sprite.
+        /// The state to use is defined in <see cref="DirectionOverride"/>.
+        /// </summary>
+        bool EnableDirectionOverride { get; set; }
+
+        /// <summary>
+        /// The directional RSI state that will always be displayed, regardless of orientation.
+        /// </summary>
+        Direction DirectionOverride { get; set; }
+
         // NOTE: The below are ALL designed to NOT throw exceptions ever,
         // instead making a bunch of noisy error logs.
 
@@ -66,6 +82,8 @@ namespace Robust.Client.Interfaces.GameObjects.Components
         uint RenderOrder { get; set; }
         bool IsInert { get; }
 
+        Matrix3 GetLocalMatrix();
+
         /// <summary>
         ///     Sets a layer key to the layer map, creating it if it does not exist.
         /// </summary>
@@ -204,30 +222,12 @@ namespace Robust.Client.Interfaces.GameObjects.Components
         ISpriteLayer this[object layerKey] { get; }
 
         IEnumerable<ISpriteLayer> AllLayers { get; }
-    }
 
-    public interface ISpriteLayer
-    {
-        SpriteComponent.DirectionOffset DirOffset { get; set; }
+        int GetLayerDirectionCount(ISpriteLayer layer);
 
-        RSI? Rsi { get; set; }
-        RSI.StateId RsiState { get; set; }
-        RSI? ActualRsi { get; }
-
-        Texture? Texture { get; set; }
-
-        Angle Rotation { get; set; }
-        Vector2 Scale { get; set; }
-
-        bool Visible { get; set; }
-        Color Color { get; set; }
-
-        float AnimationTime { get; set; }
-        int AnimationFrame { get; }
-        bool AutoAnimated { get; set; }
-
-        RSI.State.Direction EffectiveDirection(Angle worldRotation);
-
-        Vector2 LocalToLayer(Vector2 localPos);
+        /// <summary>
+        ///     Calculate sprite bounding box in world-space coordinates.
+        /// </summary>
+        Box2 CalculateBoundingBox();
     }
 }

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

@@ -0,0 +1,42 @@
+using Robust.Client.Graphics;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.GameObjects
+{
+    public interface ISpriteLayer
+    {
+        SpriteComponent.DirectionOffset DirOffset { get; set; }
+
+        RSI? Rsi { get; set; }
+        RSI.StateId RsiState { get; set; }
+        RSI? ActualRsi { get; }
+
+        Texture? Texture { get; set; }
+
+        Angle Rotation { get; set; }
+        Vector2 Scale { get; set; }
+
+        bool Visible { get; set; }
+        Color Color { get; set; }
+
+        float AnimationTime { get; set; }
+        int AnimationFrame { get; }
+        bool AutoAnimated { get; set; }
+
+        RSI.State.Direction EffectiveDirection(Angle worldRotation);
+
+        Vector2 LocalToLayer(Vector2 localPos);
+
+        /// <summary>
+        ///     Layer size in pixels.
+        ///     Don't account layer scale or sprite world transform.
+        /// </summary>
+        Vector2i PixelSize { get; }
+
+        /// <summary>
+        ///     Calculate layer bounding box in sprite local-space coordinates.
+        /// </summary>
+        /// <returns>Bounding box in sprite local-space coordinates.</returns>
+        Box2 CalculateBoundingBox();
+    }
+}

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

@@ -1,48 +1,36 @@
 using System;
 using System.Collections.Generic;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.UserInterface;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.IoC;
+using Robust.Shared.Network;
 using Robust.Shared.Players;
+using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
-using IComponent = Robust.Shared.Interfaces.GameObjects.IComponent;
+using Robust.Shared.Serialization.Manager.Attributes;
 
-namespace Robust.Client.GameObjects.Components.UserInterface
+namespace Robust.Client.GameObjects
 {
-    public class ClientUserInterfaceComponent : SharedUserInterfaceComponent
+    public class ClientUserInterfaceComponent : SharedUserInterfaceComponent, ISerializationHooks
     {
+        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
+        [Dependency] private readonly IDynamicTypeFactory _dynamicTypeFactory = default!;
+
         private readonly Dictionary<object, BoundUserInterface> _openInterfaces =
             new();
 
-        private Dictionary<object, PrototypeData> _interfaceData = default!;
-#pragma warning disable 649
-        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
-        [Dependency] private readonly IDynamicTypeFactory _dynamicTypeFactory = default!;
-#pragma warning restore 649
+        private readonly Dictionary<object, PrototypeData> _interfaces = new();
 
-        public override void ExposeData(ObjectSerializer serializer)
+        [DataField("interfaces", readOnly: true)]
+        private List<PrototypeData> _interfaceData = new();
+
+        void ISerializationHooks.AfterDeserialization()
         {
-            base.ExposeData(serializer);
+            _interfaces.Clear();
 
-            const string cache = "ui_cache";
-
-            if (serializer.TryGetCacheData<Dictionary<object, PrototypeData>>(cache, out var interfaceData))
+            foreach (var data in _interfaceData)
             {
-                _interfaceData = interfaceData;
-                return;
+                _interfaces[data.UiKey] = data;
             }
-
-            var data = serializer.ReadDataFieldCached("interfaces", new List<PrototypeData>());
-            interfaceData = new Dictionary<object, PrototypeData>();
-            foreach (var prototypeData in data)
-            {
-                interfaceData[prototypeData.UiKey] = prototypeData;
-            }
-
-            serializer.SetCacheData(cache, interfaceData);
-            _interfaceData = interfaceData;
         }
 
         public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel,
@@ -83,7 +71,7 @@ namespace Robust.Client.GameObjects.Components.UserInterface
 
         private void OpenInterface(BoundInterfaceMessageWrapMessage wrapped)
         {
-            var data = _interfaceData[wrapped.UiKey];
+            var data = _interfaces[wrapped.UiKey];
             // TODO: This type should be cached, but I'm too lazy.
             var type = _reflectionManager.LooseGetType(data.ClientType);
             var boundInterface = (BoundUserInterface) _dynamicTypeFactory.CreateInstance(type, new[]{this, wrapped.UiKey});

Robust.Client/GameObjects/EntityManagerExt.cs

@@ -1,7 +1,6 @@
-using Robust.Client.Interfaces.GameStates;
+using Robust.Client.GameStates;
 using Robust.Client.Player;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Utility;
 
@@ -10,7 +9,7 @@ namespace Robust.Client.GameObjects
     public static class EntityManagerExt
     {
         public static void RaisePredictiveEvent<T>(this IEntityManager entityManager, T msg)
-            where T : EntitySystemMessage
+            where T : EntityEventArgs
         {
             var localPlayer = IoCManager.Resolve<IPlayerManager>().LocalPlayer;
             DebugTools.AssertNotNull(localPlayer);

Robust.Client/GameObjects/EntitySystems/AnimationPlayerSystem.cs

@@ -1,7 +1,6 @@
-using Robust.Client.GameObjects.Components.Animations;
-using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.GameObjects;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     internal sealed class AnimationPlayerSystem : EntitySystem
     {

Robust.Client/GameObjects/EntitySystems/AppearanceSystem.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
-using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.GameObjects;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     internal sealed class AppearanceSystem : EntitySystem
     {

Robust.Client/GameObjects/EntitySystems/AppearanceTestSystem.cs

@@ -1,6 +1,6 @@
-using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.GameObjects;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     class AppearanceTestSystem : EntitySystem
     {

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -1,27 +1,22 @@
-using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
 using Robust.Client.Audio;
-using Robust.Client.Interfaces.Graphics;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.ResourceManagement;
+using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Audio;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Map;
-using Robust.Shared.Interfaces.Physics;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Broadphase;
+using Robust.Shared.Player;
 using Robust.Shared.Utility;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     [UsedImplicitly]
-    public class AudioSystem : EntitySystem
+    public class AudioSystem : EntitySystem, IAudioSystem
     {
         [Dependency] private readonly IResourceCache _resourceCache = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
@@ -29,17 +24,21 @@ namespace Robust.Client.GameObjects.EntitySystems
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
 
-        private readonly List<PlayingStream> _playingClydeStreams = new();
+        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
 
-        public int OcclusionCollisionMask;
+        private readonly List<PlayingStream> _playingClydeStreams = new();
 
         /// <inheritdoc />
         public override void Initialize()
         {
+            base.Initialize();
             SubscribeNetworkEvent<PlayAudioEntityMessage>(PlayAudioEntityHandler);
             SubscribeNetworkEvent<PlayAudioGlobalMessage>(PlayAudioGlobalHandler);
             SubscribeNetworkEvent<PlayAudioPositionalMessage>(PlayAudioPositionalHandler);
             SubscribeNetworkEvent<StopAudioMessageClient>(StopAudioMessageHandler);
+
+            SubscribeLocalEvent<SoundSystem.QueryAudioSystem>((ev => ev.Audio = this));
+            _broadPhaseSystem = Get<SharedBroadPhaseSystem>();
         }
 
         private void StopAudioMessageHandler(StopAudioMessageClient ev)
@@ -146,7 +145,7 @@ namespace Robust.Client.GameObjects.EntitySystems
                             var occlusion = 0f;
                             if (sourceRelative.Length > 0)
                             {
-                                occlusion = IoCManager.Resolve<IPhysicsManager>().IntersectRayPenetration(
+                                occlusion = _broadPhaseSystem.IntersectRayPenetration(
                                     pos.MapId,
                                     new CollisionRay(
                                         pos.Position,
@@ -165,6 +164,12 @@ namespace Robust.Client.GameObjects.EntitySystems
                             Logger.Warning("Interrupting positional audio, can't set position.");
                             stream.Source.StopPlaying();
                         }
+
+                        if (stream.TrackingEntity != null)
+                        {
+                            stream.Source.SetVelocity(stream.TrackingEntity.GlobalLinearVelocity());
+                        }
+
                     }
                 }
             }
@@ -181,7 +186,6 @@ namespace Robust.Client.GameObjects.EntitySystems
         {
             stream.Source.Dispose();
             stream.Done = true;
-            stream.DoPlaybackDone();
         }
 
         /// <summary>
@@ -189,7 +193,7 @@ namespace Robust.Client.GameObjects.EntitySystems
         /// </summary>
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(string filename, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
@@ -205,7 +209,7 @@ namespace Robust.Client.GameObjects.EntitySystems
         /// </summary>
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream Play(AudioStream stream, AudioParams? audioParams = null)
+        private IPlayingAudioStream Play(AudioStream stream, AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
             ApplyAudioParams(audioParams, source);
@@ -227,7 +231,7 @@ namespace Robust.Client.GameObjects.EntitySystems
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="entity">The entity "emitting" the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(string filename, IEntity entity, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, IEntity entity, AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
@@ -244,7 +248,7 @@ namespace Robust.Client.GameObjects.EntitySystems
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="entity">The entity "emitting" the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(AudioStream stream, IEntity entity, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(AudioStream stream, IEntity entity, AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
             if (!source.SetPosition(entity.Transform.WorldPosition))
@@ -273,7 +277,7 @@ namespace Robust.Client.GameObjects.EntitySystems
         /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
         /// <param name="coordinates">The coordinates at which to play the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
+        private IPlayingAudioStream? Play(string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
         {
             if (_resourceCache.TryGetResource<AudioResource>(new ResourcePath(filename), out var audio))
             {
@@ -290,7 +294,7 @@ namespace Robust.Client.GameObjects.EntitySystems
         /// <param name="stream">The audio stream to play.</param>
         /// <param name="coordinates">The coordinates at which to play the audio.</param>
         /// <param name="audioParams"></param>
-        public IPlayingAudioStream? Play(AudioStream stream, EntityCoordinates coordinates,
+        private IPlayingAudioStream? Play(AudioStream stream, EntityCoordinates coordinates,
             AudioParams? audioParams = null)
         {
             var source = _clyde.CreateAudioSource(stream);
@@ -340,92 +344,30 @@ namespace Robust.Client.GameObjects.EntitySystems
             {
                 Source.StopPlaying();
             }
-
-            public event Action? PlaybackDone;
-
-            public void DoPlaybackDone()
-            {
-                PlaybackDone?.Invoke();
-            }
-        }
-    }
-
-    public interface IPlayingAudioStream
-    {
-        void Stop();
-
-        event Action PlaybackDone;
-    }
-
-    public static class AudioSystemExtensions
-    {
-
-        /// <summary>
-        ///     Play an audio file following an entity.
-        /// </summary>
-        /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
-        /// <param name="entity">The entity "emitting" the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this IEntity entity,
-            string filename,
-            AudioParams? audioParams,
-            AudioSystem? audioSystem = null)
-        {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(filename, entity, audioParams);
         }
 
-        /// <summary>
-        ///     Play an audio stream following an entity.
-        /// </summary>
-        /// <param name="stream">The audio stream to play.</param>
-        /// <param name="entity">The entity "emitting" the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this IEntity entity,
-            AudioStream stream,
-            AudioParams? audioParams = null,
-            AudioSystem? audioSystem = null)
+        /// <inheritdoc />
+        public int DefaultSoundRange => 25;
+
+        /// <inheritdoc />
+        public int OcclusionCollisionMask { get; set; }
+
+        /// <inheritdoc />
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, AudioParams? audioParams = null)
         {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(stream, entity, audioParams);
+            return Play(filename, audioParams);
         }
 
-        /// <summary>
-        ///     Play an audio file at a static position.
-        /// </summary>
-        /// <param name="filename">The resource path to the OGG Vorbis file to play.</param>
-        /// <param name="coordinates">The coordinates at which to play the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this EntityCoordinates coordinates,
-            string filename,
-            AudioParams? audioParams = null,
-            AudioSystem? audioSystem = null)
+        /// <inheritdoc />
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, IEntity entity, AudioParams? audioParams = null)
         {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(filename, coordinates, audioParams);
+            return Play(filename, entity, audioParams);
         }
 
-        /// <summary>
-        ///     Play an audio stream at a static position.
-        /// </summary>
-        /// <param name="stream">The audio stream to play.</param>
-        /// <param name="coordinates">The coordinates at which to play the audio.</param>
-        /// <param name="audioParams"></param>
-        /// <param name="audioSystem">A pre-fetched instance of <see cref="AudioSystem"/> to use, can be null.</param>
-        public static IPlayingAudioStream? Play(
-            this EntityCoordinates coordinates,
-            AudioStream stream,
-            AudioParams? audioParams = null,
-            AudioSystem? audioSystem = null)
+        /// <inheritdoc />
+        public IPlayingAudioStream? Play(Filter playerFilter, string filename, EntityCoordinates coordinates, AudioParams? audioParams = null)
         {
-            audioSystem ??= EntitySystem.Get<AudioSystem>();
-            return audioSystem.Play(stream, coordinates, audioParams);
+            return Play(filename, coordinates, audioParams);
         }
     }
 }

Robust.Client/GameObjects/EntitySystems/ClientContainerSystem.cs

@@ -1,11 +1,10 @@
 using System.Collections.Generic;
 using Robust.Shared.Containers;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
-    public class ContainerSystem : EntitySystem
+    public class ClientContainerSystem : ContainerSystem
     {
         private readonly HashSet<IEntity> _updateQueue = new();
 
@@ -92,14 +91,4 @@ namespace Robust.Client.GameObjects.EntitySystems
             }
         }
     }
-
-    internal readonly struct UpdateContainerOcclusionMessage
-    {
-        public UpdateContainerOcclusionMessage(IEntity entity)
-        {
-            Entity = entity;
-        }
-
-        public IEntity Entity { get; }
-    }
 }

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -3,15 +3,11 @@ using System.Linq;
 using JetBrains.Annotations;
 using Robust.Client.Physics;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.Transform;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Map;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     // NOTE: this class handles both snap grid updates of occluders, as well as occluder tree updates (via its parent).
     // This seems like it's doing somewhat double work because it already has an update queue for occluders but...
@@ -110,7 +106,7 @@ namespace Robust.Client.GameObjects.EntitySystems
     /// <summary>
     ///     Event raised by a <see cref="ClientOccluderComponent"/> when it needs to be recalculated.
     /// </summary>
-    internal sealed class OccluderDirtyEvent : EntitySystemMessage
+    internal sealed class OccluderDirtyEvent : EntityEventArgs
     {
         public OccluderDirtyEvent(IEntity sender, (GridId grid, Vector2i pos)? lastPosition, SnapGridOffset offset)
         {

Robust.Client/GameObjects/EntitySystems/EffectSystem.cs

@@ -1,26 +1,17 @@
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.Drawing;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.ResourceManagement;
-using Robust.Shared.GameObjects.EntitySystemMessages;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using System;
 using System.Collections.Generic;
-using Robust.Client.Graphics.Overlays;
-using Robust.Client.Graphics.Shaders;
-using Robust.Client.Interfaces.Graphics.Overlays;
 using Robust.Client.Player;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Map;
 using Robust.Shared.Log;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
+using Robust.Shared.Enums;
 
 namespace Robust.Client.GameObjects
 {
@@ -52,7 +43,7 @@ namespace Robust.Client.GameObjects
         {
             base.Shutdown();
 
-            overlayManager.RemoveOverlay("EffectSystem");
+            overlayManager.RemoveOverlay(typeof(EffectOverlay));
         }
 
         public void CreateEffect(EffectSystemMessage message)
@@ -339,7 +330,6 @@ namespace Robust.Client.GameObjects
         {
             private readonly IPlayerManager _playerManager;
 
-            public override bool AlwaysDirty => true;
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
             private readonly ShaderInstance _unshadedShader;
@@ -347,8 +337,7 @@ namespace Robust.Client.GameObjects
             private readonly IMapManager _mapManager;
             private readonly IEntityManager _entityManager;
 
-            public EffectOverlay(EffectSystem owner, IPrototypeManager protoMan, IMapManager mapMan, IPlayerManager playerMan, IEntityManager entityManager) : base(
-                "EffectSystem")
+            public EffectOverlay(EffectSystem owner, IPrototypeManager protoMan, IMapManager mapMan, IPlayerManager playerMan, IEntityManager entityManager)
             {
                 _owner = owner;
                 _unshadedShader = protoMan.Index<ShaderPrototype>("unshaded").Instance();

Robust.Client/GameObjects/EntitySystems/EyeUpdateSystem.cs

@@ -1,8 +1,8 @@
 using System;
 using JetBrains.Annotations;
-using Robust.Client.Interfaces.Graphics.ClientEye;
+using Robust.Client.Graphics;
 using Robust.Client.Physics;
-using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.Input.Binding;
 using Robust.Shared.IoC;
@@ -10,7 +10,7 @@ using Robust.Shared.Maths;
 
 #nullable enable
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     /// Updates the position of every Eye every frame, so that the camera follows the player around.

Robust.Client/GameObjects/EntitySystems/InputSystem.cs

@@ -1,19 +1,15 @@
 using System;
-using Robust.Client.GameObjects.Components;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Input;
+using Robust.Client.GameStates;
+using Robust.Client.Input;
 using Robust.Client.Player;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Systems;
 using Robust.Shared.Input;
-using Robust.Shared.Input.Binding;
-using Robust.Shared.Interfaces.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Players;
 using Robust.Shared.Utility;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     ///     Client-side processing of all input commands through the simulation.
@@ -44,7 +40,7 @@ namespace Robust.Client.GameObjects.EntitySystems
         /// <param name="message">Arguments for this event.</param>
         /// <param name="replay">if true, current cmd state will not be checked or updated - use this for "replaying" an
         /// old input that was saved or buffered until further processing could be done</param>
-        public bool HandleInputCommand(ICommonSession session, BoundKeyFunction function, FullInputCmdMessage message, bool replay = false)
+        public bool HandleInputCommand(ICommonSession? session, BoundKeyFunction function, FullInputCmdMessage message, bool replay = false)
         {
             #if DEBUG
 
@@ -161,7 +157,7 @@ namespace Robust.Client.GameObjects.EntitySystems
     /// <summary>
     ///     Entity system message that is raised when the player changes attached entities.
     /// </summary>
-    public class PlayerAttachSysMessage : EntitySystemMessage
+    public class PlayerAttachSysMessage : EntityEventArgs
     {
         /// <summary>
         ///     New entity the player is attached to.

Robust.Client/GameObjects/EntitySystems/MidiSystem.cs

@@ -1,8 +1,8 @@
 using Robust.Client.Audio.Midi;
-using Robust.Shared.GameObjects.Systems;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     public class MidiSystem : EntitySystem
     {

Robust.Client/GameObjects/EntitySystems/RenderingTreeSystem.cs

@@ -1,16 +1,13 @@
 using System.Collections.Generic;
 using JetBrains.Annotations;
 using Robust.Client.Physics;
-using Robust.Shared.GameObjects.Components.Transform;
-using Robust.Shared.GameObjects.EntitySystemMessages;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     ///     Keeps track of <see cref="DynamicTree{T}"/>s for various rendering-related components.

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -1,10 +1,10 @@
 using JetBrains.Annotations;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Shared.GameObjects.Systems;
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     /// Updates the layer animation for every visible sprite.

Robust.Client/GameObjects/EntitySystems/TransformSystem.cs

@@ -1,16 +1,14 @@
 using System;
 using System.Collections.Generic;
 using JetBrains.Annotations;
-using Robust.Shared.GameObjects.Components.Transform;
-using Robust.Shared.GameObjects.EntitySystemMessages;
-using Robust.Shared.GameObjects.Systems;
-using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     ///     Handles interpolation of transform positions.

Robust.Client/GameObjects/EntitySystems/VelocityDebugSystem.cs

@@ -0,0 +1,51 @@
+using Robust.Client.Graphics;
+using Robust.Client.Player;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+
+namespace Robust.Client.GameObjects
+{
+    public class VelocityDebugSystem : EntitySystem
+    {
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+
+        internal bool Enabled { get; set; }
+
+        private Label _label = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _label = new Label();
+            IoCManager.Resolve<IUserInterfaceManager>().StateRoot.AddChild(_label);
+        }
+
+        public override void FrameUpdate(float frameTime)
+        {
+            base.FrameUpdate(frameTime);
+            if (!Enabled)
+            {
+                _label.Visible = false;
+                return;
+            }
+
+            var player = _playerManager.LocalPlayer?.ControlledEntity;
+
+            if (player == null || !player.TryGetComponent(out PhysicsComponent? body))
+            {
+                _label.Visible = false;
+                return;
+            }
+
+            var screenPos = _eyeManager.WorldToScreen(player.Transform.WorldPosition);
+            LayoutContainer.SetPosition(_label, screenPos + new Vector2(0, 50));
+            _label.Visible = true;
+
+            _label.Text = $"Speed: {body.LinearVelocity.Length}\nLinear: {body.LinearVelocity.X:0.00}, {body.LinearVelocity.Y:0.00}\nAngular:{body.AngularVelocity}";
+        }
+    }
+}