Rejig Device networks (#7380)

Content.Client/Entry/IgnoredComponents.cs

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

Content.IntegrationTests/Tests/DeviceNetwork/DeviceNetworkTest.cs

@@ -20,15 +20,18 @@ namespace Content.IntegrationTests.Tests.DeviceNetwork
   name: DummyNetworkDevice
   id: DummyNetworkDevice
   components:
-    - type: DeviceNetworkComponent
+    - type: DeviceNetwork
-      frequency: 100
+      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
+    - type: DeviceNetwork
-      frequency: 100
+      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);

Content.IntegrationTests/Tests/DeviceNetwork/DeviceNetworkTestSystem.cs

@@ -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;
         }

Content.Server/Atmos/Monitor/Systems/AirAlarmSystem.cs

@@ -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;

Content.Server/Atmos/Monitor/Systems/AtmosAlarmableSystem.cs

@@ -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;
 

Content.Server/Atmos/Monitor/Systems/AtmosMonitoringSystem.cs

@@ -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>

Content.Server/Atmos/Piping/Unary/EntitySystems/GasVentPumpSystem.cs

@@ -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;
             }

Content.Server/Atmos/Piping/Unary/EntitySystems/GasVentScrubberSystem.cs

@@ -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;
             }

Content.Server/DeviceNetwork/Components/DeviceNetworkComponent.cs

@@ -1,17 +1,16 @@
-using System;
+using Content.Server.DeviceNetwork.Systems;
-using Robust.Shared.GameObjects;
+using Content.Shared.DeviceNetwork;
-using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.Serialization.TypeSerializers.Implementations.Custom.Prototype;
-using Robust.Shared.ViewVariables;
 
 namespace Content.Server.DeviceNetwork.Components
 {
     [RegisterComponent]
-    [ComponentProtoName("DeviceNetworkComponent")]
+    [Friend(typeof(DeviceNetworkSystem), typeof(DeviceNet))]
     public sealed class DeviceNetworkComponent : Component
     {
         /// <summary>
-        ///  Valid device network NetIDs.
+        ///     Valid device network NetIDs. The netID is used to separate device networks that shouldn't interact with
-        /// The netID is used to separate device networks that shouldn't interact with each other e.g. wireless and wired.
+        ///     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")]
+        /// <summary>
-        public int Frequency { get; set; } = 0;
+        ///     The frequency that this device is listening on.
+        /// </summary>
+        [DataField("receiveFrequency")]
+        public uint? ReceiveFrequency;
 
-        [ViewVariables]
+        /// <summary>
-        public bool Open;
+        ///     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;
     }
 }

Content.Server/DeviceNetwork/DeviceNet.cs

@@ -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;
+    }
+}

Content.Server/DeviceNetwork/DeviceNetworkConstants.cs

@@ -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>

Content.Server/DeviceNetwork/Systems/DeviceNetworkSystem.cs

@@ -1,10 +1,10 @@
 using Content.Server.DeviceNetwork.Components;
+using Content.Shared.DeviceNetwork;
 using JetBrains.Annotations;
-using Robust.Shared.GameObjects;
+using Robust.Shared.Prototypes;
-using Robust.Shared.IoC;
 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 Dictionary<ConnectionType, DeviceNet> _networks = new();
-        private readonly Queue<NetworkPacket> _packets = 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, NetworkPayload data, uint? frequency = null, DeviceNetworkComponent? device = null)
-        public void QueuePacket(EntityUid uid, string address, int frequency, NetworkPayload data, bool broadcast = false)
         {
-            if (EntityManager.TryGetComponent<DeviceNetworkComponent>(uid, out var component))
+            if (!Resolve(uid, ref device, false))
-            {
+                return;
-                var packet = new NetworkPacket
-                {
-                    NetId = component.DeviceNetId,
-                    Address = address,
-                    Frequency = frequency,
-                    Broadcast = broadcast,
-                    Data = data,
-                    Sender = component
-                };
 
-                _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>
+        private void OnMapInit(EntityUid uid, DeviceNetworkComponent device, MapInitEvent args)
-        public void Disconnect(EntityUid uid)
         {
-            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>
+            if (device.TransmitFrequency == null
-        /// Automatically connect when an entity with a DeviceNetworkComponent starts up.
+                && device.TransmitFrequencyId != null
-        /// </summary>
+                && _protoMan.TryIndex<DeviceFrequencyPrototype>(device.TransmitFrequencyId, out var xmit))
-        private void OnNetworkStarted(EntityUid uid, DeviceNetworkComponent component, ComponentStartup args)
             {
-            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);
+            DisconnectDevice(uid, component, false);
-        }
-
-        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);
         }
 
         /// <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;
+            if (!Resolve(uid, ref device, false))
-            var connections = _connections[netId];
+                return false;
-            var address = "";
 
-            while (!unique)
+            if (!_networks.TryGetValue(device.DeviceNetId, out var network))
             {
-                address = _random.Next().ToString("x");
+                network = new(device.DeviceNetId, _random);
-                unique = !connections.Exists(connection => connection.Address == address);
+                _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))
+            if (!Resolve(uid, ref device, false))
-                return new List<DeviceNetworkComponent>();
+                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;
+            if (!_networks.TryGetValue(device.DeviceNetId, out var network))
-        }
-
-        private bool TryGetConnectionWithAddress(DeviceNetworkComponent.ConnectionType netId, int frequency, string address, [NotNullWhen(true)] out DeviceNetworkComponent connection)
             {
-            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 (!network.Remove(device))
-        {
+                return false;
-            if (!_connections.ContainsKey(netId))
-                return new List<DeviceNetworkComponent>();
 
-            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))
+            if (_networks.TryGetValue(netId, out var network) && network.ListeningDevices.TryGetValue(frequency, out var devices))
-                return;
+                return devices;
 
-            var receivers = ConnectionsWithReceiveAll(packet.NetId, packet.Frequency);
+            return new();
-            receivers.Add(connection);
-
-            SendToConnections(receivers, packet);
         }
 
-        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);
+            if (_networks.TryGetValue(netId, out var network) && network.ReceiveAllDevices.TryGetValue(frequency, out var devices))
-            SendToConnections(receivers, packet);
+                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);
+                if (connection.Owner == packet.Sender)
-                RaiseLocalEvent(connection.Owner, beforeEvent, false);
+                    continue;
 
-                if (!beforeEvent.Cancelled)
+                RaiseLocalEvent(connection.Owner, beforeEv, false);
-                {
+
-                    RaiseLocalEvent(connection.Owner, new PacketSentEvent(connection.Frequency, packet.Sender.Address, packet.Data, packet.Broadcast) , 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;
+            if (!Resolve(uid, ref device, false))
-            public int Frequency;
+                return;
-            public string Address;
+
-            public bool Broadcast;
+            if (!_networks.TryGetValue(device.DeviceNetId, out var deviceNet) || !deviceNet.RandomizeAddress(device.Address, address))
-            public NetworkPayload Data;
+            {
-            public DeviceNetworkComponent Sender;
+                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;
         }
-
     }
 }

Content.Server/DeviceNetwork/Systems/Devices/ApcNetSwitchSystem.cs

@@ -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;

Content.Server/DeviceNetwork/Systems/WiredNetworkSystem.cs

@@ -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();
             }

Content.Server/DeviceNetwork/Systems/WirelessNetworkSystem.cs

@@ -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 ownPosition = args.SenderPosition;
-            var position = EntityManager.GetComponent<TransformComponent>(args.Sender).WorldPosition;
+            var xform = Transform(uid);
-            var distance = (ownPosition - position).Length;
 
-            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();
             }

Content.Server/Light/EntitySystems/PoweredLightSystem.cs

@@ -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;

Content.Server/Medical/CrewMonitoring/CrewMonitoringConsoleSystem.cs

@@ -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)

Content.Server/Medical/SuitSensors/SuitSensorComponent.cs

@@ -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.

Content.Server/Medical/SuitSensors/SuitSensorSystem.cs

@@ -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);
             }
         }
 

Content.Shared/DeviceNetwork/DeviceFrequencyPrototype.cs

@@ -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;
+
+}

Resources/Locale/en-US/devices/device-network.ftl

@@ -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-

Resources/Prototypes/Device/devicenet_frequencies.yml

@@ -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

Resources/Prototypes/Entities/Clothing/Uniforms/base_clothinguniforms.yml

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

Resources/Prototypes/Entities/Mobs/Player/admin_ghost.yml

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

Resources/Prototypes/Entities/Objects/Specific/Medical/handheld_crew_monitor.yml

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

Resources/Prototypes/Entities/Structures/Doors/Firelocks/firelock.yml

@@ -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

Resources/Prototypes/Entities/Structures/Machines/Computers/computers.yml

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

Resources/Prototypes/Entities/Structures/Piping/Atmospherics/unary.yml

@@ -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:

Resources/Prototypes/Entities/Structures/Wallmounts/air_alarm.yml

@@ -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

Resources/Prototypes/Entities/Structures/Wallmounts/fire_alarm.yml

@@ -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

Resources/Prototypes/Entities/Structures/Wallmounts/lighting.yml

@@ -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:

Resources/Prototypes/Entities/Structures/Wallmounts/switch.yml

@@ -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:

Resources/Prototypes/Entities/Structures/lighting_ground.yml

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