move to new git server

Boards/BaseBoard.cs

@@ -6,6 +6,7 @@ using Nocturnis.DataStructures;
 using Nocturnis.Enigmos.Boards;
 using Nocturnis.Enigmos.Cables;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Controls;
 using Nocturnis.GlobalManagement.Providers;
@@ -37,7 +38,6 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
         foreach (BaseModule module in GetChildren().OfType<BaseModule>())
             if(module.HasLabel)
                 module.Label!.Visible = !mode;
-        
     }
 
     public void AddCable(IBaseCable cable)
@@ -46,25 +46,35 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
         cable.Modulate = Color.Color8(255, 255, 255, (Byte)(CableVisualMode ? 20 : 255));
     }
 
-    public IModuleManualLayer? ModuleManualLayer { get; set; }
+    public IModuleManualLayer ModuleManualLayer { get; set; }
     public bool ManualOpened { get; set; }
     protected HashSet<IBaseModule> Modules { get; set; } = new();
 
-    protected IEnumerable<ProgrammableModule> ProgrammableModules() =>
+    protected IEnumerable<ProgrammableModule> ProgrammableModules =>
         Modules
             .OfType<ProgrammableModule>();
 
     public IEnumerable<ITerminalModule> TerminalModules =>
         Modules
             .OfType<ITerminalModule>()
-            .Union(ProgrammableModules().SelectMany(module => module.UnderlyingBoard!.TerminalModules));
+            .Union(ProgrammableModules.SelectMany(module => module.UnderlyingBoard!.TerminalModules));
     
-    protected HashSet<IBasePort> Ports => Modules.SelectMany(module => module.Ports).ToHashSet();
+    public IPanelViewer PanelViewer { get; set; }
-    public IPanelViewer? PanelViewer { get; set; }
     public Dictionary<IBasePort, IBaseCable> CablePairing { get; set; } = new();
-    public IBasePort? ConnectPending { get; set; }
+
-    public IBoardControlLayer? CircuitBoardControlLayer { get; set; }
+    public IEnumerable<IBasePort> OnBoardPorts
-    public IModuleMovingLayer? ModuleMovingLayer { get; set; }
+    {
+        get
+        {
+            IEnumerable<IBasePort> res = Array.Empty<IBasePort>();
+            foreach (IInterlayerModule im in GetChildren().OfType<IInterlayerModule>())
+                res = res.Union(im.Ports);
+            return res;
+        }
+    }
+    public IBasePort ConnectPending { get; set; }
+    public IBoardControlLayer CircuitBoardControlLayer { get; set; }
+    public IModuleMovingLayer ModuleMovingLayer { get; set; }
 
     public virtual void Init()
     {
@@ -72,18 +82,13 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
         Modules = new HashSet<IBaseModule>();
         FocusedCables = new HashSet<IBaseCable>();
         ConnectPending = null;
-    }
         
-    public override void _Ready()
-    {
-        base._Ready();
         ModuleManualLayer = GetNode<IModuleManualLayer>("ModuleManualLayer");
         ModuleMovingLayer = GetNode<IModuleMovingLayer>("ModuleMovingLayer");
         ModuleMovingLayer.Board = this;
         PanelViewer = GetNode<IPanelViewer>("PanelViewer");
         CircuitBoardControlLayer = GetNode<IBoardControlLayer>("CircuitBoardControlLayer");
         CircuitBoardControlLayer.Board = this;
-        
     }
 
     protected virtual void AddModule(IBaseModule module, Vector2 pos)
@@ -105,55 +110,23 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
             pm.Board!.Reset();
         foreach (IControllingModule cm in Modules.OfType<IControllingModule>())
             cm.Visited = false;
+        foreach (ITerminalModule tm in Modules.OfType<ITerminalModule>())
+            tm.Finished = true;
         
-        
-        /*
-        foreach (IBaseModule module in Modules)
-        {
-            if (module is RootModule rootModule)
-                rootModule.ActionFinished = false;
-            if (module is ICompositeModule compositeModule)
-            {
-                foreach (IBaseModule subModule in compositeModule.SubModules())
-                {
-                    foreach (DataOutPort port in subModule.Ports.OfType<DataOutPort>())
-                    {
-                        port.DataUpdated = false;
-                    }
-                }
-            }
-
-            if (module is ProgrammableModule programmableModule)
-            {
-                programmableModule.UnderlyingBoard!.Reset();
-                foreach (DataOutPort outPort in programmableModule.ExplicitPorts.OfType<DataOutPort>())
-                    outPort.DataUpdated = false;
-                foreach (DataOutPort outPort in programmableModule.ImplicitPorts.OfType<DataOutPort>())
-                    outPort.DataUpdated = false;
-            }
-            if (module is PiplineModule controllingModule)
-                controllingModule.Visited = false;
-            if (module is TerminalModule terminalModule)
-                terminalModule.Finished = false;
-            
-            foreach (DataOutPort port in module.Ports.OfType<DataOutPort>())
-                port.DataUpdated = false;
-            
-        }*/
     }
     
     public override bool _CanDropData(Vector2 atPosition, Variant data)
     {
-        IVariantWithType vData = data.As<IVariantWithType>();
+        VariantWithType vData = data.As<VariantWithType>();
         if (vData.TypeHint != "Module")
         {
             if(vData.TypeHint != "Item")
                 return false;
-            IBaseItem item = vData.UnderlyingData.As<IBaseItem>();
+            IBaseItem item = vData.UnderlyingData.As<Node>() as IBaseItem;
             if (item is IBaseModuleItem moduleItem)
             {
                 foreach (IBaseModule module in Modules)
-                    if (GlobalProvider.UIProvider.Overlap(atPosition, moduleItem.ContentModule.Size, module.Position, module.Size))
+                    if (GlobalProvider.UIProvider!.Overlap(atPosition, moduleItem.ContentModule.Size, module.Position, module.Size))
                         return false;
                 return true;
             }
@@ -175,7 +148,7 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
     }
     public override void _DropData(Vector2 atPosition, Variant data)
     {
-        IVariantWithType vData = data.As<IVariantWithType>();
+        VariantWithType vData = data.As<VariantWithType>();
         if(vData.TypeHint == "Module")
         {
             BaseModule vModule = vData.UnderlyingData.As<BaseModule>();
@@ -184,7 +157,7 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
         }
         else
         {
-            IBaseModuleItem moduleItem = vData.UnderlyingData.As<IBaseModuleItem>();
+            IBaseModuleItem moduleItem = vData.UnderlyingData.As<Node>() as IBaseModuleItem;
             AddModule(moduleItem.ContentModule, atPosition);
             ItemDraggingControl.Instance.DraggingFrom!.Item = null;
         }
@@ -198,4 +171,17 @@ public abstract partial class BaseBoard : Panel, IBaseBoard
         res.Board = this;
         return res;
     }
+
+    public T[] GetModules<T>() where T : BaseModule
+    {
+        T[] res = GetChildren().OfType<T>().OrderBy(x => x.Name).ToArray();
+        foreach (T m in res)
+        {
+            m.Init();
+            Modules.Add(m);
+            m.Board = this;
+        }
+
+        return res;
+    }
 }

Boards/FilterModuleBoard.cs

@@ -1,25 +1,21 @@
 using Enigmos.Modules.InterlayerModules;
 using Enigmos.Modules.ProgrammableModules.FilterModule;
-using Nocturnis.Enigmos.Modules;
+using Nocturnis;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Boards;
-public partial class FilterModuleBoard : BaseBoard
+public partial class FilterModuleBoard : BaseBoard, ISceneConcept
 {
-    public IFilterModule? FilterModule { get; set; }
+    public FilterModule FilterModule { get; set; }
 
-    public FilterInputProviderModule? InputProvider { get; set; }
+    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 FilterIndicateModule Indicate { get; set; }
-    //public IDataInPort? Indicate { get; set; }
-    //public IndicateInputModule? Indicate { get; set; }
-    public FilterIndicateModule? Indicate { get; set; }
 
-    public void Init(IFilterModule filterModule)
+    public void Init(FilterModule filterModule)
     {
         base.Init();
         FilterModule = filterModule;
@@ -29,9 +25,8 @@ public partial class FilterModuleBoard : BaseBoard
         for (int i = 1; i <= 3; i++)
             FilterInputProxy[i - 1] = GetModule<InterlayerDataOutModule>($"IO{i}");
         base.Init();
-        //IterativeOutput = GetModule<XIterativeOutputModule>("IterativeOutput");
         Indicate = GetModule<FilterIndicateModule>("Indicate");
-        Indicate.Indicate!.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        Indicate.Indicate!.SetDataType(DataTypeConstant.BaseDataTypes.Bit);
     }
 
 }

Boards/FunctionModuleBoard.cs

@@ -1,8 +1,9 @@
 using Enigmos.Modules.InterlayerModules;
+using Nocturnis;
 
 namespace Enigmos.Boards;
 
-public partial class FunctionModuleBoard : BaseBoard
+public partial class FunctionModuleBoard : BaseBoard, ISceneConcept
 {
 	public InterlayerDataInModule[] DataIns { get; set; } = Array.Empty<InterlayerDataInModule>();
 	public InterlayerDataOutModule[] DataOuts { get; set; } = Array.Empty<InterlayerDataOutModule>();

Boards/OptimizationModuleBoard.cs

@@ -1,26 +1,27 @@
 using Enigmos.Modules.InterlayerModules;
-using Enigmos.Modules.Other;
 using Enigmos.Modules.ProgrammableModules.OptimizationModule;
-using Nocturnis.GlobalManagement.Constants;
+using Nocturnis;
 
 namespace Enigmos.Boards;
 
-public partial class OptimizationModuleBoard : BaseBoard
+public partial class OptimizationModuleBoard : BaseBoard, ISceneConcept
 {
     public OptimizationModule? OptimizationModule { get; set; }
 
     public OptimizationInputProviderModule? InputProvider { get; set; }
     public OptimizationSelectorModule? Selector { get; set; }
     public InterlayerDataOutModule[] ImplicitDataOuts { get; set; } = Array.Empty<InterlayerDataOutModule>();
-    public override void Init()
+    public void Init(OptimizationModule m)
     {
 
+        OptimizationModule = m;
         ImplicitDataOuts = new InterlayerDataOutModule[3];
         base.Init();
         for (int i = 0; i < 3; i++)
             ImplicitDataOuts[i] = GetModule<InterlayerDataOutModule>($"IO{i + 1}");
         InputProvider = GetModule<OptimizationInputProviderModule>("InputProvider");
         Selector = GetModule<OptimizationSelectorModule>("Selector");
-
+        InputProvider.Init(this);
+        Selector.Init();
     }
 }

Boards/PrimaryModuleBoard.cs

@@ -1,17 +1,18 @@
 using Enigmos.Modules.ControllingModules;
 using Enigmos.Modules.TerminalModules;
 using Nocturnis.Creatures;
+using Nocturnis.Enigmos.Boards;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Controls;
 
 namespace Enigmos.Boards;
 
-public partial class PrimaryModuleBoard : BaseBoard
+public partial class PrimaryModuleBoard : BaseBoard, IPrimaryModuleBoard
 {
-	private IBaseCreature? ManagedBy { get; set; }
+	private IBaseCreature ManagedBy { get; set; }
-	public IRootModule? Root { get; set; }
+	public IRootModule Root { get; set; }
-	public EngineModule? Engine { get; set; }
+	public IEngineModule Engine { get; set; }
 	
 
 	public void Init(IBaseCreature manager)
@@ -26,11 +27,10 @@ public partial class PrimaryModuleBoard : BaseBoard
 
 	public void Start()
 	{
-		if (!Root!.ActionFinished)
+		
-			return;
 		//Root.Timer = Stopwatch.StartNew();
-		Engine!.Drain();
+		Engine.Consume();
-		if (EnigmosControl.Instance.Energy < EnigmosConstant.IdlePower)
+		if (EnigmosControl.Instance.Energy < EnigmosControl.Instance.IdlePower)
 		{
 			Root!.ActionFinished = true;
 			EnigmosControl.Instance.ShutDownEngine();
@@ -38,15 +38,14 @@ public partial class PrimaryModuleBoard : BaseBoard
 		}
 		Root.Start();
 		foreach (ITerminalModule tm in TerminalModules)
-		{
 			tm.Consume();
 	}
 
+	public double IdlePower => Modules.Count * 0.05;
 	
-		//Root.RouteWithTimeoutHandle(Root);
+	public override void Reset()
-		//Root.Timer.Reset();
+	{
-		//foreach (TerminalModule module in TerminalModules())
+		base.Reset();
-		//	module.ConsumeWithTimeoutHandle(Root);
+		Root.ActionFinished = true;
 	}
-
 }

Cables/DataCable.cs

@@ -0,0 +1,33 @@
+using Godot;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Enigmos.Cables;
+
+public partial class DataCable : BaseCable
+{
+    public new IDataOutPort PortTo
+    {
+        get => (base.PortTo as IDataOutPort)!;
+        set => base.PortTo = value;
+    }
+
+    public new IDataInPort PortFrom
+    {
+        get => (base.PortFrom as IDataInPort)!;
+        set => base.PortFrom = value;
+    }
+
+    public override void LineUpdate()
+    {
+        Vector2 fromPosition = PortFrom.PositionToBoard;
+        Vector2 toPosition = PortTo.PositionToBoard;
+        Points = new[]
+        {
+            fromPosition, 
+            new Vector2((fromPosition.X + toPosition.X) / 2, fromPosition.Y),
+            new Vector2((fromPosition.X + toPosition.X) / 2, toPosition.Y), 
+            toPosition
+        };
+        InFill.Points = Points;
+    }
+}

Cables/SignalCable.cs

@@ -0,0 +1,32 @@
+using Godot;
+using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+
+namespace Enigmos.Cables;
+
+public partial class SignalCable : BaseCable
+{
+	public new ISignalOutPort PortTo
+	{
+		get => (base.PortTo as ISignalOutPort)!; 
+		set => base.PortTo = value;
+	}
+
+	public new ISignalInPort PortFrom
+	{
+		get => (base.PortFrom as ISignalInPort)!; 
+		set => base.PortFrom = value;
+	}
+	public override void LineUpdate()
+	{
+		Vector2 fromPosition = PortFrom.PositionToBoard;
+		Vector2 toPosition = PortTo.PositionToBoard;
+		Points = new []
+		{
+			fromPosition,
+			new Vector2(fromPosition.X, (fromPosition.Y + toPosition.Y) / 2),
+			new Vector2(toPosition.X, (fromPosition.Y + toPosition.Y) / 2),
+			toPosition
+		};
+		InFill.Points = Points;
+	}
+}

Enigmos.csproj

@@ -1,19 +1,23 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Godot.NET.Sdk/4.4.0-beta.1">
-
     <PropertyGroup>
-        <TargetFramework>net6.0</TargetFramework>
+        <EnableDynamicLoading>true</EnableDynamicLoading>
+        <TargetFramework>net9.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
-        <Nullable>enable</Nullable>
+        <Nullable>disable</Nullable>
+        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+        <GenerateTargetFrameworkAttribute>false</GenerateTargetFrameworkAttribute>
     </PropertyGroup>
 
     <ItemGroup>
-      <PackageReference Include="GodotSharp" Version="4.3.0-beta.2" />
+      <PackageReference Include="GodotSharp" Version="4.4.0-beta.1" />
+    </ItemGroup>
+    
+    <ItemGroup>
+      <Folder Include="Modules\InternalComputationalModule\" />
     </ItemGroup>
     
     <ItemGroup>
       <ProjectReference Include="..\Nocturnis\Nocturnis.csproj" />
-      <ProjectReference Include="..\TabulaSmaragdina\TabulaSmaragdina.csproj" />
-      <ProjectReference Include="..\VirtualChemistry\VirtualChemistry.csproj" />
     </ItemGroup>
 
 </Project>

Enigmos.sln

@@ -12,5 +12,9 @@ Global
 		{DD3504AF-4740-4B41-861C-F82C6C73C1C4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{DD3504AF-4740-4B41-861C-F82C6C73C1C4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{DD3504AF-4740-4B41-861C-F82C6C73C1C4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C0D139B4-BAC1-4AFE-AAB7-CCA6B3F581CC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C0D139B4-BAC1-4AFE-AAB7-CCA6B3F581CC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C0D139B4-BAC1-4AFE-AAB7-CCA6B3F581CC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C0D139B4-BAC1-4AFE-AAB7-CCA6B3F581CC}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

Manual/CommunicatorPairTab.cs

@@ -1,10 +1,11 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.Communicators;
 using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.Enigmos.Modules;
 
 namespace Enigmos.Manual;
-public partial class CommunicatorPairTab : Panel, IModuleManualTab
+public partial class CommunicatorPairTab : Panel, IModuleManualTab, ISceneConcept
 {
 	private bool InitFlag { get; set; }
 	public string FullName() => "Pair";

Manual/ErrorHandlerTab.cs

@@ -1,10 +1,11 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.Enigmos.Modules;
 
 namespace Enigmos.Manual;
 
-public partial class ErrorHandlerTab : Panel, IModuleManualTab
+public partial class ErrorHandlerTab : Panel, IModuleManualTab, ISceneConcept
 {
 	public string FullName() => "Error Handling";
 	private bool InitFlag { get; set; }

Manual/ModuleBoolValueParameterSetter.cs

@@ -1,9 +1,10 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures.ConfigurableParameters;
 
 namespace Enigmos.Manual;
 
-public partial class ModuleBoolValueParameterSetter : ModuleParameterSetter
+public partial class ModuleBoolValueParameterSetter : ModuleParameterSetter, ISceneConcept
 {
 	private CheckButton ToggleSetter { get; set; }
 	private Label TrueLabel { get; set; }

Manual/ModuleCharValueParameterSetter.cs

@@ -1,9 +1,10 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures.ConfigurableParameters;
 
 namespace Enigmos.Manual;
 
-public partial class ModuleCharValueParameterSetter : ModuleParameterSetter
+public partial class ModuleCharValueParameterSetter : ModuleParameterSetter, ISceneConcept
 {
 	private LineEdit CharInput { get; set; }
 	private Button Apply { get; set; }

Manual/ModuleKeyValueParameterSetter.cs

@@ -1,9 +1,10 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures.ConfigurableParameters;
 
 namespace Enigmos.Manual;
 
-public partial class ModuleKeyValueParameterSetter : ModuleParameterSetter
+public partial class ModuleKeyValueParameterSetter : ModuleParameterSetter, ISceneConcept
 {
 	public new IKeyParameter UnderlyingParameter
 	{

Manual/ModuleManual.cs

@@ -1,12 +1,12 @@
-using Enigmos.Modules.ProgrammableModules;
 using Godot;
+using Nocturnis;
 using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Manual;
 
-public partial class ModuleManual : Panel
+public abstract partial class ModuleManual : Panel, ISceneConcept, IModuleManual
 {
 	private bool InitFlag { get; set; }
 
@@ -22,9 +22,8 @@ public partial class ModuleManual : Panel
 	private TextureButton Close { get; set; }
 	private TabContainer ConfigurationTabs { get; set; }
 	private IBaseModule Module { get; set; }
-	private List<IModuleManualTab> Tabs { get; set; }
+	private List<IModuleManualTab> Tabs { get; set; } = new();
 	private LineEdit LabelString { get; set; }
-
 	public override void _Ready()
 	{
 		if(!InitFlag)
@@ -38,58 +37,47 @@ public partial class ModuleManual : Panel
 		LabelString = GetNode<LineEdit>("LabelString");
 		LabelString.Text = Module.LabelString;
 		Tabs = new List<IModuleManualTab>();
-		PortMaintenanceTab mainTab = GlobalProvider.SceneProvider
+
-			.AssetMapper<PortMaintenanceTab>()
+		PortMaintenanceTab mainTab =
-			.Instantiate<PortMaintenanceTab>();
+			GlobalProvider.ProcessProvider.BuildPortMaintenanceTab(Module) as PortMaintenanceTab;
-		mainTab.Init(Module);
 		Tabs.Add(mainTab);
 		ConfigurationTabs.AddChild(mainTab);
 		if (Module is IPolymorphismModule polyModule)
 		{
-			ModulePolymorphismTab polyTab = GlobalProvider.SceneProvider
+			ModulePolymorphismTab polyTab =
-				.AssetMapper<ModulePolymorphismTab>()
+				GlobalProvider.ProcessProvider.BuildModulePolymorphismTab(polyModule) as ModulePolymorphismTab;
-				.Instantiate<ModulePolymorphismTab>();
-			polyTab.Init(polyModule);
 			Tabs.Add(polyTab);
 			ConfigurationTabs.AddChild(polyTab);
 		}
-
 		if (Module is IParameterizedModule paraModule)
 		{
-			ModuleParameterTab paraTab = GlobalProvider.SceneProvider
+			
-				.AssetMapper<ModuleParameterTab>()
+			ModuleParameterTab paraTab = 
-				.Instantiate<ModuleParameterTab>();
+				GlobalProvider.ProcessProvider.BuildModuleParameterTab(paraModule) as ModuleParameterTab;
-			paraTab.Init(paraModule);
 			Tabs.Add(paraTab);
 			ConfigurationTabs.AddChild(paraTab);
 		}
 
 		if (Module is ICommunicateModule comModule)
 		{
-			CommunicatorPairTab pairTab = GlobalProvider.SceneProvider
+			
-				.AssetMapper<CommunicatorPairTab>()
+			CommunicatorPairTab pairTab =
-				.Instantiate<CommunicatorPairTab>();
+				GlobalProvider.ProcessProvider.BuildCommunicatorPairTab(comModule) as CommunicatorPairTab;
-			pairTab.Init(comModule);
 			Tabs.Add(pairTab);
 			ConfigurationTabs.AddChild(pairTab);
 		}
 
-		if (Module is ProgrammableModule programmableModule)
+		if (Module is IProgrammableModule progModule)
 		{
-			ProgrammableModuleSettingTab progTab =GlobalProvider.SceneProvider
+			ProgrammableModuleSettingTab progTab =
-				.AssetMapper<ProgrammableModuleSettingTab>()
+				GlobalProvider.ProcessProvider.BuildProgrammableModuleSettingTab(progModule) as ProgrammableModuleSettingTab;
-				.Instantiate<ProgrammableModuleSettingTab>();
-			progTab.Init(programmableModule);
 			Tabs.Add(progTab);
 			ConfigurationTabs.AddChild(progTab);
 		}
 
-		if (Module is IErrorHandlerModule errorHandlerModule)
+		if (Module is IErrorHandlerModule errModule)
 		{
-			ErrorHandlerTab errTab = GlobalProvider.SceneProvider
+			ErrorHandlerTab errTab = GlobalProvider.ProcessProvider.BuildErrorHandlerTab(errModule) as ErrorHandlerTab;
-				.AssetMapper<ErrorHandlerTab>()
-				.Instantiate<ErrorHandlerTab>();
-			errTab.Init(errorHandlerModule);
 			Tabs.Add(errTab);
 			ConfigurationTabs.AddChild(errTab);
 		}
@@ -110,4 +98,5 @@ public partial class ModuleManual : Panel
 		Module.Label.Text = label;
 		Module.LabelString = label;
 	}
+	
 }

Manual/ModuleParameterSetter.cs

@@ -3,7 +3,7 @@ using Nocturnis.DataStructures.ConfigurableParameters;
 
 namespace Enigmos.Manual;
 
-public abstract partial class ModuleParameterSetter : Control
+public abstract partial class ModuleParameterSetter : Control, IModuleParameterSetter
 {
     protected bool InitFlag { get; set; }
     public IConfigurableParameter UnderlyingParameter { get; set; }

Manual/ModuleParameterTab.cs

@@ -1,4 +1,5 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures.ConfigurableParameters;
 using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.Enigmos.Modules;
@@ -6,7 +7,7 @@ using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Manual;
 
-public partial class ModuleParameterTab : Panel, IModuleManualTab
+public partial class ModuleParameterTab : Panel, IModuleManualTab, ISceneConcept
 {
 	public string FullName() => "Parameter";
 	private bool InitFlag { get; set; }
@@ -18,11 +19,7 @@ public partial class ModuleParameterTab : Panel, IModuleManualTab
 
 	public IParameterizedModule Module { get; set; }
 
-	private static readonly PackedScene RealParameterSetterScene =
-		GlobalProvider.SceneProvider.AssetMapper<ModuleRealValueParameterSetter>();
 
-	private static readonly PackedScene BoolParameterSetterScene = 
-		GlobalProvider.SceneProvider.AssetMapper<ModuleBoolValueParameterSetter>();
 	private VBoxContainer Parameters { get; set; }
 	public override void _Ready()
 	{
@@ -33,35 +30,27 @@ public partial class ModuleParameterTab : Panel, IModuleManualTab
 		{
 			if(parameter is IDoubleParameter doubleParameter)
 			{
-				ModuleRealValueParameterSetter setter =
+				ModuleRealValueParameterSetter setter = GlobalProvider.ProcessProvider
-					RealParameterSetterScene.Instantiate<ModuleRealValueParameterSetter>();
+					.BuildModuleRealValueParameterSetter(doubleParameter) as ModuleRealValueParameterSetter;
-				setter.Init(doubleParameter);
 				Parameters.AddChild(setter);
 			}
 
 			else if (parameter is IBoolParameter boolParameter)
 			{
-				ModuleBoolValueParameterSetter setter =
+				ModuleBoolValueParameterSetter setter = GlobalProvider.ProcessProvider
-					BoolParameterSetterScene.Instantiate<ModuleBoolValueParameterSetter>();
+					.BuildModuleBoolValueParameterSetter(boolParameter) as ModuleBoolValueParameterSetter;
-				setter.Init(boolParameter);
 				Parameters.AddChild(setter);
 			}
 			else if (parameter is ICharParameter charParameter)
 			{
-				ModuleCharValueParameterSetter setter =
+				ModuleCharValueParameterSetter setter = GlobalProvider.ProcessProvider
-					GlobalProvider.SceneProvider
+					.BuildModuleCharValueParameterSetter(charParameter) as ModuleCharValueParameterSetter;
-						.AssetMapper<ModuleCharValueParameterSetter>()
-						.Instantiate<ModuleCharValueParameterSetter>();
-				setter.Init(charParameter);
 				Parameters.AddChild(setter);
 			}
 			else if (parameter is IKeyParameter keyParameter)
 			{
-				ModuleKeyValueParameterSetter setter = 
+				ModuleKeyValueParameterSetter setter = GlobalProvider.ProcessProvider
-					GlobalProvider.SceneProvider
+					.BuildModuleKeyValueParameterSetter(keyParameter) as ModuleKeyValueParameterSetter;
-						.AssetMapper<ModuleKeyValueParameterSetter>()
-						.Instantiate<ModuleKeyValueParameterSetter>();
-				setter.Init(keyParameter);
 				Parameters.AddChild(setter);
 			}
 		}

Manual/ModulePolymorphismTab.cs

@@ -1,4 +1,5 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.Enigmos.Modules;
@@ -6,7 +7,7 @@ using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Manual;
 
-public partial class ModulePolymorphismTab : Panel, IModuleManualTab
+public partial class ModulePolymorphismTab : Panel, IModuleManualTab, ISceneConcept
 {
 	private bool InitFlag { get; set; }
 
@@ -17,9 +18,6 @@ public partial class ModulePolymorphismTab : Panel, IModuleManualTab
 	}
 
 	public string FullName() => "Polymorphism";
-
-	private static readonly PackedScene PortTypeSelectorScene = 
-		GlobalProvider.SceneProvider.AssetMapper<PortTypeSelector>();
 	public IPolymorphismModule Module { get; set; }
 	private VBoxContainer PortGroups { get; set; }
 
@@ -30,8 +28,7 @@ public partial class ModulePolymorphismTab : Panel, IModuleManualTab
 		PortGroups = GetNode<VBoxContainer>("ScrolledItems/PortGroups");
 		foreach (IDataPortGroup group in Module.ConfigurablePortGroups)
 		{
-			PortTypeSelector selector = PortTypeSelectorScene.Instantiate<PortTypeSelector>();
+			PortTypeSelector selector = GlobalProvider.ProcessProvider.BuildPortTypeSelector(group) as PortTypeSelector;
-			selector.Init(group);
 			PortGroups.AddChild(selector);
 		}
 		Name = "Poly";

Manual/ModuleRealValueParameterSetter.cs

@@ -1,9 +1,10 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures.ConfigurableParameters;
 
 namespace Enigmos.Manual;
 
-public partial class ModuleRealValueParameterSetter : ModuleParameterSetter
+public partial class ModuleRealValueParameterSetter : ModuleParameterSetter, ISceneConcept
 {
 	public void Init(IDoubleParameter parameter)
 	{

Manual/PortMaintenanceTab.cs

@@ -1,13 +1,13 @@
 using Enigmos.Modules.ProgrammableModules;
 using Godot;
+using Nocturnis;
 using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports;
-using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Manual;
 
-public partial class PortMaintenanceTab : Panel, IModuleManualTab
+public abstract partial class PortMaintenanceTab : Panel, IModuleManualTab, ISceneConcept
 {
 	private bool InitFlag { get; set; }
 
@@ -18,7 +18,10 @@ public partial class PortMaintenanceTab : Panel, IModuleManualTab
 	}
 
 	public string FullName() => "Maintenance";
-	private static readonly PackedScene PortFixerScene = GlobalProvider.SceneProvider!.AssetMapper<PortFixer>();
+
+	protected abstract PortFixer PortFixerInstantiate();
+
+
 	/// <summary>
 	/// Should Be Assigned Before This Tab Been Added As Child To Tab Container
 	/// </summary>
@@ -31,7 +34,7 @@ public partial class PortMaintenanceTab : Panel, IModuleManualTab
 		Ports = GetNode<VBoxContainer>("ScrolledItems/Ports");
 		foreach (IBasePort port in Module!.Ports)
 		{
-			PortFixer fixer = PortFixerScene.Instantiate<PortFixer>();
+			PortFixer fixer = PortFixerInstantiate();
 			fixer.Init(port);
 			Ports.AddChild(fixer);
 		}
@@ -39,18 +42,18 @@ public partial class PortMaintenanceTab : Panel, IModuleManualTab
 		if (Module is ProgrammableModule programmableModule)
 		{
 			HashSet<string> used = new HashSet<string>();
-			foreach (IBasePort port in programmableModule.ExplicitPorts)
+			foreach (IBasePort port in programmableModule.Ports)
 			{
 				int i = 0;
 				while (used.Contains("Exterior" + port.Name + $"#{i}"))
 					i++;
 				used.Add("Exterior" + port.Name + $"#{i}");
 				port.Name = "Exterior" + port.Name + $"#{i}";
-				PortFixer fixer = PortFixerScene.Instantiate<PortFixer>();
+				PortFixer fixer = PortFixerInstantiate();
 				fixer.Init(port);
 				Ports.AddChild(fixer);
 			}
-			foreach (IBasePort port in programmableModule.ImplicitPorts)
+			foreach (IBasePort port in programmableModule.Board!.OnBoardPorts)
 			{
 				string baseName = port.Name.ToString().Replace("Empty", "Interior");
 				int i = 0;
@@ -58,7 +61,7 @@ public partial class PortMaintenanceTab : Panel, IModuleManualTab
 					i++;
 				used.Add(baseName + $"#{i}");
 				port.Name = baseName + $"#{i}";
-				PortFixer fixer = PortFixerScene.Instantiate<PortFixer>();
+				PortFixer fixer = PortFixerInstantiate();
 				fixer.Init(port);
 				Ports.AddChild(fixer);
 			}

Manual/PortTypeSelector.cs

@@ -1,10 +1,12 @@
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Manual;
 
-public partial class PortTypeSelector : Control
+public partial class PortTypeSelector : Control, ISceneConcept, IPortTypeSelector
 {
 	private bool InitFlag { get; set; }
 
@@ -17,20 +19,20 @@ public partial class PortTypeSelector : Control
 	/// <summary>
 	/// Underlying Group must be set before _Ready
 	/// </summary>
-	public IDataPortGroup? UnderlyingGroup { get; set; }
+	public IDataPortGroup UnderlyingGroup { get; set; }
-	private Label? Description { get; set; }
+	private Label Description { get; set; }
-	private OptionButton? TypeOptions { get; set; }
+	private OptionButton TypeOptions { get; set; }
 	public override void _Ready()
 	{
 		if (!InitFlag)
 			throw new Exception("TODO - NEED INIT");
 		Description = GetNode<Label>("Description");
 		TypeOptions = GetNode<OptionButton>("TypeOptions");
-		TypeOptions.Clear();
+		TypeOptions!.Clear();
-		for (int idx = 0; idx < UnderlyingGroup!.TypeOptions.Length; idx++)
+		for (int idx = 0; idx < UnderlyingGroup!.TypeOptions.Count; idx++)
-			TypeOptions.AddIconItem(GlobalProvider.EnigmosProvider!.DataPortTypeMap[UnderlyingGroup.TypeOptions[idx]], "", idx);
+			TypeOptions.AddIconItem(GlobalProvider.DataTypeTexture[UnderlyingGroup.TypeOptions[idx].Type], "", idx);
 		Description.Text = UnderlyingGroup.Description;
-		TypeOptions.Select(Array.IndexOf(UnderlyingGroup.TypeOptions, UnderlyingGroup.SelectedType));
+		TypeOptions.Select(UnderlyingGroup.TypeOptions.IndexOf(UnderlyingGroup.SelectedType));
 	}
 
 	private void SetType(int index)

Manual/ProgrammableModuleSettingTab.cs

@@ -1,17 +1,19 @@
-using Enigmos.Modules.ProgrammableModules;
 using Godot;
+using Nocturnis;
 using Nocturnis.Enigmos.ModuleManuals;
+using Nocturnis.Enigmos.Modules;
 using Nocturnis.GlobalManagement.Providers;
+using Nocturnis.Godot;
 
 namespace Enigmos.Manual;
 
-public partial class ProgrammableModuleSettingTab : Panel, IModuleManualTab
+public abstract partial class ProgrammableModuleSettingTab : Panel, IModuleManualTab, ISceneConcept
 {
-	private ProgrammableModule? Module { get; set; }
+	private IProgrammableModule Module { get; set; }
 
-	private Button? EditModule { get; set; }
+	private Button EditModule { get; set; }
 
-	public void Init(ProgrammableModule module)
+	public void Init(IProgrammableModule module)
 	{
 		Module = module;
 	}
@@ -27,6 +29,7 @@ public partial class ProgrammableModuleSettingTab : Panel, IModuleManualTab
 
 	private void EnterProgrammableBoard()
 	{
-		GlobalProvider.SceneProvider!.RootScene.ChangeScene(Module!.UnderlyingBoard);
+		GlobalProvider.SceneProvider!.RootScene.ChangeScene(Module!.UnderlyingBoard.AsNode());
 	}
+	
 }

Modules/BaseModule.cs

@@ -1,14 +1,13 @@
-using Enigmos.Exceptions;
-using Enigmos.Manual;
-using Enigmos.Ports;
 using Godot;
+using Nocturnis;
 using Nocturnis.DataStructures;
 using Nocturnis.Enigmos.Boards;
 using Nocturnis.Enigmos.Cables;
+using Nocturnis.Enigmos.ModuleManuals;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Providers;
-using Nocturnis.UIElements;
+using Nocturnis.Godot;
 
 namespace Enigmos.Modules;
 
@@ -17,19 +16,21 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
     [Export] private int PresetPortQuality { get; set; }
     [Export] private int PresetPortCondition { get; set; }
     [Export] protected bool UsingPreset { get; set; }
-    [Export] public IPresetModuleConnection[] PresetConnections { get; set; } = Array.Empty<IPresetModuleConnection>();
+    //[Export] 
+    public IPresetModuleConnection[] PresetConnections { get; set; } = Array.Empty<IPresetModuleConnection>();
     [Export] public string LabelString { get; set; } = "";
 
     public virtual Vector2 PositionToBoard => Position;
     protected virtual bool Draggable => true;
     protected virtual bool HasManual => true;
     public bool HasLabel => HasManual;
-    public virtual IEnumerable<IBasePort> Ports => Array.Empty<BasePort>();
+    public virtual IEnumerable<IBasePort> Ports => GetChildren().OfType<IBasePort>();
 
-    public IBaseBoard? Board { get; set; }
+    public IBaseBoard Board { get; set; }
-    private ModuleManual? Manual { get; set; }
+    public IModuleManual Manual { get; set; }
-    public ISimpleLabel? Label { get; set; }
+    public Label Label { get; set; }
     public Node AsNode => this;
+
     public virtual void PresetValueInit()
     {
         foreach (IBasePort port in Ports)
@@ -45,12 +46,11 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
     {
         if (HasLabel)
         {
-            Label = GlobalProvider.SceneProvider!
+            Label = new Label();
-                .AssetMapper<ISimpleLabel>()
+            Label.AddThemeFontOverride("font", GlobalProvider.Font);
-                .Instantiate<ISimpleLabel>();
             Label.Position = new Vector2(0, -25);
             Label.Text = LabelString;
-            AddChild(Label.AsNode);
+            AddChild(Label);
         }
     }
 
@@ -84,15 +84,6 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
             PresetValueInit();
     }
 
-    protected virtual void TimeoutCheck(IRootModule root)
-    {
-        if (root.Timer!.ElapsedMilliseconds < 25) return;
-        root.Timer.Stop();
-        throw ModuleExecutionTimeout.Exception;
-    }
-
-    protected virtual void TimeoutHandler(ModuleExecutionTimeout timeout) => throw timeout;
-    
     public override Variant _GetDragData(Vector2 atPosition)
     {
         if (!Draggable)
@@ -101,15 +92,6 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
         Board!.ModuleMovingLayer.MouseOffset = GetLocalMousePosition();
         return GlobalProvider.DataStructureProvider!.NewVariantWithType("Module", this);
     }
-
-
-    /*protected T GetPort<T>(string path) where T : BasePort
-    {
-        T res = GetNode<T>(path);
-        res.Init();
-        return res;
-    }*/
-
     public override void _Input(InputEvent @event)
     {
         if (@event is InputEventMouseButton eventMouseButton)
@@ -119,19 +101,11 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
             {
                 if (eventMouseButton.ButtonIndex == MouseButton.Right && eventMouseButton.Pressed)
                 {
-                    if (!HasManual)
+                    if (!HasManual || Board!.ManualOpened)
-                        return;
-                    if (Board!.ManualOpened)
                         return;
                     if (Manual == null)
-                    {
+                        GlobalProvider.ProcessProvider.BuildManual(this);
-                        Manual = GlobalProvider.SceneProvider!
+                    Board.ModuleManualLayer!.AddChild(Manual.AsNode());
-                            .AssetMapper<ModuleManual>()
-                            .Instantiate<ModuleManual>();
-                        Manual.Init(this);
-                    }
-
-                    Board.ModuleManualLayer!.AddChild(Manual);
                     Manual.Position = Board.ModuleManualLayer.ManualPosition.Position - Manual.Size / 2;
                     Board.ManualOpened = true;
                     return;
@@ -148,7 +122,8 @@ 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);
@@ -159,4 +134,6 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
 
         base._Input(@event);
     }
+    
+    public abstract Texture2D PreviewTexture { get; }
 }

Modules/CompositeModule.cs

@@ -0,0 +1,41 @@
+using Enigmos.Modules.SubModules;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+
+namespace Enigmos.Modules;
+
+public abstract partial class CompositeModule : BaseModule, ICompositeModule
+{
+    public IBaseModule[] SubModules => GetChildren().OfType<IBaseModule>().ToArray();
+
+    public override IEnumerable<IBasePort> Ports
+    {
+        get
+        {
+            IEnumerable<IBasePort> res = base.Ports;
+            foreach (IBaseModule bm in SubModules)
+                res = res.Union(bm.Ports);
+            return res;
+        }
+    }
+    protected T GetModule<T>(string path) where T : SubModule
+    {
+        T res = GetNode<T>(path);
+        res.Init();
+        res.ParentModule = this;
+        res.Board = Board;
+        return res;
+    }
+
+    protected T[] GetModules<T>() where T : SubModule
+    {
+        T[] res = SubModules.OfType<T>().OrderBy(x => x.Name).ToArray();
+        foreach (T m in res)
+        {
+            m.Init();
+            m.ParentModule = this;
+            m.Board = Board;
+        }
+        return res;
+    }
+}

Modules/ComputationalModules/Binary/AdditionModule.cs

@@ -1,20 +1,18 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class AdditionModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class AdditionModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
 	private IDataInGroup? InputGroup { get; set; }
 	private IDataOutGroup? OutputGroup { get; set; }
 	
-	public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
 	public override double MaintenanceAlpha => 0.19572021d;
 	public override double MaintenanceBeta => 0.20151779d;
 	public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
@@ -28,15 +26,15 @@ public partial class AdditionModule : BinaryComputationalModule, IPolymorphismMo
 			this,
 			DataInPorts,
 			"",
-			EnigmosConstant.DataPortTypes.Real,
+			DataTypeConstant.BaseDataTypes.Real,
-			Array.Empty<StringName>()
+			DataTypeConstant.DataTypeOptions.TensorTypes
 		);
-		OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
+		OutputGroup = GlobalProvider.DataStructureProvider!.NewDataOutGroup(
 			this,
 			DataOutPorts,
 			"Output Port Type",
-			EnigmosConstant.DataPortTypes.Real,
+			DataTypeConstant.BaseDataTypes.Real,
-			EnigmosConstant.DataPortTypes.AnyTensor
+			DataTypeConstant.DataTypeOptions.TensorTypes
 		);
 		ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
 		PostInit();
@@ -47,7 +45,7 @@ public partial class AdditionModule : BinaryComputationalModule, IPolymorphismMo
 	public override string GetDescription => GlobalProvider.EnigmosProvider!.ModuleDescription<AdditionModule>();
 	public override void Define()
 	{
-		(object, StringName) Proxy(CacheItem cache) => 
+		(object, DataType) Proxy(CacheItem cache) => 
 			GlobalProvider.PolymorphismProvider!.Add(this.X(cache), this.Y(cache));
 		this.Define(Proxy);
 	}

Modules/ComputationalModules/Binary/BinaryLogicModule.cs

@@ -1,12 +1,11 @@
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
 public abstract partial class BinaryLogicModule : BinaryComputationalModule, ILogicModule, IDuplicateOutputModule
 {
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
+
     public override void Init()
     {
         base.Init();

Modules/ComputationalModules/Binary/ComparisionModule.cs

@@ -1,29 +1,27 @@
 using Nocturnis.DataStructures.ConfigurableParameters;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ComparisionModule : BinaryComputationalModule,
+public abstract partial class ComparisionModule : BinaryComputationalModule,
 	IParameterizedModule, 
 	IDuplicateOutputModule,
 	IOperationModule
 {
-	private IBoolParameter? Greater { get; set; }
+	private IBoolParameter Greater { get; set; }
-	public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
 	public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
 
 	public override void Init()
 	{
 		base.Init();
 		this.DataOutInit("Output",1);
-		this.SetInputType(EnigmosConstant.DataPortTypes.Real);
+		this.SetInputType(DataTypeConstant.BaseDataTypes.Real);
-		this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
+		this.SetOutputType(DataTypeConstant.BaseDataTypes.Real);
 		Greater = GlobalProvider.DataStructureProvider!.NewBoolParameter("Method", "gt", "lt", true);
-		ConfigurableParameters = new HashSet<IConfigurableParameter>() { Greater };
+		ConfigurableParameters = new HashSet<IConfigurableParameter> { Greater };
 		PostInit();
 	}
 
@@ -32,8 +30,8 @@ public partial class ComparisionModule : BinaryComputationalModule,
 	{
 		this.Define(
 			cache => (
-				!(Greater!.ParameterValue ^ (this.X(cache).Double > this.Y(cache).Double)),
+				!(Greater!.ParameterValue ^ (this.X(cache).Real > this.Y(cache).Real)),
-				EnigmosConstant.DataPortTypes.Bit
+				DataTypeConstant.BaseDataTypes.Bit
 			)
 		);
 	}

Modules/ComputationalModules/Binary/ControlledOutputModule.cs

@@ -1,20 +1,19 @@
 using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ControlledOutputModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class ControlledOutputModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
     [Export] private StringName? PresetDataType { get; set; }
     private IDataOutGroup? OutputGroup { get; set; }
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public void Inference() => DataInPorts[1].SetDataType(OutputGroup!.SelectedType);
     public override void Init()
     {
@@ -24,22 +23,22 @@ public partial class ControlledOutputModule : BinaryComputationalModule, IPolymo
             this,
             DataOutPorts,
             "Output Data Type",
-            UsingPreset ? PresetDataType! : EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.AnyType
+            DataTypeConstant.DataTypeOptions.AnyType
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
-        DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        DataInPorts[0].SetDataType(DataTypeConstant.BaseDataTypes.Bit);
-        DataInPorts[1].SetDataType(EnigmosConstant.DataPortTypes.Real);
+        DataInPorts[1].SetDataType(DataTypeConstant.BaseDataTypes.Real);
         PostInit();
     }
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache)
+        (object, DataType) Func(CacheItem cache)
         {
             if (this.X(cache).Bit) 
                 return (this.Y(cache).Data!, this.Y(cache).Type!);
-            return (0, EnigmosConstant.DataPortTypes.Null);
+            return (0, DataTypeConstant.BaseDataTypes.Null);
         }
 
         this.Define(Func);

Modules/ComputationalModules/Binary/DivisionModule.cs

@@ -1,21 +1,19 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class DivisionModule : BinaryComputationalModule, 
+public abstract partial class DivisionModule : BinaryComputationalModule, 
     IPolymorphismModule,
     IDuplicateOutputModule
 {
     private IDataInGroup? InputGroup { get; set; }
     private IDataOutGroup? OutputGroup { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
@@ -26,15 +24,15 @@ public partial class DivisionModule : BinaryComputationalModule,
             this,
             DataInPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "Output Port Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.NumericTypes
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
         PostInit();
@@ -42,7 +40,7 @@ public partial class DivisionModule : BinaryComputationalModule,
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => 
+        (object, DataType) Func(CacheItem cache) => 
             GlobalProvider.PolymorphismProvider!.Div(this.X(cache), this.Y(cache));
         this.Define(Func);
     }

Modules/ComputationalModules/Binary/DotProductModule.cs

@@ -1,20 +1,17 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class DotProductModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class DotProductModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
     private IDataInGroup? VectorInputGroup { get; set; }
     private IDataOutGroup? OutputGroup { get; set; }
-
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
@@ -25,15 +22,15 @@ public partial class DotProductModule : BinaryComputationalModule, IPolymorphism
             this,
             DataInPorts,
             "Vector Input Type",
-            EnigmosConstant.DataPortTypes.R2,
+            DataTypeConstant.BaseDataTypes.R2,
-            EnigmosConstant.DataPortTypes.VectorTypes
+            DataTypeConstant.DataTypeOptions.VectorTypes
         );
         OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { VectorInputGroup };
         PostInit();
@@ -41,17 +38,17 @@ public partial class DotProductModule : BinaryComputationalModule, IPolymorphism
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) =>
+        (object, DataType) Func(CacheItem cache) =>
             GlobalProvider.PolymorphismProvider!.Dot(this.X(cache), this.Y(cache));
         this.Define(Func);
     }
 
     public void Inference()
     {
-        if (GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(VectorInputGroup!.SelectedType))
+        if (GlobalProvider.DataTypeProvider!.IsComplexTensorType(VectorInputGroup!.SelectedType))
-            OutputGroup!.SelectedType = EnigmosConstant.DataPortTypes.Complex;
+            OutputGroup!.SelectedType = DataTypeConstant.BaseDataTypes.Complex;
         else
-            OutputGroup!.SelectedType = EnigmosConstant.DataPortTypes.Real;
+            OutputGroup!.SelectedType = DataTypeConstant.BaseDataTypes.Real;
     }
 
 }

Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs

@@ -1,16 +1,16 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalAlternativeDenialModule : BinaryLogicModule
+public abstract partial class LogicalAlternativeDenialModule : BinaryLogicModule
 {
 	public override void Define()
 	{
-		(object, StringName) Func(CacheItem cache) =>
+		(object, DataType) Func(CacheItem cache) =>
-			(!this.X(cache).Bit | !this.Y(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+			(!this.X(cache).Bit | !this.Y(cache).Bit, DataTypeConstant.BaseDataTypes.Bit);
 		this.Define(Func);
 	}
 

Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs

@@ -1,16 +1,16 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalBiconditionalModule : BinaryLogicModule
+public abstract partial class LogicalBiconditionalModule : BinaryLogicModule
 {
 	public override void Define()
 	{
-		(object, StringName) Func(CacheItem cache) =>
+		(object, DataType) Func(CacheItem cache) =>
-			(!(this.X(cache).Bit ^ this.Y(cache).Bit), EnigmosConstant.DataPortTypes.Bit);
+			(!(this.X(cache).Bit ^ this.Y(cache).Bit), DataTypeConstant.BaseDataTypes.Bit);
 
 		this.Define(Func);
 

Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs

@@ -1,11 +1,11 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalConjunctionModule : BinaryLogicModule
+public abstract partial class LogicalConjunctionModule : BinaryLogicModule
 {
 
 
@@ -13,8 +13,8 @@ public partial class LogicalConjunctionModule : BinaryLogicModule
 	{
 		var x = DataOutPorts.Length;
 
-		(object, StringName) Func(CacheItem cache) =>
+		(object, DataType) Func(CacheItem cache) =>
-			(this.X(cache).Bit & this.Y(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+			(this.X(cache).Bit & this.Y(cache).Bit, DataTypeConstant.BaseDataTypes.Bit);
 		this.Define(Func);
 	}
 

Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs

@@ -1,17 +1,17 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalDisjunctionModule : BinaryLogicModule
+public abstract partial class LogicalDisjunctionModule : BinaryLogicModule
 {
 
 	public override void Define()
 	{
-		(object, StringName) Func(CacheItem x) =>
+		(object, DataType) Func(CacheItem x) =>
-			(this.X(x).Bit | this.Y(x).Bit, EnigmosConstant.DataPortTypes.Bit); 
+			(this.X(x).Bit | this.Y(x).Bit, DataTypeConstant.BaseDataTypes.Bit); 
 		this.Define(Func);
 	}
 

Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs

@@ -1,16 +1,16 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalExclusiveDisjunctionModule : BinaryLogicModule
+public abstract partial class LogicalExclusiveDisjunctionModule : BinaryLogicModule
 {
 	public override void Define()
 	{
-		(object, StringName) Func(CacheItem cache)
+		(object, DataType) Func(CacheItem cache)
-			=> (this.X(cache).Bit ^ this.Y(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+			=> (this.X(cache).Bit ^ this.Y(cache).Bit, DataTypeConstant.BaseDataTypes.Bit);
 		this.Define(Func);
 	}
 

Modules/ComputationalModules/Binary/LogicalImplicationModule.cs

@@ -3,12 +3,12 @@ using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalImplicationModule : BinaryLogicModule
+public abstract partial class LogicalImplicationModule : BinaryLogicModule
 {
 	public override void Define()
 	{
 		this.Define(
-			x => (!this.X(x).Bit | this.Y(x).Bit, EnigmosConstant.DataPortTypes.Bit)
+			x => (!this.X(x).Bit | this.Y(x).Bit, DataTypeConstant.BaseDataTypes.Bit)
 		);
 	}
 }

Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs

@@ -3,7 +3,7 @@ using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalJointDenialModule : BinaryLogicModule
+public abstract partial class LogicalJointDenialModule : BinaryLogicModule
 {
     public override void Define()
     {
@@ -11,7 +11,7 @@ public partial class LogicalJointDenialModule : BinaryLogicModule
             x =>
             (
                 !this.X(x).Bit & !this.Y(x).Bit,
-                EnigmosConstant.DataPortTypes.Bit
+                DataTypeConstant.BaseDataTypes.Bit
             )
         );
     }

Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs

@@ -1,16 +1,16 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalNonimplicationModule : BinaryLogicModule
+public abstract partial class LogicalNonimplicationModule : BinaryLogicModule
 {
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => 
+        (object, DataType) Func(CacheItem cache) => 
-            (this.X(cache).Bit & !this.Y(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+            (this.X(cache).Bit & !this.Y(cache).Bit, DataTypeConstant.BaseDataTypes.Bit);
         this.Define(Func);
     }
     

Modules/ComputationalModules/Binary/MaxModule.cs

@@ -1,30 +1,28 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class MaxModule : BinaryComputationalModule, IOperationModule, IDuplicateOutputModule
+public abstract partial class MaxModule : BinaryComputationalModule, IOperationModule, IDuplicateOutputModule
 {
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public override void Init()
     {
         base.Init();
         this.DataOutInit("Output", 3);
-        this.SetInputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetInputType(DataTypeConstant.BaseDataTypes.Real);
-        this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetOutputType(DataTypeConstant.BaseDataTypes.Real);
         PostInit();
     }
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache)
+        (object, DataType) Func(CacheItem cache)
         {
-            if (this.X(cache).Double > this.Y(cache).Double)
+            if (this.X(cache).Real > this.Y(cache).Real)
-                return (this.X(cache), EnigmosConstant.DataPortTypes.Real);
+                return (this.X(cache), DataTypeConstant.BaseDataTypes.Real);
-            return (this.Y(cache), EnigmosConstant.DataPortTypes.Real);
+            return (this.Y(cache), DataTypeConstant.BaseDataTypes.Real);
         }
         this.Define(Func);
     }

Modules/ComputationalModules/Binary/MinModule.cs

@@ -1,28 +1,26 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class MinModule : BinaryComputationalModule, IDuplicateOutputModule, IOperationModule
+public abstract partial class MinModule : BinaryComputationalModule, IDuplicateOutputModule, IOperationModule
 {
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public override void Init()
     {
         base.Init();
         this.DataOutInit("Output", 3);
-        this.SetInputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetInputType(DataTypeConstant.BaseDataTypes.Real);
-        this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetOutputType(DataTypeConstant.BaseDataTypes.Real);
         PostInit();
     }
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache)
+        (object, DataType) Func(CacheItem cache)
         {
-            if (this.X(cache).Double < this.Y(cache).Double)
+            if (this.X(cache).Real < this.Y(cache).Real)
                 return (this.X(cache).Data!, this.X(cache).Type!);
             return (this.Y(cache).Data!, this.Y(cache).Type!);
         }

Modules/ComputationalModules/Binary/MultiplicationModule.cs

@@ -1,20 +1,17 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class MultiplicationModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class MultiplicationModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
     private IDataPortGroup? InputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
-
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
@@ -26,15 +23,15 @@ public partial class MultiplicationModule : BinaryComputationalModule, IPolymorp
             this,
             DataInPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "Output Port Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.NumericTypes
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
         PostInit();
@@ -42,7 +39,7 @@ public partial class MultiplicationModule : BinaryComputationalModule, IPolymorp
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => 
+        (object, DataType) Func(CacheItem cache) => 
             GlobalProvider.PolymorphismProvider!.Mul(this.X(cache), this.Y(cache));
         this.Define(Func);
     }

Modules/ComputationalModules/Binary/PowerModule.cs

@@ -1,8 +1,7 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
@@ -10,11 +9,10 @@ using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class PowerModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class PowerModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
     private IDataPortGroup? TensorInputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
@@ -25,16 +23,16 @@ public partial class PowerModule : BinaryComputationalModule, IPolymorphismModul
             this,
             new IDataInPort[] { DataInPorts[0] },
             "Base Tensor Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.NumericTypes
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
-        DataInPorts[1].SetDataType(EnigmosConstant.DataPortTypes.Complex);
+        DataInPorts[1].SetDataType(DataTypeConstant.BaseDataTypes.Complex);
         OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { TensorInputGroup };
         PostInit();
@@ -42,11 +40,11 @@ public partial class PowerModule : BinaryComputationalModule, IPolymorphismModul
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.Pow(this.X(cache), this.Y(cache));
+        (object, DataType) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.Pow(this.X(cache), this.Y(cache));
         this.Define(Func);
     }
 
     public void Inference() => 
-        OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.ComplexVersionOf(TensorInputGroup!.SelectedType);
+        OutputGroup!.SelectedType = GlobalProvider.DataTypeProvider!.ComplexVersionOf(TensorInputGroup!.SelectedType);
 
 }

Modules/ComputationalModules/Binary/ScalarDivisionModule.cs

@@ -1,8 +1,7 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
@@ -10,14 +9,13 @@ using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ScalarDivisionModule : BinaryComputationalModule, 
+public abstract partial class ScalarDivisionModule : BinaryComputationalModule, 
     IPolymorphismModule,
     IDuplicateOutputModule
 {
     private IDataPortGroup? ScalarInputGroup { get; set; }
     private IDataPortGroup? TensorInputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public override double MaintenanceAlpha => 0.77852142d;
     public override double MaintenanceBeta => 0.9544432d;
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
@@ -30,22 +28,22 @@ public partial class ScalarDivisionModule : BinaryComputationalModule,
             this,
             new IDataInPort[] { DataInPorts[0] },
             "Tensor Input Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.R2,
-            EnigmosConstant.DataPortTypes.VectorTypes
+            DataTypeConstant.DataTypeOptions.VectorTypes
         );
         ScalarInputGroup =GlobalProvider.DataStructureProvider.NewDataInGroup(
             this,
             new IDataInPort[] { DataInPorts[1] },
             "Scalar Input Type",
-            EnigmosConstant.DataPortTypes.R2,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.VectorTypes
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.VectorTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { ScalarInputGroup, TensorInputGroup };
         SelectedOption = 0;
@@ -55,14 +53,14 @@ public partial class ScalarDivisionModule : BinaryComputationalModule,
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.ScalarDiv(this.X(cache), this.Y(cache));
+        (object, DataType) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.ScalarDiv(this.X(cache), this.Y(cache));
         this.Define(Func);
     }
 
     public void Inference()
     {
-        if (GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(ScalarInputGroup!.SelectedType))
+        if (GlobalProvider.DataTypeProvider!.IsComplexTensorType(ScalarInputGroup!.SelectedType))
-            OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup!.SelectedType);
+            OutputGroup!.SelectedType = GlobalProvider.DataTypeProvider.ComplexVersionOf(TensorInputGroup!.SelectedType);
         else
             OutputGroup!.SelectedType = TensorInputGroup!.SelectedType;
     }

Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs

@@ -1,8 +1,7 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
@@ -10,7 +9,7 @@ using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ScalarMultiplicationModule : 
+public abstract partial class ScalarMultiplicationModule : 
     BinaryComputationalModule, 
     IPolymorphismModule,
     IDuplicateOutputModule
@@ -18,7 +17,6 @@ public partial class ScalarMultiplicationModule :
     private IDataPortGroup? ScalarInputGroup { get; set; }
     private IDataPortGroup? TensorInputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
@@ -29,22 +27,22 @@ public partial class ScalarMultiplicationModule :
             this,
             new IDataInPort[] { DataInPorts[0] },
             "Scalar Input Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.NumericTypes
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         TensorInputGroup =  GlobalProvider.DataStructureProvider.NewDataInGroup(
             this,
             new IDataInPort[] { DataInPorts[1] },
             "Tensor Input Type",
-            EnigmosConstant.DataPortTypes.R2,
+            DataTypeConstant.BaseDataTypes.R2,
-            EnigmosConstant.DataPortTypes.VectorTypes
+            DataTypeConstant.DataTypeOptions.VectorTypes
         );
         OutputGroup =  GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.VectorTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { ScalarInputGroup, TensorInputGroup };
         PostInit();
@@ -53,7 +51,7 @@ public partial class ScalarMultiplicationModule :
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => 
+        (object, DataType) Func(CacheItem cache) => 
             GlobalProvider.PolymorphismProvider!.ScalarMul(this.X(cache), this.Y(cache));
         this.Define(Func);
     }
@@ -61,10 +59,10 @@ public partial class ScalarMultiplicationModule :
     public void Inference()
     {
         if (
-            GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(ScalarInputGroup!.SelectedType) ||
+            GlobalProvider.DataTypeProvider!.IsComplexTensorType(ScalarInputGroup!.SelectedType) ||
-            GlobalProvider.DataPackageTypeProvider.IsComplexTensorType(TensorInputGroup!.SelectedType)
+            GlobalProvider.DataTypeProvider.IsComplexTensorType(TensorInputGroup!.SelectedType)
         )
-            OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup!.SelectedType);
+            OutputGroup!.SelectedType = GlobalProvider.DataTypeProvider.ComplexVersionOf(TensorInputGroup!.SelectedType);
         else
             OutputGroup!.SelectedType = TensorInputGroup.SelectedType;
     }

Modules/ComputationalModules/Binary/SubtractionModule.cs

@@ -1,22 +1,19 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class SubtractionModule : BinaryComputationalModule,
+public abstract partial class SubtractionModule : BinaryComputationalModule,
     IPolymorphismModule,
     IDuplicateOutputModule
 {
     private IDataPortGroup? InputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
-
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
@@ -27,15 +24,15 @@ public partial class SubtractionModule : BinaryComputationalModule,
             this,
             DataInPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.TensorTypes
         );
         OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "Output Port Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.AnyTensor
+            DataTypeConstant.DataTypeOptions.TensorTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
         PostInit();
@@ -43,7 +40,7 @@ public partial class SubtractionModule : BinaryComputationalModule,
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.Sub(this.X(cache), this.Y(cache));
+        (object, DataType) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.Sub(this.X(cache), this.Y(cache));
     }
 
 

Modules/ComputationalModules/Binary/V2Module.cs

@@ -1,10 +1,10 @@
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.BracketSystem;
+using Nocturnis.DataStructures.Data;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
@@ -13,38 +13,37 @@ using C2 = Skeleton.Algebra.CategoryOf<Skeleton.Algebra.DimensionProviders.IDim2
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class V2Module : BinaryComputationalModule, 
+public abstract partial class V2Module : BinaryComputationalModule, 
     IPolymorphismModule,
-    IDuplicateOutputModule
+    IDuplicateOutputModule,
+    IInstructionArrowEnd
 {
-    private IDataPortGroup? ScalarInputGroup { get; set; }
+    public Marker2D EndMarker { get; set; }
-    private IDataPortGroup? OutputGroup { get; set; }
+    private IDataPortGroup ScalarInputGroup { get; set; }
-    private DataOutPort? Output1 { get; set; }
+    private IDataPortGroup OutputGroup { get; set; }
-    private DataOutPort? Output2 { get; set; }
+
-    private DataOutPort? Output3 { get; set; }
-    private DataOutPort? Output4 { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public override double MaintenanceAlpha => 0.77852142d;
     public override double MaintenanceBeta => 0.9544432d;
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
     {
+        EndMarker = GetNode<Marker2D>("EndMarker");
         base.Init();
         this.DataOutInit("Output", 4);
         ScalarInputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
             DataInPorts,
             "Scalar Input Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.NumericTypes
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "",
-            EnigmosConstant.DataPortTypes.R2,
+            DataTypeConstant.BaseDataTypes.R2,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.VectorTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { ScalarInputGroup };
         PostInit();
@@ -52,21 +51,21 @@ public partial class V2Module : BinaryComputationalModule,
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache)
+        (object, DataType) Func(CacheItem cache)
         {
-            IData x = this.X(cache);
+            DataVariable x = this.X(cache);
-            IData y = this.Y(cache);
+            DataVariable y = this.Y(cache);
             
-            if (x.Type == EnigmosConstant.DataPortTypes.Complex || y.Type == EnigmosConstant.DataPortTypes.Complex)
+            if (x.Type == DataTypeConstant.BaseDataTypes.Complex || y.Type == DataTypeConstant.BaseDataTypes.Complex)
-                return (new C2(x.Complex, y.Complex), EnigmosConstant.DataPortTypes.C2);
+                return (new C2(x.Complex, y.Complex), DataTypeConstant.BaseDataTypes.C2);
-            return (new R2(x.Double, y.Double), EnigmosConstant.DataPortTypes.Real);
+            return (new R2(x.Real, y.Real), DataTypeConstant.BaseDataTypes.R2);
         }
         this.Define(Func);
     }
 
     public void Inference()
     {
-        OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.BuildType(OutputGroup.SelectedType, 1, 2);
+        OutputGroup!.SelectedType = GlobalProvider.DataTypeProvider!.ToVector(OutputGroup.SelectedType);
     }
 
 }

Modules/ComputationalModules/BinaryComputationalModule.cs

@@ -1,14 +1,11 @@
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 
 namespace Enigmos.Modules.ComputationalModules;
 
 public abstract partial class BinaryComputationalModule : ComputationalModule, IBinaryComputationalModule
 {
-    public override IEnumerable<IBasePort> Ports => DataInPorts;
     public IDataInPort[] DataInPorts { get; set; } = new IDataInPort[2];
-
     public override void Init()
     {
         base.Init();

Modules/ComputationalModules/Nullary/ConstantModule.cs

@@ -2,23 +2,21 @@ using Godot;
 using Nocturnis.DataStructures.ConfigurableParameters;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.ComputationalModules.Nullary;
 
-public partial class ConstantModule : NullaryComputationalModule, IParameterizedModule, IDuplicateOutputModule
+public abstract partial class ConstantModule : NullaryComputationalModule, IParameterizedModule, IDuplicateOutputModule
 {
 
     [Export] private double PresetConstantValue { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     private IDoubleParameter? ConstValue { get; set; }
     public override void Init()
     {
         base.Init();
         this.DataOutInit("Output", 4);
-        this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetOutputType(DataTypeConstant.BaseDataTypes.Real);
         
         ConstValue =
             GlobalProvider.DataStructureProvider!.NewDoubleParameter(
@@ -34,7 +32,7 @@ public partial class ConstantModule : NullaryComputationalModule, IParameterized
     public override void Define()
     {
         this.Define(cache =>
-            (ConstValue!.ParameterValue, EnigmosConstant.DataPortTypes.Real)
+            (ConstValue!.ParameterValue, DataTypeConstant.BaseDataTypes.Real)
         );
     }
 

Modules/ComputationalModules/Nullary/KeyListenerModule.cs

@@ -1,7 +1,7 @@
-using Enigmos.Ports;
 using Enigmos.Ports.DataPorts;
 using Godot;
 using Nocturnis.DataStructures.ConfigurableParameters;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.GlobalManagement.Constants;
@@ -9,24 +9,23 @@ using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Nullary;
-public partial class KeyListenerModule : NullaryComputationalModule,
+public abstract partial class KeyListenerModule : NullaryComputationalModule,
 	IParameterizedModule, 
 	IKeyListenerModule,
 	IDuplicateOutputModule
 {
-	[Export] private StringName? PresetActionName { get; set; }
+	[Export] private StringName PresetActionName { get; set; }
-	private DataOutPort? Output1 { get; set; }
+	private DataOutPort Output1 { get; set; }
-	private DataOutPort? Output2 { get; set; }
+	private DataOutPort Output2 { get; set; }
-	private DataOutPort? Output3 { get; set; }
+	private DataOutPort Output3 { get; set; }
-	public IKeyParameter? ListeningKey { get; set; }
+	public IKeyParameter ListeningKey { get; set; }
 	public bool Pressed { get; set; }
 	public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
-	public override IEnumerable<BasePort> Ports => new[] { Output1, Output2, Output3 }!;
 	public override void Init()
 	{
 		base.Init();
 		this.DataOutInit("Output", 3);
-		this.SetOutputType(EnigmosConstant.DataPortTypes.Bit);
+		this.SetOutputType(DataTypeConstant.BaseDataTypes.Bit);
 		ListeningKey = GlobalProvider.DataStructureProvider!.NewKeyParameter(
 			"Listening Key",
 			UsingPreset && (PresetActionName != null) ? PresetActionName : "KeyListenAction"
@@ -38,13 +37,13 @@ public partial class KeyListenerModule : NullaryComputationalModule,
 		ListeningKey.ParameterValue = $"{ListeningKey.ParameterValue}{i}";
 		if(!UsingPreset)
 			InputMap.AddAction(ListeningKey.ParameterValue);
-		GlobalProvider.SceneProvider!.RootScene.KeyListener.Register(this);
+		GlobalProvider.SceneProvider!.RootScene!.KeyListener.Register(this);
 		PostInit();
 	}
 
 	public override void Define()
 	{
-		(object item, StringName type) Func(CacheItem cache) => (Pressed, EnigmosConstant.DataPortTypes.Bit);
+		(object, DataType) Func(CacheItem cache) => (Pressed, DataTypeConstant.BaseDataTypes.Bit);
 		this.Define(Func);
 	}
 }

Modules/ComputationalModules/Nullary/NormalDistributionModule.cs

@@ -2,7 +2,6 @@ using Enigmos.Ports.DataPorts;
 using Nocturnis.DataStructures.ConfigurableParameters;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
@@ -11,7 +10,7 @@ using Skeleton.Utils.RandomEngines;
 
 namespace Enigmos.Modules.ComputationalModules.Nullary;
 
-public partial class NormalDistributionModule : NullaryComputationalModule, 
+public abstract partial class NormalDistributionModule : NullaryComputationalModule, 
     IParameterizedModule,
     IDuplicateOutputModule
 {
@@ -20,7 +19,6 @@ public partial class NormalDistributionModule : NullaryComputationalModule,
     private DataOutPort? Output2 { get; set; }
     private DataOutPort? Output3 { get; set; }
     private DataOutPort? Output4 { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     private IDoubleParameter? Mu { get; set; }
     private IDoubleParameter? Sigma { get; set; }
 
@@ -29,7 +27,7 @@ public partial class NormalDistributionModule : NullaryComputationalModule,
     {
         base.Init();
         this.DataOutInit("Output", 4);
-        this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetOutputType(DataTypeConstant.BaseDataTypes.Real);
         Mu = GlobalProvider.DataStructureProvider!.NewDoubleParameter("mu", -1, 1, 0);
         Sigma = GlobalProvider.DataStructureProvider.NewDoubleParameter("sigma", 0, 2, 1);
         ConfigurableParameters = new HashSet<IConfigurableParameter> { Mu, Sigma };
@@ -41,7 +39,7 @@ public partial class NormalDistributionModule : NullaryComputationalModule,
         foreach (IDataOutPort op in DataOutPorts)
         {
             op.OutData.UpdateCalculation(x =>
-                (Normal.Get() * Sigma!.ParameterValue - Mu!.ParameterValue, EnigmosConstant.DataPortTypes.Real)
+                (Normal.Get() * Sigma!.ParameterValue - Mu!.ParameterValue, DataTypeConstant.BaseDataTypes.Real)
             );
         }
     }

Modules/ComputationalModules/NullaryComputationalModule.cs

@@ -1,10 +1,8 @@
-using Enigmos.Ports;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 
 namespace Enigmos.Modules.ComputationalModules;
 
 public abstract partial class NullaryComputationalModule : ComputationalModule, ISourceModule
 {
-    public override IEnumerable<IBasePort> Ports => Array.Empty<BasePort>();
+
 }

Modules/ComputationalModules/Ternary/SelectorModule.cs

@@ -1,8 +1,7 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
@@ -10,14 +9,13 @@ using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Ternary;
 
-public partial class SelectorModule : TernaryComputationalModule,
+public abstract partial class SelectorModule : TernaryComputationalModule,
     ITernaryComputationalModule,
     IPolymorphismModule, 
     IDuplicateOutputModule
 {
     private IDataPortGroup? DataTypeGroup { get; set; }
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public override void Init()
     {
         base.Init();
@@ -26,17 +24,17 @@ public partial class SelectorModule : TernaryComputationalModule,
             this,
         new IDataPort[]{DataInPorts[1], DataInPorts[2]}.Union(DataOutPorts).ToArray(),
             "Data Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.AnyType
+            DataTypeConstant.DataTypeOptions.AnyType
         );
         
-        DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        DataInPorts[0].SetDataType(DataTypeConstant.BaseDataTypes.Bit);
         PostInit();
     }
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache)
+        (object, DataType) Func(CacheItem cache)
         {
             if (this.X(cache).Bit)
                 return (this.Y(cache).Data!, this.Y(cache).Type!);

Modules/ComputationalModules/TernaryComputationalModule.cs

@@ -1,5 +1,4 @@
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 
 namespace Enigmos.Modules.ComputationalModules;
@@ -7,7 +6,6 @@ namespace Enigmos.Modules.ComputationalModules;
 public abstract partial class TernaryComputationalModule : ComputationalModule, IParameterModule
 {
     public IDataInPort[] DataInPorts { get; set; } = new IDataInPort[3];
-    public override IEnumerable<IBasePort> Ports => DataInPorts;
     public override void Init()
     {
         base.Init();

Modules/ComputationalModules/Unary/CopyModule.cs

@@ -1,20 +1,18 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Unary;
-public partial class CopyModule : UnaryComputationalModule, 
+public abstract partial class CopyModule : UnaryComputationalModule, 
     IPolymorphismModule, 
     IDuplicateOutputModule
 {
     private IDataPortGroup? InputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
     public override void Init()
     {
@@ -24,15 +22,15 @@ public partial class CopyModule : UnaryComputationalModule,
             this,
             DataInPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.AnyType
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider!.NewDataOutGroup(
             this,
             DataOutPorts,
             "Output Port Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.AnyType
+            DataTypeConstant.DataTypeOptions.AnyType
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
         PostInit();
@@ -40,7 +38,7 @@ public partial class CopyModule : UnaryComputationalModule,
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem cache) => (this.X(cache).Data, this.X(cache).Type)!;
+        (object, DataType) Func(CacheItem cache) => (this.X(cache).Data, this.X(cache).Type)!;
         this.Define(Func);
     }
     public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;

Modules/ComputationalModules/Unary/LogicalNegationModule.cs

@@ -1,26 +1,24 @@
-using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Unary;
 
-public partial class LogicalNegationModule : UnaryComputationalModule, IDuplicateOutputModule
+public abstract partial class LogicalNegationModule : UnaryComputationalModule, IDuplicateOutputModule
 {
-	public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
 	public override void Init()
 	{
 		base.Init();
 		this.DataOutInit("Output", 1);
-		this.SetInputType(EnigmosConstant.DataPortTypes.Bit);
+		this.SetInputType(DataTypeConstant.BaseDataTypes.Bit);
-		this.SetOutputType(EnigmosConstant.DataPortTypes.Bit);
+		this.SetOutputType(DataTypeConstant.BaseDataTypes.Bit);
 		PostInit();
 	}
 
 	public override void Define()
 	{
-		(object, StringName) Func(CacheItem cache) => (!this.X(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+		(object, DataType) Func(CacheItem cache) => (!this.X(cache).Bit, DataTypeConstant.BaseDataTypes.Bit);
 		this.Define(Func);
 	}
 }

Modules/ComputationalModules/Unary/NegationModule.cs

@@ -1,24 +1,18 @@
-using Enigmos.Ports.DataPorts;
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Unary;
 
-public partial class NegationModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class NegationModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
-	private DataOutPort? Output1 { get; set; }
+
-	private DataOutPort? Output2 { get; set; }
-	private DataOutPort? Output3 { get; set; }
-	private DataOutPort? Output4 { get; set; }
 	private IDataInGroup? InputGroup { get; set; }
 	private IDataOutGroup? OutputGroup { get; set; }
-	public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts)!;
 
 	public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 	public override void Init()
@@ -29,15 +23,15 @@ public partial class NegationModule : UnaryComputationalModule, IPolymorphismMod
 			this,
 			DataInPorts,
 			"",
-			EnigmosConstant.DataPortTypes.Real,
+			DataTypeConstant.BaseDataTypes.Real,
-			Array.Empty<StringName>()
+			DataTypeConstant.DataTypeOptions.TensorTypes
 		);
 		OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
 			this,
 			DataOutPorts,
 			"Output Port Type",
-			EnigmosConstant.DataPortTypes.Real,
+			DataTypeConstant.BaseDataTypes.Real,
-			EnigmosConstant.DataPortTypes.AnyTensor
+			DataTypeConstant.DataTypeOptions.TensorTypes
 		);
 		ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
 		PostInit();
@@ -46,7 +40,7 @@ public partial class NegationModule : UnaryComputationalModule, IPolymorphismMod
 
 	public override void Define()
 	{
-		(object, StringName) Func(CacheItem c) => 
+		(object, DataType) Func(CacheItem c) => 
 			GlobalProvider.PolymorphismProvider!.Neg(this.X(c));
 		this.Define(Func);
 	}

Modules/ComputationalModules/Unary/SquareModule.cs

@@ -1,19 +1,17 @@
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Unary;
 
-public partial class SquareModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class SquareModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
     private IDataPortGroup? InputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
 
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
     public override void Init()
@@ -24,15 +22,15 @@ public partial class SquareModule : UnaryComputationalModule, IPolymorphismModul
             this,
             DataInPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "Output Port Type",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.NumericTypes
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
         PostInit();
@@ -40,7 +38,7 @@ public partial class SquareModule : UnaryComputationalModule, IPolymorphismModul
 
     public override void Define()
     {
-        (object, StringName) Func(CacheItem c) => GlobalProvider.PolymorphismProvider!.Square(this.X(c));
+        (object, DataType) Func(CacheItem c) => GlobalProvider.PolymorphismProvider!.Square(this.X(c));
         this.Define(Func);
     }
 

Modules/ComputationalModules/Unary/V2ComponentModule.cs

@@ -1,9 +1,8 @@
-using Godot;
+using Nocturnis.DataStructures.Data;
-using Nocturnis.DataStructures;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 using Skeleton.DataStructure;
@@ -11,12 +10,11 @@ using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Unary;
 
-public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
+public abstract partial class V2ComponentModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
     private IDataPortGroup? VectorInputGroup { get; set; }
     private IDataPortGroup? ScalarOutputGroup { get; set; }
     
-    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
     public override void Init()
@@ -27,15 +25,15 @@ public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphism
             this,
             DataInPorts,
             "Vector Input Type",
-            EnigmosConstant.DataPortTypes.R2,
+            DataTypeConstant.BaseDataTypes.R2,
-            EnigmosConstant.DataPortTypes.VectorTypes
+            DataTypeConstant.DataTypeOptions.VectorTypes
         );
         ScalarOutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
             DataOutPorts,
             "",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            Array.Empty<StringName>()
+            DataTypeConstant.DataTypeOptions.ScalarTypes
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { VectorInputGroup };
         PostInit();
@@ -43,19 +41,19 @@ public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphism
 
     public override void Define()
     {
-        (object, StringName) Func1(CacheItem c)
+        (object, DataType) Func1(CacheItem c)
         {
-            IData v = this.X(c);
+            DataVariable v = this.X(c);
-            if (v.Type == EnigmosConstant.DataPortTypes.R2)
+            if (v.Type == DataTypeConstant.BaseDataTypes.R2)
-                return (v.R2[1], EnigmosConstant.DataPortTypes.Real);
+                return (v.R2[1], DataTypeConstant.BaseDataTypes.Real);
-            return (v.C2[1], EnigmosConstant.DataPortTypes.Complex);
+            return (v.C2[1], DataTypeConstant.BaseDataTypes.Complex);
         }
-        (object, StringName) Func2(CacheItem c)
+        (object, DataType) Func2(CacheItem c)
         {
-            IData v = this.X(c);
+            DataVariable v = this.X(c);
-            if (v.Type == EnigmosConstant.DataPortTypes.R2)
+            if (v.Type == DataTypeConstant.BaseDataTypes.R2)
-                return (v.R2[2], EnigmosConstant.DataPortTypes.Real);
+                return (v.R2[2], DataTypeConstant.BaseDataTypes.Real);
-            return (v.C2[2], EnigmosConstant.DataPortTypes.Complex);
+            return (v.C2[2], DataTypeConstant.BaseDataTypes.Complex);
         }
         DataOutPorts[0].OutData.UpdateCalculation(Func1);
         DataOutPorts[1].OutData.UpdateCalculation(Func2);
@@ -63,7 +61,7 @@ public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphism
     }
     
     public void Inference() => 
-        ScalarOutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!
+        ScalarOutputGroup!.SelectedType = GlobalProvider.DataTypeProvider!
             .GetBaseField(VectorInputGroup!.SelectedType);
     
 }

Modules/ComputationalModules/UnaryComputationalModule.cs

@@ -1,6 +1,5 @@
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 
 namespace Enigmos.Modules.ComputationalModules;
@@ -8,7 +7,6 @@ namespace Enigmos.Modules.ComputationalModules;
 public abstract partial class UnaryComputationalModule : ComputationalModule, IUnaryComputationalModule
 {
     public IDataInPort[] DataInPorts { get; set; } = new IDataInPort[1];
-    public override IEnumerable<IBasePort> Ports => DataInPorts;
     public override void Init()
     {
         base.Init();

Modules/ControllingModules/ActionModules/AttackActionModule.cs

@@ -1,34 +1,33 @@
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Controls;
 
 namespace Enigmos.Modules.ControllingModules.ActionModules;
-public partial class AttackActionModule : ActionModule, ITerminalModule
+public abstract partial class AttackActionModule : ActionModule, ITerminalModule
 {
 
 	public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
 	public void Drain()
 	{
-		foreach (IDataInPort ip in DataInPorts)
+		
-			_ = ip.GetData.Get;
 	}
 
-	public override IEnumerable<IBasePort> Ports => SignalInPorts.Union(DataInPorts.Cast<IBasePort>()).ToArray();
+	public bool Finished { get; set; }
 
 	public override void Init()
 	{
 		base.Init();
 		this.SignalInInit("SignalIn", 4);
 		this.DataInInit("Input", 1);
-		DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.R2);
+		DataInPorts[0].SetDataType(DataTypeConstant.BaseDataTypes.R2);
 		PostInit();
 	}
 
 	public override void Act()
 	{
 		CreatureControl.Instance.CurrentCharacter!.Action.Attack(DataInPorts[0].GetData.Get!.R2);
+		Finished = true;
 	}
 
 }

Modules/ControllingModules/ActionModules/MoveActionModule.cs

@@ -1,14 +1,11 @@
-using Enigmos.Ports.DataPorts;
-using Enigmos.Ports.SignalPorts;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Controls;
 
 namespace Enigmos.Modules.ControllingModules.ActionModules;
 
-public partial class MoveActionModule : ActionModule, ITerminalModule
+public abstract partial class MoveActionModule : ActionModule, ITerminalModule
 {
 
 	public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
@@ -18,14 +15,14 @@ public partial class MoveActionModule : ActionModule, ITerminalModule
 			_ = ip.GetData.Get;
 	}
 
-	public override IEnumerable<IBasePort> Ports => DataInPorts.Union(SignalInPorts.Cast<IBasePort>());
+	public bool Finished { get; set; }
 
 	public override void Init()
 	{
 		base.Init();
 		this.DataInInit("Input", 1);
 		this.SignalInInit("SignalIn", 4);
-		DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.R2);
+		DataInPorts[0].SetDataType(DataTypeConstant.BaseDataTypes.R2);
 		PostInit();
 	}
 
@@ -34,6 +31,8 @@ public partial class MoveActionModule : ActionModule, ITerminalModule
 
 	public override void Act()
 	{
-		CreatureControl.Instance.CurrentCharacter!.Action.Attack(DataInPorts[0].GetData.Get!.R2);
+		if (!DataInPorts[0].Connected)
+			return;
+		CreatureControl.Instance.CurrentCharacter!.Action.Move(DataInPorts[0].GetData.Get!.R2);
 	}
 }

Modules/ControllingModules/RootModule.cs

@@ -1,14 +1,12 @@
-using System.Diagnostics;
 using Nocturnis.Creatures;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
 
 namespace Enigmos.Modules.ControllingModules;
-public partial class RootModule : BaseModule, IRootModule
+public abstract partial class RootModule : BaseModule, IRootModule
 {
 	public bool ActionFinished { get; set; }
-	public IBaseCreature? ManagedBy { get; set; }
+	public IBaseCreature ManagedBy { get; set; }
 	public void Start()
 	{
 		SignalOutPorts[0].Route();
@@ -16,8 +14,6 @@ public partial class RootModule : BaseModule, IRootModule
 
 	protected override bool Draggable => false;
 	public ISignalOutPort[] SignalOutPorts { get; set; } = Array.Empty<ISignalOutPort>();
-	public override IEnumerable<IBasePort> Ports => SignalOutPorts;
-	public Stopwatch? Timer { get; set; }
 	public bool Visited { get; set; }
 
 	public override void Init()
@@ -28,5 +24,9 @@ public partial class RootModule : BaseModule, IRootModule
 		PostInit();
 	}
 
-	
+	public override void _Ready()
+	{
+		Console.WriteLine("RootModule Ready");
+		base._Ready();
+	}
 }

Modules/ControllingModules/SinglePoleDoubleThrowSwitchModule.cs

@@ -1,20 +1,16 @@
 using Nocturnis.DataStructures.ConfigurableParameters;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
-using Nocturnis.GlobalManagement.Controls;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.ControllingModules;
 
-public partial class SinglePoleDoubleThrowSwitchModule : PiplineModule, IParameterizedModule, ITerminalModule
+public abstract partial class SinglePoleDoubleThrowSwitchModule : PiplineModule, IParameterizedModule, ITerminalModule
 {
 	public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
 	private IBoolParameter? LeftPortForTrue { get; set; }
-	public override IEnumerable<IBasePort> Ports => 
-		SignalInPorts.Union(SignalOutPorts.Cast<IBasePort>()).Union(DataInPorts).ToArray();
 	public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
 	public void Drain()
 	{
@@ -22,6 +18,8 @@ public partial class SinglePoleDoubleThrowSwitchModule : PiplineModule, IParamet
 			_ = ip.GetData.Get;
 	}
 
+	public bool Finished { get; set; }
+
 	public override void Init()
 	{
 		base.Init();
@@ -30,7 +28,7 @@ public partial class SinglePoleDoubleThrowSwitchModule : PiplineModule, IParamet
 		this.DataInInit("Input", 1);
 		LeftPortForTrue = 
 			GlobalProvider.DataStructureProvider!.NewBoolParameter("Redirect to:", "Left", "Right", true);
-		DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		DataInPorts[0].SetDataType(DataTypeConstant.BaseDataTypes.Bit);
 		ConfigurableParameters = new HashSet<IConfigurableParameter> { LeftPortForTrue };
 		PostInit();
 	}
@@ -41,10 +39,8 @@ public partial class SinglePoleDoubleThrowSwitchModule : PiplineModule, IParamet
 		ISignalOutPort selectedPort = (LeftPortForTrue!.ParameterValue && DataInPorts[0].GetData.Get!.Bit)
 			? SignalOutPorts[0]
 			: SignalOutPorts[1];
-		if (selectedPort.Connected)
+		
 		selectedPort.Route();
-		else
-			EnigmosControl.Instance.RootModule.ActionFinished = true;
 	}
 	
 }

Modules/ControllingModules/SinglePoleSingleThrowSwitchModule.cs

@@ -1,15 +1,12 @@
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Controls;
 
 namespace Enigmos.Modules.ControllingModules;
 
-public partial class SinglePoleSingleThrowSwitchModule : PiplineModule, ITerminalModule
+public abstract partial class SinglePoleSingleThrowSwitchModule : PiplineModule, ITerminalModule
 {
-	public override IEnumerable<IBasePort> Ports => 
-		SignalInPorts.Union(SignalOutPorts.Cast<IBasePort>()).Union(DataInPorts);
 	public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
 
 	public void Drain()
@@ -19,13 +16,15 @@ public partial class SinglePoleSingleThrowSwitchModule : PiplineModule, ITermina
 
 	}
 
+	public bool Finished { get; set; }
+
 	public override void Init()
 	{
 		base.Init();
 		this.DataInInit("Input", 1);
 		this.SignalInInit("SignalIn", 1);
 		this.SignalOutInit("SignalOut", 1);
-		DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		DataInPorts[0].SetDataType(DataTypeConstant.BaseDataTypes.Bit);
 		PostInit();
 	}
 	

Modules/InterlayerModules/InterlayerDataInModule.cs

@@ -1,3 +1,4 @@
+using Enigmos.Modules.SubModules;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
@@ -15,7 +16,6 @@ public partial class InterlayerDataInModule : SubModule, IInterlayerDataInModule
     }
     public IInterlayerDataOutModule? DualModule { get; set; }
     public IDataInPort? DataIn { get; set; }
-    public override IEnumerable<IBasePort> Ports => new[] { DataIn }!;
     public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
 
 

Modules/InterlayerModules/InterlayerDataOutModule.cs

@@ -1,5 +1,4 @@
-using Enigmos.Modules.ComputationalModules;
+using Enigmos.Modules.SubModules;
-using Godot;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
@@ -20,7 +19,7 @@ public partial class InterlayerDataOutModule : SubModule, IComputationalModule,
     public IBasePort UnderlyingPort => DataOut!;
     public IInterlayerDataInModule? DualModule { get; set; }
     public IDataOutPort? DataOut { get; set; }
-    public override IEnumerable<IBasePort> Ports => new[] { DataOut }!;
+
 
     public override void Init()
     {

Modules/InterlayerModules/InterlayerSignalInModule.cs

@@ -1,4 +1,4 @@
-using Godot;
+using Enigmos.Modules.SubModules;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
@@ -8,15 +8,14 @@ namespace Enigmos.Modules.InterlayerModules;
 
 public partial class InterlayerSignalInModule : SubModule, IInterlayerSignalInModule
 {
-    public new IProgrammableModule? ParentModule
+    public new IProgrammableModule ParentModule
     {
         get => base.ParentModule as IProgrammableModule;
         set => base.ParentModule = value;
     }
     public IBasePort UnderlyingPort => SignalIn!;
-    public IInterlayerSignalOutModule? DualModule { get; set; }
+    public IInterlayerSignalOutModule DualModule { get; set; }
-    public ISignalInPort? SignalIn { get; set; }
+    public ISignalInPort SignalIn { get; set; }
-    public override IEnumerable<IBasePort> Ports => new[] { SignalIn }!;
     public ISignalInPort[] SignalInPorts { get; set; } = Array.Empty<ISignalInPort>();
 
     public override void Init()

Modules/InterlayerModules/InterlayerSignalOutModule.cs

@@ -1,3 +1,4 @@
+using Enigmos.Modules.SubModules;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
@@ -15,7 +16,6 @@ public partial class InterlayerSignalOutModule : SubModule, IInterlayerSignalOut
     public IBasePort UnderlyingPort => SignalOut!;
     public IInterlayerSignalInModule? DualModule { get; set; }
     public ISignalOutPort? SignalOut { get; set; }
-    public override IEnumerable<IBasePort> Ports => new[] { SignalOut }!;
 
     public ISignalOutPort[] SignalOutPorts { get; set; } = Array.Empty<ISignalOutPort>();
 

Modules/Other/OutputSubModule.cs

@@ -1,35 +0,0 @@
-using Enigmos.Modules.ComputationalModules;
-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;
-
-namespace Enigmos.Modules.Other;
-
-public partial class OutputSubModule : NullaryComputationalModule
-{
-    public override Vector2 PositionToBoard => 
-        base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
-    protected override bool Draggable => false;
-    protected override bool HasManual => false;
-    public override IEnumerable<IBasePort> Ports => new[] { DataOut };
-    public IComputationalCompositeModule? ParentModule { get; set; }
-    public IDataOutPort? DataOut { get; set; }
-
-    public override void Define()
-    {
-        //DataOut = ParentModule
-    }
-
-    //protected override void Compute(IRootModule root) => ParentModule.Compute(root);
-    public override void Init()
-    {
-        base.Init();
-        this.DataOutInit("DataOut", 1);
-        DataOut = DataOutPorts[0];
-        DataOut.SetDataType(EnigmosConstant.DataPortTypes.Real);
-        PostInit();
-    }
-}

Modules/ProgrammableModules/FilterModule/FilterIndicateModule.cs

@@ -1,3 +1,4 @@
+using Enigmos.Modules.SubModules;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 

Modules/ProgrammableModules/FilterModule/FilterInputProviderModule.cs

@@ -1,17 +1,16 @@
 using Enigmos.Boards;
-using Godot;
+using Enigmos.Modules.SubModules;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.Data;
+using Nocturnis.DataStructures.DataTypes;
 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 abstract 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; }
@@ -27,9 +26,9 @@ public partial class FilterInputProviderModule : SubModule, IComputationalModule
 
     public void Define()
     {
-        (object, StringName) Func(CacheItem c)
+        (object, DataType) Func(CacheItem c)
         {
-            IData w = ParentBoard!.FilterModule!.CachedInputArray[ParentBoard.FilterModule.ProcessingIndex];
+            DataVariable w = ParentBoard!.FilterModule!.CachedInputArray[ParentBoard.FilterModule.ProcessingIndex];
             return (w.Data, w.Type)!;
         }
         Output!.OutData.UpdateCalculation(Func);

Modules/ProgrammableModules/FilterModule/FilterModule.cs

@@ -1,6 +1,7 @@
 using Enigmos.Boards;
 using Enigmos.Modules.InterlayerModules;
-using Nocturnis.DataStructures;
+using Enigmos.Modules.SubModules;
+using Nocturnis.DataStructures.Data;
 using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.InterlayerModules;
@@ -12,20 +13,23 @@ using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.ProgrammableModules.FilterModule;
 
-public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFilterModule
+public abstract partial class FilterModule : ProgrammableModule, 
+    IPolymorphismModule, 
+    IInternalComputationalModule,
+    IEnumerableProcessingModule
 {
     public IDataInPort? InputArray { get; set; }
-    public FilterOutputModule? OutputArrayModule { get; set; }
+    public OutputSubModule? OutputArrayModule { get; set; }
     private IInterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<IInterlayerDataInModule>();
     
     private IDataPortGroup[] InterLayerGroups { get; set; } = Array.Empty<IDataPortGroup>();
     private IDataPortGroup? ArrayGroup { get; set; }
-    public IData[] CachedInputArray { get; set; } = Array.Empty<IData>();
+    public DataVariable[] CachedInputArray { get; set; } = Array.Empty<DataVariable>();
-    public IData[] CachedResult { get; set; } = Array.Empty<IData>();
+    public DataVariable? CachedResult { get; set; }
-    public bool FilterFinished { get; set; }
+    public bool ComputationFinished { get; set; }
-    public bool FilterStarted { get; set; }
+    public bool ComputationStarted { get; set; }
 
-    private List<IData> CachedListResult { get; set; } = new();
+    private List<DataVariable> CachedListResult { get; set; } = new();
     public int ProcessingIndex { get; set; }
 
     public new FilterModuleBoard UnderlyingBoard
@@ -34,17 +38,13 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
         set => base.UnderlyingBoard = value;
     }
 
-    public override IEnumerable<IBasePort> Ports => new IBasePort[] { InputArray!, OutputArrayModule!.Output! };
-
-    public override IBaseModule[] SubModules => ExplicitInputs;
-
     public override IEnumerable<IBasePort> ExplicitPorts =>
-        new IBasePort[] { InputArray!, OutputArrayModule!.Output! }
+        new IBasePort[] { InputArray!, OutputArrayModule!.Out! }
             .Union(ExplicitInputs.Select(c => c.DataIn))!
             .ToArray<IBasePort>();
 
     public override IEnumerable<IBasePort> ImplicitPorts =>
-        new IBasePort[] { OutputArrayModule!.Output!, InputArray! }
+        new IBasePort[] { OutputArrayModule!.Out!, InputArray! }
             .Union(UnderlyingBoard.FilterInputProxy.Select(c => c.DataOut))
             .ToArray()!;
 
@@ -54,14 +54,14 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
     {
     }
 
-    public void Filter()
+    public void Compute()
     {
-        if (!FilterStarted)
+        if (!ComputationStarted)
         {
             CachedInputArray = InputArray!.GetData.Get!.Array;
             ProcessingIndex = 0;
-            CachedListResult = new List<IData>();
+            CachedListResult = new List<DataVariable>();
-            FilterStarted = true;
+            ComputationStarted = true;
         }
 
         while (ProcessingIndex < CachedInputArray.Length)
@@ -74,9 +74,10 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
             ProcessingIndex += 1;
         }
 
-        CachedResult = CachedListResult.ToArray();
+        CachedResult.Data = CachedListResult.ToArray();
-        FilterFinished = true;
+        //TODO CachedResult.Type
-        FilterStarted = false;
+        ComputationFinished = true;
+        ComputationStarted = false;
     }
     
 
@@ -86,18 +87,18 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
     {
         base.Init();
         InputArray = this.GetPort<IDataInPort>("InputArray");
-        OutputArrayModule = GetModule<FilterOutputModule>("OutputArray");
+        OutputArrayModule = GetModule<OutputSubModule>("OutputArray");
-        UnderlyingBoard = GlobalProvider.SceneProvider!
+        UnderlyingBoard = GlobalProvider
-            .AssetMapper<FilterModuleBoard>()
+            .AssetMapper<FilterModuleBoard>.Scene
             .Instantiate<FilterModuleBoard>();
         ExplicitInputs = new IInterlayerDataInModule[3];
         for (int i = 0; i < 3; i++)
             ExplicitInputs[i] = GetModule<InterlayerDataInModule>($"EI{i + 1}");
-        OutputArrayModule.Init(this);
+        OutputArrayModule.Init();
         UnderlyingBoard.Init(this);
         
-        FilterFinished = false;
+        ComputationFinished = false;
-        FilterStarted = false;
+        ComputationStarted = false;
         
         for (int i = 0; i < 3; i++)
         {
@@ -105,18 +106,18 @@ public partial class FilterModule : ProgrammableModule, IPolymorphismModule, IFi
                 this,
                 new IDataPort[] { ExplicitInputs[i].DataIn!, UnderlyingBoard.FilterInputProxy[i].DataOut! },
                 $"Exterior In -> Interior Out{i}",
-                EnigmosConstant.DataPortTypes.Real,
+                DataTypeConstant.BaseDataTypes.Real,
-                EnigmosConstant.DataPortTypes.AnyType
+                DataTypeConstant.DataTypeOptions.AnyType
             );
             ExplicitInputs[i].Board = Board;
         }
 
         ArrayGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
             this,
-            new IDataPort[] { InputArray, OutputArrayModule.Output! },
+            new IDataPort[] { InputArray, OutputArrayModule.Out! },
             "Array Type",
-            EnigmosConstant.DataPortTypes.RealArray,
+            DataTypeConstant.AutoDataTypes.AutoArray,
-            EnigmosConstant.DataPortTypes.AnyArray
+            DataTypeConstant.DataTypeOptions.AnyArray
         );
         
         ConfigurablePortGroups = InterLayerGroups.Union(new[] { ArrayGroup }).ToHashSet();

Modules/ProgrammableModules/FilterModule/FilterOutputModule.cs

@@ -1,41 +0,0 @@
-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

@@ -1,6 +1,5 @@
 using Enigmos.Boards;
 using Enigmos.Modules.InterlayerModules;
-using Godot;
 using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports;
@@ -9,7 +8,7 @@ using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.ProgrammableModules.FunctionModule;
-public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
+public abstract partial class FunctionModule : ProgrammableModule, IPolymorphismModule
 {
 	private IDataPortGroup[] ExteriorToInterior { get; set; } = Array.Empty<IDataPortGroup>();
 	private IDataPortGroup[] InteriorToExterior { get; set; } = Array.Empty<IDataPortGroup>();
@@ -31,20 +30,11 @@ public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
 			.Union(UnderlyingBoard.SignalOuts.SelectMany(module => module.Ports));
 
 
-	private static readonly PackedScene FunctionModuleBoardScene = GlobalProvider.SceneProvider!
-		.AssetMapper<FunctionModuleBoard>();
 
-	public override BaseModule[] SubModules => 
-		ExplicitDataInModules
-			.Union<BaseModule>(ExplicitDataOutModules)
-			.Union(ExplicitSignalInModules)
-			.Union(ExplicitSignalOutModules)
-			.ToArray();
 
 	private InterlayerDataInModule[] ExplicitDataInModules { get; set; } = Array.Empty<InterlayerDataInModule>();
 	private InterlayerDataOutModule[] ExplicitDataOutModules { get; set; } = Array.Empty<InterlayerDataOutModule>();
 	private InterlayerSignalInModule[] ExplicitSignalInModules { get; set; } = Array.Empty<InterlayerSignalInModule>();
-
 	private InterlayerSignalOutModule[] ExplicitSignalOutModules { get; set; } =
 		Array.Empty<InterlayerSignalOutModule>();
 	
@@ -56,14 +46,28 @@ public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
 
 	public override void Init()
 	{
-		UnderlyingBoard = FunctionModuleBoardScene.Instantiate<FunctionModuleBoard>();
+		UnderlyingBoard = GlobalProvider
+			.AssetMapper<FunctionModuleBoard>.Scene
+			.Instantiate<FunctionModuleBoard>();
 		UnderlyingBoard.Init();
 		ExteriorToInterior = new IDataPortGroup[4];
 		InteriorToExterior = new IDataPortGroup[4];
-		ExplicitDataInModules = new InterlayerDataInModule[4];
+		ExplicitDataInModules = GetChildren()
-		ExplicitDataOutModules = new InterlayerDataOutModule[4];
+			.OfType<InterlayerDataInModule>()
-		ExplicitSignalInModules = new InterlayerSignalInModule[4];
+			.OrderBy(x => x.AsNode.Name)
-		ExplicitSignalOutModules = new InterlayerSignalOutModule[4];
+			.ToArray();
+		ExplicitDataOutModules = GetChildren()
+			.OfType<InterlayerDataOutModule>()
+			.OrderBy(x => x.AsNode.Name)
+			.ToArray();
+		ExplicitSignalInModules = GetChildren()
+			.OfType<InterlayerSignalInModule>()
+			.OrderBy(x => x.AsNode.Name)
+			.ToArray();
+		ExplicitSignalOutModules = GetChildren()
+			.OfType<InterlayerSignalOutModule>()
+			.OrderBy(x => x.AsNode.Name)
+			.ToArray();
 		
 		for (int i = 0; i < 4; i++)
 		{
@@ -91,15 +95,15 @@ public partial class FunctionModule : ProgrammableModule, IPolymorphismModule
 				this,
 				new IDataPort[] { ExplicitDataInModules[i].DataIn, UnderlyingBoard.DataOuts[i].DataOut },
 				$"Exterior In -> Interior Out{i + 1}",
-				EnigmosConstant.DataPortTypes.Real,
+				DataTypeConstant.BaseDataTypes.Real,
-				EnigmosConstant.DataPortTypes.AnyType
+				DataTypeConstant.DataTypeOptions.AnyType
 			);
 			InteriorToExterior[i] = GlobalProvider.DataStructureProvider.NewDataPortGroup(
 				this,
 				new IDataPort[] { UnderlyingBoard.DataIns[i].DataIn, ExplicitDataOutModules[i].DataOut },
 				$"Interior In -> Exterior Out{i + 1}",
-				EnigmosConstant.DataPortTypes.Real,
+				DataTypeConstant.BaseDataTypes.Real,
-				EnigmosConstant.DataPortTypes.AnyType
+				DataTypeConstant.DataTypeOptions.AnyType
 			);
 		}
 

Modules/ProgrammableModules/OptimizationModule/OptimizationInputProviderModule.cs

@@ -1,8 +1,8 @@
 using Enigmos.Boards;
-using Godot;
+using Enigmos.Modules.SubModules;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.Data;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Skeleton.DataStructure;
 
@@ -11,7 +11,6 @@ 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; }
 
@@ -26,9 +25,9 @@ public partial class OptimizationInputProviderModule : SubModule, IComputational
 
     public void Define()
     {
-        (object, StringName) Func(CacheItem c)
+        (object, DataType) Func(CacheItem c)
         {
-            IData w = ParentBoard!.OptimizationModule!.CachedInput[ParentBoard.OptimizationModule.ProcessingIndex];
+            DataVariable w = ParentBoard!.OptimizationModule!.CachedInputArray[ParentBoard.OptimizationModule.ProcessingIndex];
             return (w.Data, w.Type)!;
         }
         Output!.OutData.UpdateCalculation(Func);

Modules/ProgrammableModules/OptimizationModule/OptimizationModule.cs

@@ -1,12 +1,12 @@
 using Enigmos.Boards;
 using Enigmos.Modules.InterlayerModules;
+using Enigmos.Modules.SubModules;
 using Enigmos.Ports.DataPorts;
-using Godot;
-using Nocturnis.DataStructures;
 using Nocturnis.DataStructures.ConfigurableParameters;
+using Nocturnis.DataStructures.Data;
 using Nocturnis.DataStructures.DataPortGroups;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
@@ -15,24 +15,20 @@ using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
 
-public partial class OptimizationModule : ProgrammableModule,
+public abstract partial class OptimizationModule : ProgrammableModule,
 	IPolymorphismModule,
 	IParameterizedModule,
-	IOptimizationModule
+	IInternalComputationalModule,
+	IEnumerableProcessingModule
 {
-	public bool OptimizationFinished { get; set; }
+	public bool ComputationFinished { get; set; }
-	public bool OptimizationStarted { get; set; }
+	public bool ComputationStarted { get; set; }
 	private double? CachedOptimizeValue { get; set; }
 	public IDataInPort? ArrayInput { get; set; }
-	public IInterlayerDataInModule[] ExplicitOutputs { get; set; } = Array.Empty<IInterlayerDataInModule>();
+	public DataVariable[] CachedInputArray { get; set; } = Array.Empty<DataVariable>();
-	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; } =
+	public DataVariable CachedResult { get; set; } = new ();
-		GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
-
-
 	public IDataInPort? InternalIterOut { get; set; }
 	public IDataOutPort? InternalArrayIn { get; set; }
 	
@@ -41,8 +37,8 @@ public partial class OptimizationModule : ProgrammableModule,
 	
 	private InterlayerDataInModule[] ExplicitInputs { get; set; } = Array.Empty<InterlayerDataInModule>();
 	private OptimizationSelectorModule? Selector { get; set; }
-	private OptimizationOutputModule? Output { get; set; }
+	private OutputSubModule? Output { get; set; }
-	public override IEnumerable<IBasePort> Ports => new[] { ArrayInput! };
+
 
 	public new OptimizationModuleBoard UnderlyingBoard
 	{
@@ -54,14 +50,9 @@ public partial class OptimizationModule : ProgrammableModule,
 	public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
 
 	public override IEnumerable<IBasePort> ExplicitPorts => 
-		new IBasePort[] { ArrayInput!,  Output!.Output! }
+		new IBasePort[] { ArrayInput!,  Output!.Out! }
 			.Union<IBasePort>(ExplicitInputs.Select(c => c.DataIn)!);
 	
-	public override BaseModule[] SubModules => 
-		ExplicitInputs
-			.Union(new BaseModule[] { Output! })
-			.ToArray();
-
 	public override IEnumerable<IBasePort> ImplicitPorts =>
 		new IBasePort[] { UnderlyingBoard.InputProvider!.Output!, UnderlyingBoard.Selector!.Selector! }
 			.Union(UnderlyingBoard.ImplicitDataOuts.Select(c => c.DataOut))!;
@@ -69,14 +60,14 @@ public partial class OptimizationModule : ProgrammableModule,
 	public override void Init()
 	{
 		base.Init();
-		UnderlyingBoard = GlobalProvider.SceneProvider!
+		UnderlyingBoard = GlobalProvider
-			.AssetMapper<OptimizationModuleBoard>()
+			.AssetMapper<OptimizationModuleBoard>.Scene
 			.Instantiate<OptimizationModuleBoard>();
 		UnderlyingBoard.Init();
 		InterlayerGroups = new IDataPortGroup[3];
 		ExplicitInputs = new InterlayerDataInModule[3];
 		InternalIterOut = this.GetPort<IDataInPort>("InternalIterOut");
-		Output = GetModule<OptimizationOutputModule>("Output");
+		Output = GetModule<OutputSubModule>("Output");
 		Output.Init();
 		for (int i = 0; i < 3; i++)
 		{
@@ -85,11 +76,10 @@ public partial class OptimizationModule : ProgrammableModule,
 			UnderlyingBoard.ImplicitDataOuts[i].DualModule = ExplicitInputs[i];
 		}
 
-		OptimizationFinished = true;
+		ComputationFinished = true;
-		CachedInput = Array.Empty<IData>();
+		CachedInputArray = Array.Empty<DataVariable>();
-		//CachedArray = Array.Empty<DataPackage>();
 		ProcessingIndex = 0;
-		CachedResult = GlobalProvider.DataStructureProvider!.NullData;
+		CachedResult = new DataVariable();
 		CachedOptimizeValue = null;
 		
 		ArrayInput = this.GetPort<DataInPort>("ArrayInput");
@@ -100,8 +90,8 @@ public partial class OptimizationModule : ProgrammableModule,
 				this, 
 				new IDataPort[] { ExplicitInputs[i].DataIn!, UnderlyingBoard.ImplicitDataOuts[i].DataOut! }, 
 				$"Exterior In -> Interior Out{i}", 
-				EnigmosConstant.DataPortTypes.Real, 
+				DataTypeConstant.BaseDataTypes.Real, 
-				EnigmosConstant.DataPortTypes.AnyType
+				DataTypeConstant.DataTypeOptions.AnyType
 			);
 			ExplicitInputs[i].Board = Board;
 		}
@@ -110,8 +100,8 @@ public partial class OptimizationModule : ProgrammableModule,
 			this, 
 			new IDataPort[] { ArrayInput }, 
 			"Array Input Type",
-			EnigmosConstant.DataPortTypes.AnyArrayType, 
+			DataTypeConstant.AutoDataTypes.AutoArray, 
-			EnigmosConstant.DataPortTypes.AnyArray
+			DataTypeConstant.DataTypeOptions.AnyArray
 		);
 		UsingMax = GlobalProvider.DataStructureProvider.NewBoolParameter(
 			"Method",
@@ -119,8 +109,8 @@ public partial class OptimizationModule : ProgrammableModule,
 			"Min",
 			true
 		);
-		Output.Output!.SetDataType(EnigmosConstant.DataPortTypes.Real);
+		Output.Out!.SetDataType(DataTypeConstant.BaseDataTypes.Real);
-		Selector!.Selector!.SetDataType(EnigmosConstant.DataPortTypes.Real);
+		Selector!.Selector!.SetDataType(DataTypeConstant.BaseDataTypes.Real);
 		ConfigurableParameters = new HashSet<IConfigurableParameter> { UsingMax };
 		ConfigurablePortGroups = 
 			InterlayerGroups.Union(new[] { OptimizationGroup }).ToHashSet();
@@ -131,33 +121,33 @@ public partial class OptimizationModule : ProgrammableModule,
 
 	public void Inference()
 	{
-		StringName elementType = GlobalProvider.DataPackageTypeProvider!.ToElement(OptimizationGroup!.SelectedType);
+		DataType elementType = GlobalProvider.DataTypeProvider!.ToElement(OptimizationGroup!.SelectedType);
-		Output!.Output!.SetDataType(elementType);
+		Output!.Out!.SetDataType(elementType);
 		UnderlyingBoard.InputProvider!.Output!.SetDataType(elementType);
 	}
 
 	private void SoftReset() => UnderlyingBoard.Reset();
 
-	public void Optimize()
+	public void Compute()
 	{
-		if (OptimizationFinished)
+		if (ComputationFinished)
 		{
 			CachedOptimizeValue = null;
-			CachedInput = InternalArrayIn!.OutData.Get!.Array;
+			CachedInputArray = InternalArrayIn!.OutData.Get!.Array;
-			CachedResult = GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
+			CachedResult = new();
 			ProcessingIndex = 0;
 		}
 
-		while (ProcessingIndex < CachedInput.Length)
+		while (ProcessingIndex < CachedInputArray.Length)
 		{
 			SoftReset();
 			UnderlyingBoard.InputProvider!.Output!.OutData.UpdateCalculation(
 				cache =>
-					(CachedInput[ProcessingIndex].Data, CachedInput[ProcessingIndex].Type)!
+					(CachedInputArray[ProcessingIndex].Data, CachedInputArray[ProcessingIndex].Type)!
 			);
 			UnderlyingBoard.InputProvider.Output.OutData.Expire();
-			double currentValue = UnderlyingBoard.Selector!.Selector!.GetData.Get!.Double;
+			double currentValue = UnderlyingBoard.Selector!.Selector!.GetData.Get!.Real;
-			IData currentOut = InternalIterOut!.GetData.Get!;
+			DataVariable currentOut = InternalIterOut!.GetData.Get!;
 			if (UsingMax!.ParameterValue)
 			{
 				if (CachedOptimizeValue == null || (CachedOptimizeValue < currentValue))
@@ -178,9 +168,7 @@ public partial class OptimizationModule : ProgrammableModule,
 			
 		}
 		Output!.Define();
-		OptimizationFinished = true;
+		ComputationFinished = true;
-	}
+	}
-
-	public bool Calculated { get; set; }
 }
 

Modules/ProgrammableModules/OptimizationModule/OptimizationOutputModule.cs

@@ -1,25 +0,0 @@
-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

@@ -1,3 +1,4 @@
+using Enigmos.Modules.SubModules;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 

Modules/ProgrammableModules/ProgrammableModule.cs

@@ -1,16 +1,17 @@
-using Enigmos.Boards;
+using Enigmos.Modules.InterlayerModules;
+using Nocturnis;
+using Nocturnis.Enigmos.Boards;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Modules.InterlayerModules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.GlobalManagement.Providers;
+using Nocturnis.Godot;
 
 namespace Enigmos.Modules.ProgrammableModules;
 
-public abstract partial class ProgrammableModule : BaseModule, ICompositeModule, IProgrammableModule
+public abstract partial class ProgrammableModule : CompositeModule, IProgrammableModule
 {
-    public BaseBoard? UnderlyingBoard { get; set; }
+    public IBaseBoard UnderlyingBoard { get; set; }
-    public abstract IBaseModule[] SubModules { get; }
+    public void EnterProgrammableBoard() => GlobalProvider.SceneProvider!.RootScene.ChangeScene(UnderlyingBoard.AsNode());
-    public void EnterProgrammableBoard() => GlobalProvider.SceneProvider!.RootScene.ChangeScene(UnderlyingBoard!);
     public abstract IEnumerable<IBasePort> ExplicitPorts { get; }
     public abstract IEnumerable<IBasePort> ImplicitPorts { get; }
     public override void UpdateCables()
@@ -24,12 +25,18 @@ public abstract partial class ProgrammableModule : BaseModule, ICompositeModule,
         base.UpdateCables();
     }
 
-    protected T GetModule<T>(string path) where T : SubModule
+    public override void Init()
     {
-        T res = GetNode<T>(path);
+        base.Init();
-        res.Init();
+        InterlayerDataInModule[] explicitDataInModules = GetModules<InterlayerDataInModule>();
-        res.ParentModule = this;
+        InterlayerDataOutModule[] explicitDataOutModules = GetModules<InterlayerDataOutModule>();
-        res.Board = Board;
+        InterlayerSignalInModule[] explicitSignalInModules = GetModules<InterlayerSignalInModule>();
-        return res;
+        InterlayerSignalOutModule[] explicitSignalOutModules = GetModules<InterlayerSignalOutModule>();
+        
+        for (int i = 0; i <= explicitDataInModules.Length; i++)
+        {
+            
+        }
+
     }
 }

Modules/SubModules/EnumerableArrayInputModule.cs

@@ -0,0 +1,32 @@
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Enigmos.Modules.SubModules;
+
+public partial class EnumerableArrayInputModule : SubModule, ITerminalModule
+{
+    public new IEnumerableProcessingModule ParentModule
+    {
+        get => (base.ParentModule as IEnumerableProcessingModule)!;
+        set => base.ParentModule = value;
+    }
+    public IDataInPort? Input { get; set; }
+    public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
+    public void Init(IEnumerableProcessingModule module)
+    {
+        base.Init();
+        this.DataInInit("Input", 1);
+        Input = DataInPorts[0];
+        ParentModule = module;
+    }
+
+    public void Drain()
+    {
+        if(Finished)
+            return;
+        ParentModule.CachedInputArray = Input!.GetData.Get!.Array;
+    }
+
+    public bool Finished { get; set; }
+}
+

Modules/SubModules/EnumerableElementOutputModule.cs

@@ -0,0 +1,9 @@
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+
+namespace Enigmos.Modules.SubModules;
+
+public partial class EnumerableElementOutputModule : SubModule
+{
+    private IDataOutPort? Output { get; set; }
+    
+}

Modules/SubModules/OutputSubModule.cs

@@ -0,0 +1,35 @@
+using Nocturnis.DataStructures.DataTypes;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Skeleton.DataStructure;
+
+namespace Enigmos.Modules.SubModules;
+
+public partial class OutputSubModule : SubModule, ISourceModule
+{
+    public IDataOutPort? Out { get; set; }
+    public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
+
+    public new IInternalComputationalModule? ParentModule
+    {
+        get => base.ParentModule as IInternalComputationalModule;
+        set => base.ParentModule = value;
+    }
+
+    public override void Init()
+    {
+        base.Init();
+        Out = this.GetPort<IDataOutPort>("Out");
+    }
+
+    public void Define()
+    {
+        (object, DataType) Func(CacheItem c)
+        {
+            if (!ParentModule!.ComputationFinished)
+                ParentModule!.Compute();
+            return (ParentModule!.CachedResult.Data, ParentModule!.CachedResult.Type)!;
+        }
+        Out!.OutData.UpdateCalculation(Func);
+    }
+}

Modules/SubModules/SubModule.cs

@@ -1,13 +1,14 @@
 using Godot;
 using Nocturnis.Enigmos.Modules;
 
-namespace Enigmos.Modules;
+namespace Enigmos.Modules.SubModules;
 
-public class SubModule : BaseModule
+public partial class SubModule : BaseModule
 {
-    public IBaseModule? ParentModule { get; set; }
+    public ICompositeModule 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;
+    public override Texture2D PreviewTexture => null;
 }

Modules/TerminalModules/EngineModule.cs

@@ -1,5 +1,6 @@
-using Enigmos.Ports.DataPorts;
+using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Controls;
 using Nocturnis.Inventories.ItemSlots.ItemSlots;
@@ -7,19 +8,21 @@ using Skeleton.Utils.Helpers;
 using VirtualChemistry.Chemistry.Mixtures.Implements;
 
 namespace Enigmos.Modules.TerminalModules;
-public partial class EngineModule : TerminalModule
+public abstract partial class EngineModule : TerminalModule, IEngineModule
 {
     protected override bool Draggable => false;
-    public DataInPort? Throttle { get; set; }
+    public IDataInPort Throttle { get; set; }
-    public IChemicalItemSlot? FuelTank { get; set; }
+    public IChemicalItemSlot FuelTank { get; set; }
     private double MaxPumpSpeed => 2d;
     private double EnergyConversionEfficiency => 0.5d;
-    public override IEnumerable<IBasePort> Ports => new[] { Throttle! };
+    public override IEnumerable<IBasePort> Ports => new[] { Throttle };
 
     public override void Init()
     {
         base.Init();
-        Throttle!.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        this.DataInInit("Throttle", 1);
+        Throttle = DataInPorts[0];
+        Throttle.SetDataType(DataTypeConstant.BaseDataTypes.Real);
         FuelTank = GetNode<IChemicalItemSlot>("FuelTank");
         PostInit();
     }
@@ -27,13 +30,13 @@ public partial class EngineModule : TerminalModule
     public override void Drain()
     {
         base.Drain();
-        if (FuelTank!.Item!.ContentMaterial.Layers.Count == 0)
+        if (FuelTank.Item == null || FuelTank.Item.ContentMaterial.Layers.Count == 0)
         {
             EnigmosControl.Instance.Energy = 0;
             return;
         }
         HomogeneousMixture bottom = FuelTank.Item.ContentMaterial.LayerOrder.Last.Value;
-        double consumption = Math.Min(bottom.Amount, Throttle!.GetData.Get!.Double.DoubleCut() * bottom.CombustRate);
+        double consumption = Math.Min(bottom.Amount, Throttle!.GetData.Get!.Real.DoubleCut() * bottom.CombustRate);
         EnigmosControl.Instance.Energy = consumption * bottom.Energy;
         bottom.Amount -= consumption;
     }

Modules/TerminalModules/MemoryModule.cs

@@ -1,8 +1,7 @@
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.Data;
 using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
@@ -10,31 +9,34 @@ using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.TerminalModules;
 
-public partial class MemoryModule : BaseModule, ITerminalModule, ISourceModule, IDuplicateOutputModule
+public abstract partial class MemoryModule : BaseModule, 
+    ITerminalModule, 
+    ISourceModule, 
+    IDuplicateOutputModule,
+    IPolymorphismModule
 {
-    private IData? Memory { get; set; }
+    private DataVariable? Memory { get; set; }
     private IDataPortGroup? MemoryPortGroup { get; set; }
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
  
     public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
     public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
-    public override IEnumerable<IBasePort> Ports => DataInPorts.Union<IBasePort>(DataOutPorts);
 
     public override void Init()
     {
         base.Init();
-        Memory = GlobalProvider.DataStructureProvider!.NewData(0, EnigmosConstant.DataPortTypes.Null);
+        Memory = new DataVariable();
         this.DataInInit("Input", 3);
         this.DataOutInit("Output", 4);
-        DataInPorts[1].SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        DataInPorts[1].SetDataType(DataTypeConstant.BaseDataTypes.Bit);
-        DataInPorts[2].SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        DataInPorts[2].SetDataType(DataTypeConstant.BaseDataTypes.Bit);
         
         MemoryPortGroup =GlobalProvider.DataStructureProvider!.NewDataPortGroup(
             this,
             new IDataPort[] { DataInPorts[0] }.Union(DataOutPorts).ToArray(),
             "Memory Data Type:",
-            EnigmosConstant.DataPortTypes.Real,
+            DataTypeConstant.BaseDataTypes.Real,
-            EnigmosConstant.DataPortTypes.AnyType
+            DataTypeConstant.DataTypeOptions.AnyType
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { MemoryPortGroup };
         PostInit();
@@ -67,4 +69,5 @@ public partial class MemoryModule : BaseModule, ITerminalModule, ISourceModule,
         
     }
 
+    public bool Finished { get; set; }
 }

Modules/TerminalModules/SRLatchModule.cs

@@ -1,20 +1,18 @@
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Modules.TerminalModules;
 
-public partial class SRLatchModule : BaseModule, 
+public abstract partial class SRLatchModule : BaseModule, 
     ITerminalModule, 
     ISourceModule, 
     IDuplicateOutputModule, 
     IOperationModule
 {
-    public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
+    public IDataOutPort[] DataOutPorts { get; set; }
-    public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
+    public IDataInPort[] DataInPorts { get; set; }
-    public override IEnumerable<IBasePort> Ports => DataInPorts.Union<IBasePort>(DataOutPorts);
 
     private bool State { get; set; }
 
@@ -29,18 +27,21 @@ public partial class SRLatchModule : BaseModule,
         else if (reset)
             State = false;
     }
+
+    public bool Finished { get; set; }
+
     public override void Init()
     {
         base.Init();
         this.DataInInit("Input",2);
         this.DataOutInit("Output", 2);
-        this.SetOutputType(EnigmosConstant.DataPortTypes.Bit);
+        this.SetOutputType(DataTypeConstant.BaseDataTypes.Bit);
-        this.SetInputType(EnigmosConstant.DataPortTypes.Bit);
+        this.SetInputType(DataTypeConstant.BaseDataTypes.Bit);
         PostInit();
     }
 
     public void Define()
     {
-        this.Define(cache => (State, EnigmosConstant.DataPortTypes.Bit));
+        this.Define(cache => (State, DataTypeConstant.BaseDataTypes.Bit));
     }
 }

Modules/TerminalModules/TestingModules/LightEmittingDiodeModule.cs

@@ -1,39 +1,33 @@
-using Enigmos.Modules.ControllingModules;
 using Enigmos.Ports.DataPorts;
 using Godot;
 using Nocturnis.Enigmos.Modules;
-using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
 using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.TerminalModules.TestingModules;
 
-public partial class LightEmittingDiodeModule : TerminalModule
+public abstract partial class LightEmittingDiodeModule : TerminalModule
 {
-	private Sprite2D? LightEmittingDiode { get; set; }
+	private Sprite2D LightEmittingDiode { get; set; }
-	private IDataInPort? Input { get; set; }
+	private IDataInPort Input { get; set; }
-	public override IEnumerable<IBasePort> Ports => new[] { Input! };
 
-	private static readonly Texture2D TrueTexture =
-		ResourceLoader.Load<Texture2D>("res://Resources/Circuits/Modules/Terminal/Testing/LEDBubble-T.png");
-	private static readonly Texture2D FalseTexture =
-		ResourceLoader.Load<Texture2D>("res://Resources/Circuits/Modules/Terminal/Testing/LEDBubble-F.png");
 	public override void Init()
 	{
 		base.Init();
 		Finished = true;
 		LightEmittingDiode = GetNode<Sprite2D>("LightEmittingDiode");
 		Input = this.GetPort<DataInPort>("Input");
-		Input.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input.SetDataType(DataTypeConstant.BaseDataTypes.Bit);
 		PostInit();
 	}
 
 	public override void Drain()
 	{
-		if (Input!.GetData.Get!.Bit)
+		if (Input.GetData.Get.Bit)
-			LightEmittingDiode!.Texture = TrueTexture;
+			LightEmittingDiode.Texture = GlobalProvider.TextureProvider.LEDOn;
 		else
-			LightEmittingDiode!.Texture = FalseTexture;
+			LightEmittingDiode.Texture = GlobalProvider.TextureProvider.LEDOff;
 		Finished = true;
 	}
 }

Modules/TerminalModules/TestingModules/R2Reader.cs

@@ -6,11 +6,11 @@ namespace Enigmos.Modules.TerminalModules.TestingModules;
 
 public partial class R2Reader : Control
 {
-	private AnimatedSprite2D? Direction { get; set; }
+	private AnimatedSprite2D Direction { get; set; }
-	private AnimatedSprite2D? Magnitude { get; set; }
+	private AnimatedSprite2D Magnitude { get; set; }
-	public R2? UnderlyingVector { get; set; }
+	public R2 UnderlyingVector { get; set; }
-	private double TargetPhase() => Math.Atan2(UnderlyingVector![2], UnderlyingVector![1]);
+	private double TargetPhase() => UnderlyingVector == null ? 0: Math.Atan2(UnderlyingVector![2], UnderlyingVector![1]);
-	private double TargetLength() => UnderlyingVector!.Magnitude;
+	private double TargetLength() => UnderlyingVector?.Magnitude ?? 0;
 
 	private int TargetPhaseFrame => 
 		Mathf.FloorToInt((TargetPhase() % (2d * Math.PI) + 2d * Math.PI) % (2d * Math.PI) * 44d / (2d * Math.PI));

Modules/TerminalModules/TestingModules/R2ReaderModule.cs

@@ -1,23 +1,19 @@
-using Enigmos.Modules.ControllingModules;
-using Enigmos.Ports;
 using Enigmos.Ports.DataPorts;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Modules.TerminalModules.TestingModules;
 
-public partial class R2ReaderModule : TerminalModule
+public abstract partial class R2ReaderModule : TerminalModule
 {
-	private DataInPort? DataIn { get; set; }
+	private DataInPort DataIn { get; set; }
-	private R2Reader? R2Reader { get; set; }
+	private R2Reader R2Reader { get; set; }
-
-	public override IEnumerable<BasePort> Ports => new[] { DataIn! };
 
 	public override void Init()
 	{
 		base.Init();
 		DataIn = this.GetPort<DataInPort>("DataIn");
-		DataIn.SetDataType(EnigmosConstant.DataPortTypes.R2);
+		DataIn.SetDataType(DataTypeConstant.BaseDataTypes.R2);
 		R2Reader = GetNode<R2Reader>("R2Reader");
 		R2Reader.Init();
 		PostInit();

Modules/TerminalModules/TestingModules/RealReaderModule.cs

@@ -1,24 +1,22 @@
 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.Utils.Helpers;
 
 namespace Enigmos.Modules.TerminalModules.TestingModules;
 
-public partial class RealReaderModule : BaseModule, ITerminalModule, IOperationModule
+public abstract partial class RealReaderModule : BaseModule, ITerminalModule, IOperationModule
 {
-    private AnimatedSprite2D? RealReader { get; set; }
+    private AnimatedSprite2D RealReader { get; set; }
     public IDataInPort[] DataInPorts { get; set; } = Array.Empty<IDataInPort>();
-    public override IEnumerable<IBasePort> Ports => DataInPorts;
 
     public override void Init()
     {
         base.Init();
         this.DataInInit("Input", 3);
-        this.SetInputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetInputType(DataTypeConstant.BaseDataTypes.Real);
         RealReader = GetNode<AnimatedSprite2D>("RealReader");
         RealReader.SpeedScale = 0;
         RealReader.Play();
@@ -27,12 +25,14 @@ public partial class RealReaderModule : BaseModule, ITerminalModule, IOperationM
 
     public void Drain()
     {
-        double max = DataInPorts[0].GetData.Get!.Double;
+        double max = DataInPorts[0].GetData.Get!.Real;
-        double min = DataInPorts[2].GetData.Get!.Double;
+        double min = DataInPorts[2].GetData.Get!.Real;
-        double value = DataInPorts[1].GetData.Get!.Double;
+        double value = DataInPorts[1].GetData.Get!.Real;
         double range = max - min;
-        double percentage = (range == 0 ? 0d : value / range).DoubleCut();
+        double percentage = (range == 0 ? 0d : (value - min) / range).DoubleCut();
         int frame = Mathf.FloorToInt(percentage * 122);
         RealReader!.SpeedScale = (frame - RealReader.Frame) / 60f;
     }
+
+    public bool Finished { get; set; }
 }

Ports/BasePort.cs

@@ -17,13 +17,18 @@ public abstract partial class BasePort : TextureButton, IBasePort
     /// </summary>
     public int Quality { get; set; }
 
-    public IBaseModule? Module { get; set; }
+    public IBaseModule Module { get; set; }
     public abstract bool IsMatch(IBasePort oth);
-    public IBasePort? ConnectedPort { get; set; }
+    public IBasePort ConnectedPort { get; set; }
     public bool Connected => ConnectedPort != null;
 
     public abstract void SetStatusPending();
-    public abstract void SetStatusConnected();
+
+    public virtual void SetStatusConnected()
+    {
+        PostConnect();
+    }
+
     public abstract void SetStatusNormal();
     /// <summary>
     /// Determine whether this port can be connected with given port
@@ -33,5 +38,9 @@ public abstract partial class BasePort : TextureButton, IBasePort
     public virtual void Init()
     {
     }
+    public void Connect() => this.ExtConnect();
 
+    public virtual void PostConnect()
+    {
+    }
 }

Ports/DataPorts/DataInPort.cs

@@ -15,9 +15,9 @@ public partial class DataInPort : DataPort, IDataInPort
 
 	public override bool IsMatch(IBasePort other) =>
 		other is DataOutPort dataOut &&
-		GlobalProvider.DataPackageTypeProvider!.DataPortTypeCompatible(DataType!, dataOut.DataType!);
+		GlobalProvider.DataTypeProvider!.DataPortTypeCompatible(DataType!, dataOut.DataType!);
 
-	public DataCache GetData => Connected ? ConnectedPort!.OutData : DataCache.Null;
+	public DataCache GetData => Connected ? ConnectedPort!.OutData : DefaultDataCache.Default;
 
 	/*public IDataPackage GetData(IRootModule root)
 	{

Ports/DataPorts/DataOutPort.cs

@@ -3,11 +3,12 @@ using Nocturnis.Enigmos.Cables;
 using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Ports.DataPorts;
 
-public partial class DataOutPort : DataPort, IDataOutPort
+public abstract partial class DataOutPort : DataPort, IDataOutPort
 {
     public new IComputationalModule Module
     {
@@ -18,15 +19,15 @@ public partial class DataOutPort : DataPort, IDataOutPort
     //public void DataUpdateRequest(IRootModule root) => Module.ComputeWithTimeoutHandle(root);
     
 
-    public new IDataInPort? ConnectedPort
+    public new IDataInPort ConnectedPort
     {
-        get => (base.ConnectedPort as IDataInPort)!;
+        get => base.ConnectedPort as IDataInPort;
         set => base.ConnectedPort = value;
     }
 
     public override bool IsMatch(IBasePort other) =>
         other is DataInPort inPort &&
-        GlobalProvider.DataPackageTypeProvider!.DataPortTypeCompatible(inPort.DataType!, DataType!);
+        GlobalProvider.DataTypeProvider!.DataPortTypeCompatible(inPort.DataType!, DataType!);
 
     public override IBaseCable MakeCable(IBasePort other)
     {
@@ -36,5 +37,9 @@ public partial class DataOutPort : DataPort, IDataOutPort
         return res;
     }
 
-    public DataCache OutData { get; set; } = new(x => (0, ""));
+    public DataCache OutData { get; set; } = new(x => (0, DataTypeConstant.BaseDataTypes.Null));
+    public override void PostConnect()
+    {
+        Module.Define();
+    }
 }

Ports/DataPorts/DataPort.cs

@@ -1,33 +1,35 @@
 using Enigmos.Cables;
 using Godot;
+using Nocturnis.DataStructures.DataTypes;
 using Nocturnis.Enigmos.Cables;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.DataPorts;
+using Nocturnis.GlobalManagement.Constants;
 using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Ports.DataPorts;
 
 public abstract partial class DataPort : BasePort, IDataPort
 {
-    public new IDataPort? ConnectedPort
+    public new IDataPort ConnectedPort
     {
         get => (base.ConnectedPort as IDataPort)!;
         set => base.ConnectedPort = value;
     }
-    protected Sprite2D? DataTypeTexture { get; set; }
+    protected Sprite2D DataTypeTexture { get; set; }
-    public StringName? DataType { get; set; }
+    public DataType DataType { get; set; } = new(DataTypeConstant.BaseDataTypeNames.Null);
     public override void Init()
     {
         DataTypeTexture = GetNode<Sprite2D>("DataTypeTexture");
         DataTypeTexture.Visible = false;
         base.Init();
     }
-    public void SetDataType(StringName val)
+    public void SetDataType(DataType val)
     {
         if(Connected && val != ConnectedPort!.DataType)
             this.Disconnect();
         DataType = val;
-        DataTypeTexture!.Texture = GlobalProvider.EnigmosProvider!.DataPortTypeMap[val];
+        DataTypeTexture!.Texture = GlobalProvider.DataTypeTexture[DataType.Type];
     }
 
     private void MouseEnterHandler() => DataTypeTexture!.Visible = true;
@@ -46,8 +48,10 @@ public abstract partial class DataPort : BasePort, IDataPort
     public override void SetStatusPending() =>
         TextureNormal = GlobalProvider.EnigmosProvider!.DataPortStatusPending;
 
-    public override void SetStatusConnected() =>
+    public override void SetStatusConnected()
+    {
+        base.SetStatusConnected();
         TextureNormal = GlobalProvider.EnigmosProvider!.DataPortStatusConnected;
-
+    }
 }
 

Ports/SignalPorts/SignalInPort.cs

@@ -9,11 +9,11 @@ public partial class SignalInPort : SignalPort, ISignalInPort
 {
 	public new IControllingModule Module 
 	{ 
-		get => (base.Module as PiplineModule)!;
+		get => (base.Module as IControllingModule)!;
 		set => base.Module = value; 
 	}
 
-	public new ISignalOutPort? ConnectedPort
+	public new ISignalOutPort ConnectedPort
 	{
 		get => base.ConnectedPort as ISignalOutPort;
 		set => base.ConnectedPort = value;

Ports/SignalPorts/SignalOutPort.cs

@@ -2,6 +2,7 @@ using Enigmos.Cables;
 using Nocturnis.Enigmos.Modules;
 using Nocturnis.Enigmos.Ports;
 using Nocturnis.Enigmos.Ports.SignalPorts.Directions;
+using Nocturnis.GlobalManagement.Controls;
 
 namespace Enigmos.Ports.SignalPorts;
 
@@ -14,7 +15,7 @@ public partial class SignalOutPort : SignalPort, ISignalOutPort
 	}
 	
 
-	public new ISignalInPort? ConnectedPort
+	public new ISignalInPort ConnectedPort
 	{
 		get => base.ConnectedPort as ISignalInPort;
 		set => base.ConnectedPort = value;
@@ -33,8 +34,11 @@ public partial class SignalOutPort : SignalPort, ISignalOutPort
 	public void Route()
 	{
 		if (!Connected)
+		{
+			CreatureControl.Instance.CurrentCharacter!.MotherBoard.Root.ActionFinished = true;
 			return;
-		ConnectedPort!.Module.Execute();
+		}
+		ConnectedPort.Module.Visit();
+	}
 
 }
-}

Ports/SignalPorts/SignalPort.cs

@@ -20,9 +20,11 @@ public abstract partial class SignalPort : BasePort, ISignalPort
     private void MouseEnteredHandler() => SignalDirection!.Visible = true;
     private void MouseExitedHandler() => SignalDirection!.Visible = false;
 
-    public override void SetStatusConnected() => 
+    public override void SetStatusConnected()
+    {
+        base.SetStatusConnected();
         TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusConnected;
-
+    }
     public override void SetStatusNormal() => 
         TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusNormal;