Make instruments ECS (#5516)

Content.Server/Instruments/InstrumentSystem.cs

@@ -1,68 +1,177 @@
-using Content.Shared;
-using Content.Shared.CCVar;
+using System;
+using System.Linq;
+using Content.Server.Stunnable;
 using Content.Server.UserInterface;
+using Content.Shared.Instruments;
+using Content.Shared.Popups;
 using JetBrains.Annotations;
 using Robust.Shared.Configuration;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
+using Robust.Shared.Localization;
 
-namespace Content.Server.Instruments
+namespace Content.Server.Instruments;
+
+[UsedImplicitly]
+public sealed partial class InstrumentSystem : SharedInstrumentSystem
 {
-    [UsedImplicitly]
-    internal sealed class InstrumentSystem : EntitySystem
+    [Dependency] private readonly IConfigurationManager _cfg = default!;
+    [Dependency] private readonly StunSystem _stunSystem = default!;
+
+    public override void Initialize()
     {
-        [Dependency] private readonly IConfigurationManager _cfg = default!;
+        base.Initialize();
 
-        public override void Initialize()
+        InitializeCVars();
+
+        SubscribeNetworkEvent<InstrumentMidiEventEvent>(OnMidiEventRx);
+        SubscribeNetworkEvent<InstrumentStartMidiEvent>(OnMidiStart);
+        SubscribeNetworkEvent<InstrumentStopMidiEvent>(OnMidiStop);
+
+        SubscribeLocalEvent<InstrumentComponent, ActivatableUIPlayerChangedEvent>(InstrumentNeedsClean);
+    }
+
+    private void OnMidiStart(InstrumentStartMidiEvent msg, EntitySessionEventArgs args)
+    {
+        var uid = msg.Uid;
+
+        if (!EntityManager.TryGetComponent(uid, out InstrumentComponent? instrument))
+            return;
+
+        if (args.SenderSession != instrument.InstrumentPlayer)
+            return;
+
+        instrument.Playing = true;
+        instrument.Dirty();
+    }
+
+    private void OnMidiStop(InstrumentStopMidiEvent msg, EntitySessionEventArgs args)
+    {
+        var uid = msg.Uid;
+
+        if (!EntityManager.TryGetComponent(uid, out InstrumentComponent? instrument))
+            return;
+
+        if (args.SenderSession != instrument.InstrumentPlayer)
+            return;
+
+        Clean(uid, instrument);
+    }
+
+    public override void Shutdown()
+    {
+        base.Shutdown();
+
+        ShutdownCVars();
+    }
+
+    public void Clean(EntityUid uid, InstrumentComponent? instrument = null)
+    {
+        if (!Resolve(uid, ref instrument))
+            return;
+
+        if (instrument.Playing)
         {
-            base.Initialize();
-
-            _cfg.OnValueChanged(CCVars.MaxMidiEventsPerSecond, OnMaxMidiEventsPerSecondChanged, true);
-            _cfg.OnValueChanged(CCVars.MaxMidiEventsPerBatch, OnMaxMidiEventsPerBatchChanged, true);
-            _cfg.OnValueChanged(CCVars.MaxMidiBatchesDropped, OnMaxMidiBatchesDroppedChanged, true);
-            _cfg.OnValueChanged(CCVars.MaxMidiLaggedBatches, OnMaxMidiLaggedBatchesChanged, true);
-
-            SubscribeLocalEvent<InstrumentComponent, ActivatableUIPlayerChangedEvent>(InstrumentNeedsClean);
+            RaiseNetworkEvent(new InstrumentStopMidiEvent(uid));
         }
 
-        public int MaxMidiEventsPerSecond { get; private set; }
-        public int MaxMidiEventsPerBatch { get; private set; }
-        public int MaxMidiBatchesDropped { get; private set; }
-        public int MaxMidiLaggedBatches { get; private set; }
+        instrument.Playing = false;
+        instrument.LastSequencerTick = 0;
+        instrument.BatchesDropped = 0;
+        instrument.LaggedBatches = 0;
+        instrument.Dirty();
+    }
 
-        private void OnMaxMidiLaggedBatchesChanged(int obj)
+    private void InstrumentNeedsClean(EntityUid uid, InstrumentComponent component, ActivatableUIPlayerChangedEvent ev)
+    {
+        Clean(uid, component);
+    }
+
+    private void OnMidiEventRx(InstrumentMidiEventEvent msg, EntitySessionEventArgs args)
+    {
+        var uid = msg.Uid;
+
+        if (!EntityManager.TryGetComponent(uid, out InstrumentComponent? instrument))
+            return;
+
+        if (!instrument.Playing || args.SenderSession != instrument.InstrumentPlayer || instrument.InstrumentPlayer == null)
+            return;
+
+        var send = true;
+
+        var minTick = msg.MidiEvent.Min(x => x.Tick);
+        if (instrument.LastSequencerTick > minTick)
         {
-            MaxMidiLaggedBatches = obj;
-        }
+            instrument.LaggedBatches++;
 
-        private void OnMaxMidiBatchesDroppedChanged(int obj)
-        {
-            MaxMidiBatchesDropped = obj;
-        }
-
-        private void OnMaxMidiEventsPerBatchChanged(int obj)
-        {
-            MaxMidiEventsPerBatch = obj;
-        }
-
-        private void OnMaxMidiEventsPerSecondChanged(int obj)
-        {
-            MaxMidiEventsPerSecond = obj;
-        }
-
-        private void InstrumentNeedsClean(EntityUid uid, InstrumentComponent component, ActivatableUIPlayerChangedEvent ev)
-        {
-            component.Clean();
-        }
-
-        public override void Update(float frameTime)
-        {
-            base.Update(frameTime);
-
-            foreach (var component in EntityManager.EntityQuery<InstrumentComponent>(true))
+            if (instrument.RespectMidiLimits)
             {
-                component.Update(frameTime);
+                if (instrument.LaggedBatches == (int) (MaxMidiLaggedBatches * (1 / 3d) + 1))
+                {
+                    instrument.InstrumentPlayer.AttachedEntity?.PopupMessage(
+                        Loc.GetString("instrument-component-finger-cramps-light-message"));
+                } else if (instrument.LaggedBatches == (int) (MaxMidiLaggedBatches * (2 / 3d) + 1))
+                {
+                    instrument.InstrumentPlayer.AttachedEntity?.PopupMessage(
+                        Loc.GetString("instrument-component-finger-cramps-serious-message"));
+                }
             }
+
+            if (instrument.LaggedBatches > MaxMidiLaggedBatches)
+            {
+                send = false;
+            }
+        }
+
+        if (++instrument.MidiEventCount > MaxMidiEventsPerSecond
+            || msg.MidiEvent.Length > MaxMidiEventsPerBatch)
+        {
+            instrument.BatchesDropped++;
+
+            send = false;
+        }
+
+        if (send || !instrument.RespectMidiLimits)
+        {
+            RaiseNetworkEvent(msg);
+        }
+
+        var maxTick = msg.MidiEvent.Max(x => x.Tick);
+        instrument.LastSequencerTick = Math.Max(maxTick, minTick);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        foreach (var instrument in EntityManager.EntityQuery<InstrumentComponent>(true))
+        {
+            if ((instrument.BatchesDropped >= MaxMidiBatchesDropped
+                 || instrument.LaggedBatches >= MaxMidiLaggedBatches)
+                && instrument.InstrumentPlayer != null && instrument.RespectMidiLimits)
+            {
+                var mob = instrument.InstrumentPlayer.AttachedEntity;
+
+                // Just in case
+                Clean(instrument.OwnerUid);
+                instrument.UserInterface?.CloseAll();
+
+                if (mob != null)
+                {
+                    _stunSystem.TryParalyze(mob.Uid, TimeSpan.FromSeconds(1));
+
+                    instrument.Owner.PopupMessage(mob, "instrument-component-finger-cramps-max-message");
+                }
+            }
+
+            instrument.Timer += frameTime;
+            if (instrument.Timer < 1)
+                return;
+
+            instrument.Timer = 0f;
+            instrument.MidiEventCount = 0;
+            instrument.LaggedBatches = 0;
+            instrument.BatchesDropped = 0;
         }
     }
 }