Replace Lidgren encryption stuff with Libsodium (#2646)

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

.github/CODEOWNERS

@@ -11,7 +11,7 @@
 /Robust.Analyzers @PaulRitter
 /Robust.*/GameStates @PaulRitter
 /Robust.Shared/Analyzers @PaulRitter
-/Robust.*/Serialization @PaulRitter
+/Robust.*/Serialization @PaulRitter @DrSmugleaf
 /Robust.*/Prototypes @PaulRitter
 /Robust.Shared/GameObjects/ComponentDependencies @PaulRitter
 /Robust.*/Containers @PaulRitter

.github/workflows/benchmarks.yml

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

.github/workflows/build-docfx.yml

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

.github/workflows/build-test.yml

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

.gitignore

@@ -76,3 +76,5 @@ MSBuild/Robust.Custom.targets
 
 
 release/
+Robust.Docfx/*-site
+Robust.Docfx/api

MSBuild/Robust.Engine.Version.props

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

Robust.Analyzers/Robust.Analyzers.csproj

@@ -6,9 +6,9 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="3.8.0" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.2" PrivateAssets="all" />
-    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="3.8.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.0.1" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.3" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.Workspaces.Common" Version="4.0.1" />
   </ItemGroup>
 
 </Project>

Robust.Benchmarks/Configs/DefaultSQLConfig.cs

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

Robust.Benchmarks/EntityManager/AddRemoveComponentBenchmark.cs

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

Robust.Benchmarks/EntityManager/GetComponentBenchmark.cs

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

Robust.Benchmarks/EntityManager/SpawnDeleteEntityBenchmark.cs

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

Robust.Benchmarks/Exporters/SQLExporter.cs

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

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

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

Robust.Benchmarks/Migrations/20220328231938_InitialCreate.cs

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

Robust.Benchmarks/Migrations/BenchmarkContextModelSnapshot.cs

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

Robust.Benchmarks/NumericsHelpers/AddBenchmark.cs

@@ -9,6 +9,9 @@ namespace Robust.Benchmarks.NumericsHelpers
         [Params(32, 128)]
         public int N { get; set; }
 
+        [Params(1,2)]
+        public int T { get; set; }
+
         private float[] _inputA = default!;
         private float[] _inputB = default!;
         private float[] _output = default!;

Robust.Benchmarks/Program.cs

@@ -1,6 +1,8 @@
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Running;
 using System;
+using Robust.Benchmarks.Configs;
+using Robust.Benchmarks.Exporters;
 
 namespace Robust.Benchmarks
 {
@@ -16,7 +18,8 @@ namespace Robust.Benchmarks
             Console.WriteLine("THE DEBUG BUILD IS ONLY GOOD FOR FIXING A CRASHING BENCHMARK\n");
             BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, new DebugInProcessConfig());
 #else
-            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+            var config = Environment.GetEnvironmentVariable("ROBUST_BENCHMARKS_ENABLE_SQL") != null ? DefaultSQLConfig.Instance : null;
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
 #endif
         }
     }

Robust.Benchmarks/Robust.Benchmarks.csproj

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

Robust.Benchmarks/add-migration.ps1

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

Robust.Benchmarks/add-migration.sh

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

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

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

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

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

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -619,6 +619,7 @@ namespace Robust.Client.Audio.Midi
             var seqEv = (SequencerEvent) midiEvent;
             seqEv.Dest = _debugEvents ? _debugRegister : _synthRegister;
             _sequencer.SendAt(seqEv, time, absolute);
+            seqEv.Dispose();
         }
 
         public void Dispose()

Robust.Client/BaseClient.cs

@@ -26,7 +26,6 @@ namespace Robust.Client
         [Dependency] private readonly IPlayerManager _playMan = default!;
         [Dependency] private readonly INetConfigurationManager _configManager = default!;
         [Dependency] private readonly IClientEntityManager _entityManager = default!;
-        [Dependency] private readonly IEntityLookup _entityLookup = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IDiscordRichPresence _discord = default!;
         [Dependency] private readonly IGameTiming _timing = default!;
@@ -213,7 +212,6 @@ namespace Robust.Client
         {
             _entityManager.Startup();
             _mapManager.Startup();
-            _entityLookup.Startup();
 
             _timing.ResetSimTime();
             _timing.Paused = false;
@@ -224,7 +222,6 @@ namespace Robust.Client
             IoCManager.Resolve<INetConfigurationManager>().FlushMessages();
             _gameStates.Reset();
             _playMan.Shutdown();
-            _entityLookup.Shutdown();
             _entityManager.Shutdown();
             _mapManager.Shutdown();
             _discord.ClearPresence();

Robust.Client/ClientIoC.cs

@@ -47,7 +47,6 @@ namespace Robust.Client
             IoCManager.Register<IMapManagerInternal, NetworkedMapManager>();
             IoCManager.Register<INetworkedMapManager, NetworkedMapManager>();
             IoCManager.Register<IEntityManager, ClientEntityManager>();
-            IoCManager.Register<IEntityLookup, EntityLookup>();
             IoCManager.Register<IReflectionManager, ClientReflectionManager>();
             IoCManager.Register<IConsoleHost, ClientConsoleHost>();
             IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
@@ -72,7 +71,6 @@ namespace Robust.Client
             IoCManager.Register<IStateManager, StateManager>();
             IoCManager.Register<IUserInterfaceManager, UserInterfaceManager>();
             IoCManager.Register<IUserInterfaceManagerInternal, UserInterfaceManager>();
-            IoCManager.Register<IDebugDrawing, DebugDrawing>();
             IoCManager.Register<ILightManager, LightManager>();
             IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
             IoCManager.Register<IMidiManager, MidiManager>();

Robust.Client/Console/Commands/Debug.cs

@@ -168,7 +168,7 @@ namespace Robust.Client.Console.Commands
 
         public void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<IDebugDrawing>();
+            var mgr = EntitySystem.Get<DebugDrawingSystem>();
             mgr.DebugPositions = !mgr.DebugPositions;
         }
     }
@@ -861,7 +861,7 @@ namespace Robust.Client.Console.Commands
             var chunkIndex = grid.LocalToChunkIndices(grid.MapToGrid(mousePos));
             var chunk = internalGrid.GetChunk(chunkIndex);
 
-            shell.WriteLine($"worldBounds: {chunk.CalcWorldAABB()} localBounds: {chunk.CalcLocalBounds()}");
+            shell.WriteLine($"worldBounds: {internalGrid.CalcWorldAABB(chunk)} localBounds: {chunk.CachedBounds}");
         }
     }
 

Robust.Client/Debugging/DebugDrawingSystem.cs

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

Robust.Client/Debugging/IDebugDrawing.cs

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

Robust.Client/GameController/GameController.cs

@@ -50,7 +50,6 @@ namespace Robust.Client
         [Dependency] private readonly IClientConsoleHost _console = default!;
         [Dependency] private readonly ITimerManager _timerManager = default!;
         [Dependency] private readonly IClientEntityManager _entityManager = default!;
-        [Dependency] private readonly IEntityLookup _lookup = default!;
         [Dependency] private readonly IPlacementManager _placementManager = default!;
         [Dependency] private readonly IClientGameStateManager _gameStateManager = default!;
         [Dependency] private readonly IOverlayManagerInternal _overlayManager = default!;
@@ -471,7 +470,6 @@ namespace Robust.Client
                 // The last real tick is the current tick! This way we won't be in "prediction" mode.
                 _gameTiming.LastRealTick = _gameTiming.CurTick;
                 _entityManager.TickUpdate(frameEventArgs.DeltaSeconds, noPredictions: false);
-                _lookup.Update();
             }
 
             _modLoader.BroadcastUpdate(ModUpdateLevel.PostEngine, frameEventArgs);
@@ -576,7 +574,6 @@ namespace Robust.Client
 
             _networkManager.Shutdown("Client shutting down");
             _midiManager.Shutdown();
-            IoCManager.Resolve<IEntityLookup>().Shutdown();
             _entityManager.Shutdown();
             _clyde.Shutdown();
             _clydeAudio.Shutdown();

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -27,7 +27,6 @@ namespace Robust.Client.GameObjects
         public override void Initialize()
         {
             SetupNetworking();
-            ReceivedComponentMessage += (_, compMsg) => DispatchComponentMessage(compMsg);
             ReceivedSystemMessage += (_, systemMsg) => EventBus.RaiseEvent(EventSource.Network, systemMsg);
 
             base.Initialize();
@@ -52,9 +51,6 @@ namespace Robust.Client.GameObjects
 
         public override IEntityNetworkManager EntityNetManager => this;
 
-        /// <inheritdoc />
-        public event EventHandler<NetworkComponentMessage>? ReceivedComponentMessage;
-
         /// <inheritdoc />
         public event EventHandler<object>? ReceivedSystemMessage;
 
@@ -105,26 +101,6 @@ namespace Robust.Client.GameObjects
             throw new NotSupportedException();
         }
 
-        /// <inheritdoc />
-        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
-        public void SendComponentNetworkMessage(INetChannel? channel, EntityUid entity, IComponent component, ComponentMessage message)
-        {
-            var componentType = component.GetType();
-            var netId = ComponentFactory.GetRegistration(componentType).NetID;
-
-            if (!netId.HasValue)
-                throw new ArgumentException($"Component {componentType} does not have a NetID.", nameof(component));
-
-            var msg = _networkManager.CreateNetMessage<MsgEntity>();
-            msg.Type = EntityMessageType.ComponentMessage;
-            msg.EntityUid = entity;
-            msg.NetId = netId.Value;
-            msg.ComponentMessage = message;
-            msg.SourceTick = _gameTiming.CurTick;
-
-            _networkManager.ClientSendMessage(msg);
-        }
-
         private void HandleEntityNetworkMessage(MsgEntity message)
         {
             if (message.SourceTick <= _gameStateManager.CurServerTick)
@@ -143,10 +119,6 @@ namespace Robust.Client.GameObjects
         {
             switch (message.Type)
             {
-                case EntityMessageType.ComponentMessage:
-                    ReceivedComponentMessage?.Invoke(this, new NetworkComponentMessage(message));
-                    return;
-
                 case EntityMessageType.SystemMessage:
                     var msg = message.SystemMessage;
                     var sessionType = typeof(EntitySessionMessage<>).MakeGenericType(msg.GetType());

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

@@ -8,7 +8,7 @@ using Robust.Shared.ViewVariables;
 namespace Robust.Client.GameObjects
 {
     [ComponentReference(typeof(OccluderComponent))]
-    internal sealed class ClientOccluderComponent : OccluderComponent
+    public sealed class ClientOccluderComponent : OccluderComponent
     {
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
@@ -71,13 +71,29 @@ namespace Robust.Client.GameObjects
         {
             Occluding = OccluderDir.None;
 
-            if (Deleted || !_entityManager.GetComponent<TransformComponent>(Owner).Anchored)
+            if (Deleted)
+                return;
+
+            // Content may want to override the default behavior for occlusion.
+            var xform = _entityManager.GetComponent<TransformComponent>(Owner);
+            var ev = new OccluderDirectionsEvent
             {
+                Component = xform,
+            };
+
+            _entityManager.EventBus.RaiseLocalEvent(Owner, ref ev);
+
+            if (ev.Handled)
+            {
+                Occluding = ev.Directions;
                 return;
             }
 
-            var grid = _mapManager.GetGrid(_entityManager.GetComponent<TransformComponent>(Owner).GridID);
-            var position = _entityManager.GetComponent<TransformComponent>(Owner).Coordinates;
+            if (!xform.Anchored)
+                return;
+
+            var grid = _mapManager.GetGrid(xform.GridID);
+            var position = xform.Coordinates;
             void CheckDir(Direction dir, OccluderDir oclDir)
             {
                 foreach (var neighbor in grid.GetInDir(position, dir))
@@ -90,7 +106,7 @@ namespace Robust.Client.GameObjects
                 }
             }
 
-            var angle = _entityManager.GetComponent<TransformComponent>(Owner).LocalRotation;
+            var angle = xform.LocalRotation;
             var dirRolling = angle.GetCardinalDir();
             // dirRolling starts at effective south
 
@@ -105,15 +121,28 @@ namespace Robust.Client.GameObjects
 
             CheckDir(dirRolling, OccluderDir.East);
         }
+    }
 
-        [Flags]
-        internal enum OccluderDir : byte
-        {
-            None = 0,
-            North = 1,
-            East = 1 << 1,
-            South = 1 << 2,
-            West = 1 << 3,
-        }
+    [Flags]
+    public enum OccluderDir : byte
+    {
+        None = 0,
+        North = 1,
+        East = 1 << 1,
+        South = 1 << 2,
+        West = 1 << 3,
+    }
+
+    /// <summary>
+    /// Raised by occluders when trying to get occlusion directions.
+    /// </summary>
+    [ByRefEvent]
+    public struct OccluderDirectionsEvent
+    {
+        public bool Handled = false;
+        public OccluderDir Directions = OccluderDir.None;
+        public TransformComponent Component = default!;
+
+        public OccluderDirectionsEvent() {}
     }
 }

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

@@ -25,6 +25,8 @@ namespace Robust.Client.GameObjects
         [Animatable]
         Vector2 Scale { get; set; }
 
+        Box2 Bounds { get; }
+
         /// <summary>
         ///     A rotation applied to all layers.
         /// </summary>

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

@@ -35,6 +35,6 @@ namespace Robust.Client.GameObjects
         ///     Calculate layer bounding box in sprite local-space coordinates.
         /// </summary>
         /// <returns>Bounding box in sprite local-space coordinates.</returns>
-        Box2 CalculateBoundingBox(Angle worldAngle);
+        Box2 CalculateBoundingBox();
     }
 }

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

@@ -19,6 +19,7 @@ using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
+using TerraFX.Interop.Windows;
 using DrawDepthTag = Robust.Shared.GameObjects.DrawDepth;
 using RSIDirection = Robust.Client.Graphics.RSI.State.Direction;
 
@@ -75,7 +76,7 @@ namespace Robust.Client.GameObjects
         public Vector2 Scale
         {
             get => scale;
-            set 
+            set
             {
                 scale = value;
                 UpdateLocalMatrix();
@@ -217,6 +218,10 @@ namespace Robust.Client.GameObjects
 
         private bool _containerOccluded;
 
+        private Box2 _bounds;
+
+        public Box2 Bounds => _bounds;
+
         [ViewVariables(VVAccess.ReadWrite)]
         public bool TreeUpdateQueued { get; set; }
 
@@ -299,6 +304,7 @@ namespace Robust.Client.GameObjects
         {
             //deep copying things to avoid entanglement
             _baseRsi = other._baseRsi;
+            _bounds = other._bounds;
             _visible = other._visible;
             _layerMapShared = other._layerMapShared;
             color = other.color;
@@ -548,6 +554,7 @@ namespace Robust.Client.GameObjects
                 index = Layers.Count - 1;
             }
 
+            RebuildBounds();
             QueueUpdateIsInert();
             return index;
         }
@@ -575,6 +582,7 @@ namespace Robust.Client.GameObjects
                 }
             }
 
+            RebuildBounds();
             QueueUpdateIsInert();
         }
 
@@ -590,6 +598,15 @@ namespace Robust.Client.GameObjects
             RemoveLayer(layer);
         }
 
+        private void RebuildBounds()
+        {
+            _bounds = new Box2();
+            foreach (var layer in Layers.Where(layer => layer.Visible))
+            {
+                _bounds = _bounds.Union(layer.CalculateBoundingBox());
+            }
+        }
+
         /// <summary>
         ///     Fills in a layer's values using some <see cref="PrototypeLayerData"/>.
         /// </summary>
@@ -713,6 +730,8 @@ namespace Robust.Client.GameObjects
 
             // If neither state: nor texture: were provided we assume that they want a blank invisible layer.
             layer.Visible = anyTextureAttempted && layerDatum.Visible;
+
+            RebuildBounds();
         }
 
         public void LayerSetData(object layerKey, PrototypeLayerData data)
@@ -799,6 +818,8 @@ namespace Robust.Client.GameObjects
                 default:
                     throw new NotImplementedException();
             }
+
+            RebuildBounds();
         }
 
         public void LayerSetSprite(object layerKey, SpriteSpecifier specifier)
@@ -824,6 +845,7 @@ namespace Robust.Client.GameObjects
 
             var theLayer = Layers[layer];
             theLayer.SetTexture(texture);
+            RebuildBounds();
         }
 
         public void LayerSetTexture(object layerKey, Texture texture)
@@ -889,6 +911,7 @@ namespace Robust.Client.GameObjects
 
             var theLayer = Layers[layer];
             theLayer.SetState(stateId);
+            RebuildBounds();
         }
 
         public void LayerSetState(object layerKey, RSI.StateId stateId)
@@ -936,6 +959,8 @@ namespace Robust.Client.GameObjects
                     theLayer.Texture = null;
                 }
             }
+
+            RebuildBounds();
         }
 
         public void LayerSetState(object layerKey, RSI.StateId stateId, RSI rsi)
@@ -993,6 +1018,7 @@ namespace Robust.Client.GameObjects
 
             var theLayer = Layers[layer];
             theLayer.SetRsi(rsi);
+            RebuildBounds();
         }
 
         public void LayerSetRSI(object layerKey, RSI rsi)
@@ -1050,6 +1076,7 @@ namespace Robust.Client.GameObjects
 
             var theLayer = Layers[layer];
             theLayer.Scale = scale;
+            RebuildBounds();
         }
 
         public void LayerSetScale(object layerKey, Vector2 scale)
@@ -1076,6 +1103,7 @@ namespace Robust.Client.GameObjects
 
             var theLayer = Layers[layer];
             theLayer.Rotation = rotation;
+            RebuildBounds();
         }
 
         public void LayerSetRotation(object layerKey, Angle rotation)
@@ -1125,6 +1153,8 @@ namespace Robust.Client.GameObjects
 
             var theLayer = Layers[layer];
             theLayer.Color = color;
+
+            RebuildBounds();
         }
 
         public void LayerSetColor(object layerKey, Color color)
@@ -1150,6 +1180,8 @@ namespace Robust.Client.GameObjects
 
             var theLayer = Layers[layer];
             theLayer.DirOffset = offset;
+
+            RebuildBounds();
         }
 
         public void LayerSetDirOffset(object layerKey, DirectionOffset offset)
@@ -1201,6 +1233,8 @@ namespace Robust.Client.GameObjects
             }
 
             Layers[layer].SetAutoAnimated(autoAnimated);
+
+            RebuildBounds();
         }
 
         public void LayerSetAutoAnimated(object layerKey, bool autoAnimated)
@@ -1226,6 +1260,8 @@ namespace Robust.Client.GameObjects
             }
 
             Layers[layer].Offset = layerOffset;
+
+            RebuildBounds();
         }
 
         public void LayerSetOffset(object layerKey, Vector2 layerOffset)
@@ -1536,24 +1572,10 @@ namespace Robust.Client.GameObjects
 
             eye ??= eyeManager.CurrentEye;
 
-            // Need relative angle on screen for determining the sprite rsi direction.
-            Angle relativeRotation = NoRotation
-                ? Angle.Zero
-                : worldRotation + eye.Rotation; 
-
             // we need to calculate bounding box taking into account all nested layers
             // because layers can have offsets, scale or rotation, we need to calculate a new BB
             // based on lowest bottomLeft and highest topRight points from all layers
-            var box = Layers[0].CalculateBoundingBox(relativeRotation);
-
-            for (int i = 1; i < Layers.Count; i++)
-            {
-                var layer = Layers[i];
-                if (!layer.Visible) continue;
-                var layerBB = layer.CalculateBoundingBox(relativeRotation);
-
-                box = box.Union(layerBB);
-            }
+            var box = Bounds;
 
             // Next, what we do is take the box2 and apply the sprite's transform, and then the entity's transform. We
             // could do this via Matrix3.TransformBox, but that only yields bounding boxes. So instead we manually
@@ -1849,6 +1871,7 @@ namespace Robust.Client.GameObjects
                 Visible = value;
 
                 _parent.QueueUpdateIsInert();
+                _parent.RebuildBounds();
             }
 
             public void SetRsi(RSI? rsi)
@@ -1874,7 +1897,7 @@ namespace Robust.Client.GameObjects
                     }
                     else
                     {
-                        Logger.ErrorS(LogCategory, "State '{0}' does not exist in set RSI. Trace:\n{1}", State,
+                        Logger.ErrorS(LogCategory, "State '{0}' does not exist in set RSI ({1}). Trace:\n{2}", State, rsi?.Path?.ToString() ?? "null",
                             Environment.StackTrace);
                         Texture = null;
                     }
@@ -1943,39 +1966,40 @@ namespace Robust.Client.GameObjects
             }
 
             /// <inheritdoc/>
-            public Box2 CalculateBoundingBox(Angle angle)
+            public Box2 CalculateBoundingBox()
             {
-                // Other than some special cases for simple layers, this will basically just apply the matrix obtained
-                // via GetLayerDrawMatrix() to this layer's bounding box.
+                var textureSize = PixelSize / EyeManager.PixelsPerMeter;
+
+                // If the parent has locked rotation and we don't have any rotation,
+                // we can take the quick path of just making a box the size of the texture.
+                if (_parent.NoRotation && _rotation != 0)
+                {
+                    return Box2.CenteredAround(Offset, textureSize).Scale(_scale);
+                }
 
                 var rsiState = GetActualState();
 
-                var dir = (rsiState == null || rsiState.Directions == RSI.State.DirectionType.Dir1)
-                    ? RSIDirection.South
-                    : angle.ToRsiDirection(rsiState.Directions);
+                var longestSide = MathF.Max(textureSize.X, textureSize.Y);
+                var longestRotatedSide = Math.Max(longestSide, (textureSize.X + textureSize.Y) / MathF.Sqrt(2));
 
-                // special case for simple layers. The vast majority of layers are like this.
-                if (_rotation == Angle.Zero)
+                // Build the bounding box based on how many directions the sprite has
+                var box = (_rotation != 0, rsiState) switch
                 {
-                    var textureSize = PixelSize / EyeManager.PixelsPerMeter;
+                    // If this layer has any form of arbitrary rotation, return a bounding box big enough to cover
+                    // any possible rotation.
+                    (true, _) => Box2.CenteredAround(Offset, new Vector2(longestRotatedSide, longestRotatedSide)),
 
-                    // this switch block is basically an explicit version of the `rsiDirectionMatrix` in `GetLayerDrawMatrix()`.
-                    var box = dir switch
-                    {
-                        // No rotation:
-                        RSIDirection.South or RSIDirection.North => Box2.CenteredAround(Offset, textureSize),
-                        // rotate 90 degrees:
-                        RSIDirection.East or RSIDirection.West => Box2.CenteredAround(Offset, (textureSize.Y, textureSize.X)),
-                        // rotated 45 degrees (any 45 degree rotated rectangle has a square bounding box with sides of length (x+y)/sqrt(2) )
-                        _ => Box2.CenteredAround(Offset, Vector2.One * (textureSize.X + textureSize.Y) / MathF.Sqrt(2)) 
-                    };
-
-                    return _scale == Vector2.One ? box : box.Scale(_scale);
-                }
-
-                // Welp we have some non-zero _rotation, so lets just apply the generalized layer transform and get the bounding box from where;
-                GetLayerDrawMatrix(dir, out var layerDrawMatrix);
-                return layerDrawMatrix.TransformBox(Box2.CentredAroundZero(PixelSize / EyeManager.PixelsPerMeter));
+                    // Otherwise...
+                    // If we have only one direction or an invalid RSI state, create a simple bounding box with the size of the texture.
+                    (_, {Directions: RSI.State.DirectionType.Dir1} or null) => Box2.CenteredAround(Offset, textureSize),
+                    // If we have four cardinal directions, take the longest side of our texture and square it, then turn that into our bounding box.
+                    // This accounts for all possible rotations.
+                    (_, {Directions: RSI.State.DirectionType.Dir4}) => Box2.CenteredAround(Offset, new Vector2(longestSide, longestSide)),
+                    // If we have eight directions, find the maximum length of the texture (accounting for rotation), then square it to make
+                    // our bounding box.
+                    (_, {Directions: RSI.State.DirectionType.Dir8}) => Box2.CenteredAround(Offset, new Vector2(longestRotatedSide, longestRotatedSide)),
+                };
+                return _scale == Vector2.One ? box : box.Scale(_scale);
             }
 
             internal RSI.State? GetActualState()
@@ -1999,15 +2023,27 @@ namespace Robust.Client.GameObjects
             /// </summary>
             public void GetLayerDrawMatrix(RSIDirection dir, out Matrix3 layerDrawMatrix)
             {
-                if (_parent.NoRotation)
+                if (_parent.NoRotation || dir == RSIDirection.South)
                     layerDrawMatrix = LocalMatrix;
                 else
                 {
-                    var rsiDirectionMatrix = Matrix3.CreateTransform(Vector2.Zero, -dir.Convert().ToAngle());
-                    Matrix3.Multiply(ref rsiDirectionMatrix, ref LocalMatrix, out layerDrawMatrix);
+                    Matrix3.Multiply(ref _rsiDirectionMatrices[(int)dir], ref LocalMatrix, out layerDrawMatrix);
                 }
             }
 
+            private static Matrix3[] _rsiDirectionMatrices = new Matrix3[]
+            {
+                // array order chosen such that this array can be indexed by casing an RSI direction to an int
+                Matrix3.Identity, // should probably just avoid matrix multiplication altogether if the direction is south.
+                Matrix3.CreateRotation(-Direction.North.ToAngle()),
+                Matrix3.CreateRotation(-Direction.East.ToAngle()),
+                Matrix3.CreateRotation(-Direction.West.ToAngle()),
+                Matrix3.CreateRotation(-Direction.SouthEast.ToAngle()),
+                Matrix3.CreateRotation(-Direction.SouthWest.ToAngle()),
+                Matrix3.CreateRotation(-Direction.NorthEast.ToAngle()),
+                Matrix3.CreateRotation(-Direction.NorthWest.ToAngle())
+            };
+
             internal void Render(DrawingHandleWorld drawingHandle, ref Matrix3 spriteMatrix, Angle angle, Direction? overrideDirection)
             {
                 if (!Visible)

Robust.Client/GameObjects/EntitySystems/DebugLightTreeSystem.cs

@@ -25,7 +25,7 @@ namespace Robust.Client.GameObjects
                 if (_enabled)
                 {
                     _lightOverlay = new DebugLightOverlay(
-                        IoCManager.Resolve<IEntityLookup>(),
+                        EntitySystem.Get<EntityLookupSystem>(),
                         IoCManager.Resolve<IEyeManager>(),
                         IoCManager.Resolve<IMapManager>(),
                         Get<RenderingTreeSystem>());
@@ -44,7 +44,7 @@ namespace Robust.Client.GameObjects
 
         private sealed class DebugLightOverlay : Overlay
         {
-            private IEntityLookup _lookup;
+            private EntityLookupSystem _lookup;
             private IEyeManager _eyeManager;
             private IMapManager _mapManager;
 
@@ -52,7 +52,7 @@ namespace Robust.Client.GameObjects
 
             public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-            public DebugLightOverlay(IEntityLookup lookup, IEyeManager eyeManager, IMapManager mapManager, RenderingTreeSystem tree)
+            public DebugLightOverlay(EntityLookupSystem lookup, IEyeManager eyeManager, IMapManager mapManager, RenderingTreeSystem tree)
             {
                 _lookup = lookup;
                 _eyeManager = eyeManager;
@@ -72,7 +72,7 @@ namespace Robust.Client.GameObjects
                 {
                     foreach (var light in tree.LightTree)
                     {
-                        var aabb = _lookup.GetWorldAabbFromEntity(light.Owner);
+                        var aabb = _lookup.GetWorldAABB(light.Owner);
                         if (!aabb.Intersects(worldBounds)) continue;
 
                         args.WorldHandle.DrawRect(aabb, Color.Green.WithAlpha(0.1f));

Robust.Client/GameObjects/EntitySystems/EffectSystem.cs

@@ -342,7 +342,6 @@ namespace Robust.Client.GameObjects
                 var map = _owner.eyeManager.CurrentMap;
 
                 var worldHandle = args.WorldHandle;
-                ShaderInstance? currentShader = null;
 
                 if (_playerManager.LocalPlayer?.ControlledEntity is not {} playerEnt)
                     return;
@@ -362,13 +361,8 @@ namespace Robust.Client.GameObjects
                         continue;
                     }
 
-                    var newShader = effect.Shaded ? null : _unshadedShader;
-
-                    if (newShader != currentShader)
-                    {
-                        worldHandle.UseShader(newShader);
-                        currentShader = newShader;
-                    }
+                    if (!effect.Shaded)
+                        worldHandle.UseShader(_unshadedShader);
 
                     // TODO: Should be doing matrix transformations
                     var effectSprite = effect.EffectSprite;
@@ -377,6 +371,9 @@ namespace Robust.Client.GameObjects
                         (attachedXform?.Coordinates ?? effect.Coordinates)
                         .Offset(effect.AttachedOffset);
 
+                    // If we've never seen the entity before then can't resolve coordinates.
+                    if (!coordinates.IsValid(_entityManager)) continue;
+
                     // ???
                     var rotation = attachedXform?.WorldRotation ?? _entityManager.GetComponent<TransformComponent>(coordinates.EntityId).WorldRotation;
 
@@ -386,6 +383,9 @@ namespace Robust.Client.GameObjects
                     var rotatedBox = new Box2Rotated(effectArea, effect.Rotation + rotation, effectOrigin);
 
                     worldHandle.DrawTextureRect(effectSprite, rotatedBox, ToColor(effect.Color));
+
+                    if (!effect.Shaded)
+                        worldHandle.UseShader(null);
                 }
             }
         }

Robust.Client/GameObjects/EntitySystems/GridRenderingSystem.cs

@@ -0,0 +1,19 @@
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.GameObjects;
+
+internal class GridRenderingSystem : EntitySystem
+{
+    private readonly IClydeInternal _clyde;
+
+    public GridRenderingSystem(IClydeInternal clyde)
+    {
+        _clyde = clyde;
+    }
+
+    public override void Initialize()
+    {
+        _clyde.RegisterGridEcsEvents();
+    }
+}

Robust.Client/GameObjects/EntitySystems/RenderingTreeSystem.cs

@@ -70,18 +70,17 @@ namespace Robust.Client.GameObjects
             UpdatesAfter.Add(typeof(TransformSystem));
             UpdatesAfter.Add(typeof(PhysicsSystem));
 
-            _mapManager.MapCreated += MapManagerOnMapCreated;
-            _mapManager.OnGridCreated += MapManagerOnGridCreated;
+            SubscribeLocalEvent<MapChangedEvent>(MapManagerOnMapCreated);
+
+            SubscribeLocalEvent<GridInitializeEvent>(MapManagerOnGridCreated);
 
             // Due to how recursion works, this must be done.
             SubscribeLocalEvent<MoveEvent>(AnythingMoved);
 
-            SubscribeLocalEvent<SpriteComponent, EntMapIdChangedMessage>(SpriteMapChanged);
             SubscribeLocalEvent<SpriteComponent, EntParentChangedMessage>(SpriteParentChanged);
             SubscribeLocalEvent<SpriteComponent, ComponentRemove>(RemoveSprite);
             SubscribeLocalEvent<SpriteComponent, SpriteUpdateEvent>(HandleSpriteUpdate);
 
-            SubscribeLocalEvent<PointLightComponent, EntMapIdChangedMessage>(LightMapChanged);
             SubscribeLocalEvent<PointLightComponent, EntParentChangedMessage>(LightParentChanged);
             SubscribeLocalEvent<PointLightComponent, PointLightRadiusChangedEvent>(PointLightRadiusChanged);
             SubscribeLocalEvent<PointLightComponent, PointLightUpdateEvent>(HandleLightUpdate);
@@ -155,10 +154,6 @@ namespace Robust.Client.GameObjects
         // Otherwise these will still have their past MapId and that's all we need..
 
         #region SpriteHandlers
-        private void SpriteMapChanged(EntityUid uid, SpriteComponent component, EntMapIdChangedMessage args)
-        {
-            QueueSpriteUpdate(component);
-        }
 
         private void SpriteParentChanged(EntityUid uid, SpriteComponent component, ref EntParentChangedMessage args)
         {
@@ -188,10 +183,6 @@ namespace Robust.Client.GameObjects
         #endregion
 
         #region LightHandlers
-        private void LightMapChanged(EntityUid uid, PointLightComponent component, EntMapIdChangedMessage args)
-        {
-            QueueLightUpdate(component);
-        }
 
         private void LightParentChanged(EntityUid uid, PointLightComponent component, ref EntParentChangedMessage args)
         {
@@ -220,13 +211,6 @@ namespace Robust.Client.GameObjects
         }
         #endregion
 
-        public override void Shutdown()
-        {
-            base.Shutdown();
-            _mapManager.MapCreated -= MapManagerOnMapCreated;
-            _mapManager.OnGridCreated -= MapManagerOnGridCreated;
-        }
-
         private void OnTreeRemove(EntityUid uid, RenderingTreeComponent component, ComponentRemove args)
         {
             foreach (var sprite in component.SpriteTree)
@@ -243,9 +227,9 @@ namespace Robust.Client.GameObjects
             component.LightTree.Clear();
         }
 
-        private void MapManagerOnMapCreated(object? sender, MapEventArgs e)
+        private void MapManagerOnMapCreated(MapChangedEvent e)
         {
-            if (e.Map == MapId.Nullspace)
+            if (e.Destroyed || e.Map == MapId.Nullspace)
             {
                 return;
             }
@@ -253,9 +237,9 @@ namespace Robust.Client.GameObjects
             EntityManager.EnsureComponent<RenderingTreeComponent>(_mapManager.GetMapEntityId(e.Map));
         }
 
-        private void MapManagerOnGridCreated(MapId mapId, GridId gridId)
+        private void MapManagerOnGridCreated(GridInitializeEvent ev)
         {
-            EntityManager.EnsureComponent<RenderingTreeComponent>(_mapManager.GetGrid(gridId).GridEntityId);
+            EntityManager.EnsureComponent<RenderingTreeComponent>(_mapManager.GetGrid(ev.GridId).GridEntityId);
         }
 
         private RenderingTreeComponent? GetRenderTree(EntityUid entity, EntityQuery<TransformComponent> xforms)

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -45,7 +45,6 @@ namespace Robust.Client.GameStates
 
         [Dependency] private readonly IComponentFactory _compFactory = default!;
         [Dependency] private readonly IClientEntityManagerInternal _entities = default!;
-        [Dependency] private readonly IEntityLookup _lookup = default!;
         [Dependency] private readonly IPlayerManager _players = default!;
         [Dependency] private readonly IClientNetManager _network = default!;
         [Dependency] private readonly IBaseClient _client = default!;
@@ -332,8 +331,6 @@ namespace Robust.Client.GameStates
             }
 
             _entities.TickUpdate((float) _timing.TickPeriod.TotalSeconds, noPredictions: !IsPredictionEnabled);
-
-            _lookup.Update();
         }
 
         private void ResetPredictedEntities(GameTick curTick)
@@ -350,9 +347,7 @@ namespace Robust.Client.GameStates
 
                 // Check log level first to avoid the string alloc.
                 if (_sawmill.Level <= LogLevel.Debug)
-                {
                     _sawmill.Debug($"Entity {entity} was made dirty.");
-                }
 
                 if (!_processor.TryGetLastServerStates(entity, out var last))
                 {
@@ -370,7 +365,9 @@ namespace Robust.Client.GameStates
                         continue;
                     }
 
-                    _sawmill.Debug($"  And also its component {comp.GetType()}");
+                    if (_sawmill.Level <= LogLevel.Debug)
+                        _sawmill.Debug($"  And also its component {comp.GetType()}");
+
                     // TODO: Handle interpolation.
                     var handleState = new ComponentHandleState(compState, null);
                     _entities.EventBus.RaiseComponentEvent(comp, ref handleState);
@@ -424,7 +421,6 @@ namespace Robust.Client.GameStates
             var createdEntities = ApplyEntityStates(curState.EntityStates.Span, curState.EntityDeletions.Span,
                 nextState != null ? nextState.EntityStates.Span : default);
             _players.ApplyPlayerStates(curState.PlayerStates.Value ?? Array.Empty<PlayerState>());
-            _mapManager.ApplyGameStatePost(curState.MapData);
 
             GameStateApplied?.Invoke(new GameStateAppliedArgs(curState));
             return createdEntities;

Robust.Client/Graphics/Audio/ClydeAudio.AudioSources.cs

@@ -15,6 +15,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Audio;
 using Robust.Shared.Log;
 using Vector2 = Robust.Shared.Maths.Vector2;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.Graphics.Audio
 {
@@ -193,8 +194,10 @@ namespace Robust.Client.Graphics.Audio
                 {
                     _didPositionWarning = true;
                     Logger.WarningS("clyde.oal",
-                        "Attempting to set position on audio source with multiple audio channels! Stream: '{0}'",
+                        "Attempting to set position on audio source with multiple audio channels! Stream: '{0}'.  Make sure the audio is MONO, not stereo.",
                         _sourceStream.Name);
+                    // warning isn't enough, people just ignore it :(
+                    DebugTools.Assert(false, $"Attempting to set position on audio source with multiple audio channels! Stream: '{_sourceStream.Name}'. Make sure the audio is MONO, not stereo.");
                 }
 #endif
 

Robust.Client/Graphics/Clyde/Clyde.GridRendering.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Buffers;
 using System.Collections.Generic;
-using System.Diagnostics;
 using OpenToolkit.Graphics.OpenGL4;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
@@ -18,8 +16,8 @@ namespace Robust.Client.Graphics.Clyde
         private readonly Dictionary<GridId, Dictionary<Vector2i, MapChunkData>> _mapChunkData =
             new();
 
-        private int _verticesPerChunk(IMapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * 4;
-        private int _indicesPerChunk(IMapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * GetQuadBatchIndexCount();
+        private int _verticesPerChunk(MapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * 4;
+        private int _indicesPerChunk(MapChunk chunk) => chunk.ChunkSize * chunk.ChunkSize * GetQuadBatchIndexCount();
 
         private void _drawGrids(Viewport viewport, Box2Rotated worldBounds, IEye eye)
         {
@@ -78,7 +76,7 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        private void _updateChunkMesh(IMapGrid grid, IMapChunk chunk)
+        private void _updateChunkMesh(IMapGrid grid, MapChunk chunk)
         {
             var data = _mapChunkData[grid.Index];
 
@@ -91,25 +89,41 @@ namespace Robust.Client.Graphics.Clyde
             Span<Vertex2D> vertexBuffer = stackalloc Vertex2D[_verticesPerChunk(chunk)];
 
             var i = 0;
-            foreach (var tile in chunk)
+            var cSz = grid.ChunkSize;
+            var cScaled = chunk.Indices * cSz;
+            for (ushort x = 0; x < cSz; x++)
             {
-                var regionMaybe = _tileDefinitionManager.TileAtlasRegion(tile.Tile);
-                if (regionMaybe == null)
+                for (ushort y = 0; y < cSz; y++)
                 {
-                    continue;
+                    var tile = chunk.GetTile(x, y);
+                    if (tile.IsEmpty)
+                        continue;
+
+                    var regionMaybe = _tileDefinitionManager.TileAtlasRegion(tile);
+
+                    Box2 region;
+                    if (regionMaybe == null || regionMaybe.Length <= tile.Variant)
+                    {
+                        region = _tileDefinitionManager.ErrorTileRegion;
+                    }
+                    else
+                    {
+                        region = regionMaybe[tile.Variant];
+                    }
+
+                    var gx = x + cScaled.X;
+                    var gy = y + cScaled.Y;
+
+                    var vIdx = i * 4;
+                    vertexBuffer[vIdx + 0] = new Vertex2D(gx, gy, region.Left, region.Bottom);
+                    vertexBuffer[vIdx + 1] = new Vertex2D(gx + 1, gy, region.Right, region.Bottom);
+                    vertexBuffer[vIdx + 2] = new Vertex2D(gx + 1, gy + 1, region.Right, region.Top);
+                    vertexBuffer[vIdx + 3] = new Vertex2D(gx, gy + 1, region.Left, region.Top);
+                    var nIdx = i * GetQuadBatchIndexCount();
+                    var tIdx = (ushort)(i * 4);
+                    QuadBatchIndexWrite(indexBuffer, ref nIdx, tIdx);
+                    i += 1;
                 }
-
-                var region = regionMaybe.Value;
-
-                var vIdx = i * 4;
-                vertexBuffer[vIdx + 0] = new Vertex2D(tile.X, tile.Y, region.Left, region.Bottom);
-                vertexBuffer[vIdx + 1] = new Vertex2D(tile.X + 1, tile.Y, region.Right, region.Bottom);
-                vertexBuffer[vIdx + 2] = new Vertex2D(tile.X + 1, tile.Y + 1, region.Right, region.Top);
-                vertexBuffer[vIdx + 3] = new Vertex2D(tile.X, tile.Y + 1, region.Left, region.Top);
-                var nIdx = i * GetQuadBatchIndexCount();
-                var tIdx = (ushort) (i * 4);
-                QuadBatchIndexWrite(indexBuffer, ref nIdx, tIdx);
-                i += 1;
             }
 
             GL.BindVertexArray(datum.VAO);
@@ -122,7 +136,7 @@ namespace Robust.Client.Graphics.Clyde
             datum.TileCount = i;
         }
 
-        private MapChunkData _initChunkBuffers(IMapGrid grid, IMapChunk chunk)
+        private MapChunkData _initChunkBuffers(IMapGrid grid, MapChunk chunk)
         {
             var vao = GenVertexArray();
             BindVertexArray(vao);
@@ -159,7 +173,7 @@ namespace Robust.Client.Graphics.Clyde
             return datum;
         }
 
-        private bool _isChunkDirty(IMapGrid grid, IMapChunk chunk)
+        private bool _isChunkDirty(IMapGrid grid, MapChunk chunk)
         {
             var data = _mapChunkData[grid.Index];
             return !data.TryGetValue(chunk.Indices, out var datum) || datum.Dirty;
@@ -175,7 +189,7 @@ namespace Robust.Client.Graphics.Clyde
             // Don't need to set it if we don't have an entry since lack of an entry is treated as dirty.
         }
 
-        private void _updateOnGridModified(object? sender, GridChangedEventArgs args)
+        private void _updateOnGridModified(GridModifiedEvent args)
         {
             foreach (var (pos, _) in args.Modified)
             {
@@ -185,21 +199,23 @@ namespace Robust.Client.Graphics.Clyde
             }
         }
 
-        private void _updateTileMapOnUpdate(object? sender, TileChangedEventArgs args)
+        private void _updateTileMapOnUpdate(TileChangedEvent args)
         {
             var grid = _mapManager.GetGrid(args.NewTile.GridIndex);
             var chunk = grid.GridTileToChunkIndices(new Vector2i(args.NewTile.X, args.NewTile.Y));
             _setChunkDirty(grid, chunk);
         }
 
-        private void _updateOnGridCreated(MapId mapId, GridId gridId)
+        private void _updateOnGridCreated(GridStartupEvent ev)
         {
+            var gridId = ev.GridId;
             Logger.DebugS("grid", $"Adding {gridId} to grid renderer");
             _mapChunkData.Add(gridId, new Dictionary<Vector2i, MapChunkData>());
         }
 
-        private void _updateOnGridRemoved(MapId mapId, GridId gridId)
+        private void _updateOnGridRemoved(GridRemovalEvent ev)
         {
+            var gridId = ev.GridId;
             Logger.DebugS("grid", $"Removing {gridId} from grid renderer");
 
             var data = _mapChunkData[gridId];

Robust.Client/Graphics/Clyde/Clyde.HLR.cs

@@ -35,6 +35,8 @@ namespace Robust.Client.Graphics.Clyde
         /// </summary>
         public static float PostShadeScale = 1.25f;
 
+        private List<Overlay> _overlays = new();
+
         public void Render()
         {
             CheckTransferringScreenshots();
@@ -152,19 +154,19 @@ namespace Robust.Client.Graphics.Clyde
 
         private List<Overlay> GetOverlaysForSpace(OverlaySpace space)
         {
-            var list = new List<Overlay>();
+            _overlays.Clear();
 
             foreach (var overlay in _overlayManager.AllOverlays)
             {
                 if ((overlay.Space & space) != 0)
                 {
-                    list.Add(overlay);
+                    _overlays.Add(overlay);
                 }
             }
 
-            list.Sort(OverlayComparer.Instance);
+            _overlays.Sort(OverlayComparer.Instance);
 
-            return list;
+            return _overlays;
         }
 
         private ClydeTexture? ScreenBufferTexture;

Robust.Client/Graphics/Clyde/Clyde.LightRendering.cs

@@ -861,7 +861,6 @@ namespace Robust.Client.Graphics.Clyde
             // 3D geometry used during depth projection.
             // 2D mask geometry used to apply wall bleed.
 
-            // TODO: This code probably does not work correctly with rotated camera.
             // TODO: Yes this function throws and index exception if you reach maxOccluders.
 
             const int maxOccluders = 2048;

Robust.Client/Graphics/Clyde/Clyde.Windowing.cs

@@ -437,6 +437,13 @@ namespace Robust.Client.Graphics.Clyde
             _windowing!.WindowSetVisible(reg, visible);
         }
 
+        public void RunOnWindowThread(Action a)
+        {
+            DebugTools.AssertNotNull(_windowing);
+
+            _windowing!.RunOnWindowThread(a);
+        }
+
         private abstract class WindowReg
         {
             public bool IsDisposed;

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -22,7 +22,7 @@ namespace Robust.Client.Graphics.Clyde
     /// <summary>
     ///     Responsible for most things rendering on OpenGL mode.
     /// </summary>
-    internal sealed partial class Clyde : IClydeInternal, IPostInjectInit
+    internal sealed partial class Clyde : IClydeInternal, IPostInjectInit, IEntityEventSubscriber
     {
         [Dependency] private readonly IClydeTileDefinitionManager _tileDefinitionManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;
@@ -134,16 +134,19 @@ namespace Robust.Client.Graphics.Clyde
 
         public void PostInject()
         {
-            _mapManager.TileChanged += _updateTileMapOnUpdate;
-            _mapManager.OnGridCreated += _updateOnGridCreated;
-            _mapManager.OnGridRemoved += _updateOnGridRemoved;
-            _mapManager.GridChanged += _updateOnGridModified;
-
             // This cvar does not modify the actual GL version requested or anything,
             // it overrides the version we detect to detect GL features.
             RegisterBlockCVars();
         }
 
+        public void RegisterGridEcsEvents()
+        {
+            _entityManager.EventBus.SubscribeEvent<TileChangedEvent>(EventSource.Local, this, _updateTileMapOnUpdate);
+            _entityManager.EventBus.SubscribeEvent<GridStartupEvent>(EventSource.Local, this, _updateOnGridCreated);
+            _entityManager.EventBus.SubscribeEvent<GridRemovalEvent>(EventSource.Local, this, _updateOnGridRemoved);
+            _entityManager.EventBus.SubscribeEvent<GridModifiedEvent>(EventSource.Local, this, _updateOnGridModified);
+        }
+
         private void GLInitBindings(bool gles)
         {
             _glBindingsContext = _glContext!.BindingsContext;

Robust.Client/Graphics/Clyde/ClydeHeadless.cs

@@ -76,6 +76,11 @@ namespace Robust.Client.Graphics.Clyde
             return null;
         }
 
+        public void RegisterGridEcsEvents()
+        {
+            // Nada.
+        }
+
         public void SetWindowTitle(string title)
         {
             // Nada.
@@ -246,6 +251,11 @@ namespace Robust.Client.Graphics.Clyde
             // Nada.
         }
 
+        public void RunOnWindowThread(Action action)
+        {
+            action();
+        }
+
         private sealed class DummyCursor : ICursor
         {
             public void Dispose()

Robust.Client/Graphics/Clyde/Windowing/Glfw.WindowThread.cs

@@ -118,6 +118,10 @@ namespace Robust.Client.Graphics.Clyde
                     case CmdWinCursorSet cmd:
                         WinThreadWinCursorSet(cmd);
                         break;
+
+                    case CmdRunAction cmd:
+                        cmd.Action();
+                        break;
                 }
             }
 
@@ -169,6 +173,11 @@ namespace Robust.Client.Graphics.Clyde
                 }
             }
 
+            public void RunOnWindowThread(Action action)
+            {
+                SendCmd(new CmdRunAction(action));
+            }
+
             private abstract record CmdBase;
 
             private sealed record CmdTerminate : CmdBase;
@@ -245,6 +254,10 @@ namespace Robust.Client.Graphics.Clyde
             private sealed record CmdCursorDestroy(
                 ClydeHandle Cursor
             ) : CmdBase;
+
+            private sealed record CmdRunAction(
+                Action Action
+            ) : CmdBase;
         }
     }
 }

Robust.Client/Graphics/Clyde/Windowing/IWindowingImpl.cs

@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 using Robust.Client.Input;
 using Robust.Shared.Maths;
 using SixLabors.ImageSharp;
@@ -58,6 +59,9 @@ namespace Robust.Client.Graphics.Clyde
             void GLMakeContextCurrent(WindowReg? reg);
             void GLSwapInterval(int interval);
             unsafe void* GLGetProcAddress(string procName);
+
+            // Misc
+            void RunOnWindowThread(Action a);
         }
     }
 }

Robust.Client/Graphics/FontManager.cs

@@ -9,6 +9,7 @@ using Robust.Shared.Utility;
 using SharpFont;
 using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
+using TerraFX.Interop.Windows;
 
 namespace Robust.Client.Graphics
 {
@@ -58,6 +59,14 @@ namespace Robust.Client.Graphics
             return instance;
         }
 
+        public void ClearFontCache()
+        {
+            foreach (var fontInstance in _loadedInstances)
+            {
+                fontInstance.Value.ClearSizeData();
+            }
+        }
+
         private ScaledFontData _generateScaledDatum(FontInstanceHandle instance, float scale)
         {
             var ftFace = instance.FaceHandle.Face;
@@ -246,6 +255,18 @@ namespace Robust.Client.Graphics
                 FaceHandle = faceHandle;
             }
 
+            public void ClearSizeData()
+            {
+                foreach (var scaleData in _scaledData)
+                {
+                    foreach (var ownedTexture in scaleData.Value.AtlasTextures)
+                    {
+                        ownedTexture.Dispose();
+                    }
+                }
+                _scaledData.Clear();
+            }
+
             public Texture? GetCharTexture(Rune codePoint, float scale)
             {
                 var glyph = GetGlyph(codePoint);

Robust.Client/Graphics/IClydeInternal.cs

@@ -61,5 +61,9 @@ namespace Robust.Client.Graphics
 
         /// <returns>Null if not running on X11.</returns>
         uint? GetX11WindowId();
+
+        void RegisterGridEcsEvents();
+
+        void RunOnWindowThread(Action action);
     }
 }

Robust.Client/Graphics/IFontManager.cs

@@ -5,9 +5,8 @@ namespace Robust.Client.Graphics
 {
     public interface IFontManager
     {
-
+        public void ClearFontCache();
     }
-
     internal interface IFontManagerInternal : IFontManager
     {
         IFontFaceHandle Load(Stream stream);

Robust.Client/Graphics/RSI/RSI.State.cs

@@ -152,9 +152,12 @@ namespace Robust.Client.Graphics
             /// <summary>
             ///     Specifies a direction in an RSI state.
             /// </summary>
+            /// <remarks>
+            ///     Value of the enum here matches the index used to store it in the icons array. If this ever changes, then
+            ///     <see cref="GameObjects.SpriteComponent.Layer._rsiDirectionMatrices"/> also needs to be updated.
+            /// </remarks>
             public enum Direction : byte
             {
-                // Value of the enum here matches the index used to store it in the icons array.
                 South = 0,
                 North = 1,
                 East = 2,

Robust.Client/Map/ClydeTileDefinitionManager.cs

@@ -1,11 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.IO;
 using System.Linq;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Client.Utility;
 using Robust.Shared.IoC;
+using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
@@ -22,11 +22,20 @@ namespace Robust.Client.Map
 
         public Texture TileTextureAtlas => _tileTextureAtlas ?? Texture.Transparent;
 
-        private readonly Dictionary<ushort, Box2> _tileRegions = new();
+        private readonly Dictionary<ushort, Box2[]> _tileRegions = new();
 
-        public Box2? TileAtlasRegion(Tile tile)
+        public Box2 ErrorTileRegion { get; private set; }
+
+        /// <inheritdoc />
+        public Box2[]? TileAtlasRegion(Tile tile)
         {
-            if (_tileRegions.TryGetValue(tile.TypeId, out var region))
+            return TileAtlasRegion(tile.TypeId);
+        }
+
+        /// <inheritdoc />
+        public Box2[]? TileAtlasRegion(ushort tileType)
+        {
+            if (_tileRegions.TryGetValue(tileType, out var region))
             {
                 return region;
             }
@@ -51,39 +60,79 @@ namespace Robust.Client.Map
 
             const int tileSize = EyeManager.PixelsPerMeter;
 
-            var dimensionX = (int) Math.Ceiling(Math.Sqrt(defList.Count));
-            var dimensionY = (int) Math.Ceiling((float) defList.Count / dimensionX);
+            var tileCount = defList.Select(x => (int)x.Variants).Sum() + 1;
 
-            var sheet = new Image<Rgba32>(dimensionX * tileSize, dimensionY * tileSize);
+            var dimensionX = (int) Math.Ceiling(Math.Sqrt(tileCount));
+            var dimensionY = (int) Math.Ceiling((float) tileCount / dimensionX);
 
-            for (var i = 0; i < defList.Count; i++)
+            var imgWidth = dimensionX * tileSize;
+            var imgHeight = dimensionY * tileSize;
+            var sheet = new Image<Rgba32>(imgWidth, imgHeight);
+
+            // Add in the missing tile texture sprite as tile texture 0.
             {
-                var def = defList[i];
-                var column = i % dimensionX;
-                var row = i / dimensionX;
+                var w = (float) sheet.Width;
+                var h = (float) sheet.Height;
+                ErrorTileRegion = Box2.FromDimensions(
+                    0, (h - EyeManager.PixelsPerMeter) / h,
+                    tileSize / w, tileSize / h);
+                Image<Rgba32> image;
+                using (var stream = _resourceCache.ContentFileRead("/Textures/noTile.png"))
+                {
+                    image = Image.Load<Rgba32>(stream);
+                }
 
+                image.Blit(new UIBox2i(0, 0, tileSize, tileSize), sheet, Vector2i.Zero);
+            }
+
+            if (imgWidth >= 2048 || imgHeight >= 2048)
+            {
+                // Sanity warning, some machines don't have textures larger than this and need multiple atlases.
+                Logger.WarningS("clyde",
+                    $"Tile texture atlas is ({imgWidth} x {imgHeight}), larger than 2048 x 2048. If you really need {tileCount} tiles, file an issue on RobustToolbox.");
+            }
+
+            var column = 1;
+            var row = 0;
+            foreach (var def in defList)
+            {
                 Image<Rgba32> image;
                 using (var stream = _resourceCache.ContentFileRead(new ResourcePath(def.Path) / $"{def.SpriteName}.png"))
                 {
                     image = Image.Load<Rgba32>(stream);
                 }
 
-                if (image.Width != tileSize || image.Height != tileSize)
+                if (image.Width != (tileSize * def.Variants) || image.Height != tileSize)
                 {
-                    throw new NotSupportedException("Unable to use tiles with a dimension other than 32x32.");
+                    throw new NotSupportedException(
+                        $"Unable to load {new ResourcePath(def.Path) / $"{def.SpriteName}.png"}, due to being unable to use tile texture with a dimension other than {tileSize}x({tileSize} * Variants).");
                 }
 
-                var point = new Vector2i(column * tileSize, row * tileSize);
+                var regionList = new Box2[def.Variants];
 
-                image.Blit(new UIBox2i(0, 0, image.Width, image.Height), sheet, point);
+                for (var j = 0; j < def.Variants; j++)
+                {
+                    var point = new Vector2i(column * tileSize, row * tileSize);
 
-                var w = (float) sheet.Width;
-                var h = (float) sheet.Height;
+                    var box = new UIBox2i(0, 0, tileSize, tileSize).Translated(new Vector2i(j * tileSize, 0));
+                    image.Blit(box, sheet, point);
 
-                _tileRegions.Add(def.TileId,
-                    Box2.FromDimensions(
+                    var w = (float) sheet.Width;
+                    var h = (float) sheet.Height;
+
+                    regionList[j] = Box2.FromDimensions(
                         point.X / w, (h - point.Y - EyeManager.PixelsPerMeter) / h,
-                        tileSize / w, tileSize / h));
+                        tileSize / w, tileSize / h);
+                    column++;
+
+                    if (column >= dimensionX)
+                    {
+                        column = 0;
+                        row++;
+                    }
+                }
+
+                _tileRegions.Add(def.TileId, regionList);
             }
 
             _tileTextureAtlas = Texture.LoadFromImage(sheet, "Tile Atlas");

Robust.Client/Map/IClydeTileDefinitionManager.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
@@ -9,6 +10,8 @@ namespace Robust.Client.Map
     /// </summary>
     internal interface IClydeTileDefinitionManager : ITileDefinitionManager
     {
+        Box2 ErrorTileRegion { get; }
+
         /// <summary>
         ///     The texture atlas containing all the tiles.
         /// </summary>
@@ -18,6 +21,12 @@ namespace Robust.Client.Map
         ///     Gets the region inside the texture atlas to use to draw a tile.
         /// </summary>
         /// <returns>If null, do not draw the tile at all.</returns>
-        Box2? TileAtlasRegion(Tile tile);
+        Box2[]? TileAtlasRegion(Tile tile);
+
+        /// <summary>
+        ///     Gets the region inside the texture atlas to use to draw a tile type.
+        /// </summary>
+        /// <returns>If null, do not draw the tile at all.</returns>
+        Box2[]? TileAtlasRegion(ushort tileType);
     }
 }

Robust.Client/Physics/PhysicsSystem.cs

@@ -37,7 +37,7 @@ namespace Robust.Client.Physics
             SimulateWorld((float) diff.TotalSeconds, true);
         }
 
-        protected override void HandleMapCreated(object? sender, MapEventArgs eventArgs)
+        protected override void HandleMapCreated(MapChangedEvent eventArgs)
         {
             if (eventArgs.Map == MapId.Nullspace) return;
             var mapUid = MapManager.GetMapEntityId(eventArgs.Map);

Robust.Client/Placement/Modes/AlignSimilar.cs

@@ -31,7 +31,7 @@ namespace Robust.Client.Placement.Modes
 
             var mapId = MouseCoords.GetMapId(pManager.EntityManager);
 
-            var snapToEntities = IoCManager.Resolve<IEntityLookup>().GetEntitiesInRange(MouseCoords, SnapToRange)
+            var snapToEntities = EntitySystem.Get<EntityLookupSystem>().GetEntitiesInRange(MouseCoords, SnapToRange)
                 .Where(entity => pManager.EntityManager.GetComponent<MetaDataComponent>(entity).EntityPrototype == pManager.CurrentPrototype && pManager.EntityManager.GetComponent<TransformComponent>(entity).MapID == mapId)
                 .OrderBy(entity => (pManager.EntityManager.GetComponent<TransformComponent>(entity).WorldPosition - MouseCoords.ToMapPos(pManager.EntityManager)).LengthSquared)
                 .ToList();

Robust.Client/Placement/Modes/AlignTileEmpty.cs

@@ -53,7 +53,7 @@ namespace Robust.Client.Placement.Modes
             var topRight = new Vector2(CurrentTile.X + 0.99f, CurrentTile.Y + 0.99f);
             var box = new Box2(bottomLeft, topRight);
 
-            return !IoCManager.Resolve<IEntityLookup>().AnyEntitiesIntersecting(map, box);
+            return !EntitySystem.Get<EntityLookupSystem>().AnyEntitiesIntersecting(map, box);
         }
     }
 }

Robust.Client/Placement/PlacementManager.cs

@@ -22,7 +22,7 @@ using Robust.Shared.Utility;
 
 namespace Robust.Client.Placement
 {
-    public sealed partial class PlacementManager : IPlacementManager, IDisposable
+    public sealed partial class PlacementManager : IPlacementManager, IDisposable, IEntityEventSubscriber
     {
         [Dependency] private readonly IClientNetManager NetworkManager = default!;
         [Dependency] public readonly IPlayerManager PlayerManager = default!;
@@ -185,7 +185,7 @@ namespace Robust.Client.Placement
                 _modeDictionary.Add(type.Name, type);
             }
 
-            MapManager.TileChanged += HandleTileChanged;
+            EntityManager.EventBus.SubscribeEvent<TileChangedEvent>(EventSource.Local, this, HandleTileChanged);
 
             _drawOverlay = new PlacementOverlay(this);
             _overlayManager.AddOverlay(_drawOverlay);
@@ -328,7 +328,7 @@ namespace Robust.Client.Placement
             }
         }
 
-        private void HandleTileChanged(object? sender, TileChangedEventArgs args)
+        private void HandleTileChanged(TileChangedEvent args)
         {
             var coords = MapManager.GetGrid(args.NewTile.GridIndex).GridTileToLocal(args.NewTile.GridIndices);
             _pendingTileChanges.RemoveAll(c => c.Item1 == coords);

Robust.Client/ResourceManagement/ResourceTypes/RSIResource.cs

@@ -230,7 +230,7 @@ namespace Robust.Client.ResourceManagement
 
             using (var manifestFile = cache.ContentFileRead(manifestPath))
             {
-                if (manifestFile.Length <= 4096)
+                if (manifestFile.CanSeek && manifestFile.Length <= 4096)
                 {
                     // Most RSIs are actually tiny so if that's the case just load them into a stackalloc buffer.
                     // Avoids a ton of allocations with stream reader etc

Robust.Client/Robust.Client.csproj

@@ -13,8 +13,8 @@
   <Import Project="..\MSBuild\Robust.DefineConstants.targets" />
   <ItemGroup>
     <PackageReference Include="DiscordRichPresence" Version="1.0.175" />
-    <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.Data.Sqlite" Version="5.0.3" />
+    <PackageReference Include="JetBrains.Annotations" Version="2021.3.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.Data.Sqlite" Version="6.0.2" />
     <PackageReference Include="nfluidsynth" Version="0.3.1" />
     <PackageReference Include="NVorbis" Version="0.10.1" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />
@@ -25,9 +25,9 @@
     <PackageReference Include="TerraFX.Interop.Windows" Version="10.0.20348-rc2" />
   </ItemGroup>
   <ItemGroup Condition="'$(EnableClientScripting)' == 'True'">
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" Version="3.8.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="3.8.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.8.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.0.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.0.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1" />
 
     <ProjectReference Include="..\Robust.Shared.Scripting\Robust.Shared.Scripting.csproj" />
   </ItemGroup>
@@ -53,6 +53,7 @@
     <Compile Update="UserInterface\CustomControls\DefaultWindow.xaml.cs">
       <DependentUpon>DefaultWindow.xaml</DependentUpon>
     </Compile>
+    <Compile Remove="Debugging\IDebugDrawing.cs" />
   </ItemGroup>
   <Import Project="..\MSBuild\Robust.Engine.targets" />
   <PropertyGroup>

Robust.Client/UserInterface/Controls/WindowRoot.cs

@@ -1,4 +1,6 @@
 using Robust.Client.Graphics;
+using Robust.Shared.Maths;
+using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.UserInterface.Controls
 {
@@ -9,6 +11,30 @@ namespace Robust.Client.UserInterface.Controls
             Window = window;
         }
 
+        /// <summary>
+        ///     Enable the UI autoscale system, this will scale down the UI for lower resolutions
+        /// </summary>
+        [ViewVariables]
+        public bool AutoScale { get; set; } = false;
+
+        /// <summary>
+        ///     Minimum resolution to start clamping autoscale to 1
+        /// </summary>
+        [ViewVariables]
+        public Vector2i AutoScaleUpperCutoff { get; set; } = new Vector2i(1080, 720);
+
+        /// <summary>
+        ///     Maximum resolution to start clamping autos scale to autoscale minimum
+        /// </summary>
+        [ViewVariables]
+        public Vector2i AutoScaleLowerCutoff { get; set; } = new Vector2i(520, 520);
+
+        /// <summary>
+        ///     The minimum ui scale value that autoscale will scale to
+        /// </summary>
+        [ViewVariables]
+        public float AutoScaleMinimum { get; set; } = 0.5f;
+
         public override float UIScale => UIScaleSet;
         internal float UIScaleSet { get; set; }
         public override IClydeWindow Window { get; }

Robust.Client/UserInterface/CustomControls/DebugCoordsPanel.cs

@@ -102,13 +102,18 @@ Mouse Pos:
                 var playerScreen = _eyeManager.WorldToScreen(playerWorldOffset.Position);
 
                 var playerCoordinates = entityTransform.Coordinates;
+                var playerRotation = entityTransform.WorldRotation;
+
+                Angle gridRotation = _mapManager.TryGetGrid(entityTransform.GridID, out var grid) ? grid.WorldRotation : Angle.Zero;
 
                 stringBuilder.AppendFormat(@"    Screen: {0}
     {1}
     {2}
-    EntId: {3}
-    GridID: {4}", playerScreen, playerWorldOffset, playerCoordinates, entityTransform.Owner,
-                    entityTransform.GridID);
+    Rotation: {3:F2}°
+    EntId: {4}
+    GridID: {5}
+    Grid Rotation: {6:F2}°", playerScreen, playerWorldOffset, playerCoordinates, playerRotation.Degrees, entityTransform.Owner,
+                    entityTransform.GridID, gridRotation.Degrees);
             }
 
             if (controlHovered != null)

Robust.Client/UserInterface/FileDialogManager.cs

@@ -8,6 +8,7 @@ using System.Text;
 using System.Threading.Tasks;
 using Robust.Client.Graphics;
 using Robust.Shared;
+using Robust.Shared.Console;
 using Robust.Shared.Asynchronous;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
@@ -164,12 +165,11 @@ namespace Robust.Client.UserInterface
         {
             if (OperatingSystem.IsMacOS())
             {
-                // macOS seems pretty annoying about having the file dialog opened from the main thread.
-                // So we are forced to execute this synchronously on the main thread.
-                // Also I'm calling RunOnMainThread here to provide safety in case this is ran from a different thread.
-                // nativefiledialog doesn't provide any form of async API, so this WILL lock up the client.
+                // macOS seems pretty annoying about having the file dialog opened from the main windowing thread.
+                // So we are forced to execute this synchronously on the main windowing thread.
+                // nativefiledialog doesn't provide any form of async API, so this WILL lock up half the client.
                 var tcs = new TaskCompletionSource<string?>();
-                _taskManager.RunOnMainThread(() => tcs.SetResult(action()));
+                _clyde.RunOnWindowThread(() => tcs.SetResult(action()));
 
                 return tcs.Task;
             }
@@ -388,4 +388,17 @@ namespace Robust.Client.UserInterface
             SW_NFD_CANCEL,
         }
     }
+
+    public sealed class OpenFileCommand : IConsoleCommand
+    {
+        public string Command => "testopenfile";
+        public string Description => "";
+        public string Help => "";
+
+        public async void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            var stream = await IoCManager.Resolve<IFileDialogManager>().OpenFile();
+            stream?.Dispose();
+        }
+    }
 }

Robust.Client/UserInterface/UserInterfaceManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using Robust.Client.Graphics;
@@ -23,6 +23,7 @@ namespace Robust.Client.UserInterface
     internal sealed class UserInterfaceManager : IUserInterfaceManagerInternal
     {
         [Dependency] private readonly IInputManager _inputManager = default!;
+        [Dependency] private readonly IFontManager _fontManager = default!;
         [Dependency] private readonly IClydeInternal _clyde = default!;
         [Dependency] private readonly IGameTiming _gameTiming = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
@@ -371,16 +372,21 @@ namespace Robust.Client.UserInterface
                 }
             }
 
-            ReleaseKeyboardFocus();
 
             if (hit == null)
             {
+                ReleaseKeyboardFocus();
                 hitData = null;
                 return false;
             }
 
             var (control, rel) = hit.Value;
 
+            if (control != KeyboardFocused)
+            {
+                ReleaseKeyboardFocus();
+            }
+
             ControlFocused = control;
 
             if (ControlFocused.CanKeyboardFocus && ControlFocused.KeyboardFocusOnClick)
@@ -951,14 +957,37 @@ namespace Robust.Client.UserInterface
         private void WindowContentScaleChanged(WindowContentScaleEventArgs args)
         {
             if (_windowsToRoot.TryGetValue(args.Window.Id, out var root))
+            {
                 UpdateUIScale(root);
+                _fontManager.ClearFontCache();
+            }
+
+        }
+
+        private float CalculateAutoScale(WindowRoot root)
+        {
+            //Grab the OS UIScale or the value set through CVAR debug
+            var osScale = _configurationManager.GetCVar(CVars.DisplayUIScale);
+            osScale = osScale == 0f ? root.Window.ContentScale.X : osScale;
+            var windowSize = root.Window.RenderTarget.Size;
+            //Only run autoscale if it is enabled, otherwise default to just use OS UIScale
+            if (!root.AutoScale && (windowSize.X <= 0 || windowSize.Y <= 0)) return osScale;
+            var maxScaleRes = root.AutoScaleUpperCutoff;
+            var minScaleRes = root.AutoScaleLowerCutoff;
+            var autoScaleMin = root.AutoScaleMinimum;
+            float scaleRatioX;
+            float scaleRatioY;
+
+            //Calculate the scale ratios and clamp it between the maximums and minimums
+            scaleRatioX = Math.Clamp(((float) windowSize.X - minScaleRes.X) / (maxScaleRes.X - minScaleRes.X) * osScale, autoScaleMin, osScale);
+            scaleRatioY = Math.Clamp(((float) windowSize.Y - minScaleRes.Y) / (maxScaleRes.Y - minScaleRes.Y) * osScale, autoScaleMin, osScale);
+            //Take the smallest UIScale value and use it for UI scaling
+            return Math.Min(scaleRatioX, scaleRatioY);
         }
 
         private void UpdateUIScale(WindowRoot root)
         {
-            var newVal = _configurationManager.GetCVar(CVars.DisplayUIScale);
-            root.UIScaleSet = newVal == 0f ? root.Window.ContentScale.X : newVal;
-
+            root.UIScaleSet = CalculateAutoScale(root);
             _propagateUIScaleChanged(root);
             root.InvalidateMeasure();
         }
@@ -977,7 +1006,7 @@ namespace Robust.Client.UserInterface
         {
             if (!_windowsToRoot.TryGetValue(windowResizedEventArgs.Window.Id, out var root))
                 return;
-
+            UpdateUIScale(root);
             root.InvalidateMeasure();
         }
 

Robust.Docfx/articles/example-article.md

@@ -0,0 +1 @@
+# Add your introductions here!

Robust.Docfx/articles/toc.yml

@@ -0,0 +1,2 @@
+- name: Example-article
+  href: example-article.md

Robust.Docfx/docfx.json

@@ -0,0 +1,214 @@
+{
+  "metadata": [
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.UnitTesting"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.UnitTesting"
+    },
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.Shared"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.Shared"
+    },
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.Shared.Maths"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.Shared.Maths"
+    },
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.Shared.Scripting"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.Shared.Scripting"
+    },
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.Client"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.Client"
+    },
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.Client.WebView"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.Client.WebView"
+    },
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.Server"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.Server"
+    },
+    {
+      "src":
+      [
+        {
+          "files": [
+            "**.csproj"
+          ],
+          "exclude": [
+            "**/bin/**",
+            "**/obj/**",
+            "_site/**",
+            "**.xaml"
+          ],
+          "src": "../Robust.LoaderApi"
+        }
+      ],
+      "disableGitFeatures": false,
+      "disableDefaultFilter": false,
+      "dest": "api/Robust.LoaderApi/Robust.LoaderApi"
+    }
+  ],
+  "build": {
+    "content": [
+      {
+        "files": [
+          "api/**/**.yml"
+        ]
+      },
+      {
+        "files": [
+          "articles/**.md",
+          "articles/**/toc.yml",
+          "toc.yml",
+          "*.md"
+        ]
+      }
+    ],
+    "resource": [
+      {
+        "files": [
+          "images/**",
+          "favicon.ico",
+          "icon.svg"          
+        ]
+      }
+    ],
+    "overwrite": [
+      {
+        "files": [
+          "apidoc/**.md"
+        ],
+        "exclude": [
+          "obj/**",
+          "_site/**"
+        ]
+      }
+    ],
+    "dest": "_robust-site",
+    "globalMetadataFiles": [],
+    "fileMetadataFiles": [],
+    "template": [
+      "default",
+      "templates/darkfx"
+    ],
+    "postProcessors": [],
+    "markdownEngineName": "markdig",
+    "noLangKeyword": false,
+    "keepFileLink": false,
+    "cleanupCacheHistory": false,
+    "disableGitFeatures": false
+  }
+}

Robust.Docfx/index.md

@@ -0,0 +1,6 @@
+# RobustToolbox DocFX
+![](https://i.imgur.com/Sv3Swxg.png)
+
+## Welcome to the RobustToolbox DocFX instance.
+### Click one of the tabs above to see documentation for that particular project/namespace
+

Robust.Docfx/templates/darkfx/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Steffen Wilke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Robust.Docfx/templates/darkfx/partials/affix.tmpl.partial

@@ -0,0 +1,40 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+<div class="hidden-sm col-md-2" role="complementary">
+  <div class="sideaffix">
+    {{^_disableContribution}}
+    <div class="contribution">
+      <ul class="nav">
+        {{#docurl}}
+        <li>
+          <a href="{{docurl}}" class="contribution-link">{{__global.improveThisDoc}}</a>
+        </li>
+        {{/docurl}}
+        {{#sourceurl}}
+        <li>
+          <a href="{{sourceurl}}" class="contribution-link">{{__global.viewSource}}</a>
+        </li>
+        {{/sourceurl}}
+      </ul>
+    </div>
+    {{/_disableContribution}}
+    <div class="toggle-mode">
+      <div class="icon">
+        <i aria-hidden="true">☀</i>
+      </div>
+      <label class="switch">
+        <input type="checkbox" id="switch-style">
+        <span class="slider round"></span>
+      </label>
+      <div class="icon">
+        <i aria-hidden="true">☾</i>
+      </div>
+    </div>
+
+    <nav class="bs-docs-sidebar hidden-print hidden-xs hidden-sm affix" id="affix">
+    <h5>{{__global.inThisArticle}}</h5>
+    <div></div>
+    <!-- <p><a class="back-to-top" href="#top">Back to top</a><p> -->
+    </nav>
+  </div>
+</div>

Robust.Docfx/templates/darkfx/partials/class.header.tmpl.partial

@@ -0,0 +1,108 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+<h1 id="{{id}}" data-uid="{{uid}}" class="text-break">{{>partials/title}}</h1>
+<div class="markdown level0 summary">{{{summary}}}</div>
+<div class="markdown level0 conceptual">{{{conceptual}}}</div>
+{{#inClass}}
+<div class="inheritance">
+  <h5>{{__global.inheritance}}</h5>
+  {{#inheritance}}
+  <div class="level{{index}}">{{{specName.0.value}}}</div>
+  {{/inheritance}}
+  <div class="level{{level}}"><span class="xref">{{name.0.value}}</span></div>
+  {{#derivedClasses}}
+    <div class="level{{index}}">{{{specName.0.value}}}</div>
+  {{/derivedClasses}}
+</div>
+{{/inClass}}
+{{#implements.0}}
+<div classs="implements">
+  <h5>{{__global.implements}}</h5>
+{{/implements.0}}
+{{#implements}}
+  <div>{{{specName.0.value}}}</div>
+{{/implements}}
+{{#implements.0}}
+</div>
+{{/implements.0}}
+{{#inheritedMembers.0}}
+<div class="inheritedMembers">
+</div>
+{{/inheritedMembers.0}}
+<h6><strong>{{__global.namespace}}</strong>: {{{namespace.specName.0.value}}}</h6>
+<h6><strong>{{__global.assembly}}</strong>: {{assemblies.0}}.dll</h6>
+<h5 id="{{id}}_syntax">{{__global.syntax}}</h5>
+<div class="codewrapper">
+  <pre><code class="lang-{{_lang}} hljs">{{syntax.content.0.value}}</code></pre>
+</div>
+{{#syntax.parameters.0}}
+<h5 class="parameters">{{__global.parameters}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.name}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/syntax.parameters.0}}
+{{#syntax.parameters}}
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td><span class="parametername">{{{id}}}</span></td>
+      <td>{{{description}}}</td>
+    </tr>
+{{/syntax.parameters}}
+{{#syntax.parameters.0}}
+  </tbody>
+</table>
+{{/syntax.parameters.0}}
+{{#syntax.return}}
+<h5 class="returns">{{__global.returns}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.type}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>{{{type.specName.0.value}}}</td>
+      <td>{{{description}}}</td>
+    </tr>
+  </tbody>
+</table>
+{{/syntax.return}}
+{{#syntax.typeParameters.0}}
+<h5 class="typeParameters">{{__global.typeParameters}}</h5>
+<table class="table table-bordered table-striped table-condensed">
+  <thead>
+    <tr>
+      <th>{{__global.name}}</th>
+      <th>{{__global.description}}</th>
+    </tr>
+  </thead>
+  <tbody>
+{{/syntax.typeParameters.0}}
+{{#syntax.typeParameters}}
+    <tr>
+      <td><span class="parametername">{{{id}}}</span></td>
+      <td>{{{description}}}</td>
+    </tr>
+{{/syntax.typeParameters}}
+{{#syntax.typeParameters.0}}
+  </tbody>
+</table>
+{{/syntax.typeParameters.0}}
+{{#remarks}}
+<h5 id="{{id}}_remarks"><strong>{{__global.remarks}}</strong></h5>
+<div class="markdown level0 remarks">{{{remarks}}}</div>
+{{/remarks}}
+{{#example.0}}
+<h5 id="{{id}}_examples"><strong>{{__global.examples}}</strong></h5>
+{{/example.0}}
+{{#example}}
+{{{.}}}
+{{/example}}

Robust.Docfx/templates/darkfx/partials/footer.tmpl.partial

@@ -0,0 +1,29 @@
+{{!Copyright (c) Microsoft. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+<footer>
+  <div class="grad-bottom"></div>
+  <div class="footer">
+    <div class="container">
+      <span class="pull-right">
+        <a href="#top">Back to top</a>
+      </span>
+      <div class="pull-left">
+        {{{_appFooter}}}
+        {{^_appFooter}}<span>Generated by <strong>DocFX</strong></span>{{/_appFooter}}
+      </div>
+      <div class="toggle-mode pull-right visible-sm visible-xs">
+        <div class="icon">
+          <i aria-hidden="true">☀</i>
+        </div>
+        <label class="switch">
+          <input type="checkbox" id="switch-style-m">
+          <span class="slider round"></span>
+        </label>
+        <div class="icon">
+          <i aria-hidden="true">☾</i>
+        </div>
+      </div>
+    </div>
+  </div>
+  <script type="text/javascript" src="{{_rel}}styles/toggle-theme.js"></script>
+</footer>

Robust.Docfx/templates/darkfx/partials/head.tmpl.partial

@@ -0,0 +1,20 @@
+{{!Copyright (c) Oscar Vasquez. All rights reserved. Licensed under the MIT license. See LICENSE file in the project root for full license information.}}
+
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+  <title>{{#title}}{{title}}{{/title}}{{^title}}{{>partials/title}}{{/title}} {{#_appTitle}}| {{_appTitle}} {{/_appTitle}}</title>
+  <meta name="viewport" content="width=device-width">
+  <meta name="title" content="{{#title}}{{title}}{{/title}}{{^title}}{{>partials/title}}{{/title}} {{#_appTitle}}| {{_appTitle}} {{/_appTitle}}">
+  <meta name="generator" content="docfx {{_docfxVersion}}">
+  {{#_description}}<meta name="description" content="{{_description}}">{{/_description}}
+  <link rel="shortcut icon" href="{{_rel}}{{{_appFaviconPath}}}{{^_appFaviconPath}}favicon.ico{{/_appFaviconPath}}">
+  <link rel="stylesheet" href="{{_rel}}styles/docfx.vendor.css">
+  <link rel="stylesheet" href="{{_rel}}styles/docfx.css">
+  <link rel="stylesheet" href="{{_rel}}styles/main.css">
+  <meta property="docfx:navrel" content="{{_navRel}}">
+  <meta property="docfx:tocrel" content="{{_tocRel}}">
+  {{#_noindex}}<meta name="searchOption" content="noindex">{{/_noindex}}
+  {{#_enableSearch}}<meta property="docfx:rel" content="{{_rel}}">{{/_enableSearch}}
+  {{#_enableNewTab}}<meta property="docfx:newtab" content="true">{{/_enableNewTab}}
+</head>

Robust.Docfx/templates/darkfx/styles/main.css

@@ -0,0 +1,470 @@
+:root, body.dark-theme {
+  --color-foreground: #ccd5dc;
+  --color-navbar: #66666d;
+  --color-breadcrumb: #999;
+  --color-underline: #ddd;
+  --color-toc-hover: #fff;
+  --color-background: #2d2d30;
+  --color-background-subnav: #333337;
+  --color-background-dark: #1e1e1e;
+  --color-background-table-alt: #212123;
+  --color-background-quote: #69696e;
+}
+
+body.light-theme {
+  --color-foreground: #171717;
+  --color-breadcrumb: #4a4a4a;
+  --color-toc-hover: #4c4c4c;
+  --color-background: #ffffff;
+  --color-background-subnav: #f5f5f5;
+  --color-background-dark: #ddd;
+  --color-background-table-alt: #f9f9f9;
+}
+
+body {
+  color: var(--color-foreground);
+  line-height: 1.5;
+  font-size: 14px;
+  -ms-text-size-adjust: 100%;
+  -webkit-text-size-adjust: 100%;
+  word-wrap: break-word;
+  background-color: var(--color-background);
+}
+
+.btn.focus, .btn:focus, .btn:hover {
+  color: var(--color-foreground);
+}
+
+h1 {
+  font-weight: 600;
+  font-size: 32px;
+}
+
+h2 {
+  font-weight: 600;
+  font-size: 24px;
+  line-height: 1.8;
+}
+
+h3 {
+  font-weight: 600;
+  font-size: 20px;
+  line-height: 1.8;
+}
+
+h5 {
+  font-size: 14px;
+  padding: 10px 0px;
+}
+
+article h1, article h2, article h3, article h4 {
+  margin-top: 35px;
+  margin-bottom: 15px;
+}
+
+article h4 {
+  padding-bottom: 8px;
+  border-bottom: 2px solid var(--color-underline);
+}
+
+.navbar-brand>img {
+  color: var(--color-background);
+}
+
+.navbar {
+  border: none;
+}
+
+.subnav {
+  border-top: 1px solid var(--color-underline);
+  background-color: var(--color-background-subnav);
+}
+
+.sidenav, .fixed_header, .toc {
+  background-color: var(--color-background);
+}
+
+.navbar-inverse {
+  background-color: var(--color-background-dark);
+  z-index: 100;
+}
+
+.navbar-inverse .navbar-nav>li>a, .navbar-inverse .navbar-text {
+  color: var(--color-navbar);
+  background-color: var(--color-background-dark);
+  border-bottom: 3px solid transparent;
+  padding-bottom: 12px;
+}
+
+.navbar-inverse .navbar-nav>li>a:focus, .navbar-inverse .navbar-nav>li>a:hover {
+  color: var(--color-foreground);
+  background-color: var(--color-background-dark);
+  border-bottom: 3px solid var(--color-background-subnav);
+  transition: all ease 0.25s;
+}
+
+.navbar-inverse .navbar-nav>.active>a, .navbar-inverse .navbar-nav>.active>a:focus, .navbar-inverse .navbar-nav>.active>a:hover {
+  color: var(--color-foreground);
+  background-color: var(--color-background-dark);
+  border-bottom: 3px solid var(--color-foreground);
+  transition: all ease 0.25s;
+}
+
+.navbar-form .form-control {
+  border: none;
+  border-radius: 0;
+}
+
+.light-theme .navbar-brand svg {
+  filter: brightness(20%);
+}
+
+.toc .level1>li {
+  font-weight: 400;
+}
+
+.toc .nav>li>a {
+  color: var(--color-foreground);
+}
+
+.sidefilter {
+  background-color: var(--color-background);
+  border-left: none;
+  border-right: none;
+}
+
+.sidefilter {
+  background-color: var(--color-background);
+  border-left: none;
+  border-right: none;
+}
+
+.toc-filter {
+  padding: 10px;
+  margin: 0;
+  background-color: var(--color-background);
+}
+
+.toc-filter>input {
+  border: none;
+  border-radius: unset;
+  background-color: var(--color-background-subnav);
+  padding: 5px 0 5px 20px;
+  font-size: 90%
+}
+
+.toc-filter>.clear-icon {
+  position: absolute;
+  top: 17px;
+  right: 15px;
+}
+
+.toc-filter>input:focus {
+  color: var(--color-foreground);
+  transition: all ease 0.25s;
+}
+
+.toc-filter>.filter-icon {
+  display: none;
+}
+
+.sidetoc>.toc {
+  background-color: var(--color-background);
+  overflow-x: hidden;
+}
+
+.sidetoc {
+  background-color: var(--color-background);
+  border: none;
+}
+
+.alert {
+  background-color: inherit;
+  border: none;
+  padding: 10px 0;
+  border-radius: 0;
+}
+
+.alert>p {
+  margin-bottom: 0;
+  padding: 5px 10px;
+  border-bottom: 1px solid;
+  background-color: var(--color-background-dark);
+}
+
+.alert>h5 {
+  padding: 10px 15px;
+  margin-top: 0;
+  margin-bottom: 0;
+  text-transform: uppercase;
+  font-weight: bold;
+  border-top: 2px solid;
+  background-color: var(--color-background-dark);
+  border-radius: none;
+}
+
+.alert>ul {
+  margin-bottom: 0;
+  padding: 5px 40px;
+}
+
+.alert-info {
+  color: #1976d2;
+}
+
+.alert-warning {
+  color: #f57f17;
+}
+
+.alert-danger {
+  color: #d32f2f;
+}
+
+pre {
+  padding: 9.5px;
+  margin: 0 0 10px;
+  font-size: 13px;
+  word-break: break-all;
+  word-wrap: break-word;
+  background-color: var(--color-background-dark);
+  border-radius: 0;
+  border: none;
+}
+
+code {
+  background: var(--color-background-dark) !important;
+  border-radius: 2px;
+}
+
+.hljs {
+  color: var(--color-foreground);
+}
+
+.toc .nav>li.active>.expand-stub::before, .toc .nav>li.in>.expand-stub::before, .toc .nav>li.in.active>.expand-stub::before, .toc .nav>li.filtered>.expand-stub::before {
+  content: "▾";
+}
+
+.toc .nav>li>.expand-stub::before, .toc .nav>li.active>.expand-stub::before {
+  content: "▸";
+}
+
+.affix ul ul>li>a:before {
+  content: "|";
+}
+
+.breadcrumb {
+  background-color: var(--color-background-subnav);
+}
+
+.breadcrumb .label.label-primary {
+  background: #444;
+  border-radius: 0;
+  font-weight: normal;
+  font-size: 100%;
+}
+
+#breadcrumb .breadcrumb>li a {
+  border-radius: 0;
+  font-weight: normal;
+  font-size: 85%;
+  display: inline;
+  padding: 0 .6em 0;
+  line-height: 1;
+  text-align: center;
+  white-space: nowrap;
+  vertical-align: baseline;
+  color: var(--color-breadcrumb);
+}
+
+#breadcrumb .breadcrumb>li a:hover {
+  color: var(--color-foreground);
+  transition: all ease 0.25s;
+}
+
+.breadcrumb>li+li:before {
+  content: "⯈";
+  font-size: 75%;
+  color: var(--color-background-dark);
+  padding: 0;
+}
+
+.light-theme .breadcrumb>li+li:before {
+  color: var(--color-foreground)
+ }
+
+.toc .level1>li {
+  font-weight: 600;
+  font-size: 130%;
+  padding-left: 5px;
+}
+
+.footer {
+  border-top: none;
+  background-color: var(--color-background-dark);
+  padding: 15px 0;
+  font-size: 90%;
+}
+
+.toc .nav>li>a:hover, .toc .nav>li>a:focus {
+  color: var(--color-toc-hover);
+  transition: all ease 0.1s;
+}
+
+.form-control {
+  background-color: var(--color-background-subnav);
+  border: none;
+  border-radius: 0;
+  -webkit-box-shadow: none;
+  box-shadow: none;
+}
+
+.form-control:focus {
+  border-color: #66afe9;
+  outline: 0;
+  -webkit-box-shadow: none;
+  box-shadow: none;
+}
+
+input#search-query:focus {
+  color: var(--color-foreground);
+}
+
+.table-bordered, .table-bordered>tbody>tr>td, .table-bordered>tbody>tr>th, .table-bordered>tfoot>tr>td, .table-bordered>tfoot>tr>th, .table-bordered>thead>tr>td, .table-bordered>thead>tr>th {
+  border: 1px solid var(--color-background-dark);
+}
+
+.table-striped>tbody>tr:nth-of-type(odd) {
+  background-color: var(--color-background-table-alt);
+}
+
+blockquote {
+  padding: 10px 20px;
+  margin: 0 0 10px;
+  font-size: 110%;
+  border-left: 5px solid var(--color-background-quote);
+  color: var(--color-background-quote);
+}
+
+.pagination>.disabled>a, .pagination>.disabled>a:focus, .pagination>.disabled>a:hover, .pagination>.disabled>span, .pagination>.disabled>span:focus, .pagination>.disabled>span:hover {
+  background-color: var(--color-background-subnav);
+  border-color: var(--color-background-subnav);
+}
+
+.breadcrumb>li, .pagination {
+  display: inline;
+}
+
+.tabGroup a[role="tab"] {
+  border-bottom: 2px solid var(--color-background-dark);
+}
+
+.tabGroup a[role="tab"][aria-selected="true"] {
+  color: var(--color-foreground);
+}
+
+.tabGroup section[role="tabpanel"] {
+  border: 1px solid var(--color-background-dark);
+}
+
+.sideaffix > div.contribution > ul > li > a.contribution-link:hover {
+  background-color: var(--color-background);
+}
+
+.switch {
+  position: relative;
+  display: inline-block;
+  width: 40px;
+  height: 20px;
+}
+
+.switch input { 
+  opacity: 0;
+  width: 0;
+  height: 0;
+}
+
+.slider {
+  position: absolute;
+  cursor: pointer;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background-color: #ccc;
+  -webkit-transition: .4s;
+  transition: .4s;
+}
+
+.slider:before {
+  position: absolute;
+  content: "";
+  height: 14px;
+  width: 14px;
+  left: 4px;
+  bottom: 3px;
+  background-color: white;
+  -webkit-transition: .4s;
+  transition: .4s;
+}
+
+input:checked + .slider {
+  background-color: #337ab7;
+}
+
+input:focus + .slider {
+  box-shadow: 0 0 1px #337ab7;
+}
+
+input:checked + .slider:before {
+  -webkit-transform: translateX(19px);
+  -ms-transform: translateX(19px);
+  transform: translateX(19px);
+}
+
+/* Rounded sliders */
+.slider.round {
+  border-radius: 20px;
+}
+
+.slider.round:before {
+  border-radius: 50%;
+}
+.toggle-mode .icon {
+  display: inline-block;
+}
+
+.toggle-mode .icon i {
+  font-style: normal;
+  font-size: 17px;
+  display: inline-block;
+  padding-right: 7px;
+  padding-left: 7px;
+  vertical-align: middle;
+}
+
+@media (min-width: 1600px) {
+  .container {
+    width: 100%;
+  }
+  .sidefilter {
+    width: 18%;
+  }
+  .sidetoc {
+    width: 18%;
+  }
+  .article.grid-right {
+    margin-left: 19%;
+  }
+  .sideaffix {
+    width: 11.5%;
+  }
+  .affix ul>li.active>a {
+    white-space: initial;
+  }
+  .affix ul>li>a {
+    width: 99%;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+  }
+}

Robust.Docfx/templates/darkfx/styles/toggle-theme.js

@@ -0,0 +1,35 @@
+const sw = document.getElementById("switch-style"), sw_mobile = document.getElementById("switch-style-m"), b = document.body;
+if (b) {
+  function toggleTheme(target, dark) {
+    target.classList.toggle("dark-theme", dark)
+    target.classList.toggle("light-theme", !dark)
+  }
+
+  function switchEventListener() {
+    toggleTheme(b, this.checked);
+    if (window.localStorage) {
+      this.checked ? localStorage.setItem("theme", "dark-theme") : localStorage.setItem("theme", "light-theme")
+    }
+  }
+
+  var isDarkTheme = !window.localStorage || !window.localStorage.getItem("theme") || window.localStorage && localStorage.getItem("theme") === "dark-theme";
+
+  if(sw && sw_mobile){
+    sw.checked = isDarkTheme;
+    sw_mobile.checked = isDarkTheme;
+
+    sw.addEventListener("change", switchEventListener);
+    sw_mobile.addEventListener("change", switchEventListener);
+    
+    // sync state between switches
+    sw.addEventListener("change", function() {
+      sw_mobile.checked = this.checked;
+    });
+
+    sw_mobile.addEventListener("change", function() {
+      sw.checked = this.checked;
+    });
+  }
+
+  toggleTheme(b, isDarkTheme);
+}

Robust.Docfx/toc.yml

@@ -0,0 +1,29 @@
+- name: Articles
+  href: articles/
+  
+# Client 
+- name: Robust.Client 
+  href: api/Robust.Client/
+  homepage: api/Robust.Client/Robust.Client.html
+- name: Robust.Client.WebView
+  href: api/Robust.Client.WebView/
+
+#Loader Api
+- name: Robust.LoaderApi
+  href: api/Robust.LoaderApi/Robust.LoaderApi/
+  
+# Server
+- name: Robust.Server
+  href: api/Robust.Server/
+
+# Shared 
+- name: Robust.Shared
+  href: api/Robust.Shared/
+- name: Robust.Shared.Maths
+  href: api/Robust.Shared.Maths/
+- name: Robust.Shared.Scripting
+  href: api/Robust.Shared.Scripting/
+
+# Unit testing
+- name: Robust.UnitTesting
+  href: api/Robust.UnitTesting/

Robust.Server/BaseServer.cs

@@ -66,18 +66,17 @@ namespace Robust.Server
 
         [Dependency] private readonly IConfigurationManagerInternal _config = default!;
         [Dependency] private readonly IServerEntityManager _entityManager = default!;
-        [Dependency] private readonly IEntityLookup _lookup = default!;
         [Dependency] private readonly ILogManager _log = default!;
         [Dependency] private readonly IRobustSerializer _serializer = default!;
         [Dependency] private readonly IGameTiming _time = default!;
         [Dependency] private readonly IResourceManagerInternal _resources = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
-        [Dependency] private readonly ITimerManager timerManager = default!;
+        [Dependency] private readonly ITimerManager _timerManager = default!;
         [Dependency] private readonly IServerGameStateManager _stateManager = default!;
         [Dependency] private readonly IServerNetManager _network = default!;
         [Dependency] private readonly ISystemConsoleManager _systemConsole = default!;
         [Dependency] private readonly ITaskManager _taskManager = default!;
-        [Dependency] private readonly IRuntimeLog runtimeLog = default!;
+        [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
         [Dependency] private readonly IModLoaderInternal _modLoader = default!;
         [Dependency] private readonly IWatchdogApi _watchdogApi = default!;
         [Dependency] private readonly HubManager _hubManager = default!;
@@ -127,7 +126,7 @@ namespace Robust.Server
             else
                 Logger.InfoS("srv", $"{reason}, shutting down...");
 
-            _shutdownReason = reason;
+            _shutdownReason = reason ?? "Shutting down";
 
             if (_mainLoop != null) _mainLoop.Running = false;
             if (_logHandler != null)
@@ -344,7 +343,6 @@ namespace Robust.Server
             _consoleHost.Initialize();
             _entityManager.Startup();
             _mapManager.Startup();
-            IoCManager.Resolve<IEntityLookup>().Startup();
             _stateManager.Initialize();
 
             var reg = _entityManager.ComponentFactory.GetRegistration<TransformComponent>();
@@ -603,7 +601,6 @@ namespace Robust.Server
             _network.Shutdown($"Server shutting down: {_shutdownReason}");
 
             // shutdown entities
-            IoCManager.Resolve<IEntityLookup>().Shutdown();
             _entityManager.Cleanup();
 
             if (_config.GetCVar(CVars.LogRuntimeLog))
@@ -614,7 +611,7 @@ namespace Robust.Server
                 Directory.CreateDirectory(relPath);
                 var pathToWrite = Path.Combine(relPath,
                     "Runtime-" + DateTime.Now.ToString("yyyy-MM-dd-THH-mm-ss") + ".txt");
-                File.WriteAllText(pathToWrite, runtimeLog.Display(), EncodingHelpers.UTF8);
+                File.WriteAllText(pathToWrite, _runtimeLog.Display(), EncodingHelpers.UTF8);
             }
 
             AppDomain.CurrentDomain.ProcessExit -= ProcessExiting;
@@ -660,7 +657,7 @@ namespace Robust.Server
             using (TickUsage.WithLabels("Timers").NewTimer())
             {
                 _consoleHost.CommandBufferExecute();
-                timerManager.UpdateTimers(frameEventArgs);
+                _timerManager.UpdateTimers(frameEventArgs);
             }
 
             using (TickUsage.WithLabels("AsyncTasks").NewTimer())
@@ -671,8 +668,6 @@ namespace Robust.Server
             // Pass Histogram into the IEntityManager.Update so it can do more granular measuring.
             _entityManager.TickUpdate(frameEventArgs.DeltaSeconds, noPredictions: false, TickUsage);
 
-            _lookup.Update();
-
             using (TickUsage.WithLabels("PostEngine").NewTimer())
             {
                 _modLoader.BroadcastUpdate(ModUpdateLevel.PostEngine, frameEventArgs);

Robust.Server/Bql/BqlQuerySelector.Builtin.cs

@@ -311,7 +311,7 @@ namespace Robust.Server.Bql
         public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
         {
             var radius = (float)(double)arguments[0];
-            var entityLookup = IoCManager.Resolve<IEntityLookup>();
+            var entityLookup = EntitySystem.Get<EntityLookupSystem>();
 
             // TODO: Make this a foreach and reduce LINQ chain because it'll allocate a LOT
             //BUG: GetEntitiesInRange effectively uses manhattan distance. This is not intended, near is supposed to be circular.

Robust.Server/Console/Commands/MapCommands.cs

@@ -218,7 +218,11 @@ namespace Robust.Server.Console.Commands
             }
 
             IoCManager.Resolve<IMapLoader>().LoadMap(mapId, args[1]);
-            shell.WriteLine($"Map {mapId} has been loaded from {args[1]}.");
+
+            if (mapManager.MapExists(mapId))
+                shell.WriteLine($"Map {mapId} has been loaded from {args[1]}.");
+            else
+                shell.WriteError($"Error while loading map from {args[1]}.");
         }
     }
 
@@ -354,8 +358,8 @@ namespace Robust.Server.Console.Commands
                 msg.AppendFormat("{0}: init: {1}, paused: {2}, ent: {3}, grids: {4}\n",
                     mapId, mapManager.IsMapInitialized(mapId),
                     mapManager.IsMapPaused(mapId),
-                    string.Join(",", mapManager.GetAllMapGrids(mapId).Select(grid => grid.Index)),
-                    mapManager.GetMapEntityId(mapId));
+                    mapManager.GetMapEntityId(mapId),
+                    string.Join(",", mapManager.GetAllMapGrids(mapId).Select(grid => grid.Index)));
             }
 
             shell.WriteLine(msg.ToString());
@@ -377,7 +381,7 @@ namespace Robust.Server.Console.Commands
             foreach (var grid in mapManager.GetAllGrids().OrderBy(grid => grid.Index.Value))
             {
                 msg.AppendFormat("{0}: map: {1}, ent: {2}, pos: {3} \n",
-                    grid.Index, grid.ParentMapId, grid.WorldPosition, grid.GridEntityId);
+                    grid.Index, grid.ParentMapId, grid.GridEntityId, grid.WorldPosition);
             }
 
             shell.WriteLine(msg.ToString());

Robust.Server/GameObjects/EntitySystems/PhysicsSystem.cs

@@ -1,4 +1,4 @@
-using JetBrains.Annotations;
+using JetBrains.Annotations;
 using Robust.Server.Physics;
 using Robust.Shared;
 using Robust.Shared.Configuration;
@@ -37,7 +37,7 @@ namespace Robust.Server.GameObjects
             collideComp.BodyType = BodyType.Static;
         }
 
-        protected override void HandleMapCreated(object? sender, MapEventArgs eventArgs)
+        protected override void HandleMapCreated(MapChangedEvent eventArgs)
         {
             if (eventArgs.Map == MapId.Nullspace) return;
             var mapUid = MapManager.GetMapEntityIdOrThrow(eventArgs.Map);

Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -176,7 +176,7 @@ namespace Robust.Server.GameObjects
 
         public BoundUserInterface? GetUiOrNull(EntityUid uid, object uiKey, ServerUserInterfaceComponent? ui = null)
         {
-            return TryGetUi(uid, uiKey, out var bui)
+            return TryGetUi(uid, uiKey, out var bui, ui)
                 ? bui
                 : null;
         }
@@ -185,12 +185,12 @@ namespace Robust.Server.GameObjects
         {
             bui = null;
 
-            return Resolve(uid, ref ui) && ui.TryGetBoundUserInterface(uiKey, out bui);
+            return Resolve(uid, ref ui, false) && ui.TryGetBoundUserInterface(uiKey, out bui);
         }
 
         public bool IsUiOpen(EntityUid uid, object uiKey, ServerUserInterfaceComponent? ui = null)
         {
-            if (!Resolve(uid, ref ui))
+            if (!Resolve(uid, ref ui, false))
                 return false;
 
             if (!TryGetUi(uid, uiKey, out var bui, ui))
@@ -201,7 +201,7 @@ namespace Robust.Server.GameObjects
 
         public bool TrySetUiState(EntityUid uid, object uiKey, BoundUserInterfaceState state, IPlayerSession? session = null, ServerUserInterfaceComponent? ui = null)
         {
-            if (!Resolve(uid, ref ui))
+            if (!Resolve(uid, ref ui, false))
                 return false;
 
             if (!TryGetUi(uid, uiKey, out var bui, ui))

Robust.Server/GameObjects/ServerEntityManager.cs

@@ -37,7 +37,6 @@ namespace Robust.Server.GameObjects
         public override void Initialize()
         {
             SetupNetworking();
-            ReceivedComponentMessage += (_, compMsg) => DispatchComponentMessage(compMsg);
             ReceivedSystemMessage += (_, systemMsg) => EventBus.RaiseEvent(EventSource.Network, systemMsg);
 
             base.Initialize();
@@ -98,9 +97,6 @@ namespace Robust.Server.GameObjects
 
         public override IEntityNetworkManager EntityNetManager => this;
 
-        /// <inheritdoc />
-        public event EventHandler<NetworkComponentMessage>? ReceivedComponentMessage;
-
         /// <inheritdoc />
         public event EventHandler<object>? ReceivedSystemMessage;
 
@@ -207,35 +203,6 @@ namespace Robust.Server.GameObjects
             }
         }
 
-        /// <inheritdoc />
-        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
-        public void SendComponentNetworkMessage(INetChannel? channel, EntityUid entity, IComponent component,
-            ComponentMessage message)
-        {
-            if (_networkManager.IsClient)
-                return;
-
-            var netId = ComponentFactory.GetRegistration(component.GetType()).NetID;
-
-            if (!netId.HasValue)
-                throw new ArgumentException($"Component {component.GetType()} does not have a NetID.", nameof(component));
-
-            var msg = _networkManager.CreateNetMessage<MsgEntity>();
-            msg.Type = EntityMessageType.ComponentMessage;
-            msg.EntityUid = entity;
-            msg.NetId = netId.Value;
-            msg.ComponentMessage = message;
-            msg.SourceTick = _gameTiming.CurTick;
-
-            // Logger.DebugS("net.ent", "Sending: {0}", msg);
-
-            //Send the message
-            if (channel == null)
-                _networkManager.ServerSendToAll(msg);
-            else
-                _networkManager.ServerSendMessage(msg, channel);
-        }
-
         /// <inheritdoc />
         public void SendSystemNetworkMessage(EntityEventArgs message)
         {
@@ -302,10 +269,6 @@ namespace Robust.Server.GameObjects
             {
                 switch (message.Type)
                 {
-                    case EntityMessageType.ComponentMessage:
-                        ReceivedComponentMessage?.Invoke(this, new NetworkComponentMessage(message, player));
-                        return;
-
                     case EntityMessageType.SystemMessage:
                         var msg = message.SystemMessage;
                         var sessionType = typeof(EntitySessionMessage<>).MakeGenericType(msg.GetType());

Robust.Server/GameStates/PVSCollection.cs

@@ -8,6 +8,7 @@ using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Players;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 
 namespace Robust.Server.GameStates;
 
@@ -32,6 +33,13 @@ public interface IPVSCollection
     /// </summary>
     /// <param name="tick">The <see cref="GameTick"/> before which all deletions should be removed.</param>
     public void CullDeletionHistoryUntil(GameTick tick);
+
+    public bool IsDirty(IChunkIndexLocation location);
+
+    public bool MarkDirty(IChunkIndexLocation location);
+
+    public void ClearDirty();
+
 }
 
 public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : IComparable<TIndex>, IEquatable<TIndex>
@@ -93,6 +101,16 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
     /// </summary>
     private readonly Dictionary<TIndex, GameTick> _removalBuffer = new();
 
+    /// <summary>
+    /// To avoid re-allocating the hashset every tick we'll just store it.
+    /// </summary>
+    private HashSet<TIndex> _changedIndices = new();
+
+    /// <summary>
+    /// A set of all chunks changed last tick
+    /// </summary>
+    private HashSet<IChunkIndexLocation> _dirtyChunks = new();
+
     public PVSCollection()
     {
         IoCManager.InjectDependencies(this);
@@ -100,13 +118,17 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
 
     public void Process()
     {
-        var changedIndices = new HashSet<TIndex>(_locationChangeBuffer.Keys);
+        _changedIndices.EnsureCapacity(_locationChangeBuffer.Count);
+
+        foreach (var (key, loc) in _locationChangeBuffer)
+        {
+            _changedIndices.Add(key);
+        }
 
-        var changedChunkLocations = new HashSet<IIndexLocation>();
         foreach (var (index, tick) in _removalBuffer)
         {
             //changes dont need to be computed if we are removing the index anyways
-            if (changedIndices.Remove(index) && !_indexLocations.ContainsKey(index))
+            if (_changedIndices.Remove(index) && !_indexLocations.ContainsKey(index))
             {
                 //this index wasnt added yet, so we can safely just skip the deletion
                 continue;
@@ -114,37 +136,50 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
 
             var location = RemoveIndexInternal(index);
             if(location is GridChunkLocation or MapChunkLocation)
-                changedChunkLocations.Add(location);
+                _dirtyChunks.Add((IChunkIndexLocation) location);
             _deletionHistory.Add((tick, index));
         }
 
         // remove empty chunk-subsets
-        foreach (var chunkLocation in changedChunkLocations)
+        foreach (var chunkLocation in _dirtyChunks)
         {
             switch (chunkLocation)
             {
                 case GridChunkLocation gridChunkLocation:
-                    if (_gridChunkContents[gridChunkLocation.GridId][gridChunkLocation.ChunkIndices].Count == 0)
-                        _gridChunkContents[gridChunkLocation.GridId].Remove(gridChunkLocation.ChunkIndices);
+                    if(!_gridChunkContents.TryGetValue(gridChunkLocation.GridId, out var gridChunks)) continue;
+                    if(!gridChunks.TryGetValue(gridChunkLocation.ChunkIndices, out var chunk)) continue;
+                    if(chunk.Count == 0)
+                        gridChunks.Remove(gridChunkLocation.ChunkIndices);
                     break;
                 case MapChunkLocation mapChunkLocation:
-                    if (_mapChunkContents[mapChunkLocation.MapId][mapChunkLocation.ChunkIndices].Count == 0)
-                        _mapChunkContents[mapChunkLocation.MapId].Remove(mapChunkLocation.ChunkIndices);
+                    if(!_mapChunkContents.TryGetValue(mapChunkLocation.MapId, out var mapChunks)) continue;
+                    if(!mapChunks.TryGetValue(mapChunkLocation.ChunkIndices, out chunk)) continue;
+                    if(chunk.Count == 0)
+                        mapChunks.Remove(mapChunkLocation.ChunkIndices);
                     break;
             }
         }
 
-        foreach (var index in changedIndices)
+        foreach (var index in _changedIndices)
         {
-            RemoveIndexInternal(index);
+            var oldLoc = RemoveIndexInternal(index);
+            if(oldLoc is GridChunkLocation or MapChunkLocation)
+                _dirtyChunks.Add((IChunkIndexLocation) oldLoc);
 
-            AddIndexInternal(index, _locationChangeBuffer[index]);
+            AddIndexInternal(index, _locationChangeBuffer[index], _dirtyChunks);
         }
 
+        _changedIndices.Clear();
         _locationChangeBuffer.Clear();
         _removalBuffer.Clear();
     }
 
+    public bool IsDirty(IChunkIndexLocation location) => _dirtyChunks.Contains(location);
+
+    public bool MarkDirty(IChunkIndexLocation location) => _dirtyChunks.Add(location);
+
+    public void ClearDirty() => _dirtyChunks.Clear();
+
     public bool TryGetChunk(MapId mapId, Vector2i chunkIndices, [NotNullWhen(true)] out HashSet<TIndex>? indices) =>
         _mapChunkContents[mapId].TryGetValue(chunkIndices, out indices);
 
@@ -153,7 +188,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
 
     public HashSet<TIndex>.Enumerator GetElementsForSession(ICommonSession session) => _localOverrides[session].GetEnumerator();
 
-    private void AddIndexInternal(TIndex index, IIndexLocation location)
+    private void AddIndexInternal(TIndex index, IIndexLocation location, HashSet<IChunkIndexLocation> dirtyChunks)
     {
         switch (location)
         {
@@ -162,10 +197,10 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
                 break;
             case GridChunkLocation gridChunkLocation:
                 // might be gone due to grid-deletions
-                if(!_gridChunkContents.ContainsKey(gridChunkLocation.GridId)) return;
-                if(!_gridChunkContents[gridChunkLocation.GridId].ContainsKey(gridChunkLocation.ChunkIndices))
-                    _gridChunkContents[gridChunkLocation.GridId][gridChunkLocation.ChunkIndices] = new();
-                _gridChunkContents[gridChunkLocation.GridId][gridChunkLocation.ChunkIndices].Add(index);
+                if(!_gridChunkContents.TryGetValue(gridChunkLocation.GridId, out var gridChunk)) return;
+                var gridLoc = gridChunk.GetOrNew(gridChunkLocation.ChunkIndices);
+                gridLoc.Add(index);
+                dirtyChunks.Add(gridChunkLocation);
                 break;
             case LocalOverride localOverride:
                 // might be gone due to disconnects
@@ -174,10 +209,10 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
                 break;
             case MapChunkLocation mapChunkLocation:
                 // might be gone due to map-deletions
-                if(!_mapChunkContents.ContainsKey(mapChunkLocation.MapId)) return;
-                if(!_mapChunkContents[mapChunkLocation.MapId].ContainsKey(mapChunkLocation.ChunkIndices))
-                    _mapChunkContents[mapChunkLocation.MapId][mapChunkLocation.ChunkIndices] = new();
-                _mapChunkContents[mapChunkLocation.MapId][mapChunkLocation.ChunkIndices].Add(index);
+                if(!_mapChunkContents.TryGetValue(mapChunkLocation.MapId, out var mapChunk)) return;
+                var mapLoc = mapChunk.GetOrNew(mapChunkLocation.ChunkIndices);
+                mapLoc.Add(index);
+                dirtyChunks.Add(mapChunkLocation);
                 break;
         }
 
@@ -320,6 +355,9 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         if(!removeFromOverride && IsOverride(index))
             return;
 
+        if (_indexLocations.TryGetValue(index, out var oldLocation) &&
+            oldLocation is GlobalOverride) return;
+
         RegisterUpdate(index, new GlobalOverride());
     }
 
@@ -334,6 +372,10 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         if(!removeFromOverride && IsOverride(index))
             return;
 
+        if (_indexLocations.TryGetValue(index, out var oldLocation) &&
+            oldLocation is LocalOverride local &&
+            local.Session == session) return;
+
         RegisterUpdate(index, new LocalOverride(session));
     }
 
@@ -361,6 +403,20 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         UpdateIndex(index, mapCoordinates.MapId, mapIndices, true); //skip overridecheck bc we already did it (saves some dict lookups)
     }
 
+    public IChunkIndexLocation GetChunkIndex(EntityCoordinates coordinates)
+    {
+        var gridId = coordinates.GetGridId(_entityManager);
+        if (gridId != GridId.Invalid)
+        {
+            var gridIndices = GetChunkIndices(coordinates.Position);
+            return new GridChunkLocation(gridId, gridIndices);
+        }
+
+        var mapCoordinates = coordinates.ToMap(_entityManager);
+        var mapIndices = GetChunkIndices(coordinates.Position);
+        return new MapChunkLocation(mapCoordinates.MapId, mapIndices);
+    }
+
     /// <summary>
     /// Updates an <see cref="TIndex"/> using the provided <see cref="gridId"/> and <see cref="chunkIndices"/>.
     /// </summary>
@@ -373,6 +429,11 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         if(!removeFromOverride && IsOverride(index))
             return;
 
+        if (_indexLocations.TryGetValue(index, out var oldLocation) &&
+            oldLocation is GridChunkLocation oldGrid &&
+            oldGrid.ChunkIndices == chunkIndices &&
+            oldGrid.GridId == gridId) return;
+
         RegisterUpdate(index, new GridChunkLocation(gridId, chunkIndices));
     }
 
@@ -388,13 +449,16 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
         if(!removeFromOverride && IsOverride(index))
             return;
 
+        if (_indexLocations.TryGetValue(index, out var oldLocation) &&
+            oldLocation is MapChunkLocation oldMap &&
+            oldMap.ChunkIndices == chunkIndices &&
+            oldMap.MapId == mapId) return;
+
         RegisterUpdate(index, new MapChunkLocation(mapId, chunkIndices));
     }
 
     private void RegisterUpdate(TIndex index, IIndexLocation location)
     {
-        if(_indexLocations.TryGetValue(index, out var oldLocation) && oldLocation == location) return;
-
         _locationChangeBuffer[index] = location;
     }
 

Robust.Server/GameStates/PVSSystem.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using Microsoft.Extensions.ObjectPool;
 using NetSerializer;
@@ -7,7 +8,6 @@ using Robust.Server.GameObjects;
 using Robust.Server.Player;
 using Robust.Shared;
 using Robust.Shared.Configuration;
-using Robust.Shared.Containers;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Map;
@@ -20,11 +20,13 @@ namespace Robust.Server.GameStates;
 
 internal sealed partial class PVSSystem : EntitySystem
 {
-    [Shared.IoC.Dependency] private readonly IMapManager _mapManager = default!;
+    [Shared.IoC.Dependency] private readonly IMapManagerInternal _mapManager = default!;
     [Shared.IoC.Dependency] private readonly IPlayerManager _playerManager = default!;
     [Shared.IoC.Dependency] private readonly IConfigurationManager _configManager = default!;
+    [Shared.IoC.Dependency] private readonly IServerEntityManager _serverEntManager = default!;
     [Shared.IoC.Dependency] private readonly IServerGameStateManager _stateManager = default!;
     [Shared.IoC.Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Shared.IoC.Dependency] private readonly INetConfigurationManager _netConfigManager = default!;
 
     public const float ChunkSize = 8;
 
@@ -38,21 +40,17 @@ internal sealed partial class PVSSystem : EntitySystem
     /// </summary>
     public bool CullingEnabled { get; private set; }
 
-    /// <summary>
-    /// How many new entities we can send per tick (dont wanna nuke the clients mailbox).
-    /// </summary>
-    private int _newEntityBudget;
-
-    /// <summary>
-    /// How many entered entities can be sent per tick.
-    /// </summary>
-    private int _entityBudget;
-
     /// <summary>
     /// Size of the side of the view bounds square.
     /// </summary>
     private float _viewSize;
 
+    /// <summary>
+    /// If PVS disabled then we'll track if we've dumped all entities on the player.
+    /// This way any future ticks can be orders of magnitude faster as we only send what changes.
+    /// </summary>
+    public HashSet<ICommonSession> SeenAllEnts = new();
+
     /// <summary>
     /// All <see cref="Robust.Shared.GameObjects.EntityUid"/>s a <see cref="ICommonSession"/> saw last iteration.
     /// </summary>
@@ -80,34 +78,61 @@ internal sealed partial class PVSSystem : EntitySystem
     private readonly ObjectPool<HashSet<int>> _playerChunkPool =
         new DefaultObjectPool<HashSet<int>>(new SetPolicy<int>(), MaxVisPoolSize);
 
-    private readonly ObjectPool<List<EntityUid>> _chunkOrderPool =
-        new DefaultObjectPool<List<EntityUid>>(new ListPolicy<EntityUid>(), MaxVisPoolSize);
+    private readonly ObjectPool<RobustTree<EntityUid>> _treePool =
+        new DefaultObjectPool<RobustTree<EntityUid>>(new TreePolicy<EntityUid>(), MaxVisPoolSize);
+
+    private readonly ObjectPool<Dictionary<MapChunkLocation, int>> _mapChunkPool =
+        new DefaultObjectPool<Dictionary<MapChunkLocation, int>>(
+            new ChunkPoolPolicy<MapChunkLocation>(), 256);
+
+    private readonly ObjectPool<Dictionary<GridChunkLocation, int>> _gridChunkPool =
+        new DefaultObjectPool<Dictionary<GridChunkLocation, int>>(
+            new ChunkPoolPolicy<GridChunkLocation>(), 256);
+
+    private readonly Dictionary<uint, Dictionary<MapChunkLocation, int>> _mapIndices = new(4);
+    private readonly Dictionary<uint, Dictionary<GridChunkLocation, int>> _gridIndices = new(4);
+    private readonly List<(uint, IChunkIndexLocation)> _chunkList = new(64);
+    private readonly List<MapGrid> _gridsPool = new(8);
 
     public override void Initialize()
     {
         base.Initialize();
 
         _entityPvsCollection = RegisterPVSCollection<EntityUid>();
-        _mapManager.MapCreated += OnMapCreated;
-        _mapManager.MapDestroyed += OnMapDestroyed;
-        _mapManager.OnGridCreated += OnGridCreated;
-        _mapManager.OnGridRemoved += OnGridRemoved;
+
+        SubscribeLocalEvent<MapChangedEvent>(ev =>
+        {
+            if (ev.Created)
+                OnMapCreated(ev);
+            else
+                OnMapDestroyed(ev);
+        });
+
+        SubscribeLocalEvent<GridInitializeEvent>(OnGridCreated);
+        SubscribeLocalEvent<GridRemovalEvent>(OnGridRemoved);
+
         _playerManager.PlayerStatusChanged += OnPlayerStatusChanged;
         SubscribeLocalEvent<MoveEvent>(OnEntityMove);
+        SubscribeLocalEvent<EntParentChangedMessage>(OnParentChange);
         SubscribeLocalEvent<TransformComponent, ComponentStartup>(OnTransformStartup);
         EntityManager.EntityDeleted += OnEntityDeleted;
 
         _configManager.OnValueChanged(CVars.NetPVS, SetPvs, true);
         _configManager.OnValueChanged(CVars.NetMaxUpdateRange, OnViewsizeChanged, true);
-        _configManager.OnValueChanged(CVars.NetPVSNewEntityBudget, OnNewEntityBudgetChanged, true);
-        _configManager.OnValueChanged(CVars.NetPVSEntityBudget, OnEntityBudgetChanged, true);
 
         InitializeDirty();
     }
 
-    private void OnEntityBudgetChanged(int obj)
+    private void OnParentChange(ref EntParentChangedMessage ev)
     {
-        _entityBudget = obj;
+        if (_mapManager.IsGrid(ev.Entity) || _mapManager.IsMap(ev.Entity)) return;
+
+        // If parent changes then the RobustTree for that chunk will no longer be valid and we need to force it as dirty.
+        // Should still be at its old location as moveevent is called after.
+        var xform = Transform(ev.Entity);
+        var coordinates = _transform.GetMoverCoordinates(xform);
+        var index = _entityPvsCollection.GetChunkIndex(coordinates);
+        _entityPvsCollection.MarkDirty(index);
     }
 
     public override void Shutdown()
@@ -115,16 +140,11 @@ internal sealed partial class PVSSystem : EntitySystem
         base.Shutdown();
 
         UnregisterPVSCollection(_entityPvsCollection);
-        _mapManager.MapCreated -= OnMapCreated;
-        _mapManager.MapDestroyed -= OnMapDestroyed;
-        _mapManager.OnGridCreated -= OnGridCreated;
-        _mapManager.OnGridRemoved -= OnGridRemoved;
         _playerManager.PlayerStatusChanged -= OnPlayerStatusChanged;
         EntityManager.EntityDeleted -= OnEntityDeleted;
 
         _configManager.UnsubValueChanged(CVars.NetPVS, SetPvs);
         _configManager.UnsubValueChanged(CVars.NetMaxUpdateRange, OnViewsizeChanged);
-        _configManager.UnsubValueChanged(CVars.NetPVSEntityBudget, OnEntityBudgetChanged);
 
         ShutdownDirty();
     }
@@ -139,10 +159,6 @@ internal sealed partial class PVSSystem : EntitySystem
         CullingEnabled = value;
     }
 
-    private void OnNewEntityBudgetChanged(int obj)
-    {
-        _newEntityBudget = obj;
-    }
 
     public void ProcessCollections()
     {
@@ -154,7 +170,26 @@ internal sealed partial class PVSSystem : EntitySystem
 
     public void Cleanup(IEnumerable<IPlayerSession> sessions)
     {
-        CleanupDirty(sessions);
+        var playerSessions = sessions.ToArray();
+
+        if (!CullingEnabled)
+        {
+            foreach (var player in playerSessions)
+            {
+                SeenAllEnts.Add(player);
+            }
+        }
+        else
+        {
+            SeenAllEnts.Clear();
+        }
+
+        CleanupDirty(playerSessions);
+
+        foreach (var collection in _pvsCollections)
+        {
+            collection.ClearDirty();
+        }
     }
 
     public void CullDeletionHistory(GameTick oldestAck)
@@ -242,16 +277,17 @@ internal sealed partial class PVSSystem : EntitySystem
         }
     }
 
-    private void OnGridRemoved(MapId mapId, GridId gridId)
+    private void OnGridRemoved(GridRemovalEvent ev)
     {
         foreach (var pvsCollection in _pvsCollections)
         {
-            pvsCollection.RemoveGrid(gridId);
+            pvsCollection.RemoveGrid(ev.GridId);
         }
     }
 
-    private void OnGridCreated(MapId mapId, GridId gridId)
+    private void OnGridCreated(GridInitializeEvent ev)
     {
+        var gridId = ev.GridId;
         foreach (var pvsCollection in _pvsCollections)
         {
             pvsCollection.AddGrid(gridId);
@@ -261,7 +297,7 @@ internal sealed partial class PVSSystem : EntitySystem
         _entityPvsCollection.UpdateIndex(euid);
     }
 
-    private void OnMapDestroyed(object? sender, MapEventArgs e)
+    private void OnMapDestroyed(MapChangedEvent e)
     {
         foreach (var pvsCollection in _pvsCollections)
         {
@@ -269,7 +305,7 @@ internal sealed partial class PVSSystem : EntitySystem
         }
     }
 
-    private void OnMapCreated(object? sender, MapEventArgs e)
+    private void OnMapCreated(MapChangedEvent e)
     {
         foreach (var pvsCollection in _pvsCollections)
         {
@@ -285,15 +321,24 @@ internal sealed partial class PVSSystem : EntitySystem
 
     public (List<(uint, IChunkIndexLocation)> , HashSet<int>[], EntityUid[][] viewers) GetChunks(IPlayerSession[] sessions)
     {
-        var chunkList = new List<(uint, IChunkIndexLocation)>();
         var playerChunks = new HashSet<int>[sessions.Length];
         var eyeQuery = EntityManager.GetEntityQuery<EyeComponent>();
         var transformQuery = EntityManager.GetEntityQuery<TransformComponent>();
         var viewerEntities = new EntityUid[sessions.Length][];
 
+        _chunkList.Clear();
         // Keep track of the index of each chunk we use for a faster index lookup.
-        var mapIndices = new Dictionary<uint, Dictionary<MapChunkLocation, int>>(4);
-        var gridIndices = new Dictionary<uint, Dictionary<GridChunkLocation, int>>(4);
+        // Pool it because this will allocate a lot across ticks as we scale in players.
+        foreach (var (_, chunks) in _mapIndices)
+            _mapChunkPool.Return(chunks);
+
+        foreach (var (_, chunks) in _gridIndices)
+            _gridChunkPool.Return(chunks);
+
+        _mapIndices.Clear();
+        _gridIndices.Clear();
+        var xformQuery = GetEntityQuery<TransformComponent>();
+        var physicsQuery = GetEntityQuery<PhysicsComponent>();
 
         for (int i = 0; i < sessions.Length; i++)
         {
@@ -301,8 +346,7 @@ internal sealed partial class PVSSystem : EntitySystem
             playerChunks[i] = _playerChunkPool.Get();
 
             var viewers = GetSessionViewers(session);
-            viewerEntities[i] = new EntityUid[viewers.Count];
-            viewers.CopyTo(viewerEntities[i]);
+            viewerEntities[i] = viewers;
 
             foreach (var eyeEuid in viewers)
             {
@@ -313,10 +357,10 @@ internal sealed partial class PVSSystem : EntitySystem
                     visMask = eyeComp.VisibilityMask;
 
                 // Get the nyoom dictionary for index lookups.
-                if (!mapIndices.TryGetValue(visMask, out var mapDict))
+                if (!_mapIndices.TryGetValue(visMask, out var mapDict))
                 {
-                    mapDict = new Dictionary<MapChunkLocation, int>(32);
-                    mapIndices[visMask] = mapDict;
+                    mapDict = _mapChunkPool.Get();
+                    _mapIndices[visMask] = mapDict;
                 }
 
                 var mapChunkEnumerator = new ChunkIndicesEnumerator(viewPos, range, ChunkSize);
@@ -332,21 +376,28 @@ internal sealed partial class PVSSystem : EntitySystem
                     }
                     else
                     {
-                        playerChunks[i].Add(chunkList.Count);
-                        mapDict.Add(chunkLocation, chunkList.Count);
-                        chunkList.Add(entry);
+                        playerChunks[i].Add(_chunkList.Count);
+                        mapDict.Add(chunkLocation, _chunkList.Count);
+                        _chunkList.Add(entry);
                     }
                 }
 
                 // Get the nyoom dictionary for index lookups.
-                if (!gridIndices.TryGetValue(visMask, out var gridDict))
+                if (!_gridIndices.TryGetValue(visMask, out var gridDict))
                 {
-                    gridDict = new Dictionary<GridChunkLocation, int>(32);
-                    gridIndices[visMask] = gridDict;
+                    gridDict = _gridChunkPool.Get();
+                    _gridIndices[visMask] = gridDict;
                 }
 
-                _mapManager.FindGridsIntersectingEnumerator(mapId, new Box2(viewPos - range, viewPos + range), out var gridEnumerator, true);
-                while (gridEnumerator.MoveNext(out var mapGrid))
+                _gridsPool.Clear();
+
+                foreach (var mapGrid in _mapManager.FindGridsIntersecting(
+                             mapId,
+                             new Box2(viewPos - range, viewPos + range),
+                             _gridsPool,
+                             xformQuery,
+                             physicsQuery,
+                             true))
                 {
                     var localPos = transformQuery.GetComponent(mapGrid.GridEntityId).InvWorldMatrix.Transform(viewPos);
 
@@ -364,22 +415,77 @@ internal sealed partial class PVSSystem : EntitySystem
                         }
                         else
                         {
-                            playerChunks[i].Add(chunkList.Count);
-                            gridDict.Add(chunkLocation, chunkList.Count);
-                            chunkList.Add(entry);
+                            playerChunks[i].Add(_chunkList.Count);
+                            gridDict.Add(chunkLocation, _chunkList.Count);
+                            _chunkList.Add(entry);
                         }
                     }
                 }
             }
-
-            _uidSetPool.Return(viewers);
         }
 
-        return (chunkList, playerChunks, viewerEntities);
+        return (_chunkList, playerChunks, viewerEntities);
     }
 
-    public (Dictionary<EntityUid, MetaDataComponent> mData, List<EntityUid> order)? CalculateChunk(IChunkIndexLocation chunkLocation, uint visMask, EntityQuery<TransformComponent> transform, EntityQuery<MetaDataComponent> metadata)
+    private Dictionary<(uint visMask, IChunkIndexLocation location), (Dictionary<EntityUid, MetaDataComponent> metadata,
+        RobustTree<EntityUid> tree)?> _previousTrees = new();
+
+    private HashSet<(uint visMask, IChunkIndexLocation location)> _reusedTrees = new();
+
+    public void RegisterNewPreviousChunkTrees(
+        List<(uint, IChunkIndexLocation)> chunks,
+        (Dictionary<EntityUid, MetaDataComponent> metadata, RobustTree<EntityUid> tree)?[] trees,
+        bool[] reuse)
     {
+        // For any chunks able to re-used we'll chuck them in a dictionary for faster lookup.
+        for (var i = 0; i < chunks.Count; i++)
+        {
+            var canReuse = reuse[i];
+            if (!canReuse) continue;
+
+            _reusedTrees.Add(chunks[i]);
+        }
+
+        var previousIndices = _previousTrees.Keys.ToArray();
+        foreach (var index in previousIndices)
+        {
+            // ReSharper disable once InconsistentlySynchronizedField
+            if(_reusedTrees.Contains(index)) continue;
+            var chunk = _previousTrees[index];
+            if (chunk.HasValue)
+            {
+                _chunkCachePool.Return(chunk.Value.metadata);
+                _treePool.Return(chunk.Value.tree);
+            }
+
+            if (!chunks.Contains(index))
+            {
+                _previousTrees.Remove(index);
+            }
+        }
+        _previousTrees.EnsureCapacity(chunks.Count);
+        for (int i = 0; i < chunks.Count; i++)
+        {
+            //this is a redundant assign if the tree has been reused. the assumption is that this is cheaper than a .Contains call
+            _previousTrees[chunks[i]] = trees[i];
+        }
+        // ReSharper disable once InconsistentlySynchronizedField
+        _reusedTrees.Clear();
+    }
+
+    public bool TryCalculateChunk(
+        IChunkIndexLocation chunkLocation,
+        uint visMask,
+        EntityQuery<TransformComponent> transform,
+        EntityQuery<MetaDataComponent> metadata,
+        out (Dictionary<EntityUid, MetaDataComponent> mData, RobustTree<EntityUid> tree)? result)
+    {
+        if (!_entityPvsCollection.IsDirty(chunkLocation) && _previousTrees.TryGetValue((visMask, chunkLocation), out var previousTree))
+        {
+            result = previousTree;
+            return true;
+        }
+
         var chunk = chunkLocation switch
         {
             GridChunkLocation gridChunkLocation => _entityPvsCollection.TryGetChunk(gridChunkLocation.GridId,
@@ -391,40 +497,38 @@ internal sealed partial class PVSSystem : EntitySystem
                 ? mapChunk
                 : null
         };
-        if (chunk == null) return null;
+        if (chunk == null)
+        {
+            result = null;
+            return false;
+        }
         var chunkSet = _chunkCachePool.Get();
-        var order = _chunkOrderPool.Get();
+        var tree = _treePool.Get();
         foreach (var uid in chunk)
         {
-            AddToChunkSetRecursively(in uid, visMask, order, chunkSet, transform, metadata);
+            AddToChunkSetRecursively(in uid, visMask, tree, chunkSet, transform, metadata);
         }
 
-        return (chunkSet, order);
+        result = (chunkSet, tree);
+        return false;
     }
 
-    public void ReturnToPool((Dictionary<EntityUid, MetaDataComponent> metadata, List<EntityUid> order)?[] chunkCache, HashSet<int>[] playerChunks)
+    public void ReturnToPool(HashSet<int>[] playerChunks)
     {
-        foreach (var chunk in chunkCache)
-        {
-            if(!chunk.HasValue) continue;
-            _chunkCachePool.Return(chunk.Value.metadata);
-            _chunkOrderPool.Return(chunk.Value.order);
-        }
-
         foreach (var playerChunk in playerChunks)
         {
             _playerChunkPool.Return(playerChunk);
         }
     }
 
-    private bool AddToChunkSetRecursively(in EntityUid uid, uint visMask, List<EntityUid> order, Dictionary<EntityUid, MetaDataComponent> set, EntityQuery<TransformComponent> transform,
+    private bool AddToChunkSetRecursively(in EntityUid uid, uint visMask, RobustTree<EntityUid> tree, Dictionary<EntityUid, MetaDataComponent> set, EntityQuery<TransformComponent> transform,
         EntityQuery<MetaDataComponent> metadata)
     {
         //are we valid?
         //sometimes uids gets added without being valid YET (looking at you mapmanager) (mapcreate & gridcreated fire before the uids becomes valid)
         if (!uid.IsValid()) return false;
 
-        if (set.ContainsKey(uid)) return false;
+        if (set.ContainsKey(uid)) return true;
 
         var mComp = metadata.GetComponent(uid);
 
@@ -437,19 +541,24 @@ internal sealed partial class PVSSystem : EntitySystem
 
         if (parent.IsValid() && //is it not a worldentity?
             !set.ContainsKey(parent) && //was the parent not yet added to toSend?
-            !AddToChunkSetRecursively(in parent, visMask, order, set, transform, metadata)) //did we just fail to add the parent?
+            !AddToChunkSetRecursively(in parent, visMask, tree, set, transform, metadata)) //did we just fail to add the parent?
             return false; //we failed? suppose we dont get added either
 
         //todo paul i want it to crash here if it gets added double bc that shouldnt happen and will add alot of unneeded cycles, make this a simpl assignment at some point maybe idk
-        order.Add(uid);
+        tree.Set(uid, parent);
         set.Add(uid, mComp);
         return true;
     }
 
     public (List<EntityState>? updates, List<EntityUid>? deletions) CalculateEntityStates(IPlayerSession session,
-        GameTick fromTick, GameTick toTick, (Dictionary<EntityUid, MetaDataComponent> metadata, List<EntityUid> order)?[] chunkCache, HashSet<int> chunkIndices, EntityQuery<MetaDataComponent> mQuery, EntityQuery<TransformComponent> tQuery, EntityUid[] viewerEntities)
+        GameTick fromTick, GameTick toTick,
+        (Dictionary<EntityUid, MetaDataComponent> metadata, RobustTree<EntityUid> tree)?[] chunkCache,
+        HashSet<int> chunkIndices, EntityQuery<MetaDataComponent> mQuery, EntityQuery<TransformComponent> tQuery,
+        EntityUid[] viewerEntities)
     {
         DebugTools.Assert(session.Status == SessionStatus.InGame);
+        var newEntityBudget = _netConfigManager.GetClientCVar(session.ConnectedClient, CVars.NetPVSNewEntityBudget);
+        var enteredEntityBudget = _netConfigManager.GetClientCVar(session.ConnectedClient, CVars.NetPVSEntityBudget);
         var newEntitiesSent = 0;
         var entitiesSent = 0;
         var playerVisibleSet = _playerVisibleSets[session];
@@ -461,10 +570,10 @@ internal sealed partial class PVSSystem : EntitySystem
         {
             var cache = chunkCache[i];
             if(!cache.HasValue) continue;
-            foreach (var uid in cache.Value.order)
+            foreach (var rootNode in cache.Value.tree.RootNodes)
             {
-                TryAddToVisibleEnts(in uid, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
-                    ref entitiesSent, mQuery, tQuery, cache.Value.metadata[uid]);
+                RecursivelyAddTreeNode(in rootNode, cache.Value.tree, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
+                        ref entitiesSent, cache.Value.metadata, in enteredEntityBudget, in newEntityBudget);
             }
         }
 
@@ -472,8 +581,8 @@ internal sealed partial class PVSSystem : EntitySystem
         while (globalEnumerator.MoveNext())
         {
             var uid = globalEnumerator.Current;
-            TryAddToVisibleEnts(in uid, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
-                ref entitiesSent, mQuery, tQuery, dontSkip: true, manualParents: true);
+            RecursivelyAddOverride(in uid, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
+                ref entitiesSent, mQuery, tQuery, in enteredEntityBudget, in newEntityBudget);
         }
         globalEnumerator.Dispose();
 
@@ -481,15 +590,15 @@ internal sealed partial class PVSSystem : EntitySystem
         while (localEnumerator.MoveNext())
         {
             var uid = localEnumerator.Current;
-            TryAddToVisibleEnts(in uid, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
-                ref entitiesSent, mQuery, tQuery, dontSkip: true, manualParents: true);
+            RecursivelyAddOverride(in uid, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
+                ref entitiesSent, mQuery, tQuery, in enteredEntityBudget, in newEntityBudget);
         }
         localEnumerator.Dispose();
 
         foreach (var viewerEntity in viewerEntities)
         {
-            TryAddToVisibleEnts(in viewerEntity, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
-                ref entitiesSent, mQuery, tQuery, dontSkip: true, manualParents: true);
+            RecursivelyAddOverride(in viewerEntity, seenSet, playerVisibleSet, visibleEnts, fromTick, ref newEntitiesSent,
+                ref entitiesSent, mQuery, tQuery, in enteredEntityBudget, in newEntityBudget);
         }
 
         var entityStates = new List<EntityState>();
@@ -500,8 +609,7 @@ internal sealed partial class PVSSystem : EntitySystem
                 continue;
 
             var @new = visiblity == PVSEntityVisiblity.Entered;
-
-            var state = GetEntityState(session, entityUid, @new ? GameTick.Zero : fromTick);
+            var state = GetEntityState(session, entityUid, @new ? GameTick.Zero : fromTick, mQuery.GetComponent(entityUid).Flags);
 
             //this entity is not new & nothing changed
             if(!@new && state.Empty) continue;
@@ -534,7 +642,49 @@ internal sealed partial class PVSSystem : EntitySystem
     }
 
     [MethodImpl(MethodImplOptions.AggressiveOptimization)]
-    private void TryAddToVisibleEnts(
+    private void RecursivelyAddTreeNode(
+        in EntityUid nodeIndex,
+        RobustTree<EntityUid> tree,
+        HashSet<EntityUid> seenSet,
+        Dictionary<EntityUid, PVSEntityVisiblity> previousVisibleEnts,
+        Dictionary<EntityUid, PVSEntityVisiblity> toSend,
+        GameTick fromTick,
+        ref int newEntitiesSent,
+        ref int totalEnteredEntities,
+        Dictionary<EntityUid, MetaDataComponent> metaDataCache,
+        in int enteredEntityBudget,
+        in int newEntityBudget)
+    {
+        //are we valid?
+        //sometimes uids gets added without being valid YET (looking at you mapmanager) (mapcreate & gridcreated fire before the uids becomes valid)
+
+        // As every map is parented to uid 0 in the tree we still need to get their children, plus because we go top-down
+        // we may find duplicate parents with children we haven't encountered before
+        // on different chunks (this is especially common with direct grid children)
+        if (nodeIndex.IsValid() && !toSend.ContainsKey(nodeIndex))
+        {
+            //are we new?
+            var (entered, budgetFail) = ProcessEntry(in nodeIndex, seenSet, previousVisibleEnts, ref newEntitiesSent,
+                ref totalEnteredEntities, in enteredEntityBudget, in newEntityBudget);
+
+            if (budgetFail) return;
+
+            AddToSendSet(in nodeIndex, metaDataCache[nodeIndex], toSend, fromTick, entered);
+        }
+
+        var node = tree[nodeIndex];
+        //our children are important regardless! iterate them!
+        if(node.Children != null)
+        {
+            foreach (var child in node.Children)
+            {
+                RecursivelyAddTreeNode(in child, tree, seenSet, previousVisibleEnts, toSend, fromTick, ref newEntitiesSent,
+                    ref totalEnteredEntities, metaDataCache, in enteredEntityBudget, in newEntityBudget);
+            }
+        }
+    }
+
+    public bool RecursivelyAddOverride(
         in EntityUid uid,
         HashSet<EntityUid> seenSet,
         Dictionary<EntityUid, PVSEntityVisiblity> previousVisibleEnts,
@@ -542,36 +692,42 @@ internal sealed partial class PVSSystem : EntitySystem
         GameTick fromTick,
         ref int newEntitiesSent,
         ref int totalEnteredEntities,
-        EntityQuery<MetaDataComponent> metadataQuery,
-        EntityQuery<TransformComponent> transformQuery,
-        MetaDataComponent? metaDataComponent = null,
-        bool dontSkip = false,
-        bool manualParents = false)
+        EntityQuery<MetaDataComponent> metaQuery,
+        EntityQuery<TransformComponent> transQuery,
+        in int enteredEntityBudget,
+        in int newEntityBudget)
     {
         //are we valid?
         //sometimes uids gets added without being valid YET (looking at you mapmanager) (mapcreate & gridcreated fire before the uids becomes valid)
-        if (!uid.IsValid()) return;
-
-        if (manualParents)
-        {
-            var parent = transformQuery.GetComponent(uid).ParentUid;
-            TryAddToVisibleEnts(in parent, seenSet, previousVisibleEnts, toSend,
-                fromTick, ref newEntitiesSent, ref totalEnteredEntities, metadataQuery, transformQuery, dontSkip: dontSkip,
-                manualParents: true);
-        }
+        if (!uid.IsValid()) return false;
 
         //did we already get added?
-        //todo paul this is a shitty bandaid for the new parent, stayed child bug crashing ghost haunting
-        if (toSend.ContainsKey(uid)) return;
+        if (toSend.ContainsKey(uid)) return true;
 
-        //are we new?
+        var parent = transQuery.GetComponent(uid).ParentUid;
+        if (parent.IsValid() && !RecursivelyAddOverride(in parent, seenSet, previousVisibleEnts, toSend, fromTick,
+                ref newEntitiesSent, ref totalEnteredEntities, metaQuery, transQuery, in enteredEntityBudget, in newEntityBudget))
+            return false;
+
+        var (entered, _) = ProcessEntry(in uid, seenSet, previousVisibleEnts, ref newEntitiesSent,
+            ref totalEnteredEntities, in enteredEntityBudget, in newEntityBudget);
+
+        AddToSendSet(in uid, metaQuery.GetComponent(uid), toSend, fromTick, entered);
+        return true;
+    }
+
+    private (bool entered, bool budgetFail) ProcessEntry(in EntityUid uid, HashSet<EntityUid> seenSet,
+        Dictionary<EntityUid, PVSEntityVisiblity> previousVisibleEnts,
+        ref int newEntitiesSent,
+        ref int totalEnteredEntities, in int enteredEntityBudget, in int newEntityBudget)
+    {
         var @new = !seenSet.Contains(uid);
         var entered = @new | !previousVisibleEnts.Remove(uid);
 
         if (entered)
         {
-            if (!dontSkip && totalEnteredEntities >= _entityBudget)
-                return;
+            if (totalEnteredEntities >= enteredEntityBudget)
+                return (entered, true);
 
             totalEnteredEntities++;
         }
@@ -579,21 +735,24 @@ internal sealed partial class PVSSystem : EntitySystem
         if (@new)
         {
             //we just entered pvs, do we still have enough budget to send us?
-            if(!dontSkip && newEntitiesSent >= _newEntityBudget)
-                return;
+            if(newEntitiesSent >= newEntityBudget)
+                return (entered, true);
 
             newEntitiesSent++;
             seenSet.Add(uid);
         }
 
+        return (entered, false);
+    }
+
+    private void AddToSendSet(in EntityUid uid, MetaDataComponent metaDataComponent, Dictionary<EntityUid, PVSEntityVisiblity> toSend, GameTick fromTick, bool entered)
+    {
         if (entered)
         {
             toSend.Add(uid, PVSEntityVisiblity.Entered);
             return;
         }
 
-        metaDataComponent ??= metadataQuery.GetComponent(uid);
-
         if (metaDataComponent.EntityLastModifiedTick < fromTick)
         {
             //entity has been sent before and hasnt been updated since
@@ -603,7 +762,6 @@ internal sealed partial class PVSSystem : EntitySystem
 
         //add us
         toSend.Add(uid, PVSEntityVisiblity.StayedChanged);
-        return;
     }
 
     /// <summary>
@@ -620,38 +778,59 @@ internal sealed partial class PVSSystem : EntitySystem
         var slowPath = false;
         var metadataQuery = EntityManager.GetEntityQuery<MetaDataComponent>();
 
-        for (var i = fromTick.Value; i <= toTick.Value; i++)
+        if (!SeenAllEnts.Contains(player))
         {
-            var tick = new GameTick(i);
-            if (!TryGetTick(tick, out var add, out var dirty))
+            // Give them E V E R Y T H I N G
+            stateEntities = new List<EntityState>(EntityManager.EntityCount);
+
+            // This is the same as iterating every existing entity.
+            foreach (var md in EntityManager.EntityQuery<MetaDataComponent>(true))
             {
-                slowPath = true;
-                break;
+                DebugTools.Assert(md.EntityLifeStage >= EntityLifeStage.Initialized);
+                stateEntities.Add(GetEntityState(player, md.Owner, GameTick.Zero, md.Flags));
             }
 
-            foreach (var uid in add)
+            return (stateEntities.Count == 0 ? default : stateEntities, deletions);
+        }
+
+        // Just get the relevant entities that have been dirtied
+        // This should be extremely fast.
+        if (!slowPath)
+        {
+            for (var i = fromTick.Value; i <= toTick.Value; i++)
             {
-                if (!seenEnts.Add(uid)) continue;
-                // This is essentially the same as IEntityManager.EntityExists, but returning MetaDataComponent.
-                if (!metadataQuery.TryGetComponent(uid, out MetaDataComponent? md)) continue;
+                // Fallback to dumping every entity on them.
+                var tick = new GameTick(i);
+                if (!TryGetTick(tick, out var add, out var dirty))
+                {
+                    slowPath = true;
+                    break;
+                }
 
-                DebugTools.Assert(md.EntityLifeStage >= EntityLifeStage.Initialized);
+                foreach (var uid in add)
+                {
+                    if (!seenEnts.Add(uid)) continue;
+                    // This is essentially the same as IEntityManager.EntityExists, but returning MetaDataComponent.
+                    if (!metadataQuery.TryGetComponent(uid, out var md)) continue;
 
-                if (md.EntityLastModifiedTick >= fromTick)
-                    stateEntities.Add(GetEntityState(player, uid, GameTick.Zero));
-            }
+                    DebugTools.Assert(md.EntityLifeStage >= EntityLifeStage.Initialized);
 
-            foreach (var uid in dirty)
-            {
-                DebugTools.Assert(!add.Contains(uid));
+                    if (md.EntityLastModifiedTick >= fromTick)
+                        stateEntities.Add(GetEntityState(player, uid, GameTick.Zero, md.Flags));
+                }
 
-                if (!seenEnts.Add(uid)) continue;
-                if (!metadataQuery.TryGetComponent(uid, out MetaDataComponent? md)) continue;
+                foreach (var uid in dirty)
+                {
+                    DebugTools.Assert(!add.Contains(uid));
 
-                DebugTools.Assert(md.EntityLifeStage >= EntityLifeStage.Initialized);
+                    if (!seenEnts.Add(uid)) continue;
+                    if (!metadataQuery.TryGetComponent(uid, out var md)) continue;
 
-                if (md.EntityLastModifiedTick >= fromTick)
-                    stateEntities.Add(GetEntityState(player, uid, fromTick));
+                    DebugTools.Assert(md.EntityLifeStage >= EntityLifeStage.Initialized);
+
+                    if (md.EntityLastModifiedTick >= fromTick)
+                        stateEntities.Add(GetEntityState(player, uid, fromTick, md.Flags));
+                }
             }
         }
 
@@ -670,7 +849,7 @@ internal sealed partial class PVSSystem : EntitySystem
             DebugTools.Assert(md.EntityLifeStage >= EntityLifeStage.Initialized);
 
             if (md.EntityLastModifiedTick >= fromTick)
-                stateEntities.Add(GetEntityState(player, md.Owner, fromTick));
+                stateEntities.Add(GetEntityState(player, md.Owner, fromTick, md.Flags));
         }
 
         // no point sending an empty collection
@@ -685,11 +864,16 @@ internal sealed partial class PVSSystem : EntitySystem
     /// <param name="player">The player to generate this state for.</param>
     /// <param name="entityUid">Uid of the entity to generate the state from.</param>
     /// <param name="fromTick">Only provide delta changes from this tick.</param>
+    /// <param name="flags">Any applicable metadata flags</param>
     /// <returns>New entity State for the given entity.</returns>
-    private EntityState GetEntityState(ICommonSession player, EntityUid entityUid, GameTick fromTick)
+    private EntityState GetEntityState(ICommonSession player, EntityUid entityUid, GameTick fromTick, MetaDataFlags flags)
     {
         var bus = EntityManager.EventBus;
         var changed = new List<ComponentChange>();
+        // Whether this entity has any component states that are only for a specific session.
+        // TODO: This GetComp is probably expensive, less expensive than before, but ideally we'd cache it somewhere or something from a previous getcomp
+        // Probably still needs tweaking but checking for add / changed states up front should do most of the work.
+        var specificStates = (flags & MetaDataFlags.EntitySpecific) == MetaDataFlags.EntitySpecific;
 
         foreach (var (netId, component) in EntityManager.GetNetComponents(entityUid))
         {
@@ -704,10 +888,22 @@ internal sealed partial class PVSSystem : EntitySystem
 
             DebugTools.Assert(component.LastModifiedTick >= component.CreationTick);
 
-            if (!EntityManager.CanGetComponentState(bus, component, player))
+            var addState = false;
+            var changeState = false;
+
+            // We'll check the properties first; if we ever have specific states then doing the struct event is expensive.
+            if (component.CreationTick != GameTick.Zero && component.CreationTick >= fromTick && !component.Deleted)
+                addState = true;
+            else if (component.NetSyncEnabled && component.LastModifiedTick != GameTick.Zero && component.LastModifiedTick >= fromTick)
+                changeState = true;
+
+            if (!addState && !changeState)
                 continue;
 
-            if (component.CreationTick != GameTick.Zero && component.CreationTick >= fromTick && !component.Deleted)
+            if (specificStates && !EntityManager.CanGetComponentState(bus, component, player))
+                continue;
+
+            if (addState)
             {
                 ComponentState? state = null;
                 if (component.NetSyncEnabled && component.LastModifiedTick != GameTick.Zero &&
@@ -718,14 +914,14 @@ internal sealed partial class PVSSystem : EntitySystem
                 // ReSharper disable once PossibleInvalidOperationException
                 changed.Add(ComponentChange.Added(netId, state));
             }
-            else if (component.NetSyncEnabled && component.LastModifiedTick != GameTick.Zero &&
-                     component.LastModifiedTick >= fromTick)
+            else
             {
+                DebugTools.Assert(changeState);
                 changed.Add(ComponentChange.Changed(netId, EntityManager.GetComponentState(bus, component)));
             }
         }
 
-        foreach (var netId in ((IServerEntityManager)EntityManager).GetDeletedComponents(entityUid, fromTick))
+        foreach (var netId in _serverEntManager.GetDeletedComponents(entityUid, fromTick))
         {
             changed.Add(ComponentChange.Removed(netId));
         }
@@ -733,14 +929,24 @@ internal sealed partial class PVSSystem : EntitySystem
         return new EntityState(entityUid, changed.ToArray());
     }
 
-    private HashSet<EntityUid> GetSessionViewers(ICommonSession session)
+    private EntityUid[] GetSessionViewers(ICommonSession session)
     {
-        var viewers = _uidSetPool.Get();
         if (session.Status != SessionStatus.InGame)
-            return viewers;
+            return Array.Empty<EntityUid>();
+
+        var viewers = _uidSetPool.Get();
 
         if (session.AttachedEntity != null)
+        {
+            // Fast path
+            if (session is IPlayerSession { ViewSubscriptionCount: 0 })
+            {
+                _uidSetPool.Return(viewers);
+                return new[] { session.AttachedEntity.Value };
+            }
+
             viewers.Add(session.AttachedEntity.Value);
+        }
 
         // This is awful, but we're not gonna add the list of view subscriptions to common session.
         if (session is IPlayerSession playerSession)
@@ -751,7 +957,10 @@ internal sealed partial class PVSSystem : EntitySystem
             }
         }
 
-        return viewers;
+        var viewerArray = viewers.ToArray();
+
+        _uidSetPool.Return(viewers);
+        return viewerArray;
     }
 
     // Read Safe
@@ -775,20 +984,6 @@ internal sealed partial class PVSSystem : EntitySystem
         }
     }
 
-    public sealed class ListPolicy<T> : PooledObjectPolicy<List<T>>
-    {
-        public override List<T> Create()
-        {
-            return new();
-        }
-
-        public override bool Return(List<T> obj)
-        {
-            obj.Clear();
-            return true;
-        }
-    }
-
     public sealed class DictPolicy<T1, T2> : PooledObjectPolicy<Dictionary<T1, T2>> where T1 : notnull
     {
         public override Dictionary<T1, T2> Create()
@@ -802,6 +997,35 @@ internal sealed partial class PVSSystem : EntitySystem
             return true;
         }
     }
+
+    public sealed class TreePolicy<T> : PooledObjectPolicy<RobustTree<T>> where T : notnull
+    {
+        public override RobustTree<T> Create()
+        {
+            var pool = new DefaultObjectPool<HashSet<T>>(new SetPolicy<T>(), MaxVisPoolSize);
+            return new RobustTree<T>(pool);
+        }
+
+        public override bool Return(RobustTree<T> obj)
+        {
+            obj.Clear();
+            return true;
+        }
+    }
+
+    private sealed class ChunkPoolPolicy<T> : PooledObjectPolicy<Dictionary<T, int>> where T : notnull
+    {
+        public override Dictionary<T, int> Create()
+        {
+            return new Dictionary<T, int>(32);
+        }
+
+        public override bool Return(Dictionary<T, int> obj)
+        {
+            obj.Clear();
+            return true;
+        }
+    }
 }
 
 [ByRefEvent]

Robust.Server/GameStates/RobustTree.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Extensions.ObjectPool;
+
+namespace Robust.Server.GameStates;
+
+public sealed class RobustTree<T> where T : notnull
+{
+    private Dictionary<T, TreeNode> _nodeIndex = new();
+
+    private Dictionary<T, T> _parents = new();
+    public readonly HashSet<T> RootNodes = new();
+
+    private ObjectPool<HashSet<T>> _pool;
+
+    public RobustTree(ObjectPool<HashSet<T>>? pool = null)
+    {
+        _pool = pool ?? new DefaultObjectPool<HashSet<T>>(new PVSSystem.SetPolicy<T>());
+    }
+
+    public void Clear()
+    {
+        foreach (var value in _nodeIndex.Values)
+        {
+            if(value.Children != null)
+                _pool.Return(value.Children);
+        }
+        _nodeIndex.Clear();
+        _parents.Clear();
+        RootNodes.Clear();
+    }
+
+    public TreeNode this[T index] => _nodeIndex[index];
+
+    public void Remove(T value, bool mend = false)
+    {
+        if (!_nodeIndex.TryGetValue(value, out var node))
+            throw new InvalidOperationException("Node doesnt exist.");
+
+
+        if (RootNodes.Contains(value))
+        {
+            if (node.Children != null)
+            {
+                foreach (var child in node.Children)
+                {
+                    _parents.Remove(child);
+                    RootNodes.Add(child);
+                }
+                _pool.Return(node.Children);
+            }
+            RootNodes.Remove(value);
+            _nodeIndex.Remove(value);
+            return;
+        }
+
+        if (_parents.TryGetValue(value, out var parent))
+        {
+            if (node.Children != null)
+            {
+                foreach (var child in node.Children)
+                {
+                    if (mend)
+                    {
+                        _parents[child] = parent;
+                        var children = _nodeIndex[parent].Children;
+                        if (children == null)
+                        {
+                            children = _pool.Get();
+                            _nodeIndex[parent] = _nodeIndex[parent].WithChildren(children);
+                        }
+                        children.Add(child);
+                    }
+                    else
+                    {
+                        _parents.Remove(child);
+                        RootNodes.Add(child);
+                    }
+                }
+
+                _pool.Return(node.Children);
+            }
+            _parents.Remove(value);
+            _nodeIndex.Remove(value);
+        }
+
+        throw new InvalidOperationException("Node neither had a parent nor was a RootNode.");
+    }
+
+    public TreeNode Set(T rootNode)
+    {
+        //root node, for now
+        if (_nodeIndex.TryGetValue(rootNode, out var node))
+        {
+            if(!RootNodes.Contains(rootNode))
+                throw new InvalidOperationException("Node already exists as non-root node.");
+            return node;
+        }
+
+        node = new TreeNode(rootNode);
+        _nodeIndex.Add(rootNode, node);
+        RootNodes.Add(rootNode);
+        return node;
+    }
+
+    public TreeNode Set(T child, T parent)
+    {
+        if (!_nodeIndex.TryGetValue(parent, out var parentNode))
+            parentNode = Set(parent);
+
+        if (parentNode.Children == null)
+        {
+            _nodeIndex[parent] = parentNode = parentNode.WithChildren(_pool.Get());
+        }
+
+        if (_nodeIndex.TryGetValue(child, out var existingNode))
+        {
+            if (RootNodes.Contains(child))
+            {
+                parentNode.Children!.Add(existingNode.Value);
+                RootNodes.Remove(child);
+                _parents.Add(child, parent);
+                return existingNode;
+            }
+
+            if (!_parents.TryGetValue(child, out var previousParent) || _nodeIndex.TryGetValue(previousParent, out var previousParentNode))
+                throw new InvalidOperationException("Could not find old parent for non-root node.");
+
+            previousParentNode.Children?.Remove(existingNode.Value);
+            parentNode.Children!.Add(existingNode.Value);
+            _parents[child] = parent;
+            return existingNode;
+        }
+
+        existingNode = new TreeNode(child);
+        _nodeIndex.Add(child, existingNode);
+        parentNode.Children!.Add(existingNode.Value);
+        _parents.Add(child, parent);
+        return existingNode;
+    }
+
+    public readonly struct TreeNode : IEquatable<TreeNode>
+    {
+        public readonly T Value;
+        public readonly HashSet<T>? Children;
+
+        public TreeNode(T value, HashSet<T>? children = null)
+        {
+            Value = value;
+            Children = children;
+        }
+
+        public bool Equals(TreeNode other)
+        {
+            return Value.Equals(other.Value) && Children?.Equals(other.Children) == true;
+        }
+
+        public override bool Equals(object? obj)
+        {
+            return obj is TreeNode other && Equals(other);
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(Value, Children);
+        }
+
+        public TreeNode WithChildren(HashSet<T> children)
+        {
+            return new TreeNode(Value, children);
+        }
+    }
+}

Robust.Server/GameStates/ServerGameStateManager.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -133,7 +134,7 @@ namespace Robust.Server.GameStates
             EntityQuery<TransformComponent> transformQuery = default!;
             HashSet<int>[] playerChunks = default!;
             EntityUid[][] viewerEntities = default!;
-            (Dictionary<EntityUid, MetaDataComponent> metadata, List<EntityUid> order)?[] chunkCache = default!;
+            (Dictionary<EntityUid, MetaDataComponent> metadata, RobustTree<EntityUid> tree)?[] chunkCache = default!;
 
             if (_pvs.CullingEnabled)
             {
@@ -143,7 +144,11 @@ namespace Robust.Server.GameStates
                 var chunksCount = chunks.Count;
                 var chunkBatches = (int) MathF.Ceiling((float) chunksCount / ChunkBatchSize);
                 chunkCache =
-                    new (Dictionary<EntityUid, MetaDataComponent> metadata, List<EntityUid> order)?[chunksCount];
+                    new (Dictionary<EntityUid, MetaDataComponent> metadata, RobustTree<EntityUid> tree)?[chunksCount];
+
+                // Update the reused trees sequentially to avoid having to lock the dictionary per chunk.
+                var reuse = ArrayPool<bool>.Shared.Rent(chunksCount);
+
                 transformQuery = _entityManager.GetEntityQuery<TransformComponent>();
                 metadataQuery = _entityManager.GetEntityQuery<MetaDataComponent>();
                 Parallel.For(0, chunkBatches, i =>
@@ -154,9 +159,13 @@ namespace Robust.Server.GameStates
                     for (var j = start; j < end; ++j)
                     {
                         var (visMask, chunkIndexLocation) = chunks[j];
-                        chunkCache[j] = _pvs.CalculateChunk(chunkIndexLocation, visMask, transformQuery, metadataQuery);
+                        reuse[j] = _pvs.TryCalculateChunk(chunkIndexLocation, visMask, transformQuery, metadataQuery, out var chunk);
+                        chunkCache[j] = chunk;
                     }
                 });
+
+                _pvs.RegisterNewPreviousChunkTrees(chunks, chunkCache, reuse);
+                ArrayPool<bool>.Shared.Return(reuse);
             }
 
             const int BatchSize = 2;
@@ -209,8 +218,6 @@ namespace Robust.Server.GameStates
 
                 InterlockedHelper.Min(ref oldestAckValue, lastAck.Value);
 
-                DebugTools.Assert(state.MapData?.CreatedMaps is null || (state.MapData?.CreatedMaps is not null && state.EntityStates.HasContents), "Sending new maps, but no entity state.");
-
                 // actually send the state
                 var stateUpdateMessage = _networkManager.CreateNetMessage<MsgState>();
                 stateUpdateMessage.State = state;
@@ -232,7 +239,7 @@ namespace Robust.Server.GameStates
             }
 
             if(_pvs.CullingEnabled)
-                _pvs.ReturnToPool(chunkCache, playerChunks);
+                _pvs.ReturnToPool(playerChunks);
             _pvs.Cleanup(_playerManager.ServerSessions);
             var oldestAck = new GameTick(oldestAckValue);
 

Robust.Server/Maps/MapLoader.cs

@@ -229,6 +229,7 @@ namespace Robust.Server.Maps
             private readonly MapLoadOptions? _loadOptions;
             private readonly Dictionary<GridId, int> GridIDMap = new();
             public readonly List<MapGrid> Grids = new();
+            private readonly List<GridId> _readGridIndices = new();
 
             private readonly Dictionary<EntityUid, int> EntityUidMap = new();
             private readonly Dictionary<int, EntityUid> UidEntityMap = new();
@@ -314,9 +315,8 @@ namespace Robust.Server.Maps
                 // Create the new map.
                 AllocMap();
 
-                // Load grids.
-                ReadTileMapSection();
-                ReadGridSection();
+                // Maps grid section indices to GridIds, for deserializing GridIds on entities.
+                ReadGridSectionIndices();
 
                 // Entities are first allocated. This allows us to know the future UID of all entities on the map before
                 // even ExposeData is loaded. This allows us to resolve serialized EntityUid instances correctly.
@@ -325,8 +325,11 @@ namespace Robust.Server.Maps
                 // Actually instance components and run ExposeData on them.
                 FinishEntitiesLoad();
 
-                // Finish binding MapGrids to their respective MapGridComponents.
-                BindGridComponents();
+                // Load grids.
+                ReadTileMapSection();
+
+                // Reads the grid section, allocates MapGrids, and maps them to their respective MapGridComponents.
+                ReadGridSection();
 
                 // Clear the net tick numbers so that components from prototypes (not modified by map)
                 // aren't sent over the wire initially.
@@ -474,18 +477,20 @@ namespace Robust.Server.Maps
                 }
             }
 
-            private void BindGridComponents()
+            private void ReadGridSection()
             {
                 // There were no new grids, nothing to do here.
-                if(Grids.Count == 0)
+                if(_readGridIndices.Count == 0)
                     return;
 
                 // MapGrids already contain their assigned GridId from their ctor, and the MapComponents just got deserialized.
                 // Now we need to actually bind the MapGrids to their components so that you can resolve GridId -> EntityUid
                 // After doing this, it should be 100% safe to use the MapManager API like normal.
 
+                var yamlGrids = RootNode.GetNode<YamlSequenceNode>("grids");
+
                 // get ents that the grids will bind to
-                var gridComps = new Dictionary<GridId, MapGridComponent>(Grids.Count);
+                var gridComps = new Dictionary<GridId, MapGridComponent>(_readGridIndices.Count);
 
                 // linear search for new grid comps
                 foreach (var tuple in _entitiesToDeserialize)
@@ -502,15 +507,54 @@ namespace Robust.Server.Maps
                     gridComps[gridComp.GridIndex] = gridComp;
                 }
 
-                // Actually bind them
-                foreach (var mapGrid in Grids)
+                for (var index = 0; index < _readGridIndices.Count; index++)
                 {
+                    // Here is where the implicit index pairing magic happens from the yaml.
+                    var gridIndex = _readGridIndices[index];
+                    var yamlGrid = (YamlMappingNode)yamlGrids.Children[index];
+
                     // designed to throw if something is broken, every grid must map to an ent
-                    var gridComp = gridComps[mapGrid.Index];
-                    _mapManager.BindGrid(gridComp, mapGrid);
+                    var gridComp = gridComps[gridIndex];
+
+                    DebugTools.Assert(gridComp.GridIndex == gridIndex);
+
+                    YamlMappingNode yamlGridInfo = (YamlMappingNode)yamlGrid["settings"];
+                    YamlSequenceNode yamlGridChunks = (YamlSequenceNode)yamlGrid["chunks"];
+
+                    var grid = AllocateMapGrid(gridComp, yamlGridInfo);
+
+                    foreach (var chunkNode in yamlGridChunks.Cast<YamlMappingNode>())
+                    {
+                        YamlGridSerializer.DeserializeChunk(_mapManager, grid, chunkNode, _tileMap!, _tileDefinitionManager);
+                    }
+
+                    Grids.Add(grid); // Grids are kept in index order
                 }
             }
 
+            private static MapGrid AllocateMapGrid(MapGridComponent gridComp, YamlMappingNode yamlGridInfo)
+            {
+                // sane defaults
+                ushort csz = 16;
+                ushort tsz = 1;
+
+                foreach (var kvInfo in yamlGridInfo)
+                {
+                    var key = kvInfo.Key.ToString();
+                    var val = kvInfo.Value.ToString();
+                    if (key == "chunksize")
+                        csz = ushort.Parse(val);
+                    else if (key == "tilesize")
+                        tsz = ushort.Parse(val);
+                    else if (key == "snapsize")
+                        continue; // obsolete
+                }
+
+                var grid = gridComp.AllocMapGrid(csz, tsz);
+
+                return grid;
+            }
+
             private void AttachMapEntities()
             {
                 var mapEntity = _mapManager.GetMapEntityIdOrThrow(TargetMap);
@@ -577,21 +621,15 @@ namespace Robust.Server.Maps
                 }
             }
 
-            private void ReadGridSection()
+            private void ReadGridSectionIndices()
             {
+                // sets up the mapping so the serializer can properly deserialize GridIds.
+
                 var yamlGrids = RootNode.GetNode<YamlSequenceNode>("grids");
 
-                foreach (var yamlGrid in yamlGrids)
+                for (var i = 0; i < yamlGrids.Children.Count; i++)
                 {
-                    var grid = YamlGridSerializer.DeserializeGrid(
-                        _mapManager, TargetMap,
-                        (YamlMappingNode) yamlGrid["settings"],
-                        (YamlSequenceNode) yamlGrid["chunks"],
-                        _tileMap!,
-                        _tileDefinitionManager
-                    );
-
-                    Grids.Add(grid);
+                    _readGridIndices.Add(_mapManager.GenerateGridId(null));
                 }
             }
 
@@ -748,54 +786,55 @@ namespace Robust.Server.Maps
 
             private void PopulateEntityList()
             {
-                var withUid = new List<MapSaveIdComponent>();
-                var withoutUid = new List<EntityUid>();
-                var takenIds = new HashSet<int>();
-
+                var withoutUid = new HashSet<EntityUid>();
+                var saveCompQuery = _serverEntityManager.GetEntityQuery<MapSaveIdComponent>();
+                var transformCompQuery = _serverEntityManager.GetEntityQuery<TransformComponent>();
+                var metaCompQuery = _serverEntityManager.GetEntityQuery<MetaDataComponent>();
                 foreach (var entity in _serverEntityManager.GetEntities())
                 {
-                    if (IsMapSavable(entity))
-                    {
-                        Entities.Add(entity);
-                        if (_serverEntityManager.TryGetComponent(entity, out MapSaveIdComponent? mapSaveId))
-                        {
-                            withUid.Add(mapSaveId);
-                        }
-                        else
-                        {
-                            withoutUid.Add(entity);
-                        }
-                    }
-                }
+                    var currentTransform = transformCompQuery.GetComponent(entity);
+                    if (!GridIDMap.ContainsKey(currentTransform.GridID)) continue;
 
-                // Go over entities with a MapSaveIdComponent and assign those.
+                    var currentEntity = entity;
 
-                foreach (var mapIdComp in withUid)
-                {
-                    var uid = mapIdComp.Uid;
-                    if (takenIds.Contains(uid))
+                    // Don't serialize things parented to un savable things.
+                    // For example clothes inside a person.
+                    while (currentEntity.IsValid())
                     {
-                        // Duplicate ID. Just pretend it doesn't have an ID and use the without path.
-                        withoutUid.Add(mapIdComp.Owner);
+                        if (metaCompQuery.GetComponent(currentEntity).EntityPrototype?.MapSavable == false) break;
+                        currentEntity = transformCompQuery.GetComponent(currentEntity).ParentUid;
                     }
-                    else
+
+                    if (currentEntity.IsValid()) continue;
+
+                    Entities.Add(entity);
+
+                    if (!saveCompQuery.TryGetComponent(entity, out var mapSaveComp) ||
+                        !UidEntityMap.TryAdd(mapSaveComp.Uid, entity))
                     {
-                        EntityUidMap.Add(mapIdComp.Owner, uid);
-                        takenIds.Add(uid);
+                        // If the id was already saved before, or has no save component we need to find a new id for this entity
+                        withoutUid.Add(entity);
                     }
                 }
 
                 var uidCounter = 0;
                 foreach (var entity in withoutUid)
                 {
-                    while (takenIds.Contains(uidCounter))
+                    while (UidEntityMap.ContainsKey(uidCounter))
                     {
                         // Find next available UID.
                         uidCounter += 1;
                     }
 
-                    EntityUidMap.Add(entity, uidCounter);
-                    takenIds.Add(uidCounter);
+                    UidEntityMap.Add(uidCounter, entity);
+                    uidCounter += 1;
+                }
+
+                // Build a reverse lookup
+                EntityUidMap.EnsureCapacity(UidEntityMap.Count);
+                foreach(var (saveId, mapId) in UidEntityMap)
+                {
+                    EntityUidMap.Add(mapId, saveId);
                 }
             }
 
@@ -803,19 +842,20 @@ namespace Robust.Server.Maps
             {
                 var serializationManager = IoCManager.Resolve<ISerializationManager>();
                 var compFactory = IoCManager.Resolve<IComponentFactory>();
+                var metaQuery = _serverEntityManager.GetEntityQuery<MetaDataComponent>();
                 var entities = new YamlSequenceNode();
                 RootNode.Add("entities", entities);
 
                 var prototypeCompCache = new Dictionary<string, Dictionary<string, MappingDataNode>>();
-                foreach (var entity in Entities.OrderBy(e => EntityUidMap[e]))
+                foreach (var (saveId, entityUid) in UidEntityMap.OrderBy(e=>e.Key))
                 {
-                    CurrentWritingEntity = entity;
+                    CurrentWritingEntity = entityUid;
                     var mapping = new YamlMappingNode
                     {
-                        {"uid", EntityUidMap[entity].ToString(CultureInfo.InvariantCulture)}
+                        {"uid", saveId.ToString(CultureInfo.InvariantCulture)}
                     };
 
-                    var md = _serverEntityManager.GetComponent<MetaDataComponent>(entity);
+                    var md = metaQuery.GetComponent(entityUid);
 
                     if (md.EntityPrototype is {} prototype)
                     {
@@ -833,7 +873,7 @@ namespace Robust.Server.Maps
                     var components = new YamlSequenceNode();
 
                     // See engine#636 for why the Distinct() call.
-                    foreach (var component in _serverEntityManager.GetComponents(entity))
+                    foreach (var component in _serverEntityManager.GetComponents(entityUid))
                     {
                         if (component is MapSaveIdComponent)
                             continue;
@@ -900,27 +940,11 @@ namespace Robust.Server.Maps
                 return CurrentReadingEntityComponents!.Keys;
             }
 
-            private bool IsMapSavable(EntityUid entity)
+            [Virtual]
+            public class MapLoadException : Exception
             {
-                if (_serverEntityManager.GetComponent<MetaDataComponent>(entity).EntityPrototype?.MapSavable == false || !GridIDMap.ContainsKey(_serverEntityManager.GetComponent<TransformComponent>(entity).GridID))
-                {
-                    return false;
-                }
-
-                // Don't serialize things parented to un savable things.
-                // For example clothes inside a person.
-                var current = _serverEntityManager.GetComponent<TransformComponent>(entity);
-                while (current.Parent != null)
-                {
-                    if (_serverEntityManager.GetComponent<MetaDataComponent>(current.Parent.Owner).EntityPrototype?.MapSavable == false)
-                    {
-                        return false;
-                    }
-
-                    current = current.Parent;
-                }
-
-                return true;
+                public MapLoadException(string? message)
+                    : base(message) { }
             }
 
             public DeserializationResult Read(ISerializationManager serializationManager, ValueDataNode node,
@@ -931,19 +955,18 @@ namespace Robust.Server.Maps
                 // This is the code that deserializes the Grids index into the GridId. This has to happen between Grid allocation
                 // and when grids are bound to their entities.
 
-                if (node.Value == "null") return new DeserializedValue<GridId>(GridId.Invalid);
+                if (node.Value == "null")
+                {
+                    throw new MapLoadException($"Error in map file: found local grid ID '{node.Value}' which does not exist.");
+                }
 
                 var val = int.Parse(node.Value);
-                if (val >= Grids.Count)
+                if (val >= _readGridIndices.Count)
                 {
-                    Logger.ErrorS("map", "Error in map file: found local grid ID '{0}' which does not exist.", val);
-                }
-                else
-                {
-                    return new DeserializedValue<GridId>(Grids[val].Index);
+                    throw new MapLoadException($"Error in map file: found local grid ID '{val}' which does not exist.");
                 }
 
-                return new DeserializedValue<GridId>(GridId.Invalid);
+                return new DeserializedValue<GridId>(_readGridIndices[val]);
             }
 
             ValidationNode ITypeValidator<EntityUid, ValueDataNode>.Validate(ISerializationManager serializationManager,

Robust.Server/Maps/YamlGridSerializer.cs

@@ -36,7 +36,7 @@ namespace Robust.Server.Maps
             return gridn;
         }
 
-        private static YamlNode SerializeChunk(IMapChunk chunk)
+        private static YamlNode SerializeChunk(MapChunk chunk)
         {
             var root = new YamlMappingNode();
             var value = new YamlScalarNode($"{chunk.X},{chunk.Y}");
@@ -51,7 +51,7 @@ namespace Robust.Server.Maps
             return root;
         }
 
-        private static string SerializeTiles(IMapChunk chunk)
+        private static string SerializeTiles(MapChunk chunk)
         {
             // number of bytes written per tile, because sizeof(Tile) is useless.
             const int structSize = 4;
@@ -68,7 +68,8 @@ namespace Robust.Server.Maps
                     {
                         var tile = chunk.GetTile(x, y);
                         writer.Write(tile.TypeId);
-                        writer.Write(tile.Data);
+                        writer.Write((byte)tile.Flags);
+                        writer.Write(tile.Variant);
                     }
                 }
             }
@@ -76,38 +77,10 @@ namespace Robust.Server.Maps
             return Convert.ToBase64String(barr);
         }
 
-        public static MapGrid DeserializeGrid(IMapManagerInternal mapMan, MapId mapId, YamlMappingNode info,
-            YamlSequenceNode chunks, IReadOnlyDictionary<ushort, string> tileDefMapping,
+        public static void DeserializeChunk(IMapManager mapMan, IMapGridInternal grid,
+            YamlMappingNode chunkData,
+            IReadOnlyDictionary<ushort, string> tileDefMapping,
             ITileDefinitionManager tileDefinitionManager)
-        {
-            ushort csz = 0;
-            ushort tsz = 0;
-            float sgsz = 0.0f;
-
-            foreach (var kvInfo in info)
-            {
-                var key = kvInfo.Key.ToString();
-                var val = kvInfo.Value.ToString();
-                if (key == "chunksize")
-                    csz = ushort.Parse(val);
-                else if (key == "tilesize")
-                    tsz = ushort.Parse(val);
-                else if (key == "snapsize")
-                    sgsz = float.Parse(val, CultureInfo.InvariantCulture);
-            }
-
-            //TODO: Pass in options
-            var grid = mapMan.CreateUnboundGrid(mapId);
-
-            foreach (var chunkNode in chunks.Cast<YamlMappingNode>())
-            {
-                DeserializeChunk(mapMan, grid, chunkNode, tileDefMapping, tileDefinitionManager);
-            }
-
-            return grid;
-        }
-
-        private static void DeserializeChunk(IMapManager mapMan, IMapGridInternal grid, YamlMappingNode chunkData, IReadOnlyDictionary<ushort, string> tileDefMapping, ITileDefinitionManager tileDefinitionManager)
         {
             var indNode = chunkData["ind"];
             var tileNode = chunkData["tiles"];
@@ -129,12 +102,13 @@ namespace Robust.Server.Maps
                 for (ushort x = 0; x < grid.ChunkSize; x++)
                 {
                     var id = reader.ReadUInt16();
-                    var data = reader.ReadUInt16();
+                    var flags = (TileRenderFlag)reader.ReadByte();
+                    var variant = reader.ReadByte();
 
                     var defName = tileDefMapping[id];
                     id = tileDefinitionManager[defName].TileId;
 
-                    var tile = new Tile(id, data);
+                    var tile = new Tile(id, flags, variant);
                     chunk.SetTile(x, y, tile);
                 }
             }

Robust.Server/Placement/PlacementManager.cs

@@ -209,7 +209,7 @@ namespace Robust.Server.Placement
         {
             EntityCoordinates start = msg.EntityCoordinates;
             Vector2 rectSize = msg.RectSize;
-            foreach (EntityUid entity in IoCManager.Resolve<IEntityLookup>().GetEntitiesIntersecting(start.GetMapId(_entityManager),
+            foreach (EntityUid entity in EntitySystem.Get<EntityLookupSystem>().GetEntitiesIntersecting(start.GetMapId(_entityManager),
                 new Box2(start.Position, start.Position + rectSize)))
             {
                 if (_entityManager.Deleted(entity) || _entityManager.HasComponent<IMapGridComponent>(entity) || _entityManager.HasComponent<ActorComponent>(entity))

Robust.Server/Player/IPlayerSession.cs

@@ -44,6 +44,8 @@ namespace Robust.Server.Player
 
         IReadOnlySet<EntityUid> ViewSubscriptions { get; }
 
+        int ViewSubscriptionCount { get; }
+
         /// <summary>
         ///     Persistent data for this player.
         /// </summary>

Robust.Server/Player/PlayerSession.cs

@@ -39,6 +39,7 @@ namespace Robust.Server.Player
         }
 
         [ViewVariables] public IReadOnlySet<EntityUid> ViewSubscriptions => _viewSubscriptions;
+        public int ViewSubscriptionCount => _viewSubscriptions.Count;
 
         [ViewVariables] public INetChannel ConnectedClient { get; }
 

Robust.Server/Robust.Server.csproj

@@ -10,12 +10,12 @@
   </PropertyGroup>
   <Import Project="..\MSBuild\Robust.DefineConstants.targets" />
   <ItemGroup>
-    <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" PrivateAssets="All" />
+    <PackageReference Include="JetBrains.Annotations" Version="2021.3.0" PrivateAssets="All" />
     <!--  -->
     <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.0.7" />
     <PackageReference Include="prometheus-net" Version="4.1.1" />
     <PackageReference Include="Serilog.Sinks.Loki" Version="4.0.0-beta3" />
-    <PackageReference Include="Microsoft.Extensions.Primitives" Version="5.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Primitives" Version="6.0.0" />
     <PackageReference Include="prometheus-net.DotNetRuntime" Version="4.2.2" />
   </ItemGroup>
   <ItemGroup>

Robust.Server/ServerIoC.cs

@@ -50,7 +50,6 @@ namespace Robust.Server
             IoCManager.Register<IMapManagerInternal, NetworkedMapManager>();
             IoCManager.Register<INetworkedMapManager, NetworkedMapManager>();
             IoCManager.Register<IEntityManager, ServerEntityManager>();
-            IoCManager.Register<IEntityLookup, EntityLookup>();
             IoCManager.Register<IEntityNetworkManager, ServerEntityManager>();
             IoCManager.Register<IServerEntityNetworkManager, ServerEntityManager>();
             IoCManager.Register<IMapLoader, MapLoader>();

Robust.Server/ServerStatus/StatusHost.Handlers.cs

@@ -87,8 +87,8 @@ namespace Robust.Server.ServerStatus
             var authInfo = new JsonObject
             {
                 ["mode"] = _netManager.Auth.ToString(),
-                ["public_key"] = _netManager.RsaPublicKey != null
-                    ? Convert.ToBase64String(_netManager.RsaPublicKey)
+                ["public_key"] = _netManager.CryptoPublicKey != null
+                    ? Convert.ToBase64String(_netManager.CryptoPublicKey)
                     : null
             };
 

Robust.Shared.Maths/Box2i.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
@@ -135,5 +135,17 @@ namespace Robust.Shared.Maths
         {
             return $"({Left}, {Bottom}, {Right}, {Top})";
         }
+
+        /// <summary>
+        /// Multiplies each side of the box by the scalar.
+        /// </summary>
+        public Box2i Scale(int scalar)
+        {
+            return new Box2i(
+                Left * scalar,
+                Bottom * scalar,
+                Right * scalar,
+                Top * scalar);
+        }
     }
 }

Robust.Shared.Maths/Color.cs

@@ -880,7 +880,7 @@ namespace Robust.Shared.Maths
                 return color.Value;
             if (fallback.HasValue)
                 return fallback.Value;
-            throw new ArgumentException("Invalid color code and no fallback provided.", nameof(hexColor));
+            throw new ArgumentException($"Invalid color code \"{new string(hexColor)}\" and no fallback provided.", nameof(hexColor));
         }
 
         public static Color FromXaml(string name)

Robust.Shared.Maths/Robust.Shared.Maths.csproj

@@ -8,7 +8,7 @@
   </PropertyGroup>
   <Import Project="..\MSBuild\Robust.DefineConstants.targets" />
   <ItemGroup>
-    <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" PrivateAssets="All" />
+    <PackageReference Include="JetBrains.Annotations" Version="2021.3.0" PrivateAssets="All" />
     <PackageReference Condition="'$(TargetFramework)' == 'net472'" Include="System.Runtime.CompilerServices.Unsafe" Version="4.5.2" />
   </ItemGroup>
 </Project>

Robust.Shared.Scripting/Robust.Shared.Scripting.csproj

@@ -10,10 +10,10 @@
   <Import Project="..\MSBuild\Robust.DefineConstants.targets" />
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" Version="3.8.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="3.8.0" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="3.8.0" />
-    <PackageReference Include="JetBrains.Annotations" Version="2020.3.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.0.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.0.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1" />
+    <PackageReference Include="JetBrains.Annotations" Version="2021.3.0" PrivateAssets="All" />
   </ItemGroup>
 
   <ItemGroup>