CosCult 2.6 [ HOTFIX ] (ss14Starlight#4784)

## Short description
<!-- What do you propose to change with your PR? -->
Some CosCult fixes and tweaks.

Includes Bible working on rifts again and Colossus Visibility fix so
marked as Hotfix
Also includes some missing FTL, Stopping peeps from putting welding fuel
in the censer, Guidebook fix, And more robust herald revoting

Also generalizes reagent filtering at review request.

Generalizes Nullspace Stabilization into the normal anomaly system and
makes Shadekin anoms cleared with only it. (This sucked to do)
Cosmic Rifts are also essentially normal anomalies and there random
spawn is much rarer.
## Why we need to add this
<!-- What is the reason for adding these changes? Please post links to
Discussions as well as Bug Reports here. Please describe how this will
change the game balance. -->
Bugfixes and Requested changes
## Media (Video/Screenshots)
<!--
If your PR contains in-game changes you must provide screenshots/videos
of the changes.
-->
<img width="311" height="92" alt="image"
src="https://github.com/user-attachments/assets/d7d6f6fb-85f6-4480-83d7-b9868f19a70f"
/>
<img width="353" height="390" alt="image"
src="https://github.com/user-attachments/assets/b666a4e2-9acc-47b5-b8d6-a5f7c3fc15c5"
/>
<img width="349" height="394" alt="image"
src="https://github.com/user-attachments/assets/fbac050f-94f4-4fa3-8113-5adb0804c8b2"
/>


## Checks
<!-- check boxes for faster reviewing of your PR -->

- [X] I do not require assistance to complete the PR.
- [X] Before posting/requesting review of a PR, I have verified that the
changes work.
- [ ] I have added screenshots/videos of the changes, or this PR does
not change in-game mechanics.
- [X] I affirm that my changes are licensed under the [MIT
License](https://github.com/ss14Starlight/space-station-14/blob/Starlight/LICENSE.TXT)
and grant permission for use in this repository under its conditions.

**Changelog**
<!--
If you want the players to know about changes made in this PR, specify
them using the template outside the comment. Short and informative.

:cl: STARLIGHT TEAM
- add: Added Starlight.
- remove: Removed SS13.
- tweak: Changed SS14.
- fix: Fixed Rinary.
-->
:cl: CrazyPhantom
- fix: You can no longer put incorrect fluids in the Censer (Its holy
water only you buffoons).
- fix: Added missing CosCult localization's.
- tweak: Herald Re voting is now more robust and covers more situations.
- fix: Some overlooked errors in the CosCult guidebook.
- fix: Reverted accidental removal of Bible's being able to remove
rifts.
- fix: Colossus is no longer invisible to most.
- tweak: Nullspace Stabilizer Particles are now used to remove Shadekin
anomalies.
- tweak: Cosmic Cult rifts are now scannable and can be found with an
anomaly locator.
- tweak: Increased Do-After for Malign Rifts to 60s.
- tweak: (NOT DONE IN THIS PR, Just a PSA) Forgot to list it but Cosmic
Rifts now spawn naturally. They do not need the cult to spawn.

---------

Co-authored-by: Your Name <you@example.com>

Author: CrazyPhantom779

Content.Server/Anomaly/AnomalyScannerSystem.cs

@@ -59,8 +59,13 @@ public void UpdateScannerUi(EntityUid uid, AnomalyScannerComponent? component =
             return;
 
         TimeSpan? nextPulse = null;
-        if (TryComp<AnomalyComponent>(component.ScannedAnomaly, out var anomalyComponent))
+        // Starlight edit Start
+        if (TryComp<AnomalyComponent>(component.ScannedAnomaly, out var anomalyComponent) &&
+            anomalyComponent.CanPulse)
+        {
             nextPulse = anomalyComponent.NextPulseTime;
+        }
+        // Starlight edit End
 
         var state = new AnomalyScannerUserInterfaceState(_anomaly.GetScannerMessage(component), nextPulse);
         UI.SetUiState(uid, AnomalyScannerUiKey.Key, state);

Content.Server/Anomaly/AnomalySystem.cs

@@ -18,6 +18,14 @@
 using Robust.Shared.Prototypes;
 using Robust.Shared.Random;
 using Robust.Shared.Utility;
+#region Starlight
+using Content.Shared.DoAfter;
+using Content.Shared.Projectiles;
+using Content.Shared.Singularity.Components;
+using Content.Server.Singularity.EntitySystems;
+using Content.Shared.Power.EntitySystems;
+using Content.Shared._Starlight.CosmicCult.Components;
+#endregion
 
 namespace Content.Server.Anomaly;
 
@@ -39,6 +47,11 @@ public sealed partial class AnomalySystem : SharedAnomalySystem
     [Dependency] private readonly RadiationSystem _radiation = default!;
     [Dependency] private readonly SharedAudioSystem _audio = default!;
     [Dependency] private readonly UserInterfaceSystem _ui = default!;
+    #region Starlight
+    [Dependency] private SharedDoAfterSystem _doAfter = default!;
+    [Dependency] private EmitterSystem _emitter = default!;
+    [Dependency] private SharedPowerReceiverSystem _powerReceiver = default!;
+    #endregion
 
     public const float MinParticleVariation = 0.8f;
     public const float MaxParticleVariation = 1.2f;
@@ -53,6 +66,9 @@ public override void Initialize()
         SubscribeLocalEvent<AnomalyComponent, ComponentShutdown>(OnShutdown);
         SubscribeLocalEvent<AnomalyComponent, StartCollideEvent>(OnStartCollide);
         SubscribeLocalEvent<AnomalyStabilityChangedEvent>(OnVesselAnomalyStabilityChanged);
+        #region Starlight
+        SubscribeLocalEvent<AnomalyComponent, AnomalyParticleInteractionDoAfterEvent>(OnParticleInteractionDoAfter);
+        #endregion
 
         InitializeGenerator();
         InitializeVessel();
@@ -61,13 +77,22 @@ public override void Initialize()
 
     private void OnMapInit(Entity<AnomalyComponent> anomaly, ref MapInitEvent args)
     {
-        anomaly.Comp.NextPulseTime = Timing.CurTime + GetPulseLength(anomaly.Comp) * 3; // longer the first time
+        // Starlight edit Start
+        if (anomaly.Comp.CanPulse)
+            anomaly.Comp.NextPulseTime = Timing.CurTime + GetPulseLength(anomaly.Comp) * 3; // longer the first time
+        // Starlight edit End
         ChangeAnomalyStability(anomaly, Random.NextFloat(anomaly.Comp.InitialStabilityRange.Item1 , anomaly.Comp.InitialStabilityRange.Item2), anomaly.Comp);
         ChangeAnomalySeverity(anomaly, Random.NextFloat(anomaly.Comp.InitialSeverityRange.Item1, anomaly.Comp.InitialSeverityRange.Item2), anomaly.Comp);
 
-        ShuffleParticlesEffect(anomaly);
+        // Starlight edit Start
+        if (anomaly.Comp.ShuffleParticlesOnMapInit)
+            ShuffleParticlesEffect(anomaly);
+
         anomaly.Comp.Continuity = _random.NextFloat(anomaly.Comp.MinContituty, anomaly.Comp.MaxContituty);
-        SetBehavior(anomaly, GetRandomBehavior());
+
+        if (anomaly.Comp.RandomBehaviorOnMapInit)
+            SetBehavior(anomaly, GetRandomBehavior());
+        // Starlight edit End
     }
 
     public void ShuffleParticlesEffect(Entity<AnomalyComponent> anomaly)
@@ -112,26 +137,38 @@ private void OnStartCollide(Entity<AnomalyComponent> anomaly, ref StartCollideEv
         // small function to randomize because it's easier to read like this
         float VaryValue(float v) => v * behaviorMod * Random.NextFloat(MinParticleVariation, MaxParticleVariation);
 
-        if (particle.ParticleType == anomaly.Comp.DestabilizingParticleType || particle.DestabilzingOverride)
+        #region Starlight Edit
+        if (anomaly.Comp.UseNormalUnstableParticle &&
+            (particle.ParticleType == anomaly.Comp.DestabilizingParticleType || particle.DestabilzingOverride))
         {
             ChangeAnomalyStability(anomaly, VaryValue(particle.StabilityPerDestabilizingHit), anomaly.Comp);
         }
-        if (particle.ParticleType == anomaly.Comp.SeverityParticleType || particle.SeverityOverride)
+
+        if (anomaly.Comp.UseNormalDangerParticle &&
+            (particle.ParticleType == anomaly.Comp.SeverityParticleType || particle.SeverityOverride))
         {
             ChangeAnomalySeverity(anomaly, VaryValue(particle.SeverityPerSeverityHit), anomaly.Comp);
         }
-        if (particle.ParticleType == anomaly.Comp.WeakeningParticleType || particle.WeakeningOverride)
+
+        if (anomaly.Comp.UseNormalContainmentParticle &&
+            (particle.ParticleType == anomaly.Comp.WeakeningParticleType || particle.WeakeningOverride))
         {
             ChangeAnomalyHealth(anomaly, VaryValue(particle.HealthPerWeakeningeHit), anomaly.Comp);
             ChangeAnomalyStability(anomaly, VaryValue(particle.StabilityPerWeakeningeHit), anomaly.Comp);
         }
-        if (particle.ParticleType == anomaly.Comp.TransformationParticleType || particle.TransmutationOverride)
+
+        if (anomaly.Comp.UseNormalTransformationParticle &&
+            (particle.ParticleType == anomaly.Comp.TransformationParticleType || particle.TransmutationOverride))
         {
             ChangeAnomalySeverity(anomaly, VaryValue(particle.SeverityPerSeverityHit), anomaly.Comp);
+
             if (_random.Prob(anomaly.Comp.Continuity))
                 SetBehavior(anomaly, GetRandomBehavior());
         }
 
+        TryStartParticleInteraction(anomaly, particle, args.OtherEntity);
+        #endregion
+
         var ev = new AnomalyAffectedByParticleEvent(anomaly, args.OtherEntity);
         RaiseLocalEvent(anomaly, ref ev);
     }
@@ -223,6 +260,165 @@ private void RemoveBehavior(Entity<AnomalyComponent> anomaly, ProtoId<AnomalyBeh
 
         EntityManager.RemoveComponents(anomaly, behavior.Components);
     }
+
+    #region Starlight
+    private void TryStartParticleInteraction(
+        Entity<AnomalyComponent> anomaly,
+        AnomalousParticleComponent particle,
+        EntityUid particleUid)
+    {
+        if (anomaly.Comp.ParticleInteractions.Count == 0)
+            return;
+
+        if (_doAfter.IsRunning(anomaly.Comp.ParticleInteractionDoAfter))
+            return;
+
+        var interactionIndex = GetMatchingParticleInteraction(anomaly.Comp, particle);
+
+        if (interactionIndex == null)
+            return;
+
+        var interaction = anomaly.Comp.ParticleInteractions[interactionIndex.Value];
+
+        if (!TryComp<ProjectileComponent>(particleUid, out var projectile) ||
+            projectile.Shooter is not { } shooter)
+            return;
+
+        var source = GetPoweredNullspaceStabilizerSource(shooter);
+        if (source == null)
+            return;
+
+        if (interaction.Delay <= TimeSpan.Zero)
+        {
+            ApplyParticleInteraction(anomaly, interaction, shooter);
+            return;
+        }
+
+        var doAfterArgs = new DoAfterArgs(
+            EntityManager,
+            shooter,
+            interaction.Delay,
+            new AnomalyParticleInteractionDoAfterEvent(),
+            anomaly,
+            anomaly)
+        {
+            NeedHand = false,
+            BreakOnWeightlessMove = true,
+            BreakOnMove = true,
+            BreakOnHandChange = false,
+            BreakOnDropItem = false,
+            BreakOnDamage = false,
+            RequireCanInteract = false,
+            DistanceThreshold = interaction.DistanceThreshold,
+        };
+
+        if (!_doAfter.TryStartDoAfter(doAfterArgs, out var doAfterId))
+            return;
+
+        anomaly.Comp.ParticleInteractionDoAfter = doAfterId;
+        anomaly.Comp.ActiveParticleInteraction = interactionIndex;
+        anomaly.Comp.ActiveParticleInteractionSource = shooter;
+
+        source.DoAfterId = doAfterId;
+    }
+
+    private static int? GetMatchingParticleInteraction(
+        AnomalyComponent anomaly,
+        AnomalousParticleComponent particle)
+    {
+        for (var i = 0; i < anomaly.ParticleInteractions.Count; i++)
+        {
+            var interaction = anomaly.ParticleInteractions[i];
+
+            if (interaction.InteractionKey != null &&
+                interaction.InteractionKey == particle.InteractionKey)
+                return i;
+
+            if (interaction.ParticleType != null &&
+                interaction.ParticleType == particle.ParticleType)
+                return i;
+        }
+
+        return null;
+    }
+
+    private void OnParticleInteractionDoAfter(
+        Entity<AnomalyComponent> anomaly,
+        ref AnomalyParticleInteractionDoAfterEvent args)
+    {
+        var source = anomaly.Comp.ActiveParticleInteractionSource;
+
+        anomaly.Comp.ParticleInteractionDoAfter = null;
+        anomaly.Comp.ActiveParticleInteractionSource = null;
+
+        if (source is { } sourceUid &&
+            TryComp<CosmicLambdaParticleSourceComponent>(sourceUid, out var sourceComp))
+        {
+            sourceComp.DoAfterId = null;
+        }
+
+        if (args.Cancelled || args.Handled)
+        {
+            anomaly.Comp.ActiveParticleInteraction = null;
+            return;
+        }
+
+        args.Handled = true;
+
+        if (anomaly.Comp.ActiveParticleInteraction is not { } index ||
+            index < 0 ||
+            index >= anomaly.Comp.ParticleInteractions.Count)
+        {
+            anomaly.Comp.ActiveParticleInteraction = null;
+            return;
+        }
+
+        var interaction = anomaly.Comp.ParticleInteractions[index];
+
+        anomaly.Comp.ActiveParticleInteraction = null;
+
+        ApplyParticleInteraction(anomaly, interaction, args.User);
+    }
+
+    private void ApplyParticleInteraction(
+        Entity<AnomalyComponent> anomaly,
+        AnomalyParticleInteraction interaction,
+        EntityUid user)
+    {
+        var coords = Transform(anomaly).Coordinates;
+
+        if (TryComp<EmitterComponent>(user, out var emitter))
+            _emitter.PowerOff(user, emitter);
+
+        if (interaction.VisualEffect is { } effectProto)
+            Spawn(effectProto, coords);
+
+        if (interaction.Sound is { } sound)
+            _audio.PlayPvs(sound, coords);
+
+        switch (interaction.Effect)
+        {
+            case AnomalyParticleInteractionEffect.EndAnomaly:
+                EndAnomaly(anomaly, anomaly.Comp, spawnCore: interaction.SpawnCore);
+
+                if (interaction.DeleteEntityAfterEnd && !TerminatingOrDeleted(anomaly.Owner))
+                    QueueDel(anomaly.Owner);
+
+                break;
+
+            case AnomalyParticleInteractionEffect.DeleteEntity:
+                QueueDel(anomaly);
+                break;
+        }
+    }
+
+    private CosmicLambdaParticleSourceComponent? GetPoweredNullspaceStabilizerSource(EntityUid uid)
+        => !TryComp<CosmicLambdaParticleSourceComponent>(uid, out var source)
+        ? null : !_powerReceiver.IsPowered(uid)
+        ? null : source;
+
+    #endregion
+
     #endregion
 
     #region Information
@@ -318,7 +514,13 @@ public FormattedMessage GetScannerMessage(AnomalyScannerComponent component)
             msg.AddMarkupOrThrow(Loc.GetString("anomaly-scanner-particle-containment-unknown"));
         else
         {
-            var text = Loc.GetString("anomaly-scanner-particle-containment", ("type", GetParticleLocale(anomalyComp.WeakeningParticleType)));
+            // Starlight edit Start
+            var particleName = anomalyComp.ScannerContainmentParticleReadout is { } containmentReadout
+                ? Loc.GetString(containmentReadout)
+                : GetParticleLocale(anomalyComp.WeakeningParticleType);
+
+            var text = Loc.GetString("anomaly-scanner-particle-containment", ("type", particleName));
+            // Starlight edit End
             if (secret != null && secret.Secret.Contains(AnomalySecretData.ParticleContainment))
                 text += " " + Loc.GetString("anomaly-secret-admin");
             msg.AddMarkupOrThrow(text);

Content.Server/Anomaly/Effects/SecretDataAnomalySystem.cs

@@ -16,6 +16,11 @@ public override void Initialize()
 
     private void OnMapInit(EntityUid uid, SecretDataAnomalyComponent anomaly, MapInitEvent args)
     {
+        // Starlight Start
+        if (anomaly.RandomStartSecretMin <= 0 && anomaly.RandomStartSecretMax <= 0)
+            return;
+        // Starlight End
+
         RandomizeSecret(uid,_random.Next(anomaly.RandomStartSecretMin, anomaly.RandomStartSecretMax), anomaly);
     }