private BatteryState GetBatteryState(PowerNet pn)
{
if (Find.TickManager.TicksGame - FirstTick > 60 && pn.batteryComps.Count() > 0)
{
float cegr = pn.CurrentEnergyGainRate();
float cse = pn.CurrentStoredEnergy();
//!pn.Map.gameConditionManager.ConditionIsActive(GameConditionDefOf.SolarFlare)
// Avoid spamming the warning when browning out by checking for insufficient power and keeping the alert on.
if (cse / (float)pn.batteryComps.Sum(bc => bc.Props.storedEnergyMax) < 0.05f &&
pn.powerComps.Any(pc => !pc.PowerOn && FlickUtility.WantsToBeOn(pc.parent) && !pc.parent.IsBrokenDown()))
{
return(BatteryState.Brownout);
}
if (cegr < 0)
{
float timeLeft = (cse / cegr / -60f);
if (timeLeft <= Power_Alerts.drainingBatteriesThresholdSeconds)
{
return(BatteryState.Draining);
}
}
}
return(BatteryState.Normal);
}
public override string CompInspectStringExtra()
{
if (PowerNet == null)
{
return("PowerNotConnected".Translate());
}
StringBuilder str = new StringBuilder();
str.AppendLine("VoidNetConverterLabel1".Translate((-PowerConsumption).ToString("f0")));
string value = (PowerNet.CurrentEnergyGainRate() / CompPower.WattsToWattDaysPerTick).ToString("F0");
string value2 = PowerNet.CurrentStoredEnergy().ToString("F0");
str.Append("PowerConnectedRateStored".Translate(value, value2));
if (Prefs.DevMode)
{
str.Append("\n" + "VoidNetConverterLabel2".Translate(energyCost.ToString("f3")) +
"\n" + "VoidNetConverterLabel3".Translate((convertRate * 100).ToString("F0")));
}
return(str.ToString());
}
public void ProcessCell(IntVec3 cell)
{
PowerNet powerNet = PowerNetGrid.TransmittedPowerNetAt(cell);
if (powerNet != null)
{
float maxEnergy = 0.0f;
float storedEnergy = 0.0f;
float currentRate = powerNet.CurrentEnergyGainRate();
foreach (CompPowerBattery compPowerBattery in powerNet.batteryComps)
{
maxEnergy += compPowerBattery.Props.storedEnergyMax;
storedEnergy += compPowerBattery.StoredEnergy;
}
if (!compFlickable.SwitchIsOn &&
currentRate < 0 &&
storedEnergy < -currentRate * GenDate.TicksPerHour / 6.0f)
{
System.Reflection.FieldInfo fieldInfo = typeof(CompFlickable).GetField(
"wantSwitchOn", // Thanks Haplo!
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
fieldInfo.SetValue(compFlickable, true);
compFlickable.SwitchIsOn = true;
FlickUtility.UpdateFlickDesignation(parent);
}
else
{
if (storedEnergy >= maxEnergy)
{
System.Reflection.FieldInfo fieldInfo = typeof(CompFlickable).GetField(
"wantSwitchOn", // Thanks Haplo!
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
fieldInfo.SetValue(compFlickable, false);
compFlickable.SwitchIsOn = false;
FlickUtility.UpdateFlickDesignation(parent);
}
}
}
}
public void ProcessCell(IntVec3 cell)
{
PowerNet powerNet = parent.Map.powerNetGrid.TransmittedPowerNetAt(cell);
if (powerNet != null)
{
float maxEnergy = 0.0f;
float storedEnergy = 0.0f;
float currentRate = powerNet.CurrentEnergyGainRate();
foreach (CompPowerBattery compPowerBattery in powerNet.batteryComps)
{
maxEnergy += compPowerBattery.Props.storedEnergyMax;
storedEnergy += compPowerBattery.StoredEnergy;
}
if (compFlickable.SwitchIsOn)
{
if (storedEnergy >= maxEnergy)
{
wantsSwitchOnField.SetValue(compFlickable, false);
compFlickable.SwitchIsOn = false;
FlickUtility.UpdateFlickDesignation(parent);
}
}
else
{
if (currentRate <= 0 &&
storedEnergy <= -currentRate * GenDate.TicksPerHour / 6.0f)
{
wantsSwitchOnField.SetValue(compFlickable, true);
compFlickable.SwitchIsOn = true;
FlickUtility.UpdateFlickDesignation(parent);
}
}
}
}
public static bool Prefix(PowerNet __instance)
{
if (__instance.transmitters.Any(connector => connector.parent.GetComp <CompSteamAlternator>() != null))
{
float num = __instance.CurrentEnergyGainRate();
float num2 = __instance.CurrentStoredEnergy();
if (num2 + num >= -1E-07f)
{
float num3;
if (__instance.batteryComps.Count > 0 && num2 >= 0.1f)
{
num3 = num2 - 5f;
}
else
{
num3 = num2;
}
if (num3 + num >= 0f)
{
List <CompPowerTrader> partsWantingPowerOn = new List <CompPowerTrader>();
for (int i = 0; i < __instance.powerComps.Count; i++)
{
if (!__instance.powerComps[i].PowerOn && FlickUtility.WantsToBeOn(__instance.powerComps[i].parent) && !__instance.powerComps[i].parent.IsBrokenDown())
{
partsWantingPowerOn.Add(__instance.powerComps[i]);
}
}
if (partsWantingPowerOn.Count > 0)
{
int num4 = 200 / partsWantingPowerOn.Count;
if (num4 < 30)
{
num4 = 30;
}
if (Find.TickManager.TicksGame % num4 == 0)
{
CompPowerTrader compPowerTrader = partsWantingPowerOn.RandomElement();
if (num + num2 >= -(compPowerTrader.EnergyOutputPerTick + 1E-07f))
{
compPowerTrader.PowerOn = true;
num += compPowerTrader.EnergyOutputPerTick;
}
}
}
}
Traverse.Create(__instance).Method("ChangeStoredEnergy", num).GetValue();
}
else if (Find.TickManager.TicksGame % 20 == 0)
{
List <CompPowerTrader> potentialShutdownParts = new List <CompPowerTrader>();
for (int j = 0; j < __instance.powerComps.Count; j++)
{
if (__instance.powerComps[j].PowerOn && __instance.powerComps[j].EnergyOutputPerTick < 0f)
{
potentialShutdownParts.Add(__instance.powerComps[j]);
}
}
if (potentialShutdownParts.Count > 0)
{
potentialShutdownParts.RandomElement().PowerOn = false;
}
}
return(false);
}
return(true);
}
static bool Prefix(ref PowerNet __instance)
{
float extra = __instance.CurrentEnergyGainRate() * RefcellRespeedConfig.currentTimeMultiplier;
float num1 = __instance.CurrentStoredEnergy();
if ((double)num1 + (double)extra >= -1.0000000116861E-07 && !__instance.Map.gameConditionManager.ElectricityDisabled)
{
if ((__instance.batteryComps.Count <= 0 || (double)num1 < 0.100000001490116 ? (double)num1 : (double)(num1 - 5f)) + (double)extra >= 0.0)
{
PowerNet.partsWantingPowerOn.Clear();
for (int index = 0; index < __instance.powerComps.Count; ++index)
{
if (!__instance.powerComps[index].PowerOn && FlickUtility.WantsToBeOn((Thing)__instance.powerComps[index].parent) && !__instance.powerComps[index].parent.IsBrokenDown())
{
PowerNet.partsWantingPowerOn.Add(__instance.powerComps[index]);
}
}
if (PowerNet.partsWantingPowerOn.Count > 0)
{
int num2 = 200 / PowerNet.partsWantingPowerOn.Count;
if (num2 < 30)
{
num2 = 30;
}
if (Find.TickManager.TicksGame % num2 < RefcellRespeedConfig.currentTimeMultiplier)
{
int num3 = Mathf.Max(1, Mathf.RoundToInt((float)PowerNet.partsWantingPowerOn.Count * 0.05f));
for (int index = 0; index < num3; ++index)
{
CompPowerTrader compPowerTrader = PowerNet.partsWantingPowerOn.RandomElement <CompPowerTrader>();
if (!compPowerTrader.PowerOn && (double)extra + (double)num1 >= -((double)compPowerTrader.EnergyOutputPerTick + 1.0000000116861E-07))
{
compPowerTrader.PowerOn = true;
extra += compPowerTrader.EnergyOutputPerTick;
}
}
}
}
}
__instance.ChangeStoredEnergy(extra);
}
else
{
if (Find.TickManager.TicksGame % 20 > RefcellRespeedConfig.currentTimeMultiplier - 1)
{
return(false);
}
PowerNet.potentialShutdownParts.Clear();
for (int index = 0; index < __instance.powerComps.Count; ++index)
{
if (__instance.powerComps[index].PowerOn && (double)__instance.powerComps[index].EnergyOutputPerTick < 0.0)
{
PowerNet.potentialShutdownParts.Add(__instance.powerComps[index]);
}
}
if (PowerNet.potentialShutdownParts.Count <= 0)
{
return(false);
}
int num2 = Mathf.Max(1, Mathf.RoundToInt((float)PowerNet.potentialShutdownParts.Count * 0.05f));
for (int index = 0; index < num2; ++index)
{
PowerNet.potentialShutdownParts.RandomElement <CompPowerTrader>().PowerOn = false;
}
}
return(false);
}
