Version: 148.0.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,332 @@ END TEMPLATE-->
 *None yet*
 
 
-## 136.0.2
+## 148.0.0
+
+### Breaking changes
+
+* Several NuGet dependencies are now private assets.
+* Added `IViewportControl.PixelToMap()` and `PixelToMapEvent`. These are variants of the existing screen-to-map functions that should account for distortion effects.
+
+### New features
+
+* Added several new rich-text tags, including italic and bold-italic.
+
+### Bugfixes
+
+* Fixed log messages for unknown components not working due to threaded IoC issues.
+* Replay recordings no longer record invalid prototype uploads.
+
+
+## 147.0.0
+
+### Breaking changes
+
+* Renamed one of the EntitySystem.Dirty() methods to `DirtyEntity()` to avoid confusion with the component-dirtying methods.
+
+### New features
+
+* Added debug commands that return the entity system update order.
+
+### Bugfixes
+
+* Fixed a bug in MetaDataSystem that was causing the metadata component to not be marked as dirty.
+
+
+## 146.0.0
+
+### Breaking changes
+
+* Remove readOnly for DataFields and rename some ShaderPrototype C# fields internally to align with the normal schema.
+
+### Bugfixes
+
+* Add InvariantCulture to angle validation.
+
+### Internal
+
+* Add some additional EntityQuery<T> usages and remove a redundant CanCollide call on fixture shutdown.
+
+
+## 145.0.0
+
+### Breaking changes
+
+* Removed some old SpriteComponent data-fields ("rsi", and "layerDatums").
+
+### New features
+
+* Added `ActorSystem.TryGetActorFromUserId()`.
+* Added IPrototypeManager.EnumerateKinds().
+
+### Bugfixes
+
+* Fixed SpriteSpecifierSerializer yaml validation not working properly.
+* Fixed IoC/Threading exceptions in `Resource.Load()`.
+* Fixed `TransformSystem.SetCoordinates()` throwing uninformative client-side errors.
+* Fixed `IResourceManager.ContentFileExists()` and `TryContentFileRead()` throwing exceptions on windows when trying to open a directory.
+
+
+## 144.0.1
+
+### Bugfixes
+
+* Fix some EntityLookup queries incorrectly being double transformed internally.
+* Shrink TileEnlargement even further for EntityLookup default queries.
+
+
+## 144.0.0
+
+### Breaking changes
+
+* Add new args to entitylookup methods to allow for shrinkage of tile-bounds checks. Default changed to shrink the grid-local AABB by the polygon skin to avoid clipping neighboring tile entities.
+* Non-hard fixtures will no longer count by default for EntityLookup.
+
+### New features
+
+* Added new EntityLookup flag to return non-hard fixtures or not.
+
+
+## 143.3.0
+
+### New features
+
+* Entity placement and spawn commands now raise informative events that content can handle.
+* Replay clients can now optionally ignore some errors instead of refusing to load the replay.
+
+### Bugfixes
+
+* `AudioParams.PlayOffsetSecond` will no longer apply an offset that is larger then the length of the audio stream.
+* Fixed yaml serialization of arrays of virtual/abstract objects.
+
+
+### Other
+
+* Removed an incorrect gamestate debug assert.
+
+
+## 143.2.0
+
+### New features
+
+* Add support for tests to load extra prototypes from multiple sources.
+
+### 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/EnginePrototypes/UserInterface/uiThemes.yml

@@ -1,6 +1,6 @@
 - type: uiTheme
   id: Default
-  path: /Textures/Interface/Default
+  path: /Textures/Interface/Default/
   colors:
     # Root
     rootBackground: "#000000"

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,169 @@
+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.
+
+command-description-entitysystemupdateorder-tick =
+    Lists the tick update order of entity systems.
+
+command-description-entitysystemupdateorder-frame =
+    Lists the frame update order of entity systems.

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!;
@@ -629,18 +630,19 @@ namespace Robust.Client.Console.Commands
 
         public override void Execute(IConsoleShell shell, string argStr, string[] args)
         {
-            var mousePos = _eye.ScreenToMap(_input.MouseScreenPosition);
+            var mousePos = _eye.PixelToMap(_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/DebugAnchoringSystem.cs

@@ -61,7 +61,7 @@ namespace Robust.Client.Debugging
             }
 
             var mouseSpot = _inputManager.MouseScreenPosition;
-            var spot = _eyeManager.ScreenToMap(mouseSpot);
+            var spot = _eyeManager.PixelToMap(mouseSpot);
 
             if (!_mapManager.TryFindGridAt(spot, out var gridUid, out var grid))
             {

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)
@@ -371,7 +371,7 @@ namespace Robust.Client.Debugging
             if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.ShapeInfo) != 0x0)
             {
                 var hoverBodies = new List<PhysicsComponent>();
-                var bounds = Box2.UnitCentered.Translated(_eyeManager.ScreenToMap(mousePos.Position).Position);
+                var bounds = Box2.UnitCentered.Translated(_eyeManager.PixelToMap(mousePos.Position).Position);
 
                 foreach (var physBody in _physicsSystem.GetCollidingEntities(mapId, bounds))
                 {
@@ -404,7 +404,7 @@ namespace Robust.Client.Debugging
 
             if ((_debugPhysicsSystem.Flags & PhysicsDebugFlags.Distance) != 0x0)
             {
-                var mapPos = _eyeManager.ScreenToMap(mousePos);
+                var mapPos = _eyeManager.PixelToMap(mousePos);
 
                 if (mapPos.MapId != args.MapId)
                     return;

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/Components/Renderable/SpriteComponent.cs

@@ -167,40 +167,9 @@ namespace Robust.Client.GameObjects
 
         public bool TreeUpdateQueued { get; set; }
 
-        [DataField("layerDatums")]
-        private List<PrototypeLayerData> LayerDatums
-        {
-            get
-            {
-                var layerDatums = new List<PrototypeLayerData>();
-                foreach (var layer in Layers)
-                {
-                    layerDatums.Add(layer.ToPrototypeData());
-                }
-
-                return layerDatums;
-            }
-            set
-            {
-                if (value == null) return;
-
-                Layers.Clear();
-                foreach (var layerDatum in value)
-                {
-                    AddLayer(layerDatum);
-                }
-
-                _layerMapShared = true;
-
-                QueueUpdateRenderTree();
-                QueueUpdateIsInert();
-            }
-        }
-
         private RSI? _baseRsi;
 
         [ViewVariables(VVAccess.ReadWrite)]
-        [DataField("rsi", priority: 2)]
         public RSI? BaseRSI
         {
             get => _baseRsi;
@@ -357,7 +326,16 @@ namespace Robust.Client.GameObjects
             if (layerDatums.Count != 0)
             {
                 LayerMap.Clear();
-                LayerDatums = layerDatums;
+                Layers.Clear();
+                foreach (var datum in layerDatums)
+                {
+                    AddLayer(datum);
+                }
+
+                _layerMapShared = true;
+
+                QueueUpdateRenderTree();
+                QueueUpdateIsInert();
             }
 
             UpdateLocalMatrix();

Robust.Client/GameObjects/EntitySystems/AudioSystem.cs

@@ -314,9 +314,9 @@ public sealed class AudioSystem : SharedAudioSystem
         return source != null;
     }
 
-    private PlayingStream CreateAndStartPlayingStream(IClydeAudioSource source, AudioParams? audioParams)
+    private PlayingStream CreateAndStartPlayingStream(IClydeAudioSource source, AudioParams? audioParams, AudioStream stream)
     {
-        ApplyAudioParams(audioParams, source);
+        ApplyAudioParams(audioParams, source, stream);
         source.StartPlaying();
         var playing = new PlayingStream
         {
@@ -365,7 +365,7 @@ public sealed class AudioSystem : SharedAudioSystem
 
         source.SetGlobal();
 
-        return CreateAndStartPlayingStream(source, audioParams);
+        return CreateAndStartPlayingStream(source, audioParams, stream);
     }
 
     /// <summary>
@@ -416,7 +416,7 @@ public sealed class AudioSystem : SharedAudioSystem
         if (!source.SetPosition(worldPos))
             return Play(stream, fallbackCoordinates.Value, fallbackCoordinates.Value, audioParams);
 
-        var playing = CreateAndStartPlayingStream(source, audioParams);
+        var playing = CreateAndStartPlayingStream(source, audioParams, stream);
         playing.TrackingEntity = entity;
         playing.TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null;
         return playing;
@@ -469,7 +469,7 @@ public sealed class AudioSystem : SharedAudioSystem
             return null;
         }
 
-        var playing = CreateAndStartPlayingStream(source, audioParams);
+        var playing = CreateAndStartPlayingStream(source, audioParams, stream);
         playing.TrackingCoordinates = coordinates;
         playing.TrackingFallbackCoordinates = fallbackCoordinates != EntityCoordinates.Invalid ? fallbackCoordinates : null;
         return playing;
@@ -493,7 +493,7 @@ public sealed class AudioSystem : SharedAudioSystem
         return null;
     }
 
-    private void ApplyAudioParams(AudioParams? audioParams, IClydeAudioSource source)
+    private void ApplyAudioParams(AudioParams? audioParams, IClydeAudioSource source, AudioStream audio)
     {
         if (!audioParams.HasValue)
             return;
@@ -508,8 +508,12 @@ public sealed class AudioSystem : SharedAudioSystem
         source.SetRolloffFactor(audioParams.Value.RolloffFactor);
         source.SetMaxDistance(audioParams.Value.MaxDistance);
         source.SetReferenceDistance(audioParams.Value.ReferenceDistance);
-        source.SetPlaybackPosition(audioParams.Value.PlayOffsetSeconds);
         source.IsLooping = audioParams.Value.Loop;
+
+        // TODO clamp the offset inside of SetPlaybackPosition() itself.
+        var offset = audioParams.Value.PlayOffsetSeconds;
+        offset = Math.Clamp(offset, 0f, (float) audio.Length.TotalSeconds);
+        source.SetPlaybackPosition(offset);
     }
 
     public sealed class PlayingStream : IPlayingAudioStream

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/ClientEye/EyeManager.cs

@@ -24,6 +24,7 @@ namespace Robust.Client.Graphics
         [Dependency] private readonly IClyde _displayManager = default!;
         [Dependency] private readonly IEntityManager _entityManager = default!;
         [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
+        private ISawmill _logMill = default!;
 
         // We default to this when we get set to a null eye.
         private readonly FixedEye _defaultEye = new();
@@ -53,6 +54,7 @@ namespace Robust.Client.Graphics
         void IEyeManager.Initialize()
         {
             MainViewport = _uiManager.MainViewport;
+            _logMill = IoCManager.Resolve<ILogManager>().RootSawmill;
         }
 
         /// <inheritdoc />
@@ -129,14 +131,14 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public ScreenCoordinates CoordinatesToScreen(EntityCoordinates point)
         {
-            return MapToScreen(point.ToMap(_entityManager));
+            return MapToScreen(point.ToMap(_entityManager, _entityManager.System<SharedTransformSystem>()));
         }
 
         public ScreenCoordinates MapToScreen(MapCoordinates point)
         {
             if (CurrentEye.Position.MapId != point.MapId)
             {
-                Logger.Error($"Attempted to convert map coordinates ({point}) to screen coordinates with an eye on another map ({CurrentEye.Position.MapId})");
+                _logMill.Error($"Attempted to convert map coordinates ({point}) to screen coordinates with an eye on another map ({CurrentEye.Position.MapId})");
                 return new(default, WindowId.Invalid);
             }
 
@@ -146,12 +148,10 @@ namespace Robust.Client.Graphics
         /// <inheritdoc />
         public MapCoordinates ScreenToMap(ScreenCoordinates point)
         {
-            var (pos, window) = point;
-
             if (_uiManager.MouseGetControl(point) is not IViewportControl viewport)
                 return default;
 
-            return viewport.ScreenToMap(pos);
+            return viewport.ScreenToMap(point.Position);
         }
 
         /// <inheritdoc />
@@ -159,6 +159,21 @@ namespace Robust.Client.Graphics
         {
             return MainViewport.ScreenToMap(point);
         }
+
+        /// <inheritdoc />
+        public MapCoordinates PixelToMap(ScreenCoordinates point)
+        {
+            if (_uiManager.MouseGetControl(point) is not IViewportControl viewport)
+                return default;
+
+            return viewport.PixelToMap(point.Position);
+        }
+
+        /// <inheritdoc />
+        public MapCoordinates PixelToMap(Vector2 point)
+        {
+            return MainViewport.PixelToMap(point);
+        }
     }
 
     public sealed class CurrentEyeChangedEvent : EntityEventArgs

Robust.Client/Graphics/ClientEye/IEyeManager.cs

@@ -79,6 +79,16 @@ namespace Robust.Client.Graphics
         /// <returns>Corresponding point in the world.</returns>
         MapCoordinates ScreenToMap(Vector2 point);
 
+        /// <summary>
+        /// Similar to <see cref="ScreenToMap(ScreenCoordinates)"/>, except it should compensate for the effects of shaders on viewports.
+        /// </summary>
+        MapCoordinates PixelToMap(ScreenCoordinates point);
+
+        /// <summary>
+        /// Similar to <see cref="ScreenToMap(Vector2)"/>, except it should compensate for the effects of shaders on viewports.
+        /// </summary>
+        MapCoordinates PixelToMap(Vector2 point);
+
         void ClearCurrentEye();
         void Initialize();
     }

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/Graphics/Shaders/ShaderPrototype.cs

@@ -20,7 +20,7 @@ namespace Robust.Client.Graphics
     public sealed class ShaderPrototype : IPrototype, ISerializationHooks
     {
         [ViewVariables]
-        [IdDataFieldAttribute]
+        [IdDataField]
         public string ID { get; } = default!;
 
         [ViewVariables] private ShaderKind Kind;
@@ -65,12 +65,12 @@ namespace Robust.Client.Graphics
 
                 case ShaderKind.Canvas:
 
-                    var hasLight = rawMode != "unshaded";
+                    var hasLight = _rawMode != "unshaded";
                     ShaderBlendMode? blend = null;
-                    if (rawBlendMode != null)
+                    if (_rawBlendMode != null)
                     {
-                        if (!Enum.TryParse<ShaderBlendMode>(rawBlendMode.ToUpper(), out var parsed))
-                            Logger.Error($"invalid mode: {rawBlendMode}");
+                        if (!Enum.TryParse<ShaderBlendMode>(_rawBlendMode.ToUpper(), out var parsed))
+                            Logger.Error($"invalid mode: {_rawBlendMode}");
                         else
                             blend = parsed;
                     }
@@ -94,11 +94,20 @@ namespace Robust.Client.Graphics
             return Instance().Duplicate();
         }
 
-        [DataField("kind", readOnly: true, required: true)] private string _rawKind = default!;
-        [DataField("path", readOnly: true)] private ResPath path;
-        [DataField("params", readOnly: true)] private Dictionary<string, string>? paramMapping;
-        [DataField("light_mode", readOnly: true)] private string? rawMode;
-        [DataField("blend_mode", readOnly: true)] private string? rawBlendMode;
+        [DataField("kind", required: true)]
+        private readonly string _rawKind = default!;
+
+        [DataField("path")]
+        private readonly ResPath? _path;
+
+        [DataField("params")]
+        private readonly Dictionary<string, string>? _paramMapping;
+
+        [DataField("light_mode")]
+        private readonly string? _rawMode;
+
+        [DataField("blend_mode")]
+        private readonly string? _rawBlendMode;
 
         void ISerializationHooks.AfterDeserialization()
         {
@@ -106,18 +115,22 @@ namespace Robust.Client.Graphics
             {
                 case "source":
                     Kind = ShaderKind.Source;
-                    if (path == null) throw new InvalidOperationException();
-                    _source = IoCManager.Resolve<IResourceCache>().GetResource<ShaderSourceResource>(path);
 
-                    if (paramMapping != null)
+                    // TODO use a custom type serializer.
+                    if (_path == null)
+                        throw new InvalidOperationException("Source shaders must specify a source file.");
+
+                    _source = IoCManager.Resolve<IResourceCache>().GetResource<ShaderSourceResource>(_path.Value);
+
+                    if (_paramMapping != null)
                     {
                         _params = new Dictionary<string, object>();
-                        foreach (var item in paramMapping!)
+                        foreach (var item in _paramMapping!)
                         {
                             var name = item.Key;
                             if (!_source.ParsedShader.Uniforms.TryGetValue(name, out var uniformDefinition))
                             {
-                                Logger.ErrorS("shader", "Shader param '{0}' does not exist on shader '{1}'", name, path);
+                                Logger.ErrorS("shader", "Shader param '{0}' does not exist on shader '{1}'", name, _path);
                                 continue;
                             }
 

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

@@ -532,7 +532,7 @@ namespace Robust.Client.Placement
                     return false;
                 }
                 coordinates = EntityCoordinates.FromMap(MapManager,
-                                                        EyeManager.ScreenToMap(InputManager.MouseScreenPosition));
+                                                        EyeManager.PixelToMap(InputManager.MouseScreenPosition));
                 return true;
             }
         }
@@ -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/Placement/PlacementMode.cs

@@ -134,7 +134,7 @@ namespace Robust.Client.Placement
         public IEnumerable<EntityCoordinates> LineCoordinates()
         {
             var mouseScreen = pManager.InputManager.MouseScreenPosition;
-            var mousePos = pManager.EyeManager.ScreenToMap(mouseScreen);
+            var mousePos = pManager.EyeManager.PixelToMap(mouseScreen);
 
             if (mousePos.MapId == MapId.Nullspace)
                 yield break;
@@ -165,7 +165,7 @@ namespace Robust.Client.Placement
         public IEnumerable<EntityCoordinates> GridCoordinates()
         {
             var mouseScreen = pManager.InputManager.MouseScreenPosition;
-            var mousePos = pManager.EyeManager.ScreenToMap(mouseScreen);
+            var mousePos = pManager.EyeManager.PixelToMap(mouseScreen);
 
             if (mousePos.MapId == MapId.Nullspace)
                 yield break;
@@ -254,7 +254,7 @@ namespace Robust.Client.Placement
 
         protected EntityCoordinates ScreenToCursorGrid(ScreenCoordinates coords)
         {
-            var mapCoords = pManager.EyeManager.ScreenToMap(coords.Position);
+            var mapCoords = pManager.EyeManager.PixelToMap(coords.Position);
             if (!pManager.MapManager.TryFindGridAt(mapCoords, out var gridUid, out var grid))
             {
                 return EntityCoordinates.FromMap(pManager.MapManager, mapCoords);

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/Loading/ReplayLoadManager.Checkpoints.cs

@@ -7,6 +7,7 @@ using Robust.Shared.Network;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
 using System.Threading.Tasks;
+using Robust.Client.Upload.Commands;
 using Robust.Shared;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Replays;
@@ -131,12 +132,16 @@ public sealed partial class ReplayLoadManager
         var ticksSinceLastCheckpoint = 0;
         var spawnedTracker = 0;
         var stateTracker = 0;
+        var curState = state0;
         for (var i = 1; i < states.Count; i++)
         {
             if (i % 10 == 0)
                 await callback(i, states.Count, LoadingState.ProcessingFiles, false);
 
-            var curState = states[i];
+            var lastState = curState;
+            curState = states[i];
+            DebugTools.Assert(curState.FromSequence <= lastState.ToSequence);
+
             UpdatePlayerStates(curState.PlayerStates.Span, playerStates);
             UpdateEntityStates(curState.EntityStates.Span, entStates, ref spawnedTracker, ref stateTracker, detached);
             UpdateMessages(messages[i], uploadedFiles, prototypes, cvars, detachQueue, ref timeBase);
@@ -222,7 +227,13 @@ public sealed partial class ReplayLoadManager
                     // forwards. Also, note that files HAVE to be uploaded while generating checkpoints, in case
                     // someone spawns an entity that relies on uploaded data.
                     if (!ignoreDuplicates)
-                        throw new NotSupportedException("Overwriting an existing file is not yet supported by replays.");
+                    {
+                        var msg = $"Overwriting an existing file upload! Path: {path}";
+                        if (_confMan.GetCVar(CVars.ReplayIgnoreErrors))
+                            _sawmill.Error(msg);
+                        else
+                            throw new NotSupportedException(msg);
+                    }
 
                     message.Messages.RemoveSwap(i);
                     break;
@@ -240,31 +251,56 @@ public sealed partial class ReplayLoadManager
                 continue;
 
             message.Messages.RemoveSwap(i);
-            var changed = new Dictionary<Type, HashSet<string>>();
-            _protoMan.LoadString(protoUpload.PrototypeData, true, changed);
 
-            foreach (var (kind, ids) in changed)
+            try
             {
-                var protos = prototypes[kind];
-                var count = protos.Count;
-                protos.UnionWith(ids);
-                if (!ignoreDuplicates && ids.Count + count != protos.Count)
-                {
-                    // An existing prototype was overwritten. Much like for resource uploading, supporting this
-                    // requires tracking the last-modified time of prototypes and either resetting or applying
-                    // prototype changes when jumping around in time. This also requires reworking how the initial
-                    // implicit state data is generated, because we can't simply cache it anymore.
-                    // Also, does reloading prototypes in release mode modify existing entities?
-                    throw new NotSupportedException($"Overwriting an existing prototype is not yet supported by replays.");
-                }
+                LoadPrototype(protoUpload.PrototypeData, prototypes, ignoreDuplicates);
             }
+            catch (Exception e)
+            {
+                if (e is NotSupportedException || !_confMan.GetCVar(CVars.ReplayIgnoreErrors))
+                    throw;
 
-            _protoMan.ResolveResults();
-            _protoMan.ReloadPrototypes(changed);
-            _locMan.ReloadLocalizations();
+                var msg = $"Caught exception while parsing uploaded prototypes in a replay. Exception: {e}";
+                _sawmill.Error(msg);
+            }
         }
     }
 
+    private void LoadPrototype(
+        string data,
+        Dictionary<Type, HashSet<string>> prototypes,
+        bool ignoreDuplicates)
+    {
+        var changed = new Dictionary<Type, HashSet<string>>();
+        _protoMan.LoadString(data, true, changed);
+
+        foreach (var (kind, ids) in changed)
+        {
+            var protos = prototypes[kind];
+            var count = protos.Count;
+            protos.UnionWith(ids);
+            if (!ignoreDuplicates && ids.Count + count != protos.Count)
+            {
+                // An existing prototype was overwritten. Much like for resource uploading, supporting this
+                // requires tracking the last-modified time of prototypes and either resetting or applying
+                // prototype changes when jumping around in time. This also requires reworking how the initial
+                // implicit state data is generated, because we can't simply cache it anymore.
+                // Also, does reloading prototypes in release mode modify existing entities?
+
+                var msg = $"Overwriting an existing prototype! Kind: {kind.Name}. Ids: {string.Join(", ", ids)}";
+                if (_confMan.GetCVar(CVars.ReplayIgnoreErrors))
+                    _sawmill.Error(msg);
+                else
+                    throw new NotSupportedException(msg);
+            }
+        }
+
+        _protoMan.ResolveResults();
+        _protoMan.ReloadPrototypes(changed);
+        _locMan.ReloadLocalizations();
+    }
+
     private void UpdateDeletions(NetListAsArray<EntityUid> entityDeletions,
         Dictionary<EntityUid, EntityState> entStates, HashSet<EntityUid> detached)
     {

Robust.Client/Replays/Loading/ReplayLoadManager.Implicit.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using Robust.Client.GameStates;
+using Robust.Shared;
 using Robust.Shared.GameObjects;
 using Robust.Shared.Timing;
 using Robust.Shared.Utility;
@@ -64,6 +66,18 @@ public sealed partial class ReplayLoadManager
             }
         }
 
-        throw new Exception("Missing metadata component");
+        if (!entState.ComponentChanges.HasContents)
+        {
+            // This shouldn't be possible, yet it has happened?
+            // TODO this should probably also throw an exception.
+            _sawmill.Error($"Encountered blank entity state? Entity: {entState.Uid}. Last modified: {entState.EntityLastModified}. Attempting to continue.");
+            return null;
+        }
+
+        if (!_confMan.GetCVar(CVars.ReplayIgnoreErrors))
+            throw new MissingMetadataException(entState.Uid);
+
+        _sawmill.Error($"Missing metadata component. Entity: {entState.Uid}. Last modified: {entState.EntityLastModified}.");
+        return null;
     }
 }

Robust.Client/Replays/Loading/ReplayLoadManager.Read.cs

@@ -11,6 +11,7 @@ using Robust.Shared.Utility;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
+using Robust.Shared;
 using Robust.Shared.Replays;
 using static Robust.Shared.Replays.ReplayConstants;
 
@@ -136,9 +137,21 @@ public sealed partial class ReplayLoadManager
         if (data == null)
             throw new Exception("Failed to load yaml metadata");
 
+        TimeSpan duration;
         var finalData = LoadYamlFinalMetadata(fileReader);
         if (finalData == null)
-            throw new Exception("Failed to load final yaml metadata");
+        {
+            var msg = "Failed to load final yaml metadata";
+            if (!_confMan.GetCVar(CVars.ReplayIgnoreErrors))
+                throw new Exception(msg);
+
+            _sawmill.Error(msg);
+            duration = TimeSpan.FromDays(1);
+        }
+        else
+        {
+            duration = TimeSpan.Parse(((ValueDataNode) finalData[MetaFinalKeyDuration]).Value);
+        }
 
         var typeHash = Convert.FromHexString(((ValueDataNode) data[MetaKeyTypeHash]).Value);
         var stringHash = Convert.FromHexString(((ValueDataNode) data[MetaKeyStringHash]).Value);
@@ -146,7 +159,6 @@ public sealed partial class ReplayLoadManager
         var timeBaseTick = ((ValueDataNode) data[MetaKeyBaseTick]).Value;
         var timeBaseTimespan = ((ValueDataNode) data[MetaKeyBaseTime]).Value;
         var clientSide = bool.Parse(((ValueDataNode) data[MetaKeyIsClientRecording]).Value);
-        var duration = TimeSpan.Parse(((ValueDataNode) finalData[MetaFinalKeyDuration]).Value);
 
         if (!typeHash.SequenceEqual(_serializer.GetSerializableTypesHash()))
             throw new Exception($"{nameof(IRobustSerializer)} hashes do not match. Loading replays using a bad replay-client version?");

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/ResourceManagement/IResourceCache.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using Robust.Client.Graphics;
 using Robust.Shared.ContentPack;
 using Robust.Shared.Utility;
 
@@ -40,5 +41,9 @@ namespace Robust.Client.ResourceManagement
         // Resource load callbacks so content can hook stuff like click maps.
         event Action<TextureLoadedEventArgs> OnRawTextureLoaded;
         event Action<RsiLoadedEventArgs> OnRsiLoaded;
+        
+        IClyde Clyde { get; }
+        IClydeAudio ClydeAudio { get; }
+        IFontManager FontManager { get; }
     }
 }

Robust.Client/ResourceManagement/ResourceCache.Preload.cs

@@ -18,7 +18,9 @@ namespace Robust.Client.ResourceManagement
 {
     internal partial class ResourceCache
     {
-        [Dependency] private readonly IClyde _clyde = default!;
+        [field: Dependency] public IClyde Clyde { get; } = default!;
+        [field: Dependency] public IClydeAudio ClydeAudio { get; } = default!;
+        [field: Dependency] public IFontManager FontManager { get; } = default!;
         [Dependency] private readonly ILogManager _logManager = default!;
         [Dependency] private readonly IConfigurationManager _configurationManager = default!;
 
@@ -70,7 +72,7 @@ namespace Robust.Client.ResourceManagement
 
                 try
                 {
-                    TextureResource.LoadTexture(_clyde, data);
+                    TextureResource.LoadTexture(Clyde, data);
                 }
                 catch (Exception e)
                 {
@@ -198,7 +200,7 @@ namespace Robust.Client.ResourceManagement
 
             void FinalizeMetaAtlas(int toIndex, Image<Rgba32> sheet)
             {
-                var atlas = _clyde.LoadTextureFromImage(sheet);
+                var atlas = Clyde.LoadTextureFromImage(sheet);
                 for (int i = finalized + 1; i <= toIndex; i++)
                 {
                     var rsi = rsiList[i];

Robust.Client/ResourceManagement/ResourceTypes/AudioResource.cs

@@ -20,14 +20,13 @@ namespace Robust.Client.ResourceManagement
 
             using (var fileStream = cache.ContentFileRead(path))
             {
-                var clyde = IoCManager.Resolve<IClydeAudio>();
                 if (path.Extension == "ogg")
                 {
-                    AudioStream = clyde.LoadAudioOggVorbis(fileStream, path.ToString());
+                    AudioStream = cache.ClydeAudio.LoadAudioOggVorbis(fileStream, path.ToString());
                 }
                 else if (path.Extension == "wav")
                 {
-                    AudioStream = clyde.LoadAudioWav(fileStream, path.ToString());
+                    AudioStream = cache.ClydeAudio.LoadAudioWav(fileStream, path.ToString());
                 }
                 else
                 {

Robust.Client/ResourceManagement/ResourceTypes/FontResource.cs

@@ -18,7 +18,7 @@ namespace Robust.Client.ResourceManagement
 
             using (stream)
             {
-                FontFaceHandle = IoCManager.Resolve<IFontManagerInternal>().Load(stream);
+                FontFaceHandle = ((IFontManagerInternal)cache.FontManager).Load(stream);
             }
         }
 

Robust.Client/ResourceManagement/ResourceTypes/RSIResource.cs

@@ -34,12 +34,10 @@ namespace Robust.Client.ResourceManagement
 
         public override void Load(IResourceCache cache, ResPath path)
         {
-            var clyde = IoCManager.Resolve<IClyde>();
-
             var loadStepData = new LoadStepData {Path = path};
             LoadPreTexture(cache, loadStepData);
 
-            loadStepData.AtlasTexture = clyde.LoadTextureFromImage(
+            loadStepData.AtlasTexture = cache.Clyde.LoadTextureFromImage(
                 loadStepData.AtlasSheet,
                 loadStepData.Path.ToString());
 

Robust.Client/ResourceManagement/ResourceTypes/ShaderSourceResource.cs

@@ -1,6 +1,7 @@
 using System.IO;
 using System.Threading;
 using Robust.Client.Graphics;
+using Robust.Client.Graphics.Clyde;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
 using Robust.Shared.Utility;
@@ -27,8 +28,7 @@ namespace Robust.Client.ResourceManagement
                 ParsedShader = ShaderParser.Parse(reader, cache);
             }
 
-            var clyde = IoCManager.Resolve<IClydeInternal>();
-            ClydeHandle = clyde.LoadShader(ParsedShader, path.ToString());
+            ClydeHandle = ((IClydeInternal)cache.Clyde).LoadShader(ParsedShader, path.ToString());
         }
 
         public override void Reload(IResourceCache cache, ResPath path, CancellationToken ct = default)
@@ -57,8 +57,7 @@ namespace Robust.Client.ResourceManagement
                 }
             }
 
-            var clyde = IoCManager.Resolve<IClydeInternal>();
-            clyde.ReloadShader(ClydeHandle, ParsedShader);
+            ((IClydeInternal)cache.Clyde).ReloadShader(ClydeHandle, ParsedShader);
         }
     }
 }

Robust.Client/ResourceManagement/ResourceTypes/TextureResource.cs

@@ -20,8 +20,6 @@ namespace Robust.Client.ResourceManagement
 
         public override void Load(IResourceCache cache, ResPath path)
         {
-            var clyde = IoCManager.Resolve<IClyde>();
-
             if (path.Directory.Filename.EndsWith(".rsi"))
             {
                 Logger.WarningS(
@@ -33,7 +31,7 @@ namespace Robust.Client.ResourceManagement
             var data = new LoadStepData {Path = path};
 
             LoadPreTexture(cache, data);
-            LoadTexture(clyde, data);
+            LoadTexture(cache.Clyde, data);
             LoadFinish(cache, data);
         }
 

Robust.Client/Robust.Client.csproj

@@ -10,25 +10,26 @@
     <RobustILLink>true</RobustILLink>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="DiscordRichPresence" Version="1.0.175" />
+    <PackageReference Include="DiscordRichPresence" Version="1.0.175" PrivateAssets="compile" />
     <PackageReference Include="JetBrains.Annotations" Version="2021.3.0" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.Data.Sqlite.Core" Version="6.0.9" />
-    <PackageReference Include="SQLitePCLRaw.provider.sqlite3" Version="2.1.2" Condition="'$(UseSystemSqlite)' == 'True'" />
-    <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="OpenToolkit.Graphics" Version="4.0.0-pre9.1" />
-    <PackageReference Include="OpenTK.OpenAL" Version="4.7.5" />
-    <PackageReference Include="SpaceWizards.SharpFont" Version="1.0.1" />
+    <PackageReference Include="Microsoft.Data.Sqlite.Core" Version="6.0.9" PrivateAssets="compile" />
+    <PackageReference Include="SQLitePCLRaw.provider.sqlite3" Version="2.1.2" Condition="'$(UseSystemSqlite)' == 'True'" PrivateAssets="compile" />
+    <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.2" Condition="'$(UseSystemSqlite)' != 'True'" PrivateAssets="compile" />
+    <PackageReference Include="SpaceWizards.NFluidsynth" Version="0.1.1" PrivateAssets="compile" />
+    <PackageReference Include="NVorbis" Version="0.10.1" PrivateAssets="compile" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="2.1.3" />
+    <PackageReference Include="OpenToolkit.Graphics" Version="4.0.0-pre9.1" PrivateAssets="compile" />
+    <PackageReference Include="OpenTK.OpenAL" Version="4.7.5" PrivateAssets="compile" />
+    <PackageReference Include="SpaceWizards.SharpFont" Version="1.0.1" PrivateAssets="compile" />
     <PackageReference Include="Robust.Natives" Version="0.1.1" />
-    <PackageReference Include="TerraFX.Interop.Windows" Version="10.0.20348-rc2" />
-    <PackageReference Condition="'$(FullRelease)' != 'True'" Include="JetBrains.Profiler.Api" Version="1.2.0" />
+    <PackageReference Include="TerraFX.Interop.Windows" Version="10.0.20348-rc2" PrivateAssets="compile" />
+    <PackageReference Condition="'$(FullRelease)' != 'True'" Include="JetBrains.Profiler.Api" Version="1.2.0" PrivateAssets="compile" />
+    <PackageReference Include="SpaceWizards.Sodium" Version="0.2.1" PrivateAssets="compile" />
   </ItemGroup>
   <ItemGroup Condition="'$(EnableClientScripting)' == 'True'">
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.0.1" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.0.1" />
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Features" Version="4.0.1" PrivateAssets="compile" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Scripting" Version="4.0.1" PrivateAssets="compile" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="4.0.1" PrivateAssets="compile" />
 
     <ProjectReference Include="..\Robust.Shared.Scripting\Robust.Shared.Scripting.csproj" />
   </ItemGroup>
@@ -50,6 +51,7 @@
   <!-- ILLink configuration -->
   <ItemGroup>
     <RobustLinkRoots Include="Robust.Client" />
+    <RobustLinkRoots Include="Robust.Shared" />
     <RobustLinkAssemblies Include="TerraFX.Interop.Windows" />
     <RobustLinkAssemblies Include="OpenToolkit.Graphics" />
   </ItemGroup>

Robust.Client/Serialization/ClientSpriteSpecifierSerializer.cs

@@ -1,5 +1,4 @@
 using Robust.Client.ResourceManagement;
-using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Manager.Attributes;
@@ -29,7 +28,7 @@ public sealed class ClientSpriteSpecifierSerializer : SpriteSpecifierSerializer
         }
 
         var res = dependencies.Resolve<IResourceCache>();
-        var rsiPath = SpriteSpecifierSerializer.TextureRoot / valuePathNode.Value;
+        var rsiPath = TextureRoot / valuePathNode.Value;
         if (!res.TryGetResource(rsiPath, out RSIResource? resource))
         {
             return new ErrorNode(node, "Failed to load RSI");
@@ -40,6 +39,10 @@ public sealed class ClientSpriteSpecifierSerializer : SpriteSpecifierSerializer
             return new ErrorNode(node, "Invalid RSI state");
         }
 
-        return new ValidatedMappingNode(new());
+        return new ValidatedMappingNode(new()
+        {
+            { new ValidatedValueNode(new ValueDataNode("sprite")), new ValidatedValueNode(pathNode)},
+            { new ValidatedValueNode(new ValueDataNode("state")), new ValidatedValueNode(valueStateNode)},
+        });
     }
 }

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/Controls/OutputPanel.cs

@@ -89,7 +89,7 @@ namespace Robust.Client.UserInterface.Controls
 
         public void AddMessage(FormattedMessage message)
         {
-            var entry = new RichTextEntry(message, this, _tagManager);
+            var entry = new RichTextEntry(message, this, _tagManager, null);
 
             entry.Update(_getFont(), _getContentBox().Width, UIScale);
 

Robust.Client/UserInterface/Controls/RichTextLabel.cs

@@ -1,4 +1,5 @@
-using System.Numerics;
+using System;
+using System.Numerics;
 using JetBrains.Annotations;
 using Robust.Client.Graphics;
 using Robust.Client.UserInterface.RichText;
@@ -21,18 +22,18 @@ namespace Robust.Client.UserInterface.Controls
             IoCManager.InjectDependencies(this);
         }
 
-        public void SetMessage(FormattedMessage message)
+        public void SetMessage(FormattedMessage message, Type[]? tagsAllowed = null, Color? defaultColor = null)
         {
             _message = message;
-            _entry = new RichTextEntry(_message, this, _tagManager);
+            _entry = new RichTextEntry(_message, this, _tagManager, tagsAllowed, defaultColor);
             InvalidateMeasure();
         }
 
-        public void SetMessage(string message)
+        public void SetMessage(string message, Type[]? tagsAllowed = null, Color? defaultColor = null)
         {
             var msg = new FormattedMessage();
             msg.AddText(message);
-            SetMessage(msg);
+            SetMessage(msg, tagsAllowed, defaultColor);
         }
 
         public string? GetMessage() => _message?.ToMarkup();

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.PixelToMap(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/CustomControls/IViewportControl.cs

@@ -24,6 +24,11 @@ namespace Robust.Client.UserInterface.CustomControls
         /// </param>
         MapCoordinates ScreenToMap(Vector2 coords);
 
+        /// <summary>
+        /// Similar to <see cref="ScreenToMap(Vector2)"/>, except it should compensate for the effects of shaders on viewports.
+        /// </summary>
+        MapCoordinates PixelToMap(Vector2 point);
+
         /// <summary>
         ///     Converts a point on the map to screen coordinates.
         /// </summary>

Robust.Client/UserInterface/CustomControls/ProjectionEvents.cs

@@ -0,0 +1,34 @@
+using Robust.Client.Graphics;
+using Robust.Shared.GameObjects;
+using System.Numerics;
+
+namespace Robust.Client.UserInterface.CustomControls;
+
+/// <summary>
+/// An event used to reverse distortion effects applied by shaders.
+/// Used to find the map position that visible pixels originate from so that severe distortion shaders do not make interaction nigh-impossible.
+/// </summary>
+[ByRefEvent]
+public record struct PixelToMapEvent(Vector2 LocalPosition, IViewportControl Control, IClydeViewport Viewport)
+{
+    /// <summary>
+    /// The local position of the pixel within the <see cref="Control"/> that we are trying to convert to a map position.
+    /// </summary>
+    public readonly Vector2 LocalPosition = LocalPosition;
+
+    /// <summary>
+    /// The original (or WIP) location of the pixel within the <see cref="Control"/> that we are trying to convert to a map position.
+    /// Used as the output of the event.
+    /// </summary>
+    public Vector2 VisiblePosition = LocalPosition;
+
+    /// <summary>
+    /// The control the pixel we are considering is located within.
+    /// </summary>
+    public readonly IViewportControl Control = Control;
+
+    /// <summary>
+    /// The viewport being displayed by the control we are considering.
+    /// </summary>
+    public readonly IClydeViewport Viewport = Viewport;
+}

Robust.Client/UserInterface/CustomControls/ViewportContainer.cs

@@ -1,6 +1,7 @@
 using System.Numerics;
 using Robust.Client.Graphics;
 using Robust.Client.Input;
+using Robust.Shared.GameObjects;
 using Robust.Shared.Maths;
 using Robust.Shared.IoC;
 using Robust.Shared.Map;
@@ -13,8 +14,9 @@ namespace Robust.Client.UserInterface.CustomControls
     [Virtual]
     public class ViewportContainer : Control, IViewportControl
     {
-        private readonly IClyde _displayManager;
-        private readonly IInputManager _inputManager;
+        [Dependency] private readonly IClyde _displayManager = default!;
+        [Dependency] private readonly IEntityManager _entityManager = default!;
+        [Dependency] private readonly IInputManager _inputManager = default!;
 
         public IClydeViewport? Viewport { get; set; }
 
@@ -36,8 +38,7 @@ namespace Robust.Client.UserInterface.CustomControls
 
         public ViewportContainer()
         {
-            _displayManager = IoCManager.Resolve<IClyde>();
-            _inputManager = IoCManager.Resolve<IInputManager>();
+            IoCManager.InjectDependencies(this);
             MouseFilter = MouseFilterMode.Stop;
             Resized();
         }
@@ -99,8 +100,7 @@ namespace Robust.Client.UserInterface.CustomControls
         // -- Handlers: In --
 
         // -- Utils / S2M-M2S Base --
-
-        public MapCoordinates LocalPixelToMap(Vector2 point)
+        public MapCoordinates LocalCoordsToMap(Vector2 point)
         {
             if (Viewport == null)
                 return default;
@@ -111,6 +111,19 @@ namespace Robust.Client.UserInterface.CustomControls
             return Viewport.LocalToWorld(point);
         }
 
+        public MapCoordinates LocalPixelToMap(Vector2 point)
+        {
+            if (Viewport == null)
+                return default;
+
+            // pre-scaler
+            point *= _viewportResolution;
+            var ev = new PixelToMapEvent(point, this, Viewport);
+            _entityManager.EventBus.RaiseEvent(EventSource.Local, ref ev);
+
+            return Viewport.LocalToWorld(ev.VisiblePosition);
+        }
+
         public Vector2 WorldToLocalPixel(Vector2 point)
         {
             if (Viewport?.Eye == null)
@@ -127,6 +140,12 @@ namespace Robust.Client.UserInterface.CustomControls
         // -- Utils / S2M-M2S Extended --
 
         public MapCoordinates ScreenToMap(Vector2 point)
+        {
+            return LocalCoordsToMap(point - GlobalPixelPosition);
+        }
+
+        /// <inheritdoc/>
+        public MapCoordinates PixelToMap(Vector2 point)
         {
             return LocalPixelToMap(point - GlobalPixelPosition);
         }

Robust.Client/UserInterface/RichText/BoldItalicTag.cs

@@ -0,0 +1,29 @@
+using Robust.Client.ResourceManagement;
+using Robust.Shared.IoC;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.UserInterface.RichText;
+
+public sealed class BoldItalicTag : IMarkupTag
+{
+    public const string BoldItalicFont = "DefaultBoldItalic";
+
+    [Dependency] private readonly IResourceCache _resourceCache = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public string Name => "bolditalic";
+
+    /// <inheritdoc/>
+    public void PushDrawContext(MarkupNode node, MarkupDrawingContext context)
+    {
+        var font = FontTag.CreateFont(context.Font, node, _resourceCache, _prototypeManager, BoldItalicFont);
+        context.Font.Push(font);
+    }
+
+    /// <inheritdoc/>
+    public void PopDrawContext(MarkupNode node, MarkupDrawingContext context)
+    {
+        context.Font.Pop();
+    }
+}

Robust.Client/UserInterface/RichText/BoldTag.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.IoC;
 using Robust.Shared.Prototypes;
@@ -14,12 +15,18 @@ public sealed class BoldTag : IMarkupTag
 
     public string Name => "bold";
 
+    /// <inheritdoc/>
     public void PushDrawContext(MarkupNode node, MarkupDrawingContext context)
     {
-        var font = FontTag.CreateFont(context.Font, node, _resourceCache, _prototypeManager, BoldFont);
+        var font = FontTag.CreateFont(context.Font, node, _resourceCache, _prototypeManager,
+            context.Tags.Any(static x => x is ItalicTag)
+                ? BoldItalicTag.BoldItalicFont
+                : BoldFont
+        );
         context.Font.Push(font);
     }
 
+    /// <inheritdoc/>
     public void PopDrawContext(MarkupNode node, MarkupDrawingContext context)
     {
         context.Font.Pop();

Robust.Client/UserInterface/RichText/BulletTag.cs

@@ -0,0 +1,11 @@
+using Robust.Shared.Utility;
+
+namespace Robust.Client.UserInterface.RichText;
+
+public sealed class BulletTag : IMarkupTag
+{
+    public string Name => "bullet";
+
+    /// <inheritdoc/>
+    public string TextBefore(MarkupNode _) => " · ";
+}

Robust.Client/UserInterface/RichText/ColorTag.cs

@@ -8,7 +8,7 @@ namespace Robust.Client.UserInterface.RichText;
 /// </summary>
 public sealed class ColorTag : IMarkupTag
 {
-    private static readonly Color DefaultColor = new(200, 200, 200);
+    public static readonly Color DefaultColor = new(200, 200, 200);
 
     public string Name => "color";
 

Robust.Client/UserInterface/RichText/FontTag.cs

@@ -14,12 +14,14 @@ namespace Robust.Client.UserInterface.RichText;
 public sealed class FontTag : IMarkupTag
 {
     public const string DefaultFont = "Default";
+    public const int DefaultSize = 12;
 
     [Dependency] private readonly IResourceCache _resourceCache = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
 
     public string Name => "font";
 
+    /// <inheritdoc/>
     public void PushDrawContext(MarkupNode node, MarkupDrawingContext context)
     {
         string fontId = node.Value.StringValue ?? DefaultFont;
@@ -28,6 +30,7 @@ public sealed class FontTag : IMarkupTag
         context.Font.Push(font);
     }
 
+    /// <inheritdoc/>
     public void PopDrawContext(MarkupNode node, MarkupDrawingContext context)
     {
         context.Font.Pop();
@@ -44,7 +47,7 @@ public sealed class FontTag : IMarkupTag
         IPrototypeManager prototypeManager,
         string fontId)
     {
-        var size = 12;
+        var size = DefaultSize;
 
         if (contextFontStack.TryPeek(out var previousFont))
         {

Robust.Client/UserInterface/RichText/HeadingTag.cs

@@ -0,0 +1,36 @@
+using System;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.IoC;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+
+namespace Robust.Client.UserInterface.RichText;
+
+public sealed class HeadingTag : IMarkupTag
+{
+    [Dependency] private readonly IResourceCache _resourceCache = default!;
+    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+    public string Name => "head";
+
+    /// <inheritdoc/>
+    public void PushDrawContext(MarkupNode node, MarkupDrawingContext context)
+    {
+        if (!node.Value.TryGetLong(out var levelParam))
+            return;
+
+        var level = Math.Min(Math.Max((int)levelParam, 1), 3);
+        node.Attributes["size"] = new MarkupParameter(
+            (int)Math.Ceiling(FontTag.DefaultSize * 2 / Math.Sqrt(level))
+        );
+
+        var font = FontTag.CreateFont(context.Font, node, _resourceCache, _prototypeManager, BoldTag.BoldFont);
+        context.Font.Push(font);
+    }
+
+    /// <inheritdoc/>
+    public void PopDrawContext(MarkupNode node, MarkupDrawingContext context)
+    {
+        context.Font.Pop();
+    }
+}

Robust.Client/UserInterface/RichText/ItalicTag.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.IoC;
 using Robust.Shared.Prototypes;
@@ -11,14 +12,21 @@ public sealed class ItalicTag : IMarkupTag
 
     [Dependency] private readonly IResourceCache _resourceCache = default!;
     [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
     public string Name => "italic";
 
+    /// <inheritdoc/>
     public void PushDrawContext(MarkupNode node, MarkupDrawingContext context)
     {
-        var font = FontTag.CreateFont(context.Font, node, _resourceCache, _prototypeManager, ItalicFont);
+        var font = FontTag.CreateFont(context.Font, node, _resourceCache, _prototypeManager,
+            context.Tags.Any(static x => x is BoldTag)
+                ? BoldItalicTag.BoldItalicFont
+                : ItalicFont
+        );
         context.Font.Push(font);
     }
 
+    /// <inheritdoc/>
     public void PopDrawContext(MarkupNode node, MarkupDrawingContext context)
     {
         context.Font.Pop();

Robust.Client/UserInterface/RichText/MarkupDrawingContext.cs

@@ -8,22 +8,26 @@ public sealed class MarkupDrawingContext
 {
     public readonly Stack<Color> Color;
     public readonly Stack<Font> Font;
+    public readonly List<IMarkupTag> Tags;
 
     public MarkupDrawingContext()
     {
         Color = new Stack<Color>();
         Font = new Stack<Font>();
+        Tags = new List<IMarkupTag>();
     }
 
     public MarkupDrawingContext(int capacity)
     {
         Color = new Stack<Color>(capacity);
         Font = new Stack<Font>(capacity);
+        Tags = new List<IMarkupTag>();
     }
 
     public void Clear()
     {
         Color.Clear();
         Font.Clear();
+        Tags.Clear();
     }
 }

Robust.Client/UserInterface/RichText/MarkupTagManager.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Robust.Shared.IoC;
 using Robust.Shared.Reflection;
 using Robust.Shared.Sandboxing;
@@ -15,24 +16,29 @@ public sealed class MarkupTagManager
     /// <summary>
     /// Tags defined in engine need to be instantiated here because of sandboxing
     /// </summary>
-    private readonly Dictionary<string, IMarkupTag> _markupTagTypes = new()
-    {
-        {"color", new ColorTag()},
-        {"cmdlink", new CommandLinkTag()},
-        {"font", new FontTag()},
-        {"bold", new BoldTag()},
-        {"italic", new ItalicTag()}
-    };
+    private readonly Dictionary<string, IMarkupTag> _markupTagTypes = new IMarkupTag[] {
+        new BoldItalicTag(),
+        new BoldTag(),
+        new BulletTag(),
+        new ColorTag(),
+        new CommandLinkTag(),
+        new FontTag(),
+        new HeadingTag(),
+        new ItalicTag()
+    }.ToDictionary(x => x.Name.ToLower(), x => x);
 
     /// <summary>
     /// A list of <see cref="IMarkupTag"/> types that shouldn't be instantiated through reflection
     /// </summary>
     private readonly List<Type> _engineTypes = new()
     {
+        typeof(BoldItalicTag),
+        typeof(BoldTag),
+        typeof(BulletTag),
         typeof(ColorTag),
         typeof(CommandLinkTag),
         typeof(FontTag),
-        typeof(BoldTag),
+        typeof(HeadingTag),
         typeof(ItalicTag)
     };
 
@@ -59,9 +65,11 @@ public sealed class MarkupTagManager
         return _markupTagTypes.GetValueOrDefault(name);
     }
 
-    public bool TryGetMarkupTag(string name, [NotNullWhen(true)] out IMarkupTag? tag)
+    public bool TryGetMarkupTag(string name, Type[]? tagsAllowed, [NotNullWhen(true)] out IMarkupTag? tag)
     {
-        if (_markupTagTypes.TryGetValue(name, out var markupTag))
+        if (_markupTagTypes.TryGetValue(name, out var markupTag)
+            // Using a whitelist prevents new tags from sneaking in.
+            && (tagsAllowed == null || Array.IndexOf(tagsAllowed, markupTag.GetType()) != -1))
         {
             tag = markupTag;
             return true;

Robust.Client/UserInterface/RichTextEntry.cs

@@ -16,9 +16,9 @@ namespace Robust.Client.UserInterface
     /// </summary>
     internal struct RichTextEntry
     {
-        private static readonly Color DefaultColor = new(200, 200, 200);
-
+        private readonly Color _defaultColor;
         private readonly MarkupTagManager _tagManager;
+        private readonly Type[]? _tagsAllowed;
 
         public readonly FormattedMessage Message;
 
@@ -39,13 +39,15 @@ namespace Robust.Client.UserInterface
 
         private readonly Dictionary<int, Control> _tagControls = new();
 
-        public RichTextEntry(FormattedMessage message, Control parent, MarkupTagManager tagManager)
+        public RichTextEntry(FormattedMessage message, Control parent, MarkupTagManager tagManager, Type[]? tagsAllowed = null, Color? defaultColor = null)
         {
             Message = message;
             Height = 0;
             Width = 0;
             LineBreaks = default;
+            _defaultColor = defaultColor ?? new(200, 200, 200);
             _tagManager = tagManager;
+            _tagsAllowed = tagsAllowed;
 
             var nodeIndex = -1;
             foreach (var node in Message.Nodes)
@@ -55,7 +57,7 @@ namespace Robust.Client.UserInterface
                 if (node.Name == null)
                     continue;
 
-                if (!_tagManager.TryGetMarkupTag(node.Name, out var tag) || !tag.TryGetControl(node, out var control))
+                if (!_tagManager.TryGetMarkupTag(node.Name, _tagsAllowed, out var tag) || !tag.TryGetControl(node, out var control))
                     continue;
 
                 parent.Children.Add(control);
@@ -82,7 +84,7 @@ namespace Robust.Client.UserInterface
             var wordWrap = new WordWrap(maxSizeX);
             var context = new MarkupDrawingContext();
             context.Font.Push(defaultFont);
-            context.Color.Push(DefaultColor);
+            context.Color.Push(_defaultColor);
 
             // Go over every node.
             // Nodes can change the markup drawing context and return additional text.
@@ -171,7 +173,7 @@ namespace Robust.Client.UserInterface
             float uiScale)
         {
             context.Clear();
-            context.Color.Push(DefaultColor);
+            context.Color.Push(_defaultColor);
             context.Font.Push(defaultFont);
 
             var globalBreakCounter = 0;
@@ -186,7 +188,7 @@ namespace Robust.Client.UserInterface
                 var text = ProcessNode(node, context);
                 if (!context.Color.TryPeek(out var color) || !context.Font.TryPeek(out var font))
                 {
-                    color = DefaultColor;
+                    color = _defaultColor;
                     font = defaultFont;
                 }
 
@@ -226,15 +228,17 @@ namespace Robust.Client.UserInterface
                 return node.Value.StringValue ?? "";
 
             //Skip the node if there is no markup tag for it.
-            if (!_tagManager.TryGetMarkupTag(node.Name, out var tag))
+            if (!_tagManager.TryGetMarkupTag(node.Name, _tagsAllowed, out var tag))
                 return "";
 
             if (!node.Closing)
             {
+                context.Tags.Add(tag);
                 tag.PushDrawContext(node, context);
                 return tag.TextBefore(node);
             }
 
+            context.Tags.Remove(tag);
             tag.PopDrawContext(node, context);
             return tag.TextAfter(node);
         }

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;
+        }
     }
 }