Remove most static IoCManager. accesses from engine. (#3466)

Co-authored-by: metalgearsloth <comedian_vs_clown@hotmail.com>

RELEASE-NOTES.md

@@ -145,6 +145,7 @@ END TEMPLATE-->
 * Some internal logic in `LineEdit` has been shared with `TextEdit` by moving it to a new `TextEditShared` file.
 * SDL2 backend now uses `[UnmanagedCallersOnly]` instead of `GetFunctionPointerForDelegate`-style P/Invoke marshalling.
 * Entity prototype reloading logic has been moved out of `PrototypeManager` and into a new `PrototypeReloadSystem`.
+* Most usages of `IoCManager.` statically have been removed in favor of dependency injection.
 
 ## 0.62.1.0
 

Robust.Benchmarks/Serialization/SerializationBenchmark.cs

@@ -12,9 +12,9 @@ namespace Robust.Benchmarks.Serialization
     {
         public SerializationBenchmark()
         {
-            IoCManager.InitThread();
-            ServerIoC.RegisterIoC();
-            IoCManager.BuildGraph();
+            var deps = IoCManager.InitThread();
+            ServerIoC.RegisterIoC(deps);
+            deps.BuildGraph();
 
             var assemblies = new[]
             {
@@ -25,12 +25,12 @@ namespace Robust.Benchmarks.Serialization
 
             foreach (var assembly in assemblies)
             {
-                IoCManager.Resolve<IConfigurationManagerInternal>().LoadCVarsFromAssembly(assembly);
+                deps.Resolve<IConfigurationManagerInternal>().LoadCVarsFromAssembly(assembly);
             }
 
-            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
+            deps.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
 
-            SerializationManager = IoCManager.Resolve<ISerializationManager>();
+            SerializationManager = deps.Resolve<ISerializationManager>();
         }
 
         protected ISerializationManager SerializationManager { get; }

Robust.Client/Audio/Midi/MidiManager.cs

@@ -25,7 +25,7 @@ namespace Robust.Client.Audio.Midi;
 internal sealed partial class MidiManager : IMidiManager
 {
     [Dependency] private readonly IEyeManager _eyeManager = default!;
-    [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
+    [Dependency] private readonly IResourceCacheInternal _resourceManager = default!;
     [Dependency] private readonly IEntityManager _entityManager = default!;
     [Dependency] private readonly IConfigurationManager _cfgMan = default!;
     [Dependency] private readonly IClydeAudio _clydeAudio = default!;
@@ -107,7 +107,7 @@ internal sealed partial class MidiManager : IMidiManager
 
     private static ResourcePath CustomSoundfontDirectory = new ResourcePath("/soundfonts/");
 
-    private readonly ResourceLoaderCallbacks _soundfontLoaderCallbacks = new();
+    private readonly ResourceLoaderCallbacks _soundfontLoaderCallbacks;
 
     private bool FluidsynthInitialized;
     private bool _failedInitialize;
@@ -118,6 +118,11 @@ internal sealed partial class MidiManager : IMidiManager
     [ViewVariables(VVAccess.ReadWrite)]
     public int OcclusionCollisionMask { get; set; }
 
+    public MidiManager()
+    {
+        _soundfontLoaderCallbacks = new ResourceLoaderCallbacks(this);
+    }
+
     private void InitializeFluidsynth()
     {
         if (FluidsynthInitialized || _failedInitialize) return;
@@ -181,7 +186,7 @@ internal sealed partial class MidiManager : IMidiManager
         _midiThread = new Thread(ThreadUpdate);
         _midiThread.Start();
 
-        _broadPhaseSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<SharedPhysicsSystem>();
+        _broadPhaseSystem = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
         FluidsynthInitialized = true;
     }
 
@@ -444,9 +449,15 @@ internal sealed partial class MidiManager : IMidiManager
     /// </summary>
     private sealed class ResourceLoaderCallbacks : SoundFontLoaderCallbacks
     {
+        private readonly MidiManager _parent;
         private readonly Dictionary<int, Stream> _openStreams = new();
         private int _nextStreamId = 1;
 
+        public ResourceLoaderCallbacks(MidiManager parent)
+        {
+            _parent = parent;
+        }
+
         public override IntPtr Open(string filename)
         {
             if (string.IsNullOrEmpty(filename))
@@ -455,7 +466,7 @@ internal sealed partial class MidiManager : IMidiManager
             }
 
             Stream? stream;
-            var resourceCache = IoCManager.Resolve<IResourceCache>();
+            var resourceCache = _parent._resourceManager;
             var resourcePath = new ResourcePath(filename);
 
             if (resourcePath.IsRooted)

Robust.Client/BaseClient.cs

@@ -238,7 +238,7 @@ namespace Robust.Client
 
         private void GameStoppedReset()
         {
-            IoCManager.Resolve<INetConfigurationManager>().FlushMessages();
+            _configManager.FlushMessages();
             _gameStates.Reset();
             _playMan.Shutdown();
             _entityManager.Shutdown();

Robust.Client/ClientIoC.cs

@@ -39,86 +39,86 @@ namespace Robust.Client
 {
     internal static class ClientIoC
     {
-        public static void RegisterIoC(GameController.DisplayMode mode)
+        public static void RegisterIoC(GameController.DisplayMode mode, IDependencyCollection deps)
         {
-            SharedIoC.RegisterIoC();
+            SharedIoC.RegisterIoC(deps);
 
-            IoCManager.Register<IGameTiming, ClientGameTiming>();
-            IoCManager.Register<IClientGameTiming, ClientGameTiming>();
-            IoCManager.Register<IPrototypeManager, ClientPrototypeManager>();
-            IoCManager.Register<IMapManager, NetworkedMapManager>();
-            IoCManager.Register<IMapManagerInternal, NetworkedMapManager>();
-            IoCManager.Register<INetworkedMapManager, NetworkedMapManager>();
-            IoCManager.Register<IEntityManager, ClientEntityManager>();
-            IoCManager.Register<IReflectionManager, ClientReflectionManager>();
-            IoCManager.Register<IConsoleHost, ClientConsoleHost>();
-            IoCManager.Register<IClientConsoleHost, ClientConsoleHost>();
-            IoCManager.Register<IComponentFactory, ClientComponentFactory>();
-            IoCManager.Register<ITileDefinitionManager, ClydeTileDefinitionManager>();
-            IoCManager.Register<IClydeTileDefinitionManager, ClydeTileDefinitionManager>();
-            IoCManager.Register<GameController, GameController>();
-            IoCManager.Register<IGameController, GameController>();
-            IoCManager.Register<IGameControllerInternal, GameController>();
-            IoCManager.Register<IResourceManager, ResourceCache>();
-            IoCManager.Register<IResourceManagerInternal, ResourceCache>();
-            IoCManager.Register<IResourceCache, ResourceCache>();
-            IoCManager.Register<IResourceCacheInternal, ResourceCache>();
-            IoCManager.Register<IClientNetManager, NetManager>();
-            IoCManager.Register<EntityManager, ClientEntityManager>();
-            IoCManager.Register<ClientEntityManager>();
-            IoCManager.Register<IClientEntityManager, ClientEntityManager>();
-            IoCManager.Register<IClientEntityManagerInternal, ClientEntityManager>();
-            IoCManager.Register<IEntityNetworkManager, ClientEntityManager>();
-            IoCManager.Register<IClientGameStateManager, ClientGameStateManager>();
-            IoCManager.Register<IBaseClient, BaseClient>();
-            IoCManager.Register<IPlayerManager, PlayerManager>();
-            IoCManager.Register<ISharedPlayerManager, PlayerManager>();
-            IoCManager.Register<IStateManager, StateManager>();
-            IoCManager.Register<IUserInterfaceManager, UserInterfaceManager>();
-            IoCManager.Register<IUserInterfaceManagerInternal, UserInterfaceManager>();
-            IoCManager.Register<ILightManager, LightManager>();
-            IoCManager.Register<IDiscordRichPresence, DiscordRichPresence>();
-            IoCManager.Register<IMidiManager, MidiManager>();
-            IoCManager.Register<IAuthManager, AuthManager>();
-            IoCManager.Register<ProfViewManager>();
-            IoCManager.Register<IPhysicsManager, PhysicsManager>();
+            deps.Register<IGameTiming, ClientGameTiming>();
+            deps.Register<IClientGameTiming, ClientGameTiming>();
+            deps.Register<IPrototypeManager, ClientPrototypeManager>();
+            deps.Register<IMapManager, NetworkedMapManager>();
+            deps.Register<IMapManagerInternal, NetworkedMapManager>();
+            deps.Register<INetworkedMapManager, NetworkedMapManager>();
+            deps.Register<IEntityManager, ClientEntityManager>();
+            deps.Register<IReflectionManager, ClientReflectionManager>();
+            deps.Register<IConsoleHost, ClientConsoleHost>();
+            deps.Register<IClientConsoleHost, ClientConsoleHost>();
+            deps.Register<IComponentFactory, ClientComponentFactory>();
+            deps.Register<ITileDefinitionManager, ClydeTileDefinitionManager>();
+            deps.Register<IClydeTileDefinitionManager, ClydeTileDefinitionManager>();
+            deps.Register<GameController, GameController>();
+            deps.Register<IGameController, GameController>();
+            deps.Register<IGameControllerInternal, GameController>();
+            deps.Register<IResourceManager, ResourceCache>();
+            deps.Register<IResourceManagerInternal, ResourceCache>();
+            deps.Register<IResourceCache, ResourceCache>();
+            deps.Register<IResourceCacheInternal, ResourceCache>();
+            deps.Register<IClientNetManager, NetManager>();
+            deps.Register<EntityManager, ClientEntityManager>();
+            deps.Register<ClientEntityManager>();
+            deps.Register<IClientEntityManager, ClientEntityManager>();
+            deps.Register<IClientEntityManagerInternal, ClientEntityManager>();
+            deps.Register<IEntityNetworkManager, ClientEntityManager>();
+            deps.Register<IClientGameStateManager, ClientGameStateManager>();
+            deps.Register<IBaseClient, BaseClient>();
+            deps.Register<IPlayerManager, PlayerManager>();
+            deps.Register<ISharedPlayerManager, PlayerManager>();
+            deps.Register<IStateManager, StateManager>();
+            deps.Register<IUserInterfaceManager, UserInterfaceManager>();
+            deps.Register<IUserInterfaceManagerInternal, UserInterfaceManager>();
+            deps.Register<ILightManager, LightManager>();
+            deps.Register<IDiscordRichPresence, DiscordRichPresence>();
+            deps.Register<IMidiManager, MidiManager>();
+            deps.Register<IAuthManager, AuthManager>();
+            deps.Register<ProfViewManager>();
+            deps.Register<IPhysicsManager, PhysicsManager>();
             switch (mode)
             {
                 case GameController.DisplayMode.Headless:
-                    IoCManager.Register<IClyde, ClydeHeadless>();
-                    IoCManager.Register<IClipboardManager, ClydeHeadless>();
-                    IoCManager.Register<IClydeInternal, ClydeHeadless>();
-                    IoCManager.Register<IClydeAudio, ClydeAudioHeadless>();
-                    IoCManager.Register<IClydeAudioInternal, ClydeAudioHeadless>();
-                    IoCManager.Register<IInputManager, InputManager>();
-                    IoCManager.Register<IFileDialogManager, DummyFileDialogManager>();
-                    IoCManager.Register<IUriOpener, UriOpenerDummy>();
+                    deps.Register<IClyde, ClydeHeadless>();
+                    deps.Register<IClipboardManager, ClydeHeadless>();
+                    deps.Register<IClydeInternal, ClydeHeadless>();
+                    deps.Register<IClydeAudio, ClydeAudioHeadless>();
+                    deps.Register<IClydeAudioInternal, ClydeAudioHeadless>();
+                    deps.Register<IInputManager, InputManager>();
+                    deps.Register<IFileDialogManager, DummyFileDialogManager>();
+                    deps.Register<IUriOpener, UriOpenerDummy>();
                     break;
                 case GameController.DisplayMode.Clyde:
-                    IoCManager.Register<IClyde, Clyde>();
-                    IoCManager.Register<IClipboardManager, Clyde>();
-                    IoCManager.Register<IClydeInternal, Clyde>();
-                    IoCManager.Register<IClydeAudio, FallbackProxyClydeAudio>();
-                    IoCManager.Register<IClydeAudioInternal, FallbackProxyClydeAudio>();
-                    IoCManager.Register<IInputManager, ClydeInputManager>();
-                    IoCManager.Register<IFileDialogManager, FileDialogManager>();
-                    IoCManager.Register<IUriOpener, UriOpener>();
+                    deps.Register<IClyde, Clyde>();
+                    deps.Register<IClipboardManager, Clyde>();
+                    deps.Register<IClydeInternal, Clyde>();
+                    deps.Register<IClydeAudio, FallbackProxyClydeAudio>();
+                    deps.Register<IClydeAudioInternal, FallbackProxyClydeAudio>();
+                    deps.Register<IInputManager, ClydeInputManager>();
+                    deps.Register<IFileDialogManager, FileDialogManager>();
+                    deps.Register<IUriOpener, UriOpener>();
                     break;
                 default:
                     throw new ArgumentOutOfRangeException();
             }
 
-            IoCManager.Register<IFontManager, FontManager>();
-            IoCManager.Register<IFontManagerInternal, FontManager>();
-            IoCManager.Register<IEyeManager, EyeManager>();
-            IoCManager.Register<IPlacementManager, PlacementManager>();
-            IoCManager.Register<IOverlayManager, OverlayManager>();
-            IoCManager.Register<IOverlayManagerInternal, OverlayManager>();
-            IoCManager.Register<IViewVariablesManager, ClientViewVariablesManager>();
-            IoCManager.Register<IClientViewVariablesManager, ClientViewVariablesManager>();
-            IoCManager.Register<IClientViewVariablesManagerInternal, ClientViewVariablesManager>();
-            IoCManager.Register<IClientConGroupController, ClientConGroupController>();
-            IoCManager.Register<IScriptClient, ScriptClient>();
+            deps.Register<IFontManager, FontManager>();
+            deps.Register<IFontManagerInternal, FontManager>();
+            deps.Register<IEyeManager, EyeManager>();
+            deps.Register<IPlacementManager, PlacementManager>();
+            deps.Register<IOverlayManager, OverlayManager>();
+            deps.Register<IOverlayManagerInternal, OverlayManager>();
+            deps.Register<IViewVariablesManager, ClientViewVariablesManager>();
+            deps.Register<IClientViewVariablesManager, ClientViewVariablesManager>();
+            deps.Register<IClientViewVariablesManagerInternal, ClientViewVariablesManager>();
+            deps.Register<IClientConGroupController, ClientConGroupController>();
+            deps.Register<IScriptClient, ScriptClient>();
         }
     }
 }

Robust.Client/Console/Commands/AddCompCommand.cs

@@ -8,6 +8,9 @@ namespace Robust.Client.Console.Commands
     [UsedImplicitly]
     internal sealed class AddCompCommand : LocalizedCommands
     {
+        [Dependency] private readonly IComponentFactory _componentFactory = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "addcompc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -22,20 +25,20 @@ namespace Robust.Client.Console.Commands
             var entity = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
-            var compFactory = IoCManager.Resolve<IComponentFactory>();
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-
-            var component = (Component) compFactory.GetComponent(componentName);
+            var component = (Component) _componentFactory.GetComponent(componentName);
 
             component.Owner = entity;
 
-            entityManager.AddComponent(entity, component);
+            _entityManager.AddComponent(entity, component);
         }
     }
 
     [UsedImplicitly]
     internal sealed class RemoveCompCommand : LocalizedCommands
     {
+        [Dependency] private readonly IComponentFactory _componentFactory = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "rmcompc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -49,12 +52,9 @@ namespace Robust.Client.Console.Commands
             var entityUid = EntityUid.Parse(args[0]);
             var componentName = args[1];
 
-            var entManager = IoCManager.Resolve<IEntityManager>();
-            var compFactory = IoCManager.Resolve<IComponentFactory>();
+            var registration = _componentFactory.GetRegistration(componentName);
 
-            var registration = compFactory.GetRegistration(componentName);
-
-            entManager.RemoveComponent(entityUid, registration.Type);
+            _entityManager.RemoveComponent(entityUid, registration.Type);
         }
     }
 }

Robust.Client/Console/Commands/ClientSpawnCommand.cs

@@ -9,18 +9,21 @@ namespace Robust.Client.Console.Commands
     [UsedImplicitly]
     internal sealed class ClientSpawnCommand : LocalizedCommands
     {
+        [Dependency] private readonly IPlayerManager _playerManager = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "cspawn";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var controlled = IoCManager.Resolve<IPlayerManager>().LocalPlayer?.ControlledEntity ?? EntityUid.Invalid;
+            var controlled = _playerManager.LocalPlayer?.ControlledEntity ?? EntityUid.Invalid;
             if (controlled == EntityUid.Invalid)
             {
                 shell.WriteLine("You don't have an attached entity.");
                 return;
             }
 
-            var entityManager = IoCManager.Resolve<IEntityManager>();
+            var entityManager = _entityManager;
             entityManager.SpawnEntity(args[0], entityManager.GetComponent<TransformComponent>(controlled).Coordinates);
         }
     }

Robust.Client/Console/Commands/ConfigurationCommands.cs

@@ -8,11 +8,14 @@ namespace Robust.Client.Console.Commands
     [UsedImplicitly]
     public sealed class SaveConfig : LocalizedCommands
     {
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
+
+
         public override string Command => "saveconfig";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<IConfigurationManager>().SaveToFile();
+            _cfg.SaveToFile();
         }
     }
 

Robust.Client/Console/Commands/Debug.cs

@@ -33,22 +33,25 @@ namespace Robust.Client.Console.Commands
 {
     internal sealed class DumpEntitiesCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "dumpentities";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-
-            foreach (var e in entityManager.GetEntities().OrderBy(e => e))
+            foreach (var e in _entityManager.GetEntities().OrderBy(e => e))
             {
                 shell.WriteLine(
-                    $"entity {e}, {entityManager.GetComponent<MetaDataComponent>(e).EntityPrototype?.ID}, {entityManager.GetComponent<TransformComponent>(e).Coordinates}.");
+                    $"entity {e}, {_entityManager.GetComponent<MetaDataComponent>(e).EntityPrototype?.ID}, {_entityManager.GetComponent<TransformComponent>(e).Coordinates}.");
             }
         }
     }
 
     internal sealed class GetComponentRegistrationCommand : LocalizedCommands
     {
+        [Dependency] private readonly IComponentFactory _componentFactory = default!;
+
+
         public override string Command => "getcomponentregistration";
 
 
@@ -60,11 +63,9 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var componentFactory = IoCManager.Resolve<IComponentFactory>();
-
             try
             {
-                var registration = componentFactory.GetRegistration(args[0]);
+                var registration = _componentFactory.GetRegistration(args[0]);
 
                 var message = new StringBuilder($"'{registration.Name}': (type: {registration.Type}, ");
                 if (registration.NetID == null)
@@ -94,6 +95,9 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class ToggleMonitorCommand : LocalizedCommands
     {
+        [Dependency] private readonly IUserInterfaceManager _uiMgr = default!;
+
+
         public override string Command => "monitor";
 
         public override string Help
@@ -107,7 +111,7 @@ namespace Robust.Client.Console.Commands
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var monitors = IoCManager.Resolve<IUserInterfaceManager>().DebugMonitors;
+            var monitors = _uiMgr.DebugMonitors;
 
             if (args.Length != 1)
             {
@@ -175,17 +179,21 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class ShowPositionsCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
+
         public override string Command => "showpos";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<DebugDrawingSystem>();
+            var mgr = _entitySystems.GetEntitySystem<DebugDrawingSystem>();
             mgr.DebugPositions = !mgr.DebugPositions;
         }
     }
 
     internal sealed class ShowRayCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
+
         public override string Command => "showrays";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -202,7 +210,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var mgr = EntitySystem.Get<DebugRayDrawingSystem>();
+            var mgr = _entitySystems.GetEntitySystem<DebugRayDrawingSystem>();
             mgr.DebugDrawRays = !mgr.DebugDrawRays;
             shell.WriteError("Toggled showing rays to:" + mgr.DebugDrawRays);
             mgr.DebugRayLifetime = TimeSpan.FromSeconds(duration);
@@ -211,16 +219,20 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class DisconnectCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClientNetManager _netManager = default!;
+
         public override string Command => "disconnect";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<IClientNetManager>().ClientDisconnect("Disconnect command used.");
+            _netManager.ClientDisconnect("Disconnect command used.");
         }
     }
 
     internal sealed class EntityInfoCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "entfo";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -238,7 +250,7 @@ namespace Robust.Client.Console.Commands
             }
 
             var uid = EntityUid.Parse(args[0]);
-            var entmgr = IoCManager.Resolve<IEntityManager>();
+            var entmgr = _entityManager;
             if (!entmgr.EntityExists(uid))
             {
                 shell.WriteError("That entity does not exist. Sorry lad.");
@@ -270,6 +282,8 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class SnapGridGetCell : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "sggcell";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -294,8 +308,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var mapMan = IoCManager.Resolve<IMapManager>();
-            if (mapMan.TryGetGrid(gridUid, out var grid))
+            if (_map.TryGetGrid(gridUid, out var grid))
             {
                 foreach (var entity in grid.GetAnchoredEntities(new Vector2i(
                              int.Parse(indices.Split(',')[0], CultureInfo.InvariantCulture),
@@ -313,6 +326,8 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class SetPlayerName : LocalizedCommands
     {
+        [Dependency] private readonly IBaseClient _baseClient = default!;
+
         public override string Command => "overrideplayername";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -323,8 +338,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var client = IoCManager.Resolve<IBaseClient>();
-            client.PlayerNameOverride = args[0];
+            _baseClient.PlayerNameOverride = args[0];
 
             shell.WriteLine($"Overriding player name to \"{args[0]}\".");
         }
@@ -332,6 +346,9 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class LoadResource : LocalizedCommands
     {
+        [Dependency] private readonly IResourceCache _res = default!;
+        [Dependency] private readonly IReflectionManager _reflection = default!;
+
         public override string Command => "ldrsc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -342,13 +359,11 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var resourceCache = IoCManager.Resolve<IResourceCache>();
-            var reflection = IoCManager.Resolve<IReflectionManager>();
             Type type;
 
             try
             {
-                type = reflection.LooseGetType(args[1]);
+                type = _reflection.LooseGetType(args[1]);
             }
             catch (ArgumentException)
             {
@@ -357,17 +372,20 @@ namespace Robust.Client.Console.Commands
             }
 
             var getResourceMethod =
-                resourceCache
+                _res
                     .GetType()
                     .GetMethod("GetResource", new[] { typeof(string), typeof(bool) });
             DebugTools.Assert(getResourceMethod != null);
             var generic = getResourceMethod!.MakeGenericMethod(type);
-            generic.Invoke(resourceCache, new object[] { args[0], true });
+            generic.Invoke(_res, new object[] { args[0], true });
         }
     }
 
     internal sealed class ReloadResource : LocalizedCommands
     {
+        [Dependency] private readonly IResourceCache _res = default!;
+        [Dependency] private readonly IReflectionManager _reflection = default!;
+
         public override string Command => "rldrsc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -378,13 +396,10 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var resourceCache = IoCManager.Resolve<IResourceCache>();
-            var reflection = IoCManager.Resolve<IReflectionManager>();
-
             Type type;
             try
             {
-                type = reflection.LooseGetType(args[1]);
+                type = _reflection.LooseGetType(args[1]);
             }
             catch (ArgumentException)
             {
@@ -392,15 +407,17 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var getResourceMethod = resourceCache.GetType().GetMethod("ReloadResource", new[] { typeof(string) });
+            var getResourceMethod = _res.GetType().GetMethod("ReloadResource", new[] { typeof(string) });
             DebugTools.Assert(getResourceMethod != null);
             var generic = getResourceMethod!.MakeGenericMethod(type);
-            generic.Invoke(resourceCache, new object[] { args[0] });
+            generic.Invoke(_res, new object[] { args[0] });
         }
     }
 
     internal sealed class GridTileCount : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "gridtc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -417,8 +434,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var mapManager = IoCManager.Resolve<IMapManager>();
-            if (mapManager.TryGetGrid(gridUid, out var grid))
+            if (_map.TryGetGrid(gridUid, out var grid))
             {
                 shell.WriteLine(grid.GetAllTiles().Count().ToString());
             }
@@ -431,16 +447,16 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class GuiDumpCommand : LocalizedCommands
     {
+        [Dependency] private readonly IUserInterfaceManager _ui = default!;
+        [Dependency] private readonly IResourceCache _res = default!;
+
         public override string Command => "guidump";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var uiMgr = IoCManager.Resolve<IUserInterfaceManager>();
-            var res = IoCManager.Resolve<IResourceManager>();
+            using var writer = _res.UserData.OpenWriteText(new ResourcePath("/guidump.txt"));
 
-            using var writer = res.UserData.OpenWriteText(new ResourcePath("/guidump.txt"));
-
-            foreach (var root in uiMgr.AllRoots)
+            foreach (var root in _ui.AllRoots)
             {
                 writer.WriteLine($"ROOT: {root}");
                 _writeNode(root, 0, writer);
@@ -503,99 +519,105 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class SetClipboardCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClipboardManager _clipboard = default!;
+
         public override string Command => "setclipboard";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<IClipboardManager>();
-            mgr.SetText(args[0]);
+            _clipboard.SetText(args[0]);
         }
     }
 
     internal sealed class GetClipboardCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClipboardManager _clipboard = default!;
+
         public override string Command => "getclipboard";
 
         public override async void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<IClipboardManager>();
-            shell.WriteLine(await mgr.GetText());
+            shell.WriteLine(await _clipboard.GetText());
         }
     }
 
     internal sealed class ToggleLight : LocalizedCommands
     {
+        [Dependency] private readonly ILightManager _light = default!;
+
         public override string Command => "togglelight";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<ILightManager>();
-            if (!mgr.LockConsoleAccess)
-                mgr.Enabled = !mgr.Enabled;
+            if (!_light.LockConsoleAccess)
+                _light.Enabled = !_light.Enabled;
         }
     }
 
     internal sealed class ToggleFOV : LocalizedCommands
     {
+        [Dependency] private readonly IEyeManager _eye = default!;
+
         public override string Command => "togglefov";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<IEyeManager>();
-            if (mgr.CurrentEye != null)
-                mgr.CurrentEye.DrawFov = !mgr.CurrentEye.DrawFov;
+            _eye.CurrentEye.DrawFov = !_eye.CurrentEye.DrawFov;
         }
     }
 
     internal sealed class ToggleHardFOV : LocalizedCommands
     {
+        [Dependency] private readonly ILightManager _light = default!;
+
         public override string Command => "togglehardfov";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<ILightManager>();
-            if (!mgr.LockConsoleAccess)
-                mgr.DrawHardFov = !mgr.DrawHardFov;
+            if (!_light.LockConsoleAccess)
+                _light.DrawHardFov = !_light.DrawHardFov;
         }
     }
 
     internal sealed class ToggleShadows : LocalizedCommands
     {
+        [Dependency] private readonly ILightManager _light = default!;
+
         public override string Command => "toggleshadows";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<ILightManager>();
-            if (!mgr.LockConsoleAccess)
-                mgr.DrawShadows = !mgr.DrawShadows;
+            if (!_light.LockConsoleAccess)
+                _light.DrawShadows = !_light.DrawShadows;
         }
     }
 
     internal sealed class ToggleLightBuf : LocalizedCommands
     {
+        [Dependency] private readonly ILightManager _light = default!;
+
         public override string Command => "togglelightbuf";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<ILightManager>();
-            if (!mgr.LockConsoleAccess)
-                mgr.DrawLighting = !mgr.DrawLighting;
+            if (!_light.LockConsoleAccess)
+                _light.DrawLighting = !_light.DrawLighting;
         }
     }
 
     internal sealed class ChunkInfoCommand : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+        [Dependency] private readonly IEyeManager _eye = default!;
+        [Dependency] private readonly IInputManager _input = default!;
+
         public override string Command => "chunkinfo";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mapMan = IoCManager.Resolve<IMapManager>();
-            var inputMan = IoCManager.Resolve<IInputManager>();
-            var eyeMan = IoCManager.Resolve<IEyeManager>();
+            var mousePos = _eye.ScreenToMap(_input.MouseScreenPosition);
 
-            var mousePos = eyeMan.ScreenToMap(inputMan.MouseScreenPosition);
-
-            if (!mapMan.TryFindGridAt(mousePos, out var grid))
+            if (!_map.TryFindGridAt(mousePos, out var grid))
             {
                 shell.WriteLine("No grid under your mouse cursor.");
                 return;
@@ -612,6 +634,9 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class ReloadShadersCommand : LocalizedCommands
     {
+        [Dependency] private readonly IResourceCacheInternal _res = default!;
+        [Dependency] private readonly ITaskManager _taskManager = default!;
+
         public override string Command => "rldshader";
 
         public static Dictionary<string, FileSystemWatcher>? _watchers;
@@ -620,7 +645,7 @@ namespace Robust.Client.Console.Commands
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IResourceCacheInternal resC;
+            var resC = _res;
             if (args.Length == 1)
             {
                 if (args[0] == "+watch")
@@ -631,8 +656,6 @@ namespace Robust.Client.Console.Commands
                         return;
                     }
 
-                    resC = IoCManager.Resolve<IResourceCacheInternal>();
-
                     _watchers = new Dictionary<string, FileSystemWatcher>();
 
                     var stringComparer = PathHelpers.IsFileSystemCaseSensitive()
@@ -641,7 +664,7 @@ namespace Robust.Client.Console.Commands
 
                     var reversePathResolution = new ConcurrentDictionary<string, HashSet<ResourcePath>>(stringComparer);
 
-                    var taskManager = IoCManager.Resolve<ITaskManager>();
+                    var taskManager = _taskManager;
 
                     var shaderCount = 0;
                     var created = 0;
@@ -697,8 +720,7 @@ namespace Robust.Client.Console.Commands
                                     {
                                         try
                                         {
-                                            IoCManager.Resolve<IResourceCache>()
-                                                .ReloadResource<ShaderSourceResource>(resPath);
+                                            resC.ReloadResource<ShaderSourceResource>(resPath);
                                             shell.WriteLine($"Reloaded shader: {resPath}");
                                         }
                                         catch (Exception)
@@ -759,8 +781,6 @@ namespace Robust.Client.Console.Commands
 
             shell.WriteLine("Reloading content shader resources...");
 
-            resC = IoCManager.Resolve<IResourceCacheInternal>();
-
             foreach (var (path, _) in resC.GetAllResources<ShaderSourceResource>())
             {
                 try
@@ -779,19 +799,19 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class ClydeDebugLayerCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClydeInternal _clyde = default!;
+
         public override string Command => "cldbglyr";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var clyde = IoCManager.Resolve<IClydeInternal>();
-
             if (args.Length < 1)
             {
-                clyde.DebugLayers = ClydeDebugLayers.None;
+                _clyde.DebugLayers = ClydeDebugLayers.None;
                 return;
             }
 
-            clyde.DebugLayers = args[0] switch
+            _clyde.DebugLayers = args[0] switch
             {
                 "fov" => ClydeDebugLayers.Fov,
                 "light" => ClydeDebugLayers.Light,
@@ -802,6 +822,8 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class GetKeyInfoCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClydeInternal _clyde = default!;
+
         public override string Command => "keyinfo";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -812,13 +834,11 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var clyde = IoCManager.Resolve<IClydeInternal>();
-
             if (Enum.TryParse(typeof(Keyboard.Key), args[0], true, out var parsed))
             {
                 var key = (Keyboard.Key)parsed!;
 
-                var name = clyde.GetKeyName(key);
+                var name = _clyde.GetKeyName(key);
 
                 shell.WriteLine($"name: '{name}' ");
             }

Robust.Client/Console/Commands/LauncherAuthCommand.cs

@@ -11,13 +11,16 @@ namespace Robust.Client.Console.Commands
 {
     internal sealed class LauncherAuthCommand : LocalizedCommands
     {
+        [Dependency] private readonly IAuthManager _auth = default!;
+        [Dependency] private readonly IGameControllerInternal _gameController = default!;
+
         public override string Command => "launchauth";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             var wantName = args.Length > 0 ? args[0] : null;
 
-            var basePath = Path.GetDirectoryName(UserDataDir.GetUserDataDir())!;
+            var basePath = Path.GetDirectoryName(UserDataDir.GetUserDataDir(_gameController))!;
             var dbPath = Path.Combine(basePath, "launcher", "settings.db");
 
 #if USE_SYSTEM_SQLITE
@@ -48,9 +51,8 @@ namespace Robust.Client.Console.Commands
             var userName = reader.GetString(1);
             var token = reader.GetString(2);
 
-            var cfg = IoCManager.Resolve<IAuthManager>();
-            cfg.Token = token;
-            cfg.UserId = new NetUserId(userId);
+            _auth.Token = token;
+            _auth.UserId = new NetUserId(userId);
 
             shell.WriteLine($"Logged into account {userName}");
         }

Robust.Client/Console/Commands/MonitorCommands.cs

@@ -9,13 +9,13 @@ namespace Robust.Client.Console.Commands
     [UsedImplicitly]
     public sealed class LsMonitorCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClyde _clyde = default!;
+
         public override string Command => "lsmonitor";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var clyde = IoCManager.Resolve<IClyde>();
-
-            foreach (var monitor in clyde.EnumerateMonitors())
+            foreach (var monitor in _clyde.EnumerateMonitors())
             {
                 shell.WriteLine(
                     $"[{monitor.Id}] {monitor.Name}: {monitor.Size.X}x{monitor.Size.Y}@{monitor.RefreshRate}Hz");
@@ -26,6 +26,8 @@ namespace Robust.Client.Console.Commands
     [UsedImplicitly]
     public sealed class MonitorInfoCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClyde _clyde = default!;
+
         public override string Command => "monitorinfo";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -36,8 +38,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var clyde = IoCManager.Resolve<IClyde>();
-            var monitor = clyde.EnumerateMonitors().Single(c => c.Id == int.Parse(args[0]));
+            var monitor = _clyde.EnumerateMonitors().Single(c => c.Id == int.Parse(args[0]));
 
             shell.WriteLine($"{monitor.Id}: {monitor.Name}");
             shell.WriteLine($"Video modes:");
@@ -52,15 +53,15 @@ namespace Robust.Client.Console.Commands
     [UsedImplicitly]
     public sealed class SetMonitorCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClyde _clyde = default!;
+
         public override string Command => "setmonitor";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var clyde = IoCManager.Resolve<IClyde>();
-
             var id = int.Parse(args[0]);
-            var monitor = clyde.EnumerateMonitors().Single(m => m.Id == id);
-            clyde.SetWindowMonitor(monitor);
+            var monitor = _clyde.EnumerateMonitors().Single(m => m.Id == id);
+            _clyde.SetWindowMonitor(monitor);
         }
     }
 }

Robust.Client/Console/Commands/PhysicsOverlayCommands.cs

@@ -8,6 +8,8 @@ namespace Robust.Client.Console.Commands
 {
     public sealed class PhysicsOverlayCommands : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
+
         public override string Command => "physics";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -18,7 +20,7 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var system = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<DebugPhysicsSystem>();
+            var system = _entitySystems.GetEntitySystem<DebugPhysicsSystem>();
 
             switch (args[0])
             {

Robust.Client/Console/Commands/QuitCommand.cs

@@ -16,11 +16,13 @@ namespace Robust.Client.Console.Commands
 
     sealed class QuitCommand : LocalizedCommands
     {
+        [Dependency] private readonly IGameController _gameController = default!;
+
         public override string Command => "quit";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<IGameController>().Shutdown("quit command used");
+            _gameController.Shutdown("quit command used");
         }
     }
 }

Robust.Client/Console/Commands/ReloadLocalizationsCommand.cs

@@ -6,11 +6,13 @@ namespace Robust.Client.Console.Commands
 {
     internal sealed class ReloadLocalizationsCommand : LocalizedCommands
     {
+        [Dependency] private readonly ILocalizationManager _loc = default!;
+
         public override string Command => "rldloc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<ILocalizationManager>().ReloadLocalizations();
+            _loc.ReloadLocalizations();
 
             shell.RemoteExecuteCommand("sudo rldloc");
         }

Robust.Client/Console/Commands/Scripting.cs

@@ -27,18 +27,19 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class ServerScriptCommand : LocalizedCommands
     {
+        [Dependency] private readonly IScriptClient _scriptClient = default!;
+
         public override string Command => "scsi";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mgr = IoCManager.Resolve<IScriptClient>();
-            if (!mgr.CanScript)
+            if (!_scriptClient.CanScript)
             {
                 shell.WriteError("You do not have server side scripting permission.");
                 return;
             }
 
-            mgr.StartSession();
+            _scriptClient.StartSession();
         }
     }
 }

Robust.Client/Console/Commands/SendGarbageCommand.cs

@@ -6,16 +6,17 @@ namespace Robust.Client.Console.Commands
 {
     internal sealed class SendGarbageCommand : LocalizedCommands
     {
+        [Dependency] private readonly IClientNetManager _netManager = default!;
+
         public override string Command => "sendgarbage";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             // MsgStringTableEntries is registered as NetMessageAccept.Client so the server will immediately deny it.
             // And kick us.
-            var net = IoCManager.Resolve<IClientNetManager>();
             var msg = new MsgStringTableEntries();
             msg.Entries = new MsgStringTableEntries.Entry[0];
-            net.ClientSendMessage(msg);
+            _netManager.ClientSendMessage(msg);
         }
     }
 }

Robust.Client/Console/Commands/SetInputContextCommand.cs

@@ -8,6 +8,8 @@ namespace Robust.Client.Console.Commands
     [UsedImplicitly]
     public sealed class SetInputContextCommand : LocalizedCommands
     {
+        [Dependency] private readonly IInputManager _inputManager = default!;
+
         public override string Command => "setinputcontext";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -18,15 +20,13 @@ namespace Robust.Client.Console.Commands
                 return;
             }
 
-            var inputMan = IoCManager.Resolve<IInputManager>();
-
-            if (!inputMan.Contexts.Exists(args[0]))
+            if (!_inputManager.Contexts.Exists(args[0]))
             {
                 shell.WriteLine("Context not found!");
                 return;
             }
 
-            inputMan.Contexts.SetActiveContext(args[0]);
+            _inputManager.Contexts.SetActiveContext(args[0]);
         }
     }
 }

Robust.Client/Console/Commands/VelocitiesCommand.cs

@@ -7,11 +7,13 @@ namespace Robust.Client.Console.Commands
 {
     public sealed class VelocitiesCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _entitySystems = default!;
+
         public override string Command => "showvelocities";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<VelocityDebugSystem>().Enabled ^= true;
+            _entitySystems.GetEntitySystem<VelocityDebugSystem>().Enabled ^= true;
         }
     }
 }

Robust.Client/Credits/CreditsManager.cs

@@ -1,5 +1,7 @@
+using System;
 using System.Collections.Generic;
 using System.IO;
+using Robust.Client.ResourceManagement;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
 using Robust.Shared.Utility;
@@ -15,10 +17,18 @@ namespace Robust.Client.Credits
         /// <summary>
         ///     Gets a list of open source software used in the engine and their license.
         /// </summary>
+        [Obsolete("Use overload that takes in an explicit resource manager instead.")]
         public static IEnumerable<LicenseEntry> GetLicenses()
         {
-            var resM = IoCManager.Resolve<IResourceManager>();
-            using var file = resM.ContentFileRead("/EngineCredits/Libraries.yml");
+            return GetLicenses(IoCManager.Resolve<IResourceManager>());
+        }
+
+        /// <summary>
+        ///     Gets a list of open source software used in the engine and their license.
+        /// </summary>
+        public static IEnumerable<LicenseEntry> GetLicenses(IResourceManager resources)
+        {
+            using var file = resources.ContentFileRead("/EngineCredits/Libraries.yml");
             using var reader = new StreamReader(file);
             var yamlStream = new YamlStream();
             yamlStream.Load(reader);

Robust.Client/Debugging/DebugAnchoringSystem.cs

@@ -17,6 +17,7 @@ namespace Robust.Client.Debugging
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IInputManager _inputManager = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
+        [Dependency] private readonly IUserInterfaceManager _userInterface = default!;
 
         private Label? _label;
 
@@ -34,11 +35,11 @@ namespace Robust.Client.Debugging
                 if (_enabled)
                 {
                     _label = new Label();
-                    IoCManager.Resolve<IUserInterfaceManager>().StateRoot.AddChild(_label);
+                    _userInterface.StateRoot.AddChild(_label);
                 }
                 else
                 {
-                    IoCManager.Resolve<IUserInterfaceManager>().StateRoot.RemoveChild(_label!);
+                    _userInterface.StateRoot.RemoveChild(_label!);
                     _label = null;
                     _hovered = null;
                 }

Robust.Client/GameController/GameController.IoC.cs

@@ -10,17 +10,17 @@ namespace Robust.Client
     // Partial of GameController to initialize IoC and some other low-level systems like it.
     internal sealed partial class GameController
     {
-        private static void InitIoC(DisplayMode mode)
+        private static void InitIoC(DisplayMode mode, IDependencyCollection deps)
         {
-            ClientIoC.RegisterIoC(mode);
-            IoCManager.BuildGraph();
-            RegisterReflection();
+            ClientIoC.RegisterIoC(mode, deps);
+            deps.BuildGraph();
+            RegisterReflection(deps);
         }
 
-        internal static void RegisterReflection()
+        internal static void RegisterReflection(IDependencyCollection deps)
         {
             // Gets a handle to the shared and the current (client) dll.
-            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(new List<Assembly>(2)
+            deps.Resolve<IReflectionManager>().LoadAssemblies(new List<Assembly>(2)
             {
                 // Do NOT register Robust.Client.Godot.
                 // At least not for now.

Robust.Client/GameController/GameController.Standalone.cs

@@ -45,13 +45,12 @@ namespace Robust.Client
 
         private static void ParsedMain(CommandLineArgs args, bool contentStart, IMainArgs? loaderArgs, GameControllerOptions options)
         {
-            IoCManager.InitThread();
-
+            var deps = IoCManager.InitThread();
             var mode = args.Headless ? DisplayMode.Headless : DisplayMode.Clyde;
 
-            InitIoC(mode);
+            InitIoC(mode, deps);
 
-            var gc = IoCManager.Resolve<GameController>();
+            var gc = deps.Resolve<GameController>();
             gc.SetCommandLineArgs(args);
             gc._loaderArgs = loaderArgs;
 
@@ -107,7 +106,7 @@ namespace Robust.Client
             CleanupWindowThread();
 
             Logger.Debug("Goodbye");
-            IoCManager.Clear();
+            _dependencyCollection.Clear();
         }
 
         private void GameThreadMain(DisplayMode mode)

Robust.Client/GameController/GameController.cs

@@ -40,7 +40,7 @@ namespace Robust.Client
 {
     internal sealed partial class GameController : IGameControllerInternal
     {
-        [Dependency] private readonly IConfigurationManagerInternal _configurationManager = default!;
+        [Dependency] private readonly INetConfigurationManagerInternal _configurationManager = default!;
         [Dependency] private readonly IResourceCacheInternal _resourceCache = default!;
         [Dependency] private readonly IRobustSerializer _serializer = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
@@ -72,6 +72,7 @@ namespace Robust.Client
         [Dependency] private readonly IParallelManagerInternal _parallelMgr = default!;
         [Dependency] private readonly ProfManager _prof = default!;
         [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
+        [Dependency] private readonly ISerializationManager _serializationManager = default!;
 
         private IWebViewManagerHook? _webViewHook;
 
@@ -124,14 +125,14 @@ namespace Robust.Client
                 _configurationManager.LoadCVarsFromAssembly(loadedModule);
             }
 
-            IoCManager.Resolve<ISerializationManager>().Initialize();
+            _serializationManager.Initialize();
 
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.PreInit);
             _modLoader.BroadcastRunLevel(ModRunLevel.Init);
             _resourceCache.PreloadTextures();
             _networkManager.Initialize(false);
-            IoCManager.Resolve<INetConfigurationManager>().SetupNetworking();
+            _configurationManager.SetupNetworking();
             _serializer.Initialize();
             _inputManager.Initialize();
             _console.Initialize();
@@ -650,7 +651,7 @@ namespace Robust.Client
                 return Path.Combine(exeDir ?? throw new InvalidOperationException(), "user_data");
             }
 
-            return UserDataDir.GetUserDataDir();
+            return UserDataDir.GetUserDataDir(this);
         }
 
 

Robust.Client/Graphics/Audio/FallbackProxyClydeAudio.cs

@@ -16,18 +16,20 @@ namespace Robust.Client.Graphics.Audio
     [UsedImplicitly]
     internal sealed class FallbackProxyClydeAudio : ProxyClydeAudio
     {
+        [Dependency] private readonly IDependencyCollection _deps = default!;
+
         public override bool InitializePostWindowing()
         {
             // Deliberate lack of base call here (see base implementation for comments as to why there even is a base)
 
             ActualImplementation = new ClydeAudio();
-            IoCManager.InjectDependencies(ActualImplementation);
+            _deps.InjectDependencies(ActualImplementation, true);
             if (ActualImplementation.InitializePostWindowing())
                 return true;
 
             // If we get here, that failed, so use the fallback
             ActualImplementation = new ClydeAudioHeadless();
-            IoCManager.InjectDependencies(ActualImplementation);
+            _deps.InjectDependencies(ActualImplementation, true);
             return ActualImplementation.InitializePostWindowing();
         }
     }

Robust.Client/Graphics/Clyde/Clyde.RenderHandle.cs

@@ -2,7 +2,6 @@ using System;
 using System.Runtime.InteropServices;
 using Robust.Client.GameObjects;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Maths;
 using OpenToolkit.Graphics.OpenGL4;
 
@@ -17,13 +16,15 @@ namespace Robust.Client.Graphics.Clyde
         private sealed class RenderHandle : IRenderHandle
         {
             private readonly Clyde _clyde;
+            private readonly IEntityManager _entities;
 
             public DrawingHandleScreen DrawingHandleScreen { get; }
             public DrawingHandleWorld DrawingHandleWorld { get; }
 
-            public RenderHandle(Clyde clyde)
+            public RenderHandle(Clyde clyde, IEntityManager entities)
             {
                 _clyde = clyde;
+                _entities = entities;
 
                 DrawingHandleScreen = new DrawingHandleScreenImpl(this);
                 DrawingHandleWorld = new DrawingHandleWorldImpl(this);
@@ -126,14 +127,12 @@ namespace Robust.Client.Graphics.Clyde
 
             public void DrawEntity(EntityUid entity, Vector2 position, Vector2 scale, Direction? overrideDirection)
             {
-                var entMan = IoCManager.Resolve<IEntityManager>();
-
-                if (entMan.Deleted(entity))
+                if (_entities.Deleted(entity))
                 {
                     throw new ArgumentException("Tried to draw an entity has been deleted.", nameof(entity));
                 }
 
-                var sprite = entMan.GetComponent<SpriteComponent>(entity);
+                var sprite = _entities.GetComponent<SpriteComponent>(entity);
 
                 var oldProj = _clyde._currentMatrixProj;
                 var oldView = _clyde._currentMatrixView;
@@ -166,7 +165,7 @@ namespace Robust.Client.Graphics.Clyde
                     DrawingHandleWorld,
                     Angle.Zero,
                     overrideDirection == null
-                        ? entMan.GetComponent<TransformComponent>(entity).WorldRotation
+                        ? _entities.GetComponent<TransformComponent>(entity).WorldRotation
                         : Angle.Zero,
                     overrideDirection);
 

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

@@ -113,10 +113,10 @@ namespace Robust.Client.Graphics.Clyde
             switch (windowingApi)
             {
                 case "glfw":
-                    winImpl = new GlfwWindowingImpl(this);
+                    winImpl = new GlfwWindowingImpl(this, _deps);
                     break;
                 case "sdl2":
-                    winImpl = new Sdl2WindowingImpl(this);
+                    winImpl = new Sdl2WindowingImpl(this, _deps);
                     break;
                 default:
                     _logManager.GetSawmill("clyde.win").Log(

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -39,6 +39,7 @@ namespace Robust.Client.Graphics.Clyde
         [Dependency] private readonly IGameTiming _gameTiming = default!;
         [Dependency] private readonly IConfigurationManager _cfg = default!;
         [Dependency] private readonly ProfManager _prof = default!;
+        [Dependency] private readonly IDependencyCollection _deps = default!;
 
         private GLUniformBuffer<ProjViewMatrices> ProjViewUBO = default!;
         private GLUniformBuffer<UniformConstants> UniformConstantsUBO = default!;
@@ -244,7 +245,7 @@ namespace Robust.Client.Graphics.Clyde
 
             _sawmillOgl.Debug("Setting up RenderHandle...");
 
-            _renderHandle = new RenderHandle(this);
+            _renderHandle = new RenderHandle(this, _entityManager);
         }
 
         private (int major, int minor)? ParseGLOverrideVersion()

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

@@ -31,10 +31,10 @@ namespace Robust.Client.Graphics.Clyde
             // This will ensure some level of consistency between the backends.
             private bool _textInputActive;
 
-            public GlfwWindowingImpl(Clyde clyde)
+            public GlfwWindowingImpl(Clyde clyde, IDependencyCollection deps)
             {
                 _clyde = clyde;
-                IoCManager.InjectDependencies(this);
+                deps.InjectDependencies(this, true);
 
                 _sawmill = _logManager.GetSawmill("clyde.win");
                 _sawmillGlfw = _logManager.GetSawmill("clyde.win.glfw");

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

@@ -25,10 +25,10 @@ internal partial class Clyde
         private readonly ISawmill _sawmill;
         private readonly ISawmill _sawmillSdl2;
 
-        public Sdl2WindowingImpl(Clyde clyde)
+        public Sdl2WindowingImpl(Clyde clyde, IDependencyCollection deps)
         {
             _clyde = clyde;
-            IoCManager.InjectDependencies(this);
+            deps.InjectDependencies(this, true);
 
             _sawmill = _logManager.GetSawmill("clyde.win");
             _sawmillSdl2 = _logManager.GetSawmill("clyde.win.sdl2");

Robust.Client/Input/InputManager.cs

@@ -45,6 +45,7 @@ namespace Robust.Client.Input
         [Dependency] private readonly IReflectionManager _reflectionManager = default!;
         [Dependency] private readonly IUserInterfaceManagerInternal _uiMgr = default!;
         [Dependency] private readonly IConsoleHost _console = default!;
+        [Dependency] private readonly ISerializationManager _serialization = default!;
 
         private bool _currentlyFindingViewport;
 
@@ -127,7 +128,6 @@ namespace Robust.Client.Input
         public void SaveToUserData()
         {
             var mapping = new MappingDataNode();
-            var serializationManager = IoCManager.Resolve<ISerializationManager>();
 
             var modifiedBindings = _modifiedKeyFunctions
                 .Select(p => _bindingsByFunction[p])
@@ -151,8 +151,8 @@ namespace Robust.Client.Input
                 .ToArray();
 
             mapping.Add("version", new ValueDataNode("1"));
-            mapping.Add("binds", serializationManager.WriteValue(modifiedBindings));
-            mapping.Add("leaveEmpty", serializationManager.WriteValue(leaveEmpty));
+            mapping.Add("binds", _serialization.WriteValue(modifiedBindings));
+            mapping.Add("leaveEmpty", _serialization.WriteValue(leaveEmpty));
 
             var path = new ResourcePath(KeybindsPath);
             using var writer = _resourceMan.UserData.OpenWriteText(path);
@@ -491,13 +491,12 @@ namespace Robust.Client.Input
 
             var mapping = (YamlMappingNode) yamlStream.Documents[0].RootNode;
 
-            var serializationManager = IoCManager.Resolve<ISerializationManager>();
             var robustMapping = mapping.ToDataNode() as MappingDataNode;
             if (robustMapping == null) throw new InvalidOperationException();
 
             if (robustMapping.TryGet("binds", out var BaseKeyRegsNode))
             {
-                var baseKeyRegs = serializationManager.Read<KeyBindingRegistration[]>(BaseKeyRegsNode);
+                var baseKeyRegs = _serialization.Read<KeyBindingRegistration[]>(BaseKeyRegsNode);
 
                 foreach (var reg in baseKeyRegs)
                 {
@@ -526,7 +525,7 @@ namespace Robust.Client.Input
 
             if (userData && robustMapping.TryGet("leaveEmpty", out var node))
             {
-                var leaveEmpty = serializationManager.Read<BoundKeyFunction[]>(node);
+                var leaveEmpty = _serialization.Read<BoundKeyFunction[]>(node);
 
                 if (leaveEmpty.Length > 0)
                 {

Robust.Client/Physics/DebugPhysicsIslandSystem.cs

@@ -13,6 +13,8 @@ namespace Robust.Client.Physics
 {
     internal sealed class PhysicsIslandCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _entitySystemManager = default!;
+
         public override string Command => "showislands";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -23,13 +25,16 @@ namespace Robust.Client.Physics
                 return;
             }
 
-            EntitySystem.Get<DebugPhysicsIslandSystem>().Mode ^= DebugPhysicsIslandMode.Solve;
+            var system = _entitySystemManager.GetEntitySystem<DebugPhysicsIslandSystem>();
+            system.Mode ^= DebugPhysicsIslandMode.Solve;
         }
     }
 
     internal sealed class DebugPhysicsIslandSystem : EntitySystem
     {
         [Dependency] private readonly IGameTiming _gameTiming = default!;
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly IOverlayManager _overlayManager = default!;
 
         public DebugPhysicsIslandMode Mode { get; set; } = DebugPhysicsIslandMode.None;
 
@@ -44,15 +49,18 @@ namespace Robust.Client.Physics
         public override void Initialize()
         {
             base.Initialize();
+
             SubscribeLocalEvent<IslandSolveMessage>(HandleIslandSolveMessage);
-            IoCManager.Resolve<IOverlayManager>().AddOverlay(new PhysicsIslandOverlay());
+
+            var overlay = new PhysicsIslandOverlay(this, _gameTiming, _eyeManager);
+            _overlayManager.AddOverlay(overlay);
         }
 
         public override void Shutdown()
         {
             base.Shutdown();
 
-            IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsIslandOverlay));
+            _overlayManager.RemoveOverlay(typeof(PhysicsIslandOverlay));
         }
 
         public override void FrameUpdate(float frameTime)
@@ -88,18 +96,17 @@ namespace Robust.Client.Physics
 
     internal sealed class PhysicsIslandOverlay : Overlay
     {
-        [Dependency] private readonly IEyeManager _eyeManager = default!;
-        [Dependency] private readonly IGameTiming _gameTiming = default!;
-
-        private DebugPhysicsIslandSystem _islandSystem = default!;
+        private readonly IEyeManager _eyeManager;
+        private readonly IGameTiming _gameTiming;
+        private readonly DebugPhysicsIslandSystem _islandSystem;
 
         public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-        public PhysicsIslandOverlay()
+        public PhysicsIslandOverlay(DebugPhysicsIslandSystem system, IGameTiming gameTiming, IEyeManager eyeManager)
         {
-            _islandSystem = EntitySystem.Get<DebugPhysicsIslandSystem>();
-            _eyeManager = IoCManager.Resolve<IEyeManager>();
-            _gameTiming = IoCManager.Resolve<IGameTiming>();
+            _islandSystem = system;
+            _gameTiming = gameTiming;
+            _eyeManager = eyeManager;
         }
 
         protected internal override void Draw(in OverlayDrawArgs args)

Robust.Client/Physics/GridFixtureSystem.cs

@@ -13,6 +13,9 @@ namespace Robust.Client.Physics
 {
     internal sealed class GridFixtureSystem : SharedGridFixtureSystem
     {
+        [Dependency] private readonly IOverlayManager _overlay = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+
         public bool EnableDebug
         {
             get => _enableDebug;
@@ -22,17 +25,16 @@ namespace Robust.Client.Physics
 
                 Sawmill.Info($"Set grid fixture debug to {value}");
                 _enableDebug = value;
-                var overlayManager = IoCManager.Resolve<IOverlayManager>();
 
                 if (_enableDebug)
                 {
-                    var overlay = new GridSplitNodeOverlay(EntityManager, IoCManager.Resolve<IMapManager>(), this);
-                    overlayManager.AddOverlay(overlay);
+                    var overlay = new GridSplitNodeOverlay(EntityManager, _map, this);
+                    _overlay.AddOverlay(overlay);
                     RaiseNetworkEvent(new RequestGridNodesMessage());
                 }
                 else
                 {
-                    overlayManager.RemoveOverlay<GridSplitNodeOverlay>();
+                    _overlay.RemoveOverlay<GridSplitNodeOverlay>();
                     RaiseNetworkEvent(new StopGridNodesMessage());
                 }
             }

Robust.Client/Physics/GridSplitVisualsCommand.cs

@@ -6,11 +6,13 @@ namespace Robust.Client.Physics;
 
 public sealed class GridSplitVisualCommand : LocalizedCommands
 {
+    [Dependency] private readonly IEntitySystemManager _systemManager = default!;
+
     public override string Command => SharedGridFixtureSystem.ShowGridNodesCommand;
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        var system = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<GridFixtureSystem>();
+        var system = _systemManager.GetEntitySystem<GridFixtureSystem>();
         system.EnableDebug ^= true;
         shell.WriteLine($"Toggled gridsplit node visuals to {system.EnableDebug}");
     }

Robust.Client/Profiling/ProfViewManager.cs

@@ -123,12 +123,13 @@ public sealed class ProfViewManager
 
 public sealed class ProfSnapshotCommand : LocalizedCommands
 {
+    [Dependency] private readonly ProfViewManager _profView = default!;
+
     // ReSharper disable once StringLiteralTypo
     public override string Command => "profsnap";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        var profViewManager = IoCManager.Resolve<ProfViewManager>();
-        profViewManager.Snap();
+        _profView.Snap();
     }
 }

Robust.Client/Prototypes/ClientPrototypeManager.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -107,7 +107,7 @@ namespace Robust.Client.Prototypes
                     {
                         var file = new ResourcePath(args.FullPath);
 
-                        foreach (var root in IoCManager.Resolve<IResourceManager>().GetContentRoots())
+                        foreach (var root in Resources.GetContentRoots())
                         {
                             if (!file.TryRelativeTo(root, out var relative))
                             {

Robust.Client/Utility/UserDataDir.cs

@@ -8,7 +8,7 @@ namespace Robust.Client.Utility
     internal static class UserDataDir
     {
         [Pure]
-        public static string GetUserDataDir()
+        public static string GetUserDataDir(IGameControllerInternal gameController)
         {
             string appDataDir;
 
@@ -30,7 +30,7 @@ namespace Robust.Client.Utility
             appDataDir = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
 #endif
 
-            return Path.Combine(appDataDir, IoCManager.Resolve<IGameControllerInternal>().Options.UserDataDirectoryName, "data");
+            return Path.Combine(appDataDir, gameController.Options.UserDataDirectoryName, "data");
         }
 
     }

Robust.Client/ViewVariables/ViewVariablesCommand.cs

@@ -12,6 +12,8 @@ namespace Robust.Client.ViewVariables
     public sealed class ViewVariablesCommand : ViewVariablesBaseCommand
     {
         [Dependency] private readonly IClientViewVariablesManager _cvvm = default!;
+        [Dependency] private readonly IUserInterfaceManager _ui = default!;
+        [Dependency] private readonly IEntityManager _entities = default!;
 
         public override string Command => "vv";
 
@@ -50,7 +52,7 @@ namespace Robust.Client.ViewVariables
             if (valArg.StartsWith("guihover"))
             {
                 // UI element.
-                var obj = IoCManager.Resolve<IUserInterfaceManager>().CurrentlyHovered;
+                var obj = _ui.CurrentlyHovered;
                 if (obj == null)
                 {
                     shell.WriteLine("Not currently hovering any control.");
@@ -67,8 +69,7 @@ namespace Robust.Client.ViewVariables
                 return;
             }
 
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-            if (!entityManager.EntityExists(entity))
+            if (!_entities.EntityExists(entity))
             {
                 shell.WriteLine("That entity does not exist locally. Attempting to open remote view...");
                 _cvvm.OpenVV(new ViewVariablesEntitySelector(entity));

Robust.Server/BaseServer.cs

@@ -66,7 +66,7 @@ namespace Robust.Server
                 Buckets = Histogram.ExponentialBuckets(0.000_01, 2, 13)
             });
 
-        [Dependency] private readonly IConfigurationManagerInternal _config = default!;
+        [Dependency] private readonly INetConfigurationManagerInternal _config = default!;
         [Dependency] private readonly IServerEntityManager _entityManager = default!;
         [Dependency] private readonly ILogManager _log = default!;
         [Dependency] private readonly IRobustSerializer _serializer = default!;
@@ -87,10 +87,15 @@ namespace Robust.Server
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IRobustMappedStringSerializer _stringSerializer = default!;
         [Dependency] private readonly ILocalizationManagerInternal _loc = default!;
-        [Dependency] private readonly INetConfigurationManager _netCfgMan = default!;
         [Dependency] private readonly IServerConsoleHost _consoleHost = default!;
         [Dependency] private readonly IParallelManagerInternal _parallelMgr = default!;
         [Dependency] private readonly ProfManager _prof = default!;
+        [Dependency] private readonly IPrototypeManager _prototype = default!;
+        [Dependency] private readonly IPlacementManager _placement = default!;
+        [Dependency] private readonly IServerViewVariablesInternal _viewVariables = default!;
+        [Dependency] private readonly ISerializationManager _serialization = default!;
+        [Dependency] private readonly IStatusHost _statusHost = default!;
+        [Dependency] private readonly IComponentFactory _componentFactory = default!;
 
         private readonly Stopwatch _uptimeStopwatch = new();
 
@@ -257,15 +262,14 @@ namespace Robust.Server
             // Load metrics really early so that we can profile startup times in the future maybe.
             _metricsManager.Initialize();
 
-            var netMan = IoCManager.Resolve<IServerNetManager>();
             try
             {
-                netMan.Initialize(true);
-                netMan.StartServer();
+                _network.Initialize(true);
+                _network.StartServer();
             }
             catch (Exception e)
             {
-                var port = netMan.Port;
+                var port = _network.Port;
                 Logger.Fatal(
                     "Unable to setup networking manager. Check port {0} is not already in use and that all binding addresses are correct!\n{1}",
                     port, e);
@@ -313,7 +317,7 @@ namespace Robust.Server
 
             //IoCManager.Resolve<IMapLoader>().LoadedMapData +=
             //    IoCManager.Resolve<IRobustMappedStringSerializer>().AddStrings;
-            IoCManager.Resolve<IPrototypeManager>().LoadedData += (yaml, name) =>
+            _prototype.LoadedData += (yaml, name) =>
             {
                 if (!_stringSerializer.Locked)
                 {
@@ -322,27 +326,26 @@ namespace Robust.Server
             };
 
             // Initialize Tier 2 services
-            IoCManager.Resolve<IGameTiming>().InSimulation = true;
+            _time.InSimulation = true;
 
-            IoCManager.Resolve<INetConfigurationManager>().SetupNetworking();
+            _config.SetupNetworking();
             _playerManager.Initialize(MaxPlayers);
             _playerManager.PlayerStatusChanged += OnPlayerStatusChanged;
-            IoCManager.Resolve<IPlacementManager>().Initialize();
-            IoCManager.Resolve<IServerViewVariablesInternal>().Initialize();
+            _placement.Initialize();
+            _viewVariables.Initialize();
 
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.Init);
             _entityManager.Initialize();
             _mapManager.Initialize();
 
-            IoCManager.Resolve<ISerializationManager>().Initialize();
+            _serialization.Initialize();
 
             // because of 'reasons' this has to be called after the last assembly is loaded
             // otherwise the prototypes will be cleared
-            var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
-            prototypeManager.Initialize();
-            prototypeManager.LoadDirectory(Options.PrototypeDirectory);
-            prototypeManager.ResolveResults();
+            _prototype.Initialize();
+            _prototype.LoadDirectory(Options.PrototypeDirectory);
+            _prototype.ResolveResults();
 
             _consoleHost.Initialize();
             _entityManager.Startup();
@@ -359,8 +362,8 @@ namespace Robust.Server
 
             _modLoader.BroadcastRunLevel(ModRunLevel.PostInit);
 
-            IoCManager.Resolve<IStatusHost>().Start();
-            IoCManager.Resolve<HubManager>().Start();
+            _statusHost.Start();
+            _hubManager.Start();
 
             AppDomain.CurrentDomain.ProcessExit += ProcessExiting;
 
@@ -383,10 +386,9 @@ namespace Robust.Server
 
         private void AddFinalStringsToSerializer()
         {
-            var factory = IoCManager.Resolve<IComponentFactory>();
-            foreach (var regType in factory.AllRegisteredTypes)
+            foreach (var regType in _componentFactory.AllRegisteredTypes)
             {
-                var reg = factory.GetRegistration(regType);
+                var reg = _componentFactory.GetRegistration(regType);
                 _stringSerializer.AddString(reg.Name);
             }
 
@@ -533,9 +535,7 @@ namespace Robust.Server
         /// </summary>
         private void LoadSettings()
         {
-            var cfgMgr = IoCManager.Resolve<IConfigurationManager>();
-
-            cfgMgr.OnValueChanged(CVars.NetTickrate, i =>
+            _config.OnValueChanged(CVars.NetTickrate, i =>
             {
                 var b = (byte) i;
                 _time.TickRate = b;
@@ -551,7 +551,7 @@ namespace Robust.Server
             Logger.InfoS("srv", $"TickRate: {_time.TickRate}({_time.TickPeriod.TotalMilliseconds:0.00}ms)");
             Logger.InfoS("srv", $"Max players: {MaxPlayers}");
 
-            cfgMgr.OnValueChanged(CVars.GameAutoPauseEmpty, UpdateAutoPause, true);
+            _config.OnValueChanged(CVars.GameAutoPauseEmpty, UpdateAutoPause, true);
         }
 
         private void UpdateAutoPause(bool doAutoPause)
@@ -655,7 +655,7 @@ namespace Robust.Server
 
             using (TickUsage.WithLabels("NetworkedCVar").NewTimer())
             {
-                _netCfgMan.TickProcessMessages();
+                _config.TickProcessMessages();
             }
 
             using (TickUsage.WithLabels("Timers").NewTimer())

Robust.Server/Bql/BqlQueryManager.SimpleExecutor.cs

@@ -14,19 +14,18 @@ namespace Robust.Server.Bql
             var parsed = SimpleQuery.Parse(query);
             if (parsed.Success)
             {
-                var entityManager = IoCManager.Resolve<IEntityManager>();
                 var selectors = parsed.Value.Item1.ToArray();
                 if (selectors.Length == 0)
                 {
-                    return (entityManager.GetEntities(), parsed.Value.Item2);
+                    return (_entityManager.GetEntities(), parsed.Value.Item2);
                 }
 
                 var entities = _queriesByToken[selectors[0].Token]
-                    .DoInitialSelection(selectors[0].Arguments, selectors[0].Inverted, entityManager);
+                    .DoInitialSelection(selectors[0].Arguments, selectors[0].Inverted, _entityManager);
 
                 foreach (var sel in selectors[1..])
                 {
-                    entities = _queriesByToken[sel.Token].DoSelection(entities, sel.Arguments, sel.Inverted, entityManager);
+                    entities = _queriesByToken[sel.Token].DoSelection(entities, sel.Arguments, sel.Inverted, _entityManager);
                 }
 
                 return (entities, parsed.Value.Item2);

Robust.Server/Bql/BqlQueryManager.cs

@@ -9,18 +9,13 @@ namespace Robust.Server.Bql
 {
     public sealed partial class BqlQueryManager : IBqlQueryManager
     {
-        private readonly IReflectionManager _reflectionManager;
-        private readonly IComponentFactory _componentFactory;
+        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
+        [Dependency] private readonly IComponentFactory _componentFactory = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
 
         private readonly List<BqlQuerySelector> _instances = new();
         private readonly Dictionary<string, BqlQuerySelector> _queriesByToken = new();
 
-        public BqlQueryManager()
-        {
-            _reflectionManager = IoCManager.Resolve<IReflectionManager>();
-            _componentFactory = IoCManager.Resolve<IComponentFactory>();
-        }
-
         /// <summary>
         /// Automatically registers all query selectors with the parser/executor.
         /// </summary>

Robust.Server/Bql/ForAllCommand.cs

@@ -9,6 +9,9 @@ namespace Robust.Server.Bql
 {
     public sealed class ForAllCommand : LocalizedCommands
     {
+        [Dependency] private readonly IBqlQueryManager _bql = default!;
+        [Dependency] private readonly IEntityManager _entities = default!;
+
         public override string Command => "forall";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -19,12 +22,11 @@ namespace Robust.Server.Bql
                 return;
             }
 
-            var queryManager = IoCManager.Resolve<IBqlQueryManager>();
-            var (entities, rest) = queryManager.SimpleParseAndExecute(argStr[6..]);
+            var (entities, rest) = _bql.SimpleParseAndExecute(argStr[6..]);
 
             foreach (var ent in entities.ToList())
             {
-                var cmds = SubstituteEntityDetails(shell, ent, rest).Split(";");
+                var cmds = SubstituteEntityDetails(_entities, shell, ent, rest).Split(";");
                 foreach (var cmd in cmds)
                 {
                     shell.ExecuteCommand(cmd);
@@ -33,9 +35,12 @@ namespace Robust.Server.Bql
         }
 
         // This will be refactored out soon.
-        private static string SubstituteEntityDetails(IConsoleShell shell, EntityUid ent, string ruleString)
+        private static string SubstituteEntityDetails(
+            IEntityManager entMan,
+            IConsoleShell shell,
+            EntityUid ent,
+            string ruleString)
         {
-            var entMan = IoCManager.Resolve<IEntityManager>();
             var transform = entMan.GetComponent<TransformComponent>(ent);
             var metadata = entMan.GetComponent<MetaDataComponent>(ent);
 

Robust.Server/Console/Commands/AddComponentCommand.cs

@@ -9,6 +9,9 @@ namespace Robust.Server.Console.Commands
     [UsedImplicitly]
     internal sealed class AddComponentCommand : LocalizedCommands
     {
+        [Dependency] private readonly IComponentFactory _componentFactory = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "addcomp";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -25,9 +28,7 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-
-            if (!entityManager.EntityExists(uid))
+            if (!_entityManager.EntityExists(uid))
             {
                 shell.WriteLine($"No entity found with id {uid}.");
                 return;
@@ -35,25 +36,23 @@ namespace Robust.Server.Console.Commands
 
             var componentName = args[1];
 
-            var compFactory = IoCManager.Resolve<IComponentFactory>();
-
-            if (!compFactory.TryGetRegistration(componentName, out var registration, true))
+            if (!_componentFactory.TryGetRegistration(componentName, out var registration, true))
             {
                 shell.WriteLine($"No component found with name {componentName}.");
                 return;
             }
 
-            if (entityManager.HasComponent(uid, registration.Type))
+            if (_entityManager.HasComponent(uid, registration.Type))
             {
-                shell.WriteLine($"Entity {entityManager.GetComponent<MetaDataComponent>(uid).EntityName} already has a {componentName} component.");
+                shell.WriteLine($"Entity {_entityManager.GetComponent<MetaDataComponent>(uid).EntityName} already has a {componentName} component.");
             }
 
-            var component = (Component) compFactory.GetComponent(registration.Type);
+            var component = (Component) _componentFactory.GetComponent(registration.Type);
 
             component.Owner = uid;
-            entityManager.AddComponent(uid, component);
+            _entityManager.AddComponent(uid, component);
 
-            shell.WriteLine($"Added {componentName} component to entity {entityManager.GetComponent<MetaDataComponent>(uid).EntityName}.");
+            shell.WriteLine($"Added {componentName} component to entity {_entityManager.GetComponent<MetaDataComponent>(uid).EntityName}.");
         }
     }
 }

Robust.Server/Console/Commands/DeleteCommand.cs

@@ -7,6 +7,8 @@ namespace Robust.Server.Console.Commands
 {
     public sealed class DeleteCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "delete";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -17,21 +19,19 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var ent = IoCManager.Resolve<IServerEntityManager>();
-
             if (!EntityUid.TryParse(args[0], out var entity))
             {
                 shell.WriteLine("Invalid entity UID.");
                 return;
             }
 
-            if (!ent.EntityExists(entity))
+            if (!_entityManager.EntityExists(entity))
             {
                 shell.WriteLine("That entity does not exist.");
                 return;
             }
 
-            ent.DeleteEntity(entity);
+            _entityManager.DeleteEntity(entity);
         }
     }
 }

Robust.Server/Console/Commands/MapCommands.cs

@@ -16,6 +16,8 @@ namespace Robust.Server.Console.Commands
 {
     sealed class AddMapCommand : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "addmap";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -25,14 +27,12 @@ namespace Robust.Server.Console.Commands
 
             var mapId = new MapId(int.Parse(args[0]));
 
-            var mapMgr = IoCManager.Resolve<IMapManager>();
-
-            if (!mapMgr.MapExists(mapId))
+            if (!_map.MapExists(mapId))
             {
-                mapMgr.CreateMap(mapId);
+                _map.CreateMap(mapId);
                 if (args.Length >= 2 && args[1] == "false")
                 {
-                    mapMgr.AddUninitializedMap(mapId);
+                    _map.AddUninitializedMap(mapId);
                 }
 
                 shell.WriteLine($"Map with ID {mapId} created.");
@@ -45,6 +45,8 @@ namespace Robust.Server.Console.Commands
 
     sealed class RemoveMapCommand : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "rmmap";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -56,21 +58,23 @@ namespace Robust.Server.Console.Commands
             }
 
             var mapId = new MapId(int.Parse(args[0]));
-            var mapManager = IoCManager.Resolve<IMapManager>();
 
-            if (!mapManager.MapExists(mapId))
+            if (!_map.MapExists(mapId))
             {
                 shell.WriteError($"Map {mapId.Value} does not exist.");
                 return;
             }
 
-            mapManager.DeleteMap(mapId);
+            _map.DeleteMap(mapId);
             shell.WriteLine($"Map {mapId.Value} was removed.");
         }
     }
 
     public sealed class SaveGridCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _ent = default!;
+        [Dependency] private readonly IResourceManager _resource = default!;
+
         public override string Command => "savegrid";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -87,16 +91,14 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var entManager = IoCManager.Resolve<IEntityManager>();
-
             // no saving default grid
-            if (!entManager.EntityExists(uid))
+            if (!_ent.EntityExists(uid))
             {
                 shell.WriteError("That grid does not exist.");
                 return;
             }
 
-            IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>().Save(uid, args[1]);
+            _ent.System<MapLoaderSystem>().Save(uid, args[1]);
             shell.WriteLine("Save successful. Look in the user data directory.");
         }
 
@@ -107,8 +109,7 @@ namespace Robust.Server.Console.Commands
                 case 1:
                     return CompletionResult.FromHint(Loc.GetString("cmd-hint-savebp-id"));
                 case 2:
-                    var res = IoCManager.Resolve<IResourceManager>();
-                    var opts = CompletionHelper.UserFilePath(args[1], res.UserData);
+                    var opts = CompletionHelper.UserFilePath(args[1], _resource.UserData);
                     return CompletionResult.FromHintOptions(opts, Loc.GetString("cmd-hint-savemap-path"));
             }
             return CompletionResult.Empty;
@@ -117,6 +118,10 @@ namespace Robust.Server.Console.Commands
 
     public sealed class LoadGridCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _system = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+        [Dependency] private readonly IResourceManager _resource = default!;
+
         public override string Command => "loadgrid";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -142,8 +147,7 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var mapManager = IoCManager.Resolve<IMapManager>();
-            if (!mapManager.MapExists(mapId))
+            if (!_map.MapExists(mapId))
             {
                 shell.WriteError("Target map does not exist.");
                 return;
@@ -189,18 +193,21 @@ namespace Robust.Server.Console.Commands
                 loadOptions.StoreMapUids = storeUids;
             }
 
-            var mapLoader = IoCManager.Resolve<MapLoaderSystem>();
-            mapLoader.Load(mapId, args[1], loadOptions);
+            _system.GetEntitySystem<MapLoaderSystem>().Load(mapId, args[1], loadOptions);
         }
 
         public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
         {
-            return LoadMap.GetCompletionResult(shell, args);
+            return LoadMap.GetCompletionResult(shell, args, _resource);
         }
     }
 
     public sealed class SaveMap : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _system = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+        [Dependency] private readonly IResourceManager _resource = default!;
+
         public override string Command => "savemap";
 
         public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
@@ -210,8 +217,7 @@ namespace Robust.Server.Console.Commands
                 case 1:
                     return CompletionResult.FromHint(Loc.GetString("cmd-hint-savemap-id"));
                 case 2:
-                    var res = IoCManager.Resolve<IResourceManager>();
-                    var opts = CompletionHelper.UserFilePath(args[1], res.UserData);
+                    var opts = CompletionHelper.UserFilePath(args[1], _resource.UserData);
                     return CompletionResult.FromHintOptions(opts, Loc.GetString("cmd-hint-savemap-path"));
                 case 3:
                     return CompletionResult.FromHint(Loc.GetString("cmd-hint-savemap-force"));
@@ -239,14 +245,13 @@ namespace Robust.Server.Console.Commands
             if (mapId == MapId.Nullspace)
                 return;
 
-            var mapManager = IoCManager.Resolve<IMapManager>();
-            if (!mapManager.MapExists(mapId))
+            if (!_map.MapExists(mapId))
             {
                 shell.WriteError(Loc.GetString("cmd-savemap-not-exist"));
                 return;
             }
 
-            if (mapManager.IsMapInitialized(mapId) &&
+            if (_map.IsMapInitialized(mapId) &&
                 ( args.Length < 3  || !bool.TryParse(args[2], out var force) || !force))
             {
                 shell.WriteError(Loc.GetString("cmd-savemap-init-warning"));
@@ -254,25 +259,28 @@ namespace Robust.Server.Console.Commands
             }
 
             shell.WriteLine(Loc.GetString("cmd-savemap-attempt", ("mapId", mapId), ("path", args[1])));
-            IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>().SaveMap(mapId, args[1]);
+            _system.GetEntitySystem<MapLoaderSystem>().SaveMap(mapId, args[1]);
             shell.WriteLine(Loc.GetString("cmd-savemap-success"));
         }
     }
 
     public sealed class LoadMap : LocalizedCommands
     {
+        [Dependency] private readonly IEntitySystemManager _system = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+        [Dependency] private readonly IResourceManager _resource = default!;
+
         public override string Command => "loadmap";
 
-        public static CompletionResult GetCompletionResult(IConsoleShell shell, string[] args)
+        public static CompletionResult GetCompletionResult(IConsoleShell shell, string[] args, IResourceManager resource)
         {
             switch (args.Length)
             {
                 case 1:
                     return CompletionResult.FromHint(Loc.GetString("cmd-hint-savemap-id"));
                 case 2:
-                    var res = IoCManager.Resolve<IResourceManager>();
-                    var opts = CompletionHelper.UserFilePath(args[1], res.UserData)
-                        .Concat(CompletionHelper.ContentFilePath(args[1], res));
+                    var opts = CompletionHelper.UserFilePath(args[1], resource.UserData)
+                        .Concat(CompletionHelper.ContentFilePath(args[1], resource));
                     return CompletionResult.FromHintOptions(opts, Loc.GetString("cmd-hint-savemap-path"));
                 case 3:
                     return CompletionResult.FromHint(Loc.GetString("cmd-hint-loadmap-x-position"));
@@ -289,7 +297,7 @@ namespace Robust.Server.Console.Commands
 
         public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
         {
-            return GetCompletionResult(shell, args);
+            return GetCompletionResult(shell, args, _resource);
         }
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -315,8 +323,7 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var mapManager = IoCManager.Resolve<IMapManager>();
-            if (mapManager.MapExists(mapId))
+            if (_map.MapExists(mapId))
             {
                 shell.WriteError(Loc.GetString("cmd-loadmap-exists", ("mapId", mapId)));
                 return;
@@ -368,9 +375,9 @@ namespace Robust.Server.Console.Commands
                 loadOptions.StoreMapUids = storeUids;
             }
 
-            IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>().TryLoad(mapId, args[1], out _, loadOptions);
+            _system.GetEntitySystem<MapLoaderSystem>().TryLoad(mapId, args[1], out _, loadOptions);
 
-            if (mapManager.MapExists(mapId))
+            if (_map.MapExists(mapId))
                 shell.WriteLine(Loc.GetString("cmd-loadmap-success", ("mapId", mapId), ("path", args[1])));
             else
                 shell.WriteLine(Loc.GetString("cmd-loadmap-error", ("path", args[1])));
@@ -379,6 +386,8 @@ namespace Robust.Server.Console.Commands
 
     sealed class LocationCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _ent = default!;
+
         public override string Command => "loc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -388,16 +397,18 @@ namespace Robust.Server.Console.Commands
             if (pt == null)
                 return;
 
-            var entityManager = IoCManager.Resolve<IEntityManager>();
             var pos = pt.Coordinates;
 
             shell.WriteLine(
-                $"MapID:{pos.GetMapId(entityManager)} GridUid:{pos.GetGridUid(entityManager)} X:{pos.X:N2} Y:{pos.Y:N2}");
+                $"MapID:{pos.GetMapId(_ent)} GridUid:{pos.GetGridUid(_ent)} X:{pos.X:N2} Y:{pos.Y:N2}");
         }
     }
 
     sealed class TpGridCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _ent = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "tpgrid";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -412,19 +423,16 @@ namespace Robust.Server.Console.Commands
             var xPos = float.Parse(args[1], CultureInfo.InvariantCulture);
             var yPos = float.Parse(args[2], CultureInfo.InvariantCulture);
 
-            var mapManager = IoCManager.Resolve<IMapManager>();
-            var entManager = IoCManager.Resolve<IEntityManager>();
-
-            if (!mapManager.TryGetGrid(gridId, out var grid))
+            if (!_map.TryGetGrid(gridId, out var grid))
             {
                 shell.WriteError($"No grid found with id {args[0]}");
                 return;
             }
 
-            var gridXform = entManager.GetComponent<TransformComponent>(grid.GridEntityId);
+            var gridXform = _ent.GetComponent<TransformComponent>(grid.GridEntityId);
             var mapId = args.Length == 4 ? new MapId(int.Parse(args[3])) : gridXform.MapID;
 
-            gridXform.Coordinates = new EntityCoordinates(mapManager.GetMapEntityId(mapId), new Vector2(xPos, yPos));
+            gridXform.Coordinates = new EntityCoordinates(_map.GetMapEntityId(mapId), new Vector2(xPos, yPos));
 
             shell.WriteLine("Grid was teleported.");
         }
@@ -432,6 +440,8 @@ namespace Robust.Server.Console.Commands
 
     sealed class RemoveGridCommand : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "rmgrid";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -443,21 +453,22 @@ namespace Robust.Server.Console.Commands
             }
 
             var gridId = EntityUid.Parse(args[0]);
-            var mapManager = IoCManager.Resolve<IMapManager>();
 
-            if (!mapManager.GridExists(gridId))
+            if (!_map.GridExists(gridId))
             {
                 shell.WriteError($"Grid {gridId} does not exist.");
                 return;
             }
 
-            mapManager.DeleteGrid(gridId);
+            _map.DeleteGrid(gridId);
             shell.WriteLine($"Grid {gridId} was removed.");
         }
     }
 
     internal sealed class RunMapInitCommand : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "mapinit";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -468,44 +479,42 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var mapManager = IoCManager.Resolve<IMapManager>();
-
             var arg = args[0];
             var mapId = new MapId(int.Parse(arg, CultureInfo.InvariantCulture));
 
-            if (!mapManager.MapExists(mapId))
+            if (!_map.MapExists(mapId))
             {
                 shell.WriteError("Map does not exist!");
                 return;
             }
 
-            if (mapManager.IsMapInitialized(mapId))
+            if (_map.IsMapInitialized(mapId))
             {
                 shell.WriteError("Map is already initialized!");
                 return;
             }
 
-            mapManager.DoMapInitialize(mapId);
+            _map.DoMapInitialize(mapId);
         }
     }
 
     internal sealed class ListMapsCommand : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "lsmap";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mapManager = IoCManager.Resolve<IMapManager>();
-
             var msg = new StringBuilder();
 
-            foreach (var mapId in mapManager.GetAllMapIds().OrderBy(id => id.Value))
+            foreach (var mapId in _map.GetAllMapIds().OrderBy(id => id.Value))
             {
                 msg.AppendFormat("{0}: init: {1}, paused: {2}, ent: {3}, grids: {4}\n",
-                    mapId, mapManager.IsMapInitialized(mapId),
-                    mapManager.IsMapPaused(mapId),
-                    mapManager.GetMapEntityId(mapId),
-                    string.Join(",", mapManager.GetAllMapGrids(mapId).Select(grid => grid.GridEntityId)));
+                    mapId, _map.IsMapInitialized(mapId),
+                    _map.IsMapPaused(mapId),
+                    _map.GetMapEntityId(mapId),
+                    string.Join(",", _map.GetAllMapGrids(mapId).Select(grid => grid.GridEntityId)));
             }
 
             shell.WriteLine(msg.ToString());
@@ -514,16 +523,16 @@ namespace Robust.Server.Console.Commands
 
     internal sealed class ListGridsCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _ent = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "lsgrid";
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var entManager = IoCManager.Resolve<IEntityManager>();
-            var mapManager = IoCManager.Resolve<IMapManager>();
-
             var msg = new StringBuilder();
-            var xformQuery = entManager.GetEntityQuery<TransformComponent>();
+            var xformQuery = _ent.GetEntityQuery<TransformComponent>();
 
-            foreach (var grid in mapManager.GetAllGrids().OrderBy(grid => grid.GridEntityId))
+            foreach (var grid in _map.GetAllGrids().OrderBy(grid => grid.GridEntityId))
             {
                 var xform = xformQuery.GetComponent(grid.GridEntityId);
                 var worldPos = xform.WorldPosition;

Robust.Server/Console/Commands/PlayerCommands.cs

@@ -15,6 +15,8 @@ namespace Robust.Server.Console.Commands
 {
     internal sealed class TeleportCommand : LocalizedCommands
     {
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "tp";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -33,8 +35,6 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var mapMgr = IoCManager.Resolve<IMapManager>();
-
             var position = new Vector2(posX, posY);
 
             transform.AttachToGridOrMap();
@@ -45,13 +45,13 @@ namespace Robust.Server.Console.Commands
             else
                 mapId = transform.MapID;
 
-            if (!mapMgr.MapExists(mapId))
+            if (!_map.MapExists(mapId))
             {
                 shell.WriteError($"Map {mapId} doesn't exist!");
                 return;
             }
 
-            if (mapMgr.TryFindGridAt(mapId, position, out var grid))
+            if (_map.TryFindGridAt(mapId, position, out var grid))
             {
                 var gridPos = grid.WorldToLocal(position);
 
@@ -59,7 +59,7 @@ namespace Robust.Server.Console.Commands
             }
             else
             {
-                var mapEnt = mapMgr.GetMapEntityIdOrThrow(mapId);
+                var mapEnt = _map.GetMapEntityIdOrThrow(mapId);
                 transform.WorldPosition = position;
                 transform.AttachParent(mapEnt);
             }
@@ -70,6 +70,9 @@ namespace Robust.Server.Console.Commands
 
     public sealed class TeleportToCommand : LocalizedCommands
     {
+        [Dependency] private readonly IPlayerManager _players = default!;
+        [Dependency] private readonly IEntityManager _entities = default!;
+
         public override string Command => "tpto";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -77,12 +80,9 @@ namespace Robust.Server.Console.Commands
             if (args.Length == 0)
                 return;
 
-            var entMan = IoCManager.Resolve<IEntityManager>();
-            var playerMan = IoCManager.Resolve<IPlayerManager>();
-
             var target = args[^1];
 
-            if (!TryGetTransformFromUidOrUsername(target, shell, entMan, playerMan, out var targetTransform))
+            if (!TryGetTransformFromUidOrUsername(target, shell, _entities, _players, out var targetTransform))
                 return;
 
             var targetCoords = targetTransform.Coordinates;
@@ -96,7 +96,7 @@ namespace Robust.Server.Console.Commands
                     return;
                 }
 
-                if (!entMan.TryGetComponent(player.AttachedEntity, out TransformComponent? playerTransform))
+                if (!_entities.TryGetComponent(player.AttachedEntity, out TransformComponent? playerTransform))
                 {
                     shell.WriteError("You don't have an entity.");
                     return;
@@ -112,7 +112,7 @@ namespace Robust.Server.Console.Commands
                     if (victim == target)
                         continue;
 
-                    if (!TryGetTransformFromUidOrUsername(victim, shell, entMan, playerMan, out var victimTransform))
+                    if (!TryGetTransformFromUidOrUsername(victim, shell, _entities, _players, out var victimTransform))
                         return;
 
                     victimTransform.Coordinates = targetCoords;
@@ -143,6 +143,8 @@ namespace Robust.Server.Console.Commands
 
     public sealed class ListPlayers : LocalizedCommands
     {
+        [Dependency] private readonly IPlayerManager _players = default!;
+
         public override string Command => "listplayers";
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
@@ -152,7 +154,7 @@ namespace Robust.Server.Console.Commands
 
             var sb = new StringBuilder();
 
-            var players = IoCManager.Resolve<IPlayerManager>().ServerSessions;
+            var players = _players.ServerSessions;
             sb.AppendLine($"{"Player Name",20} {"Status",12} {"Playing Time",14} {"Ping",9} {"IP EndPoint",20}");
             sb.AppendLine("-------------------------------------------------------------------------------");
 
@@ -172,15 +174,17 @@ namespace Robust.Server.Console.Commands
 
     internal sealed class KickCommand : LocalizedCommands
     {
+        [Dependency] private readonly IPlayerManager _players = default!;
+        [Dependency] private readonly IServerNetManager _netManager = default!;
+
         public override string Command => "kick";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var players = IoCManager.Resolve<IPlayerManager>();
             if (args.Length < 1)
             {
                 var player = shell.Player as IPlayerSession;
-                var toKickPlayer = player ?? players.ServerSessions.FirstOrDefault();
+                var toKickPlayer = player ?? _players.ServerSessions.FirstOrDefault();
                 if (toKickPlayer == null)
                 {
                     shell.WriteLine("You need to provide a player to kick.");
@@ -192,17 +196,15 @@ namespace Robust.Server.Console.Commands
 
             var name = args[0];
 
-            if (players.TryGetSessionByUsername(name, out var target))
+            if (_players.TryGetSessionByUsername(name, out var target))
             {
-                var network = IoCManager.Resolve<IServerNetManager>();
-
                 string reason;
                 if (args.Length >= 2)
                     reason = $"Kicked by console: {string.Join(' ', args[1..])}";
                 else
                     reason = "Kicked by console";
 
-                network.DisconnectChannel(target.ConnectedClient, reason);
+                _netManager.DisconnectChannel(target.ConnectedClient, reason);
             }
         }
 
@@ -210,8 +212,7 @@ namespace Robust.Server.Console.Commands
         {
             if (args.Length == 1)
             {
-                var playerManager = IoCManager.Resolve<IPlayerManager>();
-                var options = playerManager.ServerSessions.OrderBy(c => c.Name).Select(c => c.Name).ToArray();
+                var options = _players.ServerSessions.OrderBy(c => c.Name).Select(c => c.Name).ToArray();
 
                 return CompletionResult.FromHintOptions(options, "<PlayerIndex>");
             }

Robust.Server/Console/Commands/ReloadLocalizationsCommand.cs

@@ -6,11 +6,13 @@ namespace Robust.Server.Console.Commands
 {
     internal sealed class ReloadLocalizationsCommand : LocalizedCommands
     {
+        [Dependency] private readonly ILocalizationManager _loc = default!;
+
         public override string Command => "rldloc";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<ILocalizationManager>().ReloadLocalizations();
+            _loc.ReloadLocalizations();
         }
     }
 }

Robust.Server/Console/Commands/RemoveComponentCommand.cs

@@ -9,6 +9,9 @@ namespace Robust.Server.Console.Commands
     [UsedImplicitly]
     internal sealed class RemoveComponentCommand : LocalizedCommands
     {
+        [Dependency] private readonly IComponentFactory _compFactory = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "rmcomp";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -25,9 +28,7 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-
-            if (!entityManager.EntityExists(uid))
+            if (!_entityManager.EntityExists(uid))
             {
                 shell.WriteLine($"No entity found with id {uid}.");
                 return;
@@ -35,23 +36,21 @@ namespace Robust.Server.Console.Commands
 
             var componentName = args[1];
 
-            var compFactory = IoCManager.Resolve<IComponentFactory>();
-
-            if (!compFactory.TryGetRegistration(componentName, out var registration, true))
+            if (!_compFactory.TryGetRegistration(componentName, out var registration, true))
             {
                 shell.WriteLine($"No component found with name {componentName}.");
                 return;
             }
 
-            if (!entityManager.HasComponent(uid, registration.Type))
+            if (!_entityManager.HasComponent(uid, registration.Type))
             {
-                shell.WriteLine($"No {componentName} component found on entity {entityManager.GetComponent<MetaDataComponent>(uid).EntityName}.");
+                shell.WriteLine($"No {componentName} component found on entity {_entityManager.GetComponent<MetaDataComponent>(uid).EntityName}.");
                 return;
             }
 
-            entityManager.RemoveComponent(uid, registration.Type);
+            _entityManager.RemoveComponent(uid, registration.Type);
 
-            shell.WriteLine($"Removed {componentName} component from entity {entityManager.GetComponent<MetaDataComponent>(uid).EntityName}.");
+            shell.WriteLine($"Removed {componentName} component from entity {_entityManager.GetComponent<MetaDataComponent>(uid).EntityName}.");
         }
     }
 }

Robust.Server/Console/Commands/ScaleCommand.cs

@@ -12,6 +12,8 @@ namespace Robust.Server.Console.Commands;
 
 public sealed class ScaleCommand : LocalizedCommands
 {
+    [Dependency] private readonly IEntityManager _entityManager = default!;
+
     public override string Command => "scale";
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
@@ -41,19 +43,17 @@ public sealed class ScaleCommand : LocalizedCommands
 
         // Event for content to use
         // We'll just set engine stuff here
-        var entManager = IoCManager.Resolve<IEntityManager>();
-
-        entManager.EnsureComponent<ScaleVisualsComponent>(uid);
+        _entityManager.EnsureComponent<ScaleVisualsComponent>(uid);
         var @event = new ScaleEntityEvent();
-        entManager.EventBus.RaiseLocalEvent(uid, ref @event);
+        _entityManager.EventBus.RaiseLocalEvent(uid, ref @event);
 
-        var appearanceComponent = entManager.EnsureComponent<ServerAppearanceComponent>(uid);
+        var appearanceComponent = _entityManager.EnsureComponent<ServerAppearanceComponent>(uid);
         if (!appearanceComponent.TryGetData<Vector2>(ScaleVisuals.Scale, out var oldScale))
             oldScale = Vector2.One;
 
         appearanceComponent.SetData(ScaleVisuals.Scale, oldScale * scale);
 
-        if (entManager.TryGetComponent(uid, out FixturesComponent? manager))
+        if (_entityManager.TryGetComponent(uid, out FixturesComponent? manager))
         {
             foreach (var (_, fixture) in manager.Fixtures)
             {
@@ -84,7 +84,7 @@ public sealed class ScaleCommand : LocalizedCommands
                 }
             }
 
-            entManager.EntitySysManager.GetEntitySystem<FixtureSystem>().FixtureUpdate(manager);
+            _entityManager.EntitySysManager.GetEntitySystem<FixtureSystem>().FixtureUpdate(manager);
         }
     }
 

Robust.Server/Console/Commands/SpawnCommand.cs

@@ -10,12 +10,14 @@ namespace Robust.Server.Console.Commands
 {
     public sealed class SpawnCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+
         public override string Command => "spawn";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
             var player = shell.Player as IPlayerSession;
-            var ent = IoCManager.Resolve<IServerEntityManager>();
+
             if (args.Length is < 1 or > 3)
             {
                 shell.WriteError("Incorrect number of arguments. " + Help);
@@ -25,21 +27,21 @@ namespace Robust.Server.Console.Commands
 
             if (args.Length == 1 && player != null && pAE != EntityUid.Invalid)
             {
-                ent.SpawnEntity(args[0], ent.GetComponent<TransformComponent>(pAE).Coordinates);
+                _entityManager.SpawnEntity(args[0], _entityManager.GetComponent<TransformComponent>(pAE).Coordinates);
             }
             else if (args.Length == 2)
             {
                 var uid = EntityUid.Parse(args[1]);
-                ent.SpawnEntity(args[0], ent.GetComponent<TransformComponent>(uid).Coordinates);
+                _entityManager.SpawnEntity(args[0], _entityManager.GetComponent<TransformComponent>(uid).Coordinates);
             }
             else if (player != null && pAE != EntityUid.Invalid)
             {
                 var coords = new MapCoordinates(
                     float.Parse(args[1], CultureInfo.InvariantCulture),
                     float.Parse(args[2], CultureInfo.InvariantCulture),
-                    ent.GetComponent<TransformComponent>(pAE).MapID);
+                    _entityManager.GetComponent<TransformComponent>(pAE).MapID);
 
-                ent.SpawnEntity(args[0], coords);
+                _entityManager.SpawnEntity(args[0], coords);
             }
         }
     }

Robust.Server/Console/Commands/SpinCommand.cs

@@ -8,6 +8,8 @@ namespace Robust.Server.Console.Commands;
 
 public sealed class SpinCommand : LocalizedCommands
 {
+    [Dependency] private readonly IEntityManager _entities = default!;
+
     public override string Command => "spin";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -25,8 +27,6 @@ public sealed class SpinCommand : LocalizedCommands
             return;
         }
 
-        var entMan = IoCManager.Resolve<IEntityManager>();
-
         // get the target
         EntityUid target;
         if (args.Length == 3)
@@ -39,7 +39,7 @@ public sealed class SpinCommand : LocalizedCommands
         }
         else
         {
-            if (!entMan.TryGetComponent(shell.Player?.AttachedEntity, out TransformComponent? xform)
+            if (!_entities.TryGetComponent(shell.Player?.AttachedEntity, out TransformComponent? xform)
                 || xform.ParentUid is not EntityUid { Valid: true } parent)
             {
                 shell.WriteError($"Cannot find default entity (attached player's parent).");
@@ -49,7 +49,7 @@ public sealed class SpinCommand : LocalizedCommands
         }
 
         // Try get physics
-        if (!entMan.TryGetComponent(target, out PhysicsComponent? physics))
+        if (!_entities.TryGetComponent(target, out PhysicsComponent? physics))
         {
             shell.WriteError($"Target entity is incorporeal");
             return;

Robust.Server/Console/Commands/SysCommands.cs

@@ -9,42 +9,48 @@ namespace Robust.Server.Console.Commands
 {
     sealed class RestartCommand : LocalizedCommands
     {
+        [Dependency] private readonly IBaseServer _server = default!;
+
         public override string Command => "restart";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<IBaseServer>().Restart();
+            _server.Restart();
         }
     }
 
     sealed class ShutdownCommand : LocalizedCommands
     {
+        [Dependency] private readonly IBaseServer _server = default!;
+
         public override string Command => "shutdown";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<IBaseServer>().Shutdown(null);
+            _server.Shutdown(null);
         }
     }
 
     public sealed class SaveConfig : LocalizedCommands
     {
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
+
         public override string Command => "saveconfig";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            IoCManager.Resolve<IConfigurationManager>().SaveToFile();
+            _cfg.SaveToFile();
         }
     }
 
     sealed class NetworkAuditCommand : LocalizedCommands
     {
+        [Dependency] private readonly INetManager _netManager = default!;
+
         public override string Command => "netaudit";
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var network = (NetManager) IoCManager.Resolve<INetManager>();
-
-            var callbacks = network.CallbackAudit;
+            var callbacks = ((NetManager)_netManager).CallbackAudit;
 
             var sb = new StringBuilder();
 
@@ -62,12 +68,13 @@ namespace Robust.Server.Console.Commands
 
     sealed class ShowTimeCommand : LocalizedCommands
     {
+        [Dependency] private readonly IGameTiming _timing = default!;
+
         public override string Command => "showtime";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var timing = IoCManager.Resolve<IGameTiming>();
-            shell.WriteLine($"Paused: {timing.Paused}, CurTick: {timing.CurTick}, CurTime: {timing.CurTime}, RealTime: {timing.RealTime}");
+            shell.WriteLine($"Paused: {_timing.Paused}, CurTick: {_timing.CurTick}, CurTime: {_timing.CurTime}, RealTime: {_timing.RealTime}");
         }
     }
 }

Robust.Server/Console/Commands/TestbedCommand.cs

@@ -48,6 +48,9 @@ namespace Robust.Server.Console.Commands
     /// </summary>
     public sealed class TestbedCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _ent = default!;
+        [Dependency] private readonly IMapManager _map = default!;
+
         public override string Command => "testbed";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -58,8 +61,6 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var mapManager = IoCManager.Resolve<IMapManager>();
-
             if (!int.TryParse(args[0], out var mapInt))
             {
                 shell.WriteError($"Unable to parse map {args[0]}");
@@ -74,9 +75,8 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var player = (IPlayerSession) shell.Player;
             Action testbed;
-            SetupPlayer(mapId, shell, player, mapManager);
+            SetupPlayer(mapId, shell);
 
             switch (args[1])
             {
@@ -99,25 +99,25 @@ namespace Robust.Server.Console.Commands
 
             Timer.Spawn(1000, () =>
             {
-                if (!mapManager.MapExists(mapId)) return;
+                if (!_map.MapExists(mapId)) return;
                 testbed();
             });
 
             shell.WriteLine($"Testbed on map {mapId}");
         }
 
-        private void SetupPlayer(MapId mapId, IConsoleShell shell, IPlayerSession? player, IMapManager mapManager)
+        private void SetupPlayer(MapId mapId, IConsoleShell shell)
         {
             if (mapId == MapId.Nullspace) return;
 
-            if (!mapManager.MapExists(mapId))
+            if (!_map.MapExists(mapId))
             {
-                mapManager.CreateMap(mapId);
+                _map.CreateMap(mapId);
             }
 
-            mapManager.SetMapPaused(mapId, false);
-            var mapUid = mapManager.GetMapEntityIdOrThrow(mapId);
-            IoCManager.Resolve<IEntityManager>().GetComponent<SharedPhysicsMapComponent>(mapUid).Gravity = new Vector2(0, -9.8f);
+            _map.SetMapPaused(mapId, false);
+            var mapUid = _map.GetMapEntityIdOrThrow(mapId);
+            _ent.GetComponent<SharedPhysicsMapComponent>(mapUid).Gravity = new Vector2(0, -9.8f);
 
             shell.ExecuteCommand("aghost");
             shell.ExecuteCommand($"tp 0 0 {mapId}");
@@ -128,11 +128,10 @@ namespace Robust.Server.Console.Commands
 
         private void CreateBoxStack(MapId mapId)
         {
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-            var physics = entityManager.System<SharedPhysicsSystem>();
+            var physics = _ent.System<SharedPhysicsSystem>();
 
-            var groundUid = entityManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
-            var ground = entityManager.AddComponent<PhysicsComponent>(groundUid);
+            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
+            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
 
             var horizontal = new EdgeShape(new Vector2(-40, 0), new Vector2(40, 0));
             var horizontalFixture = new Fixture(ground, horizontal)
@@ -171,9 +170,9 @@ namespace Robust.Server.Console.Commands
                 {
                     var x = 0.0f;
 
-                    var boxUid = entityManager.SpawnEntity(null,
+                    var boxUid = _ent.SpawnEntity(null,
                         new MapCoordinates(new Vector2(xs[j] + x, 0.55f + 1.1f * i), mapId));
-                    var box = entityManager.AddComponent<PhysicsComponent>(boxUid);
+                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
 
                     box.BodyType = BodyType.Dynamic;
                     shape = new PolygonShape();
@@ -200,11 +199,10 @@ namespace Robust.Server.Console.Commands
 
         private void CreateCircleStack(MapId mapId)
         {
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-            var physics = entityManager.System<SharedPhysicsSystem>();
+            var physics = _ent.System<SharedPhysicsSystem>();
 
-            var groundUid = entityManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
-            var ground = entityManager.AddComponent<PhysicsComponent>(groundUid);
+            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
+            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
 
             var horizontal = new EdgeShape(new Vector2(-40, 0), new Vector2(40, 0));
             var horizontalFixture = new Fixture(ground, horizontal)
@@ -242,9 +240,9 @@ namespace Robust.Server.Console.Commands
                 {
                     var x = 0.0f;
 
-                    var boxUid = entityManager.SpawnEntity(null,
+                    var boxUid = _ent.SpawnEntity(null,
                         new MapCoordinates(new Vector2(xs[j] + x, 0.55f + 2.1f * i), mapId));
-                    var box = entityManager.AddComponent<PhysicsComponent>(boxUid);
+                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
 
                     box.BodyType = BodyType.Dynamic;
                     shape = new PhysShapeCircle {Radius = 0.5f};
@@ -272,10 +270,9 @@ namespace Robust.Server.Console.Commands
             const byte count = 20;
 
             // Setup ground
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-            var physics = entityManager.System<SharedPhysicsSystem>();
-            var groundUid = entityManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
-            var ground = entityManager.AddComponent<PhysicsComponent>(groundUid);
+            var physics = _ent.System<SharedPhysicsSystem>();
+            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
+            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
 
             var horizontal = new EdgeShape(new Vector2(40, 0), new Vector2(-40, 0));
             var horizontalFixture = new Fixture(ground, horizontal)
@@ -305,10 +302,10 @@ namespace Robust.Server.Console.Commands
 
                 for (var j = i; j < count; ++j)
                 {
-                    var boxUid = entityManager.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
-                    var box = entityManager.AddComponent<PhysicsComponent>(boxUid);
+                    var boxUid = _ent.SpawnEntity(null, new MapCoordinates(0, 0, mapId));
+                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
                     box.BodyType = BodyType.Dynamic;
-                    entityManager.GetComponent<TransformComponent>(box.Owner).WorldPosition = y;
+                    _ent.GetComponent<TransformComponent>(box.Owner).WorldPosition = y;
                     broadphase.CreateFixture(box,
                         new Fixture(box, shape) {
                         CollisionLayer = 2,
@@ -327,18 +324,17 @@ namespace Robust.Server.Console.Commands
 
         private void CreateTumbler(MapId mapId)
         {
+            var physics = _ent.System<SharedPhysicsSystem>();
             var broadphaseSystem = EntitySystem.Get<FixtureSystem>();
-            var entityManager = IoCManager.Resolve<IEntityManager>();
-            var physics = entityManager.System<SharedPhysicsSystem>();
 
-            var groundUid = entityManager.SpawnEntity(null, new MapCoordinates(0f, 0f, mapId));
-            var ground = entityManager.AddComponent<PhysicsComponent>(groundUid);
+            var groundUid = _ent.SpawnEntity(null, new MapCoordinates(0f, 0f, mapId));
+            var ground = _ent.AddComponent<PhysicsComponent>(groundUid);
             // Due to lookup changes fixtureless bodies are invalid, so
             var cShape = new PhysShapeCircle();
             broadphaseSystem.CreateFixture(ground, cShape);
 
-            var bodyUid = entityManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
-            var body = entityManager.AddComponent<PhysicsComponent>(bodyUid);
+            var bodyUid = _ent.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
+            var body = _ent.AddComponent<PhysicsComponent>(bodyUid);
 
             body.BodyType = BodyType.Dynamic;
             body.SleepingAllowed = false;
@@ -375,15 +371,14 @@ namespace Robust.Server.Console.Commands
             // Wouldn't recommend higher than 100 in debug and higher than 300 on release unless
             // you really want a profile.
             var count = 300;
-            var mapManager = IoCManager.Resolve<IMapManager>();
 
             for (var i = 0; i < count; i++)
             {
                 Timer.Spawn(i * 20, () =>
                 {
-                    if (!mapManager.MapExists(mapId)) return;
-                    var boxUid = entityManager.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
-                    var box = entityManager.AddComponent<PhysicsComponent>(boxUid);
+                    if (!_map.MapExists(mapId)) return;
+                    var boxUid = _ent.SpawnEntity(null, new MapCoordinates(0f, 10f, mapId));
+                    var box = _ent.AddComponent<PhysicsComponent>(boxUid);
                     box.BodyType = BodyType.Dynamic;
                     box.FixedRotation = false;
                     var shape = new PolygonShape();

Robust.Server/Console/Commands/ViewSubscriberCommand.cs

@@ -9,6 +9,8 @@ namespace Robust.Server.Console.Commands
 {
     public sealed class AddViewSubscriberCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _entities = default!;
+
         public override string Command => "addview";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -33,19 +35,19 @@ namespace Robust.Server.Console.Commands
                 return;
             }
 
-            var entManager = IoCManager.Resolve<IEntityManager>();
-
-            if (!entManager.EntityExists(uid))
+            if (!_entities.EntityExists(uid))
             {
                 shell.WriteError($"Unable to find entity {uid}");
                 return;
             }
 
-            EntitySystem.Get<ViewSubscriberSystem>().AddViewSubscriber(uid, playerSession);
+            _entities.EntitySysManager.GetEntitySystem<ViewSubscriberSystem>().AddViewSubscriber(uid, playerSession);
         }
 
         public sealed class RemoveViewSubscriberCommand : LocalizedCommands
         {
+            [Dependency] private readonly IEntityManager _entities = default!;
+
             public override string Command => "removeview";
 
             public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -70,15 +72,13 @@ namespace Robust.Server.Console.Commands
                     return;
                 }
 
-                var entManager = IoCManager.Resolve<IEntityManager>();
-
-                if (!entManager.EntityExists(uid))
+                if (!_entities.EntityExists(uid))
                 {
                     shell.WriteError($"Unable to find entity {uid}");
                     return;
                 }
 
-                EntitySystem.Get<ViewSubscriberSystem>().RemoveViewSubscriber(uid, playerSession);
+                _entities.EntitySysManager.GetEntitySystem<ViewSubscriberSystem>().RemoveViewSubscriber(uid, playerSession);
             }
         }
     }

Robust.Server/Console/ServerConsoleHost.cs

@@ -133,7 +133,6 @@ namespace Robust.Server.Console
 
         private void HandleRegistrationRequest(INetChannel senderConnection)
         {
-            var netMgr = IoCManager.Resolve<IServerNetManager>();
             var message = new MsgConCmdReg();
 
             var counter = 0;
@@ -149,7 +148,7 @@ namespace Robust.Server.Console
                 };
             }
 
-            netMgr.ServerSendMessage(message, senderConnection);
+            NetManager.ServerSendMessage(message, senderConnection);
         }
 
         private void ProcessCommand(MsgConCmd message)

Robust.Server/GameObjects/EntitySystems/MapSystem.cs

@@ -14,6 +14,8 @@ namespace Robust.Server.GameObjects
 {
     public sealed class MapSystem : SharedMapSystem
     {
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
+
         private bool _deleteEmptyGrids;
 
         public override void Initialize()
@@ -21,8 +23,7 @@ namespace Robust.Server.GameObjects
             base.Initialize();
             SubscribeLocalEvent<MapGridComponent, EmptyGridEvent>(HandleGridEmpty);
 
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.OnValueChanged(CVars.GameDeleteEmptyGrids, SetGridDeletion, true);
+            _cfg.OnValueChanged(CVars.GameDeleteEmptyGrids, SetGridDeletion, true);
         }
 
         protected override void OnMapAdd(EntityUid uid, MapComponent component, ComponentAdd args)
@@ -60,8 +61,8 @@ namespace Robust.Server.GameObjects
         public override void Shutdown()
         {
             base.Shutdown();
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.UnsubValueChanged(CVars.GameDeleteEmptyGrids, SetGridDeletion);
+
+            _cfg.UnsubValueChanged(CVars.GameDeleteEmptyGrids, SetGridDeletion);
         }
 
         private void HandleGridEmpty(EntityUid uid, MapGridComponent component, EmptyGridEvent args)

Robust.Server/GameStates/PVSCollection.cs

@@ -51,7 +51,7 @@ public interface IPVSCollection
 
 public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : IComparable<TIndex>, IEquatable<TIndex>
 {
-    [Shared.IoC.Dependency] private readonly IEntityManager _entityManager = default!;
+    private readonly IEntityManager _entityManager;
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static Vector2i GetChunkIndices(Vector2 coordinates)
@@ -118,9 +118,9 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
     /// </summary>
     private HashSet<IChunkIndexLocation> _dirtyChunks = new();
 
-    public PVSCollection()
+    public PVSCollection(IEntityManager entityManager)
     {
-        IoCManager.InjectDependencies(this);
+        _entityManager = entityManager;
     }
 
     public void Process()
@@ -138,7 +138,7 @@ public sealed class PVSCollection<TIndex> : IPVSCollection where TIndex : ICompa
             var location = RemoveIndexInternal(index);
             if (location == null)
                 continue;
-            
+
             if(location is GridChunkLocation or MapChunkLocation)
                 _dirtyChunks.Add((IChunkIndexLocation) location);
             _deletionHistory.Add((tick, index));

Robust.Server/GameStates/PVSSystem.cs

@@ -288,7 +288,7 @@ internal sealed partial class PVSSystem : EntitySystem
 
     private PVSCollection<TIndex> RegisterPVSCollection<TIndex>() where TIndex : IComparable<TIndex>, IEquatable<TIndex>
     {
-        var collection = new PVSCollection<TIndex>();
+        var collection = new PVSCollection<TIndex>(EntityManager);
         _pvsCollections.Add(collection);
         return collection;
     }

Robust.Server/Physics/GridFixtureSystem.cs

@@ -25,6 +25,8 @@ namespace Robust.Server.Physics
     internal sealed class GridFixtureSystem : SharedGridFixtureSystem
     {
         [Dependency] private readonly IMapManager _mapManager = default!;
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
+        [Dependency] private readonly IConGroupController _conGroup = default!;
         [Dependency] private readonly EntityLookupSystem _lookup = default!;
         [Dependency] private readonly SharedTransformSystem _xformSystem = default!;
 
@@ -50,12 +52,11 @@ namespace Robust.Server.Physics
             SubscribeLocalEvent<GridRemovalEvent>(OnGridRemoval);
             SubscribeNetworkEvent<RequestGridNodesMessage>(OnDebugRequest);
             SubscribeNetworkEvent<StopGridNodesMessage>(OnDebugStopRequest);
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
 #if !FULL_RELEASE
             // It makes mapping painful
-            configManager.OverrideDefault(CVars.GridSplitting, false);
+            _cfg.OverrideDefault(CVars.GridSplitting, false);
 #endif
-            configManager.OnValueChanged(CVars.GridSplitting, SetSplitAllowed, true);
+            _cfg.OnValueChanged(CVars.GridSplitting, SetSplitAllowed, true);
         }
 
         private void SetSplitAllowed(bool value) => SplitAllowed = value;
@@ -64,8 +65,7 @@ namespace Robust.Server.Physics
         {
             base.Shutdown();
             _subscribedSessions.Clear();
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.UnsubValueChanged(CVars.GridSplitting, SetSplitAllowed);
+            _cfg.UnsubValueChanged(CVars.GridSplitting, SetSplitAllowed);
         }
 
         /// <summary>
@@ -92,10 +92,9 @@ namespace Robust.Server.Physics
 
         private void OnDebugRequest(RequestGridNodesMessage msg, EntitySessionEventArgs args)
         {
-            var adminManager = IoCManager.Resolve<IConGroupController>();
             var pSession = (PlayerSession) args.SenderSession;
 
-            if (!adminManager.CanCommand(pSession, ShowGridNodesCommand)) return;
+            if (!_conGroup.CanCommand(pSession, ShowGridNodesCommand)) return;
 
             AddDebugSubscriber(args.SenderSession);
         }

Robust.Server/Player/PlayerManager.cs

@@ -36,6 +36,7 @@ namespace Robust.Server.Player
         [Dependency] private readonly IServerNetManager _network = default!;
         [Dependency] private readonly IReflectionManager _reflectionManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly INetConfigurationManager _cfg = default!;
 
         public BoundKeyMap KeyMap { get; private set; } = default!;
 
@@ -410,7 +411,7 @@ namespace Robust.Server.Player
             (msgTimeBase.Time, msgTimeBase.Tick) = _timing.TimeBase;
             _network.ServerSendMessage(msgTimeBase, args.Channel);
 
-            IoCManager.Resolve<INetConfigurationManager>().SyncConnectingClient(args.Channel);
+            _cfg.SyncConnectingClient(args.Channel);
         }
 
         private void OnPlayerStatusChanged(IPlayerSession session, SessionStatus oldStatus, SessionStatus newStatus)

Robust.Server/Program.cs

@@ -49,49 +49,50 @@ namespace Robust.Server
         private static void ParsedMain(CommandLineArgs args, bool contentStart, ServerOptions options)
         {
             Thread.CurrentThread.Name = "Main Thread";
-            IoCManager.InitThread();
-            ServerIoC.RegisterIoC();
-            IoCManager.BuildGraph();
-            SetupLogging();
-            InitReflectionManager();
+            var deps = IoCManager.InitThread();
+            ServerIoC.RegisterIoC(deps);
+            deps.BuildGraph();
+            SetupLogging(deps);
+            InitReflectionManager(deps);
 
-            var server = IoCManager.Resolve<IBaseServerInternal>();
+            var server = deps.Resolve<IBaseServerInternal>();
+            var logger = deps.Resolve<ILogManager>().RootSawmill;
 
             server.ContentStart = contentStart;
             server.SetCommandLineArgs(args);
 
-            Logger.Info("Server -> Starting");
+            logger.Info("Server -> Starting");
 
             if (server.Start(options))
             {
-                Logger.Fatal("Server -> Can not start server");
+                logger.Fatal("Server -> Can not start server");
                 //Not like you'd see this, haha. Perhaps later for logging.
                 return;
             }
 
             string strVersion = Assembly.GetExecutingAssembly().GetName().Version!.ToString();
-            Logger.Info("Server Version " + strVersion + " -> Ready");
+            logger.Info("Server Version " + strVersion + " -> Ready");
 
             server.MainLoop();
 
-            Logger.Info("Goodbye.");
+            logger.Info("Goodbye.");
 
             // Used to dispose of systems that want to be disposed.
             // Such as the log manager.
-            IoCManager.Clear();
+            deps.Clear();
         }
 
-        internal static void InitReflectionManager()
+        internal static void InitReflectionManager(IDependencyCollection deps)
         {
             // gets a handle to the shared and the current (server) dll.
-            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(new List<Assembly>(2)
+            deps.Resolve<IReflectionManager>().LoadAssemblies(new List<Assembly>(2)
             {
                 AppDomain.CurrentDomain.GetAssemblyByName("Robust.Shared"),
                 Assembly.GetExecutingAssembly()
             });
         }
 
-        internal static void SetupLogging()
+        internal static void SetupLogging(IDependencyCollection deps)
         {
             if (OperatingSystem.IsWindows())
             {
@@ -102,7 +103,7 @@ namespace Robust.Server
 #endif
             }
 
-            var mgr = IoCManager.Resolve<ILogManager>();
+            var mgr = deps.Resolve<ILogManager>();
             var handler = new ConsoleLogHandler();
             mgr.RootSawmill.AddHandler(handler);
             mgr.GetSawmill("res.typecheck").Level = LogLevel.Info;

Robust.Server/Scripting/ScriptHost.cs

@@ -102,7 +102,7 @@ namespace Robust.Server.Scripting
 
             ScriptInstanceShared.InitDummy();
 
-            var instance = new ScriptInstance();
+            var instance = new ScriptInstance(_reflectionManager);
             instances.Add(message.ScriptSession, instance);
 
             reply.WasAccepted = true;
@@ -340,22 +340,22 @@ namespace Robust.Server.Scripting
 
             public (string[] imports, string code)? AutoImportRepeatBuffer;
 
-            public ScriptInstance()
+            public ScriptInstance(IReflectionManager reflection)
             {
-                Globals = new ScriptGlobalsImpl(this);
+                Globals = new ScriptGlobalsImpl(this, reflection);
             }
         }
 
         private sealed class ScriptGlobalsImpl : ScriptGlobals
         {
-            [Dependency] private readonly IReflectionManager _reflectionManager = default!;
+            private readonly IReflectionManager _reflectionManager;
 
             private readonly ScriptInstance _scriptInstance;
 
-            public ScriptGlobalsImpl(ScriptInstance scriptInstance)
+            public ScriptGlobalsImpl(ScriptInstance scriptInstance, IReflectionManager refl)
             {
+                _reflectionManager = refl;
                 _scriptInstance = scriptInstance;
-                IoCManager.InjectDependencies(this);
             }
 
             protected override void WriteSyntax(object toString)

Robust.Server/ServerIoC.cs

@@ -32,50 +32,50 @@ namespace Robust.Server
     internal static class ServerIoC
     {
         /// <summary>
-        /// Registers all the types into the <see cref="IoCManager"/> with <see cref="IoCManager.Register{TInterface, TImplementation}"/>
+        /// Registers all the types into the <see cref="IDependencyCollection"/>
         /// </summary>
-        internal static void RegisterIoC()
+        internal static void RegisterIoC(IDependencyCollection deps)
         {
-            SharedIoC.RegisterIoC();
+            SharedIoC.RegisterIoC(deps);
 
-            IoCManager.Register<IBaseServer, BaseServer>();
-            IoCManager.Register<IBaseServerInternal, BaseServer>();
-            IoCManager.Register<BaseServer, BaseServer>();
-            IoCManager.Register<IGameTiming, GameTiming>();
-            IoCManager.Register<IReflectionManager, ServerReflectionManager>();
-            IoCManager.Register<IConsoleHost, ServerConsoleHost>();
-            IoCManager.Register<IServerConsoleHost, ServerConsoleHost>();
-            IoCManager.Register<IComponentFactory, ServerComponentFactory>();
-            IoCManager.Register<IConGroupController, ConGroupController>();
-            IoCManager.Register<IMapManager, NetworkedMapManager>();
-            IoCManager.Register<IMapManagerInternal, NetworkedMapManager>();
-            IoCManager.Register<INetworkedMapManager, NetworkedMapManager>();
-            IoCManager.Register<IEntityManager, ServerEntityManager>();
-            IoCManager.Register<IEntityNetworkManager, ServerEntityManager>();
-            IoCManager.Register<IServerEntityNetworkManager, ServerEntityManager>();
-            IoCManager.Register<IPlacementManager, PlacementManager>();
-            IoCManager.Register<IPlayerManager, PlayerManager>();
-            IoCManager.Register<ISharedPlayerManager, PlayerManager>();
-            IoCManager.Register<IPrototypeManager, ServerPrototypeManager>();
-            IoCManager.Register<IResourceManager, ResourceManager>();
-            IoCManager.Register<IResourceManagerInternal, ResourceManager>();
-            IoCManager.Register<EntityManager, ServerEntityManager>();
-            IoCManager.Register<IServerEntityManager, ServerEntityManager>();
-            IoCManager.Register<IServerEntityManagerInternal, ServerEntityManager>();
-            IoCManager.Register<IServerGameStateManager, ServerGameStateManager>();
-            IoCManager.Register<IServerNetManager, NetManager>();
-            IoCManager.Register<IStatusHost, StatusHost>();
-            IoCManager.Register<ISystemConsoleManager, SystemConsoleManager>();
-            IoCManager.Register<ITileDefinitionManager, TileDefinitionManager>();
-            IoCManager.Register<IViewVariablesManager, ServerViewVariablesManager>();
-            IoCManager.Register<IServerViewVariablesInternal, ServerViewVariablesManager>();
-            IoCManager.Register<IWatchdogApi, WatchdogApi>();
-            IoCManager.Register<IScriptHost, ScriptHost>();
-            IoCManager.Register<IMetricsManager, MetricsManager>();
-            IoCManager.Register<IAuthManager, AuthManager>();
-            IoCManager.Register<IPhysicsManager, PhysicsManager>();
-            IoCManager.Register<IBqlQueryManager, BqlQueryManager>();
-            IoCManager.Register<HubManager, HubManager>();
+            deps.Register<IBaseServer, BaseServer>();
+            deps.Register<IBaseServerInternal, BaseServer>();
+            deps.Register<BaseServer, BaseServer>();
+            deps.Register<IGameTiming, GameTiming>();
+            deps.Register<IReflectionManager, ServerReflectionManager>();
+            deps.Register<IConsoleHost, ServerConsoleHost>();
+            deps.Register<IServerConsoleHost, ServerConsoleHost>();
+            deps.Register<IComponentFactory, ServerComponentFactory>();
+            deps.Register<IConGroupController, ConGroupController>();
+            deps.Register<IMapManager, NetworkedMapManager>();
+            deps.Register<IMapManagerInternal, NetworkedMapManager>();
+            deps.Register<INetworkedMapManager, NetworkedMapManager>();
+            deps.Register<IEntityManager, ServerEntityManager>();
+            deps.Register<IEntityNetworkManager, ServerEntityManager>();
+            deps.Register<IServerEntityNetworkManager, ServerEntityManager>();
+            deps.Register<IPlacementManager, PlacementManager>();
+            deps.Register<IPlayerManager, PlayerManager>();
+            deps.Register<ISharedPlayerManager, PlayerManager>();
+            deps.Register<IPrototypeManager, ServerPrototypeManager>();
+            deps.Register<IResourceManager, ResourceManager>();
+            deps.Register<IResourceManagerInternal, ResourceManager>();
+            deps.Register<EntityManager, ServerEntityManager>();
+            deps.Register<IServerEntityManager, ServerEntityManager>();
+            deps.Register<IServerEntityManagerInternal, ServerEntityManager>();
+            deps.Register<IServerGameStateManager, ServerGameStateManager>();
+            deps.Register<IServerNetManager, NetManager>();
+            deps.Register<IStatusHost, StatusHost>();
+            deps.Register<ISystemConsoleManager, SystemConsoleManager>();
+            deps.Register<ITileDefinitionManager, TileDefinitionManager>();
+            deps.Register<IViewVariablesManager, ServerViewVariablesManager>();
+            deps.Register<IServerViewVariablesInternal, ServerViewVariablesManager>();
+            deps.Register<IWatchdogApi, WatchdogApi>();
+            deps.Register<IScriptHost, ScriptHost>();
+            deps.Register<IMetricsManager, MetricsManager>();
+            deps.Register<IAuthManager, AuthManager>();
+            deps.Register<IPhysicsManager, PhysicsManager>();
+            deps.Register<IBqlQueryManager, BqlQueryManager>();
+            deps.Register<HubManager, HubManager>();
         }
     }
 }

Robust.Server/ViewVariables/ServerViewVariablesManager.cs

@@ -25,6 +25,8 @@ namespace Robust.Server.ViewVariables
         [Dependency] private readonly IConGroupController _groupController = default!;
         [Dependency] private readonly IRobustSerializer _robustSerializer = default!;
         [Dependency] private readonly IReflectionManager _reflectionManager = default!;
+        [Dependency] private readonly IDependencyCollection _dependencyCollection = default!;
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
 
         private readonly Dictionary<uint, ViewVariablesSession>
             _sessions = new();
@@ -186,26 +188,26 @@ namespace Robust.Server.ViewVariables
                 }
                 case ViewVariablesIoCSelector ioCSelector:
                 {
-                    var reflectionManager = IoCManager.Resolve<IReflectionManager>();
+                    var reflectionManager = _reflectionManager;
                     if (!reflectionManager.TryLooseGetType(ioCSelector.TypeName, out var type))
                     {
                         Deny(ViewVariablesResponseCode.InvalidRequest);
                         return;
                     }
 
-                    theObject = IoCManager.ResolveType(type);
+                    theObject = _dependencyCollection.ResolveType(type);
                     break;
                 }
                 case ViewVariablesEntitySystemSelector esSelector:
                 {
-                    var reflectionManager = IoCManager.Resolve<IReflectionManager>();
+                    var reflectionManager = _reflectionManager;
                     if (!reflectionManager.TryLooseGetType(esSelector.TypeName, out var type))
                     {
                         Deny(ViewVariablesResponseCode.InvalidRequest);
                         return;
                     }
 
-                    theObject = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem(type);
+                    theObject = _entityManager.EntitySysManager.GetEntitySystem(type);
                     break;
                 }
                 case ViewVariablesPathSelector paSelector:
@@ -270,12 +272,10 @@ namespace Robust.Server.ViewVariables
             switch (input)
             {
                 case ViewVariablesBlobMembers.PrototypeReferenceToken token:
-                    var protoMan = IoCManager.Resolve<IPrototypeManager>();
-
-                    if (!protoMan.TryGetVariantType(token.Variant, out var variantType))
+                    if (!_prototypeManager.TryGetVariantType(token.Variant, out var variantType))
                         return false;
 
-                    if (!protoMan.TryIndex(variantType, token.ID, out var prototype))
+                    if (!_prototypeManager.TryIndex(variantType, token.ID, out var prototype))
                         return false;
 
                     output = prototype;

Robust.Shared.Scripting/ScriptGlobalsShared.cs

@@ -26,6 +26,7 @@ namespace Robust.Shared.Scripting
         [field: Dependency] public IEntitySystemManager esm { get; } = default!;
         [field: Dependency] public IPrototypeManager prot { get; } = default!;
         [field: Dependency] public IMapManager map { get; } = default!;
+        [field: Dependency] public IDependencyCollection dependencies { get; } = default!;
 
         public IEnumerable<T> protos<T>() where T : class, IPrototype
         {
@@ -76,7 +77,7 @@ namespace Robust.Shared.Scripting
 
         public T res<T>()
         {
-            return IoCManager.Resolve<T>();
+            return dependencies.Resolve<T>();
         }
 
         public T ressys<T>() where T : EntitySystem

Robust.Shared/Configuration/ConfigurationCommands.cs

@@ -11,6 +11,8 @@ namespace Robust.Shared.Configuration
     [SuppressMessage("ReSharper", "StringLiteralTypo")]
     internal sealed class CVarCommand : LocalizedCommands
     {
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
+
         public override string Command => "cvar";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -21,17 +23,16 @@ namespace Robust.Shared.Configuration
                 return;
             }
 
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
             var name = args[0];
 
             if (name == "?")
             {
-                var cvars = configManager.GetRegisteredCVars().OrderBy(c => c);
+                var cvars = _cfg.GetRegisteredCVars().OrderBy(c => c);
                 shell.WriteLine(string.Join("\n", cvars));
                 return;
             }
 
-            if (!configManager.IsCVarRegistered(name))
+            if (!_cfg.IsCVarRegistered(name))
             {
                 shell.WriteError(Loc.GetString("cmd-cvar-not-registered", ("cvar", name)));
                 return;
@@ -40,18 +41,18 @@ namespace Robust.Shared.Configuration
             if (args.Length == 1)
             {
                 // Read CVar
-                var value = configManager.GetCVar<object>(name);
+                var value = _cfg.GetCVar<object>(name);
                 shell.WriteLine(value.ToString()!);
             }
             else
             {
                 // Write CVar
                 var value = args[1];
-                var type = configManager.GetCVarType(name);
+                var type = _cfg.GetCVarType(name);
                 try
                 {
                     var parsed = ParseObject(type, value);
-                    configManager.SetCVar(name, parsed);
+                    _cfg.SetCVar(name, parsed);
                 }
                 catch (FormatException)
                 {
@@ -62,24 +63,23 @@ namespace Robust.Shared.Configuration
 
         public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
         {
-            var cfg = IoCManager.Resolve<IConfigurationManager>();
             if (args.Length == 1)
             {
                 var helpQuestion = Loc.GetString("cmd-cvar-compl-list");
 
                 return CompletionResult.FromHintOptions(
-                    cfg.GetRegisteredCVars()
-                        .Select(c => new CompletionOption(c, GetCVarValueHint(cfg, c)))
+                    _cfg.GetRegisteredCVars()
+                        .Select(c => new CompletionOption(c, GetCVarValueHint(_cfg, c)))
                         .Union(new[] { new CompletionOption("?", helpQuestion) })
                         .OrderBy(c => c.Value),
                     Loc.GetString("cmd-cvar-arg-name"));
             }
 
             var cvar = args[0];
-            if (!cfg.IsCVarRegistered(cvar))
+            if (!_cfg.IsCVarRegistered(cvar))
                 return CompletionResult.Empty;
 
-            var type = cfg.GetCVarType(cvar);
+            var type = _cfg.GetCVarType(cvar);
             return CompletionResult.FromHint($"<{type.Name}>");
         }
 

Robust.Shared/Configuration/NetConfigurationManager.cs

@@ -72,8 +72,13 @@ namespace Robust.Shared.Configuration
         public event EventHandler ReceivedInitialNwVars;
     }
 
+    internal interface INetConfigurationManagerInternal : INetConfigurationManager, IConfigurationManagerInternal
+    {
+
+    }
+
     /// <inheritdoc cref="INetConfigurationManager"/>
-    internal sealed class NetConfigurationManager : ConfigurationManager, INetConfigurationManager
+    internal sealed class NetConfigurationManager : ConfigurationManager, INetConfigurationManagerInternal
     {
         [Dependency] private readonly INetManager _netManager = null!;
         [Dependency] private readonly IGameTiming _timing = null!;

Robust.Shared/Console/Commands/DumpEventTablesCommand.cs

@@ -6,26 +6,26 @@ namespace Robust.Shared.Console.Commands;
 
 internal sealed class DumpEventTablesCommand : LocalizedCommands
 {
+    [Dependency] private readonly EntityManager _entities = default!;
+    [Dependency] private readonly IComponentFactory _componentFactory = default!;
+
     public override string Command => "dump_event_tables";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        var entMgr = IoCManager.Resolve<EntityManager>();
-        var compFactory = IoCManager.Resolve<IComponentFactory>();
-
         if (args.Length < 1)
         {
             shell.WriteError(Loc.GetString("cmd-dump_event_tables-missing-arg-entity"));
             return;
         }
 
-        if (!EntityUid.TryParse(args[0], out var entity) || !entMgr.EntityExists(entity))
+        if (!EntityUid.TryParse(args[0], out var entity) || !_entities.EntityExists(entity))
         {
             shell.WriteError(Loc.GetString("cmd-dump_event_tables-error-entity"));
             return;
         }
 
-        var eventBus = (EntityEventBus)entMgr.EventBus;
+        var eventBus = (EntityEventBus)_entities.EventBus;
 
         var table = eventBus._entEventTables[entity];
         foreach (var (evType, comps) in table.EventIndices)
@@ -38,7 +38,7 @@ internal sealed class DumpEventTablesCommand : LocalizedCommands
                 ref var entry = ref table.ComponentLists[idx];
                 idx = entry.Next;
 
-                var reg = compFactory.IdxToType(entry.Component);
+                var reg = _componentFactory.IdxToType(entry.Component);
                 shell.WriteLine($"    {reg.Name}");
             }
         }

Robust.Shared/Console/Commands/DumpNetComponentsCommand.cs

@@ -6,13 +6,13 @@ namespace Robust.Shared.Console.Commands;
 
 internal sealed class DumpNetComponentsCommand : LocalizedCommands
 {
+    [Dependency] private readonly IComponentFactory _componentFactory = default!;
+
     public override string Command => "dump_net_comps";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
-        var mgr = IoCManager.Resolve<IComponentFactory>();
-
-        if (mgr.NetworkedComponents is not { } comps)
+        if (_componentFactory.NetworkedComponents is not { } comps)
         {
             shell.WriteError(Loc.GetString("cmd-dump_net_comps-error-writeable"));
             return;

Robust.Shared/Console/Commands/ExecCommand.cs

@@ -12,12 +12,12 @@ namespace Robust.Shared.Console.Commands
     {
         private static readonly Regex CommentRegex = new Regex(@"^\s*#");
 
+        [Dependency] private readonly IResourceManager _resources = default!;
+
         public override string Command => "exec";
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var res = IoCManager.Resolve<IResourceManager>();
-
             if (args.Length < 1)
             {
                 shell.WriteError("No file specified!");
@@ -25,13 +25,13 @@ namespace Robust.Shared.Console.Commands
             }
 
             var path = new ResourcePath(args[0]).ToRootedPath();
-            if (!res.UserData.Exists(path))
+            if (!_resources.UserData.Exists(path))
             {
                 shell.WriteError("File does not exist.");
                 return;
             }
 
-            using var text = res.UserData.OpenText(path);
+            using var text = _resources.UserData.OpenText(path);
             while (true)
             {
                 var line = text.ReadLine();
@@ -54,10 +54,8 @@ namespace Robust.Shared.Console.Commands
         {
             if (args.Length == 1)
             {
-                var res = IoCManager.Resolve<IResourceManager>();
-
                 var hint = Loc.GetString("cmd-exec-arg-filename");
-                var options = CompletionHelper.UserFilePath(args[0], res.UserData);
+                var options = CompletionHelper.UserFilePath(args[0], _resources.UserData);
 
                 return CompletionResult.FromHintOptions(options, hint);
             }

Robust.Shared/Console/Commands/LogCommands.cs

@@ -7,6 +7,8 @@ namespace Robust.Shared.Console.Commands;
 
 internal sealed class LogSetLevelCommand : LocalizedCommands
 {
+    [Dependency] private readonly ILogManager _logManager = default!;
+
     public override string Command => "loglevel";
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
@@ -39,13 +41,11 @@ internal sealed class LogSetLevelCommand : LocalizedCommands
 
     public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
     {
-        var logMgr = IoCManager.Resolve<ILogManager>();
-
         switch (args.Length)
         {
             case 1:
                 return CompletionResult.FromHintOptions(
-                    logMgr.AllSawmills.Select(c => c.Name).OrderBy(c => c),
+                    _logManager.AllSawmills.Select(c => c.Name).OrderBy(c => c),
                     "<sawmill>");
             case 2:
                 return CompletionResult.FromHintOptions(
@@ -60,6 +60,8 @@ internal sealed class LogSetLevelCommand : LocalizedCommands
 
 internal sealed class TestLog : LocalizedCommands
 {
+    [Dependency] private readonly ILogManager _logManager = default!;
+
     public override string Command => "testlog";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
@@ -86,13 +88,11 @@ internal sealed class TestLog : LocalizedCommands
 
     public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
     {
-        var logMgr = IoCManager.Resolve<ILogManager>();
-
         switch (args.Length)
         {
             case 1:
                 return CompletionResult.FromHintOptions(
-                    logMgr.AllSawmills.Select(c => c.Name).OrderBy(c => c),
+                    _logManager.AllSawmills.Select(c => c.Name).OrderBy(c => c),
                     "<sawmill>");
             case 2:
                 return CompletionResult.FromHintOptions(

Robust.Shared/Containers/SharedContainerSystem.cs

@@ -21,7 +21,7 @@ namespace Robust.Shared.Containers
         public override void Initialize()
         {
             base.Initialize();
-            
+
             SubscribeLocalEvent<EntParentChangedMessage>(OnParentChanged);
             SubscribeLocalEvent<ContainerManagerComponent, ComponentStartup>(OnStartupValidation);
         }
@@ -369,12 +369,11 @@ namespace Robust.Shared.Containers
         public void EmptyContainer(IContainer container, bool force = false, EntityCoordinates? moveTo = null,
             bool attachToGridOrMap = false, IEntityManager? entMan = null)
         {
-            IoCManager.Resolve(ref entMan);
-            var query = entMan.GetEntityQuery<TransformComponent>();
+            var query = EntityManager.GetEntityQuery<TransformComponent>();
             foreach (var entity in container.ContainedEntities.ToArray())
             {
                 if (query.TryGetComponent(entity, out var xform))
-                    container.Remove(entity, entMan, xform, null, attachToGridOrMap, force, moveTo);
+                    container.Remove(entity, EntityManager, xform, null, attachToGridOrMap, force, moveTo);
             }
         }
 

Robust.Shared/GameObjects/EntitySystemManager.cs

@@ -25,6 +25,7 @@ namespace Robust.Shared.GameObjects
         [IoC.Dependency] private readonly IReflectionManager _reflectionManager = default!;
         [IoC.Dependency] private readonly IEntityManager _entityManager = default!;
         [IoC.Dependency] private readonly ProfManager _profManager = default!;
+        [IoC.Dependency] private readonly IDependencyCollection _dependencyCollection = default!;
 
 #if EXCEPTION_TOLERANCE
         [Dependency] private readonly IRuntimeLog _runtimeLog = default!;
@@ -121,7 +122,7 @@ namespace Robust.Shared.GameObjects
 
             var excludedTypes = new HashSet<Type>();
 
-            _systemDependencyCollection = new(IoCManager.Instance!);
+            _systemDependencyCollection = new(_dependencyCollection);
             var subTypes = new Dictionary<Type, Type>();
             _systemTypes.Clear();
             IEnumerable<Type> systems;

Robust.Shared/GameObjects/Systems/SharedGridFixtureSystem.cs

@@ -19,6 +19,7 @@ namespace Robust.Shared.GameObjects
     public abstract class SharedGridFixtureSystem : EntitySystem
     {
         [Dependency] private readonly FixtureSystem _fixtures = default!;
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
 
         protected ISawmill Sawmill = default!;
         private bool _enabled;
@@ -32,11 +33,10 @@ namespace Robust.Shared.GameObjects
             base.Initialize();
             UpdatesBefore.Add(typeof(SharedBroadphaseSystem));
             Sawmill = Logger.GetSawmill("physics");
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
 
-            configManager.OnValueChanged(CVars.GenerateGridFixtures, SetEnabled, true);
-            configManager.OnValueChanged(CVars.GridFixtureEnlargement, SetEnlargement, true);
-            configManager.OnValueChanged(CVars.ConvexHullPolygons, SetConvexHulls, true);
+            _cfg.OnValueChanged(CVars.GenerateGridFixtures, SetEnabled, true);
+            _cfg.OnValueChanged(CVars.GridFixtureEnlargement, SetEnlargement, true);
+            _cfg.OnValueChanged(CVars.ConvexHullPolygons, SetConvexHulls, true);
 
             SubscribeLocalEvent<GridInitializeEvent>(OnGridInit);
         }
@@ -52,11 +52,9 @@ namespace Robust.Shared.GameObjects
         {
             base.Shutdown();
 
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-
-            configManager.UnsubValueChanged(CVars.GenerateGridFixtures, SetEnabled);
-            configManager.UnsubValueChanged(CVars.GridFixtureEnlargement, SetEnlargement);
-            configManager.UnsubValueChanged(CVars.ConvexHullPolygons, SetConvexHulls);
+            _cfg.UnsubValueChanged(CVars.GenerateGridFixtures, SetEnabled);
+            _cfg.UnsubValueChanged(CVars.GridFixtureEnlargement, SetEnlargement);
+            _cfg.UnsubValueChanged(CVars.ConvexHullPolygons, SetConvexHulls);
         }
 
         private void SetEnabled(bool value) => _enabled = value;

Robust.Shared/IoC/DependencyAttribute.cs

@@ -8,7 +8,7 @@ namespace Robust.Shared.IoC
     /// </summary>
     /// <remarks>
     /// <para>
-    /// The dependency is resolved as if <see cref="IoCManager.Resolve{T}" /> were to be called,
+    /// The dependency is resolved as if <see cref="IoCManager.Resolve{T}()" /> were to be called,
     /// but it avoids circular references and init order issues due to internal code in the <see cref="IoCManager" />.
     /// </para>
     /// <para>

Robust.Shared/Map/Commands/AmbientLightCommand.cs

@@ -11,6 +11,9 @@ namespace Robust.Shared.Map.Commands;
 /// </summary>
 public sealed class AmbientLightCommand : IConsoleCommand
 {
+    [Dependency] private readonly IMapManager _mapManager = default!;
+    [Dependency] private readonly IEntitySystemManager _systems = default!;
+
     public string Command => $"setambientlight";
     public string Description => Loc.GetString("cmd-set-ambient-light-desc");
     public string Help => Loc.GetString("cmd-set-ambient-light-help");
@@ -22,8 +25,6 @@ public sealed class AmbientLightCommand : IConsoleCommand
             return;
         }
 
-        var mapManager = IoCManager.Resolve<IMapManager>();
-
         if (!int.TryParse(args[0], out var mapInt))
         {
             shell.WriteError(Loc.GetString("cmd-parse-failure-integer"));
@@ -32,7 +33,7 @@ public sealed class AmbientLightCommand : IConsoleCommand
 
         var mapId = new MapId(mapInt);
 
-        if (!mapManager.MapExists(mapId))
+        if (!_mapManager.MapExists(mapId))
         {
             shell.WriteError(Loc.GetString("cmd-parse-failure-mapid"));
             return;
@@ -48,7 +49,7 @@ public sealed class AmbientLightCommand : IConsoleCommand
         }
 
         var color = Color.FromSrgb(new Color(r, g, b, a));
-        var mapSystem = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<SharedMapSystem>();
+        var mapSystem = _systems.GetEntitySystem<SharedMapSystem>();
         mapSystem.SetAmbientLight(mapId, color);
     }
 }

Robust.Shared/Physics/Dynamics/ContactManager.cs

@@ -34,7 +34,6 @@ using System.Threading.Tasks;
 using Microsoft.Extensions.ObjectPool;
 using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics.Collision;
@@ -49,8 +48,10 @@ namespace Robust.Shared.Physics.Dynamics
 {
     internal sealed class ContactManager
     {
-        [Dependency] private readonly IEntityManager _entityManager = default!;
-        [Dependency] private readonly IPhysicsManager _physicsManager = default!;
+        private readonly IEntityManager _entityManager;
+        private readonly IPhysicsManager _physicsManager;
+        private readonly IConfigurationManager _cfg;
+
         private EntityLookupSystem _lookup = default!;
         private SharedPhysicsSystem _physics = default!;
         private SharedTransformSystem _transform = default!;
@@ -97,7 +98,7 @@ namespace Robust.Shared.Physics.Dynamics
 
         private int ContactPoolInitialSize = 64;
 
-        private ObjectPool<Contact> _contactPool = new DefaultObjectPool<Contact>(new ContactPoolPolicy(), 1024);
+        private readonly ObjectPool<Contact> _contactPool;
 
         internal LinkedList<Contact> _activeContacts = new();
 
@@ -114,12 +115,20 @@ namespace Robust.Shared.Physics.Dynamics
 
         private sealed class ContactPoolPolicy : IPooledObjectPolicy<Contact>
         {
+            private readonly SharedDebugPhysicsSystem _debugPhysicsSystem;
+            private readonly IManifoldManager _manifoldManager;
+
+            public ContactPoolPolicy(SharedDebugPhysicsSystem debugPhysicsSystem, IManifoldManager manifoldManager)
+            {
+                _debugPhysicsSystem = debugPhysicsSystem;
+                _manifoldManager = manifoldManager;
+            }
+
             public Contact Create()
             {
-                var contact = new Contact();
-                IoCManager.InjectDependencies(contact);
+                var contact = new Contact(_manifoldManager);
 #if DEBUG
-                contact._debugPhysics = IoCManager.Resolve<IEntitySystemManager>().GetEntitySystem<SharedDebugPhysicsSystem>();
+                contact._debugPhysics = _debugPhysicsSystem;
 #endif
                 contact.Manifold = new Manifold
                 {
@@ -136,6 +145,22 @@ namespace Robust.Shared.Physics.Dynamics
             }
         }
 
+        public ContactManager(
+            SharedDebugPhysicsSystem debugPhysicsSystem,
+            IManifoldManager manifoldManager,
+            IEntityManager entityManager,
+            IPhysicsManager physicsManager,
+            IConfigurationManager cfg)
+        {
+            _entityManager = entityManager;
+            _physicsManager = physicsManager;
+            _cfg = cfg;
+
+            _contactPool = new DefaultObjectPool<Contact>(
+                new ContactPoolPolicy(debugPhysicsSystem, manifoldManager),
+                1024);
+        }
+
         private static void SetContact(Contact contact, Fixture? fixtureA, int indexA, Fixture? fixtureB, int indexB)
         {
             contact.Enabled = true;
@@ -163,22 +188,20 @@ namespace Robust.Shared.Physics.Dynamics
 
         public void Initialize()
         {
-            IoCManager.InjectDependencies(this);
             _lookup = _entityManager.EntitySysManager.GetEntitySystem<EntityLookupSystem>();
             _physics = _entityManager.EntitySysManager.GetEntitySystem<SharedPhysicsSystem>();
             _transform = _entityManager.EntitySysManager.GetEntitySystem<SharedTransformSystem>();
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.OnValueChanged(CVars.ContactMultithreadThreshold, OnContactMultithreadThreshold, true);
-            configManager.OnValueChanged(CVars.ContactMinimumThreads, OnContactMinimumThreads, true);
+
+            _cfg.OnValueChanged(CVars.ContactMultithreadThreshold, OnContactMultithreadThreshold, true);
+            _cfg.OnValueChanged(CVars.ContactMinimumThreads, OnContactMinimumThreads, true);
 
             InitializePool();
         }
 
         public void Shutdown()
         {
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.UnsubValueChanged(CVars.ContactMultithreadThreshold, OnContactMultithreadThreshold);
-            configManager.UnsubValueChanged(CVars.ContactMinimumThreads, OnContactMinimumThreads);
+            _cfg.UnsubValueChanged(CVars.ContactMultithreadThreshold, OnContactMultithreadThreshold);
+            _cfg.UnsubValueChanged(CVars.ContactMinimumThreads, OnContactMinimumThreads);
         }
 
         private void OnContactMultithreadThreshold(int value)

Robust.Shared/Physics/Dynamics/Contacts/Contact.cs

@@ -40,7 +40,8 @@ namespace Robust.Shared.Physics.Dynamics.Contacts
 {
     public sealed class Contact : IEquatable<Contact>
     {
-        [Dependency] private readonly IManifoldManager _manifoldManager = default!;
+        private readonly IManifoldManager _manifoldManager;
+
 #if DEBUG
         internal SharedDebugPhysicsSystem _debugPhysics = default!;
 #endif
@@ -72,8 +73,10 @@ namespace Robust.Shared.Physics.Dynamics.Contacts
 
         internal ContactFlags Flags = ContactFlags.None;
 
-        public Contact()
+        internal Contact(IManifoldManager manifoldManager)
         {
+            _manifoldManager = manifoldManager;
+
             MapNode = new LinkedListNode<Contact>(this);
             BodyANode = new LinkedListNode<Contact>(this);
             BodyBNode = new LinkedListNode<Contact>(this);

Robust.Shared/Physics/Systems/SharedBroadphaseSystem.cs

@@ -18,6 +18,7 @@ namespace Robust.Shared.Physics.Systems
     public abstract class SharedBroadphaseSystem : EntitySystem
     {
         [Dependency] private readonly IMapManagerInternal _mapManager = default!;
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
         [Dependency] private readonly EntityLookupSystem _lookup = default!;
         [Dependency] private readonly SharedPhysicsSystem _physicsSystem = default!;
 
@@ -53,15 +54,14 @@ namespace Robust.Shared.Physics.Systems
 
             UpdatesAfter.Add(typeof(SharedTransformSystem));
 
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.OnValueChanged(CVars.BroadphaseExpand, SetBroadphaseExpand, true);
+            _cfg.OnValueChanged(CVars.BroadphaseExpand, SetBroadphaseExpand, true);
         }
 
         public override void Shutdown()
         {
             base.Shutdown();
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.UnsubValueChanged(CVars.BroadphaseExpand, SetBroadphaseExpand);
+
+            _cfg.UnsubValueChanged(CVars.BroadphaseExpand, SetBroadphaseExpand);
         }
 
         private void SetBroadphaseExpand(float value) => _broadphaseExpand = value;

Robust.Shared/Physics/Systems/SharedPhysicsSystem.cs

@@ -48,8 +48,13 @@ namespace Robust.Shared.Physics.Systems
         [Dependency] private readonly EntityLookupSystem _lookup = default!;
         [Dependency] private readonly SharedJointSystem _joints = default!;
         [Dependency] private readonly SharedGridTraversalSystem _traversal = default!;
+        [Dependency] private readonly SharedDebugPhysicsSystem _debugPhysics = default!;
+        [Dependency] private readonly IManifoldManager _manifoldManager = default!;
         [Dependency] protected readonly IMapManager MapManager = default!;
         [Dependency] private readonly IPhysicsManager _physicsManager = default!;
+        [Dependency] private readonly IIslandManager _islandManager = default!;
+        [Dependency] private readonly IConfigurationManager _cfg = default!;
+        [Dependency] private readonly IDependencyCollection _deps = default!;
 
         public Action<Fixture, Fixture, float, Vector2>? KinematicControllerCollision;
 
@@ -77,10 +82,9 @@ namespace Robust.Shared.Physics.Systems
             SubscribeLocalEvent<PhysicsComponent, ComponentGetState>(OnPhysicsGetState);
             SubscribeLocalEvent<PhysicsComponent, ComponentHandleState>(OnPhysicsHandleState);
 
-            IoCManager.Resolve<IIslandManager>().Initialize();
+            _islandManager.Initialize();
 
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.OnValueChanged(CVars.AutoClearForces, OnAutoClearChange);
+            _cfg.OnValueChanged(CVars.AutoClearForces, OnAutoClearChange);
         }
 
         private void OnPhysicsRemove(EntityUid uid, PhysicsComponent component, ComponentRemove args)
@@ -104,12 +108,12 @@ namespace Robust.Shared.Physics.Systems
 
         private void HandlePhysicsMapInit(EntityUid uid, SharedPhysicsMapComponent component, ComponentInit args)
         {
-            IoCManager.InjectDependencies(component);
+            _deps.InjectDependencies(component);
             component.BroadphaseSystem = _broadphase;
-            component.ContactManager = new();
+            component.ContactManager = new(_debugPhysics, _manifoldManager, EntityManager, _physicsManager, _cfg);
             component.ContactManager.Initialize();
             component.ContactManager.MapId = component.MapId;
-            component.AutoClearForces = IoCManager.Resolve<IConfigurationManager>().GetCVar(CVars.AutoClearForces);
+            component.AutoClearForces = _cfg.GetCVar(CVars.AutoClearForces);
 
             component.ContactManager.KinematicControllerCollision += KinematicControllerCollision;
         }
@@ -261,8 +265,7 @@ namespace Robust.Shared.Physics.Systems
         {
             base.Shutdown();
 
-            var configManager = IoCManager.Resolve<IConfigurationManager>();
-            configManager.UnsubValueChanged(CVars.AutoClearForces, OnAutoClearChange);
+            _cfg.UnsubValueChanged(CVars.AutoClearForces, OnAutoClearChange);
         }
 
         private void OnWake(ref PhysicsWakeEvent @event)

Robust.Shared/Serialization/Manager/SerializationManager.Reading.cs

@@ -51,7 +51,7 @@ namespace Robust.Shared.Serialization.Manager
             if (node.Tag?.StartsWith("!type:") ?? false)
             {
                 var typeString = node.Tag.Substring(6);
-                value = ResolveConcreteType(value, typeString);
+                value = ResolveConcreteType(value, typeString, _reflectionManager);
             }
 
             return _readers.GetOrAdd((value, node.GetType()), static (tuple, vfArgument) =>

Robust.Shared/Serialization/Manager/SerializationManager.cs

@@ -40,7 +40,8 @@ namespace Robust.Shared.Serialization.Manager
         private readonly ConditionalWeakTable<Type, DataDefinition> _dataDefinitions = new();
         private readonly HashSet<Type> _copyByRefRegistrations = new();
 
-        public IDependencyCollection DependencyCollection { get; private set; } = default!;
+        [field: IoC.Dependency]
+        public IDependencyCollection DependencyCollection { get; } = default!;
 
         public void Initialize()
         {
@@ -52,8 +53,6 @@ namespace Robust.Shared.Serialization.Manager
 
             _initializing = true;
 
-            DependencyCollection = IoCManager.Instance ?? throw new NullReferenceException();
-
             var flagsTypes = new ConcurrentBag<Type>();
             var constantsTypes = new ConcurrentBag<Type>();
             var typeSerializers = new ConcurrentBag<Type>();
@@ -231,8 +230,6 @@ namespace Robust.Shared.Serialization.Manager
 
         public void Shutdown()
         {
-            DependencyCollection = null!;
-
             _constantsMapping.Clear();
             _flagsMapping.Clear();
 
@@ -319,7 +316,7 @@ namespace Robust.Shared.Serialization.Manager
                 var typeString = node.Tag.Substring(6);
                 try
                 {
-                    underlyingType = ResolveConcreteType(underlyingType, typeString);
+                    underlyingType = ResolveConcreteType(underlyingType, typeString, _reflectionManager);
                 }
                 catch (InvalidOperationException)
                 {
@@ -596,9 +593,8 @@ namespace Robust.Shared.Serialization.Manager
                    type.IsValueType;
         }
 
-        private static Type ResolveConcreteType(Type baseType, string typeName)
+        private static Type ResolveConcreteType(Type baseType, string typeName, IReflectionManager reflection)
         {
-            var reflection = IoCManager.Resolve<IReflectionManager>();
             var type = reflection.YamlTypeTagLookup(baseType, typeName);
             if (type == null)
             {

Robust.Shared/SharedIoC.cs

@@ -22,35 +22,36 @@ namespace Robust.Shared
 {
     internal static class SharedIoC
     {
-        public static void RegisterIoC()
+        public static void RegisterIoC(IDependencyCollection deps)
         {
-            IoCManager.Register<ISerializationManager, SerializationManager>();
-            IoCManager.Register<IConfigurationManager, NetConfigurationManager>();
-            IoCManager.Register<INetConfigurationManager, NetConfigurationManager>();
-            IoCManager.Register<IConfigurationManagerInternal, NetConfigurationManager>();
-            IoCManager.Register<IDynamicTypeFactory, DynamicTypeFactory>();
-            IoCManager.Register<IDynamicTypeFactoryInternal, DynamicTypeFactory>();
-            IoCManager.Register<IEntitySystemManager, EntitySystemManager>();
-            IoCManager.Register<ILocalizationManager, LocalizationManager>();
-            IoCManager.Register<ILocalizationManagerInternal, LocalizationManager>();
-            IoCManager.Register<ILogManager, LogManager>();
-            IoCManager.Register<IModLoader, ModLoader>();
-            IoCManager.Register<IModLoaderInternal, ModLoader>();
-            IoCManager.Register<INetManager, NetManager>();
-            IoCManager.Register<IRobustSerializer, RobustSerializer>();
-            IoCManager.Register<IRuntimeLog, RuntimeLog>();
-            IoCManager.Register<ITaskManager, TaskManager>();
-            IoCManager.Register<TaskManager, TaskManager>();
-            IoCManager.Register<ITimerManager, TimerManager>();
-            IoCManager.Register<ProfManager, ProfManager>();
-            IoCManager.Register<IRobustRandom, RobustRandom>();
-            IoCManager.Register<IRobustMappedStringSerializer, RobustMappedStringSerializer>();
-            IoCManager.Register<ISandboxHelper, SandboxHelper>();
-            IoCManager.Register<IManifoldManager, CollisionManager>();
-            IoCManager.Register<IIslandManager, IslandManager>();
-            IoCManager.Register<IVerticesSimplifier, RamerDouglasPeuckerSimplifier>();
-            IoCManager.Register<IParallelManager, ParallelManager>();
-            IoCManager.Register<IParallelManagerInternal, ParallelManager>();
+            deps.Register<ISerializationManager, SerializationManager>();
+            deps.Register<IConfigurationManager, NetConfigurationManager>();
+            deps.Register<INetConfigurationManager, NetConfigurationManager>();
+            deps.Register<IConfigurationManagerInternal, NetConfigurationManager>();
+            deps.Register<INetConfigurationManagerInternal, NetConfigurationManager>();
+            deps.Register<IDynamicTypeFactory, DynamicTypeFactory>();
+            deps.Register<IDynamicTypeFactoryInternal, DynamicTypeFactory>();
+            deps.Register<IEntitySystemManager, EntitySystemManager>();
+            deps.Register<ILocalizationManager, LocalizationManager>();
+            deps.Register<ILocalizationManagerInternal, LocalizationManager>();
+            deps.Register<ILogManager, LogManager>();
+            deps.Register<IModLoader, ModLoader>();
+            deps.Register<IModLoaderInternal, ModLoader>();
+            deps.Register<INetManager, NetManager>();
+            deps.Register<IRobustSerializer, RobustSerializer>();
+            deps.Register<IRuntimeLog, RuntimeLog>();
+            deps.Register<ITaskManager, TaskManager>();
+            deps.Register<TaskManager, TaskManager>();
+            deps.Register<ITimerManager, TimerManager>();
+            deps.Register<ProfManager, ProfManager>();
+            deps.Register<IRobustRandom, RobustRandom>();
+            deps.Register<IRobustMappedStringSerializer, RobustMappedStringSerializer>();
+            deps.Register<ISandboxHelper, SandboxHelper>();
+            deps.Register<IManifoldManager, CollisionManager>();
+            deps.Register<IIslandManager, IslandManager>();
+            deps.Register<IVerticesSimplifier, RamerDouglasPeuckerSimplifier>();
+            deps.Register<IParallelManager, ParallelManager>();
+            deps.Register<IParallelManagerInternal, ParallelManager>();
         }
     }
 }

Robust.Shared/Timing/IGameTiming.cs

@@ -152,6 +152,12 @@ namespace Robust.Shared.Timing
 
         string TickStamp => $"{CurTick}, predFirst: {IsFirstTimePredicted}, tickRem: {TickRemainder.TotalSeconds}, sim: {InSimulation}";
 
+        /// <summary>
+        /// Statically-accessible version of <see cref="TickStamp"/>.
+        /// </summary>
+        /// <remarks>
+        /// This is intended as a debugging aid, and should not be used in regular committed code.
+        /// </remarks>
         static string TickStampStatic => IoCManager.Resolve<IGameTiming>().TickStamp;
 
         /// <summary>

Robust.UnitTesting/Client/UserInterface/Controls/LineEditTest.cs

@@ -19,12 +19,12 @@ namespace Robust.UnitTesting.Client.UserInterface.Controls
             var uiMgr = new Mock<IUserInterfaceManagerInternal>();
             var clyde = new ClydeHeadless();
 
-            IoCManager.InitThread();
-            IoCManager.Clear();
-            IoCManager.RegisterInstance<IUserInterfaceManagerInternal>(uiMgr.Object);
-            IoCManager.RegisterInstance<IUserInterfaceManager>(uiMgr.Object);
-            IoCManager.RegisterInstance<IClyde>(clyde);
-            IoCManager.BuildGraph();
+            var deps = IoCManager.InitThread();
+            deps.Clear();
+            deps.RegisterInstance<IUserInterfaceManagerInternal>(uiMgr.Object);
+            deps.RegisterInstance<IUserInterfaceManager>(uiMgr.Object);
+            deps.RegisterInstance<IClyde>(clyde);
+            deps.BuildGraph();
         }
 
         [Test]

Robust.UnitTesting/RobustIntegrationTest.cs

@@ -165,7 +165,7 @@ namespace Robust.UnitTesting
         {
             await instance.WaitPost(() =>
             {
-                var config = IoCManager.Resolve<IConfigurationManagerInternal>();
+                var config = instance.InstanceDependencyCollection.Resolve<IConfigurationManagerInternal>();
                 var overrides = new[]
                 {
                     (RTCVars.FailureLogLevel.Name, (instance.Options?.FailureLogLevel ?? RTCVars.FailureLogLevel.DefaultValue).ToString())
@@ -589,21 +589,22 @@ namespace Robust.UnitTesting
 
             private BaseServer Init()
             {
-                IoCManager.InitThread(DependencyCollection, replaceExisting: true);
-                ServerIoC.RegisterIoC();
-                IoCManager.Register<INetManager, IntegrationNetManager>(true);
-                IoCManager.Register<IServerNetManager, IntegrationNetManager>(true);
-                IoCManager.Register<IntegrationNetManager, IntegrationNetManager>(true);
-                IoCManager.Register<ISystemConsoleManager, SystemConsoleManagerDummy>(true);
-                IoCManager.Register<IModLoader, TestingModLoader>(true);
-                IoCManager.Register<IModLoaderInternal, TestingModLoader>(true);
-                IoCManager.Register<TestingModLoader, TestingModLoader>(true);
-                IoCManager.RegisterInstance<IStatusHost>(new Mock<IStatusHost>().Object, true);
-                IoCManager.Register<IRobustMappedStringSerializer, IntegrationMappedStringSerializer>(true);
+                var deps = DependencyCollection;
+                IoCManager.InitThread(deps, replaceExisting: true);
+                ServerIoC.RegisterIoC(deps);
+                deps.Register<INetManager, IntegrationNetManager>(true);
+                deps.Register<IServerNetManager, IntegrationNetManager>(true);
+                deps.Register<IntegrationNetManager, IntegrationNetManager>(true);
+                deps.Register<ISystemConsoleManager, SystemConsoleManagerDummy>(true);
+                deps.Register<IModLoader, TestingModLoader>(true);
+                deps.Register<IModLoaderInternal, TestingModLoader>(true);
+                deps.Register<TestingModLoader, TestingModLoader>(true);
+                deps.RegisterInstance<IStatusHost>(new Mock<IStatusHost>().Object, true);
+                deps.Register<IRobustMappedStringSerializer, IntegrationMappedStringSerializer>(true);
                 Options?.InitIoC?.Invoke();
-                IoCManager.BuildGraph();
+                deps.BuildGraph();
                 //ServerProgram.SetupLogging();
-                ServerProgram.InitReflectionManager();
+                ServerProgram.InitReflectionManager(deps);
 
                 var server = DependencyCollection.Resolve<BaseServer>();
 
@@ -619,17 +620,17 @@ namespace Robust.UnitTesting
                 Options?.BeforeRegisterComponents?.Invoke();
                 if (!Options?.ContentStart ?? true)
                 {
-                    var componentFactory = IoCManager.Resolve<IComponentFactory>();
+                    var componentFactory = deps.Resolve<IComponentFactory>();
                     componentFactory.DoAutoRegistrations();
                     componentFactory.GenerateNetIds();
                 }
 
                 if (Options?.ContentAssemblies != null)
                 {
-                    IoCManager.Resolve<TestingModLoader>().Assemblies = Options.ContentAssemblies;
+                    deps.Resolve<TestingModLoader>().Assemblies = Options.ContentAssemblies;
                 }
 
-                var cfg = IoCManager.Resolve<IConfigurationManagerInternal>();
+                var cfg = deps.Resolve<IConfigurationManagerInternal>();
 
                 cfg.LoadCVarsFromAssembly(typeof(RobustIntegrationTest).Assembly);
 
@@ -640,7 +641,7 @@ namespace Robust.UnitTesting
 
                     if (Options.ExtraPrototypes != null)
                     {
-                        IoCManager.Resolve<IResourceManagerInternal>()
+                        deps.Resolve<IResourceManagerInternal>()
                             .MountString("/Prototypes/__integration_extra.yml", Options.ExtraPrototypes);
                     }
                 }
@@ -750,19 +751,20 @@ namespace Robust.UnitTesting
 
             private GameController Init()
             {
-                IoCManager.InitThread(DependencyCollection, replaceExisting: true);
-                ClientIoC.RegisterIoC(GameController.DisplayMode.Headless);
-                IoCManager.Register<INetManager, IntegrationNetManager>(true);
-                IoCManager.Register<IClientNetManager, IntegrationNetManager>(true);
-                IoCManager.Register<IntegrationNetManager, IntegrationNetManager>(true);
-                IoCManager.Register<IModLoader, TestingModLoader>(true);
-                IoCManager.Register<IModLoaderInternal, TestingModLoader>(true);
-                IoCManager.Register<TestingModLoader, TestingModLoader>(true);
-                IoCManager.Register<IRobustMappedStringSerializer, IntegrationMappedStringSerializer>(true);
+                var deps = DependencyCollection;
+                IoCManager.InitThread(deps, replaceExisting: true);
+                ClientIoC.RegisterIoC(GameController.DisplayMode.Headless, deps);
+                deps.Register<INetManager, IntegrationNetManager>(true);
+                deps.Register<IClientNetManager, IntegrationNetManager>(true);
+                deps.Register<IntegrationNetManager, IntegrationNetManager>(true);
+                deps.Register<IModLoader, TestingModLoader>(true);
+                deps.Register<IModLoaderInternal, TestingModLoader>(true);
+                deps.Register<TestingModLoader, TestingModLoader>(true);
+                deps.Register<IRobustMappedStringSerializer, IntegrationMappedStringSerializer>(true);
                 Options?.InitIoC?.Invoke();
-                IoCManager.BuildGraph();
+                deps.BuildGraph();
 
-                GameController.RegisterReflection();
+                GameController.RegisterReflection(deps);
 
                 var client = DependencyCollection.Resolve<GameController>();
 
@@ -778,17 +780,17 @@ namespace Robust.UnitTesting
                 Options?.BeforeRegisterComponents?.Invoke();
                 if (!Options?.ContentStart ?? true)
                 {
-                    var componentFactory = IoCManager.Resolve<IComponentFactory>();
+                    var componentFactory = deps.Resolve<IComponentFactory>();
                     componentFactory.DoAutoRegistrations();
                     componentFactory.GenerateNetIds();
                 }
 
                 if (Options?.ContentAssemblies != null)
                 {
-                    IoCManager.Resolve<TestingModLoader>().Assemblies = Options.ContentAssemblies;
+                    deps.Resolve<TestingModLoader>().Assemblies = Options.ContentAssemblies;
                 }
 
-                var cfg = IoCManager.Resolve<IConfigurationManagerInternal>();
+                var cfg = deps.Resolve<IConfigurationManagerInternal>();
 
                 cfg.LoadCVarsFromAssembly(typeof(RobustIntegrationTest).Assembly);
 
@@ -799,7 +801,7 @@ namespace Robust.UnitTesting
 
                     if (Options.ExtraPrototypes != null)
                     {
-                        IoCManager.Resolve<IResourceManagerInternal>()
+                        deps.Resolve<IResourceManagerInternal>()
                             .MountString("/Prototypes/__integration_extra.yml", Options.ExtraPrototypes);
                     }
                 }

Robust.UnitTesting/RobustUnitTest.IoC.cs

@@ -13,27 +13,29 @@ namespace Robust.UnitTesting
         /// </summary>
         private void RegisterIoC()
         {
+            var dependencies = IoCManager.Instance!;
+
             switch (Project)
             {
                 case UnitTestProject.Client:
-                    ClientIoC.RegisterIoC(GameController.DisplayMode.Headless);
+                    ClientIoC.RegisterIoC(GameController.DisplayMode.Headless, dependencies);
                     break;
 
                 case UnitTestProject.Server:
-                    ServerIoC.RegisterIoC();
+                    ServerIoC.RegisterIoC(dependencies);
                     break;
 
                 default:
                     throw new NotSupportedException($"Unknown testing project: {Project}");
             }
 
-            IoCManager.Register<IModLoader, TestingModLoader>(overwrite: true);
-            IoCManager.Register<IModLoaderInternal, TestingModLoader>(overwrite: true);
-            IoCManager.Register<TestingModLoader, TestingModLoader>(overwrite: true);
+            dependencies.Register<IModLoader, TestingModLoader>(overwrite: true);
+            dependencies.Register<IModLoaderInternal, TestingModLoader>(overwrite: true);
+            dependencies.Register<TestingModLoader, TestingModLoader>(overwrite: true);
 
             OverrideIoC();
 
-            IoCManager.BuildGraph();
+            dependencies.BuildGraph();
         }
     }
 }

Robust.UnitTesting/RobustUnitTest.cs

@@ -40,8 +40,8 @@ namespace Robust.UnitTesting
         public void BaseSetup()
         {
             // Clear state across tests.
-            IoCManager.InitThread();
-            IoCManager.Clear();
+            var deps = IoCManager.InitThread();
+            deps.Clear();
 
             RegisterIoC();
 
@@ -61,7 +61,7 @@ namespace Robust.UnitTesting
             assemblies.Add(AppDomain.CurrentDomain.GetAssemblyByName("Robust.Shared"));
             assemblies.Add(Assembly.GetExecutingAssembly());
 
-            var configurationManager = IoCManager.Resolve<IConfigurationManagerInternal>();
+            var configurationManager = deps.Resolve<IConfigurationManagerInternal>();
 
             configurationManager.Initialize(Project == UnitTestProject.Server);
 
@@ -79,7 +79,7 @@ namespace Robust.UnitTesting
 
             configurationManager.LoadCVarsFromAssembly(typeof(RobustUnitTest).Assembly);
 
-            var systems = IoCManager.Resolve<IEntitySystemManager>();
+            var systems = deps.Resolve<IEntitySystemManager>();
             // Required systems
             systems.LoadExtraSystemType<EntityLookupSystem>();
 
@@ -99,6 +99,7 @@ namespace Robust.UnitTesting
                 systems.LoadExtraSystemType<Robust.Client.Physics.PhysicsSystem>();
                 systems.LoadExtraSystemType<Robust.Client.Debugging.DebugRayDrawingSystem>();
                 systems.LoadExtraSystemType<PrototypeReloadSystem>();
+                systems.LoadExtraSystemType<Robust.Client.Debugging.DebugPhysicsSystem>();
             }
             else
             {
@@ -111,13 +112,14 @@ namespace Robust.UnitTesting
                 systems.LoadExtraSystemType<PhysicsSystem>();
                 systems.LoadExtraSystemType<DebugRayDrawingSystem>();
                 systems.LoadExtraSystemType<PrototypeReloadSystem>();
+                systems.LoadExtraSystemType<DebugPhysicsSystem>();
             }
 
-            var entMan = IoCManager.Resolve<IEntityManager>();
-            var mapMan = IoCManager.Resolve<IMapManager>();
+            var entMan = deps.Resolve<IEntityManager>();
+            var mapMan = deps.Resolve<IMapManager>();
 
             // Required components for the engine to work
-            var compFactory = IoCManager.Resolve<IComponentFactory>();
+            var compFactory = deps.Resolve<IComponentFactory>();
 
             if (!compFactory.AllRegisteredTypes.Contains(typeof(MapComponent)))
             {
@@ -163,9 +165,9 @@ namespace Robust.UnitTesting
             mapMan.Initialize();
             systems.Initialize();
 
-            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
+            deps.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
 
-            var modLoader = IoCManager.Resolve<TestingModLoader>();
+            var modLoader = deps.Resolve<TestingModLoader>();
             modLoader.Assemblies = contentAssemblies;
             modLoader.TryLoadModulesFrom(ResourcePath.Root, "");
 

Robust.UnitTesting/Server/RobustServerSimulation.cs

@@ -4,6 +4,7 @@ using System.Reflection;
 using JetBrains.Annotations;
 using Moq;
 using Robust.Server;
+using Robust.Server.Console;
 using Robust.Server.Debugging;
 using Robust.Server.Containers;
 using Robust.Server.GameObjects;
@@ -220,6 +221,8 @@ namespace Robust.UnitTesting.Server
             container.Register<INetManager, NetManager>();
             container.Register<IAuthManager, AuthManager>();
             container.Register<ITileDefinitionManager, TileDefinitionManager>();
+            // Needed for grid fixture debugging.
+            container.Register<IConGroupController, ConGroupController>();
 
             // I just wanted to load pvs system
             container.Register<IServerEntityManager, ServerEntityManager>();