public void PowerNetworkUpdate()
{
if (cacheOfConnectedDevices != electricalNodeControl.Node.InData.Data.ResistanceToConnectedDevices.Count)
{
cacheOfConnectedDevices = electricalNodeControl.Node.InData.Data.ResistanceToConnectedDevices.Count;
connectedDepartmentBatteries.Clear();
foreach (var device in electricalNodeControl.Node.InData.Data.ResistanceToConnectedDevices)
{
if (device.Key.Data.InData.Categorytype != PowerTypeCategory.DepartmentBattery)
{
continue;
}
if (!connectedDepartmentBatteries.Contains(device.Key.Data.GetComponent <DepartmentBattery>()))
{
connectedDepartmentBatteries.Add(device.Key.Data.GetComponent <DepartmentBattery>());
}
}
}
batteryCharging = false;
foreach (var bat in connectedDepartmentBatteries)
{
if (bat.BatterySupplyingModule.ChargingWatts > 0)
{
batteryCharging = true;
}
}
ElectricityFunctions.WorkOutActualNumbers(electricalNodeControl.Node.InData);
SyncVoltage(voltageSync, electricalNodeControl.Node.InData.Data.ActualVoltage);
Current = electricalNodeControl.Node.InData.Data.CurrentInWire;
HandleDevices();
}
/// <summary>
///The function for out putting current into other nodes (Basically doing ElectricityInput On another one)
/// </summary>
public virtual void ElectricityOutput(float Current, GameObject SourceInstance)
{
//SourceInstance.GetComponent<ElectricalOIinheritance>();
//Logger.Log("oh man?");
InputOutputFunctions.ElectricityOutput(Current, SourceInstance, this);
ElectricityFunctions.WorkOutActualNumbers(this);
}
protected virtual void ShowDetails()
{
if (isServer)
{
ElectricityFunctions.WorkOutActualNumbers(this);
Logger.Log("connections " + (string.Join(",", Data.connections)), Category.Electrical);
Logger.Log("ID " + (this.GetInstanceID()), Category.Electrical);
Logger.Log("Type " + (InData.Categorytype.ToString()), Category.Electrical);
Logger.Log("Can connect to " + (string.Join(",", InData.CanConnectTo)), Category.Electrical);
foreach (var Supply in Data.SupplyDependent)
{
string ToLog;
ToLog = "Supply > " + Supply.Key + "\n";
ToLog += "Upstream > ";
ToLog += string.Join(",", Supply.Value.Upstream) + "\n";
ToLog += "Downstream > ";
ToLog += string.Join(",", Supply.Value.Downstream) + "\n";
ToLog += "ResistanceGoingTo > ";
ToLog += string.Join(",", Supply.Value.ResistanceGoingTo) + "\n";
ToLog += "ResistanceComingFrom > ";
ToLog += string.Join(",", Supply.Value.ResistanceComingFrom) + "\n";
ToLog += "CurrentComingFrom > ";
ToLog += string.Join(",", Supply.Value.CurrentComingFrom) + "\n";
ToLog += "CurrentGoingTo > ";
ToLog += string.Join(",", Supply.Value.CurrentGoingTo) + "\n";
ToLog += Supply.Value.SourceVoltages.ToString();
Logger.Log(ToLog, Category.Electrical);
}
Logger.Log(" ActualVoltage > " + Data.ActualVoltage + " CurrentInWire > " + Data.CurrentInWire + " EstimatedResistance > " + Data.EstimatedResistance, Category.Electrical);
}
RequestElectricalStats.Send(PlayerManager.LocalPlayer, gameObject);
}
public override void ElectricityOutput(float Current, GameObject SourceInstance)
{
Data.ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(this);
Data.CurrentInWire = Data.ActualCurrentChargeInWire.Current;
Data.ActualVoltage = Data.ActualCurrentChargeInWire.Voltage;
Data.EstimatedResistance = Data.ActualCurrentChargeInWire.EstimatedResistant;
}
protected override void ShowDetails()
{
if (isServer)
{
ElectricityFunctions.WorkOutActualNumbers(this);
Logger.Log("connections " + (string.Join(",", Data.connections)), Category.Electrical);
Logger.Log("ID " + (this.GetInstanceID()), Category.Electrical);
Logger.Log("Type " + (InData.Categorytype.ToString()), Category.Electrical);
Logger.Log("Can connect to " + (string.Join(",", InData.CanConnectTo)), Category.Electrical);
foreach (var Supply in Data.SupplyDependent)
{
LogSupply(Supply);
}
if (RelatedLine != null)
{
Logger.Log("line heree!!!");
ElectricityFunctions.WorkOutActualNumbers(RelatedLine.TheEnd);
Data.ActualVoltage = RelatedLine.TheEnd.Data.ActualVoltage;
Data.CurrentInWire = RelatedLine.TheEnd.Data.CurrentInWire;
Data.EstimatedResistance = RelatedLine.TheEnd.Data.EstimatedResistance;
foreach (var Supply in RelatedLine.TheEnd.Data.SupplyDependent)
{
LogSupply(Supply);
}
}
Logger.Log(" ActualVoltage > " + Data.ActualVoltage + " CurrentInWire > " + Data.CurrentInWire + " EstimatedResistance > " + Data.EstimatedResistance, Category.Electrical);
}
RequestElectricalStats.Send(PlayerManager.LocalPlayer, gameObject);
}
public void PowerNetworkUpdate()
{
//Logger.Log("humm...");
if (!(CashOfConnectedDevices == ElectricalNodeControl.Node.InData.Data.ResistanceToConnectedDevices.Count))
{
CashOfConnectedDevices = ElectricalNodeControl.Node.InData.Data.ResistanceToConnectedDevices.Count;
ConnectedDepartmentBatteries.Clear();
foreach (var Device in ElectricalNodeControl.Node.InData.Data.ResistanceToConnectedDevices)
{
if (Device.Key.InData.Categorytype == PowerTypeCategory.DepartmentBattery)
{
if (!(ConnectedDepartmentBatteries.Contains(Device.Key.GetComponent <DepartmentBattery>())))
{
ConnectedDepartmentBatteries.Add(Device.Key.GetComponent <DepartmentBattery>());
}
}
}
}
BatteryCharging = false;
foreach (var bat in ConnectedDepartmentBatteries)
{
if (bat.BatterySupplyingModule.ChargingWatts > 0)
{
BatteryCharging = true;
}
}
ElectricityFunctions.WorkOutActualNumbers(ElectricalNodeControl.Node.InData);
SyncVoltage(voltageSync, ElectricalNodeControl.Node.InData.Data.ActualVoltage);
Current = ElectricalNodeControl.Node.InData.Data.CurrentInWire;
HandleDevices();
UpdateDisplay();
}
public virtual void ShowDetails()
{
ElectricityFunctions.WorkOutActualNumbers(this);
Logger.Log("connections " + (string.Join(",", Data.connections)), Category.Electrical);
//Logger.Log("ID " + (this.GetInstanceID()), Category.Electrical);
Logger.Log("Type " + (Categorytype.ToString()), Category.Electrical);
Logger.Log("Can connect to " + (string.Join(",", CanConnectTo)), Category.Electrical);
Logger.Log("WireEndA > " + WireEndA + " WireEndB > " + WireEndB, Category.Electrical);
foreach (var Supply in Data.SupplyDependent)
{
string ToLog;
ToLog = "Supply > " + Supply.Key + "\n";
ToLog += "Upstream > ";
ToLog += string.Join(",", Supply.Value.Upstream) + "\n";
ToLog += "Downstream > ";
ToLog += string.Join(",", Supply.Value.Downstream) + "\n";
ToLog += "ResistanceGoingTo > ";
ToLog += string.Join(",", Supply.Value.ResistanceGoingTo) + "\n";
ToLog += "ResistanceComingFrom > ";
ToLog += string.Join(",", Supply.Value.ResistanceComingFrom) + "\n";
ToLog += "CurrentComingFrom > ";
ToLog += string.Join(",", Supply.Value.CurrentComingFrom) + "\n";
ToLog += "CurrentGoingTo > ";
ToLog += string.Join(",", Supply.Value.CurrentGoingTo) + "\n";
ToLog += "SourceVoltages > ";
ToLog += string.Join(",", Supply.Value.SourceVoltage) + "\n";
Logger.Log(ToLog, Category.Electrical);
}
Logger.Log(" ActualVoltage > " + Data.ActualVoltage
+ " CurrentInWire > " + Data.CurrentInWire
+ " EstimatedResistance > " + Data.EstimatedResistance, Category.Electrical);
}
/// <summary>
/// [Message Handler] Perform cable cutting interaction on server side
/// </summary>
private void ServerPerformCableCuttingInteraction(NetworkConnection conn, CableCuttingWindow.CableCuttingMessage message)
{
// get object at target position
GameObject hit = MouseUtils.GetOrderedObjectsAtPoint(message.targetWorldPosition).FirstOrDefault();
// get matrix
Matrix matrix = hit.GetComponentInChildren <Matrix>();
// return if matrix is null
if (matrix == null)
{
return;
}
// convert world position to cell position and set Z value to Z value from message
Vector3Int targetCellPosition = matrix.MetaTileMap.WorldToCell(message.targetWorldPosition);
targetCellPosition.z = message.positionZ;
// get electical tile from targetCellPosition
ElectricalCableTile electricalCable = matrix.UnderFloorLayer.GetTileUsingZ(targetCellPosition) as ElectricalCableTile;
if (electricalCable == null)
{
return;
}
// add messages to chat
string othersMessage = Chat.ReplacePerformer(othersStartActionMessage, message.performer);
Chat.AddActionMsgToChat(message.performer, performerStartActionMessage, othersMessage);
// source: ElectricalCableDeconstruction.cs
var metaDataNode = matrix.GetMetaDataNode(targetCellPosition);
foreach (var ElectricalData in metaDataNode.ElectricalData)
{
if (ElectricalData.RelatedTile != electricalCable)
{
continue;
}
// Electrocute the performer. If shock is painful enough, cancel the interaction.
ElectricityFunctions.WorkOutActualNumbers(ElectricalData.InData);
float voltage = ElectricalData.InData.Data.ActualVoltage;
var electrocution = new Electrocution(voltage, message.targetWorldPosition, "cable");
var performerLHB = message.performer.GetComponent <LivingHealthBehaviour>();
var severity = performerLHB.Electrocute(electrocution);
if (severity > LivingShockResponse.Mild)
{
return;
}
ElectricalData.InData.DestroyThisPlease();
Spawn.ServerPrefab(electricalCable.SpawnOnDeconstruct, message.targetWorldPosition,
count: electricalCable.SpawnAmountOnDeconstruct);
return;
}
}
public void ElectricityOutput(int tick, float Current, GameObject SourceInstance)
{
InputOutputFunctions.ElectricityOutput(tick, Current, SourceInstance, this);
Data.ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(this);
Data.CurrentInWire = Data.ActualCurrentChargeInWire.Current;
Data.ActualVoltage = Data.ActualCurrentChargeInWire.Voltage;
Data.EstimatedResistance = Data.ActualCurrentChargeInWire.EstimatedResistant;
}
public void ElectricityOutput(int tick, float Current, GameObject SourceInstance)
{
ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(this);
CurrentInWire = ActualCurrentChargeInWire.Current;
ActualVoltage = ActualCurrentChargeInWire.Voltage;
EstimatedResistance = ActualCurrentChargeInWire.EstimatedResistant;
//Logger.Log (Voltage.ToString () + "Voltage man", Category.Electrical);
}
public virtual void PowerNetworkUpdate()
{
ElectricityFunctions.WorkOutActualNumbers(wireConnect);
if (MaximumInstantBreakCurrent != 0 && CanOverCurrent)
{
if (MaximumInstantBreakCurrent < wireConnect.Data.CurrentInWire)
{
QueueForDemolition(this);
return;
}
if (MaximumBreakdownCurrent < wireConnect.Data.CurrentInWire)
{
if (CheckDestruction)
{
if (wireConnect.RelatedLine != null)
{
foreach (var CB in wireConnect.RelatedLine.Covering)
{
CB.gameObject.GetComponent <CableInheritance>()?.Smoke.Stop();
}
}
QueueForDemolition(this);
return;
}
else
{
if (wireConnect.RelatedLine != null)
{
foreach (var CB in wireConnect.RelatedLine.Covering)
{
CB.gameObject.GetComponent <CableInheritance>()?.Smoke.Play();
}
}
Smoke.Play();
StartCoroutine(WaitForDemolition());
return;
}
}
if (CheckDestruction)
{
CheckDestruction = false;
if (wireConnect.RelatedLine != null)
{
foreach (var CB in wireConnect.RelatedLine.Covering)
{
CB.gameObject.GetComponent <CableInheritance>()?.Smoke.Stop();
}
}
Smoke.Stop();
}
if (IsSparking())
{
Sparks.Stop();
}
}
}
public void PowerNetworkUpdate()
{
ElectricityFunctions.WorkOutActualNumbers(Node);
UpPowerNetworkUpdate();
if (NodeControl != null)
{
NodeControl.PowerNetworkUpdate();
}
}
/// <summary>
/// Checks if the grille's location has exposed floor plating,
/// that a cable overlap exists there,
/// and returns the highest voltage detected (for now).
/// </summary>
/// <returns>The voltage found on the cable</returns>
private float ServerGetGrilleVoltage()
{
Vector3Int targetCellPos = interaction.TargetCellPos;
MetaTileMap metaTileMap = interaction.TileChangeManager.MetaTileMap;
Matrix matrix = metaTileMap.Layers[LayerType.Underfloor].matrix;
// Check if the floor plating is exposed.
if (metaTileMap.HasTile(targetCellPos, LayerType.Floors))
{
return(0);
}
// Check for cables underneath the grille.
var eConns = matrix.GetElectricalConnections(targetCellPos);
if (eConns == null)
{
return(0);
}
// Get the highest voltage and whether there is a connection overlap.
// The current powernet implementation means the cable
// will only report a voltage if there is current flow, it seems.
// That's why we cannot simply the overlap connection's voltage,
// and both ends of the cable need to be connected to the powernet.
//
// One possible workaround is to allow a Connection.Overlap to draw
// a small amount of current, so that it registers a voltage.
// Then, we don't need to check for the highest voltage and not worry
// about whether the overlap is actually connected to a live cable.
bool overlapExists = false;
float voltage = 0;
foreach (var conn in eConns)
{
if (conn.WireEndA == Connection.Overlap || conn.WireEndB == Connection.Overlap)
{
overlapExists = true;
}
ElectricityFunctions.WorkOutActualNumbers(conn);
if (conn.Data.ActualVoltage > voltage)
{
voltage = conn.Data.ActualVoltage;
}
}
// Check that there is a cable overlap.
if (!overlapExists)
{
return(0);
}
// All checks passed, electrocute the performer!
return(voltage);
}
public float GetResistance()
{
if (ControllingNode.Node.InData.Data.SupplyDependent.ContainsKey(ControllingNode.Node) && ControllingNode.Node.InData.Data.SupplyDependent[ControllingNode.Node].Downstream.Count > 0)
{
var DownNode = ControllingNode.Node.InData.Data.SupplyDependent[ControllingNode.Node].Downstream.PickRandom();
ElectricityFunctions.WorkOutActualNumbers(DownNode);
return(DownNode.Data.EstimatedResistance);
}
return(0);
}
public static void DoCurrentloop(HashSet <ElectricalOIinheritance> WorkingOn, GameObject SourceInstance)
{
foreach (ElectricalOIinheritance Node in WorkingOn)
{
//Logger.Log("yow");
if (!Node.InData.ElectricityOverride)
{
float SupplyingCurrent = 0;
float Voltage = Node.Data.CurrentStoreValue * (ElectricityFunctions.WorkOutResistance(Node.Data.ResistanceComingFrom[SourceInstanceID]));
foreach (KeyValuePair <ElectricalOIinheritance, float> JumpTo in Node.Data.ResistanceComingFrom[SourceInstanceID])
{
if (Voltage > 0)
{
SupplyingCurrent = (Voltage / JumpTo.Value);
}
else
{
SupplyingCurrent = Node.Data.CurrentStoreValue;
}
if (!(Node.Data.CurrentGoingTo.ContainsKey(SourceInstanceID)))
{
Node.Data.CurrentGoingTo[SourceInstanceID] = new Dictionary <ElectricalOIinheritance, float>();
}
Node.Data.CurrentGoingTo[SourceInstanceID][JumpTo.Key] = SupplyingCurrent;
if (!JumpTo.Key.InData.ElectricityOverride)
{
//Logger.Log (tick.ToString () + " <tick " + Current.ToString () + " <Current " + SourceInstance.ToString () + " <SourceInstance " + ComingFrom.ToString () + " <ComingFrom " + Thiswire.ToString () + " <Thiswire ", Category.Electrical);
if (!(JumpTo.Key.Data.SourceVoltages.ContainsKey(SourceInstanceID)))
{
JumpTo.Key.Data.SourceVoltages[SourceInstanceID] = new float();
}
if (!(JumpTo.Key.Data.CurrentComingFrom.ContainsKey(SourceInstanceID)))
{
JumpTo.Key.Data.CurrentComingFrom[SourceInstanceID] = new Dictionary <ElectricalOIinheritance, float>();
}
JumpTo.Key.Data.CurrentComingFrom[SourceInstanceID][Node] = SupplyingCurrent;
JumpTo.Key.Data.SourceVoltages[SourceInstanceID] = SupplyingCurrent * (ElectricityFunctions.WorkOutResistance(JumpTo.Key.Data.ResistanceComingFrom[SourceInstanceID]));
CurrentWorkOnNextListADD(JumpTo.Key);
JumpTo.Key.Data.CurrentStoreValue = ElectricityFunctions.WorkOutCurrent(JumpTo.Key.Data.CurrentComingFrom[SourceInstanceID]);
//JumpTo.Key.ElectricityOutput(ElectricityFunctions.WorkOutCurrent(JumpTo.Key.Data.CurrentComingFrom[SourceInstanceID]), SourceInstance);
}
else
{
JumpTo.Key.ElectricityInput(SupplyingCurrent, SourceInstance, Node);
}
ElectricityFunctions.WorkOutActualNumbers(Node);
}
}
else
{
Node.ElectricityOutput(Node.Data.CurrentStoreValue, SourceInstance);
}
}
}
public void PowerUpdateCurrentChange()
{
ElectricityFunctions.WorkOutActualNumbers(Node.InData);
if (UpdateRequestDictionary.TryGetValue(ElectricalUpdateTypeCategory.PowerUpdateCurrentChange, out HashSet <ElectricalModuleTypeCategory> updateRequest))
{
foreach (ElectricalModuleTypeCategory Module in updateRequest)
{
UpdateDelegateDictionary[Module].PowerUpdateCurrentChange();
}
}
}
public override void ElectricityOutput(float Current, GameObject SourceInstance)
{
if (!(SourceInstance == this.gameObject))
{
ElectricalSynchronisation.NUCurrentChange.Add(InData.ControllingUpdate);
}
InputOutputFunctions.ElectricityOutput(Current, SourceInstance, this);
Data.ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(this);
Data.CurrentInWire = Data.ActualCurrentChargeInWire.Current;
Data.ActualVoltage = Data.ActualCurrentChargeInWire.Voltage;
Data.EstimatedResistance = Data.ActualCurrentChargeInWire.EstimatedResistant;
}
public static void FlushSupplyAndUp(IElectricityIO Object, GameObject SourceInstance = null)
{
if (SourceInstance == null)
{
if (Object.CurrentComingFrom.Count > 0)
{
//Logger.Log ("Flushing!!", Category.Electrical);
Object.CurrentComingFrom.Clear();
foreach (IElectricityIO JumpTo in Object.connections)
{
JumpTo.FlushSupplyAndUp();
}
Object.CurrentGoingTo.Clear();
Object.SourceVoltages.Clear();
Object.CurrentInWire = new float();
Object.ActualVoltage = new float();
}
}
else
{
int InstanceID = SourceInstance.GetInstanceID();
if (Object.CurrentComingFrom.ContainsKey(InstanceID))
{
//Logger.Log ("Flushing!!", Category.Electrical);
Object.CurrentGoingTo.Remove(InstanceID);
Object.CurrentComingFrom.Remove(InstanceID);
foreach (IElectricityIO JumpTo in Object.connections)
{
JumpTo.FlushSupplyAndUp(SourceInstance);
}
}
else if (Object.CurrentGoingTo.ContainsKey(InstanceID))
{
//Logger.Log ("Flushing!!", Category.Electrical);
Object.CurrentGoingTo.Remove(InstanceID);
Object.CurrentComingFrom.Remove(InstanceID);
foreach (IElectricityIO JumpTo in Object.connections)
{
JumpTo.FlushSupplyAndUp(SourceInstance);
}
}
Object.CurrentGoingTo.Remove(InstanceID);
Object.SourceVoltages.Remove(InstanceID);
Object.ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(Object);
Object.CurrentInWire = Object.ActualCurrentChargeInWire.Current;
Object.ActualVoltage = Object.ActualCurrentChargeInWire.Voltage;
Object.EstimatedResistance = Object.ActualCurrentChargeInWire.EstimatedResistant;
}
}
public override void ElectricityOutput(float Current, GameObject SourceInstance)
{
//Logger.Log (CurrentInWire.ToString () + " How much current", Category.Electrical);
InputOutputFunctions.ElectricityOutput(Current, SourceInstance, this);
Data.ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(this);
Data.CurrentInWire = Data.ActualCurrentChargeInWire.Current;
Data.ActualVoltage = Data.ActualCurrentChargeInWire.Voltage;
Data.EstimatedResistance = Data.ActualCurrentChargeInWire.EstimatedResistant;
if (RelatedLine != null)
{
RelatedLine.UpdateCoveringCable(this);
}
}
public void ElectricityOutput(int tick, float Current, GameObject SourceInstance)
{
Current = RelatedDevice.ModifyElectricityOutput(tick, Current, SourceInstance);
//Logger.Log (CurrentInWire.ToString () + " How much current", Category.Electrical);
if (Current != 0)
{
InputOutputFunctions.ElectricityOutput(tick, Current, SourceInstance, this);
}
Data.ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(this);
Data.CurrentInWire = Data.ActualCurrentChargeInWire.Current;
Data.ActualVoltage = Data.ActualCurrentChargeInWire.Voltage;
Data.EstimatedResistance = Data.ActualCurrentChargeInWire.EstimatedResistant;
}
public void PowerNetworkUpdate()
{
ElectricityFunctions.WorkOutActualNumbers(Node.InData);
if (UpdateRequestDictionary.TryGetValue(ElectricalUpdateTypeCategory.PowerNetworkUpdate, out HashSet <ElectricalModuleTypeCategory> updateRequest))
{
foreach (ElectricalModuleTypeCategory Module in updateRequest)
{
UpdateDelegateDictionary[Module].PowerNetworkUpdate();
}
}
if (NodeControl != null)
{
NodeControl.PowerNetworkUpdate();
}
}
public static void FlushSupplyAndUp(ElectricalOIinheritance Object, GameObject SourceInstance = null)
{
if (SourceInstance == null)
{
bool pass = false;
foreach (var Supply in Object.Data.SupplyDependent)
{
if (Supply.Value.CurrentComingFrom.Count > 0)
{
pass = true;
}
}
if (pass)
{
foreach (var Supply in Object.Data.SupplyDependent)
{
Supply.Value.CurrentComingFrom.Clear();
Supply.Value.CurrentGoingTo.Clear();
Supply.Value.SourceVoltages = 0;
}
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.FlushSupplyAndUp();
}
Object.Data.CurrentInWire = new float();
Object.Data.ActualVoltage = new float();
}
}
else
{
int InstanceID = SourceInstance.GetInstanceID();
if (Object.Data.SupplyDependent.ContainsKey(InstanceID))
{
if (Object.Data.SupplyDependent[InstanceID].CurrentComingFrom.Count > 0 || Object.Data.SupplyDependent[InstanceID].CurrentGoingTo.Count > 0)
{
Object.Data.SupplyDependent[InstanceID].CurrentGoingTo.Clear();
Object.Data.SupplyDependent[InstanceID].CurrentComingFrom.Clear();
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.FlushSupplyAndUp(SourceInstance);
}
}
Object.Data.SupplyDependent[InstanceID].SourceVoltages = 0;
}
ElectricityFunctions.WorkOutActualNumbers(Object);
}
}
public override void ElectricityOutput(float Current, GameObject SourceInstance)
{
if (!(SourceInstance == gameObject))
{
if (!ElectricalSynchronisation.NUCurrentChange.Contains(InData.ControllingUpdate))
{
ElectricalSynchronisation.NUCurrentChange.Add(InData.ControllingUpdate);
}
}
Current = RelatedDevice.ModifyElectricityOutput(Current, SourceInstance);
InputOutputFunctions.ElectricityOutput(Current, SourceInstance, this);
ElectricityFunctions.WorkOutActualNumbers(this);
}
public static void RemoveSupply(ElectricalOIinheritance Object, GameObject 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)
{
Object.Data.SupplyDependent.Clear();
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.RemoveSupply();
}
Object.Data.CurrentInWire = new float();
Object.Data.ActualVoltage = new float();
Object.Data.EstimatedResistance = new float();
Object.Data.ResistanceToConnectedDevices.Clear();
Object.connectedDevices.Clear();
}
}
else
{
int InstanceID = SourceInstance.GetInstanceID();
if (Object.Data.SupplyDependent[InstanceID].Downstream.Count > 0)
{
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.RemoveSupply(SourceInstance);
}
if (InstanceID == Object.GameObject().GetInstanceID())
{
CleanConnectedDevicesFromPower(Object);
Object.Data.ResistanceToConnectedDevices.Clear();
}
Object.Data.SupplyDependent.Remove(InstanceID);
ElectricityFunctions.WorkOutActualNumbers(Object);
}
}
}
public override void ServerPerformInteraction(TileApply interaction)
{
string othersMessage = Chat.ReplacePerformer(othersStartActionMessage, interaction.Performer);
Chat.AddActionMsgToChat(interaction.Performer, performerStartActionMessage, othersMessage);
if (interaction.BasicTile.LayerType != LayerType.Underfloor)
{
return;
}
var ElectricalCable = interaction.BasicTile as ElectricalCableTile;
if (ElectricalCable == null)
{
return;
}
var matrix = interaction.TileChangeManager.MetaTileMap.Layers[LayerType.Underfloor].matrix;
var metaDataNode = matrix.GetMetaDataNode(interaction.TargetCellPos);
foreach (var ElectricalData in metaDataNode.ElectricalData)
{
if (ElectricalData.RelatedTile != ElectricalCable)
{
continue;
}
// Electrocute the performer. If shock is painful enough, cancel the interaction.
ElectricityFunctions.WorkOutActualNumbers(ElectricalData.InData);
float voltage = ElectricalData.InData.Data.ActualVoltage;
var electrocution = new Electrocution(voltage, interaction.WorldPositionTarget, "cable");
var performerLHB = interaction.Performer.GetComponent <LivingHealthMasterBase>();
var severity = performerLHB.Electrocute(electrocution);
if (severity > LivingShockResponse.Mild)
{
return;
}
ElectricalData.InData.DestroyThisPlease();
Spawn.ServerPrefab(ElectricalCable.SpawnOnDeconstruct, interaction.WorldPositionTarget,
count: ElectricalCable.SpawnAmountOnDeconstruct);
return;
}
}
public override void ElectricityOutput(float Current, GameObject SourceInstance)
{
if (!(SourceInstance == this.gameObject))
{
ElectricalSynchronisation.NUCurrentChange.Add(InData.ControllingUpdate);
}
Current = RelatedDevice.ModifyElectricityOutput(Current, SourceInstance);
//Logger.Log (CurrentInWire.ToString () + " How much current", Category.Electrical);
if (Current != 0)
{
InputOutputFunctions.ElectricityOutput(Current, SourceInstance, this);
}
Data.ActualCurrentChargeInWire = ElectricityFunctions.WorkOutActualNumbers(this);
Data.CurrentInWire = Data.ActualCurrentChargeInWire.Current;
Data.ActualVoltage = Data.ActualCurrentChargeInWire.Voltage;
Data.EstimatedResistance = Data.ActualCurrentChargeInWire.EstimatedResistant;
}
private void WireChew(IntrinsicElectronicData cable)
{
ElectricityFunctions.WorkOutActualNumbers(cable);
float voltage = cable.Data.ActualVoltage;
// Remove the cable and spawn the item.
cable.DestroyThisPlease();
var electricalTile = registerObject.TileChangeManager.MetaTileMap.GetTile(registerObject.WorldPosition, LayerType.Underfloor) as ElectricalCableTile;
// Electrical tile is not null iff this is the first mousechew. Why?
if (electricalTile != null)
{
Spawn.ServerPrefab(electricalTile.SpawnOnDeconstruct, registerObject.WorldPosition,
count: electricalTile.SpawnAmountOnDeconstruct);
}
Electrocute(voltage);
}
public static void FlushSupplyAndUp(ElectricalOIinheritance Object, GameObject SourceInstance = null)
{
if (SourceInstance == null)
{
if (Object.Data.CurrentComingFrom.Count > 0)
{
Object.Data.CurrentComingFrom.Clear();
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.FlushSupplyAndUp();
}
Object.Data.CurrentGoingTo.Clear();
Object.Data.SourceVoltages.Clear();
Object.Data.CurrentInWire = new float();
Object.Data.ActualVoltage = new float();
}
}
else
{
int InstanceID = SourceInstance.GetInstanceID();
//Logger.Log(Object.GameObject().name);
if (Object.Data.CurrentComingFrom.ContainsKey(InstanceID))
{
Object.Data.CurrentGoingTo.Remove(InstanceID);
Object.Data.CurrentComingFrom.Remove(InstanceID);
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.FlushSupplyAndUp(SourceInstance);
}
}
else if (Object.Data.CurrentGoingTo.ContainsKey(InstanceID))
{
Object.Data.CurrentGoingTo.Remove(InstanceID);
Object.Data.CurrentComingFrom.Remove(InstanceID);
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.FlushSupplyAndUp(SourceInstance);
}
}
Object.Data.CurrentGoingTo.Remove(InstanceID);
Object.Data.SourceVoltages.Remove(InstanceID);
ElectricityFunctions.WorkOutActualNumbers(Object);
}
}
public virtual void PowerNetworkUpdate()
{
//Logger.Log("PowerNetworkUpdate");
ElectricityFunctions.WorkOutActualNumbers(wireConnect.InData);
if (CheckOverlap)
{
//Logger.Log("CheckOverlap");
CheckOverlap = false;
FindOverlapsAndCombine();
ConvertToTile();
}
//if (MaximumInstantBreakCurrent != 0 && CanOverCurrent)
//{
// if (MaximumInstantBreakCurrent < wireConnect.Data.CurrentInWire)
// {
// QueueForDemolition(this);
// return;
// }
// if (MaximumBreakdownCurrent < wireConnect.Data.CurrentInWire) {
// if (CheckDestruction)
// {
// QueueForDemolition(this);
// return;
// }
// else
// {
// Smoke.Play();
// StartCoroutine(WaitForDemolition());
// return;
// }
// }
// if (CheckDestruction)
// {
// CheckDestruction = false;
// Smoke.Stop();
// }
// Sparks.Stop();
//}
}
public static void RemoveSupply(ElectricalOIinheritance Object, GameObject SourceInstance = null)
{
if (SourceInstance == null)
{
if (Object.Data.Downstream.Count > 0 || Object.Data.Upstream.Count > 0)
{
Object.Data.Downstream.Clear();
Object.Data.Upstream.Clear();
Object.Data.FirstPresent = new int();
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.RemoveSupply();
}
Object.Data.Upstream.Clear();
Object.Data.SourceVoltages.Clear();
Object.Data.ResistanceGoingTo.Clear();
Object.Data.ResistanceComingFrom.Clear();
Object.Data.CurrentGoingTo.Clear();
Object.Data.CurrentComingFrom.Clear();
Object.Data.SourceVoltages.Clear();
Object.Data.CurrentInWire = new float();
Object.Data.ActualVoltage = new float();
Object.Data.EstimatedResistance = new float();
Object.Data.UpstreamCount = new int();
Object.Data.DownstreamCount = new int();
Object.Data.ResistanceToConnectedDevices.Clear();
Object.connectedDevices.Clear();
}
}
else
{
int InstanceID = SourceInstance.GetInstanceID();
if (Object.Data.Downstream.ContainsKey(InstanceID))
{
Object.Data.Downstream.Remove(InstanceID);
if (Object.Data.FirstPresent == InstanceID)
{
Object.Data.FirstPresent = new int();
}
foreach (ElectricalOIinheritance JumpTo in Object.Data.connections)
{
JumpTo.RemoveSupply(SourceInstance);
}
if (InstanceID == Object.GameObject().GetInstanceID())
{
CleanConnectedDevicesFromPower(Object);
Object.Data.ResistanceToConnectedDevices.Clear();
}
Object.Data.Upstream.Remove(InstanceID);
Object.Data.SourceVoltages.Remove(InstanceID);
Object.Data.ResistanceGoingTo.Remove(InstanceID);
Object.Data.ResistanceComingFrom.Remove(InstanceID);
Object.Data.CurrentGoingTo.Remove(InstanceID);
Object.Data.CurrentComingFrom.Remove(InstanceID);
Object.Data.SourceVoltages.Remove(InstanceID);
ElectricityFunctions.WorkOutActualNumbers(Object);;
Object.Data.UpstreamCount = new int();
Object.Data.DownstreamCount = new int();
}
}
}
