/// <summary>
/// Calculates the heat capacity for a gas mixture.
/// </summary>
- public float GetHeatCapacity(GasMixture mixture)
+ /// <param name="mixture">The mixture whose heat capacity should be calculated</param>
+ /// <param name="applyScaling"> Whether the internal heat capacity scaling should be applied. This should not be
+ /// used outside of atmospheric related heat transfer.</param>
+ /// <returns></returns>
+ public float GetHeatCapacity(GasMixture mixture, bool applyScaling)
{
- return GetHeatCapacityCalculation(mixture.Moles, mixture.Immutable);
+ var scale = GetHeatCapacityCalculation(mixture.Moles, mixture.Immutable);
+
+ // By default GetHeatCapacityCalculation() has the heat-scale divisor pre-applied.
+ // So if we want the un-scaled heat capacity, we have to multiply by the scale.
+ return applyScaling ? scale : scale * HeatScale;
}
+ private float GetHeatCapacity(GasMixture mixture)
+ => GetHeatCapacityCalculation(mixture.Moles, mixture.Immutable);
+
[MethodImpl(MethodImplOptions.AggressiveInlining)]
private float GetHeatCapacityCalculation(float[] moles, bool space)
{
var req = prototype.MinimumRequirements[i];
- if (!(mixture.GetMoles(i) < req)) continue;
+ if (!(mixture.GetMoles(i) < req))
+ continue;
+
doReaction = false;
break;
}
if (!doReaction)
continue;
- reaction = prototype.React(mixture, holder, this);
+ reaction = prototype.React(mixture, holder, this, HeatScale);
if(reaction.HasFlag(ReactionResult.StopReactions))
break;
}
using Content.Server.Atmos.Reactions;
using Content.Shared.Atmos;
using Content.Shared.Atmos.Components;
+using Robust.Shared.Map;
using Robust.Shared.Map.Components;
using Robust.Shared.Utility;
InvalidateVisuals(uid, position, overlay);
}
}
+
+ public TileRef GetTileRef(TileAtmosphere tile)
+ {
+ if (!TryComp(tile.GridIndex, out MapGridComponent? grid))
+ return default;
+ _map.TryGetTileRef(tile.GridIndex, grid, tile.GridIndices, out var tileRef);
+ return tileRef;
+ }
}
using Content.Server.Administration.Logs;
using Content.Server.Atmos.Components;
using Content.Server.Body.Systems;
-using Content.Server.Maps;
+using Content.Server.Fluids.EntitySystems;
using Content.Server.NodeContainer.EntitySystems;
using Content.Shared.Atmos.EntitySystems;
using Content.Shared.Maps;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
-using Robust.Shared.Audio;
using Robust.Shared.Audio.Systems;
using Robust.Shared.Containers;
using Robust.Shared.Map;
[Dependency] private readonly SharedAudioSystem _audio = default!;
[Dependency] private readonly TransformSystem _transformSystem = default!;
[Dependency] private readonly TileSystem _tile = default!;
+ [Dependency] private readonly MapSystem _map = default!;
+ [Dependency] public readonly PuddleSystem Puddle = default!;
private const float ExposedUpdateDelay = 1f;
private float _exposedTimer = 0f;
return;
var query = EntityQueryEnumerator<AtmosExposedComponent, TransformComponent>();
- while (query.MoveNext(out var uid, out var exposed, out var transform))
+ while (query.MoveNext(out var uid, out _, out var transform))
{
var air = GetContainingMixture(uid, transform:transform);
else
xfer = outlet.Air.Remove(-n);
- float CXfer = _atmosphereSystem.GetHeatCapacity(xfer);
+ float CXfer = _atmosphereSystem.GetHeatCapacity(xfer, true);
if (CXfer < Atmospherics.MinimumHeatCapacity)
return;
float CEnv = 0f;
if (environment != null)
{
- CEnv = _atmosphereSystem.GetHeatCapacity(environment);
+ CEnv = _atmosphereSystem.GetHeatCapacity(environment, true);
hasEnv = CEnv >= Atmospherics.MinimumHeatCapacity && environment.TotalMoles > 0f;
if (hasEnv)
radTemp = environment.Temperature;
[ImplicitDataDefinitionForInheritors]
public partial interface IGasReactionEffect
{
- ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem);
+ /// <summary>
+ /// Process this reaction effect.
+ /// </summary>
+ /// <param name="mixture">The gas mixture to react</param>
+ /// <param name="holder">The container of this gas mixture</param>
+ /// <param name="atmosphereSystem">The atmosphere system</param>
+ /// <param name="heatScale">Scaling factor that should be applied to all heat input or outputs.</param>
+ ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem,
+ float heatScale);
}
}
public float NumberOfMolesToConvert(ApcPowerReceiverComponent comp, GasMixture mix, float dt)
{
- var hc = _atmosphereSystem.GetHeatCapacity(mix);
+ var hc = _atmosphereSystem.GetHeatCapacity(mix, true);
var alpha = 0.8f; // tuned to give us 1-ish u/second of reagent conversion
// ignores the energy needed to cool down the solution to the condensation point, but that probably adds too much difficulty and so let's not simulate that
var energy = comp.Load * dt;
float dQ = thermoMachine.HeatCapacity * thermoMachine.Cp * args.dt;
// Clamps the heat transferred to not overshoot
- float Cin = _atmosphereSystem.GetHeatCapacity(inlet.Air);
+ float Cin = _atmosphereSystem.GetHeatCapacity(inlet.Air, true);
float dT = targetTemp - temp;
float dQLim = dT * Cin;
float scale = 1f;
[UsedImplicitly]
public sealed partial class FrezonCoolantReaction : IGasReactionEffect
{
- public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem)
+ public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem, float heatScale)
{
- var oldHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture);
+ var oldHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture, true);
var temperature = mixture.Temperature;
var energyModifier = 1f;
energyReleased = burnRate * Atmospherics.FrezonCoolEnergyReleased * energyModifier;
}
- energyReleased /= atmosphereSystem.HeatScale; // adjust energy to make sure speedup doesn't cause mega temperature rise
+ energyReleased /= heatScale; // adjust energy to make sure speedup doesn't cause mega temperature rise
if (energyReleased >= 0f)
return ReactionResult.NoReaction;
- var newHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture);
+ var newHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture, true);
if (newHeatCapacity > Atmospherics.MinimumHeatCapacity)
mixture.Temperature = (temperature * oldHeatCapacity + energyReleased) / newHeatCapacity;
[UsedImplicitly]
public sealed partial class FrezonProductionReaction : IGasReactionEffect
{
- public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem)
+ public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem, float heatScale)
{
var initialN2 = mixture.GetMoles(Gas.Nitrogen);
var initialOxy = mixture.GetMoles(Gas.Oxygen);
// Amount of tritium & oxygen that are reacting
var tritBurned = Math.Min(oxyLimit, initialTrit);
var oxyBurned = tritBurned * Atmospherics.FrezonProductionTritRatio;
- var burnRatio = tritBurned / initialTrit;
var oxyConversion = oxyBurned / Atmospherics.FrezonProductionConversionRate;
var tritConversion = tritBurned / Atmospherics.FrezonProductionConversionRate;
/// </summary>
[DataField("effects")] private List<IGasReactionEffect> _effects = new();
- public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem)
+ /// <summary>
+ /// Process all reaction effects.
+ /// </summary>
+ /// <param name="mixture">The gas mixture to react</param>
+ /// <param name="holder">The container of this gas mixture</param>
+ /// <param name="atmosphereSystem">The atmosphere system</param>
+ /// <param name="heatScale">Scaling factor that should be applied to all heat input or outputs.</param>
+ public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem, float heatScale)
{
var result = ReactionResult.NoReaction;
foreach (var effect in _effects)
{
- result |= effect.React(mixture, holder, atmosphereSystem);
+ result |= effect.React(mixture, holder, atmosphereSystem, heatScale);
}
return result;
[UsedImplicitly]
public sealed partial class MiasmicSubsumationReaction : IGasReactionEffect
{
- public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem)
+ public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem, float heatScale)
{
var initialMiasma = mixture.GetMoles(Gas.Miasma);
var initialFrezon = mixture.GetMoles(Gas.Frezon);
[DataDefinition]
public sealed partial class PlasmaFireReaction : IGasReactionEffect
{
- public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem)
+ public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem, float heatScale)
{
var energyReleased = 0f;
- var oldHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture);
+ var oldHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture, true);
var temperature = mixture.Temperature;
var location = holder as TileAtmosphere;
mixture.ReactionResults[GasReaction.Fire] = 0;
if (temperature > Atmospherics.PlasmaUpperTemperature)
temperatureScale = 1f;
else
+ {
temperatureScale = (temperature - Atmospherics.PlasmaMinimumBurnTemperature) /
(Atmospherics.PlasmaUpperTemperature - Atmospherics.PlasmaMinimumBurnTemperature);
+ }
if (temperatureScale > 0)
{
mixture.AdjustMoles(Gas.CarbonDioxide, plasmaBurnRate * (1.0f - supersaturation));
energyReleased += Atmospherics.FirePlasmaEnergyReleased * plasmaBurnRate;
- energyReleased /= atmosphereSystem.HeatScale; // adjust energy to make sure speedup doesn't cause mega temperature rise
+ energyReleased /= heatScale; // adjust energy to make sure speedup doesn't cause mega temperature rise
mixture.ReactionResults[GasReaction.Fire] += plasmaBurnRate * (1 + oxygenBurnRate);
}
}
if (energyReleased > 0)
{
- var newHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture);
+ var newHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture, true);
if (newHeatCapacity > Atmospherics.MinimumHeatCapacity)
mixture.Temperature = (temperature * oldHeatCapacity + energyReleased) / newHeatCapacity;
}
[DataDefinition]
public sealed partial class TritiumFireReaction : IGasReactionEffect
{
- public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem)
+ public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem, float heatScale)
{
var energyReleased = 0f;
- var oldHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture);
+ var oldHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture, true);
var temperature = mixture.Temperature;
var location = holder as TileAtmosphere;
mixture.ReactionResults[GasReaction.Fire] = 0f;
mixture.ReactionResults[GasReaction.Fire] += burnedFuel;
}
- energyReleased /= atmosphereSystem.HeatScale; // adjust energy to make sure speedup doesn't cause mega temperature rise
+ energyReleased /= heatScale; // adjust energy to make sure speedup doesn't cause mega temperature rise
if (energyReleased > 0)
{
- var newHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture);
+ var newHeatCapacity = atmosphereSystem.GetHeatCapacity(mixture, true);
if (newHeatCapacity > Atmospherics.MinimumHeatCapacity)
mixture.Temperature = ((temperature * oldHeatCapacity + energyReleased) / newHeatCapacity);
}
[DataField("molesPerUnit")] public float MolesPerUnit { get; private set; } = 1;
- public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem)
+ public ReactionResult React(GasMixture mixture, IGasMixtureHolder? holder, AtmosphereSystem atmosphereSystem, float heatScale)
{
// If any of the prototypes is invalid, we do nothing.
if (string.IsNullOrEmpty(Reagent))
// Remove the moles from the mixture...
mixture.AdjustMoles(GasId, -MolesPerUnit);
- var tileRef = tile.GridIndices.GetTileRef(tile.GridIndex);
- EntitySystem.Get<PuddleSystem>()
- .TrySpillAt(tileRef, new Solution(Reagent, FixedPoint2.New(MolesPerUnit)), out _, sound: false);
+ var tileRef = atmosphereSystem.GetTileRef(tile);
+ atmosphereSystem.Puddle.TrySpillAt(tileRef, new Solution(Reagent, FixedPoint2.New(MolesPerUnit)), out _, sound: false);
return ReactionResult.Reacting;
}
var (airA, δpA) = GetCirculatorAirTransfer(inletA.Air, outletA.Air);
var (airB, δpB) = GetCirculatorAirTransfer(inletB.Air, outletB.Air);
- var cA = _atmosphere.GetHeatCapacity(airA);
- var cB = _atmosphere.GetHeatCapacity(airB);
+ var cA = _atmosphere.GetHeatCapacity(airA, true);
+ var cB = _atmosphere.GetHeatCapacity(airB, true);
// Shift ramp position based on demand and generation from previous tick.
var curRamp = component.RampPosition;
if (transform.MapUid == null)
return;
- var position = _transform.GetGridTilePositionOrDefault((uid, transform));
var temperatureDelta = args.GasMixture.Temperature - temperature.CurrentTemperature;
- var tileHeatCapacity =
- _atmosphere.GetTileHeatCapacity(transform.GridUid, transform.MapUid.Value, position);
+ var airHeatCapacity = _atmosphere.GetHeatCapacity(args.GasMixture, false);
var heatCapacity = GetHeatCapacity(uid, temperature);
- var heat = temperatureDelta * (tileHeatCapacity * heatCapacity /
- (tileHeatCapacity + heatCapacity));
+ var heat = temperatureDelta * (airHeatCapacity * heatCapacity /
+ (airHeatCapacity + heatCapacity));
ChangeHeat(uid, heat * temperature.AtmosTemperatureTransferEfficiency, temperature: temperature);
}
projects / space-station-14.git / commitdiff