Apc device network and apc based light switch (#4908)

* Remove WireNet node group from cables
Implement extension cable components and system
Remove connection over distance logic from ApcPower... components

* Add extension cable components to prototypes

* Implement ApcNetwork
Implement ApcNetSwitch

* Fix ignoredComponents.cs

* Add friend attribute to new components

* Add construction graph for a light switch

* Address reviews

* Fix broken test

* Move ConnectionType enum to DeviceNetworkComponent
Change netId data definition to use the ConnectionType enum values

Co-authored-by: Julian Giebel <j.giebel@netrocks.info>

Content.Server/Power/Components/ApcPowerProviderComponent.cs

@@ -1,9 +1,6 @@
-using System;
 using System.Collections.Generic;
 using Content.Server.Power.NodeGroups;
 using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Serialization.Manager.Attributes;
 using Robust.Shared.ViewVariables;
 
 namespace Content.Server.Power.Components
@@ -13,24 +10,8 @@ namespace Content.Server.Power.Components
     {
         public override string Name => "PowerProvider";
 
-        public IEntity ProviderOwner => Owner;
-
-        /// <summary>
-        ///     The max distance this can transmit power to <see cref="ApcPowerReceiverComponent"/>s from.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        public int PowerTransferRange { get => _powerTransferRange; set => SetPowerTransferRange(value); }
-        [DataField("powerTransferRange")]
-        private int _powerTransferRange = 3;
-
         [ViewVariables] public List<ApcPowerReceiverComponent> LinkedReceivers { get; } = new();
 
-        /// <summary>
-        ///     If <see cref="ApcPowerReceiverComponent"/>s should consider connecting to this.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        public bool Connectable { get; private set; } = true;
-
         public void AddReceiver(ApcPowerReceiverComponent receiver)
         {
             LinkedReceivers.Add(receiver);
@@ -47,49 +28,6 @@ namespace Content.Server.Power.Components
             Net?.QueueNetworkReconnect();
         }
 
-        protected override void Startup()
-        {
-            base.Startup();
-
-            foreach (var receiver in FindAvailableReceivers())
-            {
-                receiver.Provider = this;
-            }
-        }
-
-        protected override void OnRemove()
-        {
-            Connectable = false;
-            var receivers = LinkedReceivers.ToArray();
-            foreach (var receiver in receivers)
-            {
-                receiver.Provider = null;
-            }
-            foreach (var receiver in receivers)
-            {
-                receiver.TryFindAndSetProvider();
-            }
-            base.OnRemove();
-        }
-
-        private IEnumerable<ApcPowerReceiverComponent> FindAvailableReceivers()
-        {
-            var nearbyEntities = IoCManager.Resolve<IEntityLookup>()
-                .GetEntitiesInRange(Owner, PowerTransferRange);
-
-            foreach (var entity in nearbyEntities)
-            {
-                if (entity.TryGetComponent<ApcPowerReceiverComponent>(out var receiver) &&
-                    receiver.Connectable &&
-                    receiver.NeedsProvider &&
-                    receiver.Owner.Transform.Coordinates.TryDistance(Owner.EntityManager, Owner.Transform.Coordinates, out var distance) &&
-                    distance < Math.Min(PowerTransferRange, receiver.PowerReceptionRange))
-                {
-                    yield return receiver;
-                }
-            }
-        }
-
         protected override void AddSelfToNet(IApcNet apcNet)
         {
             apcNet.AddPowerProvider(this);
@@ -99,22 +37,5 @@ namespace Content.Server.Power.Components
         {
             apcNet.RemovePowerProvider(this);
         }
-
-        private void SetPowerTransferRange(int newPowerTransferRange)
-        {
-            var receivers = LinkedReceivers.ToArray();
-
-            foreach (var receiver in receivers)
-            {
-                receiver.Provider = null;
-            }
-
-            _powerTransferRange = newPowerTransferRange;
-
-            foreach (var receiver in receivers)
-            {
-                receiver.TryFindAndSetProvider();
-            }
-        }
     }
 }

Content.Server/Power/Components/ApcPowerReceiverComponent.cs

@@ -23,47 +23,11 @@ namespace Content.Server.Power.Components
     [RegisterComponent]
     public class ApcPowerReceiverComponent : Component, IExamine
     {
-        [ViewVariables] [ComponentDependency] private readonly IPhysBody? _physicsComponent = null;
-
         public override string Name => "ApcPowerReceiver";
 
         [ViewVariables]
         public bool Powered => (MathHelper.CloseToPercent(NetworkLoad.ReceivingPower, Load) || !NeedsPower) && !PowerDisabled;
 
-        /// <summary>
-        ///     The max distance from a <see cref="ApcPowerProviderComponent"/> that this can receive power from.
-        /// </summary>
-        [ViewVariables(VVAccess.ReadWrite)]
-        public int PowerReceptionRange { get => _powerReceptionRange; set => SetPowerReceptionRange(value); }
-        [DataField("powerReceptionRange")]
-        private int _powerReceptionRange = 3;
-
-        [ViewVariables]
-        public ApcPowerProviderComponent? Provider
-        {
-            get => _provider;
-            set
-            {
-                // Will get updated before power networks process.
-                NetworkLoad.LinkedNetwork = default;
-                _provider?.RemoveReceiver(this);
-                _provider = value;
-                value?.AddReceiver(this);
-                ApcPowerChanged();
-            }
-        }
-
-        private ApcPowerProviderComponent? _provider;
-
-        /// <summary>
-        ///     If this should be considered for connection by <see cref="ApcPowerProviderComponent"/>s.
-        /// </summary>
-        public bool Connectable => Anchored;
-
-        private bool Anchored => _physicsComponent == null || _physicsComponent.BodyType == BodyType.Static;
-
-        [ViewVariables] public bool NeedsProvider => Provider == null;
-
         /// <summary>
         ///     Amount of charge this needs from an APC per second to function.
         /// </summary>
@@ -104,73 +68,11 @@ namespace Content.Server.Power.Components
             DesiredPower = 5
         };
 
-        protected override void Startup()
-        {
-            base.Startup();
-            if (NeedsProvider)
-            {
-                TryFindAndSetProvider();
-            }
-            if (_physicsComponent != null)
-            {
-                AnchorUpdate();
-            }
-        }
-
-        protected override void OnRemove()
-        {
-            _provider?.RemoveReceiver(this);
-
-            base.OnRemove();
-        }
-
-        public void TryFindAndSetProvider()
-        {
-            if (TryFindAvailableProvider(out var provider))
-            {
-                Provider = provider;
-            }
-        }
-
         public void ApcPowerChanged()
         {
             OnNewPowerState();
         }
 
-        private bool TryFindAvailableProvider([NotNullWhen(true)] out ApcPowerProviderComponent? foundProvider)
-        {
-            var nearbyEntities = IoCManager.Resolve<IEntityLookup>()
-                .GetEntitiesInRange(Owner, PowerReceptionRange);
-
-            foreach (var entity in nearbyEntities)
-            {
-                if (entity.TryGetComponent<ApcPowerProviderComponent>(out var provider))
-                {
-                    if (provider.Connectable)
-                    {
-                        if (provider.Owner.Transform.Coordinates.TryDistance(Owner.EntityManager, Owner.Transform.Coordinates, out var distance))
-                        {
-                            if (distance < Math.Min(PowerReceptionRange, provider.PowerTransferRange))
-                            {
-                                foundProvider = provider;
-                                return true;
-                            }
-                        }
-                    }
-                }
-            }
-
-            foundProvider = default;
-            return false;
-        }
-
-        private void SetPowerReceptionRange(int newPowerReceptionRange)
-        {
-            Provider = null;
-            _powerReceptionRange = newPowerReceptionRange;
-            TryFindAndSetProvider();
-        }
-
         private void OnNewPowerState()
         {
             SendMessage(new PowerChangedMessage(Powered));
@@ -182,21 +84,6 @@ namespace Content.Server.Power.Components
             }
         }
 
-        public void AnchorUpdate()
-        {
-            if (Anchored)
-            {
-                if (NeedsProvider)
-                {
-                    TryFindAndSetProvider();
-                }
-            }
-            else
-            {
-                Provider = null;
-            }
-        }
-
         ///<summary>
         ///Adds some markup to the examine text of whatever object is using this component to tell you if it's powered or not, even if it doesn't have an icon state to do this for you.
         ///</summary>

Content.Server/Power/Components/ExtensionCableProviderComponent.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using Content.Server.Power.EntitySystems;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Power.Components
+{
+    [RegisterComponent]
+    [Friend(typeof(ExtensionCableSystem))]
+    public class ExtensionCableProviderComponent : Component
+    {
+        public override string Name => "ExtensionCableProvider";
+
+        /// <summary>
+        ///     The max distance this can connect to <see cref="ExtensionCableReceiverComponent"/>s from.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("transferRange")]
+        public int TransferRange { get; set; } = 3;
+
+        [ViewVariables] public List<ExtensionCableReceiverComponent> LinkedReceivers { get; } = new();
+
+        /// <summary>
+        ///     If <see cref="ExtensionCableReceiverComponent"/>s should consider connecting to this.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        public bool Connectable { get; set; } = true;
+
+
+    }
+}

Content.Server/Power/Components/ExtensionCableReceiverComponent.cs

@@ -0,0 +1,28 @@
+using Content.Server.Power.EntitySystems;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Power.Components
+{
+    [RegisterComponent]
+    [Friend(typeof(ExtensionCableSystem))]
+    public class ExtensionCableReceiverComponent : Component
+    {
+        public override string Name => "ExtensionCableReceiver";
+
+        [ViewVariables]
+        public ExtensionCableProviderComponent? Provider { get; set; }
+
+        [ViewVariables]
+        public bool Connectable = false;
+
+        /// <summary>
+        ///     The max distance from a <see cref="ExtensionCableProviderComponent"/> that this can receive power from.
+        /// </summary>
+        [ViewVariables(VVAccess.ReadWrite)]
+        [DataField("receptionRange")]
+        public int ReceptionRange { get; set; } = 3;
+    }
+}

Content.Server/Power/EntitySystems/ExtensionCableSystem.cs

@@ -0,0 +1,256 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Content.Server.Power.Components;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Physics;
+
+namespace Content.Server.Power.EntitySystems
+{
+    public sealed class ExtensionCableSystem : EntitySystem
+    {
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            //Lifecycle events
+            SubscribeLocalEvent<ExtensionCableProviderComponent, ComponentStartup>(OnProviderStarted);
+            SubscribeLocalEvent<ExtensionCableProviderComponent, ComponentShutdown>(OnProviderShutdown);
+            SubscribeLocalEvent<ExtensionCableReceiverComponent, ComponentStartup>(OnReceiverStarted);
+            SubscribeLocalEvent<ExtensionCableReceiverComponent, ComponentShutdown>(OnReceiverShutdown);
+
+            //Anchoring
+            SubscribeLocalEvent<ExtensionCableReceiverComponent, AnchorStateChangedEvent>(AnchorStateChanged);
+        }
+
+        #region Provider
+
+        public void SetProviderTransferRange(EntityUid uid, int range, ExtensionCableProviderComponent? provider = null)
+        {
+            if (!Resolve(uid, ref provider))
+                return;
+
+            provider.TransferRange = range;
+            ResetReceivers(provider);
+        }
+
+        private void OnProviderStarted(EntityUid uid, ExtensionCableProviderComponent provider, ComponentStartup args)
+        {
+            foreach (var receiver in FindAvailableReceivers(uid, provider.TransferRange))
+            {
+                receiver.Provider?.LinkedReceivers.Remove(receiver);
+                receiver.Provider = provider;
+                provider.LinkedReceivers.Add(receiver);
+                RaiseLocalEvent(receiver.Owner.Uid, new ProviderConnectedEvent(provider), broadcast: false);
+                RaiseLocalEvent(uid, new ReceiverConnectedEvent(receiver), broadcast: false);
+            }
+        }
+
+        private void OnProviderShutdown(EntityUid uid, ExtensionCableProviderComponent provider, ComponentShutdown args)
+        {
+            provider.Connectable = false;
+            ResetReceivers(provider);
+        }
+
+        private void ResetReceivers(ExtensionCableProviderComponent provider)
+        {
+            var receivers = provider.LinkedReceivers.ToArray();
+
+            foreach (var receiver in receivers)
+            {
+                receiver.Provider = null;
+                RaiseLocalEvent(receiver.Owner.Uid, new ProviderDisconnectedEvent(provider), broadcast: false);
+                RaiseLocalEvent(provider.Owner.Uid, new ReceiverDisconnectedEvent(receiver), broadcast: false);
+            }
+
+            foreach (var receiver in receivers)
+            {
+                TryFindAndSetProvider(receiver);
+            }
+        }
+
+        private IEnumerable<ExtensionCableReceiverComponent> FindAvailableReceivers(EntityUid uid, float range)
+        {
+            var owner = EntityManager.GetEntity(uid);
+
+            var nearbyEntities = IoCManager.Resolve<IEntityLookup>()
+                .GetEntitiesInRange(owner, range);
+
+            foreach (var entity in nearbyEntities)
+            {
+                if (entity.TryGetComponent<ExtensionCableReceiverComponent>(out var receiver) &&
+                    receiver.Connectable &&
+                    receiver.Provider == null &&
+                    entity.Transform.Coordinates.TryDistance(owner.EntityManager, owner.Transform.Coordinates, out var distance) &&
+                    distance < Math.Min(range, receiver.ReceptionRange))
+                {
+                    yield return receiver;
+                }
+            }
+        }
+
+        #endregion
+
+        #region Receiver
+
+        public void SetReceiverReceptionRange(EntityUid uid, int range, ExtensionCableReceiverComponent? receiver = null)
+        {
+            if (!Resolve(uid, ref receiver))
+                return;
+
+            var provider = receiver.Provider;
+            receiver.Provider = null;
+            RaiseLocalEvent(uid, new ProviderDisconnectedEvent(provider), broadcast: false);
+
+            if (provider != null)
+                RaiseLocalEvent(provider.Owner.Uid, new ReceiverDisconnectedEvent(receiver), broadcast: false);
+
+            receiver.ReceptionRange = range;
+            TryFindAndSetProvider(receiver);
+        }
+
+        private void OnReceiverStarted(EntityUid uid, ExtensionCableReceiverComponent receiver, ComponentStartup args)
+        {
+            if (receiver.Owner.TryGetComponent(out PhysicsComponent? physicsComponent))
+            {
+                receiver.Connectable = physicsComponent.BodyType == BodyType.Static;
+            }
+
+            if (receiver.Provider == null)
+            {
+                TryFindAndSetProvider(receiver);
+            }
+        }
+
+        private void OnReceiverShutdown(EntityUid uid, ExtensionCableReceiverComponent receiver, ComponentShutdown args)
+        {
+            if (receiver.Provider == null) return;
+
+            receiver.Provider.LinkedReceivers.Remove(receiver);
+            RaiseLocalEvent(uid, new ProviderDisconnectedEvent(receiver.Provider), broadcast: false);
+            RaiseLocalEvent(receiver.Provider.Owner.Uid, new ReceiverDisconnectedEvent(receiver), broadcast: false);
+        }
+
+        private void AnchorStateChanged(EntityUid uid, ExtensionCableReceiverComponent receiver, ref AnchorStateChangedEvent args)
+        {
+            if (args.Anchored)
+            {
+                receiver.Connectable = true;
+                if (receiver.Provider == null)
+                {
+                    TryFindAndSetProvider(receiver);
+                }
+            }
+            else
+            {
+                receiver.Connectable = false;
+                RaiseLocalEvent(uid, new ProviderDisconnectedEvent(receiver.Provider), broadcast: false);
+
+                if (receiver.Provider != null)
+                    RaiseLocalEvent(receiver.Provider.Owner.Uid, new ReceiverDisconnectedEvent(receiver), broadcast: false);
+
+                receiver.Provider = null;
+            }
+        }
+
+        private void TryFindAndSetProvider(ExtensionCableReceiverComponent receiver)
+        {
+            if (!TryFindAvailableProvider(receiver.Owner, receiver.ReceptionRange, out var provider)) return;
+
+            receiver.Provider = provider;
+            RaiseLocalEvent(receiver.Owner.Uid, new ProviderConnectedEvent(provider), broadcast: false);
+            RaiseLocalEvent(provider.Owner.Uid, new ReceiverConnectedEvent(receiver), broadcast: false);
+        }
+
+        private static bool TryFindAvailableProvider(IEntity owner, float range, [NotNullWhen(true)] out ExtensionCableProviderComponent? foundProvider)
+        {
+            var nearbyEntities = IoCManager.Resolve<IEntityLookup>()
+                .GetEntitiesInRange(owner, range);
+
+            foreach (var entity in nearbyEntities)
+            {
+                if (!entity.TryGetComponent<ExtensionCableProviderComponent>(out var provider)) continue;
+
+                if (!provider.Connectable) continue;
+
+                if (!entity.Transform.Coordinates.TryDistance(owner.EntityManager, owner.Transform.Coordinates, out var distance)) continue;
+
+                if (!(distance < Math.Min(range, provider.TransferRange))) continue;
+
+                foundProvider = provider;
+                return true;
+            }
+
+            foundProvider = default;
+            return false;
+        }
+
+        #endregion
+
+        #region Events
+
+        /// <summary>
+        /// Sent when a <see cref="ExtensionCableProviderComponent"/> connects to a <see cref="ExtensionCableReceiverComponent"/>
+        /// </summary>
+        public class ProviderConnectedEvent : EntityEventArgs
+        {
+            /// <summary>
+            /// The <see cref="ExtensionCableProviderComponent"/> that connected.
+            /// </summary>
+            public ExtensionCableProviderComponent Provider;
+
+            public ProviderConnectedEvent(ExtensionCableProviderComponent provider)
+            {
+                Provider = provider;
+            }
+        }
+        /// <summary>
+        /// Sent when a <see cref="ExtensionCableProviderComponent"/> disconnects from a <see cref="ExtensionCableReceiverComponent"/>
+        /// </summary>
+        public class ProviderDisconnectedEvent : EntityEventArgs
+        {
+            /// <summary>
+            /// The <see cref="ExtensionCableProviderComponent"/> that disconnected.
+            /// </summary>
+            public ExtensionCableProviderComponent? Provider;
+
+            public ProviderDisconnectedEvent(ExtensionCableProviderComponent? provider)
+            {
+                Provider = provider;
+            }
+        }
+        /// <summary>
+        /// Sent when a <see cref="ExtensionCableReceiverComponent"/> connects to a <see cref="ExtensionCableProviderComponent"/>
+        /// </summary>
+        public class ReceiverConnectedEvent : EntityEventArgs
+        {
+            /// <summary>
+            /// The <see cref="ExtensionCableReceiverComponent"/> that connected.
+            /// </summary>
+            public ExtensionCableReceiverComponent Receiver;
+
+            public ReceiverConnectedEvent(ExtensionCableReceiverComponent receiver)
+            {
+                Receiver = receiver;
+            }
+        }
+        /// <summary>
+        /// Sent when a <see cref="ExtensionCableReceiverComponent"/> disconnects from a <see cref="ExtensionCableProviderComponent"/>
+        /// </summary>
+        public class ReceiverDisconnectedEvent : EntityEventArgs
+        {
+            /// <summary>
+            /// The <see cref="ExtensionCableReceiverComponent"/> that disconnected.
+            /// </summary>
+            public ExtensionCableReceiverComponent Receiver;
+
+            public ReceiverDisconnectedEvent(ExtensionCableReceiverComponent receiver)
+            {
+                Receiver = receiver;
+            }
+        }
+
+        #endregion
+    }
+}

Content.Server/Power/EntitySystems/PowerReceiverSystem.cs

@@ -9,15 +9,43 @@ namespace Content.Server.Power.EntitySystems
         {
             base.Initialize();
 
-            SubscribeLocalEvent<ApcPowerReceiverComponent, PhysicsBodyTypeChangedEvent>(BodyTypeChanged);
+            SubscribeLocalEvent<ApcPowerReceiverComponent, ExtensionCableSystem.ProviderConnectedEvent>(OnProviderConnected);
+            SubscribeLocalEvent<ApcPowerReceiverComponent, ExtensionCableSystem.ProviderDisconnectedEvent>(OnProviderDisconnected);
+
+            SubscribeLocalEvent<ApcPowerProviderComponent, ExtensionCableSystem.ReceiverConnectedEvent>(OnReceiverConnected);
+            SubscribeLocalEvent<ApcPowerProviderComponent, ExtensionCableSystem.ReceiverDisconnectedEvent>(OnReceiverDisconnected);
         }
 
-        private static void BodyTypeChanged(
-            EntityUid uid,
-            ApcPowerReceiverComponent component,
-            PhysicsBodyTypeChangedEvent args)
+        private void OnProviderConnected(EntityUid uid, ApcPowerReceiverComponent receiver, ExtensionCableSystem.ProviderConnectedEvent args)
         {
-            component.AnchorUpdate();
+            ProviderChanged(receiver);
+        }
+
+        private void OnProviderDisconnected(EntityUid uid, ApcPowerReceiverComponent receiver, ExtensionCableSystem.ProviderDisconnectedEvent args)
+        {
+            ProviderChanged(receiver);
+        }
+
+        private void OnReceiverConnected(EntityUid uid, ApcPowerProviderComponent provider, ExtensionCableSystem.ReceiverConnectedEvent args)
+        {
+            if (EntityManager.TryGetComponent(args.Receiver.Owner.Uid, out ApcPowerReceiverComponent receiver))
+            {
+                provider.AddReceiver(receiver);
+            }
+        }
+
+        private void OnReceiverDisconnected(EntityUid uid, ApcPowerProviderComponent provider, ExtensionCableSystem.ReceiverDisconnectedEvent args)
+        {
+            if (EntityManager.TryGetComponent(args.Receiver.Owner.Uid, out ApcPowerReceiverComponent receiver))
+            {
+                provider.RemoveReceiver(receiver);
+            }
+        }
+
+        private static void ProviderChanged(ApcPowerReceiverComponent receiver)
+        {
+            receiver.NetworkLoad.LinkedNetwork = default;
+            receiver.ApcPowerChanged();
         }
     }
 }