123a4147de
* Fix ActivatableUIRequiresPowerCellComponent stopping power draw when one of two people closes the UI. Also fixes it to check UiKey properly. * Remove unnecessary CrewManifestViewer on PDAs This is for a pop-up crew manifest UI, which the PDA doesn't use. * Fix BoundUIClosedEvents that didn't check UI key/not correctly at least. Uses the new helper method in engine. * Fix drone (cargo shuttle) pilot console UI breaking if two people open it and one person closes it. * Fixes for disposal router/tagger UI. Code was badly copy pasted without changing identifiers, never worked. Also cleaned up some of the logic (text trimming, sounds). Also removed the "refuse to work if you have something in your active hand" check like why. * Avoid running most ActivatableUIComponent logic when closing a UI via toggle Activating the UI while it's already open closes it via toggle. Except it still ran 99% of the "attempting to open" logic which makes no sense. This probably fixes a bug or some other dumb behavior somewhere. * Bitch
492 lines
17 KiB
C#
492 lines
17 KiB
C#
using System.Linq;
|
|
using Content.Server.DeviceNetwork;
|
|
using Content.Server.DeviceNetwork.Systems;
|
|
using Content.Server.Power.Components;
|
|
using Content.Server.UserInterface;
|
|
using Content.Shared.SurveillanceCamera;
|
|
using Robust.Server.GameObjects;
|
|
using Robust.Shared.Player;
|
|
|
|
namespace Content.Server.SurveillanceCamera;
|
|
|
|
public sealed class SurveillanceCameraMonitorSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly SurveillanceCameraSystem _surveillanceCameras = default!;
|
|
[Dependency] private readonly UserInterfaceSystem _userInterface = default!;
|
|
[Dependency] private readonly DeviceNetworkSystem _deviceNetworkSystem = default!;
|
|
|
|
public override void Initialize()
|
|
{
|
|
SubscribeLocalEvent<SurveillanceCameraMonitorComponent, SurveillanceCameraDeactivateEvent>(OnSurveillanceCameraDeactivate);
|
|
SubscribeLocalEvent<SurveillanceCameraMonitorComponent, PowerChangedEvent>(OnPowerChanged);
|
|
SubscribeLocalEvent<SurveillanceCameraMonitorComponent, DeviceNetworkPacketEvent>(OnPacketReceived);
|
|
SubscribeLocalEvent<SurveillanceCameraMonitorComponent, ComponentStartup>(OnComponentStartup);
|
|
SubscribeLocalEvent<SurveillanceCameraMonitorComponent, AfterActivatableUIOpenEvent>(OnToggleInterface);
|
|
Subs.BuiEvents<SurveillanceCameraMonitorComponent>(SurveillanceCameraMonitorUiKey.Key, subs =>
|
|
{
|
|
subs.Event<SurveillanceCameraRefreshCamerasMessage>(OnRefreshCamerasMessage);
|
|
subs.Event<SurveillanceCameraRefreshSubnetsMessage>(OnRefreshSubnetsMessage);
|
|
subs.Event<SurveillanceCameraDisconnectMessage>(OnDisconnectMessage);
|
|
subs.Event<SurveillanceCameraMonitorSubnetRequestMessage>(OnSubnetRequest);
|
|
subs.Event<SurveillanceCameraMonitorSwitchMessage>(OnSwitchMessage);
|
|
subs.Event<BoundUIClosedEvent>(OnBoundUiClose);
|
|
});
|
|
}
|
|
|
|
private const float _maxHeartbeatTime = 300f;
|
|
private const float _heartbeatDelay = 30f;
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
var query = EntityQueryEnumerator<ActiveSurveillanceCameraMonitorComponent, SurveillanceCameraMonitorComponent>();
|
|
while (query.MoveNext(out var uid, out _, out var monitor))
|
|
{
|
|
if (Paused(uid))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
monitor.LastHeartbeatSent += frameTime;
|
|
SendHeartbeat(uid, monitor);
|
|
monitor.LastHeartbeat += frameTime;
|
|
|
|
if (monitor.LastHeartbeat > _maxHeartbeatTime)
|
|
{
|
|
DisconnectCamera(uid, true, monitor);
|
|
EntityManager.RemoveComponent<ActiveSurveillanceCameraMonitorComponent>(uid);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// ROUTING:
|
|
///
|
|
/// Monitor freq: General frequency for cameras, routers, and monitors to speak on.
|
|
///
|
|
/// Subnet freqs: Frequency for each specific subnet. Routers ping cameras here,
|
|
/// cameras ping back on monitor frequency. When a monitor
|
|
/// selects a subnet, it saves that subnet's frequency
|
|
/// so it can connect to the camera. All outbound cameras
|
|
/// always speak on the monitor frequency and will not
|
|
/// do broadcast pings - whatever talks to it, talks to it.
|
|
///
|
|
/// How a camera is discovered:
|
|
///
|
|
/// Subnet ping:
|
|
/// Surveillance camera monitor - [ monitor freq ] -> Router
|
|
/// Router -> camera discovery
|
|
/// Router - [ subnet freq ] -> Camera
|
|
/// Camera -> router ping
|
|
/// Camera - [ monitor freq ] -> Router
|
|
/// Router -> monitor data forward
|
|
/// Router - [ monitor freq ] -> Monitor
|
|
|
|
#region Event Handling
|
|
private void OnComponentStartup(EntityUid uid, SurveillanceCameraMonitorComponent component, ComponentStartup args)
|
|
{
|
|
RefreshSubnets(uid, component);
|
|
}
|
|
|
|
private void OnSubnetRequest(EntityUid uid, SurveillanceCameraMonitorComponent component,
|
|
SurveillanceCameraMonitorSubnetRequestMessage args)
|
|
{
|
|
if (args.Session.AttachedEntity != null)
|
|
{
|
|
SetActiveSubnet(uid, args.Subnet, component);
|
|
}
|
|
}
|
|
|
|
private void OnPacketReceived(EntityUid uid, SurveillanceCameraMonitorComponent component,
|
|
DeviceNetworkPacketEvent args)
|
|
{
|
|
if (string.IsNullOrEmpty(args.SenderAddress))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (args.Data.TryGetValue(DeviceNetworkConstants.Command, out string? command))
|
|
{
|
|
switch (command)
|
|
{
|
|
case SurveillanceCameraSystem.CameraConnectMessage:
|
|
if (component.NextCameraAddress == args.SenderAddress)
|
|
{
|
|
component.ActiveCameraAddress = args.SenderAddress;
|
|
TrySwitchCameraByUid(uid, args.Sender, component);
|
|
}
|
|
|
|
component.NextCameraAddress = null;
|
|
break;
|
|
case SurveillanceCameraSystem.CameraHeartbeatMessage:
|
|
if (args.SenderAddress == component.ActiveCameraAddress)
|
|
{
|
|
component.LastHeartbeat = 0;
|
|
}
|
|
|
|
break;
|
|
case SurveillanceCameraSystem.CameraDataMessage:
|
|
if (!args.Data.TryGetValue(SurveillanceCameraSystem.CameraNameData, out string? name)
|
|
|| !args.Data.TryGetValue(SurveillanceCameraSystem.CameraSubnetData, out string? subnetData)
|
|
|| !args.Data.TryGetValue(SurveillanceCameraSystem.CameraAddressData, out string? address))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (component.ActiveSubnet != subnetData)
|
|
{
|
|
DisconnectFromSubnet(uid, subnetData);
|
|
}
|
|
|
|
if (!component.KnownCameras.ContainsKey(address))
|
|
{
|
|
component.KnownCameras.Add(address, name);
|
|
}
|
|
|
|
UpdateUserInterface(uid, component);
|
|
break;
|
|
case SurveillanceCameraSystem.CameraSubnetData:
|
|
if (args.Data.TryGetValue(SurveillanceCameraSystem.CameraSubnetData, out string? subnet)
|
|
&& !component.KnownSubnets.ContainsKey(subnet))
|
|
{
|
|
component.KnownSubnets.Add(subnet, args.SenderAddress);
|
|
}
|
|
|
|
UpdateUserInterface(uid, component);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnDisconnectMessage(EntityUid uid, SurveillanceCameraMonitorComponent component,
|
|
SurveillanceCameraDisconnectMessage message)
|
|
{
|
|
DisconnectCamera(uid, true, component);
|
|
}
|
|
|
|
private void OnRefreshCamerasMessage(EntityUid uid, SurveillanceCameraMonitorComponent component,
|
|
SurveillanceCameraRefreshCamerasMessage message)
|
|
{
|
|
component.KnownCameras.Clear();
|
|
RequestActiveSubnetInfo(uid, component);
|
|
}
|
|
|
|
private void OnRefreshSubnetsMessage(EntityUid uid, SurveillanceCameraMonitorComponent component,
|
|
SurveillanceCameraRefreshSubnetsMessage message)
|
|
{
|
|
RefreshSubnets(uid, component);
|
|
}
|
|
|
|
private void OnSwitchMessage(EntityUid uid, SurveillanceCameraMonitorComponent component, SurveillanceCameraMonitorSwitchMessage message)
|
|
{
|
|
// there would be a null check here, but honestly
|
|
// whichever one is the "latest" switch message gets to
|
|
// do the switch
|
|
TrySwitchCameraByAddress(uid, message.Address, component);
|
|
}
|
|
|
|
private void OnPowerChanged(EntityUid uid, SurveillanceCameraMonitorComponent component, ref PowerChangedEvent args)
|
|
{
|
|
if (!args.Powered)
|
|
{
|
|
RemoveActiveCamera(uid, component);
|
|
component.NextCameraAddress = null;
|
|
component.ActiveSubnet = string.Empty;
|
|
}
|
|
}
|
|
|
|
private void OnToggleInterface(EntityUid uid, SurveillanceCameraMonitorComponent component,
|
|
AfterActivatableUIOpenEvent args)
|
|
{
|
|
AfterOpenUserInterface(uid, args.User, component);
|
|
}
|
|
|
|
// This is to ensure that there's no delay in ensuring that a camera is deactivated.
|
|
private void OnSurveillanceCameraDeactivate(EntityUid uid, SurveillanceCameraMonitorComponent monitor, SurveillanceCameraDeactivateEvent args)
|
|
{
|
|
DisconnectCamera(uid, false, monitor);
|
|
}
|
|
|
|
private void OnBoundUiClose(EntityUid uid, SurveillanceCameraMonitorComponent component, BoundUIClosedEvent args)
|
|
{
|
|
if (args.Session.AttachedEntity == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
RemoveViewer(uid, args.Session.AttachedEntity.Value, component);
|
|
}
|
|
#endregion
|
|
|
|
private void SendHeartbeat(EntityUid uid, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| monitor.LastHeartbeatSent < _heartbeatDelay
|
|
|| !monitor.KnownSubnets.TryGetValue(monitor.ActiveSubnet, out var subnetAddress))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var payload = new NetworkPayload()
|
|
{
|
|
{ DeviceNetworkConstants.Command, SurveillanceCameraSystem.CameraHeartbeatMessage },
|
|
{ SurveillanceCameraSystem.CameraAddressData, monitor.ActiveCameraAddress }
|
|
};
|
|
|
|
_deviceNetworkSystem.QueuePacket(uid, subnetAddress, payload);
|
|
}
|
|
|
|
private void DisconnectCamera(EntityUid uid, bool removeViewers, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (removeViewers)
|
|
{
|
|
RemoveActiveCamera(uid, monitor);
|
|
}
|
|
|
|
monitor.ActiveCamera = null;
|
|
monitor.ActiveCameraAddress = string.Empty;
|
|
EntityManager.RemoveComponent<ActiveSurveillanceCameraMonitorComponent>(uid);
|
|
UpdateUserInterface(uid, monitor);
|
|
}
|
|
|
|
private void RefreshSubnets(EntityUid uid, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
monitor.KnownSubnets.Clear();
|
|
PingCameraNetwork(uid, monitor);
|
|
}
|
|
|
|
private void PingCameraNetwork(EntityUid uid, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var payload = new NetworkPayload()
|
|
{
|
|
{ DeviceNetworkConstants.Command, SurveillanceCameraSystem.CameraPingMessage }
|
|
};
|
|
_deviceNetworkSystem.QueuePacket(uid, null, payload);
|
|
}
|
|
|
|
private void SetActiveSubnet(EntityUid uid, string subnet,
|
|
SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| !monitor.KnownSubnets.ContainsKey(subnet))
|
|
{
|
|
return;
|
|
}
|
|
|
|
DisconnectFromSubnet(uid, monitor.ActiveSubnet);
|
|
DisconnectCamera(uid, true, monitor);
|
|
monitor.ActiveSubnet = subnet;
|
|
monitor.KnownCameras.Clear();
|
|
UpdateUserInterface(uid, monitor);
|
|
|
|
ConnectToSubnet(uid, subnet);
|
|
}
|
|
|
|
private void RequestActiveSubnetInfo(EntityUid uid, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| !monitor.KnownSubnets.TryGetValue(monitor.ActiveSubnet, out var address))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var payload = new NetworkPayload()
|
|
{
|
|
{DeviceNetworkConstants.Command, SurveillanceCameraSystem.CameraPingSubnetMessage},
|
|
};
|
|
_deviceNetworkSystem.QueuePacket(uid, address, payload);
|
|
}
|
|
|
|
private void ConnectToSubnet(EntityUid uid, string subnet, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| !monitor.KnownSubnets.TryGetValue(subnet, out var address))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var payload = new NetworkPayload()
|
|
{
|
|
{DeviceNetworkConstants.Command, SurveillanceCameraSystem.CameraSubnetConnectMessage},
|
|
};
|
|
_deviceNetworkSystem.QueuePacket(uid, address, payload);
|
|
|
|
RequestActiveSubnetInfo(uid);
|
|
}
|
|
|
|
private void DisconnectFromSubnet(EntityUid uid, string subnet, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| !monitor.KnownSubnets.TryGetValue(subnet, out var address))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var payload = new NetworkPayload()
|
|
{
|
|
{DeviceNetworkConstants.Command, SurveillanceCameraSystem.CameraSubnetDisconnectMessage},
|
|
};
|
|
_deviceNetworkSystem.QueuePacket(uid, address, payload);
|
|
}
|
|
|
|
// Adds a viewer to the camera and the monitor.
|
|
private void AddViewer(EntityUid uid, EntityUid player, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
monitor.Viewers.Add(player);
|
|
|
|
if (monitor.ActiveCamera != null)
|
|
{
|
|
_surveillanceCameras.AddActiveViewer(monitor.ActiveCamera.Value, player, uid);
|
|
}
|
|
|
|
UpdateUserInterface(uid, monitor, player);
|
|
}
|
|
|
|
// Removes a viewer from the camera and the monitor.
|
|
private void RemoveViewer(EntityUid uid, EntityUid player, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
monitor.Viewers.Remove(player);
|
|
|
|
if (monitor.ActiveCamera != null)
|
|
{
|
|
_surveillanceCameras.RemoveActiveViewer(monitor.ActiveCamera.Value, player);
|
|
}
|
|
}
|
|
|
|
// Sets the camera. If the camera is not null, this will return.
|
|
//
|
|
// The camera should always attempt to switch over, rather than
|
|
// directly setting it, so that the active viewer list and view
|
|
// subscriptions can be updated.
|
|
private void SetCamera(EntityUid uid, EntityUid camera, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| monitor.ActiveCamera != null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_surveillanceCameras.AddActiveViewers(camera, monitor.Viewers, uid);
|
|
|
|
monitor.ActiveCamera = camera;
|
|
|
|
AddComp<ActiveSurveillanceCameraMonitorComponent>(uid);
|
|
|
|
UpdateUserInterface(uid, monitor);
|
|
}
|
|
|
|
// Switches the camera's viewers over to this new given camera.
|
|
private void SwitchCamera(EntityUid uid, EntityUid camera, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| monitor.ActiveCamera == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_surveillanceCameras.SwitchActiveViewers(monitor.ActiveCamera.Value, camera, monitor.Viewers, uid);
|
|
|
|
monitor.ActiveCamera = camera;
|
|
|
|
UpdateUserInterface(uid, monitor);
|
|
}
|
|
|
|
private void TrySwitchCameraByAddress(EntityUid uid, string address,
|
|
SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| !monitor.KnownSubnets.TryGetValue(monitor.ActiveSubnet, out var subnetAddress))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var payload = new NetworkPayload()
|
|
{
|
|
{DeviceNetworkConstants.Command, SurveillanceCameraSystem.CameraConnectMessage},
|
|
{SurveillanceCameraSystem.CameraAddressData, address}
|
|
};
|
|
|
|
monitor.NextCameraAddress = address;
|
|
_deviceNetworkSystem.QueuePacket(uid, subnetAddress, payload);
|
|
}
|
|
|
|
// Attempts to switch over the current viewed camera on this monitor
|
|
// to the new camera.
|
|
private void TrySwitchCameraByUid(EntityUid uid, EntityUid newCamera, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (monitor.ActiveCamera == null)
|
|
{
|
|
SetCamera(uid, newCamera, monitor);
|
|
}
|
|
else
|
|
{
|
|
SwitchCamera(uid, newCamera, monitor);
|
|
}
|
|
}
|
|
|
|
private void RemoveActiveCamera(EntityUid uid, SurveillanceCameraMonitorComponent? monitor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| monitor.ActiveCamera == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_surveillanceCameras.RemoveActiveViewers(monitor.ActiveCamera.Value, monitor.Viewers, uid);
|
|
|
|
UpdateUserInterface(uid, monitor);
|
|
}
|
|
|
|
// This is public primarily because it might be useful to have the ability to
|
|
// have this component added to any entity, and have them open the BUI (somehow).
|
|
public void AfterOpenUserInterface(EntityUid uid, EntityUid player, SurveillanceCameraMonitorComponent? monitor = null, ActorComponent? actor = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor)
|
|
|| !Resolve(player, ref actor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
AddViewer(uid, player);
|
|
}
|
|
|
|
private void UpdateUserInterface(EntityUid uid, SurveillanceCameraMonitorComponent? monitor = null, EntityUid? player = null)
|
|
{
|
|
if (!Resolve(uid, ref monitor))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var state = new SurveillanceCameraMonitorUiState(GetNetEntity(monitor.ActiveCamera), monitor.KnownSubnets.Keys.ToHashSet(), monitor.ActiveCameraAddress, monitor.ActiveSubnet, monitor.KnownCameras);
|
|
_userInterface.TrySetUiState(uid, SurveillanceCameraMonitorUiKey.Key, state);
|
|
}
|
|
}
|