From a2893dd6c3963639b0236b183629ec5cd9dd14b9 Mon Sep 17 00:00:00 2001
From: Vera Aguilera Puerto <6766154+Zumorica@users.noreply.github.com>
Date: Sun, 16 Jul 2023 21:12:53 +0200
Subject: [PATCH] Instrument band support, submodule update to 138.0.0 (#17995)

---
 .../Instruments/InstrumentSystem.cs           | 114 ++++++--
 Content.Client/Instruments/UI/BandMenu.xaml   |   9 +
 .../Instruments/UI/BandMenu.xaml.cs           |  45 +++
 .../Instruments/UI/ChannelsMenu.xaml          |  11 +
 .../Instruments/UI/ChannelsMenu.xaml.cs       |  66 +++++
 .../UI/InstrumentBoundUserInterface.cs        |  83 +++++-
 .../Instruments/UI/InstrumentMenu.xaml        |  10 +-
 .../Instruments/UI/InstrumentMenu.xaml.cs     | 121 +++++---
 .../Instruments/InstrumentComponent.cs        |  23 +-
 .../Instruments/InstrumentSystem.cs           | 264 ++++++++++++++++--
 .../Instruments/SharedInstrumentComponent.cs  |  82 +++---
 .../Instruments/SharedInstrumentSystem.cs     |  39 +--
 .../InstrumentBoundUserInterfaceMessages.cs   |  19 ++
 .../instruments/instruments-component.ftl     |  10 +-
 RobustToolbox                                 |   2 +-
 SpaceStation14.sln.DotSettings                |   2 +
 16 files changed, 722 insertions(+), 178 deletions(-)
 create mode 100644 Content.Client/Instruments/UI/BandMenu.xaml
 create mode 100644 Content.Client/Instruments/UI/BandMenu.xaml.cs
 create mode 100644 Content.Client/Instruments/UI/ChannelsMenu.xaml
 create mode 100644 Content.Client/Instruments/UI/ChannelsMenu.xaml.cs
 create mode 100644 Content.Shared/Instruments/UI/InstrumentBoundUserInterfaceMessages.cs

diff --git a/Content.Client/Instruments/InstrumentSystem.cs b/Content.Client/Instruments/InstrumentSystem.cs
index 009fa6bcc5..02e3cf0da3 100644
--- a/Content.Client/Instruments/InstrumentSystem.cs
+++ b/Content.Client/Instruments/InstrumentSystem.cs
@@ -52,13 +52,44 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
         EndRenderer(uid, false, component);
     }
 
+    public void SetMaster(EntityUid uid, EntityUid? masterUid)
+    {
+        if (!TryComp(uid, out InstrumentComponent? instrument))
+            return;
+
+        RaiseNetworkEvent(new InstrumentSetMasterEvent(uid, masterUid));
+    }
+
+    public void SetFilteredChannel(EntityUid uid, int channel, bool value)
+    {
+        if (!TryComp(uid, out InstrumentComponent? instrument))
+            return;
+
+        if(value)
+            instrument.Renderer?.SendMidiEvent(RobustMidiEvent.AllNotesOff((byte)channel, 0), false);
+
+        RaiseNetworkEvent(new InstrumentSetFilteredChannelEvent(uid, channel, value));
+    }
+
     public override void SetupRenderer(EntityUid uid, bool fromStateChange, SharedInstrumentComponent? component = null)
     {
         if (!Resolve(uid, ref component))
             return;
 
-        if (component is not InstrumentComponent instrument || instrument.IsRendererAlive)
+        if (component is not InstrumentComponent instrument)
+        {
             return;
+        }
+
+        if (instrument.IsRendererAlive)
+        {
+            if (fromStateChange)
+            {
+                UpdateRenderer(uid, instrument);
+            }
+
+            return;
+        }
 
         instrument.SequenceDelay = 0;
         instrument.SequenceStartTick = 0;
@@ -88,17 +119,39 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
             return;
 
         instrument.Renderer.TrackingEntity = uid;
+
+        instrument.Renderer.FilteredChannels.SetAll(false);
+        instrument.Renderer.FilteredChannels.Or(instrument.FilteredChannels);
+
         instrument.Renderer.DisablePercussionChannel = !instrument.AllowPercussion;
         instrument.Renderer.DisableProgramChangeEvent = !instrument.AllowProgramChange;
 
+        for (int i = 0; i < RobustMidiEvent.MaxChannels; i++)
+        {
+            if(instrument.FilteredChannels[i])
+                instrument.Renderer.SendMidiEvent(RobustMidiEvent.AllNotesOff((byte)i, 0));
+        }
+
         if (!instrument.AllowProgramChange)
         {
             instrument.Renderer.MidiBank = instrument.InstrumentBank;
             instrument.Renderer.MidiProgram = instrument.InstrumentProgram;
         }
 
+        UpdateRendererMaster(instrument);
+
         instrument.Renderer.LoopMidi = instrument.LoopMidi;
-        instrument.DirtyRenderer = false;
+    }
+
+    private void UpdateRendererMaster(InstrumentComponent instrument)
+    {
+        if (instrument.Renderer == null || instrument.Master == null)
+            return;
+
+        if (!TryComp(instrument.Master, out InstrumentComponent? masterInstrument) || masterInstrument.Renderer == null)
+            return;
+
+        instrument.Renderer.Master = masterInstrument.Renderer;
     }
 
     public override void EndRenderer(EntityUid uid, bool fromStateChange, SharedInstrumentComponent? component = null)
@@ -121,7 +174,8 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
             return;
         }
 
-        instrument.Renderer?.StopAllNotes();
+        instrument.Renderer?.SystemReset();
+        instrument.Renderer?.ClearAllEvents();
 
         var renderer = instrument.Renderer;
 
@@ -162,13 +216,14 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
 
         SetupRenderer(uid, false, instrument);
 
-        if (instrument.Renderer != null && instrument.Renderer.OpenInput())
-        {
-            instrument.Renderer.OnMidiEvent += instrument.MidiEventBuffer.Add;
-            return true;
-        }
+        if (instrument.Renderer == null || !instrument.Renderer.OpenInput())
+            return false;
+
+        SetMaster(uid, null);
+        instrument.MidiEventBuffer.Clear();
+        instrument.Renderer.OnMidiEvent += instrument.MidiEventBuffer.Add;
+        return true;
 
-        return false;
     }
 
     public bool OpenMidi(EntityUid uid, ReadOnlySpan<byte> data, InstrumentComponent? instrument = null)
@@ -179,12 +234,10 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
         SetupRenderer(uid, false, instrument);
 
         if (instrument.Renderer == null || !instrument.Renderer.OpenMidi(data))
-        {
             return false;
-        }
 
+        SetMaster(uid, null);
         instrument.MidiEventBuffer.Clear();
-
         instrument.Renderer.OnMidiEvent += instrument.MidiEventBuffer.Add;
         return true;
     }
@@ -266,12 +319,24 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
 
         instrument.SequenceDelay = Math.Max(instrument.SequenceDelay, delta);
 
-        var currentTick = renderer.SequencerTick;
+        SendMidiEvents(midiEv.MidiEvent, instrument);
+    }
+
+    private void SendMidiEvents(IReadOnlyList<RobustMidiEvent> midiEvents, InstrumentComponent instrument)
+    {
+        if (instrument.Renderer == null)
+        {
+            Log.Warning($"Tried to send Midi events to an instrument without a renderer.");
+            return;
+        }
+
+        var currentTick = instrument.Renderer.SequencerTick;
 
         // ReSharper disable once ForCanBeConvertedToForeach
-        for (uint i = 0; i < midiEv.MidiEvent.Length; i++)
+        for (uint i = 0; i < midiEvents.Count; i++)
         {
-            var ev = midiEv.MidiEvent[i];
+            // I am surprised this doesn't take uint...
+            var ev = midiEvents[(int)i];
 
             var scheduled = ev.Tick + instrument.SequenceDelay;
 
@@ -306,12 +371,14 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
             return;
         }
 
-        foreach (var instrument in EntityManager.EntityQuery<InstrumentComponent>(true))
+        var query = EntityQueryEnumerator<InstrumentComponent>();
+        while (query.MoveNext(out var uid, out var instrument))
         {
-            if (instrument.DirtyRenderer && instrument.Renderer != null)
-                UpdateRenderer(instrument.Owner, instrument);
+            // For cases where the master renderer was not created yet.
+            if (instrument is { Renderer.Master: null, Master: not null })
+                UpdateRendererMaster(instrument);
 
-            if (!instrument.IsMidiOpen && !instrument.IsInputOpen)
+            if (instrument is { IsMidiOpen: false, IsInputOpen: false })
                 continue;
 
             var now = _gameTiming.RealTime;
@@ -323,10 +390,11 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
                 instrument.SentWithinASec = 0;
             }
 
-            if (instrument.MidiEventBuffer.Count == 0) continue;
+            if (instrument.MidiEventBuffer.Count == 0)
+                continue;
 
-            var max = instrument.RespectMidiLimits ?
-                Math.Min(MaxMidiEventsPerBatch, MaxMidiEventsPerSecond - instrument.SentWithinASec)
+            var max = instrument.RespectMidiLimits
+                ? Math.Min(MaxMidiEventsPerBatch, MaxMidiEventsPerSecond - instrument.SentWithinASec)
                 : instrument.MidiEventBuffer.Count;
 
             if (max <= 0)
@@ -357,7 +425,7 @@ public sealed class InstrumentSystem : SharedInstrumentSystem
             if (eventCount == 0)
                 continue;
 
-            RaiseNetworkEvent(new InstrumentMidiEventEvent(instrument.Owner, events));
+            RaiseNetworkEvent(new InstrumentMidiEventEvent(uid, events));
 
             instrument.SentWithinASec += eventCount;
 
diff --git a/Content.Client/Instruments/UI/BandMenu.xaml b/Content.Client/Instruments/UI/BandMenu.xaml
new file mode 100644
index 0000000000..620f38fa97
--- /dev/null
+++ b/Content.Client/Instruments/UI/BandMenu.xaml
@@ -0,0 +1,9 @@
+<DefaultWindow Title="{Loc 'instruments-component-band-menu'}" MinSize="250 350" xmlns="https://spacestation14.io"
+               xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client">
+    <BoxContainer Orientation="Vertical" Align="Center" HorizontalExpand="true" VerticalExpand="true">
+        <ItemList Name="BandList" SelectMode="Button" Margin="3 3 3 3"
+                  HorizontalExpand="true" VerticalExpand="true" SizeFlagsStretchRatio="8"/>
+        <Button Name="RefreshButton" Text="{Loc 'instrument-component-band-refresh'}" TextAlign="Center"
+                HorizontalExpand="true" Margin="5 5 5 5" SizeFlagsStretchRatio="1"/>
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/Instruments/UI/BandMenu.xaml.cs b/Content.Client/Instruments/UI/BandMenu.xaml.cs
new file mode 100644
index 0000000000..a225fcdfd6
--- /dev/null
+++ b/Content.Client/Instruments/UI/BandMenu.xaml.cs
@@ -0,0 +1,45 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Timing;
+
+namespace Content.Client.Instruments.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class BandMenu : DefaultWindow
+{
+    private readonly InstrumentBoundUserInterface _owner;
+
+    public BandMenu(InstrumentBoundUserInterface owner) : base()
+    {
+        RobustXamlLoader.Load(this);
+
+        _owner = owner;
+        BandList.OnItemSelected += OnItemSelected;
+        RefreshButton.OnPressed += OnRefreshPressed;
+    }
+
+    private void OnRefreshPressed(BaseButton.ButtonEventArgs obj)
+    {
+        _owner.RefreshBands();
+    }
+
+    private void OnItemSelected(ItemList.ItemListSelectedEventArgs args)
+    {
+        _owner.Instruments.SetMaster(_owner.Owner, (EntityUid)args.ItemList[args.ItemIndex].Metadata!);
+        BandList.Clear();
+        Timer.Spawn(0, Close);
+    }
+
+    public void Populate((EntityUid, string)[] nearby)
+    {
+        BandList.Clear();
+
+        foreach (var (uid, name) in nearby)
+        {
+            var item = BandList.AddItem(name, null, true, uid);
+            item.Selected = _owner.Instrument?.Master == uid;
+        }
+    }
+}
diff --git a/Content.Client/Instruments/UI/ChannelsMenu.xaml b/Content.Client/Instruments/UI/ChannelsMenu.xaml
new file mode 100644
index 0000000000..1bf4647609
--- /dev/null
+++ b/Content.Client/Instruments/UI/ChannelsMenu.xaml
@@ -0,0 +1,11 @@
+<DefaultWindow Title="{Loc 'instruments-component-channels-menu'}" MinSize="250 350" xmlns="https://spacestation14.io"
+               xmlns:gfx="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client">
+    <BoxContainer Orientation="Vertical" HorizontalExpand="true" VerticalExpand="true" Align="Center">
+        <ItemList Name="ChannelList" SelectMode="Multiple" Margin="3 3 3 3" HorizontalExpand="true" VerticalExpand="true" SizeFlagsStretchRatio="8"/>
+        <BoxContainer Orientation="Horizontal" HorizontalExpand="true" VerticalExpand="true" Align="Center"
+                      SizeFlagsStretchRatio="1">
+            <Button Name="AllButton" Text="{Loc 'instruments-component-channels-all-button'}" HorizontalExpand="true" VerticalExpand="true" SizeFlagsStretchRatio="1"/>
+            <Button Name="ClearButton" Text="{Loc 'instruments-component-channels-clear-button'}" HorizontalExpand="true" VerticalExpand="true" SizeFlagsStretchRatio="1"/>
+        </BoxContainer>
+    </BoxContainer>
+</DefaultWindow>
diff --git a/Content.Client/Instruments/UI/ChannelsMenu.xaml.cs b/Content.Client/Instruments/UI/ChannelsMenu.xaml.cs
new file mode 100644
index 0000000000..2814d41536
--- /dev/null
+++ b/Content.Client/Instruments/UI/ChannelsMenu.xaml.cs
@@ -0,0 +1,66 @@
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Audio.Midi;
+using Robust.Shared.Timing;
+
+namespace Content.Client.Instruments.UI;
+
+[GenerateTypedNameReferences]
+public sealed partial class ChannelsMenu : DefaultWindow
+{
+    private readonly InstrumentBoundUserInterface _owner;
+
+    public ChannelsMenu(InstrumentBoundUserInterface owner) : base()
+    {
+        RobustXamlLoader.Load(this);
+        _owner = owner;
+
+        ChannelList.OnItemSelected += OnItemSelected;
+        ChannelList.OnItemDeselected += OnItemDeselected;
+        AllButton.OnPressed += OnAllPressed;
+        ClearButton.OnPressed += OnClearPressed;
+    }
+
+    private void OnItemSelected(ItemList.ItemListSelectedEventArgs args)
+    {
+        _owner.Instruments.SetFilteredChannel(_owner.Owner, (int)ChannelList[args.ItemIndex].Metadata!, false);
+    }
+
+    private void OnItemDeselected(ItemList.ItemListDeselectedEventArgs args)
+    {
+        _owner.Instruments.SetFilteredChannel(_owner.Owner, (int)ChannelList[args.ItemIndex].Metadata!, true);
+    }
+
+    private void OnAllPressed(BaseButton.ButtonEventArgs obj)
+    {
+        foreach (var item in ChannelList)
+        {
+            // TODO: Make this efficient jfc
+            item.Selected = true;
+        }
+    }
+
+    private void OnClearPressed(BaseButton.ButtonEventArgs obj)
+    {
+        foreach (var item in ChannelList)
+        {
+            // TODO: Make this efficient jfc
+            item.Selected = false;
+        }
+    }
+
+    public void Populate()
+    {
+        ChannelList.Clear();
+
+        for (int i = 0; i < RobustMidiEvent.MaxChannels; i++)
+        {
+            var item = ChannelList.AddItem(_owner.Loc.GetString("instrument-component-channel-name",
+                ("number", i)), null, true, i);
+
+            item.Selected = !_owner.Instrument?.FilteredChannels[i] ?? false;
+        }
+    }
+}
diff --git a/Content.Client/Instruments/UI/InstrumentBoundUserInterface.cs b/Content.Client/Instruments/UI/InstrumentBoundUserInterface.cs
index 630345418e..23611c3fda 100644
--- a/Content.Client/Instruments/UI/InstrumentBoundUserInterface.cs
+++ b/Content.Client/Instruments/UI/InstrumentBoundUserInterface.cs
@@ -1,22 +1,56 @@
+using Content.Shared.ActionBlocker;
+using Content.Shared.Instruments.UI;
+using Content.Shared.Interaction;
+using Robust.Client.Audio.Midi;
 using Robust.Client.GameObjects;
+using Robust.Client.Player;
+using Robust.Client.UserInterface;
 
 namespace Content.Client.Instruments.UI
 {
     public sealed class InstrumentBoundUserInterface : BoundUserInterface
     {
-        [ViewVariables]
-        private InstrumentMenu? _instrumentMenu;
+        [Dependency] public readonly IEntityManager Entities = default!;
+        [Dependency] public readonly IMidiManager MidiManager = default!;
+        [Dependency] public readonly IFileDialogManager FileDialogManager = default!;
+        [Dependency] public readonly IPlayerManager PlayerManager = default!;
+        [Dependency] public readonly ILocalizationManager Loc = default!;
 
-        [ViewVariables]
-        public InstrumentComponent? Instrument { get; set; }
+        public readonly InstrumentSystem Instruments = default!;
+        public readonly ActionBlockerSystem ActionBlocker = default!;
+        public readonly SharedInteractionSystem Interactions = default!;
+
+        [ViewVariables] private InstrumentMenu? _instrumentMenu;
+        [ViewVariables] private BandMenu? _bandMenu;
+        [ViewVariables] private ChannelsMenu? _channelsMenu;
+
+        [ViewVariables] public InstrumentComponent? Instrument { get; private set; }
 
         public InstrumentBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
         {
+            IoCManager.InjectDependencies(this);
+
+            Instruments = Entities.System<InstrumentSystem>();
+            ActionBlocker = Entities.System<ActionBlockerSystem>();
+            Interactions = Entities.System<SharedInteractionSystem>();
+        }
+
+        protected override void ReceiveMessage(BoundUserInterfaceMessage message)
+        {
+            switch (message)
+            {
+                case InstrumentBandResponseBuiMessage bandRx:
+                    _bandMenu?.Populate(bandRx.Nearby);
+                    break;
+                default:
+                    break;
+            }
         }
 
         protected override void Open()
         {
-            if (!EntMan.TryGetComponent<InstrumentComponent?>(Owner, out var instrument)) return;
+            if (!EntMan.TryGetComponent<InstrumentComponent?>(Owner, out var instrument))
+                return;
 
             Instrument = instrument;
             _instrumentMenu = new InstrumentMenu(this);
@@ -28,8 +62,45 @@ namespace Content.Client.Instruments.UI
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
-            if (!disposing) return;
+            if (!disposing)
+                return;
             _instrumentMenu?.Dispose();
+            _bandMenu?.Dispose();
+            _channelsMenu?.Dispose();
+        }
+
+        public void RefreshBands()
+        {
+            SendMessage(new InstrumentBandRequestBuiMessage());
+        }
+
+        public void OpenBandMenu()
+        {
+            _bandMenu ??= new BandMenu(this);
+
+            // Refresh cache...
+            RefreshBands();
+
+            _bandMenu.OpenCenteredLeft();
+        }
+
+        public void CloseBandMenu()
+        {
+            if(_bandMenu?.IsOpen ?? false)
+                _bandMenu.Close();
+        }
+
+        public void OpenChannelsMenu()
+        {
+            _channelsMenu ??= new ChannelsMenu(this);
+            _channelsMenu.Populate();
+            _channelsMenu.OpenCenteredRight();
+        }
+
+        public void CloseChannelsMenu()
+        {
+            if(_channelsMenu?.IsOpen ?? false)
+                _channelsMenu.Close();
         }
     }
 }
diff --git a/Content.Client/Instruments/UI/InstrumentMenu.xaml b/Content.Client/Instruments/UI/InstrumentMenu.xaml
index e90864f50c..691e3ce502 100644
--- a/Content.Client/Instruments/UI/InstrumentMenu.xaml
+++ b/Content.Client/Instruments/UI/InstrumentMenu.xaml
@@ -4,14 +4,20 @@
         <BoxContainer Orientation="Horizontal" VerticalExpand="True">
             <Button Name="InputButton" ToggleMode="True" Text="{Loc 'instruments-component-menu-input-button'}" TextAlign="Center"
                     HorizontalExpand="True" SizeFlagsStretchRatio="1" />
-            <Control HorizontalExpand="True" SizeFlagsStretchRatio="2" />
+            <Control HorizontalExpand="True" SizeFlagsStretchRatio="0.5" />
+            <Button Name="BandButton" Text="{Loc 'instruments-component-menu-band-button'}" TextAlign="Center" HorizontalExpand="True"
+                    SizeFlagsStretchRatio="1"/>
+            <Control HorizontalExpand="True" SizeFlagsStretchRatio="0.5" />
             <Button Name="FileButton" Text="{Loc 'instruments-component-menu-play-button'}" TextAlign="Center" HorizontalExpand="True"
                     SizeFlagsStretchRatio="1" />
         </BoxContainer>
         <BoxContainer Orientation="Horizontal" VerticalExpand="True">
             <Button Name="LoopButton" ToggleMode="True" Text="{Loc 'instruments-component-menu-loop-button'}" TextAlign="Center" HorizontalExpand="True"
                     SizeFlagsStretchRatio="1" />
-            <Control HorizontalExpand="True" SizeFlagsStretchRatio="2" />
+            <Control HorizontalExpand="True" SizeFlagsStretchRatio="0.5" />
+            <Button Name="ChannelsButton" Text="{Loc 'instruments-component-menu-channels-button'}" TextAlign="Center" HorizontalExpand="True"
+                    SizeFlagsStretchRatio="1"/>
+            <Control HorizontalExpand="True" SizeFlagsStretchRatio="0.5" />
             <Button Name="StopButton" Text="{Loc 'instruments-component-menu-stop-button'}" TextAlign="Center" HorizontalExpand="True"
                     SizeFlagsStretchRatio="1" />
         </BoxContainer>
diff --git a/Content.Client/Instruments/UI/InstrumentMenu.xaml.cs b/Content.Client/Instruments/UI/InstrumentMenu.xaml.cs
index d0901315ae..b50ab96251 100644
--- a/Content.Client/Instruments/UI/InstrumentMenu.xaml.cs
+++ b/Content.Client/Instruments/UI/InstrumentMenu.xaml.cs
@@ -1,20 +1,12 @@
-using System;
 using System.IO;
 using System.Numerics;
 using System.Threading.Tasks;
-using Content.Client.Interactable;
-using Content.Shared.ActionBlocker;
-using Content.Shared.Interaction;
-using Robust.Client.Audio.Midi;
 using Robust.Client.AutoGenerated;
-using Robust.Client.Player;
 using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
 using Robust.Shared.Containers;
-using Robust.Shared.GameObjects;
 using Robust.Shared.Input;
-using Robust.Shared.IoC;
 using Robust.Shared.Timing;
 using static Robust.Client.UserInterface.Controls.BaseButton;
 using Range = Robust.Client.UserInterface.Controls.Range;
@@ -24,29 +16,26 @@ namespace Content.Client.Instruments.UI
     [GenerateTypedNameReferences]
     public sealed partial class InstrumentMenu : DefaultWindow
     {
-        [Dependency] private readonly IMidiManager _midiManager = default!;
-        [Dependency] private readonly IFileDialogManager _fileDialogManager = default!;
-
         private readonly InstrumentBoundUserInterface _owner;
 
         public InstrumentMenu(InstrumentBoundUserInterface owner)
         {
             RobustXamlLoader.Load(this);
-            IoCManager.InjectDependencies(this);
 
             _owner = owner;
 
             if (_owner.Instrument != null)
             {
                 _owner.Instrument.OnMidiPlaybackEnded += InstrumentOnMidiPlaybackEnded;
-                Title = IoCManager.Resolve<IEntityManager>().GetComponent<MetaDataComponent>(_owner.Instrument.Owner).EntityName;
+                Title = _owner.Entities.GetComponent<MetaDataComponent>(_owner.Owner).EntityName;
                 LoopButton.Disabled = !_owner.Instrument.IsMidiOpen;
                 LoopButton.Pressed = _owner.Instrument.LoopMidi;
+                ChannelsButton.Disabled = !_owner.Instrument.IsRendererAlive;
                 StopButton.Disabled = !_owner.Instrument.IsMidiOpen;
                 PlaybackSlider.MouseFilter = _owner.Instrument.IsMidiOpen ? MouseFilterMode.Pass : MouseFilterMode.Ignore;
             }
 
-            if (!_midiManager.IsAvailable)
+            if (!_owner.MidiManager.IsAvailable)
             {
                 UnavailableOverlay.Visible = true;
                 // We return early as to not give the buttons behavior.
@@ -54,8 +43,11 @@ namespace Content.Client.Instruments.UI
             }
 
             InputButton.OnToggled += MidiInputButtonOnOnToggled;
+            BandButton.OnPressed += BandButtonOnPressed;
+            BandButton.OnToggled += BandButtonOnToggled;
             FileButton.OnPressed += MidiFileButtonOnOnPressed;
             LoopButton.OnToggled += MidiLoopButtonOnOnToggled;
+            ChannelsButton.OnPressed += ChannelsButtonOnPressed;
             StopButton.OnPressed += MidiStopButtonOnPressed;
             PlaybackSlider.OnValueChanged += PlaybackSliderSeek;
             PlaybackSlider.OnKeyBindUp += PlaybackSliderKeyUp;
@@ -63,6 +55,27 @@ namespace Content.Client.Instruments.UI
             MinSize = SetSize = new Vector2(400, 150);
         }
 
+        private void BandButtonOnPressed(ButtonEventArgs obj)
+        {
+            if (!PlayCheck())
+                return;
+
+            _owner.OpenBandMenu();
+        }
+
+        private void BandButtonOnToggled(ButtonToggledEventArgs obj)
+        {
+            if (obj.Pressed)
+                return;
+
+            _owner.Instruments.SetMaster(_owner.Owner, null);
+        }
+
+        private void ChannelsButtonOnPressed(ButtonEventArgs obj)
+        {
+            _owner.OpenChannelsMenu();
+        }
+
         private void InstrumentOnMidiPlaybackEnded()
         {
             MidiPlaybackSetButtonsDisabled(true);
@@ -70,6 +83,9 @@ namespace Content.Client.Instruments.UI
 
         public void MidiPlaybackSetButtonsDisabled(bool disabled)
         {
+            if(disabled)
+                _owner.CloseChannelsMenu();
+
             LoopButton.Disabled = disabled;
             StopButton.Disabled = disabled;
 
@@ -79,8 +95,10 @@ namespace Content.Client.Instruments.UI
 
         private async void MidiFileButtonOnOnPressed(ButtonEventArgs obj)
         {
+            _owner.CloseBandMenu();
+
             var filters = new FileDialogFilters(new FileDialogFilters.Group("mid", "midi"));
-            await using var file = await _fileDialogManager.OpenFile(filters);
+            await using var file = await _owner.FileDialogManager.OpenFile(filters);
 
             // did the instrument menu get closed while waiting for the user to select a file?
             if (Disposed)
@@ -89,7 +107,8 @@ namespace Content.Client.Instruments.UI
             // The following checks are only in place to prevent players from playing MIDI songs locally.
             // There are equivalents for these checks on the server.
 
-            if (file == null) return;
+            if (file == null)
+                return;
 
             /*if (!_midiManager.IsMidiFile(filename))
             {
@@ -107,7 +126,7 @@ namespace Content.Client.Instruments.UI
             await Task.WhenAll(Timer.Delay(100), file.CopyToAsync(memStream));
 
             if (_owner.Instrument is not {} instrument
-                || !EntitySystem.Get<InstrumentSystem>().OpenMidi(instrument.Owner, memStream.GetBuffer().AsSpan(0, (int) memStream.Length), instrument))
+                || !_owner.Instruments.OpenMidi(_owner.Owner, memStream.GetBuffer().AsSpan(0, (int) memStream.Length), instrument))
                 return;
 
             MidiPlaybackSetButtonsDisabled(false);
@@ -117,7 +136,7 @@ namespace Content.Client.Instruments.UI
 
         private void MidiInputButtonOnOnToggled(ButtonToggledEventArgs obj)
         {
-            var instrumentSystem = EntitySystem.Get<InstrumentSystem>();
+            _owner.CloseBandMenu();
 
             if (obj.Pressed)
             {
@@ -126,55 +145,58 @@ namespace Content.Client.Instruments.UI
 
                 MidiStopButtonOnPressed(null);
                 if(_owner.Instrument is {} instrument)
-                    instrumentSystem.OpenInput(instrument.Owner, instrument);
+                    _owner.Instruments.OpenInput(_owner.Owner, instrument);
+            }
+            else if (_owner.Instrument is { } instrument)
+            {
+                _owner.Instruments.CloseInput(_owner.Owner, false, instrument);
+                _owner.CloseChannelsMenu();
             }
-            else  if(_owner.Instrument is {} instrument)
-                instrumentSystem.CloseInput(instrument.Owner, false, instrument);
         }
 
         private bool PlayCheck()
         {
             // TODO all of these checks should also be done server-side.
 
-            var instrumentEnt = _owner.Instrument?.Owner;
+            var instrumentEnt = _owner.Owner;
             var instrument = _owner.Instrument;
 
-            // If either the entity or component are null, return.
-            if (instrumentEnt == null || instrument == null)
+            if (instrument == null)
                 return false;
 
-            var localPlayer = IoCManager.Resolve<IPlayerManager>().LocalPlayer;
+            var localPlayer = _owner.PlayerManager.LocalPlayer;
 
             // If we don't have a player or controlled entity, we return.
-            if (localPlayer?.ControlledEntity == null) return false;
+            if (localPlayer?.ControlledEntity == null)
+                return false;
 
             // By default, allow an instrument to play itself and skip all other checks
             if (localPlayer.ControlledEntity == instrumentEnt)
                 return true;
 
             // If we're a handheld instrument, we might be in a container. Get it just in case.
-            instrumentEnt.Value.TryGetContainerMan(out var conMan);
+            instrumentEnt.TryGetContainerMan(out var conMan);
 
             // If the instrument is handheld and we're not holding it, we return.
-            if ((instrument.Handheld && (conMan == null
-                                         || conMan.Owner != localPlayer.ControlledEntity))) return false;
+            if ((instrument.Handheld && (conMan == null || conMan.Owner != localPlayer.ControlledEntity)))
+                return false;
 
-            var entSysMan = IoCManager.Resolve<IEntitySystemManager>();
-            if (!entSysMan.GetEntitySystem<ActionBlockerSystem>().CanInteract(localPlayer.ControlledEntity.Value, instrumentEnt))
+            if (!_owner.ActionBlocker.CanInteract(localPlayer.ControlledEntity.Value, instrumentEnt))
                 return false;
 
             // We check that we're in range unobstructed just in case.
-            return entSysMan.GetEntitySystem<SharedInteractionSystem>().InRangeUnobstructed(localPlayer.ControlledEntity.Value, instrumentEnt.Value);
+            return _owner.Interactions.InRangeUnobstructed(localPlayer.ControlledEntity.Value, instrumentEnt);
         }
 
         private void MidiStopButtonOnPressed(ButtonEventArgs? obj)
         {
             MidiPlaybackSetButtonsDisabled(true);
 
-            if (_owner.Instrument is not { } instrument)
+            if (_owner.Instrument is not {} instrument)
                 return;
 
-            EntitySystem.Get<InstrumentSystem>().CloseMidi(instrument.Owner, false, instrument);
+            _owner.Instruments.CloseMidi(_owner.Owner, false, instrument);
+            _owner.CloseChannelsMenu();
         }
 
         private void MidiLoopButtonOnOnToggled(ButtonToggledEventArgs obj)
@@ -183,29 +205,45 @@ namespace Content.Client.Instruments.UI
                 return;
 
             _owner.Instrument.LoopMidi = obj.Pressed;
-            _owner.Instrument.DirtyRenderer = true;
+            _owner.Instruments.UpdateRenderer(_owner.Owner, _owner.Instrument);
         }
 
         private void PlaybackSliderSeek(Range _)
         {
             // Do not seek while still grabbing.
-            if (PlaybackSlider.Grabbed || _owner.Instrument is not {} instrument) return;
+            if (PlaybackSlider.Grabbed || _owner.Instrument is not {} instrument)
+                return;
 
-            EntitySystem.Get<InstrumentSystem>().SetPlayerTick(instrument.Owner, (int)Math.Ceiling(PlaybackSlider.Value), instrument);
+            _owner.Instruments.SetPlayerTick(_owner.Owner, (int)Math.Ceiling(PlaybackSlider.Value), instrument);
         }
 
         private void PlaybackSliderKeyUp(GUIBoundKeyEventArgs args)
         {
-            if (args.Function != EngineKeyFunctions.UIClick || _owner.Instrument is not {} instrument) return;
+            if (args.Function != EngineKeyFunctions.UIClick || _owner.Instrument is not {} instrument)
+                return;
 
-            EntitySystem.Get<InstrumentSystem>().SetPlayerTick(instrument.Owner, (int)Math.Ceiling(PlaybackSlider.Value), instrument);
+            _owner.Instruments.SetPlayerTick(_owner.Owner, (int)Math.Ceiling(PlaybackSlider.Value), instrument);
+        }
+
+        public override void Close()
+        {
+            base.Close();
+            _owner.CloseBandMenu();
+            _owner.CloseChannelsMenu();
         }
 
         protected override void FrameUpdate(FrameEventArgs args)
         {
             base.FrameUpdate(args);
 
-            if (_owner.Instrument == null) return;
+            if (_owner.Instrument == null)
+                return;
+
+            var hasMaster = _owner.Instrument.Master != null;
+            BandButton.ToggleMode = hasMaster;
+            BandButton.Pressed = hasMaster;
+            BandButton.Disabled = _owner.Instrument.IsMidiOpen || _owner.Instrument.IsInputOpen;
+            ChannelsButton.Disabled = !_owner.Instrument.IsRendererAlive;
 
             if (!_owner.Instrument.IsMidiOpen)
             {
@@ -214,7 +252,8 @@ namespace Content.Client.Instruments.UI
                 return;
             }
 
-            if (PlaybackSlider.Grabbed) return;
+            if (PlaybackSlider.Grabbed)
+                return;
 
             PlaybackSlider.MaxValue = _owner.Instrument.PlayerTotalTick;
             PlaybackSlider.SetValueWithoutEvent(_owner.Instrument.PlayerTick);
diff --git a/Content.Server/Instruments/InstrumentComponent.cs b/Content.Server/Instruments/InstrumentComponent.cs
index c1060c9248..fb56925095 100644
--- a/Content.Server/Instruments/InstrumentComponent.cs
+++ b/Content.Server/Instruments/InstrumentComponent.cs
@@ -10,20 +10,11 @@ public sealed class InstrumentComponent : SharedInstrumentComponent
 {
     [Dependency] private readonly IEntityManager _entMan = default!;
 
-    [ViewVariables]
-    public float Timer = 0f;
-
-    [ViewVariables]
-    public int BatchesDropped = 0;
-
-    [ViewVariables]
-    public int LaggedBatches = 0;
-
-    [ViewVariables]
-    public int MidiEventCount = 0;
-
-    [ViewVariables]
-    public uint LastSequencerTick = 0;
+    [ViewVariables] public float Timer = 0f;
+    [ViewVariables] public int BatchesDropped = 0;
+    [ViewVariables] public int LaggedBatches = 0;
+    [ViewVariables] public int MidiEventCount = 0;
+    [ViewVariables] public uint LastSequencerTick = 0;
 
     // TODO Instruments: Make this ECS
     public IPlayerSession? InstrumentPlayer =>
@@ -34,4 +25,6 @@ public sealed class InstrumentComponent : SharedInstrumentComponent
 }
 
 [RegisterComponent]
-public sealed class ActiveInstrumentComponent : Component {}
+public sealed class ActiveInstrumentComponent : Component
+{
+}
diff --git a/Content.Server/Instruments/InstrumentSystem.cs b/Content.Server/Instruments/InstrumentSystem.cs
index 31269c5dcd..2f27e5ff55 100644
--- a/Content.Server/Instruments/InstrumentSystem.cs
+++ b/Content.Server/Instruments/InstrumentSystem.cs
@@ -1,20 +1,44 @@
+using Content.Server.Administration;
+using Content.Server.Interaction;
+using Content.Server.Popups;
 using Content.Server.Stunnable;
-using Content.Server.UserInterface;
+using Content.Shared.Administration;
 using Content.Shared.Instruments;
+using Content.Shared.Instruments.UI;
+using Content.Shared.Interaction;
+using Content.Shared.Physics;
 using Content.Shared.Popups;
 using JetBrains.Annotations;
 using Robust.Server.GameObjects;
 using Robust.Server.Player;
+using Robust.Shared.Audio.Midi;
+using Robust.Shared.Collections;
 using Robust.Shared.Configuration;
+using Robust.Shared.Console;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 
 namespace Content.Server.Instruments;
 
 [UsedImplicitly]
 public sealed partial class InstrumentSystem : SharedInstrumentSystem
 {
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IConsoleHost _conHost = default!;
     [Dependency] private readonly IConfigurationManager _cfg = default!;
-    [Dependency] private readonly StunSystem _stunSystem = default!;
-    [Dependency] private readonly UserInterfaceSystem _userInterfaceSystem = default!;
+    [Dependency] private readonly StunSystem _stuns = default!;
+    [Dependency] private readonly UserInterfaceSystem _bui = default!;
+    [Dependency] private readonly PopupSystem _popup = default!;
+    [Dependency] private readonly TransformSystem _transform = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly InteractionSystem _interactions = default!;
+
+    private const float MaxInstrumentBandRange = 10f;
+
+    // Band Requests are queued and delayed both to avoid metagaming and to prevent spamming it, since it's expensive.
+    private const float BandRequestDelay = 1.0f;
+    private TimeSpan _bandRequestTimer = TimeSpan.Zero;
+    private readonly List<InstrumentBandRequestBuiMessage> _bandRequestQueue = new();
 
     public override void Initialize()
     {
@@ -25,30 +49,62 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
         SubscribeNetworkEvent<InstrumentMidiEventEvent>(OnMidiEventRx);
         SubscribeNetworkEvent<InstrumentStartMidiEvent>(OnMidiStart);
         SubscribeNetworkEvent<InstrumentStopMidiEvent>(OnMidiStop);
+        SubscribeNetworkEvent<InstrumentSetMasterEvent>(OnMidiSetMaster);
+        SubscribeNetworkEvent<InstrumentSetFilteredChannelEvent>(OnMidiSetFilteredChannel);
 
         SubscribeLocalEvent<InstrumentComponent, BoundUIClosedEvent>(OnBoundUIClosed);
         SubscribeLocalEvent<InstrumentComponent, BoundUIOpenedEvent>(OnBoundUIOpened);
+        SubscribeLocalEvent<InstrumentComponent, InstrumentBandRequestBuiMessage>(OnBoundUIRequestBands);
+
+        _conHost.RegisterCommand("addtoband", AddToBandCommand);
+    }
+
+    [AdminCommand(AdminFlags.Fun)]
+    private void AddToBandCommand(IConsoleShell shell, string _, string[] args)
+    {
+        if (!EntityUid.TryParse(args[0], out var firstUid))
+        {
+            shell.WriteError($"Cannot parse first Uid");
+            return;
+        }
+
+        if (!EntityUid.TryParse(args[1], out var secondUid))
+        {
+            shell.WriteError($"Cannot parse second Uid");
+            return;
+        }
+
+        if (!HasComp<ActiveInstrumentComponent>(secondUid))
+        {
+            shell.WriteError($"Puppet instrument is not active!");
+            return;
+        }
+
+        var otherInstrument = Comp<InstrumentComponent>(secondUid);
+        otherInstrument.Playing = true;
+        otherInstrument.Master = firstUid;
+        Dirty(secondUid, otherInstrument);
     }
 
     private void OnMidiStart(InstrumentStartMidiEvent msg, EntitySessionEventArgs args)
     {
         var uid = msg.Uid;
 
-        if (!EntityManager.TryGetComponent(uid, out InstrumentComponent? instrument))
+        if (!TryComp(uid, out InstrumentComponent? instrument))
             return;
 
         if (args.SenderSession != instrument.InstrumentPlayer)
             return;
 
         instrument.Playing = true;
-        instrument.Dirty();
+        Dirty(uid, instrument);
     }
 
     private void OnMidiStop(InstrumentStopMidiEvent msg, EntitySessionEventArgs args)
     {
         var uid = msg.Uid;
 
-        if (!EntityManager.TryGetComponent(uid, out InstrumentComponent? instrument))
+        if (!TryComp(uid, out InstrumentComponent? instrument))
             return;
 
         if (args.SenderSession != instrument.InstrumentPlayer)
@@ -57,6 +113,66 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
         Clean(uid, instrument);
     }
 
+    private void OnMidiSetMaster(InstrumentSetMasterEvent msg, EntitySessionEventArgs args)
+    {
+        var uid = msg.Uid;
+        var master = msg.Master;
+
+        if (!HasComp<ActiveInstrumentComponent>(uid))
+            return;
+
+        if (!TryComp(uid, out InstrumentComponent? instrument))
+            return;
+
+        if (args.SenderSession != instrument.InstrumentPlayer)
+            return;
+
+        if (master != null)
+        {
+            if (!HasComp<ActiveInstrumentComponent>(master))
+                return;
+
+            if (!TryComp<InstrumentComponent>(master, out var masterInstrument) || masterInstrument.Master != null)
+                return;
+
+            instrument.Master = master;
+            instrument.FilteredChannels.SetAll(false);
+            instrument.Playing = true;
+            Dirty(uid, instrument);
+            return;
+        }
+
+        // Cleanup when disabling master...
+        if (master == null && instrument.Master != null)
+        {
+            Clean(uid, instrument);
+        }
+    }
+
+    private void OnMidiSetFilteredChannel(InstrumentSetFilteredChannelEvent msg, EntitySessionEventArgs args)
+    {
+        var uid = msg.Uid;
+
+        if (!TryComp(uid, out InstrumentComponent? instrument))
+            return;
+
+        if (args.SenderSession != instrument.InstrumentPlayer)
+            return;
+
+        if (msg.Channel == RobustMidiEvent.PercussionChannel && !instrument.AllowPercussion)
+            return;
+
+        instrument.FilteredChannels[msg.Channel] = msg.Value;
+
+        if (msg.Value)
+        {
+            // Prevent stuck notes when turning off a channel... Shrimple.
+            RaiseNetworkEvent(new InstrumentMidiEventEvent(uid, new []{RobustMidiEvent.AllNotesOff((byte)msg.Channel, 0)}));
+        }
+
+        Dirty(uid, instrument);
+    }
+
     public override void Shutdown()
     {
         base.Shutdown();
@@ -70,7 +186,7 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
             return;
 
         if (HasComp<ActiveInstrumentComponent>(uid)
-            && _userInterfaceSystem.TryGetUi(uid, args.UiKey, out var bui)
+            && _bui.TryGetUi(uid, args.UiKey, out var bui)
             && bui.SubscribedSessions.Count == 0)
         {
             RemComp<ActiveInstrumentComponent>(uid);
@@ -88,6 +204,63 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
         Clean(uid, component);
     }
 
+    private void OnBoundUIRequestBands(EntityUid uid, InstrumentComponent component, InstrumentBandRequestBuiMessage args)
+    {
+        foreach (var request in _bandRequestQueue)
+        {
+            // Prevent spamming requests for the same entity.
+            if (request.Entity == args.Entity)
+                return;
+        }
+
+        _bandRequestQueue.Add(args);
+    }
+
+    public (EntityUid, string)[] GetBands(EntityUid uid)
+    {
+        var metadataQuery = EntityManager.GetEntityQuery<MetaDataComponent>();
+
+        if (Deleted(uid, metadataQuery))
+            return Array.Empty<(EntityUid, string)>();
+
+        var list = new ValueList<(EntityUid, string)>();
+        var instrumentQuery = EntityManager.GetEntityQuery<InstrumentComponent>();
+
+        if (!TryComp(uid, out InstrumentComponent? originInstrument)
+            || originInstrument.InstrumentPlayer?.AttachedEntity is not {} originPlayer)
+            return Array.Empty<(EntityUid, string)>();
+
+        // It's probably faster to get all possible active instruments than all entities in range
+        var activeEnumerator = EntityManager.EntityQueryEnumerator<ActiveInstrumentComponent>();
+        while (activeEnumerator.MoveNext(out var entity, out _))
+        {
+            if (entity == uid)
+                continue;
+
+            // Don't grab puppet instruments.
+            if (!instrumentQuery.TryGetComponent(entity, out var instrument) || instrument.Master != null)
+                continue;
+
+            // We want to use the instrument player's name.
+            if (instrument.InstrumentPlayer?.AttachedEntity is not {} playerUid)
+                continue;
+
+            // Maybe a bit expensive but oh well GetBands is queued and has a timer anyway.
+            // Make sure the instrument is visible, uses the Opaque collision group so this works across windows etc.
+            if (!_interactions.InRangeUnobstructed(uid, entity, MaxInstrumentBandRange,
+                    CollisionGroup.Opaque, e => e == playerUid || e == originPlayer))
+                continue;
+
+            if (!metadataQuery.TryGetComponent(playerUid, out var playerMetadata)
+                || !metadataQuery.TryGetComponent(entity, out var metadata))
+                continue;
+
+            list.Add((entity, $"{playerMetadata.EntityName} - {metadata.EntityName}"));
+        }
+
+        return list.ToArray();
+    }
+
     public void Clean(EntityUid uid, InstrumentComponent? instrument = null)
     {
         if (!Resolve(uid, ref instrument))
@@ -95,14 +268,19 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
 
         if (instrument.Playing)
         {
+            // Reset puppet instruments too.
+            RaiseNetworkEvent(new InstrumentMidiEventEvent(uid, new[]{RobustMidiEvent.SystemReset(0)}));
+
             RaiseNetworkEvent(new InstrumentStopMidiEvent(uid));
         }
 
         instrument.Playing = false;
+        instrument.Master = null;
+        instrument.FilteredChannels.SetAll(false);
         instrument.LastSequencerTick = 0;
         instrument.BatchesDropped = 0;
         instrument.LaggedBatches = 0;
-        instrument.Dirty();
+        Dirty(uid, instrument);
     }
 
     private void OnMidiEventRx(InstrumentMidiEventEvent msg, EntitySessionEventArgs args)
@@ -142,12 +320,13 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
             {
                 if (instrument.LaggedBatches == (int) (MaxMidiLaggedBatches * (1 / 3d) + 1))
                 {
-                    attached.PopupMessage(
-                        Loc.GetString("instrument-component-finger-cramps-light-message"));
-                } else if (instrument.LaggedBatches == (int) (MaxMidiLaggedBatches * (2 / 3d) + 1))
+                    _popup.PopupEntity(Loc.GetString("instrument-component-finger-cramps-light-message"),
+                        uid, attached, PopupType.SmallCaution);
+                }
+                else if (instrument.LaggedBatches == (int) (MaxMidiLaggedBatches * (2 / 3d) + 1))
                 {
-                    attached.PopupMessage(
-                        Loc.GetString("instrument-component-finger-cramps-serious-message"));
+                    _popup.PopupEntity(Loc.GetString("instrument-component-finger-cramps-serious-message"),
+                        uid, attached, PopupType.MediumCaution);
                 }
             }
 
@@ -165,24 +344,58 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
             send = false;
         }
 
+        instrument.LastSequencerTick = Math.Max(maxTick, minTick);
+
         if (send || !instrument.RespectMidiLimits)
         {
             RaiseNetworkEvent(msg);
         }
-
-        instrument.LastSequencerTick = Math.Max(maxTick, minTick);
     }
 
     public override void Update(float frameTime)
     {
         base.Update(frameTime);
 
-        foreach (var (_, instrument) in EntityManager.EntityQuery<ActiveInstrumentComponent, InstrumentComponent>(true))
+        if (_bandRequestQueue.Count > 0 && _bandRequestTimer < _timing.RealTime)
         {
-            if (instrument.DirtyRenderer)
+            _bandRequestTimer = _timing.RealTime.Add(TimeSpan.FromSeconds(BandRequestDelay));
+
+            foreach (var request in _bandRequestQueue)
             {
-                Dirty(instrument);
-                instrument.DirtyRenderer = false;
+                var nearby = GetBands(request.Entity);
+                _bui.TrySendUiMessage(request.Entity, request.UiKey, new InstrumentBandResponseBuiMessage(nearby),
+                    (IPlayerSession)request.Session);
+            }
+
+            _bandRequestQueue.Clear();
+        }
+
+        var activeQuery = EntityManager.GetEntityQuery<ActiveInstrumentComponent>();
+        var metadataQuery = EntityManager.GetEntityQuery<MetaDataComponent>();
+        var transformQuery = EntityManager.GetEntityQuery<TransformComponent>();
+
+        var query = AllEntityQuery<ActiveInstrumentComponent, InstrumentComponent>();
+        while (query.MoveNext(out var uid, out _, out var instrument))
+        {
+            if (instrument.Master is {} master)
+            {
+                if (Deleted(master, metadataQuery))
+                {
+                    Clean(uid, instrument);
+                }
+
+                var masterActive = activeQuery.CompOrNull(master);
+                if (masterActive == null)
+                {
+                    Clean(uid, instrument);
+                }
+
+                var trans = transformQuery.GetComponent(uid);
+                var masterTrans = transformQuery.GetComponent(master);
+                if (!masterTrans.Coordinates.InRange(EntityManager, _transform, trans.Coordinates, 10f))
+                {
+                    Clean(uid, instrument);
+                }
             }
 
             if (instrument.RespectMidiLimits &&
@@ -191,16 +404,17 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
             {
                 if (instrument.InstrumentPlayer?.AttachedEntity is {Valid: true} mob)
                 {
-                    _stunSystem.TryParalyze(mob, TimeSpan.FromSeconds(1), true);
+                    _stuns.TryParalyze(mob, TimeSpan.FromSeconds(1), true);
 
-                    instrument.Owner.PopupMessage(mob, Loc.GetString("instrument-component-finger-cramps-max-message"));
+                    _popup.PopupEntity(Loc.GetString("instrument-component-finger-cramps-max-message"),
+                        uid, mob, PopupType.LargeCaution);
                 }
 
                 // Just in case
-                Clean((instrument).Owner);
+                Clean(uid);
 
                 if (instrument.UserInterface is not null)
-                    _userInterfaceSystem.CloseAll(instrument.UserInterface);
+                    _bui.CloseAll(instrument.UserInterface);
             }
 
             instrument.Timer += frameTime;
@@ -219,7 +433,7 @@ public sealed partial class InstrumentSystem : SharedInstrumentSystem
         if (!Resolve(uid, ref component))
             return;
 
-        if (_userInterfaceSystem.TryGetUi(uid, InstrumentUiKey.Key, out var bui))
-            _userInterfaceSystem.ToggleUi(bui, session);
+        if (_bui.TryGetUi(uid, InstrumentUiKey.Key, out var bui))
+            _bui.ToggleUi(bui, session);
     }
 }
diff --git a/Content.Shared/Instruments/SharedInstrumentComponent.cs b/Content.Shared/Instruments/SharedInstrumentComponent.cs
index 6c4435e759..61a3d28f46 100644
--- a/Content.Shared/Instruments/SharedInstrumentComponent.cs
+++ b/Content.Shared/Instruments/SharedInstrumentComponent.cs
@@ -1,33 +1,38 @@
+using System.Collections;
 using Robust.Shared.Audio.Midi;
 using Robust.Shared.GameStates;
 using Robust.Shared.Serialization;
 
 namespace Content.Shared.Instruments;
 
-[NetworkedComponent, Access(typeof(SharedInstrumentSystem))]
-public abstract class SharedInstrumentComponent : Component
+[NetworkedComponent]
+[AutoGenerateComponentState(true)]
+[Access(typeof(SharedInstrumentSystem))]
+public abstract partial class SharedInstrumentComponent : Component
 {
-    [ViewVariables]
+    [ViewVariables, AutoNetworkedField]
     public bool Playing { get; set; }
 
-    [DataField("program"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField("program"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
     public byte InstrumentProgram { get; set; }
 
-    [DataField("bank"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField("bank"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
     public byte InstrumentBank { get; set; }
 
-    [DataField("allowPercussion"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField("allowPercussion"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
     public bool AllowPercussion { get; set; }
 
-    [DataField("allowProgramChange"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField("allowProgramChange"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
     public bool AllowProgramChange { get ; set; }
 
-    [DataField("respectMidiLimits"), ViewVariables(VVAccess.ReadWrite)]
+    [DataField("respectMidiLimits"), ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
     public bool RespectMidiLimits { get; set; } = true;
 
-    [ViewVariables(VVAccess.ReadWrite)]
-    [Access(typeof(SharedInstrumentSystem), Other = AccessPermissions.ReadWrite)] // FIXME Friends
-    public bool DirtyRenderer { get; set; }
+    [ViewVariables(VVAccess.ReadWrite), AutoNetworkedField]
+    public EntityUid? Master { get; set; } = null;
+
+    [ViewVariables, AutoNetworkedField]
+    public BitArray FilteredChannels { get; set; } = new(RobustMidiEvent.MaxChannels, true);
 }
 
 
@@ -45,6 +50,40 @@ public sealed class InstrumentStopMidiEvent : EntityEventArgs
     }
 }
 
+/// <summary>
+///     Send from the client to the server to set a master instrument.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class InstrumentSetMasterEvent : EntityEventArgs
+{
+    public EntityUid Uid { get; }
+    public EntityUid? Master { get; }
+
+    public InstrumentSetMasterEvent(EntityUid uid, EntityUid? master)
+    {
+        Uid = uid;
+        Master = master;
+    }
+}
+
+/// <summary>
+///     Send from the client to the server to set a master instrument channel.
+/// </summary>
+[Serializable, NetSerializable]
+public sealed class InstrumentSetFilteredChannelEvent : EntityEventArgs
+{
+    public EntityUid Uid { get; }
+    public int Channel { get; }
+    public bool Value { get; }
+
+    public InstrumentSetFilteredChannelEvent(EntityUid uid, int channel, bool value)
+    {
+        Uid = uid;
+        Channel = channel;
+        Value = value;
+    }
+}
+
 /// <summary>
 ///     This message is sent to the client to start the synth.
 /// </summary>
@@ -75,27 +114,6 @@ public sealed class InstrumentMidiEventEvent : EntityEventArgs
     }
 }
 
-[Serializable, NetSerializable]
-public sealed class InstrumentState : ComponentState
-{
-    public bool Playing { get; }
-    public byte InstrumentProgram { get; }
-    public byte InstrumentBank { get; }
-    public bool AllowPercussion { get; }
-    public bool AllowProgramChange { get; }
-    public bool RespectMidiLimits { get; }
-
-    public InstrumentState(bool playing, byte instrumentProgram, byte instrumentBank, bool allowPercussion, bool allowProgramChange, bool respectMidiLimits)
-    {
-        Playing = playing;
-        InstrumentProgram = instrumentProgram;
-        InstrumentBank = instrumentBank;
-        AllowPercussion = allowPercussion;
-        AllowProgramChange = allowProgramChange;
-        RespectMidiLimits = respectMidiLimits;
-    }
-}
-
 [NetSerializable, Serializable]
 public enum InstrumentUiKey
 {
diff --git a/Content.Shared/Instruments/SharedInstrumentSystem.cs b/Content.Shared/Instruments/SharedInstrumentSystem.cs
index cdfc7506a0..a2a7425a5b 100644
--- a/Content.Shared/Instruments/SharedInstrumentSystem.cs
+++ b/Content.Shared/Instruments/SharedInstrumentSystem.cs
@@ -1,57 +1,32 @@
-using Robust.Shared.GameStates;
-
 namespace Content.Shared.Instruments;
 
 public abstract class SharedInstrumentSystem : EntitySystem
 {
     public override void Initialize()
     {
-        base.Initialize();
-
-        SubscribeLocalEvent<SharedInstrumentComponent, ComponentGetState>(OnGetState);
-        SubscribeLocalEvent<SharedInstrumentComponent, ComponentHandleState>(OnHandleState);
+        SubscribeLocalEvent<SharedInstrumentComponent, AfterAutoHandleStateEvent>(AfterHandleInstrumentState);
     }
 
     public virtual void SetupRenderer(EntityUid uid, bool fromStateChange, SharedInstrumentComponent? instrument = null)
-    { }
+    {
+    }
 
     public virtual void EndRenderer(EntityUid uid, bool fromStateChange, SharedInstrumentComponent? instrument = null)
-    { }
+    {
+    }
 
     public void SetInstrumentProgram(SharedInstrumentComponent component, byte program, byte bank)
     {
         component.InstrumentBank = bank;
         component.InstrumentProgram = program;
-        component.DirtyRenderer = true;
         Dirty(component);
     }
 
-    private void OnGetState(EntityUid uid, SharedInstrumentComponent instrument, ref ComponentGetState args)
+    private void AfterHandleInstrumentState(EntityUid uid, SharedInstrumentComponent instrument, ref AfterAutoHandleStateEvent args)
     {
-        args.State =
-            new InstrumentState(instrument.Playing, instrument.InstrumentProgram, instrument.InstrumentBank,
-                instrument.AllowPercussion, instrument.AllowProgramChange, instrument.RespectMidiLimits);
-    }
-
-    private void OnHandleState(EntityUid uid, SharedInstrumentComponent instrument, ref ComponentHandleState args)
-    {
-        if (args.Current is not InstrumentState state)
-            return;
-
-        if (state.Playing)
-        {
+        if(instrument.Playing)
             SetupRenderer(uid, true, instrument);
-        }
         else
-        {
             EndRenderer(uid, true, instrument);
-        }
-
-        instrument.Playing = state.Playing;
-        instrument.AllowPercussion = state.AllowPercussion;
-        instrument.AllowProgramChange = state.AllowProgramChange;
-        instrument.InstrumentBank = state.InstrumentBank;
-        instrument.InstrumentProgram = state.InstrumentProgram;
-        instrument.DirtyRenderer = true;
     }
 }
diff --git a/Content.Shared/Instruments/UI/InstrumentBoundUserInterfaceMessages.cs b/Content.Shared/Instruments/UI/InstrumentBoundUserInterfaceMessages.cs
new file mode 100644
index 0000000000..47471b0e22
--- /dev/null
+++ b/Content.Shared/Instruments/UI/InstrumentBoundUserInterfaceMessages.cs
@@ -0,0 +1,19 @@
+using Robust.Shared.Serialization;
+
+namespace Content.Shared.Instruments.UI;
+
+[Serializable, NetSerializable]
+public sealed class InstrumentBandRequestBuiMessage : BoundUserInterfaceMessage
+{
+}
+
+[Serializable, NetSerializable]
+public sealed class InstrumentBandResponseBuiMessage : BoundUserInterfaceMessage
+{
+    public (EntityUid, string)[] Nearby { get; set; }
+
+    public InstrumentBandResponseBuiMessage((EntityUid, string)[] nearby)
+    {
+        Nearby = nearby;
+    }
+}
diff --git a/Resources/Locale/en-US/instruments/instruments-component.ftl b/Resources/Locale/en-US/instruments/instruments-component.ftl
index ed64a4b0c7..f0e0c1b3a9 100644
--- a/Resources/Locale/en-US/instruments/instruments-component.ftl
+++ b/Resources/Locale/en-US/instruments/instruments-component.ftl
@@ -8,9 +8,17 @@ instruments-component-menu-no-midi-support = MIDI support is currently not
                                              FluidSynth or a development package
                                              for FluidSynth.
 instruments-component-menu-input-button = MIDI Input
-instruments-component-menu-play-button = Play MIDI File
+instruments-component-menu-band-button = Join Band
+instruments-component-menu-play-button = Play MIDI
 instruments-component-menu-loop-button = Loop
+instruments-component-menu-channels-button = Channels
 instruments-component-menu-stop-button = Stop
+instruments-component-band-menu = Choose band leader
+instrument-component-band-refresh = Refresh
+instruments-component-channels-menu = MIDI Channel Selection
+instrument-component-channel-name = MIDI Channel {$number}
+instruments-component-channels-all-button = All
+instruments-component-channels-clear-button = Clear
 
 # SwappableInstrumentComponent
 swappable-instrument-component-style-set = Style set to "{$style}"
diff --git a/RobustToolbox b/RobustToolbox
index 8eae802fb6..aa52e8c2ef 160000
--- a/RobustToolbox
+++ b/RobustToolbox
@@ -1 +1 @@
-Subproject commit 8eae802fb6feb1863479381ca98825bc0151f35b
+Subproject commit aa52e8c2ef400b041bd130e304519bc17842cadf
diff --git a/SpaceStation14.sln.DotSettings b/SpaceStation14.sln.DotSettings
index 99209d355d..37e8181972 100644
--- a/SpaceStation14.sln.DotSettings
+++ b/SpaceStation14.sln.DotSettings
@@ -550,6 +550,7 @@ public sealed class $CLASS$ : Shared$CLASS$ {
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=LOOC/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Magboots/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=metabolizable/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=metagaming/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=mommi/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Monstermos/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Nar_0027/@EntryIndexedValue">True</s:Boolean>
@@ -578,6 +579,7 @@ public sealed class $CLASS$ : Shared$CLASS$ {
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=saltern/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=sandboxing/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Serilog/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Shrimple/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=singulo/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Smokable/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=smokables/@EntryIndexedValue">True</s:Boolean>