Make DOOM work

I think I lost this work originally

Robust.Benchmarks/Serialization/Copy/SerializationCopyBenchmark.cs

@@ -1,44 +1,21 @@
-using System;
-using System.IO;
+using System.IO;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
 using Robust.Benchmarks.Serialization.Definitions;
-using Robust.Server;
-using Robust.Shared.Configuration;
-using Robust.Shared.ContentPack;
-using Robust.Shared.IoC;
-using Robust.Shared.Reflection;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
 using Robust.Shared.Utility;
 using YamlDotNet.RepresentationModel;
 
 namespace Robust.Benchmarks.Serialization.Copy
 {
-    public class SerializationCopyBenchmark
+    public class SerializationCopyBenchmark : SerializationBenchmark
     {
         public SerializationCopyBenchmark()
         {
-            IoCManager.InitThread();
-            ServerIoC.RegisterIoC();
-            IoCManager.BuildGraph();
-
-            var assemblies = new[]
-            {
-                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Shared"),
-                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Server"),
-                AppDomain.CurrentDomain.GetAssemblyByName("Robust.Benchmarks")
-            };
-
-            foreach (var assembly in assemblies)
-            {
-                IoCManager.Resolve<IConfigurationManagerInternal>().LoadCVarsFromAssembly(assembly);
-            }
-
-            IoCManager.Resolve<IReflectionManager>().LoadAssemblies(assemblies);
-
-            SerializationManager = IoCManager.Resolve<ISerializationManager>();
-            SerializationManager.Initialize();
+            InitializeSerialization();
 
             DataDefinitionWithString = new DataDefinitionWithString {StringField = "ABC"};
 
@@ -50,8 +27,6 @@ namespace Robust.Benchmarks.Serialization.Copy
             Seed = SerializationManager.ReadValueOrThrow<SeedDataDefinition>(seedMapping);
         }
 
-        private ISerializationManager SerializationManager { get; }
-
         private const string String = "ABC";
 
         private const int Integer = 1;

Robust.Benchmarks/Serialization/Definitions/SeedDataDefinition.cs

@@ -6,6 +6,10 @@ using Robust.Shared.Utility;
 
 namespace Robust.Benchmarks.Serialization.Definitions
 {
+    /// <summary>
+    ///     Arbitrarily large data definition for benchmarks.
+    ///     Taken from content.
+    /// </summary>
     [Prototype("seed")]
     public class SeedDataDefinition : IPrototype
     {
@@ -96,13 +100,15 @@ namespace Robust.Benchmarks.Serialization.Definitions
         Repeat
     }
 
-    public enum Gas {}
+    public enum Gas
+    {
+    }
 
     [DataDefinition]
     public struct SeedChemQuantity
     {
         [DataField("Min")]
-        public int Min { get; }
+        public int Min;
 
         [DataField("Max")]
         public int Max;

Robust.Benchmarks/Serialization/Read/SerializationReadBenchmark.cs

@@ -2,6 +2,9 @@
 using BenchmarkDotNet.Attributes;
 using Robust.Benchmarks.Serialization.Definitions;
 using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.Markdown.Value;
 using YamlDotNet.RepresentationModel;
 
 namespace Robust.Benchmarks.Serialization.Read
@@ -13,7 +16,7 @@ namespace Robust.Benchmarks.Serialization.Read
             InitializeSerialization();
 
             StringDataDefNode = new MappingDataNode();
-            StringDataDefNode.AddNode(new ValueDataNode("string"), new ValueDataNode("ABC"));
+            StringDataDefNode.Add(new ValueDataNode("string"), new ValueDataNode("ABC"));
 
             var yamlStream = new YamlStream();
             yamlStream.Load(new StringReader(SeedDataDefinition.Prototype));

Robust.Benchmarks/Serialization/Write/SerializationWriteBenchmark.cs

@@ -0,0 +1,98 @@
+using System.Globalization;
+using System.IO;
+using BenchmarkDotNet.Attributes;
+using Robust.Benchmarks.Serialization.Definitions;
+using Robust.Shared.Serialization.Manager;
+using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Sequence;
+using Robust.Shared.Serialization.Markdown.Value;
+using YamlDotNet.RepresentationModel;
+
+namespace Robust.Benchmarks.Serialization.Write
+{
+    public class SerializationWriteBenchmark : SerializationBenchmark
+    {
+        public SerializationWriteBenchmark()
+        {
+            InitializeSerialization();
+
+            DataDefinitionWithString = new DataDefinitionWithString {StringField = "ABC"};
+
+            var yamlStream = new YamlStream();
+            yamlStream.Load(new StringReader(SeedDataDefinition.Prototype));
+
+            var seedMapping = yamlStream.Documents[0].RootNode.ToDataNodeCast<SequenceDataNode>().Cast<MappingDataNode>(0);
+
+            Seed = SerializationManager.ReadValueOrThrow<SeedDataDefinition>(seedMapping);
+        }
+
+        private const string String = "ABC";
+
+        private const int Integer = 1;
+
+        private DataDefinitionWithString DataDefinitionWithString { get; }
+
+        private SeedDataDefinition Seed { get; }
+
+        [Benchmark]
+        public DataNode WriteString()
+        {
+            return SerializationManager.WriteValue(String);
+        }
+
+        [Benchmark]
+        public DataNode WriteInteger()
+        {
+            return SerializationManager.WriteValue(Integer);
+        }
+
+        [Benchmark]
+        public DataNode WriteDataDefinitionWithString()
+        {
+            return SerializationManager.WriteValue(DataDefinitionWithString);
+        }
+
+        [Benchmark]
+        public DataNode WriteSeedDataDefinition()
+        {
+            return SerializationManager.WriteValue(Seed);
+        }
+
+        [Benchmark]
+        public DataNode BaselineWriteSeedDataDefinition()
+        {
+            var mapping = new MappingDataNode();
+
+            mapping.Add("id", Seed.ID);
+            mapping.Add("name", Seed.Name);
+            mapping.Add("seedName", Seed.SeedName);
+            mapping.Add("displayName", Seed.DisplayName);
+            mapping.Add("productPrototypes", Seed.ProductPrototypes);
+            mapping.Add("harvestRepeat", Seed.HarvestRepeat.ToString());
+            mapping.Add("lifespan", Seed.Lifespan.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("maturation", Seed.Maturation.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("production", Seed.Production.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("yield", Seed.Yield.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("potency", Seed.Potency.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("growthStages", Seed.GrowthStages.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("idealLight", Seed.IdealLight.ToString(CultureInfo.InvariantCulture));
+            mapping.Add("idealHeat", Seed.IdealHeat.ToString(CultureInfo.InvariantCulture));
+
+            var chemicals = new MappingDataNode();
+            foreach (var (name, quantity) in Seed.Chemicals)
+            {
+                chemicals.Add(name, new MappingDataNode
+                {
+                    ["Min"] = new ValueDataNode(quantity.Min.ToString(CultureInfo.InvariantCulture)),
+                    ["Max"] = new ValueDataNode(quantity.Max.ToString(CultureInfo.InvariantCulture)),
+                    ["PotencyDivisor"] = new ValueDataNode(quantity.PotencyDivisor.ToString(CultureInfo.InvariantCulture))
+                });
+            }
+
+            mapping.Add("chemicals", chemicals);
+
+            return mapping;
+        }
+    }
+}

Robust.Client.NameGenerator/XamlUiPartialClassGenerator.cs

@@ -247,7 +247,6 @@ namespace {nameSpace}
                                 DiagnosticSeverity.Error,
                                 true),
                             Location.None));
-                    return null;
                 }
             }
 

Robust.Client/Audio/Midi/MidiManager.cs

@@ -11,9 +11,11 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
+using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 using Robust.Shared.Physics.Broadphase;
 using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
 using Logger = Robust.Shared.Log.Logger;
 
 namespace Robust.Client.Audio.Midi
@@ -32,24 +34,6 @@ namespace Robust.Client.Audio.Midi
         /// </returns>
         IMidiRenderer? GetNewRenderer();
 
-        /*
-        /// <summary>
-        ///     Checks whether the file at the given path is a valid midi file or not.
-        /// </summary>
-        /// <remarks>
-        ///     We add this here so content doesn't need to reference NFluidsynth.
-        /// </remarks>
-        bool IsMidiFile(string filename);
-
-        /// <summary>
-        ///     Checks whether the file at the given path is a valid midi file or not.
-        /// </summary>
-        /// <remarks>
-        ///     We add this here so content doesn't need to reference NFluidsynth.
-        /// </remarks>
-        bool IsSoundfontFile(string filename);
-        */
-
         /// <summary>
         ///     Method called every frame.
         ///     Should be used to update positional audio.
@@ -57,6 +41,11 @@ namespace Robust.Client.Audio.Midi
         /// <param name="frameTime"></param>
         void FrameUpdate(float frameTime);
 
+        /// <summary>
+        ///     Volume, in db.
+        /// </summary>
+        float Volume { get; set; }
+
         /// <summary>
         ///     If true, MIDI support is available.
         /// </summary>
@@ -75,6 +64,7 @@ namespace Robust.Client.Audio.Midi
 
         private SharedBroadPhaseSystem _broadPhaseSystem = default!;
 
+        [ViewVariables]
         public bool IsAvailable
         {
             get
@@ -85,12 +75,29 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
-        private readonly List<MidiRenderer> _renderers = new();
+        [ViewVariables]
+        private readonly List<IMidiRenderer> _renderers = new();
 
         private bool _alive = true;
         private Settings? _settings;
         private Thread? _midiThread;
         private ISawmill _midiSawmill = default!;
+        private float _volume = 0f;
+        private bool _volumeDirty = true;
+
+        [ViewVariables(VVAccess.ReadWrite)]
+        public float Volume
+        {
+            get => _volume;
+            set
+            {
+                if (MathHelper.CloseTo(_volume, value))
+                    return;
+
+                _volume = value;
+                _volumeDirty = true;
+            }
+        }
 
         private static readonly string[] LinuxSoundfonts =
         {
@@ -117,6 +124,7 @@ namespace Robust.Client.Audio.Midi
         private NFluidsynth.Logger.LoggerDelegate _loggerDelegate = default!;
         private ISawmill _sawmill = default!;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public int OcclusionCollisionMask { get; set; }
 
         private void InitializeFluidsynth()
@@ -175,18 +183,6 @@ namespace Robust.Client.Audio.Midi
             _sawmill.Log(rLevel, message);
         }
 
-        /*
-        public bool IsMidiFile(string filename)
-        {
-            return SoundFont.IsMidiFile(filename);
-        }
-
-        public bool IsSoundfontFile(string filename)
-        {
-            return SoundFont.IsSoundFont(filename);
-        }
-        */
-
         public IMidiRenderer? GetNewRenderer()
         {
             if (!FluidsynthInitialized)
@@ -250,7 +246,9 @@ namespace Robust.Client.Audio.Midi
                 }
 
                 lock (_renderers)
+                {
                     _renderers.Add(renderer);
+                }
 
                 return renderer;
             }
@@ -268,74 +266,79 @@ namespace Robust.Client.Audio.Midi
             }
 
             // Update positions of streams every frame.
-            lock (_renderers)
-                foreach (var renderer in _renderers)
+            foreach (var renderer in _renderers)
+            {
+                if (renderer.Disposed)
+                    continue;
+
+                if(_volumeDirty)
+                    renderer.Source.SetVolume(Volume);
+
+                if (!renderer.Mono)
                 {
-                    if (renderer.Disposed)
-                        continue;
-
-                    if (!renderer.Mono)
-                    {
-                        renderer.Source.SetGlobal();
-                        continue;
-                    }
-
-                    MapCoordinates? mapPos = null;
-                    if (renderer.TrackingCoordinates != null)
-                    {
-                        mapPos = renderer.TrackingCoordinates.Value.ToMap(_entityManager);
-                    }
-                    else if (renderer.TrackingEntity != null)
-                    {
-                        mapPos = renderer.TrackingEntity.Transform.MapPosition;
-                    }
-
-                    if (mapPos != null)
-                    {
-                        var pos = mapPos.Value;
-                        if (pos.MapId != _eyeManager.CurrentMap)
-                        {
-                            renderer.Source.SetVolume(-10000000);
-                        }
-                        else
-                        {
-                            var sourceRelative = _eyeManager.CurrentEye.Position.Position - pos.Position;
-                            var occlusion = 0f;
-                            if (sourceRelative.Length > 0)
-                            {
-                                occlusion = _broadPhaseSystem.IntersectRayPenetration(
-                                    pos.MapId,
-                                    new CollisionRay(
-                                        pos.Position,
-                                        sourceRelative.Normalized,
-                                        OcclusionCollisionMask),
-                                    sourceRelative.Length,
-                                    renderer.TrackingEntity);
-                            }
-                            renderer.Source.SetOcclusion(occlusion);
-                        }
-
-                        if (renderer.Source.SetPosition(pos.Position))
-                        {
-                            continue;
-                        }
-
-                        if (renderer.TrackingEntity != null)
-                        {
-                            renderer.Source.SetVelocity(renderer.TrackingEntity.GlobalLinearVelocity());
-                        }
-
-                        if (float.IsNaN(pos.Position.X) || float.IsNaN(pos.Position.Y))
-                        {
-                            // just duck out instead of move to NaN
-                            renderer.Source.SetOcclusion(float.MaxValue);
-                            continue;
-                        }
-
-                        _midiSawmill?.Warning("Interrupting positional audio, can't set position.");
-                        renderer.Source.StopPlaying();
-                    }
+                    renderer.Source.SetGlobal();
+                    continue;
                 }
+
+                MapCoordinates? mapPos = null;
+                if (renderer.TrackingCoordinates != null)
+                {
+                    mapPos = renderer.TrackingCoordinates.Value.ToMap(_entityManager);
+                }
+                else if (renderer.TrackingEntity != null)
+                {
+                    mapPos = renderer.TrackingEntity.Transform.MapPosition;
+                }
+
+                if (mapPos != null)
+                {
+                    var pos = mapPos.Value;
+                    if (pos.MapId != _eyeManager.CurrentMap)
+                    {
+                        renderer.Source.SetVolume(-10000000);
+                    }
+                    else
+                    {
+                        var sourceRelative = _eyeManager.CurrentEye.Position.Position - pos.Position;
+                        var occlusion = 0f;
+                        if (sourceRelative.Length > 0)
+                        {
+                            occlusion = _broadPhaseSystem.IntersectRayPenetration(
+                                pos.MapId,
+                                new CollisionRay(
+                                    pos.Position,
+                                    sourceRelative.Normalized,
+                                    OcclusionCollisionMask),
+                                sourceRelative.Length,
+                                renderer.TrackingEntity);
+                        }
+
+                        renderer.Source.SetOcclusion(occlusion);
+                    }
+
+                    if (renderer.Source.SetPosition(pos.Position))
+                    {
+                        continue;
+                    }
+
+                    if (renderer.TrackingEntity != null)
+                    {
+                        renderer.Source.SetVelocity(renderer.TrackingEntity.GlobalLinearVelocity());
+                    }
+
+                    if (float.IsNaN(pos.Position.X) || float.IsNaN(pos.Position.Y))
+                    {
+                        // just duck out instead of move to NaN
+                        renderer.Source.SetOcclusion(float.MaxValue);
+                        continue;
+                    }
+
+                    _midiSawmill?.Warning("Interrupting positional audio, can't set position.");
+                    renderer.Source.StopPlaying();
+                }
+            }
+
+            _volumeDirty = false;
         }
 
         /// <summary>
@@ -346,6 +349,7 @@ namespace Robust.Client.Audio.Midi
             while (_alive)
             {
                 lock (_renderers)
+                {
                     for (var i = 0; i < _renderers.Count; i++)
                     {
                         var renderer = _renderers[i];
@@ -353,10 +357,11 @@ namespace Robust.Client.Audio.Midi
                             renderer.Render();
                         else
                         {
-                            ((IMidiRenderer)renderer).InternalDispose();
+                            renderer.InternalDispose();
                             _renderers.Remove(renderer);
                         }
                     }
+                }
 
                 Thread.Sleep(1);
             }
@@ -367,9 +372,13 @@ namespace Robust.Client.Audio.Midi
             _alive = false;
             _midiThread?.Join();
             _settings?.Dispose();
-            foreach (var renderer in _renderers)
+
+            lock (_renderers)
             {
-                renderer?.Dispose();
+                foreach (var renderer in _renderers)
+                {
+                    renderer?.Dispose();
+                }
             }
 
             if (FluidsynthInitialized && !_failedInitialize)
@@ -424,6 +433,7 @@ namespace Robust.Client.Audio.Midi
                 var span = new Span<byte>(buf.ToPointer(), length);
                 var stream = _openStreams[(int) sfHandle];
 
+                // Fluidsynth's docs state that this method should leave the buffer unmodified if it fails. (returns -1)
                 try
                 {
                     // Fluidsynth does a LOT of tiny allocations (frankly, way too much).
@@ -447,6 +457,7 @@ namespace Robust.Client.Audio.Midi
                 {
                     return -1;
                 }
+
                 return 0;
             }
 
@@ -468,10 +479,12 @@ namespace Robust.Client.Audio.Midi
 
             public override int Close(IntPtr sfHandle)
             {
-                var stream = _openStreams[(int) sfHandle];
+                if (!_openStreams.Remove((int) sfHandle, out var stream))
+                    return -1;
+
                 stream.Dispose();
-                _openStreams.Remove((int) sfHandle);
                 return 0;
+
             }
         }
     }

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -8,6 +8,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
 using MidiEvent = NFluidsynth.MidiEvent;
 
 namespace Robust.Client.Audio.Midi
@@ -21,6 +22,17 @@ namespace Robust.Client.Audio.Midi
 
     public interface IMidiRenderer : IDisposable
     {
+
+        /// <summary>
+        ///     The buffered audio source of this renderer.
+        /// </summary>
+        internal IClydeBufferedAudioSource Source { get; }
+
+        /// <summary>
+        ///     Whether this renderer has been disposed or not.
+        /// </summary>
+        bool Disposed { get; }
+
         /// <summary>
         ///     This controls whether the midi file being played will loop or not.
         /// </summary>
@@ -110,6 +122,11 @@ namespace Robust.Client.Audio.Midi
         /// </summary>
         void StopAllNotes();
 
+        /// <summary>
+        ///     Render and play MIDI to the audio source.
+        /// </summary>
+        internal void Render();
+
         /// <summary>
         ///     Loads a new soundfont into the renderer.
         /// </summary>
@@ -159,7 +176,7 @@ namespace Robust.Client.Audio.Midi
         internal void InternalDispose();
     }
 
-    public class MidiRenderer : IMidiRenderer
+    internal class MidiRenderer : IMidiRenderer
     {
         [Dependency] private readonly IClydeAudio _clydeAudio = default!;
         [Dependency] private readonly ITaskManager _taskManager = default!;
@@ -188,8 +205,12 @@ namespace Robust.Client.Audio.Midi
         private readonly object _playerStateLock = new();
         private SequencerClientId _synthRegister;
         public IClydeBufferedAudioSource Source { get; set; }
+        IClydeBufferedAudioSource IMidiRenderer.Source => Source;
+
+        [ViewVariables]
         public bool Disposed { get; private set; } = false;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public byte MidiProgram
         {
             get => _midiProgram;
@@ -203,6 +224,7 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public byte MidiBank
         {
             get => _midiBank;
@@ -216,6 +238,7 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public uint MidiSoundfont
         {
             get => _midiSoundfont;
@@ -229,10 +252,16 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool DisablePercussionChannel { get; set; } = true;
+
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool DisableProgramChangeEvent { get; set; } = true;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public int PlayerTotalTick => _player?.GetTotalTicks ?? 0;
+
+        [ViewVariables(VVAccess.ReadWrite)]
         public int PlayerTick
         {
             get => _player?.CurrentTick ?? 0;
@@ -243,12 +272,19 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public uint SequencerTick => _sequencer?.Tick ?? 0;
+
+        [ViewVariables(VVAccess.ReadWrite)]
         public double SequencerTimeScale => _sequencer?.TimeScale ?? 0;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool Mono { get; set; }
+
+        [ViewVariables]
         public MidiRendererStatus Status { get; private set; } = MidiRendererStatus.None;
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public bool LoopMidi
         {
             get => _loopMidi;
@@ -260,10 +296,11 @@ namespace Robust.Client.Audio.Midi
             }
         }
 
+        [ViewVariables(VVAccess.ReadWrite)]
         public IEntity? TrackingEntity { get; set; } = null;
-        public EntityCoordinates? TrackingCoordinates { get; set; } = null;
 
-        internal bool Free { get; set; } = false;
+        [ViewVariables(VVAccess.ReadWrite)]
+        public EntityCoordinates? TrackingCoordinates { get; set; } = null;
 
         internal MidiRenderer(Settings settings, SoundFontLoader soundFontLoader, bool mono = true)
         {
@@ -294,7 +331,11 @@ namespace Robust.Client.Audio.Midi
             Status = MidiRendererStatus.Input;
             StopAllNotes();
 
-            _driver = new MidiDriver(_settings, MidiDriverEventHandler);
+            lock (_playerStateLock)
+            {
+                _driver = new MidiDriver(_settings, MidiDriverEventHandler);
+            }
+
             return true;
         }
 
@@ -332,8 +373,13 @@ namespace Robust.Client.Audio.Midi
         {
             if (Status != MidiRendererStatus.Input) return false;
             Status = MidiRendererStatus.None;
-            _driver?.Dispose();
-            _driver = null;
+
+            lock (_playerStateLock)
+            {
+                _driver?.Dispose();
+                _driver = null;
+            }
+
             StopAllNotes();
             return true;
         }
@@ -357,7 +403,8 @@ namespace Robust.Client.Audio.Midi
 
         public void StopAllNotes()
         {
-            _synth.AllNotesOff(-1);
+            lock(_playerStateLock)
+                _synth.AllNotesOff(-1);
         }
 
         public void LoadSoundfont(string filename, bool resetPresets = false)
@@ -372,7 +419,12 @@ namespace Robust.Client.Audio.Midi
         public event Action<Shared.Audio.Midi.MidiEvent>? OnMidiEvent;
         public event Action? OnMidiPlayerFinished;
 
-        internal void Render(int length = SampleRate / 250)
+        void IMidiRenderer.Render()
+        {
+            Render();
+        }
+
+        private void Render(int length = SampleRate / 250)
         {
             if (Disposed) return;
 
@@ -452,6 +504,7 @@ namespace Robust.Client.Audio.Midi
             var timestamp = SequencerTick;
             var midiEv = (Shared.Audio.Midi.MidiEvent) midiEvent;
             midiEv.Tick = timestamp;
+            midiEvent.Dispose();
             SendMidiEvent(midiEv);
             return 0;
         }
@@ -462,6 +515,7 @@ namespace Robust.Client.Audio.Midi
             var timestamp = SequencerTick;
             var midiEv = (Shared.Audio.Midi.MidiEvent) midiEvent;
             midiEv.Tick = timestamp;
+            midiEvent.Dispose();
             SendMidiEvent(midiEv);
             return 0;
         }

Robust.Client/BaseClient.cs

@@ -13,6 +13,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
 using Robust.Shared.Network;
+using Robust.Shared.Players;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -25,6 +26,7 @@ namespace Robust.Client
         [Dependency] private readonly IPlayerManager _playMan = default!;
         [Dependency] private readonly INetConfigurationManager _configManager = default!;
         [Dependency] private readonly IClientEntityManager _entityManager = default!;
+        [Dependency] private readonly IEntityLookup _entityLookup = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
         [Dependency] private readonly IDiscordRichPresence _discord = default!;
         [Dependency] private readonly IGameTiming _timing = default!;
@@ -165,7 +167,7 @@ namespace Robust.Client
         ///     receiving states when they join the lobby.
         /// </summary>
         /// <param name="session">Session of the player.</param>
-        private void OnPlayerJoinedServer(IPlayerSession session)
+        private void OnPlayerJoinedServer(ICommonSession session)
         {
             DebugTools.Assert(RunLevel < ClientRunLevel.Connected);
             OnRunLevelChanged(ClientRunLevel.Connected);
@@ -175,20 +177,11 @@ namespace Robust.Client
             PlayerJoinedServer?.Invoke(this, new PlayerEventArgs(session));
         }
 
-        private void GameStartedSetup()
-        {
-            _entityManager.Startup();
-            _mapManager.Startup();
-
-            _timing.ResetSimTime();
-            _timing.Paused = false;
-        }
-
         /// <summary>
         ///     Player is joining the game
         /// </summary>
         /// <param name="session">Session of the player.</param>
-        private void OnPlayerJoinedGame(IPlayerSession session)
+        private void OnPlayerJoinedGame(ICommonSession session)
         {
             DebugTools.Assert(RunLevel >= ClientRunLevel.Connected);
             OnRunLevelChanged(ClientRunLevel.InGame);
@@ -218,12 +211,22 @@ namespace Robust.Client
             GameStoppedReset();
         }
 
+        private void GameStartedSetup()
+        {
+            _entityManager.Startup();
+            _mapManager.Startup();
+            _entityLookup.Startup();
+
+            _timing.ResetSimTime();
+            _timing.Paused = false;
+        }
+
         private void GameStoppedReset()
         {
             IoCManager.Resolve<INetConfigurationManager>().FlushMessages();
             _gameStates.Reset();
             _playMan.Shutdown();
-            IoCManager.Resolve<IEntityLookup>().Shutdown();
+            _entityLookup.Shutdown();
             _entityManager.Shutdown();
             _mapManager.Shutdown();
             _discord.ClearPresence();
@@ -295,12 +298,12 @@ namespace Robust.Client
         /// <summary>
         ///     The session that triggered the event.
         /// </summary>
-        private IPlayerSession? Session { get; }
+        private ICommonSession? Session { get; }
 
         /// <summary>
         ///     Constructs a new instance of the class.
         /// </summary>
-        public PlayerEventArgs(IPlayerSession? session)
+        public PlayerEventArgs(ICommonSession? session)
         {
             Session = session;
         }

Robust.Client/ClientIoC.cs

@@ -45,7 +45,7 @@ namespace Robust.Client
             IoCManager.Register<IMapManagerInternal, ClientMapManager>();
             IoCManager.Register<IClientMapManager, ClientMapManager>();
             IoCManager.Register<IEntityManager, ClientEntityManager>();
-            IoCManager.Register<IEntityLookup, SharedEntityLookup>();
+            IoCManager.Register<IEntityLookup, EntityLookup>();
             IoCManager.Register<IComponentFactory, ClientComponentFactory>();
             IoCManager.Register<ITileDefinitionManager, ClydeTileDefinitionManager>();
             IoCManager.Register<IClydeTileDefinitionManager, ClydeTileDefinitionManager>();

Robust.Client/Console/Commands/MonitorCommands.cs

@@ -25,6 +25,34 @@ namespace Robust.Client.Console.Commands
         }
     }
 
+    [UsedImplicitly]
+    public sealed class MonitorInfoCommand : IConsoleCommand
+    {
+        public string Command => "monitorinfo";
+        public string Description => "";
+        public string Help => "Usage: monitorinfo <id>";
+
+        public void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            if (args.Length < 1)
+            {
+                shell.WriteError("Expected one argument.");
+                return;
+            }
+
+            var clyde = IoCManager.Resolve<IClyde>();
+            var monitor = clyde.EnumerateMonitors().Single(c => c.Id == int.Parse(args[0]));
+
+            shell.WriteLine($"{monitor.Id}: {monitor.Name}");
+            shell.WriteLine($"Video modes:");
+
+            foreach (var mode in monitor.VideoModes)
+            {
+                shell.WriteLine($"  {mode.Width}x{mode.Height} {mode.RefreshRate} Hz {mode.RedBits}/{mode.GreenBits}/{mode.BlueBits}");
+            }
+        }
+    }
+
     [UsedImplicitly]
     public sealed class SetMonitorCommand : IConsoleCommand
     {

Robust.Client/Console/ScriptClient.cs

@@ -30,7 +30,8 @@ namespace Robust.Client.Console
 
             var console = new ScriptConsoleServer(this, session);
             _activeConsoles.Add(session, console);
-            console.Open();
+            // FIXME: When this is Open(), resizing the window will cause its position to get NaN'd.
+            console.OpenCentered();
         }
 
         private void ReceiveScriptResponse(MsgScriptResponse message)

Robust.Client/GameController/GameController.cs

@@ -93,7 +93,7 @@ namespace Robust.Client
             // Disable load context usage on content start.
             // This prevents Content.Client being loaded twice and things like csi blowing up because of it.
             _modLoader.SetUseLoadContext(!ContentStart);
-            _modLoader.SetEnableSandboxing(Options.Sandboxing);
+            _modLoader.SetEnableSandboxing(false && Options.Sandboxing);
 
             if (!_modLoader.TryLoadModulesFrom(new ResourcePath("/Assemblies/"), Options.ContentModulePrefix))
             {
@@ -125,7 +125,6 @@ namespace Robust.Client
             _prototypeManager.Resync();
             _mapManager.Initialize();
             _entityManager.Initialize();
-            IoCManager.Resolve<IEntityLookup>().Initialize();
             _gameStateManager.Initialize();
             _placementManager.Initialize();
             _viewVariablesManager.Initialize();

Robust.Client/GameObjects/ClientComponentFactory.cs

@@ -9,58 +9,30 @@ namespace Robust.Client.GameObjects
         public ClientComponentFactory()
         {
             // Required for the engine to work
-            Register<MetaDataComponent>();
-            RegisterReference<MetaDataComponent, IMetaDataComponent>();
-
-            // Required for the engine to work
-            Register<TransformComponent>();
-            RegisterReference<TransformComponent, ITransformComponent>();
-
-            Register<MapComponent>();
-            RegisterReference<MapComponent, IMapComponent>();
-
-            Register<MapGridComponent>();
-            RegisterReference<MapGridComponent, IMapGridComponent>();
-
-            Register<PhysicsComponent>();
-            RegisterReference<PhysicsComponent, IPhysBody>();
-
-            Register<CollisionWakeComponent>();
-
-            Register<ContainerManagerComponent>();
-            RegisterReference<ContainerManagerComponent, IContainerManager>();
-
             RegisterIgnore("KeyBindingInput");
 
-            Register<InputComponent>();
-
-            Register<SpriteComponent>();
-            RegisterReference<SpriteComponent, SharedSpriteComponent>();
-            RegisterReference<SpriteComponent, ISpriteComponent>();
-
-            Register<ClientOccluderComponent>();
-            RegisterReference<ClientOccluderComponent, OccluderComponent>();
-
-            Register<EyeComponent>();
-            RegisterReference<EyeComponent, SharedEyeComponent>();
-
-            Register<AppearanceComponent>();
-            RegisterReference<AppearanceComponent, SharedAppearanceComponent>();
-
-            Register<AppearanceTestComponent>();
-            Register<SnapGridComponent>();
-
-            Register<ClientUserInterfaceComponent>();
-            RegisterReference<ClientUserInterfaceComponent, SharedUserInterfaceComponent>();
-
-            Register<AnimationPlayerComponent>();
-
-            Register<TimerComponent>();
+            RegisterClass<MetaDataComponent>();
+            RegisterClass<TransformComponent>();
+            RegisterClass<MapComponent>();
+            RegisterClass<MapGridComponent>();
+            RegisterClass<PhysicsComponent>();
+            RegisterClass<CollisionWakeComponent>();
+            RegisterClass<ClientUserInterfaceComponent>();
+            RegisterClass<ContainerManagerComponent>();
+            RegisterClass<InputComponent>();
+            RegisterClass<SpriteComponent>();
+            RegisterClass<ClientOccluderComponent>();
+            RegisterClass<EyeComponent>();
+            RegisterClass<AppearanceComponent>();
+            RegisterClass<AppearanceTestComponent>();
+            RegisterClass<SnapGridComponent>();
+            RegisterClass<AnimationPlayerComponent>();
+            RegisterClass<TimerComponent>();
 
 #if DEBUG
-            Register<DebugExceptionOnAddComponent>();
-            Register<DebugExceptionInitializeComponent>();
-            Register<DebugExceptionStartupComponent>();
+            RegisterClass<DebugExceptionOnAddComponent>();
+            RegisterClass<DebugExceptionInitializeComponent>();
+            RegisterClass<DebugExceptionStartupComponent>();
 #endif
 
         }

Robust.Client/GameObjects/ClientEntityManager.cs

@@ -109,6 +109,7 @@ namespace Robust.Client.GameObjects
         }
 
         /// <inheritdoc />
+        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
         public void SendComponentNetworkMessage(INetChannel? channel, IEntity entity, IComponent component, ComponentMessage message)
         {
             if (!component.NetID.HasValue)

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

@@ -10,6 +10,7 @@ using YamlDotNet.RepresentationModel;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(SharedAppearanceComponent))]
     public sealed class AppearanceComponent : SharedAppearanceComponent
     {
         [ViewVariables]

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

@@ -10,6 +10,7 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(SharedEyeComponent))]
     public class EyeComponent : SharedEyeComponent
     {
         [Dependency] private readonly IEyeManager _eyeManager = default!;

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

@@ -8,10 +8,11 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(OccluderComponent))]
     internal sealed class ClientOccluderComponent : OccluderComponent
     {
         [Dependency] private readonly IMapManager _mapManager = default!;
-        
+
         [ViewVariables] private (GridId, Vector2i) _lastPosition;
         [ViewVariables] internal OccluderDir Occluding { get; private set; }
         [ViewVariables] internal uint UpdateGeneration { get; set; }

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

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Animations;
@@ -167,7 +168,7 @@ namespace Robust.Client.GameObjects
             set
             {
                 _radius = MathF.Max(value, 0.01f); // setting radius to 0 causes exceptions, so just use a value close enough to zero that it's unnoticeable.
-                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new PointLightRadiusChangedMessage(this));
+                Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local, new PointLightRadiusChangedEvent(this));
             }
         }
 
@@ -179,6 +180,18 @@ namespace Robust.Client.GameObjects
                 Mask = null;
         }
 
+        /// <summary>
+        /// What MapId we are intersecting for RenderingTreeSystem.
+        /// </summary>
+        [ViewVariables]
+        internal MapId IntersectingMapId { get; set; } = MapId.Nullspace;
+
+        /// <summary>
+        /// What grids we're on for RenderingTreeSystem.
+        /// </summary>
+        [ViewVariables]
+        internal List<GridId> IntersectingGrids = new();
+
         void ISerializationHooks.AfterDeserialization()
         {
             if (_maskPath != null)
@@ -230,7 +243,7 @@ namespace Robust.Client.GameObjects
             if (map != MapId.Nullspace)
             {
                 Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local,
-                    new RenderTreeRemoveLightMessage(this, map));
+                    new RenderTreeRemoveLightEvent(this, map));
             }
         }
 
@@ -248,11 +261,11 @@ namespace Robust.Client.GameObjects
         }
     }
 
-    public struct PointLightRadiusChangedMessage
+    public class PointLightRadiusChangedEvent : EntityEventArgs
     {
         public PointLightComponent PointLightComponent { get; }
 
-        public PointLightRadiusChangedMessage(PointLightComponent pointLightComponent)
+        public PointLightRadiusChangedEvent(PointLightComponent pointLightComponent)
         {
             PointLightComponent = pointLightComponent;
         }

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

@@ -27,6 +27,8 @@ using DrawDepthTag = Robust.Shared.GameObjects.DrawDepth;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(SharedSpriteComponent))]
+    [ComponentReference(typeof(ISpriteComponent))]
     public sealed class SpriteComponent : SharedSpriteComponent, ISpriteComponent,
         IComponentDebug, ISerializationHooks
     {
@@ -123,6 +125,18 @@ namespace Robust.Client.GameObjects
         [DataField("directional")]
         private bool _directional = true;
 
+        /// <summary>
+        /// What MapId we are intersecting for RenderingTreeSystem.
+        /// </summary>
+        [ViewVariables]
+        internal MapId IntersectingMapId { get; set; } = MapId.Nullspace;
+
+        /// <summary>
+        /// What grids we're on for RenderingTreeSystem.
+        /// </summary>
+        [ViewVariables]
+        internal List<GridId> IntersectingGrids { get; } = new();
+
         [DataField("layerDatums")]
         private List<PrototypeLayerData> LayerDatums
         {
@@ -1353,7 +1367,7 @@ namespace Robust.Client.GameObjects
             if (map != MapId.Nullspace)
             {
                 Owner.EntityManager.EventBus.RaiseEvent(EventSource.Local,
-                    new RenderTreeRemoveSpriteMessage(this, map));
+                    new RenderTreeRemoveSpriteEvent(this, map));
             }
         }
 
@@ -1576,9 +1590,10 @@ namespace Robust.Client.GameObjects
         {
             var builder = new StringBuilder();
             builder.AppendFormat(
-                "vis/depth/scl/rot/ofs/col/diral/dir: {0}/{1}/{2}/{3}/{4}/{5}/{6}/{7}\n",
+                "vis/depth/scl/rot/ofs/col/norot/override/dir: {0}/{1}/{2}/{3}/{4}/{5}/{6}/{8}/{7}\n",
                 Visible, DrawDepth, Scale, Rotation, Offset,
-                Color, Directional, GetDir(RSI.State.DirectionType.Dir8, Owner.Transform.WorldRotation)
+                Color, NoRotation, GetDir(RSI.State.DirectionType.Dir8, Owner.Transform.WorldRotation),
+                DirectionOverride
             );
 
             foreach (var layer in Layers)
@@ -2176,6 +2191,10 @@ namespace Robust.Client.GameObjects
                 return null;
             }
 
+            public void QueueDelete()
+            {
+            }
+
             public void Delete()
             {
             }
@@ -2190,10 +2209,12 @@ namespace Robust.Client.GameObjects
                 return Enumerable.Empty<T>();
             }
 
+            [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
             public void SendMessage(IComponent? owner, ComponentMessage message)
             {
             }
 
+            [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
             public void SendNetworkMessage(IComponent owner, ComponentMessage message, INetChannel? channel = null)
             {
             }

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

@@ -2,14 +2,14 @@
 using System.Collections.Generic;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
-using Robust.Shared.Network;
-using Robust.Shared.Players;
 using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.GameObjects
 {
+    [ComponentReference(typeof(SharedUserInterfaceComponent))]
     public class ClientUserInterfaceComponent : SharedUserInterfaceComponent, ISerializationHooks
     {
         [Dependency] private readonly IReflectionManager _reflectionManager = default!;
@@ -23,6 +23,9 @@ namespace Robust.Client.GameObjects
         [DataField("interfaces", readOnly: true)]
         private List<PrototypeData> _interfaceData = new();
 
+        [ViewVariables]
+        public IEnumerable<BoundUserInterface> Interfaces => _openInterfaces.Values;
+
         void ISerializationHooks.AfterDeserialization()
         {
             _interfaces.Clear();
@@ -33,48 +36,40 @@ namespace Robust.Client.GameObjects
             }
         }
 
-        public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel,
-            ICommonSession? session = null)
+        internal void MessageReceived(BoundUIWrapMessage msg)
         {
-            base.HandleNetworkMessage(message, netChannel, session);
-
-            switch (message)
+            switch (msg.Message)
             {
-                case BoundInterfaceMessageWrapMessage wrapped:
-                    // Double nested switches who needs readability anyways.
-                    switch (wrapped.Message)
+                case OpenBoundInterfaceMessage _:
+                    if (_openInterfaces.ContainsKey(msg.UiKey))
                     {
-                        case OpenBoundInterfaceMessage _:
-                            if (_openInterfaces.ContainsKey(wrapped.UiKey))
-                            {
-                                return;
-                            }
+                        return;
+                    }
 
-                            OpenInterface(wrapped);
-                            break;
+                    OpenInterface(msg);
+                    break;
 
-                        case CloseBoundInterfaceMessage _:
-                            Close(wrapped.UiKey, true);
-                            break;
+                case CloseBoundInterfaceMessage _:
+                    Close(msg.UiKey, true);
+                    break;
 
-                        default:
-                            if (_openInterfaces.TryGetValue(wrapped.UiKey, out var bi))
-                            {
-                                bi.InternalReceiveMessage(wrapped.Message);
-                            }
-                            break;
+                default:
+                    if (_openInterfaces.TryGetValue(msg.UiKey, out var bi))
+                    {
+                        bi.InternalReceiveMessage(msg.Message);
                     }
 
                     break;
             }
         }
 
-        private void OpenInterface(BoundInterfaceMessageWrapMessage wrapped)
+        private void OpenInterface(BoundUIWrapMessage wrapped)
         {
             var data = _interfaces[wrapped.UiKey];
             // TODO: This type should be cached, but I'm too lazy.
             var type = _reflectionManager.LooseGetType(data.ClientType);
-            var boundInterface = (BoundUserInterface) _dynamicTypeFactory.CreateInstance(type, new[]{this, wrapped.UiKey});
+            var boundInterface =
+                (BoundUserInterface) _dynamicTypeFactory.CreateInstance(type, new[] {this, wrapped.UiKey});
             boundInterface.Open();
             _openInterfaces[wrapped.UiKey] = boundInterface;
         }
@@ -86,7 +81,7 @@ namespace Robust.Client.GameObjects
                 return;
             }
 
-            if(!remoteCall)
+            if (!remoteCall)
                 SendMessage(new CloseBoundInterfaceMessage(), uiKey);
             _openInterfaces.Remove(uiKey);
             boundUserInterface.Dispose();
@@ -94,7 +89,8 @@ namespace Robust.Client.GameObjects
 
         internal void SendMessage(BoundUserInterfaceMessage message, object uiKey)
         {
-            SendNetworkMessage(new BoundInterfaceMessageWrapMessage(message, uiKey));
+            EntitySystem.Get<UserInterfaceSystem>()
+                .Send(new BoundUIWrapMessage(Owner.Uid, message, uiKey));
         }
     }
 

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -41,17 +41,6 @@ namespace Robust.Client.GameObjects
             _broadPhaseSystem = Get<SharedBroadPhaseSystem>();
         }
 
-        public override void Shutdown()
-        {
-            base.Shutdown();
-            UnsubscribeNetworkEvent<PlayAudioEntityMessage>();
-            UnsubscribeNetworkEvent<PlayAudioGlobalMessage>();
-            UnsubscribeNetworkEvent<PlayAudioPositionalMessage>();
-            UnsubscribeNetworkEvent<StopAudioMessageClient>();
-
-            UnsubscribeLocalEvent<SoundSystem.QueryAudioSystem>();
-        }
-
         private void StopAudioMessageHandler(StopAudioMessageClient ev)
         {
             var stream = _playingClydeStreams.Find(p => p.NetIdentifier == ev.Identifier);

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -38,15 +38,6 @@ namespace Robust.Client.GameObjects
             SubscribeLocalEvent<ClientOccluderComponent, SnapGridPositionChangedEvent>(HandleSnapGridMove);
         }
 
-        /// <inheritdoc />
-        public override void Shutdown()
-        {
-            UnsubscribeLocalEvent<OccluderDirtyEvent>();
-            UnsubscribeLocalEvent<ClientOccluderComponent, SnapGridPositionChangedEvent>();
-
-            base.Shutdown();
-        }
-
         public override void FrameUpdate(float frameTime)
         {
             base.FrameUpdate(frameTime);

Robust.Client/GameObjects/EntitySystems/EffectSystem.cs

@@ -67,9 +67,10 @@ namespace Robust.Client.GameObjects
             //Create effect from creation message
             var effect = new Effect(message, resourceCache, _mapManager, _entityManager);
             effect.Deathtime = gameTiming.CurTime + message.LifeTime;
-            if (effect.AttachedEntityUid != null)
+            if (effect.AttachedEntityUid != null
+                && _entityManager.TryGetEntity(effect.AttachedEntityUid.Value, out var attachedEntity))
             {
-                effect.AttachedEntity = _entityManager.GetEntity(effect.AttachedEntityUid.Value);
+                effect.AttachedEntity = attachedEntity;
             }
 
             _Effects.Add(effect);

Robust.Client/GameObjects/EntitySystems/RenderingTreeSystem.cs

@@ -1,4 +1,6 @@
 using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
 using JetBrains.Annotations;
 using Robust.Client.Physics;
 using Robust.Shared.GameObjects;
@@ -6,6 +8,7 @@ using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
+using Robust.Shared.Utility;
 
 namespace Robust.Client.GameObjects
 {
@@ -47,14 +50,148 @@ namespace Robust.Client.GameObjects
             _mapManager.OnGridCreated += MapManagerOnGridCreated;
             _mapManager.OnGridRemoved += MapManagerOnGridRemoved;
 
-            SubscribeLocalEvent<EntMapIdChangedMessage>(EntMapIdChanged);
-            SubscribeLocalEvent<MoveEvent>(EntMoved);
-            SubscribeLocalEvent<EntParentChangedMessage>(EntParentChanged);
-            SubscribeLocalEvent<PointLightRadiusChangedMessage>(PointLightRadiusChanged);
-            SubscribeLocalEvent<RenderTreeRemoveSpriteMessage>(RemoveSprite);
-            SubscribeLocalEvent<RenderTreeRemoveLightMessage>(RemoveLight);
+            SubscribeLocalEvent<SpriteComponent, EntMapIdChangedMessage>(SpriteMapChanged);
+            SubscribeLocalEvent<SpriteComponent, MoveEvent>(SpriteMoved);
+            SubscribeLocalEvent<SpriteComponent, EntParentChangedMessage>(SpriteParentChanged);
+            SubscribeLocalEvent<SpriteComponent, RenderTreeRemoveSpriteEvent>(RemoveSprite);
+
+            SubscribeLocalEvent<PointLightComponent, EntMapIdChangedMessage>(LightMapChanged);
+            SubscribeLocalEvent<PointLightComponent, MoveEvent>(LightMoved);
+            SubscribeLocalEvent<PointLightComponent, EntParentChangedMessage>(LightParentChanged);
+            SubscribeLocalEvent<PointLightComponent, PointLightRadiusChangedEvent>(PointLightRadiusChanged);
+            SubscribeLocalEvent<PointLightComponent, RenderTreeRemoveLightEvent>(RemoveLight);
         }
 
+        // For the RemoveX methods
+        // If the Transform is removed BEFORE the Sprite/Light,
+        // then the MapIdChanged code will handle and remove it (because MapId gets set to nullspace).
+        // Otherwise these will still have their past MapId and that's all we need..
+
+        #region SpriteHandlers
+        private void SpriteMapChanged(EntityUid uid, SpriteComponent component, EntMapIdChangedMessage args)
+        {
+            QueueSpriteUpdate(component);
+        }
+
+        private void SpriteMoved(EntityUid uid, SpriteComponent component, MoveEvent args)
+        {
+            QueueSpriteUpdate(component);
+        }
+
+        private void SpriteParentChanged(EntityUid uid, SpriteComponent component, EntParentChangedMessage args)
+        {
+            QueueSpriteUpdate(component);
+        }
+
+        private void RemoveSprite(EntityUid uid, SpriteComponent component, RenderTreeRemoveSpriteEvent args)
+        {
+            ClearSprite(component);
+        }
+
+        private void ClearSprite(SpriteComponent component)
+        {
+            if (_gridTrees.TryGetValue(component.IntersectingMapId, out var gridTrees))
+            {
+                foreach (var gridId in component.IntersectingGrids)
+                {
+                    if (!gridTrees.TryGetValue(gridId, out var tree)) continue;
+                    tree.SpriteTree.Remove(component);
+                }
+            }
+
+            component.IntersectingGrids.Clear();
+        }
+
+        private void QueueSpriteUpdate(SpriteComponent component)
+        {
+            if (component.TreeUpdateQueued) return;
+
+            component.TreeUpdateQueued = true;
+            _spriteQueue.Add(component);
+
+            foreach (var child in component.Owner.Transform.Children)
+            {
+                QueueSpriteUpdate(child.Owner);
+            }
+        }
+
+        private void QueueSpriteUpdate(IEntity entity)
+        {
+            if (!entity.TryGetComponent(out SpriteComponent? spriteComponent)) return;
+            QueueSpriteUpdate(spriteComponent);
+
+            foreach (var child in entity.Transform.Children)
+            {
+                QueueSpriteUpdate(child.Owner);
+            }
+        }
+        #endregion
+
+        #region LightHandlers
+        private void LightMapChanged(EntityUid uid, PointLightComponent component, EntMapIdChangedMessage args)
+        {
+            QueueLightUpdate(component);
+        }
+
+        private void LightMoved(EntityUid uid, PointLightComponent component, MoveEvent args)
+        {
+            QueueLightUpdate(component);
+        }
+
+        private void LightParentChanged(EntityUid uid, PointLightComponent component, EntParentChangedMessage args)
+        {
+            QueueLightUpdate(component);
+        }
+
+        private void PointLightRadiusChanged(EntityUid uid, PointLightComponent component, PointLightRadiusChangedEvent args)
+        {
+            QueueLightUpdate(component);
+        }
+
+        private void RemoveLight(EntityUid uid, PointLightComponent component, RenderTreeRemoveLightEvent args)
+        {
+            ClearLight(component);
+        }
+
+        private void ClearLight(PointLightComponent component)
+        {
+            if (_gridTrees.TryGetValue(component.IntersectingMapId, out var gridTrees))
+            {
+                foreach (var gridId in component.IntersectingGrids)
+                {
+                    if (!gridTrees.TryGetValue(gridId, out var tree)) continue;
+                    tree.LightTree.Remove(component);
+                }
+            }
+
+            component.IntersectingGrids.Clear();
+        }
+
+        private void QueueLightUpdate(PointLightComponent component)
+        {
+            if (component.TreeUpdateQueued) return;
+
+            component.TreeUpdateQueued = true;
+            _lightQueue.Add(component);
+
+            foreach (var child in component.Owner.Transform.Children)
+            {
+                QueueLightUpdate(child.Owner);
+            }
+        }
+
+        private void QueueLightUpdate(IEntity entity)
+        {
+            if (!entity.TryGetComponent(out PointLightComponent? lightComponent)) return;
+            QueueLightUpdate(lightComponent);
+
+            foreach (var child in entity.Transform.Children)
+            {
+                QueueLightUpdate(child.Owner);
+            }
+        }
+        #endregion
+
         public override void Shutdown()
         {
             base.Shutdown();
@@ -62,136 +199,27 @@ namespace Robust.Client.GameObjects
             _mapManager.MapDestroyed -= MapManagerOnMapDestroyed;
             _mapManager.OnGridCreated -= MapManagerOnGridCreated;
             _mapManager.OnGridRemoved -= MapManagerOnGridRemoved;
-
-            UnsubscribeLocalEvent<EntMapIdChangedMessage>();
-            UnsubscribeLocalEvent<MoveEvent>();
-            UnsubscribeLocalEvent<EntParentChangedMessage>();
-            UnsubscribeLocalEvent<PointLightRadiusChangedMessage>();
-            UnsubscribeLocalEvent<RenderTreeRemoveSpriteMessage>();
-            UnsubscribeLocalEvent<RenderTreeRemoveLightMessage>();
-        }
-
-        // For these next 2 methods (the Remove* ones):
-        // If the Transform is removed BEFORE the Sprite/Light,
-        // then the MapIdChanged code will handle and remove it (because MapId gets set to nullspace).
-        // Otherwise these will still have their past MapId and that's all we need..
-        private void RemoveLight(RenderTreeRemoveLightMessage ev)
-        {
-            foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Map, MapTrees.LightAabbFunc(ev.Light), true))
-            {
-                _gridTrees[ev.Map][gridId].LightTree.Remove(ev.Light);
-            }
-        }
-
-        private void RemoveSprite(RenderTreeRemoveSpriteMessage ev)
-        {
-            foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Map, MapTrees.SpriteAabbFunc(ev.Sprite), true))
-            {
-                _gridTrees[ev.Map][gridId].SpriteTree.Remove(ev.Sprite);
-            }
-        }
-
-        private void PointLightRadiusChanged(PointLightRadiusChangedMessage ev)
-        {
-            QueueUpdateLight(ev.PointLightComponent);
-        }
-
-        private void EntParentChanged(EntParentChangedMessage ev)
-        {
-            UpdateEntity(ev.Entity);
-        }
-
-        private void EntMoved(MoveEvent ev)
-        {
-            UpdateEntity(ev.Sender);
-        }
-
-        private void UpdateEntity(IEntity entity)
-        {
-            if (entity.TryGetComponent(out SpriteComponent? spriteComponent))
-            {
-                if (!spriteComponent.TreeUpdateQueued)
-                {
-                    spriteComponent.TreeUpdateQueued = true;
-
-                    _spriteQueue.Add(spriteComponent);
-                }
-            }
-
-            if (entity.TryGetComponent(out PointLightComponent? light))
-            {
-                QueueUpdateLight(light);
-            }
-
-            foreach (var child in entity.Transform.ChildEntityUids)
-            {
-                UpdateEntity(EntityManager.GetEntity(child));
-            }
-        }
-
-        private void QueueUpdateLight(PointLightComponent light)
-        {
-            if (!light.TreeUpdateQueued)
-            {
-                light.TreeUpdateQueued = true;
-
-                _lightQueue.Add(light);
-            }
-        }
-
-        private void EntMapIdChanged(EntMapIdChangedMessage ev)
-        {
-            // Nullspace is a valid map ID for stuff to have but we also aren't gonna bother indexing it.
-            // So that's why there's a GetValueOrDefault.
-            var oldMapTrees = _gridTrees.GetValueOrDefault(ev.OldMapId);
-            var newMapTrees = _gridTrees.GetValueOrDefault(ev.Entity.Transform.MapID);
-
-            // TODO: MMMM probably a better way to do this.
-            if (ev.Entity.TryGetComponent(out SpriteComponent? sprite))
-            {
-                if (oldMapTrees != null)
-                {
-                    foreach (var (_, gridTree) in oldMapTrees)
-                    {
-                        gridTree.SpriteTree.Remove(sprite);
-                    }
-                }
-
-                var bounds = MapTrees.SpriteAabbFunc(sprite);
-
-                foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Entity.Transform.MapID, bounds, true))
-                {
-                    var gridBounds = gridId == GridId.Invalid
-                        ? bounds : bounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
-
-                    newMapTrees?[gridId].SpriteTree.AddOrUpdate(sprite, gridBounds);
-                }
-            }
-
-            if (ev.Entity.TryGetComponent(out PointLightComponent? light))
-            {
-                if (oldMapTrees != null)
-                {
-                    foreach (var (_, gridTree) in oldMapTrees)
-                    {
-                        gridTree.LightTree.Remove(light);
-                    }
-                }
-
-                var bounds = MapTrees.LightAabbFunc(light);
-
-                foreach (var gridId in _mapManager.FindGridIdsIntersecting(ev.Entity.Transform.MapID, bounds, true))
-                {
-                    var gridBounds = gridId == GridId.Invalid
-                        ? bounds : bounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
-
-                    newMapTrees?[gridId].LightTree.AddOrUpdate(light, gridBounds);
-                }
-            }
         }
 
         private void MapManagerOnMapDestroyed(object? sender, MapEventArgs e)
         {
+            foreach (var (_, gridTree) in _gridTrees[e.Map])
+            {
+                foreach (var comp in gridTree.LightTree)
+                {
+                    comp.IntersectingGrids.Clear();
+                }
+
+                foreach (var comp in gridTree.SpriteTree)
+                {
+                    comp.IntersectingGrids.Clear();
+                }
+
+                // Just in case?
+                gridTree.LightTree.Clear();
+                gridTree.SpriteTree.Clear();
+            }
+
             _gridTrees.Remove(e.Map);
         }
 
@@ -215,47 +243,109 @@ namespace Robust.Client.GameObjects
 
         private void MapManagerOnGridRemoved(MapId mapId, GridId gridId)
         {
+            var gridTree = _gridTrees[mapId][gridId];
+
+            foreach (var sprite in gridTree.SpriteTree)
+            {
+                sprite.IntersectingGrids.Remove(gridId);
+            }
+
+            foreach (var light in gridTree.LightTree)
+            {
+                light.IntersectingGrids.Remove(gridId);
+            }
+
+            // Clear in case
+            gridTree.LightTree.Clear();
+            gridTree.SpriteTree.Clear();
             _gridTrees[mapId].Remove(gridId);
         }
 
         public override void FrameUpdate(float frameTime)
         {
-            foreach (var queuedUpdateSprite in _spriteQueue)
+            foreach (var sprite in _spriteQueue)
             {
-                var map = queuedUpdateSprite.Owner.Transform.MapID;
-                if (map == MapId.Nullspace)
+                var mapId = sprite.Owner.Transform.MapID;
+
+                // If we're on a new map then clear the old one.
+                if (sprite.IntersectingMapId != mapId)
                 {
-                    continue;
+                    ClearSprite(sprite);
                 }
 
-                var mapTree = _gridTrees[map];
+                sprite.IntersectingMapId = mapId;
 
-                foreach (var gridId in _mapManager.FindGridIdsIntersecting(map,
-                    MapTrees.SpriteAabbFunc(queuedUpdateSprite), true))
+                if (mapId == MapId.Nullspace) continue;
+
+                var mapTree = _gridTrees[mapId];
+                var aabb = MapTrees.SpriteAabbFunc(sprite);
+                var intersectingGrids = _mapManager.FindGridIdsIntersecting(mapId, aabb, true).ToList();
+
+                // Remove from old
+                foreach (var gridId in sprite.IntersectingGrids)
                 {
-                    mapTree[gridId].SpriteTree.AddOrUpdate(queuedUpdateSprite);
+                    if (intersectingGrids.Contains(gridId)) continue;
+                    mapTree[gridId].SpriteTree.Remove(sprite);
                 }
 
-                queuedUpdateSprite.TreeUpdateQueued = false;
+                // Rebuild in the update below
+                sprite.IntersectingGrids.Clear();
+
+                // Update / add to new
+                foreach (var gridId in intersectingGrids)
+                {
+                    var translated = aabb.Translated(gridId == GridId.Invalid
+                        ? Vector2.Zero
+                        : -_mapManager.GetGrid(gridId).WorldPosition);
+
+                    mapTree[gridId].SpriteTree.AddOrUpdate(sprite, translated);
+
+                    sprite.IntersectingGrids.Add(gridId);
+                }
+
+                sprite.TreeUpdateQueued = false;
             }
 
-            foreach (var queuedUpdateLight in _lightQueue)
+            foreach (var light in _lightQueue)
             {
-                var map = queuedUpdateLight.Owner.Transform.MapID;
-                if (map == MapId.Nullspace)
+                var mapId = light.Owner.Transform.MapID;
+
+                // If we're on a new map then clear the old one.
+                if (light.IntersectingMapId != mapId)
                 {
-                    continue;
+                    ClearLight(light);
                 }
 
-                var mapTree = _gridTrees[map];
+                light.IntersectingMapId = mapId;
 
-                foreach (var gridId in _mapManager.FindGridIdsIntersecting(map,
-                    MapTrees.LightAabbFunc(queuedUpdateLight), true))
+                if (mapId == MapId.Nullspace) continue;
+
+                var mapTree = _gridTrees[mapId];
+                var aabb = MapTrees.LightAabbFunc(light);
+                var intersectingGrids = _mapManager.FindGridIdsIntersecting(mapId, aabb, true).ToList();
+
+                // Remove from old
+                foreach (var gridId in intersectingGrids)
                 {
-                    mapTree[gridId].LightTree.AddOrUpdate(queuedUpdateLight);
+                    if (intersectingGrids.Contains(gridId)) continue;
+                    mapTree[gridId].LightTree.Remove(light);
                 }
 
-                queuedUpdateLight.TreeUpdateQueued = false;
+                // Rebuild in the update below
+                light.IntersectingGrids.Clear();
+
+                // Update / add to new
+                foreach (var gridId in intersectingGrids)
+                {
+                    var translated = aabb.Translated(gridId == GridId.Invalid
+                        ? Vector2.Zero
+                        : -_mapManager.GetGrid(gridId).WorldPosition);
+
+                    mapTree[gridId].LightTree.AddOrUpdate(light, translated);
+                    light.IntersectingGrids.Add(gridId);
+                }
+
+                light.TreeUpdateQueued = false;
             }
 
             _spriteQueue.Clear();
@@ -290,9 +380,9 @@ namespace Robust.Client.GameObjects
         }
     }
 
-    internal struct RenderTreeRemoveSpriteMessage
+    internal class RenderTreeRemoveSpriteEvent : EntityEventArgs
     {
-        public RenderTreeRemoveSpriteMessage(SpriteComponent sprite, MapId map)
+        public RenderTreeRemoveSpriteEvent(SpriteComponent sprite, MapId map)
         {
             Sprite = sprite;
             Map = map;
@@ -302,9 +392,9 @@ namespace Robust.Client.GameObjects
         public MapId Map { get; }
     }
 
-    internal struct RenderTreeRemoveLightMessage
+    internal class RenderTreeRemoveLightEvent : EntityEventArgs
     {
-        public RenderTreeRemoveLightMessage(PointLightComponent light, MapId map)
+        public RenderTreeRemoveLightEvent(PointLightComponent light, MapId map)
         {
             Light = light;
             Map = map;

Robust.Client/GameObjects/EntitySystems/SpriteSystem.cs

@@ -16,11 +16,17 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IMapManager _mapManager = default!;
 
+        private RenderingTreeSystem _treeSystem = default!;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _treeSystem = Get<RenderingTreeSystem>();
+        }
+
         /// <inheritdoc />
         public override void FrameUpdate(float frameTime)
         {
-            var renderTreeSystem = EntitySystemManager.GetEntitySystem<RenderingTreeSystem>();
-
             // So we could calculate the correct size of the entities based on the contents of their sprite...
             // Or we can just assume that no entity is larger than 10x10 and get a stupid easy check.
             var pvsBounds = _eyeManager.GetWorldViewport().Enlarged(5);
@@ -33,18 +39,9 @@ namespace Robust.Client.GameObjects
 
             foreach (var gridId in _mapManager.FindGridIdsIntersecting(currentMap, pvsBounds, true))
             {
-                Box2 gridBounds;
+                var gridBounds = gridId == GridId.Invalid ? pvsBounds : pvsBounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
 
-                if (gridId == GridId.Invalid)
-                {
-                    gridBounds = pvsBounds;
-                }
-                else
-                {
-                    gridBounds = pvsBounds.Translated(-_mapManager.GetGrid(gridId).WorldPosition);
-                }
-
-                var mapTree = renderTreeSystem.GetSpriteTreeForMap(currentMap, gridId);
+                var mapTree = _treeSystem.GetSpriteTreeForMap(currentMap, gridId);
 
                 mapTree.QueryAabb(ref frameTime, (ref float state, in SpriteComponent value) =>
                 {

Robust.Client/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -0,0 +1,37 @@
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+
+namespace Robust.Client.GameObjects
+{
+    [UsedImplicitly]
+    public sealed class UserInterfaceSystem : EntitySystem
+    {
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            SubscribeNetworkEvent<BoundUIWrapMessage>(MessageReceived);
+            SubscribeLocalEvent<ClientUserInterfaceComponent, ComponentShutdown>(OnUserInterfaceShutdown);
+        }
+
+        private void OnUserInterfaceShutdown(EntityUid uid, ClientUserInterfaceComponent component, ComponentShutdown args)
+        {
+            foreach (var bui in component.Interfaces)
+            {
+                bui.Dispose();
+            }
+        }
+
+        private void MessageReceived(BoundUIWrapMessage ev)
+        {
+            var cmp = ComponentManager.GetComponent<ClientUserInterfaceComponent>(ev.Entity);
+
+            cmp.MessageReceived(ev);
+        }
+
+        internal void Send(BoundUIWrapMessage msg)
+        {
+            RaiseNetworkEvent(msg);
+        }
+    }
+}

Robust.Client/GameObjects/PlayerMessages.cs

@@ -1,12 +1,15 @@
+using System;
 using Robust.Shared.GameObjects;
 
 namespace Robust.Client.GameObjects
 {
+    [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
     public class PlayerAttachedMsg : ComponentMessage
     {
 
     }
 
+    [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
     public class PlayerDetachedMsg : ComponentMessage
     {
 

Robust.Client/GameStates/NetEntityOverlay.cs

@@ -146,13 +146,12 @@ namespace Robust.Client.GameStates
         private void DrawWorld(in OverlayDrawArgs args)
         {
             bool pvsEnabled = _configurationManager.GetCVar<bool>("net.pvs");
-
             if(!pvsEnabled)
                 return;
 
-            float pvsSize = _configurationManager.GetCVar<float>("net.maxupdaterange");
+            float pvsRange = _configurationManager.GetCVar<float>("net.maxupdaterange");
             var pvsCenter = _eyeManager.CurrentEye.Position;
-            Box2 pvsBox = Box2.CenteredAround(pvsCenter.Position, new Vector2(pvsSize, pvsSize));
+            Box2 pvsBox = Box2.CenteredAround(pvsCenter.Position, new Vector2(pvsRange * 2, pvsRange * 2));
 
             var worldHandle = args.WorldHandle;
 

Robust.Client/Graphics/Clyde/Audio/Clyde.Audio.cs

@@ -183,6 +183,32 @@ namespace Robust.Client.Graphics.Clyde
             if (handles.filterHandle != 0) EFX.DeleteFilter(handles.filterHandle);
         }
 
+        public AudioStream LoadAudioRaw(short[] samples, int channels, int sampleRate)
+        {
+            var buffer = AL.GenBuffer();
+
+            unsafe
+            {
+                fixed (short* ptr = samples)
+                {
+                    AL.BufferData(
+                        buffer,
+                        channels == 1 ? ALFormat.Mono16 : ALFormat.Stereo16,
+                        (IntPtr) ptr,
+                        samples.Length * 2,
+                        sampleRate);
+                }
+            }
+
+            _checkAlError();
+
+            var handle = new ClydeHandle(_audioSampleBuffers.Count);
+            _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
+            // ReSharper disable once PossibleLossOfFraction
+            var length = TimeSpan.FromSeconds(samples.Length / channels / (double) sampleRate);
+            return new AudioStream(handle, length, channels);
+        }
+
         public void SetMasterVolume(float newVolume)
         {
             AL.Listener(ALListenerf.Gain, _baseGain * newVolume);
@@ -439,6 +465,21 @@ namespace Robust.Client.Graphics.Clyde
                 _checkAlError();
             }
 
+            public void SetVolumeDirect(float decibels)
+            {
+                _checkDisposed();
+                var priorOcclusion = 1f;
+                if (!IsEfxSupported)
+                {
+                    AL.GetSource(SourceHandle, ALSourcef.Gain, out var priorGain);
+                    priorOcclusion = priorGain / _gain;
+                }
+
+                _gain = decibels;
+                AL.Source(SourceHandle, ALSourcef.Gain, _gain * priorOcclusion);
+                _checkAlError();
+            }
+
             public void SetOcclusion(float blocks)
             {
                 _checkDisposed();
@@ -747,6 +788,21 @@ namespace Robust.Client.Graphics.Clyde
                 _checkAlError();
             }
 
+            public void SetVolumeDirect(float masterVolumeDecay)
+            {
+                _checkDisposed();
+                var priorOcclusion = 1f;
+                if (!IsEfxSupported)
+                {
+                    AL.GetSource(SourceHandle!.Value, ALSourcef.Gain, out var priorGain);
+                    priorOcclusion = priorGain / _gain;
+                }
+
+                _gain = masterVolumeDecay;
+                AL.Source(SourceHandle!.Value, ALSourcef.Gain, _gain * priorOcclusion);
+                _checkAlError();
+            }
+
             public void SetPitch(float pitch)
             {
                 _checkDisposed();

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

@@ -470,18 +470,20 @@ namespace Robust.Client.Graphics.Clyde
 
         private sealed class MonitorHandle : IClydeMonitor
         {
-            public MonitorHandle(int id, string name, Vector2i size, int refreshRate)
+            public MonitorHandle(int id, string name, Vector2i size, int refreshRate, VideoMode[] videoModes)
             {
                 Id = id;
                 Name = name;
                 Size = size;
                 RefreshRate = refreshRate;
+                VideoModes = videoModes;
             }
 
             public int Id { get; }
             public string Name { get; }
             public Vector2i Size { get; }
             public int RefreshRate { get; }
+            public IEnumerable<VideoMode> VideoModes { get; }
         }
 
         private abstract class MonitorReg

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -59,7 +59,6 @@ namespace Robust.Client.Graphics.Clyde
         private bool _enableSoftShadows = true;
 
         private bool _checkGLErrors;
-        private bool _initialized;
 
         private Thread? _gameThread;
 
@@ -105,7 +104,6 @@ namespace Robust.Client.Graphics.Clyde
                 return false;
 
             _initializeAudio();
-            _initialized = true;
             return true;
         }
 

Robust.Client/Graphics/Clyde/ClydeHeadless.cs

@@ -48,14 +48,14 @@ namespace Robust.Client.Graphics.Clyde
         public IClydeDebugInfo DebugInfo { get; } = new DummyDebugInfo();
         public IClydeDebugStats DebugStats { get; } = new DummyDebugStats();
 
-        public event Action<TextEventArgs>? TextEntered;
-        public event Action<MouseMoveEventArgs>? MouseMove;
-        public event Action<MouseEnterLeaveEventArgs>? MouseEnterLeave;
-        public event Action<KeyEventArgs>? KeyUp;
-        public event Action<KeyEventArgs>? KeyDown;
-        public event Action<MouseWheelEventArgs>? MouseWheel;
-        public event Action<WindowClosedEventArgs>? CloseWindow;
-        public event Action<WindowDestroyedEventArgs>? DestroyWindow;
+        public event Action<TextEventArgs>? TextEntered { add { } remove { } }
+        public event Action<MouseMoveEventArgs>? MouseMove { add { } remove { } }
+        public event Action<MouseEnterLeaveEventArgs>? MouseEnterLeave { add { } remove { } }
+        public event Action<KeyEventArgs>? KeyUp { add { } remove { } }
+        public event Action<KeyEventArgs>? KeyDown { add { } remove { } }
+        public event Action<MouseWheelEventArgs>? MouseWheel { add { } remove { } }
+        public event Action<WindowClosedEventArgs>? CloseWindow { add { } remove { } }
+        public event Action<WindowDestroyedEventArgs>? DestroyWindow { add { } remove { } }
 
         public Texture GetStockTexture(ClydeStockTexture stockTexture)
         {
@@ -248,6 +248,11 @@ namespace Robust.Client.Graphics.Clyde
             return new(default, default, 1, name);
         }
 
+        public AudioStream LoadAudioRaw(short[] samples, int channels, int sampleRate)
+        {
+            throw new NotImplementedException();
+        }
+
         public IClydeAudioSource CreateAudioSource(AudioStream stream)
         {
             return DummyAudioSource.Instance;
@@ -337,6 +342,11 @@ namespace Robust.Client.Graphics.Clyde
             {
                 // Nada.
             }
+
+            public void SetVolumeDirect(float masterVolumeDecay)
+            {
+                // Nada.
+            }
         }
 
         private sealed class DummyBufferedAudioSource : DummyAudioSource, IClydeBufferedAudioSource
@@ -594,7 +604,7 @@ namespace Robust.Client.Graphics.Clyde
             public bool IsVisible { get; set; } = true;
             public Vector2 ContentScale => Vector2.One;
             public bool DisposeOnClose { get; set; }
-            public event Action<WindowClosedEventArgs>? Closed;
+            public event Action<WindowClosedEventArgs>? Closed { add { } remove { } }
 
             public void MaximizeOnMonitor(IClydeMonitor monitor)
             {

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

@@ -71,7 +71,7 @@ namespace Robust.Client.Graphics.Clyde
                 var impl = (CursorImpl) cursor;
                 DebugTools.Assert(impl.Owner == this);
 
-                if (impl.Id == null)
+                if (impl.Id == default)
                 {
                     throw new ObjectDisposedException(nameof(cursor));
                 }

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

@@ -1,6 +1,8 @@
 using System.Collections.Generic;
+using System.Runtime.CompilerServices;
 using OpenToolkit.GraphicsLibraryFramework;
 using Robust.Shared.Utility;
+using GlfwVideoMode = OpenToolkit.GraphicsLibraryFramework.VideoMode;
 
 namespace Robust.Client.Graphics.Clyde
 {
@@ -18,7 +20,6 @@ namespace Robust.Client.Graphics.Clyde
             private readonly Dictionary<int, WinThreadMonitorReg> _winThreadMonitors = new();
 
             // Can't use ClydeHandle because it's 64 bit.
-            // TODO: this should be MONITOR ID.
             private int _nextMonitorId = 1;
             private int _primaryMonitorId;
             private readonly Dictionary<int, GlfwMonitorReg> _monitors = new();
@@ -39,6 +40,7 @@ namespace Robust.Client.Graphics.Clyde
                 ProcessEvents();
             }
 
+            [MethodImpl(MethodImplOptions.NoInlining)]
             private void WinThreadSetupMonitor(Monitor* monitor)
             {
                 var id = _nextMonitorId++;
@@ -48,12 +50,31 @@ namespace Robust.Client.Graphics.Clyde
 
                 var name = GLFW.GetMonitorName(monitor);
                 var videoMode = GLFW.GetVideoMode(monitor);
+                var modesPtr = GLFW.GetVideoModesRaw(monitor, out var modeCount);
+                var modes = new VideoMode[modeCount];
+                for (var i = 0; i < modes.Length; i++)
+                {
+                    modes[i] = ConvertVideoMode(modesPtr[i]);
+                }
 
                 GLFW.SetMonitorUserPointer(monitor, (void*) id);
 
                 _winThreadMonitors.Add(id, new WinThreadMonitorReg {Ptr = monitor});
 
-                SendEvent(new EventMonitorSetup(id, name, *videoMode));
+                SendEvent(new EventMonitorSetup(id, name, ConvertVideoMode(*videoMode), modes));
+            }
+
+            private static VideoMode ConvertVideoMode(in GlfwVideoMode mode)
+            {
+                return new()
+                {
+                    Width = (ushort) mode.Width,
+                    Height = (ushort) mode.Height,
+                    RedBits = (byte) mode.RedBits,
+                    RefreshRate = (ushort) mode.RefreshRate,
+                    GreenBits = (byte) mode.GreenBits,
+                    BlueBits = (byte) mode.BlueBits,
+                };
             }
 
             private void ProcessSetupMonitor(EventMonitorSetup ev)
@@ -61,8 +82,9 @@ namespace Robust.Client.Graphics.Clyde
                 var impl = new MonitorHandle(
                     ev.Id,
                     ev.Name,
-                    (ev.Mode.Width, ev.Mode.Height),
-                    ev.Mode.RefreshRate);
+                    (ev.CurrentMode.Width, ev.CurrentMode.Height),
+                    ev.CurrentMode.RefreshRate,
+                    ev.AllModes);
 
                 _clyde._monitorHandles.Add(impl);
                 _monitors[ev.Id] = new GlfwMonitorReg

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

@@ -210,7 +210,8 @@ namespace Robust.Client.Graphics.Clyde
             (
                 int Id,
                 string Name,
-                VideoMode Mode
+                VideoMode CurrentMode,
+                VideoMode[] AllModes
             ) : EventBase;
 
             private record EventMonitorDestroy

Robust.Client/Graphics/IClydeAudio.cs

@@ -8,6 +8,7 @@ namespace Robust.Client.Graphics
         // AUDIO SYSTEM DOWN BELOW.
         AudioStream LoadAudioOggVorbis(Stream stream, string? name = null);
         AudioStream LoadAudioWav(Stream stream, string? name = null);
+        AudioStream LoadAudioRaw(short[] samples, int channels, int sampleRate);
 
         void SetMasterVolume(float newVolume);
 

Robust.Client/Graphics/IClydeAudioSource.cs

@@ -21,5 +21,6 @@ namespace Robust.Client.Graphics
         void SetOcclusion(float blocks);
         void SetPlaybackPosition(float seconds);
         void SetVelocity(Vector2 velocity);
+        void SetVolumeDirect(float masterVolumeDecay);
     }
 }

Robust.Client/Graphics/IClydeMonitor.cs

@@ -1,4 +1,5 @@
-using Robust.Shared.Maths;
+using System.Collections.Generic;
+using Robust.Shared.Maths;
 
 namespace Robust.Client.Graphics
 {
@@ -14,5 +15,7 @@ namespace Robust.Client.Graphics
         string Name { get; }
         Vector2i Size { get; }
         int RefreshRate { get; }
+
+        IEnumerable<VideoMode> VideoModes { get; }
     }
 }

Robust.Client/Graphics/IRenderHandle.cs

@@ -4,7 +4,7 @@ using Robust.Shared.Maths;
 
 namespace Robust.Client.Graphics
 {
-    internal interface IRenderHandle
+    public interface IRenderHandle
     {
         DrawingHandleScreen DrawingHandleScreen { get; }
         DrawingHandleWorld DrawingHandleWorld { get; }

Robust.Client/Graphics/VideoMode.cs

@@ -0,0 +1,12 @@
+namespace Robust.Client.Graphics
+{
+    public struct VideoMode
+    {
+        public ushort Width;
+        public ushort Height;
+        public ushort RefreshRate;
+        public byte RedBits;
+        public byte BlueBits;
+        public byte GreenBits;
+    }
+}

Robust.Client/Input/InputManager.cs

@@ -16,11 +16,12 @@ using Robust.Shared.IoC;
 using Robust.Shared.Localization;
 using Robust.Shared.Log;
 using Robust.Shared.Map;
-using Robust.Shared.Maths;
 using Robust.Shared.Reflection;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
+using Robust.Shared.Serialization.Markdown.Value;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 using YamlDotNet.Core;
@@ -145,13 +146,13 @@ namespace Robust.Client.Input
                 .Where(p => _bindingsByFunction[p].Count == 0)
                 .ToArray();
 
-            mapping.AddNode("version", new ValueDataNode("1"));
-            mapping.AddNode("binds", serializationManager.WriteValue(modifiedBindings));
-            mapping.AddNode("leaveEmpty", serializationManager.WriteValue(leaveEmpty));
+            mapping.Add("version", new ValueDataNode("1"));
+            mapping.Add("binds", serializationManager.WriteValue(modifiedBindings));
+            mapping.Add("leaveEmpty", serializationManager.WriteValue(leaveEmpty));
 
             var path = new ResourcePath(KeybindsPath);
             using var writer = new StreamWriter(_resourceMan.UserData.Create(path));
-            var stream = new YamlStream {new(mapping.ToMappingNode())};
+            var stream = new YamlStream {new(mapping.ToYaml())};
             stream.Save(new YamlMappingFix(new Emitter(writer)), false);
         }
 
@@ -333,6 +334,7 @@ namespace Robust.Client.Input
         {
             // christ this crap *is* re-entrant thanks to PlacementManager and
             // I honestly have no idea what the best solution here is.
+            // note from the future: context switches won't cause re-entrancy anymore because InputContextContainer defers context switches
             DebugTools.Assert(!_currentlyFindingViewport, "Re-entrant key events??");
 
             try
@@ -340,6 +342,8 @@ namespace Robust.Client.Input
                 // This is terrible but anyways.
                 // This flag keeps track of "did a viewport fire the key up for us" so we know we don't do it again.
                 _currentlyFindingViewport = true;
+                // And this stops context switches from causing crashes
+                Contexts.DeferringEnabled = true;
 
                 binding.State = state;
 
@@ -360,12 +364,14 @@ namespace Robust.Client.Input
             finally
             {
                 _currentlyFindingViewport = false;
+                Contexts.DeferringEnabled = false;
             }
         }
 
         public void ViewportKeyEvent(Control? viewport, BoundKeyEventArgs eventArgs)
         {
             _currentlyFindingViewport = false;
+            Contexts.DeferringEnabled = false;
 
             var cmd = GetInputCommand(eventArgs.Function);
             // TODO: Allow input commands to still get forwarded to server if necessary.
@@ -453,7 +459,7 @@ namespace Robust.Client.Input
             var robustMapping = mapping.ToDataNode() as MappingDataNode;
             if (robustMapping == null) throw new InvalidOperationException();
 
-            if (robustMapping.TryGetNode("binds", out var BaseKeyRegsNode))
+            if (robustMapping.TryGet("binds", out var BaseKeyRegsNode))
             {
                 var baseKeyRegs = serializationManager.ReadValueOrThrow<KeyBindingRegistration[]>(BaseKeyRegsNode);
 
@@ -482,7 +488,7 @@ namespace Robust.Client.Input
                 }
             }
 
-            if (userData && robustMapping.TryGetNode("leaveEmpty", out var node))
+            if (userData && robustMapping.TryGet("leaveEmpty", out var node))
             {
                 var leaveEmpty = serializationManager.ReadValueOrThrow<BoundKeyFunction[]>(node);
 

Robust.Client/Physics/DebugPhysicsIslandSystem.cs

@@ -52,7 +52,7 @@ namespace Robust.Client.Physics
         public override void Shutdown()
         {
             base.Shutdown();
-            UnsubscribeLocalEvent<IslandSolveMessage>();
+
             IoCManager.Resolve<IOverlayManager>().RemoveOverlay(typeof(PhysicsIslandOverlay));
         }
 

Robust.Client/Player/IPlayerManager.cs

@@ -2,13 +2,14 @@ using System;
 using System.Collections.Generic;
 using Robust.Shared.GameStates;
 using Robust.Shared.Network;
+using Robust.Shared.Players;
 
 namespace Robust.Client.Player
 {
     public interface IPlayerManager : Shared.Players.ISharedPlayerManager
     {
-        new IEnumerable<IPlayerSession> Sessions { get; }
-        IReadOnlyDictionary<NetUserId, IPlayerSession> SessionsDict { get; }
+        new IEnumerable<ICommonSession> Sessions { get; }
+        IReadOnlyDictionary<NetUserId, ICommonSession> SessionsDict { get; }
 
         LocalPlayer? LocalPlayer { get; }
 

Robust.Client/Player/IPlayerSession.cs

@@ -1,11 +0,0 @@
-using System;
-using Robust.Shared.Players;
-
-namespace Robust.Client.Player
-{
-    /// <summary>
-    /// Client side session of a player.
-    /// </summary>
-    [Obsolete("Use the base " + nameof(ICommonSession))]
-    public interface IPlayerSession : ICommonSession { }
-}

Robust.Client/Player/LocalPlayer.cs

@@ -4,6 +4,7 @@ using Robust.Shared.Configuration;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Network;
+using Robust.Shared.Players;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.Player
@@ -36,7 +37,7 @@ namespace Robust.Client.Player
         ///     Session of the local client.
         /// </summary>
         [ViewVariables]
-        public IPlayerSession Session => InternalSession;
+        public ICommonSession Session => InternalSession;
 
         internal PlayerSession InternalSession { get; set; } = default!;
 

Robust.Client/Player/PlayerManager.cs

@@ -28,7 +28,7 @@ namespace Robust.Client.Player
         /// <summary>
         ///     Active sessions of connected clients to the server.
         /// </summary>
-        private readonly Dictionary<NetUserId, IPlayerSession> _sessions = new();
+        private readonly Dictionary<NetUserId, ICommonSession> _sessions = new();
 
         /// <inheritdoc />
         public IEnumerable<ICommonSession> NetworkedSessions
@@ -69,10 +69,10 @@ namespace Robust.Client.Player
 
         /// <inheritdoc />
         [ViewVariables]
-        IEnumerable<IPlayerSession> IPlayerManager.Sessions => _sessions.Values;
+        IEnumerable<ICommonSession> IPlayerManager.Sessions => _sessions.Values;
 
         /// <inheritdoc />
-        public IReadOnlyDictionary<NetUserId, IPlayerSession> SessionsDict => _sessions;
+        public IReadOnlyDictionary<NetUserId, ICommonSession> SessionsDict => _sessions;
 
         /// <inheritdoc />
         public event EventHandler? PlayerListUpdated;

Robust.Client/Player/PlayerSession.cs

@@ -5,9 +5,8 @@ using Robust.Shared.Players;
 
 namespace Robust.Client.Player
 {
-    internal sealed class PlayerSession : IPlayerSession
+    internal sealed class PlayerSession : ICommonSession
     {
-        /// <inheritdoc />
         internal SessionStatus Status { get; set; } = SessionStatus.Connecting;
 
         /// <inheritdoc />
@@ -26,17 +25,15 @@ namespace Robust.Client.Player
         /// <inheritdoc />
         public NetUserId UserId { get; }
 
-        /// <inheritdoc cref="IPlayerSession" />
         internal string Name { get; set; } = "<Unknown>";
 
-        /// <inheritdoc cref="IPlayerSession" />
+        /// <inheritdoc />
         string ICommonSession.Name
         {
             get => this.Name;
             set => this.Name = value;
         }
 
-        /// <inheritdoc />
         internal short Ping { get; set; }
 
         /// <inheritdoc />
@@ -51,7 +48,7 @@ namespace Robust.Client.Player
 
         /// <summary>
         ///     Creates an instance of a PlayerSession.
-        /// </summary
+        /// </summary>
         public PlayerSession(NetUserId user)
         {
             UserId = user;

Robust.Client/Serialization/AppearanceVisualizerSerializer.cs

@@ -6,7 +6,9 @@ using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.Serialization.Manager.Result;
 using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Validation;
+using Robust.Shared.Serialization.Markdown.Value;
 using Robust.Shared.Serialization.TypeSerializers.Interfaces;
 
 namespace Robust.Client.Serialization
@@ -19,7 +21,7 @@ namespace Robust.Client.Serialization
             bool skipHook,
             ISerializationContext? context = null)
         {
-            if (!node.TryGetNode("type", out var typeNode))
+            if (!node.TryGet("type", out var typeNode))
                 throw new InvalidMappingException("No type specified for AppearanceVisualizer!");
 
             if (typeNode is not ValueDataNode typeValueDataNode)
@@ -32,7 +34,7 @@ namespace Robust.Client.Serialization
                     $"Invalid type {typeValueDataNode.Value} specified for AppearanceVisualizer!");
 
             var newNode = (MappingDataNode)node.Copy();
-            newNode.RemoveNode("type");
+            newNode.Remove("type");
             return serializationManager.Read(type, newNode, context, skipHook);
         }
 
@@ -40,7 +42,7 @@ namespace Robust.Client.Serialization
             IDependencyCollection dependencies,
             ISerializationContext? context)
         {
-            if (!node.TryGetNode("type", out var typeNode) || typeNode is not ValueDataNode valueNode)
+            if (!node.TryGet("type", out var typeNode) || typeNode is not ValueDataNode valueNode)
             {
                 return new ErrorNode(node, "Missing/Invalid type", true);
             }
@@ -53,14 +55,14 @@ namespace Robust.Client.Serialization
                 return new ErrorNode(node, $"Failed to resolve type: {valueNode.Value}", true);
             }
 
-            return serializationManager.ValidateNode(type, node.CopyCast<MappingDataNode>().RemoveNode("type"));
+            return serializationManager.ValidateNode(type, node.CopyCast<MappingDataNode>().Remove("type"));
         }
 
         public DataNode Write(ISerializationManager serializationManager, AppearanceVisualizer value, bool alwaysWrite = false,
             ISerializationContext? context = null)
         {
             var mapping = serializationManager.WriteValueAs<MappingDataNode>(value.GetType(), value, alwaysWrite, context);
-            mapping.AddNode("type", new ValueDataNode(value.GetType().Name));
+            mapping.Add("type", new ValueDataNode(value.GetType().Name));
             return mapping;
         }
 

Robust.Client/UserInterface/Control.cs

@@ -463,7 +463,7 @@ namespace Robust.Client.UserInterface
         {
         }
 
-        internal virtual void DrawInternal(IRenderHandle renderHandle)
+        public virtual void DrawInternal(IRenderHandle renderHandle)
         {
             Draw(renderHandle.DrawingHandleScreen);
         }

Robust.Client/UserInterface/Controls/SpriteView.cs

@@ -41,7 +41,7 @@ namespace Robust.Client.UserInterface.Controls
             return (32, 32) * Scale;
         }
 
-        internal override void DrawInternal(IRenderHandle renderHandle)
+        public override void DrawInternal(IRenderHandle renderHandle)
         {
             if (Sprite == null || Sprite.Deleted)
             {

Robust.Client/UserInterface/Controls/Tree.cs

@@ -20,7 +20,7 @@ namespace Robust.Client.UserInterface.Controls
 
         public bool HideRoot { get; set; }
 
-        public Item? Root => _root;
+        public Item? TreeRoot => _root;
 
         public Item? Selected => _selectedIndex == null ? null : _itemList[_selectedIndex.Value];
 

Robust.Client/UserInterface/CustomControls/DebugConsole.xaml.cs

@@ -288,7 +288,7 @@ namespace Robust.Client.UserInterface.CustomControls
                 }
                 catch (Exception e)
                 {
-                    sawmill.Warning("Failed to load debug console history due to exception!\n{e}");
+                    sawmill.Warning($"Failed to load debug console history due to exception!\n{e}");
                     return null;
                 }
                 finally

Robust.Client/UserInterface/CustomControls/SS14Window.xaml.cs

@@ -96,7 +96,7 @@ namespace Robust.Client.UserInterface.CustomControls
             var (spaceX, spaceY) = Parent!.Size;
             if (Position.Y > spaceY)
             {
-                LayoutContainer.SetPosition(this, (Position.X, spaceY - HEADER_SIZE_Y));
+                LayoutContainer.SetPosition(this, (Position.X, spaceY + HEADER_SIZE_Y));
             }
 
             if (Position.X > spaceX)
@@ -104,6 +104,16 @@ namespace Robust.Client.UserInterface.CustomControls
                 // 50 is arbitrary here. As long as it's bumped back into view.
                 LayoutContainer.SetPosition(this, (spaceX - 50, Position.Y));
             }
+
+            if (Position.Y < 0)
+            {
+                LayoutContainer.SetPosition(this, (Position.X, 0));
+            }
+
+            if (Position.X < 0)
+            {
+                LayoutContainer.SetPosition(this, (0, Position.Y));
+            }
         }
 
         protected override DragMode GetDragModeFor(Vector2 relativeMousePos)

Robust.Client/UserInterface/UserInterfaceManager.cs

@@ -25,8 +25,6 @@ namespace Robust.Client.UserInterface
     {
         [Dependency] private readonly IInputManager _inputManager = default!;
         [Dependency] private readonly IClydeInternal _clyde = default!;
-        [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
-        [Dependency] private readonly IResourceManager _resourceManager = default!;
         [Dependency] private readonly IGameTiming _gameTiming = default!;
         [Dependency] private readonly IPlayerManager _playerManager = default!;
         [Dependency] private readonly IEyeManager _eyeManager = default!;

Robust.Client/ViewVariables/ViewVariablesInstance.cs

@@ -58,7 +58,7 @@ namespace Robust.Client.ViewVariables
             var styleOther = false;
             var type = obj.GetType();
 
-            var members = new List<(MemberInfo, VVAccess, object? value, Action<object, bool> onValueChanged, Type)>();
+            var members = new List<(MemberInfo, VVAccess, object? value, Action<object?, bool> onValueChanged, Type)>();
 
             foreach (var fieldInfo in type.GetAllFields())
             {

Robust.Server/BaseServer.cs

@@ -306,7 +306,6 @@ namespace Robust.Server
             // Call Init in game assemblies.
             _modLoader.BroadcastRunLevel(ModRunLevel.Init);
             _entityManager.Initialize();
-            IoCManager.Resolve<IEntityLookup>().Initialize();
 
             IoCManager.Resolve<ISerializationManager>().Initialize();
 
@@ -319,6 +318,7 @@ namespace Robust.Server
 
             IoCManager.Resolve<IServerConsoleHost>().Initialize();
             _entityManager.Startup();
+            IoCManager.Resolve<IEntityLookup>().Startup();
             _stateManager.Initialize();
             _scriptHost.Initialize();
 

Robust.Server/Console/Commands/PlayerCommands.cs

@@ -57,9 +57,8 @@ namespace Robust.Server.Console.Commands
             else
             {
                 var mapEnt = mapMgr.GetMapEntity(mapId);
-
-                transform.AttachParent(mapEnt);
                 transform.WorldPosition = position;
+                transform.AttachParent(mapEnt);
             }
 
             shell.WriteLine($"Teleported {player} to {mapId}:{posX},{posY}.");

Robust.Server/Debugging/DebugDrawingManager.cs

@@ -1,4 +1,5 @@
 using System.Diagnostics;
+using JetBrains.Annotations;
 using Robust.Shared.IoC;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
@@ -6,10 +7,10 @@ using Robust.Shared.Physics;
 
 namespace Robust.Server.Debugging
 {
+    [UsedImplicitly]
     internal class DebugDrawingManager : IDebugDrawingManager
     {
         [Dependency] private readonly IServerNetManager _net = default!;
-        [Dependency] private readonly IPhysicsManager _physics = default!;
 
         public void Initialize()
         {

Robust.Server/GameObjects/Components/Actor/ActorComponent.cs

@@ -5,21 +5,21 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Server.GameObjects
 {
-    public class BasicActorComponent : Component, IActorComponent
+    public class ActorComponent : Component
     {
-        public override string Name => "BasicActor";
+        public override string Name => "Actor";
 
-        [ViewVariables] public IPlayerSession playerSession { get; internal set; } = default!;
+        [ViewVariables] public IPlayerSession PlayerSession { get; internal set; } = default!;
 
         /// <inheritdoc />
         protected override void Shutdown()
         {
             base.Shutdown();
-            
+
             // Warning: careful here, Detach removes this component, make sure this is after the base shutdown
             // to prevent infinite recursion
             // ReSharper disable once ConstantConditionalAccessQualifier
-            playerSession?.DetachFromEntity();
+            PlayerSession?.DetachFromEntity();
         }
     }
 
@@ -27,6 +27,7 @@ namespace Robust.Server.GameObjects
     ///     Raised on an entity whenever a player attaches to this entity.
     /// </summary>
     [Serializable]
+    [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
     public class PlayerAttachedMsg : ComponentMessage
     {
         public IPlayerSession NewPlayer { get; }
@@ -41,6 +42,7 @@ namespace Robust.Server.GameObjects
     ///     Raised on an entity whenever a player detaches from this entity.
     /// </summary>
     [Serializable]
+    [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
     public class PlayerDetachedMsg : ComponentMessage
     {
         public IPlayerSession OldPlayer { get; }

Robust.Server/GameObjects/Components/Actor/IActorComponent.cs

@@ -1,10 +0,0 @@
-using Robust.Server.Player;
-using Robust.Shared.GameObjects;
-
-namespace Robust.Server.GameObjects
-{
-    public interface IActorComponent : IComponent
-    {
-        IPlayerSession playerSession { get; }
-    }
-}

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

@@ -7,6 +7,7 @@ using Robust.Shared.Players;
 
 namespace Robust.Server.GameObjects
 {
+    [ComponentReference(typeof(SharedAppearanceComponent))]
     public sealed class AppearanceComponent : SharedAppearanceComponent
     {
         [ViewVariables]

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

@@ -8,6 +8,7 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Server.GameObjects
 {
+    [ComponentReference(typeof(SharedEyeComponent))]
     public class EyeComponent : SharedEyeComponent
     {
         [DataField("drawFov")]

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

@@ -14,6 +14,8 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Server.GameObjects
 {
+    [ComponentReference(typeof(SharedSpriteComponent))]
+    [ComponentReference(typeof(ISpriteRenderableComponent))]
     public class SpriteComponent : SharedSpriteComponent, ISpriteRenderableComponent, ISerializationHooks
     {
         const string LayerSerializationCache = "spritelayersrv";

Robust.Server/GameObjects/Components/UserInterface/ServerUserInterfaceComponent.cs

@@ -7,8 +7,6 @@ using Robust.Server.Player;
 using Robust.Shared.Enums;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Log;
-using Robust.Shared.Network;
-using Robust.Shared.Players;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager.Attributes;
 
@@ -20,6 +18,7 @@ namespace Robust.Server.GameObjects
     /// </summary>
     /// <seealso cref="BoundUserInterface"/>
     [PublicAPI]
+    [ComponentReference(typeof(SharedUserInterfaceComponent))]
     public sealed class ServerUserInterfaceComponent : SharedUserInterfaceComponent, ISerializationHooks
     {
         private readonly Dictionary<object, BoundUserInterface> _interfaces =
@@ -48,7 +47,8 @@ namespace Robust.Server.GameObjects
             return _interfaces[uiKey];
         }
 
-        public bool TryGetBoundUserInterface(object uiKey, [NotNullWhen(true)] out BoundUserInterface? boundUserInterface)
+        public bool TryGetBoundUserInterface(object uiKey,
+            [NotNullWhen(true)] out BoundUserInterface? boundUserInterface)
         {
             return _interfaces.TryGetValue(uiKey, out boundUserInterface);
         }
@@ -67,32 +67,20 @@ namespace Robust.Server.GameObjects
 
         internal void SendToSession(IPlayerSession session, BoundUserInterfaceMessage message, object uiKey)
         {
-            SendNetworkMessage(new BoundInterfaceMessageWrapMessage(message, uiKey), session.ConnectedClient);
+            EntitySystem.Get<UserInterfaceSystem>()
+                .SendTo(session, new BoundUIWrapMessage(Owner.Uid, message, uiKey));
         }
 
-        public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel,
-            ICommonSession? session = null)
+        internal void ReceiveMessage(IPlayerSession session, BoundUIWrapMessage msg)
         {
-            base.HandleNetworkMessage(message, netChannel, session);
-
-            switch (message)
+            if (!_interfaces.TryGetValue(msg.UiKey, out var @interface))
             {
-                case BoundInterfaceMessageWrapMessage wrapped:
-                    if (session == null)
-                    {
-                        throw new ArgumentNullException(nameof(session));
-                    }
-
-                    if (!_interfaces.TryGetValue(wrapped.UiKey, out var @interface))
-                    {
-                        Logger.DebugS("go.comp.ui", "Got BoundInterfaceMessageWrapMessage for unknown UI key: {0}",
-                            wrapped.UiKey);
-                        return;
-                    }
-
-                    @interface.ReceiveMessage(wrapped.Message, (IPlayerSession)session);
-                    break;
+                Logger.DebugS("go.comp.ui", "Got BoundInterfaceMessageWrapMessage for unknown UI key: {0}",
+                    msg.UiKey);
+                return;
             }
+
+            @interface.ReceiveMessage(msg.Message, session);
         }
     }
 
@@ -153,6 +141,7 @@ namespace Robust.Server.GameObjects
             {
                 _playerStateOverrides[session] = state;
             }
+
             _stateDirty = true;
         }
 
@@ -178,7 +167,6 @@ namespace Robust.Server.GameObjects
         }
 
 
-
         /// <summary>
         ///     Opens this interface for a specific client.
         /// </summary>

Robust.Server/GameObjects/EntitySystems/AudioSystem.cs

@@ -80,13 +80,9 @@ namespace Robust.Server.GameObjects
                 Identifier = id
             };
 
-            var players = (playerFilter as IFilter).Recipients;
-            foreach (var player in players)
-            {
-                RaiseNetworkEvent(msg, player.ConnectedClient);
-            }
+            RaiseNetworkEvent(msg, playerFilter);
 
-            return new AudioSourceServer(this, id, players);
+            return new AudioSourceServer(this, id, playerFilter.Recipients.ToArray());
         }
 
         /// <inheritdoc />
@@ -105,21 +101,14 @@ namespace Robust.Server.GameObjects
                 AudioParams = audioParams ?? AudioParams.Default,
                 Identifier = id,
             };
-            
-            IList<ICommonSession> players;
-            var recipients = (playerFilter as IFilter).Recipients;
 
+            // We clone the filter here as to not modify the original instance.
             if (range > 0.0f)
-                players = PasInRange(recipients, entity.Transform.MapPosition, range);
-            else
-                players = recipients;
+                playerFilter = playerFilter.Clone().AddInRange(entity.Transform.MapPosition, range);
 
-            foreach (var player in players)
-            {
-                RaiseNetworkEvent(msg, player.ConnectedClient);
-            }
-            
-            return new AudioSourceServer(this, id, players);
+            RaiseNetworkEvent(msg, playerFilter);
+
+            return new AudioSourceServer(this, id, playerFilter.Recipients.ToArray());
         }
 
         /// <inheritdoc />
@@ -136,29 +125,14 @@ namespace Robust.Server.GameObjects
                 AudioParams = audioParams ?? AudioParams.Default,
                 Identifier = id
             };
-            
-            IList<ICommonSession> players;
-            var recipients = (playerFilter as IFilter).Recipients;
 
+            // We clone the filter here as to not modify the original instance.
             if (range > 0.0f)
-                players = PasInRange(recipients, coordinates.ToMap(EntityManager), range);
-            else
-                players = recipients;
+                playerFilter = playerFilter.Clone().AddInRange(coordinates.ToMap(EntityManager), range);
 
-            foreach (var player in players)
-            {
-                RaiseNetworkEvent(msg, player.ConnectedClient);
-            }
-            
-            return new AudioSourceServer(this, id, players);
-        }
+            RaiseNetworkEvent(msg, playerFilter);
 
-        private static List<ICommonSession> PasInRange(IEnumerable<ICommonSession> players, MapCoordinates position, float range)
-        {
-            return players.Where(x =>
-                    x.AttachedEntity != null &&
-                    position.InRange(x.AttachedEntity.Transform.MapPosition, range))
-                .ToList();
+            return new AudioSourceServer(this, id, playerFilter.Recipients.ToArray());
         }
     }
 }

Robust.Server/GameObjects/EntitySystems/InputSystem.cs

@@ -30,6 +30,8 @@ namespace Robust.Server.GameObjects
         /// <inheritdoc />
         public override void Shutdown()
         {
+            base.Shutdown();
+
             _playerManager.PlayerStatusChanged -= OnPlayerStatusChanged;
         }
 

Robust.Server/GameObjects/EntitySystems/TileLookup/GridTileLookupSystem.cs

@@ -219,9 +219,7 @@ namespace Robust.Server.GameObjects
         public override void Shutdown()
         {
             base.Shutdown();
-            UnsubscribeLocalEvent<MoveEvent>();
-            UnsubscribeLocalEvent<EntityInitializedMessage>();
-            UnsubscribeLocalEvent<EntityDeletedMessage>();
+
             _mapManager.OnGridCreated -= HandleGridCreated;
             _mapManager.OnGridRemoved -= HandleGridRemoval;
             _mapManager.TileChanged -= HandleTileChanged;
@@ -320,7 +318,12 @@ namespace Robust.Server.GameObjects
         /// <param name="moveEvent"></param>
         private void HandleEntityMove(MoveEvent moveEvent)
         {
-            if (moveEvent.Sender.Deleted || moveEvent.NewPosition.GetGridId(EntityManager) == GridId.Invalid || !moveEvent.NewPosition.IsValid(EntityManager))
+            // TODO: When Acruid does TileEntities we may actually be able to delete this system if tile lookups become fast enough
+            var gridId = moveEvent.NewPosition.GetGridId(EntityManager);
+
+            if (moveEvent.Sender.Deleted ||
+                gridId == GridId.Invalid ||
+                !moveEvent.NewPosition.IsValid(EntityManager))
             {
                 HandleEntityRemove(moveEvent.Sender);
                 return;
@@ -332,7 +335,7 @@ namespace Robust.Server.GameObjects
             }
 
             // Memory leak protection
-            var gridBounds = _mapManager.GetGrid(moveEvent.Sender.Transform.GridID).WorldBounds;
+            var gridBounds = _mapManager.GetGrid(gridId).WorldBounds;
             if (!gridBounds.Contains(moveEvent.Sender.Transform.WorldPosition))
             {
                 HandleEntityRemove(moveEvent.Sender);

Robust.Server/GameObjects/EntitySystems/UserInterfaceSystem.cs

@@ -22,6 +22,31 @@ namespace Robust.Server.GameObjects
         /// <inheritdoc />
         public override void Initialize()
         {
+            base.Initialize();
+
+            SubscribeNetworkEvent<BoundUIWrapMessage>(OnMessageReceived);
+            SubscribeLocalEvent<ServerUserInterfaceComponent, ComponentShutdown>(OnUserInterfaceShutdown);
+        }
+
+        private void OnUserInterfaceShutdown(EntityUid uid, ServerUserInterfaceComponent component, ComponentShutdown args)
+        {
+            foreach (var bui in component.Interfaces)
+            {
+                DeactivateInterface(bui);
+            }
+        }
+
+        internal void SendTo(IPlayerSession session, BoundUIWrapMessage msg)
+        {
+            RaiseNetworkEvent(msg, session.ConnectedClient);
+        }
+
+        private void OnMessageReceived(BoundUIWrapMessage msg, EntitySessionEventArgs args)
+        {
+            if (!ComponentManager.TryGetComponent<ServerUserInterfaceComponent>(msg.Entity, out var uiComp))
+                return;
+
+            uiComp.ReceiveMessage((IPlayerSession) args.SenderSession, msg);
         }
 
         /// <inheritdoc />

Robust.Server/GameObjects/ServerComponentFactory.cs

@@ -1,68 +1,37 @@
 using Robust.Shared.Containers;
 using Robust.Shared.GameObjects;
 
-using Robust.Shared.Physics;
-
 namespace Robust.Server.GameObjects
 {
     public class ServerComponentFactory : ComponentFactory
     {
         public ServerComponentFactory()
         {
-            // Required for the engine to work
-            Register<MetaDataComponent>();
-            RegisterReference<MetaDataComponent, IMetaDataComponent>();
-
-            // Required for the engine to work
-            Register<TransformComponent>();
-            RegisterReference<TransformComponent, ITransformComponent>();
-
-            Register<MapComponent>();
-            RegisterReference<MapComponent, IMapComponent>();
-
-            Register<MapGridComponent>();
-            RegisterReference<MapGridComponent, IMapGridComponent>();
-
-            Register<EyeComponent>();
-            RegisterReference<EyeComponent, SharedEyeComponent>();
-
-            Register<BasicActorComponent>();
-            RegisterReference<BasicActorComponent, IActorComponent>();
-
-            Register<PhysicsComponent>();
-            RegisterReference<PhysicsComponent, IPhysBody>();
-
-            Register<CollisionWakeComponent>();
-
-            Register<ContainerManagerComponent>();
-            RegisterReference<ContainerManagerComponent, IContainerManager>();
-
-            Register<OccluderComponent>();
-
             RegisterIgnore("Input");
-            Register<SpriteComponent>();
-            RegisterReference<SpriteComponent, SharedSpriteComponent>();
-            RegisterReference<SpriteComponent, ISpriteRenderableComponent>();
-
-            Register<AppearanceComponent>();
-            RegisterReference<AppearanceComponent, SharedAppearanceComponent>();
-
-            Register<SnapGridComponent>();
-
-            Register<ServerUserInterfaceComponent>();
-            RegisterReference<ServerUserInterfaceComponent, SharedUserInterfaceComponent>();
-
-            Register<TimerComponent>();
-
             RegisterIgnore("AnimationPlayer");
 
-#if DEBUG
-            Register<DebugExceptionOnAddComponent>();
-            Register<DebugExceptionInitializeComponent>();
-            Register<DebugExceptionStartupComponent>();
-#endif
+            RegisterClass<MetaDataComponent>();
+            RegisterClass<TransformComponent>();
+            RegisterClass<MapComponent>();
+            RegisterClass<MapGridComponent>();
+            RegisterClass<EyeComponent>();
+            RegisterClass<ActorComponent>();
+            RegisterClass<PhysicsComponent>();
+            RegisterClass<CollisionWakeComponent>();
+            RegisterClass<ContainerManagerComponent>();
+            RegisterClass<OccluderComponent>();
+            RegisterClass<SpriteComponent>();
+            RegisterClass<AppearanceComponent>();
+            RegisterClass<SnapGridComponent>();
+            RegisterClass<ServerUserInterfaceComponent>();
+            RegisterClass<TimerComponent>();
+            RegisterClass<MapSaveIdComponent>();
 
-            Register<MapSaveIdComponent>();
+#if DEBUG
+            RegisterClass<DebugExceptionOnAddComponent>();
+            RegisterClass<DebugExceptionInitializeComponent>();
+            RegisterClass<DebugExceptionStartupComponent>();
+#endif
         }
     }
 }

Robust.Server/GameObjects/ServerEntityManager.cs

@@ -137,6 +137,7 @@ namespace Robust.Server.GameObjects
         }
 
         /// <inheritdoc />
+        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
         public void SendComponentNetworkMessage(INetChannel? channel, IEntity entity, IComponent component,
             ComponentMessage message)
         {

Robust.Server/GameStates/EntityViewCulling.cs

@@ -132,11 +132,11 @@ namespace Robust.Server.GameStates
             if (session.Status != SessionStatus.InGame || session.AttachedEntityUid is null)
                 return viewers;
 
-            var query = _compMan.EntityQuery<BasicActorComponent>();
+            var query = _compMan.EntityQuery<ActorComponent>();
 
             foreach (var actorComp in query)
             {
-                if (actorComp.playerSession == session)
+                if (actorComp.PlayerSession == session)
                     viewers.Add(actorComp.Owner.Uid);
             }
 

Robust.Server/Map/ServerMapManager.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using JetBrains.Annotations;
 using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
@@ -9,10 +10,9 @@ using Robust.Shared.Timing;
 
 namespace Robust.Server.Map
 {
+    [UsedImplicitly]
     internal sealed class ServerMapManager : MapManager, IServerMapManager
     {
-        [Dependency] private readonly INetManager _netManager = default!;
-
         private readonly List<(GameTick tick, GridId gridId)> _gridDeletionHistory = new();
         private readonly List<(GameTick tick, MapId mapId)> _mapDeletionHistory = new();
 

Robust.Server/Maps/MapLoader.cs

@@ -15,7 +15,9 @@ using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Manager.Result;
 using Robust.Shared.Serialization.Markdown;
+using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Validation;
+using Robust.Shared.Serialization.Markdown.Value;
 using Robust.Shared.Serialization.TypeSerializers.Interfaces;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
@@ -767,7 +769,7 @@ namespace Robust.Server.Maps
                         // Don't need to write it if nothing was written!
                         if (compMapping.Children.Count != 0)
                         {
-                            compMapping.AddNode("type", new ValueDataNode(component.Name));
+                            compMapping.Add("type", new ValueDataNode(component.Name));
                             // Something actually got written!
                             components.Add(compMapping.ToYamlNode());
                         }

Robust.Server/Placement/PlacementManager.cs

@@ -212,7 +212,7 @@ namespace Robust.Server.Placement
             foreach (IEntity entity in IoCManager.Resolve<IEntityLookup>().GetEntitiesIntersecting(start.GetMapId(_entityManager),
                 new Box2(start.Position, start.Position + rectSize)))
             {
-                if (entity.Deleted || entity.HasComponent<IMapGridComponent>() || entity.HasComponent<IActorComponent>())
+                if (entity.Deleted || entity.HasComponent<IMapGridComponent>() || entity.HasComponent<ActorComponent>())
                     continue;
                 entity.Delete();
             }
@@ -223,10 +223,10 @@ namespace Robust.Server.Placement
         /// </summary>
         public void SendPlacementBegin(IEntity mob, int range, string objectType, string alignOption)
         {
-            if (!mob.TryGetComponent<IActorComponent>(out var actor))
+            if (!mob.TryGetComponent<ActorComponent>(out var actor))
                 return;
 
-            var playerConnection = actor.playerSession.ConnectedClient;
+            var playerConnection = actor.PlayerSession.ConnectedClient;
             if (playerConnection == null)
                 return;
 
@@ -244,10 +244,10 @@ namespace Robust.Server.Placement
         /// </summary>
         public void SendPlacementBeginTile(IEntity mob, int range, string tileType, string alignOption)
         {
-            if (!mob.TryGetComponent<IActorComponent>(out var actor))
+            if (!mob.TryGetComponent<ActorComponent>(out var actor))
                 return;
 
-            var playerConnection = actor.playerSession.ConnectedClient;
+            var playerConnection = actor.PlayerSession.ConnectedClient;
             if (playerConnection == null)
                 return;
 
@@ -265,10 +265,10 @@ namespace Robust.Server.Placement
         /// </summary>
         public void SendPlacementCancel(IEntity mob)
         {
-            if (!mob.TryGetComponent<IActorComponent>(out var actor))
+            if (!mob.TryGetComponent<ActorComponent>(out var actor))
                 return;
 
-            var playerConnection = actor.playerSession.ConnectedClient;
+            var playerConnection = actor.PlayerSession.ConnectedClient;
             if (playerConnection == null)
                 return;
 

Robust.Server/Player/PlayerHelpers.cs

@@ -10,10 +10,10 @@ namespace Robust.Server.Player
             if (entity == null)
                 return null;
             
-            if (!entity.TryGetComponent(out IActorComponent? actorComponent))
+            if (!entity.TryGetComponent(out ActorComponent? actorComponent))
                 return null;
 
-            return actorComponent.playerSession;
+            return actorComponent.PlayerSession;
         }
     }
 }

Robust.Server/Player/PlayerManager.cs

@@ -55,10 +55,24 @@ namespace Robust.Server.Player
         private readonly Dictionary<string, NetUserId> _userIdMap = new();
 
         /// <inheritdoc />
-        public IEnumerable<ICommonSession> NetworkedSessions => _sessions.Values;
+        public IEnumerable<ICommonSession> NetworkedSessions => Sessions;
 
         /// <inheritdoc />
-        public IEnumerable<ICommonSession> Sessions => _sessions.Values;
+        public IEnumerable<ICommonSession> Sessions
+        {
+            get
+            {
+                _sessionsLock.EnterReadLock();
+                try
+                {
+                    return _sessions.Values;
+                }
+                finally
+                {
+                    _sessionsLock.ExitReadLock();
+                }
+            }
+        }
 
         /// <inheritdoc />
         [ViewVariables]
@@ -109,11 +123,20 @@ namespace Robust.Server.Player
                 return false;
             }
 
-            if (_sessions.TryGetValue(userId, out var iSession))
+            _sessionsLock.EnterReadLock();
+            try
             {
-                session = iSession;
-                return true;
+                if (_sessions.TryGetValue(userId, out var iSession))
+                {
+                    session = iSession;
+                    return true;
+                }
             }
+            finally
+            {
+                _sessionsLock.ExitReadLock();
+            }
+
 
             session = null;
             return false;
@@ -210,7 +233,9 @@ namespace Robust.Server.Player
             try
             {
                 foreach (var s in _sessions.Values)
+                {
                     s.JoinGame();
+                }
             }
             finally
             {
@@ -237,7 +262,9 @@ namespace Robust.Server.Player
             try
             {
                 foreach (var s in _sessions.Values)
+                {
                     s.DetachFromEntity();
+                }
             }
             finally
             {
@@ -286,9 +313,7 @@ namespace Robust.Server.Player
             try
             {
                 return
-                    _sessions.Values.Where(predicate)
-                        .Cast<IPlayerSession>()
-                        .ToList();
+                    _sessions.Values.Where(predicate).ToList();
             }
             finally
             {

Robust.Server/Player/PlayerSession.cs

@@ -118,8 +118,8 @@ namespace Robust.Server.Player
                 return;
             }
 
-            var actorComponent = a.AddComponent<BasicActorComponent>();
-            actorComponent.playerSession = this;
+            var actorComponent = a.AddComponent<ActorComponent>();
+            actorComponent.PlayerSession = this;
             AttachedEntity = a;
             a.SendMessage(actorComponent, new PlayerAttachedMsg(this));
             a.EntityManager.EventBus.RaiseEvent(EventSource.Local, new PlayerAttachSystemMessage(a, this));
@@ -137,11 +137,11 @@ namespace Robust.Server.Player
                 throw new InvalidOperationException("Tried to detach player, but my entity does not exist!");
             }
 
-            if (AttachedEntity.TryGetComponent<BasicActorComponent>(out var actor))
+            if (AttachedEntity.TryGetComponent<ActorComponent>(out var actor))
             {
                 AttachedEntity.SendMessage(actor, new PlayerDetachedMsg(this));
                 AttachedEntity.EntityManager.EventBus.RaiseEvent(EventSource.Local, new PlayerDetachedSystemMessage(AttachedEntity));
-                AttachedEntity.RemoveComponent<BasicActorComponent>();
+                AttachedEntity.RemoveComponent<ActorComponent>();
                 AttachedEntity = null;
                 UpdatePlayerState();
             }

Robust.Server/ServerIoC.cs

@@ -46,7 +46,7 @@ namespace Robust.Server
             IoCManager.Register<IMapManagerInternal, ServerMapManager>();
             IoCManager.Register<IServerMapManager, ServerMapManager>();
             IoCManager.Register<IEntityManager, ServerEntityManager>();
-            IoCManager.Register<IEntityLookup, SharedEntityLookup>();
+            IoCManager.Register<IEntityLookup, EntityLookup>();
             IoCManager.Register<IEntityNetworkManager, ServerEntityManager>();
             IoCManager.Register<IServerEntityNetworkManager, ServerEntityManager>();
             IoCManager.Register<IMapLoader, MapLoader>();

Robust.Shared/CVars.cs

@@ -415,14 +415,26 @@ namespace Robust.Shared
             CVarDef.Create("physics.maxangularcorrection", 8.0f / 180.0f * MathF.PI);
 
         // - Maximums
-        // Squared
-        // 35 m/s, AKA half a tile per frame allowed. Divide this by frametime to get units per second.
+        /// <summary>
+        /// Maximum linear velocity per second.
+        /// Make sure that MaxLinVelocity / <see cref="NetTickrate"/> is around 0.5 or higher so that moving objects don't go through walls.
+        /// MaxLinVelocity is compared to the dot product of linearVelocity * frameTime.
+        /// </summary>
+        /// <remarks>
+        /// Default is 35 m/s. Around half a tile per tick at 60 ticks per second.
+        /// </remarks>
         public static readonly CVarDef<float> MaxLinVelocity =
-            CVarDef.Create("physics.maxlinvelocity", 0.56f);
+            CVarDef.Create("physics.maxlinvelocity", 35f);
 
-        // Squared
+        /// <summary>
+        /// Maximum angular velocity in full rotations per second.
+        /// MaxAngVelocity is compared to the squared rotation.
+        /// </summary>
+        /// <remarks>
+        /// Default is 15 rotations per second. Approximately a quarter rotation per tick at 60 ticks per second.
+        /// </remarks>
         public static readonly CVarDef<float> MaxAngVelocity =
-            CVarDef.Create("physics.maxangvelocity", 0.5f * MathF.PI);
+            CVarDef.Create("physics.maxangvelocity", 15f);
 
         /*
          * DISCORD

Robust.Shared/Containers/ContainerContentsModifiedMessage.cs

@@ -1,3 +1,4 @@
+using System;
 using Robust.Shared.GameObjects;
 
 namespace Robust.Shared.Containers
@@ -5,6 +6,7 @@ namespace Robust.Shared.Containers
     /// <summary>
     /// The contents of this container have been changed.
     /// </summary>
+    [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
     public class ContainerContentsModifiedMessage : ComponentMessage
     {
         /// <summary>
@@ -35,4 +37,4 @@ namespace Robust.Shared.Containers
             Removed = removed;
         }
     }
-}
+}

Robust.Shared/Containers/ContainerManagerComponent.cs

@@ -16,8 +16,7 @@ namespace Robust.Shared.Containers
     /// <summary>
     /// Holds data about a set of entity containers on this entity.
     /// </summary>
-    // [RegisterComponent]
-    // [ComponentReference(typeof(IContainerManager))]
+    [ComponentReference(typeof(IContainerManager))]
     public class ContainerManagerComponent : Component, IContainerManager
     {
         [Dependency] private readonly IRobustSerializer _serializer = default!;

Robust.Shared/Enums/Gender.cs

@@ -1,11 +1,30 @@
 
 namespace Robust.Shared.Enums
 {
+    /// <summary>
+    ///     Represents a grammatical gender of an object.
+    /// </summary>
     public enum Gender : byte
     {
+        /// <summary>
+        ///     Object has no gender and a gender probably makes no sense. Think inanimate objects. It/it.
+        /// </summary>
+        Neuter = 0,
+
+        /// <summary>
+        ///     Object is something you would consider as *capable of having a gender*, but *doesn't*.
+        ///     Think people without (visible/unambiguous) gender. They/them.
+        /// </summary>
         Epicene,
+
+        /// <summary>
+        ///     Female gender. She/her
+        /// </summary>
         Female,
+
+        /// <summary>
+        ///     Male gender. He/his
+        /// </summary>
         Male,
-        Neuter,
     }
 }

Robust.Shared/GameObjects/Component.cs

@@ -210,9 +210,11 @@ namespace Robust.Shared.GameObjects
         }
 
         /// <inheritdoc />
+        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
         public virtual void HandleMessage(ComponentMessage message, IComponent? component) { }
 
         /// <inheritdoc />
+        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
         public virtual void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession? session = null) { }
 
         /// <param name="player"></param>

Robust.Shared/GameObjects/ComponentMessage.cs

@@ -7,6 +7,7 @@ namespace Robust.Shared.GameObjects
     ///     A message containing info to send through the component message system.
     /// </summary>
     [Serializable, NetSerializable]
+    [Obsolete("Component messages are deprecated. Use directed local events instead.")]
     public abstract class ComponentMessage
     {
         /// <summary>

Robust.Shared/GameObjects/ComponentMessages/Messages.cs

@@ -1,7 +1,9 @@
-using JetBrains.Annotations;
+using System;
+using JetBrains.Annotations;
 
 namespace Robust.Shared.GameObjects
 {
+    [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
     public class RelayMovementEntityMessage : ComponentMessage
     {
         [PublicAPI]
@@ -16,6 +18,7 @@ namespace Robust.Shared.GameObjects
     /// <summary>
     ///     The entity transform parent has been changed.
     /// </summary>
+    [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
     public class ParentChangedMessage : ComponentMessage
     {
         /// <summary>

Robust.Shared/GameObjects/Components/Collidable/PhysicsComponent.Physics.cs

@@ -98,7 +98,6 @@ namespace Robust.Shared.GameObjects
                 if (_bodyType == value)
                     return;
 
-                var oldAnchored = _bodyType == BodyType.Static;
                 var oldType = _bodyType;
                 _bodyType = value;
 
@@ -121,14 +120,7 @@ namespace Robust.Shared.GameObjects
 
                 RegenerateContacts();
 
-                var anchored = value == BodyType.Static;
-
                 Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, new PhysicsBodyTypeChangedEvent(_bodyType, oldType), false);
-
-                if (oldAnchored != anchored)
-                {
-                    SendMessage(new AnchoredChangedMessage(Anchored));
-                }
             }
         }
 
@@ -900,35 +892,6 @@ namespace Robust.Shared.GameObjects
             }
         }
 
-        /// <summary>
-        ///     Whether or not the entity is anchored in place.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        [Obsolete("Use BodyType.Static instead")]
-        public bool Anchored
-        {
-            get => BodyType == BodyType.Static;
-            set
-            {
-                var anchored = BodyType == BodyType.Static;
-
-                if (anchored == value)
-                    return;
-
-                if (value)
-                {
-                    _bodyType = BodyType.Static;
-                }
-                else
-                {
-                    _bodyType = BodyType.Dynamic;
-                }
-
-                SendMessage(new AnchoredChangedMessage(Anchored));
-                Dirty();
-            }
-        }
-
         [ViewVariables(VVAccess.ReadWrite)]
         public bool Predict
         {
@@ -1331,6 +1294,7 @@ namespace Robust.Shared.GameObjects
 
             if (preventCollideMessage.Cancelled) return false;
 
+#pragma warning disable 618
             foreach (var comp in Owner.GetAllComponents<ICollideSpecial>())
             {
                 if (comp.PreventCollide(other)) return false;
@@ -1340,21 +1304,12 @@ namespace Robust.Shared.GameObjects
             {
                 if (comp.PreventCollide(this)) return false;
             }
+#pragma warning restore 618
 
             return true;
         }
     }
 
-    public class AnchoredChangedMessage : ComponentMessage
-    {
-        public readonly bool Anchored;
-
-        public AnchoredChangedMessage(bool anchored)
-        {
-            Anchored = anchored;
-        }
-    }
-
     /// <summary>
     ///     Directed event raised when an entity's physics BodyType changes.
     /// </summary>
@@ -1370,11 +1325,6 @@ namespace Robust.Shared.GameObjects
         /// </summary>
         public BodyType Old { get; }
 
-        /// <summary>
-        ///     Whether the body is "anchored".
-        /// </summary>
-        public bool Anchored => New == BodyType.Static;
-
         public PhysicsBodyTypeChangedEvent(BodyType newType, BodyType oldType)
         {
             New = newType;

Robust.Shared/GameObjects/Components/ITransformComponent.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using JetBrains.Annotations;
 using Robust.Shared.Animations;
 using Robust.Shared.Map;
@@ -93,9 +94,6 @@ namespace Robust.Shared.GameObjects
         /// </summary>
         bool IsMapTransform { get; }
 
-        /// <summary>
-        ///
-        /// </summary>
         Vector2? LerpDestination { get; }
 
         /// <summary>

Robust.Shared/GameObjects/Components/Localization/GrammarComponent.cs

@@ -1,9 +1,14 @@
+using System;
+using System.Collections.Generic;
 using Robust.Shared.Enums;
 using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Shared.GameObjects.Components.Localization
 {
+    /// <summary>
+    ///     Overrides grammar attributes specified in prototypes or localization files.
+    /// </summary>
     [RegisterComponent]
     public class GrammarComponent : Component
     {
@@ -11,15 +16,33 @@ namespace Robust.Shared.GameObjects.Components.Localization
         public override uint? NetID => NetIDs.GRAMMAR;
 
         [ViewVariables]
-        [DataField("localizationId")]
-        public string LocalizationId = "";
+        [DataField("attributes")]
+        public Dictionary<string, string> Attributes { get; } = new();
 
         [ViewVariables]
-        [DataField("gender")]
-        public Gender? Gender = null;
+        public Gender? Gender
+        {
+            get => Attributes.TryGetValue("gender", out var g) ? Enum.Parse<Gender>(g, true) : null;
+            set
+            {
+                if (value.HasValue)
+                    Attributes["gender"] = value.Value.ToString();
+                else
+                    Attributes.Remove("gender");
+            }
+        }
 
         [ViewVariables]
-        [DataField("proper")]
-        public bool? ProperNoun = null;
+        public bool? ProperNoun
+        {
+            get => Attributes.TryGetValue("proper", out var g) ? bool.Parse(g) : null;
+            set
+            {
+                if (value.HasValue)
+                    Attributes["proper"] = value.Value.ToString();
+                else
+                    Attributes.Remove("proper");
+            }
+        }
     }
 }

Robust.Shared/GameObjects/Components/Map/MapComponent.cs

@@ -1,6 +1,5 @@
 using System;
 using Robust.Shared.Map;
-using Robust.Shared.Prototypes;
 using Robust.Shared.Players;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager.Attributes;
@@ -18,6 +17,7 @@ namespace Robust.Shared.GameObjects
     }
 
     /// <inheritdoc cref="IMapComponent"/>
+    [ComponentReference(typeof(IMapComponent))]
     public class MapComponent : Component, IMapComponent
     {
         [ViewVariables(VVAccess.ReadOnly)]

Robust.Shared/GameObjects/Components/Map/MapGridComponent.cs

@@ -21,6 +21,7 @@ namespace Robust.Shared.GameObjects
     }
 
     /// <inheritdoc cref="IMapGridComponent"/>
+    [ComponentReference(typeof(IMapGridComponent))]
     internal class MapGridComponent : Component, IMapGridComponent
     {
         [Dependency] private readonly IMapManager _mapManager = default!;
@@ -51,6 +52,17 @@ namespace Robust.Shared.GameObjects
             _gridIndex = GridId.Invalid;
         }
 
+        public override void Initialize()
+        {
+            base.Initialize();
+            var mapId = Owner.Transform.MapID;
+
+            if (_mapManager.HasMapEntity(mapId))
+            {
+                Owner.Transform.AttachParent(_mapManager.GetMapEntity(mapId));
+            }
+        }
+
         /// <param name="player"></param>
         /// <inheritdoc />
         public override ComponentState GetComponentState(ICommonSession player)

Robust.Shared/GameObjects/Components/MetaDataComponent.cs

@@ -65,6 +65,7 @@ namespace Robust.Shared.GameObjects
     }
 
     /// <inheritdoc cref="IMetaDataComponent"/>
+    [ComponentReference(typeof(IMetaDataComponent))]
     internal class MetaDataComponent : Component, IMetaDataComponent
     {
         [Dependency] private readonly IPrototypeManager _prototypes = default!;

Robust.Shared/GameObjects/Components/Transform/TransformComponent.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Robust.Shared.Animations;
 using Robust.Shared.Containers;
@@ -14,6 +15,7 @@ using Robust.Shared.ViewVariables;
 
 namespace Robust.Shared.GameObjects
 {
+    [ComponentReference(typeof(ITransformComponent))]
     internal class TransformComponent : Component, ITransformComponent, IComponentDebug
     {
         [DataField("parent")]
@@ -65,25 +67,21 @@ namespace Robust.Shared.GameObjects
         [ViewVariables]
         public GridId GridID
         {
-            get
+            get => _gridId;
+            private set
             {
-                // root node, grid id is undefined
-                if (Owner.HasComponent<IMapComponent>())
-                    return GridId.Invalid;
-
-                // second level node, terminates recursion up the branch of the tree
-                if (Owner.TryGetComponent(out IMapGridComponent? gridComp))
-                    return gridComp.GridIndex;
-
-                // branch or leaf node
-                if (_parent.IsValid())
-                    return Parent!.GridID;
-
-                // Not on a grid
-                return GridId.Invalid;
+                if (_gridId.Equals(value)) return;
+                _gridId = value;
+                foreach (var transformComponent in Children)
+                {
+                    var child = (TransformComponent) transformComponent;
+                    child.GridID = value;
+                }
             }
         }
 
+        private GridId _gridId = GridId.Invalid;
+
         /// <inheritdoc />
         [ViewVariables(VVAccess.ReadWrite)]
         public bool NoLocalRotation
@@ -263,6 +261,7 @@ namespace Robust.Shared.GameObjects
             set
             {
                 var oldPosition = Coordinates;
+                _localPosition = value.Position;
 
                 if (value.EntityId != _parent)
                 {
@@ -270,7 +269,6 @@ namespace Robust.Shared.GameObjects
                     AttachParent(newEntity);
                 }
 
-                _localPosition = value.Position;
                 Dirty();
 
                 if (!DeferUpdates)
@@ -424,6 +422,28 @@ namespace Robust.Shared.GameObjects
                 // so duplicate additions (which will happen) don't matter.
                 ((TransformComponent) Parent!)._children.Add(Owner.Uid);
             }
+
+            GridID = GetGridIndex();
+        }
+
+        private GridId GetGridIndex()
+        {
+            if (Owner.HasComponent<IMapComponent>())
+            {
+                return GridId.Invalid;
+            }
+
+            if (Owner.TryGetComponent(out IMapGridComponent? gridComponent))
+            {
+                return gridComponent.GridIndex;
+            }
+
+            if (_parent.IsValid())
+            {
+                return Parent!.GridID;
+            }
+
+            return _mapManager.TryFindGridAt(MapID, WorldPosition, out var mapgrid) ? mapgrid.Index : GridId.Invalid;
         }
 
         /// <inheritdoc />
@@ -571,14 +591,14 @@ namespace Robust.Shared.GameObjects
             // offset position from world to parent
             SetPosition(newParent.InvWorldMatrix.Transform(WorldPosition));
             _parent = newParentEnt.Uid;
-
             ChangeMapId(newConcrete.MapID);
 
             Owner.EntityManager.EventBus.RaiseLocalEvent(Owner.Uid, entMessage);
             Owner.SendMessage(this, compMessage);
-            
+
             RebuildMatrices();
             Dirty();
+            GridID = GetGridIndex();
         }
 
         internal void ChangeMapId(MapId newMapId)

Robust.Shared/GameObjects/Components/UserInterface/SharedUserInterfaceComponent.cs

@@ -35,25 +35,6 @@ namespace Robust.Shared.GameObjects
                 UiKey = _uiKeyRaw;
             }
         }
-
-        [NetSerializable, Serializable]
-        protected sealed class BoundInterfaceMessageWrapMessage : ComponentMessage
-        {
-            public readonly BoundUserInterfaceMessage Message;
-            public readonly object UiKey;
-
-            public BoundInterfaceMessageWrapMessage(BoundUserInterfaceMessage message, object uiKey)
-            {
-                Directed = true;
-                Message = message;
-                UiKey = uiKey;
-            }
-
-            public override string ToString()
-            {
-                return $"{nameof(BoundInterfaceMessageWrapMessage)}: {Message}";
-            }
-        }
     }
 
     [NetSerializable, Serializable]
@@ -87,4 +68,24 @@ namespace Robust.Shared.GameObjects
     internal sealed class CloseBoundInterfaceMessage : BoundUserInterfaceMessage
     {
     }
+
+    [Serializable, NetSerializable]
+    internal sealed class BoundUIWrapMessage : EntityEventArgs
+    {
+        public readonly EntityUid Entity;
+        public readonly BoundUserInterfaceMessage Message;
+        public readonly object UiKey;
+
+        public BoundUIWrapMessage(EntityUid entity, BoundUserInterfaceMessage message, object uiKey)
+        {
+            Message = message;
+            UiKey = uiKey;
+            Entity = entity;
+        }
+
+        public override string ToString()
+        {
+            return $"{nameof(BoundUIWrapMessage)}: {Message}";
+        }
+    }
 }

Robust.Shared/GameObjects/Entity.cs

@@ -286,6 +286,12 @@ namespace Robust.Shared.GameObjects
             return TryGetComponent(type, out var component) ? component : null;
         }
 
+        /// <inheritdoc />
+        public void QueueDelete()
+        {
+            EntityManager.QueueDeleteEntity(this);
+        }
+
         /// <inheritdoc />
         public void Delete()
         {

Robust.Shared/GameObjects/EntityManager.cs

@@ -44,6 +44,8 @@ namespace Robust.Shared.GameObjects
         /// <inheritdoc />
         public virtual IEntityNetworkManager? EntityNetManager => null;
 
+        protected readonly HashSet<EntityUid> QueuedDeletions = new();
+
         /// <summary>
         ///     All entities currently stored in the manager.
         /// </summary>
@@ -112,6 +114,16 @@ namespace Robust.Shared.GameObjects
                 _eventBus.ProcessEventQueue();
             }
 
+            using (histogram?.WithLabels("QueuedDeletion").NewTimer())
+            {
+                foreach (var uid in QueuedDeletions)
+                {
+                    DeleteEntity(uid);
+                }
+
+                QueuedDeletions.Clear();
+            }
+
             using (histogram?.WithLabels("ComponentCull").NewTimer())
             {
                 _componentManager.CullRemovedComponents();
@@ -212,6 +224,7 @@ namespace Robust.Shared.GameObjects
             return false;
         }
 
+        [Obsolete("IEntityQuery is obsolete")]
         public IEnumerable<IEntity> GetEntities(IEntityQuery query)
         {
             return query.Match(this);
@@ -287,6 +300,16 @@ namespace Robust.Shared.GameObjects
             EventBus.RaiseEvent(EventSource.Local, new EntityDeletedMessage(entity));
         }
 
+        public void QueueDeleteEntity(IEntity entity)
+        {
+            QueueDeleteEntity(entity.Uid);
+        }
+
+        public void QueueDeleteEntity(EntityUid uid)
+        {
+            QueuedDeletions.Add(uid);
+        }
+
         public void DeleteEntity(EntityUid uid)
         {
             if (TryGetEntity(uid, out var entity))
@@ -359,7 +382,7 @@ namespace Robust.Shared.GameObjects
             // we want this called before adding components
             EntityAdded?.Invoke(this, entity.Uid);
 
-            // We do this after the event, so if the event throws we have not committed 
+            // We do this after the event, so if the event throws we have not committed
             Entities[entity.Uid] = entity;
             AllEntities.Add(entity);
 
@@ -457,6 +480,7 @@ namespace Robust.Shared.GameObjects
             var session = netMsg.Session;
             compMsg.Remote = true;
 
+#pragma warning disable 618
             var uid = netMsg.EntityUid;
             if (compMsg.Directed)
             {
@@ -470,6 +494,7 @@ namespace Robust.Shared.GameObjects
                     component.HandleNetworkMessage(compMsg, compChannel, session);
                 }
             }
+#pragma warning restore 618
         }
 
         /// <summary>

Robust.Shared/GameObjects/EntityQuery.cs

@@ -11,7 +11,7 @@ namespace Robust.Shared.GameObjects
     ///     An entity query that will let all entities pass.
     ///     This is the same as matching <c>ITransformComponent</c>, but faster.
     /// </summary>
-    [PublicAPI]
+    [PublicAPI, Obsolete]
     public class AllEntityQuery : IEntityQuery
     {
         /// <inheritdoc />
@@ -28,7 +28,7 @@ namespace Robust.Shared.GameObjects
     ///     An entity query which will match entities based on a predicate.
     ///     If you only want a single type of Component, use <c>TypeEntityQuery</c>.
     /// </summary>
-    [PublicAPI]
+    [PublicAPI, Obsolete]
     public class PredicateEntityQuery : IEntityQuery
     {
         private readonly Predicate<IEntity> Predicate;
@@ -59,7 +59,7 @@ namespace Robust.Shared.GameObjects
     ///     An entity query that will match one type of component.
     ///     This the fastest and most common query, and should be the default choice.
     /// </summary>
-    [PublicAPI]
+    [PublicAPI, Obsolete]
     public class TypeEntityQuery : IEntityQuery
     {
         private readonly Type ComponentType;
@@ -90,7 +90,7 @@ namespace Robust.Shared.GameObjects
     ///     This the fastest and most common query, and should be the default choice.
     /// </summary>
     /// <typeparamref name="T">Type of component to match.</typeparamref>
-    [PublicAPI]
+    [PublicAPI, Obsolete]
     public class TypeEntityQuery<T> : IEntityQuery where T : IComponent
     {
         public bool Match(IEntity entity) => entity.HasComponent<T>();
@@ -104,7 +104,7 @@ namespace Robust.Shared.GameObjects
     /// <summary>
     ///     An entity query that will match all entities that intersect with the argument entity.
     /// </summary>
-    [PublicAPI]
+    [PublicAPI, Obsolete]
     public class IntersectingEntityQuery : IEntityQuery
     {
         private readonly IEntity Entity;
@@ -137,7 +137,7 @@ namespace Robust.Shared.GameObjects
     /// <summary>
     ///     An entity query that will match entities that have all of the provided components.
     /// </summary>
-    [PublicAPI]
+    [PublicAPI, Obsolete]
     public class MultipleTypeEntityQuery : IEntityQuery
     {
         private readonly List<Type> ComponentTypes;

Robust.Shared/GameObjects/EntitySystem.Subscriptions.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+
+namespace Robust.Shared.GameObjects
+{
+    public abstract partial class EntitySystem
+    {
+        private List<SubBase>? _subscriptions;
+
+        protected void SubscribeNetworkEvent<T>(EntityEventHandler<T> handler)
+            where T : notnull
+        {
+            EntityManager.EventBus.SubscribeEvent(EventSource.Network, this, handler);
+
+            _subscriptions ??= new();
+            _subscriptions.Add(new SubBroadcast<T>(EventSource.Network));
+        }
+
+        protected void SubscribeNetworkEvent<T>(EntitySessionEventHandler<T> handler)
+            where T : notnull
+        {
+            EntityManager.EventBus.SubscribeSessionEvent(EventSource.Network, this, handler);
+
+            _subscriptions ??= new();
+            _subscriptions.Add(new SubBroadcast<EntitySessionMessage<T>>(EventSource.Network));
+        }
+
+        protected void SubscribeLocalEvent<T>(EntityEventHandler<T> handler)
+            where T : notnull
+        {
+            EntityManager.EventBus.SubscribeEvent(EventSource.Local, this, handler);
+
+            _subscriptions ??= new();
+            _subscriptions.Add(new SubBroadcast<T>(EventSource.Local));
+        }
+
+        protected void SubscribeLocalEvent<T>(EntitySessionEventHandler<T> handler)
+            where T : notnull
+        {
+            EntityManager.EventBus.SubscribeSessionEvent(EventSource.Local, this, handler);
+
+            _subscriptions ??= new();
+            _subscriptions.Add(new SubBroadcast<EntitySessionMessage<T>>(EventSource.Local));
+        }
+
+        [Obsolete("Unsubscribing of entity system events is now automatic")]
+        protected void UnsubscribeNetworkEvent<T>()
+            where T : notnull
+        {
+            EntityManager.EventBus.UnsubscribeEvent<T>(EventSource.Network, this);
+        }
+
+        [Obsolete("Unsubscribing of entity system events is now automatic")]
+        protected void UnsubscribeLocalEvent<T>()
+            where T : notnull
+        {
+            EntityManager.EventBus.UnsubscribeEvent<T>(EventSource.Local, this);
+        }
+
+
+        protected void SubscribeLocalEvent<TComp, TEvent>(ComponentEventHandler<TComp, TEvent> handler)
+            where TComp : IComponent
+            where TEvent : EntityEventArgs
+        {
+            EntityManager.EventBus.SubscribeLocalEvent(handler);
+
+            _subscriptions ??= new();
+            _subscriptions.Add(new SubLocal<TComp, TEvent>());
+        }
+
+        [Obsolete("Unsubscribing of entity system events is now automatic")]
+        protected void UnsubscribeLocalEvent<TComp, TEvent>(ComponentEventHandler<TComp, TEvent> handler)
+            where TComp : IComponent
+            where TEvent : EntityEventArgs
+        {
+            EntityManager.EventBus.UnsubscribeLocalEvent<TComp, TEvent>();
+        }
+
+        [Obsolete("Unsubscribing of entity system events is now automatic")]
+        protected void UnsubscribeLocalEvent<TComp, TEvent>()
+            where TComp : IComponent
+            where TEvent : EntityEventArgs
+        {
+            EntityManager.EventBus.UnsubscribeLocalEvent<TComp, TEvent>();
+        }
+
+        private void ShutdownSubscriptions()
+        {
+            if (_subscriptions == null)
+                return;
+
+            foreach (var sub in _subscriptions)
+            {
+                sub.Unsubscribe(this, EntityManager.EventBus);
+            }
+
+            _subscriptions = null;
+        }
+
+        private abstract class SubBase
+        {
+            public abstract void Unsubscribe(EntitySystem sys, IEventBus bus);
+        }
+
+        private sealed class SubBroadcast<T> : SubBase where T : notnull
+        {
+            private readonly EventSource _source;
+
+            public SubBroadcast(EventSource source)
+            {
+                _source = source;
+            }
+
+            public override void Unsubscribe(EntitySystem sys, IEventBus bus)
+            {
+                bus.UnsubscribeEvent<T>(_source, sys);
+            }
+        }
+
+        private sealed class SubLocal<TComp, TBase> : SubBase where TComp : IComponent where TBase : EntityEventArgs
+        {
+            public override void Unsubscribe(EntitySystem sys, IEventBus bus)
+            {
+                bus.UnsubscribeLocalEvent<TComp, TBase>();
+            }
+        }
+    }
+}

Robust.Shared/GameObjects/EntitySystem.cs

@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using JetBrains.Annotations;
 using Robust.Shared.IoC;
 using Robust.Shared.Network;
+using Robust.Shared.Player;
 using Robust.Shared.Reflection;
 
 namespace Robust.Shared.GameObjects
@@ -17,18 +18,12 @@ namespace Robust.Shared.GameObjects
     ///     This class is instantiated by the <c>EntitySystemManager</c>, and any IoC Dependencies will be resolved.
     /// </remarks>
     [Reflect(false), PublicAPI]
-    public abstract class EntitySystem : IEntitySystem
+    public abstract partial class EntitySystem : IEntitySystem
     {
         [Dependency] protected readonly IEntityManager EntityManager = default!;
         [Dependency] protected readonly IComponentManager ComponentManager = default!;
         [Dependency] protected readonly IEntitySystemManager EntitySystemManager = default!;
 
-        [Obsolete("You need to create and store the query yourself in a field.")]
-        protected IEntityQuery? EntityQuery;
-
-        [Obsolete("You need to use `EntityManager.GetEntities(EntityQuery)`, or store a query yourself.")]
-        protected IEnumerable<IEntity> RelevantEntities => EntityQuery != null ? EntityManager.GetEntities(EntityQuery) : EntityManager.GetEntities();
-
         protected internal List<Type> UpdatesAfter { get; } = new();
         protected internal List<Type> UpdatesBefore { get; } = new();
 
@@ -45,47 +40,14 @@ namespace Robust.Shared.GameObjects
         public virtual void FrameUpdate(float frameTime) { }
 
         /// <inheritdoc />
-        public virtual void Shutdown() { }
+        public virtual void Shutdown()
+        {
+            ShutdownSubscriptions();
+        }
 
 
         #region Event Proxy
 
-        protected void SubscribeNetworkEvent<T>(EntityEventHandler<T> handler)
-            where T : notnull
-        {
-            EntityManager.EventBus.SubscribeEvent(EventSource.Network, this, handler);
-        }
-
-        protected void SubscribeNetworkEvent<T>(EntitySessionEventHandler<T> handler)
-            where T : notnull
-        {
-            EntityManager.EventBus.SubscribeSessionEvent(EventSource.Network, this, handler);
-        }
-
-        protected void SubscribeLocalEvent<T>(EntityEventHandler<T> handler)
-            where T : notnull
-        {
-            EntityManager.EventBus.SubscribeEvent(EventSource.Local, this, handler);
-        }
-
-        protected void SubscribeLocalEvent<T>(EntitySessionEventHandler<T> handler)
-            where T : notnull
-        {
-            EntityManager.EventBus.SubscribeSessionEvent(EventSource.Local, this, handler);
-        }
-
-        protected void UnsubscribeNetworkEvent<T>()
-            where T : notnull
-        {
-            EntityManager.EventBus.UnsubscribeEvent<T>(EventSource.Network, this);
-        }
-
-        protected void UnsubscribeLocalEvent<T>()
-            where T : notnull
-        {
-            EntityManager.EventBus.UnsubscribeEvent<T>(EventSource.Local, this);
-        }
-
         protected void RaiseLocalEvent<T>(T message) where T : notnull
         {
             EntityManager.EventBus.RaiseEvent(EventSource.Local, message);
@@ -111,34 +73,20 @@ namespace Robust.Shared.GameObjects
             EntityManager.EntityNetManager?.SendSystemNetworkMessage(message, channel);
         }
 
+        protected void RaiseNetworkEvent(EntityEventArgs message, Filter filter)
+        {
+            foreach (var session in filter.Recipients)
+            {
+                EntityManager.EntityNetManager?.SendSystemNetworkMessage(message, session.ConnectedClient);
+            }
+        }
+
         protected Task<T> AwaitNetworkEvent<T>(CancellationToken cancellationToken)
             where T : EntityEventArgs
         {
             return EntityManager.EventBus.AwaitEvent<T>(EventSource.Network, cancellationToken);
         }
 
-        protected void SubscribeLocalEvent<TComp, TEvent>(ComponentEventHandler<TComp, TEvent> handler)
-            where TComp : IComponent
-            where TEvent : EntityEventArgs
-        {
-            EntityManager.EventBus.SubscribeLocalEvent(handler);
-        }
-
-        [Obsolete("Use the overload without the handler argument.")]
-        protected void UnsubscribeLocalEvent<TComp, TEvent>(ComponentEventHandler<TComp, TEvent> handler)
-            where TComp : IComponent
-            where TEvent : EntityEventArgs
-        {
-            EntityManager.EventBus.UnsubscribeLocalEvent<TComp, TEvent>();
-        }
-
-        protected void UnsubscribeLocalEvent<TComp, TEvent>()
-            where TComp : IComponent
-            where TEvent : EntityEventArgs
-        {
-            EntityManager.EventBus.UnsubscribeLocalEvent<TComp, TEvent>();
-        }
-
         protected void RaiseLocalEvent<TEvent>(EntityUid uid, TEvent args, bool broadcast = true)
             where TEvent : EntityEventArgs
         {

Robust.Shared/GameObjects/EntitySystemMessages/EntMapIdChangedMessage.cs

@@ -2,7 +2,7 @@ using Robust.Shared.Map;
 
 namespace Robust.Shared.GameObjects
 {
-    public readonly struct EntMapIdChangedMessage
+    public class EntMapIdChangedMessage : EntityEventArgs
     {
         public EntMapIdChangedMessage(IEntity entity, MapId oldMapId)
         {

Robust.Shared/GameObjects/IComponent.cs

@@ -1,4 +1,5 @@
-using Robust.Shared.Network;
+using System;
+using Robust.Shared.Network;
 using Robust.Shared.Players;
 using Robust.Shared.Serialization;
 using Robust.Shared.Timing;
@@ -105,6 +106,7 @@ namespace Robust.Shared.GameObjects
         /// </summary>
         /// <param name="message">Incoming event message.</param>
         /// <param name="component">The local component that sent the message.</param>
+        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
         void HandleMessage(ComponentMessage message, IComponent? component);
 
         /// <summary>
@@ -113,6 +115,7 @@ namespace Robust.Shared.GameObjects
         /// <param name="message">Incoming event message.</param>
         /// <param name="netChannel">The channel of the remote client that sent the message.</param>
         /// <param name="session">The session data for the player who sent this message. Null if this is a client.</param>
+        [Obsolete("Component Messages are deprecated, use Entity Events instead.")]
         void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession? session = null);
 
         /// <summary>