"ECS" do_after (#6531)

Content.Server/DoAfter/DoAfterSystem.cs

@@ -1,11 +1,10 @@
-using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using Content.Shared.Damage;
+using Content.Shared.DoAfter;
 using Content.Shared.MobState;
 using JetBrains.Annotations;
-using Robust.Shared.GameObjects;
+using Robust.Shared.GameStates;
 
 namespace Content.Server.DoAfter
 {
@@ -19,27 +18,81 @@ namespace Content.Server.DoAfter
         public override void Initialize()
         {
             base.Initialize();
-            SubscribeLocalEvent<DoAfterComponent, DamageChangedEvent>(HandleDamage);
-            SubscribeLocalEvent<DoAfterComponent, MobStateChangedEvent>(HandleStateChanged);
+            SubscribeLocalEvent<DoAfterComponent, DamageChangedEvent>(OnDamage);
+            SubscribeLocalEvent<DoAfterComponent, MobStateChangedEvent>(OnStateChanged);
+            SubscribeLocalEvent<DoAfterComponent, ComponentGetState>(OnDoAfterGetState);
         }
 
-        private void HandleStateChanged(EntityUid uid, DoAfterComponent component, MobStateChangedEvent args)
+        public void Add(DoAfterComponent component, DoAfter doAfter)
+        {
+            component.DoAfters.Add(doAfter, component.RunningIndex);
+            component.RunningIndex++;
+            Dirty(component);
+        }
+
+        public void Cancelled(DoAfterComponent component, DoAfter doAfter)
+        {
+            if (!component.DoAfters.TryGetValue(doAfter, out var index))
+                return;
+
+            component.DoAfters.Remove(doAfter);
+
+            RaiseNetworkEvent(new CancelledDoAfterMessage(component.Owner, index));
+        }
+
+        /// <summary>
+        ///     Call when the particular DoAfter is finished.
+        ///     Client should be tracking this independently.
+        /// </summary>
+        public void Finished(DoAfterComponent component, DoAfter doAfter)
+        {
+            if (!component.DoAfters.ContainsKey(doAfter))
+                return;
+
+            component.DoAfters.Remove(doAfter);
+        }
+
+        private void OnDoAfterGetState(EntityUid uid, DoAfterComponent component, ref ComponentGetState args)
+        {
+            var toAdd = new List<ClientDoAfter>(component.DoAfters.Count);
+
+            foreach (var (doAfter, _) in component.DoAfters)
+            {
+                // THE ALMIGHTY PYRAMID
+                var clientDoAfter = new ClientDoAfter(
+                    component.DoAfters[doAfter],
+                    doAfter.UserGrid,
+                    doAfter.TargetGrid,
+                    doAfter.StartTime,
+                    doAfter.EventArgs.Delay,
+                    doAfter.EventArgs.BreakOnUserMove,
+                    doAfter.EventArgs.BreakOnTargetMove,
+                    doAfter.EventArgs.MovementThreshold,
+                    doAfter.EventArgs.Target);
+
+                toAdd.Add(clientDoAfter);
+            }
+
+            args.State = new DoAfterComponentState(toAdd);
+        }
+
+        private void OnStateChanged(EntityUid uid, DoAfterComponent component, MobStateChangedEvent args)
         {
             if (!args.CurrentMobState.IsIncapacitated())
                 return;
 
-            foreach (var doAfter in component.DoAfters)
+            foreach (var (doAfter, _) in component.DoAfters)
             {
                 doAfter.Cancel();
             }
         }
 
-        public void HandleDamage(EntityUid _, DoAfterComponent component, DamageChangedEvent args)
+        public void OnDamage(EntityUid _, DoAfterComponent component, DamageChangedEvent args)
         {
             if (!args.InterruptsDoAfters || !args.DamageIncreased)
                 return;
 
-            foreach (var doAfter in component.DoAfters)
+            foreach (var (doAfter, _) in component.DoAfters)
             {
                 if (doAfter.EventArgs.BreakOnDamage)
                 {
@@ -54,7 +107,7 @@ namespace Content.Server.DoAfter
 
             foreach (var comp in EntityManager.EntityQuery<DoAfterComponent>())
             {
-                foreach (var doAfter in comp.DoAfters.ToArray())
+                foreach (var (doAfter, _) in comp.DoAfters.ToArray())
                 {
                     doAfter.Run(frameTime, EntityManager);
 
@@ -75,7 +128,7 @@ namespace Content.Server.DoAfter
 
                 while (_cancelled.TryDequeue(out var doAfter))
                 {
-                    comp.Cancelled(doAfter);
+                    Cancelled(comp, doAfter);
 
                     if(EntityManager.EntityExists(doAfter.EventArgs.User) && doAfter.EventArgs.UserCancelledEvent != null)
                         RaiseLocalEvent(doAfter.EventArgs.User, doAfter.EventArgs.UserCancelledEvent, false);
@@ -89,7 +142,7 @@ namespace Content.Server.DoAfter
 
                 while (_finished.TryDequeue(out var doAfter))
                 {
-                    comp.Finished(doAfter);
+                    Finished(comp, doAfter);
 
                     if(EntityManager.EntityExists(doAfter.EventArgs.User) && doAfter.EventArgs.UserFinishedEvent != null)
                         RaiseLocalEvent(doAfter.EventArgs.User, doAfter.EventArgs.UserFinishedEvent, false);
@@ -133,13 +186,13 @@ namespace Content.Server.DoAfter
             // Setup
             var doAfter = new DoAfter(eventArgs, EntityManager);
             // Caller's gonna be responsible for this I guess
-            var doAfterComponent = EntityManager.GetComponent<DoAfterComponent>(eventArgs.User);
-            doAfterComponent.Add(doAfter);
+            var doAfterComponent = Comp<DoAfterComponent>(eventArgs.User);
+            Add(doAfterComponent, doAfter);
             return doAfter;
         }
     }
 
-    public enum DoAfterStatus
+    public enum DoAfterStatus : byte
     {
         Running,
         Cancelled,