// TODO Add documentation, clean up, remove commented out code, etc.
public static float WorkOutAtResistance(ElectronicSupplyData ResistanceSources, IntrinsicElectronicData Indata)
{
float Resistanc = 0;
if (Indata == null)
{
return(Resistanc);
}
bool goingToExists = ResistanceSources.ResistanceGoingTo.TryGetValue(Indata, out VIRResistances goingTo);
bool comingFromExists = ResistanceSources.ResistanceComingFrom.TryGetValue(Indata, out VIRResistances comingFrom);
if (goingToExists && comingFromExists)
{
HashSet <ResistanceWrap> ResistanceSour = new HashSet <ResistanceWrap>(comingFrom.ResistanceSources);
//ResistanceSour.UnionWith(ResistanceSources.ResistanceComingFrom[Indata].ResistanceSources);
//HashSet<ResistanceWrap> ResistanceSour = new HashSet<ResistanceWrap>(ResistanceSources.ResistanceGoingTo[Indata].ResistanceSources);
//ResistanceSourtoreove.UnionWith(ResistanceSources.ResistanceGoingTo[Indata].ResistanceSources);
//ResistanceSour.ExceptWith(ResistanceSourtoreove);
float Toadd = 0;
float ToRemove = 0;
foreach (var Resistance in ResistanceSour)
{
if (goingTo.ResistanceSources.Contains(Resistance))
{
Toadd = 1 / Resistance.Resistance();
}
//else {
// ToRemove = 1 / Resistance.Resistance();
//}
}
if (Toadd != 0)
{
Toadd = 1 / Toadd;
}
Resistanc = Toadd - ToRemove;
}
else
{
if (comingFromExists)
{
Resistanc = comingFrom.Resistance();
}
else if (goingToExists)
{
Resistanc = goingTo.Resistance();
}
}
return(Resistanc);
}
public static void FlushConnectionAndUp(IntrinsicElectronicData Object)
{
Object.Data.CurrentInWire = 0;
Object.Data.ActualVoltage = 0;
Object.Data.ResistanceToConnectedDevices.Clear();
//Object.connectedDevices.Clear();//#
if (Object.Data.connections.Count > 0)
{
List <IntrinsicElectronicData> Backupconnections = new List <IntrinsicElectronicData>(Object.Data.connections); //GC
Object.Data.connections.Clear();
foreach (IntrinsicElectronicData JumpTo in Backupconnections)
{
JumpTo.FlushConnectionAndUp();
}
}
foreach (KeyValuePair <ElectricalOIinheritance, ElectronicSupplyData> Supply in Object.Data.SupplyDependent)
{
Pool(Supply.Value.CurrentGoingTo);
Pool(Supply.Value.CurrentComingFrom);
Pool(Supply.Value.ResistanceGoingTo);
Pool(Supply.Value.ResistanceComingFrom);
Supply.Value.Upstream.Clear();
Supply.Value.Downstream.Clear();
Supply.Value.SourceVoltage = 0;
}
}
public static void ElectricityInput(VIRCurrent Current,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom,
IntrinsicElectronicData Thiswire)
{
//Logger.Log("ElectricityInput" + Thiswire + " ComingFrom > " + ComingFrom);
//Logger.Log("5 > " + Current + " Categorytype > " + Thiswire.Categorytype + " ComingFrom > " + ComingFrom.Categorytype);
//Logger.Log("poke > " + SourceInstance.InData.Data.SupplyDependent[SourceInstance].ToString());
if (!Thiswire.Data.SupplyDependent[SourceInstance].CurrentComingFrom.ContainsKey(ComingFrom))
{
Thiswire.Data.SupplyDependent[SourceInstance].CurrentComingFrom[ComingFrom] = Current;
}
else
{
//Logger.Log("AADD");
Thiswire.Data.SupplyDependent[SourceInstance].CurrentComingFrom[ComingFrom].addCurrent(Current);
}
if (!(Thiswire.Data.SupplyDependent[SourceInstance].ResistanceComingFrom.Count > 0))
{
var sync = ElectricalManager.Instance.electricalSync;
sync.StructureChange = true;
sync.NUStructureChangeReact.Add(Thiswire.ControllingDevice);
sync.NUResistanceChange.Add(Thiswire.ControllingDevice);
sync.NUCurrentChange.Add(Thiswire.ControllingDevice);
Logger.LogErrorFormat("Resistance isn't initialised on", Category.Electrical);
return;
}
Thiswire.Data.SupplyDependent[SourceInstance].SourceVoltage = (float)Current.Current() * (ElectricityFunctions.WorkOutResistance(Thiswire.Data.SupplyDependent[SourceInstance].ResistanceComingFrom));
//ELCurrent.CurrentWorkOnNextListADD(Thiswire);
Thiswire.ElectricityOutput(Current, SourceInstance);
}
/// <summary>
/// <para>Replaces, builds a new electrical connection, and consumes
/// cables from the hand.</para>
/// <para>Destroys the electrical connection (if we're given one) and
/// then adds a new electrical connection by adding an electrical
/// node. We then calculate and consume a number of cables from the
/// hand.</para>
/// </summary>
/// <param name="position">Position of the electrical connection.</param>
/// <param name="eConn">Electrical connection we're replacing.</param>
/// <param name="wireEndA">Connection direction of one end.</param>
/// <param name="wireEndB">Connection direction of the other end.</param>
private void ReplaceEConn(Vector3 position, IntrinsicElectronicData eConn, Connection wireEndA,
Connection wireEndB, ConnectionApply interaction)
{
// Cost of cable coils to construct the original cable tile. Assume
// 0 until we verify whether or not we are given an electrical
// connection.
int oldTileCost = 0;
// Get the cost of the old tile. Then destroy the current
// electrical connection only if we were given a connection.
if (eConn != null)
{
oldTileCost = eConn.MetaDataPresent.RelatedTile.SpawnAmountOnDeconstruct;
eConn.DestroyThisPlease();
}
// Get the electrical cable tile with the wire connection direction.
ElectricalCableTile tile =
ElectricityFunctions.RetrieveElectricalTile(wireEndA, wireEndB, powerTypeCategory);
// Then, add an electrical node at the tile.
interaction.Performer.GetComponentInParent <Matrix>().AddElectricalNode(position.RoundToInt(), tile, true);
// We only want to consume the difference needed to build the new
// cable.
int newTileCost = tile.SpawnAmountOnDeconstruct;
int finalCost = newTileCost - oldTileCost;
// Finally, consume the cables in the hands using the final cost
// we found.
Inventory.ServerConsume(interaction.HandSlot, finalCost);
}
public static void DirectionOutput(ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData Thiswire,
CableLine RelatedLine = null)
{
if (Thiswire.Data.connections.Count == 0)
{
Thiswire.FindPossibleConnections();
}
if (!(Thiswire.Data.SupplyDependent.TryGetValue(SourceInstance, out ElectronicSupplyData outputSupplyingUsingData)))
{
outputSupplyingUsingData = Thiswire.Data.SupplyDependent[SourceInstance] = ElectricalPool.GetElectronicSupplyData();
}
foreach (IntrinsicElectronicData Relatedindata in Thiswire.Data.connections)
{
if (!(outputSupplyingUsingData.Upstream.Contains(Relatedindata)) && (!(Thiswire == Relatedindata)))
{
bool pass = true;
if (RelatedLine != null)
{
if (RelatedLine.Covering.Contains(Relatedindata))
{
pass = false;
}
}
if (!(outputSupplyingUsingData.Downstream.Contains(Relatedindata)) && pass)
{
outputSupplyingUsingData.Downstream.Add(Relatedindata);
Relatedindata.DirectionInput(SourceInstance, Thiswire);
}
}
}
}
public static void ElectricityOutput(VIRCurrent Current,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData Thiswire)
{
//Logger.Log("4 > " + Current);
//Logger.Log("poke > " + SourceInstance.InData.Data.SupplyDependent[SourceInstance].ToString());
var OutputSupplyingUsingData = Thiswire.Data.SupplyDependent[SourceInstance];
VIRCurrent SupplyingCurrent = null;
float Divider = (ElectricityFunctions.WorkOutResistance(OutputSupplyingUsingData.ResistanceComingFrom));
foreach (KeyValuePair <IntrinsicElectronicData, VIRResistances> JumpTo in OutputSupplyingUsingData
.ResistanceComingFrom)
{
if (OutputSupplyingUsingData.ResistanceComingFrom.Count > 1)
{
SupplyingCurrent = Current.SplitCurrent(Divider / JumpTo.Value.Resistance());
}
else
{
SupplyingCurrent = Current;
}
OutputSupplyingUsingData.CurrentGoingTo[JumpTo.Key] = SupplyingCurrent;
if (JumpTo.Key != null && JumpTo.Key.Categorytype != PowerTypeCategory.DeadEndConnection)
{
JumpTo.Key.ElectricityInput(SupplyingCurrent, SourceInstance, Thiswire);
}
}
}
///// <summary>
///// Sets the upstream
///// </summary>
public virtual void DirectionInput(ElectricalOIinheritance SourceInstance, IntrinsicElectronicData ComingFrom, CableLine PassOn = null)
{
if (Logall)
{
Logger.Log("this > " + this + "DirectionInput SourceInstance > " + SourceInstance + " ComingFrom > " + ComingFrom + " PassOn > " + PassOn, Category.Electrical);
}
InputOutputFunctions.DirectionInput(SourceInstance, ComingFrom, InData);
}
public static void RemoveSupply(IntrinsicElectronicData Object, ElectricalOIinheritance SourceInstance = null)
{
if (SourceInstance == null)
{
bool pass = false;
foreach (var Supply in Object.Data.SupplyDependent)
{
if (Supply.Value.Downstream.Count > 0 || Supply.Value.Upstream.Count > 0)
{
pass = true;
}
}
if (pass)
{
Pool(Object.Data.SupplyDependent);
foreach (IntrinsicElectronicData JumpTo in Object.Data.connections)
{
JumpTo.RemoveSupply();
}
Object.Data.CurrentInWire = 0;
Object.Data.ActualVoltage = 0;
Object.Data.EstimatedResistance = 0;
Object.Data.ResistanceToConnectedDevices.Clear();
//Object.connectedDevices.Clear();#
}
}
else
{
//SourceInstance
bool pass = false;
if (Object.Data.SupplyDependent.ContainsKey(SourceInstance))
{
if (Object.Data.SupplyDependent[SourceInstance].Downstream.Count > 0 ||
Object.Data.SupplyDependent[SourceInstance].Upstream.Count > 0)
{
pass = true;
}
Object.Data.SupplyDependent[SourceInstance].Pool();
Object.Data.SupplyDependent.Remove(SourceInstance);
}
if (SourceInstance == Object.Present)
{
CleanConnectedDevicesFromPower(Object.Present);
Object.Data.ResistanceToConnectedDevices.Clear();
}
if (pass)
{
foreach (IntrinsicElectronicData JumpTo in Object.Data.connections)
{
JumpTo.RemoveSupply(SourceInstance);
}
}
}
}
public static void DirectionInput(ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom,
IntrinsicElectronicData Thiswire)
{
//Logger.Log(Thiswire.Categorytype + "DirectionInput");
if (Thiswire.Data.connections.Count == 0)
{
Thiswire.FindPossibleConnections(); //plz don't remove it is necessary for preventing incomplete cleanups when there has been multiple
}
if (!(Thiswire.Data.SupplyDependent.ContainsKey(SourceInstance)))
{
Thiswire.Data.SupplyDependent[SourceInstance] = ElectricalPool.GetElectronicSupplyData();
}
if (ComingFrom != null)
{
Thiswire.Data.SupplyDependent[SourceInstance].Upstream.Add(ComingFrom);
}
if (Thiswire.ConnectionReaction.ContainsKey(ComingFrom.Categorytype))
{
var Reaction = Thiswire.ConnectionReaction[ComingFrom.Categorytype];
if (Reaction.DirectionReaction || Reaction.ResistanceReaction)
{
if (SourceInstance != null)
{
if (!Thiswire.Data.ResistanceToConnectedDevices.ContainsKey(SourceInstance))
{
Thiswire.Data.ResistanceToConnectedDevices[SourceInstance] = new Dictionary <Resistance, HashSet <IntrinsicElectronicData> >();
}
if (!Thiswire.Data.ResistanceToConnectedDevices[SourceInstance].ContainsKey(Reaction.ResistanceReactionA.Resistance))
{
Thiswire.Data.ResistanceToConnectedDevices[SourceInstance][Reaction.ResistanceReactionA.Resistance]
= new HashSet <IntrinsicElectronicData>();
}
Thiswire.Data.ResistanceToConnectedDevices[SourceInstance][Reaction.ResistanceReactionA.Resistance]
.Add(ComingFrom);
SourceInstance.connectedDevices.Add(Thiswire);
ElectricalManager.Instance.electricalSync.InitialiseResistanceChange.Add(Thiswire.ControllingDevice);
}
if (Thiswire.ConnectionReaction[ComingFrom.Categorytype].DirectionReactionA.YouShallNotPass)
{
return;
}
}
}
if (Thiswire.Data.connections.Count > 2)
{
ElectricalManager.Instance.electricalSync.DirectionWorkOnNextListWaitADD(Thiswire);
}
else
{
ElectricalManager.Instance.electricalSync.DirectionWorkOnNextListADD(Thiswire);
}
}
public void SetUp(IntrinsicElectronicData indata)
{
Categorytype = indata.Categorytype;
ConnectionReaction = indata.ConnectionReaction;
Present = indata.Present;
MetaDataPresent = indata.MetaDataPresent;
CanConnectTo = indata.CanConnectTo;
WireEndB = indata.WireEndB;
WireEndA = indata.WireEndA;
}
public void Initialise(WireConnect DataToTake, MetaDataNode metaDataNode, Vector3Int searchVec, Matrix locatedon)
{
IsOn = metaDataNode;
InData = new IntrinsicElectronicData();
InData.SetUp(DataToTake.InData);
NodeLocation = searchVec;
Locatedon = locatedon;
InData.MetaDataPresent = this;
InData.Present = null;
}
public static void DirectionInput(ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom,
IntrinsicElectronicData Thiswire)
{
if (Thiswire.Data.connections.Count == 0)
{
Thiswire.FindPossibleConnections(); //plz don't remove it is necessary for preventing incomplete cleanups when there has been multiple
}
if (!Thiswire.Data.SupplyDependent.TryGetValue(SourceInstance, out ElectronicSupplyData supplyDep))
{
supplyDep = Thiswire.Data.SupplyDependent[SourceInstance] = ElectricalPool.GetElectronicSupplyData();
}
if (ComingFrom != null)
{
supplyDep.Upstream.Add(ComingFrom);
}
if (Thiswire.ConnectionReaction.TryGetValue(ComingFrom.Categorytype, out PowerInputReactions reaction))
{
if (reaction.DirectionReaction || reaction.ResistanceReaction)
{
if (SourceInstance != null)
{
if (!Thiswire.Data.ResistanceToConnectedDevices.TryGetValue(SourceInstance, out var resToConDev))
{
resToConDev = Thiswire.Data.ResistanceToConnectedDevices[SourceInstance] = new Dictionary <Resistance, HashSet <IntrinsicElectronicData> >();
}
if (!resToConDev.TryGetValue(reaction.ResistanceReactionA.Resistance, out HashSet <IntrinsicElectronicData> resToConDevHash))
{
resToConDevHash = resToConDev[reaction.ResistanceReactionA.Resistance] = new HashSet <IntrinsicElectronicData>();
}
resToConDevHash.Add(ComingFrom);
SourceInstance.connectedDevices.Add(Thiswire);
ElectricalManager.Instance.electricalSync.InitialiseResistanceChange.Add(Thiswire.ControllingDevice);
}
if (reaction.DirectionReactionA.YouShallNotPass)
{
return;
}
}
}
if (Thiswire.Data.connections.Count > 2)
{
ElectricalManager.Instance.electricalSync.DirectionWorkOnNextListWaitADD(Thiswire);
}
else
{
ElectricalManager.Instance.electricalSync.DirectionWorkOnNextListADD(Thiswire);
}
}
public static (float, float, float) WorkOutActualNumbers(IntrinsicElectronicData ElectricItem)
{
//Sometimes gives wrong readings at junctions, Needs to be looked into
float Current = 0; //Calculates the actual voltage and current flowing through the Node
float Voltage = 0;
AnInterestingDictionary.Clear();
//Voltages easy to work out just add up all the voltages from different sources
foreach (var Supply in ElectricItem.Data.SupplyDependent)
{
Voltage += Supply.Value.SourceVoltage;
}
foreach (var CurrentIDItem in ElectricItem.Data.SupplyDependent)
{
foreach (var CurrentItem in CurrentIDItem.Value.CurrentComingFrom)
{
if (AnInterestingDictionary.ContainsKey(CurrentItem.Key))
{
AnInterestingDictionary[CurrentItem.Key] += (float)CurrentItem.Value.Current();
}
else
{
AnInterestingDictionary[CurrentItem.Key] = (float)CurrentItem.Value.Current();
}
}
foreach (var CurrentItem in CurrentIDItem.Value.CurrentGoingTo)
{
if (AnInterestingDictionary.ContainsKey(CurrentItem.Key))
{
AnInterestingDictionary[CurrentItem.Key] += (float)-CurrentItem.Value.Current();
}
else
{
AnInterestingDictionary[CurrentItem.Key] = (float)-CurrentItem.Value.Current();
}
}
}
foreach (var CurrentItem in AnInterestingDictionary)
{
if (CurrentItem.Value > 0)
{
Current += CurrentItem.Value;
}
}
//Logger.Log (Voltage.ToString () + " < yeah Those voltage " + Current.ToString() + " < yeah Those Current " + (Voltage/Current).ToString() + " < yeah Those Resistance" + ElectricItem.GameObject().name.ToString() + " < at", Category.Electrical);
ElectricItem.Data.CurrentInWire = Current;
ElectricItem.Data.ActualVoltage = Voltage;
ElectricItem.Data.EstimatedResistance = (Voltage / Current);
return(Current, Voltage, (Voltage / Current));
}
// TODO Add documentation, clean up, remove commented out code, etc.
public static float WorkOutAtResistance(ElectronicSupplyData ResistanceSources, IntrinsicElectronicData Indata)
{
float Resistanc = 0;
if (Indata != null && ResistanceSources.ResistanceGoingTo.ContainsKey(Indata) &&
ResistanceSources.ResistanceComingFrom.ContainsKey(Indata))
{
HashSet <ResistanceWrap> ResistanceSour =
new HashSet <ResistanceWrap>(ResistanceSources.ResistanceComingFrom[Indata].ResistanceSources);
//ResistanceSour.UnionWith(ResistanceSources.ResistanceComingFrom[Indata].ResistanceSources);
//HashSet<ResistanceWrap> ResistanceSour = new HashSet<ResistanceWrap>(ResistanceSources.ResistanceGoingTo[Indata].ResistanceSources);
//ResistanceSourtoreove.UnionWith(ResistanceSources.ResistanceGoingTo[Indata].ResistanceSources);
//ResistanceSour.ExceptWith(ResistanceSourtoreove);
float Toadd = 0;
float ToRemove = 0;
foreach (var Resistance in ResistanceSour)
{
if (ResistanceSources.ResistanceGoingTo[Indata].ResistanceSources.Contains(Resistance))
{
Toadd = 1 / Resistance.Resistance();
}
//else {
// ToRemove = 1 / Resistance.Resistance();
//}
}
if (Toadd != 0)
{
Toadd = 1 / Toadd;
}
Resistanc = Toadd - ToRemove;
}
else
{
if (ResistanceSources.ResistanceComingFrom.ContainsKey(Indata))
{
Resistanc = ResistanceSources.ResistanceComingFrom[Indata].Resistance();
}
else if (ResistanceSources.ResistanceGoingTo.ContainsKey(Indata))
{
Resistanc = ResistanceSources.ResistanceGoingTo[Indata].Resistance();
}
}
//Logger.Log((1 / ResistanceXAll)+ "< Return");
return(Resistanc);
}
/// <summary>
/// Sets the upstream
/// </summary>
public virtual void DirectionInput(ElectricalOIinheritance SourceInstance, IntrinsicElectronicData ComingFrom, CableLine PassOn = null)
{
if (Present != null)
{
Present.DirectionInput(SourceInstance, ComingFrom);
}
else
{
InputOutputFunctions.DirectionInput(SourceInstance, ComingFrom, this);
}
}
public static void FindPossibleConnections(Matrix matrix,
HashSet <PowerTypeCategory> CanConnectTo,
ConnPoint ConnPoints,
IntrinsicElectronicData OIinheritance,
HashSet <IntrinsicElectronicData> InPutHashSet)
{
Vector2 searchVec = OIinheritance.GetLocation();
SwitchCaseConnections(searchVec, matrix, CanConnectTo, ConnPoints.pointA, OIinheritance, InPutHashSet);
SwitchCaseConnections(searchVec, matrix, CanConnectTo, ConnPoints.pointB, OIinheritance, InPutHashSet);
}
public void DirectionWorkOnNextListWaitADD(IntrinsicElectronicData Thiswire)
{
if (UesAlternativeDirectionWorkOnNextList)
{
_DirectionWorkOnNextListWait.Add(Thiswire);
}
else
{
DirectionWorkOnNextListWait.Add(Thiswire);
}
}
//What is the purpose of inline device, It is to modify current, resistance going over the device E.G a Transformer For any other device that can be thought of
public override void ResistanceInput(ResistanceWrap Resistance,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom)
{
Resistance = InData.ControllingDevice.ModifyResistanceInput(Resistance, SourceInstance, ComingFrom);
if (Logall)
{
Logger.Log("this > " + this + "ResistanceInput, Resistance > " + Resistance + " SourceInstance > " + SourceInstance + " ComingFrom > " + ComingFrom, Category.Electrical);
}
InputOutputFunctions.ResistanceInput(Resistance, SourceInstance, ComingFrom, InData);
}
public override void ElectricityInput(VIRCurrent Current,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom)
{
Current = InData.ControllingDevice.ModifyElectricityInput(Current, SourceInstance, ComingFrom);
if (Logall)
{
Logger.Log("this > " + this + "ElectricityInput, Current > " + Current + " SourceInstance > " + SourceInstance + " ComingFrom > " + ComingFrom, Category.Electrical);
}
InputOutputFunctions.ElectricityInput(Current, SourceInstance, ComingFrom, InData);
}
public void Initialise(ElectricalCableTile DataToTake, MetaDataNode metaDataNode, Vector3Int searchVec, Matrix locatedon)
{
RelatedTile = DataToTake;
IsOn = metaDataNode;
InData = new IntrinsicElectronicData();
InData.SetUp(DataToTake);
InData.MetaDataPresent = this;
NodeLocation = searchVec;
Locatedon = locatedon;
InData.MetaDataPresent = this;
InData.Present = null;
}
/// <summary>
/// Inputs a current from a device, with the supply
/// </summary>
public virtual void ElectricityInput(VIRCurrent Current,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom)
{
if (Logall)
{
Logger.Log("this > " + this
+ "ElectricityInput, Current > " + Current
+ " SourceInstance > " + SourceInstance
+ " ComingFrom > " + ComingFrom, Category.Electrical);
}
InputOutputFunctions.ElectricityInput(Current, SourceInstance, ComingFrom, InData);
}
/// <summary>
/// Pass resistance with GameObject of the Machine it is heading toward
/// </summary>
public virtual void ResistanceInput(ResistanceWrap Resistance,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom)
{
if (Logall)
{
Logger.Log("this > " + this
+ "ResistanceInput, Resistance > " + Resistance
+ " SourceInstance > " + SourceInstance
+ " ComingFrom > " + ComingFrom, Category.Electrical);
}
InputOutputFunctions.ResistanceInput(Resistance, SourceInstance, ComingFrom, InData);
}
/// <summary>
/// Inputs a current from a device, with the supply
/// </summary>
public virtual void ElectricityInput(VIRCurrent Current,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom)
{
if (Present != null)
{
Present.ElectricityInput(Current, SourceInstance, ComingFrom);
}
else
{
InputOutputFunctions.ElectricityInput(Current, SourceInstance, ComingFrom, this);
}
}
/// <summary>
/// Pass resistance with GameObject of the Machine it is heading toward
/// </summary>
public virtual void ResistanceInput(ResistanceWrap Resistance,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom)
{
if (Present != null)
{
Present.ResistanceInput(Resistance, SourceInstance, ComingFrom);
}
else
{
InputOutputFunctions.ResistanceInput(Resistance, SourceInstance, ComingFrom, this);
}
}
public VIRCurrent UpModifyElectricityInput(VIRCurrent Current,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFromm)
{
if (UpdateRequestDictionary.TryGetValue(ElectricalUpdateTypeCategory.ModifyElectricityInput, out HashSet <ElectricalModuleTypeCategory> updateRequest))
{
foreach (ElectricalModuleTypeCategory Module in updateRequest)
{
Current = UpdateDelegateDictionary[Module].ModifyElectricityInput(Current, SourceInstance, ComingFromm);
}
}
return(Current);
}
public VIRCurrent UpModifyElectricityInput(VIRCurrent Current,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFromm)
{
if (UpdateRequestDictionary.ContainsKey(ElectricalUpdateTypeCategory.ModifyElectricityInput))
{
foreach (ElectricalModuleTypeCategory Module in UpdateRequestDictionary[ElectricalUpdateTypeCategory.ModifyElectricityInput])
{
Current = UpdateDelegateDictionary[Module].ModifyElectricityInput(Current, SourceInstance, ComingFromm);
}
}
return(Current);
}
public static void FlushResistanceAndUp(IntrinsicElectronicData Object, ElectricalOIinheritance SourceInstance = null)
{
if (SourceInstance == null)
{
bool pass = false;
foreach (var Supply in Object.Data.SupplyDependent)
{
if (Supply.Value.ResistanceComingFrom.Count > 0)
{
pass = true;
break;
}
}
if (pass)
{
foreach (var Supply in Object.Data.SupplyDependent)
{
Pool(Supply.Value.ResistanceComingFrom);
Pool(Supply.Value.ResistanceGoingTo);
Pool(Supply.Value.CurrentGoingTo);
Pool(Supply.Value.CurrentComingFrom);
Supply.Value.SourceVoltage = 0;
}
foreach (IntrinsicElectronicData JumpTo in Object.Data.connections)
{
JumpTo.FlushResistanceAndUp();
}
Object.Data.CurrentInWire = 0;
Object.Data.ActualVoltage = 0;
}
}
else
{
ElectronicSupplyData supplyDep = Object.Data.SupplyDependent[SourceInstance];
if (supplyDep.ResistanceComingFrom.Count > 0 || supplyDep.ResistanceGoingTo.Count > 0)
{
Pool(supplyDep.ResistanceComingFrom);
Pool(supplyDep.ResistanceGoingTo);
foreach (IntrinsicElectronicData JumpTo in Object.Data.connections)
{
JumpTo.FlushResistanceAndUp(SourceInstance);
}
Pool(supplyDep.CurrentGoingTo);
Pool(supplyDep.CurrentComingFrom);
supplyDep.SourceVoltage = 0;
Object.Data.CurrentInWire = new float();
Object.Data.ActualVoltage = new float();
}
}
}
public static void ResistanceInput(ResistanceWrap Resistance,
ElectricalOIinheritance SourceInstance,
IntrinsicElectronicData ComingFrom,
IntrinsicElectronicData Thiswire)
{
if (!Thiswire.Data.SupplyDependent[SourceInstance].ResistanceComingFrom.ContainsKey(ComingFrom))
{
Thiswire.Data.SupplyDependent[SourceInstance].ResistanceComingFrom[ComingFrom] = ElectricalPool.GetVIRResistances();
}
Thiswire.Data.SupplyDependent[SourceInstance].ResistanceComingFrom[ComingFrom].AddResistance(Resistance);
Thiswire.ResistancyOutput(Resistance, SourceInstance);
}
private int NumberOfReactiveSupplies(IntrinsicElectronicData devices)
{
var counting = 0;
foreach (var device in devices.Data.ResistanceToConnectedDevices)
{
if (ReactiveSuppliesSet.Contains(device.Key.Data.InData.Categorytype))
{
counting++;
}
}
return(counting);
}
public int NumberOfReactiveSupplies(IntrinsicElectronicData Devices)
{
int Counting = 0;
foreach (var Device in Devices.Data
.ResistanceToConnectedDevices)
{
if (ReactiveSuppliesSet.Contains(Device.Key.Data.InData.Categorytype))
{
Counting++;
}
}
return(Counting);
}
