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 static void SetNetColor(PowerNet net)
{
if (net.powerComps.Count == 0 && net.batteryComps.Count == 0) // just conduits
{
netColors.SetOrAdd(net, ActiveCircuitsSettings.justConduits);
return;
}
float production;
float consumption;
PowerMetrics(net, out production, out consumption);
if (consumption == 0) // nothing using power
{
netColors.SetOrAdd(net, ActiveCircuitsSettings.nothingConnected);
return;
}
float rate = consumption + production;
if (rate < 0)
{
float stored = net.CurrentStoredEnergy();
if (stored < 5f)
{
netColors.SetOrAdd(net, ActiveCircuitsSettings.noPower);
}
else
{
netColors.SetOrAdd(net, ActiveCircuitsSettings.drainingPower);
}
return;
}
else // rate >= 0
{
if (rate > 1.5 * consumption || net.CurrentStoredEnergy() >= consumption) // 1 day of power
{
netColors.SetOrAdd(net, ActiveCircuitsSettings.surplusPower);
}
else
{
netColors.SetOrAdd(net, ActiveCircuitsSettings.hasPower);
}
return;
}
}
private bool HasEnoughEnergy()
{
float?num;
if (powerTrader == null)
{
num = null;
}
else
{
PowerNet powerNet = powerTrader.PowerNet;
num = ((powerNet != null) ? new float?(powerNet.CurrentStoredEnergy()) : null);
}
float?num2 = num;
float num3 = activePower;
return(num2.GetValueOrDefault() >= num3 & num2 != null);
}
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 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);
}
public override void Tick()
{
base.Tick();
if (this.StoredEnergy > 0)
{
this.StoredEnergy -= 0.01f;
}
else
{
if (!this.Downed)
{
Hediff hediff = HediffMaker.MakeHediff(ProfSchmilvsPokemon.DefOfs.HediffDefOf.OutOfPower, this);
this.health.AddHediff(hediff);
}
}
if (closestCompPower == null && this.StoredEnergy >= this.storedEnergyMax * 0.21f && this.Faction != null)
{
if (this.repairJob == null)
{
List <Thing> toRepair = base.Map.listerBuildingsRepairable.RepairableBuildings(this.Faction);
if (!toRepair.NullOrEmpty())
{
this.repairJob = toRepair[0];
this.jobs.ClearQueuedJobs();
this.pather.StartPath(new LocalTargetInfo(this.repairJob.Position), Verse.AI.PathEndMode.Touch);
}
}
else
{
if (this.repairJob.MaxHitPoints == this.repairJob.HitPoints)
{
base.Map.listerBuildingsRepairable.Notify_BuildingRepaired((Building)this.repairJob);
this.repairJob = null;
this.jobs.ClearQueuedJobs();
}
else
{
if (this.Position.AdjacentTo8WayOrInside(this.repairJob.Position))
{
this.repairing();
}
else if (this.pather.Destination != new LocalTargetInfo(this.repairJob.Position))
{
this.pather.StartPath(new LocalTargetInfo(this.repairJob.Position), Verse.AI.PathEndMode.Touch);
}
}
}
}
if (closestCompPower != null && this.StoredEnergy >= this.storedEnergyMax)
{
closestCompPower = null;
this.jobs.ClearQueuedJobs();
}
if (this.Downed)
{
if (this.StoredEnergy < this.storedEnergyMax * 0.2f)
{
List <CompPower> dummylist = Spawner.spawnerPokemon.PowerComps;
if (!dummylist.NullOrEmpty())
{
float distance = 999999f;
foreach (CompPower cp in dummylist)
{
float compareDistance = this.Position.DistanceTo(cp.parent.Position);
if (compareDistance < distance)
{
distance = compareDistance;
closestCompPower = cp;
}
}
}
}
if (this.Position.AdjacentTo8WayOrInside(this.closestCompPower.parent.Position))
{
PowerNet pn = this.closestCompPower.PowerNet;
if (pn != null)
{
float currentEnergy = pn.CurrentStoredEnergy();
if (currentEnergy >= 0.5f)
{
List <CompPowerBattery> cpb = pn.batteryComps;
CompPowerBattery bat = null;
foreach (CompPowerBattery c in cpb)
{
if (c.StoredEnergy >= 0.5f)
{
bat = c;
break;
}
}
if (bat != null)
{
this.StoredEnergy += 0.5f;
bat.DrawPower(0.5f);
}
}
}
}
if (this.StoredEnergy > this.storedEnergyMax * 0.2f)
{
List <Hediff> heds = this.health.hediffSet.hediffs;
if (!heds.NullOrEmpty())
{
Hediff oop = null;
foreach (Hediff h in heds)
{
if (h.def.Equals(ProfSchmilvsPokemon.DefOfs.HediffDefOf.OutOfPower))
{
oop = h;
}
}
if (oop != null)
{
this.health.RemoveHediff(oop);
}
}
}
}
else
{
if (closestCompPower == null)
{
if (this.StoredEnergy > 0 && this.StoredEnergy < this.storedEnergyMax * 0.2f)
{
List <CompPower> dummylist = Spawner.spawnerPokemon.PowerComps;
if (!dummylist.NullOrEmpty())
{
float distance = 999999f;
foreach (CompPower cp in dummylist)
{
float compareDistance = this.Position.DistanceTo(cp.parent.Position);
if (compareDistance < distance)
{
distance = compareDistance;
closestCompPower = cp;
}
}
this.pather.StartPath(new LocalTargetInfo(this.closestCompPower.parent.Position), Verse.AI.PathEndMode.OnCell);
}
}
}
else
{
if (this.Position.AdjacentTo8WayOrInside(this.closestCompPower.parent.Position))
{
PowerNet pn = this.closestCompPower.PowerNet;
if (pn != null)
{
float currentEnergy = pn.CurrentStoredEnergy();
if (currentEnergy >= 0.5f)
{
List <CompPowerBattery> cpb = pn.batteryComps;
CompPowerBattery bat = null;
foreach (CompPowerBattery c in cpb)
{
if (c.StoredEnergy >= 0.5f)
{
bat = c;
break;
}
}
if (bat != null)
{
this.StoredEnergy += 0.5f;
bat.DrawPower(0.5f);
this.evolve();
}
}
}
}
else
{
if (this.pather.Destination != new LocalTargetInfo(this.closestCompPower.parent.Position))
{
this.jobs.ClearQueuedJobs();
this.pather.StartPath(new LocalTargetInfo(this.closestCompPower.parent.Position), Verse.AI.PathEndMode.Touch);
}
}
}
}
}
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);
}
