Split project

Modules/BaseModule.cs

@@ -0,0 +1,162 @@
+using Enigmos.Exceptions;
+using Enigmos.Manual;
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Boards;
+using Nocturnis.Enigmos.Cables;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.UIElements;
+using TabulaSmaragdina;
+
+namespace Enigmos.Modules;
+
+public abstract partial class BaseModule : TextureRect, IBaseModule
+{
+    private static readonly Font GnuUni = ResourceLoader.Load<Font>("res://Resources/Fonts/GnuUnifontFull-Pm9P.ttf");
+    [Export] private int PresetPortQuality { get; set; }
+    [Export] private int PresetPortCondition { get; set; }
+    [Export] protected bool UsingPreset { get; set; }
+    [Export] public IPresetModuleConnection[] PresetConnections { get; set; }
+    [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 IBaseBoard? Board { get; set; }
+    private ModuleManual? Manual { get; set; }
+    public ISimpleLabel? Label { get; set; }
+    public Node AsNode => this;
+    public virtual void PresetValueInit()
+    {
+        foreach (IBasePort port in Ports)
+        {
+            port.Condition = PresetPortCondition;
+            port.Quality = PresetPortQuality;
+        }
+    }
+
+    public virtual void Init()
+    {
+        if (HasLabel())
+        {
+            Label = GlobalProvider.SceneProvider
+                .AssetMapper<ISimpleLabel>()
+                .Instantiate<ISimpleLabel>();
+            Label.Position = new Vector2(0, -25);
+            Label.Text = LabelString;
+            AddChild(Label.AsNode);
+
+        }
+    }
+
+    /// <summary>
+    /// Used to determine result of fixing a port with given material 
+    /// </summary>
+    public virtual double MaintenanceAlpha => 0d;
+
+    /// <summary>
+    /// Used to determine result of fixing a port with given material 
+    /// </summary>
+    public virtual double MaintenanceBeta => 0d;
+
+    public virtual string GetDescription => "";
+
+    public virtual void UpdateCables()
+    {
+        foreach (IBasePort port in Ports)
+        {
+            if(!Board!.CablePairing.ContainsKey(port))
+                continue;
+            Board.CablePairing[port].LineUpdate();
+        }
+    }
+
+    protected virtual void PostInit()
+    {
+        foreach (IBasePort port in Ports)
+            port.Module = this;
+        if(UsingPreset)
+            PresetValueInit();
+    }
+
+    protected virtual void TimeoutCheck(RootModule 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())
+            return default;
+        Board!.ModuleMovingLayer.DraggingModule = this;
+        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)
+        {
+            Vector2 mousePosition = GetLocalMousePosition();
+            if(mousePosition.X > 0 && mousePosition.X < Size.X && mousePosition.Y > 0  && mousePosition.Y < Size.Y)
+            {
+                if (eventMouseButton.ButtonIndex == MouseButton.Right && eventMouseButton.Pressed)
+                {
+                    if (!HasManual())
+                        return;
+                    if (Board.ManualOpened)
+                        return;
+                    if (Manual == null)
+                    {
+                        Manual = GlobalProvider.SceneProvider
+                            .AssetMapper<ModuleManual>()
+                            .Instantiate<ModuleManual>();
+                        Manual.Init(this);
+                    }
+
+                    Board.ModuleManualLayer.AddChild(Manual);
+                    Manual.Position = Board.ModuleManualLayer.ManualPosition.Position - Manual.Size / 2;
+                    Board.ManualOpened = true;
+                    return;
+                }
+
+                if (eventMouseButton.ButtonIndex == MouseButton.Left && eventMouseButton.Pressed)
+                {
+                    if (Board!.CableVisualMode)
+                    {
+                        foreach (IBaseCable cable in Board.FocusedCables)
+                            cable.Modulate = Color.Color8(255, 255, 255, 20);
+                        Board.FocusedCables = Ports
+                            .Where(Board.CablePairing.ContainsKey)
+                            .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))
+                                Board.FocusedCables.Add(Board.CablePairing[port]);
+                        foreach (IBaseCable cable in Board.FocusedCables)
+                            cable.Modulate = Color.Color8(255, 255, 255, 255);
+                    }
+                }
+            }
+        }
+
+        base._Input(@event);
+    }
+}

Modules/ComputationalModules/BinaryComputationalModule.cs

@@ -0,0 +1,25 @@
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+
+namespace Enigmos.Modules.ComputationalModules;
+
+public abstract partial class BinaryComputationalModule : ComputationalModule
+{
+    protected DataInPort Input1 { get; set; }
+    protected DataInPort Input2 { get; set; }
+    public override IEnumerable<BasePort> Ports => new[] { Input1, Input2 };
+
+    public override void Init()
+    {
+        base.Init();
+        Input1 = GetPort<DataInPort>("Input1");
+        Input2 = GetPort<DataInPort>("Input2");
+    }
+    
+
+    protected abstract void Compute(IDataPackage input1, IDataPackage input2);
+    protected override void Compute(RootModule root) => Compute(Input1.GetData(root), Input2.GetData(root));
+    
+}

Modules/ComputationalModules/ComputationalModule.cs

@@ -0,0 +1,31 @@
+using Enigmos.Exceptions;
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports.DataPorts;
+
+namespace Enigmos.Modules.ComputationalModules;
+
+public abstract partial class ComputationalModule : BaseModule
+{
+    protected override void TimeoutHandler(ModuleExecutionTimeout timeout)
+    {
+        foreach (DataOutPort port in Ports.OfType<DataOutPort>())
+            port.DataUpdated = false;
+        base.TimeoutHandler(timeout);
+    }
+
+    protected abstract void Compute(RootModule root);
+    public void ComputeWithTimeoutHandle(RootModule root)
+    {
+        foreach (DataOutPort port in Ports.OfType<DataOutPort>())
+            port.DataUpdated = true;
+        try
+        {
+            Compute(root);
+        }
+        catch (ModuleExecutionTimeout timeOut)
+        {
+            TimeoutHandler(timeOut);
+        }
+        TimeoutCheck(root);
+    }
+}

Modules/ComputationalModules/NullaryComputationalModule.cs

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

Modules/ComputationalModules/QuaternaryComputationalModule.cs

@@ -0,0 +1,29 @@
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+
+namespace Enigmos.Modules.ComputationalModules;
+
+public abstract partial class QuaternaryComputationalModule : ComputationalModule
+{
+    protected DataInPort Input1 { get; set; }
+    protected DataInPort Input2 { get; set; }
+    protected DataInPort Input3 { get; set; }
+    protected DataInPort Input4 { get; set; }
+    public override IEnumerable<BasePort> Ports => new[] { Input1, Input2, Input3, Input4 };
+    public override void Init()
+    {
+        base.Init();
+        Input1 = GetPort<DataInPort>("Input1");
+        Input2 = GetPort<DataInPort>("Input2");
+        Input3 = GetPort<DataInPort>("Input3");
+        Input4 = GetPort<DataInPort>("Input4");
+    }
+
+
+    protected abstract void Compute(IDataPackage input1, IDataPackage input2, IDataPackage input3, IDataPackage input4);
+
+    protected override void Compute(RootModule root) => 
+        Compute(Input1.GetData(root), Input2.GetData(root), Input3.GetData(root), Input4.GetData(root));
+}

Modules/ComputationalModules/TernaryComputationalModule.cs

@@ -0,0 +1,26 @@
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+
+namespace Enigmos.Modules.ComputationalModules;
+
+public abstract partial class TernaryComputationalModule : ComputationalModule
+{
+    protected DataInPort Input1 { get; set; }
+    protected DataInPort Input2 { get; set; }
+    protected DataInPort Input3 { get; set; }
+    public override IEnumerable<BasePort> Ports => new[] { Input1, Input2, Input3 };
+    public override void Init()
+    {
+        base.Init();
+        Input1 = GetPort<DataInPort>("Input1");
+        Input2 = GetPort<DataInPort>("Input2");
+        Input3 = GetPort<DataInPort>("Input3");
+    }
+
+    protected abstract void Compute(IDataPackage input1, IDataPackage input2, IDataPackage input3);
+
+    protected override void Compute(RootModule root) =>
+        Compute(Input1.GetData(root), Input2.GetData(root), Input3.GetData(root));
+}

Modules/ComputationalModules/UnaryComputationalModule.cs

@@ -0,0 +1,20 @@
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+
+namespace Enigmos.Modules.ComputationalModules;
+
+public abstract partial class UnaryComputationalModule : ComputationalModule
+{
+    protected DataInPort Input1 { get; set; }
+    public override IEnumerable<BasePort> Ports => new[] { Input1 };
+    public override void Init()
+    {
+        base.Init();
+        Input1 = GetPort<DataInPort>("Input1");
+    }
+    
+    protected abstract void Compute(IDataPackage input1);
+    protected override void Compute(RootModule root) => Compute(Input1.GetData(root));
+}

Modules/ControllingModules/ActionModules/ActionModule.cs

@@ -0,0 +1,12 @@
+namespace Enigmos.Modules.ControllingModules.ActionModules;
+
+public abstract partial class ActionModule : ControllingModule
+{
+    protected abstract void Execute(RootModule root);
+    protected override void Route(RootModule root)
+    {
+        if(!root.ActionFinished)
+            Execute(root);
+        root.ActionFinished = true;
+    }
+}

Modules/ControllingModules/ActionModules/AttackActionModule.cs

@@ -0,0 +1,34 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Enigmos.Ports.SignalPorts;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ControllingModules.ActionModules;
+public partial class AttackActionModule : ActionModule
+{
+	private SignalInPort SignalIn1 { get; set; }
+	private SignalInPort SignalIn2 { get; set; }
+	private SignalInPort SignalIn3 { get; set; }
+	private SignalInPort SignalIn4 { get; set; }
+
+	private DataInPort Input1 { get; set; }
+
+	public override IEnumerable<BasePort> Ports =>
+		new BasePort[] { SignalIn1, SignalIn2, SignalIn3, SignalIn4, Input1 };
+
+	public override void Init()
+	{
+		base.Init();
+		SignalIn1 = GetNode<SignalInPort>("SignalIn1");
+		SignalIn2 = GetNode<SignalInPort>("SignalIn2");
+		SignalIn3 = GetNode<SignalInPort>("SignalIn3");
+		SignalIn4 = GetNode<SignalInPort>("SignalIn4");
+		Input1 = GetNode<DataInPort>("Input1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.R2);
+		PostInit();
+	}
+
+
+	protected override void Execute(RootModule root) => 
+		root.ManagedBy.Action.Attack(Input1.GetData(root).R2);
+}

Modules/ControllingModules/ActionModules/MoveActionModule.cs

@@ -0,0 +1,41 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Enigmos.Ports.SignalPorts;
+using Skeleton.Algebra;
+using Skeleton.Algebra.DimensionProviders;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ControllingModules.ActionModules;
+using R2 = CategoryOf<IDim2>.OnField<double>.FVector;
+public partial class MoveActionModule : ActionModule
+{
+
+	private DataInPort Input1 { get; set; }
+	private SignalInPort SignalIn1 { get; set; }
+	private SignalInPort SignalIn2 { get; set; }
+	private SignalInPort SignalIn3 { get; set; }
+	private SignalInPort SignalIn4 { get; set; }
+
+	public override IEnumerable<BasePort> Ports => new BasePort[] { Input1, SignalIn1, SignalIn2, SignalIn3, SignalIn4 };
+
+	public override void Init()
+	{
+		base.Init();
+		Input1 = GetPort<DataInPort>("Input1");
+		SignalIn1 = GetPort<SignalInPort>("SignalIn1");
+		SignalIn2 = GetPort<SignalInPort>("SignalIn2");
+		SignalIn3 = GetPort<SignalInPort>("SignalIn3");
+		SignalIn4 = GetPort<SignalInPort>("SignalIn4");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.R2);
+		PostInit();
+	}
+
+	
+	public override string GetDescription => "";
+
+	protected override void Execute(RootModule root)
+	{
+		R2 direction = Input1.GetData(root).R2;
+		root.ManagedBy.Action.Move(direction);
+	}
+}

Modules/ControllingModules/ControllingModule.cs

@@ -0,0 +1,30 @@
+using Enigmos.Exceptions;
+
+namespace Enigmos.Modules.ControllingModules;
+
+public abstract partial class ControllingModule : BaseModule
+{
+    
+    protected abstract void Route(RootModule root);
+    public bool Visited { get; set; }
+    protected override void TimeoutHandler(ModuleExecutionTimeout timeout)
+    {
+        Visited = false;
+        base.TimeoutHandler(timeout);
+    }
+
+    public void RouteWithTimeoutHandle(RootModule root)
+    {
+        if (Visited)
+            return;
+        TimeoutCheck(root);
+        try
+        {
+            Route(root);
+        }
+        catch (ModuleExecutionTimeout timeOut)
+        {
+            TimeoutHandler(timeOut);
+        }
+    }
+}

Modules/ControllingModules/RootModule.cs

@@ -0,0 +1,34 @@
+using System.Diagnostics;
+using Enigmos.Ports;
+using Enigmos.Ports.SignalPorts;
+using Nocturnis.Creatures;
+
+namespace Enigmos.Modules.ControllingModules;
+public partial class RootModule : ControllingModule
+{
+	public bool ActionFinished { get; set; }
+	public IBaseCreature ManagedBy { get; set; }
+	protected override bool Draggable() => false;
+	private SignalOutPort SignalOut1 { get; set; }
+	public override IEnumerable<BasePort> Ports => new[] { SignalOut1 };
+	public Stopwatch Timer { get; set; }
+
+	public override void Init()
+	{
+		base.Init();
+		ActionFinished = true;
+		SignalOut1 = GetPort<SignalOutPort>("SignalOut1");
+		PostInit();
+	}
+
+	protected override void Route(RootModule r)
+	{
+		if(!SignalOut1.Connected)
+		{
+			ActionFinished = true;
+			return;
+		}
+		Visited = true;
+		SignalOut1.ConnectedPort.Module.RouteWithTimeoutHandle(this);
+	}
+}

Modules/ControllingModules/SinglePoleDoubleThrowSwitchModule.cs

@@ -0,0 +1,47 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Enigmos.Ports.SignalPorts;
+using Nocturnis.DataStructures.ConfigurableParameters;
+using Nocturnis.Enigmos.Modules;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ControllingModules;
+
+public partial class SinglePoleDoubleThrowSwitchModule : ControllingModule, IParameterizedModule
+{
+	private DataInPort ControlInput { get; set; }
+	private SignalInPort SignalIn { get; set; }
+	private SignalOutPort SignalOut1 { get; set; }
+	private SignalOutPort SignalOut2 { get; set; }
+	public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; }
+	private IBoolParameter LeftPortForTrue { get; set; }
+	public override IEnumerable<BasePort> Ports => new BasePort[] { SignalIn, SignalOut1, SignalOut2, ControlInput };
+
+	public override void Init()
+	{
+		base.Init();
+		SignalIn = GetPort<SignalInPort>("SignalIn");
+		SignalOut1 = GetPort<SignalOutPort>("SignalOut1");
+		SignalOut2 = GetPort<SignalOutPort>("SignalOut2");
+		ControlInput = GetPort<DataInPort>("ControlInput");
+		LeftPortForTrue = 
+			GlobalProvider.DataStructureProvider.NewBoolParameter("Redirect to:", "Left", "Right", true);
+		ControlInput.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		ConfigurableParameters = new HashSet<IConfigurableParameter> { LeftPortForTrue };
+		PostInit();
+	}
+
+	protected override void Route(RootModule root)
+	{
+		Visited = true;
+		SignalOutPort selectedPort = (LeftPortForTrue.ParameterValue && ControlInput.GetData(root).Bit)
+			? SignalOut1
+			: SignalOut2;
+		if (selectedPort.Connected)
+			selectedPort.ConnectedPort.Module.RouteWithTimeoutHandle(root);
+		else
+			root.ActionFinished = true;
+	}
+	
+}

Modules/ControllingModules/SinglePoleSingleThrowSwitchModule.cs

@@ -0,0 +1,35 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Enigmos.Ports.SignalPorts;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ControllingModules;
+
+public partial class SinglePoleSingleThrowSwitchModule : ControllingModule
+{
+	private SignalInPort SignalIn { get; set; }
+	private SignalOutPort SignalOut { get; set; }
+	private DataInPort ControlInput { get; set; }
+	public override IEnumerable<BasePort> Ports => new BasePort[] { SignalIn, SignalOut, ControlInput };
+
+	public override void Init()
+	{
+		base.Init();
+		SignalIn = GetPort<SignalInPort>("SignalIn");
+		SignalOut = GetPort<SignalOutPort>("SignalOut");
+		ControlInput = GetPort<DataInPort>("ControlInput");
+		ControlInput.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+
+	
+
+	protected override void Route(RootModule root)
+	{
+		Visited = true;
+		if (ControlInput.GetData(root).Bit && SignalOut.Connected)
+			SignalOut.ConnectedPort.Module.RouteWithTimeoutHandle(root);
+		else
+			root.ActionFinished = true;
+	}
+}

Modules/Extensions/CommunicateModuleExtension.cs

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

Modules/IBaseModule.cs

@@ -1,9 +0,0 @@
-namespace Enigmos.Modules;
-using Godot;
-public interface IBaseModule
-{
-    Vector2 Size { get; set; }
-    Vector2 Position { get; set; }
-    Vector2 PositionToBoard { get; }
-    bool Draggable { get; }
-}

Modules/ProgrammableModules/ProgrammableModule.cs

@@ -0,0 +1,34 @@
+using Enigmos.Boards;
+using Enigmos.Ports;
+using Nocturnis.Enigmos.Modules;
+using TabulaSmaragdina;
+
+namespace Enigmos.Modules.ProgrammableModules;
+
+public abstract partial class ProgrammableModule : BaseModule, ICompositeModule, IProgrammableModule
+{
+    public BaseBoard UnderlyingBoard { get; set; }
+    public abstract IBaseModule[] SubModules();
+    public void EnterProgrammableBoard() => GlobalProvider.SceneProvider.RootScene.ChangeScene(UnderlyingBoard);
+    public abstract IEnumerable<BasePort> ExplicitPorts(); 
+    public abstract IEnumerable<BasePort> ImplicitPorts(); 
+    public override void UpdateCables()
+    {
+        foreach (BasePort port in ExplicitPorts())
+        {
+            if(!Board.CablePairing.ContainsKey(port) )
+                continue;
+            Board.CablePairing[port].LineUpdate();
+        }
+        base.UpdateCables();
+    }
+
+    protected T GetModule<T>(string path) where T : BaseModule, IInterlayerModule
+    {
+        T res = GetNode<T>(path);
+        res.Init();
+        res.ParentModule = this;
+        res.Board = Board;
+        return res;
+    }
+}

Modules/TerminalModules/TerminalModule.cs

@@ -0,0 +1,36 @@
+using Enigmos.Exceptions;
+using Enigmos.Modules.ControllingModules;
+using Enigmos.Ports.DataPorts;
+
+namespace Enigmos.Modules.TerminalModules;
+
+public abstract partial class TerminalModule : BaseModule
+{
+    public bool Finished { get; set; }
+
+    protected virtual void Consume(RootModule root)
+    {
+        foreach (DataInPort port in Ports.OfType<DataInPort>())
+            port.GetData(root);
+        Finished = true;
+    }
+
+    public void ConsumeWithTimeoutHandle(RootModule root)
+    {
+        try
+        {
+            Finished = true;
+            Consume(root);
+        }
+        catch (ModuleExecutionTimeout timeout)
+        {
+            TimeoutHandler(timeout);
+        }
+    }
+
+    protected override void TimeoutHandler(ModuleExecutionTimeout timeout)
+    {
+        Finished = false;
+        base.TimeoutHandler(timeout);
+    }
+}