290 lines
11 KiB
C#
290 lines
11 KiB
C#
using Content.Server.Atmos.Components;
|
|
using Content.Server.Decals;
|
|
using Content.Shared.Atmos;
|
|
using Content.Shared.Atmos.Components;
|
|
using Content.Shared.Atmos.Reactions;
|
|
using Content.Shared.Database;
|
|
using Robust.Shared.Audio;
|
|
using Robust.Shared.Map;
|
|
using Robust.Shared.Map.Components;
|
|
using Robust.Shared.Prototypes;
|
|
using Robust.Shared.Random;
|
|
|
|
namespace Content.Server.Atmos.EntitySystems;
|
|
|
|
public sealed partial class AtmosphereSystem
|
|
{
|
|
/*
|
|
Handles Hotspots, which are gas-based tile fires that slowly grow and spread
|
|
to adjacent tiles if conditions are met.
|
|
|
|
You can think of a hotspot as a small flame on a tile that
|
|
grows by consuming a fuel and oxidizer from the tile's air,
|
|
with a certain volume and temperature.
|
|
|
|
This volume grows bigger and bigger as the fire continues,
|
|
until it effectively engulfs the entire tile, at which point
|
|
it starts spreading to adjacent tiles by radiating heat.
|
|
*/
|
|
|
|
/// <summary>
|
|
/// Collection of hotspot sounds to play.
|
|
/// </summary>
|
|
private static readonly ProtoId<SoundCollectionPrototype> DefaultHotspotSounds = "AtmosHotspot";
|
|
|
|
[Dependency] private readonly DecalSystem _decalSystem = default!;
|
|
[Dependency] private readonly IRobustRandom _random = default!;
|
|
|
|
/// <summary>
|
|
/// Number of cycles the hotspot system must process before it can play another sound
|
|
/// on a hotspot.
|
|
/// </summary>
|
|
private const int HotspotSoundCooldownCycles = 200;
|
|
|
|
/// <summary>
|
|
/// Cooldown counter for hotspot sounds.
|
|
/// </summary>
|
|
private int _hotspotSoundCooldown = 0;
|
|
|
|
[ViewVariables(VVAccess.ReadWrite)]
|
|
public SoundSpecifier? HotspotSound = new SoundCollectionSpecifier(DefaultHotspotSounds);
|
|
|
|
/// <summary>
|
|
/// Processes a hotspot on a <see cref="TileAtmosphere"/>.
|
|
/// </summary>
|
|
/// <param name="ent">The grid entity that belongs to the tile to process.</param>
|
|
/// <param name="tile">The <see cref="TileAtmosphere"/> to process.</param>
|
|
private void ProcessHotspot(
|
|
Entity<GridAtmosphereComponent, GasTileOverlayComponent, MapGridComponent, TransformComponent> ent,
|
|
TileAtmosphere tile)
|
|
{
|
|
var gridAtmosphere = ent.Comp1;
|
|
|
|
// Hotspots that have fizzled out are assigned a new Hotspot struct
|
|
// with Valid set to false, so we can just check that here in
|
|
// one central place instead of manually removing it everywhere.
|
|
if (!tile.Hotspot.Valid)
|
|
{
|
|
gridAtmosphere.HotspotTiles.Remove(tile);
|
|
return;
|
|
}
|
|
|
|
AddActiveTile(gridAtmosphere, tile);
|
|
|
|
// Prevent the hotspot from processing on the same cycle it was created (???)
|
|
// TODO ATMOS: Is this even necessary anymore? The queue is kept per processing stage
|
|
// and is not updated until tne next cycle, so the condition of a hotspot being created
|
|
// and processed in the same cycle is impossible.
|
|
if (!tile.Hotspot.SkippedFirstProcess)
|
|
{
|
|
tile.Hotspot.SkippedFirstProcess = true;
|
|
return;
|
|
}
|
|
|
|
if (tile.ExcitedGroup != null)
|
|
ExcitedGroupResetCooldowns(tile.ExcitedGroup);
|
|
|
|
if (tile.Hotspot.Temperature < Atmospherics.FireMinimumTemperatureToExist ||
|
|
tile.Hotspot.Volume <= 1f ||
|
|
tile.Air == null ||
|
|
tile.Air.GetMoles(Gas.Oxygen) < 0.5f ||
|
|
tile.Air.GetMoles(Gas.Plasma) < 0.5f && tile.Air.GetMoles(Gas.Tritium) < 0.5f)
|
|
{
|
|
tile.Hotspot = new Hotspot();
|
|
InvalidateVisuals(ent, tile);
|
|
return;
|
|
}
|
|
|
|
PerformHotspotExposure(tile);
|
|
|
|
// This tile has now turned into a full-blown tile-fire.
|
|
// Start applying fire effects and spreading to adjacent tiles.
|
|
if (tile.Hotspot.Bypassing)
|
|
{
|
|
tile.Hotspot.State = 3;
|
|
|
|
var gridUid = ent.Owner;
|
|
var tilePos = tile.GridIndices;
|
|
|
|
// Get the existing decals on the tile
|
|
var tileDecals = _decalSystem.GetDecalsInRange(gridUid, tilePos);
|
|
|
|
// Count the burnt decals on the tile
|
|
var tileBurntDecals = 0;
|
|
|
|
foreach (var set in tileDecals)
|
|
{
|
|
if (Array.IndexOf(_burntDecals, set.Decal.Id) == -1)
|
|
continue;
|
|
|
|
tileBurntDecals++;
|
|
|
|
if (tileBurntDecals > 4)
|
|
break;
|
|
}
|
|
|
|
// Add a random burned decal to the tile only if there are less than 4 of them
|
|
if (tileBurntDecals < 4)
|
|
{
|
|
_decalSystem.TryAddDecal(_burntDecals[_random.Next(_burntDecals.Length)],
|
|
new EntityCoordinates(gridUid, tilePos),
|
|
out _,
|
|
cleanable: true);
|
|
}
|
|
|
|
if (tile.Air.Temperature > Atmospherics.FireMinimumTemperatureToSpread)
|
|
{
|
|
var radiatedTemperature = tile.Air.Temperature * Atmospherics.FireSpreadRadiosityScale;
|
|
foreach (var otherTile in tile.AdjacentTiles)
|
|
{
|
|
// TODO ATMOS: This is sus. Suss this out.
|
|
// Spread this fire to other tiles by exposing them to a hotspot if air can flow there.
|
|
// Unsure as to why this is sus.
|
|
if (otherTile == null)
|
|
continue;
|
|
|
|
if (!otherTile.Hotspot.Valid)
|
|
HotspotExpose(gridAtmosphere, otherTile, radiatedTemperature, Atmospherics.CellVolume / 4);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Little baby fire. Set the sprite state based on the current size of the fire.
|
|
tile.Hotspot.State = (byte)(tile.Hotspot.Volume > Atmospherics.CellVolume * 0.4f ? 2 : 1);
|
|
}
|
|
|
|
if (tile.Hotspot.Temperature > tile.MaxFireTemperatureSustained)
|
|
tile.MaxFireTemperatureSustained = tile.Hotspot.Temperature;
|
|
|
|
if (_hotspotSoundCooldown++ == 0 && HotspotSound != null)
|
|
{
|
|
var coordinates = _mapSystem.ToCenterCoordinates(tile.GridIndex, tile.GridIndices);
|
|
|
|
// A few details on the audio parameters for fire.
|
|
// The greater the fire state, the lesser the pitch variation.
|
|
// The greater the fire state, the greater the volume.
|
|
_audio.PlayPvs(HotspotSound,
|
|
coordinates,
|
|
HotspotSound.Params.WithVariation(0.15f / tile.Hotspot.State)
|
|
.WithVolume(-5f + 5f * tile.Hotspot.State));
|
|
}
|
|
|
|
if (_hotspotSoundCooldown > HotspotSoundCooldownCycles)
|
|
_hotspotSoundCooldown = 0;
|
|
|
|
// TODO ATMOS Maybe destroy location here?
|
|
}
|
|
|
|
/// <summary>
|
|
/// Exposes a tile to a hotspot of given temperature and volume, igniting it if conditions are met.
|
|
/// </summary>
|
|
/// <param name="gridAtmosphere">The <see cref="GridAtmosphereComponent"/> of the grid the tile is on.</param>
|
|
/// <param name="tile">The <see cref="TileAtmosphere"/> to expose.</param>
|
|
/// <param name="exposedTemperature">The temperature of the hotspot to expose.
|
|
/// You can think of this as exposing a temperature of a flame.</param>
|
|
/// <param name="exposedVolume">The volume of the hotspot to expose.
|
|
/// You can think of this as how big the flame is initially.
|
|
/// Bigger flames will ramp a fire faster.</param>
|
|
/// <param name="soh">Whether to "boost" a fire that's currently on the tile already.
|
|
/// Does nothing if the tile isn't already a hotspot.
|
|
/// This clamps the temperature and volume of the hotspot to the maximum
|
|
/// of the provided parameters and whatever's on the tile.</param>
|
|
/// <param name="sparkSourceUid">Entity that started the exposure for admin logging.</param>
|
|
private void HotspotExpose(GridAtmosphereComponent gridAtmosphere,
|
|
TileAtmosphere tile,
|
|
float exposedTemperature,
|
|
float exposedVolume,
|
|
bool soh = false,
|
|
EntityUid? sparkSourceUid = null)
|
|
{
|
|
if (tile.Air == null)
|
|
return;
|
|
|
|
var oxygen = tile.Air.GetMoles(Gas.Oxygen);
|
|
|
|
if (oxygen < 0.5f)
|
|
return;
|
|
|
|
var plasma = tile.Air.GetMoles(Gas.Plasma);
|
|
var tritium = tile.Air.GetMoles(Gas.Tritium);
|
|
|
|
if (tile.Hotspot.Valid)
|
|
{
|
|
if (soh)
|
|
{
|
|
if (plasma > 0.5f || tritium > 0.5f)
|
|
{
|
|
tile.Hotspot.Temperature = MathF.Max(tile.Hotspot.Temperature, exposedTemperature);
|
|
tile.Hotspot.Volume = MathF.Max(tile.Hotspot.Volume, exposedVolume);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (exposedTemperature > Atmospherics.PlasmaMinimumBurnTemperature && (plasma > 0.5f || tritium > 0.5f))
|
|
{
|
|
if (sparkSourceUid.HasValue)
|
|
{
|
|
_adminLog.Add(LogType.Flammable,
|
|
LogImpact.High,
|
|
$"Heat/spark of {ToPrettyString(sparkSourceUid.Value)} caused atmos ignition of gas: {tile.Air.Temperature.ToString():temperature}K - {oxygen}mol Oxygen, {plasma}mol Plasma, {tritium}mol Tritium");
|
|
}
|
|
|
|
tile.Hotspot = new Hotspot
|
|
{
|
|
Volume = exposedVolume * 25f,
|
|
Temperature = exposedTemperature,
|
|
SkippedFirstProcess = tile.CurrentCycle > gridAtmosphere.UpdateCounter,
|
|
Valid = true,
|
|
State = 1
|
|
};
|
|
|
|
AddActiveTile(gridAtmosphere, tile);
|
|
gridAtmosphere.HotspotTiles.Add(tile);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Performs hotspot exposure processing on a <see cref="TileAtmosphere"/>.
|
|
/// </summary>
|
|
/// <param name="tile">The <see cref="TileAtmosphere"/> to process.</param>
|
|
private void PerformHotspotExposure(TileAtmosphere tile)
|
|
{
|
|
if (tile.Air == null || !tile.Hotspot.Valid)
|
|
return;
|
|
|
|
// Determine if the tile has become a full-blown fire if the volume of the fire has effectively reached
|
|
// the volume of the tile's air.
|
|
tile.Hotspot.Bypassing = tile.Hotspot.SkippedFirstProcess && tile.Hotspot.Volume > tile.Air.Volume * 0.95f;
|
|
|
|
// If the tile is effectively a full fire, use the tile's air for reactions, don't bother partitioning.
|
|
if (tile.Hotspot.Bypassing)
|
|
{
|
|
tile.Hotspot.Volume = tile.Air.ReactionResults[(byte)GasReaction.Fire] * Atmospherics.FireGrowthRate;
|
|
tile.Hotspot.Temperature = tile.Air.Temperature;
|
|
}
|
|
// Otherwise, pull out a fraction of the tile's air (the current hotspot volume) to perform reactions on.
|
|
else
|
|
{
|
|
var affected = tile.Air.RemoveVolume(tile.Hotspot.Volume);
|
|
affected.Temperature = tile.Hotspot.Temperature;
|
|
React(affected, tile);
|
|
tile.Hotspot.Temperature = affected.Temperature;
|
|
// Scale the fire based on the type of reaction that occured.
|
|
tile.Hotspot.Volume = affected.ReactionResults[(byte)GasReaction.Fire] * Atmospherics.FireGrowthRate;
|
|
Merge(tile.Air, affected);
|
|
}
|
|
|
|
var fireEvent = new TileFireEvent(tile.Hotspot.Temperature, tile.Hotspot.Volume);
|
|
_entSet.Clear();
|
|
_lookup.GetLocalEntitiesIntersecting(tile.GridIndex, tile.GridIndices, _entSet, 0f);
|
|
|
|
foreach (var entity in _entSet)
|
|
{
|
|
RaiseLocalEvent(entity, ref fireEvent);
|
|
}
|
|
}
|
|
}
|