105 lines
4.1 KiB
C#
105 lines
4.1 KiB
C#
using Content.Shared.Damage;
|
|
using Content.Shared.Sound;
|
|
using Robust.Shared.Prototypes;
|
|
using Robust.Shared.Utility;
|
|
|
|
namespace Content.Shared.Explosion;
|
|
|
|
/// <summary>
|
|
/// Explosion Prototype. Determines damage, tile break probabilities, and visuals.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Does not currently support prototype hot-reloading. The explosion-intensity required to destroy airtight
|
|
/// entities is evaluated and stored by the explosion system. Adding or removing a prototype would require updating
|
|
/// that map of airtight entities. This could be done, but is just not yet implemented.
|
|
/// </remarks>
|
|
[Prototype("explosion")]
|
|
public sealed class ExplosionPrototype : IPrototype
|
|
{
|
|
[IdDataField]
|
|
public string ID { get; } = default!;
|
|
|
|
/// <summary>
|
|
/// Damage to deal to entities. This is scaled by the explosion intensity.
|
|
/// </summary>
|
|
[DataField("damagePerIntensity", required: true)]
|
|
public readonly DamageSpecifier DamagePerIntensity = default!;
|
|
|
|
/// <summary>
|
|
/// This set of points, together with <see cref="_tileBreakIntensity"/> define a function that maps the
|
|
/// explosion intensity to a tile break chance via linear interpolation.
|
|
/// </summary>
|
|
[DataField("tileBreakChance")]
|
|
private readonly float[] _tileBreakChance = { 0f, 1f };
|
|
|
|
/// <summary>
|
|
/// This set of points, together with <see cref="_tileBreakChance"/> define a function that maps the
|
|
/// explosion intensity to a tile break chance via linear interpolation.
|
|
/// </summary>
|
|
[DataField("tileBreakIntensity")]
|
|
private readonly float[] _tileBreakIntensity = {0f, 15f };
|
|
|
|
/// <summary>
|
|
/// When a tile is broken by an explosion, the intensity is reduced by this amount and is used to try and
|
|
/// break the tile a second time. This is repeated until a roll fails or the tile has become space.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// If this number is too small, even relatively weak explosions can have a non-zero
|
|
/// chance to create a space tile.
|
|
/// </remarks>
|
|
[DataField("tileBreakRerollReduction")]
|
|
public readonly float TileBreakRerollReduction = 10f;
|
|
|
|
/// <summary>
|
|
/// Color emitted by a point light at the center of the explosion.
|
|
/// </summary>
|
|
[DataField("lightColor")]
|
|
public readonly Color LightColor = Color.Orange;
|
|
|
|
/// <summary>
|
|
/// Color used to modulate the fire texture.
|
|
/// </summary>
|
|
[DataField("fireColor")]
|
|
public readonly Color? FireColor;
|
|
|
|
[DataField("Sound")]
|
|
public readonly SoundSpecifier Sound = new SoundCollectionSpecifier("explosion");
|
|
|
|
[DataField("texturePath")]
|
|
public readonly ResourcePath TexturePath = new("/Textures/Effects/fire.rsi");
|
|
|
|
/// <summary>
|
|
/// How intense does the explosion have to be at a tile to advance to the next fire texture state?
|
|
/// </summary>
|
|
[DataField("intensityPerState")]
|
|
public float IntensityPerState = 12;
|
|
|
|
// Theres probably a better way to do this. Currently Atmos just hard codes a constant int, so I have no one to
|
|
// steal code from.
|
|
[DataField("fireStates")]
|
|
public readonly int FireStates = 3;
|
|
|
|
/// <summary>
|
|
/// Basic function for linear interpolation of the _tileBreakChance and _tileBreakIntensity arrays
|
|
/// </summary>
|
|
public float TileBreakChance(float intensity)
|
|
{
|
|
if (_tileBreakChance.Length == 0 || _tileBreakChance.Length != _tileBreakIntensity.Length)
|
|
{
|
|
Logger.Error($"Malformed tile break chance definitions for explosion prototype: {ID}");
|
|
return 0;
|
|
}
|
|
|
|
if (intensity >= _tileBreakIntensity[^1] || _tileBreakIntensity.Length == 1)
|
|
return _tileBreakChance[^1];
|
|
|
|
if (intensity <= _tileBreakIntensity[0])
|
|
return _tileBreakChance[0];
|
|
|
|
int i = Array.FindIndex(_tileBreakIntensity, k => k >= intensity);
|
|
|
|
var slope = (_tileBreakChance[i] - _tileBreakChance[i - 1]) / (_tileBreakIntensity[i] - _tileBreakIntensity[i - 1]);
|
|
return _tileBreakChance[i - 1] + slope * (intensity - _tileBreakIntensity[i - 1]);
|
|
}
|
|
}
|