CatStation/Content.Shared/Medical/VomitSystem.cs

using Content.Shared.Body;
using Content.Shared.Body.Components;
using Content.Shared.Body.Systems;
using Content.Shared.Chemistry.Components;
using Content.Shared.Chemistry.EntitySystems;
using Content.Shared.Chemistry.Reagent;
using Content.Shared.Fluids;
using Content.Shared.Forensics.Systems;
using Content.Shared.IdentityManagement;
using Content.Shared.Mobs.Systems;
using Content.Shared.Movement.Systems;
using Content.Shared.Nutrition.Components;
using Content.Shared.Nutrition.EntitySystems;
using Content.Shared.Nutrition.Prototypes;
using Content.Shared.Popups;
using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Network;
using Robust.Shared.Prototypes;

namespace Content.Shared.Medical;

public sealed partial class VomitSystem : EntitySystem
{
    [Dependency] private INetManager _netManager = default!;
    [Dependency] private MobStateSystem _mobState = default!;
    [Dependency] private MovementModStatusSystem _movementMod = default!;
    [Dependency] private SharedAudioSystem _audio = default!;
    [Dependency] private SharedBloodstreamSystem _bloodstream = default!;
    [Dependency] private SharedForensicsSystem _forensics = default!;
    [Dependency] private SharedPopupSystem _popup = default!;
    [Dependency] private SharedPuddleSystem _puddle = default!;
    [Dependency] private SatiationSystem _satiation = default!;
    [Dependency] private SharedSolutionContainerSystem _solutionContainer = default!;

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

        SubscribeLocalEvent<StomachComponent, BodyRelayedEvent<TryVomitEvent>>(TryVomitSolution);
    }

    private const float ChemMultiplier = 0.1f;

    private static readonly ProtoId<SoundCollectionPrototype> VomitCollection = "Vomit";

    private static readonly ProtoId<ReagentPrototype> VomitPrototype = "Vomit";  // TODO: Dehardcode vomit prototype

    private readonly SoundSpecifier _vomitSound = new SoundCollectionSpecifier(VomitCollection,
        AudioParams.Default.WithVariation(0.2f).WithVolume(-4f));

    private void TryVomitSolution(Entity<StomachComponent> ent, ref BodyRelayedEvent<TryVomitEvent> args)
    {
        if (!_solutionContainer.ResolveSolution(ent.Owner,
                StomachSystem.DefaultSolutionName,
                ref ent.Comp.Solution,
                out var sol))
            return;

        // Empty stomach solution into the new vomit solution
        args.Args.Sol.AddSolution(sol, ProtoMan);
        sol.RemoveAllSolution();

        // Remind the stomach that it's empty.
        _solutionContainer.UpdateChemicals(ent.Comp.Solution.Value);
        args.Args = args.Args with { Handled = true };
    }

    /// <summary>
    /// Make an entity vomit, if they have a stomach.
    /// </summary>
    public void Vomit(EntityUid uid, float thirstAdded = -40f, float hungerAdded = -40f, bool force = false)
    {
        // Vomit only if entity is alive
        // Ignore condition if force was set to true
        if (!force && _mobState.IsDead(uid))
            return;

        // TODO: Need decals
        var solution = new Solution();

        var ev = new TryVomitEvent(solution, force);
        RaiseLocalEvent(uid, ref ev);

        if (!ev.Handled)
            return;

        // Vomiting makes you hungrier and thirstier
        if (TryComp<SatiationComponent>(uid, out var satiation))
        {
            Entity<SatiationComponent> entity = (uid, satiation);
            _satiation.ModifyValue(entity, SatiationSystem.Hunger, hungerAdded);
            _satiation.ModifyValue(entity, SatiationSystem.Thirst, thirstAdded);
        }

        // It fully empties the stomach, this amount from the chem stream is relatively small
        var solutionSize = (MathF.Abs(thirstAdded) + MathF.Abs(hungerAdded)) / 6;

        // Apply a bit of slowdown
        _movementMod.TryUpdateMovementSpeedModDuration(uid, MovementModStatusSystem.VomitingSlowdown, TimeSpan.FromSeconds(solutionSize), 0.5f);

        // Adds a tiny amount of the chem stream from earlier along with vomit
        if (TryComp<BloodstreamComponent>(uid, out var bloodStream))
        {
            var vomitAmount = solutionSize;

            // Flushes small portion of the chemicals removed from the bloodstream stream
            if (_solutionContainer.ResolveSolution(uid, bloodStream.BloodSolutionName, ref bloodStream.BloodSolution))
            {
                var vomitChemstreamAmount = _bloodstream.FlushChemicals((uid, bloodStream), vomitAmount);

                if (vomitChemstreamAmount != null)
                {
                    vomitChemstreamAmount.ScaleSolution(ChemMultiplier);
                    solution.AddSolution(vomitChemstreamAmount, ProtoMan);
                    vomitAmount -= (float)vomitChemstreamAmount.Volume;
                }
            }

            // Makes a vomit solution the size of 90% of the chemicals removed from the chemstream
            solution.AddReagent(new ReagentId(VomitPrototype, _bloodstream.GetEntityBloodData((uid, bloodStream))), vomitAmount);
        }

        if (_puddle.TrySpillAt(uid, solution, out var puddle, false))
        {
            _forensics.TransferDna(puddle, uid, false);
        }


        if (!_netManager.IsServer)
            return;

        // Force sound to play as spill doesn't work if solution is empty.
        _audio.PlayPvs(_vomitSound, uid);
        _popup.PopupEntity(Loc.GetString("disease-vomit", ("person", Identity.Entity(uid, EntityManager))), uid);
    }
}

[ByRefEvent]
public record struct TryVomitEvent(Solution Sol, bool Forced = false, bool Handled = false);