public override void TickRare()
{
if (FlickUtility.WantsToBeOn(this))
{
GenTemperature.EqualizeTemperaturesThroughBuilding(this, ORIGINAL_VENT_RATE * VENT_RATE_MULTIPLIER, true);
}
}
protected override void GetAffectedThings()
{
int curTick = Find.TickManager.TicksGame;
if (lastTick + 10 > curTick)
{
return;
}
else
{
this.affectedThings = new List <Thing>();
foreach (Map map in Find.Maps)
{
foreach (PowerNet pn in map.powerNetManager.AllNetsListForReading)
{
foreach (CompPowerTrader cpt in pn.powerComps)
{
if (!cpt.PowerOn && FlickUtility.WantsToBeOn(cpt.parent) && !cpt.parent.IsBrokenDown())
{
this.affectedThings.Add(cpt.parent);
}
}
}
}
lastTick = curTick;
}
}
public override void PostDraw()
{
base.PostDraw();
if (!this.parent.IsBrokenDown())
{
if (this.flickableComp != null && !this.flickableComp.SwitchIsOn)
{
this.parent.Map.overlayDrawer.DrawOverlay(this.parent, OverlayTypes.PowerOff);
}
else if (FlickUtility.WantsToBeOn(this.parent))
{
if (!this.PowerOn)
{
/* Vector3 drawPos = parent.DrawPos;
*
* drawPos.y = BaseAlt + 0.181818187f;
* Graphics.DrawMesh(MeshPool.plane05, drawPos, Quaternion.identity, OutOfGas, 0);*/
Vector3 drawPos = parent.DrawPos;
drawPos.y = BaseAlt + 0.181818187f;
float num = ((float)Math.Sin((double)((Time.realtimeSinceStartup + 397f * (float)(parent.thingIDNumber % 571)) * 4f)) + 1f) * 0.5f;
num = 0.3f + num * 0.7f;
Material material = FadedMaterialPool.FadedVersionOf(OutOfGas, num);
Graphics.DrawMesh(MeshPool.plane08, drawPos, Quaternion.identity, material, 0);
//this.parent.Map.overlayDrawer.DrawOverlay(this.parent, OverlayTypes.NeedsPower);
}
}
}
}
public void UpdateDesiredPowerOutput()
{
if (parent.IsHashIntervalTick(60))
{
if (!parent.IsBrokenDown() && FlickUtility.WantsToBeOn(parent))
{
if (compMannable != null)
{
if (compMannable.MannedNow)
{
PowerOutput = (compMannable.ManningPawn.GetStatValue(StatDefOf.MoveSpeed) * 100) + Rand.RangeInclusive(-100, 100);
}
else
{
PowerOutput = 0;
}
}
else
{
Log.Error(parent + "not have CompProperties_UseBuilding.");
}
}
else
{
PowerOutput = 0;
}
}
}
public static void CanBeSeenOver_Postfix(Building b, ref bool __result)
{
if (b is Building_Window && FlickUtility.WantsToBeOn(b))
{
__result = true;
}
}
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 ShouldBeLitNow_Postfix(ref bool __result, CompGlower __instance)
{
if (__result)
{
return;
}
if (!__instance.parent.Spawned)
{
return;
}
if (!FlickUtility.WantsToBeOn(__instance.parent))
{
return;
}
Comp.VoidNetPort compPowerTrader = __instance.parent.TryGetComp <Comp.VoidNetPort>();
if (compPowerTrader != null && !compPowerTrader.PowerOn)
{
__result = true;
return;
}
CompRefuelable compRefuelable = __instance.parent.TryGetComp <CompRefuelable>();
if (compRefuelable != null && !compRefuelable.HasFuel)
{
return;
}
CompSendSignalOnCountdown compSendSignalOnCountdown = __instance.parent.TryGetComp <CompSendSignalOnCountdown>();
if (compSendSignalOnCountdown != null && compSendSignalOnCountdown.ticksLeft <= 0)
{
return;
}
return;
}
public void SteamSprayerTick()
{
if (sprayTicksLeft > 0)
{
sprayTicksLeft--;
CompSteam comp = parent.TryGetComp <CompSteam>();
CompSteamTrader trader = parent.TryGetComp <CompSteamTrader>();
if (Rand.Value < 0.6f && (trader == null || trader.SteamOn) &&
(comp != null && comp.SteamNet.CurrentStoredEnergy() >= PressureCutoff) &&
(parent.TryGetComp <CompFlickable>() == null || FlickUtility.WantsToBeOn(parent)))
{
MoteMaker.ThrowSmoke(parent.TrueCenter(), parent.Map, SmokeAmount);
MoteMaker.ThrowAirPuffUp(parent.TrueCenter(), parent.Map);
}
if (sprayTicksLeft <= 0)
{
endSprayCallback?.Invoke();
ticksUntilSpray = Rand.RangeInclusive(MinTicksBetweenSprays, MaxTicksBetweenSprays);
}
}
else
{
ticksUntilSpray--;
if (ticksUntilSpray <= 0)
{
startSprayCallback?.Invoke();
sprayTicksLeft = Rand.RangeInclusive(MinSprayDuration, MaxSprayDuration);
}
}
}
public override void TickRare()
{
if (!compPowerTrader.PowerOn || !FlickUtility.WantsToBeOn(this))
{
airFlowComp.isAirFlowing = false;
return;
}
IntVec3 intVec = Position + IntVec3.South.RotatedBy(Rotation);
IntVec3 intVec2 = Position + IntVec3.North.RotatedBy(Rotation);
if (intVec2.Impassable(Map) || intVec.Impassable(Map))
{
airFlowComp.isAirFlowing = false;
return;
}
float temperatureRed = intVec2.GetTemperature(Map);
float temperature = intVec.GetTemperature(Map);
if (temperatureRed == airFlowComp.targetTemperature || temperatureRed == temperature || (temperatureRed < airFlowComp.targetTemperature && temperatureRed > temperature) || (temperatureRed > airFlowComp.targetTemperature && temperatureRed < temperature))
{
airFlowComp.isAirFlowing = false;
return;
}
GenTemperature.EqualizeTemperaturesThroughBuilding(this, 14f, twoWay: true);
airFlowComp.isAirFlowing = true;
}
public static bool IsOnAndNotBrokenDown(this ThingWithComps thing)
{
if (FlickUtility.WantsToBeOn(thing) && !thing.IsBrokenDown())
{
return(true);
}
return(false);
}
public static SteamPowerNet NewPowerNetStartingFrom(Building root)
{
// return new net from contiguous buildings if flicked on (or not flickable) and steam building
return((root.TryGetComp <CompSteam>() != null && FlickUtility.WantsToBeOn(root))
? new SteamPowerNet(ContiguousSteamBuildings(root))
// if the building is an off valve, return the net at root's position, or if null build a new net at root
: new SteamPowerNet(root.GetComps <CompSteam>()));
}
public float Consumption(CompPowerTrader comp)
{
if (!comp.PowerOn && !FlickUtility.WantsToBeOn(comp.parent))
{
return(0);
}
return(Mathf.Max(-comp.PowerOutput, 0f));
}
public override void TickRare()
{
if (FlickUtility.WantsToBeOn(this))
{
//def
//GenTemperature.EqualizeTemperaturesThroughBuilding(this, 14f, twoWay: true);
GenTemperature.EqualizeTemperaturesThroughBuilding(this, 20f, twoWay: true);
}
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
refuelableComp = parent.GetComp <CompRefuelable>();
breakdownableComp = parent.GetComp <CompBreakdownable>();
if (Props.baseWaterConsumption < 0f && !parent.IsBrokenDown() && FlickUtility.WantsToBeOn(parent))
{
WaterOn = true;
}
}
private void UpdateGasGrid()
{
if (FlickUtility.WantsToBeOn(this) != this.wantsOnOld)
{
if (base.Spawned)
{
this.Map.GetComponent <PipeMapComponent>().Notfiy_TransmitterTransmitsPowerNowChanged(this.TryGetComp <CompPipe>());
}
this.wantsOnOld = FlickUtility.WantsToBeOn(this);
}
}
public static float WindowBaseBlockChance(Building_Window window, float result)
{
if (FlickUtility.WantsToBeOn(window))
{
return(WindowBaseFillPercent);
}
else
{
return(result);
}
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
breakdownableComp = parent.GetComp <CompBreakdownable>();
if (base.Props.basePowerConsumption < 0f && !parent.IsBrokenDown() && FlickUtility.WantsToBeOn(parent))
{
base.PowerOn = true;
}
compGasPowerPlantSettings = parent.GetComp <CompGasPowerPlantSettings>();
gasConsumePerTick = compGasPowerPlantSettings.Props.GasConsumption / 60000;
}
public override void ExposeData()
{
base.ExposeData();
if (Scribe.mode == LoadSaveMode.PostLoadInit)
{
if (this.flickableComp == null)
{
this.flickableComp = base.GetComp <CompFlickable>();
}
this.wantsOnOld = !FlickUtility.WantsToBeOn(this);
this.UpdateGasGrid();
}
}
public override string GetInspectString()
{
string text = base.GetInspectString();
if (!FlickUtility.WantsToBeOn(this))
{
if (!text.NullOrEmpty())
{
text += "\n";
}
text += "RimMisc_VentClosed".Translate();
}
return(text);
}
private static IEnumerable <CompSteam> ContiguousSteamBuildings(Building root)
{
closedSet.Clear();
currentSet.Clear();
openSet.Add(root);
do
{
foreach (Building building in openSet)
{
closedSet.Add(building);
}
HashSet <Building> hashSet = currentSet;
currentSet = openSet;
openSet = hashSet;
openSet.Clear();
foreach (Building currentBuilding in currentSet)
{
foreach (IntVec3 adjacentCell in GenAdj.CellsAdjacentCardinal(currentBuilding))
{
if (adjacentCell.InBounds(currentBuilding.Map))
{
List <Thing> thingList = adjacentCell.GetThingList(currentBuilding.Map);
foreach (Thing thing in thingList)
{
if (thing.TryGetComp <CompSteam>() != null)
{
Building building = (Building)thing;
if (FlickUtility.WantsToBeOn(building))
{
if (!openSet.Contains(building) && !currentSet.Contains(building) &&
!closedSet.Contains(building))
{
openSet.Add(building);
break;
}
}
}
}
}
}
}
}while (openSet.Count > 0);
return(from b in closedSet
select b.GetComp <CompSteam>());
}
public override void PostDraw()
{
base.PostDraw();
if (!this.parent.IsBrokenDown())
{
if (this.flickableComp != null && !this.flickableComp.SwitchIsOn)
{
this.parent.Map.overlayDrawer.DrawOverlay(this.parent, OverlayTypes.PowerOff); //TODO
}
else if (FlickUtility.WantsToBeOn(this.parent))
{
if (!this.SteamOn)
{
this.parent.Map.overlayDrawer.DrawOverlay(this.parent, OverlayTypes.NeedsPower); //TODO
}
}
}
}
// Token: 0x0600006F RID: 111 RVA: 0x00004414 File Offset: 0x00002614
public override string GetInspectString()
{
var stringBuilder = new StringBuilder();
stringBuilder.Append(base.GetInspectString());
if (FlickUtility.WantsToBeOn(this))
{
return(stringBuilder.ToString());
}
if (stringBuilder.Length > 0)
{
stringBuilder.AppendLine();
}
stringBuilder.Append("VentClosed".Translate());
return(stringBuilder.ToString());
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
RunningTrack_southSheet.Add(RunningTrack_south0);
RunningTrack_southSheet.Add(RunningTrack_south1);
RunningTrack_southSheet.Add(RunningTrack_south2);
RunningTrack_southSheet.Add(RunningTrack_south3);
RunningTrack_southSheet.Add(RunningTrack_south4);
RunningTrack_southSheet.Add(RunningTrack_south5);
RunningTrack_southSheet.Add(RunningTrack_south6);
RunningTrack_southSheet.Add(RunningTrack_south7);
RunningTrack_southSheet.Add(RunningTrack_south8);
RunningTrack_northSheet.Add(RunningTrack_north0);
RunningTrack_northSheet.Add(RunningTrack_north1);
RunningTrack_northSheet.Add(RunningTrack_north2);
RunningTrack_northSheet.Add(RunningTrack_north3);
RunningTrack_northSheet.Add(RunningTrack_north4);
RunningTrack_northSheet.Add(RunningTrack_north5);
RunningTrack_northSheet.Add(RunningTrack_north6);
RunningTrack_northSheet.Add(RunningTrack_north7);
RunningTrack_northSheet.Add(RunningTrack_north8);
RunningTrack_eastSheet.Add(RunningTrack_east0);
RunningTrack_eastSheet.Add(RunningTrack_east1);
RunningTrack_eastSheet.Add(RunningTrack_east2);
RunningTrack_eastSheet.Add(RunningTrack_east3);
RunningTrack_eastSheet.Add(RunningTrack_east4);
RunningTrack_eastSheet.Add(RunningTrack_east5);
RunningTrack_eastSheet.Add(RunningTrack_east6);
RunningTrack_eastSheet.Add(RunningTrack_east7);
RunningTrack_eastSheet.Add(RunningTrack_east8);
compMannable = parent.TryGetComp <CompMannable>();
if (base.Props.basePowerConsumption <= 0f && !parent.IsBrokenDown() && FlickUtility.WantsToBeOn(parent))
{
base.PowerOn = true;
}
//Log.Message("RunningTrack_southSheet frames count = " + RunningTrack_southSheet.Count);
}
public override string GetInspectString()
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(base.GetInspectString());
if (stringBuilder.Length != 0)
{
stringBuilder.AppendLine();
}
stringBuilder.Append("PowerSwitch_Power".Translate() + ": ");
if (FlickUtility.WantsToBeOn(this))
{
stringBuilder.Append("On".Translate().ToLower());
}
else
{
stringBuilder.Append("Off".Translate().ToLower());
}
return(stringBuilder.ToString());
}
// Token: 0x0600006E RID: 110 RVA: 0x00004338 File Offset: 0x00002538
public override void TickRare()
{
var tempRange = default(FloatRange);
GetSafeTemps(this, UseFixed, out var tempMin, out var tempMax);
tempRange.min = tempMin;
tempRange.max = tempMax;
if (UseFixed && RPGVentCheckTemps(this, tempRange) || !UseFixed)
{
if (!InRangeATM && VentIsWorking(this))
{
InRangeATM = !InRangeATM;
if (!flickableComp.SwitchIsOn)
{
flickableComp.DoFlick();
}
}
if (!FlickUtility.WantsToBeOn(this))
{
return;
}
if (VentIsWorking(this))
{
GenTemperature.EqualizeTemperaturesThroughBuilding(this, 20f, true);
return;
}
GenTemperature.EqualizeTemperaturesThroughBuilding(this, 14f, true);
}
else
{
InRangeATM = false;
if (VentIsWorking(this) && flickableComp.SwitchIsOn)
{
flickableComp.DoFlick();
}
}
}
public void PowerNetTick()
{
float num = this.CurrentEnergyGainRate();
float num2 = this.CurrentStoredEnergy();
if (num2 + num >= -1E-07f && !this.shieldNetManager.map.gameConditionManager.ConditionIsActive(GameConditionDefOf.SolarFlare))
{
float num3;
if (this.batteryComps.Count > 0 && num2 >= 0.1f)
{
num3 = num2 - 5f;
}
else
{
num3 = num2;
}
if (UnityData.isDebugBuild)
{
this.debugLastApparentStoredEnergy = num3;
this.debugLastCreatedEnergy = num;
this.debugLastRawStoredEnergy = num2;
}
if (num3 + num >= 0f)
{
ShieldNet.partsWantingPowerOn.Clear();
for (int i = 0; i < this.powerComps.Count; i++)
{
if (!this.powerComps[i].PowerOn && FlickUtility.WantsToBeOn(this.powerComps[i].parent) && !this.powerComps[i].parent.IsBrokenDown())
{
ShieldNet.partsWantingPowerOn.Add(this.powerComps[i]);
}
}
if (ShieldNet.partsWantingPowerOn.Count > 0)
{
int num4 = 200 / ShieldNet.partsWantingPowerOn.Count;
if (num4 < 30)
{
num4 = 30;
}
if (Find.TickManager.TicksGame % num4 == 0)
{
CompShieldTrader compPowerTrader = ShieldNet.partsWantingPowerOn.RandomElement <CompShieldTrader>();
if (num + num2 >= -(compPowerTrader.EnergyOutputPerTick + 1E-07f))
{
compPowerTrader.PowerOn = true;
num += compPowerTrader.EnergyOutputPerTick;
}
}
}
}
this.ChangeStoredEnergy(num);
}
else if (Find.TickManager.TicksGame % 20 == 0)
{
ShieldNet.potentialShutdownParts.Clear();
for (int j = 0; j < this.powerComps.Count; j++)
{
if (this.powerComps[j].PowerOn && this.powerComps[j].EnergyOutputPerTick < 0f)
{
ShieldNet.potentialShutdownParts.Add(this.powerComps[j]);
}
}
if (ShieldNet.potentialShutdownParts.Count > 0)
{
ShieldNet.potentialShutdownParts.RandomElement <CompShieldTrader>().PowerOn = false;
}
}
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
this.breakdownableComp = this.parent.GetComp <CompBreakdownable>();
if (base.Props.basePowerConsumption < 0f && !this.parent.IsBrokenDown() && FlickUtility.WantsToBeOn(this.parent))
{
base.PowerOn = true;
}
if (parent.GetComp <CompPowerBattery>() != null)
{
compPowerBattery = parent.GetComp <CompPowerBattery>();
}
currentPowerEfficiency = 1;
additionalEfficiency = ((CompPropertie_ResonancePowerPlant)Props).additionalEfficiency;
linkedBuildings.Add(parent);
LinkToNearbyBuildings();
/*Log.Message(parent.def.label + ": " + parent.GetHashCode() + " List");
* foreach(Thing t in linkedBuildings)
* {
* Log.Message(t.def.label + ": " + t.GetHashCode());
* }*/
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
this.breakdownableComp = this.parent.GetComp <CompBreakdownable>();
if (base.Props.basePowerConsumption < 0f && !this.parent.IsBrokenDown() && FlickUtility.WantsToBeOn(this.parent))
{
base.PowerOn = true;
}
if (parent.GetComp <CompPowerBattery>() != null)
{
compPowerBattery = parent.GetComp <CompPowerBattery>();
}
}
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 PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
this.refuelableComp = this.parent.GetComp <CompRefuelable>();
this.breakdownableComp = this.parent.GetComp <CompBreakdownable>();
this.variableHeatPusherComp = this.parent.GetComp <CompVariableHeatPusher>();
if (base.Props.basePowerConsumption < 0f && !this.parent.IsBrokenDown() && FlickUtility.WantsToBeOn(this.parent))
{
base.PowerOn = true;
}
}
