Anomalies (#13371)

Content.Server/Anomaly/Effects/ElectricityAnomalySystem.cs

@@ -0,0 +1,61 @@
+using Content.Server.Electrocution;
+using Content.Server.Lightning;
+using Content.Server.Power.Components;
+using Content.Shared.Anomaly.Components;
+using Content.Shared.Anomaly.Effects.Components;
+using Content.Shared.Mobs.Components;
+using Content.Shared.StatusEffect;
+using Robust.Shared.Random;
+
+namespace Content.Server.Anomaly.Effects;
+
+public sealed class ElectricityAnomalySystem : EntitySystem
+{
+    [Dependency] private readonly IRobustRandom _random = default!;
+    [Dependency] private readonly LightningSystem _lightning = default!;
+    [Dependency] private readonly ElectrocutionSystem _electrocution = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<ElectricityAnomalyComponent, AnomalyPulseEvent>(OnPulse);
+        SubscribeLocalEvent<ElectricityAnomalyComponent, AnomalySupercriticalEvent>(OnSupercritical);
+    }
+
+    private void OnPulse(EntityUid uid, ElectricityAnomalyComponent component, ref AnomalyPulseEvent args)
+    {
+        var range = component.MaxElectrocuteRange * args.Stabiltiy;
+        var damage = (int) (component.MaxElectrocuteDamage * args.Severity);
+        var duration = component.MaxElectrocuteDuration * args.Severity;
+
+        var xform = Transform(uid);
+        foreach (var comp in _lookup.GetComponentsInRange<StatusEffectsComponent>(xform.MapPosition, range))
+        {
+            var ent = comp.Owner;
+
+            _electrocution.TryDoElectrocution(ent, uid, damage, duration, true, statusEffects: comp, ignoreInsulation: true);
+        }
+    }
+
+    private void OnSupercritical(EntityUid uid, ElectricityAnomalyComponent component, ref AnomalySupercriticalEvent args)
+    {
+        var poweredQuery = GetEntityQuery<ApcPowerReceiverComponent>();
+        var mobQuery = GetEntityQuery<MobThresholdsComponent>();
+        var validEnts = new HashSet<EntityUid>();
+        foreach (var ent in _lookup.GetEntitiesInRange(uid, component.MaxElectrocuteRange * 2))
+        {
+            if (mobQuery.HasComponent(ent))
+                validEnts.Add(ent);
+
+            if (_random.Prob(0.1f) && poweredQuery.HasComponent(ent))
+                validEnts.Add(ent);
+        }
+
+        // goodbye, sweet perf
+        foreach (var ent in validEnts)
+        {
+            _lightning.ShootLightning(uid, ent);
+        }
+    }
+}

Content.Server/Anomaly/Effects/GravityAnomalySystem.cs

@@ -0,0 +1,39 @@
+using Content.Server.Singularity.Components;
+using Content.Shared.Anomaly.Components;
+using Content.Shared.Anomaly.Effects;
+using Content.Shared.Anomaly.Effects.Components;
+using Content.Shared.Radiation.Components;
+
+namespace Content.Server.Anomaly.Effects;
+
+/// <summary>
+/// This handles logic and events relating to <see cref="GravityAnomalyComponent"/> and <seealso cref="AnomalySystem"/>
+/// </summary>
+public sealed class GravityAnomalySystem : SharedGravityAnomalySystem
+{
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<GravityAnomalyComponent, AnomalySeverityChangedEvent>(OnSeverityChanged);
+        SubscribeLocalEvent<GravityAnomalyComponent, AnomalyStabilityChangedEvent>(OnStabilityChanged);
+    }
+
+    private void OnSeverityChanged(EntityUid uid, GravityAnomalyComponent component, ref AnomalySeverityChangedEvent args)
+    {
+        if (TryComp<RadiationSourceComponent>(uid, out var radSource))
+            radSource.Intensity = component.MaxRadiationIntensity * args.Severity;
+
+        if (!TryComp<GravityWellComponent>(uid, out var gravityWell))
+            return;
+        var accel = (component.MaxAccel - component.MinAccel) * args.Severity + component.MinAccel;
+        gravityWell.BaseRadialAcceleration = accel;
+        gravityWell.BaseTangentialAcceleration = accel * 0.2f;
+    }
+
+    private void OnStabilityChanged(EntityUid uid, GravityAnomalyComponent component, ref AnomalyStabilityChangedEvent args)
+    {
+        if (TryComp<GravityWellComponent>(uid, out var gravityWell))
+            gravityWell.MaxRange = component.MaxGravityWellRange * args.Stability;
+    }
+}

Content.Server/Anomaly/Effects/PyroclasticAnomalySystem.cs

@@ -0,0 +1,100 @@
+using Content.Server.Atmos.Components;
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Interaction;
+using Content.Shared.Anomaly.Components;
+using Content.Shared.Anomaly.Effects.Components;
+using Robust.Server.GameObjects;
+using Robust.Shared.Map;
+
+namespace Content.Server.Anomaly.Effects;
+
+/// <summary>
+/// This handles <see cref="PyroclasticAnomalyComponent"/> and the events from <seealso cref="AnomalySystem"/>
+/// </summary>
+public sealed class PyroclasticAnomalySystem : EntitySystem
+{
+    [Dependency] private readonly AtmosphereSystem _atmosphere = default!;
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly FlammableSystem _flammable = default!;
+    [Dependency] private readonly InteractionSystem _interaction = default!;
+    [Dependency] private readonly TransformSystem _xform = default!;
+
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<PyroclasticAnomalyComponent, AnomalyPulseEvent>(OnPulse);
+        SubscribeLocalEvent<PyroclasticAnomalyComponent, AnomalySupercriticalEvent>(OnSupercritical);
+    }
+
+    private void OnPulse(EntityUid uid, PyroclasticAnomalyComponent component, ref AnomalyPulseEvent args)
+    {
+        var xform = Transform(uid);
+        var ignitionRadius = component.MaximumIgnitionRadius * args.Stabiltiy;
+        IgniteNearby(xform.Coordinates, args.Severity, ignitionRadius);
+    }
+
+    private void OnSupercritical(EntityUid uid, PyroclasticAnomalyComponent component, ref AnomalySupercriticalEvent args)
+    {
+        var xform = Transform(uid);
+        var grid = xform.GridUid;
+        var map = xform.MapUid;
+
+        var indices = _xform.GetGridOrMapTilePosition(uid, xform);
+        var mixture = _atmosphere.GetTileMixture(grid, map, indices, true);
+
+        if (mixture == null)
+            return;
+        mixture.AdjustMoles(component.SupercriticalGas, component.SupercriticalMoleAmount);
+        if (grid is { })
+        {
+            foreach (var ind in _atmosphere.GetAdjacentTiles(grid.Value, indices))
+            {
+                var mix = _atmosphere.GetTileMixture(grid, map, indices, true);
+                if (mix is not {})
+                    continue;
+                mix.AdjustMoles(component.SupercriticalGas, component.SupercriticalMoleAmount);
+                mix.Temperature += component.HotspotExposeTemperature;
+                _atmosphere.HotspotExpose(grid.Value, indices, component.HotspotExposeTemperature, mix?.Volume ?? component.SupercriticalMoleAmount, true);
+            }
+        }
+        IgniteNearby(xform.Coordinates, 1, component.MaximumIgnitionRadius * 2);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        foreach (var (pyro, anom, xform) in EntityQuery<PyroclasticAnomalyComponent, AnomalyComponent, TransformComponent>())
+        {
+            var ent = pyro.Owner;
+
+            var grid = xform.GridUid;
+            var map = xform.MapUid;
+            var indices = _xform.GetGridOrMapTilePosition(ent, xform);
+            var mixture = _atmosphere.GetTileMixture(grid, map, indices, true);
+            if (mixture is { })
+            {
+                mixture.Temperature += pyro.HeatPerSecond * anom.Severity * frameTime;
+            }
+
+            if (grid != null && anom.Severity > pyro.AnomalyHotspotThreshold)
+            {
+                _atmosphere.HotspotExpose(grid.Value, indices, pyro.HotspotExposeTemperature, pyro.HotspotExposeVolume, true);
+            }
+        }
+    }
+
+    public void IgniteNearby(EntityCoordinates coordinates, float severity, float radius)
+    {
+        foreach (var flammable in _lookup.GetComponentsInRange<FlammableComponent>(coordinates, radius))
+        {
+            var ent = flammable.Owner;
+            if (!_interaction.InRangeUnobstructed(coordinates.ToMap(EntityManager), ent, -1))
+                continue;
+
+            var stackAmount = 1 + (int) (severity / 0.25f);
+            _flammable.AdjustFireStacks(ent, stackAmount, flammable);
+            _flammable.Ignite(ent, flammable);
+        }
+    }
+}