273 lines
9.7 KiB
C#
273 lines
9.7 KiB
C#
using Content.Shared.Damage;
|
|
using Content.Shared.Atmos;
|
|
using Content.Server.Atmos.EntitySystems;
|
|
using Content.Server.Body.Components;
|
|
using Content.Server.Temperature.Components;
|
|
using Content.Shared.Atmos.Miasma;
|
|
using Content.Shared.Examine;
|
|
using Content.Shared.Mobs;
|
|
using Content.Shared.Mobs.Systems;
|
|
using Content.Shared.Rejuvenate;
|
|
using Robust.Server.Containers;
|
|
using Robust.Server.GameObjects;
|
|
using Robust.Shared.Physics.Components;
|
|
using Robust.Shared.Random;
|
|
using Robust.Shared.Timing;
|
|
|
|
namespace Content.Server.Atmos.Miasma;
|
|
|
|
public sealed class RottingSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly IGameTiming _timing = default!;
|
|
[Dependency] private readonly IRobustRandom _random = default!;
|
|
[Dependency] private readonly AtmosphereSystem _atmosphere = default!;
|
|
[Dependency] private readonly ContainerSystem _container = default!;
|
|
[Dependency] private readonly DamageableSystem _damageable = default!;
|
|
[Dependency] private readonly MobStateSystem _mobState = default!;
|
|
[Dependency] private readonly TransformSystem _transform = default!;
|
|
|
|
/// Miasma Disease Pool
|
|
/// Miasma outbreaks are not per-entity,
|
|
/// so this ensures that each entity in the same incident
|
|
/// receives the same disease.
|
|
|
|
public readonly IReadOnlyList<string> MiasmaDiseasePool = new[]
|
|
{
|
|
"VentCough",
|
|
"AMIV",
|
|
"SpaceCold",
|
|
"SpaceFlu",
|
|
"BirdFlew",
|
|
"VanAusdallsRobovirus",
|
|
"BleedersBite",
|
|
"Plague",
|
|
"TongueTwister",
|
|
"MemeticAmirmir"
|
|
};
|
|
|
|
/// <summary>
|
|
/// The current pool disease.
|
|
/// </summary>
|
|
private string _poolDisease = "";
|
|
|
|
/// <summary>
|
|
/// The target time it waits until..
|
|
/// After that, it resets current time + _poolRepickTime.
|
|
/// Any infection will also reset it to current time + _poolRepickTime.
|
|
/// </summary>
|
|
private TimeSpan _diseaseTime = TimeSpan.FromMinutes(5);
|
|
|
|
/// <summary>
|
|
/// How long without an infection before we pick a new disease.
|
|
/// </summary>
|
|
private readonly TimeSpan _poolRepickTime = TimeSpan.FromMinutes(5);
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
|
|
SubscribeLocalEvent<PerishableComponent, EntityUnpausedEvent>(OnPerishableUnpaused);
|
|
SubscribeLocalEvent<PerishableComponent, MobStateChangedEvent>(OnMobStateChanged);
|
|
|
|
SubscribeLocalEvent<RottingComponent, EntityUnpausedEvent>(OnRottingUnpaused);
|
|
SubscribeLocalEvent<RottingComponent, ComponentShutdown>(OnShutdown);
|
|
SubscribeLocalEvent<RottingComponent, MobStateChangedEvent>(OnRottingMobStateChanged);
|
|
SubscribeLocalEvent<RottingComponent, BeingGibbedEvent>(OnGibbed);
|
|
SubscribeLocalEvent<RottingComponent, ExaminedEvent>(OnExamined);
|
|
SubscribeLocalEvent<RottingComponent, RejuvenateEvent>(OnRejuvenate);
|
|
|
|
SubscribeLocalEvent<FliesComponent, ComponentInit>(OnFliesInit);
|
|
SubscribeLocalEvent<FliesComponent, ComponentShutdown>(OnFliesShutdown);
|
|
|
|
SubscribeLocalEvent<TemperatureComponent, IsRottingEvent>(OnTempIsRotting);
|
|
|
|
// Init disease pool
|
|
_poolDisease = _random.Pick(MiasmaDiseasePool);
|
|
}
|
|
|
|
private void OnPerishableUnpaused(EntityUid uid, PerishableComponent component, ref EntityUnpausedEvent args)
|
|
{
|
|
component.NextPerishUpdate += args.PausedTime;
|
|
}
|
|
|
|
private void OnMobStateChanged(EntityUid uid, PerishableComponent component, MobStateChangedEvent args)
|
|
{
|
|
if (!_mobState.IsDead(uid))
|
|
return;
|
|
|
|
component.RotAccumulator = TimeSpan.Zero;
|
|
component.NextPerishUpdate = _timing.CurTime + component.PerishUpdateRate;
|
|
}
|
|
|
|
private void OnRottingUnpaused(EntityUid uid, RottingComponent component, ref EntityUnpausedEvent args)
|
|
{
|
|
component.NextRotUpdate += args.PausedTime;
|
|
}
|
|
|
|
private void OnShutdown(EntityUid uid, RottingComponent component, ComponentShutdown args)
|
|
{
|
|
RemComp<FliesComponent>(uid);
|
|
if (TryComp<PerishableComponent>(uid, out var perishable))
|
|
{
|
|
perishable.NextPerishUpdate = TimeSpan.Zero;
|
|
}
|
|
}
|
|
|
|
private void OnRottingMobStateChanged(EntityUid uid, RottingComponent component, MobStateChangedEvent args)
|
|
{
|
|
if (args.NewMobState == MobState.Dead)
|
|
return;
|
|
RemCompDeferred(uid, component);
|
|
}
|
|
|
|
public bool IsRotProgressing(EntityUid uid, PerishableComponent? perishable)
|
|
{
|
|
// things don't perish by default.
|
|
if (!Resolve(uid, ref perishable, false))
|
|
return false;
|
|
|
|
// only dead things perish
|
|
if (!_mobState.IsDead(uid))
|
|
return false;
|
|
|
|
if (_container.TryGetOuterContainer(uid, Transform(uid), out var container) &&
|
|
HasComp<AntiRottingContainerComponent>(container.Owner))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var ev = new IsRottingEvent();
|
|
RaiseLocalEvent(uid, ref ev);
|
|
|
|
return ev.Handled;
|
|
}
|
|
|
|
public bool IsRotten(EntityUid uid, RottingComponent? rotting = null)
|
|
{
|
|
return Resolve(uid, ref rotting, false);
|
|
}
|
|
|
|
private void OnGibbed(EntityUid uid, RottingComponent component, BeingGibbedEvent args)
|
|
{
|
|
if (!TryComp<PhysicsComponent>(uid, out var physics))
|
|
return;
|
|
|
|
if (!TryComp<PerishableComponent>(uid, out var perishable))
|
|
return;
|
|
|
|
var molsToDump = perishable.MolsPerSecondPerUnitMass * physics.FixturesMass * (float) component.TotalRotTime.TotalSeconds;
|
|
var transform = Transform(uid);
|
|
var indices = _transform.GetGridOrMapTilePosition(uid, transform);
|
|
var tileMix = _atmosphere.GetTileMixture(transform.GridUid, transform.MapUid, indices, true);
|
|
tileMix?.AdjustMoles(Gas.Miasma, molsToDump);
|
|
}
|
|
|
|
private void OnExamined(EntityUid uid, RottingComponent component, ExaminedEvent args)
|
|
{
|
|
if (!TryComp<PerishableComponent>(uid, out var perishable))
|
|
return;
|
|
|
|
var stage = (int) (component.TotalRotTime.TotalSeconds / perishable.RotAfter.TotalSeconds);
|
|
var description = stage switch
|
|
{
|
|
>= 2 => "miasma-extremely-bloated",
|
|
>= 1 => "miasma-bloated",
|
|
_ => "miasma-rotting"
|
|
};
|
|
args.PushMarkup(Loc.GetString(description));
|
|
}
|
|
|
|
private void OnRejuvenate(EntityUid uid, RottingComponent component, RejuvenateEvent args)
|
|
{
|
|
RemCompDeferred<RottingComponent>(uid);
|
|
}
|
|
|
|
/// Containers
|
|
|
|
|
|
#region Fly stuff
|
|
private void OnFliesInit(EntityUid uid, FliesComponent component, ComponentInit args)
|
|
{
|
|
component.VirtFlies = Spawn("AmbientSoundSourceFlies", Transform(uid).Coordinates);
|
|
}
|
|
|
|
private void OnFliesShutdown(EntityUid uid, FliesComponent component, ComponentShutdown args)
|
|
{
|
|
if (!Terminating(uid) && !Deleted(uid))
|
|
Del(component.VirtFlies);
|
|
}
|
|
#endregion
|
|
|
|
private void OnTempIsRotting(EntityUid uid, TemperatureComponent component, ref IsRottingEvent args)
|
|
{
|
|
if (args.Handled)
|
|
return;
|
|
args.Handled = component.CurrentTemperature > Atmospherics.T0C + 0.85f;
|
|
}
|
|
|
|
public string RequestPoolDisease()
|
|
{
|
|
// We reset the current time on this outbreak so people don't get unlucky at the transition time
|
|
_diseaseTime = _timing.CurTime + _poolRepickTime;
|
|
return _poolDisease;
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
if (_timing.CurTime >= _diseaseTime)
|
|
{
|
|
_diseaseTime = _timing.CurTime + _poolRepickTime;
|
|
_poolDisease = _random.Pick(MiasmaDiseasePool);
|
|
}
|
|
|
|
var perishQuery = EntityQueryEnumerator<PerishableComponent>();
|
|
while (perishQuery.MoveNext(out var uid, out var perishable))
|
|
{
|
|
if (_timing.CurTime < perishable.NextPerishUpdate)
|
|
continue;
|
|
perishable.NextPerishUpdate += perishable.PerishUpdateRate;
|
|
|
|
if (IsRotten(uid) || !IsRotProgressing(uid, perishable))
|
|
continue;
|
|
|
|
perishable.RotAccumulator += perishable.PerishUpdateRate;
|
|
if (perishable.RotAccumulator >= perishable.RotAfter)
|
|
{
|
|
var rot = AddComp<RottingComponent>(uid);
|
|
rot.NextRotUpdate = _timing.CurTime + rot.RotUpdateRate;
|
|
EnsureComp<FliesComponent>(uid);
|
|
}
|
|
|
|
}
|
|
|
|
var rotQuery = EntityQueryEnumerator<RottingComponent, PerishableComponent, TransformComponent>();
|
|
while (rotQuery.MoveNext(out var uid, out var rotting, out var perishable, out var xform))
|
|
{
|
|
if (!IsRotProgressing(uid, perishable))
|
|
continue;
|
|
|
|
if (_timing.CurTime < rotting.NextRotUpdate) // This is where it starts to get noticable on larger animals, no need to run every second
|
|
continue;
|
|
rotting.NextRotUpdate += rotting.RotUpdateRate;
|
|
rotting.TotalRotTime += rotting.RotUpdateRate;
|
|
|
|
if (rotting.DealDamage)
|
|
{
|
|
var damage = rotting.Damage * rotting.RotUpdateRate.TotalSeconds;
|
|
_damageable.TryChangeDamage(uid, damage, true, false);
|
|
}
|
|
|
|
if (!TryComp<PhysicsComponent>(uid, out var physics))
|
|
continue;
|
|
// We need a way to get the mass of the mob alone without armor etc in the future
|
|
// or just remove the mass mechanics altogether because they aren't good.
|
|
var molRate = perishable.MolsPerSecondPerUnitMass * (float) rotting.RotUpdateRate.TotalSeconds;
|
|
var indices = _transform.GetGridOrMapTilePosition(uid);
|
|
var tileMix = _atmosphere.GetTileMixture(xform.GridUid, null, indices, true);
|
|
tileMix?.AdjustMoles(Gas.Miasma, molRate * physics.FixturesMass);
|
|
}
|
|
}
|
|
}
|