NorbiPeti
63295f82c9
Removed old dependencies, including uREPL Added new block IDs Implemented basic command handling to support existing mod commands
388 lines
13 KiB
C#
388 lines
13 KiB
C#
using System;
|
|
|
|
using Gamecraft.Wires;
|
|
using Svelto.DataStructures;
|
|
using Svelto.ECS;
|
|
|
|
using TechbloxModdingAPI.Engines;
|
|
using TechbloxModdingAPI.Utility;
|
|
|
|
namespace TechbloxModdingAPI.Blocks.Engines
|
|
{
|
|
/// <summary>
|
|
/// Engine which executes signal actions
|
|
/// </summary>
|
|
public class SignalEngine : IApiEngine, IFactoryEngine
|
|
{
|
|
public const float POSITIVE_HIGH = 1.0f;
|
|
public const float NEGATIVE_HIGH = -1.0f;
|
|
public const float HIGH = 1.0f;
|
|
public const float ZERO = 0.0f;
|
|
|
|
public string Name { get; } = "TechbloxModdingAPISignalGameEngine";
|
|
|
|
public EntitiesDB entitiesDB { set; private get; }
|
|
|
|
public IEntityFactory Factory { get; set; }
|
|
|
|
public bool isRemovable => false;
|
|
|
|
public bool IsInGame = false;
|
|
|
|
public void Dispose()
|
|
{
|
|
IsInGame = false;
|
|
}
|
|
|
|
public void Ready()
|
|
{
|
|
IsInGame = true;
|
|
}
|
|
|
|
// implementations for block wiring
|
|
|
|
public WireEntityStruct CreateNewWire(EGID startBlock, byte startPort, EGID endBlock, byte endPort)
|
|
{
|
|
EGID wireEGID = new EGID(WiresExclusiveGroups.NewWireEntityId, NamedExclusiveGroup<WiresGroup>.Group);
|
|
EntityInitializer wireInitializer = Factory.BuildEntity<WireEntityDescriptor>(wireEGID);
|
|
wireInitializer.Init(new WireEntityStruct
|
|
{
|
|
sourceBlockEGID = startBlock,
|
|
sourcePortUsage = startPort,
|
|
destinationBlockEGID = endBlock,
|
|
destinationPortUsage = endPort,
|
|
ID = wireEGID
|
|
});
|
|
return wireInitializer.Get<WireEntityStruct>();
|
|
}
|
|
|
|
public ref WireEntityStruct GetWire(EGID wire)
|
|
{
|
|
if (!entitiesDB.Exists<WireEntityStruct>(wire))
|
|
{
|
|
throw new WiringException($"Wire {wire} does not exist");
|
|
}
|
|
return ref entitiesDB.QueryEntity<WireEntityStruct>(wire);
|
|
}
|
|
|
|
public ref PortEntityStruct GetPort(EGID port)
|
|
{
|
|
if (!entitiesDB.Exists<PortEntityStruct>(port))
|
|
{
|
|
throw new WiringException($"Port {port} does not exist (yet?)");
|
|
}
|
|
return ref entitiesDB.QueryEntity<PortEntityStruct>(port);
|
|
}
|
|
|
|
public ref PortEntityStruct GetPortByOffset(BlockPortsStruct bps, byte portNumber, bool input)
|
|
{
|
|
ExclusiveGroup group = input
|
|
? NamedExclusiveGroup<InputPortsGroup>.Group
|
|
: NamedExclusiveGroup<OutputPortsGroup>.Group;
|
|
uint id = (input ? bps.firstInputID : bps.firstOutputID) + portNumber;
|
|
EGID egid = new EGID(id, group);
|
|
if (!entitiesDB.Exists<PortEntityStruct>(egid))
|
|
{
|
|
throw new WiringException("Port does not exist");
|
|
}
|
|
return ref entitiesDB.QueryEntity<PortEntityStruct>(egid);
|
|
}
|
|
|
|
public ref PortEntityStruct GetPortByOffset(Block block, byte portNumber, bool input)
|
|
{
|
|
var bps = entitiesDB.QueryEntityOptional<BlockPortsStruct>(block);
|
|
if (!bps)
|
|
{
|
|
throw new BlockException("Block does not exist");
|
|
}
|
|
return ref GetPortByOffset(bps, portNumber, input);
|
|
}
|
|
|
|
public ref T GetComponent<T>(EGID egid) where T : unmanaged, IEntityComponent
|
|
{
|
|
return ref entitiesDB.QueryEntity<T>(egid);
|
|
}
|
|
|
|
public bool Exists<T>(EGID egid) where T : struct, IEntityComponent
|
|
{
|
|
return entitiesDB.Exists<T>(egid);
|
|
}
|
|
|
|
public bool SetSignal(EGID blockID, float signal, out uint signalID, bool input = true)
|
|
{
|
|
signalID = GetSignalIDs(blockID, input)[0];
|
|
return SetSignal(signalID, signal);
|
|
}
|
|
|
|
public bool SetSignal(uint signalID, float signal, bool input = true)
|
|
{
|
|
var array = GetSignalStruct(signalID, out uint index, input);
|
|
var arrayB = array.ToBuffer();
|
|
if (array.count > 0) arrayB.buffer[index].valueAsFloat = signal;
|
|
return false;
|
|
}
|
|
|
|
public float AddSignal(EGID blockID, float signal, out uint signalID, bool clamp = true, bool input = true)
|
|
{
|
|
signalID = GetSignalIDs(blockID, input)[0];
|
|
return AddSignal(signalID, signal, clamp, input);
|
|
}
|
|
|
|
public float AddSignal(uint signalID, float signal, bool clamp = true, bool input = true)
|
|
{
|
|
var array = GetSignalStruct(signalID, out uint index, input);
|
|
var arrayB = array.ToBuffer();
|
|
if (array.count > 0)
|
|
{
|
|
ref var channelData = ref arrayB.buffer[index];
|
|
channelData.valueAsFloat += signal;
|
|
if (clamp)
|
|
{
|
|
if (channelData.valueAsFloat > POSITIVE_HIGH)
|
|
{
|
|
channelData.valueAsFloat = POSITIVE_HIGH;
|
|
}
|
|
else if (channelData.valueAsFloat < NEGATIVE_HIGH)
|
|
{
|
|
channelData.valueAsFloat = NEGATIVE_HIGH;
|
|
}
|
|
|
|
return channelData.valueAsFloat;
|
|
}
|
|
}
|
|
|
|
return signal;
|
|
}
|
|
|
|
public float GetSignal(EGID blockID, out uint signalID, bool input = true)
|
|
{
|
|
signalID = GetSignalIDs(blockID, input)[0];
|
|
return GetSignal(signalID, input);
|
|
}
|
|
|
|
public float GetSignal(uint signalID, bool input = true)
|
|
{
|
|
var array = GetSignalStruct(signalID, out uint index, input);
|
|
var arrayB = array.ToBuffer();
|
|
return array.count > 0 ? arrayB.buffer[index].valueAsFloat : 0f;
|
|
}
|
|
|
|
public uint[] GetSignalIDs(EGID blockID, bool input = true)
|
|
{
|
|
ref BlockPortsStruct bps = ref entitiesDB.QueryEntity<BlockPortsStruct>(blockID);
|
|
uint[] signals;
|
|
if (input) {
|
|
signals = new uint[bps.inputCount];
|
|
for (uint i = 0u; i < bps.inputCount; i++)
|
|
{
|
|
signals[i] = bps.firstInputID + i;
|
|
}
|
|
} else {
|
|
signals = new uint[bps.outputCount];
|
|
for (uint i = 0u; i < bps.outputCount; i++)
|
|
{
|
|
signals[i] = bps.firstOutputID + i;
|
|
}
|
|
}
|
|
return signals;
|
|
}
|
|
|
|
public EGID[] GetSignalInputs(EGID blockID)
|
|
{
|
|
BlockPortsStruct ports = entitiesDB.QueryEntity<BlockPortsStruct>(blockID);
|
|
EGID[] inputs = new EGID[ports.inputCount];
|
|
for (uint i = 0; i < ports.inputCount; i++)
|
|
{
|
|
inputs[i] = new EGID(i + ports.firstInputID, NamedExclusiveGroup<InputPortsGroup>.Group);
|
|
}
|
|
return inputs;
|
|
}
|
|
|
|
public EGID[] GetSignalOutputs(EGID blockID)
|
|
{
|
|
BlockPortsStruct ports = entitiesDB.QueryEntity<BlockPortsStruct>(blockID);
|
|
EGID[] outputs = new EGID[ports.outputCount];
|
|
for (uint i = 0; i < ports.outputCount; i++)
|
|
{
|
|
outputs[i] = new EGID(i + ports.firstOutputID, NamedExclusiveGroup<OutputPortsGroup>.Group);
|
|
}
|
|
return outputs;
|
|
}
|
|
|
|
public OptionalRef<PortEntityStruct> MatchBlockIOToPort(Block block, byte portUsage, bool output)
|
|
{
|
|
return MatchBlockIOToPort(block.Id, portUsage, output);
|
|
}
|
|
|
|
public OptionalRef<PortEntityStruct> MatchBlockIOToPort(EGID block, byte portUsage, bool output)
|
|
{
|
|
if (!entitiesDB.Exists<BlockPortsStruct>(block))
|
|
return default;
|
|
var group = output
|
|
? NamedExclusiveGroup<OutputPortsGroup>.Group
|
|
: NamedExclusiveGroup<InputPortsGroup>.Group;
|
|
BlockPortsStruct ports = entitiesDB.QueryEntity<BlockPortsStruct>(block);
|
|
if (!entitiesDB.TryQueryMappedEntities<PortEntityStruct>(group, out var mapper))
|
|
return default;
|
|
for (uint i = 0; i < (output ? ports.outputCount : ports.inputCount); ++i)
|
|
{
|
|
uint entityID = (output ? ports.firstOutputID : ports.firstInputID) + i;
|
|
if (!mapper.TryGetArrayAndEntityIndex(entityID, out var index, out var array) ||
|
|
array[index].usage != portUsage) continue;
|
|
return new OptionalRef<PortEntityStruct>(array, index);
|
|
}
|
|
|
|
return default;
|
|
}
|
|
|
|
public ref WireEntityStruct MatchPortToWire(PortEntityStruct port, EGID blockID, out bool exists)
|
|
{
|
|
var wires = entitiesDB.QueryEntities<WireEntityStruct>(NamedExclusiveGroup<WiresGroup>.Group);
|
|
var wiresB = wires.ToBuffer().buffer;
|
|
for (uint i = 0; i < wires.count; i++)
|
|
{
|
|
if ((wiresB[i].destinationPortUsage == port.usage && wiresB[i].destinationBlockEGID == blockID)
|
|
|| (wiresB[i].sourcePortUsage == port.usage && wiresB[i].sourceBlockEGID == blockID))
|
|
{
|
|
exists = true;
|
|
return ref wiresB[i];
|
|
}
|
|
}
|
|
exists = false;
|
|
WireEntityStruct[] defRef = new WireEntityStruct[1];
|
|
return ref defRef[0];
|
|
}
|
|
|
|
public EGID MatchBlocksToWire(EGID startBlock, EGID endBlock, byte startPort = byte.MaxValue, byte endPort = byte.MaxValue)
|
|
{
|
|
EGID[] startPorts;
|
|
if (startPort == byte.MaxValue)
|
|
{
|
|
// search all output ports on source block
|
|
startPorts = GetSignalOutputs(startBlock);
|
|
}
|
|
else
|
|
{
|
|
BlockPortsStruct ports = entitiesDB.QueryEntity<BlockPortsStruct>(startBlock);
|
|
startPorts = new EGID[] {new EGID(ports.firstOutputID + startPort, NamedExclusiveGroup<OutputPortsGroup>.Group) };
|
|
}
|
|
|
|
EGID[] endPorts;
|
|
if (startPort == byte.MaxValue)
|
|
{
|
|
// search all input ports on destination block
|
|
endPorts = GetSignalInputs(endBlock);
|
|
}
|
|
else
|
|
{
|
|
BlockPortsStruct ports = entitiesDB.QueryEntity<BlockPortsStruct>(endBlock);
|
|
endPorts = new EGID[] {new EGID(ports.firstInputID + endPort, NamedExclusiveGroup<InputPortsGroup>.Group) };
|
|
}
|
|
|
|
EntityCollection<WireEntityStruct> wires = entitiesDB.QueryEntities<WireEntityStruct>(NamedExclusiveGroup<WiresGroup>.Group);
|
|
var wiresB = wires.ToBuffer().buffer;
|
|
for (int endIndex = 0; endIndex < endPorts.Length; endIndex++)
|
|
{
|
|
PortEntityStruct endPES = entitiesDB.QueryEntity<PortEntityStruct>(endPorts[endIndex]);
|
|
for (int startIndex = 0; startIndex < startPorts.Length; startIndex++)
|
|
{
|
|
PortEntityStruct startPES = entitiesDB.QueryEntity<PortEntityStruct>(startPorts[startIndex]);
|
|
for (int w = 0; w < wires.count; w++)
|
|
{
|
|
if ((wiresB[w].destinationPortUsage == endPES.usage && wiresB[w].destinationBlockEGID == endBlock)
|
|
&& (wiresB[w].sourcePortUsage == startPES.usage && wiresB[w].sourceBlockEGID == startBlock))
|
|
{
|
|
return wiresB[w].ID;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return default;
|
|
}
|
|
|
|
public OptionalRef<ChannelDataStruct> GetChannelDataStruct(EGID portID)
|
|
{
|
|
var port = GetPort(portID);
|
|
var channels = entitiesDB.QueryEntities<ChannelDataStruct>(NamedExclusiveGroup<ChannelDataGroup>.Group);
|
|
var channelsB = channels.ToBuffer();
|
|
return port.firstChannelIndexCachedInSim < channels.count
|
|
? new OptionalRef<ChannelDataStruct>(channelsB.buffer, port.firstChannelIndexCachedInSim)
|
|
: default;
|
|
}
|
|
|
|
public EGID[] GetElectricBlocks()
|
|
{
|
|
var res = new FasterList<EGID>();
|
|
foreach (var (coll, _) in entitiesDB.QueryEntities<BlockPortsStruct>())
|
|
{
|
|
var collB = coll.ToBuffer();
|
|
for (int i = 0; i < coll.count; i++)
|
|
{
|
|
ref BlockPortsStruct s = ref collB.buffer[i];
|
|
res.Add(s.ID);
|
|
}
|
|
}
|
|
|
|
return res.ToArray();
|
|
}
|
|
|
|
public EGID[] WiredToInput(EGID block, byte port)
|
|
{
|
|
WireEntityStruct[] wireEntityStructs = Search(NamedExclusiveGroup<WiresGroup>.Group,
|
|
(WireEntityStruct wes) => wes.destinationPortUsage == port && wes.destinationBlockEGID == block);
|
|
EGID[] result = new EGID[wireEntityStructs.Length];
|
|
for (uint i = 0; i < wireEntityStructs.Length; i++)
|
|
{
|
|
result[i] = wireEntityStructs[i].ID;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
public EGID[] WiredToOutput(EGID block, byte port)
|
|
{
|
|
WireEntityStruct[] wireEntityStructs = Search(NamedExclusiveGroup<WiresGroup>.Group,
|
|
(WireEntityStruct wes) => wes.sourcePortUsage == port && wes.sourceBlockEGID == block);
|
|
EGID[] result = new EGID[wireEntityStructs.Length];
|
|
for (uint i = 0; i < wireEntityStructs.Length; i++)
|
|
{
|
|
result[i] = wireEntityStructs[i].ID;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private T[] Search<T>(ExclusiveGroup group, Func<T, bool> isMatch) where T : unmanaged, IEntityComponent
|
|
{
|
|
FasterList<T> results = new FasterList<T>();
|
|
EntityCollection<T> components = entitiesDB.QueryEntities<T>(group);
|
|
var componentsB = components.ToBuffer();
|
|
for (uint i = 0; i < components.count; i++)
|
|
{
|
|
if (isMatch(componentsB.buffer[i]))
|
|
{
|
|
results.Add(componentsB.buffer[i]);
|
|
}
|
|
}
|
|
return results.ToArray();
|
|
}
|
|
|
|
private EntityCollection<ChannelDataStruct> GetSignalStruct(uint signalID, out uint index, bool input = true)
|
|
{
|
|
ExclusiveGroup group = input
|
|
? NamedExclusiveGroup<InputPortsGroup>.Group
|
|
: NamedExclusiveGroup<OutputPortsGroup>.Group;
|
|
if (entitiesDB.Exists<PortEntityStruct>(signalID, group))
|
|
{
|
|
index = entitiesDB.QueryEntity<PortEntityStruct>(signalID, group).anyChannelIndex;
|
|
var channelData =
|
|
entitiesDB.QueryEntities<ChannelDataStruct>(NamedExclusiveGroup<ChannelDataGroup>.Group);
|
|
return channelData;
|
|
}
|
|
|
|
index = 0;
|
|
return default; //count: 0
|
|
}
|
|
}
|
|
}
|