tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Severely nerf fires and severely buff fire protection (#5396)

Browse Source 
* Make fires do less damage

* Severely nerf fires and severely buff temperature protection

* fuck it, i'll nerf it so hard and we can buff it later if we decide

* new scaling func

* fix

* unused

* reviews + balance metabolism heat + reduce atmos air temp transfer efficiency

* little more balance

* just a wee bit more

* slight adjustment
This commit is contained in:
mirrorcult
2021-11-18 23:08:30 -07:00
committed by GitHub
parent a724292023
commit 07024f7c77
17 changed files with 179 additions and 84 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
Content.Server/Temperature/Systems/TemperatureSystem.cs
View File

@@ -1,9 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using Content.Server.Alert;
using Content.Server.Atmos.Components;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Temperature.Components;
using Content.Shared.Alert;
using Content.Shared.Damage;
using Content.Shared.FixedPoint;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
@@ -14,11 +18,47 @@ namespace Content.Server.Temperature.Systems
[Dependency] private readonly DamageableSystem _damageableSystem = default!;
[Dependency] private readonly AtmosphereSystem _atmosphereSystem = 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 = 0.0f;
public override void Initialize()
{
SubscribeLocalEvent<TemperatureComponent, OnTemperatureChangeEvent>(ChangeDamage);
SubscribeLocalEvent<TemperatureComponent, OnTemperatureChangeEvent>(EnqueueDamage);
SubscribeLocalEvent<TemperatureComponent, AtmosExposedUpdateEvent>(OnAtmosExposedUpdate);
SubscribeLocalEvent<ServerAlertsComponent, OnTemperatureChangeEvent>(ServerAlert);
SubscribeLocalEvent<TemperatureProtectionComponent, ModifyChangedTemperatureEvent>(OnTemperatureChangeAttempt);
}
public override void Update(float frameTime)
{
base.Update(frameTime);
_accumulatedFrametime += frameTime;
if (_accumulatedFrametime < UpdateInterval)
return;
_accumulatedFrametime -= UpdateInterval;
if (!ShouldUpdateDamage.Any())
return;
foreach (var comp in ShouldUpdateDamage)
{
if (comp.Deleted || comp.Paused)
continue;
ChangeDamage(comp.OwnerUid, comp);
}
ShouldUpdateDamage.Clear();
}
public void ForceChangeTemperature(EntityUid uid, float temp, TemperatureComponent? temperature = null)
@@ -32,10 +72,17 @@ namespace Content.Server.Temperature.Systems
}
}
public void ReceiveHeat(EntityUid uid, float heatAmount, TemperatureComponent? temperature = null)
public void ChangeHeat(EntityUid uid, float heatAmount, bool ignoreHeatResistance=false, TemperatureComponent? temperature = null)
{
if (Resolve(uid, ref temperature))
{
if (!ignoreHeatResistance)
{
var ev = new ModifyChangedTemperatureEvent(heatAmount);
RaiseLocalEvent(uid, ev, false);
heatAmount = ev.TemperatureDelta;
}
float lastTemp = temperature.CurrentTemperature;
temperature.CurrentTemperature += heatAmount / temperature.HeatCapacity;
float delta = temperature.CurrentTemperature - lastTemp;
@@ -44,24 +91,12 @@ namespace Content.Server.Temperature.Systems
}
}
public void RemoveHeat(EntityUid uid, float heatAmount, TemperatureComponent? temperature = null)
{
if (Resolve(uid, ref temperature))
{
float lastTemp = temperature.CurrentTemperature;
temperature.CurrentTemperature -= heatAmount / temperature.HeatCapacity;
float delta = temperature.CurrentTemperature - lastTemp;
RaiseLocalEvent(uid, new OnTemperatureChangeEvent(temperature.CurrentTemperature, lastTemp, delta));
}
}
private void OnAtmosExposedUpdate(EntityUid uid, TemperatureComponent temperature, ref AtmosExposedUpdateEvent args)
{
var temperatureDelta = args.GasMixture.Temperature - temperature.CurrentTemperature;
var tileHeatCapacity = _atmosphereSystem.GetHeatCapacity(args.GasMixture);
var heat = temperatureDelta * (tileHeatCapacity * temperature.HeatCapacity / (tileHeatCapacity + temperature.HeatCapacity));
ReceiveHeat(uid, heat, temperature);
ChangeHeat(uid, heat * temperature.AtmosTemperatureTransferEfficiency, temperature: temperature );
}
private void ServerAlert(EntityUid uid, ServerAlertsComponent status, OnTemperatureChangeEvent args)
@@ -94,33 +129,53 @@ namespace Content.Server.Temperature.Systems
break;
// Heat mild.
case <= 345 and > 335:
case <= 360 and > 335:
status.ShowAlert(AlertType.Hot, 2);
break;
// Heat strong.
case > 345:
case > 360:
status.ShowAlert(AlertType.Hot, 3);
break;
}
}
private void ChangeDamage(EntityUid uid, TemperatureComponent temperature, OnTemperatureChangeEvent args)
private void EnqueueDamage(EntityUid uid, TemperatureComponent component, OnTemperatureChangeEvent args)
{
ShouldUpdateDamage.Add(component);
}
private void ChangeDamage(EntityUid uid, TemperatureComponent temperature)
{
if (!EntityManager.TryGetComponent<DamageableComponent>(uid, out var damage))
return;
if (args.CurrentTemperature >= temperature.HeatDamageThreshold)
// 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;
if (temperature.CurrentTemperature >= temperature.HeatDamageThreshold)
{
int tempDamage = (int) Math.Floor((args.CurrentTemperature - temperature.HeatDamageThreshold) * temperature.TempDamageCoefficient);
var diff = Math.Abs(temperature.CurrentTemperature - temperature.HeatDamageThreshold);
var tempDamage = c / (1 + a * Math.Pow(Math.E, -heatK * diff)) - y;
_damageableSystem.TryChangeDamage(uid, temperature.HeatDamage * tempDamage);
}
else if (args.CurrentTemperature <= temperature.ColdDamageThreshold)
else if (temperature.CurrentTemperature <= temperature.ColdDamageThreshold)
{
int tempDamage = (int) Math.Floor((temperature.ColdDamageThreshold - args.CurrentTemperature) * temperature.TempDamageCoefficient);
var diff = Math.Abs(temperature.CurrentTemperature - temperature.ColdDamageThreshold);
var tempDamage =
Math.Sqrt(diff * (Math.Pow(temperature.DamageCap.Double(), 2) / temperature.ColdDamageThreshold));
_damageableSystem.TryChangeDamage(uid, temperature.ColdDamage * tempDamage);
}
}
private void OnTemperatureChangeAttempt(EntityUid uid, TemperatureProtectionComponent component, ModifyChangedTemperatureEvent args)
{
args.TemperatureDelta *= component.Coefficient;
}
}
@@ -137,4 +192,14 @@ namespace Content.Server.Temperature.Systems
TemperatureDelta = delta;
}
}
public class ModifyChangedTemperatureEvent : EntityEventArgs
{
public float TemperatureDelta;
public ModifyChangedTemperatureEvent(float temperature)
{
TemperatureDelta = temperature;
}
}
}