More DoAfter Changes (#14609)

* DoAfters

* Compact Clone()

* Fix mice and cuffables

* Try generalize attempt events

* moves climbabledoafter event to shared, fixes issue with climbable target

* Fix merge (cuffing)

* Make all events netserializable

* handful of doafter events moved

* moves the rest of the events to their respective shared folders

* Changes all mentions of server doafter to shared

* stop stripping cancellation

* fix merge errors

* draw paused doafters

* handle unpausing

* missing netserializable ref

* removes break on stun reference

* removes cuffing state reference

* Fix tools

* Fix door prying.

* Fix construction

* Fix dumping

* Fix wielding assert

* fix rev

* Fix test

* more test fixes

---------

Co-authored-by: keronshb <keronshb@live.com>

Content.Shared/DoAfter/DoAfterComponent.cs

@@ -1,92 +1,40 @@
+using System.Threading.Tasks;
 using Robust.Shared.GameStates;
 using Robust.Shared.Serialization;
 
 namespace Content.Shared.DoAfter;
 
 [RegisterComponent, NetworkedComponent]
+[Access(typeof(SharedDoAfterSystem))]
 public sealed class DoAfterComponent : Component
 {
+    [DataField("nextId")]
+    public ushort NextId;
+
     [DataField("doAfters")]
-    public readonly Dictionary<byte, DoAfter> DoAfters = new();
+    public readonly Dictionary<ushort, DoAfter> DoAfters = new();
 
-    [DataField("cancelledDoAfters")]
-    public readonly Dictionary<byte, DoAfter> CancelledDoAfters = new();
-
-    // So the client knows which one to update (and so we don't send all of the do_afters every time 1 updates)
-    // we'll just send them the index. Doesn't matter if it wraps around.
-    [DataField("runningIndex")]
-    public byte RunningIndex;
+    // Used by obsolete async do afters
+    public readonly Dictionary<ushort, TaskCompletionSource<DoAfterStatus>> AwaitedDoAfters = new();
 }
 
 [Serializable, NetSerializable]
 public sealed class DoAfterComponentState : ComponentState
 {
-    public Dictionary<byte, DoAfter> DoAfters;
+    public readonly ushort NextId;
+    public readonly Dictionary<ushort, DoAfter> DoAfters;
 
-    public DoAfterComponentState(Dictionary<byte, DoAfter> doAfters)
+    public DoAfterComponentState(DoAfterComponent component)
     {
-        DoAfters = doAfters;
-    }
-}
-
-/// <summary>
-/// Use this event to raise your DoAfter events now.
-/// Check for cancelled, and if it is, then null the token there.
-/// </summary>
-/// TODO: Add a networked DoAfterEvent to pass in AdditionalData for the future
-[Serializable, NetSerializable]
-public sealed class DoAfterEvent : HandledEntityEventArgs
-{
-    public bool Cancelled;
-    public byte Id;
-    public readonly DoAfterEventArgs Args;
-
-    public DoAfterEvent(bool cancelled, DoAfterEventArgs args, byte id)
-    {
-        Cancelled = cancelled;
-        Args = args;
-        Id = id;
-    }
-}
-
-/// <summary>
-/// Use this event to raise your DoAfter events now.
-/// Check for cancelled, and if it is, then null the token there.
-/// Can't be serialized
-/// </summary>
-/// TODO: Net/Serilization isn't supported so this needs to be networked somehow
-public sealed class DoAfterEvent<T> : HandledEntityEventArgs
-{
-    public T AdditionalData;
-    public bool Cancelled;
-    public byte Id;
-    public readonly DoAfterEventArgs Args;
-
-    public DoAfterEvent(T additionalData, bool cancelled, DoAfterEventArgs args, byte id)
-    {
-        AdditionalData = additionalData;
-        Cancelled = cancelled;
-        Args = args;
-        Id = id;
-    }
-}
-
-[Serializable, NetSerializable]
-public sealed class CancelledDoAfterMessage : EntityEventArgs
-{
-    public EntityUid Uid;
-    public byte ID;
-
-    public CancelledDoAfterMessage(EntityUid uid, byte id)
-    {
-        Uid = uid;
-        ID = id;
+        NextId = component.NextId;
+        DoAfters = component.DoAfters;
     }
 }
 
 [Serializable, NetSerializable]
 public enum DoAfterStatus : byte
 {
+    Invalid,
     Running,
     Cancelled,
     Finished,