Anomaly Generator Tweaks (#13856)

Content.Server/Anomaly/AnomalySystem.Generator.cs

@@ -1,9 +1,11 @@
-using Content.Server.Anomaly.Components;
+using Content.Server.Anomaly.Components;
 using Content.Server.Power.Components;
 using Content.Server.Power.EntitySystems;
 using Content.Shared.Anomaly;
 using Content.Shared.CCVar;
 using Content.Shared.Materials;
+using Content.Shared.Radio;
+using Robust.Shared.Audio;
 using Content.Shared.Physics;
 using Robust.Shared.Map.Components;
 using Robust.Shared.Physics;
@@ -24,6 +26,9 @@ public sealed partial class AnomalySystem
         SubscribeLocalEvent<AnomalyGeneratorComponent, MaterialAmountChangedEvent>(OnGeneratorMaterialAmountChanged);
         SubscribeLocalEvent<AnomalyGeneratorComponent, AnomalyGeneratorGenerateButtonPressedEvent>(OnGenerateButtonPressed);
         SubscribeLocalEvent<AnomalyGeneratorComponent, PowerChangedEvent>(OnGeneratorPowerChanged);
+        SubscribeLocalEvent<AnomalyGeneratorComponent, EntityUnpausedEvent>(OnGeneratorUnpaused);
+        SubscribeLocalEvent<GeneratingAnomalyGeneratorComponent, ComponentStartup>(OnGeneratingStartup);
+        SubscribeLocalEvent<GeneratingAnomalyGeneratorComponent, EntityUnpausedEvent>(OnGeneratingUnpaused);
     }
 
     private void OnGeneratorPowerChanged(EntityUid uid, AnomalyGeneratorComponent component, ref PowerChangedEvent args)
@@ -46,6 +51,11 @@ public sealed partial class AnomalySystem
         TryGeneratorCreateAnomaly(uid, component);
     }
 
+    private void OnGeneratorUnpaused(EntityUid uid, AnomalyGeneratorComponent component, ref EntityUnpausedEvent args)
+    {
+        component.CooldownEndTime += args.PausedTime;
+    }
+
     public void UpdateGeneratorUi(EntityUid uid, AnomalyGeneratorComponent component)
     {
         var materialAmount = _material.GetMaterialAmount(uid, component.RequiredMaterial);
@@ -65,14 +75,12 @@ public sealed partial class AnomalySystem
         if (Timing.CurTime < component.CooldownEndTime)
             return;
 
-        var grid = Transform(uid).GridUid;
-        if (grid == null)
-            return;
-
         if (!_material.TryChangeMaterialAmount(uid, component.RequiredMaterial, -component.MaterialPerAnomaly))
             return;
 
-        SpawnOnRandomGridLocation(grid.Value, component.SpawnerPrototype);
+        var generating = EnsureComp<GeneratingAnomalyGeneratorComponent>(uid);
+        generating.EndTime = Timing.CurTime + component.GenerationLength;
+        generating.AudioStream = Audio.PlayPvs(component.GeneratingSound, uid, AudioParams.Default.WithLoop(true));
         component.CooldownEndTime = Timing.CurTime + component.CooldownLength;
         UpdateGeneratorUi(uid, component);
     }
@@ -126,4 +134,42 @@ public sealed partial class AnomalySystem
 
         Spawn(toSpawn, targetCoords);
     }
+
+    private void OnGeneratingStartup(EntityUid uid, GeneratingAnomalyGeneratorComponent component, ComponentStartup args)
+    {
+        Appearance.SetData(uid, AnomalyGeneratorVisuals.Generating, true);
+    }
+
+    private void OnGeneratingUnpaused(EntityUid uid, GeneratingAnomalyGeneratorComponent component, ref EntityUnpausedEvent args)
+    {
+        component.EndTime += args.PausedTime;
+    }
+
+    private void OnGeneratingFinished(EntityUid uid, AnomalyGeneratorComponent component)
+    {
+        var grid = Transform(uid).GridUid;
+        if (grid == null)
+            return;
+
+        SpawnOnRandomGridLocation(grid.Value, component.SpawnerPrototype);
+        RemComp<GeneratingAnomalyGeneratorComponent>(uid);
+        Appearance.SetData(uid, AnomalyGeneratorVisuals.Generating, false);
+        Audio.PlayPvs(component.GeneratingFinishedSound, uid);
+
+        var message = Loc.GetString("anomaly-generator-announcement");
+        _radio.SendRadioMessage(uid, message, _prototype.Index<RadioChannelPrototype>(component.ScienceChannel));
+    }
+
+    private void UpdateGenerator()
+    {
+        foreach (var (active, gen) in EntityQuery<GeneratingAnomalyGeneratorComponent, AnomalyGeneratorComponent>())
+        {
+            var ent = active.Owner;
+
+            if (Timing.CurTime < active.EndTime)
+                continue;
+            active.AudioStream?.Stop();
+            OnGeneratingFinished(ent, gen);
+        }
+    }
 }

Content.Server/Anomaly/AnomalySystem.cs

@@ -4,12 +4,15 @@ using Content.Server.Audio;
 using Content.Server.DoAfter;
 using Content.Server.Explosion.EntitySystems;
 using Content.Server.Materials;
+using Content.Server.Radio.EntitySystems;
 using Content.Shared.Anomaly;
 using Content.Shared.Anomaly.Components;
 using Robust.Server.GameObjects;
 using Robust.Shared.Configuration;
 using Robust.Shared.Physics.Events;
+using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
+
 namespace Content.Server.Anomaly;
 
 /// <summary>
@@ -18,11 +21,13 @@ namespace Content.Server.Anomaly;
 public sealed partial class AnomalySystem : SharedAnomalySystem
 {
     [Dependency] private readonly IConfigurationManager _configuration = default!;
+    [Dependency] private readonly IPrototypeManager _prototype = default!;
     [Dependency] private readonly AmbientSoundSystem _ambient = default!;
     [Dependency] private readonly AtmosphereSystem _atmosphere = default!;
     [Dependency] private readonly DoAfterSystem _doAfter = default!;
     [Dependency] private readonly ExplosionSystem _explosion = default!;
     [Dependency] private readonly MaterialStorageSystem _material = default!;
+    [Dependency] private readonly RadioSystem _radio = default!;
     [Dependency] private readonly UserInterfaceSystem _ui = default!;
 
     public const float MinParticleVariation = 0.8f;
@@ -128,6 +133,7 @@ public sealed partial class AnomalySystem : SharedAnomalySystem
     {
         base.Update(frameTime);
 
+        UpdateGenerator();
         UpdateVessels();
     }
 }

Content.Server/Anomaly/Components/AnomalyGeneratorComponent.cs

@@ -1,4 +1,6 @@
 using Content.Shared.Materials;
+using Content.Shared.Radio;
+using Robust.Shared.Audio;
 using Robust.Shared.Prototypes;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
 using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
@@ -24,6 +26,12 @@ public sealed class AnomalyGeneratorComponent : Component
     [DataField("cooldownLength"), ViewVariables(VVAccess.ReadWrite)]
     public TimeSpan CooldownLength = TimeSpan.FromMinutes(5);
 
+    /// <summary>
+    /// How long it takes to generate an anomaly after pushing the button.
+    /// </summary>
+    [DataField("generationLength"), ViewVariables(VVAccess.ReadWrite)]
+    public TimeSpan GenerationLength = TimeSpan.FromSeconds(8);
+
     /// <summary>
     /// The material needed to generate an anomaly
     /// </summary>
@@ -41,4 +49,22 @@ public sealed class AnomalyGeneratorComponent : Component
     /// </summary>
     [DataField("spawnerPrototype", customTypeSerializer: typeof(PrototypeIdSerializer<EntityPrototype>)), ViewVariables(VVAccess.ReadWrite)]
     public string SpawnerPrototype = "RandomAnomalySpawner";
+
+    /// <summary>
+    /// The radio channel for science
+    /// </summary>
+    [DataField("scienceChannel", customTypeSerializer: typeof(PrototypeIdSerializer<RadioChannelPrototype>))]
+    public string ScienceChannel = "Science";
+
+    /// <summary>
+    /// The sound looped while an anomaly generates
+    /// </summary>
+    [DataField("generatingSound")]
+    public SoundSpecifier? GeneratingSound;
+
+    /// <summary>
+    /// Sound played on generation completion.
+    /// </summary>
+    [DataField("generatingFinishedSound")]
+    public SoundSpecifier? GeneratingFinishedSound;
 }

Content.Server/Anomaly/Components/GeneratingAnomalyGeneratorComponent.cs

@@ -0,0 +1,16 @@
+using Robust.Shared.Audio;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom;
+
+namespace Content.Server.Anomaly.Components;
+
+[RegisterComponent]
+public sealed class GeneratingAnomalyGeneratorComponent : Component
+{
+    /// <summary>
+    /// When the generating period will end.
+    /// </summary>
+    [DataField("endTime", customTypeSerializer: typeof(TimeOffsetSerializer))]
+    public TimeSpan EndTime = TimeSpan.Zero;
+
+    public IPlayingAudioStream? AudioStream;
+}