Delta-v/Content.Server/_Goobstation/Religion/WeakToHolySystem.cs

// SPDX-FileCopyrightText: 2025 Aiden <28298836+Aidenkrz@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 GoobBot <uristmchands@proton.me>
// SPDX-FileCopyrightText: 2025 Solstice <solsticeofthewinter@gmail.com>
// SPDX-FileCopyrightText: 2025 SolsticeOfTheWinter <solsticeofthewinter@gmail.com>
// SPDX-FileCopyrightText: 2025 TheBorzoiMustConsume <197824988+TheBorzoiMustConsume@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 gluesniffler <159397573+gluesniffler@users.noreply.github.com>
// SPDX-FileCopyrightText: 2025 gluesniffler <linebarrelerenthusiast@gmail.com>
//
// SPDX-License-Identifier: AGPL-3.0-or-later

using System.Linq;
using Content.Shared._Goobstation.Religion;
using Content.Server._Goobstation.Bible;
using Content.Shared.Damage.Components;
using Content.Shared.Damage.Systems;
using Content.Shared.Interaction;
using Content.Shared.Inventory;
using Robust.Shared.Physics.Events;
using Robust.Shared.Timing;
using Content.Shared.Timing;
using Content.Server.Bible.Components;
using Content.Shared.Body;
using Content.Shared.Damage;
using Content.Shared.Damage.Prototypes;
using Content.Shared.FixedPoint;
using Robust.Shared.Prototypes;

namespace Content.Server._Goobstation.Religion;

public sealed class WeakToHolySystem : EntitySystem
{
    [Dependency] private readonly DamageableSystem _damageableSystem = default!;
    [Dependency] private readonly IGameTiming _timing = default!;
    [Dependency] private readonly GoobBibleSystem _goobBible = default!;
    [Dependency] private readonly UseDelaySystem _useDelay = default!;

    private static readonly ProtoId<DamageContainerPrototype> DamageContainerId = "BiologicalMetaphysical"; // Delta V - Metaphysical Biological for Holy Damage

    public override void Initialize()
    {
        base.Initialize();

        SubscribeLocalEvent<WeakToHolyComponent, InteractUsingEvent>(AfterBibleUse);
        SubscribeLocalEvent<WeakToHolyComponent, MapInitEvent>(OnInit); // DeltaV - Add damage set
        SubscribeLocalEvent<WeakToHolyComponent, ComponentRemove>(OnRemove); // DeltaV - Clean up on removal
    }


    // Begin DeltaV Additions - Holy Weakness
    private void OnInit(Entity<WeakToHolyComponent> ent, ref MapInitEvent args)
    {
        if (!TryComp<DamageableComponent>(ent, out var damageable))
            return;

        var dmg = _damageableSystem.GetPositiveDamage((ent, damageable));
        _damageableSystem.ChangeDamageContainer((ent, damageable), DamageContainerId); // Delta V - Changes the DamageContainer of the Entity from (presumably) Biological to BiologicalMetaphysical.
    }

    private void OnRemove(Entity<WeakToHolyComponent> ent, ref ComponentRemove args)
    {
        if (!TryComp<DamageableComponent>(ent, out var damageable))
            return;

        if (!ent.Comp.HadHolyWeakness)
        {
            var dmg = _damageableSystem.GetPositiveDamage((ent, damageable));
            dmg.DamageDict.TryGetValue("Holy", out var holyDmg);
            DamageSpecifier heal = new() {DamageDict = new Dictionary<ProtoId<DamageTypePrototype>, FixedPoint2>() {{ "Holy", -holyDmg }}};
            _damageableSystem.TryChangeDamage((ent, damageable), heal, ignoreResistances: true);
        }
    }
    // End DeltaV additions

    private void AfterBibleUse(Entity<WeakToHolyComponent> ent, ref InteractUsingEvent args)
    {
        if (!TryComp<BibleComponent>(args.Used, out var bibleComp))
            return;

        if (!TryComp(args.Used, out UseDelayComponent? useDelay)
            || _useDelay.IsDelayed((args.Used, useDelay))
            || !HasComp<BibleUserComponent>(args.User))
            return;

        _goobBible.TryDoSmite(args.Used, args.User, args.Target, useDelay);
    }

    #region Holy Healing
    public override void Update(float frameTime)
    {
        base.Update(frameTime);

        // Holy damage healing.
        var query = EntityQueryEnumerator<WeakToHolyComponent, BodyComponent>();
        while (query.MoveNext(out var uid, out var weakToHoly, out var body))
        {
            if (weakToHoly.NextPassiveHealTick > _timing.CurTime)
                continue;
            weakToHoly.NextPassiveHealTick = _timing.CurTime + weakToHoly.HealTickDelay;

            if (!TryComp<DamageableComponent>(uid, out var damageable))
                continue;

            var dmg = _damageableSystem.GetPositiveDamage((uid, damageable));

            if (TerminatingOrDeleted(uid)
                || !dmg.DamageDict.TryGetValue("Holy", out _))
                continue;

            // Rune healing.
            if (weakToHoly.IsColliding)
                _damageableSystem.TryChangeDamage(uid, weakToHoly.HealAmount, ignoreResistances: true);

            // Passive healing.
            _damageableSystem.TryChangeDamage(uid, weakToHoly.PassiveAmount, ignoreResistances: true);
        }
    }

    #endregion
}