Upgrade structure of code base

src/Enigmos/Boards/IBaseBoard.cs

@@ -1,5 +1,4 @@
 using Nocturnis.Enigmos.Cables;
-using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.UIElements.Layers;
 
@@ -13,6 +12,7 @@ public interface IBaseBoard
     HashSet<IBaseCable> FocusedCables { get; set; }
     bool ManualOpened { get; set; }
     bool CableVisualMode { get; set; }
-    IModuleManualLayer ModuleManualLayer { get; set; }
-    IModuleMovingLayer ModuleMovingLayer { get; set; }
+    IModuleManualLayer? ModuleManualLayer { get; set; }
+    IModuleMovingLayer? ModuleMovingLayer { get; set; }
+    void Reset();
 }

src/Enigmos/Cables/IBaseCable.cs

@@ -1,4 +1,5 @@
 using Godot;
+using Nocturnis.Enigmos.Ports;
 
 namespace Nocturnis.Enigmos.Cables;
 
@@ -8,4 +9,6 @@ public interface IBaseCable
     void LineUpdate();
     Color Modulate { get; set; }
     Node AsNode { get; }
+    IBasePort PortFrom { get; set; }
+    IBasePort PortTo { get; set; }
 }

src/Enigmos/Modules/ComputationalModules/EBinaryComputationalModule.cs

@@ -0,0 +1,17 @@
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Skeleton.DataStructure;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public static class EBinaryComputationalModule
+{
+    public static IData X(this IBinaryComputationalModule p, CacheItem x) => p.DataInPorts[0].GetData.GetFrom(x)!;
+    public static IData Y(this IBinaryComputationalModule p, CacheItem x) => p.DataInPorts[1].GetData.GetFrom(x)!;
+
+    public static void BinaryInit(this IBinaryComputationalModule p)
+    {
+        p.DataInPorts = new IDataInPort[2];
+        p.DataInInit("Input", 2);
+    }
+}

src/Enigmos/Modules/ComputationalModules/EComputationalModule.cs

@@ -0,0 +1,13 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public static class EComputationalModule
+{
+    public static void DataOutInit(this IComputationalModule a, string prefix, int dI)
+    {
+        a.DataOutPorts = new IDataOutPort[dI];
+        for (int i = 1; i <= dI; i++)
+            a.DataOutPorts[i - 1] = a.GetPort<IDataOutPort>($"{prefix}{i}");
+    }
+}

src/Enigmos/Modules/ComputationalModules/EDuplicateOutputModule.cs

@@ -0,0 +1,20 @@
+using Godot;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Skeleton.DataStructure;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public static class EDuplicateOutputModule
+{
+    public static void Define(this IDuplicateOutputModule m, Func<CacheItem, (object, StringName)> define)
+    {
+        foreach (IDataOutPort op in m.DataOutPorts)
+            op.OutData.UpdateCalculation(define);
+    }
+
+    public static void SetOutputType(this IDuplicateOutputModule m, StringName type)
+    {
+        foreach (IDataOutPort op in m.DataOutPorts)
+            op.SetDataType(type);
+    }
+}

src/Enigmos/Modules/ComputationalModules/ELogicModule.cs

@@ -0,0 +1,15 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Nocturnis.GlobalManagement.Constants;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public static class ELogicModule
+{
+    public static void LogicModuleInit(this ILogicModule lm)
+    {
+        foreach (IDataOutPort op in lm.DataOutPorts)
+            op.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        foreach (IDataInPort ip in lm.DataInPorts)
+            ip.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+    }
+}

src/Enigmos/Modules/ComputationalModules/EOperationModule.cs

@@ -0,0 +1,13 @@
+using Godot;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public static class EOperationModule
+{
+    public static void SetInputType(this IOperationModule m, StringName type)
+    {
+        foreach (IDataInPort ip in m.DataInPorts)
+            ip.SetDataType(type);
+    }
+}

src/Enigmos/Modules/ComputationalModules/ETernaryComputationalModule.cs

@@ -0,0 +1,14 @@
+using Nocturnis.DataStructures;
+using Skeleton.DataStructure;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public static class ETernaryComputationalModule
+{
+    public static IData X(this ITernaryComputationalModule m, CacheItem cache) =>
+        m.DataOutPorts[0].OutData.GetFrom(cache)!;
+    public static IData Y(this ITernaryComputationalModule m, CacheItem cache) =>
+        m.DataOutPorts[1].OutData.GetFrom(cache)!;
+    public static IData Z(this ITernaryComputationalModule m, CacheItem cache) =>
+        m.DataOutPorts[2].OutData.GetFrom(cache)!;
+}

src/Enigmos/Modules/ComputationalModules/EUnaryComputationalModule.cs

@@ -0,0 +1,10 @@
+using Nocturnis.DataStructures;
+using Skeleton.DataStructure;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public static class EUnaryComputationalModule
+{
+    public static IData X(this IUnaryComputationalModule m, CacheItem cache) =>
+        m.DataOutPorts[0].OutData.GetFrom(cache)!;
+}

src/Enigmos/Modules/ComputationalModules/IBinaryComputationalModule.cs

@@ -0,0 +1,6 @@
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public interface IBinaryComputationalModule : IComputationalModule, IParameterModule
+{
+
+}

src/Enigmos/Modules/ComputationalModules/IComputationalModule.cs

@@ -0,0 +1,9 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public interface IComputationalModule : IBaseModule
+{
+    IDataOutPort[] DataOutPorts { get; set; }
+    void Define();
+}

src/Enigmos/Modules/ComputationalModules/IDuplicateOutputModule.cs

@@ -0,0 +1,6 @@
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public interface IDuplicateOutputModule : IComputationalModule
+{
+    
+}

src/Enigmos/Modules/ComputationalModules/IOperationModule.cs

@@ -0,0 +1,6 @@
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public interface IOperationModule : IParameterModule
+{
+    
+}

src/Enigmos/Modules/ComputationalModules/ITernaryComputationalModule.cs

@@ -0,0 +1,6 @@
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public interface ITernaryComputationalModule: IParameterModule, IComputationalModule
+{
+    
+}

src/Enigmos/Modules/ComputationalModules/IUnaryComputationalModule.cs

@@ -0,0 +1,6 @@
+namespace Nocturnis.Enigmos.Modules.ComputationalModules;
+
+public interface IUnaryComputationalModule: IComputationalModule, IOperationModule
+{
+    
+}

src/Enigmos/Modules/EBaseModule.cs

@@ -0,0 +1,19 @@
+using Godot;
+using Nocturnis.Enigmos.Ports;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public static class EBaseModule
+{
+    public static TPort GetPort<TPort>(this IBaseModule m, NodePath path)
+        where TPort : IBasePort
+    {
+        if (m.GetNode(path) is TPort port)
+        {
+            port.Init();
+            return port;
+        }
+
+        throw new Exception("NOT A PORT");
+    }
+}

src/Enigmos/Modules/ECommunicateModule.cs

@@ -0,0 +1,62 @@
+using Nocturnis.Communicators;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Controls;
+using Nocturnis.GlobalManagement.Providers;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public static class ECommunicateModule
+{
+    public static bool Paired(this ICommunicateModule module) => module.PairedCommunicator != null;
+
+    /// <summary>
+    /// Determine if the module can be paired with given communicator
+    /// </summary>
+    public static bool IsMatch(this ICommunicateModule module, IBaseCommunicator communicator) =>
+        module.CommunicationDataType == communicator.CommunicationDataType &&
+        GlobalProvider.EnigmosProvider!.CommunicationDirectionCompatible(
+            module.CommunicationDirection,
+            communicator.CommunicationDirection
+        );
+    /// <summary>
+    /// Pair the module with given communicator
+    /// </summary>
+    public static void Pair(this ICommunicateModule module, IBaseCommunicator communicator)
+    {
+        if(module.Paired())
+            module.Unpair();
+        module.PairedCommunicator = communicator;
+        communicator.PairedModule = module;
+    }
+
+    /// <summary>
+    /// Unpair the module with its paired communicator
+    /// </summary>
+    public static void Unpair(this ICommunicateModule module)
+    {
+        if (!module.Paired())
+            return;
+        module.PairedCommunicator!.PairedModule = null;
+        module.PairedCommunicator = null;
+    }
+
+    public static void SendData(this ICommunicateModule module)
+    {
+        if (!module.Paired() || module.CommunicationDirection == EnigmosConstant.CommunicationDirections.Receive)
+            return;
+        module.PairedCommunicator!.DataBuffer.Assign(module.DataBuffer, module.CommunicationDataType);
+    }
+    
+
+    public static void ReceiveData(this ICommunicateModule module)
+    {
+        if (!module.Paired() || module.CommunicationDirection == EnigmosConstant.CommunicationDirections.Send)
+            return;
+        module.DataBuffer.Assign(module.PairedCommunicator!.DataBuffer, module.CommunicationDataType);
+    }
+
+    public static IBaseCommunicator[] CompatibleCommunicators(this ICommunicateModule module) =>
+        CreatureControl.Instance.CurrentCharacter!.DashboardTab.AllCommunicators
+            .Where(module.IsMatch)
+            .ToArray();
+}

src/Enigmos/Modules/EControllingModule.cs

@@ -0,0 +1,13 @@
+using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public static class EControllingModule
+{
+    public static void SignalInInit(this IControllingModule m, string prefix, int sI)
+    {
+        m.SignalInPorts = new ISignalInPort[sI];
+        for (int i = 1; i <= sI; i++)
+            m.SignalInPorts[i - 1] = m.GetPort<ISignalInPort>($"{prefix}{i}");
+    }
+}

src/Enigmos/Modules/EParameterModule.cs

@@ -0,0 +1,13 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public static class EParameterModule
+{
+    public static void DataInInit(this IParameterModule m, string prefix, int dI)
+    {
+        m.DataInPorts = new IDataInPort[dI];
+        for (int i = 1; i <= dI; i++)
+            m.DataInPorts[i - 1] = m.GetPort<IDataInPort>($"{prefix}{i}");
+    }
+}

src/Enigmos/Modules/ERoutingModule.cs

@@ -0,0 +1,13 @@
+using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public static class ERoutingModule
+{
+    public static void SignalOutInit(this IRoutingModule m, string prefix, int sO)
+    {
+        m.SignalOutPorts = new ISignalOutPort[sO];
+        for (int i = 1; i <= sO; i++)
+            m.SignalOutPorts[i - 1] = m.GetPort<ISignalOutPort>($"{prefix}{i}");
+    }
+}

src/Enigmos/Modules/ESourceModule.cs

@@ -0,0 +1,12 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public static class ESourceModule
+{
+    public static void Reset(this ISourceModule m)
+    {
+        foreach (IDataOutPort port in m.DataOutPorts)
+            port.OutData.Expire();
+    }
+}

src/Enigmos/Modules/ETerminalModule.cs

@@ -0,0 +1,14 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public static class ETerminalModule
+{
+    public static void Consume(this ITerminalModule m)
+    {
+        foreach (IDataInPort ip in m.DataInPorts)
+            if(ip.GetData.Expired)
+                _ = ip.GetData.Get;
+        
+    }
+}

src/Enigmos/Modules/IActionModule.cs

@@ -0,0 +1,6 @@
+namespace Nocturnis.Enigmos.Modules;
+
+public interface IActionModule : IControllingModule
+{
+    void Act();
+}

src/Enigmos/Modules/IBaseModule.cs

@@ -8,16 +8,19 @@ namespace Nocturnis.Enigmos.Modules;
 public interface IBaseModule
 {
     IEnumerable<IBasePort> Ports { get; }
-    IBaseBoard Board { get; set; }
+    IBaseBoard? Board { get; set; }
     Vector2 PositionToBoard { get; }
     Vector2 Size { get; set; }
     double MaintenanceAlpha { get; }
     double MaintenanceBeta { get; }
     string GetDescription { get; }
-    ISimpleLabel Label { get; }
+    ISimpleLabel? Label { get; }
     Node AsNode { get; }
     Vector2 Position { get; set; }
     string LabelString { get; set; }
     void UpdateCables();
-
-}
+    //T GetPort<T>(NodePath path);
+    Node GetNode(NodePath path);
+    void Init();
+    
+}

src/Enigmos/Modules/ICommunicateModule.cs

@@ -4,10 +4,10 @@ using Nocturnis.DataStructures;
 
 namespace Nocturnis.Enigmos.Modules;
 
-public interface ICommunicateModule
+public interface ICommunicateModule : IBaseModule
 {
-    IBaseCommunicator PairedCommunicator { get; set; }
+    IBaseCommunicator? PairedCommunicator { get; set; }
     StringName CommunicationDataType { get; }
     StringName CommunicationDirection { get; }
-    IDataPackage DataBuffer { get; set; }
+    IData DataBuffer { get; set; }
 }

src/Enigmos/Modules/IComputationalCompositeModule.cs

@@ -4,6 +4,5 @@ namespace Nocturnis.Enigmos.Modules;
 
 public interface IComputationalCompositeModule : ICompositeModule
 {
-    void Compute(IRootModule root);
     Vector2 PositionToBoard { get; }
 }

src/Enigmos/Modules/IControllingModule.cs

@@ -1,6 +1,10 @@
+using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+
 namespace Nocturnis.Enigmos.Modules;
 
 public interface IControllingModule : IBaseModule
 {
-    void RouteWithTimeoutHandle(IRootModule root);
-}
+    ISignalInPort[] SignalInPorts { get; set; }
+    void Execute();
+    bool Visited { get; set; }
+}

src/Enigmos/Modules/IFilterModule.cs

@@ -1,6 +1,10 @@
+using Nocturnis.DataStructures;
+
 namespace Nocturnis.Enigmos.Modules;
 
 public interface IFilterModule : IProgrammableModule
 {
-    void FilterWithTimeoutHandle(IRootModule root);
-}
+    void Filter();
+    IData[] CachedResult { get; set; }
+    
+}

src/Enigmos/Modules/IInterlayerDataInModule.cs

@@ -1,9 +0,0 @@
-using Nocturnis.Enigmos.Ports;
-
-namespace Nocturnis.Enigmos.Modules;
-
-public interface IInterlayerDataInModule : IInterlayerModule
-{
-    IInterlayerDataOutModule? DualModule { get; set; }
-    IDataInPort? DataIn { get; set; }
-}

src/Enigmos/Modules/IInterlayerDataOutModule.cs

@@ -1,9 +0,0 @@
-using Nocturnis.Enigmos.Ports;
-
-namespace Nocturnis.Enigmos.Modules;
-
-public interface IInterlayerDataOutModule : IInterlayerModule
-{
-    IInterlayerDataInModule? DualModule { get; set; }
-    IDataOutPort? DataOut { get; set; }
-}

src/Enigmos/Modules/IInterlayerSignalInModule.cs

@@ -1,9 +0,0 @@
-using Nocturnis.Enigmos.Ports;
-
-namespace Nocturnis.Enigmos.Modules;
-
-public interface IInterlayerSignalInModule : IInterlayerModule
-{
-    IInterlayerSignalOutModule? DualModule { get; set; }
-    ISignalInPort? SignalIn { get; set; }
-}

src/Enigmos/Modules/IInterlayerSignalOutModule.cs

@@ -1,9 +0,0 @@
-using Nocturnis.Enigmos.Ports;
-
-namespace Nocturnis.Enigmos.Modules;
-
-public interface IInterlayerSignalOutModule : IInterlayerModule
-{
-    IInterlayerSignalInModule? DualModule { get; set; }
-    ISignalOutPort? SignalOut { get; set; }
-}

src/Enigmos/Modules/ILogicModule.cs

@@ -0,0 +1,8 @@
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public interface ILogicModule : IComputationalModule, IParameterModule
+{
+    
+}

src/Enigmos/Modules/IOptimizationModule.cs

@@ -1,6 +1,10 @@
+using Nocturnis.DataStructures;
+
 namespace Nocturnis.Enigmos.Modules;
 
 public interface IOptimizationModule : IProgrammableModule
 {
-    void OptimizeWithTimeoutHandle(IRootModule root);
-}
+    IData CachedResult { get; set; }
+    bool Calculated { get; set; }
+    void Optimize();
+}

src/Enigmos/Modules/IParameterModule.cs

@@ -0,0 +1,8 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public interface IParameterModule : IBaseModule
+{
+    IDataInPort[] DataInPorts { get; set; }
+}

src/Enigmos/Modules/IParameterizedModule.cs

@@ -1,4 +1,3 @@
-using Nocturnis.DataStructures;
 using Nocturnis.DataStructures.ConfigurableParameters;
 
 namespace Nocturnis.Enigmos.Modules;

src/Enigmos/Modules/IPolymorphismModule.cs

@@ -1,4 +1,4 @@
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 
 namespace Nocturnis.Enigmos.Modules;
 

src/Enigmos/Modules/IProgrammableModule.cs

@@ -1,5 +1,3 @@
-using Godot;
-
 namespace Nocturnis.Enigmos.Modules;
 
 public interface IProgrammableModule : IBaseModule

src/Enigmos/Modules/IRootModule.cs

@@ -3,10 +3,11 @@ using Nocturnis.Creatures;
 
 namespace Nocturnis.Enigmos.Modules;
 
-public interface IRootModule : IControllingModule
+public interface IRootModule : IRoutingModule
 {
     Stopwatch? Timer { get; set; }
     bool ActionFinished { get; set; }
-    IBaseCreature ManagedBy { get; set; }
+    IBaseCreature? ManagedBy { get; set; }
+    void Start();
 
 }

src/Enigmos/Modules/IRoutingModule.cs

@@ -0,0 +1,9 @@
+using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public interface IRoutingModule : IBaseModule
+{
+    ISignalOutPort[] SignalOutPorts { get; set; }
+    
+}

src/Enigmos/Modules/ISourceModule.cs

@@ -0,0 +1,8 @@
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+
+namespace Nocturnis.Enigmos.Modules;
+
+public interface ISourceModule : IComputationalModule
+{
+    
+}

src/Enigmos/Modules/ITerminalModule.cs

@@ -0,0 +1,7 @@
+namespace Nocturnis.Enigmos.Modules;
+
+public interface ITerminalModule : IParameterModule
+{
+    void Drain();
+}
+

src/Enigmos/Modules/InterlayerModules/IInterlayerDataInModule.cs

@@ -0,0 +1,11 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules.InterlayerModules;
+
+public interface IInterlayerDataInModule : IInterlayerModule, IParameterModule
+{
+    new IInterlayerDataOutModule? DualModule { get; set; }
+    IDataInPort? DataIn { get; set; }
+
+}
+

src/Enigmos/Modules/InterlayerModules/IInterlayerDataOutModule.cs

@@ -0,0 +1,11 @@
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules.InterlayerModules;
+
+public interface IInterlayerDataOutModule : IInterlayerModule, IComputationalModule
+{
+    new IInterlayerDataInModule? DualModule { get; set; }
+    IDataOutPort? DataOut { get; set; }
+    
+}

src/Enigmos/Modules/InterlayerModules/IInterlayerModule.cs

@@ -1,10 +1,11 @@
 using Nocturnis.Enigmos.Ports;
 
-namespace Nocturnis.Enigmos.Modules;
+namespace Nocturnis.Enigmos.Modules.InterlayerModules;
 
 public interface IInterlayerModule
 {
     IBasePort? UnderlyingPort { get; }
     IProgrammableModule? ParentModule { get; set; }
-
+    
 }
+

src/Enigmos/Modules/InterlayerModules/IInterlayerSignalInModule.cs

@@ -0,0 +1,9 @@
+using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules.InterlayerModules;
+
+public interface IInterlayerSignalInModule : IInterlayerModule, IControllingModule
+{
+    new IInterlayerSignalOutModule? DualModule { get; set; }
+    ISignalInPort? SignalIn { get; set; }
+}

src/Enigmos/Modules/InterlayerModules/IInterlayerSignalOutModule.cs

@@ -0,0 +1,9 @@
+using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+
+namespace Nocturnis.Enigmos.Modules.InterlayerModules;
+
+public interface IInterlayerSignalOutModule : IInterlayerModule, IRoutingModule
+{
+    new IInterlayerSignalInModule? DualModule { get; set; }
+    ISignalOutPort? SignalOut { get; set; }
+}

src/Enigmos/Ports/DataPorts/Directions/IDataInPort.cs

@@ -0,0 +1,10 @@
+using Nocturnis.DataStructures;
+using Skeleton.DataStructure;
+
+namespace Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+public interface IDataInPort : IDataPort
+{
+    DataCache GetData { get; }
+    new IDataOutPort? ConnectedPort { get; set; }
+}

src/Enigmos/Ports/DataPorts/Directions/IDataOutPort.cs

@@ -0,0 +1,13 @@
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Skeleton.DataStructure;
+
+namespace Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+public interface IDataOutPort : IDataPort
+{
+    new IDataInPort? ConnectedPort { get; set; }
+    new IComputationalModule Module { get; set; }
+    DataCache OutData { get; set; }
+}

src/Enigmos/Ports/DataPorts/EDataPort.cs

@@ -0,0 +1,6 @@
+namespace Nocturnis.Enigmos.Ports.DataPorts;
+
+public class EDataPort
+{
+    
+}

src/Enigmos/Ports/DataPorts/IDataPort.cs

@@ -0,0 +1,10 @@
+using Godot;
+
+namespace Nocturnis.Enigmos.Ports.DataPorts;
+
+public interface IDataPort : IBasePort
+{
+    new IDataPort? ConnectedPort { get; set; }
+    StringName? DataType { get; set; }
+    void SetDataType(StringName type);
+}

src/Enigmos/Ports/EBasePort.cs

@@ -0,0 +1,67 @@
+using Godot;
+using Nocturnis.Enigmos.Cables;
+using Nocturnis.Inventories.Items.Items;
+using VirtualChemistry.Chemistry.Mixtures.Implements;
+
+namespace Nocturnis.Enigmos.Ports;
+
+public static class EBasePort
+{
+    public static void FixWith(this IBasePort p, IBaseChemicalItem c)
+    {
+        if (c.ContentMaterial.Amount == 0)
+            return;
+        HeterogeneousMixture material = c.ContentMaterial;
+        double s = 1; //material.LayerOrder.Last.Value.CayleyValue();
+        double u = 1;//material.LayerOrder.Last.Value.EuclidValue();
+        double usedAmount = Math.Min(1d, material.LayerOrder.Last.Value.Amount);
+        double dCond = usedAmount * (p.Module!.MaintenanceAlpha * s - p.Module.MaintenanceBeta * u);
+        double dQuality = usedAmount * (Math.Pow(p.Module.MaintenanceBeta, 2) * s - p.Module.MaintenanceAlpha * u);
+        c.ConsumeFromBottom(usedAmount);
+        p.Condition = Mathf.FloorToInt(Math.Max(0, Math.Min(100, p.Condition + dCond)));
+        p.Quality = Mathf.FloorToInt(Math.Max(0, Math.Min(20000, p.Quality + dQuality)));
+    }
+    public static void Connect(this IBasePort p)
+    {
+        if(p.Connected)
+            p.Disconnect();
+        if (p.Module!.Board!.ConnectPending == null)
+        {
+            p.SetStatusPending();
+            p.Module.Board.ConnectPending = p;
+            return;
+        }
+
+        if (p.Module.Board.ConnectPending.IsMatch(p))
+        {
+            p.ConnectedPort = p.Module.Board.ConnectPending;
+            p.Module.Board.ConnectPending.ConnectedPort = p;
+            IBaseCable cable = p.MakeCable(p.Module.Board.ConnectPending);
+            p.Module.Board.CablePairing[p] = cable;
+            p.Module.Board.CablePairing[p.Module.Board.ConnectPending] = cable;
+            p.Module.Board.AddCable(cable);
+            cable.LineUpdate();
+            p.SetStatusConnected();
+            p.Module.Board.ConnectPending.SetStatusConnected();
+            p.Module.Board.ConnectPending = null;
+            return;
+        }
+        p.Module.Board.ConnectPending.SetStatusNormal();
+        p.Module.Board.ConnectPending = null;
+    }
+    public static void Disconnect(this IBasePort p)
+    {
+        if (!p.Connected)
+            return;
+        IBaseCable cable = p.Module!.Board!.CablePairing[p];
+        p.Module.Board.CablePairing.Remove(p.ConnectedPort!);
+        p.Module.Board.FocusedCables.Remove(p.Module.Board.CablePairing[p]);
+        p.Module.Board.CablePairing.Remove(p);
+        
+        cable.Free();
+        p.ConnectedPort!.SetStatusNormal();
+        p.ConnectedPort.ConnectedPort = null;
+        p.SetStatusNormal();
+        p.ConnectedPort = null;
+    }
+}

src/Enigmos/Ports/IBasePort.cs

@@ -1,13 +1,13 @@
 using Godot;
+using Nocturnis.Enigmos.Cables;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Inventories.Items.Items;
 
 namespace Nocturnis.Enigmos.Ports;
 
 public interface IBasePort
 {
     bool Connected { get; }
-    IBaseModule Module { get; set; }
+    IBaseModule? Module { get; set; }
     bool IsMatch(IBasePort oth);
     IBasePort? ConnectedPort { get; set; }
     void SetStatusConnected();
@@ -16,5 +16,7 @@ public interface IBasePort
     StringName Name { get; set; }
     int Condition { get; set; }
     int Quality { get; set; }
-    void FixWith(IBaseChemicalItem item);
-}
+    //void FixWith(IBaseChemicalItem item);
+    void Init();
+    IBaseCable MakeCable(IBasePort port);
+}

src/Enigmos/Ports/IDataInPort.cs

@@ -1,9 +0,0 @@
-using Nocturnis.DataStructures;
-using Nocturnis.Enigmos.Modules;
-
-namespace Nocturnis.Enigmos.Ports;
-
-public interface IDataInPort : IDataPort
-{
-    IDataPackage GetData(IRootModule root);
-}

src/Enigmos/Ports/IDataOutPort.cs

@@ -1,8 +0,0 @@
-using Nocturnis.DataStructures;
-
-namespace Nocturnis.Enigmos.Ports;
-
-public interface IDataOutPort : IDataPort
-{
-    IDataPackage ResultData { get; set; }
-}

src/Enigmos/Ports/IDataPort.cs

@@ -1,6 +0,0 @@
-namespace Nocturnis.Enigmos.Ports;
-
-public interface IDataPort : IBasePort
-{
-    
-}

src/Enigmos/Ports/SignalPorts/Directions/ISignalInPort.cs

@@ -1,6 +1,6 @@
 using Nocturnis.Enigmos.Modules;
 
-namespace Nocturnis.Enigmos.Ports;
+namespace Nocturnis.Enigmos.Ports.SignalPorts.Directions;
 
 public interface ISignalInPort : ISignalPort
 {

src/Enigmos/Ports/SignalPorts/Directions/ISignalOutPort.cs

@@ -1,9 +1,11 @@
 using Nocturnis.Enigmos.Modules;
 
-namespace Nocturnis.Enigmos.Ports;
+namespace Nocturnis.Enigmos.Ports.SignalPorts.Directions;
 
 public interface ISignalOutPort : ISignalPort
 {
-    new IControllingModule Module { get; set; }
+    new IRoutingModule Module { get; set; }
     new ISignalInPort? ConnectedPort { get; set; }
+    void Route();
+
 }

src/Enigmos/Ports/SignalPorts/ISignalPort.cs

@@ -1,4 +1,4 @@
-namespace Nocturnis.Enigmos.Ports;
+namespace Nocturnis.Enigmos.Ports.SignalPorts;
 
 public interface ISignalPort : IBasePort
 {