refactor programmable modules

Boards/BaseBoard.cs

@@ -91,9 +91,8 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
         module.Board = this;
         AddChild(module.AsNode);
         if (module is ICompositeModule compositeModule)
-            foreach (IBaseModule subModule in compositeModule.SubModules())
+            foreach (IBaseModule subModule in compositeModule.SubModules)
                 subModule.Board = this;
-        
         module.Position = pos;
         Modules.Add(module);
     }

Boards/FilterModuleBoard.cs

@@ -1,25 +1,37 @@
 using Enigmos.Modules.InterlayerModules;
-using Enigmos.Modules.Other;
+using Enigmos.Modules.ProgrammableModules.FilterModule;
+using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Boards;
 public partial class FilterModuleBoard : BaseBoard
 {
-    public IInterlayerDataOutModule[] Outputs { get; set; } = Array.Empty<IInterlayerDataOutModule>();
+    public IFilterModule? FilterModule { get; set; }
-    public IterativeOutputModule? IterativeOutput { get; set; }
-    public IndicateInputModule? Indicate { get; set; }
 
-    public override void Init()
+    public FilterInputProviderModule? InputProvider { get; set; }
+
+    public IInterlayerDataOutModule[] FilterInputProxy { get; set; } = Array.Empty<IInterlayerDataOutModule>();
+    //public IInterlayerDataOutModule[] Outputs { get; set; } = Array.Empty<IInterlayerDataOutModule>();
+    
+    //public XIterativeOutputModule? IterativeOutput { get; set; }
+    //public IDataInPort? Indicate { get; set; }
+    //public IndicateInputModule? Indicate { get; set; }
+    public FilterIndicateModule? Indicate { get; set; }
+
+    public void Init(IFilterModule filterModule)
     {
         base.Init();
-        Outputs = new IInterlayerDataOutModule[3];
+        FilterModule = filterModule;
+        FilterInputProxy = new IInterlayerDataOutModule[3];
+        InputProvider = GetModule<FilterInputProviderModule>("InputProvider");
+        InputProvider.Init(this);
         for (int i = 1; i <= 3; i++)
-            Outputs[i-1] = GetModule<InterlayerDataOutModule>($"IO{i}");
+            FilterInputProxy[i - 1] = GetModule<InterlayerDataOutModule>($"IO{i}");
         base.Init();
-        IterativeOutput = GetModule<IterativeOutputModule>("IterativeOutput");
+        //IterativeOutput = GetModule<XIterativeOutputModule>("IterativeOutput");
-        Indicate = GetModule<IndicateInputModule>("Indicate");
+        Indicate = GetModule<FilterIndicateModule>("Indicate");
-        Indicate.Input!.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        Indicate.Indicate!.SetDataType(EnigmosConstant.DataPortTypes.Bit);
     }
 
 }

Boards/OptimizationModuleBoard.cs

@@ -1,13 +1,16 @@
 using Enigmos.Modules.InterlayerModules;
 using Enigmos.Modules.Other;
+using Enigmos.Modules.ProgrammableModules.OptimizationModule;
 using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Boards;
 
 public partial class OptimizationModuleBoard : BaseBoard
 {
-    public IterativeOutputModule? IterOut { get; set; }
+    public OptimizationModule? OptimizationModule { get; set; }
-    public OptimizationValueInputModule? ValueIn { get; set; }
+
+    public OptimizationInputProviderModule? InputProvider { get; set; }
+    public OptimizationSelectorModule? Selector { get; set; }
     public InterlayerDataOutModule[] ImplicitDataOuts { get; set; } = Array.Empty<InterlayerDataOutModule>();
     public override void Init()
     {
@@ -16,9 +19,8 @@ public partial class OptimizationModuleBoard : BaseBoard
         base.Init();
         for (int i = 0; i < 3; i++)
             ImplicitDataOuts[i] = GetModule<InterlayerDataOutModule>($"IO{i + 1}");
-        IterOut = GetModule<IterativeOutputModule>("IterOut");
+        InputProvider = GetModule<OptimizationInputProviderModule>("InputProvider");
-        ValueIn = GetModule<OptimizationValueInputModule>("ValueIn");
+        Selector = GetModule<OptimizationSelectorModule>("Selector");
-        IterOut.Output!.SetDataType(EnigmosConstant.DataPortTypes.Real);
+
-        ValueIn.DataIn.SetDataType(EnigmosConstant.DataPortTypes.Real);
     }
 }

Modules/BaseModule.cs

@@ -97,7 +97,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
     {
         if (!Draggable)
             return default;
-        Board!.ModuleMovingLayer.DraggingModule = this;
+        Board!.ModuleMovingLayer!.DraggingModule = this;
         Board!.ModuleMovingLayer.MouseOffset = GetLocalMousePosition();
         return GlobalProvider.DataStructureProvider!.NewVariantWithType("Module", this);
     }
@@ -121,7 +121,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
                 {
                     if (!HasManual)
                         return;
-                    if (Board.ManualOpened)
+                    if (Board!.ManualOpened)
                         return;
                     if (Manual == null)
                     {
@@ -131,7 +131,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
                         Manual.Init(this);
                     }
 
-                    Board.ModuleManualLayer.AddChild(Manual);
+                    Board.ModuleManualLayer!.AddChild(Manual);
                     Manual.Position = Board.ModuleManualLayer.ManualPosition.Position - Manual.Size / 2;
                     Board.ManualOpened = true;
                     return;
@@ -148,7 +148,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
                             .Select(p => Board.CablePairing[p])
                             .ToHashSet();
                         if (this is ICompositeModule thisCompositeModule)
-                            foreach (IBasePort port in thisCompositeModule.SubModules().SelectMany(module => module.Ports).Where(Board.CablePairing.ContainsKey))
+                            foreach (IBasePort port in thisCompositeModule.SubModules.SelectMany(module => module.Ports).Where(Board.CablePairing.ContainsKey))
                                 Board.FocusedCables.Add(Board.CablePairing[port]);
                         foreach (IBaseCable cable in Board.FocusedCables)
                             cable.Modulate = Color.Color8(255, 255, 255, 255);

Modules/ComputationalModules/ComputationalModule.cs

@@ -1,5 +1,3 @@
-using Enigmos.Exceptions;
-using Enigmos.Ports.DataPorts;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 

Modules/InterlayerModules/FilterOutputModule.cs

@@ -1,43 +0,0 @@
-using Godot;
-using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Modules.InterlayerModules;
-using Nocturnis.Enigmos.Ports;
-using Nocturnis.Enigmos.Ports.DataPorts.Directions;
-using Enigmos.Modules.ComputationalModules;
-using Nocturnis.GlobalManagement.Constants;
-
-namespace Enigmos.Modules.InterlayerModules;
-
-public partial class FilterOutputModule : NullaryComputationalModule, IInterlayerModule
-{
-    public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
-
-    public IFilterModule FilterModule
-    {
-        get => (ParentModule as IFilterModule)!;
-        set => ParentModule = value;
-    }
-    public IDataOutPort? Output { get; set; }
-    public override IEnumerable<IBasePort> Ports => new[] { Output! };
-    protected override bool Draggable => false;
-    protected override bool HasManual => false;
-    public override void Init()
-    {
-        base.Init();
-        this.DataOutInit("Output", 1);
-        Output = DataOutPorts[0];
-        PostInit();
-    }
-
-    public override void Define()
-    {
-        FilterModule.Filter();
-        Output!.OutData.UpdateCalculation(
-            cache => (FilterModule.CachedResult, EnigmosConstant.DataPortTypes.AnyArrayType)
-        );
-    }
-
-    public IBasePort UnderlyingPort => Output!;
-    public IProgrammableModule? ParentModule { get; set; }
-}

Modules/InterlayerModules/InterlayerDataInModule.cs

@@ -1,17 +1,18 @@
-using Godot;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 
 namespace Enigmos.Modules.InterlayerModules;
-public partial class InterlayerDataInModule : BaseModule, IInterlayerDataInModule
+public partial class InterlayerDataInModule : SubModule, IInterlayerDataInModule
 {
-    protected override bool HasManual => false;
-    public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
-    public IProgrammableModule? ParentModule { get; set; }
-    protected override bool Draggable => false;
     public IBasePort? UnderlyingPort => DataIn;
+
+    public new IProgrammableModule? ParentModule
+    {
+        get => base.ParentModule as IProgrammableModule; 
+        set => base.ParentModule = value;
+    }
     public IInterlayerDataOutModule? DualModule { get; set; }
     public IDataInPort? DataIn { get; set; }
     public override IEnumerable<IBasePort> Ports => new[] { DataIn }!;

Modules/InterlayerModules/InterlayerDataOutModule.cs

@@ -8,13 +8,15 @@ using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 
 namespace Enigmos.Modules.InterlayerModules;
 
-public partial class InterlayerDataOutModule : ComputationalModule, IInterlayerDataOutModule
+public partial class InterlayerDataOutModule : SubModule, IComputationalModule, IInterlayerDataOutModule
 {
-    public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
+    public new IProgrammableModule? ParentModule
-    public IProgrammableModule? ParentModule { get; set; }
+    {
+        get => base.ParentModule as IProgrammableModule; 
+        set => base.ParentModule = value; 
+    }
 
-    protected override bool Draggable => false;
+    public IDataOutPort[] DataOutPorts { get; set; }
-    protected override bool HasManual => false;
     public IBasePort UnderlyingPort => DataOut!;
     public IInterlayerDataInModule? DualModule { get; set; }
     public IDataOutPort? DataOut { get; set; }
@@ -28,7 +30,7 @@ public partial class InterlayerDataOutModule : ComputationalModule, IInterlayerD
         PostInit();
     }
 
-    public override void Define()
+    public void Define()
     {
         DataOut!.OutData = DualModule!.DataIn!.GetData;
     }

Modules/InterlayerModules/InterlayerSignalInModule.cs

@@ -6,12 +6,13 @@ using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
 
 namespace Enigmos.Modules.InterlayerModules;
 
-public partial class InterlayerSignalInModule : BaseModule, IInterlayerSignalInModule
+public partial class InterlayerSignalInModule : SubModule, IInterlayerSignalInModule
 {
-    public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
+    public new IProgrammableModule? ParentModule
-    public IProgrammableModule? ParentModule { get; set; }
+    {
-    protected override bool Draggable => false;
+        get => base.ParentModule as IProgrammableModule;
-    protected override bool HasManual => false;
+        set => base.ParentModule = value;
+    }
     public IBasePort UnderlyingPort => SignalIn!;
     public IInterlayerSignalOutModule? DualModule { get; set; }
     public ISignalInPort? SignalIn { get; set; }

Modules/InterlayerModules/InterlayerSignalOutModule.cs

@@ -1,4 +1,3 @@
-using Godot;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
@@ -6,13 +5,13 @@ using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
 
 namespace Enigmos.Modules.InterlayerModules;
 
-public partial class InterlayerSignalOutModule : BaseModule, IInterlayerSignalOutModule
+public partial class InterlayerSignalOutModule : SubModule, IInterlayerSignalOutModule
 {
-    public override Vector2 PositionToBoard => 
+    public new IProgrammableModule? ParentModule
-        base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
+    {
-    public IProgrammableModule? ParentModule { get; set; }
+        get => base.ParentModule as IProgrammableModule;
-    protected override bool Draggable => false;
+        set => base.ParentModule = value;
-    protected override bool HasManual => false;
+    }
     public IBasePort UnderlyingPort => SignalOut!;
     public IInterlayerSignalInModule? DualModule { get; set; }
     public ISignalOutPort? SignalOut { get; set; }
@@ -27,7 +26,4 @@ public partial class InterlayerSignalOutModule : BaseModule, IInterlayerSignalOu
         SignalOut = SignalOutPorts[0];
         PostInit();
     }
-
-    public bool Visited { get; set; }
-
 }

Modules/InterlayerModules/IterativeOutputModule.cs

@@ -1,39 +0,0 @@
-using Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Modules.InterlayerModules;
-using Nocturnis.Enigmos.Ports;
-using Nocturnis.Enigmos.Ports.DataPorts.Directions;
-using Nocturnis.GlobalManagement.Constants;
-
-namespace Enigmos.Modules.InterlayerModules;
-
-public partial class IterativeOutputModule : NullaryComputationalModule, IInterlayerModule, IDuplicateOutputModule
-{
-	protected override bool Draggable => false;
-	protected override bool HasManual => false;
-	public IDataOutPort? Output { get; set; }
-
-	public override IEnumerable<IBasePort> Ports => new[] { Output }!;
-
-	public override void Init()
-	{
-		base.Init();
-		this.DataOutInit("DataOut", 1);
-		Output = DataOutPorts[0];
-		PostInit();
-	}
-
-	public override void Define()
-	{
-		if (ParentModule is IOptimizationModule opm)
-			this.Define(cache => (opm.CachedResult.Data, opm.CachedResult.Type)!);
-		if (ParentModule is IFilterModule fm)
-			this.Define(cache => (fm.CachedResult, EnigmosConstant.DataPortTypes.AnyArrayType));
-		
-	}
-
-	//protected override void Compute(IRootModule root) => throw new Exception("Should be Handled by Other Module");
-	public IBasePort UnderlyingPort => Output!;
-	public IProgrammableModule? ParentModule { get; set; }
-}

Modules/InterlayerModules/OptimizationItemOutputModule.cs

@@ -1,42 +0,0 @@
-using Enigmos.Modules.ComputationalModules;
-using Godot;
-using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Modules.InterlayerModules;
-using Nocturnis.Enigmos.Ports;
-using Nocturnis.Enigmos.Ports.DataPorts.Directions;
-
-namespace Enigmos.Modules.InterlayerModules;
-
-public partial class OptimizationItemOutputModule : NullaryComputationalModule, IInterlayerModule
-{
-    public override Vector2 PositionToBoard =>
-        base.PositionToBoard + (OptimizationModule?.PositionToBoard ?? Vector2.Zero);
-    protected override bool Draggable => false;
-    protected override bool HasManual => false;
-
-    public IOptimizationModule OptimizationModule
-    {
-        get => (ParentModule as IOptimizationModule)!;
-        set => ParentModule = value;
-    }
-    public IDataOutPort DataOut { get; set; }
-
-    public override IEnumerable<IBasePort> Ports => new[] { DataOut };
-    //protected override void Compute(IRootModule root) => OptimizationModule.OptimizeWithTimeoutHandle(root);
-    public override void Init()
-    {
-        base.Init();
-        this.DataOutInit("DataOut", 1);
-        DataOut = DataOutPorts[0];
-        PostInit();
-    }
-
-    public IBasePort UnderlyingPort => DataOut;
-    public IProgrammableModule? ParentModule { get; set; }
-    public override void Define()
-    {
-        IOptimizationModule im = (ParentModule as IOptimizationModule)!;
-        DataOut.OutData.UpdateCalculation(cache => (im.CachedResult.Data, im.CachedResult.Type)!);
-    }
-}

Modules/InterlayerModules/OptimizationValueOutputModule.cs

@@ -1,44 +0,0 @@
-using Enigmos.Modules.ComputationalModules;
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Godot;
-using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Modules.InterlayerModules;
-using Nocturnis.Enigmos.Ports;
-using Nocturnis.GlobalManagement.Constants;
-
-namespace Enigmos.Modules.InterlayerModules;
-
-public partial class OptimizationValueOutputModule : NullaryComputationalModule, 
-	IInterlayerModule, 
-	IDuplicateOutputModule
-{
-	public override Vector2 PositionToBoard => 
-		base.PositionToBoard + (OptimizationModule?.PositionToBoard ?? Vector2.Zero);
-	protected override bool Draggable => false;
-	protected override bool HasManual => false;
-	public DataOutPort? DataOut { get; set; }
-	public IOptimizationModule OptimizationModule 
-	{
-		get => (ParentModule as IOptimizationModule)!;
-		set => ParentModule = value; 
-	}
-	public override IEnumerable<BasePort> Ports => new[] { DataOut }!;
-
-	public override void Init()
-	{
-		base.Init();
-		this.DataOutInit("DataOut", 1);
-		DataOut.SetDataType(EnigmosConstant.DataPortTypes.Real);
-		PostInit();
-	}
-
-	public override void Define()
-	{
-		this.Define(cache => (OptimizationModule.CachedResult.Data, OptimizationModule.CachedResult.Type) );
-	}
-
-	public IBasePort UnderlyingPort => DataOut;
-	public IProgrammableModule? ParentModule { get; set; }
-}

Modules/Other/IndicateInputModule.cs

@@ -1,22 +0,0 @@
-using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
-using Nocturnis.Enigmos.Ports.DataPorts.Directions;
-
-namespace Enigmos.Modules.Other;
-
-public partial class IndicateInputModule : BaseModule, IParameterModule
-{
-    public IDataInPort? Input { get; set; }
-    protected override bool Draggable => false;
-    protected override bool HasManual => false;
-    public override IEnumerable<IBasePort> Ports => new[] { Input! };
-    public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
-
-    public override void Init()
-    {
-        base.Init();
-        this.DataInInit("Input", 1);
-        Input = DataInPorts[0];
-        PostInit();
-    }
-}

Modules/Other/OptimizationValueInputModule.cs

@@ -1,24 +0,0 @@
-using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
-using Nocturnis.Enigmos.Ports.DataPorts.Directions;
-using Nocturnis.GlobalManagement.Constants;
-
-namespace Enigmos.Modules.Other;
-
-public partial class OptimizationValueInputModule : BaseModule, IParameterModule
-{
-    protected override bool Draggable => false;
-    protected override bool HasManual => false;
-    public IDataInPort? DataIn { get; set; }
-    public override IEnumerable<IBasePort> Ports => new[] { DataIn! };
-    public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
-
-    public override void Init()
-    {
-        base.Init();
-        this.DataInInit("DataIn", 1);
-        DataIn = DataInPorts[0];
-        DataIn.SetDataType(EnigmosConstant.DataPortTypes.Real);
-        DataIn.Module = this;
-    }
-}

Modules/ProgrammableModules/FilterModule/FilterIndicateModule.cs

@@ -0,0 +1,15 @@
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Enigmos.Modules.ProgrammableModules.FilterModule;
+
+public partial class FilterIndicateModule : SubModule
+{
+    public IDataInPort? Indicate { get; set; }
+
+    public override void Init()
+    {
+        base.Init();
+        Indicate = this.GetPort<IDataInPort>("Indicate");
+    }
+}

Modules/ProgrammableModules/FilterModule/FilterInputProviderModule.cs

@@ -0,0 +1,37 @@
+using Enigmos.Boards;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Skeleton.DataStructure;
+
+namespace Enigmos.Modules.ProgrammableModules.FilterModule;
+
+public partial class FilterInputProviderModule : SubModule, IComputationalModule
+{
+    public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
+    public override IEnumerable<IBasePort> Ports => DataOutPorts;
+    public IDataOutPort? Output { get; set; }
+
+    public FilterModuleBoard? ParentBoard { get; set; }
+
+    public void Init(FilterModuleBoard board)
+    {
+        base.Init();
+        ParentBoard = board;
+        this.DataOutInit("Output", 1);
+        Output = DataOutPorts[0];
+        PostInit();
+    }
+
+    public void Define()
+    {
+        (object, StringName) Func(CacheItem c)
+        {
+            IData w = ParentBoard!.FilterModule!.CachedInputArray[ParentBoard.FilterModule.ProcessingIndex];
+            return (w.Data, w.Type)!;
+        }
+        Output!.OutData.UpdateCalculation(Func);
+    }
+}

Modules/ProgrammableModules/FilterModule/FilterModule.cs

@@ -1,9 +1,5 @@
 using Enigmos.Boards;
-using Enigmos.Exceptions;
-using Enigmos.Modules.ControllingModules;
 using Enigmos.Modules.InterlayerModules;
-using Enigmos.Modules.Other;
-using Enigmos.Ports.DataPorts;
 using Nocturnis.DataStructures;
 using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
@@ -14,107 +10,100 @@ using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
-namespace Enigmos.Modules.ProgrammableModules;
+namespace Enigmos.Modules.ProgrammableModules.FilterModule;
 
 public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFilterModule
 {
-
+    public IDataInPort? InputArray { get; set; }
-    private IDataInPort? Input { get; set; }
+    public FilterOutputModule? OutputArrayModule { get; set; }
     private IInterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<IInterlayerDataInModule>();
-    private FilterOutputModule? Output { get; set; }
+    
-    private IterativeOutputModule? IterativeOutput { get; set; }
-    private IndicateInputModule? Indicate { get; set; }
     private IDataPortGroup[] InterLayerGroups { get; set; } = Array.Empty<IDataPortGroup>();
     private IDataPortGroup? ArrayGroup { get; set; }
-    private bool FilterEnded { get; set; }
+    public IData[] CachedInputArray { get; set; } = Array.Empty<IData>();
-    private IData[] CachedInputArray { get; set; } = Array.Empty<IData>();
     public IData[] CachedResult { get; set; } = Array.Empty<IData>();
+    public bool FilterFinished { get; set; }
+    public bool FilterStarted { get; set; }
 
     private List<IData> CachedListResult { get; set; } = new();
-
+    public int ProcessingIndex { get; set; }
-    //private List<IData> CachedResult { get; set; } = new();
-    private int CachedIndex { get; set; }
 
     public new FilterModuleBoard UnderlyingBoard
     {
         get => (base.UnderlyingBoard as FilterModuleBoard)!;
         set => base.UnderlyingBoard = value;
     }
+    
+    public override IEnumerable<IBasePort> Ports => new IBasePort[] { InputArray!, OutputArrayModule!.Output! };
 
-    public override IEnumerable<IBasePort> Ports => new[] { Input! };
+    public override IBaseModule[] SubModules => ExplicitInputs;
-
-    public override IBaseModule[] SubModules() => ExplicitInputs.Union<IBaseModule>(new[] { Output! }).ToArray();
 
     public override IEnumerable<IBasePort> ExplicitPorts =>
-        new IBasePort[] { Output!.Output! }
+        new IBasePort[] { InputArray!, OutputArrayModule!.Output! }
             .Union(ExplicitInputs.Select(c => c.DataIn))!
             .ToArray<IBasePort>();
 
     public override IEnumerable<IBasePort> ImplicitPorts =>
-        new IBasePort[] { IterativeOutput!.Output!, Indicate!.Input! }
+        new IBasePort[] { OutputArrayModule!.Output!, InputArray! }
-            .Union(UnderlyingBoard.Outputs.Select(c => c.DataOut))
+            .Union(UnderlyingBoard.FilterInputProxy.Select(c => c.DataOut))
             .ToArray()!;
 
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
-    public void Inference() => IterativeOutput!.Output!
+    public void Inference()
-        .SetDataType(GlobalProvider.DataStructureProvider!.ArrayToElement(ArrayGroup!.SelectedType));
+    {
-
+    }
 
     public void Filter()
     {
-        if (FilterEnded)
+        if (!FilterStarted)
         {
-            CachedInputArray = Input!.GetData.Get!.Array;
+            CachedInputArray = InputArray!.GetData.Get!.Array;
-            CachedIndex = 0;
+            ProcessingIndex = 0;
             CachedListResult = new List<IData>();
+            FilterStarted = true;
         }
 
-        while (CachedIndex < CachedInputArray.Length)
+        while (ProcessingIndex < CachedInputArray.Length)
         {
             SoftReset();
-            IterativeOutput!.Output!.OutData.UpdateCalculation(cache =>
+            UnderlyingBoard.InputProvider!.Define();
-                (CachedInputArray[CachedIndex].Data, IterativeOutput.Output.DataType)!);
+            UnderlyingBoard.InputProvider.Output!.OutData.Expire();
-            IterativeOutput.Output.OutData.Expire();
+            if(UnderlyingBoard.Indicate!.Indicate!.GetData.Get!.Bit)
-            if(Indicate!.Input!.GetData.Get!.Bit)
+                CachedListResult.Add(CachedInputArray[ProcessingIndex]);
-                CachedListResult.Add(CachedInputArray[CachedIndex]);
+            ProcessingIndex += 1;
-            CachedIndex += 1;
         }
 
         CachedResult = CachedListResult.ToArray();
-        FilterEnded = true;
+        FilterFinished = true;
+        FilterStarted = false;
     }
+    
 
     private void SoftReset() => UnderlyingBoard.Reset();
 
     public override void Init()
     {
         base.Init();
+        InputArray = this.GetPort<IDataInPort>("InputArray");
+        OutputArrayModule = GetModule<FilterOutputModule>("OutputArray");
         UnderlyingBoard = GlobalProvider.SceneProvider!
             .AssetMapper<FilterModuleBoard>()
             .Instantiate<FilterModuleBoard>();
-        UnderlyingBoard.Init();
+        ExplicitInputs = new IInterlayerDataInModule[3];
-        ExplicitInputs = new InterlayerDataInModule[3];
-        InterLayerGroups = new IDataPortGroup[3];
-        IterativeOutput = UnderlyingBoard.IterativeOutput;
-        IterativeOutput.Output.SetDataType(EnigmosConstant.DataPortTypes.Real);
-        Indicate = UnderlyingBoard.Indicate;
         for (int i = 0; i < 3; i++)
-        {
             ExplicitInputs[i] = GetModule<InterlayerDataInModule>($"EI{i + 1}");
-            ExplicitInputs[i].DualModule = UnderlyingBoard.Outputs[i];
+        OutputArrayModule.Init(this);
-            UnderlyingBoard.Outputs[i].DualModule = ExplicitInputs[i];
+        UnderlyingBoard.Init(this);
-        }
+        
-
+        FilterFinished = false;
-        FilterEnded = true;
+        FilterStarted = false;
         
-        Input = this.GetPort<DataInPort>("Input");
-        Output = GetModule<FilterOutputModule>("Output");
         for (int i = 0; i < 3; i++)
         {
-            InterLayerGroups[i] = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            InterLayerGroups[i] = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
                 this,
-                new IDataPort[] { ExplicitInputs[i].DataIn, UnderlyingBoard.Outputs[i].DataOut },
+                new IDataPort[] { ExplicitInputs[i].DataIn!, UnderlyingBoard.FilterInputProxy[i].DataOut! },
                 $"Exterior In -> Interior Out{i}",
                 EnigmosConstant.DataPortTypes.Real,
                 EnigmosConstant.DataPortTypes.AnyType
@@ -124,7 +113,7 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
 
         ArrayGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
             this,
-            new IDataPort[] { Input, Output.Output! },
+            new IDataPort[] { InputArray, OutputArrayModule.Output! },
             "Array Type",
             EnigmosConstant.DataPortTypes.RealArray,
             EnigmosConstant.DataPortTypes.AnyArray
@@ -133,8 +122,6 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
         ConfigurablePortGroups = InterLayerGroups.Union(new[] { ArrayGroup }).ToHashSet();
 
         PostInit();
-        
-        
     }
-
+ 
-}
+}

Modules/ProgrammableModules/FilterModule/FilterOutputModule.cs

@@ -0,0 +1,41 @@
+using Godot;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Nocturnis.GlobalManagement.Constants;
+using Skeleton.DataStructure;
+
+namespace Enigmos.Modules.ProgrammableModules.FilterModule;
+
+public partial class FilterOutputModule : SubModule, IComputationalModule
+{
+    public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
+    public IDataOutPort? Output { get; set; }
+    public override IEnumerable<IBasePort> Ports => DataOutPorts;
+    public new IFilterModule? ParentModule { 
+        get => base.ParentModule as IFilterModule; 
+        set => base.ParentModule = value; 
+    }
+
+    public void Init(IFilterModule parent)
+    {
+        base.Init();
+        this.DataOutInit("Output", 1);
+        Output = DataOutPorts[0];
+        ParentModule = parent;
+        PostInit();
+    }
+
+    public void Define()
+    {
+        (object, StringName) Func(CacheItem c)
+        {
+            if (!ParentModule!.FilterFinished)
+                ParentModule!.Filter();
+            return (ParentModule!.CachedResult, EnigmosConstant.DataPortTypes.AnyArrayType);
+        }
+        Output!.OutData.UpdateCalculation(Func);
+    }
+}
+

Modules/ProgrammableModules/FunctionModule/FunctionModule.cs

@@ -8,7 +8,7 @@ using Nocturnis.Enigmos.Ports.DataPorts;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
-namespace Enigmos.Modules.ProgrammableModules;
+namespace Enigmos.Modules.ProgrammableModules.FunctionModule;
 public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
 {
 	private IDataPortGroup[] ExteriorToInterior { get; set; } = Array.Empty<IDataPortGroup>();
@@ -34,7 +34,7 @@ public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
 	private static readonly PackedScene FunctionModuleBoardScene = GlobalProvider.SceneProvider!
 		.AssetMapper<FunctionModuleBoard>();
 
-	public override BaseModule[] SubModules() => 
+	public override BaseModule[] SubModules => 
 		ExplicitDataInModules
 			.Union<BaseModule>(ExplicitDataOutModules)
 			.Union(ExplicitSignalInModules)

Modules/ProgrammableModules/OptimizationModule/OptimizationInputProviderModule.cs

@@ -0,0 +1,36 @@
+using Enigmos.Boards;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Skeleton.DataStructure;
+
+namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
+
+public partial class OptimizationInputProviderModule : SubModule, IComputationalModule
+{
+    public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
+    public override IEnumerable<IBasePort> Ports => DataOutPorts;
+    public IDataOutPort? Output { get; set; }
+    public OptimizationModuleBoard? ParentBoard { get; set; }
+
+    public void Init(OptimizationModuleBoard board)
+    {
+        base.Init();
+        ParentBoard = board;
+        this.DataOutInit("Output", 1);
+        Output = DataOutPorts[0];
+        PostInit();
+    }
+
+    public void Define()
+    {
+        (object, StringName) Func(CacheItem c)
+        {
+            IData w = ParentBoard!.OptimizationModule!.CachedInput[ParentBoard.OptimizationModule.ProcessingIndex];
+            return (w.Data, w.Type)!;
+        }
+        Output!.OutData.UpdateCalculation(Func);
+    }
+}

Modules/ProgrammableModules/OptimizationModule/OptimizationModule.cs

@@ -1,46 +1,47 @@
 using Enigmos.Boards;
-using Enigmos.Exceptions;
-using Enigmos.Modules.ControllingModules;
 using Enigmos.Modules.InterlayerModules;
-using Enigmos.Ports;
 using Enigmos.Ports.DataPorts;
 using Godot;
 using Nocturnis.DataStructures;
 using Nocturnis.DataStructures.ConfigurableParameters;
 using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
-namespace Enigmos.Modules.ProgrammableModules;
+namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
 
-public partial class OptimizationModule : ProgrammableModule, 
+public partial class OptimizationModule : ProgrammableModule,
-	IPolymorphismModule, 
+	IPolymorphismModule,
-	IParameterizedModule, 
+	IParameterizedModule,
 	IOptimizationModule
 {
-	private bool OptimizationEnded { get; set; }
+	public bool OptimizationFinished { get; set; }
+	public bool OptimizationStarted { get; set; }
 	private double? CachedOptimizeValue { get; set; }
-	public IDataInPort? InternalIterOut { get; set; }
+	public IDataInPort? ArrayInput { get; set; }
-	public IDataOutPort? InternalArrayIn { get; set; }
+	public IInterlayerDataInModule[] ExplicitOutputs { get; set; } = Array.Empty<IInterlayerDataInModule>();
-
+	public IInterlayerDataOutModule[] ImplicitInputs { get; set; } = Array.Empty<IInterlayerDataOutModule>();
+	public IData[] CachedInput { get; set; } = Array.Empty<IData>();
+	public int ProcessingIndex { get; set; }
+	private IBoolParameter? UsingMax { get; set; }
 	public IData CachedResult { get; set; } =
 		GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
 
-	private IData[] CachedInput { get; set; } = Array.Empty<IData>();
-	private int ProcessingIndex { get; set; }
 
-	private IBoolParameter? UsingMax { get; set; }
+	public IDataInPort? InternalIterOut { get; set; }
+	public IDataOutPort? InternalArrayIn { get; set; }
+	
 	private IDataPortGroup[] InterlayerGroups { get; set; } = Array.Empty<IDataPortGroup>();
 	private IDataPortGroup? OptimizationGroup { get; set; }
-	private DataInPort? ArrayInput { get; set; }
-	private InterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<InterlayerDataInModule>();
-	private OptimizationItemOutputModule? ItemOut { get; set; }
-	private OptimizationValueOutputModule? ValueOut { get; set; }
 	
+	private InterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<InterlayerDataInModule>();
+	private OptimizationSelectorModule? Selector { get; set; }
+	private OptimizationOutputModule? Output { get; set; }
 	public override IEnumerable<IBasePort> Ports => new[] { ArrayInput! };
 
 	public new OptimizationModuleBoard UnderlyingBoard
@@ -53,17 +54,17 @@ public partial class OptimizationModule : ProgrammableModule,
 	public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
 	public override IEnumerable<IBasePort> ExplicitPorts => 
-		new IBasePort[] { ItemOut!.DataOut, ValueOut!.DataOut! }
+		new IBasePort[] { ArrayInput!,  Output!.Output! }
 			.Union<IBasePort>(ExplicitInputs.Select(c => c.DataIn)!);
 
-	public override BaseModule[] SubModules() => 
+	public override BaseModule[] SubModules => 
 		ExplicitInputs
-			.Union(new BaseModule[] { ItemOut, ValueOut })
+			.Union(new BaseModule[] { Output! })
 			.ToArray();
 
 	public override IEnumerable<IBasePort> ImplicitPorts =>
-		new IBasePort[] { UnderlyingBoard.IterOut.Output, UnderlyingBoard.ValueIn.DataIn }
+		new IBasePort[] { UnderlyingBoard.InputProvider!.Output!, UnderlyingBoard.Selector!.Selector! }
-			.Union(UnderlyingBoard.ImplicitDataOuts.Select(c => c.DataOut));
+			.Union(UnderlyingBoard.ImplicitDataOuts.Select(c => c.DataOut))!;
 
 	public override void Init()
 	{
@@ -75,7 +76,8 @@ public partial class OptimizationModule : ProgrammableModule,
 		InterlayerGroups = new IDataPortGroup[3];
 		ExplicitInputs = new InterlayerDataInModule[3];
 		InternalIterOut = this.GetPort<IDataInPort>("InternalIterOut");
-		
+		Output = GetModule<OptimizationOutputModule>("Output");
+		Output.Init();
 		for (int i = 0; i < 3; i++)
 		{
 			ExplicitInputs[i] = GetModule<InterlayerDataInModule>($"EI{i + 1}");
@@ -83,7 +85,7 @@ public partial class OptimizationModule : ProgrammableModule,
 			UnderlyingBoard.ImplicitDataOuts[i].DualModule = ExplicitInputs[i];
 		}
 
-		OptimizationEnded = true;
+		OptimizationFinished = true;
 		CachedInput = Array.Empty<IData>();
 		//CachedArray = Array.Empty<DataPackage>();
 		ProcessingIndex = 0;
@@ -91,9 +93,7 @@ public partial class OptimizationModule : ProgrammableModule,
 		CachedOptimizeValue = null;
 		
 		ArrayInput = this.GetPort<DataInPort>("ArrayInput");
-		ItemOut = GetModule<OptimizationItemOutputModule>("ItemOut");
+		
-		ValueOut = GetModule<OptimizationValueOutputModule>("ValueOut");
-
 		for (int i = 0; i < 3; i++)
 		{
 			InterlayerGroups[i] = GlobalProvider.DataStructureProvider.NewDataPortGroup(
@@ -119,8 +119,8 @@ public partial class OptimizationModule : ProgrammableModule,
 			"Min",
 			true
 		);
-		ItemOut.DataOut.SetDataType(EnigmosConstant.DataPortTypes.Real);
+		Output.Output!.SetDataType(EnigmosConstant.DataPortTypes.Real);
-		ValueOut.DataOut!.SetDataType(EnigmosConstant.DataPortTypes.Real);
+		Selector!.Selector!.SetDataType(EnigmosConstant.DataPortTypes.Real);
 		ConfigurableParameters = new HashSet<IConfigurableParameter> { UsingMax };
 		ConfigurablePortGroups = 
 			InterlayerGroups.Union(new[] { OptimizationGroup }).ToHashSet();
@@ -132,31 +132,31 @@ public partial class OptimizationModule : ProgrammableModule,
 	public void Inference()
 	{
 		StringName elementType = GlobalProvider.DataPackageTypeProvider!.ToElement(OptimizationGroup!.SelectedType);
-		ItemOut!.DataOut.SetDataType(elementType);
+		Output!.Output!.SetDataType(elementType);
-		UnderlyingBoard.IterOut!.Output!.SetDataType(elementType);
+		UnderlyingBoard.InputProvider!.Output!.SetDataType(elementType);
 	}
 
 	private void SoftReset() => UnderlyingBoard.Reset();
 
 	public void Optimize()
 	{
-		if (OptimizationEnded)
+		if (OptimizationFinished)
 		{
 			CachedOptimizeValue = null;
 			CachedInput = InternalArrayIn!.OutData.Get!.Array;
-			CachedResult = GlobalProvider.DataStructureProvider.NewData(0, EnigmosConstant.DataPortTypes.Null);
+			CachedResult = GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
 			ProcessingIndex = 0;
 		}
 
 		while (ProcessingIndex < CachedInput.Length)
 		{
 			SoftReset();
-			UnderlyingBoard.IterOut!.Output!.OutData.UpdateCalculation(
+			UnderlyingBoard.InputProvider!.Output!.OutData.UpdateCalculation(
 				cache =>
 					(CachedInput[ProcessingIndex].Data, CachedInput[ProcessingIndex].Type)!
 			);
-			UnderlyingBoard.IterOut.Output.OutData.Expire();
+			UnderlyingBoard.InputProvider.Output.OutData.Expire();
-			double currentValue = UnderlyingBoard.ValueIn!.DataIn!.GetData.Get!.Double;
+			double currentValue = UnderlyingBoard.Selector!.Selector!.GetData.Get!.Double;
 			IData currentOut = InternalIterOut!.GetData.Get!;
 			if (UsingMax!.ParameterValue)
 			{
@@ -177,8 +177,8 @@ public partial class OptimizationModule : ProgrammableModule,
 			ProcessingIndex++;
 			
 		}
-		ValueOut!.Define();
+		Output!.Define();
-		OptimizationEnded = true;
+		OptimizationFinished = true;
 	}
 
 	public bool Calculated { get; set; }

Modules/ProgrammableModules/OptimizationModule/OptimizationOutputModule.cs

@@ -0,0 +1,25 @@
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
+
+public partial class OptimizationOutputModule : SubModule, IComputationalModule
+{
+    public IDataOutPort? Output { get; set; }
+    public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
+    public override IEnumerable<IBasePort> Ports => DataOutPorts;
+
+    public override void Init()
+    {
+        this.DataOutInit("DataOut", 1);
+        Output = DataOutPorts[0];
+
+    }
+
+    public void Define()
+    {
+        throw new NotImplementedException();
+    }
+}

Modules/ProgrammableModules/OptimizationModule/OptimizationSelectorModule.cs

@@ -0,0 +1,14 @@
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
+
+public partial class OptimizationSelectorModule : SubModule
+{
+    public IDataInPort? Selector { get; set; }
+    public override void Init()
+    {
+        base.Init();
+        Selector = this.GetPort<IDataInPort>("Selector");
+    }
+}

Modules/ProgrammableModules/ProgrammableModule.cs

@@ -9,7 +9,7 @@ namespace Enigmos.Modules.ProgrammableModules;
 public abstract partial class ProgrammableModule : BaseModule, ICompositeModule, IProgrammableModule
 {
     public BaseBoard? UnderlyingBoard { get; set; }
-    public abstract IBaseModule[] SubModules();
+    public abstract IBaseModule[] SubModules { get; }
     public void EnterProgrammableBoard() => GlobalProvider.SceneProvider!.RootScene.ChangeScene(UnderlyingBoard!);
     public abstract IEnumerable<IBasePort> ExplicitPorts { get; }
     public abstract IEnumerable<IBasePort> ImplicitPorts { get; }
@@ -24,7 +24,7 @@ public abstract partial class ProgrammableModule : BaseModule, ICompositeModule,
         base.UpdateCables();
     }
 
-    protected T GetModule<T>(string path) where T : BaseModule, IInterlayerModule
+    protected T GetModule<T>(string path) where T : SubModule
     {
         T res = GetNode<T>(path);
         res.Init();

Modules/SubModule.cs

@@ -0,0 +1,13 @@
+using Godot;
+using Nocturnis.Enigmos.Modules;
+
+namespace Enigmos.Modules;
+
+public class SubModule : BaseModule
+{
+    public IBaseModule? ParentModule { get; set; }
+    public sealed override Vector2 PositionToBoard => 
+        base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
+    protected sealed override bool Draggable => false;
+    protected sealed override bool HasManual => false;
+}