Cinka/OldThink
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Gas tank internals alerts (#9567)

Browse Source
This commit is contained in:
metalgearsloth
2022-07-25 14:42:25 +10:00
committed by GitHub
parent dad26db137
commit 40a7584c2f
25 changed files with 570 additions and 354 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
Content.Server/Atmos/Components/BreathToolComponent.cs
View File

@@ -1,5 +1,4 @@
using Content.Server.Body.Components;
using Content.Shared.Inventory;
using Content.Shared.Inventory;
namespace Content.Server.Atmos.Components
{
@@ -10,33 +9,12 @@ namespace Content.Server.Atmos.Components
[ComponentProtoName("BreathMask")]
public sealed class BreathToolComponent : Component
{
[Dependency] private readonly IEntityManager _entities = default!;
/// <summary>
/// Tool is functional only in allowed slots
/// </summary>
[DataField("allowedSlots")]
public SlotFlags AllowedSlots = SlotFlags.MASK;
public bool IsFunctional;
public EntityUid ConnectedInternalsEntity;
protected override void Shutdown()
{
base.Shutdown();
DisconnectInternals();
}
public void DisconnectInternals()
{
var old = ConnectedInternalsEntity;
ConnectedInternalsEntity = default;
if (old != default && _entities.TryGetComponent<InternalsComponent?>(old, out var internalsComponent))
{
internalsComponent.DisconnectBreathTool();
}
IsFunctional = false;
}
public EntityUid? ConnectedInternalsEntity;
}
}

250
Content.Server/Atmos/Components/GasTankComponent.cs
View File

@@ -1,49 +1,35 @@
using Content.Server.Atmos.EntitySystems;
using Content.Server.Body.Components;
using Content.Server.Explosion.EntitySystems;
using Content.Server.UserInterface;
using Content.Shared.Actions;
using Content.Shared.Actions.ActionTypes;
using Content.Shared.Atmos;
using Content.Shared.Atmos.Components;
using Content.Shared.Audio;
using Content.Shared.Sound;
using Robust.Server.GameObjects;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Robust.Shared.Player;
namespace Content.Server.Atmos.Components
{
[RegisterComponent]
#pragma warning disable 618
public sealed class GasTankComponent : Component, IGasMixtureHolder
#pragma warning restore 618
{
[Dependency] private readonly IEntityManager _entMan = default!;
private const float MaxExplosionRange = 14f;
public const float MaxExplosionRange = 14f;
private const float DefaultOutputPressure = Atmospherics.OneAtmosphere;
private int _integrity = 3;
public int Integrity = 3;
[ViewVariables] public BoundUserInterface? UserInterface;
[ViewVariables(VVAccess.ReadWrite), DataField("ruptureSound")]
public SoundSpecifier RuptureSound = new SoundPathSpecifier("/Audio/Effects/spray.ogg");
[ViewVariables(VVAccess.ReadWrite), DataField("ruptureSound")] private SoundSpecifier _ruptureSound = new SoundPathSpecifier("/Audio/Effects/spray.ogg");
[ViewVariables(VVAccess.ReadWrite), DataField("connectSound")] private SoundSpecifier? _connectSound =
[ViewVariables(VVAccess.ReadWrite), DataField("connectSound")]
public SoundSpecifier? ConnectSound =
new SoundPathSpecifier("/Audio/Effects/internals.ogg")
{
Params = AudioParams.Default.WithVolume(10f),
Params = AudioParams.Default.WithVolume(5f),
};
[ViewVariables(VVAccess.ReadWrite), DataField("disconnectSound")] private SoundSpecifier? _disconnectSound;
[ViewVariables(VVAccess.ReadWrite), DataField("disconnectSound")]
public SoundSpecifier? DisconnectSound;
// Cancel toggles sounds if we re-toggle again.
private IPlayingAudioStream? _connectStream;
private IPlayingAudioStream? _disconnectStream;
public IPlayingAudioStream? ConnectStream;
public IPlayingAudioStream? DisconnectStream;
[DataField("air")] [ViewVariables] public GasMixture Air { get; set; } = new();
@@ -52,18 +38,13 @@ namespace Content.Server.Atmos.Components
/// </summary>
[DataField("outputPressure")]
[ViewVariables]
public float OutputPressure { get; private set; } = DefaultOutputPressure;
public float OutputPressure { get; set; } = DefaultOutputPressure;
/// <summary>
/// Tank is connected to internals.
/// </summary>
[ViewVariables] public bool IsConnected { get; set; }
/// <summary>
/// Represents that tank is functional and can be connected to internals.
/// </summary>
public bool IsFunctional => GetInternalsComponent() != null;
/// <summary>
/// Pressure at which tanks start leaking.
/// </summary>
@@ -90,212 +71,5 @@ namespace Content.Server.Atmos.Components
[DataField("toggleAction", required: true)]
public InstantAction ToggleAction = new();
protected override void Initialize()
{
base.Initialize();
UserInterface = Owner.GetUIOrNull(SharedGasTankUiKey.Key);
if (UserInterface != null)
{
UserInterface.OnReceiveMessage += UserInterfaceOnOnReceiveMessage;
}
}
protected override void Shutdown()
{
base.Shutdown();
DisconnectFromInternals();
}
public GasMixture? RemoveAir(float amount)
{
var gas = Air?.Remove(amount);
CheckStatus();
return gas;
}
public GasMixture RemoveAirVolume(float volume)
{
if (Air == null)
return new GasMixture(volume);
var tankPressure = Air.Pressure;
if (tankPressure < OutputPressure)
{
OutputPressure = tankPressure;
UpdateUserInterface();
}
var molesNeeded = OutputPressure * volume / (Atmospherics.R * Air.Temperature);
var air = RemoveAir(molesNeeded);
if (air != null)
air.Volume = volume;
else
return new GasMixture(volume);
return air;
}
public void ConnectToInternals()
{
if (IsConnected || !IsFunctional) return;
var internals = GetInternalsComponent();
if (internals == null) return;
IsConnected = internals.TryConnectTank(Owner);
EntitySystem.Get<SharedActionsSystem>().SetToggled(ToggleAction, IsConnected);
// Couldn't toggle!
if (!IsConnected) return;
_connectStream?.Stop();
if (_connectSound != null)
_connectStream = SoundSystem.Play(_connectSound.GetSound(), Filter.Pvs(Owner, entityManager: _entMan), Owner, _connectSound.Params);
UpdateUserInterface();
}
public void DisconnectFromInternals(EntityUid? owner = null)
{
if (!IsConnected) return;
IsConnected = false;
EntitySystem.Get<SharedActionsSystem>().SetToggled(ToggleAction, false);
GetInternalsComponent(owner)?.DisconnectTank();
_disconnectStream?.Stop();
if (_disconnectSound != null)
_disconnectStream = SoundSystem.Play(_disconnectSound.GetSound(), Filter.Pvs(Owner, entityManager: _entMan), Owner, _disconnectSound.Params);
UpdateUserInterface();
}
public void UpdateUserInterface(bool initialUpdate = false)
{
var internals = GetInternalsComponent();
UserInterface?.SetState(
new GasTankBoundUserInterfaceState
{
TankPressure = Air?.Pressure ?? 0,
OutputPressure = initialUpdate ? OutputPressure : null,
InternalsConnected = IsConnected,
CanConnectInternals = IsFunctional && internals != null
});
}
private void UserInterfaceOnOnReceiveMessage(ServerBoundUserInterfaceMessage message)
{
switch (message.Message)
{
case GasTankSetPressureMessage msg:
OutputPressure = msg.Pressure;
break;
case GasTankToggleInternalsMessage _:
ToggleInternals();
break;
}
}
internal void ToggleInternals()
{
if (IsConnected)
{
DisconnectFromInternals();
return;
}
ConnectToInternals();
}
private InternalsComponent? GetInternalsComponent(EntityUid? owner = null)
{
if (_entMan.Deleted(Owner)) return null;
if (owner != null) return _entMan.GetComponentOrNull<InternalsComponent>(owner.Value);
return Owner.TryGetContainer(out var container)
? _entMan.GetComponentOrNull<InternalsComponent>(container.Owner)
: null;
}
public void AssumeAir(GasMixture giver)
{
var atmos = EntitySystem.Get<AtmosphereSystem>();
atmos.Merge(Air, giver);
CheckStatus(atmos);
}
public void CheckStatus(AtmosphereSystem? atmosphereSystem=null)
{
if (Air == null)
return;
atmosphereSystem ??= EntitySystem.Get<AtmosphereSystem>();
var pressure = Air.Pressure;
if (pressure > TankFragmentPressure)
{
// Give the gas a chance to build up more pressure.
for (var i = 0; i < 3; i++)
{
atmosphereSystem.React(Air, this);
}
pressure = Air.Pressure;
var range = (pressure - TankFragmentPressure) / TankFragmentScale;
// Let's cap the explosion, yeah?
// !1984
if (range > MaxExplosionRange)
{
range = MaxExplosionRange;
}
EntitySystem.Get<ExplosionSystem>().TriggerExplosive(Owner, radius: range);
return;
}
if (pressure > TankRupturePressure)
{
if (_integrity <= 0)
{
var environment = atmosphereSystem.GetContainingMixture(Owner, false, true);
if(environment != null)
atmosphereSystem.Merge(environment, Air);
SoundSystem.Play(_ruptureSound.GetSound(), Filter.Pvs(Owner), _entMan.GetComponent<TransformComponent>(Owner).Coordinates, AudioHelpers.WithVariation(0.125f));
_entMan.QueueDeleteEntity(Owner);
return;
}
_integrity--;
return;
}
if (pressure > TankLeakPressure)
{
if (_integrity <= 0)
{
var environment = atmosphereSystem.GetContainingMixture(Owner, false, true);
if (environment == null)
return;
var leakedGas = Air.RemoveRatio(0.25f);
atmosphereSystem.Merge(environment, leakedGas);
}
else
{
_integrity--;
}
return;
}
if (_integrity < 3)
_integrity++;
}
}
}

30
Content.Server/Atmos/EntitySystems/AtmosphereSystem.BreathTool.cs Normal file
View File

@@ -0,0 +1,30 @@
using Content.Server.Atmos.Components;
using Content.Server.Body.Components;
namespace Content.Server.Atmos.EntitySystems;
public sealed partial class AtmosphereSystem
{
private void InitializeBreathTool()
{
SubscribeLocalEvent<BreathToolComponent, ComponentShutdown>(OnBreathToolShutdown);
}
private void OnBreathToolShutdown(EntityUid uid, BreathToolComponent component, ComponentShutdown args)
{
DisconnectInternals(component);
}
public void DisconnectInternals(BreathToolComponent component)
{
var old = component.ConnectedInternalsEntity;
component.ConnectedInternalsEntity = null;
if (TryComp<InternalsComponent>(old, out var internalsComponent))
{
_internals.DisconnectBreathTool(internalsComponent);
}
component.IsFunctional = false;
}
}

3
Content.Server/Atmos/EntitySystems/AtmosphereSystem.cs
View File

@@ -1,5 +1,6 @@
using Content.Server.Administration.Logs;
using Content.Server.Atmos.Components;
using Content.Server.Body.Systems;
using Content.Server.NodeContainer.EntitySystems;
using Content.Shared.Atmos.EntitySystems;
using Content.Shared.Maps;
@@ -21,6 +22,7 @@ public sealed partial class AtmosphereSystem : SharedAtmosphereSystem
[Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
[Dependency] private readonly IRobustRandom _robustRandom = default!;
[Dependency] private readonly IAdminLogManager _adminLog = default!;
[Dependency] private readonly InternalsSystem _internals = default!;
[Dependency] private readonly SharedContainerSystem _containers = default!;
[Dependency] private readonly SharedPhysicsSystem _physics = default!;
[Dependency] private readonly GasTileOverlaySystem _gasTileOverlaySystem = default!;
@@ -36,6 +38,7 @@ public sealed partial class AtmosphereSystem : SharedAtmosphereSystem
UpdatesAfter.Add(typeof(NodeGroupSystem));
InitializeBreathTool();
InitializeGases();
InitializeCommands();
InitializeCVars();

239
Content.Server/Atmos/EntitySystems/GasTankSystem.cs
View File

@@ -1,10 +1,22 @@
using Content.Server.Atmos.Components;
using Content.Server.Body.Components;
using Content.Server.Body.Systems;
using Content.Server.Explosion.EntitySystems;
using Content.Server.UserInterface;
using Content.Shared.Actions;
using Content.Shared.Atmos;
using Content.Shared.Atmos.Components;
using Content.Shared.Audio;
using Content.Shared.Interaction.Events;
using Content.Shared.Toggleable;
using Content.Shared.Examine;
using Content.Shared.Inventory;
using JetBrains.Annotations;
using Robust.Server.GameObjects;
using Robust.Server.Player;
using Robust.Shared.Audio;
using Robust.Shared.Containers;
using Robust.Shared.Player;
namespace Content.Server.Atmos.EntitySystems
{
@@ -12,6 +24,11 @@ namespace Content.Server.Atmos.EntitySystems
public sealed class GasTankSystem : EntitySystem
{
[Dependency] private readonly AtmosphereSystem _atmosphereSystem = default!;
[Dependency] private readonly ExplosionSystem _explosions = default!;
[Dependency] private readonly InternalsSystem _internals = default!;
[Dependency] private readonly SharedContainerSystem _containers = default!;
[Dependency] private readonly SharedActionsSystem _actions = default!;
[Dependency] private readonly UserInterfaceSystem _ui = default!;
private const float TimerDelay = 0.5f;
private float _timer = 0f;
@@ -19,22 +36,57 @@ namespace Content.Server.Atmos.EntitySystems
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<GasTankComponent, ComponentShutdown>(OnGasShutdown);
SubscribeLocalEvent<GasTankComponent, BeforeActivatableUIOpenEvent>(BeforeUiOpen);
SubscribeLocalEvent<GasTankComponent, GetItemActionsEvent>(OnGetActions);
SubscribeLocalEvent<GasTankComponent, ExaminedEvent>(OnExamined);
SubscribeLocalEvent<GasTankComponent, ToggleActionEvent>(OnActionToggle);
SubscribeLocalEvent<GasTankComponent, DroppedEvent>(OnDropped);
SubscribeLocalEvent<GasTankComponent, GasTankSetPressureMessage>(OnGasTankSetPressure);
SubscribeLocalEvent<GasTankComponent, GasTankToggleInternalsMessage>(OnGasTankToggleInternals);
}
private void OnGasShutdown(EntityUid uid, GasTankComponent component, ComponentShutdown args)
{
DisconnectFromInternals(component);
}
private void OnGasTankToggleInternals(EntityUid uid, GasTankComponent component, GasTankToggleInternalsMessage args)
{
if (args.Session is not IPlayerSession playerSession ||
playerSession.AttachedEntity is not {} player) return;
ToggleInternals(component);
}
private void OnGasTankSetPressure(EntityUid uid, GasTankComponent component, GasTankSetPressureMessage args)
{
component.OutputPressure = args.Pressure;
}
public void UpdateUserInterface(GasTankComponent component, bool initialUpdate = false)
{
var internals = GetInternalsComponent(component);
_ui.GetUiOrNull(component.Owner, SharedGasTankUiKey.Key)?.SetState(
new GasTankBoundUserInterfaceState
{
TankPressure = component.Air?.Pressure ?? 0,
OutputPressure = initialUpdate ? component.OutputPressure : null,
InternalsConnected = component.IsConnected,
CanConnectInternals = IsFunctional(component) && internals != null
});
}
private void BeforeUiOpen(EntityUid uid, GasTankComponent component, BeforeActivatableUIOpenEvent args)
{
// Only initial update includes output pressure information, to avoid overwriting client-input as the updates come in.
component.UpdateUserInterface(true);
UpdateUserInterface(component, true);
}
private void OnDropped(EntityUid uid, GasTankComponent component, DroppedEvent args)
{
component.DisconnectFromInternals(args.User);
DisconnectFromInternals(component, args.User);
}
private void OnGetActions(EntityUid uid, GasTankComponent component, GetItemActionsEvent args)
@@ -55,8 +107,7 @@ namespace Content.Server.Atmos.EntitySystems
if (args.Handled)
return;
component.ToggleInternals();
ToggleInternals(component);
args.Handled = true;
}
@@ -72,13 +123,185 @@ namespace Content.Server.Atmos.EntitySystems
foreach (var gasTank in EntityManager.EntityQuery<GasTankComponent>())
{
_atmosphereSystem.React(gasTank.Air, gasTank);
gasTank.CheckStatus(_atmosphereSystem);
if (gasTank.UserInterface != null && gasTank.UserInterface.SubscribedSessions.Count > 0)
CheckStatus(gasTank);
if (_ui.IsUiOpen(gasTank.Owner, SharedGasTankUiKey.Key))
{
gasTank.UpdateUserInterface();
UpdateUserInterface(gasTank);
}
}
}
private void ToggleInternals(GasTankComponent component)
{
if (component.IsConnected)
{
DisconnectFromInternals(component);
}
else
{
ConnectToInternals(component);
}
}
public GasMixture? RemoveAir(GasTankComponent component, float amount)
{
var gas = component.Air?.Remove(amount);
CheckStatus(component);
return gas;
}
public GasMixture RemoveAirVolume(GasTankComponent component, float volume)
{
if (component.Air == null)
return new GasMixture(volume);
var tankPressure = component.Air.Pressure;
if (tankPressure < component.OutputPressure)
{
component.OutputPressure = tankPressure;
UpdateUserInterface(component);
}
var molesNeeded = component.OutputPressure * volume / (Atmospherics.R * component.Air.Temperature);
var air = RemoveAir(component, molesNeeded);
if (air != null)
air.Volume = volume;
else
return new GasMixture(volume);
return air;
}
public bool CanConnectToInternals(GasTankComponent component)
{
return !component.IsConnected && IsFunctional(component);
}
public void ConnectToInternals(GasTankComponent component)
{
if (!CanConnectToInternals(component)) return;
var internals = GetInternalsComponent(component);
if (internals == null) return;
component.IsConnected = _internals.TryConnectTank(internals, component.Owner);
_actions.SetToggled(component.ToggleAction, component.IsConnected);
// Couldn't toggle!
if (!component.IsConnected) return;
component.ConnectStream?.Stop();
if (component.ConnectSound != null)
component.ConnectStream = SoundSystem.Play(component.ConnectSound.GetSound(), Filter.Pvs(component.Owner, entityManager: EntityManager), component.Owner, component.ConnectSound.Params);
UpdateUserInterface(component);
}
public void DisconnectFromInternals(GasTankComponent component, EntityUid? owner = null)
{
if (!component.IsConnected) return;
component.IsConnected = false;
_actions.SetToggled(component.ToggleAction, false);
_internals.DisconnectTank(GetInternalsComponent(component, owner));
component.DisconnectStream?.Stop();
if (component.DisconnectSound != null)
component.DisconnectStream = SoundSystem.Play(component.DisconnectSound.GetSound(), Filter.Pvs(component.Owner, entityManager: EntityManager), component.Owner, component.DisconnectSound.Params);
UpdateUserInterface(component);
}
private InternalsComponent? GetInternalsComponent(GasTankComponent component, EntityUid? owner = null)
{
if (Deleted(component.Owner)) return null;
if (owner != null) return CompOrNull<InternalsComponent>(owner.Value);
return _containers.TryGetContainingContainer(component.Owner, out var container)
? CompOrNull<InternalsComponent>(container.Owner)
: null;
}
public void AssumeAir(GasTankComponent component, GasMixture giver)
{
_atmosphereSystem.Merge(component.Air, giver);
CheckStatus(component);
}
public void CheckStatus(GasTankComponent component)
{
if (component.Air == null)
return;
var pressure = component.Air.Pressure;
if (pressure > component.TankFragmentPressure)
{
// Give the gas a chance to build up more pressure.
for (var i = 0; i < 3; i++)
{
_atmosphereSystem.React(component.Air, component);
}
pressure = component.Air.Pressure;
var range = (pressure - component.TankFragmentPressure) / component.TankFragmentScale;
// Let's cap the explosion, yeah?
// !1984
if (range > GasTankComponent.MaxExplosionRange)
{
range = GasTankComponent.MaxExplosionRange;
}
_explosions.TriggerExplosive(component.Owner, radius: range);
return;
}
if (pressure > component.TankRupturePressure)
{
if (component.Integrity <= 0)
{
var environment = _atmosphereSystem.GetContainingMixture(component.Owner, false, true);
if(environment != null)
_atmosphereSystem.Merge(environment, component.Air);
SoundSystem.Play(component.RuptureSound.GetSound(), Filter.Pvs(component.Owner), Transform(component.Owner).Coordinates, AudioHelpers.WithVariation(0.125f));
QueueDel(component.Owner);
return;
}
component.Integrity--;
return;
}
if (pressure > component.TankLeakPressure)
{
if (component.Integrity <= 0)
{
var environment = _atmosphereSystem.GetContainingMixture(component.Owner, false, true);
if (environment == null)
return;
var leakedGas = component.Air.RemoveRatio(0.25f);
_atmosphereSystem.Merge(environment, leakedGas);
}
else
{
component.Integrity--;
}
return;
}
if (component.Integrity < 3)
component.Integrity++;
}
private bool IsFunctional(GasTankComponent component)
{
return GetInternalsComponent(component) != null;
}
}
}