Ивентовый контент NDA/Terror spider

Content.Server/Imperial/SCP/SCP008/Components/SCP008InfectionAuraComponent.cs

@@ -0,0 +1,37 @@
+// usings moved to file-level globals; removed unused using
+
+namespace Content.Server.Imperial.SCP.SCP008.Components;
+
+[RegisterComponent]
+public sealed partial class SCP008InfectionAuraComponent : Component
+{
+    [DataField("radius")]
+    public float Radius = 8f;
+
+    [DataField("zombifyDelay")]
+    public TimeSpan ZombifyDelay = TimeSpan.FromSeconds(12);
+
+    [DataField("updateInterval")]
+    public TimeSpan UpdateInterval = TimeSpan.FromSeconds(1);
+
+    [DataField("lookupFlags")]
+    public LookupFlags LookupFlags = LookupFlags.Dynamic;
+
+    [DataField("allowCritical")]
+    public bool AllowCritical = false;
+
+    [DataField("warningDelay")]
+    public TimeSpan WarningDelay = TimeSpan.FromSeconds(3);
+
+    [DataField("warningPopup")]
+    public LocId WarningPopup = "scp008-warning-popup";
+
+    [ViewVariables]
+    public TimeSpan NextUpdate;
+
+    [ViewVariables]
+    public TimeSpan LastUpdate;
+
+    [ViewVariables]
+    public Dictionary<EntityUid, TimeSpan> ExposureTime = new();
+}

Content.Server/Imperial/SCP/SCP008/Systems/SCP008InfectionAuraSystem.cs

@@ -0,0 +1,119 @@
+using Content.Server.Imperial.SCP.SCP008.Components;
+using Content.Server.Zombies;
+using Content.Shared.Mobs;
+using Content.Shared.Mobs.Components;
+using Content.Shared.Popups;
+using Content.Shared.Zombies;
+using Robust.Shared.Timing;
+using Robust.Shared.Localization;
+
+namespace Content.Server.Imperial.SCP.SCP008.Systems;
+
+public sealed class SCP008InfectionAuraSystem : EntitySystem
+{
+    private readonly HashSet<EntityUid> _reusableInRange = new();
+    [Dependency] private readonly EntityLookupSystem _lookup = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly ZombieSystem _zombie = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+
+        SubscribeLocalEvent<SCP008InfectionAuraComponent, MapInitEvent>(OnMapInit);
+        SubscribeLocalEvent<SCP008InfectionAuraComponent, ComponentShutdown>(OnShutdown);
+    }
+
+    private void OnMapInit(Entity<SCP008InfectionAuraComponent> ent, ref MapInitEvent args)
+    {
+        ent.Comp.LastUpdate = _timing.CurTime;
+        ent.Comp.NextUpdate = _timing.CurTime + ent.Comp.UpdateInterval;
+        ent.Comp.ExposureTime.Clear();
+    }
+
+    private void OnShutdown(Entity<SCP008InfectionAuraComponent> ent, ref ComponentShutdown args)
+    {
+        ent.Comp.ExposureTime.Clear();
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var curTime = _timing.CurTime;
+        var query = EntityQueryEnumerator<SCP008InfectionAuraComponent>();
+
+        while (query.MoveNext(out var uid, out var comp))
+        {
+            if (comp.NextUpdate > curTime)
+                continue;
+
+            var elapsed = curTime - comp.LastUpdate;
+            comp.LastUpdate = curTime;
+            comp.NextUpdate = curTime + comp.UpdateInterval;
+
+            if (elapsed <= TimeSpan.Zero)
+                continue;
+
+            _reusableInRange.Clear();
+            var nearbyEntities = _lookup.GetEntitiesInRange(uid, comp.Radius, comp.LookupFlags);
+
+            foreach (var target in nearbyEntities)
+            {
+                if (target == uid)
+                    continue;
+
+                if (!TryComp<MobStateComponent>(target, out var mobState))
+                    continue;
+
+                var validState = mobState.CurrentState == MobState.Alive ||
+                                 (comp.AllowCritical && mobState.CurrentState == MobState.Critical);
+
+                if (!validState)
+                    continue;
+
+                if (HasComp<ZombieComponent>(target) || HasComp<ZombieImmuneComponent>(target))
+                    continue;
+
+                _reusableInRange.Add(target);
+
+                var totalExposure = elapsed;
+                var previousExposure = TimeSpan.Zero;
+                if (comp.ExposureTime.TryGetValue(target, out var existingExposure))
+                {
+                    previousExposure = existingExposure;
+                    totalExposure += previousExposure;
+                }
+
+                var warningStart = comp.ZombifyDelay - comp.WarningDelay;
+                if (warningStart < TimeSpan.Zero)
+                    warningStart = TimeSpan.Zero;
+
+                if (previousExposure < warningStart && totalExposure >= warningStart && totalExposure < comp.ZombifyDelay)
+                    _popup.PopupEntity(Loc.GetString(comp.WarningPopup), target, target, PopupType.MediumCaution);
+
+                if (totalExposure >= comp.ZombifyDelay)
+                {
+                    _zombie.ZombifyEntity(target, mobState);
+                    comp.ExposureTime.Remove(target);
+                    continue;
+                }
+
+                comp.ExposureTime[target] = totalExposure;
+            }
+
+            var toRemove = new List<EntityUid>();
+            foreach (var (tracked, _) in comp.ExposureTime)
+            {
+                if (!_reusableInRange.Contains(tracked))
+                    toRemove.Add(tracked);
+            }
+
+            foreach (var tracked in toRemove)
+            {
+                comp.ExposureTime.Remove(tracked);
+            }
+        }
+    }
+}

Content.Server/Imperial/SCP/SCP096/Components/SCP096RageOnLookComponent.cs

@@ -0,0 +1,73 @@
+using Robust.Shared.Audio;
+
+namespace Content.Server.Imperial.SCP.SCP096.Components;
+
+[RegisterComponent]
+public sealed partial class SCP096RageOnLookComponent : Component
+{
+    [DataField("observeRadius")]
+    public float ObserveRadius = 9f;
+
+    [DataField("minLookDot")]
+    public float MinLookDot = 0.42f;
+
+    [DataField("requireUnobstructed")]
+    public bool RequireUnobstructed = true;
+
+    [DataField("enragedWalkModifier")]
+    public float EnragedWalkModifier = 1.7f;
+
+    [DataField("enragedSprintModifier")]
+    public float EnragedSprintModifier = 1.7f;
+
+    [DataField("enragedAttackRate")]
+    public float EnragedAttackRate = 1.7f;
+
+    [DataField("calmAttackRate")]
+    public float CalmAttackRate = 1.0f;
+
+    [DataField("rageWindup")]
+    public TimeSpan RageWindup = TimeSpan.FromSeconds(10);
+
+    [DataField("rageDuration")]
+    public TimeSpan RageDuration = TimeSpan.FromSeconds(120);
+
+    [DataField("rageWindupPopup")]
+    public LocId RageWindupPopup = "scp096-rage-windup-popup";
+
+    [DataField("ragePopup")]
+    public LocId RagePopup = "scp096-rage-popup";
+
+    [DataField("rageCalmPopup")]
+    public LocId RageCalmPopup = "scp096-rage-calm-popup";
+
+    [DataField("rageSound")]
+    public SoundSpecifier RageSound = new SoundPathSpecifier("/Audio/Voice/Human/malescream_1.ogg");
+
+    [DataField("cryingSound")]
+    public SoundSpecifier CryingSound = new SoundPathSpecifier("/Audio/Voice/Human/cry_male_1.ogg");
+
+    [DataField("rageLoopSound")]
+    public SoundSpecifier RageLoopSound = new SoundPathSpecifier("/Audio/Ambience/Objects/anomaly_generator_ambi.ogg");
+
+    [ViewVariables]
+    public bool IsEnraged;
+
+    [ViewVariables]
+    public bool IsRageWindup;
+
+    [ViewVariables]
+    public TimeSpan RageWindupEndTime;
+
+    [ViewVariables]
+    public TimeSpan RageEndTime;
+
+    [ViewVariables]
+    public bool UsingRageLoopSound;
+
+    [ViewVariables]
+    public float? OriginalAttackRate;
+
+    [ViewVariables]
+    public HashSet<EntityUid> RageTargets = new();
+}

Content.Server/Imperial/SCP/SCP096/Components/SCP096RageSuppressorComponent.cs

@@ -0,0 +1,6 @@
+namespace Content.Server.Imperial.SCP.SCP096.Components;
+
+[RegisterComponent]
+public sealed partial class SCP096RageSuppressorComponent : Component
+{
+}