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

Firelock ECS + some other stuff. (#8366)

Browse Source 
* firelock rejig

* dont error failed resolves

* fix

* less resolves

* switch fire and pressure messages

* update

Co-authored-by: wrexbe <wrexbe@protonmail.com>
This commit is contained in:
Leon Friedrich
2022-09-06 17:55:33 +12:00
committed by GitHub
parent 414f32a4ee
commit 35a142965d
11 changed files with 192 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

178
Content.Server/Doors/Systems/FirelockSystem.cs
View File

@@ -1,68 +1,133 @@
using Content.Server.Atmos.Monitor.Components;
using Content.Server.Atmos.Components;
using Content.Server.Atmos.EntitySystems;
using Content.Server.Atmos.Monitor.Systems;
using Content.Server.Doors.Components;
using Content.Server.Popups;
using Content.Server.Power.EntitySystems;
using Content.Server.Power.Components;
using Content.Shared.Atmos.Monitor;
using Content.Shared.Doors;
using Content.Shared.Doors.Components;
using Content.Shared.Doors.Systems;
using Content.Shared.Popups;
using Robust.Server.GameObjects;
using Robust.Shared.Player;
namespace Content.Server.Doors.Systems
{
public sealed class FirelockSystem : EntitySystem
{
[Dependency] private readonly PopupSystem _popupSystem = default!;
[Dependency] private readonly SharedDoorSystem _doorSystem = default!;
[Dependency] private readonly AtmosAlarmableSystem _atmosAlarmable = default!;
[Dependency] private readonly AtmosphereSystem _atmosSystem = default!;
[Dependency] private readonly AirtightSystem _airtightSystem = default!;
private static float _visualUpdateInterval = 0.2f;
private float _accumulatedFrameTime;
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<FirelockComponent, BeforeDoorOpenedEvent>(OnBeforeDoorOpened);
SubscribeLocalEvent<FirelockComponent, BeforeDoorDeniedEvent>(OnBeforeDoorDenied);
SubscribeLocalEvent<FirelockComponent, DoorGetPryTimeModifierEvent>(OnDoorGetPryTimeModifier);
SubscribeLocalEvent<FirelockComponent, BeforeDoorPryEvent>(OnBeforeDoorPry);
SubscribeLocalEvent<FirelockComponent, DoorStateChangedEvent>(OnUpdateState);
SubscribeLocalEvent<FirelockComponent, BeforeDoorAutoCloseEvent>(OnBeforeDoorAutoclose);
SubscribeLocalEvent<FirelockComponent, AtmosAlarmEvent>(OnAtmosAlarm);
// Visuals
SubscribeLocalEvent<FirelockComponent, MapInitEvent>(UpdateVisuals);
}
#region Visuals
private void UpdateVisuals(EntityUid uid, FirelockComponent component, EntityEventArgs args) => UpdateVisuals(uid);
public override void Update(float frameTime)
{
_accumulatedFrameTime += frameTime;
if (_accumulatedFrameTime < _visualUpdateInterval)
return;
_accumulatedFrameTime -= _visualUpdateInterval;
var powerQuery = GetEntityQuery<ApcPowerReceiverComponent>();
foreach (var (_, door, appearance, xform) in EntityQuery<FirelockComponent, DoorComponent, AppearanceComponent, TransformComponent>())
{
UpdateVisuals(door.Owner, door, appearance, powerQuery);
}
}
private void UpdateVisuals(EntityUid uid,
DoorComponent? door = null,
AppearanceComponent? appearance = null,
EntityQuery<ApcPowerReceiverComponent>? powerQuery = null)
{
if (!Resolve(uid, ref door, ref appearance, false))
return;
// only bother to check pressure on doors that are some variation of closed.
if (door.State != DoorState.Closed
&& door.State != DoorState.Welded
&& door.State != DoorState.Denying)
{
appearance.SetData(DoorVisuals.ClosedLights, false);
return;
}
powerQuery ??= EntityManager.GetEntityQuery<ApcPowerReceiverComponent>();
if (powerQuery.Value.TryGetComponent(uid, out var receiver) && !receiver.Powered)
{
appearance.SetData(DoorVisuals.ClosedLights, false);
return;
}
appearance.SetData(DoorVisuals.ClosedLights,
IsHoldingPressureOrFire(uid));
}
#endregion
public bool EmergencyPressureStop(EntityUid uid, FirelockComponent? firelock = null, DoorComponent? door = null)
{
if (!Resolve(uid, ref firelock, ref door))
return false;
if (door.State == DoorState.Open)
{
if (_doorSystem.TryClose(door.Owner, door))
{
return _doorSystem.OnPartialClose(door.Owner, door);
}
}
return false;
}
private void OnBeforeDoorOpened(EntityUid uid, FirelockComponent component, BeforeDoorOpenedEvent args)
{
if (!this.IsPowered(uid, EntityManager) || component.IsHoldingFire() || component.IsHoldingPressure())
if (!this.IsPowered(uid, EntityManager) || IsHoldingPressureOrFire(uid))
args.Cancel();
}
private void OnBeforeDoorDenied(EntityUid uid, FirelockComponent component, BeforeDoorDeniedEvent args)
{
args.Cancel();
}
private void OnDoorGetPryTimeModifier(EntityUid uid, FirelockComponent component, DoorGetPryTimeModifierEvent args)
{
if (component.IsHoldingFire() || component.IsHoldingPressure())
var state = CheckPressureAndFire(uid);
if (state.Fire)
{
_popupSystem.PopupEntity(Loc.GetString("firelock-component-is-holding-fire-message"),
uid, Filter.Pvs(uid, entityManager: EntityManager));
}
else if (state.Pressure)
{
_popupSystem.PopupEntity(Loc.GetString("firelock-component-is-holding-pressure-message"),
uid, Filter.Pvs(uid, entityManager: EntityManager));
}
if (state.Fire || state.Pressure)
args.PryTimeModifier *= component.LockedPryTimeModifier;
}
private void OnBeforeDoorPry(EntityUid uid, FirelockComponent component, BeforeDoorPryEvent args)
{
if (!TryComp<DoorComponent>(uid, out var door) || door.State != DoorState.Closed)
{
return;
}
if (component.IsHoldingPressure())
{
component.Owner.PopupMessage(args.User, Loc.GetString("firelock-component-is-holding-pressure-message"));
}
else if (component.IsHoldingFire())
{
component.Owner.PopupMessage(args.User, Loc.GetString("firelock-component-is-holding-fire-message"));
}
}
private void OnUpdateState(EntityUid uid, FirelockComponent component, DoorStateChangedEvent args)
{
var ev = new BeforeDoorAutoCloseEvent();
@@ -73,6 +138,7 @@ namespace Content.Server.Doors.Systems
}
_doorSystem.SetNextStateChange(uid, component.AutocloseDelay);
UpdateVisuals(uid, component, args);
}
private void OnBeforeDoorAutoclose(EntityUid uid, FirelockComponent component, BeforeDoorAutoCloseEvent args)
@@ -83,7 +149,8 @@ namespace Content.Server.Doors.Systems
// Make firelocks autoclose, but only if the last alarm type it
// remembers was a danger. This is to prevent people from
// flooding hallways with endless bad air/fire.
if (_atmosAlarmable.TryGetHighestAlert(uid, out var alarm) && alarm != AtmosAlarmType.Danger || alarm == null)
if (component.AlarmAutoClose &&
(_atmosAlarmable.TryGetHighestAlert(uid, out var alarm) && alarm != AtmosAlarmType.Danger || alarm == null))
args.Cancel();
}
@@ -98,7 +165,58 @@ namespace Content.Server.Doors.Systems
}
else if (args.AlarmType == AtmosAlarmType.Danger)
{
component.EmergencyPressureStop();
EmergencyPressureStop(uid, component, doorComponent);
}
}
public bool IsHoldingPressureOrFire(EntityUid uid)
{
var result = CheckPressureAndFire(uid);
return result.Pressure || result.Fire;
}
public (bool Pressure, bool Fire) CheckPressureAndFire(EntityUid owner)
{
float threshold = 20;
var atmosphereSystem = EntityManager.EntitySysManager.GetEntitySystem<AtmosphereSystem>();
var transformSystem = EntityManager.EntitySysManager.GetEntitySystem<TransformSystem>();
var transform = EntityManager.GetComponent<TransformComponent>(owner);
var position = transformSystem.GetGridOrMapTilePosition(owner, transform);
if (transform.GridUid is not {} gridUid)
return (false, false);
var minMoles = float.MaxValue;
var maxMoles = 0f;
return (IsHoldingPressure(), IsHoldingFire());
bool IsHoldingPressure()
{
foreach (var adjacent in atmosphereSystem.GetAdjacentTileMixtures(gridUid, position))
{
var moles = adjacent.TotalMoles;
if (moles < minMoles)
minMoles = moles;
if (moles > maxMoles)
maxMoles = moles;
}
return (maxMoles - minMoles) > threshold;
}
bool IsHoldingFire()
{
if (atmosphereSystem.GetTileMixture(gridUid, null, position) == null)
return false;
if (atmosphereSystem.IsHotspotActive(gridUid, position))
return true;
foreach (var adjacent in atmosphereSystem.GetAdjacentTiles(gridUid, position))
{
if (atmosphereSystem.IsHotspotActive(gridUid, adjacent))
return true;
}
return false;
}
}
}