Port Coyote Expedition Retrieval

Content.Server/Atmos/EntitySystems/FlammableSystem.cs

@@ -23,6 +23,7 @@
 using Content.Shared.Toggleable;
 using Content.Shared.Weapons.Melee.Events;
 using Content.Shared.FixedPoint;
+using Content.Shared.Hands;
 using Robust.Server.Audio;
 using Robust.Shared.Physics.Components;
 using Robust.Shared.Physics.Events;
@@ -75,6 +76,7 @@ public override void Initialize()
             SubscribeLocalEvent<FlammableComponent, TileFireEvent>(OnTileFire);
             SubscribeLocalEvent<FlammableComponent, RejuvenateEvent>(OnRejuvenate);
             SubscribeLocalEvent<FlammableComponent, ResistFireAlertEvent>(OnResistFireAlert);
+            Subs.SubscribeWithRelay<FlammableComponent, ExtinguishEvent>(OnExtinguishEvent);
 
             SubscribeLocalEvent<IgniteOnCollideComponent, StartCollideEvent>(IgniteOnCollide);
             SubscribeLocalEvent<IgniteOnCollideComponent, LandEvent>(OnIgniteLand);
@@ -88,6 +90,14 @@ public override void Initialize()
             SubscribeLocalEvent<IgniteOnHeatDamageComponent, DamageChangedEvent>(OnDamageChanged);
         }
 
+        private void OnExtinguishEvent(Entity<FlammableComponent> ent, ref ExtinguishEvent args)
+        {
+            // You know I'm really not sure if having AdjustFireStacks *after* Extinguish,
+            // but I'm just moving this code, not questioning it.
+            Extinguish(ent, ent.Comp);
+            AdjustFireStacks(ent, args.FireStacksAdjustment, ent.Comp);
+        }
+
         private void OnMeleeHit(EntityUid uid, IgniteOnMeleeHitComponent component, MeleeHitEvent args)
         {
             foreach (var entity in args.HitEntities)
@@ -331,6 +341,9 @@ public void Extinguish(EntityUid uid, FlammableComponent? flammable = null)
 
             _ignitionSourceSystem.SetIgnited(uid, false);
 
+            var extinguished = new ExtinguishedEvent();
+            RaiseLocalEvent(uid, ref extinguished);
+
             UpdateAppearance(uid, flammable);
         }
 
@@ -361,6 +374,9 @@ public void Ignite(EntityUid uid, EntityUid ignitionSource, FlammableComponent?
                 else
                     _adminLogger.Add(LogType.Flammable, $"{ToPrettyString(uid):target} set on fire by {ToPrettyString(ignitionSource):actor}");
                 flammable.OnFire = true;
+
+                var extinguished = new IgnitedEvent();
+                RaiseLocalEvent(uid, ref extinguished);
             }
 
             UpdateAppearance(uid, flammable);

Content.Server/EntityEffects/Effects/ExtinguishReaction.cs

@@ -1,5 +1,4 @@
-using Content.Server.Atmos.Components;
-using Content.Server.Atmos.EntitySystems;
+using Content.Shared.Atmos;
 using Content.Shared.EntityEffects;
 using JetBrains.Annotations;
 using Robust.Shared.Prototypes;
@@ -20,17 +19,17 @@ public sealed partial class ExtinguishReaction : EntityEffect
 
         public override void Effect(EntityEffectBaseArgs args)
         {
-            if (!args.EntityManager.TryGetComponent(args.TargetEntity, out FlammableComponent? flammable)) return;
+            var ev = new ExtinguishEvent
+            {
+                FireStacksAdjustment = FireStacksAdjustment,
+            };
 
-            var flammableSystem = args.EntityManager.System<FlammableSystem>();
-            flammableSystem.Extinguish(args.TargetEntity, flammable);
             if (args is EntityEffectReagentArgs reagentArgs)
             {
-                flammableSystem.AdjustFireStacks(reagentArgs.TargetEntity, FireStacksAdjustment * (float) reagentArgs.Quantity, flammable);
-            } else
-            {
-                flammableSystem.AdjustFireStacks(args.TargetEntity, FireStacksAdjustment, flammable);
+                ev.FireStacksAdjustment *= (float)reagentArgs.Quantity;
             }
+
+            args.EntityManager.EventBus.RaiseLocalEvent(args.TargetEntity, ref ev);
         }
     }
 }

Content.Server/Explosion/Components/TriggerOnMobstateChangeComponent.cs

@@ -1,4 +1,5 @@
-using Content.Shared.Mobs;
+using System.Threading;
+using Content.Shared.Mobs;
 
 namespace Content.Server.Explosion.Components;
 
@@ -21,4 +22,12 @@ public sealed partial class TriggerOnMobstateChangeComponent : Component
     [ViewVariables]
     [DataField("preventSuicide")]
     public bool PreventSuicide = false;
+
+    // the timer cancel token
+    [ViewVariables]
+    public CancellationTokenSource RattleCancelToken = new();
+
+    // The delay before the implant sends the message again
+    [DataField]
+    public TimeSpan RattleRefireDelay = TimeSpan.FromMinutes(20);
 }

Content.Server/Explosion/EntitySystems/TriggerSystem.Mobstate.cs

@@ -1,8 +1,14 @@
-using Content.Server.Explosion.Components;
+using System.Threading;
+using Content.Server.Explosion.Components;
 using Content.Shared.Explosion.Components;
 using Content.Shared.Implants;
 using Content.Shared.Interaction.Events;
+using Content.Shared.Mind;
+using Content.Shared.Mind.Components;
 using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Verbs;
+using Robust.Shared.Timing;
 
 namespace Content.Server.Explosion.EntitySystems;
 
@@ -15,27 +21,95 @@ private void InitializeMobstate()
 
         SubscribeLocalEvent<TriggerOnMobstateChangeComponent, ImplantRelayEvent<SuicideEvent>>(OnSuicideRelay);
         SubscribeLocalEvent<TriggerOnMobstateChangeComponent, ImplantRelayEvent<MobStateChangedEvent>>(OnMobStateRelay);
+        SubscribeLocalEvent<TriggerOnMobstateChangeComponent, ImplantRelayEvent<ReTriggerRattleImplantEvent>>(OnFtlArriveRelay);
     }
 
     private void OnMobStateChanged(EntityUid uid, TriggerOnMobstateChangeComponent component, MobStateChangedEvent args)
     {
+        component.RattleCancelToken.Cancel();
+        component.RattleCancelToken = new CancellationTokenSource();
         if (!component.MobState.Contains(args.NewMobState))
             return;
 
+        TryRunTrigger(
+            uid,
+            component,
+            args.Target,
+            args.NewMobState,
+            args.Origin);
+    }
+
+    private void TryRunTrigger(
+        EntityUid uid,
+        TriggerOnMobstateChangeComponent component,
+        EntityUid changedStateMobUid,
+        MobState coolState,
+        EntityUid? stateChangerUid = null,
+        bool retry = false)
+    {
+
         //This chains Mobstate Changed triggers with OnUseTimerTrigger if they have it
         //Very useful for things that require a mobstate change and a timer
         if (TryComp<OnUseTimerTriggerComponent>(uid, out var timerTrigger))
         {
             HandleTimerTrigger(
                 uid,
-                args.Origin,
+                stateChangerUid,
                 timerTrigger.Delay,
                 timerTrigger.BeepInterval,
                 timerTrigger.InitialBeepDelay,
                 timerTrigger.BeepSound);
         }
         else
-            Trigger(uid);
+        {
+            Dictionary<string, object> extraData = new()
+            {
+                { "isRetry", retry }
+            };
+            Trigger(uid, extras: extraData);
+        }
+
+        // but only repeat if their mind has a people behind it
+        if (!TryComp<MindContainerComponent>(changedStateMobUid, out var mindContainer))
+            return;
+        var mind = CompOrNull<MindComponent>(mindContainer.Mind);
+        var hasUserId = mind?.UserId;
+        if (hasUserId == null)
+            return;
+
+        // then do it AGAIN
+        component.RattleCancelToken.Cancel();
+        component.RattleCancelToken = new CancellationTokenSource();
+        Robust.Shared.Timing.Timer.Spawn(component.RattleRefireDelay, () => CheckAndTryRefire(uid, component, changedStateMobUid), component.RattleCancelToken.Token);
+    }
+
+    /// <summary>
+    /// Check if the trigger can be retriggered and does so if possible
+    /// </summary>
+    private void CheckAndTryRefire(
+        EntityUid uid,
+        TriggerOnMobstateChangeComponent component,
+        EntityUid changedStateMobUid)
+    {
+        if (!Exists(uid)
+            || !Exists(changedStateMobUid))
+            return;
+        if (Deleted(uid)
+            || Deleted(changedStateMobUid))
+            return;
+        if (!HasComp<MobStateComponent>(changedStateMobUid))
+            return;
+        var stat = Comp<MobStateComponent>(changedStateMobUid).CurrentState;
+        if (component.MobState.Contains(stat))
+        {
+            TryRunTrigger(
+                uid,
+                component,
+                changedStateMobUid,
+                stat,
+                null,
+                true);
+        }
     }
 
     /// <summary>
@@ -61,6 +135,24 @@ private void OnSuicideRelay(EntityUid uid, TriggerOnMobstateChangeComponent comp
 
     private void OnMobStateRelay(EntityUid uid, TriggerOnMobstateChangeComponent component, ImplantRelayEvent<MobStateChangedEvent> args)
     {
-        OnMobStateChanged(uid, component, args.Event);
+        OnMobStateChanged(
+            uid,
+            component,
+            args.Event);
+    }
+
+    /// <summary>
+    /// When ftl arrives, and they are fucked, do the needful
+    /// </summary>
+    private void OnFtlArriveRelay(EntityUid uid,
+        TriggerOnMobstateChangeComponent component,
+        ImplantRelayEvent<ReTriggerRattleImplantEvent> args)
+    {
+        TryRunTrigger(
+            uid,
+            component,
+            args.Event.Implanted,
+            args.Event.CurrentState,
+            null);
     }
 }

Content.Server/Explosion/EntitySystems/TriggerSystem.cs

@@ -1,4 +1,6 @@
 using Content.Server._Mono.Planets;
+using System.Linq;
+using System.Threading;
 using Content.Server.Administration.Logs;
 using Content.Server.Body.Systems;
 using Content.Server.Explosion.Components;
@@ -35,6 +37,8 @@
 using Content.Shared.Humanoid;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
+using Robust.Shared.Timing;
+using Robust.Shared.Utility;
 using Content.Shared.Body.Components; // Frontier: Gib organs
 using Content.Shared.Projectiles; // Frontier: embed triggers
 using Content.Shared.Mind;
@@ -51,14 +55,26 @@ public sealed class TriggerEvent : HandledEntityEventArgs
     {
         public EntityUid Triggered { get; }
         public EntityUid? User { get; }
+        public Dictionary<string, object> Extras { get; } = new();
 
         public TriggerEvent(EntityUid triggered, EntityUid? user = null)
         {
             Triggered = triggered;
             User = user;
         }
+
+        public void AddExtra(string extra, object value)
+        {
+            Extras[extra] = value;
+        }
     }
 
+    /// <summary>
+    /// Raised before a trigger is activated.
+    /// </summary>
+    [ByRefEvent]
+    public record struct BeforeTriggerEvent(EntityUid Triggered, EntityUid? User, bool Cancelled = false);
+
     /// <summary>
     /// Raised when timer trigger becomes active.
     /// </summary>
@@ -250,8 +266,8 @@ private void HandleRattleTrigger(EntityUid uid, RattleComponent component, Trigg
             // Gets location of the implant
             var ownerXform = Transform(uid);
             var pos = ownerXform.MapPosition;
-            var x = (int) pos.X;
-            var y = (int) pos.Y;
+            var x = (int)pos.X;
+            var y = (int)pos.Y;
             var posText = $"({x}, {y})";
 
             // Frontier: Gets station location of the implant
@@ -367,9 +383,16 @@ private void OnRepeatInit(Entity<RepeatingTriggerComponent> ent, ref MapInitEven
             ent.Comp.NextTrigger = _timing.CurTime + ent.Comp.Delay;
         }
 
-        public bool Trigger(EntityUid trigger, EntityUid? user = null)
+        public bool Trigger(EntityUid trigger, EntityUid? user = null, Dictionary<string, object>? extras = null)
         {
             var triggerEvent = new TriggerEvent(trigger, user);
+            if (extras != null)
+            {
+                foreach (var (key, value) in extras)
+                {
+                    triggerEvent.AddExtra(key, value);
+                }
+            }
             EntityManager.EventBus.RaiseLocalEvent(trigger, triggerEvent, true);
             return triggerEvent.Handled;
         }

Content.Server/Nutrition/EntitySystems/SmokingSystem.cs

@@ -17,6 +17,7 @@
 using Robust.Server.GameObjects;
 using Robust.Shared.Containers;
 using System.Linq;
+using Content.Shared.Atmos;
 
 namespace Content.Server.Nutrition.EntitySystems
 {
@@ -48,12 +49,19 @@ public override void Initialize()
             SubscribeLocalEvent<SmokableComponent, IsHotEvent>(OnSmokableIsHotEvent);
             SubscribeLocalEvent<SmokableComponent, ComponentShutdown>(OnSmokableShutdownEvent);
             SubscribeLocalEvent<SmokableComponent, GotEquippedEvent>(OnSmokeableEquipEvent);
+            Subs.SubscribeWithRelay<SmokableComponent, ExtinguishEvent>(OnExtinguishEvent);
 
             InitializeCigars();
             InitializePipes();
             InitializeVapes();
         }
 
+        private void OnExtinguishEvent(Entity<SmokableComponent> ent, ref ExtinguishEvent args)
+        {
+            if (ent.Comp.State == SmokableState.Lit)
+                SetSmokableState(ent, SmokableState.Burnt, ent);
+        }
+
         public void SetSmokableState(EntityUid uid, SmokableState state, SmokableComponent? smokable = null,
             AppearanceComponent? appearance = null, ClothingComponent? clothing = null)
         {
@@ -74,9 +82,19 @@ public void SetSmokableState(EntityUid uid, SmokableState state, SmokableCompone
             _items.SetHeldPrefix(uid, newState);
 
             if (state == SmokableState.Lit)
+            {
+                var igniteEvent = new IgnitedEvent();
+                RaiseLocalEvent(uid, ref igniteEvent);
+
                 _active.Add(uid);
+            }
             else
+            {
+                var igniteEvent = new ExtinguishedEvent();
+                RaiseLocalEvent(uid, ref igniteEvent);
+
                 _active.Remove(uid);
+            }
         }
 
         private void OnSmokableIsHotEvent(Entity<SmokableComponent> entity, ref IsHotEvent args)

Content.Server/Salvage/Expeditions/SalvageExpeditionComponent.cs

@@ -71,4 +71,10 @@ public sealed partial class SalvageExpeditionComponent : SharedSalvageExpedition
     [ViewVariables(VVAccess.ReadWrite), DataField("rewards", customTypeSerializer: typeof(PrototypeIdListSerializer<EntityPrototype>))]
     public List<string> Rewards = default!;
     // End Frontier: expedition difficulty and rewards
+
+    /// <summary>
+    /// next time to check for autoabort
+    /// </summary>
+    [ViewVariables(VVAccess.ReadWrite), DataField]
+    public TimeSpan NextAutoAbortCheck = TimeSpan.Zero;
 }