Version: 143.2.0

* Saving work

* Move shit to engine

* lord

* merg

* awa

* bql is kill

* forgot the fucking bike rack

* bql is kill for real

* pjb will kill me

* aughfhbdj

* yo ho here we go on my way to the MINES

* a

* adgddf

* gdsgvfvxshngfgh

* b

* hfsjhghj

* hbfdjjh

* tf you mean i have to document it

* follow C# standards

* Assorted cleanup and documentation pass, minor bugfix in ValueRefParser.

* Start porting old commands, remove that pesky prefix in favor of integrating with the shell.

* Fix valueref up a bit, improve autocomplete for it.

* e

* Toolshed type system adventure.

* a log

* a

* a e i o u

* awa

* fix tests

* Arithmetic commands.

* a

* parse improvements

---------

Co-authored-by: moonheart08 <moonheart08@users.noreply.github.com>

MSBuild/Robust.DefineConstants.targets

@@ -23,7 +23,7 @@
   <PropertyGroup Condition="'$(FullRelease)' != 'True'">
     <DefineConstants>$(DefineConstants);DEVELOPMENT</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
+  <PropertyGroup Condition="'$(Configuration)' == 'Release' Or '$(Configuration)' == 'Tools'">
     <DefineConstants>$(DefineConstants);EXCEPTION_TOLERANCE</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="'$(EnableClientScripting)' == 'True'">

MSBuild/Robust.Engine.Version.props

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

RELEASE-NOTES.md

@@ -54,7 +54,228 @@ END TEMPLATE-->
 *None yet*
 
 
-## 136.0.2
+## 143.2.0
+
+### New features
+
+* Add support for tests to load extra prototypes.
+
+### Bugfixes
+
+* Fix named toolshed command.
+* Unsubscribe from grid rendering events on shutdown.
+
+### Other
+
+* Remove unnecessary test prototypes.
+
+
+## 143.1.0
+
+### New features
+
+* Add locale support for grammatical measure words.
+
+### Bugfixes
+
+* Don't raise contact events for entities that were QueueDeleted during the tick.
+* Exception on duplicate broadcast subscriptions as this was unsupported behaviour.
+
+### Other
+
+* Add VV ReadWrite to PhysicsComponent BodyStatus.
+
+
+## 143.0.0
+
+### New features
+
+
+- Toolshed, a tacit shell language, has been introduced.
+  - Use Robust.Shared.ToolshedManager to invoke commands, with optional input and output.
+  - Implement IInvocationContext for custom invocation contexts i.e. scripting systems.
+
+
+## 142.1.2
+
+### Other
+
+* Don't log an error on failing to resolve for joint relay refreshing.
+
+
+## 142.1.1
+
+### Bugfixes
+
+* Fixed a bad debug assert in `DetachParentToNull()`
+
+
+## 142.1.0
+
+### New features
+
+* `IHttpClientHolder` holds a shared `HttpClient` for use by content. It has Happy Eyeballs fixed and an appropriate `User-Agent`.
+* Added `DataNode.ToString()`. Makes it easier to save yaml files and debug code.
+* Added some cvars to modify discord rich presence icons.
+* .ogg files now read the `Artist` and `Title` tags and make them available via new fields in `AudioStream`. 
+* The default fragment shaders now have access to the local light level (`lowp vec3 lightSample`).
+* Added `IPrototypeManager.ValidateAllPrototypesSerializable()`, which can be used to check that all currently loaded prototypes can be serialised & deserialised.
+
+### Bugfixes
+
+* Fix certain debug commands and tools crashing on non-SS14 RobustToolbox games due to a missing font.
+* Discord rich presence strings are now truncated if they are too long.
+* Fixed a couple of broadphase/entity-lookup update bugs that were affecting containers and entities attached to other (non-grid/map) entities.
+* Fixed `INetChannel.Disconnect()` not properly disconnecting clients in integration tests. 
+
+### Other
+
+* Outgoing HTTP requests now all use Happy Eyeballs to try to prioritize IPv6. This is necessary because .NET still does not support this critical feature itself.
+* Made various physics related component properties VV-editable.
+* The default EntitySystem sawmill log level now defaults to `Info` instead of `Verbose`. The level remains verbose when in debug mode.
+
+### Internal
+
+* The debug asserts in `DetachParentToNull()` are now more informative.
+
+
+## 142.0.1
+
+### Bugfixes
+
+* Fix Enum serialization.
+
+
+## 142.0.0
+
+### Breaking changes
+
+* `EntityManager.GetAllComponents()` now returns a (EntityUid, Component) tuple
+
+### New features
+
+* Added `IPrototypeManager.ValidateFields()`, which uses reflection to validate that the default values of c# string fields correspond to valid entity prototypes. Validates any fields with a `ValidatePrototypeIdAttribute`  and any data-field that uses the PrototypeIdSerializer custom type serializer.
+
+### Other
+
+* Replay playback will now log errors when encountering unhandled messages.
+* Made `GetAssemblyByName()` throw descriptive error messages.
+* Improved performance of various EntityLookupSystem functions
+
+
+## 141.2.1
+
+### Bugfixes
+
+* Fix component trait dictionaries not clearing on reconnect leading to bad GetComponent in areas (e.g. entire game looks black due to no entities).
+
+
+## 141.2.0
+
+### Other
+
+* Fix bug in `NetManager` that allowed exception spam through protocol abuse.
+
+
+## 141.1.0
+
+### New features
+
+* MapInitEvent is run clientside for placementmanager entities to predict entity appearances.
+* Add CollisionLayerChangeEvent for physics fixtures.
+
+
+## 141.0.0
+
+### Breaking changes
+
+* Component.Initialize has been fully replaced with the Eventbus.
+
+### Bugfixes
+
+* Fixed potential crashes if buffered audio sources (e.g. MIDI) fail to create due to running out of audio streams.
+
+### Other
+
+* Pressing `^C` twice on the server will now cause it to hard-exit immediately.
+* `Tools` now has `EXCEPTION_TOLERANCE` enabled.
+
+
+## 140.0.0
+
+### Breaking changes
+
+* `IReplayRecordingManager.RecordingFinished` now takes a `ReplayRecordingFinished` object as argument.
+* `IReplayRecordingManager.GetReplayStats` now returns a `ReplayRecordingStats` struct instead of a tuple. The units have also been normalized
+
+### New features
+
+* `IReplayRecordingManager` can now track a "state" object for an active recording.
+* If the path given to `IReplayRecordingManager.TryStartRecording` is rooted, the base replay directory is ignored.
+
+### Other
+
+* `IReplayRecordingManager` no longer considers itself recording inside `RecordingFinished`.
+* `IReplayRecordingManager.Initialize()` was moved to an engine-internal interface.
+
+
+## 139.0.0
+
+### Breaking changes
+
+* Remove Component.Startup(), fully replacing it with the Eventbus.
+
+
+## 138.1.0
+
+### New features
+
+* Add rotation methods to TransformSystem for no lerp.
+
+### Bugfixes
+
+* Fix AnimationCompleted ordering.
+
+
+## 138.0.0
+
+### Breaking changes
+
+* Obsoleted unused `IMidiRenderer.VolumeBoost` property. Use `IMidiRenderer.VelocityOverride` instead.
+* `IMidiRenderer.TrackedCoordinates` is now a `MapCoordinates`.
+
+### New features
+
+* Added `Master` property to `IMidiRenderer`, which allows it to copy all MIDI events from another renderer.
+* Added `FilteredChannels` property to `IMidiRenderer`, which allows it to filter out notes from certain channels.
+* Added `SystemReset` helper property to `IMidiRenderer`, which allows you to easily send it a SystemReset MIDI message.
+
+### Bugfixes
+
+* Fixed some cases were `MidiRenderer` would not respect the `MidiBank` and `MidiProgram.
+* Fixed user soundfonts not loading.
+* Fixed `ItemList` item selection unselecting everything when in `Multiple` mode.
+
+
+## 137.1.0
+
+### New features
+
+* Added BQL `paused` selector.
+* `ModUpdateLevel.PostInput` allows running content code after network and async task processing.
+
+### Other
+
+* BQL `with` now includes paused entities.
+* The game loop now times more accurately and avoids sleeping more than necessary.
+* Sandboxing (and thus, client startup) should be much faster when ran from the launcher.
+
+
+## 137.0.0
+
+### Breaking changes
+
+* Component network state handler methods have been fully deprecated and replaced with the eventbus event equivalents (ComponentGetState and ComponentHandleState).
 
 
 ## 136.0.1

Resources/Locale/en-US/commands.ftl

@@ -17,15 +17,15 @@ cmd-error-dir-not-found = Could not find directory: {$dir}.
 cmd-failure-no-attached-entity = There is no entity attached to this shell.
 
 ## 'help' command
-cmd-help-desc = Display general help or help text for a specific command
-cmd-help-help = Usage: help [command name]
+cmd-oldhelp-desc = Display general help or help text for a specific command
+cmd-oldhelp-help = Usage: help [command name]
     When no command name is provided, displays general-purpose help text. If a command name is provided, displays help text for that command.
 
-cmd-help-no-args = To display help for a specific command, write 'help <command>'. To list all available commands, write 'list'. To search for commands, use 'list <filter>'.
-cmd-help-unknown = Unknown command: { $command }
-cmd-help-top = { $command } - { $description }
-cmd-help-invalid-args = Invalid amount of arguments.
-cmd-help-arg-cmdname = [command name]
+cmd-oldhelp-no-args = To display help for a specific command, write 'help <command>'. To list all available commands, write 'list'. To search for commands, use 'list <filter>'.
+cmd-oldhelp-unknown = Unknown command: { $command }
+cmd-oldhelp-top = { $command } - { $description }
+cmd-oldhelp-invalid-args = Invalid amount of arguments.
+cmd-oldhelp-arg-cmdname = [command name]
 
 ## 'cvar' command
 cmd-cvar-desc = Gets or sets a CVar.

Resources/Locale/en-US/discordRPC.ftl

@@ -1,4 +1,5 @@
 discord-rpc-in-main-menu = In Main Menu
+discord-rpc-in-main-menu-logo-text = I think coolsville SUCKS
 discord-rpc-character = Username: {$username}
 discord-rpc-on-server = On Server: {$servername}
-discord-rpc-players = Players: {$players}/{$maxplayers}
+discord-rpc-players = Players: {$players}/{$maxplayers}

Resources/Locale/en-US/replays.ftl

@@ -22,7 +22,7 @@ cmd-replay-skip-hint = Ticks or timespan (HH:MM:SS).
 
 cmd-replay-set-time-desc = Jump forwards or backwards to some specific time.
 cmd-replay-set-time-help = replay_set <tick or time>
-cmd-replay-set-time-hint = Tick or timespan (HH:MM:SS), starting from 
+cmd-replay-set-time-hint = Tick or timespan (HH:MM:SS), starting from
 
 cmd-replay-error-time = "{$time}" is not an integer or timespan.
 cmd-replay-error-args = Wrong number of arguments.
@@ -33,7 +33,7 @@ cmd-replay-error-run-level = You cannot load a replay while connected to a serve
 # Recording commands
 
 cmd-replay-recording-start-desc = Starts a replay recording, optionally with some time limit.
-cmd-replay-recording-start-help = Usage: replay_recording_start [name] [overwrite] [time limit] 
+cmd-replay-recording-start-help = Usage: replay_recording_start [name] [overwrite] [time limit]
 cmd-replay-recording-start-success = Started recording a replay.
 cmd-replay-recording-start-already-recording = Already recording a replay.
 cmd-replay-recording-start-error = An error occurred while trying to start the recording.
@@ -48,7 +48,7 @@ cmd-replay-recording-stop-not-recording = Not currently recording a replay.
 
 cmd-replay-recording-stats-desc = Displays information about the current replay recording.
 cmd-replay-recording-stats-help = Usage: replay_recording_stats
-cmd-replay-recording-stats-result = Duration: {$time} min, Ticks: {$ticks}, Size: {$size} mb, rate: {$rate} mb/min.
+cmd-replay-recording-stats-result = Duration: {$time} min, Ticks: {$ticks}, Size: {$size} MB, rate: {$rate} MB/min.
 
 
 # Time Control UI
@@ -56,4 +56,4 @@ replay-time-box-scrubbing-label = Dynamic Scrubbing
 replay-time-box-replay-time-label = Recording Time: {$current} / {$end}  ({$percentage}%)
 replay-time-box-server-time-label = Server Time: {$current} / {$end}
 replay-time-box-index-label = Index: {$current} / {$total}
-replay-time-box-tick-label = Tick: {$current} / {$total}
+replay-time-box-tick-label = Tick: {$current} / {$total}

Resources/Locale/en-US/toolshed-commands.ftl

@@ -0,0 +1,163 @@
+command-description-tpto =
+    Teleport the given entities to some target entity.
+command-description-player-list =
+    Returns a list of all player sessions.
+command-description-player-self =
+    Returns the current player session.
+command-description-player-imm =
+    Returns the session associated with the player given as argument.
+command-description-player-entity =
+    Returns the entities of the input sessions.
+command-description-self =
+    Returns the current attached entity.
+command-description-physics-velocity =
+    Returns the velocity of the input entities.
+command-description-physics-angular-velocity =
+    Returns the angular velocity of the input entities.
+command-description-buildinfo =
+    Provides information about the build of the game.
+command-description-cmd-list =
+    Returns a list of all commands, for this side.
+command-description-explain =
+    Explains the given expression, providing command descriptions and signatures.
+command-description-search =
+    Searches through the input for the provided value.
+command-description-stopwatch =
+    Measures the execution time of the given expression.
+command-description-types-consumers =
+    Provides all commands that can consume the given type.
+command-description-types-tree =
+    Debug tool to return all types the command interpreter can downcast the input to.
+command-description-types-gettype =
+    Returns the type of the input.
+command-description-types-fullname =
+    Returns the full name of the input type according to CoreCLR.
+command-description-as =
+    Casts the input to the given type.
+    Effectively a type hint if you know the type but the interpreter does not.
+command-description-count =
+    Counts the amount of entries in it's input, returning an integer.
+command-description-map =
+    Maps the input over the given block, with the provided expected return type.
+    This command may be modified to not need an explicit return type in the future.
+command-description-select =
+    Selects N objects or N% of objects from the input.
+    One can additionally invert this command with not to make it select everything except N objects instead.
+command-description-comp =
+    Returns the given component from the input entities, discarding entities without that component.
+command-description-delete =
+    Deletes the input entities.
+command-description-ent =
+    Returns the provided entity ID.
+command-description-entities =
+    Returns all entities on the server.
+command-description-paused =
+    Filters the input entities by whether or not they are paused.
+    This command can be inverted with not.
+command-description-with =
+    Filters the input entities by whether or not they have the given component.
+    This command can be inverted with not.
+command-description-fuck =
+    Throws an exception.
+command-description-ecscomp-listty =
+    Lists every type of component registered.
+command-description-cd =
+    Changes the session's current directory to the given relative or absolute path.
+command-description-ls-here =
+    Lists the contents of the current directory.
+command-description-ls-in =
+    Lists the contents of the given relative or absolute path.
+command-description-methods-get =
+    Returns all methods associated with the input type.
+command-description-methods-overrides =
+    Returns all methods overriden on the input type.
+command-description-methods-overridesfrom =
+    Returns all methods overriden from the given type on the input type.
+command-description-cmd-moo =
+    Asks the important questions.
+command-description-cmd-descloc =
+    Returns the localization string for a command's description.
+command-description-cmd-getshim =
+    Returns a command's execution shim.
+command-description-help =
+    Provides a quick rundown of how to use toolshed.
+command-description-ioc-registered =
+    Returns all the types registered with IoCManager on the current thread (usually the game thread)
+command-description-ioc-get =
+    Gets an instance of an IoC registration.
+command-description-loc-tryloc =
+    Tries to get a localization string, returning null if unable.
+command-description-loc-loc =
+    Gets a localization string, returning the unlocalized string if unable.
+command-description-physics-angular_velocity =
+    Returns the angular velocity of the given entities.
+command-description-vars =
+    Provides a list of all variables set in this session.
+command-description-any =
+    Returns true if there's any values in the input, otherwise false.
+command-description-ArrowCommand =
+    Assigns the input to a variable.
+command-description-isempty =
+    Returns true if the input is empty, otherwise false.
+command-description-isnull =
+    Returns true if the input is null, otherwise false.
+command-description-unique =
+    Filters the input sequence for uniqueness, removing duplicate values.
+command-description-where =
+    Given some input sequence IEnumerable<T>, takes a block of signature T -> bool that decides if each input value should be included in the output sequence.
+command-description-do =
+    Backwards compatibility with BQL, applies the given old commands over the input sequence.
+command-description-named =
+    Filters the input entities by their name, with the regex ^selector$.
+command-description-prototyped =
+    Filters the input entities by their prototype.
+command-description-nearby =
+    Creates a new list of all entities nearby the inputs within the given range.
+command-description-first =
+    Returns the first entry of the given enumerable.
+command-description-splat =
+    "Splats" a block, value, or variable, creating N copies of it in a list.
+command-description-val =
+    Casts the given value, block, or variable to the given type. This is mostly a workaround for current limitations of variables.
+command-description-actor-controlled =
+    Filters entities by whether or not they're actively controlled.
+command-description-actor-session =
+    Returns the sessions associated with the input entities.
+command-description-physics-parent =
+    Returns the parent(s) of the input entities.
+command-description-emplace =
+    Runs the given block over it's inputs, with the input value placed into the variable $value within the block.
+    Additionally breaks out $wx, $wy, $proto, $desc, $name, and $paused for entities.
+    Can also have breakout values for other types, consult the documentation for that type for further info.
+command-description-AddCommand =
+    Performs numeric addition.
+command-description-SubtractCommand =
+    Performs numeric subtraction.
+command-description-MultiplyCommand =
+    Performs numeric multiplication.
+command-description-DivideCommand =
+    Performs numeric division.
+command-description-min =
+    Returns the minimum of two values.
+command-description-max =
+    Returns the maximum of two values.
+command-description-BitAndCommand =
+    Performs bitwise AND.
+command-description-BitOrCommand =
+    Performs bitwise OR.
+command-description-BitXorCommand =
+    Performs bitwise XOR.
+command-description-neg =
+    Negates the input.
+command-description-GreaterThanCommand =
+    Performs a greater-than comparison, x > y.
+command-description-LessThanCommand =
+    Performs a less-than comparison, x < y.
+command-description-GreaterThanOrEqualCommand =
+    Performs a greater-than-or-equal comparison, x >= y.
+command-description-LessThanOrEqualCommand =
+    Performs a less-than-or-equal comparison, x <= y.
+command-description-EqualCommand =
+    Performs an equality comparison, returning true if the inputs are equal.
+command-description-NotEqualCommand =
+    Performs an equality comparison, returning true if the inputs are not equal.

Robust.Benchmarks/EntityManager/ComponentIteratorBenchmark.cs

@@ -0,0 +1,75 @@
+using BenchmarkDotNet.Attributes;
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.UnitTesting.Server;
+
+namespace Robust.Benchmarks.EntityManager;
+
+public class ComponentIteratorBenchmark
+{
+    private ISimulation _simulation = default!;
+    private IEntityManager _entityManager = default!;
+
+    [UsedImplicitly]
+    [Params(1, 10, 100, 1000)]
+    public int N;
+
+    public A[] Comps = default!;
+
+    [GlobalSetup]
+    public void GlobalSetup()
+    {
+        _simulation = RobustServerSimulation
+            .NewSimulation()
+            .RegisterComponents(f => f.RegisterClass<A>())
+            .InitializeInstance();
+
+        _entityManager = _simulation.Resolve<IEntityManager>();
+
+        Comps = new A[N+2];
+
+        var coords = new MapCoordinates(0, 0, new MapId(1));
+        _simulation.AddMap(coords.MapId);
+
+        for (var i = 0; i < N; i++)
+        {
+            var uid = _entityManager.SpawnEntity(null, coords);
+            _entityManager.AddComponent<A>(uid);
+        }
+    }
+
+    [Benchmark]
+    public A[] ComponentStructEnumerator()
+    {
+        var query = _entityManager.EntityQueryEnumerator<A>();
+        var i = 0;
+
+        while (query.MoveNext(out var comp))
+        {
+            Comps[i] = comp;
+            i++;
+        }
+
+        return Comps;
+    }
+
+    [Benchmark]
+    public A[] ComponentIEnumerable()
+    {
+        var i = 0;
+
+        foreach (var comp in _entityManager.EntityQuery<A>())
+        {
+            Comps[i] = comp;
+            i++;
+        }
+
+        return Comps;
+    }
+
+    [ComponentProtoName("A")]
+    public sealed class A : Component
+    {
+    }
+}

Robust.Client/Audio/AudioStream.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using Robust.Client.Graphics;
 
 namespace Robust.Client.Audio;
@@ -8,13 +8,17 @@ public sealed class AudioStream
     public TimeSpan Length { get; }
     internal ClydeHandle? ClydeHandle { get; }
     public string? Name { get; }
+    public string? Title { get; }
+    public string? Artist { get; }
     public int ChannelCount { get; }
 
-    internal AudioStream(ClydeHandle handle, TimeSpan length, int channelCount, string? name = null)
+    internal AudioStream(ClydeHandle handle, TimeSpan length, int channelCount, string? name = null, string? title = null, string? artist = null)
     {
         ClydeHandle = handle;
         Length = length;
         ChannelCount = channelCount;
         Name = name;
+        Title = title;
+        Artist = artist;
     }
 }

Robust.Client/Audio/Midi/IMidiRenderer.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using Robust.Client.Graphics;
 using Robust.Shared.Audio.Midi;
 using Robust.Shared.GameObjects;
@@ -15,7 +17,6 @@ public enum MidiRendererStatus : byte
 
 public interface IMidiRenderer : IDisposable
 {
-
     /// <summary>
     ///     The buffered audio source of this renderer.
     /// </summary>
@@ -34,6 +35,7 @@ public interface IMidiRenderer : IDisposable
     /// <summary>
     ///     This increases all note on velocities to 127.
     /// </summary>
+    [Obsolete($"Use {nameof(VelocityOverride)} instead, you can set it to 127 to achieve the same effect.")]
     bool VolumeBoost { get; set; }
 
     /// <summary>
@@ -94,6 +96,27 @@ public interface IMidiRenderer : IDisposable
     /// </summary>
     double SequencerTimeScale { get; }
 
+    /// <summary>
+    ///     Whether this renderer will subscribe to another and copy its events.
+    ///     See <see cref="FilteredChannels"/> to filter specific channels.
+    /// </summary>
+    IMidiRenderer? Master { get; set; }
+
+    // NOTE: Why is the properties below BitArray, you ask?
+    // Well see, MIDI 2.0 supports up to 256(!) channels as opposed to MIDI 1.0's meekly 16 channels...
+    // I'd like us to support MIDI 2.0 one day so I'm just future-proofing here. Also BitArray is cool!
+
+    /// <summary>
+    ///     Allows you to filter out note events from certain channels.
+    ///     Only NoteOn will be filtered.
+    /// </summary>
+    BitArray FilteredChannels { get; }
+
+    /// <summary>
+    ///     Allows you to override all NoteOn velocities. Set to null to disable.
+    /// </summary>
+    byte? VelocityOverride { get; set; }
+
     /// <summary>
     ///     Start listening for midi input.
     /// </summary>
@@ -120,6 +143,11 @@ public interface IMidiRenderer : IDisposable
     /// </summary>
     void StopAllNotes();
 
+    /// <summary>
+    ///     Reset renderer back to a clean state.
+    /// </summary>
+    void SystemReset();
+
     /// <summary>
     /// Clears all scheduled events.
     /// </summary>
@@ -156,7 +184,7 @@ public interface IMidiRenderer : IDisposable
     ///     This is only used if <see cref="Mono"/> is set to True
     ///     and <see cref="TrackingEntity"/> is null.
     /// </summary>
-    EntityCoordinates? TrackingCoordinates { get; set; }
+    MapCoordinates? TrackingCoordinates { get; set; }
 
     MidiRendererState RendererState { get; }
 
@@ -164,7 +192,8 @@ public interface IMidiRenderer : IDisposable
     ///     Send a midi event for the renderer to play.
     /// </summary>
     /// <param name="midiEvent">The midi event to be played</param>
-    void SendMidiEvent(RobustMidiEvent midiEvent);
+    /// <param name="raiseEvent">Whether to raise an event for this event.</param>
+    void SendMidiEvent(RobustMidiEvent midiEvent, bool raiseEvent = true);
 
     /// <summary>
     ///     Schedule a MIDI event to be played at a later time.
@@ -177,7 +206,7 @@ public interface IMidiRenderer : IDisposable
     /// <summary>
     ///     Apply a certain state to the renderer.
     /// </summary>
-    void ApplyState(MidiRendererState state);
+    void ApplyState(MidiRendererState state, bool filterChannels = false);
 
     /// <summary>
     ///     Actually disposes of this renderer. Do NOT use outside the MIDI thread.

Robust.Client/Audio/Midi/MidiManager.cs

@@ -3,20 +3,27 @@ using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
+using System.Threading.Tasks;
 using NFluidsynth;
+using Robust.Client.GameObjects;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Shared;
 using Robust.Shared.Asynchronous;
+using Robust.Shared.Audio.Midi;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
+using Robust.Shared.Exceptions;
 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.Components;
 using Robust.Shared.Physics.Systems;
+using Robust.Shared.Threading;
+using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 
@@ -26,6 +33,13 @@ internal sealed partial class MidiManager : IMidiManager
 {
     public const string SoundfontEnvironmentVariable = "ROBUST_SOUNDFONT_OVERRIDE";
 
+    private int _minRendererParallel;
+    private float _occlusionUpdateDelay;
+    private float _positionUpdateDelay;
+
+    [ViewVariables] private TimeSpan _nextOcclusionUpdate = TimeSpan.Zero;
+    [ViewVariables] private TimeSpan _nextPositionUpdate = TimeSpan.Zero;
+
     [Dependency] private readonly IEyeManager _eyeManager = default!;
     [Dependency] private readonly IResourceCacheInternal _resourceManager = default!;
     [Dependency] private readonly IEntityManager _entityManager = default!;
@@ -33,6 +47,9 @@ internal sealed partial class MidiManager : IMidiManager
     [Dependency] private readonly IClydeAudio _clydeAudio = default!;
     [Dependency] private readonly ITaskManager _taskManager = default!;
     [Dependency] private readonly ILogManager _logger = default!;
+    [Dependency] private readonly IParallelManager _parallel = default!;
+    [Dependency] private readonly IRuntimeLog _runtime = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
 
     private SharedPhysicsSystem _broadPhaseSystem = default!;
 
@@ -59,11 +76,10 @@ internal sealed partial class MidiManager : IMidiManager
         }
     }
 
-    [ViewVariables]
-    private readonly List<IMidiRenderer> _renderers = new();
+    [ViewVariables] private readonly List<IMidiRenderer> _renderers = new();
 
     private bool _alive = true;
-    private Settings? _settings;
+    [ViewVariables] private Settings? _settings;
     private Thread? _midiThread;
     private ISawmill _midiSawmill = default!;
     private float _volume = 0f;
@@ -115,7 +131,7 @@ internal sealed partial class MidiManager : IMidiManager
     private bool _failedInitialize;
 
     private NFluidsynth.Logger.LoggerDelegate _loggerDelegate = default!;
-    private ISawmill _sawmill = default!;
+    private ISawmill _fluidsynthSawmill = default!;
     private float _maxCastLength;
 
     [ViewVariables(VVAccess.ReadWrite)]
@@ -130,20 +146,28 @@ internal sealed partial class MidiManager : IMidiManager
     {
         if (FluidsynthInitialized || _failedInitialize) return;
 
-        _volume = _cfgMan.GetCVar(CVars.MidiVolume);
         _cfgMan.OnValueChanged(CVars.MidiVolume, value =>
         {
             _volume = value;
             _volumeDirty = true;
         }, true);
 
+        _cfgMan.OnValueChanged(CVars.MidiMinRendererParallel,
+            value => _minRendererParallel = value, true);
+
+        _cfgMan.OnValueChanged(CVars.MidiOcclusionUpdateDelay,
+            value => _occlusionUpdateDelay = value, true);
+
+        _cfgMan.OnValueChanged(CVars.MidiPositionUpdateDelay,
+            value => _positionUpdateDelay = value, true);
+
         _midiSawmill = _logger.GetSawmill("midi");
 #if DEBUG
         _midiSawmill.Level = LogLevel.Debug;
 #else
         _midiSawmill.Level = LogLevel.Error;
 #endif
-        _sawmill = _logger.GetSawmill("midi.fluidsynth");
+        _fluidsynthSawmill = _logger.GetSawmill("midi.fluidsynth");
         _loggerDelegate = LoggerDelegate;
 
         if (!_resourceManager.UserData.Exists(CustomSoundfontDirectory))
@@ -167,8 +191,6 @@ internal sealed partial class MidiManager : IMidiManager
             _settings["synth.lock-memory"].IntValue = 0;
             _settings["synth.threadsafe-api"].IntValue = 1;
             _settings["synth.gain"].DoubleValue = 1.0d;
-            _settings["synth.polyphony"].IntValue = 1024;
-            _settings["synth.cpu-cores"].IntValue = 2;
             _settings["synth.midi-channels"].IntValue = 16;
             _settings["synth.overflow.age"].DoubleValue = 3000;
             _settings["audio.driver"].StringValue = "file";
@@ -176,8 +198,11 @@ internal sealed partial class MidiManager : IMidiManager
             _settings["audio.period-size"].IntValue = 4096;
             _settings["midi.autoconnect"].IntValue = 1;
             _settings["player.reset-synth"].IntValue = 0;
+            _settings["synth.midi-channels"].IntValue = Math.Clamp(RobustMidiEvent.MaxChannels, 16, 256);
             _settings["synth.midi-bank-select"].StringValue = "gm";
             //_settings["synth.verbose"].IntValue = 1; // Useful for debugging.
+
+            _parallel.AddAndInvokeParallelCountChanged(UpdateParallelCount);
         }
         catch (Exception e)
         {
@@ -195,6 +220,18 @@ internal sealed partial class MidiManager : IMidiManager
         FluidsynthInitialized = true;
     }
 
+    private void UpdateParallelCount()
+    {
+        if (_settings == null)
+            return;
+
+        _settings["synth.polyphony"].IntValue = Math.Clamp(1024 + (int)(Math.Log2(_parallel.ParallelProcessCount) * 2048), 1, 65535);
+        _settings["synth.cpu-cores"].IntValue = Math.Clamp(_parallel.ParallelProcessCount, 1, 256);
+
+        _midiSawmill.Debug($"Synth Cores: {_settings["synth.cpu-cores"].IntValue}");
+        _midiSawmill.Debug($"Synth Polyphony: {_settings["synth.polyphony"].IntValue}");
+    }
+
     private void OnRaycastLengthChanged(float value)
     {
         _maxCastLength = value;
@@ -211,7 +248,7 @@ internal sealed partial class MidiManager : IMidiManager
             NFluidsynth.Logger.LogLevel.Debug => LogLevel.Debug,
             _ => LogLevel.Debug
         };
-        _sawmill.Log(rLevel, message);
+        _fluidsynthSawmill.Log(rLevel, message);
     }
 
     public IMidiRenderer? GetNewRenderer(bool mono = true)
@@ -238,7 +275,7 @@ internal sealed partial class MidiManager : IMidiManager
 
             var renderer = new MidiRenderer(_settings!, soundfontLoader, mono, this, _clydeAudio, _taskManager, _midiSawmill);
 
-            _midiSawmill.Debug($"Loading soundfont {FallbackSoundfont}");
+            _midiSawmill.Debug($"Loading fallback soundfont {FallbackSoundfont}");
             // Since the last loaded soundfont takes priority, we load the fallback soundfont before the soundfont.
             renderer.LoadSoundfont(FallbackSoundfont);
 
@@ -252,8 +289,8 @@ internal sealed partial class MidiManager : IMidiManager
 
                     try
                     {
+                        _midiSawmill.Debug($"Loading OS soundfont {filepath}");
                         renderer.LoadSoundfont(filepath);
-                        _midiSawmill.Debug($"Loaded Linux soundfont {filepath}");
                     }
                     catch (Exception)
                     {
@@ -267,7 +304,7 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(OsxSoundfont) && SoundFont.IsSoundFont(OsxSoundfont))
                 {
-                    _midiSawmill.Debug($"Loading soundfont {OsxSoundfont}");
+                    _midiSawmill.Debug($"Loading OS soundfont {OsxSoundfont}");
                     renderer.LoadSoundfont(OsxSoundfont);
                 }
             }
@@ -275,7 +312,7 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(WindowsSoundfont) && SoundFont.IsSoundFont(WindowsSoundfont))
                 {
-                    _midiSawmill.Debug($"Loading soundfont {WindowsSoundfont}");
+                    _midiSawmill.Debug($"Loading OS soundfont {WindowsSoundfont}");
                     renderer.LoadSoundfont(WindowsSoundfont);
                 }
             }
@@ -286,27 +323,31 @@ internal sealed partial class MidiManager : IMidiManager
             {
                 if (File.Exists(soundfontOverride) && SoundFont.IsSoundFont(soundfontOverride))
                 {
-                    _midiSawmill.Debug($"Loading soundfont {soundfontOverride} from environment variable.");
+                    _midiSawmill.Debug($"Loading environment variable soundfont {soundfontOverride}");
                     renderer.LoadSoundfont(soundfontOverride);
                 }
             }
 
             // Load content-specific custom soundfonts, which should override the system/fallback soundfont.
-            _midiSawmill.Debug($"Loading soundfonts from {ContentCustomSoundfontDirectory}");
+            _midiSawmill.Debug($"Loading soundfonts from content directory {ContentCustomSoundfontDirectory}");
             foreach (var file in _resourceManager.ContentFindFiles(ContentCustomSoundfontDirectory))
             {
                 if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
-                _midiSawmill.Debug($"Loading soundfont {file}");
+                _midiSawmill.Debug($"Loading content soundfont {file}");
                 renderer.LoadSoundfont(file.ToString());
             }
 
+            var userDataPath = _resourceManager.UserData.RootDir == null
+                ? CustomSoundfontDirectory
+                : new ResPath(_resourceManager.UserData.RootDir) / CustomSoundfontDirectory.ToRelativePath();
+
             // Load every soundfont from the user data directory last, since those may override any other soundfont.
-            _midiSawmill.Debug($"Loading soundfonts from {{USERDATA}} {CustomSoundfontDirectory}");
-            var enumerator = _resourceManager.UserData.Find($"{CustomSoundfontDirectory.ToRelativePath()}/*").Item1;
+            _midiSawmill.Debug($"Loading soundfonts from user data directory {userDataPath}");
+            var enumerator = _resourceManager.UserData.Find($"{CustomSoundfontDirectory.ToRelativePath()}*").Item1;
             foreach (var file in enumerator)
             {
                 if (file.Extension != "sf2" && file.Extension != "dls" && file.Extension != "sf3") continue;
-                _midiSawmill.Debug($"Loading soundfont {{USERDATA}} {file}");
+                _midiSawmill.Debug($"Loading user soundfont {file}");
                 renderer.LoadSoundfont(file.ToString());
             }
 
@@ -336,72 +377,108 @@ internal sealed partial class MidiManager : IMidiManager
 
         lock (_renderers)
         {
-            foreach (var renderer in _renderers)
+            if (_renderers.Count == 0)
+                return;
+
+            var transQuery = _entityManager.GetEntityQuery<TransformComponent>();
+            var physicsQuery = _entityManager.GetEntityQuery<PhysicsComponent>();
+            var opts = new ParallelOptions { MaxDegreeOfParallelism = _parallel.ParallelProcessCount };
+
+            if (_renderers.Count > _minRendererParallel)
             {
-                if (renderer.Disposed)
-                    continue;
-
-                if(_volumeDirty)
-                    renderer.Source.SetVolume(Volume);
-
-                if (!renderer.Mono)
+                Parallel.ForEach(_renderers, opts, renderer => UpdateRenderer(renderer, transQuery, physicsQuery));
+            }
+            else
+            {
+                foreach (var renderer in _renderers)
                 {
-                    renderer.Source.SetGlobal();
-                    continue;
-                }
-
-                MapCoordinates? mapPos = null;
-                var trackingEntity = renderer.TrackingEntity != null && !_entityManager.Deleted(renderer.TrackingEntity);
-                if (trackingEntity)
-                {
-                    renderer.TrackingCoordinates = _entityManager.GetComponent<TransformComponent>(renderer.TrackingEntity!.Value).Coordinates;
-                }
-
-                if (renderer.TrackingCoordinates != null)
-                {
-                    mapPos = renderer.TrackingCoordinates.Value.ToMap(_entityManager);
-                }
-
-                if (mapPos != null && mapPos.Value.MapId == _eyeManager.CurrentMap)
-                {
-                    var pos = mapPos.Value;
-
-                    var sourceRelative = pos.Position - _eyeManager.CurrentEye.Position.Position;
-                    var occlusion = 0f;
-                    if (sourceRelative.Length() > 0)
-                    {
-                        occlusion = _broadPhaseSystem.IntersectRayPenetration(
-                            pos.MapId,
-                            new CollisionRay(
-                                _eyeManager.CurrentEye.Position.Position,
-                                sourceRelative.Normalized(),
-                                OcclusionCollisionMask),
-                            MathF.Min(sourceRelative.Length(), _maxCastLength),
-                            renderer.TrackingEntity);
-                    }
-
-                    renderer.Source.SetOcclusion(occlusion);
-
-                    if (!renderer.Source.SetPosition(pos.Position))
-                    {
-                        return;
-                    }
-
-                    if (trackingEntity)
-                    {
-                        var vel = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity!.Value);
-                        renderer.Source.SetVelocity(vel);
-                    }
-                }
-                else
-                {
-                    renderer.Source.SetOcclusion(float.MaxValue);
+                    UpdateRenderer(renderer, transQuery, physicsQuery);
                 }
             }
+
         }
 
+        if (_nextOcclusionUpdate < _timing.RealTime)
+            _nextOcclusionUpdate = _timing.RealTime.Add(TimeSpan.FromSeconds(_occlusionUpdateDelay));
+
+        if (_nextPositionUpdate < _timing.RealTime)
+            _nextPositionUpdate = _timing.RealTime.Add(TimeSpan.FromSeconds(_positionUpdateDelay));
+
         _volumeDirty = false;
     }
+    private void UpdateRenderer(IMidiRenderer renderer, EntityQuery<TransformComponent> transQuery,
+        EntityQuery<PhysicsComponent> physicsQuery)
+    {
+        try
+        {
+            if (renderer.Disposed)
+                return;
+
+            if (_volumeDirty)
+                renderer.Source.SetVolume(Volume);
+
+            if (!renderer.Mono)
+            {
+                renderer.Source.SetGlobal();
+                return;
+            }
+
+            if (_nextPositionUpdate < _timing.RealTime)
+            {
+                if (renderer.TrackingEntity is {} trackedEntity && !_entityManager.Deleted(trackedEntity))
+                {
+                    renderer.TrackingCoordinates = transQuery.GetComponent(renderer.TrackingEntity!.Value).MapPosition;
+                }
+                else if (renderer.TrackingCoordinates == null)
+                {
+                    return;
+                }
+
+                if (!renderer.Source.SetPosition(renderer.TrackingCoordinates.Value.Position))
+                {
+                    return;
+                }
+
+                var vel = _broadPhaseSystem.GetMapLinearVelocity(renderer.TrackingEntity!.Value,
+                    xformQuery: transQuery, physicsQuery: physicsQuery);
+                renderer.Source.SetVelocity(vel);
+            }
+
+            if (renderer.TrackingCoordinates != null && renderer.TrackingCoordinates.Value.MapId == _eyeManager.CurrentMap)
+            {
+                if (_nextOcclusionUpdate >= _timing.RealTime)
+                    return;
+
+                var pos = renderer.TrackingCoordinates.Value;
+
+                var sourceRelative = pos.Position - _eyeManager.CurrentEye.Position.Position;
+                var occlusion = 0f;
+                if (sourceRelative.Length() > 0)
+                {
+                    occlusion = _broadPhaseSystem.IntersectRayPenetration(
+                        pos.MapId,
+                        new CollisionRay(
+                            _eyeManager.CurrentEye.Position.Position,
+                            sourceRelative.Normalized(),
+                            OcclusionCollisionMask),
+                        MathF.Min(sourceRelative.Length(), _maxCastLength),
+                        renderer.TrackingEntity);
+                }
+
+                renderer.Source.SetOcclusion(occlusion);
+            }
+            else
+            {
+                renderer.Source.SetOcclusion(float.MaxValue);
+            }
+
+        }
+        catch (Exception ex)
+        {
+            _runtime.LogException(ex, _midiSawmill.Name);
+        }
+
+    }
 
     /// <summary>
     ///     Main method for the thread rendering the midi audio.
@@ -416,7 +493,12 @@ internal sealed partial class MidiManager : IMidiManager
                 {
                     var renderer = _renderers[i];
                     if (!renderer.Disposed)
+                    {
+                        if (renderer.Master is { Disposed: true })
+                            renderer.Master = null;
+
                         renderer.Render();
+                    }
                     else
                     {
                         renderer.InternalDispose();

Robust.Client/Audio/Midi/MidiRenderer.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections;
+using JetBrains.Annotations;
 using NFluidsynth;
 using Robust.Client.Graphics;
 using Robust.Shared.Asynchronous;
@@ -9,7 +11,6 @@ using Robust.Shared.Map;
 using Robust.Shared.Maths;
 using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
-using Logger = Robust.Shared.Log.Logger;
 
 namespace Robust.Client.Audio.Midi;
 
@@ -21,14 +22,13 @@ internal sealed class MidiRenderer : IMidiRenderer
     // TODO: Make this a replicated CVar in MidiManager
     private const int MidiSizeLimit = 2000000;
     private const double BytesToMegabytes = 0.000001d;
-    private const int ChannelCount = 16;
+    private const int ChannelCount = RobustMidiEvent.MaxChannels;
 
     private readonly ISawmill _midiSawmill;
 
     private readonly Settings _settings;
 
-    [ViewVariables(VVAccess.ReadWrite)]
-    private bool _debugEvents = false;
+    [ViewVariables(VVAccess.ReadWrite)] private bool _debugEvents = false;
 
     // Kept around to avoid the loader callbacks getting GC'd
     // ReSharper disable once NotAccessedField.Local
@@ -48,8 +48,9 @@ internal sealed class MidiRenderer : IMidiRenderer
     private readonly SequencerClientId _robustRegister;
     private readonly SequencerClientId _debugRegister;
 
-    [ViewVariables]
-    private MidiRendererState _rendererState = new();
+    [ViewVariables] private MidiRendererState _rendererState = new();
+
+    private IMidiRenderer? _master;
     public MidiRendererState RendererState => _rendererState;
     public IClydeBufferedAudioSource Source { get; set; }
     IClydeBufferedAudioSource IMidiRenderer.Source => Source;
@@ -70,8 +71,8 @@ internal sealed class MidiRenderer : IMidiRenderer
             {
                 for (byte i = 0; i < ChannelCount; i++)
                 {
-                    // Channel 9 is the percussion channel. Let's not change its instrument...
-                    if (i == 9)
+                    // Don't change percussion channel instrument.
+                    if (i == RobustMidiEvent.PercussionChannel)
                         continue;
 
                     SendMidiEvent(RobustMidiEvent.ProgramChange(i, value, SequencerTick));
@@ -96,11 +97,14 @@ internal sealed class MidiRenderer : IMidiRenderer
             {
                 for (byte i = 0; i < ChannelCount; i++)
                 {
-                    // Channel 9 is the percussion channel. Let's not change its bank...
-                    if (i == 9)
+                    // Don't change percussion channel bank.
+                    if (i == RobustMidiEvent.PercussionChannel)
                         continue;
 
                     SendMidiEvent(RobustMidiEvent.BankSelect(i, value, SequencerTick));
+
+                    // Re-select program.
+                    SendMidiEvent(RobustMidiEvent.ProgramChange(i, _midiProgram, SequencerTick));
                 }
             }
 
@@ -128,7 +132,11 @@ internal sealed class MidiRenderer : IMidiRenderer
     }
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public bool DisablePercussionChannel { get; set; } = true;
+    public bool DisablePercussionChannel
+    {
+        get => FilteredChannels[RobustMidiEvent.PercussionChannel];
+        set => FilteredChannels[RobustMidiEvent.PercussionChannel] = value;
+    }
 
     [ViewVariables(VVAccess.ReadWrite)]
     public bool DisableProgramChangeEvent { get; set; } = true;
@@ -181,13 +189,62 @@ internal sealed class MidiRenderer : IMidiRenderer
     }
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public bool VolumeBoost { get; set; }
+    [Obsolete($"Use {nameof(VelocityOverride)} instead, you can set it to 127 to achieve the same effect.")]
+    public bool VolumeBoost
+    {
+        get => VelocityOverride == 127;
+        set => VelocityOverride = value ? 127 : null;
+    }
 
     [ViewVariables(VVAccess.ReadWrite)]
     public EntityUid? TrackingEntity { get; set; } = null;
 
     [ViewVariables(VVAccess.ReadWrite)]
-    public EntityCoordinates? TrackingCoordinates { get; set; } = null;
+    public MapCoordinates? TrackingCoordinates { get; set; } = null;
+
+    [ViewVariables]
+    public BitArray FilteredChannels { get; } = new(RobustMidiEvent.MaxChannels);
+
+    [ViewVariables(VVAccess.ReadWrite)]
+    public byte? VelocityOverride { get; set; } = null;
+
+    [ViewVariables(VVAccess.ReadWrite)]
+    public IMidiRenderer? Master
+    {
+        get => _master;
+        set
+        {
+            if (value == _master)
+                return;
+
+            if (_master is { Disposed: false })
+            {
+                try
+                {
+                    _master.OnMidiEvent -= SendMidiEvent;
+                }
+                catch
+                {
+                    // ignored
+                }
+            }
+
+            _master = value;
+
+            if (_master == null)
+                return;
+
+            _master.OnMidiEvent += SendMidiEvent;
+            ApplyState(_master.RendererState, true);
+            MidiBank = _midiBank;
+        }
+    }
+
+    [ViewVariables, UsedImplicitly]
+    private double CpuLoad => !_synth.Disposed ? _synth.CpuLoad : 0;
+
+    public event Action<RobustMidiEvent>? OnMidiEvent;
+    public event Action? OnMidiPlayerFinished;
 
     internal MidiRenderer(Settings settings, SoundFontLoader soundFontLoader, bool mono,
         IMidiManager midiManager, IClydeAudio clydeAudio, ITaskManager taskManager, ISawmill midiSawmill)
@@ -354,6 +411,11 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
+    public void SystemReset()
+    {
+        SendMidiEvent(RobustMidiEvent.SystemReset(SequencerTick));
+    }
+
     public void ClearAllEvents()
     {
         _sequencer.RemoveEvents(SequencerClientId.Wildcard, SequencerClientId.Wildcard, -1);
@@ -368,9 +430,6 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
-    public event Action<RobustMidiEvent>? OnMidiEvent;
-    public event Action? OnMidiPlayerFinished;
-
     void IMidiRenderer.Render()
     {
         Render();
@@ -432,7 +491,7 @@ internal sealed class MidiRenderer : IMidiRenderer
         if (!Source.IsPlaying) Source.StartPlaying();
     }
 
-    public void ApplyState(MidiRendererState state)
+    public void ApplyState(MidiRendererState state, bool filterChannels = false)
     {
         lock (_playerStateLock)
         {
@@ -440,6 +499,9 @@ internal sealed class MidiRenderer : IMidiRenderer
 
             for (var channel = 0; channel < ChannelCount; channel++)
             {
+                if (filterChannels && !FilteredChannels[channel])
+                    continue;
+
                 _synth.AllNotesOff(channel);
 
                 _synth.PitchBend(channel, state.PitchBend.AsSpan[channel]);
@@ -462,7 +524,8 @@ internal sealed class MidiRenderer : IMidiRenderer
                     }
                 }
 
-                _synth.ProgramChange(channel, state.Program.AsSpan[channel]);
+                var program = DisableProgramChangeEvent ? MidiProgram : state.Program.AsSpan[channel];
+                _synth.ProgramChange(channel, program);
 
                 for (var key = 0; key < state.NoteVelocities.AsSpan[channel].AsSpan.Length; key++)
                 {
@@ -487,7 +550,12 @@ internal sealed class MidiRenderer : IMidiRenderer
         }
     }
 
-    public void SendMidiEvent(RobustMidiEvent midiEvent)
+    private void SendMidiEvent(RobustMidiEvent midiEvent)
+    {
+        SendMidiEvent(midiEvent, true);
+    }
+
+    public void SendMidiEvent(RobustMidiEvent midiEvent, bool raiseEvent)
     {
         if (Disposed)
             return;
@@ -505,11 +573,10 @@ internal sealed class MidiRenderer : IMidiRenderer
                         break;
 
                     case RobustMidiCommand.NoteOn:
-                        // Channel 9 is the percussion channel. We only block NoteOn events to it.
-                        if (DisablePercussionChannel && midiEvent.Channel == 9)
-                            return;
+                        if (FilteredChannels[midiEvent.Channel])
+                            break;
 
-                        var velocity = (byte)(VolumeBoost ? 127 : midiEvent.Velocity);
+                        var velocity = VelocityOverride ?? midiEvent.Velocity;
 
                         _rendererState.NoteVelocities.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Key] = velocity;
                         _synth.NoteOn(midiEvent.Channel, midiEvent.Key, velocity);
@@ -523,7 +590,7 @@ internal sealed class MidiRenderer : IMidiRenderer
                     case RobustMidiCommand.ControlChange:
                         // CC0 is bank selection
                         if (midiEvent.Control == 0x0 && DisableProgramChangeEvent)
-                            return;
+                            break;
 
                         _rendererState.Controllers.AsSpan[midiEvent.Channel].AsSpan[midiEvent.Control] = midiEvent.Value;
                         if(midiEvent.Control != 0x0)
@@ -534,7 +601,7 @@ internal sealed class MidiRenderer : IMidiRenderer
 
                     case RobustMidiCommand.ProgramChange:
                         if (DisableProgramChangeEvent)
-                            return;
+                            break;
 
                         _rendererState.Program.AsSpan[midiEvent.Channel] = midiEvent.Program;
                         _synth.ProgramChange(midiEvent.Channel, midiEvent.Program);
@@ -561,14 +628,14 @@ internal sealed class MidiRenderer : IMidiRenderer
                         switch (midiEvent.Control)
                         {
                             case 0x0 when midiEvent.Status == 0xFF:
-                                _rendererState = new ();
+                                _rendererState = new MidiRendererState();
                                 _synth.SystemReset();
 
                                 // Reset the instrument to the one we were using.
                                 if (DisableProgramChangeEvent)
                                 {
-                                    MidiProgram = _midiProgram;
                                     MidiBank = _midiBank;
+                                    MidiProgram = _midiProgram;
                                 }
 
                                 break;
@@ -597,7 +664,10 @@ internal sealed class MidiRenderer : IMidiRenderer
             //_midiSawmill.Error("Exception while sending midi event of type {0}: {1}", midiEvent.Type, e, midiEvent);
         }
 
-        _taskManager.RunOnMainThread(() => OnMidiEvent?.Invoke(midiEvent));
+        if (raiseEvent)
+        {
+            _taskManager.RunOnMainThread(() => OnMidiEvent?.Invoke(midiEvent));
+        }
     }
 
     public void ScheduleMidiEvent(RobustMidiEvent midiEvent, uint time, bool absolute = false)
@@ -633,6 +703,9 @@ internal sealed class MidiRenderer : IMidiRenderer
     /// <inheritdoc />
     void IMidiRenderer.InternalDispose()
     {
+        OnMidiEvent = null;
+        OnMidiPlayerFinished = null;
+
         Source?.Dispose();
         _driver?.Dispose();
 

Robust.Client/Audio/Midi/MidiRendererState.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Runtime.InteropServices;
 using Robust.Shared.Utility;
+using Robust.Shared.ViewVariables;
 
 namespace Robust.Client.Audio.Midi;
 
@@ -12,7 +13,7 @@ public struct MidiRendererState
     internal FixedArray16<byte> ChannelPressure;
     internal FixedArray16<ushort> PitchBend;
 
-    internal Span<byte> AsSpan => MemoryMarshal.CreateSpan(ref NoteVelocities._00._00, 4160);
+    [ViewVariables] internal Span<byte> AsSpan => MemoryMarshal.CreateSpan(ref NoteVelocities._00._00, 4160);
 
     static unsafe MidiRendererState()
     {

Robust.Client/ClientIoC.cs

@@ -84,6 +84,7 @@ namespace Robust.Client
             deps.Register<IReplayLoadManager, ReplayLoadManager>();
             deps.Register<IReplayPlaybackManager, ReplayPlaybackManager>();
             deps.Register<IReplayRecordingManager, ReplayRecordingManager>();
+            deps.Register<IReplayRecordingManagerInternal, ReplayRecordingManager>();
             deps.Register<IClientGameStateManager, ClientGameStateManager>();
             deps.Register<IBaseClient, BaseClient>();
             deps.Register<IPlayerManager, PlayerManager>();

Robust.Client/Console/ClientConsoleHost.Completions.cs

@@ -14,7 +14,7 @@ internal sealed partial class ClientConsoleHost
     private int _completionSeq;
 
 
-    public async Task<CompletionResult> GetCompletions(List<string> args, CancellationToken cancel)
+    public async Task<CompletionResult> GetCompletions(List<string> args, string argStr, CancellationToken cancel)
     {
         // Last element is the command currently being typed. May be empty.
 
@@ -24,10 +24,10 @@ internal sealed partial class ClientConsoleHost
         if (delay > 0)
             await Task.Delay((int)(delay * 1000), cancel);
 
-        return await CalcCompletions(args, cancel);
+        return await CalcCompletions(args, argStr, cancel);
     }
 
-    private Task<CompletionResult> CalcCompletions(List<string> args, CancellationToken cancel)
+    private Task<CompletionResult> CalcCompletions(List<string> args, string argStr, CancellationToken cancel)
     {
         if (args.Count == 1)
         {
@@ -44,10 +44,10 @@ internal sealed partial class ClientConsoleHost
         if (!AvailableCommands.TryGetValue(args[0], out var cmd))
             return Task.FromResult(CompletionResult.Empty);
 
-        return cmd.GetCompletionAsync(LocalShell, args.ToArray()[1..], cancel).AsTask();
+        return cmd.GetCompletionAsync(LocalShell, args.ToArray()[1..], argStr, cancel).AsTask();
     }
 
-    private Task<CompletionResult> DoServerCompletions(List<string> args, CancellationToken cancel)
+    private Task<CompletionResult> DoServerCompletions(List<string> args, string argStr, CancellationToken cancel)
     {
         var tcs = new TaskCompletionSource<CompletionResult>();
         var cts = CancellationTokenSource.CreateLinkedTokenSource(cancel);
@@ -62,6 +62,7 @@ internal sealed partial class ClientConsoleHost
         var msg = new MsgConCompletion
         {
             Args = args.ToArray(),
+            ArgString = argStr,
             Seq = seq
         };
 

Robust.Client/Console/ClientConsoleHost.cs

@@ -10,6 +10,7 @@ using Robust.Shared.Console;
 using Robust.Shared.Enums;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Maths;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
 using Robust.Shared.Players;
@@ -21,13 +22,13 @@ namespace Robust.Client.Console
 {
     public sealed class AddStringArgs : EventArgs
     {
-        public string Text { get; }
+        public FormattedMessage Text { get; }
 
         public bool Local { get; }
 
         public bool Error { get; }
 
-        public AddStringArgs(string text, bool local, bool error)
+        public AddStringArgs(FormattedMessage text, bool local, bool error)
         {
             Text = text;
             Local = local;
@@ -132,10 +133,17 @@ namespace Robust.Client.Console
             AddFormatted?.Invoke(this, new AddFormattedMessageArgs(message));
         }
 
+        public override void WriteLine(ICommonSession? session, FormattedMessage msg)
+        {
+            AddFormattedLine(msg);
+        }
+
         /// <inheritdoc />
         public override void WriteError(ICommonSession? session, string text)
         {
-            OutputText(text, true, true);
+            var msg = new FormattedMessage();
+            msg.AddText(text);
+            OutputText(msg, true, true);
         }
 
         public bool IsCmdServer(IConsoleCommand cmd)
@@ -151,8 +159,13 @@ namespace Robust.Client.Console
             if (string.IsNullOrWhiteSpace(command))
                 return;
 
+            WriteLine(null, "");
+            var msg = new FormattedMessage();
+            msg.PushColor(Color.Gold);
+            msg.AddText("> " + command);
+            msg.Pop();
             // echo the command locally
-            WriteLine(null, "> " + command);
+            OutputText(msg, true, false);
 
             //Commands are processed locally and then sent to the server to be processed there again.
             var args = new List<string>();
@@ -205,7 +218,9 @@ namespace Robust.Client.Console
         /// <inheritdoc />
         public override void WriteLine(ICommonSession? session, string text)
         {
-            OutputText(text, true, false);
+            var msg = new FormattedMessage();
+            msg.AddText(text);
+            OutputText(msg, true, false);
         }
 
         /// <inheritdoc />
@@ -214,12 +229,12 @@ namespace Robust.Client.Console
             // We don't have anything to dispose.
         }
 
-        private void OutputText(string text, bool local, bool error)
+        private void OutputText(FormattedMessage text, bool local, bool error)
         {
             AddString?.Invoke(this, new AddStringArgs(text, local, error));
 
             var level = error ? LogLevel.Warning : LogLevel.Info;
-            _conLogger.Log(level, text);
+            _conLogger.Log(level, text.ToString());
         }
 
         private void OnNetworkConnected(object? sender, NetChannelArgs netChannelArgs)
@@ -229,7 +244,7 @@ namespace Robust.Client.Console
 
         private void HandleConCmdAck(MsgConCmdAck msg)
         {
-            OutputText("< " + msg.Text, false, msg.Error);
+            OutputText(msg.Text, false, msg.Error);
         }
 
         private void HandleConCmdReg(MsgConCmdReg msg)
@@ -303,13 +318,14 @@ namespace Robust.Client.Console
             public async ValueTask<CompletionResult> GetCompletionAsync(
                 IConsoleShell shell,
                 string[] args,
+                string argStr,
                 CancellationToken cancel)
             {
                 var host = (ClientConsoleHost)shell.ConsoleHost;
                 var argsList = args.ToList();
                 argsList.Insert(0, Command);
 
-                return await host.DoServerCompletions(argsList, cancel);
+                return await host.DoServerCompletions(argsList, argStr, cancel);
             }
         }
 
@@ -327,10 +343,11 @@ namespace Robust.Client.Console
             public override async ValueTask<CompletionResult> GetCompletionAsync(
                 IConsoleShell shell,
                 string[] args,
+                string argStr,
                 CancellationToken cancel)
             {
                 var host = (ClientConsoleHost)shell.ConsoleHost;
-                return await host.DoServerCompletions(args.ToList(), cancel);
+                return await host.DoServerCompletions(args.ToList(), argStr[">".Length..], cancel);
             }
         }
     }

Robust.Client/Console/Commands/Debug.cs

@@ -621,6 +621,7 @@ namespace Robust.Client.Console.Commands
 
     internal sealed class ChunkInfoCommand : LocalizedCommands
     {
+        [Dependency] private readonly IEntityManager _entManager = default!;
         [Dependency] private readonly IMapManager _map = default!;
         [Dependency] private readonly IEyeManager _eye = default!;
         [Dependency] private readonly IInputManager _input = default!;
@@ -631,16 +632,17 @@ namespace Robust.Client.Console.Commands
         {
             var mousePos = _eye.ScreenToMap(_input.MouseScreenPosition);
 
-            if (!_map.TryFindGridAt(mousePos, out _, out var grid))
+            if (!_map.TryFindGridAt(mousePos, out var gridUid, out var grid))
             {
                 shell.WriteLine("No grid under your mouse cursor.");
                 return;
             }
 
-            var chunkIndex = grid.LocalToChunkIndices(grid.MapToGrid(mousePos));
-            var chunk = grid.GetOrAddChunk(chunkIndex);
+            var mapSystem = _entManager.System<SharedMapSystem>();
+            var chunkIndex = mapSystem.LocalToChunkIndices(gridUid, grid, grid.MapToGrid(mousePos));
+            var chunk = mapSystem.GetOrAddChunk(gridUid, grid, chunkIndex);
 
-            shell.WriteLine($"worldBounds: {grid.CalcWorldAABB(chunk)} localBounds: {chunk.CachedBounds}");
+            shell.WriteLine($"worldBounds: {mapSystem.CalcWorldAABB(gridUid, grid, chunk)} localBounds: {chunk.CachedBounds}");
         }
     }
 

Robust.Client/Console/IClientConsoleHost.cs

@@ -19,6 +19,6 @@ namespace Robust.Client.Console
 
         void AddFormattedLine(FormattedMessage message);
 
-        Task<CompletionResult> GetCompletions(List<string> args, CancellationToken cancel);
+        Task<CompletionResult> GetCompletions(List<string> args, string argStr, CancellationToken cancel);
     }
 }

Robust.Client/Debugging/DebugPhysicsSystem.cs

@@ -218,7 +218,7 @@ namespace Robust.Client.Debugging
             _debugPhysicsSystem = system;
             _lookup = lookup;
             _physicsSystem = physicsSystem;
-            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+            _font = new VectorFont(cache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
         }
 
         private void DrawWorld(DrawingHandleWorld worldHandle, OverlayDrawArgs args)

Robust.Client/GameController/GameController.cs

@@ -33,6 +33,7 @@ using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Profiling;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Reflection;
 using Robust.Shared.Replays;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager;
@@ -84,7 +85,8 @@ namespace Robust.Client
         [Dependency] private readonly NetworkResourceManager _netResMan = default!;
         [Dependency] private readonly IReplayLoadManager _replayLoader = default!;
         [Dependency] private readonly IReplayPlaybackManager _replayPlayback = default!;
-        [Dependency] private readonly IReplayRecordingManager _replayRecording = default!;
+        [Dependency] private readonly IReplayRecordingManagerInternal _replayRecording = default!;
+        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
 
         private IWebViewManagerHook? _webViewHook;
 
@@ -162,6 +164,7 @@ namespace Robust.Client
             // before prototype load.
             ProgramShared.FinishCheckBadFileExtensions(checkBadExtensions);
 
+            _reflectionManager.Initialize();
             _prototypeManager.Initialize();
             _prototypeManager.LoadDefaultPrototypes();
             _prototypeManager.ResolveResults();
@@ -200,7 +203,12 @@ namespace Robust.Client
             // Setup main loop
             if (_mainLoop == null)
             {
-                _mainLoop = new GameLoop(_gameTiming, _runtimeLog, _prof, _logManager.GetSawmill("eng"))
+                _mainLoop = new GameLoop(
+                    _gameTiming,
+                    _runtimeLog,
+                    _prof,
+                    _logManager.GetSawmill("eng"),
+                    GameLoopOptions.FromCVars(_configurationManager))
                 {
                     SleepMode = displayMode == DisplayMode.Headless ? SleepMode.Delay : SleepMode.None
                 };
@@ -560,6 +568,11 @@ namespace Robust.Client
             {
                 _taskManager.ProcessPendingTasks(); // tasks like connect
             }
+
+            using (_prof.Group("Content post engine"))
+            {
+                _modLoader.BroadcastUpdate(ModUpdateLevel.InputPostEngine, frameEventArgs);
+            }
         }
 
         private void Tick(FrameEventArgs frameEventArgs)
@@ -756,6 +769,8 @@ namespace Robust.Client
 
         internal void CleanupGameThread()
         {
+            _replayRecording.Shutdown();
+
             _modLoader.Shutdown();
 
             // CEF specifically makes a massive silent stink of it if we don't shut it down from the correct thread.

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

@@ -15,15 +15,12 @@ namespace Robust.Client.GameObjects
         [Dependency] private readonly IEyeManager _eyeManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
 
-        [ViewVariables]
-        private Eye? _eye = default!;
+        [ViewVariables] internal Eye? _eye = default!;
 
         // Horrible hack to get around ordering issues.
-        private bool _setCurrentOnInitialize;
-        [DataField("drawFov")]
-        private bool _setDrawFovOnInitialize = true;
-        [DataField("zoom")]
-        private Vector2 _setZoomOnInitialize = Vector2.One;
+        internal bool _setCurrentOnInitialize;
+        [DataField("drawFov")] internal bool _setDrawFovOnInitialize = true;
+        [DataField("zoom")] internal Vector2 _setZoomOnInitialize = Vector2.One;
 
         /// <summary>
         ///     If not null, this entity is used to update the eye's position instead of just using the component's owner.
@@ -119,54 +116,6 @@ namespace Robust.Client.GameObjects
         [ViewVariables]
         public MapCoordinates? Position => _eye?.Position;
 
-        /// <inheritdoc />
-        protected override void Initialize()
-        {
-            base.Initialize();
-
-            _eye = new Eye
-            {
-                Position = _entityManager.GetComponent<TransformComponent>(Owner).MapPosition,
-                Zoom = _setZoomOnInitialize,
-                DrawFov = _setDrawFovOnInitialize
-            };
-
-            if ((_eyeManager.CurrentEye == _eye) != _setCurrentOnInitialize)
-            {
-                if (_setCurrentOnInitialize)
-                {
-                    _eyeManager.ClearCurrentEye();
-                }
-                else
-                {
-                    _eyeManager.CurrentEye = _eye;
-                }
-            }
-        }
-
-        public override void HandleComponentState(ComponentState? curState, ComponentState? nextState)
-        {
-            base.HandleComponentState(curState, nextState);
-
-            if (curState is not EyeComponentState state)
-            {
-                return;
-            }
-
-            DrawFov = state.DrawFov;
-            // TODO: Should be a way for content to override lerping and lerp the zoom
-            Zoom = state.Zoom;
-            Offset = state.Offset;
-            VisibilityMask = state.VisibilityMask;
-        }
-
-        protected override void OnRemove()
-        {
-            base.OnRemove();
-
-            Current = false;
-        }
-
         /// <summary>
         /// Updates the Eye of this entity with the transform position. This has to be called every frame to
         /// keep the view following the entity.

Robust.Client/GameObjects/EntitySystems/ClientOccluderSystem.cs

@@ -40,7 +40,7 @@ internal sealed class ClientOccluderSystem : OccluderSystem
             return;
 
         comp.Enabled = enabled;
-        Dirty(comp);
+        Dirty(uid, comp);
 
         var xform = Transform(uid);
         QueueTreeUpdate(uid, comp, xform);

Robust.Client/GameObjects/EntitySystems/DebugEntityLookupSystem.cs

@@ -38,7 +38,8 @@ public sealed class DebugEntityLookupSystem : EntitySystem
                 IoCManager.Resolve<IOverlayManager>().AddOverlay(
                     new EntityLookupOverlay(
                         EntityManager,
-                        Get<EntityLookupSystem>()));
+                        EntityManager.System<EntityLookupSystem>(),
+                        EntityManager.System<SharedTransformSystem>()));
             }
             else
             {
@@ -52,31 +53,35 @@ public sealed class DebugEntityLookupSystem : EntitySystem
 
 public sealed class EntityLookupOverlay : Overlay
 {
-    private IEntityManager _entityManager = default!;
-    private EntityLookupSystem _lookup = default!;
+    private readonly IEntityManager _entityManager;
+    private readonly EntityLookupSystem _lookup;
+    private readonly SharedTransformSystem _transform;
+
+    private EntityQuery<TransformComponent> _xformQuery;
 
     public override OverlaySpace Space => OverlaySpace.WorldSpace;
 
-    public EntityLookupOverlay(IEntityManager entManager, EntityLookupSystem lookup)
+    public EntityLookupOverlay(IEntityManager entManager, EntityLookupSystem lookup, SharedTransformSystem transform)
     {
         _entityManager = entManager;
         _lookup = lookup;
+        _xformQuery = entManager.GetEntityQuery<TransformComponent>();
+        _transform = transform;
     }
 
     protected internal override void Draw(in OverlayDrawArgs args)
     {
         var worldHandle = args.WorldHandle;
-        var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
+        var worldBounds = args.WorldBounds;
 
-        foreach (var lookup in _lookup.FindLookupsIntersecting(args.MapId, args.WorldBounds))
+        // TODO: Static version
+        _lookup.FindLookupsIntersecting(args.MapId, worldBounds, (uid, lookup) =>
         {
-            var lookupXform = xformQuery.GetComponent(lookup.Owner);
-
-            var (_, rotation, matrix, invMatrix) = lookupXform.GetWorldPositionRotationMatrixWithInv();
+            var (_, rotation, matrix, invMatrix) = _transform.GetWorldPositionRotationMatrixWithInv(uid);
 
             worldHandle.SetTransform(matrix);
 
-            var lookupAABB = invMatrix.TransformBox(args.WorldBounds);
+            var lookupAABB = invMatrix.TransformBox(worldBounds);
             var ents = new List<EntityUid>();
 
             lookup.DynamicTree.QueryAabb(ref ents, static (ref List<EntityUid> state, in FixtureProxy value) =>
@@ -105,20 +110,22 @@ public sealed class EntityLookupOverlay : Overlay
 
             foreach (var ent in ents)
             {
-                if (_entityManager.Deleted(ent)) continue;
-                var xform = xformQuery.GetComponent(ent);
+                if (_entityManager.Deleted(ent))
+                    continue;
+
+                var xform = _xformQuery.GetComponent(ent);
 
                 //DebugTools.Assert(!ent.IsInContainer(_entityManager));
-                var (entPos, entRot) = xform.GetWorldPositionRotation();
+                var (entPos, entRot) = _transform.GetWorldPositionRotation(ent);
 
                 var lookupPos = invMatrix.Transform(entPos);
                 var lookupRot = entRot - rotation;
 
-                var aabb = _lookup.GetAABB(ent, lookupPos, lookupRot, xform, xformQuery);
+                var aabb = _lookup.GetAABB(ent, lookupPos, lookupRot, xform, _xformQuery);
 
                 worldHandle.DrawRect(aabb, Color.Blue.WithAlpha(0.2f));
             }
-        }
+        });
 
         worldHandle.SetTransform(Matrix3.Identity);
     }

Robust.Client/GameObjects/EntitySystems/EyeSystem.cs

@@ -0,0 +1,60 @@
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameStates;
+using Robust.Shared.IoC;
+
+namespace Robust.Client.GameObjects;
+
+public sealed class EyeSystem : SharedEyeSystem
+{
+    [Dependency] private readonly IEyeManager _eyeManager = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<EyeComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<EyeComponent, ComponentRemove>(OnRemove);
+        SubscribeLocalEvent<EyeComponent, ComponentHandleState>(OnHandleState);
+    }
+
+    private void OnInit(EntityUid uid, EyeComponent component, ComponentInit args)
+    {
+        component._eye = new Eye
+        {
+            Position = Transform(uid).MapPosition,
+            Zoom = component._setZoomOnInitialize,
+            DrawFov = component._setDrawFovOnInitialize
+        };
+
+        if ((_eyeManager.CurrentEye == component._eye) != component._setCurrentOnInitialize)
+        {
+            if (component._setCurrentOnInitialize)
+            {
+                _eyeManager.ClearCurrentEye();
+            }
+            else
+            {
+                _eyeManager.CurrentEye = component._eye;
+            }
+        }
+    }
+
+    private void OnRemove(EntityUid uid, EyeComponent component, ComponentRemove args)
+    {
+        component.Current = false;
+    }
+
+    private void OnHandleState(EntityUid uid, EyeComponent component, ref ComponentHandleState args)
+    {
+        if (args.Current is not EyeComponentState state)
+        {
+            return;
+        }
+
+        component.DrawFov = state.DrawFov;
+        // TODO: Should be a way for content to override lerping and lerp the zoom
+        component.Zoom = state.Zoom;
+        component.Offset = state.Offset;
+        component.VisibilityMask = state.VisibilityMask;
+    }
+}

Robust.Client/GameObjects/EntitySystems/GridRenderingSystem.cs

@@ -16,4 +16,9 @@ internal sealed class GridRenderingSystem : EntitySystem
     {
         _clyde.RegisterGridEcsEvents();
     }
+
+    public override void Shutdown()
+    {
+        _clyde.ShutdownGridEcsEvents();
+    }
 }

Robust.Client/GameObjects/EntitySystems/PointLightSystem.cs

@@ -37,7 +37,7 @@ namespace Robust.Client.GameObjects
                 return;
 
             comp.ContainerOccluded = occluded;
-            Dirty(comp);
+            Dirty(uid, comp);
 
             if (comp.Enabled)
                 _lightTree.QueueTreeUpdate(uid, comp);
@@ -50,7 +50,7 @@ namespace Robust.Client.GameObjects
 
             comp._enabled = enabled;
             RaiseLocalEvent(uid, new PointLightToggleEvent(comp.Enabled));
-            Dirty(comp);
+            Dirty(uid, comp);
 
             var cast = (PointLightComponent)comp;
             if (!cast.ContainerOccluded)
@@ -63,7 +63,7 @@ namespace Robust.Client.GameObjects
                 return;
 
             comp._radius = radius;
-            Dirty(comp);
+            Dirty(uid, comp);
 
             var cast = (PointLightComponent)comp;
             if (cast.TreeUid != null)

Robust.Client/GameObjects/EntitySystems/TransformSystem.Component.cs

@@ -22,6 +22,13 @@ public sealed partial class TransformSystem
         base.SetLocalPositionNoLerp(xform, value);
     }
 
+    public override void SetLocalRotationNoLerp(TransformComponent xform, Angle angle)
+    {
+        xform.NextRotation = null;
+        xform.LerpParent = EntityUid.Invalid;
+        base.SetLocalRotationNoLerp(xform, angle);
+    }
+
     public override void SetLocalRotation(TransformComponent xform, Angle angle)
     {
         xform.PrevRotation = xform._localRotation;

Robust.Client/GameStates/ClientGameStateManager.cs

@@ -532,7 +532,6 @@ namespace Robust.Client.GameStates
 
                     var handleState = new ComponentHandleState(compState, null);
                     _entities.EventBus.RaiseComponentEvent(comp, ref handleState);
-                    comp.HandleComponentState(compState, null);
                     comp.LastModifiedTick = _timing.LastRealTick;
                 }
 
@@ -561,7 +560,6 @@ namespace Robust.Client.GameStates
 
                         var stateEv = new ComponentHandleState(state, null);
                         _entities.EventBus.RaiseComponentEvent(comp, ref stateEv);
-                        comp.HandleComponentState(state, null);
                         comp.ClearCreationTick(); // don't undo the re-adding.
                         comp.LastModifiedTick = _timing.LastRealTick;
                     }
@@ -747,10 +745,6 @@ namespace Robust.Client.GameStates
                 }
             }
 
-            var contQuery = _entities.GetEntityQuery<ContainerManagerComponent>();
-            var physicsQuery = _entities.GetEntityQuery<PhysicsComponent>();
-            var fixturesQuery = _entities.GetEntityQuery<FixturesComponent>();
-            var broadQuery = _entities.GetEntityQuery<BroadphaseComponent>();
             var queuedBroadphaseUpdates = new List<(EntityUid, TransformComponent)>(enteringPvs);
 
             // Apply entity states.
@@ -1172,7 +1166,6 @@ namespace Robust.Client.GameStates
                 {
                     var handleState = new ComponentHandleState(cur, next);
                     bus.RaiseComponentEvent(comp, ref handleState);
-                    comp.HandleComponentState(cur, next);
                 }
                 catch (Exception e)
                 {
@@ -1223,7 +1216,7 @@ namespace Robust.Client.GameStates
                 return;
 
             using var _ = _timing.StartStateApplicationArea();
-            ResetEnt(meta, false);
+            ResetEnt(uid, meta, false);
         }
 
         /// <summary>
@@ -1301,24 +1294,24 @@ namespace Robust.Client.GameStates
         {
             using var _ = _timing.StartStateApplicationArea();
 
-            foreach (var meta in _entities.EntityQuery<MetaDataComponent>(true))
+            var query = _entityManager.AllEntityQueryEnumerator<MetaDataComponent>();
+
+            while (query.MoveNext(out var uid, out var meta))
             {
-                ResetEnt(meta);
+                ResetEnt(uid, meta);
             }
         }
 
         /// <summary>
         ///     Reset a given entity to the most recent server state.
         /// </summary>
-        private void ResetEnt(MetaDataComponent meta, bool skipDetached = true)
+        private void ResetEnt(EntityUid uid, MetaDataComponent meta, bool skipDetached = true)
         {
             if (skipDetached && (meta.Flags & MetaDataFlags.Detached) != 0)
                 return;
 
             meta.Flags &= ~MetaDataFlags.Detached;
 
-            var uid = meta.Owner;
-
             if (!_processor.TryGetLastServerStates(uid, out var lastState))
                 return;
 
@@ -1334,7 +1327,6 @@ namespace Robust.Client.GameStates
 
                 var handleState = new ComponentHandleState(state, null);
                 _entityManager.EventBus.RaiseComponentEvent(comp, ref handleState);
-                comp.HandleComponentState(state, null);
             }
 
             // ensure we don't have any extra components

Robust.Client/GameStates/NetEntityOverlay.cs

@@ -41,7 +41,7 @@ namespace Robust.Client.GameStates
         {
             IoCManager.InjectDependencies(this);
             var cache = IoCManager.Resolve<IResourceCache>();
-            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+            _font = new VectorFont(cache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
             _lineHeight = _font.GetLineHeight(1);
 
             _gameStateManager.GameStateApplied += HandleGameStateApplied;

Robust.Client/GameStates/NetGraphOverlay.cs

@@ -53,7 +53,7 @@ namespace Robust.Client.GameStates
         {
             IoCManager.InjectDependencies(this);
             var cache = IoCManager.Resolve<IResourceCache>();
-            _font = new VectorFont(cache.GetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf"), 10);
+            _font = new VectorFont(cache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
 
             _gameStateManager.GameStateApplied += HandleGameStateApplied;
         }

Robust.Client/Graphics/Audio/ClydeAudio.Formats.OggVorbis.cs

@@ -27,7 +27,7 @@ namespace Robust.Client.Graphics.Audio
                     readSamples += read;
                 }
 
-                return new OggVorbisData(totalSamples, sampleRate, channels, buffer);
+                return new OggVorbisData(totalSamples, sampleRate, channels, buffer, vorbis.Tags.Title, vorbis.Tags.Artist);
             }
         }
 
@@ -37,13 +37,17 @@ namespace Robust.Client.Graphics.Audio
             public readonly long SampleRate;
             public readonly long Channels;
             public readonly ReadOnlyMemory<float> Data;
+            public readonly string Title;
+            public readonly string Artist;
 
-            public OggVorbisData(long totalSamples, long sampleRate, long channels, ReadOnlyMemory<float> data)
+            public OggVorbisData(long totalSamples, long sampleRate, long channels, ReadOnlyMemory<float> data, string title, string artist)
             {
                 TotalSamples = totalSamples;
                 SampleRate = sampleRate;
                 Channels = channels;
                 Data = data;
+                Title = title;
+                Artist = artist;
             }
         }
     }

Robust.Client/Graphics/Audio/ClydeAudio.cs

@@ -261,6 +261,9 @@ namespace Robust.Client.Graphics.Audio
         {
             var source = AL.GenSource();
 
+            if (!AL.IsSource(source))
+                throw new Exception("Failed to generate source. Too many simultaneous audio streams?");
+
             // ReSharper disable once PossibleInvalidOperationException
 
             var audioSource = new BufferedAudioSource(this, source, AL.GenBuffers(buffers), floatAudio);
@@ -326,7 +329,7 @@ namespace Robust.Client.Graphics.Audio
             var handle = new ClydeHandle(_audioSampleBuffers.Count);
             _audioSampleBuffers.Add(new LoadedAudioSample(buffer));
             var length = TimeSpan.FromSeconds(vorbis.TotalSamples / (double) vorbis.SampleRate);
-            return new AudioStream(handle, length, (int) vorbis.Channels, name);
+            return new AudioStream(handle, length, (int) vorbis.Channels, name, vorbis.Title, vorbis.Artist);
         }
 
         public AudioStream LoadAudioWav(Stream stream, string? name = null)

Robust.Client/Graphics/Clyde/Clyde.cs

@@ -176,6 +176,14 @@ namespace Robust.Client.Graphics.Clyde
             _entityManager.EventBus.SubscribeEvent<GridModifiedEvent>(EventSource.Local, this, _updateOnGridModified);
         }
 
+        public void ShutdownGridEcsEvents()
+        {
+            _entityManager.EventBus.UnsubscribeEvent<TileChangedEvent>(EventSource.Local, this);
+            _entityManager.EventBus.UnsubscribeEvent<GridStartupEvent>(EventSource.Local, this);
+            _entityManager.EventBus.UnsubscribeEvent<GridRemovalEvent>(EventSource.Local, this);
+            _entityManager.EventBus.UnsubscribeEvent<GridModifiedEvent>(EventSource.Local, this);
+        }
+
         private void GLInitBindings(bool gles)
         {
             _glBindingsContext = _glContext!.BindingsContext;

Robust.Client/Graphics/Clyde/ClydeHeadless.cs

@@ -88,6 +88,11 @@ namespace Robust.Client.Graphics.Clyde
             // Nada.
         }
 
+        public void ShutdownGridEcsEvents()
+        {
+
+        }
+
         public void SetWindowTitle(string title)
         {
             // Nada.

Robust.Client/Graphics/Clyde/Shaders/base-default.frag

@@ -12,9 +12,9 @@ void main()
 
     lowp vec4 COLOR;
 
-    // [SHADER_CODE]
-
     lowp vec3 lightSample = texture2D(lightMap, Pos).rgb;
 
+    // [SHADER_CODE]
+
     gl_FragColor = zAdjustResult(COLOR * VtxModulate * vec4(lightSample, 1.0));
 }

Robust.Client/Graphics/IClydeInternal.cs

@@ -65,6 +65,8 @@ namespace Robust.Client.Graphics
 
         void RegisterGridEcsEvents();
 
+        void ShutdownGridEcsEvents();
+
         void RunOnWindowThread(Action action);
     }
 }

Robust.Client/Physics/GridFixtureSystem.cs

@@ -23,7 +23,7 @@ namespace Robust.Client.Physics
             {
                 if (_enableDebug == value) return;
 
-                Sawmill.Info($"Set grid fixture debug to {value}");
+                Log.Info($"Set grid fixture debug to {value}");
                 _enableDebug = value;
 
                 if (_enableDebug)
@@ -59,7 +59,7 @@ namespace Robust.Client.Physics
 
         private void OnDebugMessage(ChunkSplitDebugMessage ev)
         {
-            Sawmill.Info($"Received grid fixture debug data");
+            Log.Info($"Received grid fixture debug data");
             if (!_enableDebug) return;
 
             _nodes[ev.Grid] = ev.Nodes;

Robust.Client/Placement/PlacementManager.cs

@@ -694,6 +694,9 @@ namespace Robust.Client.Placement
             IsActive = true;
 
             CurrentPlacementOverlayEntity = EntityManager.SpawnEntity(templateName, MapCoordinates.Nullspace);
+            EntityManager.RunMapInit(
+                CurrentPlacementOverlayEntity.Value,
+                EntityManager.GetComponent<MetaDataComponent>(CurrentPlacementOverlayEntity.Value));
         }
 
         public void PreparePlacementSprite(SpriteComponent sprite)

Robust.Client/Profiling/LiveProfileViewControl.cs

@@ -24,7 +24,7 @@ public sealed class LiveProfileViewControl : Control
     {
         IoCManager.InjectDependencies(this);
 
-        if (!_resourceCache.TryGetResource<FontResource>("/Fonts/NotoSans/NotoSans-Regular.ttf", out var font))
+        if (!_resourceCache.TryGetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf", out var font))
             return;
 
         _font = font.MakeDefault();

Robust.Client/Replays/Playback/ReplayPlaybackManager.Update.cs

@@ -97,6 +97,8 @@ internal sealed partial class ReplayPlaybackManager
 
             if (message is EntityEventArgs args)
                 _entMan.DispatchReceivedNetworkMsg(args);
+            else if (_warned.Add(message.GetType()))
+                _sawmill.Error($"Unhandled replay message: {message.GetType()}.");
         }
     }
 }

Robust.Client/Replays/Playback/ReplayPlaybackManager.cs

@@ -55,6 +55,7 @@ internal sealed partial class ReplayPlaybackManager : IReplayPlaybackManager
 
     private bool _initialized;
     private ISawmill _sawmill = default!;
+    private HashSet<Type> _warned = new();
 
     public bool Playing
     {

Robust.Client/Replays/ReplayRecordingManager.cs

@@ -78,15 +78,16 @@ internal sealed class ReplayRecordingManager : SharedReplayRecordingManager
         IWritableDirProvider directory,
         string? name = null,
         bool overwrite = false,
-        TimeSpan? duration = null)
+        TimeSpan? duration = null,
+        object? state = null)
     {
-        if (!base.TryStartRecording(directory, name, overwrite, duration))
+        if (!base.TryStartRecording(directory, name, overwrite, duration, state))
             return false;
 
-        var (state, detachMsg) = CreateFullState();
+        var (gameState, detachMsg) = CreateFullState();
         if (detachMsg != null)
             RecordReplayMessage(detachMsg);
-        Update(state);
+        Update(gameState);
         return true;
     }
 

Robust.Client/Robust.Client.csproj

@@ -17,7 +17,7 @@
     <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.2" Condition="'$(UseSystemSqlite)' != 'True'" />
     <PackageReference Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
     <PackageReference Include="NVorbis" Version="0.10.1" />
-    <PackageReference Include="SixLabors.ImageSharp" Version="2.1.7" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="2.1.3" />
     <PackageReference Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" />
     <PackageReference Include="OpenTK.OpenAL" Version="4.7.5" />
     <PackageReference Include="SpaceWizards.SharpFont" Version="1.0.1" />
@@ -50,6 +50,7 @@
   <!-- ILLink configuration -->
   <ItemGroup>
     <RobustLinkRoots Include="Robust.Client" />
+    <RobustLinkRoots Include="Robust.Shared" />
     <RobustLinkAssemblies Include="TerraFX.Interop.Windows" />
     <RobustLinkAssemblies Include="OpenToolkit.Graphics" />
   </ItemGroup>

Robust.Client/UserInterface/Control.Animations.cs

@@ -55,12 +55,12 @@ namespace Robust.Client.UserInterface
                     continue;
 
                 toRemove.Add(key);
-                AnimationCompleted?.Invoke(key);
             }
 
             foreach (var key in toRemove)
             {
                 _playingAnimations.Remove(key);
+                AnimationCompleted?.Invoke(key);
             }
         }
     }

Robust.Client/UserInterface/Controls/ItemList.cs

@@ -88,9 +88,9 @@ namespace Robust.Client.UserInterface.Controls
                 _scrollBar.MoveToEnd();
         }
 
-        public Item AddItem(string text, Texture? icon = null, bool selectable = true)
+        public Item AddItem(string text, Texture? icon = null, bool selectable = true, object? metadata = null)
         {
-            var item = new Item(this) {Text = text, Icon = icon, Selectable = selectable};
+            var item = new Item(this) {Text = text, Icon = icon, Selectable = selectable, Metadata = metadata};
             Add(item);
             return item;
         }
@@ -448,7 +448,8 @@ namespace Robust.Client.UserInterface.Controls
                 {
                     if (item.Selected && SelectMode != ItemListSelectMode.Button)
                     {
-                        ClearSelected();
+                        if(SelectMode != ItemListSelectMode.Multiple)
+                            ClearSelected();
                         item.Selected = false;
                         return;
                     }

Robust.Client/UserInterface/CustomControls/DebugConsole.xaml

@@ -1,7 +1,7 @@
 <Control xmlns="https://spacestation14.io"
          xmlns:gfx="clr-namespace:Robust.Client.Graphics">
     <BoxContainer Orientation="Vertical">
-        <OutputPanel Name="Output" VerticalExpand="True">
+        <OutputPanel Name="Output" VerticalExpand="True" StyleClasses="monospace">
             <OutputPanel.StyleBoxOverride>
                 <gfx:StyleBoxFlat BackgroundColor="#25252add"
                                   ContentMarginLeftOverride="3" ContentMarginRightOverride="3"

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

@@ -90,7 +90,7 @@ public sealed partial class DebugConsole
 
     private async void TypeUpdateCompletions(bool fullUpdate)
     {
-        var (args, _, _) = CalcTypingArgs();
+        var (args, _, _, str) = CalcTypingArgs();
 
         if (args.Count != _compParamCount)
         {
@@ -101,7 +101,7 @@ public sealed partial class DebugConsole
         if (fullUpdate)
         {
             var seq = ++_compSeqSend;
-            var task = _consoleHost.GetCompletions(args, _compCancel.Token);
+            var task = _consoleHost.GetCompletions(args, str, _compCancel.Token);
 
             if (!task.IsCompleted)
             {
@@ -140,7 +140,7 @@ public sealed partial class DebugConsole
         if (_compCurResult == null)
             return;
 
-        var (_, curTyping, _) = CalcTypingArgs();
+        var (_, curTyping, _, _) = CalcTypingArgs();
 
         var curSelected = _compFiltered?.Length > 0 ? _compFiltered[_compSelected] : default;
         _compFiltered = FilterCompletions(_compCurResult.Options, curTyping);
@@ -168,7 +168,7 @@ public sealed partial class DebugConsole
 
         DebugTools.AssertNotNull(_compCurResult);
 
-        var (_, _, endRange) = CalcTypingArgs();
+        var (_, _, endRange, _) = CalcTypingArgs();
 
         var offset = CommandBar.GetOffsetAtIndex(endRange.start);
         // Logger.Debug($"Offset: {offset}");
@@ -231,7 +231,7 @@ public sealed partial class DebugConsole
         }
     }
 
-    private (List<string> args, string curTyping, (int start, int end) lastRange) CalcTypingArgs()
+    private (List<string> args, string curTyping, (int start, int end) lastRange, string argStr) CalcTypingArgs()
     {
         var cursor = CommandBar.CursorPosition;
         // Don't consider text after the cursor.
@@ -252,7 +252,7 @@ public sealed partial class DebugConsole
         else
             lastRange = (cursor, cursor);
 
-        return (args, args[^1], lastRange);
+        return (args, args[^1], lastRange, text.ToString());
     }
 
     private CompletionOption[] FilterCompletions(IEnumerable<CompletionOption> completions, string curTyping)
@@ -270,7 +270,7 @@ public sealed partial class DebugConsole
             {
                 // Figure out typing word so we know how much to replace.
                 var (completion, _, completionFlags) = _compFiltered[_compSelected];
-                var (_, _, lastRange) = CalcTypingArgs();
+                var (_, _, lastRange, _) = CalcTypingArgs();
 
                 // Replace the full word from the start.
                 // This means that letter casing will match the completion suggestion.

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

@@ -23,9 +23,9 @@ namespace Robust.Client.UserInterface.CustomControls
         /// <summary>
         /// Write a line with a specific color to the console window.
         /// </summary>
-        void AddLine(string text, Color color);
+        void AddLine(FormattedMessage text, Color color);
 
-        void AddLine(string text);
+        void AddLine(FormattedMessage text);
 
         void AddFormattedLine(FormattedMessage message);
 
@@ -108,7 +108,7 @@ namespace Robust.Client.UserInterface.CustomControls
 
         private Color DetermineColor(bool local, bool error)
         {
-            return Color.White;
+            return error ? Color.Red : Color.White;
         }
 
         protected override void FrameUpdate(FrameEventArgs args)
@@ -136,16 +136,16 @@ namespace Robust.Client.UserInterface.CustomControls
             _flushHistoryToDisk();
         }
 
-        public void AddLine(string text, Color color)
+        public void AddLine(FormattedMessage text, Color color)
         {
             var formatted = new FormattedMessage(3);
             formatted.PushColor(color);
-            formatted.AddText(text);
+            formatted.AddMessage(text);
             formatted.Pop();
             AddFormattedLine(formatted);
         }
 
-        public void AddLine(string text)
+        public void AddLine(FormattedMessage text)
         {
             AddLine(text, Color.White);
         }

Robust.Client/UserInterface/CustomControls/DebugMonitorControls/DebugCoordsPanel.cs

@@ -62,18 +62,19 @@ namespace Robust.Client.UserInterface.CustomControls.DebugMonitorControls
             var screenSize = _displayManager.ScreenSize;
             var screenScale = _displayManager.MainWindow.ContentScale;
 
-            MapCoordinates mouseWorldMap;
             EntityCoordinates mouseGridPos;
             TileRef tile;
 
-            mouseWorldMap = _eyeManager.ScreenToMap(mouseScreenPos);
+            var mouseWorldMap = _eyeManager.ScreenToMap(mouseScreenPos);
             if (mouseWorldMap == MapCoordinates.Nullspace)
                 return;
 
-            if (_mapManager.TryFindGridAt(mouseWorldMap, out _, out var mouseGrid))
+            var mapSystem = _entityManager.System<SharedMapSystem>();
+
+            if (_mapManager.TryFindGridAt(mouseWorldMap, out var mouseGridUid, out var mouseGrid))
             {
-                mouseGridPos = mouseGrid.MapToGrid(mouseWorldMap);
-                tile = mouseGrid.GetTileRef(mouseGridPos);
+                mouseGridPos = mapSystem.MapToGrid(mouseGridUid, mouseWorldMap);
+                tile = mapSystem.GetTileRef(mouseGridUid, mouseGrid, mouseGridPos);
             }
             else
             {

Robust.Client/UserInterface/Stylesheets/DefaultStylesheet.cs

@@ -15,6 +15,9 @@ public sealed class DefaultStylesheet
     {
         var notoSansFont = res.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf");
         var notoSansFont12 = new VectorFont(notoSansFont, 12);
+        var notoSansMonoFont = res.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSansMono-Regular.ttf");
+        var notoSansMono12 = new VectorFont(notoSansMonoFont, 12);
+
 
         var theme = userInterfaceManager.CurrentTheme;
 
@@ -38,6 +41,13 @@ public sealed class DefaultStylesheet
 
         Stylesheet = new Stylesheet(new StyleRule[]
         {
+            /*
+             * Debug console and other monospace things.
+             */
+
+            Element().Class("monospace")
+                .Prop("font", notoSansMono12),
+
             /*
              * OS Window defaults
              */

Robust.Client/Utility/DiscordRichPresence.cs

@@ -1,3 +1,5 @@
+using System;
+using System.Text;
 using DiscordRPC;
 using DiscordRPC.Logging;
 using Robust.Shared;
@@ -25,13 +27,17 @@ namespace Robust.Client.Utility
 
         public void Initialize()
         {
+            var state = _loc.GetString("discord-rpc-in-main-menu");
+            var largeImageKey = _configurationManager.GetCVar(CVars.DiscordRichPresenceSecondIconId);
+            var largeImageText = _loc.GetString("discord-rpc-in-main-menu-logo-text");
+
             _defaultPresence = new()
             {
-                State = _loc.GetString("discord-rpc-in-main-menu"),
+                State = Truncate(state, 128),
                 Assets = new Assets
                 {
-                    LargeImageKey = "logo",
-                    LargeImageText = "I think coolsville SUCKS"
+                    LargeImageKey = Truncate(largeImageKey, 32),
+                    LargeImageText = Truncate(largeImageText, 128),
                 }
             };
             _configurationManager.OnValueChanged(CVars.DiscordEnabled, newValue =>
@@ -95,18 +101,60 @@ namespace Robust.Client.Utility
 
         public void Update(string serverName, string username, string maxUsers, string users)
         {
-            _activePresence = new RichPresence
+            if (_client == null)
+                return;
+
+            try
             {
-                Details = _loc.GetString("discord-rpc-on-server", ("servername", serverName)),
-                State = _loc.GetString("discord-rpc-players", ("players", users), ("maxplayers", maxUsers)),
-                Assets = new Assets
+                var details = _loc.GetString("discord-rpc-on-server", ("servername", serverName));
+                var state = _loc.GetString("discord-rpc-players", ("players", users), ("maxplayers", maxUsers));
+                var largeImageText = _loc.GetString("discord-rpc-character", ("username", username));
+                var largeImageKey = _configurationManager.GetCVar(CVars.DiscordRichPresenceMainIconId);
+                var smallImageKey = _configurationManager.GetCVar(CVars.DiscordRichPresenceSecondIconId);
+
+                // Strings are limited by byte count. See the setters in RichPresence. Hence the truncate calls.
+                _activePresence = new RichPresence
                 {
-                    LargeImageKey = "devstation",
-                    LargeImageText = _loc.GetString("discord-rpc-character", ("username", username)),
-                    SmallImageKey = "logo"
-                }
-            };
-            _client?.SetPresence(_activePresence);
+                    Details = Truncate(details, 128),
+                    State = Truncate(state, 128),
+                    Assets = new Assets
+                    {
+                        LargeImageKey = Truncate(largeImageKey, 32),
+                        LargeImageText = Truncate(largeImageText, 128),
+                        SmallImageKey = Truncate(smallImageKey, 32)
+                    }
+                };
+                _client.SetPresence(_activePresence);
+            }
+            catch (Exception ex)
+            {
+                _client.Logger.Error($"Caught exception while updating discord rich presence. Exception:\n{ex}");
+            }
+        }
+
+        private string Truncate(string value, int bytes, string postfix = "...")
+            => Truncate(value, bytes, postfix, Encoding.UTF8);
+
+        /// <summary>
+        /// Truncate strings down to some minimum byte count. If the string gets truncated, it will have the postfix appended.
+        /// </summary>
+        private string Truncate(string value, int bytes, string postfix, Encoding encoding)
+        {
+            value = value.Trim();
+            var output = value;
+
+            // Theres probably a better way of doing this, but I don't know how.
+            // If this wasn't a crude hack this function should
+            while (encoding.GetByteCount(output) > bytes)
+            {
+                if (value.Length == 0)
+                    return string.Empty;
+
+                value = value.Substring(0, value.Length - 1);
+                output = value + postfix;
+            }
+
+            return output;
         }
 
         public void ClearPresence()

Robust.Client/ViewVariables/Instances/ViewVariablesInstanceEntity.cs

@@ -88,7 +88,7 @@ namespace Robust.Client.ViewVariables.Instances
                 var stringified = PrettyPrint.PrintUserFacingWithType(obj, out var typeStringified);
                 if (typeStringified != "")
                 {
-                    //var smallFont = new VectorFont(_resourceCache.GetResource<FontResource>("/Fonts/CALIBRI.TTF"), 10);
+                    //var smallFont = new VectorFont(_resourceCache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
                     // Custom ToString() implementation.
                     var headBox = new BoxContainer
                     {

Robust.Client/ViewVariables/ViewVariablesInstance.cs

@@ -121,7 +121,7 @@ namespace Robust.Client.ViewVariables
             }
 
             //var smallFont =
-            //    new VectorFont(IoCManager.Resolve<IResourceCache>().GetResource<FontResource>("/Fonts/CALIBRI.TTF"),
+            //    new VectorFont(IoCManager.Resolve<IResourceCache>().GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"),
             //        10);
 
             // Custom ToString() implementation.

Robust.Client/ViewVariables/ViewVariablesPropertyControl.cs

@@ -57,7 +57,7 @@ namespace Robust.Client.ViewVariables
             };
             VBox.AddChild(BottomContainer);
 
-            //var smallFont = new VectorFont(_resourceCache.GetResource<FontResource>("/Fonts/CALIBRI.TTF"), 10);
+            //var smallFont = new VectorFont(_resourceCache.GetResource<FontResource>("/EngineFonts/NotoSans/NotoSans-Regular.ttf"), 10);
 
             _bottomLabel = new Label
             {

Robust.Server/BaseServer.cs

@@ -30,7 +30,9 @@ using Robust.Shared.Map;
 using Robust.Shared.Network;
 using Robust.Shared.Profiling;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Reflection;
 using Robust.Shared.Replays;
+using Robust.Shared.Toolshed;
 using Robust.Shared.Serialization;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Threading;
@@ -98,9 +100,10 @@ namespace Robust.Server
         [Dependency] private readonly ISerializationManager _serialization = default!;
         [Dependency] private readonly IStatusHost _statusHost = default!;
         [Dependency] private readonly IComponentFactory _componentFactory = default!;
-        [Dependency] private readonly IReplayRecordingManager _replay = default!;
+        [Dependency] private readonly IReplayRecordingManagerInternal _replay = default!;
         [Dependency] private readonly IGamePrototypeLoadManager _protoLoadMan = default!;
         [Dependency] private readonly NetworkResourceManager _netResMan = default!;
+        [Dependency] private readonly IReflectionManager _refMan = default!;
 
         private readonly Stopwatch _uptimeStopwatch = new();
 
@@ -367,7 +370,9 @@ namespace Robust.Server
             _prototype.Initialize();
             _prototype.LoadDefaultPrototypes();
             _prototype.ResolveResults();
+            _refMan.Initialize();
 
+            IoCManager.Resolve<ToolshedManager>().Initialize();
             _consoleHost.Initialize();
             _entityManager.Startup();
             _mapManager.Startup();
@@ -510,7 +515,12 @@ namespace Robust.Server
         {
             if (_mainLoop == null)
             {
-                _mainLoop = new GameLoop(_time, _runtimeLog, _prof, _log.GetSawmill("eng"))
+                _mainLoop = new GameLoop(
+                    _time,
+                    _runtimeLog,
+                    _prof,
+                    _log.GetSawmill("eng"),
+                    GameLoopOptions.FromCVars(_config))
                 {
                     SleepMode = SleepMode.Delay,
                     DetectSoftLock = true,
@@ -628,6 +638,8 @@ namespace Robust.Server
         // called right before main loop returns, do all saving/cleanup in here
         public void Cleanup()
         {
+            _replay.Shutdown();
+
             _modLoader.Shutdown();
 
             _playerManager.Shutdown();
@@ -670,6 +682,8 @@ namespace Robust.Server
 
             _network.ProcessPackets();
             _taskManager.ProcessPendingTasks();
+
+            _modLoader.BroadcastUpdate(ModUpdateLevel.InputPostEngine, args);
         }
 
         private void Update(FrameEventArgs frameEventArgs)

Robust.Server/Bql/BqlQueryManager.Parsers.cs

@@ -1,162 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using JetBrains.Annotations;
-using Pidgin;
-using Robust.Shared.GameObjects;
-using static Pidgin.Parser;
-using static Pidgin.Parser<char>;
-
-namespace Robust.Server.Bql
-{
-    public partial class BqlQueryManager
-    {
-        private readonly Dictionary<Type, Parser<char, BqlQuerySelectorParsed>> _parsers = new();
-        private Parser<char, BqlQuerySelectorParsed> _allQuerySelectors = default!;
-        private Parser<char, (IEnumerable<BqlQuerySelectorParsed>, string)> SimpleQuery => Parser.Map((en, _, rest) => (en, rest), SkipWhitespaces.Then(_allQuerySelectors).Many(), String("do").Then(SkipWhitespaces), Any.ManyString());
-
-        private static Parser<char, string> Word => OneOf(LetterOrDigit, Char('_')).ManyString();
-
-        private static Parser<char, object> Objectify<T>(Parser<char, T> inp)
-        {
-            return Parser.Map(x => (object) x!, inp);
-        }
-
-        private struct SubstitutionData
-        {
-            public string Name;
-
-            public SubstitutionData(string name)
-            {
-                Name = name;
-            }
-        }
-
-        private static Parser<char, SubstitutionData> Substitution =>
-            Try(Char('$').Then(OneOf(Uppercase, Char('_')).ManyString()))
-                .MapWithInput((x, _) => new SubstitutionData(x.ToString()));
-
-        private static Parser<char, int> Integer =>
-            Try(Int(10));
-
-        private static Parser<char, object> SubstitutableInteger =>
-            Objectify(Integer).Or(Objectify(Try(Substitution)));
-
-        private static Parser<char, double> Float =>
-            Try(Real);
-
-        private static Parser<char, object> SubstitutableFloat =>
-            Objectify(Float).Or(Objectify(Try(Substitution)));
-
-        private static Parser<char, double> Percentage =>
-            Try(Real).Before(Char('%'));
-
-        private static Parser<char, object> SubstitutablePercentage =>
-            Objectify(Percentage).Or(Objectify(Try(Substitution)));
-
-        private static Parser<char, EntityUid> EntityId =>
-            Try(Parser.Map(x => new EntityUid(x), Int(10)));
-
-        private static Parser<char, object> SubstitutableEntityId =>
-            Objectify(EntityId).Or(Objectify(Try(Substitution)));
-
-        private Parser<char, Type> Component =>
-            Try(Parser.Map(t => _componentFactory.GetRegistration(t).Type, Word));
-
-        private Parser<char, object> SubstitutableComponent =>
-            Objectify(Component).Or(Objectify(Try(Substitution)));
-
-        private static Parser<char, string> QuotedString =>
-            OneOf(Try(Char('"').Then(OneOf(new []
-            {
-                AnyCharExcept("\"")
-            }).ManyString().Before(Char('"')))), Try(Word));
-
-        private static Parser<char, object> SubstitutableString =>
-            Objectify(QuotedString).Or(Objectify(Try(Substitution)));
-
-        // thing to make sure it all compiles.
-        [UsedImplicitly]
-        private Parser<char, object> TypeSystemCheck =>
-            OneOf(new[]
-            {
-                Objectify(Integer),
-                Objectify(Percentage),
-                Objectify(EntityId),
-                Objectify(Component),
-                Objectify(Float),
-                Objectify(QuotedString)
-            });
-
-        private Parser<char, BqlQuerySelectorParsed> BuildBqlQueryParser(BqlQuerySelector inst)
-        {
-            if (inst.Arguments.Length == 0)
-            {
-                return Parser.Map(_ => new BqlQuerySelectorParsed(new List<object>(), inst.Token, false), SkipWhitespaces);
-            }
-
-            List<Parser<char, object>> argsParsers = new();
-
-            foreach (var (arg, _) in inst.Arguments.Select((x, i) => (x, i)))
-            {
-                List<Parser<char, object>> choices = new();
-                if ((arg & QuerySelectorArgument.String) == QuerySelectorArgument.String)
-                {
-                    choices.Add(Try(SubstitutableString.Before(SkipWhitespaces).Labelled("string argument")));
-                }
-                if ((arg & QuerySelectorArgument.Component) == QuerySelectorArgument.Component)
-                {
-                    choices.Add(Try(SubstitutableComponent.Before(SkipWhitespaces).Labelled("component argument")));
-                }
-                if ((arg & QuerySelectorArgument.EntityId) == QuerySelectorArgument.EntityId)
-                {
-                    choices.Add(Try(SubstitutableEntityId.Before(SkipWhitespaces).Labelled("entity ID argument")));
-                }
-                if ((arg & QuerySelectorArgument.Integer) == QuerySelectorArgument.Integer)
-                {
-                    choices.Add(Try(SubstitutableInteger.Before(SkipWhitespaces).Labelled("integer argument")));
-                }
-                if ((arg & QuerySelectorArgument.Percentage) == QuerySelectorArgument.Percentage)
-                {
-                    choices.Add(Try(SubstitutablePercentage.Before(SkipWhitespaces).Labelled("percentage argument")));
-                }
-                if ((arg & QuerySelectorArgument.Float) == QuerySelectorArgument.Float)
-                {
-                    choices.Add(Try(SubstitutableFloat.Before(SkipWhitespaces).Labelled("float argument")));
-                }
-
-                argsParsers.Add(OneOf(choices));
-            }
-
-            Parser<char, List<object>> finalParser = argsParsers[0].Map(x => new List<object> { x });
-
-            for (var i = 1; i < argsParsers.Count; i++)
-            {
-                finalParser = finalParser.Then(argsParsers[i], (list, o) =>
-                {
-                    list.Add(o);
-                    return list;
-                }).Labelled("arguments");
-            }
-
-            return Parser.Map(args => new BqlQuerySelectorParsed(args, inst.Token, false), finalParser);
-        }
-
-        private void DoParserSetup()
-        {
-            foreach (var inst in _instances)
-            {
-                _parsers.Add(inst.GetType(), BuildBqlQueryParser(inst));
-            }
-
-            _allQuerySelectors = Parser.Map((a,b) => (a,b), Try(String("not").Before(Char(' '))).Optional(), OneOf(_instances.Select(x =>
-                Try(String(x.Token).Before(Char(' '))))).Then(tok =>
-                _parsers[_queriesByToken[tok].GetType()])
-            ).Map(pair =>
-            {
-                pair.b.Inverted = pair.a.HasValue;
-                return pair.b;
-            });
-        }
-    }
-}

Robust.Server/Bql/BqlQueryManager.SimpleExecutor.cs

@@ -1,39 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Pidgin;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-
-namespace Robust.Server.Bql
-{
-    public partial class BqlQueryManager
-    {
-        public (IEnumerable<EntityUid>, string) SimpleParseAndExecute(string query)
-        {
-            var parsed = SimpleQuery.Parse(query);
-            if (parsed.Success)
-            {
-                var selectors = parsed.Value.Item1.ToArray();
-                if (selectors.Length == 0)
-                {
-                    return (_entityManager.GetEntities(), parsed.Value.Item2);
-                }
-
-                var entities = _queriesByToken[selectors[0].Token]
-                    .DoInitialSelection(selectors[0].Arguments, selectors[0].Inverted, _entityManager);
-
-                foreach (var sel in selectors[1..])
-                {
-                    entities = _queriesByToken[sel.Token].DoSelection(entities, sel.Arguments, sel.Inverted, _entityManager);
-                }
-
-                return (entities, parsed.Value.Item2);
-            }
-            else
-            {
-                throw new Exception(parsed.Error!.RenderErrorMessage());
-            }
-        }
-    }
-}

Robust.Server/Bql/BqlQueryManager.cs

@@ -1,44 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Reflection;
-using Robust.Shared.Utility;
-
-namespace Robust.Server.Bql
-{
-    public sealed partial class BqlQueryManager : IBqlQueryManager
-    {
-        [Dependency] private readonly IReflectionManager _reflectionManager = default!;
-        [Dependency] private readonly IComponentFactory _componentFactory = default!;
-        [Dependency] private readonly IEntityManager _entityManager = default!;
-
-        private readonly List<BqlQuerySelector> _instances = new();
-        private readonly Dictionary<string, BqlQuerySelector> _queriesByToken = new();
-
-        /// <summary>
-        /// Automatically registers all query selectors with the parser/executor.
-        /// </summary>
-        public void DoAutoRegistrations()
-        {
-            foreach (var type in _reflectionManager.FindTypesWithAttribute<RegisterBqlQuerySelectorAttribute>())
-            {
-                RegisterClass(type);
-            }
-
-            DoParserSetup();
-        }
-
-        /// <summary>
-        /// Internally registers the given <see cref="BqlQuerySelector"/>.
-        /// </summary>
-        /// <param name="bqlQuerySelector">The selector to register</param>
-        private void RegisterClass(Type bqlQuerySelector)
-        {
-            DebugTools.Assert(bqlQuerySelector.BaseType == typeof(BqlQuerySelector));
-            var inst = (BqlQuerySelector)Activator.CreateInstance(bqlQuerySelector)!;
-            _instances.Add(inst);
-            _queriesByToken.Add(inst.Token, inst);
-        }
-    }
-}

Robust.Server/Bql/BqlQuerySelector.Builtin.cs

@@ -1,355 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Map;
-using Robust.Shared.Prototypes;
-
-namespace Robust.Server.Bql
-{
-    [RegisterBqlQuerySelector]
-    public sealed class WithQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "with";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.Component };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var comp = (Type) arguments[0];
-            return input.Where(x => entityManager.HasComponent(x, comp) ^ isInverted);
-        }
-
-        public override IEnumerable<EntityUid> DoInitialSelection(IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            if (isInverted)
-            {
-                return base.DoInitialSelection(arguments, isInverted, entityManager);
-            }
-
-            return entityManager.GetAllComponents((Type) arguments[0])
-                .Select(x => x.Owner);
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class NamedQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "named";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.String };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var r = new Regex("^" + (string) arguments[0] + "$");
-            return input.Where(e =>
-            {
-                if (entityManager.TryGetComponent<MetaDataComponent>(e, out var metaDataComponent))
-                    return r.IsMatch(metaDataComponent.EntityName) ^ isInverted;
-                return isInverted;
-            });
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class ParentedToQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "parentedto";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.EntityId };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var uid = (EntityUid) arguments[0];
-            return input.Where(e => (entityManager.TryGetComponent<TransformComponent>(e, out var transform) &&
-                                     transform.ParentUid == uid) ^ isInverted);
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class RecursiveParentedToQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "rparentedto";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.EntityId };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var uid = (EntityUid) arguments[0];
-            return input.Where(e =>
-            {
-                if (!entityManager.TryGetComponent<TransformComponent>(e, out var transform))
-                    return isInverted;
-                while (transform.ParentUid != EntityUid.Invalid)
-                {
-                    if ((transform.ParentUid == uid) ^ isInverted)
-                        return true;
-                    if (!entityManager.TryGetComponent(transform.ParentUid, out transform))
-                        return false;
-                }
-
-                return false;
-            });
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class ChildrenQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "children";
-
-        public override QuerySelectorArgument[] Arguments => Array.Empty<QuerySelectorArgument>();
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            foreach (var uid in input)
-            {
-                if (!entityManager.TryGetComponent(uid, out TransformComponent? xform)) continue;
-
-                foreach (var child in xform.ChildEntities)
-                {
-                    yield return child;
-                }
-            }
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class RecursiveChildrenQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "rchildren";
-
-        public override QuerySelectorArgument[] Arguments => Array.Empty<QuerySelectorArgument>();
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments,
-            bool isInverted, IEntityManager entityManager)
-        {
-            IEnumerable<EntityUid> toSearch = input;
-
-            while (true)
-            {
-                // TODO: Reduce LINQ chaining
-                var doing = toSearch.Where(entityManager.HasComponent<TransformComponent>).Select(entityManager.GetComponent<TransformComponent>).ToArray();
-                var search = doing.SelectMany(x => x.ChildEntities);
-                if (!search.Any())
-                    break;
-                toSearch = doing.SelectMany(x => x.ChildEntities).Where(x => x != EntityUid.Invalid);
-
-                foreach (var xform in doing)
-                {
-                    foreach (var uid in xform.ChildEntities)
-                    {
-                        // This should never happen anyway
-                        if (uid == EntityUid.Invalid) continue;
-                        yield return uid;
-                    }
-                }
-            }
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class ParentQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "parent";
-
-        public override QuerySelectorArgument[] Arguments => Array.Empty<QuerySelectorArgument>();
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            return input.Where(entityManager.HasComponent<TransformComponent>)
-                .Distinct();
-        }
-
-        public override IEnumerable<EntityUid> DoInitialSelection(IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            return DoSelection(
-                Query(entityManager.AllEntityQueryEnumerator<TransformComponent>()),
-                arguments,
-                isInverted, entityManager);
-
-            IEnumerable<EntityUid> Query(AllEntityQueryEnumerator<TransformComponent> enumerator)
-            {
-                while (enumerator.MoveNext(out var entityUid, out _))
-                {
-                    yield return entityUid;
-                }
-            }
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class AboveQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "above";
-
-        public override QuerySelectorArgument[] Arguments => new [] { QuerySelectorArgument.String };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var tileDefinitionManager = IoCManager.Resolve<ITileDefinitionManager>();
-            var tileTy = tileDefinitionManager[(string) arguments[0]];
-
-            var map = IoCManager.Resolve<IMapManager>();
-            if (tileTy.TileId == 0)
-            {
-                return input.Where(e => entityManager.TryGetComponent<TransformComponent>(e, out var transform) && (transform.GridUid is null) ^ isInverted);
-            }
-            else
-            {
-                return input.Where(e =>
-                {
-                    if (!entityManager.TryGetComponent<TransformComponent>(e, out var transform)) return isInverted;
-
-                    if (!map.TryGetGrid(transform.GridUid, out var grid))
-                        return isInverted;
-
-                    return (grid.GetTileRef(transform.Coordinates).Tile.TypeId == tileTy.TileId) ^ isInverted;
-
-                });
-            }
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    // ReSharper disable once InconsistentNaming the name is correct shut up
-    public sealed class OnGridQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "ongrid";
-
-        public override QuerySelectorArgument[] Arguments => new [] { QuerySelectorArgument.Integer };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            // TODO: Probably easier and significantly faster to just iterate the grid's children.
-            var grid = new EntityUid((int) arguments[0]);
-            return input.Where(e => (entityManager.TryGetComponent<TransformComponent>(e, out var transform) && transform.GridUid == grid) ^ isInverted);
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    // ReSharper disable once InconsistentNaming the name is correct shut up
-    public sealed class OnMapQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "onmap";
-
-        public override QuerySelectorArgument[] Arguments => new [] { QuerySelectorArgument.Integer };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            // TODO: Just use EntityLookup GetEntitiesInMap
-            var map = new MapId((int) arguments[0]);
-            return input.Where(e => (entityManager.TryGetComponent<TransformComponent>(e, out var transform) && transform.MapID == map) ^ isInverted);
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class PrototypedQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "prototyped";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.String };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var name = (string) arguments[0];
-            return input.Where(e => (entityManager.TryGetComponent<MetaDataComponent>(e, out var metaData) && metaData.EntityPrototype?.ID == name) ^ isInverted);
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class RecursivePrototypedQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "rprototyped";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.String };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var name = (string) arguments[0];
-            return input.Where(e =>
-            {
-                if (!entityManager.TryGetComponent<MetaDataComponent>(e, out var metaData))
-                    return isInverted;
-                if ((metaData.EntityPrototype?.ID == name) ^ isInverted)
-                    return true;
-
-                var prototypeManager = IoCManager.Resolve<IPrototypeManager>();
-
-                return metaData.EntityPrototype != null && prototypeManager.EnumerateParents<EntityPrototype>(metaData.EntityPrototype.ID).Any(x => x.Name == name) ^ isInverted;
-            });
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class SelectQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "select";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.Integer | QuerySelectorArgument.Percentage };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            if (arguments[0] is int)
-            {
-                var inp = input.OrderBy(_ => Guid.NewGuid()).ToArray();
-                var taken = (int) arguments[0];
-
-                if (isInverted)
-                    taken = Math.Max(0, inp.Length - taken);
-
-                return inp.Take(taken);
-            }
-
-            var enumerable = input.OrderBy(_ => Guid.NewGuid()).ToArray();
-            var amount = isInverted
-                ? (int) Math.Floor(enumerable.Length * Math.Clamp(1 - (double) arguments[0], 0, 1))
-                : (int) Math.Floor(enumerable.Length * Math.Clamp((double) arguments[0], 0, 1));
-            return enumerable.Take(amount);
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    public sealed class NearQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "near";
-
-        public override QuerySelectorArgument[] Arguments => new []{ QuerySelectorArgument.Float };
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            var radius = (float)(double)arguments[0];
-            var entityLookup = entityManager.System<EntityLookupSystem>();
-            var xformQuery = entityManager.GetEntityQuery<TransformComponent>();
-            var distinct = new HashSet<EntityUid>();
-
-            foreach (var uid in input)
-            {
-                foreach (var near in entityLookup.GetEntitiesInRange(xformQuery.GetComponent(uid).Coordinates,
-                             radius))
-                {
-                    if (!distinct.Add(near)) continue;
-                    yield return near;
-                }
-            }
-
-            //BUG: GetEntitiesInRange effectively uses manhattan distance. This is not intended, near is supposed to be circular.
-        }
-    }
-
-    [RegisterBqlQuerySelector]
-    // ReSharper disable once InconsistentNaming the name is correct shut up
-    public sealed class AnchoredQuerySelector : BqlQuerySelector
-    {
-        public override string Token => "anchored";
-
-        public override QuerySelectorArgument[] Arguments => Array.Empty<QuerySelectorArgument>();
-
-        public override IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input, IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            return input.Where(e => (entityManager.TryGetComponent<TransformComponent>(e, out var transform) && transform.Anchored) ^ isInverted);
-        }
-    }
-}

Robust.Server/Bql/BqlQuerySelector.cs

@@ -1,63 +0,0 @@
-using System;
-using System.Collections.Generic;
-using JetBrains.Annotations;
-using Robust.Shared.GameObjects;
-
-namespace Robust.Server.Bql
-{
-    [Flags]
-    [PublicAPI]
-    public enum QuerySelectorArgument
-    {
-        Integer    = 0b00000001,
-        Float      = 0b00000010,
-        String     = 0b00000100,
-        Percentage = 0b00001000,
-        Component  = 0b00010000,
-        //SubQuery   = 0b00100000,
-        EntityId   = 0b01000000,
-    }
-
-    [PublicAPI]
-    public abstract class BqlQuerySelector
-    {
-        /// <summary>
-        /// The token name for the given QuerySelector, for example `when`.
-        /// </summary>
-        public virtual string Token => throw new NotImplementedException();
-
-        /// <summary>
-        /// Arguments for the given QuerySelector, presented as "what arguments are permitted in what spot".
-        /// </summary>
-        public virtual QuerySelectorArgument[] Arguments => throw new NotImplementedException();
-
-        /// <summary>
-        /// Performs a transform over it's input entity list, whether that be filtering (selecting) or expanding the
-        /// input on some criteria like what entities are nearby.
-        /// </summary>
-        /// <param name="input">Input entity list.</param>
-        /// <param name="arguments">Parsed selector arguments.</param>
-        /// <param name="isInverted">Whether the query is inverted.</param>
-        /// <param name="entityManager">The entity manager.</param>
-        /// <returns>New list of entities</returns>
-        /// <exception cref="NotImplementedException">someone is a moron if this happens.</exception>
-        public abstract IEnumerable<EntityUid> DoSelection(IEnumerable<EntityUid> input,
-            IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager);
-
-        /// <summary>
-        /// Performs selection as the first selector in the query. Allows for optimizing when you can be more efficient
-        /// than just querying every entity.
-        /// </summary>
-        /// <param name="arguments"></param>
-        /// <param name="isInverted"></param>
-        /// <param name="entityManager"></param>
-        /// <returns></returns>
-        public virtual IEnumerable<EntityUid> DoInitialSelection(IReadOnlyList<object> arguments, bool isInverted, IEntityManager entityManager)
-        {
-            return DoSelection(entityManager.GetEntities(), arguments, isInverted, entityManager);
-        }
-
-        [UsedImplicitly]
-        protected BqlQuerySelector() {}
-    }
-}

Robust.Server/Bql/BqlQuerySelectorParsed.cs

@@ -1,19 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Robust.Server.Bql
-{
-    public struct BqlQuerySelectorParsed
-    {
-        public List<object> Arguments;
-        public string Token;
-        public bool Inverted;
-
-        public BqlQuerySelectorParsed(List<object> arguments, string token, bool inverted)
-        {
-            Arguments = arguments;
-            Token = token;
-            Inverted = inverted;
-        }
-    }
-}

Robust.Server/Bql/ForAllCommand.cs

@@ -1,78 +0,0 @@
-using System.Globalization;
-using System.Linq;
-using Robust.Server.Player;
-using Robust.Shared.Console;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-
-namespace Robust.Server.Bql
-{
-    public sealed class ForAllCommand : LocalizedCommands
-    {
-        [Dependency] private readonly IBqlQueryManager _bql = default!;
-        [Dependency] private readonly IEntityManager _entities = default!;
-
-        public override string Command => "forall";
-
-        public override void Execute(IConsoleShell shell, string argStr, string[] args)
-        {
-            if (args.Length < 2)
-            {
-                shell.WriteLine(Help);
-                return;
-            }
-
-            var transformSystem = _entities.System<SharedTransformSystem>();
-
-            var (entities, rest) = _bql.SimpleParseAndExecute(argStr[6..]);
-
-            foreach (var ent in entities.ToList())
-            {
-                var cmds = SubstituteEntityDetails(_entities, transformSystem, shell, ent, rest).Split(";");
-                foreach (var cmd in cmds)
-                {
-                    shell.ExecuteCommand(cmd);
-                }
-            }
-        }
-
-        // This will be refactored out soon.
-        private static string SubstituteEntityDetails(
-            IEntityManager entMan,
-            SharedTransformSystem transformSystem,
-            IConsoleShell shell,
-            EntityUid ent,
-            string ruleString)
-        {
-            var transform = entMan.GetComponent<TransformComponent>(ent);
-            var metadata = entMan.GetComponent<MetaDataComponent>(ent);
-
-            var worldPos = transformSystem.GetWorldPosition(transform);
-            var localPos = transform.LocalPosition;
-
-            // gross, is there a better way to do this?
-            ruleString = ruleString.Replace("$ID", ent.ToString());
-            ruleString = ruleString.Replace("$WX", worldPos.X.ToString(CultureInfo.InvariantCulture));
-            ruleString = ruleString.Replace("$WY", worldPos.Y.ToString(CultureInfo.InvariantCulture));
-            ruleString = ruleString.Replace("$LX", localPos.X.ToString(CultureInfo.InvariantCulture));
-            ruleString = ruleString.Replace("$LY", localPos.Y.ToString(CultureInfo.InvariantCulture));
-            ruleString = ruleString.Replace("$NAME", metadata.EntityName);
-
-            if (shell.Player is { AttachedEntity: { } pEntity})
-            {
-                var pTransform = entMan.GetComponent<TransformComponent>(pEntity);
-
-                var pWorldPos = transformSystem.GetWorldPosition(pTransform);
-                var pLocalPos = pTransform.LocalPosition;
-
-                ruleString = ruleString.Replace("$PID", pEntity.ToString());
-                ruleString = ruleString.Replace("$PWX", pWorldPos.X.ToString(CultureInfo.InvariantCulture));
-                ruleString = ruleString.Replace("$PWY", pWorldPos.Y.ToString(CultureInfo.InvariantCulture));
-                ruleString = ruleString.Replace("$PLX", pLocalPos.X.ToString(CultureInfo.InvariantCulture));
-                ruleString = ruleString.Replace("$PLY", pLocalPos.Y.ToString(CultureInfo.InvariantCulture));
-            }
-
-            return ruleString;
-        }
-    }
-}

Robust.Server/Bql/IBqlQueryManager.cs

@@ -1,11 +0,0 @@
-using System.Collections.Generic;
-using Robust.Shared.GameObjects;
-
-namespace Robust.Server.Bql
-{
-    public interface IBqlQueryManager
-    {
-        public (IEnumerable<EntityUid>, string) SimpleParseAndExecute(string query);
-        void DoAutoRegistrations();
-    }
-}

Robust.Server/Bql/RegisterBqlQuerySelectorAttribute.cs

@@ -1,14 +0,0 @@
-using System;
-using JetBrains.Annotations;
-
-namespace Robust.Server.Bql
-{
-    [AttributeUsage(AttributeTargets.Class, Inherited = false)]
-    [BaseTypeRequired(typeof(BqlQuerySelector))]
-    [MeansImplicitUse]
-    [PublicAPI]
-    public sealed class RegisterBqlQuerySelectorAttribute : Attribute
-    {
-
-    }
-}

Robust.Server/Console/ConGroupController.cs

@@ -1,8 +1,12 @@
 using Robust.Server.Player;
+using Robust.Shared.Map;
+using Robust.Shared.Players;
+using Robust.Shared.Toolshed;
+using Robust.Shared.Toolshed.Errors;
 
 namespace Robust.Server.Console
 {
-    internal sealed class ConGroupController : IConGroupController
+    internal sealed class ConGroupController : IConGroupController, IPermissionController
     {
         public IConGroupControllerImplementation? Implementation { get; set; }
 
@@ -30,5 +34,11 @@ namespace Robust.Server.Console
         {
             return Implementation?.CanAdminReloadPrototypes(session) ?? false;
         }
+
+        public bool CheckInvokable(CommandSpec command, ICommonSession? user, out IConError? error)
+        {
+            error = null;
+            return Implementation?.CheckInvokable(command, user, out error) ?? false;
+        }
     }
 }

Robust.Server/Console/IConGroupControllerImplementation.cs

@@ -1,8 +1,9 @@
 using Robust.Server.Player;
+using Robust.Shared.Toolshed;
 
 namespace Robust.Server.Console
 {
-    public interface IConGroupControllerImplementation
+    public interface IConGroupControllerImplementation : IPermissionController
     {
         bool CanCommand(IPlayerSession session, string cmdName);
         bool CanAdminPlace(IPlayerSession session);

Robust.Server/Console/ServerConsoleHost.cs

@@ -9,6 +9,8 @@ using Robust.Shared.Log;
 using Robust.Shared.Network;
 using Robust.Shared.Network.Messages;
 using Robust.Shared.Players;
+using Robust.Shared.Toolshed;
+using Robust.Shared.Toolshed.Syntax;
 using Robust.Shared.Utility;
 
 namespace Robust.Server.Console
@@ -19,6 +21,7 @@ namespace Robust.Server.Console
         [Dependency] private readonly IConGroupController _groupController = default!;
         [Dependency] private readonly IPlayerManager _players = default!;
         [Dependency] private readonly ISystemConsoleManager _systemConsole = default!;
+        [Dependency] private readonly ToolshedManager _toolshed = default!;
 
         public ServerConsoleHost() : base(isServer: true) {}
 
@@ -45,19 +48,31 @@ namespace Robust.Server.Console
         /// <inheritdoc />
         public override void WriteLine(ICommonSession? session, string text)
         {
+            var msg = new FormattedMessage();
+            msg.AddText(text);
             if (session is IPlayerSession playerSession)
-                OutputText(playerSession, text, false);
+                OutputText(playerSession, msg, false);
             else
-                OutputText(null, text, false);
+                OutputText(null, msg, false);
+        }
+
+        public override void WriteLine(ICommonSession? session, FormattedMessage msg)
+        {
+            if (session is IPlayerSession playerSession)
+                OutputText(playerSession, msg, false);
+            else
+                OutputText(null, msg, false);
         }
 
         /// <inheritdoc />
         public override void WriteError(ICommonSession? session, string text)
         {
+            var msg = new FormattedMessage();
+            msg.AddText(text);
             if (session is IPlayerSession playerSession)
-                OutputText(playerSession, text, true);
+                OutputText(playerSession, msg, true);
             else
-                OutputText(null, text, true);
+                OutputText(null, msg, true);
         }
 
         public bool IsCmdServer(IConsoleCommand cmd) => true;
@@ -70,13 +85,13 @@ namespace Robust.Server.Console
                 var localShell = shell.ConsoleHost.LocalShell;
                 var sudoShell = new SudoShell(this, localShell, shell);
                 ExecuteInShell(sudoShell, argStr["sudo ".Length..]);
-            }, (shell, args) =>
+            }, (shell, args, argStr) =>
             {
                 var localShell = shell.ConsoleHost.LocalShell;
                 var sudoShell = new SudoShell(this, localShell, shell);
 
 #pragma warning disable CA2012
-                return CalcCompletions(sudoShell, args);
+                return CalcCompletions(sudoShell, args, argStr);
 #pragma warning restore CA2012
             });
 
@@ -117,6 +132,18 @@ namespace Robust.Server.Console
                     AnyCommandExecuted?.Invoke(shell, cmdName, command, cmdArgs);
                     conCmd.Execute(shell, command, cmdArgs);
                 }
+                else
+                {
+                    // toolshed time
+                    _toolshed.InvokeCommand(shell, command, null, out var res, out var ctx);
+
+                    foreach (var err in ctx.GetErrors())
+                    {
+                        ctx.WriteLine(err.Describe());
+                    }
+
+                    shell.WriteLine(_toolshed.PrettyPrintType(res));
+                }
             }
             catch (Exception e)
             {
@@ -162,7 +189,7 @@ namespace Robust.Server.Console
             ExecuteCommand(session, text);
         }
 
-        private void OutputText(IPlayerSession? session, string text, bool error)
+        private void OutputText(IPlayerSession? session, FormattedMessage text, bool error)
         {
             if (session != null)
             {
@@ -183,10 +210,25 @@ namespace Robust.Server.Console
         private async void HandleConCompletions(MsgConCompletion message)
         {
             var session = _players.GetSessionByChannel(message.MsgChannel);
+
             var shell = new ConsoleShell(this, session, false);
 
-            var result = await CalcCompletions(shell, message.Args);
+            var result = await CalcCompletions(shell, message.Args, message.ArgString);
 
+            if ((result.Options.Length == 0 && result.Hint is null) || message.Args.Length <= 1)
+            {
+                var parser = new ForwardParser(message.ArgString, _toolshed);
+                CommandRun.TryParse(false, true, parser, null, null, false, out _, out var completions, out _);
+                if (completions == null)
+                {
+                    goto done;
+                }
+                var (shedRes, _) = await completions.Value;
+                shedRes ??= CompletionResult.Empty;
+                result = new CompletionResult(shedRes.Options.Concat(result.Options).ToArray(), shedRes.Hint ?? result.Hint);
+            }
+
+            done:
             var msg = new MsgConCompletionResp
             {
                 Result = result,
@@ -199,7 +241,7 @@ namespace Robust.Server.Console
             NetManager.ServerSendMessage(msg, message.MsgChannel);
         }
 
-        private ValueTask<CompletionResult> CalcCompletions(IConsoleShell shell, string[] args)
+        private ValueTask<CompletionResult> CalcCompletions(IConsoleShell shell, string[] args, string argStr)
         {
             // Logger.Debug(string.Join(", ", args));
 
@@ -217,7 +259,7 @@ namespace Robust.Server.Console
             if (!ShellCanExecute(shell, cmdName))
                 return ValueTask.FromResult(CompletionResult.Empty);
 
-            return cmd.GetCompletionAsync(shell, args[1..], default);
+            return cmd.GetCompletionAsync(shell, args[1..], argStr, default);
         }
 
         private sealed class SudoShell : IConsoleShell
@@ -254,6 +296,12 @@ namespace Robust.Server.Console
                 _sudoer.WriteLine(text);
             }
 
+            public void WriteLine(FormattedMessage message)
+            {
+                _owner.WriteLine(message);
+                _sudoer.WriteLine(message);
+            }
+
             public void WriteError(string text)
             {
                 _owner.WriteError(text);

Robust.Server/Console/SystemConsoleManager.cs

@@ -47,6 +47,7 @@ namespace Robust.Server.Console
         private long _lastReceivedBytes;
         private long _lastSentBytes;
 
+        private bool _hasCancelled;
 
         public void Dispose()
         {
@@ -319,8 +320,15 @@ namespace Robust.Server.Console
 
         private void CancelKeyHandler(object? sender, ConsoleCancelEventArgs args)
         {
+            if (_hasCancelled)
+            {
+                Con.WriteLine("Double CancelKey, terminating process.");
+                return;
+            }
+
             // Handle process exiting ourselves.
             args.Cancel = true;
+            _hasCancelled = true;
 
             _taskManager.RunOnMainThread(() => { _baseServer.Shutdown("CancelKey"); });
         }

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

@@ -87,10 +87,5 @@ namespace Robust.Server.GameObjects
                 Dirty();
             }
         }
-
-        public override ComponentState GetComponentState()
-        {
-            return new EyeComponentState(DrawFov, Zoom, Offset, VisibilityMask);
-        }
     }
 }

Robust.Server/GameObjects/EntitySystems/EyeSystem.cs

@@ -0,0 +1,18 @@
+using Robust.Shared.GameObjects;
+using Robust.Shared.GameStates;
+
+namespace Robust.Server.GameObjects;
+
+public sealed class EyeSystem : SharedEyeSystem
+{
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<EyeComponent, ComponentGetState>(OnHandleState);
+    }
+
+    private void OnHandleState(EntityUid uid, EyeComponent component, ref ComponentGetState args)
+    {
+        args.State = new EyeComponentState(component.DrawFov, component.Zoom, component.Offset, component.VisibilityMask);
+    }
+}

Robust.Server/GameObjects/EntitySystems/MapLoaderSystem.cs

@@ -44,6 +44,7 @@ public sealed class MapLoaderSystem : EntitySystem
                  private          IServerEntityManagerInternal _serverEntityManager = default!;
     [Dependency] private readonly ITileDefinitionManager _tileDefManager = default!;
     [Dependency] private readonly MetaDataSystem _meta = default!;
+    [Dependency] private readonly SharedMapSystem _mapSystem = default!;
     [Dependency] private readonly SharedTransformSystem _transform = default!;
 
     private ISawmill _logLoader = default!;
@@ -764,11 +765,12 @@ public sealed class MapLoaderSystem : EntitySystem
             SequenceDataNode yamlGridChunks = (SequenceDataNode)yamlGrid["chunks"];
 
             var grid = AllocateMapGrid(gridComp, yamlGridInfo);
+            var gridUid = grid.Owner;
 
             foreach (var chunkNode in yamlGridChunks.Cast<MappingDataNode>())
             {
                 var (chunkOffsetX, chunkOffsetY) = _serManager.Read<Vector2i>(chunkNode["ind"]);
-                _serManager.Read(chunkNode, _context, instanceProvider: () => grid.GetOrAddChunk(chunkOffsetX, chunkOffsetY), notNullableOverride: true);
+                _serManager.Read(chunkNode, _context, instanceProvider: () => _mapSystem.GetOrAddChunk(gridUid, grid, chunkOffsetX, chunkOffsetY), notNullableOverride: true);
             }
         }
     }

Robust.Server/GameObjects/EntitySystems/ServerMetaDataSystem.cs

@@ -70,7 +70,7 @@ public sealed class ServerMetaDataSystem : MetaDataSystem
         foreach (var (_, comp) in EntityManager.GetNetComponents(uid))
         {
             if (comp.SessionSpecific || comp.SendOnlyToOwner)
-                Dirty(comp);
+                Dirty(uid, comp);
         }
     }
 

Robust.Server/GameStates/PvsSystem.cs

@@ -107,15 +107,12 @@ internal sealed partial class PvsSystem : EntitySystem
     private EntityQuery<EyeComponent> _eyeQuery;
     private EntityQuery<TransformComponent> _xformQuery;
 
-    private ISawmill _sawmill = default!;
-
     public override void Initialize()
     {
         base.Initialize();
 
         _eyeQuery = GetEntityQuery<EyeComponent>();
         _xformQuery = GetEntityQuery<TransformComponent>();
-        _sawmill = Logger.GetSawmill("PVS");
 
         _entityPvsCollection = RegisterPVSCollection<EntityUid>();
 
@@ -182,7 +179,7 @@ internal sealed partial class PvsSystem : EntitySystem
                 sb.Append($" Entity last sent: {lastSeenTick.Value}");
         }
 
-        _sawmill.Warning(sb.ToString());
+        Log.Warning(sb.ToString());
 
         sessionData.LastSeenAt.Clear();
 
@@ -231,7 +228,7 @@ internal sealed partial class PvsSystem : EntitySystem
 
     private PVSCollection<TIndex> RegisterPVSCollection<TIndex>() where TIndex : IComparable<TIndex>, IEquatable<TIndex>
     {
-        var collection = new PVSCollection<TIndex>(_sawmill, EntityManager, _transform);
+        var collection = new PVSCollection<TIndex>(Log, EntityManager, _transform);
         _pvsCollections.Add(collection);
         return collection;
     }
@@ -334,12 +331,12 @@ internal sealed partial class PvsSystem : EntitySystem
         if (e.NewStatus == SessionStatus.InGame)
         {
             if (!PlayerData.TryAdd(e.Session, new()))
-                _sawmill.Error($"Attempted to add player to _playerVisibleSets, but they were already present? Session:{e.Session}");
+                Log.Error($"Attempted to add player to _playerVisibleSets, but they were already present? Session:{e.Session}");
 
             foreach (var pvsCollection in _pvsCollections)
             {
                 if (!pvsCollection.AddPlayer(e.Session))
-                    _sawmill.Error($"Attempted to add player to pvsCollection, but they were already present? Session:{e.Session}");
+                    Log.Error($"Attempted to add player to pvsCollection, but they were already present? Session:{e.Session}");
             }
             return;
         }
@@ -353,7 +350,7 @@ internal sealed partial class PvsSystem : EntitySystem
         foreach (var pvsCollection in _pvsCollections)
         {
             if (!pvsCollection.RemovePlayer(e.Session))
-                _sawmill.Error($"Attempted to remove player from pvsCollection, but they were already removed? Session:{e.Session}");
+                Log.Error($"Attempted to remove player from pvsCollection, but they were already removed? Session:{e.Session}");
         }
 
         if (data.Overflow != null)
@@ -822,7 +819,7 @@ internal sealed partial class PvsSystem : EntitySystem
 #if DEBUG
                 // This happens relatively frequently for the current TickBuffer value, and doesn't really provide any
                 // useful info when not debugging/testing locally. Hence only enable on DEBUG.
-                _sawmill.Debug($"Client {session} exceeded tick buffer.");
+                Log.Debug($"Client {session} exceeded tick buffer.");
 #endif
             }
             else if (oldEntry.Value.Value != lastAcked)
@@ -980,7 +977,7 @@ internal sealed partial class PvsSystem : EntitySystem
         if (metaDataComponent.EntityLifeStage >= EntityLifeStage.Terminating)
         {
             var rep = new EntityStringRepresentation(uid, metaDataComponent.EntityDeleted, metaDataComponent.EntityName, metaDataComponent.EntityPrototype?.ID);
-            _sawmill.Error($"Attempted to add a deleted entity to PVS send set: '{rep}'. Trace:\n{Environment.StackTrace}");
+            Log.Error($"Attempted to add a deleted entity to PVS send set: '{rep}'. Trace:\n{Environment.StackTrace}");
             return;
         }
 
@@ -1110,7 +1107,7 @@ internal sealed partial class PvsSystem : EntitySystem
 
             if (component.Deleted || !component.Initialized)
             {
-                _sawmill.Error("Entity manager returned deleted or uninitialized components while sending entity data");
+                Log.Error("Entity manager returned deleted or uninitialized components while sending entity data");
                 continue;
             }
 

Robust.Server/Maps/GridSerializer.cs

@@ -77,7 +77,7 @@ internal sealed class MapChunkSerializer : ITypeSerializer<MapChunk, MappingData
                 id = tileDefinitionManager[defName].TileId;
 
                 var tile = new Tile(id, flags, variant);
-                chunk.SetTile(x, y, tile);
+                chunk.TrySetTile(x, y, tile, out _, out _);
             }
         }
 
@@ -143,7 +143,7 @@ internal sealed class MapChunkSerializer : ITypeSerializer<MapChunk, MappingData
         {
             for (ushort x = 0; x < chunk.ChunkSize; x++)
             {
-                chunk.SetTile(x, y, source.GetTile(x, y));
+                chunk.TrySetTile(x, y, source.GetTile(x, y), out _, out _);
             }
         }
 

Robust.Server/Robust.Server.csproj

@@ -9,6 +9,7 @@
     <ServerGarbageCollection>true</ServerGarbageCollection>
     <!-- Try to fix sporadic errors against Robust.Packaging, apparently?? -->
     <ValidateExecutableReferencesMatchSelfContained>false</ValidateExecutableReferencesMatchSelfContained>
+    <RobustILLink>true</RobustILLink>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="JetBrains.Annotations" Version="2021.3.0" PrivateAssets="All" />
@@ -40,5 +41,14 @@
     </EmbeddedResource>
   </ItemGroup>
 
+  <!-- ILLink configuration -->
+  <ItemGroup>
+    <RobustLinkRoots Include="Robust.Server" />
+    <RobustLinkRoots Include="Robust.Shared" />
+    <RobustLinkAssemblies Include="TerraFX.Interop.Windows" />
+  </ItemGroup>
+
   <Import Project="..\MSBuild\Robust.Properties.targets" />
+
+  <Import Project="..\MSBuild\Robust.Trimming.targets" />
 </Project>

Robust.Server/ServerHub/HubManager.cs

@@ -6,6 +6,7 @@ using Robust.Shared;
 using Robust.Shared.Configuration;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Network;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -71,12 +72,12 @@ internal sealed class HubManager
         _interval = TimeSpan.FromSeconds(interval);
         _httpClient?.Dispose();
 
-        _httpClient = new HttpClient(new SocketsHttpHandler
-        {
-            // Keep-alive connections stay open for longer than the advertise interval.
-            // This way the same HTTPS connection can be re-used.
-            PooledConnectionIdleTimeout = _interval + TimeSpan.FromSeconds(10),
-        });
+        var socketsHandler = HappyEyeballsHttp.CreateHttpHandler();
+        // Keep-alive connections stay open for longer than the advertise interval.
+        // This way the same HTTPS connection can be re-used.
+        socketsHandler.PooledConnectionIdleTimeout = _interval + TimeSpan.FromSeconds(10);
+
+        _httpClient = new HttpClient(socketsHandler);
 
         HttpClientUserAgent.AddUserAgent(_httpClient);
     }

Robust.Server/ServerIoC.cs

@@ -1,4 +1,3 @@
-using Robust.Server.Bql;
 using Robust.Server.Configuration;
 using Robust.Server.Console;
 using Robust.Server.DataMetrics;
@@ -70,6 +69,7 @@ namespace Robust.Server
             deps.Register<IServerEntityManagerInternal, ServerEntityManager>();
             deps.Register<IServerGameStateManager, ServerGameStateManager>();
             deps.Register<IReplayRecordingManager, ReplayRecordingManager>();
+            deps.Register<IReplayRecordingManagerInternal, ReplayRecordingManager>();
             deps.Register<IServerReplayRecordingManager, ReplayRecordingManager>();
             deps.Register<IServerNetManager, NetManager>();
             deps.Register<IStatusHost, StatusHost>();
@@ -81,7 +81,6 @@ namespace Robust.Server
             deps.Register<IScriptHost, ScriptHost>();
             deps.Register<IMetricsManager, MetricsManager>();
             deps.Register<IAuthManager, AuthManager>();
-            deps.Register<IBqlQueryManager, BqlQueryManager>();
             deps.Register<HubManager, HubManager>();
             deps.Register<IRobustSerializer, ServerRobustSerializer>();
             deps.Register<IRobustSerializerInternal, ServerRobustSerializer>();
@@ -92,6 +91,7 @@ namespace Robust.Server
             deps.Register<INetConfigurationManagerInternal, ServerNetConfigurationManager>();
             deps.Register<IGamePrototypeLoadManager, GamePrototypeLoadManager>();
             deps.Register<NetworkResourceManager>();
+            deps.Register<IHttpClientHolder, HttpClientHolder>();
         }
     }
 }

Robust.Server/ServerStatus/StatusHost.Acz.Sources.cs

@@ -105,11 +105,11 @@ internal sealed partial class StatusHost
     private Task<bool> SourceAczDictionaryViaFile(AssetPass pass, IPackageLogger logger)
     {
         var path = PathHelpers.ExecutableRelativeFile("Content.Client.zip");
-        if (!File.Exists(path))
+        if (!FileHelper.TryOpenFileRead(path, out var fileStream))
             return Task.FromResult(false);
 
         _aczSawmill.Info($"StatusHost found client zip: {path}");
-        using var zip = new ZipArchive(File.OpenRead(path), ZipArchiveMode.Read, leaveOpen: false);
+        using var zip = new ZipArchive(fileStream, ZipArchiveMode.Read, leaveOpen: false);
         SourceAczDictionaryViaZipStream(zip, pass, logger);
         return Task.FromResult(true);
     }

Robust.Server/ServerStatus/WatchdogApi.cs

@@ -11,6 +11,7 @@ using Robust.Shared.Asynchronous;
 using Robust.Shared.Configuration;
 using Robust.Shared.IoC;
 using Robust.Shared.Log;
+using Robust.Shared.Network;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 
@@ -28,7 +29,7 @@ namespace Robust.Server.ServerStatus
 
         // Ping watchdog every 15 seconds.
         private static readonly TimeSpan PingGap = TimeSpan.FromSeconds(15);
-        private readonly HttpClient _httpClient = new();
+        private readonly HttpClient _httpClient = new(HappyEyeballsHttp.CreateHttpHandler());
 
         private TimeSpan? _lastPing;
         private string? _watchdogToken;

Robust.Server/Toolshed/Commands/Players/ActorCommand.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.Linq;
+using Robust.Server.GameObjects;
+using Robust.Server.Player;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Toolshed;
+
+namespace Robust.Server.Toolshed.Commands.Players;
+
+[ToolshedCommand]
+public sealed class ActorCommand : ToolshedCommand
+{
+    [CommandImplementation("controlled")]
+    public IEnumerable<EntityUid> Controlled([PipedArgument] IEnumerable<EntityUid> input)
+    {
+        return input.Where(HasComp<ActorComponent>);
+    }
+
+    [CommandImplementation("session")]
+    public IEnumerable<IPlayerSession> Session([PipedArgument] IEnumerable<EntityUid> input)
+    {
+        return input.Where(HasComp<ActorComponent>).Select(x => Comp<ActorComponent>(x).PlayerSession);
+    }
+}

Robust.Server/Toolshed/Commands/Players/PlayersCommand.cs

@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using Robust.Server.Player;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Maths;
+using Robust.Shared.Network;
+using Robust.Shared.Players;
+using Robust.Shared.Toolshed;
+using Robust.Shared.Toolshed.Errors;
+using Robust.Shared.Utility;
+
+namespace Robust.Server.Toolshed.Commands.Players;
+
+[ToolshedCommand]
+public sealed class PlayerCommand : ToolshedCommand
+{
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+
+    [CommandImplementation("list")]
+    public IEnumerable<IPlayerSession> Players()
+        => _playerManager.ServerSessions;
+
+    [CommandImplementation("self")]
+    public IPlayerSession Self([CommandInvocationContext] IInvocationContext ctx)
+    {
+        if (ctx.Session is null)
+        {
+            ctx.ReportError(new NotForServerConsoleError());
+        }
+
+        return (IPlayerSession)ctx.Session!;
+    }
+
+    [CommandImplementation("imm")]
+    public ICommonSession Immediate(
+        [CommandInvocationContext] IInvocationContext ctx,
+        [CommandArgument] string username
+        )
+    {
+        _playerManager.TryGetSessionByUsername(username, out var session);
+
+        if (session is null)
+        {
+            if (Guid.TryParse(username, out var guid))
+            {
+                _playerManager.TryGetSessionById(new NetUserId(guid), out session);
+            }
+        }
+
+        if (session is null)
+        {
+            ctx.ReportError(new NoSuchPlayerError(username));
+        }
+
+        return session!;
+    }
+
+    [CommandImplementation("entity")]
+    public IEnumerable<EntityUid> GetPlayerEntity([PipedArgument] IEnumerable<IPlayerSession> sessions)
+    {
+        return sessions.Select(x => x.AttachedEntity).Where(x => x is not null).Cast<EntityUid>();
+    }
+
+    [CommandImplementation("entity")]
+    public EntityUid GetPlayerEntity([PipedArgument] IPlayerSession sessions)
+    {
+        return sessions.AttachedEntity ?? default;
+    }
+}
+
+public record struct NoSuchPlayerError(string Username) : IConError
+{
+    public FormattedMessage DescribeInner()
+    {
+        return FormattedMessage.FromMarkup($"No player with the username/GUID {Username} could be found.");
+    }
+
+    public string? Expression { get; set; }
+    public Vector2i? IssueSpan { get; set; }
+    public StackTrace? Trace { get; set; }
+}

Robust.Server/Utility/WindowsTickPeriod.cs

@@ -1,21 +1,17 @@
 using System;
-using System.Runtime.InteropServices;
+using TerraFX.Interop.Windows;
 
 namespace Robust.Server.Utility
 {
     internal static class WindowsTickPeriod
     {
-        private const uint TIMERR_NOERROR = 0;
-        // This is an actual error code my god.
-        private const uint TIMERR_NOCANDO = 97;
-
         public static void TimeBeginPeriod(uint period)
         {
             if (!OperatingSystem.IsWindows())
                 throw new InvalidOperationException();
 
-            var ret = timeBeginPeriod(period);
-            if (ret != TIMERR_NOERROR)
+            var ret = Windows.timeBeginPeriod(period);
+            if (ret != Windows.TIMERR_NOERROR)
                 throw new InvalidOperationException($"timeBeginPeriod returned error: {ret}");
         }
 
@@ -24,15 +20,9 @@ namespace Robust.Server.Utility
             if (!OperatingSystem.IsWindows())
                 throw new InvalidOperationException();
 
-            var ret = timeEndPeriod(period);
-            if (ret != TIMERR_NOERROR)
+            var ret = Windows.timeBeginPeriod(period);
+            if (ret != Windows.TIMERR_NOERROR)
                 throw new InvalidOperationException($"timeEndPeriod returned error: {ret}");
         }
-
-        [DllImport("Winmm.dll")]
-        private static extern uint timeBeginPeriod(uint uPeriod);
-
-        [DllImport("Winmm.dll")]
-        private static extern uint timeEndPeriod(uint uPeriod);
     }
 }

Robust.Shared.Scripting/ILCommand.cs

@@ -0,0 +1,35 @@
+using System.Reflection;
+using System.Reflection.Emit;
+using ILReader;
+using ILReader.Readers;
+using Robust.Shared.Toolshed;
+
+namespace Robust.Shared.Scripting;
+
+[ToolshedCommand]
+public sealed class ILCommand : ToolshedCommand
+{
+    [CommandImplementation("dumpil")]
+    public void DumpIL(
+        [CommandInvocationContext] IInvocationContext ctx,
+        [PipedArgument] MethodInfo info
+    )
+    {
+        var reader = GetReader(info);
+
+        foreach (var instruction in reader)
+        {
+            if (instruction is null)
+                break;
+
+            ctx.WriteLine(instruction.ToString()!);
+        }
+    }
+
+    private IILReader GetReader(MethodBase method)
+    {
+        IILReaderConfiguration cfg = ILReader.Configuration.Resolve(method);
+        return cfg.GetReader(method);
+    }
+}
+

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

@@ -7,6 +7,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="ILReader.Core" Version="1.0.0.4" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.0.1" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.0.1" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1" />

Robust.Shared.Scripting/ScriptGlobalsShared.cs

@@ -10,7 +10,10 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Map.Components;
+using Robust.Shared.Players;
 using Robust.Shared.Prototypes;
+using Robust.Shared.Toolshed;
+using Robust.Shared.Toolshed.Errors;
 using Robust.Shared.Utility;
 
 namespace Robust.Shared.Scripting
@@ -19,7 +22,7 @@ namespace Robust.Shared.Scripting
     [SuppressMessage("ReSharper", "IdentifierTypo")]
     [SuppressMessage("ReSharper", "InconsistentNaming")]
     [SuppressMessage("ReSharper", "CA1822")]
-    public abstract class ScriptGlobalsShared
+    public abstract class ScriptGlobalsShared : IInvocationContext
     {
         private const BindingFlags DefaultHelpFlags =
             BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public;
@@ -30,6 +33,8 @@ namespace Robust.Shared.Scripting
         [field: Dependency] public IMapManager map { get; } = default!;
         [field: Dependency] public IDependencyCollection dependencies { get; } = default!;
 
+        [field: Dependency] public ToolshedManager shed { get; } = default!;
+
         protected ScriptGlobalsShared(IDependencyCollection dependencies)
         {
             dependencies.InjectDependencies(this);
@@ -161,11 +166,29 @@ namespace Robust.Shared.Scripting
         public abstract void write(object toString);
         public abstract void show(object obj);
 
+        public object? tsh(string toolshedCommand)
+        {
+            shed.InvokeCommand(this, toolshedCommand, null, out var res);
+            return res;
+        }
+
+        public T tsh<T>(string toolshedCommand)
+        {
+            shed.InvokeCommand(this, toolshedCommand, null, out var res);
+            return (T)res!;
+        }
+
+        public TOut tsh<TIn, TOut>(TIn value, string toolshedCommand)
+        {
+            shed.InvokeCommand(this, toolshedCommand, value, out var res);
+            return (TOut)res!;
+        }
+
         #region EntityManager proxy methods
-        public T Comp<T>(EntityUid uid)
+        public T Comp<T>(EntityUid uid) where T : Component
             => ent.GetComponent<T>(uid);
 
-        public bool TryComp<T>(EntityUid uid, out T? comp)
+        public bool TryComp<T>(EntityUid uid, out T? comp) where T : Component
             => ent.TryGetComponent(uid, out comp);
 
         public bool HasComp<T>(EntityUid uid)
@@ -227,5 +250,34 @@ namespace Robust.Shared.Scripting
             return ent.EntityQuery<TComp1, TComp2, TComp3>(includePaused);
         }
         #endregion
+
+        public bool CheckInvokable(CommandSpec command, out IConError? error)
+        {
+            error = null;
+            return true; // Do as I say!
+        }
+
+        public ICommonSession? Session => null;
+
+        public void WriteLine(string line)
+        {
+            write(line);
+        }
+
+        public void ReportError(IConError err)
+        {
+            write(err);
+        }
+
+        public IEnumerable<IConError> GetErrors()
+        {
+            return Array.Empty<IConError>();
+        }
+
+        public void ClearErrors()
+        {
+        }
+
+        public Dictionary<string, object?> Variables { get; }  = new();
     }
 }

Robust.Shared/Audio/Midi/RobustMidiEvent.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Robust.Shared.Serialization;
 
 namespace Robust.Shared.Audio.Midi
@@ -9,6 +10,9 @@ namespace Robust.Shared.Audio.Midi
     [Serializable, NetSerializable]
     public readonly struct RobustMidiEvent
     {
+        public const int MaxChannels = 16;
+        public const int PercussionChannel = 9;
+
         #region Data
 
         /// <summary>
@@ -49,6 +53,17 @@ namespace Robust.Shared.Audio.Midi
             Tick = tick;
         }
 
+        /// <summary>
+        ///     Clones another event but with a different tick value.
+        /// </summary>
+        public RobustMidiEvent(RobustMidiEvent ev, uint tick)
+        {
+            Status = ev.Status;
+            Data1 = ev.Data1;
+            Data2 = ev.Data2;
+            Tick = tick;
+        }
+
         public override string ToString()
         {
             return $"{base.ToString()} >> CHANNEL: 0x{Channel:X} || COMMAND: 0x{Command:X} {MidiCommand} || DATA1: 0x{Data1:X} || DATA2: 0x{Data2:X} || TICK: {Tick} <<";

Robust.Shared/CVars.cs

@@ -319,6 +319,12 @@ namespace Robust.Shared
         public static readonly CVarDef<bool> SysGCCollectStart =
             CVarDef.Create("sys.gc_collect_start", true);
 
+        /// <summary>
+        /// Use precise sleeping methods in the game loop.
+        /// </summary>
+        public static readonly CVarDef<bool> SysPreciseSleep =
+            CVarDef.Create("sys.precise_sleep", true);
+
         /*
          * METRICS
          */
@@ -1182,6 +1188,12 @@ namespace Robust.Shared
         public static readonly CVarDef<bool> DiscordEnabled =
             CVarDef.Create("discord.enabled", true, CVar.CLIENTONLY);
 
+        public static readonly CVarDef<string> DiscordRichPresenceMainIconId =
+            CVarDef.Create("discord.rich_main_icon_id", "devstation", CVar.CLIENTONLY);
+
+        public static readonly CVarDef<string> DiscordRichPresenceSecondIconId =
+            CVarDef.Create("discord.rich_second_icon_id", "logo", CVar.CLIENTONLY);
+
         /*
          * RES
          */
@@ -1258,6 +1270,15 @@ namespace Robust.Shared
         public static readonly CVarDef<float> MidiVolume =
             CVarDef.Create("midi.volume", 0f, CVar.CLIENTONLY | CVar.ARCHIVE);
 
+        public static readonly CVarDef<int> MidiMinRendererParallel =
+            CVarDef.Create("midi.min_renderers_parallel_update", 3, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+        public static readonly CVarDef<float> MidiPositionUpdateDelay =
+            CVarDef.Create("midi.position_update_delay", 0.125f, CVar.CLIENTONLY | CVar.ARCHIVE);
+
+        public static readonly CVarDef<float> MidiOcclusionUpdateDelay =
+            CVarDef.Create("midi.occlusion_update_delay", 0.25f, CVar.CLIENTONLY | CVar.ARCHIVE);
+
         /*
          * HUB
          * CVars related to public master server hub

Robust.Shared/ComponentTrees/RecursiveMoveSystem.cs

@@ -15,8 +15,16 @@ internal sealed class RecursiveMoveSystem : EntitySystem
 {
     [Dependency] private readonly IMapManager _mapManager = default!;
 
+    private EntityQuery<TransformComponent> _xformQuery;
+
     bool Subscribed = false;
 
+    public override void Initialize()
+    {
+        base.Initialize();
+        _xformQuery = GetEntityQuery<TransformComponent>();
+    }
+
     internal void AddSubscription()
     {
         if (Subscribed)
@@ -34,14 +42,12 @@ internal sealed class RecursiveMoveSystem : EntitySystem
         DebugTools.Assert(!_mapManager.IsMap(args.Sender));
         DebugTools.Assert(!_mapManager.IsGrid(args.Sender));
 
-        var xformQuery = GetEntityQuery<TransformComponent>();
-        AnythingMovedSubHandler(args.Sender, args.Component, xformQuery);
+        AnythingMovedSubHandler(args.Sender, args.Component);
     }
 
     private void AnythingMovedSubHandler(
         EntityUid uid,
-        TransformComponent xform,
-        EntityQuery<TransformComponent> xformQuery)
+        TransformComponent xform)
     {
         // TODO maybe use a c# event? This event gets raised a lot.
         // Would probably help with server performance and is also the main bottleneck for replay scrubbing.
@@ -55,8 +61,8 @@ internal sealed class RecursiveMoveSystem : EntitySystem
         var childEnumerator = xform.ChildEnumerator;
         while (childEnumerator.MoveNext(out var child))
         {
-            if (xformQuery.TryGetComponent(child.Value, out var childXform))
-                AnythingMovedSubHandler(child.Value, childXform, xformQuery);
+            if (_xformQuery.TryGetComponent(child.Value, out var childXform))
+                AnythingMovedSubHandler(child.Value, childXform);
         }
     }
 }

Robust.Shared/Console/Commands/HelpCommand.cs

@@ -5,31 +5,31 @@ namespace Robust.Shared.Console.Commands;
 
 internal sealed class HelpCommand : LocalizedCommands
 {
-    public override string Command => "help";
+    public override string Command => "oldhelp";
 
     public override void Execute(IConsoleShell shell, string argStr, string[] args)
     {
         switch (args.Length)
         {
             case 0:
-                shell.WriteLine(Loc.GetString("cmd-help-no-args"));
+                shell.WriteLine(Loc.GetString("cmd-oldhelp-no-args"));
                 break;
 
             case 1:
                 var commandName = args[0];
                 if (!shell.ConsoleHost.AvailableCommands.TryGetValue(commandName, out var cmd))
                 {
-                    shell.WriteError(Loc.GetString("cmd-help-unknown", ("command", commandName)));
+                    shell.WriteError(Loc.GetString("cmd-oldhelp-unknown", ("command", commandName)));
                     return;
                 }
 
-                shell.WriteLine(Loc.GetString("cmd-help-top", ("command", cmd.Command),
+                shell.WriteLine(Loc.GetString("cmd-oldhelp-top", ("command", cmd.Command),
                     ("description", cmd.Description)));
                 shell.WriteLine(cmd.Help);
                 break;
 
             default:
-                shell.WriteError(Loc.GetString("cmd-help-invalid-args"));
+                shell.WriteError(Loc.GetString("cmd-oldhelp-invalid-args"));
                 break;
         }
     }
@@ -41,7 +41,7 @@ internal sealed class HelpCommand : LocalizedCommands
             var host = shell.ConsoleHost;
             return CompletionResult.FromHintOptions(
                 host.AvailableCommands.Values.OrderBy(c => c.Command).Select(c => new CompletionOption(c.Command, c.Description)).ToArray(),
-                Loc.GetString("cmd-help-arg-cmdname"));
+                Loc.GetString("cmd-oldhelp-arg-cmdname"));
         }
 
         return CompletionResult.Empty;

Robust.Shared/Console/Commands/TeleportCommands.cs

@@ -54,7 +54,7 @@ internal sealed class TeleportCommand : LocalizedCommands
 
         if (_map.TryFindGridAt(mapId, position, out var gridUid, out var grid))
         {
-            var gridPos = grid.WorldToLocal(position);
+            var gridPos = xformSystem.GetInvWorldMatrix(gridUid).Transform(position);
 
             xformSystem.SetCoordinates(entity, transform, new EntityCoordinates(gridUid, gridPos));
         }

Robust.Shared/Console/ConsoleHost.cs

@@ -11,6 +11,7 @@ using Robust.Shared.Network;
 using Robust.Shared.Players;
 using Robust.Shared.Reflection;
 using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 using Robust.Shared.ViewVariables;
 
 namespace Robust.Shared.Console
@@ -173,6 +174,8 @@ namespace Robust.Shared.Console
 
         //TODO: IConsoleOutput for [e#1225]
         public abstract void WriteLine(ICommonSession? session, string text);
+        public abstract void WriteLine(ICommonSession? session, FormattedMessage msg);
+
         public abstract void WriteError(ICommonSession? session, string text);
 
         /// <inheritdoc />
@@ -324,10 +327,11 @@ namespace Robust.Shared.Console
             public ValueTask<CompletionResult> GetCompletionAsync(
                 IConsoleShell shell,
                 string[] args,
+                string argStr,
                 CancellationToken cancel)
             {
                 if (CompletionCallbackAsync != null)
-                    return CompletionCallbackAsync(shell, args);
+                    return CompletionCallbackAsync(shell, args, argStr);
 
                 if (CompletionCallback != null)
                     return ValueTask.FromResult(CompletionCallback(shell, args));

Robust.Shared/Console/ConsoleShell.cs

@@ -1,4 +1,5 @@
 using Robust.Shared.Players;
+using Robust.Shared.Utility;
 
 namespace Robust.Shared.Console
 {
@@ -48,6 +49,11 @@ namespace Robust.Shared.Console
             ConsoleHost.WriteLine(Player, text);
         }
 
+        public void WriteLine(FormattedMessage message)
+        {
+            ConsoleHost.WriteLine(Player, message);
+        }
+
         /// <inheritdoc />
         public void WriteError(string text)
         {

Robust.Shared/Console/IConsoleCommand.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
@@ -8,7 +9,7 @@ namespace Robust.Shared.Console
     /// Basic interface to handle console commands. Any class implementing this will be
     /// registered with the console system through reflection.
     /// </summary>
-    [UsedImplicitly(ImplicitUseTargetFlags.WithInheritors)]
+    [UsedImplicitly(ImplicitUseTargetFlags.WithInheritors), Obsolete("New commands should utilize RtShellCommand.")]
     public interface IConsoleCommand
     {
         /// <summary>
@@ -78,7 +79,7 @@ namespace Robust.Shared.Console
         /// <remarks>
         /// If this method is implemented, <see cref="GetCompletion"/> will not be automatically called.
         /// </remarks>
-        ValueTask<CompletionResult> GetCompletionAsync(IConsoleShell shell, string[] args, CancellationToken cancel)
+        ValueTask<CompletionResult> GetCompletionAsync(IConsoleShell shell, string[] args, string argStr, CancellationToken cancel)
         {
             return ValueTask.FromResult(GetCompletion(shell, args));
         }

Robust.Shared/Console/IConsoleHost.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Robust.Shared.Players;
+using Robust.Shared.Utility;
 
 namespace Robust.Shared.Console
 {
@@ -21,7 +22,7 @@ namespace Robust.Shared.Console
     /// <summary>
     /// Called to fetch completions for a console command (async). See <see cref="IConsoleCommand.GetCompletionAsync"/> for details.
     /// </summary>
-    public delegate ValueTask<CompletionResult> ConCommandCompletionAsyncCallback(IConsoleShell shell, string[] args);
+    public delegate ValueTask<CompletionResult> ConCommandCompletionAsyncCallback(IConsoleShell shell, string[] args, string argStr);
 
     public delegate void ConAnyCommandCallback(IConsoleShell shell, string commandName, string argStr, string[] args);
 
@@ -249,6 +250,8 @@ namespace Robust.Shared.Console
         /// <param name="text">Text message to send.</param>
         void WriteLine(ICommonSession? session, string text);
 
+        void WriteLine(ICommonSession? session, FormattedMessage msg);
+
         /// <summary>
         /// Sends a foreground colored text string to the remote session.
         /// </summary>

Robust.Shared/Console/IConsoleShell.cs

@@ -1,4 +1,5 @@
 using Robust.Shared.Players;
+using Robust.Shared.Utility;
 
 namespace Robust.Shared.Console
 {
@@ -54,6 +55,8 @@ namespace Robust.Shared.Console
         /// <param name="text">Line of text to write.</param>
         void WriteLine(string text);
 
+        void WriteLine(FormattedMessage message);
+
         /// <summary>
         /// Write an error line to the console window.
         /// </summary>

Robust.Shared/Console/LocalizedCommands.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using Robust.Shared.IoC;
@@ -5,6 +6,7 @@ using Robust.Shared.Localization;
 
 namespace Robust.Shared.Console;
 
+[Obsolete("You should use ToolshedCommand instead.")]
 public abstract class LocalizedCommands : IConsoleCommand
 {
     [Dependency] protected readonly ILocalizationManager LocalizationManager = default!;
@@ -23,12 +25,12 @@ public abstract class LocalizedCommands : IConsoleCommand
 
     /// <inheritdoc />
     public abstract void Execute(IConsoleShell shell, string argStr, string[] args);
-    
+
     /// <inheritdoc />
     public virtual CompletionResult GetCompletion(IConsoleShell shell, string[] args) => CompletionResult.Empty;
 
     /// <inheritdoc />
-    public virtual ValueTask<CompletionResult> GetCompletionAsync(IConsoleShell shell, string[] args,
+    public virtual ValueTask<CompletionResult> GetCompletionAsync(IConsoleShell shell, string[] args, string argStr,
         CancellationToken cancel)
     {
         return ValueTask.FromResult(GetCompletion(shell, args));

Robust.Shared/Containers/ContainerManagerComponent.cs

@@ -54,28 +54,6 @@ namespace Robust.Shared.Containers
             Containers.Clear();
         }
 
-        /// <inheritdoc />
-        public override ComponentState GetComponentState()
-        {
-            // naive implementation that just sends the full state of the component
-            Dictionary<string, ContainerManagerComponentState.ContainerData> containerSet = new(Containers.Count);
-
-            foreach (var container in Containers.Values)
-            {
-                var uidArr = new EntityUid[container.ContainedEntities.Count];
-
-                for (var index = 0; index < container.ContainedEntities.Count; index++)
-                {
-                    uidArr[index] = container.ContainedEntities[index];
-                }
-
-                var sContainer = new ContainerManagerComponentState.ContainerData(container.ContainerType, container.ID, container.ShowContents, container.OccludesLight, uidArr);
-                containerSet.Add(container.ID, sContainer);
-            }
-
-            return new ContainerManagerComponentState(containerSet);
-        }
-
         /// <inheritdoc />
         public T MakeContainer<T>(string id)
             where T : IContainer

Robust.Shared/Containers/SharedContainerSystem.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Robust.Shared.GameObjects;
+using Robust.Shared.GameStates;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
 using Robust.Shared.Maths;
@@ -23,6 +24,28 @@ namespace Robust.Shared.Containers
 
             SubscribeLocalEvent<EntParentChangedMessage>(OnParentChanged);
             SubscribeLocalEvent<ContainerManagerComponent, ComponentStartup>(OnStartupValidation);
+            SubscribeLocalEvent<ContainerManagerComponent, ComponentGetState>(OnContainerGetState);
+        }
+
+        private void OnContainerGetState(EntityUid uid, ContainerManagerComponent component, ref ComponentGetState args)
+        {
+            // naive implementation that just sends the full state of the component
+            Dictionary<string, ContainerManagerComponent.ContainerManagerComponentState.ContainerData> containerSet = new(component.Containers.Count);
+
+            foreach (var container in component.Containers.Values)
+            {
+                var uidArr = new EntityUid[container.ContainedEntities.Count];
+
+                for (var index = 0; index < container.ContainedEntities.Count; index++)
+                {
+                    uidArr[index] = container.ContainedEntities[index];
+                }
+
+                var sContainer = new ContainerManagerComponent.ContainerManagerComponentState.ContainerData(container.ContainerType, container.ID, container.ShowContents, container.OccludesLight, uidArr);
+                containerSet.Add(container.ID, sContainer);
+            }
+
+            args.State = new ContainerManagerComponent.ContainerManagerComponentState(containerSet);
         }
 
         // TODO: Make ContainerManagerComponent ECS and make these proxy methods the real deal.

Robust.Shared/ContentPack/AppDomainExt.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Linq;
 using System.Reflection;
+using Robust.Shared.Collections;
 
 namespace Robust.Shared.ContentPack
 {
@@ -14,7 +15,23 @@ namespace Robust.Shared.ContentPack
         /// <returns></returns>
         public static Assembly GetAssemblyByName(this AppDomain domain, string name)
         {
-            return domain.GetAssemblies().Single(assembly => assembly.GetName().Name == name);
+            var assemblies = new ValueList<Assembly>(1);
+
+            foreach (var assembly in domain.GetAssemblies())
+            {
+                if (assembly.GetName().Name != name)
+                    continue;
+
+                assemblies.Add(assembly);
+            }
+
+            if (assemblies.Count != 1)
+            {
+                var assemblyDesc = string.Join(" ", assemblies.Select(o => o.GetName().Name));
+                throw new InvalidOperationException($"Expected 1 assembly for {name}, found {assemblies.Count}. Found {assemblyDesc}");
+            }
+
+            return assemblies[0];
         }
     }
 }