From 59d257c06a41b0c183359b15977badda353b0102 Mon Sep 17 00:00:00 2001 From: hzhang Date: Sun, 30 Jun 2024 01:52:44 +0800 Subject: [PATCH] project update --- Boards/BaseBoard.cs | 2 +- Modules/BaseModule.cs | 23 ++-- .../Binary/AdditionModule.cs | 63 +++++++++ .../Binary/ComparisionModule.cs | 36 +++++ .../Binary/ControlledOutputModule.cs | 56 ++++++++ .../Binary/DivisionModule.cs | 61 +++++++++ .../Binary/DotProductModule.cs | 65 +++++++++ .../Binary/LogicalAlternativeDenialModule.cs | 28 ++++ .../Binary/LogicalBiconditionalModule.cs | 28 ++++ .../Binary/LogicalConjunctionModule.cs | 27 ++++ .../Binary/LogicalDisjunctionModule.cs | 27 ++++ .../LogicalExclusiveDisjunctionModule.cs | 27 ++++ .../Binary/LogicalImplicationModule.cs | 27 ++++ .../Binary/LogicalJointDenialModule.cs | 28 ++++ .../Binary/LogicalNonimplicationModule.cs | 28 ++++ .../ComputationalModules/Binary/MaxModule.cs | 44 +++++++ .../ComputationalModules/Binary/MinModule.cs | 44 +++++++ .../Binary/MultiplicationModule.cs | 56 ++++++++ .../Binary/PowerModule.cs | 63 +++++++++ .../Binary/ScalarDivisionModule.cs | 123 ++++++++++++++++++ .../Binary/ScalarMultiplicationModule.cs | 77 +++++++++++ .../Binary/SubtractionModule.cs | 58 +++++++++ .../ComputationalModules/Binary/V2Module.cs | 70 ++++++++++ .../BinaryComputationalModule.cs | 3 +- .../ComputationalModule.cs | 5 +- .../Nullary/ConstantModule.cs | 54 ++++++++ .../Nullary/KeyListenerModule.cs | 51 ++++++++ .../Nullary/NormalDistributionModule.cs | 51 ++++++++ .../QuaternaryComputationalModule.cs | 29 ----- .../Ternary/SelectorModule.cs | 46 +++++++ .../TernaryComputationalModule.cs | 11 +- .../ComputationalModules/Unary/CopyModule.cs | 56 ++++++++ .../Unary/LogicalNegationModule.cs | 26 ++++ .../Unary/NegationModule.cs | 58 +++++++++ .../Unary/SquareModule.cs | 60 +++++++++ .../Unary/V2ComponentModule.cs | 61 +++++++++ .../UnaryComputationalModule.cs | 7 +- .../ActionModules/ActionModule.cs | 6 +- .../ActionModules/AttackActionModule.cs | 3 +- .../ActionModules/MoveActionModule.cs | 13 +- .../ControllingModules/ControllingModule.cs | 7 +- Modules/ControllingModules/RootModule.cs | 19 +-- .../SinglePoleDoubleThrowSwitchModule.cs | 2 +- .../SinglePoleSingleThrowSwitchModule.cs | 3 +- .../InterlayerDataInModule.cs | 24 ++++ .../InterlayerDataOutModule.cs | 32 +++++ .../InterlayerSignalInModule.cs | 28 ++++ .../InterlayerSignalOutModule.cs | 36 +++++ Modules/Other/EngineControllingModule.cs | 53 ++++++++ Modules/Other/FilterOutputModule.cs | 37 ++++++ Modules/Other/IndicateInputModule.cs | 20 +++ Modules/Other/IterativeOutputModule.cs | 30 +++++ Modules/Other/OptimizationItemOutputModule.cs | 38 ++++++ Modules/Other/OptimizationValueInputModule.cs | 21 +++ .../Other/OptimizationValueOutputModule.cs | 38 ++++++ Modules/Other/OutputSubModule.cs | 28 ++++ Modules/TerminalModules/MemoryModule.cs | 91 +++++++++++++ Modules/TerminalModules/SRLatchModule.cs | 66 ++++++++++ .../LightEmittingDiodeModule.cs | 38 ++++++ .../TestingModules/R2Reader.cs | 34 +++++ .../TestingModules/R2ReaderModule.cs | 29 +++++ .../TestingModules/RealReaderModule.cs | 45 +++++++ Ports/DataPorts/DataInPort.cs | 5 +- Ports/DataPorts/DataOutPort.cs | 5 +- Ports/SignalPorts/SignalInPort.cs | 7 +- Ports/SignalPorts/SignalOutPort.cs | 7 +- Ports/SignalPorts/SignalPort.cs | 16 ++- 67 files changed, 2268 insertions(+), 92 deletions(-) create mode 100644 Modules/ComputationalModules/Binary/AdditionModule.cs create mode 100644 Modules/ComputationalModules/Binary/ComparisionModule.cs create mode 100644 Modules/ComputationalModules/Binary/ControlledOutputModule.cs create mode 100644 Modules/ComputationalModules/Binary/DivisionModule.cs create mode 100644 Modules/ComputationalModules/Binary/DotProductModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalImplicationModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs create mode 100644 Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs create mode 100644 Modules/ComputationalModules/Binary/MaxModule.cs create mode 100644 Modules/ComputationalModules/Binary/MinModule.cs create mode 100644 Modules/ComputationalModules/Binary/MultiplicationModule.cs create mode 100644 Modules/ComputationalModules/Binary/PowerModule.cs create mode 100644 Modules/ComputationalModules/Binary/ScalarDivisionModule.cs create mode 100644 Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs create mode 100644 Modules/ComputationalModules/Binary/SubtractionModule.cs create mode 100644 Modules/ComputationalModules/Binary/V2Module.cs create mode 100644 Modules/ComputationalModules/Nullary/ConstantModule.cs create mode 100644 Modules/ComputationalModules/Nullary/KeyListenerModule.cs create mode 100644 Modules/ComputationalModules/Nullary/NormalDistributionModule.cs delete mode 100644 Modules/ComputationalModules/QuaternaryComputationalModule.cs create mode 100644 Modules/ComputationalModules/Ternary/SelectorModule.cs create mode 100644 Modules/ComputationalModules/Unary/CopyModule.cs create mode 100644 Modules/ComputationalModules/Unary/LogicalNegationModule.cs create mode 100644 Modules/ComputationalModules/Unary/NegationModule.cs create mode 100644 Modules/ComputationalModules/Unary/SquareModule.cs create mode 100644 Modules/ComputationalModules/Unary/V2ComponentModule.cs create mode 100644 Modules/InterlayerModules/InterlayerDataInModule.cs create mode 100644 Modules/InterlayerModules/InterlayerDataOutModule.cs create mode 100644 Modules/InterlayerModules/InterlayerSignalInModule.cs create mode 100644 Modules/InterlayerModules/InterlayerSignalOutModule.cs create mode 100644 Modules/Other/EngineControllingModule.cs create mode 100644 Modules/Other/FilterOutputModule.cs create mode 100644 Modules/Other/IndicateInputModule.cs create mode 100644 Modules/Other/IterativeOutputModule.cs create mode 100644 Modules/Other/OptimizationItemOutputModule.cs create mode 100644 Modules/Other/OptimizationValueInputModule.cs create mode 100644 Modules/Other/OptimizationValueOutputModule.cs create mode 100644 Modules/Other/OutputSubModule.cs create mode 100644 Modules/TerminalModules/MemoryModule.cs create mode 100644 Modules/TerminalModules/SRLatchModule.cs create mode 100644 Modules/TerminalModules/TestingModules/LightEmittingDiodeModule.cs create mode 100644 Modules/TerminalModules/TestingModules/R2Reader.cs create mode 100644 Modules/TerminalModules/TestingModules/R2ReaderModule.cs create mode 100644 Modules/TerminalModules/TestingModules/RealReaderModule.cs diff --git a/Boards/BaseBoard.cs b/Boards/BaseBoard.cs index efb4a37..560f24a 100644 --- a/Boards/BaseBoard.cs +++ b/Boards/BaseBoard.cs @@ -38,7 +38,7 @@ public abstract partial class BaseBoard : Panel, IBaseBoard { LabelVisualMode = mode; foreach (BaseModule module in GetChildren().OfType()) - if(module.HasLabel()) + if(module.HasLabel) module.Label!.Visible = !mode; } diff --git a/Modules/BaseModule.cs b/Modules/BaseModule.cs index 12c61d9..d4150f0 100644 --- a/Modules/BaseModule.cs +++ b/Modules/BaseModule.cs @@ -15,16 +15,15 @@ namespace Enigmos.Modules; public abstract partial class BaseModule : TextureRect, IBaseModule { - private static readonly Font GnuUni = ResourceLoader.Load("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(); + protected virtual bool Draggable => true; + protected virtual bool HasManual => true; + public bool HasLabel => HasManual; public virtual IEnumerable Ports => Array.Empty(); public IBaseBoard? Board { get; set; } @@ -42,9 +41,9 @@ public abstract partial class BaseModule : TextureRect, IBaseModule public virtual void Init() { - if (HasLabel()) + if (HasLabel) { - Label = GlobalProvider.SceneProvider + Label = GlobalProvider.SceneProvider! .AssetMapper() .Instantiate(); Label.Position = new Vector2(0, -25); @@ -84,9 +83,9 @@ public abstract partial class BaseModule : TextureRect, IBaseModule PresetValueInit(); } - protected virtual void TimeoutCheck(RootModule root) + protected virtual void TimeoutCheck(IRootModule root) { - if (root.Timer.ElapsedMilliseconds < 25) return; + if (root.Timer!.ElapsedMilliseconds < 25) return; root.Timer.Stop(); throw ModuleExecutionTimeout.Exception; } @@ -95,11 +94,11 @@ public abstract partial class BaseModule : TextureRect, IBaseModule public override Variant _GetDragData(Vector2 atPosition) { - if (!Draggable()) + if (!Draggable) return default; Board!.ModuleMovingLayer.DraggingModule = this; Board!.ModuleMovingLayer.MouseOffset = GetLocalMousePosition(); - return GlobalProvider.DataStructureProvider.NewVariantWithType("Module", this); + return GlobalProvider.DataStructureProvider!.NewVariantWithType("Module", this); } @@ -119,13 +118,13 @@ public abstract partial class BaseModule : TextureRect, IBaseModule { if (eventMouseButton.ButtonIndex == MouseButton.Right && eventMouseButton.Pressed) { - if (!HasManual()) + if (!HasManual) return; if (Board.ManualOpened) return; if (Manual == null) { - Manual = GlobalProvider.SceneProvider + Manual = GlobalProvider.SceneProvider! .AssetMapper() .Instantiate(); Manual.Init(this); diff --git a/Modules/ComputationalModules/Binary/AdditionModule.cs b/Modules/ComputationalModules/Binary/AdditionModule.cs new file mode 100644 index 0000000..0ecd805 --- /dev/null +++ b/Modules/ComputationalModules/Binary/AdditionModule.cs @@ -0,0 +1,63 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class AdditionModule : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup? InputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => + base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public override double MaintenanceAlpha => 0.19572021d; + public override double MaintenanceBeta => 0.20151779d; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + + InputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup( + this, + new IDataPort[] { Input1, Input2 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "Output Port Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.AnyTensor + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + IDataPackage res = GlobalProvider.PolymorphismProvider!.Add(input1, input2, OutputGroup!.SelectedType); + foreach (IDataPort port in OutputGroup) + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + + } + + public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType; + + public override string GetDescription => GlobalProvider.EnigmosProvider.ModuleDescription(); +} diff --git a/Modules/ComputationalModules/Binary/ComparisionModule.cs b/Modules/ComputationalModules/Binary/ComparisionModule.cs new file mode 100644 index 0000000..0eee282 --- /dev/null +++ b/Modules/ComputationalModules/Binary/ComparisionModule.cs @@ -0,0 +1,36 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using Nocturnis.DataStructures.ConfigurableParameters; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class ComparisionModule : BinaryComputationalModule, IParameterizedModule +{ + + private DataOutPort? Output { get; set; } + private IBoolParameter Greater { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output }); + public HashSet ConfigurableParameters { get; set; } + + public override void Init() + { + base.Init(); + Greater = GlobalProvider.DataStructureProvider.NewBoolParameter("Method", "gt", "lt", true); + ConfigurableParameters = new HashSet() { Greater }; + Output = GetPort("Output"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Real); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Real); + Output.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + Output!.ResultData.Bit = !(Greater.ParameterValue ^ (input1.Real > input2.Real)); + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/ControlledOutputModule.cs b/Modules/ComputationalModules/Binary/ControlledOutputModule.cs new file mode 100644 index 0000000..9e7fbef --- /dev/null +++ b/Modules/ComputationalModules/Binary/ControlledOutputModule.cs @@ -0,0 +1,56 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class ControlledOutputModule : BinaryComputationalModule, IPolymorphismModule +{ + [Export] private StringName PresetDataType { get; set; } + private DataOutPort Output1 { get; set; } + private DataOutPort Output2 { get; set; } + private DataOutPort Output3 { get; set; } + private DataOutPort Output4 { get; set; } + private IDataPortGroup OutputGroup { get; set; } + public HashSet ConfigurablePortGroups { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 }); + public void Inference() => Input2.SetDataType(OutputGroup.SelectedType); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "Output Data Type", + UsingPreset ? PresetDataType : EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.AnyType + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Real); + PostInit(); + } + + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + if (input1.Bit) + foreach (DataOutPort port in OutputGroup.OfType()) + port.ResultData.Assign(input2, OutputGroup.SelectedType); + else + foreach (DataOutPort port in OutputGroup.OfType()) + port.ResultData.Assign( + GlobalProvider.DataStructureProvider.DefaultDataPackage, + OutputGroup.SelectedType + ); + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/DivisionModule.cs b/Modules/ComputationalModules/Binary/DivisionModule.cs new file mode 100644 index 0000000..1565527 --- /dev/null +++ b/Modules/ComputationalModules/Binary/DivisionModule.cs @@ -0,0 +1,61 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class DivisionModule : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup? InputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Input1, Input2 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "Output Port Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.NumericTypes + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + PostInit(); + } + + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + IDataPackage res = GlobalProvider.PolymorphismProvider.Div(input1, input2, OutputGroup.SelectedType); + foreach (DataPort port in OutputGroup) + { + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + //(port as DataOutPort)!.DataUpdated = true; + } + } + + public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType; + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/DotProductModule.cs b/Modules/ComputationalModules/Binary/DotProductModule.cs new file mode 100644 index 0000000..1dfcf7b --- /dev/null +++ b/Modules/ComputationalModules/Binary/DotProductModule.cs @@ -0,0 +1,65 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class DotProductModule : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup? VectorInputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + VectorInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup( + this, + new IDataPort[] { Input1, Input2 }, + "Vector Input Type", + EnigmosConstant.DataPortTypes.R2, + EnigmosConstant.DataPortTypes.VectorTypes + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + ConfigurablePortGroups = new HashSet { VectorInputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + IDataPackage res = GlobalProvider.PolymorphismProvider!.Dot(input1, input2, VectorInputGroup!.SelectedType); + foreach (IDataPort port in OutputGroup!) + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + + } + + + public void Inference() + { + if (GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(VectorInputGroup!.SelectedType)) + OutputGroup!.SelectedType = EnigmosConstant.DataPortTypes.Complex; + else + OutputGroup!.SelectedType = EnigmosConstant.DataPortTypes.Real; + } + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs b/Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs new file mode 100644 index 0000000..29bc456 --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs @@ -0,0 +1,28 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalAlternativeDenialModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = !input1.Bit | !input2.Bit; + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs b/Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs new file mode 100644 index 0000000..6c3e8ab --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs @@ -0,0 +1,28 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalBiconditionalModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = !(input1.Bit ^ input2.Bit); + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs b/Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs new file mode 100644 index 0000000..f0343a3 --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs @@ -0,0 +1,27 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalConjunctionModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = input1.Bit & input2.Bit; + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs b/Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs new file mode 100644 index 0000000..fe34d13 --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs @@ -0,0 +1,27 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalDisjunctionModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = input1.Bit | input2.Bit; + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs b/Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs new file mode 100644 index 0000000..bcc6ff9 --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs @@ -0,0 +1,27 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalExclusiveDisjunctionModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = input1.Bit ^ input2.Bit; + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalImplicationModule.cs b/Modules/ComputationalModules/Binary/LogicalImplicationModule.cs new file mode 100644 index 0000000..9ac6999 --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalImplicationModule.cs @@ -0,0 +1,27 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalImplicationModule : BinaryComputationalModule +{ + private DataOutPort? Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = !input1.Bit | input2.Bit; + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs b/Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs new file mode 100644 index 0000000..83b1fd9 --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs @@ -0,0 +1,28 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalJointDenialModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = !input1.Bit & !input2.Bit; + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs b/Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs new file mode 100644 index 0000000..2b15b1b --- /dev/null +++ b/Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs @@ -0,0 +1,28 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class LogicalNonimplicationModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + //Output1.DataUpdated = true; + Output1.ResultData.Bit = input1.Bit & !input2.Bit; + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/MaxModule.cs b/Modules/ComputationalModules/Binary/MaxModule.cs new file mode 100644 index 0000000..cf227d7 --- /dev/null +++ b/Modules/ComputationalModules/Binary/MaxModule.cs @@ -0,0 +1,44 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class MaxModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + private DataOutPort Output2 { get; set; } + private DataOutPort Output3 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Real); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Real); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Real); + Output2.SetDataType(EnigmosConstant.DataPortTypes.Real); + Output3.SetDataType(EnigmosConstant.DataPortTypes.Real); + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + if (input1.Real > input2.Real) + { + Output1.ResultData.Real = input1.Real; + Output2.ResultData.Real = input1.Real; + Output3.ResultData.Real = input1.Real; + } + else + { + Output1.ResultData.Real = input2.Real; + Output2.ResultData.Real = input2.Real; + Output3.ResultData.Real = input2.Real; + } + + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/MinModule.cs b/Modules/ComputationalModules/Binary/MinModule.cs new file mode 100644 index 0000000..8819d3f --- /dev/null +++ b/Modules/ComputationalModules/Binary/MinModule.cs @@ -0,0 +1,44 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class MinModule : BinaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + private DataOutPort Output2 { get; set; } + private DataOutPort Output3 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Real); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Real); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Real); + Output2.SetDataType(EnigmosConstant.DataPortTypes.Real); + Output3.SetDataType(EnigmosConstant.DataPortTypes.Real); + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + if (input1.Real < input2.Real) + { + Output1.ResultData.Real = input1.Real; + Output2.ResultData.Real = input1.Real; + Output3.ResultData.Real = input1.Real; + } + else + { + Output1.ResultData.Real = input2.Real; + Output2.ResultData.Real = input2.Real; + Output3.ResultData.Real = input2.Real; + } + + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/MultiplicationModule.cs b/Modules/ComputationalModules/Binary/MultiplicationModule.cs new file mode 100644 index 0000000..13523cc --- /dev/null +++ b/Modules/ComputationalModules/Binary/MultiplicationModule.cs @@ -0,0 +1,56 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class MultiplicationModule : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup InputGroup { get; set; } + private IDataPortGroup OutputGroup { get; set; } + private DataOutPort Output1 { get; set; } + private DataOutPort Output2 { get; set; } + private DataOutPort Output3 { get; set; } + private DataOutPort Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 }); + public HashSet ConfigurablePortGroups { get; set; } + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new DataPort[] { Input1, Input2 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new DataPort[] { Output1, Output2, Output3, Output4 }, + "Output Port Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.NumericTypes + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + IDataPackage res = GlobalProvider.PolymorphismProvider.Mul(input1, input2, OutputGroup.SelectedType); + foreach (DataPort port in OutputGroup) + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + } + + public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType; + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/PowerModule.cs b/Modules/ComputationalModules/Binary/PowerModule.cs new file mode 100644 index 0000000..444d240 --- /dev/null +++ b/Modules/ComputationalModules/Binary/PowerModule.cs @@ -0,0 +1,63 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class PowerModule : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup? TensorInputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + TensorInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup( + this, + new IDataPort[] { Input1 }, + "Base Tensor Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.NumericTypes + ); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Complex); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + ConfigurablePortGroups = new HashSet { TensorInputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + + IDataPackage res = GlobalProvider.PolymorphismProvider!.Pow(input1, input2, TensorInputGroup!.SelectedType); + foreach (IDataPort port in OutputGroup!) + { + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + //(port as DataOutPort)!.DataUpdated = true; + } + } + + public void Inference() => + OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.ComplexVersionOf(TensorInputGroup.SelectedType); + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/ScalarDivisionModule.cs b/Modules/ComputationalModules/Binary/ScalarDivisionModule.cs new file mode 100644 index 0000000..3214ea8 --- /dev/null +++ b/Modules/ComputationalModules/Binary/ScalarDivisionModule.cs @@ -0,0 +1,123 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class ScalarDivisionModule : BinaryComputationalModule, IPolymorphismModule, IErrorHandlerModule +{ + private IDataPortGroup? ScalarInputGroup { get; set; } + private IDataPortGroup? TensorInputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public override double MaintenanceAlpha => 0.77852142d; + public override double MaintenanceBeta => 0.9544432d; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + TensorInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup( + this, + new IDataPort[] { Input1 }, + "Tensor Input Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.VectorTypes + ); + ScalarInputGroup =GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Input2 }, + "Scalar Input Type", + EnigmosConstant.DataPortTypes.R2, + EnigmosConstant.DataPortTypes.VectorTypes + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + ConfigurablePortGroups = new HashSet { ScalarInputGroup, TensorInputGroup }; + SelectedOption = 0; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + try + { + IDataPackage res = + GlobalProvider.PolymorphismProvider!.ScalarDiv( + input1, + input2, + TensorInputGroup!.SelectedType, + ScalarInputGroup!.SelectedType + ); + foreach (IDataPort port in OutputGroup) + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + + } + catch (Exception e) + { + ErrorHandler(e, SelectedOption); + } + + + } + + public void Inference() + { + if (GlobalProvider.DataPackageTypeProvider.IsComplexTensorType(ScalarInputGroup.SelectedType)) + OutputGroup.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup.SelectedType); + else + OutputGroup.SelectedType = TensorInputGroup.SelectedType; + } + + public void ErrorHandler(Exception error, int idx) + { + switch (idx) + { + case 0: + foreach (IDataPort port in OutputGroup!) + (port as DataOutPort)!.ResultData + .Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, OutputGroup.SelectedType); + break; + case 1: + foreach (IDataPort port in OutputGroup!) + (port as DataOutPort)!.ResultData + .Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, OutputGroup.SelectedType); + break; + case 2: + foreach (IDataPort port in OutputGroup!) + (port as DataOutPort)!.ResultData + .Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, OutputGroup.SelectedType); + break; + default: + return; + } + } + + public string[] HandlingOptions() => + new[] + { + "Reset Circuit State", + "Return Previous Valid Value", + "Return Default Value" + }; + + public int SelectedOption { get; set; } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs b/Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs new file mode 100644 index 0000000..2249340 --- /dev/null +++ b/Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs @@ -0,0 +1,77 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class ScalarMultiplicationModule : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup? ScalarInputGroup { get; set; } + private IDataPortGroup? TensorInputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + ScalarInputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Input1 }, + "Scalar Input Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.NumericTypes + ); + TensorInputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Input2 }, + "Tensor Input Type", + EnigmosConstant.DataPortTypes.R2, + EnigmosConstant.DataPortTypes.VectorTypes + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + ConfigurablePortGroups = new HashSet { ScalarInputGroup, TensorInputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + IDataPackage res = + GlobalProvider.PolymorphismProvider! + .ScalarMul(input1, input2, ScalarInputGroup!.SelectedType, TensorInputGroup!.SelectedType); + foreach (IDataPort port in OutputGroup!) + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + + } + + public void Inference() + { + if ( + GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(ScalarInputGroup!.SelectedType) || + GlobalProvider.DataPackageTypeProvider.IsComplexTensorType(TensorInputGroup!.SelectedType) + ) + OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup!.SelectedType); + else + OutputGroup!.SelectedType = TensorInputGroup.SelectedType; + } + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/SubtractionModule.cs b/Modules/ComputationalModules/Binary/SubtractionModule.cs new file mode 100644 index 0000000..5c2a868 --- /dev/null +++ b/Modules/ComputationalModules/Binary/SubtractionModule.cs @@ -0,0 +1,58 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class SubtractionModule : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup InputGroup { get; set; } + private IDataPortGroup OutputGroup { get; set; } + private DataOutPort Output1 { get; set; } + private DataOutPort Output2 { get; set; } + private DataOutPort Output3 { get; set; } + private DataOutPort Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 }); + + public HashSet ConfigurablePortGroups { get; set; } + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Input1, Input2 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "Output Port Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.AnyTensor + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + IDataPackage res = GlobalProvider.PolymorphismProvider.Sub(input1, input2, OutputGroup.SelectedType); + foreach (DataPort port in OutputGroup) + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + } + + public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType; + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Binary/V2Module.cs b/Modules/ComputationalModules/Binary/V2Module.cs new file mode 100644 index 0000000..0ea47fc --- /dev/null +++ b/Modules/ComputationalModules/Binary/V2Module.cs @@ -0,0 +1,70 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; +using R2 = Skeleton.Algebra.CategoryOf.OnField.FVector; +using C2 = Skeleton.Algebra.CategoryOf.OnField.FVector; + +namespace Enigmos.Modules.ComputationalModules.Binary; + +public partial class V2Module : BinaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup? ScalarInputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public override double MaintenanceAlpha => 0.77852142d; + public override double MaintenanceBeta => 0.9544432d; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + ScalarInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup( + this, + new IDataPort[] { Input1, Input2 }, + "Scalar Input Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.NumericTypes + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "", + EnigmosConstant.DataPortTypes.R2, + Array.Empty() + ); + ConfigurablePortGroups = new HashSet { ScalarInputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2) + { + R2 v2R = new R2(input1.Real, input2.Real); + C2 v2C = new C2(input1.Complex, input2.Complex); + foreach (IDataPort port in OutputGroup!) + { + if (ScalarInputGroup!.SelectedType == EnigmosConstant.DataPortTypes.Real) + (port as DataOutPort)!.ResultData.R2 = v2R; + else + (port as DataOutPort)!.ResultData.C2 = v2C; + } + } + + public void Inference() + { + OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.BuildType(OutputGroup.SelectedType, 1, 2); + } + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/BinaryComputationalModule.cs b/Modules/ComputationalModules/BinaryComputationalModule.cs index bd87e11..6da27e1 100644 --- a/Modules/ComputationalModules/BinaryComputationalModule.cs +++ b/Modules/ComputationalModules/BinaryComputationalModule.cs @@ -2,6 +2,7 @@ using Enigmos.Modules.ControllingModules; using Enigmos.Ports; using Enigmos.Ports.DataPorts; using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; namespace Enigmos.Modules.ComputationalModules; @@ -20,6 +21,6 @@ public abstract partial class BinaryComputationalModule : ComputationalModule protected abstract void Compute(IDataPackage input1, IDataPackage input2); - protected override void Compute(RootModule root) => Compute(Input1.GetData(root), Input2.GetData(root)); + protected override void Compute(IRootModule root) => Compute(Input1.GetData(root), Input2.GetData(root)); } \ No newline at end of file diff --git a/Modules/ComputationalModules/ComputationalModule.cs b/Modules/ComputationalModules/ComputationalModule.cs index 5e843b4..39d7ed6 100644 --- a/Modules/ComputationalModules/ComputationalModule.cs +++ b/Modules/ComputationalModules/ComputationalModule.cs @@ -1,6 +1,7 @@ using Enigmos.Exceptions; using Enigmos.Modules.ControllingModules; using Enigmos.Ports.DataPorts; +using Nocturnis.Enigmos.Modules; namespace Enigmos.Modules.ComputationalModules; @@ -13,8 +14,8 @@ public abstract partial class ComputationalModule : BaseModule base.TimeoutHandler(timeout); } - protected abstract void Compute(RootModule root); - public void ComputeWithTimeoutHandle(RootModule root) + protected abstract void Compute(IRootModule root); + public void ComputeWithTimeoutHandle(IRootModule root) { foreach (DataOutPort port in Ports.OfType()) port.DataUpdated = true; diff --git a/Modules/ComputationalModules/Nullary/ConstantModule.cs b/Modules/ComputationalModules/Nullary/ConstantModule.cs new file mode 100644 index 0000000..dbb4a91 --- /dev/null +++ b/Modules/ComputationalModules/Nullary/ConstantModule.cs @@ -0,0 +1,54 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures.ConfigurableParameters; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Nullary; + +public partial class ConstantModule : NullaryComputationalModule, IParameterizedModule +{ + + [Export] private double PresetConstantValue { get; set; } + + private HashSet OutputGroup { get; set; } = new(); + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + private IDoubleParameter ConstValue { get; set; } + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + + OutputGroup = new HashSet(new[] { Output1, Output2, Output3, Output4 }); + foreach (DataOutPort port in OutputGroup) + port.SetDataType(EnigmosConstant.DataPortTypes.Real); + ConstValue = + GlobalProvider.DataStructureProvider.NewDoubleParameter( + "Constant Value", + -1, + 1, + UsingPreset ? PresetConstantValue : 0 + ); + ConfigurableParameters = new HashSet { ConstValue }; + PostInit(); + } + + protected override void Compute(IRootModule root) + { + foreach (DataOutPort port in OutputGroup) + port.ResultData.Real = ConstValue.ParameterValue; + + } + + public HashSet ConfigurableParameters { get; set; } = new(); +} diff --git a/Modules/ComputationalModules/Nullary/KeyListenerModule.cs b/Modules/ComputationalModules/Nullary/KeyListenerModule.cs new file mode 100644 index 0000000..feff889 --- /dev/null +++ b/Modules/ComputationalModules/Nullary/KeyListenerModule.cs @@ -0,0 +1,51 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures.ConfigurableParameters; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Nullary; +public partial class KeyListenerModule : NullaryComputationalModule, IParameterizedModule, IKeyListenerModule +{ + [Export] private StringName? PresetActionName { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + public IKeyParameter? ListeningKey { get; set; } + public bool Pressed { get; set; } + public HashSet ConfigurableParameters { get; set; } = new(); + public override IEnumerable Ports => new[] { Output1, Output2, Output3 }!; + protected override void Compute(IRootModule root) + { + Output1!.ResultData.Bit = Pressed; + Output2!.ResultData.Bit = Pressed; + Output3!.ResultData.Bit = Pressed; + } + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output3.SetDataType(EnigmosConstant.DataPortTypes.Bit); + ListeningKey = GlobalProvider.DataStructureProvider!.NewKeyParameter( + "Listening Key", + UsingPreset && (PresetActionName != null) ? PresetActionName : "KeyListenAction" + ); + ConfigurableParameters = new HashSet { ListeningKey }; + int i = 0; + while (InputMap.HasAction($"{ListeningKey.ParameterValue}{i}") && !UsingPreset) + i++; + ListeningKey.ParameterValue = $"{ListeningKey.ParameterValue}{i}"; + if(!UsingPreset) + InputMap.AddAction(ListeningKey.ParameterValue); + GlobalProvider.SceneProvider!.RootScene.KeyListener.Register(this); + PostInit(); + } +} diff --git a/Modules/ComputationalModules/Nullary/NormalDistributionModule.cs b/Modules/ComputationalModules/Nullary/NormalDistributionModule.cs new file mode 100644 index 0000000..ced1576 --- /dev/null +++ b/Modules/ComputationalModules/Nullary/NormalDistributionModule.cs @@ -0,0 +1,51 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures.ConfigurableParameters; +using Nocturnis.Enigmos.Modules; +using Skeleton.Utils.RandomEngines; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + + +namespace Enigmos.Modules.ComputationalModules.Nullary; + +public partial class NormalDistributionModule : NullaryComputationalModule, IParameterizedModule +{ + private HashSet OutputGroup { get; set; } = new(); + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + private IDoubleParameter? Mu { get; set; } + private IDoubleParameter? Sigma { get; set; } + + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + + OutputGroup = new HashSet(new[] { Output1, Output2, Output3, Output4 }); + foreach (DataOutPort port in OutputGroup) + port.SetDataType(EnigmosConstant.DataPortTypes.Real); + Mu = GlobalProvider.DataStructureProvider!.NewDoubleParameter("mu", -1, 1, 0); + Sigma = GlobalProvider.DataStructureProvider.NewDoubleParameter("sigma", 0, 2, 1); + ConfigurableParameters = new HashSet { Mu, Sigma }; + PostInit(); + } + + protected override void Compute(IRootModule root) + { + foreach (DataOutPort port in OutputGroup) + { + port.ResultData.Real = Normal.Get() * Sigma.ParameterValue - Mu.ParameterValue; + } + } + + public HashSet ConfigurableParameters { get; set; } = new(); +} \ No newline at end of file diff --git a/Modules/ComputationalModules/QuaternaryComputationalModule.cs b/Modules/ComputationalModules/QuaternaryComputationalModule.cs deleted file mode 100644 index 56a02df..0000000 --- a/Modules/ComputationalModules/QuaternaryComputationalModule.cs +++ /dev/null @@ -1,29 +0,0 @@ -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 Ports => new[] { Input1, Input2, Input3, Input4 }; - public override void Init() - { - base.Init(); - Input1 = GetPort("Input1"); - Input2 = GetPort("Input2"); - Input3 = GetPort("Input3"); - Input4 = GetPort("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)); -} diff --git a/Modules/ComputationalModules/Ternary/SelectorModule.cs b/Modules/ComputationalModules/Ternary/SelectorModule.cs new file mode 100644 index 0000000..cb9c6ab --- /dev/null +++ b/Modules/ComputationalModules/Ternary/SelectorModule.cs @@ -0,0 +1,46 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Ternary; + +public partial class SelectorModule : TernaryComputationalModule, IPolymorphismModule +{ + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private IDataPortGroup? DataTypeGroup { get; set; } + public HashSet ConfigurablePortGroups { get; set; } = new(); + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3 })!; + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + DataTypeGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new DataPort[] { Input2, Input3, Output1, Output2, Output3 }, + "Data Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.AnyType + ); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + protected override void Compute(IDataPackage input1, IDataPackage input2, IDataPackage input3) + { + + Output1!.ResultData.Assign(input1.Bit ? input2 : input3, DataTypeGroup.SelectedType); + Output2!.ResultData.Assign(input1.Bit ? input2 : input3, DataTypeGroup.SelectedType); + Output3!.ResultData.Assign(input1.Bit ? input2 : input3, DataTypeGroup.SelectedType); + } + + public void Inference() + { + } +} \ No newline at end of file diff --git a/Modules/ComputationalModules/TernaryComputationalModule.cs b/Modules/ComputationalModules/TernaryComputationalModule.cs index 7e12cc6..6ec791a 100644 --- a/Modules/ComputationalModules/TernaryComputationalModule.cs +++ b/Modules/ComputationalModules/TernaryComputationalModule.cs @@ -2,15 +2,16 @@ using Enigmos.Modules.ControllingModules; using Enigmos.Ports; using Enigmos.Ports.DataPorts; using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; 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 Ports => new[] { Input1, Input2, Input3 }; + protected DataInPort? Input1 { get; set; } + protected DataInPort? Input2 { get; set; } + protected DataInPort? Input3 { get; set; } + public override IEnumerable Ports => new[] { Input1, Input2, Input3 }!; public override void Init() { base.Init(); @@ -21,6 +22,6 @@ public abstract partial class TernaryComputationalModule : ComputationalModule protected abstract void Compute(IDataPackage input1, IDataPackage input2, IDataPackage input3); - protected override void Compute(RootModule root) => + protected override void Compute(IRootModule root) => Compute(Input1.GetData(root), Input2.GetData(root), Input3.GetData(root)); } \ No newline at end of file diff --git a/Modules/ComputationalModules/Unary/CopyModule.cs b/Modules/ComputationalModules/Unary/CopyModule.cs new file mode 100644 index 0000000..f3d890f --- /dev/null +++ b/Modules/ComputationalModules/Unary/CopyModule.cs @@ -0,0 +1,56 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Unary; +public partial class CopyModule : UnaryComputationalModule, IPolymorphismModule +{ + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + private IDataPortGroup? InputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + public HashSet ConfigurablePortGroups { get; set; } = new(); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] {Input1}, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "Output Port Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.AnyType + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + PostInit(); + } + + + protected override void Compute(IDataPackage input1) + { + foreach (IDataPort port in OutputGroup!) + (port as DataOutPort)!.ResultData.Assign(input1, OutputGroup.SelectedType); + + } + + public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType; + +} diff --git a/Modules/ComputationalModules/Unary/LogicalNegationModule.cs b/Modules/ComputationalModules/Unary/LogicalNegationModule.cs new file mode 100644 index 0000000..3f9d663 --- /dev/null +++ b/Modules/ComputationalModules/Unary/LogicalNegationModule.cs @@ -0,0 +1,26 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Unary; + +public partial class LogicalNegationModule : UnaryComputationalModule +{ + private DataOutPort Output1 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1 }); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + protected override void Compute(IDataPackage input1) + { + Output1.ResultData.Bit = !input1.Bit; + } + +} diff --git a/Modules/ComputationalModules/Unary/NegationModule.cs b/Modules/ComputationalModules/Unary/NegationModule.cs new file mode 100644 index 0000000..38290eb --- /dev/null +++ b/Modules/ComputationalModules/Unary/NegationModule.cs @@ -0,0 +1,58 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Unary; + +public partial class NegationModule : UnaryComputationalModule, IPolymorphismModule +{ + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + private IDataPortGroup? InputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + + public HashSet ConfigurablePortGroups { get; set; } = new(); + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] {Input1}, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2, Output3, Output4 }, + "Output Port Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.AnyTensor + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + PostInit(); + } + + + protected override void Compute(IDataPackage input1) + { + IDataPackage res = GlobalProvider.PolymorphismProvider.Neg(input1, OutputGroup.SelectedType); + foreach (IDataPort port in OutputGroup) + (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType); + + } + + public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType; +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Unary/SquareModule.cs b/Modules/ComputationalModules/Unary/SquareModule.cs new file mode 100644 index 0000000..13db4dd --- /dev/null +++ b/Modules/ComputationalModules/Unary/SquareModule.cs @@ -0,0 +1,60 @@ + +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.ComputationalModules.Unary; + +public partial class SquareModule : UnaryComputationalModule, IPolymorphismModule +{ + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + private DataOutPort? Output3 { get; set; } + private DataOutPort? Output4 { get; set; } + private IDataPortGroup? InputGroup { get; set; } + private IDataPortGroup? OutputGroup { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!; + + public HashSet ConfigurablePortGroups { get; set; } + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + Output3 = GetPort("Output3"); + Output4 = GetPort("Output4"); + InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] {Input1}, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new DataPort[] { Output1, Output2, Output3, Output4 }, + "Output Port Type", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.NumericTypes + ); + ConfigurablePortGroups = new HashSet { OutputGroup }; + PostInit(); + } + + + protected override void Compute(IDataPackage input1) + { + IDataPackage res = GlobalProvider.PolymorphismProvider.Square(input1, OutputGroup.SelectedType); + foreach (DataOutPort port in OutputGroup.OfType()) + port.ResultData.Assign(res, OutputGroup.SelectedType); + + } + + public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType; + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/Unary/V2ComponentModule.cs b/Modules/ComputationalModules/Unary/V2ComponentModule.cs new file mode 100644 index 0000000..c56bfac --- /dev/null +++ b/Modules/ComputationalModules/Unary/V2ComponentModule.cs @@ -0,0 +1,61 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + + +namespace Enigmos.Modules.ComputationalModules.Unary; + +public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphismModule +{ + private IDataPortGroup? VectorInputGroup { get; set; } + private IDataPortGroup? ScalarOutputGroup { get; set; } + private DataOutPort? Output1 { get; set; } + private DataOutPort? Output2 { get; set; } + public override IEnumerable Ports => base.Ports.Union(new[] { Output1, Output2 })!; + public HashSet ConfigurablePortGroups { get; set; } = new(); + + public override void Init() + { + base.Init(); + Output1 = GetPort("Output1"); + Output2 = GetPort("Output2"); + VectorInputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Input1 }, + "Vector Input Type", + EnigmosConstant.DataPortTypes.R2, + EnigmosConstant.DataPortTypes.VectorTypes + ); + ScalarOutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup( + this, + new IDataPort[] { Output1, Output2 }, + "", + EnigmosConstant.DataPortTypes.Real, + Array.Empty() + ); + ConfigurablePortGroups = new HashSet { VectorInputGroup }; + PostInit(); + } + + protected override void Compute(IDataPackage input1) + { + if (VectorInputGroup!.SelectedType == EnigmosConstant.DataPortTypes.R2) + { + Output1!.ResultData.Real = input1.R2[1]; + Output2!.ResultData.Real = input1.R2[2]; + } + else + { + Output1!.ResultData.Complex = input1.C2[1]; + Output2!.ResultData.Complex = input1.C2[2]; + } + } + public void Inference() => + ScalarOutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.GetBaseField(VectorInputGroup.SelectedType); + +} \ No newline at end of file diff --git a/Modules/ComputationalModules/UnaryComputationalModule.cs b/Modules/ComputationalModules/UnaryComputationalModule.cs index 57cb385..c16bbe8 100644 --- a/Modules/ComputationalModules/UnaryComputationalModule.cs +++ b/Modules/ComputationalModules/UnaryComputationalModule.cs @@ -2,13 +2,14 @@ using Enigmos.Modules.ControllingModules; using Enigmos.Ports; using Enigmos.Ports.DataPorts; using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; namespace Enigmos.Modules.ComputationalModules; public abstract partial class UnaryComputationalModule : ComputationalModule { - protected DataInPort Input1 { get; set; } - public override IEnumerable Ports => new[] { Input1 }; + protected DataInPort? Input1 { get; set; } + public override IEnumerable Ports => new[] { Input1 }!; public override void Init() { base.Init(); @@ -16,5 +17,5 @@ public abstract partial class UnaryComputationalModule : ComputationalModule } protected abstract void Compute(IDataPackage input1); - protected override void Compute(RootModule root) => Compute(Input1.GetData(root)); + protected override void Compute(IRootModule root) => Compute(Input1.GetData(root)); } diff --git a/Modules/ControllingModules/ActionModules/ActionModule.cs b/Modules/ControllingModules/ActionModules/ActionModule.cs index 25926fa..0a70e5b 100644 --- a/Modules/ControllingModules/ActionModules/ActionModule.cs +++ b/Modules/ControllingModules/ActionModules/ActionModule.cs @@ -1,9 +1,11 @@ +using Nocturnis.Enigmos.Modules; + namespace Enigmos.Modules.ControllingModules.ActionModules; public abstract partial class ActionModule : ControllingModule { - protected abstract void Execute(RootModule root); - protected override void Route(RootModule root) + protected abstract void Execute(IRootModule root); + protected override void Route(IRootModule root) { if(!root.ActionFinished) Execute(root); diff --git a/Modules/ControllingModules/ActionModules/AttackActionModule.cs b/Modules/ControllingModules/ActionModules/AttackActionModule.cs index 722d6bb..388654c 100644 --- a/Modules/ControllingModules/ActionModules/AttackActionModule.cs +++ b/Modules/ControllingModules/ActionModules/AttackActionModule.cs @@ -1,6 +1,7 @@ using Enigmos.Ports; using Enigmos.Ports.DataPorts; using Enigmos.Ports.SignalPorts; +using Nocturnis.Enigmos.Modules; using TabulaSmaragdina.Constants; namespace Enigmos.Modules.ControllingModules.ActionModules; @@ -29,6 +30,6 @@ public partial class AttackActionModule : ActionModule } - protected override void Execute(RootModule root) => + protected override void Execute(IRootModule root) => root.ManagedBy.Action.Attack(Input1.GetData(root).R2); } diff --git a/Modules/ControllingModules/ActionModules/MoveActionModule.cs b/Modules/ControllingModules/ActionModules/MoveActionModule.cs index 6e3e2f5..217ca43 100644 --- a/Modules/ControllingModules/ActionModules/MoveActionModule.cs +++ b/Modules/ControllingModules/ActionModules/MoveActionModule.cs @@ -1,6 +1,7 @@ using Enigmos.Ports; using Enigmos.Ports.DataPorts; using Enigmos.Ports.SignalPorts; +using Nocturnis.Enigmos.Modules; using Skeleton.Algebra; using Skeleton.Algebra.DimensionProviders; using TabulaSmaragdina.Constants; @@ -10,11 +11,11 @@ using R2 = CategoryOf.OnField.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; } + 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 Ports => new BasePort[] { Input1, SignalIn1, SignalIn2, SignalIn3, SignalIn4 }; @@ -33,7 +34,7 @@ public partial class MoveActionModule : ActionModule public override string GetDescription => ""; - protected override void Execute(RootModule root) + protected override void Execute(IRootModule root) { R2 direction = Input1.GetData(root).R2; root.ManagedBy.Action.Move(direction); diff --git a/Modules/ControllingModules/ControllingModule.cs b/Modules/ControllingModules/ControllingModule.cs index 865d773..61eb1d5 100644 --- a/Modules/ControllingModules/ControllingModule.cs +++ b/Modules/ControllingModules/ControllingModule.cs @@ -1,11 +1,12 @@ using Enigmos.Exceptions; +using Nocturnis.Enigmos.Modules; namespace Enigmos.Modules.ControllingModules; -public abstract partial class ControllingModule : BaseModule +public abstract partial class ControllingModule : BaseModule, IControllingModule { - protected abstract void Route(RootModule root); + protected abstract void Route(IRootModule root); public bool Visited { get; set; } protected override void TimeoutHandler(ModuleExecutionTimeout timeout) { @@ -13,7 +14,7 @@ public abstract partial class ControllingModule : BaseModule base.TimeoutHandler(timeout); } - public void RouteWithTimeoutHandle(RootModule root) + public void RouteWithTimeoutHandle(IRootModule root) { if (Visited) return; diff --git a/Modules/ControllingModules/RootModule.cs b/Modules/ControllingModules/RootModule.cs index c348c8f..9b89fce 100644 --- a/Modules/ControllingModules/RootModule.cs +++ b/Modules/ControllingModules/RootModule.cs @@ -2,16 +2,17 @@ using System.Diagnostics; using Enigmos.Ports; using Enigmos.Ports.SignalPorts; using Nocturnis.Creatures; +using Nocturnis.Enigmos.Modules; namespace Enigmos.Modules.ControllingModules; -public partial class RootModule : ControllingModule +public partial class RootModule : ControllingModule, IRootModule { public bool ActionFinished { get; set; } - public IBaseCreature ManagedBy { get; set; } - protected override bool Draggable() => false; - private SignalOutPort SignalOut1 { get; set; } - public override IEnumerable Ports => new[] { SignalOut1 }; - public Stopwatch Timer { get; set; } + public IBaseCreature? ManagedBy { get; set; } + protected override bool Draggable => false; + private SignalOutPort? SignalOut1 { get; set; } + public override IEnumerable Ports => new[] { SignalOut1 }!; + public Stopwatch? Timer { get; set; } public override void Init() { @@ -21,14 +22,14 @@ public partial class RootModule : ControllingModule PostInit(); } - protected override void Route(RootModule r) + protected override void Route(IRootModule r) { - if(!SignalOut1.Connected) + if(!SignalOut1!.Connected) { ActionFinished = true; return; } Visited = true; - SignalOut1.ConnectedPort.Module.RouteWithTimeoutHandle(this); + SignalOut1.ConnectedPort!.Module.RouteWithTimeoutHandle(this); } } diff --git a/Modules/ControllingModules/SinglePoleDoubleThrowSwitchModule.cs b/Modules/ControllingModules/SinglePoleDoubleThrowSwitchModule.cs index 7e03da9..92ed47a 100644 --- a/Modules/ControllingModules/SinglePoleDoubleThrowSwitchModule.cs +++ b/Modules/ControllingModules/SinglePoleDoubleThrowSwitchModule.cs @@ -32,7 +32,7 @@ public partial class SinglePoleDoubleThrowSwitchModule : ControllingModule, IPar PostInit(); } - protected override void Route(RootModule root) + protected override void Route(IRootModule root) { Visited = true; SignalOutPort selectedPort = (LeftPortForTrue.ParameterValue && ControlInput.GetData(root).Bit) diff --git a/Modules/ControllingModules/SinglePoleSingleThrowSwitchModule.cs b/Modules/ControllingModules/SinglePoleSingleThrowSwitchModule.cs index 7afcd36..aca5cf8 100644 --- a/Modules/ControllingModules/SinglePoleSingleThrowSwitchModule.cs +++ b/Modules/ControllingModules/SinglePoleSingleThrowSwitchModule.cs @@ -1,6 +1,7 @@ using Enigmos.Ports; using Enigmos.Ports.DataPorts; using Enigmos.Ports.SignalPorts; +using Nocturnis.Enigmos.Modules; using TabulaSmaragdina.Constants; namespace Enigmos.Modules.ControllingModules; @@ -24,7 +25,7 @@ public partial class SinglePoleSingleThrowSwitchModule : ControllingModule - protected override void Route(RootModule root) + protected override void Route(IRootModule root) { Visited = true; if (ControlInput.GetData(root).Bit && SignalOut.Connected) diff --git a/Modules/InterlayerModules/InterlayerDataInModule.cs b/Modules/InterlayerModules/InterlayerDataInModule.cs new file mode 100644 index 0000000..bc67dc8 --- /dev/null +++ b/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 Ports => new[] { DataIn }!; + + public override void Init() + { + base.Init(); + DataIn = GetPort("DataIn"); + PostInit(); + } +} diff --git a/Modules/InterlayerModules/InterlayerDataOutModule.cs b/Modules/InterlayerModules/InterlayerDataOutModule.cs new file mode 100644 index 0000000..effd55f --- /dev/null +++ b/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 Ports => new[] { DataOut }!; + + public override void Init() + { + base.Init(); + DataOut = GetPort("DataOut"); + PostInit(); + } + + protected override void Compute(IRootModule root) + { + DataOut!.ResultData = DualModule!.DataIn!.GetData(root); + } +} \ No newline at end of file diff --git a/Modules/InterlayerModules/InterlayerSignalInModule.cs b/Modules/InterlayerModules/InterlayerSignalInModule.cs new file mode 100644 index 0000000..e5fc4ac --- /dev/null +++ b/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 Ports => new[] { SignalIn }!; + + public override void Init() + { + base.Init(); + SignalIn = GetPort("SignalIn"); + PostInit(); + } + + protected override void Route(IRootModule root) => DualModule!.SignalOut!.Module.RouteWithTimeoutHandle(root); +} \ No newline at end of file diff --git a/Modules/InterlayerModules/InterlayerSignalOutModule.cs b/Modules/InterlayerModules/InterlayerSignalOutModule.cs new file mode 100644 index 0000000..240f6b8 --- /dev/null +++ b/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 Ports => new[] { SignalOut }!; + + public override void Init() + { + base.Init(); + SignalOut = GetPort("SignalOut"); + PostInit(); + } + + protected override void Route(IRootModule root) + { + if (!SignalOut!.Connected) + return; + SignalOut.ConnectedPort!.Module.RouteWithTimeoutHandle(root); + } +} \ No newline at end of file diff --git a/Modules/Other/EngineControllingModule.cs b/Modules/Other/EngineControllingModule.cs new file mode 100644 index 0000000..57730b4 --- /dev/null +++ b/Modules/Other/EngineControllingModule.cs @@ -0,0 +1,53 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.Inventories.ItemSlots.ItemSlots; +using Skeleton.Algebra.Extensions; +using Skeleton.Utils.Helpers; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.Other; +public partial class EngineControllingModule : BaseModule +{ + protected override bool Draggable => false; + public DataInPort Throttle { get; set; } + public IChemicalItemSlot FuelTank { get; set; } + private double MaxPumpSpeed => 2d; + private double EnergyConversionEfficiency => 0.5d; + public override IEnumerable Ports => new[] { Throttle }; + public override void Init() + { + base.Init(); + Throttle = GetPort("Throttle"); + Throttle.SetDataType(EnigmosConstant.DataPortTypes.Real); + FuelTank = GetNode("FuelTank"); + PostInit(); + } + + public double Combust(RootModule root) + { + if (FuelTank.Item == null) + return 0d; + if (FuelTank.Item.Amount <= 0) + return 0d; + double fuelAmount = Mathf.Min( + FuelTank.Item.BottomAmount, + Throttle.GetData(root).Real.DoubleCut() * MaxPumpSpeed * (1 - FuelTank.Item.BottomViscosity) + ); + if (fuelAmount == 0) + { + //TODO Drain fuel from pipeline + } + + double res = + fuelAmount * FuelTank.Item.ContentMaterial.LayerOrder.Last.Value.Energy * EnergyConversionEfficiency; + FuelTank.Item.ConsumeFromBottom(fuelAmount); + if (FuelTank.Item.Amount.IsEqualApprox(0d)) + { + //TODO Try get fuel + } + + return res; + } +} diff --git a/Modules/Other/FilterOutputModule.cs b/Modules/Other/FilterOutputModule.cs new file mode 100644 index 0000000..af9f1d4 --- /dev/null +++ b/Modules/Other/FilterOutputModule.cs @@ -0,0 +1,37 @@ + +using Enigmos.Modules.ComputationalModules; +using Enigmos.Modules.ControllingModules; +using Enigmos.Modules.ProgrammableModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; + +namespace Enigmos.Modules.Other; + +public partial class FilterOutputModule : NullaryComputationalModule, IInterlayerModule +{ + public override Vector2 PositionToBoard => base.PositionToBoard + (ParentModule?.PositionToBoard ?? Vector2.Zero); + + public IFilterModule FilterModule + { + get => (ParentModule as IFilterModule)!; + set => ParentModule = value; + } + public DataOutPort Output { get; set; } + public override IEnumerable Ports => new[] { Output }; + protected override bool Draggable => false; + protected override bool HasManual => false; + + public override void Init() + { + base.Init(); + Output = GetPort("Output"); + PostInit(); + } + + protected override void Compute(IRootModule root) => FilterModule.FilterWithTimeoutHandle(root); + public IBasePort UnderlyingPort => Output; + public IProgrammableModule? ParentModule { get; set; } +} \ No newline at end of file diff --git a/Modules/Other/IndicateInputModule.cs b/Modules/Other/IndicateInputModule.cs new file mode 100644 index 0000000..9e34e49 --- /dev/null +++ b/Modules/Other/IndicateInputModule.cs @@ -0,0 +1,20 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; + +namespace Enigmos.Modules.Other; + +public partial class IndicateInputModule : BaseModule +{ + public DataInPort Input { get; set; } + protected override bool Draggable => false; + protected override bool HasManual => false; + public override IEnumerable Ports => new[] { Input }; + public override void Init() + { + base.Init(); + Input = GetPort("Input"); + PostInit(); + } + + +} \ No newline at end of file diff --git a/Modules/Other/IterativeOutputModule.cs b/Modules/Other/IterativeOutputModule.cs new file mode 100644 index 0000000..a3e64ea --- /dev/null +++ b/Modules/Other/IterativeOutputModule.cs @@ -0,0 +1,30 @@ +using Enigmos.Modules.ComputationalModules; +using Enigmos.Modules.ControllingModules; +using Enigmos.Modules.ProgrammableModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; + +namespace Enigmos.Modules.Other; + +public partial class IterativeOutputModule : NullaryComputationalModule, IInterlayerModule +{ + protected override bool Draggable => false; + protected override bool HasManual => false; + public DataOutPort? Output { get; set; } + + public override IEnumerable Ports => new[] { Output }!; + + public override void Init() + { + base.Init(); + Output = GetPort("DataOut"); + PostInit(); + } + + + protected override void Compute(IRootModule root) => throw new Exception("Should be Handled by Other Module"); + public IBasePort UnderlyingPort => Output!; + public IProgrammableModule? ParentModule { get; set; } +} \ No newline at end of file diff --git a/Modules/Other/OptimizationItemOutputModule.cs b/Modules/Other/OptimizationItemOutputModule.cs new file mode 100644 index 0000000..2b4a936 --- /dev/null +++ b/Modules/Other/OptimizationItemOutputModule.cs @@ -0,0 +1,38 @@ + +using Enigmos.Modules.ComputationalModules; +using Enigmos.Modules.ControllingModules; +using Enigmos.Modules.ProgrammableModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; + +namespace Enigmos.Modules.Other; + +public partial class OptimizationItemOutputModule : NullaryComputationalModule, IInterlayerModule +{ + public override Vector2 PositionToBoard => + base.PositionToBoard + (OptimizationModule?.PositionToBoard ?? Vector2.Zero); + protected override bool Draggable => false; + protected override bool HasManual => false; + + public IOptimizationModule OptimizationModule + { + get => ParentModule as IOptimizationModule; + set => ParentModule = value; + } + public DataOutPort DataOut { get; set; } + + public override IEnumerable Ports => new[] { DataOut }; + protected override void Compute(IRootModule root) => OptimizationModule.OptimizeWithTimeoutHandle(root); + public override void Init() + { + base.Init(); + DataOut = GetPort("DataOut"); + PostInit(); + } + + public IBasePort UnderlyingPort => DataOut; + public IProgrammableModule? ParentModule { get; set; } +} \ No newline at end of file diff --git a/Modules/Other/OptimizationValueInputModule.cs b/Modules/Other/OptimizationValueInputModule.cs new file mode 100644 index 0000000..4ef57c4 --- /dev/null +++ b/Modules/Other/OptimizationValueInputModule.cs @@ -0,0 +1,21 @@ +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.Other; + +public partial class OptimizationValueInputModule : BaseModule +{ + protected override bool Draggable => false; + protected override bool HasManual => false; + public DataInPort DataIn { get; set; } + public override IEnumerable Ports => new[] { DataIn }; + + public override void Init() + { + DataIn = GetPort("DataIn"); + DataIn.SetDataType(EnigmosConstant.DataPortTypes.Real); + DataIn.Module = this; + } +} \ No newline at end of file diff --git a/Modules/Other/OptimizationValueOutputModule.cs b/Modules/Other/OptimizationValueOutputModule.cs new file mode 100644 index 0000000..9665195 --- /dev/null +++ b/Modules/Other/OptimizationValueOutputModule.cs @@ -0,0 +1,38 @@ +using Enigmos.Modules.ComputationalModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.Other; + +public partial class OptimizationValueOutputModule : NullaryComputationalModule, IInterlayerModule +{ + public override Vector2 PositionToBoard => + base.PositionToBoard + (OptimizationModule?.PositionToBoard ?? Vector2.Zero); + protected override bool Draggable => false; + protected override bool HasManual => false; + public DataOutPort? DataOut { get; set; } + public IOptimizationModule OptimizationModule + { + get => (ParentModule as IOptimizationModule)!; + set => ParentModule = value; + } + public override IEnumerable Ports => new[] { DataOut }!; + + public override void Init() + { + base.Init(); + DataOut = GetPort("DataOut"); + DataOut.SetDataType(EnigmosConstant.DataPortTypes.Real); + PostInit(); + } + + protected override void Compute(IRootModule root) => + OptimizationModule.OptimizeWithTimeoutHandle(root); + + public IBasePort UnderlyingPort => DataOut; + public IProgrammableModule? ParentModule { get; set; } +} \ No newline at end of file diff --git a/Modules/Other/OutputSubModule.cs b/Modules/Other/OutputSubModule.cs new file mode 100644 index 0000000..b1a8d13 --- /dev/null +++ b/Modules/Other/OutputSubModule.cs @@ -0,0 +1,28 @@ +using Enigmos.Modules.ComputationalModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina.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 Ports => new[] { DataOut }; + public IComputationalCompositeModule ParentModule { get; set; } + public DataOutPort DataOut { get; set; } + protected override void Compute(IRootModule root) => ParentModule.Compute(root); + public override void Init() + { + base.Init(); + DataOut = GetPort("DataOut"); + DataOut.SetDataType(EnigmosConstant.DataPortTypes.Real); + PostInit(); + } + +} \ No newline at end of file diff --git a/Modules/TerminalModules/MemoryModule.cs b/Modules/TerminalModules/MemoryModule.cs new file mode 100644 index 0000000..b9e2d79 --- /dev/null +++ b/Modules/TerminalModules/MemoryModule.cs @@ -0,0 +1,91 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Modules.Other; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.TerminalModules; + +public partial class MemoryModule : TerminalModule, IPolymorphismModule, IComputationalCompositeModule +{ + private DataInPort? Input1 { get; set; } + private DataInPort? Input2 { get; set; } + private DataInPort? Input3 { get; set; } + private IDataPackage? Memory { get; set; } + private IDataPortGroup? MemoryPortGroup { get; set; } + public HashSet ConfigurablePortGroups { get; set; } = new(); + private OutputSubModule? Output1 { get; set; } + private OutputSubModule? Output2 { get; set; } + private OutputSubModule? Output3 { get; set; } + private OutputSubModule? Output4 { get; set; } + public override IEnumerable Ports => new BasePort[] { Input1!, Input2!, Input3! }; + public IBaseModule[] SubModules() => new IBaseModule[] { Output1!, Output2!, Output3!, Output4! }; + + + protected OutputSubModule GetOutputModule(string path) + { + OutputSubModule res = GetNode(path); + res.Init(); + res.ParentModule = this; + res.Board = Board; + return res; + } + public override void Init() + { + base.Init(); + Memory = GlobalProvider.DataStructureProvider!.NewDataPackage(); + Input1 = GetPort("Input1"); + Input2 = GetPort("Input2"); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input3 = GetPort("Input3"); + Input3.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1 = GetOutputModule("Output1"); + Output2 = GetOutputModule("Output2"); + Output3 = GetOutputModule("Output3"); + Output4 = GetOutputModule("Output4"); + MemoryPortGroup =GlobalProvider.DataStructureProvider!.NewDataPortGroup( + this, + new IDataPort[] { Input1, Output1.DataOut, Output2.DataOut, Output3.DataOut, Output4.DataOut }, + "Memory Data Type:", + EnigmosConstant.DataPortTypes.Real, + EnigmosConstant.DataPortTypes.AnyType + ); + ConfigurablePortGroups = new HashSet() { MemoryPortGroup }; + PostInit(); + } + + public void Inference() + { + } + + public void Compute(IRootModule root) + { + Output1!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup!.SelectedType); + Output2!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType); + Output3!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType); + Output4!.DataOut.ResultData.Assign(Memory!, MemoryPortGroup.SelectedType); + } + + protected override void Consume(RootModule root) + { + bool setValue = Input2!.GetData(root).Bit; + bool resetValue = Input3!.GetData(root).Bit; + if (setValue) + Memory!.Assign(Input1!.GetData(root), MemoryPortGroup!.SelectedType); + else if(resetValue) + Memory!.Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, MemoryPortGroup!.SelectedType); + Finished = true; + } + + public override void UpdateCables() + { + base.UpdateCables(); + foreach (BaseModule subModule in SubModules()) + subModule.UpdateCables(); + + } +} \ No newline at end of file diff --git a/Modules/TerminalModules/SRLatchModule.cs b/Modules/TerminalModules/SRLatchModule.cs new file mode 100644 index 0000000..4fe2bb0 --- /dev/null +++ b/Modules/TerminalModules/SRLatchModule.cs @@ -0,0 +1,66 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Modules.Other; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Nocturnis.Enigmos.Modules; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.TerminalModules; + +public partial class SRLatchModule : TerminalModule, IComputationalCompositeModule +{ + private DataInPort? Input1 { get; set; } + private DataInPort? Input2 { get; set; } + public OutputSubModule? Output1 { get; set; } + public OutputSubModule? Output2 { get; set; } + public override IEnumerable Ports => new[] { Input1, Input2 }!; + + private bool State { get; set; } + public IBaseModule[] SubModules() => new IBaseModule[] { Output1, Output2 }; + public void Compute(IRootModule root) + { + Output1!.DataOut.ResultData.Bit = State; + Output2!.DataOut.ResultData.Bit = State; + } + + protected override void Consume(RootModule root) + { + bool set = Input1!.GetData(root).Bit; + bool reset = Input2!.GetData(root).Bit; + if (set && reset) + State = false; + else if (set) + State = true; + else if (reset) + State = false; + } + protected OutputSubModule GetOutputModule(string path) + { + OutputSubModule res = GetNode(path); + res.Init(); + res.ParentModule = this; + res.Board = Board; + return res; + } + public override void Init() + { + base.Init(); + Input1 = GetPort("Input1"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Input2 = GetPort("Input2"); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output1 = GetOutputModule("Output1"); + Output1.DataOut.SetDataType(EnigmosConstant.DataPortTypes.Bit); + Output2 = GetOutputModule("Output2"); + Output2.DataOut.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + public override void UpdateCables() + { + base.UpdateCables(); + foreach (IBaseModule subModule in SubModules()) + subModule.UpdateCables(); + + } +} diff --git a/Modules/TerminalModules/TestingModules/LightEmittingDiodeModule.cs b/Modules/TerminalModules/TestingModules/LightEmittingDiodeModule.cs new file mode 100644 index 0000000..29b6509 --- /dev/null +++ b/Modules/TerminalModules/TestingModules/LightEmittingDiodeModule.cs @@ -0,0 +1,38 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Nocturnis.Enigmos.Ports; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.TerminalModules.TestingModules; + +public partial class LightEmittingDiodeModule : TerminalModule +{ + private Sprite2D LightEmittingDiode { get; set; } + private DataInPort Input { get; set; } + public override IEnumerable Ports => new[] { Input }; + + private static readonly Texture2D TrueTexture = + ResourceLoader.Load("res://Resources/Circuits/Modules/Terminal/Testing/LEDBubble-T.png"); + private static readonly Texture2D FalseTexture = + ResourceLoader.Load("res://Resources/Circuits/Modules/Terminal/Testing/LEDBubble-F.png"); + public override void Init() + { + base.Init(); + Finished = true; + LightEmittingDiode = GetNode("LightEmittingDiode"); + Input = GetPort("Input"); + Input.SetDataType(EnigmosConstant.DataPortTypes.Bit); + PostInit(); + } + + protected override void Consume(RootModule root) + { + if (Input.GetData(root).Bit) + LightEmittingDiode.Texture = TrueTexture; + else + LightEmittingDiode.Texture = FalseTexture; + Finished = true; + } +} \ No newline at end of file diff --git a/Modules/TerminalModules/TestingModules/R2Reader.cs b/Modules/TerminalModules/TestingModules/R2Reader.cs new file mode 100644 index 0000000..9921d8e --- /dev/null +++ b/Modules/TerminalModules/TestingModules/R2Reader.cs @@ -0,0 +1,34 @@ +using Godot; +using Skeleton.Utils.Helpers; +using R2 = Skeleton.Algebra.CategoryOf.OnField.FVector; + +namespace Enigmos.Modules.TerminalModules.TestingModules; + +public partial class R2Reader : Control +{ + private AnimatedSprite2D Direction { get; set; } + private AnimatedSprite2D Magnitude { get; set; } + public R2 UnderlyingVector { get; set; } + private double TargetPhase() => Math.Atan2(UnderlyingVector[2], UnderlyingVector[1]); + private double TargetLength() => UnderlyingVector.Magnitude; + + private int TargetPhaseFrame => + Mathf.FloorToInt((TargetPhase() % (2d * Math.PI) + 2d * Math.PI) % (2d * Math.PI) * 44d / (2d * Math.PI)); + + private int TargetLengthFrame => + Mathf.FloorToInt(TargetLength().DoubleCut() * 9d); + public override void _Process(double delta) + { + Magnitude.SpeedScale = (TargetLengthFrame - Magnitude.Frame) / 7f; + var debug = new[] { TargetPhaseFrame - Direction.Frame, TargetPhaseFrame + 44 - Direction.Frame }; + Direction.SpeedScale = debug.MinBy(Math.Abs) / 25f; + } + + public void Init() + { + Direction = GetNode("Direction"); + Magnitude = GetNode("Magnitude"); + Direction.Play(); + Magnitude.Play(); + } +} \ No newline at end of file diff --git a/Modules/TerminalModules/TestingModules/R2ReaderModule.cs b/Modules/TerminalModules/TestingModules/R2ReaderModule.cs new file mode 100644 index 0000000..044076e --- /dev/null +++ b/Modules/TerminalModules/TestingModules/R2ReaderModule.cs @@ -0,0 +1,29 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.TerminalModules.TestingModules; + +public partial class R2ReaderModule : TerminalModule +{ + private DataInPort DataIn { get; set; } + private R2Reader R2Reader { get; set; } + + public override IEnumerable Ports => new[] { DataIn }; + + public override void Init() + { + base.Init(); + DataIn = GetPort("DataIn"); + DataIn.SetDataType(EnigmosConstant.DataPortTypes.R2); + R2Reader = GetNode("R2Reader"); + R2Reader.Init(); + PostInit(); + } + + protected override void Consume(RootModule root) + { + R2Reader.UnderlyingVector = DataIn.GetData(root).R2; + } +} \ No newline at end of file diff --git a/Modules/TerminalModules/TestingModules/RealReaderModule.cs b/Modules/TerminalModules/TestingModules/RealReaderModule.cs new file mode 100644 index 0000000..0a2422a --- /dev/null +++ b/Modules/TerminalModules/TestingModules/RealReaderModule.cs @@ -0,0 +1,45 @@ +using Enigmos.Modules.ControllingModules; +using Enigmos.Ports; +using Enigmos.Ports.DataPorts; +using Godot; +using Skeleton.Utils.Helpers; +using TabulaSmaragdina.Constants; + +namespace Enigmos.Modules.TerminalModules.TestingModules; + +public partial class RealReaderModule : TerminalModule +{ + private DataInPort Input1 { get; set; } + private DataInPort Input2 { get; set; } + private DataInPort Input3 { get; set; } + private AnimatedSprite2D RealReader { get; set; } + public override IEnumerable Ports => new[] { Input1, Input2, Input3 }; + + public override void Init() + { + base.Init(); + Input1 = GetPort("Input1"); + Input2 = GetPort("Input2"); + Input3 = GetPort("Input3"); + Input1.SetDataType(EnigmosConstant.DataPortTypes.Real); + Input2.SetDataType(EnigmosConstant.DataPortTypes.Real); + Input3.SetDataType(EnigmosConstant.DataPortTypes.Real); + RealReader = GetNode("RealReader"); + RealReader.SpeedScale = 0; + RealReader.Play(); + PostInit(); + } + + protected override void Consume(RootModule root) + { + double max = Input1.GetData(root).Real; + double min = Input3.GetData(root).Real; + double value = Input2.GetData(root).Real; + //DebugToolWindow.FreeInfo = $"{value}"; + double range = max - min; + double percentage = (range == 0 ? 0d : value / range).DoubleCut(); + int frame = Mathf.FloorToInt(percentage * 122); + RealReader.SpeedScale = (frame - RealReader.Frame) / 60f; + Finished = true; + } +} \ No newline at end of file diff --git a/Ports/DataPorts/DataInPort.cs b/Ports/DataPorts/DataInPort.cs index de0daea..f6fa0b3 100644 --- a/Ports/DataPorts/DataInPort.cs +++ b/Ports/DataPorts/DataInPort.cs @@ -1,6 +1,7 @@ using Enigmos.Cables; using Enigmos.Modules.ControllingModules; using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; using Nocturnis.Enigmos.Ports; using TabulaSmaragdina; @@ -15,10 +16,10 @@ public partial class DataInPort : DataPort, IDataInPort public override bool IsMatch(IBasePort other) => other is DataOutPort dataOut && - GlobalProvider.EnigmosProvider.DataPortTypeCompatible(DataType, dataOut.DataType); + GlobalProvider.DataPackageTypeProvider.DataPortTypeCompatible(DataType, dataOut.DataType); - public IDataPackage GetData(RootModule root) + public IDataPackage GetData(IRootModule root) { if (!Connected) return GlobalProvider.DataStructureProvider.DefaultDataPackage; diff --git a/Ports/DataPorts/DataOutPort.cs b/Ports/DataPorts/DataOutPort.cs index 4863518..d633791 100644 --- a/Ports/DataPorts/DataOutPort.cs +++ b/Ports/DataPorts/DataOutPort.cs @@ -2,6 +2,7 @@ using Enigmos.Cables; using Enigmos.Modules.ComputationalModules; using Enigmos.Modules.ControllingModules; using Nocturnis.DataStructures; +using Nocturnis.Enigmos.Modules; using Nocturnis.Enigmos.Ports; using TabulaSmaragdina; @@ -17,7 +18,7 @@ public partial class DataOutPort : DataPort, IDataOutPort set => base.Module = value; } - public void DataUpdateRequest(RootModule root) => Module.ComputeWithTimeoutHandle(root); + public void DataUpdateRequest(IRootModule root) => Module.ComputeWithTimeoutHandle(root); public DataOutPort() { @@ -33,7 +34,7 @@ public partial class DataOutPort : DataPort, IDataOutPort public override bool IsMatch(IBasePort other) => other is DataInPort inPort && - GlobalProvider.EnigmosProvider.DataPortTypeCompatible(inPort.DataType, DataType); + GlobalProvider.DataPackageTypeProvider.DataPortTypeCompatible(inPort.DataType, DataType); public IDataPackage ResultData { get; set; } public override BaseCable MakeCable(IBasePort other) diff --git a/Ports/SignalPorts/SignalInPort.cs b/Ports/SignalPorts/SignalInPort.cs index f5f1bef..978d90e 100644 --- a/Ports/SignalPorts/SignalInPort.cs +++ b/Ports/SignalPorts/SignalInPort.cs @@ -1,17 +1,18 @@ using Enigmos.Cables; using Enigmos.Modules.ControllingModules; +using Nocturnis.Enigmos.Modules; using Nocturnis.Enigmos.Ports; namespace Enigmos.Ports.SignalPorts; public partial class SignalInPort : SignalPort, ISignalInPort { - public new ControllingModule Module + public new IControllingModule Module { - get => base.Module as ControllingModule; + get => (base.Module as ControllingModule)!; set => base.Module = value; } - public new SignalOutPort ConnectedPort + public new SignalOutPort? ConnectedPort { get => base.ConnectedPort as SignalOutPort; set => base.ConnectedPort = value; diff --git a/Ports/SignalPorts/SignalOutPort.cs b/Ports/SignalPorts/SignalOutPort.cs index 906f51d..08f1e77 100644 --- a/Ports/SignalPorts/SignalOutPort.cs +++ b/Ports/SignalPorts/SignalOutPort.cs @@ -1,19 +1,20 @@ using Enigmos.Cables; using Enigmos.Modules.ControllingModules; +using Nocturnis.Enigmos.Modules; using Nocturnis.Enigmos.Ports; namespace Enigmos.Ports.SignalPorts; public partial class SignalOutPort : SignalPort, ISignalOutPort { - public new ControllingModule Module + public new IControllingModule Module { - get => base.Module as ControllingModule; + get => (base.Module as ControllingModule)!; set => base.Module = value; } - public new SignalInPort ConnectedPort + public new ISignalInPort? ConnectedPort { get => base.ConnectedPort as SignalInPort; set => base.ConnectedPort = value; diff --git a/Ports/SignalPorts/SignalPort.cs b/Ports/SignalPorts/SignalPort.cs index c4c809f..bf987bf 100644 --- a/Ports/SignalPorts/SignalPort.cs +++ b/Ports/SignalPorts/SignalPort.cs @@ -1,5 +1,6 @@ using Enigmos.Cables; using Godot; +using Nocturnis.Enigmos.Modules; using Nocturnis.Enigmos.Ports; using TabulaSmaragdina; @@ -7,6 +8,11 @@ namespace Enigmos.Ports.SignalPorts; public abstract partial class SignalPort : BasePort, ISignalInPort { + public new IControllingModule Module + { + get => (base.Module as IControllingModule)!; + set => base.Module = value; + } protected AnimatedSprite2D SignalDirection { get; set; } public override void Init() { @@ -14,24 +20,22 @@ public abstract partial class SignalPort : BasePort, ISignalInPort SignalDirection = GetNode("SignalDirection"); SignalDirection.Visible = false; } - - private void MouseEnteredHandler() => SignalDirection.Visible = true; private void MouseExitedHandler() => SignalDirection.Visible = false; public override void SetStatusConnected() => - TextureNormal = GlobalProvider.EnigmosProvider.SignalPortStatusConnected; + TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusConnected; public override void SetStatusNormal() => - TextureNormal = GlobalProvider.EnigmosProvider.SignalPortStatusNormal; + TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusNormal; public override void SetStatusPending() => - TextureNormal = GlobalProvider.EnigmosProvider.SignalPortStatusPending; + TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusPending; public override BaseCable MakeCable(IBasePort other) { - BaseCable res = GlobalProvider.EnigmosProvider.SignalCableScene.Instantiate(); + BaseCable res = GlobalProvider.EnigmosProvider!.SignalCableScene.Instantiate(); res.Init(); return res; }