Upgrade structure of code base

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