Improvements to SpriteComponent for new angle changes: (#1589)

1. Fixes CopyFrom with new rotation parameters.
2. Adds a couple APIs for ClickableComponent content side.

MSBuild/Robust.Analyzers.targets

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

MSBuild/Robust.Engine.targets

@@ -1,2 +1,3 @@
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="12.0">
+  <Import Project="Robust.Analyzers.targets" />
 </Project>

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/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/ExplicitInterfaceAnalyzer.cs

@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Document = Microsoft.CodeAnalysis.Document;
+
+namespace Robust.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class ExplicitInterfaceAnalyzer : DiagnosticAnalyzer
+    {
+        public readonly SyntaxKind[] ExcludedModifiers =
+        {
+            SyntaxKind.VirtualKeyword,
+            SyntaxKind.AbstractKeyword,
+            SyntaxKind.OverrideKeyword
+        };
+
+        public const string DiagnosticId = "RA0000";
+
+        private const string Title = "No explicit interface specified";
+        private const string MessageFormat = "No explicit interface specified";
+        private const string Description = "Make sure to specify the interface in your method-declaration.";
+        private const string Category = "Usage";
+
+        [SuppressMessage("ReSharper", "RS2008")] private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, description: Description);
+
+        private const string RequiresExplicitImplementationAttributeMetadataName =
+            "Robust.Shared.Analyzers.RequiresExplicitImplementationAttribute";
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.MethodDeclaration);
+            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.PropertyDeclaration);
+        }
+
+        private void AnalyzeNode(SyntaxNodeAnalysisContext context)
+        {
+            ISymbol symbol;
+            Location location;
+            switch (context.Node)
+            {
+                //we already have a explicit interface specified, no need to check further
+                case MethodDeclarationSyntax methodDecl when methodDecl.ExplicitInterfaceSpecifier != null || methodDecl.Modifiers.Any(m => ExcludedModifiers.Contains(m.Kind())):
+                    return;
+                case PropertyDeclarationSyntax propertyDecl when propertyDecl.ExplicitInterfaceSpecifier != null || propertyDecl.Modifiers.Any(m => ExcludedModifiers.Contains(m.Kind())):
+                    return;
+
+                case MethodDeclarationSyntax methodDecl:
+                    symbol = context.SemanticModel.GetDeclaredSymbol(methodDecl);
+                    location = methodDecl.Identifier.GetLocation();
+                    break;
+                case PropertyDeclarationSyntax propertyDecl:
+                    symbol = context.SemanticModel.GetDeclaredSymbol(propertyDecl);
+                    location = propertyDecl.Identifier.GetLocation();
+                    break;
+
+                default:
+                    return;
+            }
+
+            var attrSymbol = context.Compilation.GetTypeByMetadataName(RequiresExplicitImplementationAttributeMetadataName);
+
+            var isInterfaceMember = symbol?.ContainingType.AllInterfaces.Any(
+                i =>
+                    i.GetMembers().Any(m => SymbolEqualityComparer.Default.Equals(symbol, symbol.ContainingType.FindImplementationForInterfaceMember(m)))
+                    && i.GetAttributes().Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attrSymbol))
+            ) ?? false;
+
+            if (isInterfaceMember)
+            {
+                //we do not have an explicit interface specified. bad!
+                var diagnostic = Diagnostic.Create(
+                    Rule,
+                    location);
+                context.ReportDiagnostic(diagnostic);
+            }
+        }
+    }
+}

Robust.Analyzers/Robust.Analyzers.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="3.8.0" />
+  </ItemGroup>
+
+</Project>

Robust.Analyzers/SerializableAnalyzer.cs

@@ -0,0 +1,150 @@
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Robust.Analyzers
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class SerializableAnalyzer : DiagnosticAnalyzer
+    {
+        // Metadata of the analyzer
+        public const string DiagnosticId = "RA0001";
+
+        // You could use LocalizedString but it's a little more complicated for this sample
+        private const string Title = "Class not marked as (Net)Serializable";
+        private const string MessageFormat = "Class not marked as (Net)Serializable";
+        private const string Description = "The class should be marked as (Net)Serializable.";
+        private const string Category = "Usage";
+
+        private const string RequiresSerializableAttributeMetadataName = "Robust.Shared.Analyzers.RequiresSerializableAttribute";
+        private const string SerializableAttributeMetadataName = "System.SerializableAttribute";
+        private const string NetSerializableAttributeMetadataName = "Robust.Shared.Serialization.NetSerializableAttribute";
+
+        [SuppressMessage("ReSharper", "RS2008")] private static readonly DiagnosticDescriptor Rule = new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, Category, DiagnosticSeverity.Warning, isEnabledByDefault: true, description: Description);
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
+
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+            context.RegisterSyntaxNodeAction(AnalyzeNode, SyntaxKind.ClassDeclaration);
+        }
+
+        private bool Marked(INamedTypeSymbol namedTypeSymbol, INamedTypeSymbol attrSymbol)
+        {
+            if (namedTypeSymbol == null) return false;
+            if (namedTypeSymbol.GetAttributes()
+                .Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, attrSymbol))) return true;
+            return Marked(namedTypeSymbol.BaseType, attrSymbol);
+        }
+
+        private void AnalyzeNode(SyntaxNodeAnalysisContext context)
+        {
+            var attrSymbol = context.Compilation.GetTypeByMetadataName(RequiresSerializableAttributeMetadataName);
+            var classDecl = (ClassDeclarationSyntax) context.Node;
+            var classSymbol = context.SemanticModel.GetDeclaredSymbol(classDecl);
+            if (classSymbol == null) return;
+
+            if (Marked(classSymbol, attrSymbol))
+            {
+                var attributes = classSymbol.GetAttributes();
+                var serAttr = context.Compilation.GetTypeByMetadataName(SerializableAttributeMetadataName);
+                var netSerAttr = context.Compilation.GetTypeByMetadataName(NetSerializableAttributeMetadataName);
+
+                var hasSerAttr = attributes.Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, serAttr));
+                var hasNetSerAttr =
+                    attributes.Any(a => SymbolEqualityComparer.Default.Equals(a.AttributeClass, netSerAttr));
+
+                if (!hasSerAttr || !hasNetSerAttr)
+                {
+                    var requiredAttributes = new List<string>();
+                    if(!hasSerAttr) requiredAttributes.Add(SerializableAttributeMetadataName);
+                    if(!hasNetSerAttr) requiredAttributes.Add(NetSerializableAttributeMetadataName);
+
+                    context.ReportDiagnostic(
+                        Diagnostic.Create(
+                            Rule,
+                            classDecl.Identifier.GetLocation(),
+                            ImmutableDictionary.CreateRange(new Dictionary<string, string>()
+                            {
+                                {
+                                    "requiredAttributes", string.Join(",", requiredAttributes)
+                                }
+                            })));
+                }
+            }
+        }
+    }
+
+    [ExportCodeFixProvider(LanguageNames.CSharp)]
+    public class SerializableCodeFixProvider : CodeFixProvider
+    {
+        private const string Title = "Annotate class as (Net)Serializable.";
+
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
+
+            foreach (var diagnostic in context.Diagnostics)
+            {
+                var span = diagnostic.Location.SourceSpan;
+                var classDecl = root.FindToken(span.Start).Parent.AncestorsAndSelf().OfType<ClassDeclarationSyntax>().First();
+
+                if(!diagnostic.Properties.TryGetValue("requiredAttributes", out var requiredAttributes)) return;
+
+                context.RegisterCodeFix(
+                    CodeAction.Create(
+                        Title,
+                        c => FixAsync(context.Document, classDecl, requiredAttributes, c),
+                        Title),
+                    diagnostic);
+            }
+        }
+
+        private async Task<Document> FixAsync(Document document, ClassDeclarationSyntax classDecl,
+            string requiredAttributes, CancellationToken cancellationToken)
+        {
+            var attributes = new List<AttributeSyntax>();
+            var namespaces = new List<string>();
+            foreach (var attribute in requiredAttributes.Split(','))
+            {
+                var tempSplit = attribute.Split('.');
+                namespaces.Add(string.Join(".",tempSplit.Take(tempSplit.Length-1)));
+                var @class = tempSplit.Last();
+                @class = @class.Substring(0, @class.Length - 9); //cut out "Attribute" at the end
+                attributes.Add(SyntaxFactory.Attribute(SyntaxFactory.ParseName(@class)));
+            }
+
+            var newClassDecl =
+                classDecl.AddAttributeLists(SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList(attributes)));
+
+            var root = (CompilationUnitSyntax) await document.GetSyntaxRootAsync(cancellationToken);
+            root = root.ReplaceNode(classDecl, newClassDecl);
+
+            foreach (var ns in namespaces)
+            {
+                if(root.Usings.Any(u => u.Name.ToString() == ns)) continue;
+                root = root.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(ns)));
+            }
+            return document.WithSyntaxRoot(root);
+        }
+
+        public sealed override ImmutableArray<string> FixableDiagnosticIds => ImmutableArray.Create(SerializableAnalyzer.DiagnosticId);
+
+        public override FixAllProvider GetFixAllProvider()
+        {
+            return WellKnownFixAllProviders.BatchFixer;
+        }
+
+    }
+}

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
 {

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,8 @@
 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;
 
 namespace Robust.Client.Animations
 {

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

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.Utility;
 using Logger = Robust.Shared.Log.Logger;
 

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,14 @@ 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.Prototypes;
+using Robust.Shared.Reflection;
 
 namespace Robust.Client
 {
@@ -53,7 +35,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>();
@@ -79,9 +61,11 @@ namespace Robust.Client
             IoCManager.Register<ILightManager, LightManager>();
             IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
             IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
+            IoCManager.Register<IConsoleHost, ClientConsoleHost>();
             IoCManager.Register<IFontManager, FontManager>();
             IoCManager.Register<IFontManagerInternal, FontManager>();
             IoCManager.Register<IMidiManager, MidiManager>();
+            IoCManager.Register<IAuthManager, AuthManager>();
             switch (mode)
             {
                 case GameController.DisplayMode.Headless:

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,20 +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.Debugging;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
 using Robust.Client.ResourceManagement.ResourceTypes;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
@@ -28,15 +20,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 +481,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 +544,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 +564,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 +601,7 @@ namespace Robust.Client.Console.Commands
                 {
                     grid.AddChild(new Button
                     {
-                        CustomMinimumSize = (50, 50),
+                        MinSize = (50, 50),
                         Text = $"{x}, {y}"
                     });
                 }
@@ -643,6 +633,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/LauncherAuthCommand.cs

@@ -1,13 +1,13 @@
 #if !FULL_RELEASE
+using System;
 using System.IO;
 using System.Linq;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 using Robust.Client.Utility;
-using Robust.Shared;
 using Robust.Shared.Console;
-using Robust.Shared.Interfaces.Configuration;
 using Robust.Shared.IoC;
+using Robust.Shared.Network;
 
 namespace Robust.Client.Console.Commands
 {
@@ -39,9 +39,9 @@ namespace Robust.Client.Console.Commands
             var token = login.Token.Token;
             var userId = login.UserId;
 
-            var cfg = IoCManager.Resolve<IConfigurationManagerInternal>();
-            cfg.SetSecureCVar(CVars.AuthUserId, userId);
-            cfg.SetSecureCVar(CVars.AuthToken, token);
+            var cfg = IoCManager.Resolve<IAuthManager>();
+            cfg.Token = token;
+            cfg.UserId = new NetUserId(Guid.Parse(userId));
         }
 
         private sealed class LauncherConfig

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/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/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

@@ -10,10 +10,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;
 

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,18 +1,9 @@
 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.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;

Robust.Client/Debugging/DebugDrawingManager.cs

@@ -1,15 +1,11 @@
-using Robust.Client.Interfaces.Debugging;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.IoC;
+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.Network;
 
 namespace Robust.Client.Debugging
 {

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

@@ -3,18 +3,15 @@ using System.IO;
 using System.Net;
 using System.Threading.Tasks;
 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,15 +19,11 @@ 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.Timing;
@@ -67,6 +60,7 @@ namespace Robust.Client
         [Dependency] private readonly IComponentManager _componentManager = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IRobustMappedStringSerializer _stringSerializer = default!;
+        [Dependency] private readonly IAuthManager _authManager = default!;
 
         private CommandLineArgs? _commandLineArgs;
         private bool _disableAssemblyLoadContext;
@@ -168,6 +162,7 @@ namespace Robust.Client
             _serializer.Initialize();
             _inputManager.Initialize();
             _consoleHost.Initialize();
+            _prototypeManager.Initialize();
             _prototypeManager.LoadDirectory(new ResourcePath(@"/Prototypes/"));
             _prototypeManager.Resync();
             _mapManager.Initialize();
@@ -186,6 +181,8 @@ namespace Robust.Client
                 _client.PlayerNameOverride = _commandLineArgs.Username;
             }
 
+            _authManager.LoadFromEnv();
+
             _clyde.Ready();
 
             if ((_commandLineArgs?.Connect == true || _commandLineArgs?.Launcher == true)

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
 {

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,4 @@
-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.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
@@ -39,7 +25,6 @@ namespace Robust.Client.GameObjects
             RegisterReference<PhysicsComponent, IPhysBody>();
             RegisterReference<PhysicsComponent, IPhysicsComponent>();
             RegisterIgnore("KeyBindingInput");
-            Register<PointLightComponent>();
 
             Register<InputComponent>();
 

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;

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

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,13 +1,9 @@
 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.Reflection;
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
@@ -78,6 +74,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 +83,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();
         }

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

@@ -1,13 +1,10 @@
 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
+namespace Robust.Client.GameObjects
 {
     public sealed partial class ContainerManagerComponent
     {

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

@@ -2,14 +2,10 @@
 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
+namespace Robust.Client.GameObjects
 {
     public sealed partial class ContainerManagerComponent : SharedContainerManagerComponent
     {

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

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

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

@@ -1,9 +1,9 @@
 using Robust.Client.Graphics;
-using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization;
 using Robust.Shared.Utility;
 

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,9 @@
-using Robust.Client.GameObjects.EntitySystems;
-using Robust.Shared.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.Serialization;
 using Robust.Shared.ViewVariables;
 
-namespace Robust.Client.GameObjects.Components
+namespace Robust.Client.GameObjects
 {
     /// <summary>
     ///     Defines data fields used in the <see cref="InputSystem"/>.

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,22 @@
-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.ViewVariables;
-using System;
 
 namespace Robust.Client.GameObjects
 {
-    public class PointLightComponent : Component
+    [RegisterComponent]
+    [ComponentReference(typeof(IPointLightComponent))]
+    public class PointLightComponent : Component, IPointLightComponent
     {
+        [Dependency] private readonly IResourceCache _resourceCache = default!;
+
         public override string Name => "PointLight";
         public override uint? NetID => NetIDs.POINT_LIGHT;
 
@@ -68,6 +69,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
@@ -120,7 +136,7 @@ namespace Robust.Client.GameObjects
 
         private float _radius = 5;
         private bool _visibleNested = true;
-        private bool _lightOnParent = false;
+        private bool _lightOnParent;
         private Color _color = Color.White;
         private Vector2 _offset;
         private bool _enabled = true;
@@ -128,6 +144,7 @@ namespace Robust.Client.GameObjects
         private Angle _rotation;
         private float _energy;
         private float _softness;
+        private string? _maskPath;
 
         /// <summary>
         ///     Radius, in meters.
@@ -144,6 +161,20 @@ namespace Robust.Client.GameObjects
             }
         }
 
+        private void UpdateMask()
+        {
+            if (_maskPath is not null)
+                Mask = _resourceCache.GetResource<TextureResource>(_maskPath);
+            else
+                Mask = null;
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            UpdateMask();
+        }
+
         /// <inheritdoc />
         public override void HandleMessage(ComponentMessage message, IComponent? component)
         {
@@ -183,11 +214,7 @@ namespace Robust.Client.GameObjects
             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);
-            }
+            serializer.DataFieldCached(ref _maskPath, "mask", null);
         }
 
         public override void 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,6 @@ namespace Robust.Client.Interfaces.GameObjects.Components
         ISpriteLayer this[object layerKey] { get; }
 
         IEnumerable<ISpriteLayer> AllLayers { get; }
-    }
-
-    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);
+        int GetLayerDirectionCount(ISpriteLayer layer);
     }
 }

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

@@ -0,0 +1,30 @@
+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);
+    }
+}

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

@@ -1,33 +1,24 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.Linq;
 using System.Text;
-using Robust.Client.GameObjects.EntitySystems;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.ClientEye;
-using Robust.Client.Graphics.Drawing;
-using Robust.Client.Graphics.Shaders;
-using Robust.Client.Interfaces.GameObjects.Components;
-using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.ResourceManagement;
 using Robust.Client.Utility;
 using Robust.Shared.Animations;
 using Robust.Shared.GameObjects;
-using Robust.Shared.GameObjects.Components.Renderable;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Reflection;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
+using Robust.Shared.Network;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
-using Robust.Shared.Utility;
-using System.Linq;
-using Robust.Shared.Interfaces.GameObjects.Components;
-using Robust.Shared.Interfaces.Network;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 using DrawDepthTag = Robust.Shared.GameObjects.DrawDepth;
 
@@ -110,6 +101,7 @@ namespace Robust.Client.GameObjects
         ///     If false, all layers get locked to south and rotation is a transformation.
         /// </summary>
         [ViewVariables(VVAccess.ReadWrite)]
+        [Obsolete("Use NoRotation and/or DirectionOverride")]
         public bool Directional
         {
             get => _directional;
@@ -197,34 +189,42 @@ namespace Robust.Client.GameObjects
         public void CopyFrom(SpriteComponent other)
         {
             //deep copying things to avoid entanglement
-            this._baseRsi = other._baseRsi;
-            this._directional = other._directional;
-            this._visible = other._visible;
-            this._layerMapShared = other._layerMapShared;
-            this.color = other.color;
-            this.offset = other.offset;
-            this.rotation = other.rotation;
-            this.scale = other.scale;
-            this.drawDepth = other.drawDepth;
-            this.Layers = new List<Layer>(other.Layers.Count);
+            _baseRsi = other._baseRsi;
+            _directional = other._directional;
+            _visible = other._visible;
+            _layerMapShared = other._layerMapShared;
+            color = other.color;
+            offset = other.offset;
+            rotation = other.rotation;
+            scale = other.scale;
+            drawDepth = other.drawDepth;
+            _screenLock = other._screenLock;
+            _overrideDirection = other._overrideDirection;
+            _enableOverrideDirection = other._enableOverrideDirection;
+            Layers = new List<Layer>(other.Layers.Count);
             foreach (var otherLayer in other.Layers)
             {
-                this.Layers.Add(new Layer(otherLayer, this));
+                Layers.Add(new Layer(otherLayer, this));
             }
-            this.IsInert = other.IsInert;
-            this.LayerMap = other.LayerMap.ToDictionary(entry => entry.Key,
+            IsInert = other.IsInert;
+            LayerMap = other.LayerMap.ToDictionary(entry => entry.Key,
                 entry => entry.Value);
             if (other.PostShader != null)
             {
                 // only need to copy the shader if it's mutable
-                this.PostShader = other.PostShader.Mutable ? other.PostShader.Duplicate() : other.PostShader;
+                PostShader = other.PostShader.Mutable ? other.PostShader.Duplicate() : other.PostShader;
             }
             else
             {
-                this.PostShader = null;
+                PostShader = null;
             }
 
-            this.RenderOrder = other.RenderOrder;
+            RenderOrder = other.RenderOrder;
+        }
+
+        public Matrix3 GetLocalMatrix()
+        {
+            return Matrix3.CreateTransform(in offset, in rotation, in scale);
         }
 
         /// <inheritdoc />
@@ -974,40 +974,60 @@ namespace Robust.Client.GameObjects
         public ISpriteLayer this[object layerKey] => this[LayerMap[layerKey]];
         public IEnumerable<ISpriteLayer> AllLayers => Layers;
 
-        internal void Render(DrawingHandleWorld drawingHandle, in Matrix3 worldTransform, Angle worldRotation,
-            Direction? overrideDirection = null)
+        // Lobby SpriteView rendering path
+        internal void Render(DrawingHandleWorld drawingHandle, Angle worldRotation, Direction? overrideDirection = null)
         {
-            var angle = Rotation;
-            if (Directional)
+            RenderInternal(drawingHandle, worldRotation, Vector2.Zero, overrideDirection);
+        }
+
+        private bool _screenLock = false;
+        private Direction _overrideDirection = Direction.South;
+        private bool _enableOverrideDirection = false;
+
+        /// <inheritdoc />
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool NoRotation { get => _screenLock; set => _screenLock = value; }
+
+        /// <inheritdoc />
+        [ViewVariables(VVAccess.ReadWrite)]
+        public Direction DirectionOverride { get => _overrideDirection; set => _overrideDirection = value; }
+
+        /// <inheritdoc />
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool EnableDirectionOverride { get => _enableOverrideDirection; set => _enableOverrideDirection = value; }
+
+        // Sprite rendering path
+        internal void Render(DrawingHandleWorld drawingHandle, in Angle worldRotation, in Vector2 worldPosition)
+        {
+            Direction? overrideDir = null;
+            if (_enableOverrideDirection)
             {
-                angle -= worldRotation;
+                overrideDir = _overrideDirection;
+            }
+
+            RenderInternal(drawingHandle, worldRotation, worldPosition, overrideDir);
+        }
+
+        private void CalcModelMatrix(int numDirs, Angle worldRotation, Vector2 worldPosition, out Matrix3 modelMatrix)
+        {
+            Angle angle;
+
+            if (_screenLock)
+            {
+                angle = Angle.Zero;
             }
             else
             {
-                angle -= new Angle(MathHelper.PiOver2);
+                angle = CalcRectWorldAngle(worldRotation, numDirs);
             }
 
-            var mOffset = Matrix3.CreateTranslation(Offset);
-            var mRotation = Matrix3.CreateRotation(angle);
-            Matrix3.Multiply(ref mRotation, ref mOffset, out var transform);
-
-            // Only apply scale if needed.
-            if(!Scale.EqualsApprox(Vector2.One)) transform.Multiply(Matrix3.CreateScale(Scale));
-
-            transform.Multiply(worldTransform);
-
-            RenderInternal(drawingHandle, worldRotation, overrideDirection, transform);
+            var sWorldRotation = angle;
+            modelMatrix = Matrix3.CreateTransform(in worldPosition, in sWorldRotation);
         }
 
-        internal void Render(DrawingHandleWorld drawingHandle, Angle worldRotation, Direction? overrideDirection = null)
+        private void RenderInternal(DrawingHandleWorld drawingHandle, Angle worldRotation, Vector2 worldPosition, Direction? overrideDirection)
         {
-            RenderInternal(drawingHandle, worldRotation, overrideDirection, Matrix3.Identity);
-        }
-
-        private void RenderInternal(DrawingHandleWorld drawingHandle, Angle worldRotation, Direction? overrideDirection,
-            in Matrix3 transform)
-        {
-            drawingHandle.SetTransform(transform);
+            var localMatrix = GetLocalMatrix();
 
             foreach (var layer in Layers)
             {
@@ -1016,26 +1036,77 @@ namespace Robust.Client.GameObjects
                     continue;
                 }
 
-                // TODO: Implement layer-specific rotation and scale.
-                // Oh and when you do update Layer.LocalToLayer so content doesn't break.
+                var numDirs = GetLayerDirectionCount(layer);
 
-                var texture = GetRenderTexture(layer, worldRotation, overrideDirection);
+                CalcModelMatrix(numDirs, worldRotation, worldPosition, out var modelMatrix);
+                Matrix3.Multiply(ref localMatrix, ref modelMatrix, out var transformMatrix);
+                drawingHandle.SetTransform(in transformMatrix);
 
-                if (layer.Shader != null)
-                {
-                    drawingHandle.UseShader(layer.Shader);
-                }
-
-                drawingHandle.DrawTexture(texture, -(Vector2) texture.Size / (2f * EyeManager.PixelsPerMeter),
-                    color * layer.Color);
-
-                if (layer.Shader != null)
-                {
-                    drawingHandle.UseShader(null);
-                }
+                RenderLayer(drawingHandle, layer, worldRotation, overrideDirection);
             }
         }
 
+        private void RenderLayer(DrawingHandleWorld drawingHandle, Layer layer, Angle worldRotation, Direction? overrideDirection)
+        {
+            var texture = GetRenderTexture(layer, worldRotation, overrideDirection);
+
+            if (layer.Shader != null)
+            {
+                drawingHandle.UseShader(layer.Shader);
+            }
+
+            var layerColor = color * layer.Color;
+
+            var position = -(Vector2) texture.Size / (2f * EyeManager.PixelsPerMeter);
+            var textureSize = texture.Size / (float) EyeManager.PixelsPerMeter;
+            var quad = Box2.FromDimensions(position, textureSize);
+
+            // TODO: Implement layer-specific rotation and scale.
+            // Apply these directly to the box.
+            // Oh and when you do update Layer.LocalToLayer so content doesn't break.
+
+            // handle.Modulate changes the color
+            // drawingHandle.SetTransform() is set above, turning the quad into local space vertices
+            drawingHandle.DrawTextureRectRegion(texture, quad, layerColor);
+
+            if (layer.Shader != null)
+            {
+                drawingHandle.UseShader(null);
+            }
+        }
+
+        public static Angle CalcRectWorldAngle(Angle worldAngle, int numDirections)
+        {
+            var theta = worldAngle.Theta;
+            var segSize = (MathF.PI*2) / (numDirections * 2);
+            var segments = (int)(theta / segSize);
+            var odd = segments % 2;
+            var result = theta - (segments * segSize) - (odd * segSize);
+
+            return result;
+        }
+
+        public int GetLayerDirectionCount(ISpriteLayer layer)
+        {
+            if (!layer.RsiState.IsValid)
+                return 1;
+
+            // Pull texture from RSI state instead.
+            var rsi = layer.Rsi ?? BaseRSI;
+            if (rsi == null || !rsi.TryGetState(layer.RsiState, out var state))
+            {
+                state = GetFallbackState(resourceCache);
+            }
+
+            return state.Directions switch
+            {
+                RSI.State.DirectionType.Dir1 => 1,
+                RSI.State.DirectionType.Dir4 => 4,
+                RSI.State.DirectionType.Dir8 => 8,
+                _ => throw new ArgumentOutOfRangeException()
+            };
+        }
+
         private Texture GetRenderTexture(Layer layer, Angle worldRotation, Direction? overrideDirection)
         {
             var texture = layer.Texture;
@@ -1067,8 +1138,11 @@ namespace Robust.Client.GameObjects
             serializer.DataFieldCached(ref drawDepth, "drawdepth", DrawDepthTag.Default,
                 WithFormat.Constants<DrawDepthTag>());
             serializer.DataFieldCached(ref color, "color", Color.White);
-            serializer.DataFieldCached(ref _directional, "directional", true);
             serializer.DataFieldCached(ref _visible, "visible", true);
+            serializer.DataFieldCached(ref _directional, "directional", true); //TODO: Kill ME
+            serializer.DataFieldCached(ref _screenLock, "noRot", false);
+            serializer.DataFieldCached(ref _enableOverrideDirection, "enableOverrideDir", false);
+            serializer.DataFieldCached(ref _overrideDirection, "overrideDir", Direction.East);
 
             // TODO: Writing?
             if (!serializer.Reading)
@@ -1323,7 +1397,6 @@ namespace Robust.Client.GameObjects
             Rotation = thestate.Rotation;
             Offset = thestate.Offset;
             Color = thestate.Color;
-            Directional = thestate.Directional;
             RenderOrder = thestate.RenderOrder;
 
             if (thestate.BaseRsiPath != null && BaseRSI != null)
@@ -1380,16 +1453,28 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        private RSI.State.Direction GetDir(RSI.State.DirectionType type, Angle worldRotation)
+        private RSI.State.Direction GetDir(RSI.State.DirectionType rsiDirectionType, Angle worldRotation)
         {
-            if (!Directional)
-
+            var dir = rsiDirectionType switch
             {
-                return RSI.State.Direction.South;
-            }
+                RSI.State.DirectionType.Dir1 => Direction.South,
+                RSI.State.DirectionType.Dir4 => worldRotation.GetCardinalDir(),
+                RSI.State.DirectionType.Dir8 => worldRotation.GetDir(),
+                _ => throw new ArgumentException($"Unknown RSI DirectionType: {rsiDirectionType}.", nameof(rsiDirectionType))
+            };
 
-            var angle = new Angle(worldRotation);
-            return angle.GetDir().Convert(type);
+            return dir switch
+            {
+                Direction.North => RSI.State.Direction.North,
+                Direction.South => RSI.State.Direction.South,
+                Direction.East => RSI.State.Direction.East,
+                Direction.West => RSI.State.Direction.West,
+                Direction.SouthEast => RSI.State.Direction.SouthEast,
+                Direction.SouthWest => RSI.State.Direction.SouthWest,
+                Direction.NorthEast => RSI.State.Direction.NorthEast,
+                Direction.NorthWest => RSI.State.Direction.NorthWest,
+                _ => throw new ArgumentOutOfRangeException(nameof(dir), dir, null)
+            };
         }
 
         private void UpdateIsInert()

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

@@ -1,15 +1,13 @@
 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;
 
-namespace Robust.Client.GameObjects.Components.UserInterface
+namespace Robust.Client.GameObjects
 {
     public class ClientUserInterfaceComponent : SharedUserInterfaceComponent
     {

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;
 

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

@@ -2,23 +2,18 @@
 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.Utility;
 
-namespace Robust.Client.GameObjects.EntitySystems
+namespace Robust.Client.GameObjects
 {
     [UsedImplicitly]
     public class AudioSystem : EntitySystem

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...

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -1,9 +1,8 @@
 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
     {

Robust.Client/GameObjects/EntitySystems/EffectSystem.cs

@@ -1,25 +1,15 @@
 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;
 
 namespace Robust.Client.GameObjects

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
 

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/IClientEntityManager.cs

@@ -1,8 +1,7 @@
-using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.GameObjects;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using Robust.Shared.GameObjects;
 
-namespace Robust.Client.Interfaces.GameObjects
+namespace Robust.Client.GameObjects
 {
     public interface IClientEntityManager : IEntityManager
     {

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -1,12 +1,9 @@
 using System;
 using System.Collections.Generic;
-using Robust.Client.GameObjects.EntitySystems;
-using Robust.Client.Interfaces;
-using Robust.Client.Interfaces.GameObjects;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Input;
+using System.Diagnostics;
+using Robust.Client.GameObjects;
+using Robust.Client.Input;
 using Robust.Shared.GameStates;
-using Robust.Shared.Interfaces.Network;
 using Robust.Shared.IoC;
 using Robust.Shared.Network.Messages;
 using Robust.Client.Player;
@@ -14,11 +11,9 @@ using Robust.Shared;
 using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
-using Robust.Shared.Interfaces.Configuration;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Map;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.Log;
+using Robust.Shared.Map;
+using Robust.Shared.Network;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -358,7 +353,10 @@ namespace Robust.Client.GameStates
 
                 foreach (var component in _componentManager.GetNetComponents(createdEntity))
                 {
-                    var state = component.GetComponentState();
+                    Debug.Assert(_players.LocalPlayer != null, "_players.LocalPlayer != null");
+
+                    var player = _players.LocalPlayer.Session;
+                    var state = component.GetComponentState(player);
 
                     if (state.GetType() == typeof(ComponentState))
                     {

Robust.Client/GameStates/GameStateProcessor.cs

@@ -3,7 +3,6 @@ using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Robust.Shared.GameObjects;
 using Robust.Shared.GameStates;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.Log;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;

Robust.Client/GameStates/IClientGameStateManager.cs

@@ -1,10 +1,9 @@
 using System;
-using Robust.Client.GameStates;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
 using Robust.Shared.Timing;
 
-namespace Robust.Client.Interfaces.GameStates
+namespace Robust.Client.GameStates
 {
     /// <summary>
     ///     Engine service that provides processing and management of game states.

Robust.Client/GameStates/NetEntityOverlay.cs

@@ -1,20 +1,12 @@
 using System.Collections.Generic;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.Drawing;
-using Robust.Client.Graphics.Overlays;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.Graphics.Overlays;
-using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.ResourceManagement;
+using Robust.Shared.Configuration;
 using Robust.Shared.Console;
 using Robust.Shared.GameObjects;
-using Robust.Shared.Interfaces.Configuration;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
+using Robust.Shared.Network;
 using Robust.Shared.Timing;
 
 namespace Robust.Client.GameStates

Robust.Client/GameStates/NetGraphOverlay.cs

@@ -1,16 +1,10 @@
 using System.Collections.Generic;
 using Robust.Client.Graphics;
-using Robust.Client.Graphics.Drawing;
-using Robust.Client.Graphics.Overlays;
-using Robust.Client.Interfaces.GameStates;
-using Robust.Client.Interfaces.Graphics.Overlays;
-using Robust.Client.Interfaces.ResourceManagement;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Console;
-using Robust.Shared.Interfaces.Network;
-using Robust.Shared.Interfaces.Timing;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
+using Robust.Shared.Network;
 using Robust.Shared.Timing;
 
 namespace Robust.Client.GameStates

Robust.Client/GameStates/NetInterpOverlay.cs

@@ -1,16 +1,11 @@
-using Robust.Client.Graphics.Drawing;
-using Robust.Client.Graphics.Overlays;
-using Robust.Client.Graphics.Shaders;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Client.Interfaces.Graphics.Overlays;
+using Robust.Client.Graphics;
 using Robust.Shared.Console;
-using Robust.Shared.GameObjects.Components;
-using Robust.Shared.Interfaces.GameObjects;
-using Robust.Shared.Interfaces.Timing;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
 
 namespace Robust.Client.GameStates
 {

Robust.Client/Graphics/ClientEye/Eye.cs

@@ -1,11 +1,10 @@
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Shared.Map;
+using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.ViewVariables;
 
 #nullable enable
 
-namespace Robust.Client.Graphics.ClientEye
+namespace Robust.Client.Graphics
 {
     /// <inheritdoc />
     public class Eye : IEye

Robust.Client/Graphics/ClientEye/EyeManager.cs

@@ -1,13 +1,11 @@
-using Robust.Client.Interfaces.Graphics;
-using Robust.Client.Interfaces.Graphics.ClientEye;
-using Robust.Shared.Interfaces.GameObjects;
+using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 
 #nullable enable
 
-namespace Robust.Client.Graphics.ClientEye
+namespace Robust.Client.Graphics
 {
     /// <inheritdoc />
     public sealed class EyeManager : IEyeManager