project update

Modules/InterlayerModules/InterlayerDataInModule.cs

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

Modules/InterlayerModules/InterlayerDataOutModule.cs

@@ -0,0 +1,32 @@
+using Enigmos.Modules.ComputationalModules;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+
+namespace Enigmos.Modules.InterlayerModules;
+
+public partial class InterlayerDataOutModule : ComputationalModule, IInterlayerDataOutModule
+{
+    public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
+    public IProgrammableModule? ParentModule { get; set; }
+
+    protected override bool Draggable => false;
+    protected override bool HasManual => false;
+    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()
+    {
+        base.Init();
+        DataOut = GetPort<DataOutPort>("DataOut");
+        PostInit();
+    }
+
+    protected override void Compute(IRootModule root)
+    {
+        DataOut!.ResultData = DualModule!.DataIn!.GetData(root);
+    }
+}

Modules/InterlayerModules/InterlayerSignalInModule.cs

@@ -0,0 +1,28 @@
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports.SignalPorts;
+using Godot;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+
+namespace Enigmos.Modules.InterlayerModules;
+
+public partial class InterlayerSignalInModule : ControllingModule, IInterlayerSignalInModule
+{
+    public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
+    public IProgrammableModule? ParentModule { get; set; }
+    protected override bool Draggable => false;
+    protected override bool HasManual => false;
+    public IBasePort UnderlyingPort => SignalIn!;
+    public IInterlayerSignalOutModule? DualModule { get; set; }
+    public ISignalInPort? SignalIn { get; set; }
+    public override IEnumerable<IBasePort> Ports => new[] { SignalIn }!;
+
+    public override void Init()
+    {
+        base.Init();
+        SignalIn = GetPort<SignalInPort>("SignalIn");
+        PostInit();
+    }
+
+    protected override void Route(IRootModule root) => DualModule!.SignalOut!.Module.RouteWithTimeoutHandle(root);
+}

Modules/InterlayerModules/InterlayerSignalOutModule.cs

@@ -0,0 +1,36 @@
+
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Modules.ProgrammableModules;
+using Enigmos.Ports;
+using Enigmos.Ports.SignalPorts;
+using Godot;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+
+namespace Enigmos.Modules.InterlayerModules;
+
+public partial class InterlayerSignalOutModule : ControllingModule, IInterlayerSignalOutModule
+{
+    public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero);
+    public IProgrammableModule? ParentModule { get; set; }
+    protected override bool Draggable => false;
+    protected override bool HasManual => false;
+    public IBasePort UnderlyingPort => SignalOut!;
+    public IInterlayerSignalInModule? DualModule { get; set; }
+    public ISignalOutPort? SignalOut { get; set; }
+    public override IEnumerable<IBasePort> Ports => new[] { SignalOut }!;
+
+    public override void Init()
+    {
+        base.Init();
+        SignalOut = GetPort<SignalOutPort>("SignalOut");
+        PostInit();
+    }
+
+    protected override void Route(IRootModule root)
+    {
+        if (!SignalOut!.Connected)
+            return;
+        SignalOut.ConnectedPort!.Module.RouteWithTimeoutHandle(root);
+    }
+}