Temperature refactor (#20662)

Co-authored-by: deltanedas <@deltanedas:kde.org>
This commit is contained in:
deltanedas
2023-10-02 15:44:05 +01:00
committed by GitHub
parent f0bd861fc8
commit c988f21d25
3 changed files with 385 additions and 396 deletions

View File

@@ -3,11 +3,9 @@
[RegisterComponent] [RegisterComponent]
public sealed partial class ContainerTemperatureDamageThresholdsComponent: Component public sealed partial class ContainerTemperatureDamageThresholdsComponent: Component
{ {
[DataField("heatDamageThreshold")] [DataField, ViewVariables(VVAccess.ReadWrite)]
[ViewVariables(VVAccess.ReadWrite)]
public float? HeatDamageThreshold; public float? HeatDamageThreshold;
[DataField("coldDamageThreshold")] [DataField, ViewVariables(VVAccess.ReadWrite)]
[ViewVariables(VVAccess.ReadWrite)]
public float? ColdDamageThreshold; public float? ColdDamageThreshold;
} }

View File

@@ -4,84 +4,80 @@ using Content.Shared.FixedPoint;
using Robust.Shared.Physics; using Robust.Shared.Physics;
using Robust.Shared.Physics.Components; using Robust.Shared.Physics.Components;
namespace Content.Server.Temperature.Components namespace Content.Server.Temperature.Components;
/// <summary>
/// Handles changing temperature,
/// informing others of the current temperature,
/// and taking fire damage from high temperature.
/// </summary>
[RegisterComponent]
public sealed partial class TemperatureComponent : Component
{ {
[DataField, ViewVariables(VVAccess.ReadWrite)]
public float CurrentTemperature = Atmospherics.T20C;
[DataField, ViewVariables(VVAccess.ReadWrite)]
public float HeatDamageThreshold = 360f;
[DataField, ViewVariables(VVAccess.ReadWrite)]
public float ColdDamageThreshold = 260f;
/// <summary> /// <summary>
/// Handles changing temperature, /// Overrides HeatDamageThreshold if the entity's within a parent with the TemperatureDamageThresholdsComponent component.
/// informing others of the current temperature,
/// and taking fire damage from high temperature.
/// </summary> /// </summary>
[RegisterComponent] [DataField, ViewVariables(VVAccess.ReadWrite)]
public sealed partial class TemperatureComponent : Component public float? ParentHeatDamageThreshold;
/// <summary>
/// Overrides ColdDamageThreshold if the entity's within a parent with the TemperatureDamageThresholdsComponent component.
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite)]
public float? ParentColdDamageThreshold;
/// <summary>
/// Heat capacity per kg of mass.
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite)]
public float SpecificHeat = 50f;
/// <summary>
/// How well does the air surrounding you merge into your body temperature?
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite)]
public float AtmosTemperatureTransferEfficiency = 0.1f;
[ViewVariables] public float HeatCapacity
{ {
[ViewVariables(VVAccess.ReadWrite)] get
[DataField("currentTemperature")]
public float CurrentTemperature { get; set; } = Atmospherics.T20C;
[DataField("heatDamageThreshold")]
[ViewVariables(VVAccess.ReadWrite)]
public float HeatDamageThreshold = 360f;
[DataField("coldDamageThreshold")]
[ViewVariables(VVAccess.ReadWrite)]
public float ColdDamageThreshold = 260f;
/// <summary>
/// Overrides HeatDamageThreshold if the entity's within a parent with the TemperatureDamageThresholdsComponent component.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public float? ParentHeatDamageThreshold;
/// <summary>
/// Overrides ColdDamageThreshold if the entity's within a parent with the TemperatureDamageThresholdsComponent component.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
public float? ParentColdDamageThreshold;
[DataField("specificHeat")]
[ViewVariables(VVAccess.ReadWrite)]
public float SpecificHeat = 50f;
/// <summary>
/// How well does the air surrounding you merge into your body temperature?
/// </summary>
[DataField("atmosTemperatureTransferEfficiency")]
[ViewVariables(VVAccess.ReadWrite)]
public float AtmosTemperatureTransferEfficiency = 0.1f;
[ViewVariables] public float HeatCapacity
{ {
get if (IoCManager.Resolve<IEntityManager>().TryGetComponent<PhysicsComponent>(Owner, out var physics) && physics.FixturesMass != 0)
{ {
if (IoCManager.Resolve<IEntityManager>().TryGetComponent<PhysicsComponent>(Owner, out var physics) && physics.FixturesMass != 0) return SpecificHeat * physics.FixturesMass;
{
return SpecificHeat * physics.FixturesMass;
}
return Atmospherics.MinimumHeatCapacity;
} }
return Atmospherics.MinimumHeatCapacity;
} }
[DataField("coldDamage")]
[ViewVariables(VVAccess.ReadWrite)]
public DamageSpecifier ColdDamage = new();
[DataField("heatDamage")]
[ViewVariables(VVAccess.ReadWrite)]
public DamageSpecifier HeatDamage = new();
/// <summary>
/// Temperature won't do more than this amount of damage per second.
///
/// Okay it genuinely reaches this basically immediately for a plasma fire.
/// </summary>
[DataField("damageCap")]
[ViewVariables(VVAccess.ReadWrite)]
public FixedPoint2 DamageCap = FixedPoint2.New(8);
/// <summary>
/// Used to keep track of when damage starts/stops. Useful for logs.
/// </summary>
public bool TakingDamage = false;
} }
[DataField, ViewVariables(VVAccess.ReadWrite)]
public DamageSpecifier ColdDamage = new();
[DataField, ViewVariables(VVAccess.ReadWrite)]
public DamageSpecifier HeatDamage = new();
/// <summary>
/// Temperature won't do more than this amount of damage per second.
/// </summary>
/// <remarks>
/// Okay it genuinely reaches this basically immediately for a plasma fire.
/// </summary>
[DataField, ViewVariables(VVAccess.ReadWrite)]
public FixedPoint2 DamageCap = FixedPoint2.New(8);
/// <summary>
/// Used to keep track of when damage starts/stops. Useful for logs.
/// </summary>
[DataField]
public bool TakingDamage = false;
} }

View File

@@ -1,6 +1,3 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Server.Administration.Logs; using Content.Server.Administration.Logs;
using Content.Server.Atmos.Components; using Content.Server.Atmos.Components;
using Content.Server.Atmos.EntitySystems; using Content.Server.Atmos.EntitySystems;
@@ -13,351 +10,349 @@ using Content.Shared.Inventory;
using Content.Shared.Rejuvenate; using Content.Shared.Rejuvenate;
using Content.Shared.Temperature; using Content.Shared.Temperature;
using Robust.Server.GameObjects; using Robust.Server.GameObjects;
using System.Linq;
namespace Content.Server.Temperature.Systems namespace Content.Server.Temperature.Systems;
public sealed class TemperatureSystem : EntitySystem
{ {
public sealed class TemperatureSystem : EntitySystem [Dependency] private readonly AlertsSystem _alerts = default!;
[Dependency] private readonly AtmosphereSystem _atmosphere = default!;
[Dependency] private readonly IAdminLogManager _adminLogger = default!;
[Dependency] private readonly DamageableSystem _damageable = default!;
[Dependency] private readonly TransformSystem _transform = default!;
/// <summary>
/// All the components that will have their damage updated at the end of the tick.
/// This is done because both AtmosExposed and Flammable call ChangeHeat in the same tick, meaning
/// that we need some mechanism to ensure it doesn't double dip on damage for both calls.
/// </summary>
public HashSet<TemperatureComponent> ShouldUpdateDamage = new();
public float UpdateInterval = 1.0f;
private float _accumulatedFrametime;
public override void Initialize()
{ {
[Dependency] private readonly TransformSystem _transformSystem = default!; SubscribeLocalEvent<TemperatureComponent, OnTemperatureChangeEvent>(EnqueueDamage);
[Dependency] private readonly DamageableSystem _damageableSystem = default!; SubscribeLocalEvent<TemperatureComponent, AtmosExposedUpdateEvent>(OnAtmosExposedUpdate);
[Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!; SubscribeLocalEvent<TemperatureComponent, RejuvenateEvent>(OnRejuvenate);
[Dependency] private readonly AlertsSystem _alertsSystem = default!; SubscribeLocalEvent<AlertsComponent, OnTemperatureChangeEvent>(ServerAlert);
[Dependency] private readonly IAdminLogManager _adminLogger = default!; SubscribeLocalEvent<TemperatureProtectionComponent, InventoryRelayedEvent<ModifyChangedTemperatureEvent>>(
OnTemperatureChangeAttempt);
/// <summary> // Allows overriding thresholds based on the parent's thresholds.
/// All the components that will have their damage updated at the end of the tick. SubscribeLocalEvent<TemperatureComponent, EntParentChangedMessage>(OnParentChange);
/// This is done because both AtmosExposed and Flammable call ChangeHeat in the same tick, meaning SubscribeLocalEvent<ContainerTemperatureDamageThresholdsComponent, ComponentStartup>(
/// that we need some mechanism to ensure it doesn't double dip on damage for both calls. OnParentThresholdStartup);
/// </summary> SubscribeLocalEvent<ContainerTemperatureDamageThresholdsComponent, ComponentShutdown>(
public HashSet<TemperatureComponent> ShouldUpdateDamage = new(); OnParentThresholdShutdown);
}
public float UpdateInterval = 1.0f; public override void Update(float frameTime)
{
base.Update(frameTime);
private float _accumulatedFrametime; _accumulatedFrametime += frameTime;
public override void Initialize() if (_accumulatedFrametime < UpdateInterval)
return;
_accumulatedFrametime -= UpdateInterval;
if (!ShouldUpdateDamage.Any())
return;
foreach (var comp in ShouldUpdateDamage)
{ {
SubscribeLocalEvent<TemperatureComponent, OnTemperatureChangeEvent>(EnqueueDamage); MetaDataComponent? metaData = null;
SubscribeLocalEvent<TemperatureComponent, AtmosExposedUpdateEvent>(OnAtmosExposedUpdate);
SubscribeLocalEvent<TemperatureComponent, RejuvenateEvent>(OnRejuvenate);
SubscribeLocalEvent<AlertsComponent, OnTemperatureChangeEvent>(ServerAlert);
SubscribeLocalEvent<TemperatureProtectionComponent, InventoryRelayedEvent<ModifyChangedTemperatureEvent>>(
OnTemperatureChangeAttempt);
// Allows overriding thresholds based on the parent's thresholds. var uid = comp.Owner;
SubscribeLocalEvent<TemperatureComponent, EntParentChangedMessage>(OnParentChange); if (Deleted(uid, metaData) || Paused(uid, metaData))
SubscribeLocalEvent<ContainerTemperatureDamageThresholdsComponent, ComponentStartup>( continue;
OnParentThresholdStartup);
SubscribeLocalEvent<ContainerTemperatureDamageThresholdsComponent, ComponentShutdown>( ChangeDamage(uid, comp);
OnParentThresholdShutdown);
} }
public override void Update(float frameTime) ShouldUpdateDamage.Clear();
}
public void ForceChangeTemperature(EntityUid uid, float temp, TemperatureComponent? temperature = null)
{
if (!Resolve(uid, ref temperature))
return;
float lastTemp = temperature.CurrentTemperature;
float delta = temperature.CurrentTemperature - temp;
temperature.CurrentTemperature = temp;
RaiseLocalEvent(uid, new OnTemperatureChangeEvent(temperature.CurrentTemperature, lastTemp, delta),
true);
}
public void ChangeHeat(EntityUid uid, float heatAmount, bool ignoreHeatResistance = false,
TemperatureComponent? temperature = null)
{
if (!Resolve(uid, ref temperature))
return;
if (!ignoreHeatResistance)
{ {
base.Update(frameTime); var ev = new ModifyChangedTemperatureEvent(heatAmount);
RaiseLocalEvent(uid, ev, false);
_accumulatedFrametime += frameTime; heatAmount = ev.TemperatureDelta;
if (_accumulatedFrametime < UpdateInterval)
return;
_accumulatedFrametime -= UpdateInterval;
if (!ShouldUpdateDamage.Any())
return;
foreach (var comp in ShouldUpdateDamage)
{
MetaDataComponent? metaData = null;
var uid = comp.Owner;
if (Deleted(uid, metaData) || Paused(uid, metaData))
continue;
ChangeDamage(uid, comp);
}
ShouldUpdateDamage.Clear();
} }
public void ForceChangeTemperature(EntityUid uid, float temp, TemperatureComponent? temperature = null) float lastTemp = temperature.CurrentTemperature;
temperature.CurrentTemperature += heatAmount / temperature.HeatCapacity;
float delta = temperature.CurrentTemperature - lastTemp;
RaiseLocalEvent(uid, new OnTemperatureChangeEvent(temperature.CurrentTemperature, lastTemp, delta), true);
}
private void OnAtmosExposedUpdate(EntityUid uid, TemperatureComponent temperature,
ref AtmosExposedUpdateEvent args)
{
var transform = args.Transform;
if (transform.MapUid == null)
return;
var position = _transform.GetGridOrMapTilePosition(uid, transform);
var temperatureDelta = args.GasMixture.Temperature - temperature.CurrentTemperature;
var tileHeatCapacity =
_atmosphere.GetTileHeatCapacity(transform.GridUid, transform.MapUid.Value, position);
var heat = temperatureDelta * (tileHeatCapacity * temperature.HeatCapacity /
(tileHeatCapacity + temperature.HeatCapacity));
ChangeHeat(uid, heat * temperature.AtmosTemperatureTransferEfficiency, temperature: temperature);
}
private void OnRejuvenate(EntityUid uid, TemperatureComponent comp, RejuvenateEvent args)
{
ForceChangeTemperature(uid, Atmospherics.T20C, comp);
}
private void ServerAlert(EntityUid uid, AlertsComponent status, OnTemperatureChangeEvent args)
{
switch (args.CurrentTemperature)
{ {
if (!Resolve(uid, ref temperature)) // Cold strong.
return; case <= 260:
_alerts.ShowAlert(uid, AlertType.Cold, 3);
break;
float lastTemp = temperature.CurrentTemperature; // Cold mild.
float delta = temperature.CurrentTemperature - temp; case <= 280 and > 260:
temperature.CurrentTemperature = temp; _alerts.ShowAlert(uid, AlertType.Cold, 2);
RaiseLocalEvent(uid, new OnTemperatureChangeEvent(temperature.CurrentTemperature, lastTemp, delta), break;
true);
}
public void ChangeHeat(EntityUid uid, float heatAmount, bool ignoreHeatResistance = false, // Cold weak.
TemperatureComponent? temperature = null) case <= 292 and > 280:
{ _alerts.ShowAlert(uid, AlertType.Cold, 1);
if (Resolve(uid, ref temperature)) break;
{
if (!ignoreHeatResistance)
{
var ev = new ModifyChangedTemperatureEvent(heatAmount);
RaiseLocalEvent(uid, ev, false);
heatAmount = ev.TemperatureDelta;
}
float lastTemp = temperature.CurrentTemperature; // Safe.
temperature.CurrentTemperature += heatAmount / temperature.HeatCapacity; case <= 327 and > 292:
float delta = temperature.CurrentTemperature - lastTemp; _alerts.ClearAlertCategory(uid, AlertCategory.Temperature);
break;
RaiseLocalEvent(uid, new OnTemperatureChangeEvent(temperature.CurrentTemperature, lastTemp, delta), // Heat weak.
true); case <= 335 and > 327:
} _alerts.ShowAlert(uid, AlertType.Hot, 1);
} break;
private void OnAtmosExposedUpdate(EntityUid uid, TemperatureComponent temperature, // Heat mild.
ref AtmosExposedUpdateEvent args) case <= 360 and > 335:
{ _alerts.ShowAlert(uid, AlertType.Hot, 2);
var transform = args.Transform; break;
if (transform.MapUid == null) // Heat strong.
return; case > 360:
_alerts.ShowAlert(uid, AlertType.Hot, 3);
var position = _transformSystem.GetGridOrMapTilePosition(uid, transform); break;
var temperatureDelta = args.GasMixture.Temperature - temperature.CurrentTemperature;
var tileHeatCapacity =
_atmosphereSystem.GetTileHeatCapacity(transform.GridUid, transform.MapUid.Value, position);
var heat = temperatureDelta * (tileHeatCapacity * temperature.HeatCapacity /
(tileHeatCapacity + temperature.HeatCapacity));
ChangeHeat(uid, heat * temperature.AtmosTemperatureTransferEfficiency, temperature: temperature);
}
private void OnRejuvenate(EntityUid uid, TemperatureComponent comp, RejuvenateEvent args)
{
ForceChangeTemperature(uid, Atmospherics.T20C, comp);
}
private void ServerAlert(EntityUid uid, AlertsComponent status, OnTemperatureChangeEvent args)
{
switch (args.CurrentTemperature)
{
// Cold strong.
case <= 260:
_alertsSystem.ShowAlert(uid, AlertType.Cold, 3);
break;
// Cold mild.
case <= 280 and > 260:
_alertsSystem.ShowAlert(uid, AlertType.Cold, 2);
break;
// Cold weak.
case <= 292 and > 280:
_alertsSystem.ShowAlert(uid, AlertType.Cold, 1);
break;
// Safe.
case <= 327 and > 292:
_alertsSystem.ClearAlertCategory(uid, AlertCategory.Temperature);
break;
// Heat weak.
case <= 335 and > 327:
_alertsSystem.ShowAlert(uid, AlertType.Hot, 1);
break;
// Heat mild.
case <= 360 and > 335:
_alertsSystem.ShowAlert(uid, AlertType.Hot, 2);
break;
// Heat strong.
case > 360:
_alertsSystem.ShowAlert(uid, AlertType.Hot, 3);
break;
}
}
private void EnqueueDamage(EntityUid uid, TemperatureComponent component, OnTemperatureChangeEvent args)
{
ShouldUpdateDamage.Add(component);
}
private void ChangeDamage(EntityUid uid, TemperatureComponent temperature)
{
if (!HasComp<DamageableComponent>(uid))
return;
// See this link for where the scaling func comes from:
// https://www.desmos.com/calculator/0vknqtdvq9
// Based on a logistic curve, which caps out at MaxDamage
var heatK = 0.005;
var a = 1;
var y = temperature.DamageCap;
var c = y * 2;
var heatDamageThreshold = temperature.ParentHeatDamageThreshold ?? temperature.HeatDamageThreshold;
var coldDamageThreshold = temperature.ParentColdDamageThreshold ?? temperature.ColdDamageThreshold;
if (temperature.CurrentTemperature >= heatDamageThreshold)
{
if (!temperature.TakingDamage)
{
_adminLogger.Add(LogType.Temperature, $"{ToPrettyString(uid):entity} started taking high temperature damage");
temperature.TakingDamage = true;
}
var diff = Math.Abs(temperature.CurrentTemperature - heatDamageThreshold);
var tempDamage = c / (1 + a * Math.Pow(Math.E, -heatK * diff)) - y;
_damageableSystem.TryChangeDamage(uid, temperature.HeatDamage * tempDamage, ignoreResistances: true, interruptsDoAfters: false);
}
else if (temperature.CurrentTemperature <= coldDamageThreshold)
{
if (!temperature.TakingDamage)
{
_adminLogger.Add(LogType.Temperature, $"{ToPrettyString(uid):entity} started taking low temperature damage");
temperature.TakingDamage = true;
}
var diff = Math.Abs(temperature.CurrentTemperature - coldDamageThreshold);
var tempDamage =
Math.Sqrt(diff * (Math.Pow(temperature.DamageCap.Double(), 2) / coldDamageThreshold));
_damageableSystem.TryChangeDamage(uid, temperature.ColdDamage * tempDamage, ignoreResistances: true, interruptsDoAfters: false);
}
else if (temperature.TakingDamage)
{
_adminLogger.Add(LogType.Temperature, $"{ToPrettyString(uid):entity} stopped taking temperature damage");
temperature.TakingDamage = false;
}
}
private void OnTemperatureChangeAttempt(EntityUid uid, TemperatureProtectionComponent component,
InventoryRelayedEvent<ModifyChangedTemperatureEvent> args)
{
args.Args.TemperatureDelta *= component.Coefficient;
}
private void OnParentChange(EntityUid uid, TemperatureComponent component,
ref EntParentChangedMessage args)
{
var temperatureQuery = GetEntityQuery<TemperatureComponent>();
var transformQuery = GetEntityQuery<TransformComponent>();
var thresholdsQuery = GetEntityQuery<ContainerTemperatureDamageThresholdsComponent>();
// We only need to update thresholds if the thresholds changed for the entity's ancestors.
var oldThresholds = args.OldParent != null
? RecalculateParentThresholds(args.OldParent.Value, transformQuery, thresholdsQuery)
: (null, null);
var newThresholds = RecalculateParentThresholds(transformQuery.GetComponent(uid).ParentUid, transformQuery, thresholdsQuery);
if (oldThresholds != newThresholds)
{
RecursiveThresholdUpdate(uid, temperatureQuery, transformQuery, thresholdsQuery);
}
}
private void OnParentThresholdStartup(EntityUid uid, ContainerTemperatureDamageThresholdsComponent component,
ComponentStartup args)
{
RecursiveThresholdUpdate(uid, GetEntityQuery<TemperatureComponent>(), GetEntityQuery<TransformComponent>(),
GetEntityQuery<ContainerTemperatureDamageThresholdsComponent>());
}
private void OnParentThresholdShutdown(EntityUid uid, ContainerTemperatureDamageThresholdsComponent component,
ComponentShutdown args)
{
RecursiveThresholdUpdate(uid, GetEntityQuery<TemperatureComponent>(), GetEntityQuery<TransformComponent>(),
GetEntityQuery<ContainerTemperatureDamageThresholdsComponent>());
}
/// <summary>
/// Recalculate and apply parent thresholds for the root entity and all its descendant.
/// </summary>
/// <param name="root"></param>
/// <param name="temperatureQuery"></param>
/// <param name="transformQuery"></param>
/// <param name="tempThresholdsQuery"></param>
private void RecursiveThresholdUpdate(EntityUid root, EntityQuery<TemperatureComponent> temperatureQuery,
EntityQuery<TransformComponent> transformQuery,
EntityQuery<ContainerTemperatureDamageThresholdsComponent> tempThresholdsQuery)
{
RecalculateAndApplyParentThresholds(root, temperatureQuery, transformQuery, tempThresholdsQuery);
foreach (var child in Transform(root).ChildEntities)
{
RecursiveThresholdUpdate(child, temperatureQuery, transformQuery, tempThresholdsQuery);
}
}
/// <summary>
/// Recalculate parent thresholds and apply them on the uid temperature component.
/// </summary>
/// <param name="uid"></param>
/// <param name="temperatureQuery"></param>
/// <param name="transformQuery"></param>
/// <param name="tempThresholdsQuery"></param>
private void RecalculateAndApplyParentThresholds(EntityUid uid,
EntityQuery<TemperatureComponent> temperatureQuery, EntityQuery<TransformComponent> transformQuery,
EntityQuery<ContainerTemperatureDamageThresholdsComponent> tempThresholdsQuery)
{
if (!temperatureQuery.TryGetComponent(uid, out var temperature))
{
return;
}
var newThresholds = RecalculateParentThresholds(transformQuery.GetComponent(uid).ParentUid, transformQuery, tempThresholdsQuery);
temperature.ParentHeatDamageThreshold = newThresholds.Item1;
temperature.ParentColdDamageThreshold = newThresholds.Item2;
}
/// <summary>
/// Recalculate Parent Heat/Cold DamageThreshold by recursively checking each ancestor and fetching the
/// maximum HeatDamageThreshold and the minimum ColdDamageThreshold if any exists (aka the best value for each).
/// </summary>
/// <param name="initialParentUid"></param>
/// <param name="transformQuery"></param>
/// <param name="tempThresholdsQuery"></param>
private (float?, float?) RecalculateParentThresholds(
EntityUid initialParentUid,
EntityQuery<TransformComponent> transformQuery,
EntityQuery<ContainerTemperatureDamageThresholdsComponent> tempThresholdsQuery)
{
// Recursively check parents for the best threshold available
var parentUid = initialParentUid;
float? newHeatThreshold = null;
float? newColdThreshold = null;
while (parentUid.IsValid())
{
if (tempThresholdsQuery.TryGetComponent(parentUid, out var newThresholds))
{
if (newThresholds.HeatDamageThreshold != null)
{
newHeatThreshold = Math.Max(newThresholds.HeatDamageThreshold.Value,
newHeatThreshold ?? 0);
}
if (newThresholds.ColdDamageThreshold != null)
{
newColdThreshold = Math.Min(newThresholds.ColdDamageThreshold.Value,
newColdThreshold ?? float.MaxValue);
}
}
parentUid = transformQuery.GetComponent(parentUid).ParentUid;
}
return (newHeatThreshold, newColdThreshold);
} }
} }
public sealed class OnTemperatureChangeEvent : EntityEventArgs private void EnqueueDamage(EntityUid uid, TemperatureComponent component, OnTemperatureChangeEvent args)
{ {
public float CurrentTemperature { get; } ShouldUpdateDamage.Add(component);
public float LastTemperature { get; } }
public float TemperatureDelta { get; }
public OnTemperatureChangeEvent(float current, float last, float delta) private void ChangeDamage(EntityUid uid, TemperatureComponent temperature)
{
if (!HasComp<DamageableComponent>(uid))
return;
// See this link for where the scaling func comes from:
// https://www.desmos.com/calculator/0vknqtdvq9
// Based on a logistic curve, which caps out at MaxDamage
var heatK = 0.005;
var a = 1;
var y = temperature.DamageCap;
var c = y * 2;
var heatDamageThreshold = temperature.ParentHeatDamageThreshold ?? temperature.HeatDamageThreshold;
var coldDamageThreshold = temperature.ParentColdDamageThreshold ?? temperature.ColdDamageThreshold;
if (temperature.CurrentTemperature >= heatDamageThreshold)
{ {
CurrentTemperature = current; if (!temperature.TakingDamage)
LastTemperature = last; {
TemperatureDelta = delta; _adminLogger.Add(LogType.Temperature, $"{ToPrettyString(uid):entity} started taking high temperature damage");
temperature.TakingDamage = true;
}
var diff = Math.Abs(temperature.CurrentTemperature - heatDamageThreshold);
var tempDamage = c / (1 + a * Math.Pow(Math.E, -heatK * diff)) - y;
_damageable.TryChangeDamage(uid, temperature.HeatDamage * tempDamage, ignoreResistances: true, interruptsDoAfters: false);
} }
else if (temperature.CurrentTemperature <= coldDamageThreshold)
{
if (!temperature.TakingDamage)
{
_adminLogger.Add(LogType.Temperature, $"{ToPrettyString(uid):entity} started taking low temperature damage");
temperature.TakingDamage = true;
}
var diff = Math.Abs(temperature.CurrentTemperature - coldDamageThreshold);
var tempDamage =
Math.Sqrt(diff * (Math.Pow(temperature.DamageCap.Double(), 2) / coldDamageThreshold));
_damageable.TryChangeDamage(uid, temperature.ColdDamage * tempDamage, ignoreResistances: true, interruptsDoAfters: false);
}
else if (temperature.TakingDamage)
{
_adminLogger.Add(LogType.Temperature, $"{ToPrettyString(uid):entity} stopped taking temperature damage");
temperature.TakingDamage = false;
}
}
private void OnTemperatureChangeAttempt(EntityUid uid, TemperatureProtectionComponent component,
InventoryRelayedEvent<ModifyChangedTemperatureEvent> args)
{
args.Args.TemperatureDelta *= component.Coefficient;
}
private void OnParentChange(EntityUid uid, TemperatureComponent component,
ref EntParentChangedMessage args)
{
var temperatureQuery = GetEntityQuery<TemperatureComponent>();
var transformQuery = GetEntityQuery<TransformComponent>();
var thresholdsQuery = GetEntityQuery<ContainerTemperatureDamageThresholdsComponent>();
// We only need to update thresholds if the thresholds changed for the entity's ancestors.
var oldThresholds = args.OldParent != null
? RecalculateParentThresholds(args.OldParent.Value, transformQuery, thresholdsQuery)
: (null, null);
var newThresholds = RecalculateParentThresholds(transformQuery.GetComponent(uid).ParentUid, transformQuery, thresholdsQuery);
if (oldThresholds != newThresholds)
{
RecursiveThresholdUpdate(uid, temperatureQuery, transformQuery, thresholdsQuery);
}
}
private void OnParentThresholdStartup(EntityUid uid, ContainerTemperatureDamageThresholdsComponent component,
ComponentStartup args)
{
RecursiveThresholdUpdate(uid, GetEntityQuery<TemperatureComponent>(), GetEntityQuery<TransformComponent>(),
GetEntityQuery<ContainerTemperatureDamageThresholdsComponent>());
}
private void OnParentThresholdShutdown(EntityUid uid, ContainerTemperatureDamageThresholdsComponent component,
ComponentShutdown args)
{
RecursiveThresholdUpdate(uid, GetEntityQuery<TemperatureComponent>(), GetEntityQuery<TransformComponent>(),
GetEntityQuery<ContainerTemperatureDamageThresholdsComponent>());
}
/// <summary>
/// Recalculate and apply parent thresholds for the root entity and all its descendant.
/// </summary>
/// <param name="root"></param>
/// <param name="temperatureQuery"></param>
/// <param name="transformQuery"></param>
/// <param name="tempThresholdsQuery"></param>
private void RecursiveThresholdUpdate(EntityUid root, EntityQuery<TemperatureComponent> temperatureQuery,
EntityQuery<TransformComponent> transformQuery,
EntityQuery<ContainerTemperatureDamageThresholdsComponent> tempThresholdsQuery)
{
RecalculateAndApplyParentThresholds(root, temperatureQuery, transformQuery, tempThresholdsQuery);
foreach (var child in Transform(root).ChildEntities)
{
RecursiveThresholdUpdate(child, temperatureQuery, transformQuery, tempThresholdsQuery);
}
}
/// <summary>
/// Recalculate parent thresholds and apply them on the uid temperature component.
/// </summary>
/// <param name="uid"></param>
/// <param name="temperatureQuery"></param>
/// <param name="transformQuery"></param>
/// <param name="tempThresholdsQuery"></param>
private void RecalculateAndApplyParentThresholds(EntityUid uid,
EntityQuery<TemperatureComponent> temperatureQuery, EntityQuery<TransformComponent> transformQuery,
EntityQuery<ContainerTemperatureDamageThresholdsComponent> tempThresholdsQuery)
{
if (!temperatureQuery.TryGetComponent(uid, out var temperature))
{
return;
}
var newThresholds = RecalculateParentThresholds(transformQuery.GetComponent(uid).ParentUid, transformQuery, tempThresholdsQuery);
temperature.ParentHeatDamageThreshold = newThresholds.Item1;
temperature.ParentColdDamageThreshold = newThresholds.Item2;
}
/// <summary>
/// Recalculate Parent Heat/Cold DamageThreshold by recursively checking each ancestor and fetching the
/// maximum HeatDamageThreshold and the minimum ColdDamageThreshold if any exists (aka the best value for each).
/// </summary>
/// <param name="initialParentUid"></param>
/// <param name="transformQuery"></param>
/// <param name="tempThresholdsQuery"></param>
private (float?, float?) RecalculateParentThresholds(
EntityUid initialParentUid,
EntityQuery<TransformComponent> transformQuery,
EntityQuery<ContainerTemperatureDamageThresholdsComponent> tempThresholdsQuery)
{
// Recursively check parents for the best threshold available
var parentUid = initialParentUid;
float? newHeatThreshold = null;
float? newColdThreshold = null;
while (parentUid.IsValid())
{
if (tempThresholdsQuery.TryGetComponent(parentUid, out var newThresholds))
{
if (newThresholds.HeatDamageThreshold != null)
{
newHeatThreshold = Math.Max(newThresholds.HeatDamageThreshold.Value,
newHeatThreshold ?? 0);
}
if (newThresholds.ColdDamageThreshold != null)
{
newColdThreshold = Math.Min(newThresholds.ColdDamageThreshold.Value,
newColdThreshold ?? float.MaxValue);
}
}
parentUid = transformQuery.GetComponent(parentUid).ParentUid;
}
return (newHeatThreshold, newColdThreshold);
}
}
public sealed class OnTemperatureChangeEvent : EntityEventArgs
{
public float CurrentTemperature { get; }
public float LastTemperature { get; }
public float TemperatureDelta { get; }
public OnTemperatureChangeEvent(float current, float last, float delta)
{
CurrentTemperature = current;
LastTemperature = last;
TemperatureDelta = delta;
} }
} }