661 lines
22 KiB
C#
661 lines
22 KiB
C#
using System.Linq;
|
|
using Content.Server.Atmos.Monitor.Components;
|
|
using Content.Server.Atmos.Piping.Components;
|
|
using Content.Server.DeviceLinking.Systems;
|
|
using Content.Server.DeviceNetwork;
|
|
using Content.Server.DeviceNetwork.Components;
|
|
using Content.Server.DeviceNetwork.Systems;
|
|
using Content.Server.Popups;
|
|
using Content.Server.Power.Components;
|
|
using Content.Server.Power.EntitySystems;
|
|
using Content.Shared.Access.Components;
|
|
using Content.Shared.Access.Systems;
|
|
using Content.Shared.Atmos;
|
|
using Content.Shared.Atmos.Monitor;
|
|
using Content.Shared.Atmos.Monitor.Components;
|
|
using Content.Shared.Atmos.Piping.Unary.Components;
|
|
using Content.Shared.DeviceLinking;
|
|
using Content.Shared.DeviceNetwork;
|
|
using Content.Shared.DeviceNetwork.Systems;
|
|
using Content.Shared.Interaction;
|
|
using Content.Shared.Wires;
|
|
using Robust.Server.GameObjects;
|
|
|
|
namespace Content.Server.Atmos.Monitor.Systems;
|
|
|
|
// AirAlarm system - specific for atmos devices, rather than
|
|
// atmos monitors.
|
|
//
|
|
// oh boy, message passing!
|
|
//
|
|
// Commands should always be sent into packet's Command
|
|
// data key. In response, a packet will be transmitted
|
|
// with the response type as its command, and the
|
|
// response data in its data key.
|
|
public sealed class AirAlarmSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly AccessReaderSystem _access = default!;
|
|
[Dependency] private readonly AtmosAlarmableSystem _atmosAlarmable = default!;
|
|
[Dependency] private readonly AtmosDeviceNetworkSystem _atmosDevNet = default!;
|
|
[Dependency] private readonly DeviceNetworkSystem _deviceNet = default!;
|
|
[Dependency] private readonly DeviceLinkSystem _deviceLink = default!;
|
|
[Dependency] private readonly DeviceListSystem _deviceList = default!;
|
|
[Dependency] private readonly PopupSystem _popup = default!;
|
|
[Dependency] private readonly UserInterfaceSystem _ui = default!;
|
|
|
|
#region Device Network API
|
|
|
|
/// <summary>
|
|
/// Command to set an air alarm's mode.
|
|
/// </summary>
|
|
public const string AirAlarmSetMode = "air_alarm_set_mode";
|
|
|
|
// -- API --
|
|
|
|
/// <summary>
|
|
/// Set the data for an air alarm managed device.
|
|
/// </summary>
|
|
/// <param name="address">The address of the device.</param>
|
|
/// <param name="data">The data to send to the device.</param>
|
|
public void SetData(EntityUid uid, string address, IAtmosDeviceData data)
|
|
{
|
|
_atmosDevNet.SetDeviceState(uid, address, data);
|
|
_atmosDevNet.Sync(uid, address);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Broadcast a sync packet to an air alarm's local network.
|
|
/// </summary>
|
|
private void SyncAllDevices(EntityUid uid)
|
|
{
|
|
_atmosDevNet.Sync(uid, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send a sync packet to a specific device from an air alarm.
|
|
/// </summary>
|
|
/// <param name="address">The address of the device.</param>
|
|
private void SyncDevice(EntityUid uid, string address)
|
|
{
|
|
_atmosDevNet.Sync(uid, address);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Register and synchronize with all devices
|
|
/// on this network.
|
|
/// </summary>
|
|
/// <param name="uid"></param>
|
|
private void SyncRegisterAllDevices(EntityUid uid)
|
|
{
|
|
_atmosDevNet.Register(uid, null);
|
|
_atmosDevNet.Sync(uid, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Synchronize all sensors on an air alarm, but only if its current tab is set to Sensors.
|
|
/// </summary>
|
|
/// <param name="uid"></param>
|
|
/// <param name="monitor"></param>
|
|
private void SyncAllSensors(EntityUid uid, AirAlarmComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
foreach (var addr in monitor.SensorData.Keys)
|
|
{
|
|
SyncDevice(uid, addr);
|
|
}
|
|
}
|
|
|
|
private void SetThreshold(EntityUid uid, string address, AtmosMonitorThresholdType type,
|
|
AtmosAlarmThreshold threshold, Gas? gas = null)
|
|
{
|
|
var payload = new NetworkPayload
|
|
{
|
|
[DeviceNetworkConstants.Command] = AtmosMonitorSystem.AtmosMonitorSetThresholdCmd,
|
|
[AtmosMonitorSystem.AtmosMonitorThresholdDataType] = type,
|
|
[AtmosMonitorSystem.AtmosMonitorThresholdData] = threshold,
|
|
};
|
|
|
|
if (gas != null)
|
|
{
|
|
payload.Add(AtmosMonitorSystem.AtmosMonitorThresholdGasType, gas);
|
|
}
|
|
|
|
_deviceNet.QueuePacket(uid, address, payload);
|
|
|
|
SyncDevice(uid, address);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sync this air alarm's mode with the rest of the network.
|
|
/// </summary>
|
|
/// <param name="mode">The mode to sync with the rest of the network.</param>
|
|
private void SyncMode(EntityUid uid, AirAlarmMode mode)
|
|
{
|
|
if (TryComp<AtmosMonitorComponent>(uid, out var monitor) && !monitor.NetEnabled)
|
|
return;
|
|
|
|
var payload = new NetworkPayload
|
|
{
|
|
[DeviceNetworkConstants.Command] = AirAlarmSetMode,
|
|
[AirAlarmSetMode] = mode
|
|
};
|
|
|
|
_deviceNet.QueuePacket(uid, null, payload);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Events
|
|
|
|
public override void Initialize()
|
|
{
|
|
SubscribeLocalEvent<AirAlarmComponent, DeviceNetworkPacketEvent>(OnPacketRecv);
|
|
SubscribeLocalEvent<AirAlarmComponent, AtmosDeviceUpdateEvent>(OnAtmosUpdate);
|
|
SubscribeLocalEvent<AirAlarmComponent, AtmosAlarmEvent>(OnAtmosAlarm);
|
|
SubscribeLocalEvent<AirAlarmComponent, PowerChangedEvent>(OnPowerChanged);
|
|
SubscribeLocalEvent<AirAlarmComponent, AirAlarmResyncAllDevicesMessage>(OnResyncAll);
|
|
SubscribeLocalEvent<AirAlarmComponent, AirAlarmUpdateAlarmModeMessage>(OnUpdateAlarmMode);
|
|
SubscribeLocalEvent<AirAlarmComponent, AirAlarmUpdateAutoModeMessage>(OnUpdateAutoMode);
|
|
SubscribeLocalEvent<AirAlarmComponent, AirAlarmUpdateAlarmThresholdMessage>(OnUpdateThreshold);
|
|
SubscribeLocalEvent<AirAlarmComponent, AirAlarmUpdateDeviceDataMessage>(OnUpdateDeviceData);
|
|
SubscribeLocalEvent<AirAlarmComponent, AirAlarmCopyDeviceDataMessage>(OnCopyDeviceData);
|
|
SubscribeLocalEvent<AirAlarmComponent, AirAlarmTabSetMessage>(OnTabChange);
|
|
SubscribeLocalEvent<AirAlarmComponent, DeviceListUpdateEvent>(OnDeviceListUpdate);
|
|
SubscribeLocalEvent<AirAlarmComponent, BoundUIClosedEvent>(OnClose);
|
|
SubscribeLocalEvent<AirAlarmComponent, ComponentInit>(OnInit);
|
|
SubscribeLocalEvent<AirAlarmComponent, MapInitEvent>(OnMapInit);
|
|
SubscribeLocalEvent<AirAlarmComponent, ComponentShutdown>(OnShutdown);
|
|
SubscribeLocalEvent<AirAlarmComponent, ActivateInWorldEvent>(OnActivate);
|
|
}
|
|
|
|
private void OnDeviceListUpdate(EntityUid uid, AirAlarmComponent component, DeviceListUpdateEvent args)
|
|
{
|
|
var query = GetEntityQuery<DeviceNetworkComponent>();
|
|
foreach (var device in args.OldDevices)
|
|
{
|
|
if (!query.TryGetComponent(device, out var deviceNet))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
_atmosDevNet.Deregister(uid, deviceNet.Address);
|
|
}
|
|
|
|
component.ScrubberData.Clear();
|
|
component.SensorData.Clear();
|
|
component.VentData.Clear();
|
|
component.KnownDevices.Clear();
|
|
|
|
UpdateUI(uid, component);
|
|
|
|
SyncRegisterAllDevices(uid);
|
|
}
|
|
|
|
private void OnTabChange(EntityUid uid, AirAlarmComponent component, AirAlarmTabSetMessage msg)
|
|
{
|
|
component.CurrentTab = msg.Tab;
|
|
UpdateUI(uid, component);
|
|
}
|
|
|
|
private void OnPowerChanged(EntityUid uid, AirAlarmComponent component, ref PowerChangedEvent args)
|
|
{
|
|
if (args.Powered)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ForceCloseAllInterfaces(uid);
|
|
component.CurrentModeUpdater = null;
|
|
component.KnownDevices.Clear();
|
|
component.ScrubberData.Clear();
|
|
component.SensorData.Clear();
|
|
component.VentData.Clear();
|
|
}
|
|
|
|
private void OnClose(EntityUid uid, AirAlarmComponent component, BoundUIClosedEvent args)
|
|
{
|
|
component.ActivePlayers.Remove(args.Session.UserId);
|
|
if (component.ActivePlayers.Count == 0)
|
|
RemoveActiveInterface(uid);
|
|
}
|
|
|
|
private void OnInit(EntityUid uid, AirAlarmComponent comp, ComponentInit args)
|
|
{
|
|
_deviceLink.EnsureSourcePorts(uid, comp.DangerPort, comp.WarningPort, comp.NormalPort);
|
|
}
|
|
|
|
private void OnMapInit(EntityUid uid, AirAlarmComponent comp, MapInitEvent args)
|
|
{
|
|
// for mapped linked air alarms, start with high so when it changes for the first time it goes from high to low
|
|
// without this the output would suddenly get sent a low signal after nothing which is bad
|
|
_deviceLink.SendSignal(uid, GetPort(comp), true);
|
|
}
|
|
|
|
private void OnShutdown(EntityUid uid, AirAlarmComponent component, ComponentShutdown args)
|
|
{
|
|
_activeUserInterfaces.Remove(uid);
|
|
}
|
|
|
|
private void OnActivate(EntityUid uid, AirAlarmComponent component, ActivateInWorldEvent args)
|
|
{
|
|
if (!TryComp<ActorComponent>(args.User, out var actor))
|
|
return;
|
|
|
|
if (TryComp<WiresPanelComponent>(uid, out var panel) && panel.Open)
|
|
{
|
|
args.Handled = false;
|
|
return;
|
|
}
|
|
|
|
if (!this.IsPowered(uid, EntityManager))
|
|
return;
|
|
|
|
var ui = _ui.GetUiOrNull(uid, SharedAirAlarmInterfaceKey.Key);
|
|
if (ui != null)
|
|
_ui.OpenUi(ui, actor.PlayerSession);
|
|
component.ActivePlayers.Add(actor.PlayerSession.UserId);
|
|
AddActiveInterface(uid);
|
|
SyncAllDevices(uid);
|
|
UpdateUI(uid, component);
|
|
}
|
|
|
|
private void OnResyncAll(EntityUid uid, AirAlarmComponent component, AirAlarmResyncAllDevicesMessage args)
|
|
{
|
|
if (!AccessCheck(uid, args.Session.AttachedEntity, component))
|
|
{
|
|
return;
|
|
}
|
|
|
|
component.KnownDevices.Clear();
|
|
component.VentData.Clear();
|
|
component.ScrubberData.Clear();
|
|
component.SensorData.Clear();
|
|
|
|
SyncRegisterAllDevices(uid);
|
|
}
|
|
|
|
private void OnUpdateAlarmMode(EntityUid uid, AirAlarmComponent component, AirAlarmUpdateAlarmModeMessage args)
|
|
{
|
|
if (AccessCheck(uid, args.Session.AttachedEntity, component))
|
|
{
|
|
var addr = string.Empty;
|
|
if (TryComp<DeviceNetworkComponent>(uid, out var netConn))
|
|
{
|
|
addr = netConn.Address;
|
|
}
|
|
|
|
SetMode(uid, addr, args.Mode, false);
|
|
}
|
|
else
|
|
{
|
|
UpdateUI(uid, component);
|
|
}
|
|
}
|
|
|
|
private void OnUpdateAutoMode(EntityUid uid, AirAlarmComponent component, AirAlarmUpdateAutoModeMessage args)
|
|
{
|
|
component.AutoMode = args.Enabled;
|
|
UpdateUI(uid, component);
|
|
}
|
|
|
|
private void OnUpdateThreshold(EntityUid uid, AirAlarmComponent component, AirAlarmUpdateAlarmThresholdMessage args)
|
|
{
|
|
if (AccessCheck(uid, args.Session.AttachedEntity, component))
|
|
SetThreshold(uid, args.Address, args.Type, args.Threshold, args.Gas);
|
|
else
|
|
UpdateUI(uid, component);
|
|
}
|
|
|
|
private void OnUpdateDeviceData(EntityUid uid, AirAlarmComponent component, AirAlarmUpdateDeviceDataMessage args)
|
|
{
|
|
if (AccessCheck(uid, args.Session.AttachedEntity, component)
|
|
&& _deviceList.ExistsInDeviceList(uid, args.Address))
|
|
{
|
|
SetDeviceData(uid, args.Address, args.Data);
|
|
}
|
|
else
|
|
{
|
|
UpdateUI(uid, component);
|
|
}
|
|
}
|
|
|
|
private void OnCopyDeviceData(EntityUid uid, AirAlarmComponent component, AirAlarmCopyDeviceDataMessage args)
|
|
{
|
|
if (!AccessCheck(uid, args.Session.AttachedEntity, component))
|
|
{
|
|
UpdateUI(uid, component);
|
|
return;
|
|
}
|
|
|
|
switch (args.Data)
|
|
{
|
|
case GasVentPumpData ventData:
|
|
foreach (string addr in component.VentData.Keys)
|
|
{
|
|
SetData(uid, addr, args.Data);
|
|
}
|
|
break;
|
|
|
|
case GasVentScrubberData scrubberData:
|
|
foreach (string addr in component.ScrubberData.Keys)
|
|
{
|
|
SetData(uid, addr, args.Data);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private bool AccessCheck(EntityUid uid, EntityUid? user, AirAlarmComponent? component = null)
|
|
{
|
|
if (!Resolve(uid, ref component))
|
|
return false;
|
|
|
|
// if it has no access reader behave as if the user has AA
|
|
if (!TryComp<AccessReaderComponent>(uid, out var reader))
|
|
return true;
|
|
|
|
if (user == null)
|
|
return false;
|
|
|
|
if (!_access.IsAllowed(user.Value, uid, reader))
|
|
{
|
|
_popup.PopupEntity(Loc.GetString("air-alarm-ui-access-denied"), user.Value, user.Value);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private void OnAtmosAlarm(EntityUid uid, AirAlarmComponent component, AtmosAlarmEvent args)
|
|
{
|
|
if (component.ActivePlayers.Count != 0)
|
|
{
|
|
SyncAllDevices(uid);
|
|
}
|
|
|
|
var addr = string.Empty;
|
|
if (TryComp<DeviceNetworkComponent>(uid, out var netConn))
|
|
{
|
|
addr = netConn.Address;
|
|
}
|
|
|
|
if (component.AutoMode)
|
|
{
|
|
if (args.AlarmType == AtmosAlarmType.Danger)
|
|
{
|
|
SetMode(uid, addr, AirAlarmMode.WideFiltering, false);
|
|
}
|
|
else if (args.AlarmType == AtmosAlarmType.Normal || args.AlarmType == AtmosAlarmType.Warning)
|
|
{
|
|
SetMode(uid, addr, AirAlarmMode.Filtering, false);
|
|
}
|
|
}
|
|
|
|
if (component.State != args.AlarmType)
|
|
{
|
|
TryComp<DeviceLinkSourceComponent>(uid, out var source);
|
|
|
|
// send low to old state's port
|
|
_deviceLink.SendSignal(uid, GetPort(component), false, source);
|
|
|
|
// send high to new state's port, along with updating the cached state
|
|
component.State = args.AlarmType;
|
|
_deviceLink.SendSignal(uid, GetPort(component), true, source);
|
|
}
|
|
|
|
UpdateUI(uid, component);
|
|
}
|
|
|
|
private string GetPort(AirAlarmComponent comp)
|
|
{
|
|
if (comp.State == AtmosAlarmType.Danger)
|
|
return comp.DangerPort;
|
|
|
|
if (comp.State == AtmosAlarmType.Warning)
|
|
return comp.WarningPort;
|
|
|
|
return comp.NormalPort;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Air Alarm Settings
|
|
|
|
/// <summary>
|
|
/// Set an air alarm's mode.
|
|
/// </summary>
|
|
/// <param name="origin">The origin address of this mode set. Used for network sync.</param>
|
|
/// <param name="mode">The mode to set the alarm to.</param>
|
|
/// <param name="uiOnly">Whether this change is for the UI only, or if it changes the air alarm's operating mode. Defaults to true.</param>
|
|
public void SetMode(EntityUid uid, string origin, AirAlarmMode mode, bool uiOnly = true, AirAlarmComponent? controller = null)
|
|
{
|
|
if (!Resolve(uid, ref controller) || controller.CurrentMode == mode)
|
|
{
|
|
return;
|
|
}
|
|
|
|
controller.CurrentMode = mode;
|
|
|
|
// setting it to UI only means we don't have
|
|
// to deal with the issue of not-single-owner
|
|
// alarm mode executors
|
|
if (!uiOnly)
|
|
{
|
|
var newMode = AirAlarmModeFactory.ModeToExecutor(mode);
|
|
if (newMode != null)
|
|
{
|
|
newMode.Execute(uid);
|
|
if (newMode is IAirAlarmModeUpdate updatedMode)
|
|
{
|
|
controller.CurrentModeUpdater = updatedMode;
|
|
controller.CurrentModeUpdater.NetOwner = origin;
|
|
}
|
|
else if (controller.CurrentModeUpdater != null)
|
|
controller.CurrentModeUpdater = null;
|
|
}
|
|
}
|
|
// only one air alarm in a network can use an air alarm mode
|
|
// that updates, so even if it's a ui-only change,
|
|
// we have to invalidate the last mode's updater and
|
|
// remove it because otherwise it'll execute a now
|
|
// invalid mode
|
|
else if (controller.CurrentModeUpdater != null
|
|
&& controller.CurrentModeUpdater.NetOwner != origin)
|
|
{
|
|
controller.CurrentModeUpdater = null;
|
|
}
|
|
|
|
UpdateUI(uid, controller);
|
|
|
|
// setting sync deals with the issue of air alarms
|
|
// in the same network needing to have the same mode
|
|
// as other alarms
|
|
SyncMode(uid, mode);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets device data. Practically a wrapper around the packet sending function, SetData.
|
|
/// </summary>
|
|
/// <param name="address">The address to send the new data to.</param>
|
|
/// <param name="devData">The device data to be sent.</param>
|
|
private void SetDeviceData(EntityUid uid, string address, IAtmosDeviceData devData, AirAlarmComponent? controller = null)
|
|
{
|
|
if (!Resolve(uid, ref controller))
|
|
{
|
|
return;
|
|
}
|
|
|
|
devData.Dirty = true;
|
|
SetData(uid, address, devData);
|
|
}
|
|
|
|
private void OnPacketRecv(EntityUid uid, AirAlarmComponent controller, DeviceNetworkPacketEvent args)
|
|
{
|
|
if (!args.Data.TryGetValue(DeviceNetworkConstants.Command, out string? cmd))
|
|
return;
|
|
|
|
switch (cmd)
|
|
{
|
|
case AtmosDeviceNetworkSystem.SyncData:
|
|
if (!args.Data.TryGetValue(AtmosDeviceNetworkSystem.SyncData, out IAtmosDeviceData? data)
|
|
|| !controller.CanSync)
|
|
break;
|
|
|
|
// Save into component.
|
|
// Sync data to interface.
|
|
switch (data)
|
|
{
|
|
case GasVentPumpData ventData:
|
|
if (!controller.VentData.TryAdd(args.SenderAddress, ventData))
|
|
controller.VentData[args.SenderAddress] = ventData;
|
|
break;
|
|
case GasVentScrubberData scrubberData:
|
|
if (!controller.ScrubberData.TryAdd(args.SenderAddress, scrubberData))
|
|
controller.ScrubberData[args.SenderAddress] = scrubberData;
|
|
break;
|
|
case AtmosSensorData sensorData:
|
|
if (!controller.SensorData.TryAdd(args.SenderAddress, sensorData))
|
|
controller.SensorData[args.SenderAddress] = sensorData;
|
|
break;
|
|
}
|
|
|
|
controller.KnownDevices.Add(args.SenderAddress);
|
|
|
|
UpdateUI(uid, controller);
|
|
|
|
return;
|
|
case AirAlarmSetMode:
|
|
if (!args.Data.TryGetValue(AirAlarmSetMode, out AirAlarmMode alarmMode))
|
|
break;
|
|
|
|
SetMode(uid, args.SenderAddress, alarmMode, uiOnly: false);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UI
|
|
|
|
// List of active user interfaces.
|
|
private readonly HashSet<EntityUid> _activeUserInterfaces = new();
|
|
|
|
/// <summary>
|
|
/// Adds an active interface to be updated.
|
|
/// </summary>
|
|
private void AddActiveInterface(EntityUid uid)
|
|
{
|
|
_activeUserInterfaces.Add(uid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Removes an active interface from the system update loop.
|
|
/// </summary>
|
|
private void RemoveActiveInterface(EntityUid uid)
|
|
{
|
|
_activeUserInterfaces.Remove(uid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Force closes all interfaces currently open related to this air alarm.
|
|
/// </summary>
|
|
private void ForceCloseAllInterfaces(EntityUid uid)
|
|
{
|
|
_ui.TryCloseAll(uid, SharedAirAlarmInterfaceKey.Key);
|
|
}
|
|
|
|
private void OnAtmosUpdate(EntityUid uid, AirAlarmComponent alarm, AtmosDeviceUpdateEvent args)
|
|
{
|
|
alarm.CurrentModeUpdater?.Update(uid);
|
|
}
|
|
|
|
public float CalculatePressureAverage(AirAlarmComponent alarm)
|
|
{
|
|
return alarm.SensorData.Count != 0
|
|
? alarm.SensorData.Values.Select(v => v.Pressure).Average()
|
|
: 0f;
|
|
}
|
|
|
|
public float CalculateTemperatureAverage(AirAlarmComponent alarm)
|
|
{
|
|
return alarm.SensorData.Count != 0
|
|
? alarm.SensorData.Values.Select(v => v.Temperature).Average()
|
|
: 0f;
|
|
}
|
|
|
|
public void UpdateUI(EntityUid uid, AirAlarmComponent? alarm = null, DeviceNetworkComponent? devNet = null, AtmosAlarmableComponent? alarmable = null)
|
|
{
|
|
if (!Resolve(uid, ref alarm, ref devNet, ref alarmable))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var pressure = CalculatePressureAverage(alarm);
|
|
var temperature = CalculateTemperatureAverage(alarm);
|
|
var dataToSend = new Dictionary<string, IAtmosDeviceData>();
|
|
|
|
if (alarm.CurrentTab != AirAlarmTab.Settings)
|
|
{
|
|
switch (alarm.CurrentTab)
|
|
{
|
|
case AirAlarmTab.Vent:
|
|
foreach (var (addr, data) in alarm.VentData)
|
|
{
|
|
dataToSend.Add(addr, data);
|
|
}
|
|
|
|
break;
|
|
case AirAlarmTab.Scrubber:
|
|
foreach (var (addr, data) in alarm.ScrubberData)
|
|
{
|
|
dataToSend.Add(addr, data);
|
|
}
|
|
|
|
break;
|
|
case AirAlarmTab.Sensors:
|
|
foreach (var (addr, data) in alarm.SensorData)
|
|
{
|
|
dataToSend.Add(addr, data);
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
var deviceCount = alarm.KnownDevices.Count;
|
|
|
|
if (!_atmosAlarmable.TryGetHighestAlert(uid, out var highestAlarm))
|
|
{
|
|
highestAlarm = AtmosAlarmType.Normal;
|
|
}
|
|
|
|
_ui.TrySetUiState(
|
|
uid,
|
|
SharedAirAlarmInterfaceKey.Key,
|
|
new AirAlarmUIState(devNet.Address, deviceCount, pressure, temperature, dataToSend, alarm.CurrentMode, alarm.CurrentTab, highestAlarm.Value, alarm.AutoMode));
|
|
}
|
|
|
|
private const float Delay = 8f;
|
|
private float _timer;
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
_timer += frameTime;
|
|
if (_timer >= Delay)
|
|
{
|
|
_timer = 0f;
|
|
foreach (var uid in _activeUserInterfaces)
|
|
{
|
|
SyncAllSensors(uid);
|
|
}
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|