// 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 float MitigateSurge(float amount)
{
if (compBreakdownable == null || !compBreakdownable.BrokenDown)
{
if (compBreakdownable != null && breakdownOnTrip)
{
compBreakdownable.DoBreakdown();
return(surgeMitigation);
}
else if (compFlickable != null)
{
compFlickable.ResetToOn();
compFlickable.DoFlick();
FlickUtility.UpdateFlickDesignation(parent);
return(surgeMitigation);
}
}
return(0.0f);
}
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 void Flick()
{
if (FlickComp == null)
{
return;
}
bool currentWantsToBeOn = (bool)WantsToBeOnInfo.GetValue(FlickComp);
WantsToBeOnInfo.SetValue(FlickComp, !currentWantsToBeOn);
if (InstantFlickActive)
{
FlickComp.DoFlick();
}
else
{
FlickUtility.UpdateFlickDesignation(Thing);
}
}
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());
}
public override IEnumerable <Command> CompGetGizmosExtra()
{
if (canSwitchModes)
{
Command_Action commandModeSwitch = new Command_Action();
commandModeSwitch.groupKey = 676192;
if (switchedToChunkSilo)
{
commandModeSwitch.defaultLabel = "CompRTDeviceModeSwitcher_StockpileModeLabel".Translate();
commandModeSwitch.defaultDesc = "CompRTDeviceModeSwitcher_StockpileModeDesc".Translate();
commandModeSwitch.icon = Resources.stockpileTexture;
}
else
{
commandModeSwitch.defaultLabel = "CompRTDeviceModeSwitcher_ChunkSiloModeLabel".Translate();
commandModeSwitch.defaultDesc = "CompRTDeviceModeSwitcher_ChunkSiloModeDesc".Translate();
commandModeSwitch.icon = Resources.chunkSiloTexture;
}
commandModeSwitch.action = () =>
{
CompFlickable compFlickable = parent.TryGetComp <CompFlickable>();
if (compFlickable != null)
{
compFlickable.ResetToOn();
compFlickable.DoFlick();
FlickUtility.UpdateFlickDesignation(parent);
}
if (switchedToChunkSilo)
{
CompRTQuantumChunkSilo compChunkSilo = parent.TryGetComp <CompRTQuantumChunkSilo>();
if (compChunkSilo != null)
{
compChunkSilo.EmptyOut();
}
}
switchedToChunkSilo = !switchedToChunkSilo;
SortOutComps();
};
yield return(commandModeSwitch);
}
}
// 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 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);
}
}
}
}
protected override Job TryGivePlayJob(Pawn pawn, Thing thing)
{
CompPowerTrader compPowerTrader = (CompPowerTrader)thing.TryGetComp <CompPowerTrader>();
if (compPowerTrader != null)
{
if (compPowerTrader.PowerNet.CurrentStoredEnergy() <= 0 || thing.IsBrokenDown() || !FlickUtility.WantsToBeOn(thing))
{
return(null);
}
}
Room room = pawn.GetRoom(RegionType.Set_Passable);
if (room != null)
{
List <Building_Bed> containedBeds = room.ContainedBeds.ToList();
for (int i = 0; i < containedBeds.Count(); i++)
{
Building_Bed bed = containedBeds[i];
if (bed.owners != null)
{
for (int j = 0; j < bed.owners.Count(); j++)
{
Pawn bedOwner = bed.owners[j];
if (bedOwner.CurrentBed() == bed)
{
return(null);
}
}
}
}
}
List <IntVec3> thingWatchCells = WatchBuildingUtility.CalculateWatchCells(thing.def, thing.Position, thing.Rotation, thing.Map).ToList();
for (int i = 0; i < thingWatchCells.Count(); i++)
{
int cellRand = Rand.RangeInclusive(0, thingWatchCells.Count());
IntVec3 cell = thingWatchCells[cellRand];
if (cell.Standable(pawn.Map))
{
//Log.Message(pawn + " watch cell = " + cellRand + " of " + thingWatchCells.Count());
return(new Job(def.jobDef, thing, cell));
}
}
return(null);
}
public override void CompTick()
{
base.CompTick();
if (parent.IsHashIntervalTick(8))
{
if (compPowerTrader != null)
{
if (compPowerTrader.PowerNet.CurrentStoredEnergy() <= 0 || parent.IsBrokenDown() || !FlickUtility.WantsToBeOn(parent))
{
powered = false;
return;
}
}
powered = true;
//Log.Message("currFrame = " + currFrame);
if (currFrame >= 19)
{
currFrame = -1;
}
currFrame++;
}
}
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;
}
}
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
//this.mannableComp = this.parent.GetComp<CompMannable>();
this.breakdownableComp = this.parent.GetComp <CompBreakdownable>();
this.hpgmcyclecomp = this.parent.GetComp <HPGMcyclecomp>();
if (base.Props.basePowerConsumption < 0f && !this.parent.IsBrokenDown() && FlickUtility.WantsToBeOn(this.parent))
{
base.PowerOn = true;
}
}
public void WaterNetTick()
{
float num = this.CurrentWaterGainRate();
float num2 = this.CurrentStoredWater();
if (num2 + num >= -1E-07f && !this.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.debugLastApparentStoredWater = num3;
this.debugLastCreatedWater = num;
this.debugLastRawStoredWater = num2;
}
if (num3 + num >= 0f)
{
WaterNet.partsWantingWaterOn.Clear();
for (int i = 0; i < this.WaterComps.Count; i++)
{
if (!this.WaterComps[i].WaterOn && FlickUtility.WantsToBeOn(this.WaterComps[i].parent) && !this.WaterComps[i].parent.IsBrokenDown())
{
WaterNet.partsWantingWaterOn.Add(this.WaterComps[i]);
}
}
if (WaterNet.partsWantingWaterOn.Count > 0)
{
int num4 = 200 / WaterNet.partsWantingWaterOn.Count;
if (num4 < 30)
{
num4 = 30;
}
if (Find.TickManager.TicksGame % num4 == 0)
{
int num5 = Mathf.Max(1, Mathf.RoundToInt((float)WaterNet.partsWantingWaterOn.Count * 0.05f));
for (int j = 0; j < num5; j++)
{
CompWaterTrader compWaterTrader = WaterNet.partsWantingWaterOn.RandomElement <CompWaterTrader>();
if (!compWaterTrader.WaterOn)
{
if (num + num2 >= -(compWaterTrader.WaterOutputPerTick + 1E-07f))
{
compWaterTrader.WaterOn = true;
num += compWaterTrader.WaterOutputPerTick;
}
}
}
}
}
}
this.ChangeStoredWater(num);
}
else if (Find.TickManager.TicksGame % 20 == 0)
{
WaterNet.potentialShutdownParts.Clear();
for (int k = 0; k < this.WaterComps.Count; k++)
{
if (this.WaterComps[k].WaterOn && this.WaterComps[k].WaterOutputPerTick < 0f)
{
WaterNet.potentialShutdownParts.Add(this.WaterComps[k]);
}
}
if (WaterNet.potentialShutdownParts.Count > 0)
{
int num6 = Mathf.Max(1, Mathf.RoundToInt((float)WaterNet.potentialShutdownParts.Count * 0.05f));
for (int l = 0; l < num6; l++)
{
WaterNet.potentialShutdownParts.RandomElement <CompWaterTrader>().WaterOn = false;
}
}
}
}
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 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)
{
base.PostSpawnSetup(respawningAfterLoad);
refuelableComp = parent.GetComp <CompRefuelable>();
breakdownableComp = parent.GetComp <CompBreakdownable>();
waterTankComp = parent.GetComp <CompWaterTank>();
if ((Props.baseSteamConsumption < 0f || Props.baseWaterConsumption < 0f) && !parent.IsBrokenDown() && FlickUtility.WantsToBeOn(parent))
{
SteamOn = true;
}
}
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>();
}
}
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);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawnedOrNull(thingInd, JobCondition.Incompletable); // thing
this.FailOnForbidden(thingInd);
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.OnCell)); // cell
CompPowerTrader compPowerTrader = (CompPowerTrader)thing.TryGetComp <CompPowerTrader>();
float statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor, true);
Toil sing = new Toil();
sing.tickAction = delegate
{
pawn.rotationTracker.FaceCell(TargetA.Cell);
if (compPowerTrader != null)
{
if (compPowerTrader.PowerNet.CurrentStoredEnergy() <= 0 || thing.IsBrokenDown() || !FlickUtility.WantsToBeOn(thing))
{
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
}
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, statValue);
if (pawn.IsHashIntervalTick(100))
{
MoteMaker.ThrowMetaIcon(pawn.Position, pawn.Map, ThingDefOf.Mote_Note);
// add thought to everyone in room
Room room = pawn.GetRoom(RegionType.Set_Passable);
if (room != null)
{
int stage = 0;
SkillRecord artSkill = pawn.skills.GetSkill(SkillDefOf.Artistic);
if (!artSkill.TotallyDisabled)
{
float stageFloat = GetSingThoughtState(artSkill.Level) * pawn.health.capacities.GetLevel(PawnCapacityDefOf.Talking) * pawn.health.capacities.GetLevel(PawnCapacityDefOf.Hearing);
stage = (int)stageFloat;
if (stage > 4)
{
stage = 4;
}
}
List <Thing> containedAndAdjacentThings = room.ContainedAndAdjacentThings;
for (int i = 0; i < containedAndAdjacentThings.Count; i++)
{
Pawn pawn2 = containedAndAdjacentThings[i] as Pawn;
if (pawn2 != null)
{
if (pawn2 != pawn && pawn2.RaceProps.Humanlike)
{
//Log.Message("Singer: " + pawn + ". Stage: " + stage);
//Log.Message("Listener: " + pawn2);
if (pawn.health.hediffSet.HasHediff(HediffDefOf.AvaliBiology)) // Avali singer
{
if (pawn2.health.hediffSet.HasHediff(HediffDefOf.AvaliBiology)) // Avali listener
{
if (stage < 2)
{
stage = 2;
}
stage = CheckSingerTraits(stage);
pawn2.GiveThoughtWithStage(ThoughtDefOf.ListenerAvali, stage);
}
else // non Avali listener
{
if (stage < 1)
{
stage = 1;
}
stage = CheckSingerTraits(stage);
pawn2.GiveThoughtWithStage(ThoughtDefOf.ListenerAny, stage);
}
}
else // non Avali singer
{
stage = CheckSingerTraits(stage);
if (pawn2.health.hediffSet.HasHediff(HediffDefOf.AvaliBiology)) // Avali listener
{
pawn2.GiveThoughtWithStage(ThoughtDefOf.ListenerAvali, stage);
}
else // non Avali listener
{
pawn2.GiveThoughtWithStage(ThoughtDefOf.ListenerAny, stage);
}
}
}
}
}
}
}
};
sing.handlingFacing = true;
sing.socialMode = RandomSocialMode.Off;
sing.defaultCompleteMode = ToilCompleteMode.Delay;
sing.defaultDuration = job.def.joyDuration;
sing.AddFinishAction(delegate
{
JoyUtility.TryGainRecRoomThought(pawn);
});
yield return(sing);
yield break;
}
private void SetFlicked(bool flicked)
{
wantsSwitchOnField.SetValue(compFlickable, flicked);
compFlickable.SwitchIsOn = flicked;
FlickUtility.UpdateFlickDesignation(parent);
}
public new void PowerNetTick()
{
List <CompPowerTrader> partsWantingPowerOn = HighVoltagePowerNet.partsWantingPowerOn;
float consumed;
float generated;
this.GetEnergyRates(out generated, out consumed);
float gainRate = consumed + generated;
float storedEnergy = this.CurrentStoredEnergy();
if (storedEnergy + gainRate >= -1E-07f && !this.Map.gameConditionManager.ElectricityDisabled)
{
float num3;
if (this.batteryComps.Count > 0 && storedEnergy >= 0.1f)
{
num3 = storedEnergy - 5f;
}
else
{
num3 = storedEnergy;
}
if (num3 + gainRate >= 0f)
{
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())
{
partsWantingPowerOn.Add(this.powerComps[i]);
}
}
if (partsWantingPowerOn.Count > 0)
{
int num4 = 200 / partsWantingPowerOn.Count;
if (num4 < 30)
{
num4 = 30;
}
if (Find.TickManager.TicksGame % num4 == 0)
{
int num5 = Mathf.Max(1, Mathf.RoundToInt((float)partsWantingPowerOn.Count * 0.05f));
for (int j = 0; j < num5; j++)
{
CompPowerTrader compPowerTrader = partsWantingPowerOn.RandomElement <CompPowerTrader>();
if (!compPowerTrader.PowerOn && gainRate + storedEnergy >= -(compPowerTrader.EnergyOutputPerTick + 1E-07f))
{
compPowerTrader.PowerOn = true;
gainRate += compPowerTrader.EnergyOutputPerTick;
}
}
}
}
}
this.ChangeStoredEnergy(gainRate);
return;
}
if (Find.TickManager.TicksGame % 20 == 0)
{
List <CompPowerTrader> potentialShutdownParts = HighVoltagePowerNet.potentialShutdownParts;
potentialShutdownParts.Clear();
for (int k = 0; k < this.powerComps.Count; k++)
{
if (this.powerComps[k].PowerOn && this.powerComps[k].EnergyOutputPerTick < 0f)
{
potentialShutdownParts.Add(this.powerComps[k]);
}
}
if (potentialShutdownParts.Count > 0)
{
int num6 = Mathf.Max(1, Mathf.RoundToInt((float)potentialShutdownParts.Count * 0.05f));
for (int l = 0; l < num6; l++)
{
potentialShutdownParts.RandomElement <CompPowerTrader>().PowerOn = false;
}
}
}
return;
}
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 void PowerNetTick()
{
float num = this.CurrentEnergyGainRate();
float num2 = this.CurrentStoredEnergy();
if (num2 + num >= -1E-07f)
{
float num3;
if (this.batteryComps.Count > 0 && num2 >= 0.1f)
{
num3 = num2 - 5f;
}
else
{
num3 = num2;
}
if (num3 + num >= 0f)
{
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())
{
partsWantingPowerOn.Add(this.powerComps[i]);
}
}
if (partsWantingPowerOn.Count > 0)
{
int num4 = 200 / partsWantingPowerOn.Count;
if (num4 < 30)
{
num4 = 30;
}
if (Find.TickManager.TicksGame % num4 == 0)
{
int num5 = Mathf.Max(1, Mathf.RoundToInt((float)partsWantingPowerOn.Count * 0.05f));
for (int j = 0; j < num5; j++)
{
CompPipeTrader compPowerTrader = partsWantingPowerOn.RandomElement <CompPipeTrader>();
if (!compPowerTrader.PowerOn)
{
if (num + num2 >= -(compPowerTrader.EnergyOutputPerTick + 1E-07f))
{
compPowerTrader.PowerOn = true;
num += compPowerTrader.EnergyOutputPerTick;
}
}
}
}
}
}
this.ChangeStoredEnergy(num);
}
else if (Find.TickManager.TicksGame % 20 == 0)
{
potentialShutdownParts.Clear();
for (int k = 0; k < this.powerComps.Count; k++)
{
if (this.powerComps[k].PowerOn && this.powerComps[k].EnergyOutputPerTick < 0f)
{
potentialShutdownParts.Add(this.powerComps[k]);
}
}
if (potentialShutdownParts.Count > 0)
{
int num6 = Mathf.Max(1, Mathf.RoundToInt((float)potentialShutdownParts.Count * 0.05f));
for (int l = 0; l < num6; l++)
{
potentialShutdownParts.RandomElement <CompPipeTrader>().PowerOn = false;
}
}
}
}
private bool WantOnline()
{
return(FlickUtility.WantsToBeOn(parent));
}
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();
}
