machine linking refactor to ecs (#4323)

* started work

* some more work, ui working (somewhat)

* stuff

* reorganization

* some more reorg

* conveyors

* conveyors working

* finalized (dis)connection
added linkattempt
added feedback text
work on conveyors

* removed command
add rangecheck

* fixed inrange check

* handling

* ui no longer kanser, ship it

* adresses reviews

* reformats file

* reformats file

Co-authored-by: Paul <ritter.paul1+git@googlemail.com>

Content.Server/MachineLinking/Models/SignalLink.cs

@@ -0,0 +1,20 @@
+using Content.Server.MachineLinking.Components;
+
+namespace Content.Server.MachineLinking.Models
+{
+    public class SignalLink
+    {
+        public readonly SignalTransmitterComponent TransmitterComponent;
+        public readonly SignalReceiverComponent ReceiverComponent;
+        public readonly SignalPort Transmitterport;
+        public readonly SignalPort Receiverport;
+
+        public SignalLink(SignalTransmitterComponent transmitterComponent, string transmitterPort, SignalReceiverComponent receiverComponent, string receiverPort)
+        {
+            TransmitterComponent = transmitterComponent;
+            ReceiverComponent = receiverComponent;
+            Transmitterport = TransmitterComponent.Outputs.GetPort(transmitterPort);
+            Receiverport = ReceiverComponent.Inputs.GetPort(receiverPort);
+        }
+    }
+}

Content.Server/MachineLinking/Models/SignalLinkCollection.cs

@@ -0,0 +1,131 @@
+using System.Collections.Generic;
+using Content.Server.MachineLinking.Components;
+using Content.Server.MachineLinking.Exceptions;
+
+namespace Content.Server.MachineLinking.Models
+{
+    public class SignalLinkCollection
+    {
+        private Dictionary<SignalTransmitterComponent, List<SignalLink>> _transmitterDict = new();
+        private Dictionary<SignalReceiverComponent, List<SignalLink>> _receiverDict = new();
+
+        public SignalLink AddLink(SignalTransmitterComponent transmitterComponent, string transmitterPort,
+            SignalReceiverComponent receiverComponent, string receiverPort)
+        {
+            if (LinkExists(transmitterComponent, transmitterPort, receiverComponent, receiverPort))
+            {
+                throw new LinkAlreadyRegisteredException();
+            }
+
+            if (!_transmitterDict.ContainsKey(transmitterComponent))
+            {
+                _transmitterDict[transmitterComponent] = new();
+            }
+
+            if (!_receiverDict.ContainsKey(receiverComponent))
+            {
+                _receiverDict[receiverComponent] = new();
+            }
+
+            var link = new SignalLink(transmitterComponent, transmitterPort, receiverComponent, receiverPort);
+            _transmitterDict[transmitterComponent].Add(link);
+            _receiverDict[receiverComponent].Add(link);
+
+            return link;
+        }
+
+        public bool LinkExists(SignalTransmitterComponent transmitterComponent, string transmitterPort,
+            SignalReceiverComponent receiverComponent, string receiverPort)
+        {
+            if (!_transmitterDict.ContainsKey(transmitterComponent) || !_receiverDict.ContainsKey(receiverComponent))
+            {
+                return false;
+            }
+
+            foreach (var link in _transmitterDict[transmitterComponent])
+            {
+                if (link.Transmitterport.Name == transmitterPort && link.Receiverport.Name == receiverPort &&
+                    link.ReceiverComponent == receiverComponent)
+                    return true;
+            }
+
+            return false;
+        }
+
+        public bool RemoveLink(SignalTransmitterComponent transmitterComponent, string transmitterPort,
+            SignalReceiverComponent receiverComponent, string receiverPort)
+        {
+            if (!_transmitterDict.ContainsKey(transmitterComponent) || !_receiverDict.ContainsKey(receiverComponent))
+            {
+                return false;
+            }
+
+            SignalLink? theLink = null;
+            foreach (var link in _transmitterDict[transmitterComponent])
+            {
+                if (link.Transmitterport.Name == transmitterPort && link.Receiverport.Name == receiverPort &&
+                    link.ReceiverComponent == receiverComponent)
+                {
+                    theLink = link;
+                    break;
+                }
+            }
+
+            if (theLink == null) return false;
+
+            _transmitterDict[transmitterComponent].Remove(theLink);
+            if (_transmitterDict[transmitterComponent].Count == 0) _transmitterDict.Remove(transmitterComponent);
+            _receiverDict[receiverComponent].Remove(theLink);
+            if (_receiverDict[receiverComponent].Count == 0) _receiverDict.Remove(receiverComponent);
+            return true;
+        }
+
+        public int LinkCount(SignalTransmitterComponent comp) =>
+            _transmitterDict.ContainsKey(comp) ? _transmitterDict[comp].Count : 0;
+
+        public int LinkCount(SignalReceiverComponent comp) =>
+            _receiverDict.ContainsKey(comp) ? _receiverDict[comp].Count : 0;
+
+        public void RemoveLinks(SignalTransmitterComponent component)
+        {
+            if (!_transmitterDict.ContainsKey(component))
+            {
+                return;
+            }
+
+            foreach (var link in _transmitterDict[component])
+            {
+                _receiverDict[link.ReceiverComponent].Remove(link);
+                if (_receiverDict[link.ReceiverComponent].Count == 0) _receiverDict.Remove(link.ReceiverComponent);
+            }
+
+            _transmitterDict.Remove(component);
+        }
+
+        public void RemoveLinks(SignalReceiverComponent component)
+        {
+            if (!_receiverDict.ContainsKey(component))
+            {
+                return;
+            }
+
+            foreach (var link in _receiverDict[component])
+            {
+                _transmitterDict[link.TransmitterComponent].Remove(link);
+                if (_transmitterDict[link.TransmitterComponent].Count == 0)
+                    _transmitterDict.Remove(link.TransmitterComponent);
+            }
+        }
+
+        public IEnumerable<SignalLink> GetLinks(SignalTransmitterComponent component, string port)
+        {
+            if (!_transmitterDict.ContainsKey(component)) yield break;
+
+            foreach (var link in _transmitterDict[component])
+            {
+                if (link.Transmitterport.Name != port) continue;
+                yield return link;
+            }
+        }
+    }
+}

Content.Server/MachineLinking/Models/SignalPort.cs

@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Content.Server.MachineLinking.Events;
+using Content.Server.MachineLinking.Exceptions;
+using Robust.Shared.Serialization.Manager.Attributes;
+
+namespace Content.Server.MachineLinking.Models
+{
+    [DataDefinition]
+    public class SignalPort
+    {
+        [DataField("name", required: true)] public string Name { get; } = default!;
+        [DataField("type")] public Type? Type { get; }
+        /// <summary>
+        /// Maximum connections of the port. 0 means infinite.
+        /// </summary>
+        [DataField("maxConnections")] public int MaxConnections { get; } = 0;
+
+        public object? Signal;
+    }
+
+    public static class PortPrototypeExtensions{
+        public static bool ContainsPort(this IReadOnlyList<SignalPort> ports, string port)
+        {
+            foreach (var portPrototype in ports)
+            {
+                if (portPrototype.Name == port)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public static IEnumerable<string> GetPortStrings(this IReadOnlyList<SignalPort> ports)
+        {
+            foreach (var portPrototype in ports)
+            {
+                yield return portPrototype.Name;
+            }
+        }
+
+        public static IEnumerable<KeyValuePair<string, bool>> GetValidatedPorts(this IReadOnlyList<SignalPort> ports, Type? validType)
+        {
+            foreach (var portPrototype in ports)
+            {
+                yield return new KeyValuePair<string, bool>(portPrototype.Name, portPrototype.Type == validType);
+            }
+        }
+
+        public static bool TryGetPort(this IReadOnlyList<SignalPort> ports, string name, [NotNullWhen(true)] out SignalPort? port)
+        {
+            foreach (var portPrototype in ports)
+            {
+                if (portPrototype.Name == name)
+                {
+                    port = portPrototype;
+                    return true;
+                }
+            }
+
+            port = null;
+            return false;
+        }
+
+        public static SignalPort GetPort(this IReadOnlyList<SignalPort> ports, string name)
+        {
+            foreach (var portPrototype in ports)
+            {
+                if (portPrototype.Name == name)
+                {
+                    return portPrototype;
+                }
+            }
+
+            throw new PortNotFoundException();
+        }
+    }
+}