Merge branch 'master' into replace-sounds-with-sound-specifier

Content.Server/Body/Behavior/LiverBehavior.cs

@@ -1,7 +1,6 @@
 using System.Linq;
 using Content.Server.Body.Circulatory;
 using Content.Shared.Body.Networks;
-using Content.Shared.Chemistry.Metabolizable;
 using Content.Shared.Chemistry.Reagent;
 using Robust.Shared.IoC;
 using Robust.Shared.Prototypes;
@@ -13,52 +12,8 @@ namespace Content.Server.Body.Behavior
     /// </summary>
     public class LiverBehavior : MechanismBehavior
     {
-        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-
         private float _accumulatedFrameTime;
 
-        /// <summary>
-        ///     Delay time that determines how often to metabolise blood contents (in seconds).
-        /// </summary>
-        private float _updateIntervalSeconds = 1.0f;
-
-        /// <summary>
-        ///     Whether the liver is functional.
-        /// </summary>
-        //[ViewVariables] private bool _liverFailing = false;
-
-        /// <summary>
-        ///     Modifier for alcohol damage.
-        /// </summary>
-        //[DataField("alcoholLethality")]
-        //[ViewVariables] private float _alcoholLethality = 0.005f;
-
-        /// <summary>
-        ///     Modifier for alcohol damage.
-        /// </summary>
-        //[DataField("alcoholExponent")]
-        //[ViewVariables] private float _alcoholExponent = 1.6f;
-
-        /// <summary>
-        ///     Toxin volume that can be purged without damage.
-        /// </summary>
-        //[DataField("toxinTolerance")]
-        //[ViewVariables] private float _toxinTolerance = 3f;
-
-        /// <summary>
-        ///     Toxin damage modifier.
-        /// </summary>
-        //[DataField("toxinLethality")]
-        //[ViewVariables] private float _toxinLethality = 0.01f;
-
-        /// <summary>
-        ///     Loops through each reagent in _internalSolution,
-        ///     and calls <see cref="IMetabolizable.Metabolize"/> for each of them.
-        ///     Also handles toxins and alcohol.
-        /// </summary>
-        /// <param name="frameTime">
-        ///     The time since the last update in seconds.
-        /// </param>
         public override void Update(float frameTime)
         {
             if (Body == null)
@@ -68,51 +23,13 @@ namespace Content.Server.Body.Behavior
 
             _accumulatedFrameTime += frameTime;
 
-            // Update at most once every _updateIntervalSeconds
-            if (_accumulatedFrameTime < _updateIntervalSeconds)
+            // Update at most once per second
+            if (_accumulatedFrameTime < 1)
             {
                 return;
             }
 
-            _accumulatedFrameTime -= _updateIntervalSeconds;
-
-            if (!Body.Owner.TryGetComponent(out BloodstreamComponent? bloodstream))
-            {
-                return;
-            }
-
-            if (bloodstream.Solution.CurrentVolume <= ReagentUnit.Zero)
-            {
-                return;
-            }
-
-            // Run metabolism for each reagent, remove metabolized reagents
-            // Using ToList here lets us edit reagents while iterating
-            foreach (var reagent in bloodstream.Solution.ReagentList.ToList())
-            {
-                if (!_prototypeManager.TryIndex(reagent.ReagentId, out ReagentPrototype? prototype))
-                {
-                    continue;
-                }
-
-                // How much reagent is available to metabolise?
-                // This needs to be passed to other functions that have metabolism rate information, such that they don't "overmetabolise" a reagent.
-                var availableReagent = bloodstream.Solution.Solution.GetReagentQuantity(reagent.ReagentId);
-
-                //TODO BODY Check if it's a Toxin. If volume < _toxinTolerance, just remove it. If greater, add damage = volume * _toxinLethality
-                //TODO BODY Check if it has BoozePower > 0. Affect drunkenness, apply damage. Proposed formula (SS13-derived): damage = sqrt(volume) * BoozePower^_alcoholExponent * _alcoholLethality / 10
-                //TODO BODY Liver failure.
-
-                //TODO Make sure reagent prototypes actually have the toxin and boozepower vars set.
-
-                // Run metabolism code for each reagent
-                foreach (var metabolizable in prototype.Metabolism)
-                {
-                    var reagentDelta = metabolizable.Metabolize(Body.Owner, reagent.ReagentId, _updateIntervalSeconds, availableReagent);
-                    bloodstream.Solution.TryRemoveReagent(reagent.ReagentId, reagentDelta);
-                    availableReagent -= reagentDelta;
-                }
-            }
+            _accumulatedFrameTime -= 1;
         }
     }
 }

Content.Server/Body/Circulatory/BloodstreamComponent.cs

@@ -2,8 +2,8 @@ using System;
 using System.Linq;
 using Content.Server.Atmos;
 using Content.Server.Atmos.EntitySystems;
+using Content.Server.Body.Respiratory;
 using Content.Server.Chemistry.Components;
-using Content.Server.Metabolism;
 using Content.Shared.Atmos;
 using Content.Shared.Body.Networks;
 using Content.Shared.Chemistry.Reagent;
@@ -72,7 +72,7 @@ namespace Content.Server.Body.Circulatory
         {
             var atmosphereSystem = EntitySystem.Get<AtmosphereSystem>();
 
-            if (!Owner.TryGetComponent(out MetabolismComponent? metabolism))
+            if (!Owner.TryGetComponent(out RespiratorComponent? metabolism))
             {
                 atmosphereSystem.Merge(to, Air);
                 Air.Clear();

Content.Server/Body/Metabolism/MetabolizerComponent.cs

@@ -0,0 +1,57 @@
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using Content.Shared.Chemistry.Reagent;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype.Dictionary;
+
+namespace Content.Server.Body.Metabolism
+{
+    /// <summary>
+    ///     Handles metabolizing various reagents with given effects.
+    /// </summary>
+    [RegisterComponent]
+    public class MetabolizerComponent : Component
+    {
+        public override string Name => "Metabolizer";
+
+        public float AccumulatedFrametime = 0.0f;
+
+        /// <summary>
+        ///     How often to metabolize reagents, in seconds.
+        /// </summary>
+        /// <returns></returns>
+        [DataField("updateFrequency")]
+        public float UpdateFrequency = 1.0f;
+
+        /// <summary>
+        ///     Whether this metabolizer should attempt to metabolize chemicals in its parent bodies' bloodstream,
+        ///     as opposed to a solution container on the metabolizing entity itself.
+        /// </summary>
+        [DataField("takeFromBloodstream")]
+        public bool TakeFromBloodstream = true;
+
+        /// <summary>
+        ///     A dictionary mapping reagent string IDs to a list of effects & associated metabolism rate.
+        /// </summary>
+        /// <returns></returns>
+        [DataField("metabolisms", required: true, customTypeSerializer:typeof(PrototypeIdDictionarySerializer<ReagentEffectsEntry, ReagentPrototype>))]
+        public Dictionary<string, ReagentEffectsEntry> Metabolisms = default!;
+    }
+
+    [DataDefinition]
+    public class ReagentEffectsEntry
+    {
+        /// <summary>
+        ///     Amount of reagent to metabolize, per metabolism cycle.
+        /// </summary>
+        [DataField("metabolismRate")]
+        public ReagentUnit MetabolismRate = ReagentUnit.New(1.0f);
+
+        /// <summary>
+        ///     A list of effects to apply when these reagents are metabolized.
+        /// </summary>
+        [DataField("effects", required: true)]
+        public ReagentEffect[] Effects = default!;
+    }
+}

Content.Server/Body/Metabolism/MetabolizerSystem.cs

@@ -0,0 +1,107 @@
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.Body.Circulatory;
+using Content.Server.Chemistry.Components;
+using Content.Shared.Body.Components;
+using Content.Shared.Body.Mechanism;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Chemistry.Solution;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Prototypes;
+
+namespace Content.Server.Body.Metabolism
+{
+    // TODO mirror in the future working on mechanisms move updating here to BodySystem so it can be ordered?
+    public class MetabolizerSystem : EntitySystem
+    {
+        public override void Update(float frameTime)
+        {
+            base.Update(frameTime);
+
+            foreach (var metab in ComponentManager.EntityQuery<MetabolizerComponent>(false))
+            {
+                metab.AccumulatedFrametime += frameTime;
+
+                // Only update as frequently as it should
+                if (metab.AccumulatedFrametime >= metab.UpdateFrequency)
+                {
+                    metab.AccumulatedFrametime = 0.0f;
+                    TryMetabolize(metab);
+                }
+            }
+        }
+
+        private void TryMetabolize(MetabolizerComponent comp)
+        {
+            var owner = comp.Owner;
+            var reagentList = new List<Solution.ReagentQuantity>();
+            SolutionContainerComponent? solution = null;
+            SharedBodyComponent? body = null;
+
+            // if this field is passed we should try and take from the bloodstream over anything else
+            if (comp.TakeFromBloodstream && owner.TryGetComponent<SharedMechanismComponent>(out var mech))
+            {
+                body = mech.Body;
+                if (body != null)
+                {
+                    if (body.Owner.TryGetComponent<BloodstreamComponent>(out var bloodstream)
+                        && bloodstream.Solution.CurrentVolume >= ReagentUnit.Zero)
+                    {
+                        solution = bloodstream.Solution;
+                        reagentList = bloodstream.Solution.ReagentList.ToList();
+                    }
+                }
+            }
+            else if (owner.TryGetComponent<SolutionContainerComponent>(out var sol))
+            {
+                // if we have no mechanism/body but a solution container instead,
+                // we'll just use that to metabolize from
+                solution = sol;
+                reagentList = sol.ReagentList.ToList();
+            }
+            if (solution == null || reagentList.Count == 0)
+            {
+                // We're all outta ideas on where to metabolize from
+                return;
+            }
+
+            // Run metabolism for each reagent, remove metabolized reagents
+            foreach (var reagent in reagentList)
+            {
+                if (!comp.Metabolisms.ContainsKey(reagent.ReagentId))
+                    continue;
+
+                var metabolism = comp.Metabolisms[reagent.ReagentId];
+                // Run metabolism code for each reagent
+                foreach (var effect in metabolism.Effects)
+                {
+                    var ent = body != null ? body.Owner : owner;
+                    var conditionsMet = true;
+                    if (effect.Conditions != null)
+                    {
+                        // yes this is 3 nested for loops, but all of these lists are
+                        // basically guaranteed to be small or empty
+                        foreach (var condition in effect.Conditions)
+                        {
+                            if (!condition.Condition(ent, reagent))
+                            {
+                                conditionsMet = false;
+                                break;
+                            }
+                        }
+                    }
+
+                    if (!conditionsMet)
+                        return;
+
+                    // If we're part of a body, pass that entity to Metabolize
+                    // Otherwise, just pass our owner entity, maybe we're a plant or something
+                    effect.Metabolize(ent, reagent);
+                }
+
+                solution.TryRemoveReagent(reagent.ReagentId, metabolism.MetabolismRate);
+            }
+        }
+    }
+}

Content.Server/Body/Respiratory/RespiratorComponent.cs

@@ -0,0 +1,402 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Content.Server.Alert;
+using Content.Server.Atmos;
+using Content.Server.Atmos.EntitySystems;
+using Content.Server.Body.Behavior;
+using Content.Server.Body.Circulatory;
+using Content.Server.Temperature.Components;
+using Content.Shared.ActionBlocker;
+using Content.Shared.Alert;
+using Content.Shared.Atmos;
+using Content.Shared.Body.Components;
+using Content.Shared.Damage;
+using Content.Shared.Damage.Components;
+using Content.Shared.MobState;
+using Content.Shared.Notification.Managers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Localization;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Body.Respiratory
+{
+    [RegisterComponent]
+    public class RespiratorComponent : Component
+    {
+        [ComponentDependency] private readonly SharedBodyComponent? _body = default!;
+
+        public override string Name => "Respirator";
+
+        private float _accumulatedFrameTime;
+
+        private bool _isShivering;
+        private bool _isSweating;
+
+        [ViewVariables(VVAccess.ReadWrite)] [DataField("suffocationDamage")] private int _suffocationDamage = 1;
+
+        [ViewVariables(VVAccess.ReadWrite)] [DataField("suffocationDamageRecovery")] private int _suffocationDamageRecovery = 1;
+
+        [ViewVariables] [DataField("needsGases")] public Dictionary<Gas, float> NeedsGases { get; set; } = new();
+
+        [ViewVariables] [DataField("producesGases")] public Dictionary<Gas, float> ProducesGases { get; set; } = new();
+
+        [ViewVariables] [DataField("deficitGases")] public Dictionary<Gas, float> DeficitGases { get; set; } = new();
+
+        /// <summary>
+        /// Heat generated due to metabolism. It's generated via metabolism
+        /// </summary>
+        [ViewVariables]
+        [DataField("metabolismHeat")]
+        public float MetabolismHeat { get; private set; }
+
+        /// <summary>
+        /// Heat output via radiation.
+        /// </summary>
+        [ViewVariables]
+        [DataField("radiatedHeat")]
+        public float RadiatedHeat { get; private set; }
+
+        /// <summary>
+        /// Maximum heat regulated via sweat
+        /// </summary>
+        [ViewVariables]
+        [DataField("sweatHeatRegulation")]
+        public float SweatHeatRegulation { get; private set; }
+
+        /// <summary>
+        /// Maximum heat regulated via shivering
+        /// </summary>
+        [ViewVariables]
+        [DataField("shiveringHeatRegulation")]
+        public float ShiveringHeatRegulation { get; private set; }
+
+        /// <summary>
+        /// Amount of heat regulation that represents thermal regulation processes not
+        /// explicitly coded.
+        /// </summary>
+        [DataField("implicitHeatRegulation")]
+        public float ImplicitHeatRegulation { get; private set; }
+
+        /// <summary>
+        /// Normal body temperature
+        /// </summary>
+        [ViewVariables]
+        [DataField("normalBodyTemperature")]
+        public float NormalBodyTemperature { get; private set; }
+
+        /// <summary>
+        /// Deviation from normal temperature for body to start thermal regulation
+        /// </summary>
+        [DataField("thermalRegulationTemperatureThreshold")]
+        public float ThermalRegulationTemperatureThreshold { get; private set; }
+
+        [ViewVariables] public bool Suffocating { get; private set; }
+
+        private Dictionary<Gas, float> NeedsAndDeficit(float frameTime)
+        {
+            var needs = new Dictionary<Gas, float>(NeedsGases);
+            foreach (var (gas, amount) in DeficitGases)
+            {
+                var newAmount = (needs.GetValueOrDefault(gas) + amount) * frameTime;
+                needs[gas] = newAmount;
+            }
+
+            return needs;
+        }
+
+        private void ClampDeficit()
+        {
+            var deficitGases = new Dictionary<Gas, float>(DeficitGases);
+
+            foreach (var (gas, deficit) in deficitGases)
+            {
+                if (!NeedsGases.TryGetValue(gas, out var need))
+                {
+                    DeficitGases.Remove(gas);
+                    continue;
+                }
+
+                if (deficit > need)
+                {
+                    DeficitGases[gas] = need;
+                }
+            }
+        }
+
+        private float SuffocatingPercentage()
+        {
+            var total = 0f;
+
+            foreach (var (gas, deficit) in DeficitGases)
+            {
+                var lack = 1f;
+                if (NeedsGases.TryGetValue(gas, out var needed))
+                {
+                    lack = deficit / needed;
+                }
+
+                total += lack / Atmospherics.TotalNumberOfGases;
+            }
+
+            return total;
+        }
+
+        private float GasProducedMultiplier(Gas gas, float usedAverage)
+        {
+            if (!ProducesGases.TryGetValue(gas, out var produces))
+            {
+                return 0;
+            }
+
+            if (!NeedsGases.TryGetValue(gas, out var needs))
+            {
+                needs = 1;
+            }
+
+            return needs * produces * usedAverage;
+        }
+
+        private Dictionary<Gas, float> GasProduced(float usedAverage)
+        {
+            return ProducesGases.ToDictionary(pair => pair.Key, pair => GasProducedMultiplier(pair.Key, usedAverage));
+        }
+
+        private void ProcessGases(float frameTime)
+        {
+            if (!Owner.TryGetComponent(out BloodstreamComponent? bloodstream))
+            {
+                return;
+            }
+
+            if (_body == null)
+            {
+                return;
+            }
+
+            var lungs = _body.GetMechanismBehaviors<LungBehavior>().ToArray();
+
+            var needs = NeedsAndDeficit(frameTime);
+            var used = 0f;
+            foreach (var (gas, amountNeeded) in needs)
+            {
+                var bloodstreamAmount = bloodstream.Air.GetMoles(gas);
+                var deficit = 0f;
+
+                if (bloodstreamAmount < amountNeeded)
+                {
+                    if (!Owner.GetComponent<IMobStateComponent>().IsCritical())
+                    {
+                        // Panic inhale
+                        foreach (var lung in lungs)
+                        {
+                            lung.Gasp();
+                        }
+                    }
+
+                    bloodstreamAmount = bloodstream.Air.GetMoles(gas);
+
+                    deficit = Math.Max(0, amountNeeded - bloodstreamAmount);
+
+                    if (deficit > 0)
+                    {
+                        bloodstream.Air.SetMoles(gas, 0);
+                    }
+                    else
+                    {
+                        bloodstream.Air.AdjustMoles(gas, -amountNeeded);
+                    }
+                }
+                else
+                {
+                    bloodstream.Air.AdjustMoles(gas, -amountNeeded);
+                }
+
+                DeficitGases[gas] = deficit;
+
+
+                used += (amountNeeded - deficit) / amountNeeded;
+            }
+
+            var produced = GasProduced(used / needs.Count);
+
+            foreach (var (gas, amountProduced) in produced)
+            {
+                bloodstream.Air.AdjustMoles(gas, amountProduced);
+            }
+
+            ClampDeficit();
+        }
+
+        /// <summary>
+        /// Process thermal regulation
+        /// </summary>
+        /// <param name="frameTime"></param>
+        private void ProcessThermalRegulation(float frameTime)
+        {
+            if (!Owner.TryGetComponent(out TemperatureComponent? temperatureComponent)) return;
+            temperatureComponent.ReceiveHeat(MetabolismHeat);
+            temperatureComponent.RemoveHeat(RadiatedHeat);
+
+            // implicit heat regulation
+            var tempDiff = Math.Abs(temperatureComponent.CurrentTemperature - NormalBodyTemperature);
+            var targetHeat = tempDiff * temperatureComponent.HeatCapacity;
+            if (temperatureComponent.CurrentTemperature > NormalBodyTemperature)
+            {
+                temperatureComponent.RemoveHeat(Math.Min(targetHeat, ImplicitHeatRegulation));
+            }
+            else
+            {
+                temperatureComponent.ReceiveHeat(Math.Min(targetHeat, ImplicitHeatRegulation));
+            }
+
+            // recalc difference and target heat
+            tempDiff = Math.Abs(temperatureComponent.CurrentTemperature - NormalBodyTemperature);
+            targetHeat = tempDiff * temperatureComponent.HeatCapacity;
+
+            // if body temperature is not within comfortable, thermal regulation
+            // processes starts
+            if (tempDiff < ThermalRegulationTemperatureThreshold)
+            {
+                if (_isShivering || _isSweating)
+                {
+                    Owner.PopupMessage(Loc.GetString("metabolism-component-is-comfortable"));
+                }
+
+                _isShivering = false;
+                _isSweating = false;
+                return;
+            }
+
+
+            var actionBlocker = EntitySystem.Get<ActionBlockerSystem>();
+
+            if (temperatureComponent.CurrentTemperature > NormalBodyTemperature)
+            {
+                if (!actionBlocker.CanSweat(Owner)) return;
+                if (!_isSweating)
+                {
+                    Owner.PopupMessage(Loc.GetString("metabolism-component-is-sweating"));
+                    _isSweating = true;
+                }
+
+                // creadth: sweating does not help in airless environment
+                if (EntitySystem.Get<AtmosphereSystem>().GetTileMixture(Owner.Transform.Coordinates) is not {})
+                {
+                    temperatureComponent.RemoveHeat(Math.Min(targetHeat, SweatHeatRegulation));
+                }
+            }
+            else
+            {
+                if (!actionBlocker.CanShiver(Owner)) return;
+                if (!_isShivering)
+                {
+                    Owner.PopupMessage(Loc.GetString("metabolism-component-is-shivering"));
+                    _isShivering = true;
+                }
+
+                temperatureComponent.ReceiveHeat(Math.Min(targetHeat, ShiveringHeatRegulation));
+            }
+        }
+
+        /// <summary>
+        ///     Processes gases in the bloodstream.
+        /// </summary>
+        /// <param name="frameTime">
+        ///     The time since the last metabolism tick in seconds.
+        /// </param>
+        public void Update(float frameTime)
+        {
+            if (!Owner.TryGetComponent<IMobStateComponent>(out var state) ||
+                state.IsDead())
+            {
+                return;
+            }
+
+            _accumulatedFrameTime += frameTime;
+
+            if (_accumulatedFrameTime < 1)
+            {
+                return;
+            }
+
+            ProcessGases(_accumulatedFrameTime);
+            ProcessThermalRegulation(_accumulatedFrameTime);
+
+            _accumulatedFrameTime -= 1;
+
+            if (SuffocatingPercentage() > 0)
+            {
+                TakeSuffocationDamage();
+                return;
+            }
+
+            StopSuffocation();
+        }
+
+        private void TakeSuffocationDamage()
+        {
+            Suffocating = true;
+
+            if (Owner.TryGetComponent(out ServerAlertsComponent? alertsComponent))
+            {
+                alertsComponent.ShowAlert(AlertType.LowOxygen);
+            }
+
+            if (!Owner.TryGetComponent(out IDamageableComponent? damageable))
+            {
+                return;
+            }
+
+            damageable.ChangeDamage(DamageType.Asphyxiation, _suffocationDamage, false);
+        }
+
+        private void StopSuffocation()
+        {
+            Suffocating = false;
+
+            if (Owner.TryGetComponent(out IDamageableComponent? damageable))
+            {
+                damageable.ChangeDamage(DamageType.Asphyxiation, -_suffocationDamageRecovery, false);
+            }
+
+            if (Owner.TryGetComponent(out ServerAlertsComponent? alertsComponent))
+            {
+                alertsComponent.ClearAlert(AlertType.LowOxygen);
+            }
+        }
+
+        public GasMixture Clean(BloodstreamComponent bloodstream)
+        {
+            var gasMixture = new GasMixture(bloodstream.Air.Volume)
+            {
+                Temperature = bloodstream.Air.Temperature
+            };
+
+            for (Gas gas = 0; gas < (Gas) Atmospherics.TotalNumberOfGases; gas++)
+            {
+                float amount;
+                var molesInBlood = bloodstream.Air.GetMoles(gas);
+
+                if (!NeedsGases.TryGetValue(gas, out var needed))
+                {
+                    amount = molesInBlood;
+                }
+                else
+                {
+                    var overflowThreshold = needed * 5f;
+
+                    amount = molesInBlood > overflowThreshold
+                        ? molesInBlood - overflowThreshold
+                        : 0;
+                }
+
+                gasMixture.AdjustMoles(gas, amount);
+                bloodstream.Air.AdjustMoles(gas, -amount);
+            }
+
+            return gasMixture;
+        }
+    }
+}

Content.Server/Body/Respiratory/RespiratorSystem.cs

@@ -0,0 +1,19 @@
+using JetBrains.Annotations;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Body.Respiratory
+{
+    [UsedImplicitly]
+    public class RespiratorSystem : EntitySystem
+    {
+        public override void Update(float frameTime)
+        {
+            base.Update(frameTime);
+
+            foreach (var respirator in ComponentManager.EntityQuery<RespiratorComponent>(false))
+            {
+                respirator.Update(frameTime);
+            }
+        }
+    }
+}