Replace IClickAlert with events (#30728)

* Replace IAlertClick with events

* whoop

* eek!

Content.Client/Alerts/ClientAlertsSystem.cs

@@ -93,6 +93,6 @@ private void OnPlayerDetached(EntityUid uid, AlertsComponent component, LocalPla
 
     public void AlertClicked(ProtoId<AlertPrototype> alertType)
     {
-        RaiseNetworkEvent(new ClickAlertEvent(alertType));
+        RaisePredictiveEvent(new ClickAlertEvent(alertType));
     }
 }

Content.Server/Abilities/Mime/MimePowersSystem.cs

@@ -1,4 +1,5 @@
 using Content.Server.Popups;
+using Content.Shared.Abilities.Mime;
 using Content.Shared.Actions;
 using Content.Shared.Actions.Events;
 using Content.Shared.Alert;
@@ -31,6 +32,9 @@ public override void Initialize()
             base.Initialize();
             SubscribeLocalEvent<MimePowersComponent, ComponentInit>(OnComponentInit);
             SubscribeLocalEvent<MimePowersComponent, InvisibleWallActionEvent>(OnInvisibleWall);
+
+            SubscribeLocalEvent<MimePowersComponent, BreakVowAlertEvent>(OnBreakVowAlert);
+            SubscribeLocalEvent<MimePowersComponent, RetakeVowAlertEvent>(OnRetakeVowAlert);
         }
 
         public override void Update(float frameTime)
@@ -104,6 +108,22 @@ private void OnInvisibleWall(EntityUid uid, MimePowersComponent component, Invis
             args.Handled = true;
         }
 
+        private void OnBreakVowAlert(Entity<MimePowersComponent> ent, ref BreakVowAlertEvent args)
+        {
+            if (args.Handled)
+                return;
+            BreakVow(ent, ent);
+            args.Handled = true;
+        }
+
+        private void OnRetakeVowAlert(Entity<MimePowersComponent> ent, ref RetakeVowAlertEvent args)
+        {
+            if (args.Handled)
+                return;
+            RetakeVow(ent, ent);
+            args.Handled = true;
+        }
+
         /// <summary>
         /// Break this mime's vow to not speak.
         /// </summary>

Content.Server/Atmos/EntitySystems/FlammableSystem.cs

@@ -73,6 +73,7 @@ public override void Initialize()
             SubscribeLocalEvent<FlammableComponent, IsHotEvent>(OnIsHot);
             SubscribeLocalEvent<FlammableComponent, TileFireEvent>(OnTileFire);
             SubscribeLocalEvent<FlammableComponent, RejuvenateEvent>(OnRejuvenate);
+            SubscribeLocalEvent<FlammableComponent, ResistFireAlertEvent>(OnResistFireAlert);
 
             SubscribeLocalEvent<IgniteOnCollideComponent, StartCollideEvent>(IgniteOnCollide);
             SubscribeLocalEvent<IgniteOnCollideComponent, LandEvent>(OnIgniteLand);
@@ -268,6 +269,15 @@ private void OnRejuvenate(EntityUid uid, FlammableComponent component, Rejuvenat
             Extinguish(uid, component);
         }
 
+        private void OnResistFireAlert(Entity<FlammableComponent> ent, ref ResistFireAlertEvent args)
+        {
+            if (args.Handled)
+                return;
+
+            Resist(ent, ent);
+            args.Handled = true;
+        }
+
         public void UpdateAppearance(EntityUid uid, FlammableComponent? flammable = null, AppearanceComponent? appearance = null)
         {
             if (!Resolve(uid, ref flammable, ref appearance))

Content.Server/Body/Components/InternalsComponent.cs

@@ -25,4 +25,5 @@ public sealed partial class InternalsComponent : Component
         [DataField]
         public ProtoId<AlertPrototype> InternalsAlert = "Internals";
     }
+
 }

Content.Server/Body/Systems/InternalsSystem.cs

@@ -37,6 +37,7 @@ public override void Initialize()
         SubscribeLocalEvent<InternalsComponent, ComponentShutdown>(OnInternalsShutdown);
         SubscribeLocalEvent<InternalsComponent, GetVerbsEvent<InteractionVerb>>(OnGetInteractionVerbs);
         SubscribeLocalEvent<InternalsComponent, InternalsDoAfterEvent>(OnDoAfter);
+        SubscribeLocalEvent<InternalsComponent, ToggleInternalsAlertEvent>(OnToggleInternalsAlert);
 
         SubscribeLocalEvent<StartingGearEquippedEvent>(OnStartingGear);
     }
@@ -143,6 +144,14 @@ private void OnDoAfter(Entity<InternalsComponent> ent, ref InternalsDoAfterEvent
         args.Handled = true;
     }
 
+    private void OnToggleInternalsAlert(Entity<InternalsComponent> ent, ref ToggleInternalsAlertEvent args)
+    {
+        if (args.Handled)
+            return;
+        ToggleInternals(ent, ent, false, internals: ent.Comp);
+        args.Handled = true;
+    }
+
     private void OnInternalsStartup(Entity<InternalsComponent> ent, ref ComponentStartup args)
     {
         _alerts.ShowAlert(ent, ent.Comp.InternalsAlert, GetSeverity(ent));

Content.Server/Ensnaring/EnsnareableSystem.Ensnaring.cs

@@ -28,13 +28,32 @@ public void InitializeEnsnaring()
         SubscribeLocalEvent<EnsnaringComponent, StepTriggeredOffEvent>(OnStepTrigger);
         SubscribeLocalEvent<EnsnaringComponent, ThrowDoHitEvent>(OnThrowHit);
         SubscribeLocalEvent<EnsnaringComponent, AttemptPacifiedThrowEvent>(OnAttemptPacifiedThrow);
+        SubscribeLocalEvent<EnsnareableComponent, RemoveEnsnareAlertEvent>(OnRemoveEnsnareAlert);
     }
 
     private void OnAttemptPacifiedThrow(Entity<EnsnaringComponent> ent, ref AttemptPacifiedThrowEvent args)
     {
         args.Cancel("pacified-cannot-throw-snare");
     }
 
+    private void OnRemoveEnsnareAlert(Entity<EnsnareableComponent> ent, ref RemoveEnsnareAlertEvent args)
+    {
+        if (args.Handled)
+            return;
+
+        foreach (var ensnare in ent.Comp.Container.ContainedEntities)
+        {
+            if (!TryComp<EnsnaringComponent>(ensnare, out var ensnaringComponent))
+                return;
+
+            TryFree(ent, ent, ensnare, ensnaringComponent);
+
+            args.Handled = true;
+            // Only one snare at a time.
+            break;
+        }
+    }
+
     private void OnComponentRemove(EntityUid uid, EnsnaringComponent component, ComponentRemove args)
     {
         if (!TryComp<EnsnareableComponent>(component.Ensnared, out var ensnared))