tommy/tbd-station-14
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rejig Device networks (#7380)

Browse Source
This commit is contained in:
Leon Friedrich
2022-04-09 00:27:10 +12:00
committed by GitHub
parent 44649e7fed
commit a4d55235cc
33 changed files with 671 additions and 247 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Content.Client/Entry/IgnoredComponents.cs
View File

@@ -281,7 +281,7 @@ namespace Content.Client.Entry
"TabletopGame",
"LitOnPowered",
"TriggerOnSignalReceived",
"DeviceNetworkComponent",
"DeviceNetwork",
"WiredNetworkConnection",
"WirelessNetworkConnection",
"ExtensionCableReceiver",

36
Content.IntegrationTests/Tests/DeviceNetwork/DeviceNetworkTest.cs
View File

@@ -20,15 +20,18 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
name: DummyNetworkDevice
id: DummyNetworkDevice
components:
- type: DeviceNetworkComponent
frequency: 100
- type: DeviceNetwork
transmitFrequency: 100
receiveFrequency: 100
- type: entity
name: DummyWiredNetworkDevice
id: DummyWiredNetworkDevice
components:
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Wired
transmitFrequency: 0
receiveFrequency: 0
- type: WiredNetworkConnection
- type: ApcPowerReceiver
@@ -36,8 +39,9 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
name: DummyWirelessNetworkDevice
id: DummyWirelessNetworkDevice
components:
- type: DeviceNetworkComponent
frequency: 100
- type: DeviceNetwork
transmitFrequency: 100
receiveFrequency: 100
deviceNetId: Wireless
- type: WirelessNetworkConnection
range: 100
@@ -83,18 +87,18 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
device1 = entityManager.SpawnEntity("DummyNetworkDevice", MapCoordinates.Nullspace);
Assert.That(entityManager.TryGetComponent(device1, out networkComponent1), Is.True);
Assert.That(networkComponent1.Open, Is.True);
Assert.That(networkComponent1.ReceiveFrequency != null, Is.True);
Assert.That(networkComponent1.Address, Is.Not.EqualTo(string.Empty));
device2 = entityManager.SpawnEntity("DummyNetworkDevice", MapCoordinates.Nullspace);
Assert.That(entityManager.TryGetComponent(device2, out networkComponent2), Is.True);
Assert.That(networkComponent2.Open, Is.True);
Assert.That(networkComponent1.ReceiveFrequency != null, Is.True);
Assert.That(networkComponent2.Address, Is.Not.EqualTo(string.Empty));
Assert.That(networkComponent1.Address, Is.Not.EqualTo(networkComponent2.Address));
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, networkComponent2.Frequency, payload);
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, payload, networkComponent2.ReceiveFrequency.Value);
});
await server.WaitRunTicks(1);
@@ -147,18 +151,18 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
Assert.That(entityManager.TryGetComponent(device1, out networkComponent1), Is.True);
Assert.That(entityManager.TryGetComponent(device1, out wirelessNetworkComponent), Is.True);
Assert.That(networkComponent1.Open, Is.True);
Assert.That(networkComponent1.ReceiveFrequency != null, Is.True);
Assert.That(networkComponent1.Address, Is.Not.EqualTo(string.Empty));
device2 = entityManager.SpawnEntity("DummyWirelessNetworkDevice", new MapCoordinates(new Robust.Shared.Maths.Vector2(0,50), MapId.Nullspace));
Assert.That(entityManager.TryGetComponent(device2, out networkComponent2), Is.True);
Assert.That(networkComponent2.Open, Is.True);
Assert.That(networkComponent2.ReceiveFrequency != null, Is.True);
Assert.That(networkComponent2.Address, Is.Not.EqualTo(string.Empty));
Assert.That(networkComponent1.Address, Is.Not.EqualTo(networkComponent2.Address));
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, networkComponent2.Frequency, payload);
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, payload, networkComponent2.ReceiveFrequency.Value);
});
await server.WaitRunTicks(1);
@@ -174,7 +178,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
wirelessNetworkComponent.Range = 0;
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, networkComponent2.Frequency, payload);
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, payload, networkComponent2.ReceiveFrequency.Value);
});
await server.WaitRunTicks(1);
@@ -234,18 +238,18 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
Assert.That(entityManager.TryGetComponent(device1, out networkComponent1), Is.True);
Assert.That(entityManager.TryGetComponent(device1, out wiredNetworkComponent), Is.True);
Assert.That(networkComponent1.Open, Is.True);
Assert.That(networkComponent1.ReceiveFrequency != null, Is.True);
Assert.That(networkComponent1.Address, Is.Not.EqualTo(string.Empty));
device2 = entityManager.SpawnEntity("DummyWiredNetworkDevice", new MapCoordinates(new Robust.Shared.Maths.Vector2(0, 2), MapId.Nullspace));
Assert.That(entityManager.TryGetComponent(device2, out networkComponent2), Is.True);
Assert.That(networkComponent2.Open, Is.True);
Assert.That(networkComponent2.ReceiveFrequency != null, Is.True);
Assert.That(networkComponent2.Address, Is.Not.EqualTo(string.Empty));
Assert.That(networkComponent1.Address, Is.Not.EqualTo(networkComponent2.Address));
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, networkComponent2.Frequency, payload);
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, payload, networkComponent2.ReceiveFrequency.Value);
});
await server.WaitRunTicks(1);
@@ -256,7 +260,7 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
entityManager.SpawnEntity("CableApcExtension", grid.MapToGrid(new MapCoordinates(new Robust.Shared.Maths.Vector2(0, 1), MapId.Nullspace)));
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, networkComponent2.Frequency, payload);
deviceNetSystem.QueuePacket(device1, networkComponent2.Address, payload, networkComponent2.ReceiveFrequency.Value);
});
await server.WaitRunTicks(1);

4
Content.IntegrationTests/Tests/DeviceNetwork/DeviceNetworkTestSystem.cs
View File

@@ -16,10 +16,10 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
{
base.Initialize();
SubscribeLocalEvent<DeviceNetworkComponent, PacketSentEvent>(OnPacketReceived);
SubscribeLocalEvent<DeviceNetworkComponent, DeviceNetworkPacketEvent>(OnPacketReceived);
}
private void OnPacketReceived(EntityUid uid, DeviceNetworkComponent component, PacketSentEvent args)
private void OnPacketReceived(EntityUid uid, DeviceNetworkComponent component, DeviceNetworkPacketEvent args)
{
LastPayload = args.Data;
}

15
Content.Server/Atmos/Monitor/Systems/AirAlarmSystem.cs
View File

@@ -42,9 +42,6 @@ namespace Content.Server.Atmos.Monitor.Systems
[Dependency] private readonly SharedInteractionSystem _interactionSystem = default!;
#region Device Network API
public const int Freq = AtmosMonitorSystem.AtmosMonitorApcFreq;
/// <summary>
/// Command to set device data within the air alarm's network.
/// </summary>
@@ -93,7 +90,7 @@ namespace Content.Server.Atmos.Monitor.Systems
[AirAlarmSetData] = data
};
_deviceNet.QueuePacket(uid, address, Freq, payload);
_deviceNet.QueuePacket(uid, address, payload);
}
/// <summary>
@@ -110,7 +107,7 @@ namespace Content.Server.Atmos.Monitor.Systems
[DeviceNetworkConstants.Command] = AirAlarmSyncCmd
};
_deviceNet.QueuePacket(uid, string.Empty, Freq, payload, true);
_deviceNet.QueuePacket(uid, null, payload);
}
/// <summary>
@@ -129,7 +126,7 @@ namespace Content.Server.Atmos.Monitor.Systems
[DeviceNetworkConstants.Command] = AirAlarmSyncCmd
};
_deviceNet.QueuePacket(uid, address, Freq, payload);
_deviceNet.QueuePacket(uid, address, payload);
}
/// <summary>
@@ -148,7 +145,7 @@ namespace Content.Server.Atmos.Monitor.Systems
[AirAlarmSetMode] = mode
};
_deviceNet.QueuePacket(uid, string.Empty, Freq, payload, true);
_deviceNet.QueuePacket(uid, null, payload);
}
#endregion
@@ -157,7 +154,7 @@ namespace Content.Server.Atmos.Monitor.Systems
public override void Initialize()
{
SubscribeLocalEvent<AirAlarmComponent, PacketSentEvent>(OnPacketRecv);
SubscribeLocalEvent<AirAlarmComponent, DeviceNetworkPacketEvent>(OnPacketRecv);
SubscribeLocalEvent<AirAlarmComponent, AtmosDeviceUpdateEvent>(OnAtmosUpdate);
SubscribeLocalEvent<AirAlarmComponent, AtmosMonitorAlarmEvent>(OnAtmosAlarm);
SubscribeLocalEvent<AirAlarmComponent, PowerChangedEvent>(OnPowerChanged);
@@ -383,7 +380,7 @@ namespace Content.Server.Atmos.Monitor.Systems
SetData(uid, address, devData);
}
private void OnPacketRecv(EntityUid uid, AirAlarmComponent controller, PacketSentEvent args)
private void OnPacketRecv(EntityUid uid, AirAlarmComponent controller, DeviceNetworkPacketEvent args)
{
if (!args.Data.TryGetValue(DeviceNetworkConstants.Command, out string? cmd))
return;

4
Content.Server/Atmos/Monitor/Systems/AtmosAlarmableSystem.cs
View File

@@ -11,10 +11,10 @@ namespace Content.Server.Atmos.Monitor.Systems
{
public override void Initialize()
{
SubscribeLocalEvent<AtmosAlarmableComponent, PacketSentEvent>(OnPacketRecv);
SubscribeLocalEvent<AtmosAlarmableComponent, DeviceNetworkPacketEvent>(OnPacketRecv);
}
private void OnPacketRecv(EntityUid uid, AtmosAlarmableComponent component, PacketSentEvent args)
private void OnPacketRecv(EntityUid uid, AtmosAlarmableComponent component, DeviceNetworkPacketEvent args)
{
if (component.IgnoreAlarms) return;

15
Content.Server/Atmos/Monitor/Systems/AtmosMonitoringSystem.cs
View File

@@ -62,11 +62,6 @@ namespace Content.Server.Atmos.Monitor.Systems
/// </summary>
public const string AtmosMonitorAlarmNetMax = "atmos_monitor_alarm_net_max";
/// <summary>
/// Frequency (all prototypes that use AtmosMonitor should use this)
/// </summary>
public const int AtmosMonitorApcFreq = 1621;
public override void Initialize()
{
SubscribeLocalEvent<AtmosMonitorComponent, ComponentInit>(OnAtmosMonitorInit);
@@ -76,7 +71,7 @@ namespace Content.Server.Atmos.Monitor.Systems
SubscribeLocalEvent<AtmosMonitorComponent, TileFireEvent>(OnFireEvent);
SubscribeLocalEvent<AtmosMonitorComponent, PowerChangedEvent>(OnPowerChangedEvent);
SubscribeLocalEvent<AtmosMonitorComponent, BeforePacketSentEvent>(BeforePacketRecv);
SubscribeLocalEvent<AtmosMonitorComponent, PacketSentEvent>(OnPacketRecv);
SubscribeLocalEvent<AtmosMonitorComponent, DeviceNetworkPacketEvent>(OnPacketRecv);
}
private void OnAtmosMonitorInit(EntityUid uid, AtmosMonitorComponent component, ComponentInit args)
@@ -158,7 +153,7 @@ namespace Content.Server.Atmos.Monitor.Systems
if (!component.NetEnabled) args.Cancel();
}
private void OnPacketRecv(EntityUid uid, AtmosMonitorComponent component, PacketSentEvent args)
private void OnPacketRecv(EntityUid uid, AtmosMonitorComponent component, DeviceNetworkPacketEvent args)
{
// sync the internal 'last alarm state' from
// the other alarms, so that we can calculate
@@ -389,7 +384,7 @@ namespace Content.Server.Atmos.Monitor.Systems
[AtmosMonitorAlarmSrc] = prototype != null ? prototype.ID : string.Empty
};
_deviceNetSystem.QueuePacket(monitor.Owner, string.Empty, AtmosMonitorApcFreq, payload, true);
_deviceNetSystem.QueuePacket(monitor.Owner, null, payload);
monitor.NetworkAlarmStates.Clear();
Alert(uid, AtmosMonitorAlarmType.Normal, null, monitor);
@@ -411,7 +406,7 @@ namespace Content.Server.Atmos.Monitor.Systems
[AtmosMonitorAlarmSrc] = prototype != null ? prototype.ID : string.Empty
};
_deviceNetSystem.QueuePacket(monitor.Owner, string.Empty, AtmosMonitorApcFreq, payload, true);
_deviceNetSystem.QueuePacket(monitor.Owner, null, payload);
}
/// <summary>
@@ -445,7 +440,7 @@ namespace Content.Server.Atmos.Monitor.Systems
[AtmosMonitorAlarmSrc] = source
};
_deviceNetSystem.QueuePacket(monitor.Owner, string.Empty, AtmosMonitorApcFreq, payload, true);
_deviceNetSystem.QueuePacket(monitor.Owner, null, payload);
}
/// <summary>

8
Content.Server/Atmos/Piping/Unary/EntitySystems/GasVentPumpSystem.cs
View File

@@ -35,7 +35,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
SubscribeLocalEvent<GasVentPumpComponent, AtmosDeviceDisabledEvent>(OnGasVentPumpLeaveAtmosphere);
SubscribeLocalEvent<GasVentPumpComponent, AtmosMonitorAlarmEvent>(OnAtmosAlarm);
SubscribeLocalEvent<GasVentPumpComponent, PowerChangedEvent>(OnPowerChanged);
SubscribeLocalEvent<GasVentPumpComponent, PacketSentEvent>(OnPacketRecv);
SubscribeLocalEvent<GasVentPumpComponent, DeviceNetworkPacketEvent>(OnPacketRecv);
}
private void OnGasVentPumpUpdated(EntityUid uid, GasVentPumpComponent vent, AtmosDeviceUpdateEvent args)
@@ -162,7 +162,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
component.Enabled = args.Powered;
}
private void OnPacketRecv(EntityUid uid, GasVentPumpComponent component, PacketSentEvent args)
private void OnPacketRecv(EntityUid uid, GasVentPumpComponent component, DeviceNetworkPacketEvent args)
{
if (!EntityManager.TryGetComponent(uid, out DeviceNetworkComponent netConn)
|| !EntityManager.TryGetComponent(uid, out AtmosAlarmableComponent alarmable)
@@ -177,7 +177,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
payload.Add(DeviceNetworkConstants.Command, AirAlarmSystem.AirAlarmSyncData);
payload.Add(AirAlarmSystem.AirAlarmSyncData, component.ToAirAlarmData());
_deviceNetSystem.QueuePacket(uid, args.SenderAddress, AirAlarmSystem.Freq, payload);
_deviceNetSystem.QueuePacket(uid, args.SenderAddress, payload, device: netConn);
return;
case AirAlarmSystem.AirAlarmSetData:
@@ -189,7 +189,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
payload.Add(DeviceNetworkConstants.Command, AirAlarmSystem.AirAlarmSetDataStatus);
payload.Add(AirAlarmSystem.AirAlarmSetDataStatus, true);
_deviceNetSystem.QueuePacket(uid, string.Empty, AirAlarmSystem.Freq, payload, true);
_deviceNetSystem.QueuePacket(uid, null, payload, device: netConn);
return;
}

8
Content.Server/Atmos/Piping/Unary/EntitySystems/GasVentScrubberSystem.cs
View File

@@ -36,7 +36,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
SubscribeLocalEvent<GasVentScrubberComponent, AtmosDeviceDisabledEvent>(OnVentScrubberLeaveAtmosphere);
SubscribeLocalEvent<GasVentScrubberComponent, AtmosMonitorAlarmEvent>(OnAtmosAlarm);
SubscribeLocalEvent<GasVentScrubberComponent, PowerChangedEvent>(OnPowerChanged);
SubscribeLocalEvent<GasVentScrubberComponent, PacketSentEvent>(OnPacketRecv);
SubscribeLocalEvent<GasVentScrubberComponent, DeviceNetworkPacketEvent>(OnPacketRecv);
}
private void OnVentScrubberUpdated(EntityUid uid, GasVentScrubberComponent scrubber, AtmosDeviceUpdateEvent args)
@@ -136,7 +136,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
private void OnPowerChanged(EntityUid uid, GasVentScrubberComponent component, PowerChangedEvent args) =>
component.Enabled = args.Powered;
private void OnPacketRecv(EntityUid uid, GasVentScrubberComponent component, PacketSentEvent args)
private void OnPacketRecv(EntityUid uid, GasVentScrubberComponent component, DeviceNetworkPacketEvent args)
{
if (!EntityManager.TryGetComponent(uid, out DeviceNetworkComponent netConn)
|| !EntityManager.TryGetComponent(uid, out AtmosAlarmableComponent alarmable)
@@ -151,7 +151,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
payload.Add(DeviceNetworkConstants.Command, AirAlarmSystem.AirAlarmSyncData);
payload.Add(AirAlarmSystem.AirAlarmSyncData, component.ToAirAlarmData());
_deviceNetSystem.QueuePacket(uid, args.SenderAddress, AirAlarmSystem.Freq, payload);
_deviceNetSystem.QueuePacket(uid, args.SenderAddress, payload, device: netConn);
return;
case AirAlarmSystem.AirAlarmSetData:
@@ -163,7 +163,7 @@ namespace Content.Server.Atmos.Piping.Unary.EntitySystems
payload.Add(DeviceNetworkConstants.Command, AirAlarmSystem.AirAlarmSetDataStatus);
payload.Add(AirAlarmSystem.AirAlarmSetDataStatus, true);
_deviceNetSystem.QueuePacket(uid, string.Empty, AirAlarmSystem.Freq, payload, true);
_deviceNetSystem.QueuePacket(uid, null, payload, device: netConn);
return;
}

77
Content.Server/DeviceNetwork/Components/DeviceNetworkComponent.cs
View File

@@ -1,17 +1,16 @@
using System;
using Robust.Shared.GameObjects;
using Robust.Shared.Serialization.Manager.Attributes;
using Robust.Shared.ViewVariables;
using Content.Server.DeviceNetwork.Systems;
using Content.Shared.DeviceNetwork;
using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
namespace Content.Server.DeviceNetwork.Components
{
[RegisterComponent]
[ComponentProtoName("DeviceNetworkComponent")]
[Friend(typeof(DeviceNetworkSystem), typeof(DeviceNet))]
public sealed class DeviceNetworkComponent : Component
{
/// <summary>
/// Valid device network NetIDs.
/// The netID is used to separate device networks that shouldn't interact with each other e.g. wireless and wired.
/// Valid device network NetIDs. The netID is used to separate device networks that shouldn't interact with
/// each other e.g. wireless and wired.
/// </summary>
[Serializable]
public enum ConnectionType
@@ -21,20 +20,74 @@ namespace Content.Server.DeviceNetwork.Components
Wireless,
Apc
}
// TODO allow devices to join more than one network?
// TODO if wireless/wired is determined by ConnectionType, what is the point of WirelessNetworkComponent & the
// other network-type-specific components? Shouldn't DeviceNetId determine conectivity checks?
[DataField("deviceNetId")]
public ConnectionType DeviceNetId { get; set; } = ConnectionType.Private;
[DataField("frequency")]
public int Frequency { get; set; } = 0;
/// <summary>
/// The frequency that this device is listening on.
/// </summary>
[DataField("receiveFrequency")]
public uint? ReceiveFrequency;
[ViewVariables]
public bool Open;
/// <summary>
/// frequency prototype. Used to select a default frequency to listen to on. Used when the map is
/// initialized.
/// </summary>
[DataField("receiveFrequencyId", customTypeSerializer: typeof(PrototypeIdSerializer<DeviceFrequencyPrototype>))]
public string? ReceiveFrequencyId;
[ViewVariables]
/// <summary>
/// The frequency that this device going to try transmit on.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("transmitFrequency")]
public uint? TransmitFrequency;
/// <summary>
/// frequency prototype. Used to select a default frequency to transmit on. Used when the map is
/// initialized.
/// </summary>
[DataField("transmitFrequencyId", customTypeSerializer: typeof(PrototypeIdSerializer<DeviceFrequencyPrototype>))]
public string? TransmitFrequencyId;
/// <summary>
/// The address of the device, either on the network it is currently connected to or whatever address it
/// most recently used.
/// </summary>
[DataField("address")]
public string Address = string.Empty;
/// <summary>
/// If true, the address was customized and should be preserved across networks. If false, a randomly
/// generated address will be created whenever this device connects to a network.
/// </summary>
[DataField("customAddress")]
public bool CustomAddress = false;
/// <summary>
/// Prefix to prepend to any automatically generated addresses. Helps players to identify devices. This gets
/// localized.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("prefix")]
public string? Prefix;
/// <summary>
/// Whether the device should listen for all device messages, regardless of the intended recipient.
/// </summary>
[DataField("receiveAll")]
public bool ReceiveAll;
/// <summary>
/// Whether the device should attempt to join the network on map init.
/// </summary>
[ViewVariables(VVAccess.ReadWrite)]
[DataField("autoConnect")]
public bool AutoConnect = true;
}
}

236
Content.Server/DeviceNetwork/DeviceNet.cs Normal file
View File

@@ -0,0 +1,236 @@
using Content.Server.DeviceNetwork.Components;
using Robust.Shared.Random;
using static Content.Server.DeviceNetwork.Components.DeviceNetworkComponent;
namespace Content.Server.DeviceNetwork;
/// <summary>
/// Data class for storing and retrieving information about devices connected to a device network.
/// </summary>
/// <remarks>
/// This basically just makes <see cref="DeviceNetworkComponent"/> accessible via their addresses and frequencies on
/// some network.
/// </remarks>
public sealed class DeviceNet
{
/// <summary>
/// Devices, mapped by their "Address", which is just an int that gets converted to Hex for displaying to users.
/// This dictionary contains all devices connected to this network, though they may not be listening to any
/// specific frequency.
/// </summary>
public readonly Dictionary<string, DeviceNetworkComponent> Devices = new();
/// <summary>
/// Devices listening on a given frequency.
/// </summary>
public readonly Dictionary<uint, HashSet<DeviceNetworkComponent>> ListeningDevices = new();
/// <summary>
/// Devices listening to all packets on a given frequency, regardless of the intended recipient.
/// </summary>
public readonly Dictionary<uint, HashSet<DeviceNetworkComponent>> ReceiveAllDevices = new();
private readonly IRobustRandom _random;
public readonly ConnectionType Type;
public DeviceNet(ConnectionType netType, IRobustRandom random)
{
_random = random;
Type = netType;
}
/// <summary>
/// Add a device to the network.
/// </summary>
public bool Add(DeviceNetworkComponent device)
{
if (device.CustomAddress)
{
// Only add if the device's existing address is available.
if (!Devices.TryAdd(device.Address, device))
return false;
}
else
{
// Randomly generate a new address if the existing random one is invalid. Otherwise, keep the existing address
if (string.IsNullOrWhiteSpace(device.Address) || Devices.ContainsKey(device.Address))
device.Address = GenerateValidAddress(device.Prefix);
Devices[device.Address] = device;
}
if (device.ReceiveFrequency is not uint freq)
return true;
if (!ListeningDevices.TryGetValue(freq, out var devices))
ListeningDevices[freq] = devices = new();
devices.Add(device);
if (!device.ReceiveAll)
return true;
if (!ReceiveAllDevices.TryGetValue(freq, out var receiveAlldevices))
ReceiveAllDevices[freq] = receiveAlldevices = new();
receiveAlldevices.Add(device);
return true;
}
/// <summary>
/// Remove a device from the network.
/// </summary>
public bool Remove(DeviceNetworkComponent device)
{
if (device.Address == null || Devices.Remove(device.Address))
return false;
if (device.ReceiveFrequency is not uint freq)
return true;
if (ListeningDevices.TryGetValue(freq, out var listening))
{
listening.Remove(device);
if (listening.Count == 0)
ListeningDevices.Remove(freq);
}
if (device.ReceiveAll && ReceiveAllDevices.TryGetValue(freq, out var receiveAll))
{
receiveAll.Remove(device);
if (receiveAll.Count == 0)
ListeningDevices.Remove(freq);
}
return true;
}
/// <summary>
/// Give an existing device a new randomly generated address. Useful if the device's address prefix was updated
/// and they want a new address to reflect that, or something like that.
/// </summary>
public bool RandomizeAddress(string oldAddress, string? prefix = null)
{
if (!Devices.Remove(oldAddress, out var device))
return false;
device.Address = GenerateValidAddress(prefix ?? device.Prefix);
device.CustomAddress = false;
Devices[device.Address] = device;
return true;
}
/// <summary>
/// Update the address of an existing device.
/// </summary>
public bool UpdateAddress(string oldAddress, string newAddress)
{
if (Devices.ContainsKey(newAddress))
return false;
if (!Devices.Remove(oldAddress, out var device))
return false;
device.Address = newAddress;
device.CustomAddress = true;
Devices[newAddress] = device;
return true;
}
/// <summary>
/// Make an existing network device listen to a new frequency.
/// </summary>
public bool UpdateReceiveFrequency(string address, uint? newFrequency)
{
if (!Devices.TryGetValue(address, out var device))
return false;
if (device.ReceiveFrequency == newFrequency)
return true;
if (device.ReceiveFrequency is uint freq)
{
if (ListeningDevices.TryGetValue(freq, out var listening))
{
listening.Remove(device);
if (listening.Count == 0)
ListeningDevices.Remove(freq);
}
if (device.ReceiveAll && ReceiveAllDevices.TryGetValue(freq, out var receiveAll))
{
receiveAll.Remove(device);
if (receiveAll.Count == 0)
ListeningDevices.Remove(freq);
}
}
device.ReceiveFrequency = newFrequency;
if (newFrequency == null)
return true;
if (!ListeningDevices.TryGetValue(newFrequency.Value, out var devices))
ListeningDevices[newFrequency.Value] = devices = new();
devices.Add(device);
if (!device.ReceiveAll)
return true;
if (!ReceiveAllDevices.TryGetValue(newFrequency.Value, out var receiveAlldevices))
ReceiveAllDevices[newFrequency.Value] = receiveAlldevices = new();
receiveAlldevices.Add(device);
return true;
}
/// <summary>
/// Make an existing network device listen to a new frequency.
/// </summary>
public bool UpdateReceiveAll(string address, bool receiveAll)
{
if (!Devices.TryGetValue(address, out var device))
return false;
if (device.ReceiveAll == receiveAll)
return true;
device.ReceiveAll = receiveAll;
if (device.ReceiveFrequency is not uint freq)
return true;
// remove or add to set of listening devices
HashSet<DeviceNetworkComponent>? devices;
if (receiveAll)
{
if (!ReceiveAllDevices.TryGetValue(freq, out devices))
ReceiveAllDevices[freq] = devices = new();
devices.Add(device);
}
else if (ReceiveAllDevices.TryGetValue(freq, out devices))
{
devices.Remove(device);
if (devices.Count == 0)
ReceiveAllDevices.Remove(freq);
}
return true;
}
/// <summary>
/// Generates a valid address by randomly generating one and checking if it already exists on the network.
/// </summary>
private string GenerateValidAddress(string? prefix)
{
prefix = string.IsNullOrWhiteSpace(prefix) ? null : Loc.GetString(prefix);
string address;
do
address = $"{prefix}{_random.Next():x}";
while (Devices.ContainsKey(address));
return address;
}
}

5
Content.Server/DeviceNetwork/DeviceNetworkConstants.cs
View File

@@ -5,11 +5,6 @@ namespace Content.Server.DeviceNetwork
/// </summary>
public static class DeviceNetworkConstants
{
/// <summary>
/// Invalid address used for broadcasting
/// </summary>
public const string NullAddress = "######";
#region Commands
/// <summary>

361
Content.Server/DeviceNetwork/Systems/DeviceNetworkSystem.cs
View File

@@ -1,10 +1,10 @@
using Content.Server.DeviceNetwork.Components;
using Content.Shared.DeviceNetwork;
using JetBrains.Annotations;
using Robust.Shared.GameObjects;
using Robust.Shared.IoC;
using Robust.Shared.Prototypes;
using Robust.Shared.Random;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using static Content.Server.DeviceNetwork.Components.DeviceNetworkComponent;
namespace Content.Server.DeviceNetwork.Systems
{
@@ -16,15 +16,17 @@ namespace Content.Server.DeviceNetwork.Systems
public sealed class DeviceNetworkSystem : EntitySystem
{
[Dependency] private readonly IRobustRandom _random = default!;
[Dependency] private readonly IPrototypeManager _protoMan = default!;
[Dependency] private readonly SharedTransformSystem _transformSystem = default!;
private readonly Dictionary<DeviceNetworkComponent.ConnectionType, List<DeviceNetworkComponent>> _connections = new();
private readonly Queue<NetworkPacket> _packets = new();
private readonly Dictionary<ConnectionType, DeviceNet> _networks = new();
private readonly Queue<DeviceNetworkPacketEvent> _packets = new();
public override void Initialize()
{
base.Initialize();
SubscribeLocalEvent<DeviceNetworkComponent, ComponentStartup>(OnNetworkStarted);
SubscribeLocalEvent<DeviceNetworkComponent, MapInitEvent>(OnMapInit);
SubscribeLocalEvent<DeviceNetworkComponent, ComponentShutdown>(OnNetworkShutdown);
}
@@ -36,72 +38,53 @@ namespace Content.Server.DeviceNetwork.Systems
{
var packet = _packets.Dequeue();
if(packet.Broadcast)
{
BroadcastPacket(packet);
continue;
}
SendPacket(packet);
}
}
/// <summary>
/// Manually connect an entity with a DeviceNetworkComponent.
/// </summary>
/// <param name="uid">The Entity containing a DeviceNetworkComponent</param>
public void Connect(EntityUid uid)
{
if (EntityManager.TryGetComponent<DeviceNetworkComponent>(uid, out var component))
{
AddConnection(component);
}
}
/// <summary>
/// Sends the given payload as a device network packet to the entity with the given address and frequency.
/// Addresses are given to the DeviceNetworkComponent of an entity when connecting.
/// </summary>
/// <param name="uid">The EntityUid of the sending entity</param>
/// <param name="address">The address of the entity that the packet gets sent to when not broadcasting</param>
/// <param name="address">The address of the entity that the packet gets sent to. If null, the message is broadcast to all devices on that frequency (except the sender)</param>
/// <param name="frequency">The frequency to send on</param>
/// <param name="data">The data to be sent</param>
/// <param name="broadcast">Send to all devices on the same device network on the given frequency</param>
public void QueuePacket(EntityUid uid, string address, int frequency, NetworkPayload data, bool broadcast = false)
public void QueuePacket(EntityUid uid, string? address, NetworkPayload data, uint? frequency = null, DeviceNetworkComponent? device = null)
{
if (EntityManager.TryGetComponent<DeviceNetworkComponent>(uid, out var component))
{
var packet = new NetworkPacket
{
NetId = component.DeviceNetId,
Address = address,
Frequency = frequency,
Broadcast = broadcast,
Data = data,
Sender = component
};
if (!Resolve(uid, ref device, false))
return;
_packets.Enqueue(packet);
}
if (device.Address == null)
return;
frequency ??= device.TransmitFrequency;
if (frequency != null)
_packets.Enqueue(new DeviceNetworkPacketEvent(device.DeviceNetId, address, frequency.Value, device.Address, uid, data));
}
/// <summary>
/// Manually disconnect an entity with a DeviceNetworkComponent.
/// Automatically attempt to connect some devices when a map starts.
/// </summary>
/// <param name="uid">The Entity containing a DeviceNetworkComponent</param>
public void Disconnect(EntityUid uid)
private void OnMapInit(EntityUid uid, DeviceNetworkComponent device, MapInitEvent args)
{
if (EntityManager.TryGetComponent<DeviceNetworkComponent>(uid, out var component))
if (device.ReceiveFrequency == null
&& device.ReceiveFrequencyId != null
&& _protoMan.TryIndex<DeviceFrequencyPrototype>(device.ReceiveFrequencyId, out var receive))
{
RemoveConnection(component);
}
device.ReceiveFrequency = receive.Frequency;
}
/// <summary>
/// Automatically connect when an entity with a DeviceNetworkComponent starts up.
/// </summary>
private void OnNetworkStarted(EntityUid uid, DeviceNetworkComponent component, ComponentStartup args)
if (device.TransmitFrequency == null
&& device.TransmitFrequencyId != null
&& _protoMan.TryIndex<DeviceFrequencyPrototype>(device.TransmitFrequencyId, out var xmit))
{
AddConnection(component);
device.TransmitFrequency = xmit.Frequency;
}
if (device.AutoConnect)
ConnectDevice(uid, device);
}
/// <summary>
@@ -109,128 +92,198 @@ namespace Content.Server.DeviceNetwork.Systems
/// </summary>
private void OnNetworkShutdown(EntityUid uid, DeviceNetworkComponent component, ComponentShutdown args)
{
RemoveConnection(component);
}
private bool AddConnection(DeviceNetworkComponent connection)
{
var netId = connection.DeviceNetId;
if (!_connections.ContainsKey(netId))
_connections[netId] = new List<DeviceNetworkComponent>();
if (!_connections[netId].Contains(connection))
{
connection.Address = GenerateValidAddress(netId);
_connections[netId].Add(connection);
connection.Open = true;
return true;
}
return false;
}
private bool RemoveConnection(DeviceNetworkComponent connection)
{
connection.Address = "";
connection.Open = false;
return _connections[connection.DeviceNetId].Remove(connection);
DisconnectDevice(uid, component, false);
}
/// <summary>
/// Generates a valid address by randomly generating one and checking if it already exists on the device network with the given device netId.
/// Connect an entity with a DeviceNetworkComponent. Note that this will re-use an existing address if the
/// device already had one configured. If there is a clash, the device cannot join the network.
/// </summary>
private string GenerateValidAddress(DeviceNetworkComponent.ConnectionType netId)
public bool ConnectDevice(EntityUid uid, DeviceNetworkComponent? device = null)
{
var unique = false;
var connections = _connections[netId];
var address = "";
if (!Resolve(uid, ref device, false))
return false;
while (!unique)
if (!_networks.TryGetValue(device.DeviceNetId, out var network))
{
address = _random.Next().ToString("x");
unique = !connections.Exists(connection => connection.Address == address);
network = new(device.DeviceNetId, _random);
_networks[device.DeviceNetId] = network;
}
return address;
return network.Add(device);
}
private List<DeviceNetworkComponent> ConnectionsForFrequency(DeviceNetworkComponent.ConnectionType netId, int frequency)
/// <summary>
/// Disconnect an entity with a DeviceNetworkComponent.
/// </summary>
public bool DisconnectDevice(EntityUid uid, DeviceNetworkComponent? device, bool preventAutoConnect = true)
{
if (!_connections.ContainsKey(netId))
return new List<DeviceNetworkComponent>();
if (!Resolve(uid, ref device, false))
return false;
var result = _connections[netId].FindAll(connection => connection.Frequency == frequency);
// If manually disconnected, don't auto reconnect when a game state is loaded.
if (preventAutoConnect)
device.AutoConnect = false;
return result;
}
private bool TryGetConnectionWithAddress(DeviceNetworkComponent.ConnectionType netId, int frequency, string address, [NotNullWhen(true)] out DeviceNetworkComponent connection)
if (!_networks.TryGetValue(device.DeviceNetId, out var network))
{
var connections = ConnectionsForFrequency(netId, frequency);
var result = connections.Find(dvc => dvc.Address == address);
if(result != null)
{
connection = result;
return true;
}
connection = default!;
return false;
}
private List<DeviceNetworkComponent> ConnectionsWithReceiveAll(DeviceNetworkComponent.ConnectionType netId, int frequency)
{
if (!_connections.ContainsKey(netId))
return new List<DeviceNetworkComponent>();
if (!network.Remove(device))
return false;
var result = _connections[netId].FindAll(device => device.Frequency == frequency && device.ReceiveAll);
if (network.Devices.Count == 0)
_networks.Remove(device.DeviceNetId);
return result;
return true;
}
private void SendPacket(NetworkPacket packet)
#region Get Device
/// <summary>
/// Get a list of devices listening on a given frequency on some network.
/// </summary>
private HashSet<DeviceNetworkComponent> GetListeningDevices(ConnectionType netId, uint frequency)
{
if (!TryGetConnectionWithAddress(packet.NetId, packet.Frequency, packet.Address, out var connection))
return;
if (_networks.TryGetValue(netId, out var network) && network.ListeningDevices.TryGetValue(frequency, out var devices))
return devices;
var receivers = ConnectionsWithReceiveAll(packet.NetId, packet.Frequency);
receivers.Add(connection);
SendToConnections(receivers, packet);
return new();
}
private void BroadcastPacket(NetworkPacket packet)
/// <summary>
/// Get a list of devices listening for ANY transmission on a given frequency, rather than just broadcast & addressed events.
/// </summary>
private HashSet<DeviceNetworkComponent> GetRecieveAllDevices(ConnectionType netId, uint frequency)
{
var receivers = ConnectionsForFrequency(packet.NetId, packet.Frequency);
SendToConnections(receivers, packet);
if (_networks.TryGetValue(netId, out var network) && network.ReceiveAllDevices.TryGetValue(frequency, out var devices))
return devices;
return new();
}
private void SendToConnections(List<DeviceNetworkComponent> connections, NetworkPacket packet)
/// <summary>
/// Try to find a device on a network using its address.
/// </summary>
private bool TryGetDevice(ConnectionType netId, string address, [NotNullWhen(true)] out DeviceNetworkComponent? device)
{
if (!_networks.TryGetValue(netId, out var network))
{
device = null;
return false;
}
return network.Devices.TryGetValue(address, out device);
}
#endregion
#region Packet Sending
private void SendPacket(DeviceNetworkPacketEvent packet)
{
HashSet<DeviceNetworkComponent> recipients;
if (packet.Address == null)
{
// Broadcast to all listening devices
recipients = GetListeningDevices(packet.NetId, packet.Frequency);
}
else
{
// Add devices listening to all messages
recipients = new(GetRecieveAllDevices(packet.NetId, packet.Frequency));
// add the intended recipient (if they are even listening).
if (TryGetDevice(packet.NetId, packet.Address, out var device) && device.ReceiveFrequency == packet.Frequency)
recipients.Add(device);
}
SendToConnections(recipients, packet);
}
private void SendToConnections(HashSet<DeviceNetworkComponent> connections, DeviceNetworkPacketEvent packet)
{
var xform = Transform(packet.Sender);
BeforePacketSentEvent beforeEv = new(packet.Sender, xform, _transformSystem.GetWorldPosition(xform));
foreach (var connection in connections)
{
var beforeEvent = new BeforePacketSentEvent(packet.Sender.Owner);
RaiseLocalEvent(connection.Owner, beforeEvent, false);
if (connection.Owner == packet.Sender)
continue;
if (!beforeEvent.Cancelled)
{
RaiseLocalEvent(connection.Owner, new PacketSentEvent(connection.Frequency, packet.Sender.Address, packet.Data, packet.Broadcast) , false);
RaiseLocalEvent(connection.Owner, beforeEv, false);
if (!beforeEv.Cancelled)
RaiseLocalEvent(connection.Owner, packet, false);
else
beforeEv.Uncancel();
}
}
#endregion
#region Component Setter Functions
public void SetReceiveFrequency(EntityUid uid, uint? frequency, DeviceNetworkComponent? device = null)
{
if (!Resolve(uid, ref device, false))
return;
if (device.ReceiveFrequency == frequency)
return;
if (!_networks.TryGetValue(device.DeviceNetId, out var deviceNet) || !deviceNet.UpdateReceiveFrequency(device.Address, frequency))
device.ReceiveFrequency = frequency;
}
public void SetTransmitFrequency(EntityUid uid, uint? frequency, DeviceNetworkComponent? device = null)
{
if (Resolve(uid, ref device, false))
device.TransmitFrequency = frequency;
}
public void SetReceiveAll(EntityUid uid, bool receiveAll, DeviceNetworkComponent? device = null)
{
if (!Resolve(uid, ref device, false))
return;
if (device.ReceiveAll == receiveAll)
return;
if (!_networks.TryGetValue(device.DeviceNetId, out var deviceNet) || !deviceNet.UpdateReceiveAll(device.Address, receiveAll))
device.ReceiveAll = receiveAll;
}
public void SetAddress(EntityUid uid, string address, DeviceNetworkComponent? device = null)
{
if (!Resolve(uid, ref device, false))
return;
if (device.Address == address)
{
device.CustomAddress = true;
return;
}
if (!_networks.TryGetValue(device.DeviceNetId, out var deviceNet) || !deviceNet.UpdateAddress(device.Address, address))
{
device.Address = address;
device.CustomAddress = true;
}
}
internal struct NetworkPacket
public void RandomizeAddress(EntityUid uid, string address, DeviceNetworkComponent? device = null)
{
public DeviceNetworkComponent.ConnectionType NetId;
public int Frequency;
public string Address;
public bool Broadcast;
public NetworkPayload Data;
public DeviceNetworkComponent Sender;
if (!Resolve(uid, ref device, false))
return;
if (!_networks.TryGetValue(device.DeviceNetId, out var deviceNet) || !deviceNet.RandomizeAddress(device.Address, address))
{
var prefix = string.IsNullOrWhiteSpace(device.Prefix) ? null : Loc.GetString(device.Prefix);
device.Address = $"{prefix}{_random.Next():x}";
device.CustomAddress = false;
}
}
#endregion
}
/// <summary>
/// Event raised before a device network packet is send.
@@ -241,46 +294,66 @@ namespace Content.Server.DeviceNetwork.Systems
/// <summary>
/// The EntityUid of the entity the packet was sent from.
/// </summary>
public EntityUid Sender;
public readonly EntityUid Sender;
public BeforePacketSentEvent(EntityUid sender)
public readonly TransformComponent SenderTransform;
/// <summary>
/// The senders current position in world coordinates.
/// </summary>
public readonly Vector2 SenderPosition;
public BeforePacketSentEvent(EntityUid sender, TransformComponent xform, Vector2 senderPosition)
{
Sender = sender;
SenderTransform = xform;
SenderPosition = senderPosition;
}
}
/// <summary>
/// Event raised when a device network packet gets sent.
/// </summary>
public sealed class PacketSentEvent : EntityEventArgs
public sealed class DeviceNetworkPacketEvent : EntityEventArgs
{
/// <summary>
/// The type of network that this packet is being sent on.
/// </summary>
public ConnectionType NetId;
/// <summary>
/// The frequency the packet is sent on.
/// </summary>
public int Frequency;
public readonly uint Frequency;
/// <summary>
/// Address of the intended recipient. Null if the message was broadcast.
/// </summary>
public string? Address;
/// <summary>
/// The device network address of the sending entity.
/// </summary>
public string SenderAddress;
public readonly string SenderAddress;
/// <summary>
/// The data that is beeing sent.
/// The entity that sent the packet.
/// </summary>
public NetworkPayload Data;
public EntityUid Sender;
/// <summary>
/// Whether the packet was broadcasted.
/// The data that is being sent.
/// </summary>
public bool Broadcast;
public readonly NetworkPayload Data;
public PacketSentEvent(int frequency, string senderAddress, NetworkPayload data, bool broadcast)
public DeviceNetworkPacketEvent(ConnectionType netId, string? address, uint frequency, string senderAddress, EntityUid sender, NetworkPayload data)
{
NetId = netId;
Address = address;
Frequency = frequency;
SenderAddress = senderAddress;
Sender = sender;
Data = data;
Broadcast = broadcast;
}
}
}

11
Content.Server/DeviceNetwork/Systems/Devices/ApcNetSwitchSystem.cs
View File

@@ -1,4 +1,4 @@
using Content.Server.DeviceNetwork.Components;
using Content.Server.DeviceNetwork.Components;
using Content.Server.DeviceNetwork.Components.Devices;
using Content.Shared.Interaction;
using Robust.Shared.GameObjects;
@@ -15,7 +15,7 @@ namespace Content.Server.DeviceNetwork.Systems.Devices
base.Initialize();
SubscribeLocalEvent<ApcNetSwitchComponent, InteractHandEvent>(OnInteracted);
SubscribeLocalEvent<ApcNetSwitchComponent, PacketSentEvent>(OnPackedReceived);
SubscribeLocalEvent<ApcNetSwitchComponent, DeviceNetworkPacketEvent>(OnPackedReceived);
}
/// <summary>
@@ -28,13 +28,16 @@ namespace Content.Server.DeviceNetwork.Systems.Devices
component.State = !component.State;
if (networkComponent.TransmitFrequency == null)
return;
var payload = new NetworkPayload
{
[DeviceNetworkConstants.Command] = DeviceNetworkConstants.CmdSetState,
[DeviceNetworkConstants.StateEnabled] = component.State,
};
_deviceNetworkSystem.QueuePacket(uid, DeviceNetworkConstants.NullAddress, networkComponent.Frequency, payload, true);
_deviceNetworkSystem.QueuePacket(uid, null, payload, device: networkComponent);
args.Handled = true;
}
@@ -42,7 +45,7 @@ namespace Content.Server.DeviceNetwork.Systems.Devices
/// <summary>
/// Listens to the <see cref="DeviceNetworkConstants.CmdSetState"/> command of other switches to sync state
/// </summary>
private void OnPackedReceived(EntityUid uid, ApcNetSwitchComponent component, PacketSentEvent args)
private void OnPackedReceived(EntityUid uid, ApcNetSwitchComponent component, DeviceNetworkPacketEvent args)
{
if (!EntityManager.TryGetComponent(uid, out DeviceNetworkComponent? networkComponent) || args.SenderAddress == networkComponent.Address) return;
if (!args.Data.TryGetValue(DeviceNetworkConstants.Command, out string? command) || command != DeviceNetworkConstants.CmdSetState) return;

2
Content.Server/DeviceNetwork/Systems/WiredNetworkSystem.cs
View File

@@ -18,7 +18,7 @@ namespace Content.Server.DeviceNetwork.Systems
/// </summary>
private void OnBeforePacketSent(EntityUid uid, WiredNetworkComponent component, BeforePacketSentEvent args)
{
if (EntityManager.GetComponent<TransformComponent>(uid).GridID != EntityManager.GetComponent<TransformComponent>(args.Sender).GridID)
if (EntityManager.GetComponent<TransformComponent>(uid).GridID != args.SenderTransform.GridID)
{
args.Cancel();
}

9
Content.Server/DeviceNetwork/Systems/WirelessNetworkSystem.cs
View File

@@ -18,11 +18,12 @@ namespace Content.Server.DeviceNetwork.Systems
/// </summary>
private void OnBeforePacketSent(EntityUid uid, WirelessNetworkComponent component, BeforePacketSentEvent args)
{
var ownPosition = EntityManager.GetComponent<TransformComponent>(component.Owner).WorldPosition;
var position = EntityManager.GetComponent<TransformComponent>(args.Sender).WorldPosition;
var distance = (ownPosition - position).Length;
var ownPosition = args.SenderPosition;
var xform = Transform(uid);
if (EntityManager.TryGetComponent<WirelessNetworkComponent?>(args.Sender, out var sendingComponent) && distance > sendingComponent.Range)
if (xform.MapID != args.SenderTransform.MapID
|| !TryComp<WirelessNetworkComponent?>(args.Sender, out var sendingComponent)
|| (ownPosition - xform.WorldPosition).Length > sendingComponent.Range)
{
args.Cancel();
}

4
Content.Server/Light/EntitySystems/PoweredLightSystem.cs
View File

@@ -51,7 +51,7 @@ namespace Content.Server.Light.EntitySystems
SubscribeLocalEvent<PoweredLightComponent, DamageChangedEvent>(HandleLightDamaged);
SubscribeLocalEvent<PoweredLightComponent, SignalReceivedEvent>(OnSignalReceived);
SubscribeLocalEvent<PoweredLightComponent, PacketSentEvent>(OnPacketReceived);
SubscribeLocalEvent<PoweredLightComponent, DeviceNetworkPacketEvent>(OnPacketReceived);
SubscribeLocalEvent<PoweredLightComponent, PowerChangedEvent>(OnPowerChanged);
}
@@ -346,7 +346,7 @@ namespace Content.Server.Light.EntitySystems
/// Turns the light on or of when receiving a <see cref="DeviceNetworkConstants.CmdSetState"/> command.
/// The light is turned on or of according to the <see cref="DeviceNetworkConstants.StateEnabled"/> value
/// </summary>
private void OnPacketReceived(EntityUid uid, PoweredLightComponent component, PacketSentEvent args)
private void OnPacketReceived(EntityUid uid, PoweredLightComponent component, DeviceNetworkPacketEvent args)
{
if (!args.Data.TryGetValue(DeviceNetworkConstants.Command, out string? command) || command != DeviceNetworkConstants.CmdSetState) return;
if (!args.Data.TryGetValue(DeviceNetworkConstants.StateEnabled, out bool enabled)) return;

4
Content.Server/Medical/CrewMonitoring/CrewMonitoringConsoleSystem.cs
View File

@@ -21,7 +21,7 @@ namespace Content.Server.Medical.CrewMonitoring
{
base.Initialize();
SubscribeLocalEvent<CrewMonitoringConsoleComponent, ComponentRemove>(OnRemove);
SubscribeLocalEvent<CrewMonitoringConsoleComponent, PacketSentEvent>(OnPacketReceived);
SubscribeLocalEvent<CrewMonitoringConsoleComponent, DeviceNetworkPacketEvent>(OnPacketReceived);
}
public override void Update(float frameTime)
@@ -47,7 +47,7 @@ namespace Content.Server.Medical.CrewMonitoring
component.ConnectedSensors.Clear();
}
private void OnPacketReceived(EntityUid uid, CrewMonitoringConsoleComponent component, PacketSentEvent args)
private void OnPacketReceived(EntityUid uid, CrewMonitoringConsoleComponent component, DeviceNetworkPacketEvent args)
{
var suitSensor = _sensors.PacketToSuitSensor(args.Data);
if (suitSensor == null)

4
Content.Server/Medical/SuitSensors/SuitSensorComponent.cs
View File

@@ -40,10 +40,10 @@ namespace Content.Server.Medical.SuitSensors
public string ActivationSlot = "jumpsuit";
/// <summary>
/// How often does sensor update its owners status (in seconds).
/// How often does sensor update its owners status (in seconds). Limited by the system update rate.
/// </summary>
[DataField("updateRate")]
public float UpdateRate = 2f;
public TimeSpan UpdateRate = TimeSpan.FromSeconds(2f);
/// <summary>
/// Current user that wears suit sensor. Null if nobody wearing it.

11
Content.Server/Medical/SuitSensors/SuitSensorSystem.cs
View File

@@ -1,4 +1,4 @@
using System;
using System;
using Content.Server.Access.Systems;
using Content.Server.DeviceNetwork;
using Content.Server.DeviceNetwork.Components;
@@ -30,7 +30,7 @@ namespace Content.Server.Medical.SuitSensors
[Dependency] private readonly DeviceNetworkSystem _deviceNetworkSystem = default!;
[Dependency] private readonly IGameTiming _gameTiming = default!;
private const float UpdateRate = 0.5f;
private const float UpdateRate = 1f;
private float _updateDif;
public override void Initialize()
@@ -58,8 +58,11 @@ namespace Content.Server.Medical.SuitSensors
var sensors = EntityManager.EntityQuery<SuitSensorComponent, DeviceNetworkComponent>();
foreach (var (sensor, device) in sensors)
{
if (device.TransmitFrequency is not uint frequency)
continue;
// check if sensor is ready to update
if (curTime - sensor.LastUpdate < TimeSpan.FromSeconds(sensor.UpdateRate))
if (curTime - sensor.LastUpdate < sensor.UpdateRate)
continue;
sensor.LastUpdate = curTime;
@@ -70,7 +73,7 @@ namespace Content.Server.Medical.SuitSensors
// broadcast it to device network
var payload = SuitSensorToPacket(status);
_deviceNetworkSystem.QueuePacket(sensor.Owner, DeviceNetworkConstants.NullAddress, device.Frequency, payload, true);
_deviceNetworkSystem.QueuePacket(sensor.Owner, null, payload, device: device);
}
}

26
Content.Shared/DeviceNetwork/DeviceFrequencyPrototype.cs Normal file
View File

@@ -0,0 +1,26 @@
using Robust.Shared.Prototypes;
using Robust.Shared.Serialization;
namespace Content.Shared.DeviceNetwork;
/// <summary>
/// A named device network frequency. Useful for ensuring entity prototypes can communicate with each other.
/// </summary>
[Prototype("deviceFrequency")]
[Serializable, NetSerializable]
public sealed class DeviceFrequencyPrototype : IPrototype
{
[IdDataFieldAttribute]
public string ID { get; } = default!;
// TODO Somehow Allow per-station or some other type of named but randomized frequencies?
[DataField("frequency", required: true)]
public uint Frequency;
/// <summary>
/// Optional name for this frequency, for displaying in game.
/// </summary>
[DataField("name")]
public string? Name;
}

8
Resources/Locale/en-US/devices/device-network.ftl Normal file
View File

@@ -0,0 +1,8 @@
# named frequencies
device-frequency-prototype-name-atmos = Atmospheric Devices
device-frequency-prototype-name-suit-sensors = Suit Sensors
device-frequency-prototype-name-lights = Smart Lights
# prefixes for randomly generated device addresses
device-address-prefix-vent = Vnt-
device-address-prefix-scrubber = Scr-

16
Resources/Prototypes/Device/devicenet_frequencies.yml Normal file
View File

@@ -0,0 +1,16 @@
- type: deviceFrequency
id: AtmosMonitor
name: device-frequency-prototype-name-atmos
frequency: 1621
# Only listen to this frequency if you are a health or GPS monitor. Otherwise you will just slow down the server by constantly receiving periodic broadcasts from every player-entity.
- type: deviceFrequency
id: SuitSensor
name: device-frequency-prototype-name-suit-sensors
frequency: 1262
# This frequency will likely have a LARGE number of listening entities. Please don't broadcast on this frequency.
- type: deviceFrequency
id: SmartLight #used by powered lights.
name: device-frequency-prototype-name-lights
frequency: 1173

3
Resources/Prototypes/Entities/Clothing/Uniforms/base_clothinguniforms.yml
View File

@@ -4,8 +4,9 @@
id: ClothingWithSuitSensor
components:
- type: SuitSensor
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Wireless
transmitFrequencyId: SuitSensor
- type: WirelessNetworkConnection
range: 500

3
Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml
View File

@@ -176,7 +176,8 @@
- AtmosphericsNitrogen
- AtmosphericsCarbonDioxide
- type: CrewMonitoringConsole
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Wireless
receiveFrequencyId: SuitSensor
- type: WirelessNetworkConnection
range: 500

3
Resources/Prototypes/Entities/Objects/Specific/Medical/handheld_crew_monitor.yml
View File

@@ -14,7 +14,8 @@
- key: enum.CrewMonitoringUIKey.Key
type: CrewMonitoringBoundUserInterface
- type: CrewMonitoringConsole
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Wireless
receiveFrequencyId: SuitSensor
- type: WirelessNetworkConnection
range: 500

4
Resources/Prototypes/Entities/Structures/Doors/Firelocks/firelock.yml
View File

@@ -10,9 +10,9 @@
- AirAlarm
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
frequency: 1621
receiveFrequencyId: AtmosMonitor
- type: ApcNetworkConnection
- type: InteractionOutline
- type: Damageable

3
Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml
View File

@@ -137,8 +137,9 @@
- key: enum.CrewMonitoringUIKey.Key
type: CrewMonitoringBoundUserInterface
- type: CrewMonitoringConsole
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Wireless
receiveFrequencyId: SuitSensor
- type: WirelessNetworkConnection
range: 500

12
Resources/Prototypes/Entities/Structures/Piping/Atmospherics/unary.yml
View File

@@ -26,9 +26,11 @@
components:
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
frequency: 1621
receiveFrequencyId: AtmosMonitor
transmitFrequencyId: AtmosMonitor
prefix: device-address-prefix-vent
- type: ApcNetworkConnection
- type: AtmosAlarmable
alarmedBy:
@@ -96,9 +98,11 @@
components:
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
frequency: 1621
receiveFrequencyId: AtmosMonitor
transmitFrequencyId: AtmosMonitor
prefix: device-address-prefix-scrubber
- type: ApcNetworkConnection
- type: AtmosAlarmable
alarmedBy:

5
Resources/Prototypes/Entities/Structures/Wallmounts/air_alarm.yml
View File

@@ -6,9 +6,10 @@
- type: WallMount
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
frequency: 1621
receiveFrequencyId: AtmosMonitor
transmitFrequencyId: AtmosMonitor
- type: ApcNetworkConnection
- type: AtmosMonitor
temperatureThreshold: stationTemperature

5
Resources/Prototypes/Entities/Structures/Wallmounts/fire_alarm.yml
View File

@@ -6,9 +6,10 @@
- type: WallMount
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
frequency: 1621
receiveFrequencyId: AtmosMonitor
transmitFrequencyId: AtmosMonitor
- type: ApcNetworkConnection
- type: AtmosMonitor
monitorFire: true

6
Resources/Prototypes/Entities/Structures/Wallmounts/lighting.yml
View File

@@ -79,8 +79,9 @@
Heat: 5
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
receiveFrequencyId: SmartLight
- type: ApcNetworkConnection
- type: Appearance
visuals:
@@ -245,8 +246,9 @@
Heat: 5
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
receiveFrequencyId: SmartLight
- type: ApcNetworkConnection
- type: Appearance
visuals:

3
Resources/Prototypes/Entities/Structures/Wallmounts/switch.yml
View File

@@ -58,8 +58,9 @@
graph: LightSwitch
node: lightSwitch
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
transmitFrequencyId: SmartLight # assuming people want to use it for light switches.
- type: ApcNetworkConnection
- type: ApcNetSwitch
placement:

3
Resources/Prototypes/Entities/Structures/lighting_ground.yml
View File

@@ -77,8 +77,9 @@
Heat: 20
- type: ApcPowerReceiver
- type: ExtensionCableReceiver
- type: DeviceNetworkComponent
- type: DeviceNetwork
deviceNetId: Apc
receiveFrequencyId: SmartLight
- type: ApcNetworkConnection
- type: Construction
graph: LightFixture