413 lines
15 KiB
C#
413 lines
15 KiB
C#
using System.Linq;
|
|
using Content.Shared._Offbrand.StatusEffects;
|
|
using Content.Shared.Body.Components;
|
|
using Content.Shared.Body.Events;
|
|
using Content.Shared.Chemistry.EntitySystems;
|
|
using Content.Shared.FixedPoint;
|
|
using Content.Shared.Medical;
|
|
using Content.Shared.Random.Helpers;
|
|
using Content.Shared.Rejuvenate;
|
|
using Content.Shared.StatusEffectNew;
|
|
using Robust.Shared.Maths;
|
|
using Robust.Shared.Random;
|
|
using Robust.Shared.Timing;
|
|
|
|
namespace Content.Shared._Offbrand.Wounds;
|
|
|
|
public sealed partial class HeartSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly IGameTiming _timing = default!;
|
|
[Dependency] private readonly PainSystem _pain = default!;
|
|
[Dependency] private readonly SharedSolutionContainerSystem _solutionContainer = default!;
|
|
[Dependency] private readonly StatusEffectsSystem _statusEffects = default!;
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
SubscribeLocalEvent<HeartrateComponent, MapInitEvent>(OnMapInit);
|
|
SubscribeLocalEvent<HeartrateComponent, ComponentShutdown>(OnShutdown);
|
|
SubscribeLocalEvent<HeartrateComponent, ApplyMetabolicMultiplierEvent>(OnApplyMetabolicMultiplier);
|
|
SubscribeLocalEvent<HeartrateComponent, RejuvenateEvent>(OnRejuvenate);
|
|
|
|
SubscribeLocalEvent<HeartStopOnHighStrainComponent, HeartBeatEvent>(OnHeartBeatStrain);
|
|
SubscribeLocalEvent<HeartStopOnHighStrainComponent, BeforeTargetDefibrillatedEvent>(OnHeartBeatStrainMessage);
|
|
|
|
SubscribeLocalEvent<HeartDefibrillatableComponent, TargetDefibrillatedEvent>(OnTargetDefibrillated);
|
|
}
|
|
|
|
private void OnRejuvenate(Entity<HeartrateComponent> ent, ref RejuvenateEvent args)
|
|
{
|
|
ent.Comp.Damage = 0;
|
|
ent.Comp.Running = true;
|
|
Dirty(ent);
|
|
|
|
var overlays = new PotentiallyUpdateDamageOverlayEvent(ent);
|
|
RaiseLocalEvent(ent, ref overlays, true);
|
|
}
|
|
|
|
private void OnMapInit(Entity<HeartrateComponent> ent, ref MapInitEvent args)
|
|
{
|
|
ent.Comp.LastUpdate = _timing.CurTime;
|
|
}
|
|
|
|
private void OnShutdown(Entity<HeartrateComponent> ent, ref ComponentShutdown args)
|
|
{
|
|
_statusEffects.TryRemoveStatusEffect(ent, ent.Comp.HeartStoppedEffect);
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
var query = EntityQueryEnumerator<HeartrateComponent>();
|
|
while (query.MoveNext(out var uid, out var heartrate))
|
|
{
|
|
if (heartrate.LastUpdate is not { } last || last + heartrate.AdjustedUpdateInterval >= _timing.CurTime)
|
|
continue;
|
|
|
|
var delta = _timing.CurTime - last;
|
|
heartrate.LastUpdate = _timing.CurTime;
|
|
Dirty(uid, heartrate);
|
|
|
|
RecomputeVitals((uid, heartrate));
|
|
|
|
var strainChanged = new AfterStrainChangedEvent();
|
|
RaiseLocalEvent(uid, ref strainChanged);
|
|
|
|
var respiration = new ApplyRespiratoryRateModifiersEvent(ComputeRespiratoryRateModifier((uid, heartrate)), ComputeExhaleEfficiencyModifier((uid, heartrate)));
|
|
RaiseLocalEvent(uid, ref respiration);
|
|
|
|
if (!heartrate.Running)
|
|
continue;
|
|
|
|
var evt = new HeartBeatEvent(false);
|
|
RaiseLocalEvent(uid, ref evt);
|
|
|
|
if (!evt.Stop)
|
|
{
|
|
var threshold = heartrate.StrainDamageThresholds.HighestMatch(Strain((uid, heartrate)));
|
|
if (threshold is (var chance, var amount))
|
|
{
|
|
var seed = SharedRandomExtensions.HashCodeCombine(new() { (int)_timing.CurTick.Value, GetNetEntity(uid).Id });
|
|
var rand = new System.Random(seed);
|
|
|
|
if (rand.Prob(chance))
|
|
{
|
|
heartrate.Damage = FixedPoint2.Min(heartrate.Damage + amount, heartrate.MaxDamage);
|
|
}
|
|
|
|
if (heartrate.Damage >= heartrate.MaxDamage)
|
|
{
|
|
evt.Stop = true;
|
|
}
|
|
Dirty(uid, heartrate);
|
|
}
|
|
}
|
|
|
|
|
|
if (evt.Stop)
|
|
{
|
|
StopHeart((uid, heartrate));
|
|
continue;
|
|
}
|
|
|
|
var overlays = new PotentiallyUpdateDamageOverlayEvent(uid);
|
|
RaiseLocalEvent(uid, ref overlays, true);
|
|
}
|
|
}
|
|
|
|
private void StopHeart(Entity<HeartrateComponent> ent)
|
|
{
|
|
ent.Comp.Running = false;
|
|
Dirty(ent);
|
|
|
|
var stoppedEvt = new HeartStoppedEvent();
|
|
RaiseLocalEvent(ent, ref stoppedEvt);
|
|
|
|
_statusEffects.TryUpdateStatusEffectDuration(ent.Owner, ent.Comp.HeartStoppedEffect, out _);
|
|
}
|
|
|
|
public void KillHeart(Entity<HeartrateComponent?> ent)
|
|
{
|
|
if (!Resolve(ent, ref ent.Comp, false))
|
|
return;
|
|
|
|
ent.Comp.Damage = ent.Comp.MaxDamage;
|
|
ent.Comp.Running = false;
|
|
Dirty(ent);
|
|
|
|
var stoppedEvt = new HeartStoppedEvent();
|
|
RaiseLocalEvent(ent, ref stoppedEvt);
|
|
|
|
_statusEffects.TryUpdateStatusEffectDuration(ent, ent.Comp.HeartStoppedEffect, out _);
|
|
}
|
|
|
|
private void OnApplyMetabolicMultiplier(Entity<HeartrateComponent> ent, ref ApplyMetabolicMultiplierEvent args)
|
|
{
|
|
ent.Comp.UpdateIntervalMultiplier = args.Multiplier;
|
|
Dirty(ent);
|
|
}
|
|
|
|
private void OnHeartBeatStrain(Entity<HeartStopOnHighStrainComponent> ent, ref HeartBeatEvent args)
|
|
{
|
|
var seed = SharedRandomExtensions.HashCodeCombine(new() { (int)_timing.CurTick.Value, GetNetEntity(ent).Id });
|
|
var rand = new System.Random(seed);
|
|
|
|
if (_statusEffects.HasEffectComp<PreventHeartStopFromStrainStatusEffectComponent>(ent))
|
|
return;
|
|
|
|
var strain = Strain((ent.Owner, Comp<HeartrateComponent>(ent)));
|
|
args.Stop = args.Stop || rand.Prob(ent.Comp.Chance) && strain > ent.Comp.Threshold;
|
|
}
|
|
|
|
private void OnHeartBeatStrainMessage(Entity<HeartStopOnHighStrainComponent> ent, ref BeforeTargetDefibrillatedEvent args)
|
|
{
|
|
if (_statusEffects.HasEffectComp<PreventHeartStopFromStrainStatusEffectComponent>(ent))
|
|
return;
|
|
|
|
var heartrate = Comp<HeartrateComponent>(ent);
|
|
|
|
var volume = ComputeBloodVolume((ent.Owner, heartrate));
|
|
var tone = ComputeVascularTone((ent.Owner, heartrate));
|
|
var perfusion = MathF.Min(volume, tone);
|
|
var function = ComputeLungFunction((ent.Owner, heartrate));
|
|
var supply = function * perfusion;
|
|
var demand = ComputeMetabolicRate((ent.Owner, heartrate));
|
|
var compensation = ComputeCompensation((ent.Owner, heartrate), supply, demand);
|
|
var strain = heartrate.CompensationStrainCoefficient * compensation + heartrate.CompensationStrainConstant;
|
|
|
|
if (strain < ent.Comp.Threshold)
|
|
return;
|
|
|
|
args.Messages.Add(ent.Comp.Warning);
|
|
}
|
|
|
|
public void ChangeHeartDamage(Entity<HeartrateComponent?> ent, FixedPoint2 amount)
|
|
{
|
|
if (!Resolve(ent, ref ent.Comp, false))
|
|
return;
|
|
|
|
var newValue = FixedPoint2.Clamp(ent.Comp.Damage + amount, FixedPoint2.Zero, ent.Comp.MaxDamage);
|
|
if (newValue == ent.Comp.Damage)
|
|
return;
|
|
|
|
ent.Comp.Damage = newValue;
|
|
Dirty(ent);
|
|
|
|
if (newValue >= ent.Comp.MaxDamage && ent.Comp.Running)
|
|
{
|
|
StopHeart((ent.Owner, ent.Comp));
|
|
}
|
|
}
|
|
|
|
private void RecomputeVitals(Entity<HeartrateComponent> ent)
|
|
{
|
|
var volume = ComputeBloodVolume(ent);
|
|
var tone = ComputeVascularTone(ent);
|
|
|
|
var perfusion = MathF.Min(volume, MathF.Min(tone, CardiacOutput(ent)));
|
|
|
|
var function = ComputeLungFunction(ent);
|
|
|
|
var supply = function * perfusion;
|
|
|
|
var demand = ComputeMetabolicRate(ent);
|
|
|
|
var compensation = ComputeCompensation(ent, supply, demand);
|
|
|
|
perfusion *= compensation;
|
|
supply = function * perfusion;
|
|
|
|
ent.Comp.Perfusion = perfusion;
|
|
ent.Comp.Compensation = compensation;
|
|
ent.Comp.OxygenSupply = supply;
|
|
ent.Comp.OxygenDemand = demand;
|
|
|
|
Dirty(ent);
|
|
}
|
|
|
|
[Access(typeof(HeartSystem), typeof(HeartrateComponent))]
|
|
public float CardiacOutput(Entity<HeartrateComponent> ent)
|
|
{
|
|
var baseEv = new BaseCardiacOutputEvent(!ent.Comp.Running ? 0f : 1f - (ent.Comp.Damage.Float() / ent.Comp.MaxDamage.Float()));
|
|
RaiseLocalEvent(ent, ref baseEv);
|
|
|
|
var modifiedEv = new ModifiedCardiacOutputEvent(baseEv.Output);
|
|
RaiseLocalEvent(ent, ref modifiedEv);
|
|
|
|
return Math.Max(modifiedEv.Output, ent.Comp.MinimumCardiacOutput);
|
|
}
|
|
|
|
[Access(typeof(HeartSystem), typeof(HeartrateComponent))]
|
|
public float ComputeCompensation(Entity<HeartrateComponent> ent, float supply, float demand)
|
|
{
|
|
var invert = MathF.Log(demand / supply);
|
|
if (!float.IsFinite(invert))
|
|
throw new InvalidOperationException($"demand/supply {demand}/{supply} is not finite: {invert}");
|
|
|
|
var targetCompensation = ent.Comp.CompensationCoefficient * invert + ent.Comp.CompensationConstant;
|
|
var healthFactor = !ent.Comp.Running ? 0f : 1f - (ent.Comp.Damage.Float() / ent.Comp.MaxDamage.Float());
|
|
|
|
return Math.Max(targetCompensation * healthFactor, 1f);
|
|
}
|
|
|
|
[Access(typeof(HeartSystem), typeof(HeartrateComponent))]
|
|
public float ComputeBloodVolume(Entity<HeartrateComponent> ent)
|
|
{
|
|
var bloodstream = Comp<BloodstreamComponent>(ent);
|
|
if (!_solutionContainer.ResolveSolution(ent.Owner, bloodstream.BloodSolutionName,
|
|
ref bloodstream.BloodSolution, out var bloodSolution))
|
|
{
|
|
return 1f;
|
|
}
|
|
|
|
return Math.Max(bloodSolution.Volume.Float() / bloodSolution.MaxVolume.Float(), ent.Comp.MinimumBloodVolume);
|
|
}
|
|
|
|
[Access(typeof(HeartSystem), typeof(HeartrateComponent))]
|
|
public float ComputeVascularTone(Entity<HeartrateComponent> ent)
|
|
{
|
|
var baseEv = new BaseVascularToneEvent(1f);
|
|
RaiseLocalEvent(ent, ref baseEv);
|
|
|
|
var modifiedEv = new ModifiedVascularToneEvent(baseEv.Tone);
|
|
RaiseLocalEvent(ent, ref modifiedEv);
|
|
|
|
return Math.Max(modifiedEv.Tone, ent.Comp.MinimumVascularTone);
|
|
}
|
|
|
|
[Access(typeof(HeartSystem), typeof(HeartrateComponent))]
|
|
public float ComputeMetabolicRate(Entity<HeartrateComponent> ent)
|
|
{
|
|
var baseEv = new BaseMetabolicRateEvent(1f);
|
|
RaiseLocalEvent(ent, ref baseEv);
|
|
|
|
var modifiedEv = new ModifiedMetabolicRateEvent(baseEv.Rate);
|
|
RaiseLocalEvent(ent, ref modifiedEv);
|
|
|
|
return modifiedEv.Rate;
|
|
}
|
|
|
|
[Access(typeof(HeartSystem), typeof(HeartrateComponent))]
|
|
public float ComputeLungFunction(Entity<HeartrateComponent> ent)
|
|
{
|
|
var baseEv = new BaseLungFunctionEvent(1f);
|
|
RaiseLocalEvent(ent, ref baseEv);
|
|
|
|
var modifiedEv = new ModifiedLungFunctionEvent(baseEv.Function);
|
|
RaiseLocalEvent(ent, ref modifiedEv);
|
|
|
|
return Math.Max(modifiedEv.Function, ent.Comp.MinimumLungFunction);
|
|
}
|
|
|
|
private float OxygenBalance(Entity<HeartrateComponent> ent)
|
|
{
|
|
return ent.Comp.OxygenSupply / ent.Comp.OxygenDemand;
|
|
}
|
|
|
|
public float Strain(Entity<HeartrateComponent> ent)
|
|
{
|
|
return Math.Max(ent.Comp.CompensationStrainCoefficient * ent.Comp.Compensation + ent.Comp.CompensationStrainConstant, 0f);
|
|
}
|
|
|
|
public int HeartRate(Entity<HeartrateComponent> ent)
|
|
{
|
|
if (!ent.Comp.Running)
|
|
return 0;
|
|
|
|
var seed = SharedRandomExtensions.HashCodeCombine(new() { (int)_timing.CurTick.Value, GetNetEntity(ent).Id });
|
|
var rand = new System.Random(seed);
|
|
|
|
var deviation = rand.Next(-ent.Comp.HeartRateDeviation, ent.Comp.HeartRateDeviation);
|
|
|
|
return Math.Max((int)MathHelper.Lerp(ent.Comp.HeartRateFullPerfusion, ent.Comp.HeartRateNoPerfusion, Strain(ent)) + deviation, 0);
|
|
}
|
|
|
|
public (int, int) BloodPressure(Entity<HeartrateComponent> ent)
|
|
{
|
|
var seed = SharedRandomExtensions.HashCodeCombine(new() { (int)_timing.CurTick.Value, GetNetEntity(ent).Id });
|
|
var rand = new System.Random(seed);
|
|
|
|
var deviationA = rand.Next(-ent.Comp.BloodPressureDeviation, ent.Comp.BloodPressureDeviation);
|
|
var deviationB = rand.Next(-ent.Comp.BloodPressureDeviation, ent.Comp.BloodPressureDeviation);
|
|
|
|
var upper = (int)Math.Max((ent.Comp.SystolicBase * ent.Comp.Perfusion + deviationA), 0);
|
|
var lower = (int)Math.Max((ent.Comp.DiastolicBase * ent.Comp.Perfusion + deviationB), 0);
|
|
|
|
return (upper, lower);
|
|
}
|
|
|
|
public int Etco2(Entity<HeartrateComponent> ent)
|
|
{
|
|
var seed = SharedRandomExtensions.HashCodeCombine(new() { (int)_timing.CurTick.Value, GetNetEntity(ent).Id });
|
|
var rand = new System.Random(seed);
|
|
|
|
var deviation = rand.Next(-ent.Comp.Etco2Deviation, ent.Comp.Etco2Deviation);
|
|
|
|
var baseEtco2 = ent.Comp.Etco2Base * ComputeExhaleEfficiencyModifier(ent);
|
|
|
|
return Math.Max((int)baseEtco2 + deviation, 0);
|
|
}
|
|
|
|
public float ComputeExhaleEfficiencyModifier(Entity<HeartrateComponent> ent)
|
|
{
|
|
return Math.Max(ent.Comp.Perfusion, ent.Comp.MinimumPerfusionEtco2Modifier) * ComputeRespiratoryRateModifier(ent);
|
|
}
|
|
|
|
public float ComputeRespiratoryRateModifier(Entity<HeartrateComponent> ent)
|
|
{
|
|
var balance = ent.Comp.OxygenSupply / ent.Comp.OxygenDemand;
|
|
var rate = Math.Max(1f/(ent.Comp.RespiratoryRateCoefficient * balance) + ent.Comp.RespiratoryRateConstant, ent.Comp.MinimumRespiratoryRateModifier);
|
|
|
|
var modifiedEv = new ModifiedRespiratoryRateEvent(rate);
|
|
RaiseLocalEvent(ent, ref modifiedEv);
|
|
|
|
return modifiedEv.Rate;
|
|
}
|
|
|
|
public int RespiratoryRate(Entity<HeartrateComponent> ent)
|
|
{
|
|
var breathDuration = ent.Comp.RespiratoryRateNormalBreath * ComputeRespiratoryRateModifier(ent);
|
|
if (breathDuration <= 0f)
|
|
return 0;
|
|
|
|
return (int)(60f / breathDuration);
|
|
}
|
|
|
|
public FixedPoint2 Spo2(Entity<HeartrateComponent> ent)
|
|
{
|
|
return FixedPoint2.Clamp(OxygenBalance(ent), 0, 1);
|
|
}
|
|
|
|
public void TryRestartHeart(Entity<HeartrateComponent?> ent)
|
|
{
|
|
if (!Resolve(ent, ref ent.Comp, false))
|
|
return;
|
|
|
|
if (ent.Comp.MaxDamage <= ent.Comp.Damage || ent.Comp.Running)
|
|
return;
|
|
|
|
ent.Comp.Running = true;
|
|
Dirty(ent);
|
|
|
|
_statusEffects.TryRemoveStatusEffect(ent.Owner, ent.Comp.HeartStoppedEffect);
|
|
|
|
var evt = new HeartStartedEvent();
|
|
RaiseLocalEvent(ent, ref evt);
|
|
}
|
|
|
|
private void OnTargetDefibrillated(Entity<HeartDefibrillatableComponent> ent, ref TargetDefibrillatedEvent args)
|
|
{
|
|
TryRestartHeart(ent.Owner);
|
|
}
|
|
|
|
public bool IsCritical(Entity<HeartrateComponent?> ent)
|
|
{
|
|
if (!Resolve(ent, ref ent.Comp, false))
|
|
return false;
|
|
|
|
return !ent.Comp.Running;
|
|
}
|
|
}
|