remove a bunch of instances of component reference (#13164)

Content.Shared/Ensnaring/Components/EnsnareableComponent.cs

@@ -1,12 +1,13 @@
+using Robust.Shared.Containers;
 using Robust.Shared.GameStates;
 using Robust.Shared.Serialization;
 
 namespace Content.Shared.Ensnaring.Components;
 /// <summary>
-/// Use this on an entity that you would like to be ensnared by anything that has the <see cref="SharedEnsnaringComponent"/>
+/// Use this on an entity that you would like to be ensnared by anything that has the <see cref="EnsnaringComponent"/>
 /// </summary>
-[NetworkedComponent]
-public abstract class SharedEnsnareableComponent : Component
+[RegisterComponent, NetworkedComponent]
+public sealed class EnsnareableComponent : Component
 {
     /// <summary>
     /// How much should this slow down the entities walk?
@@ -28,6 +29,17 @@ public abstract class SharedEnsnareableComponent : Component
     [ViewVariables(VVAccess.ReadWrite)]
     [DataField("isEnsnared")]
     public bool IsEnsnared;
+
+    /// <summary>
+    /// The container where the <see cref="EnsnaringComponent"/> entity will be stored
+    /// </summary>
+    public Container Container = default!;
+
+    [DataField("sprite")]
+    public string? Sprite;
+
+    [DataField("state")]
+    public string? State;
 }
 
 [Serializable, NetSerializable]

Content.Shared/Ensnaring/Components/EnsnaringComponent.cs

@@ -1,8 +1,12 @@
-namespace Content.Shared.Ensnaring.Components;
+using System.Threading;
+using Robust.Shared.GameStates;
+
+namespace Content.Shared.Ensnaring.Components;
 /// <summary>
 /// Use this on something you want to use to ensnare an entity with
 /// </summary>
-public abstract class SharedEnsnaringComponent : Component
+[RegisterComponent, NetworkedComponent]
+public sealed class EnsnaringComponent : Component
 {
     /// <summary>
     /// How long it should take to free someone else.
@@ -45,10 +49,19 @@ public abstract class SharedEnsnaringComponent : Component
     [ViewVariables(VVAccess.ReadWrite)]
     [DataField("ensnared")]
     public EntityUid? Ensnared;
+
+    /// <summary>
+    /// Should movement cancel breaking out?
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite)]
+    [DataField("canMoveBreakout")]
+    public bool CanMoveBreakout;
+
+    public CancellationTokenSource? CancelToken;
 }
 
 /// <summary>
-/// Used whenever you want to do something when someone becomes ensnared by the <see cref="SharedEnsnaringComponent"/>
+/// Used whenever you want to do something when someone becomes ensnared by the <see cref="EnsnaringComponent"/>
 /// </summary>
 public sealed class EnsnareEvent : EntityEventArgs
 {
@@ -63,9 +76,35 @@ public sealed class EnsnareEvent : EntityEventArgs
 }
 
 /// <summary>
-/// Used whenever you want to do something when someone is freed by the <see cref="SharedEnsnaringComponent"/>
+/// Used whenever you want to do something when someone is freed by the <see cref="EnsnaringComponent"/>
 /// </summary>
 public sealed class EnsnareRemoveEvent : CancellableEntityEventArgs
 {
 
 }
+
+/// <summary>
+/// Used for the do after event to free the entity that owns the <see cref="EnsnareableComponent"/>
+/// </summary>
+public sealed class FreeEnsnareDoAfterComplete : EntityEventArgs
+{
+    public readonly EntityUid EnsnaringEntity;
+
+    public FreeEnsnareDoAfterComplete(EntityUid ensnaringEntity)
+    {
+        EnsnaringEntity = ensnaringEntity;
+    }
+}
+
+/// <summary>
+/// Used for the do after event when it fails to free the entity that owns the <see cref="EnsnareableComponent"/>
+/// </summary>
+public sealed class FreeEnsnareDoAfterCancel : EntityEventArgs
+{
+    public readonly EntityUid EnsnaringEntity;
+
+    public FreeEnsnareDoAfterCancel(EntityUid ensnaringEntity)
+    {
+        EnsnaringEntity = ensnaringEntity;
+    }
+}

Content.Shared/Ensnaring/SharedEnsnareableSystem.cs

@@ -13,15 +13,15 @@ public abstract class SharedEnsnareableSystem : EntitySystem
     {
         base.Initialize();
 
-        SubscribeLocalEvent<SharedEnsnareableComponent, RefreshMovementSpeedModifiersEvent>(MovementSpeedModify);
-        SubscribeLocalEvent<SharedEnsnareableComponent, EnsnareEvent>(OnEnsnare);
-        SubscribeLocalEvent<SharedEnsnareableComponent, EnsnareRemoveEvent>(OnEnsnareRemove);
-        SubscribeLocalEvent<SharedEnsnareableComponent, EnsnaredChangedEvent>(OnEnsnareChange);
-        SubscribeLocalEvent<SharedEnsnareableComponent, ComponentGetState>(OnGetState);
-        SubscribeLocalEvent<SharedEnsnareableComponent, ComponentHandleState>(OnHandleState);
+        SubscribeLocalEvent<EnsnareableComponent, RefreshMovementSpeedModifiersEvent>(MovementSpeedModify);
+        SubscribeLocalEvent<EnsnareableComponent, EnsnareEvent>(OnEnsnare);
+        SubscribeLocalEvent<EnsnareableComponent, EnsnareRemoveEvent>(OnEnsnareRemove);
+        SubscribeLocalEvent<EnsnareableComponent, EnsnaredChangedEvent>(OnEnsnareChange);
+        SubscribeLocalEvent<EnsnareableComponent, ComponentGetState>(OnGetState);
+        SubscribeLocalEvent<EnsnareableComponent, ComponentHandleState>(OnHandleState);
     }
 
-    private void OnHandleState(EntityUid uid, SharedEnsnareableComponent component, ref ComponentHandleState args)
+    private void OnHandleState(EntityUid uid, EnsnareableComponent component, ref ComponentHandleState args)
     {
         if (args.Current is not EnsnareableComponentState state)
             return;
@@ -33,12 +33,12 @@ public abstract class SharedEnsnareableSystem : EntitySystem
         RaiseLocalEvent(uid, new EnsnaredChangedEvent(component.IsEnsnared));
     }
 
-    private void OnGetState(EntityUid uid, SharedEnsnareableComponent component, ref ComponentGetState args)
+    private void OnGetState(EntityUid uid, EnsnareableComponent component, ref ComponentGetState args)
     {
         args.State = new EnsnareableComponentState(component.IsEnsnared);
     }
 
-    private void OnEnsnare(EntityUid uid, SharedEnsnareableComponent component, EnsnareEvent args)
+    private void OnEnsnare(EntityUid uid, EnsnareableComponent component, EnsnareEvent args)
     {
         component.WalkSpeed = args.WalkSpeed;
         component.SprintSpeed = args.SprintSpeed;
@@ -49,7 +49,7 @@ public abstract class SharedEnsnareableSystem : EntitySystem
         RaiseLocalEvent(uid, ev);
     }
 
-    private void OnEnsnareRemove(EntityUid uid, SharedEnsnareableComponent component, EnsnareRemoveEvent args)
+    private void OnEnsnareRemove(EntityUid uid, EnsnareableComponent component, EnsnareRemoveEvent args)
     {
         _speedModifier.RefreshMovementSpeedModifiers(uid);
 
@@ -57,17 +57,17 @@ public abstract class SharedEnsnareableSystem : EntitySystem
         RaiseLocalEvent(uid, ev);
     }
 
-    private void OnEnsnareChange(EntityUid uid, SharedEnsnareableComponent component, EnsnaredChangedEvent args)
+    private void OnEnsnareChange(EntityUid uid, EnsnareableComponent component, EnsnaredChangedEvent args)
     {
         UpdateAppearance(uid, component);
     }
 
-    private void UpdateAppearance(EntityUid uid, SharedEnsnareableComponent component, AppearanceComponent? appearance = null)
+    private void UpdateAppearance(EntityUid uid, EnsnareableComponent component, AppearanceComponent? appearance = null)
     {
         Appearance.SetData(uid, EnsnareableVisuals.IsEnsnared, component.IsEnsnared, appearance);
     }
 
-    private void MovementSpeedModify(EntityUid uid, SharedEnsnareableComponent component, RefreshMovementSpeedModifiersEvent args)
+    private void MovementSpeedModify(EntityUid uid, EnsnareableComponent component, RefreshMovementSpeedModifiersEvent args)
     {
         if (!component.IsEnsnared)
             return;