hzhang/Enigmos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: hzhang:3eec8a1345bdd44d7ba77ec4e16e801866390fda
Branches Tags
hzhang:master
...
compare: hzhang:75d7033601376abb1bc9cfe83bf6a6dcdea2774a
Branches Tags
hzhang:master

10 Commits
3eec8a1345 ... 75d7033601

Author SHA1 Message Date
hzhang
75d7033601 move to new git server 2025-01-19 13:47:29 +00:00
hzhang
acaef122ae Instruction System 2024-09-29 15:39:37 +01:00
hzhang
cd726f5d33 Bracket System 2024-09-26 10:29:27 +01:00
hzhang
097e3522a5 bracket system 2024-07-29 17:24:31 +01:00
hzhang
f6a8f3e899 To net8.0 2024-07-13 09:29:45 +01:00
hzhang
1df3c08a9e Upgrade 2024-07-12 14:32:16 +01:00
hzhang
5548a7243b Update 2024-07-11 12:54:28 +01:00
hzhang
bd5ab1e940 Data Type 2024-07-11 11:21:29 +01:00
hzhang
a8688d7f95 source generator upgrade 2024-07-10 15:27:36 +01:00
hzhang
401e48e0ba source generator 2024-07-10 07:02:11 +01:00
97 changed files with 877 additions and 885 deletions
Expand all files Collapse all files

96
Boards/BaseBoard.cs
View File

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

21
Boards/FilterModuleBoard.cs
View File

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

3
Boards/FunctionModuleBoard.cs
View File

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

13
Boards/OptimizationModuleBoard.cs
View File

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

31
Boards/PrimaryModuleBoard.cs
View File

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

33
Cables/DataCable.cs Normal file
View File

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

32
Cables/SignalCable.cs Normal file
View File

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

20
Enigmos.csproj
View File

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

4
Enigmos.sln
View File

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

3
Manual/CommunicatorPairTab.cs
View File

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

3
Manual/ErrorHandlerTab.cs
View File

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

3
Manual/ModuleBoolValueParameterSetter.cs
View File

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

3
Manual/ModuleCharValueParameterSetter.cs
View File

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

3
Manual/ModuleKeyValueParameterSetter.cs
View File

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

53
Manual/ModuleManual.cs
View File

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

2
Manual/ModuleParameterSetter.cs
View File

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

31
Manual/ModuleParameterTab.cs
View File

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

9
Manual/ModulePolymorphismTab.cs
View File

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

3
Manual/ModuleRealValueParameterSetter.cs
View File

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

19
Manual/PortMaintenanceTab.cs
View File

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

18
Manual/PortTypeSelector.cs
View File

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

15
Manual/ProgrammableModuleSettingTab.cs
View File

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

77
Modules/BaseModule.cs
View File

@@ -1,14 +1,13 @@
using Enigmos.Exceptions;
using Enigmos.Manual;
using Enigmos.Ports;
using Godot;
using Nocturnis;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Boards;
using Nocturnis.Enigmos.Cables;
using Nocturnis.Enigmos.ModuleManuals;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.GlobalManagement.Providers;
using Nocturnis.UIElements;
using Nocturnis.Godot;
namespace Enigmos.Modules;
@@ -17,19 +16,21 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
[Export] private int PresetPortQuality { get; set; }
[Export] private int PresetPortCondition { get; set; }
[Export] protected bool UsingPreset { get; set; }
[Export] public IPresetModuleConnection[] PresetConnections { get; set; } = Array.Empty<IPresetModuleConnection>();
//[Export]
public IPresetModuleConnection[] PresetConnections { get; set; } = Array.Empty<IPresetModuleConnection>();
[Export] public string LabelString { get; set; } = "";
public virtual Vector2 PositionToBoard => Position;
protected virtual bool Draggable => true;
protected virtual bool HasManual => true;
public bool HasLabel => HasManual;
public virtual IEnumerable<IBasePort> Ports => Array.Empty<BasePort>();
public IBaseBoard? Board { get; set; }
private ModuleManual? Manual { get; set; }
public ISimpleLabel? Label { get; set; }
public virtual IEnumerable<IBasePort> Ports => GetChildren().OfType<IBasePort>();
public IBaseBoard Board { get; set; }
public IModuleManual Manual { get; set; }
public Label Label { get; set; }
public Node AsNode => this;
public virtual void PresetValueInit()
{
foreach (IBasePort port in Ports)
@@ -38,19 +39,18 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
port.Quality = PresetPortQuality;
}
}
public virtual void Init()
{
if (HasLabel)
{
Label = GlobalProvider.SceneProvider!
.AssetMapper<ISimpleLabel>()
.Instantiate<ISimpleLabel>();
Label = new Label();
Label.AddThemeFontOverride("font", GlobalProvider.Font);
Label.Position = new Vector2(0, -25);
Label.Text = LabelString;
AddChild(Label.AsNode);
AddChild(Label);
}
}
@@ -70,7 +70,7 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
{
foreach (IBasePort port in Ports)
{
if(!Board!.CablePairing.ContainsKey(port))
if (!Board!.CablePairing.ContainsKey(port))
continue;
Board.CablePairing[port].LineUpdate();
}
@@ -80,19 +80,10 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
{
foreach (IBasePort port in Ports)
port.Module = this;
if(UsingPreset)
if (UsingPreset)
PresetValueInit();
}
protected virtual void TimeoutCheck(IRootModule root)
{
if (root.Timer!.ElapsedMilliseconds < 25) return;
root.Timer.Stop();
throw ModuleExecutionTimeout.Exception;
}
protected virtual void TimeoutHandler(ModuleExecutionTimeout timeout) => throw timeout;
public override Variant _GetDragData(Vector2 atPosition)
{
if (!Draggable)
@@ -101,37 +92,20 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
Board!.ModuleMovingLayer.MouseOffset = GetLocalMousePosition();
return GlobalProvider.DataStructureProvider!.NewVariantWithType("Module", this);
}
/*protected T GetPort<T>(string path) where T : BasePort
{
T res = GetNode<T>(path);
res.Init();
return res;
}*/
public override void _Input(InputEvent @event)
{
if (@event is InputEventMouseButton eventMouseButton)
{
Vector2 mousePosition = GetLocalMousePosition();
if(mousePosition.X > 0 && mousePosition.X < Size.X && mousePosition.Y > 0 && mousePosition.Y < Size.Y)
if (mousePosition.X > 0 && mousePosition.X < Size.X && mousePosition.Y > 0 && mousePosition.Y < Size.Y)
{
if (eventMouseButton.ButtonIndex == MouseButton.Right && eventMouseButton.Pressed)
{
if (!HasManual)
return;
if (Board!.ManualOpened)
if (!HasManual || Board!.ManualOpened)
return;
if (Manual == null)
{
Manual = GlobalProvider.SceneProvider!
.AssetMapper<ModuleManual>()
.Instantiate<ModuleManual>();
Manual.Init(this);
}
Board.ModuleManualLayer!.AddChild(Manual);
GlobalProvider.ProcessProvider.BuildManual(this);
Board.ModuleManualLayer!.AddChild(Manual.AsNode());
Manual.Position = Board.ModuleManualLayer.ManualPosition.Position - Manual.Size / 2;
Board.ManualOpened = true;
return;
@@ -148,7 +122,8 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
.Select(p => Board.CablePairing[p])
.ToHashSet();
if (this is ICompositeModule thisCompositeModule)
foreach (IBasePort port in thisCompositeModule.SubModules.SelectMany(module => module.Ports).Where(Board.CablePairing.ContainsKey))
foreach (IBasePort port in thisCompositeModule.SubModules.SelectMany(module => module.Ports)
.Where(Board.CablePairing.ContainsKey))
Board.FocusedCables.Add(Board.CablePairing[port]);
foreach (IBaseCable cable in Board.FocusedCables)
cable.Modulate = Color.Color8(255, 255, 255, 255);
@@ -159,4 +134,6 @@ public abstract partial class BaseModule : TextureRect, IBaseModule
base._Input(@event);
}
public abstract Texture2D PreviewTexture { get; }
}

41
Modules/CompositeModule.cs Normal file
View File

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

20
Modules/ComputationalModules/Binary/AdditionModule.cs
View File

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

5
Modules/ComputationalModules/Binary/BinaryLogicModule.cs
View File

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

16
Modules/ComputationalModules/Binary/ComparisionModule.cs
View File

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

17
Modules/ComputationalModules/Binary/ControlledOutputModule.cs
View File

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

16
Modules/ComputationalModules/Binary/DivisionModule.cs
View File

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

23
Modules/ComputationalModules/Binary/DotProductModule.cs
View File

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

8
Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs
View File

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

8
Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs
View File

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

8
Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs
View File

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

8
Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs
View File

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

8
Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs
View File

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

4
Modules/ComputationalModules/Binary/LogicalImplicationModule.cs
View File

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

4
Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs
View File

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

8
Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs
View File

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

18
Modules/ComputationalModules/Binary/MaxModule.cs
View File

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

14
Modules/ComputationalModules/Binary/MinModule.cs
View File

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

17
Modules/ComputationalModules/Binary/MultiplicationModule.cs
View File

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

20
Modules/ComputationalModules/Binary/PowerModule.cs
View File

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

24
Modules/ComputationalModules/Binary/ScalarDivisionModule.cs
View File

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

26
Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs
View File

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

17
Modules/ComputationalModules/Binary/SubtractionModule.cs
View File

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

45
Modules/ComputationalModules/Binary/V2Module.cs
View File

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

3
Modules/ComputationalModules/BinaryComputationalModule.cs
View File

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

8
Modules/ComputationalModules/Nullary/ConstantModule.cs
View File

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

21
Modules/ComputationalModules/Nullary/KeyListenerModule.cs
View File

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

8
Modules/ComputationalModules/Nullary/NormalDistributionModule.cs
View File

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

4
Modules/ComputationalModules/NullaryComputationalModule.cs
View File

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

14
Modules/ComputationalModules/Ternary/SelectorModule.cs
View File

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

2
Modules/ComputationalModules/TernaryComputationalModule.cs
View File

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

18
Modules/ComputationalModules/Unary/CopyModule.cs
View File

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

12
Modules/ComputationalModules/Unary/LogicalNegationModule.cs
View File

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

22
Modules/ComputationalModules/Unary/NegationModule.cs
View File

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

18
Modules/ComputationalModules/Unary/SquareModule.cs
View File

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

42
Modules/ComputationalModules/Unary/V2ComponentModule.cs
View File

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

2
Modules/ComputationalModules/UnaryComputationalModule.cs
View File

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

11
Modules/ControllingModules/ActionModules/AttackActionModule.cs
View File

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

13
Modules/ControllingModules/ActionModules/MoveActionModule.cs
View File

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

16
Modules/ControllingModules/RootModule.cs
View File

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

16
Modules/ControllingModules/SinglePoleDoubleThrowSwitchModule.cs
View File

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

9
Modules/ControllingModules/SinglePoleSingleThrowSwitchModule.cs
View File

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

2
Modules/InterlayerModules/InterlayerDataInModule.cs
View File

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

5
Modules/InterlayerModules/InterlayerDataOutModule.cs
View File

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

11
Modules/InterlayerModules/InterlayerSignalInModule.cs
View File

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

2
Modules/InterlayerModules/InterlayerSignalOutModule.cs
View File

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

35
Modules/Other/OutputSubModule.cs
View File

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

1
Modules/ProgrammableModules/FilterModule/FilterIndicateModule.cs
View File

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

13
Modules/ProgrammableModules/FilterModule/FilterInputProviderModule.cs
View File

@@ -1,17 +1,16 @@
using Enigmos.Boards;
using Godot;
using Nocturnis.DataStructures;
using Enigmos.Modules.SubModules;
using Nocturnis.DataStructures.Data;
using Nocturnis.DataStructures.DataTypes;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Skeleton.DataStructure;
namespace Enigmos.Modules.ProgrammableModules.FilterModule;
public partial class FilterInputProviderModule : SubModule, IComputationalModule
public abstract partial class FilterInputProviderModule : SubModule, IComputationalModule
{
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public IDataOutPort? Output { get; set; }
public FilterModuleBoard? ParentBoard { get; set; }
@@ -27,9 +26,9 @@ public partial class FilterInputProviderModule : SubModule, IComputationalModule
public void Define()
{
(object, StringName) Func(CacheItem c)
(object, DataType) Func(CacheItem c)
{
IData w = ParentBoard!.FilterModule!.CachedInputArray[ParentBoard.FilterModule.ProcessingIndex];
DataVariable w = ParentBoard!.FilterModule!.CachedInputArray[ParentBoard.FilterModule.ProcessingIndex];
return (w.Data, w.Type)!;
}
Output!.OutData.UpdateCalculation(Func);

65
Modules/ProgrammableModules/FilterModule/FilterModule.cs
View File

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

41
Modules/ProgrammableModules/FilterModule/FilterOutputModule.cs
View File

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

44
Modules/ProgrammableModules/FunctionModule/FunctionModule.cs
View File

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

11
Modules/ProgrammableModules/OptimizationModule/OptimizationInputProviderModule.cs
View File

@@ -1,8 +1,8 @@
using Enigmos.Boards;
using Godot;
using Nocturnis.DataStructures;
using Enigmos.Modules.SubModules;
using Nocturnis.DataStructures.Data;
using Nocturnis.DataStructures.DataTypes;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Skeleton.DataStructure;
@@ -11,7 +11,6 @@ namespace Enigmos.Modules.ProgrammableModules.OptimizationModule;
public partial class OptimizationInputProviderModule : SubModule, IComputationalModule
{
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public override IEnumerable<IBasePort> Ports => DataOutPorts;
public IDataOutPort? Output { get; set; }
public OptimizationModuleBoard? ParentBoard { get; set; }
@@ -26,9 +25,9 @@ public partial class OptimizationInputProviderModule : SubModule, IComputational
public void Define()
{
(object, StringName) Func(CacheItem c)
(object, DataType) Func(CacheItem c)
{
IData w = ParentBoard!.OptimizationModule!.CachedInput[ParentBoard.OptimizationModule.ProcessingIndex];
DataVariable w = ParentBoard!.OptimizationModule!.CachedInputArray[ParentBoard.OptimizationModule.ProcessingIndex];
return (w.Data, w.Type)!;
}
Output!.OutData.UpdateCalculation(Func);

86
Modules/ProgrammableModules/OptimizationModule/OptimizationModule.cs
View File

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

25
Modules/ProgrammableModules/OptimizationModule/OptimizationOutputModule.cs
View File

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

1
Modules/ProgrammableModules/OptimizationModule/OptimizationSelectorModule.cs
View File

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

31
Modules/ProgrammableModules/ProgrammableModule.cs
View File

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

32
Modules/SubModules/EnumerableArrayInputModule.cs Normal file
View File

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

9
Modules/SubModules/EnumerableElementOutputModule.cs Normal file
View File

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

35
Modules/SubModules/OutputSubModule.cs Normal file
View File

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

7
Modules/SubModule.cs → Modules/SubModules/SubModule.cs
View File

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

19
Modules/TerminalModules/EngineModule.cs
View File

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

23
Modules/TerminalModules/MemoryModule.cs
View File

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

17
Modules/TerminalModules/SRLatchModule.cs
View File

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

22
Modules/TerminalModules/TestingModules/LightEmittingDiodeModule.cs
View File

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

10
Modules/TerminalModules/TestingModules/R2Reader.cs
View File

@@ -6,11 +6,11 @@ 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 AnimatedSprite2D Direction { get; set; }
private AnimatedSprite2D Magnitude { get; set; }
public R2 UnderlyingVector { get; set; }
private double TargetPhase() => UnderlyingVector == null ? 0: Math.Atan2(UnderlyingVector![2], UnderlyingVector![1]);
private double TargetLength() => UnderlyingVector?.Magnitude ?? 0;
private int TargetPhaseFrame =>
Mathf.FloorToInt((TargetPhase() % (2d * Math.PI) + 2d * Math.PI) % (2d * Math.PI) * 44d / (2d * Math.PI));

12
Modules/TerminalModules/TestingModules/R2ReaderModule.cs
View File

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

18
Modules/TerminalModules/TestingModules/RealReaderModule.cs
View File

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

17
Ports/BasePort.cs
View File

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

4
Ports/DataPorts/DataInPort.cs
View File

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

15
Ports/DataPorts/DataOutPort.cs
View File

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

18
Ports/DataPorts/DataPort.cs
View File

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

4
Ports/SignalPorts/SignalInPort.cs
View File

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

10
Ports/SignalPorts/SignalOutPort.cs
View File

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

8
Ports/SignalPorts/SignalPort.cs
View File

@@ -20,15 +20,17 @@ public abstract partial class SignalPort : BasePort, ISignalPort
private void MouseEnteredHandler() => SignalDirection!.Visible = true;
private void MouseExitedHandler() => SignalDirection!.Visible = false;
public override void SetStatusConnected() =>
public override void SetStatusConnected()
{
base.SetStatusConnected();
TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusConnected;
}
public override void SetStatusNormal() =>
TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusNormal;
public override void SetStatusPending() =>
TextureNormal = GlobalProvider.EnigmosProvider!.SignalPortStatusPending;
public override BaseCable MakeCable(IBasePort other)
{
BaseCable res = GlobalProvider.EnigmosProvider!.SignalCableScene.Instantiate<BaseCable>();