/// <summary>
/// Adds an energy consumer to the consumers list.
/// </summary>
/// <param name="iConsumer">The consumer to add.</param>
/// <param name="index">The consumer's index.</param>
/// <param name="required">The wattage needed when the consumer is active.</param>
/// <param name="selected">The currently selected object.</param>
private void AddConsumer(IEnergyConsumer iConsumer, int index, float required,
GameObject selected)
{
var text = CACHED_BUILDER;
if (iConsumer is KMonoBehaviour consumer && consumer != null)
{
var label = AddOrGetLabel(es.labelTemplate, consumerParent,
"consumer" + index.ToString());
var go = consumer.gameObject;
var fontStyle = (go == selected) ? FontStyles.Bold : FontStyles.Normal;
var title = label.text;
float used = iConsumer.WattsUsed;
text.Clear().Append(iConsumer.Name).Append(": ");
FormatStringPatches.GetFormattedWattage(text, used);
if (!Mathf.Approximately(used, required))
{
text.Append(" / ");
FormatStringPatches.GetFormattedWattage(text, required);
}
title.fontStyle = fontStyle;
title.SetText(text);
consumerLabels.Add(label);
}
}
public void Disconnect(IEnergyConsumer consumer)
{
if (!Game.IsQuitting())
{
consumers.Remove(consumer);
dirty = true;
}
}
public void Connect(IEnergyConsumer consumer)
{
if (!Game.IsQuitting())
{
consumers.Add(consumer);
dirty = true;
}
}
private float PowerFromGenerator(float joules_needed, Generator g, IEnergyConsumer c)
{
float num = Mathf.Min(g.JoulesAvailable, joules_needed);
joules_needed -= num;
g.ApplyDeltaJoules(0f - num, false);
ReportManager.Instance.ReportValue(ReportManager.ReportType.EnergyCreated, 0f - num, c.Name, null);
return(joules_needed);
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
IEnergyConsumer energyConsumersCasted = item.As <IEnergyConsumer>();
if ((energyConsumersCasted != null))
{
this._parent.EnergyConsumers.Add(energyConsumersCasted);
}
}
/// <summary>
/// Removes the given item from the collection
/// </summary>
/// <returns>True, if the item was removed, otherwise False</returns>
/// <param name="item">The item that should be removed</param>
public override bool Remove(IModelElement item)
{
IEnergyConsumer energyConsumerItem = item.As <IEnergyConsumer>();
if (((energyConsumerItem != null) &&
this._parent.EnergyConsumers.Remove(energyConsumerItem)))
{
return(true);
}
return(false);
}
private void Bind()
{
if (requirePower)
{
energy = GetComponent <IEnergyConsumer>();
button = GetComponent <BuildingEnabledButton>();
}
if (requireConduit && !(bool)conduitConsumer)
{
conduitConsumer = GetComponent <ConduitConsumer>();
}
}
/// <summary>
/// Adds the given element to the collection
/// </summary>
/// <param name="item">The item to add</param>
public override void Add(IModelElement item)
{
if ((this._parent.EnergyConsumer == null))
{
IEnergyConsumer energyConsumerCasted = item.As <IEnergyConsumer>();
if ((energyConsumerCasted != null))
{
this._parent.EnergyConsumer = energyConsumerCasted;
return;
}
}
}
private void AddConsumerInfo(IEnergyConsumer consumer, GameObject label)
{
KMonoBehaviour kMonoBehaviour = consumer as KMonoBehaviour;
if ((Object)kMonoBehaviour != (Object)null)
{
label = AddOrGetLabel(consumersLabels, consumersPanel, kMonoBehaviour.gameObject.GetInstanceID().ToString());
float wattsUsed = consumer.WattsUsed;
float wattsNeededWhenActive = consumer.WattsNeededWhenActive;
string text = null;
text = ((wattsUsed != wattsNeededWhenActive) ? $"{GameUtil.GetFormattedWattage(wattsUsed, GameUtil.WattageFormatterUnit.Automatic)} / {GameUtil.GetFormattedWattage(wattsNeededWhenActive, GameUtil.WattageFormatterUnit.Automatic)}" : GameUtil.GetFormattedWattage(wattsUsed, GameUtil.WattageFormatterUnit.Automatic));
label.GetComponent <LocText>().text = $"{consumer.Name}: {text}";
label.SetActive(true);
label.GetComponent <LocText>().fontStyle = (((Object)kMonoBehaviour.gameObject == (Object)selectedTarget) ? FontStyles.Bold : FontStyles.Normal);
}
}
private float PowerFromBatteries(float joules_needed, List <Battery> batteries, IEnergyConsumer c)
{
int num_powered;
do
{
float batteryJoulesAvailable = GetBatteryJoulesAvailable(batteries, out num_powered);
float num = batteryJoulesAvailable * (float)num_powered;
float num2 = (!(num < joules_needed)) ? joules_needed : num;
joules_needed -= num2;
ReportManager.Instance.ReportValue(ReportManager.ReportType.EnergyCreated, 0f - num2, c.Name, null);
float joules = num2 / (float)num_powered;
for (int i = batteries.Count - num_powered; i < batteries.Count; i++)
{
Battery battery = batteries[i];
battery.ConsumeEnergy(joules);
}
}while (joules_needed >= 0.01f && num_powered > 0);
return(joules_needed);
}
public void Sim200msLast(float dt)
{
elapsedTime += dt;
if (!(elapsedTime < 0.2f))
{
elapsedTime -= 0.2f;
for (int i = 0; i < this.circuitInfo.Count; i++)
{
CircuitInfo value = this.circuitInfo[i];
value.wattsUsed = 0f;
activeGenerators.Clear();
List <Generator> list = value.generators;
List <IEnergyConsumer> list2 = value.consumers;
List <Battery> batteries = value.batteries;
List <Generator> outputTransformers = value.outputTransformers;
batteries.Sort((Battery a, Battery b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
bool flag = false;
bool flag2 = list.Count > 0;
for (int j = 0; j < list.Count; j++)
{
Generator generator = list[j];
if (generator.JoulesAvailable > 0f)
{
flag = true;
activeGenerators.Add(generator);
}
}
activeGenerators.Sort((Generator a, Generator b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
if (!flag)
{
for (int k = 0; k < outputTransformers.Count; k++)
{
Generator generator2 = outputTransformers[k];
if (generator2.JoulesAvailable > 0f)
{
flag = true;
}
}
}
float num = 1f;
for (int l = 0; l < batteries.Count; l++)
{
Battery battery = batteries[l];
if (battery.JoulesAvailable > 0f)
{
flag = true;
}
num = Mathf.Min(num, battery.PercentFull);
}
for (int m = 0; m < value.inputTransformers.Count; m++)
{
Battery battery2 = value.inputTransformers[m];
num = Mathf.Min(num, battery2.PercentFull);
}
value.minBatteryPercentFull = num;
if (flag)
{
for (int n = 0; n < list2.Count; n++)
{
IEnergyConsumer energyConsumer = list2[n];
float num2 = energyConsumer.WattsUsed * 0.2f;
if (num2 > 0f)
{
bool flag3 = false;
for (int num3 = 0; num3 < activeGenerators.Count; num3++)
{
Generator g = activeGenerators[num3];
num2 = PowerFromGenerator(num2, g, energyConsumer);
if (num2 <= 0f)
{
flag3 = true;
break;
}
}
if (!flag3)
{
for (int num4 = 0; num4 < outputTransformers.Count; num4++)
{
Generator g2 = outputTransformers[num4];
num2 = PowerFromGenerator(num2, g2, energyConsumer);
if (num2 <= 0f)
{
flag3 = true;
break;
}
}
}
if (!flag3)
{
num2 = PowerFromBatteries(num2, batteries, energyConsumer);
flag3 = (num2 <= 0.01f);
}
if (flag3)
{
value.wattsUsed += energyConsumer.WattsUsed;
}
else
{
value.wattsUsed += energyConsumer.WattsUsed - num2 / 0.2f;
}
energyConsumer.SetConnectionStatus((!flag3) ? ConnectionStatus.Unpowered : ConnectionStatus.Powered);
}
else
{
energyConsumer.SetConnectionStatus((!flag) ? ConnectionStatus.Unpowered : ConnectionStatus.Powered);
}
}
}
else if (flag2)
{
for (int num5 = 0; num5 < list2.Count; num5++)
{
IEnergyConsumer energyConsumer2 = list2[num5];
energyConsumer2.SetConnectionStatus(ConnectionStatus.Unpowered);
}
}
else
{
for (int num6 = 0; num6 < list2.Count; num6++)
{
IEnergyConsumer energyConsumer3 = list2[num6];
energyConsumer3.SetConnectionStatus(ConnectionStatus.NotConnected);
}
}
this.circuitInfo[i] = value;
}
for (int num7 = 0; num7 < this.circuitInfo.Count; num7++)
{
CircuitInfo value2 = this.circuitInfo[num7];
value2.batteries.Sort((Battery a, Battery b) => (a.Capacity - a.JoulesAvailable).CompareTo(b.Capacity - b.JoulesAvailable));
value2.inputTransformers.Sort((Battery a, Battery b) => (a.Capacity - a.JoulesAvailable).CompareTo(b.Capacity - b.JoulesAvailable));
value2.generators.Sort((Generator a, Generator b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
float joules_used = 0f;
ChargeTransformers(value2.inputTransformers, value2.generators, ref joules_used);
ChargeTransformers(value2.inputTransformers, value2.outputTransformers, ref joules_used);
float joules_used2 = 0f;
ChargeBatteries(value2.batteries, value2.generators, ref joules_used2);
ChargeBatteries(value2.batteries, value2.outputTransformers, ref joules_used2);
value2.minBatteryPercentFull = 1f;
for (int num8 = 0; num8 < value2.batteries.Count; num8++)
{
Battery battery3 = value2.batteries[num8];
float percentFull = battery3.PercentFull;
if (percentFull < value2.minBatteryPercentFull)
{
value2.minBatteryPercentFull = percentFull;
}
}
for (int num9 = 0; num9 < value2.inputTransformers.Count; num9++)
{
Battery battery4 = value2.inputTransformers[num9];
float percentFull2 = battery4.PercentFull;
if (percentFull2 < value2.minBatteryPercentFull)
{
value2.minBatteryPercentFull = percentFull2;
}
}
value2.wattsUsed += joules_used / 0.2f;
this.circuitInfo[num7] = value2;
}
for (int num10 = 0; num10 < this.circuitInfo.Count; num10++)
{
CircuitInfo value3 = this.circuitInfo[num10];
value3.batteries.Sort((Battery a, Battery b) => a.JoulesAvailable.CompareTo(b.JoulesAvailable));
float joules_used3 = 0f;
ChargeTransformers(value3.inputTransformers, value3.batteries, ref joules_used3);
value3.wattsUsed += joules_used3 / 0.2f;
this.circuitInfo[num10] = value3;
}
for (int num11 = 0; num11 < this.circuitInfo.Count; num11++)
{
CircuitInfo value4 = this.circuitInfo[num11];
bool is_connected_to_something_useful = value4.generators.Count + value4.consumers.Count + value4.outputTransformers.Count > 0;
UpdateBatteryConnectionStatus(value4.batteries, is_connected_to_something_useful, num11);
bool flag4 = value4.generators.Count > 0 || value4.outputTransformers.Count > 0;
if (!flag4)
{
foreach (Battery battery5 in value4.batteries)
{
if (battery5.JoulesAvailable > 0f)
{
flag4 = true;
break;
}
}
}
UpdateBatteryConnectionStatus(value4.inputTransformers, flag4, num11);
this.circuitInfo[num11] = value4;
for (int num12 = 0; num12 < value4.generators.Count; num12++)
{
Generator generator3 = value4.generators[num12];
ReportManager.Instance.ReportValue(ReportManager.ReportType.EnergyWasted, 0f - generator3.JoulesAvailable, StringFormatter.Replace(BUILDINGS.PREFABS.GENERATOR.OVERPRODUCTION, "{Generator}", generator3.gameObject.GetProperName()), null);
}
}
for (int num13 = 0; num13 < this.circuitInfo.Count; num13++)
{
CircuitInfo circuitInfo = this.circuitInfo[num13];
CheckCircuitOverloaded(0.2f, num13, circuitInfo.wattsUsed);
}
}
}
public void Rebuild()
{
for (int i = 0; i < this.circuitInfo.Count; i++)
{
CircuitInfo value = this.circuitInfo[i];
value.generators.Clear();
value.consumers.Clear();
value.batteries.Clear();
value.inputTransformers.Clear();
value.outputTransformers.Clear();
value.minBatteryPercentFull = 1f;
for (int j = 0; j < value.bridgeGroups.Length; j++)
{
value.bridgeGroups[j].Clear();
}
this.circuitInfo[i] = value;
}
consumersShadow.AddRange(consumers);
List <IEnergyConsumer> .Enumerator enumerator = consumersShadow.GetEnumerator();
while (enumerator.MoveNext())
{
IEnergyConsumer current = enumerator.Current;
int powerCell = current.PowerCell;
ushort circuitID = GetCircuitID(powerCell);
if (circuitID != 65535)
{
Battery battery = current as Battery;
if ((Object)battery != (Object)null)
{
Operational component = battery.GetComponent <Operational>();
if ((Object)component == (Object)null || component.IsOperational)
{
CircuitInfo value2 = this.circuitInfo[circuitID];
PowerTransformer powerTransformer = battery.powerTransformer;
if ((Object)powerTransformer != (Object)null)
{
value2.inputTransformers.Add(battery);
}
else
{
value2.batteries.Add(battery);
CircuitInfo circuitInfo = this.circuitInfo[circuitID];
value2.minBatteryPercentFull = Mathf.Min(circuitInfo.minBatteryPercentFull, battery.PercentFull);
}
this.circuitInfo[circuitID] = value2;
}
}
else
{
CircuitInfo circuitInfo2 = this.circuitInfo[circuitID];
circuitInfo2.consumers.Add(current);
}
}
}
consumersShadow.Clear();
for (int k = 0; k < this.circuitInfo.Count; k++)
{
CircuitInfo circuitInfo3 = this.circuitInfo[k];
circuitInfo3.consumers.Sort((IEnergyConsumer a, IEnergyConsumer b) => a.WattsNeededWhenActive.CompareTo(b.WattsNeededWhenActive));
}
HashSet <Generator> .Enumerator enumerator2 = generators.GetEnumerator();
while (enumerator2.MoveNext())
{
Generator current2 = enumerator2.Current;
int powerCell2 = current2.PowerCell;
ushort circuitID2 = GetCircuitID(powerCell2);
if (circuitID2 != 65535)
{
if (current2.GetType() == typeof(PowerTransformer))
{
CircuitInfo circuitInfo4 = this.circuitInfo[circuitID2];
circuitInfo4.outputTransformers.Add(current2);
}
else
{
CircuitInfo circuitInfo5 = this.circuitInfo[circuitID2];
circuitInfo5.generators.Add(current2);
}
}
}
HashSet <WireUtilityNetworkLink> .Enumerator enumerator3 = bridges.GetEnumerator();
while (enumerator3.MoveNext())
{
WireUtilityNetworkLink current3 = enumerator3.Current;
current3.GetCells(out int linked_cell, out int _);
ushort circuitID3 = GetCircuitID(linked_cell);
if (circuitID3 != 65535)
{
Wire.WattageRating maxWattageRating = current3.GetMaxWattageRating();
CircuitInfo circuitInfo6 = this.circuitInfo[circuitID3];
circuitInfo6.bridgeGroups[(int)maxWattageRating].Add(current3);
}
}
dirty = false;
}
/// <summary>
/// Creates a new observable property access proxy
/// </summary>
/// <param name="modelElement">The model instance element for which to create the property access proxy</param>
public PowerAProxy(IEnergyConsumer modelElement) :
base(modelElement, "PowerA")
{
}
/// <summary>
/// Creates a new observable property access proxy
/// </summary>
/// <param name="modelElement">The model instance element for which to create the property access proxy</param>
public ReachabilityProxy(IEnergyConsumer modelElement) :
base(modelElement, "Reachability")
{
}
