Addictions 2 electric boogaloo

Content.Server/DeltaV/Addictions/AddictionSystem.cs

@@ -0,0 +1,123 @@
+using Content.Shared.DeltaV.Addictions;
+using Content.Shared.Popups;
+using Content.Shared.StatusEffect;
+using Robust.Server.Player;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Random;
+using Robust.Shared.Timing;
+
+namespace Content.Server.DeltaV.Addictions;
+
+public sealed class AddictionSystem : SharedAddictionSystem
+{
+    [Dependency] private readonly SharedPopupSystem _popupSystem = default!;
+    [Dependency] private readonly IGameTiming _timing = default!;
+    [Dependency] private readonly IPlayerManager _playerManager = default!;
+    [Dependency] private readonly IRobustRandom _random = default!;
+
+    private readonly Dictionary<EntityUid, TimeSpan> _nextEffectTime = new();
+
+    // Define the numbers, we're not making another DeepFryerSystem.cs
+    // Minimum time between popups
+    private const int MinEffectInterval = 10;
+
+    // Maximum time between popups
+    private const int MaxEffectInterval = 41;
+
+    public override void Initialize()
+    {
+        base.Initialize();
+        SubscribeLocalEvent<AddictedComponent, ComponentShutdown>(OnShutdown);
+    }
+
+    public override void Update(float frameTime)
+    {
+        base.Update(frameTime);
+
+        var curTime = _timing.CurTime;
+        var query = EntityQueryEnumerator<AddictedComponent>();
+
+        while (query.MoveNext(out var uid, out var component))
+        {
+            // If it's suppressed, check if it's still supposed to be
+            if (component.Suppressed)
+            {
+                UpdateSuppressed(uid, component);
+                continue;
+            }
+
+            if (!_nextEffectTime.TryGetValue(uid, out var nextTime))
+            {
+                // Between 10 and 40 seconds
+                _nextEffectTime[uid] = curTime + TimeSpan.FromSeconds(_random.Next(MinEffectInterval, MaxEffectInterval));
+                continue;
+            }
+
+            if (curTime < nextTime)
+                continue;
+
+            DoAddictionEffect(uid);
+            _nextEffectTime[uid] = curTime + TimeSpan.FromSeconds(_random.Next(MinEffectInterval, MaxEffectInterval));
+        }
+    }
+
+    private void OnShutdown(EntityUid uid, AddictedComponent component, ComponentShutdown args)
+    {
+        _nextEffectTime.Remove(uid);
+    }
+
+    private void UpdateSuppressed(EntityUid uid, AddictedComponent component)
+    {
+        var componentTime = component.LastMetabolismTime + TimeSpan.FromSeconds(10); // Ten seconds after the last metabolism cycle
+        if (componentTime > _timing.CurTime)
+        {
+            component.Suppressed = true;
+            Dirty(uid, component);
+        }
+        else
+        {
+            component.Suppressed = false;
+            Dirty(uid, component);
+        }
+    }
+
+    private string GetRandomPopup()
+    {
+        return _random.Pick(new[]
+        {
+            Loc.GetString("reagent-effect-medaddiction-1"),
+            Loc.GetString("reagent-effect-medaddiction-2"),
+            Loc.GetString("reagent-effect-medaddiction-3"),
+            Loc.GetString("reagent-effect-medaddiction-4"),
+            Loc.GetString("reagent-effect-medaddiction-5"),
+            Loc.GetString("reagent-effect-medaddiction-6"),
+            Loc.GetString("reagent-effect-medaddiction-7"),
+            Loc.GetString("reagent-effect-medaddiction-8")
+        });
+    }
+
+    public override void TryApplyAddiction(EntityUid uid, float addictionTime, StatusEffectsComponent? status = null)
+    {
+        base.TryApplyAddiction(uid, addictionTime, status);
+    }
+
+    protected override void DoAddictionEffect(EntityUid uid)
+    {
+        if (_playerManager.TryGetSessionByEntity(uid, out var session))
+        {
+            _popupSystem.PopupEntity(GetRandomPopup(), uid, session);
+        }
+    }
+
+    // Called each time a reagent with the Addicted effect gets metabolized
+    protected override void UpdateTime(EntityUid uid)
+    {
+        if (TryComp<AddictedComponent>((uid), out var component))
+        {
+            component.LastMetabolismTime = _timing.CurTime;
+            UpdateSuppressed(uid, component);
+        }
+        else
+            return;
+    }
+}

Content.Server/DeltaV/EntityEffects/Effects/Addicted.cs

@@ -0,0 +1,29 @@
+using Content.Shared.DeltaV.Addictions;
+using Content.Shared.EntityEffects;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.EntityEffects.Effects;
+
+public sealed partial class Addicted : EntityEffect
+{
+    /// <summary>
+    ///     How long should each metabolism cycle make the effect last for.
+    /// </summary>
+    [DataField]
+    public float AddictionTime = 3f;
+
+    protected override string? ReagentEffectGuidebookText(IPrototypeManager prototype, IEntitySystemManager entSys)
+        => Loc.GetString("reagent-effect-guidebook-addicted", ("chance", Probability));
+
+    public override void Effect(EntityEffectBaseArgs args)
+    {
+        var addictionTime = AddictionTime;
+
+        if (args is EntityEffectReagentArgs reagentArgs) {
+            addictionTime *= reagentArgs.Scale.Float();
+        }
+
+        var addictionSystem = args.EntityManager.EntitySysManager.GetEntitySystem<SharedAddictionSystem>();
+        addictionSystem.TryApplyAddiction(args.TargetEntity, addictionTime);
+    }
+}

Content.Shared/DeltaV/Addictions/AddictedComponent.cs

@@ -0,0 +1,21 @@
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Timing;
+
+namespace Content.Shared.DeltaV.Addictions;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class AddictedComponent : Component
+{
+    /// <summary>
+    ///     Whether to suppress pop-ups.
+    /// </summary>
+    [DataField]
+    public bool Suppressed;
+
+    /// <summary>
+    ///     The <see cref="IGameTiming.CurTime"/> timestamp of last StatusEffect trigger.
+    /// </summary>
+    [DataField(serverOnly: true)]
+    public TimeSpan? LastMetabolismTime;
+}

Content.Shared/DeltaV/Addictions/SharedAddictionSystem.cs

@@ -0,0 +1,40 @@
+
+using Content.Shared.DeltaV.Addictions;
+using Content.Shared.StatusEffect;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+
+namespace Content.Shared.DeltaV.Addictions;
+
+public abstract class SharedAddictionSystem : EntitySystem
+{
+    [Dependency] protected readonly StatusEffectsSystem StatusEffects = default!;
+
+    public ProtoId<StatusEffectPrototype> StatusEffectKey = "Addicted";
+
+    public override void Initialize()
+    {
+        base.Initialize();
+    }
+
+    protected abstract void DoAddictionEffect(EntityUid uid);
+
+    protected abstract void UpdateTime(EntityUid uid);
+
+    public virtual void TryApplyAddiction(EntityUid uid, float addictionTime, StatusEffectsComponent? status = null)
+    {
+        if (!Resolve(uid, ref status, false))
+            return;
+
+        UpdateTime(uid);
+
+        if (!StatusEffects.HasStatusEffect(uid, StatusEffectKey, status))
+        {
+            StatusEffects.TryAddStatusEffect<AddictedComponent>(uid, StatusEffectKey, TimeSpan.FromSeconds(addictionTime), true, status);
+        }
+        else
+        {
+            StatusEffects.TryAddTime(uid, StatusEffectKey, TimeSpan.FromSeconds(addictionTime), status);
+        }
+    }
+}

Resources/Locale/en-US/deltav/guidebook/chemistry/effects.ftl

@@ -0,0 +1,5 @@
+reagent-effect-guidebook-addicted =
+    { $chance ->
+        [1] Causes
+        *[other] cause
+    } an addiction.

Resources/Prototypes/DeltaV/status_effects.yml

@@ -0,0 +1,2 @@
+- type: statusEffect
+  id: Addicted

Resources/Prototypes/Entities/Mobs/Species/base.yml

@@ -138,6 +138,7 @@
     - Adrenaline
     - PsionicsDisabled #Nyano - Summary: PCs can have psionics disabled.
     - PsionicallyInsulated #Nyano - Summary: PCs can be made insulated from psionic powers.
+    - Addicted # DeltaV - Psych med addictions system
   - type: Body
     prototype: Human
     requiredLegs: 2