static HighVoltageBase()
{
foreach (ThingDef def in DefDatabase <ThingDef> .AllDefsListForReading)
{
if (def.GetCompProperties <CompProperties_DVoltage>() == null)
{
CompProperties_Power powerComp = def.GetCompProperties <CompProperties_Power>();
if (powerComp != null)
{
if (powerComp.compClass == typeof(CompPowerTransmitter))
{
if (def.stuffCategories == null)
{
if (def.costList != null)
{
StuffIt(def);
}
def.ResolveReferences();
def.PostLoad();
}
CompProperties_DVoltage comp = new CompProperties_DVoltage();
def.comps.Add(comp);
}
}
}
}
CostListCalculator.Reset();
GenConstruct.Reset();
DefDatabase <DesignationCategoryDef> .ResolveAllReferences();
}
public override void SetUpPowerVars()
{
base.SetUpPowerVars();
CompProperties_Power props = base.Props;
this.PowerOutput = -1f * props.basePowerConsumption;
this.powerLastOutputted = (props.basePowerConsumption <= 0f);
// === NEW ADDITION ===
CompProperties_Power_EmergencyPowerCore props2 = base.Props as CompProperties_Power_EmergencyPowerCore;
if (props == null)
{
return;
}
this.generatingTime = props2.baseGeneratingTime;
this.cooldownTime = props2.baseCoolingTime;
this.showEmergencyTimeInSeconds = props2.showEmergencyTimeInSeconds;
this.explosionChance = props2.ExplosionChance;
this.explosionRadius = props2.ExplosionRadius;
this.explosionDamageDef = props2.ExplosionDamageDef;
// === END NEW ADDITION ===
}
public void Add(Building b)
{
if (b.def.building != null && b.def.building.isNaturalRock)
{
return;
}
if (b.Faction == Faction.OfPlayer)
{
allBuildingsColonist.Add(b);
if (b is IAttackTarget)
{
allBuildingsColonistCombatTargets.Add(b);
}
}
else
{
allBuildingsNonColonist.Add(b);
}
CompProperties_Power compProperties = b.def.GetCompProperties <CompProperties_Power>();
if (compProperties != null && compProperties.shortCircuitInRain)
{
allBuildingsColonistElecFire.Add(b);
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
refuelable = GetComp <CompRefuelable>();
power = GetComp <CompPowerTrader>();
props = power.Props;
fuelprops = refuelable.Props;
fuelprops.fuelConsumptionRate = CryptoRestoreSettings.fuelRate / 60f;
}
public override void TickRare()
{
if (this.compPowerTrader.PowerOn)
{
float ambientTemperature = base.AmbientTemperature;
float num;
if (ambientTemperature > this.compTempControl.targetTemperature - 1 && ambientTemperature < this.compTempControl.targetTemperature + 1)
{
num = 0f;
}
else if (ambientTemperature < this.compTempControl.targetTemperature - 1)
{
if (ambientTemperature < 20f)
{
num = 1f;
}
else if (ambientTemperature > 150f)
{
num = 0f;
}
else
{
num = Mathf.InverseLerp(150f, 100f, ambientTemperature);
}
}
else if (ambientTemperature > this.compTempControl.targetTemperature + 1)
{
if (ambientTemperature < -50f)
{
num = -Mathf.InverseLerp(-273f, -50f, ambientTemperature);
}
else
{
num = -1f;
}
}
else
{
num = 0f;
}
float energyLimit = this.compTempControl.Props.energyPerSecond * num * 4.16666651f;
float num2 = GenTemperature.ControlTemperatureTempChange(base.Position, base.Map, energyLimit, this.compTempControl.targetTemperature);
bool flag = !Mathf.Approximately(num2, 0f);
CompProperties_Power props = this.compPowerTrader.Props;
if (flag)
{
this.GetRoom(RegionType.Set_All).Temperature += num2;
this.compPowerTrader.PowerOutput = -props.basePowerConsumption;
}
else
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption * this.compTempControl.Props.lowPowerConsumptionFactor;
}
this.compTempControl.operatingAtHighPower = flag;
}
}
private void StartSustainerPoweredIfInactive()
{
CompProperties_Power props = base.Props;
if (!props.soundAmbientPowered.NullOrUndefined() && this.sustainerPowered == null)
{
SoundInfo info = SoundInfo.InMap(this.parent, MaintenanceType.None);
this.sustainerPowered = props.soundAmbientPowered.TrySpawnSustainer(info);
}
}
public static void ApplyFactor(float newFactor)
{
CreateBaseEnergyMap();
foreach (KeyValuePair <string, float> basePower in BaseEnergy)
{
ThingDef def = FridgeDefs[basePower.Key];
CompProperties_Power power = def.GetCompProperties <CompProperties_Power>();
power.basePowerConsumption = basePower.Value * newFactor;
}
}
public override void Apply()
{
ThoughtDef.Named("PsychicEmanatorSoothe").stages.First().baseMoodEffect = 6f;
ThingDefOf.PsychicEmanator.specialDisplayRadius = 20f;
CompProperties_Power power = (CompProperties_Power)ThingDefOf.PsychicEmanator.comps.FirstOrDefault(x => x is CompProperties_Power);
if (power != null)
{
power.basePowerConsumption *= 1.5f;
}
this.Active = true;
}
public void Remove(Building b)
{
allBuildingsColonist.Remove(b);
if (b is IAttackTarget)
{
allBuildingsColonistCombatTargets.Remove(b);
}
CompProperties_Power compProperties = b.def.GetCompProperties <CompProperties_Power>();
if (compProperties != null && compProperties.shortCircuitInRain)
{
allBuildingsColonistElecFire.Remove(b);
}
}
public void Remove(Building b)
{
this.allBuildingsColonist.Remove(b);
if (b is IAttackTarget)
{
this.allBuildingsColonistCombatTargets.Remove(b);
}
CompProperties_Power compProperties = b.def.GetCompProperties <CompProperties_Power>();
if (compProperties != null && compProperties.startElectricalFires)
{
this.allBuildingsColonistElecFire.Remove(b);
}
}
public override void TickRare()
{
if (this.compPowerTrader.PowerOn)
{
IntVec3 vecNorth = base.Position + IntVec3.North.RotatedBy(base.Rotation);
bool hotIsHot = false;
Room roomNorth = vecNorth.GetRoom(this.Map);
if (!vecNorth.Impassable(base.Map) && (roomNorth != null))
{
var temperature = roomNorth.Temperature;
float energyMod;
if (temperature < 20f)
{
energyMod = 1f;
}
else
{
energyMod = temperature > 120f
? 0f
: Mathf.InverseLerp(120f, 20f, temperature);
}
var energyLimit = compTempControl.Props.energyPerSecond * energyMod * 4.16666651f;
if (temperature > this.compTempControl.targetTemperature)
{
energyLimit *= -1;
}
var hotAir = GenTemperature.ControlTemperatureTempChange(vecNorth, this.Map, energyLimit,
compTempControl.targetTemperature);
hotIsHot = !Mathf.Approximately(hotAir, 0f);
if (hotIsHot)
{
vecNorth.GetRoomGroup(base.Map).Temperature += hotAir;
}
}
CompProperties_Power props = this.compPowerTrader.Props;
if (hotIsHot)
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption;
}
else
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption * this.compTempControl.Props.lowPowerConsumptionFactor;
}
this.compTempControl.operatingAtHighPower = hotIsHot;
}
}
public override void SetUpPowerVars()
{
base.SetUpPowerVars();
CompProperties_Power props = base.Props;
if (compPowerBattery != null)
{
if (compPowerBattery.StoredEnergyPct > 0.9)
{
PowerOutput = -Props.basePowerConsumption;
return;
}
}
PowerOutput = 0;
}
public static bool Add(ListerBuildings __instance, Building b)
{
if (b.def.building != null && b.def.building.isNaturalRock)
{
return(false);
}
if (b.Faction == Faction.OfPlayer)
{
if (b is Building_PlantGrower building_PlantGrower)
{
List <Building_PlantGrower> plantGrowers = get_AllBuildingsColonistBuilding_PlantGrower(__instance);
lock (plantGrowers)
{
plantGrowers.Add(building_PlantGrower);
}
}
lock (__instance.allBuildingsColonist)
{
__instance.allBuildingsColonist.Add(b);
}
if (b is IAttackTarget)
{
lock (__instance.allBuildingsColonistCombatTargets)
{
__instance.allBuildingsColonistCombatTargets.Add(b);
}
}
}
else
{
lock (__instance.allBuildingsNonColonist)
{
__instance.allBuildingsNonColonist.Add(b);
}
}
CompProperties_Power compProperties = b.def.GetCompProperties <CompProperties_Power>();
if (compProperties != null && compProperties.shortCircuitInRain)
{
__instance.allBuildingsColonistElecFire.Add(b);
}
return(false);
}
static public PowerType powerTypeFor(ThingDef def)
{
CompProperties_Battery powerBattery = def.GetCompProperties <CompProperties_Battery>();
if (powerBattery != null)
{
return(PowerType.Storage);
}
CompProperties_Power power = def.GetCompProperties <CompProperties_Power>();
if (power != null)
{
return(power.basePowerConsumption > 0 ? PowerType.Consumer : PowerType.Producer);
}
return(PowerType.None);
}
public override void TickRare()
{
if (this.compPowerTrader.PowerOn)
{
IntVec3 intVec = Position + IntVec3.South.RotatedBy(Rotation);
IntVec3 intVec2 = Position + IntVec3.North.RotatedBy(Rotation);
bool flag = false;
if (!intVec2.Impassable() && !intVec.Impassable())
{
float temperature = intVec2.GetTemperature();
float temperature2 = intVec.GetTemperature();
float num = temperature - temperature2;
//if (temperature - 40f > num)
//{
// num = temperature - 40f;
//}
float num2 = 1f - num * 0.0076923077f;
if (num2 < 0f)
{
num2 = 0f;
}
float num3 = this.compTempControl.Props.energyPerSecond * num2 * 4.16666651f;
float num4 = GenTemperature.ControlTemperatureTempChange(intVec, num3, this.compTempControl.targetTemperature);
flag = !Mathf.Approximately(num4, 0f);
if (flag)
{
intVec.GetRoom().Temperature += num4;
GenTemperature.PushHeat(intVec2, -num3 * 1.25f);
}
}
CompProperties_Power props = this.compPowerTrader.Props;
if (flag)
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption;
}
else
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption * this.compTempControl.Props.lowPowerConsumptionFactor;
}
this.compTempControl.operatingAtHighPower = flag;
}
}
private static void CreateBaseEnergyMap()
{
if (BaseEnergy == null)
{
BaseEnergy = new Dictionary <string, float>();
FridgeDefs = new Dictionary <string, ThingDef>();
foreach (ThingDef def in DefDatabase <ThingDef> .AllDefsListForReading)
{
if (def.defName.StartsWith("RimFridge"))
{
CompProperties_Power power = def.GetCompProperties <CompProperties_Power>();
if (power != null)
{
BaseEnergy.Add(def.defName, power.basePowerConsumption);
FridgeDefs.Add(def.defName, def);
}
}
}
}
}
public void Add(Building b)
{
if (b.def.building != null && b.def.building.isNaturalRock)
{
return;
}
if (b.Faction == Faction.OfPlayer)
{
this.allBuildingsColonist.Add(b);
if (b is IAttackTarget)
{
this.allBuildingsColonistCombatTargets.Add(b);
}
}
CompProperties_Power compProperties = b.def.GetCompProperties <CompProperties_Power>();
if (compProperties != null && compProperties.startElectricalFires)
{
this.allBuildingsColonistElecFire.Add(b);
}
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
this.currentMap = map;
refuelable = GetComp <CompRefuelable>();
power = GetComp <CompPowerTrader>();
props = power.Props;
fuelprops = refuelable.Props;
// Require more fuel for faster rates.
float fuelPerReversedYear = 1.0f * ((float)rate / 250);
fuelConsumption = fuelPerReversedYear / ((float)GenDate.TicksPerYear / rate);
// Log.Message("Fuel consumption per Tick: " + fuelConsumption);
if (HasAnyContents)
{
Pawn pawn = ContainedThing as Pawn;
this.configTargetAge(pawn);
this.determineCurableInjuries(pawn);
}
}
private void DoTickerWork(int tickerAmount)
{
bool flag = (this.powerComp == null || this.powerComp.PowerOn);
if (flag && base.Spawned)
{
if (GridsUtility.Roofed(base.Position, this.Map))
{
if (!BreakdownableUtility.IsBrokenDown(this))
{
SetRoofInRange();
ResetRemovedRoof();
}
}
CompProperties_Power props = powerComp.Props;
powerComp.PowerOutput = -props.basePowerConsumption;
}
else
{
// Set roofs that were changed back to being thickRoof
ResetRoofInRange();
}
}
public static bool Remove(ListerBuildings __instance, Building b)
{
if (b is Building_PlantGrower building_PlantGrower)
{
List <Building_PlantGrower> plantGrowers = get_AllBuildingsColonistBuilding_PlantGrower(__instance);
lock (plantGrowers)
{
plantGrowers.Remove(building_PlantGrower);
}
}
lock (__instance.allBuildingsColonist)
{
__instance.allBuildingsColonist.Remove(b);
}
lock (__instance.allBuildingsNonColonist)
{
__instance.allBuildingsNonColonist.Remove(b);
}
if (b is IAttackTarget)
{
lock (__instance.allBuildingsColonistCombatTargets)
{
__instance.allBuildingsColonistCombatTargets.Remove(b);
}
}
CompProperties_Power compProperties = b.def.GetCompProperties <CompProperties_Power>();
if (compProperties != null && compProperties.shortCircuitInRain)
{
lock (__instance.allBuildingsColonistElecFire)
{
__instance.allBuildingsColonistElecFire.Remove(b);
}
}
return(false);
}
internal static ThingDef CreateNanoBedDefFromSupportedBed(this ThingDef bed, Action <ThingDef> fnAdditionalProcessing, List <ThingDef> linkableBuildings, List <CompProperties_Facility> facilities)
{
Type typeRimworldBed = typeof(Building_Bed);
Type bedToClone = bed.GetType();
if (typeRimworldBed.IsAssignableFrom(bedToClone))
{
throw new Exception("Type [" + bedToClone.Name + "] is not supported.");
}
FieldInfo[] fields = typeof(ThingDef).GetFields(BindingFlags.Public | BindingFlags.Instance);
ThingDef nBed = new ThingDef();
foreach (FieldInfo field in fields)
{
field.SetValue(nBed, field.GetValue(bed));
}
nBed.comps = new List <CompProperties>();
for (int i = 0; i < bed.comps.Count; i++)
{
ConstructorInfo constructor = bed.comps[i].GetType().GetConstructor(Type.EmptyTypes);
CompProperties comp = (CompProperties)constructor.Invoke(null);
fields = comp.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
foreach (FieldInfo field in fields)
{
field.SetValue(comp, field.GetValue(bed.comps[i]));
}
nBed.comps.Add(comp);
}
nBed.statBases.Add(new StatModifier()
{
stat = StatDef.Named("Ogre_NanoApparelRate"), value = 0
});
nBed.statBases.Add(new StatModifier()
{
stat = StatDef.Named("Ogre_NanoWeaponsRate"), value = 0
});
CompProperties_Power power = new CompProperties_Power();
power.compClass = typeof(CompPowerTrader);
power.basePowerConsumption = 60f;
power.shortCircuitInRain = false;
nBed.comps.Add(power);
CompProperties_Flickable flick = new CompProperties_Flickable();
flick.compClass = typeof(CompFlickable);
nBed.comps.Add(flick);
CompProperties_Refuelable fuel = new CompProperties_Refuelable();
fuel.fuelConsumptionRate = 0;
fuel.fuelCapacity = 25.0f * bed.size.x; // same way it calculates in BedUtility
fuel.consumeFuelOnlyWhenUsed = true;
fuel.fuelFilter = new ThingFilter();
fuel.fuelFilter.SetAllow(ThingDef.Named("Ogre_NanoTechFuel"), true);
nBed.comps.Add(fuel);
Dictionary <string, int> cost = new Dictionary <string, int>()
{
{ "ComponentIndustrial", 1 },
{ "Steel", 5 }
};
if (nBed.costList == null)
{
nBed.costList = new List <ThingDefCountClass>();
}
Dictionary <string, ThingDefCountClass> current = nBed.costList.ToDictionary(x => x.thingDef.defName, y => y);
foreach (string item in cost.Keys)
{
ThingDefCountClass count = null;
if (!current.TryGetValue(item, out count))
{
count = new ThingDefCountClass(ThingDef.Named(item), (cost[item] * nBed.size.x));
nBed.costList.Add(count);
}
else
{
count.count += (cost[item] * nBed.size.x);
}
}
bool found = false;
nBed.researchPrerequisites = new List <ResearchProjectDef>();
if (bed.researchPrerequisites != null && bed.researchPrerequisites.Count > 0)
{
foreach (ResearchProjectDef d in bed.researchPrerequisites)
{
if (d.defName == "Ogre_NanoTech")
{
found = true;
}
nBed.researchPrerequisites.Add(d);
}
}
if (!found)
{
nBed.researchPrerequisites.Add(ResearchProjectDef.Named("Ogre_NanoTech"));
}
nBed.defName += "_NanoBed";
nBed.description += "\n\n" + TranslatorFormattedStringExtensions.Translate("NanoTech.Description.Short");
nBed.label = TranslatorFormattedStringExtensions.Translate("NanoTech.ModName.Short") + " " + nBed.label;
nBed.thingClass = typeof(NanoBed);
nBed.tradeability = Tradeability.None;
nBed.scatterableOnMapGen = false;
nBed.tickerType = TickerType.Rare;
nBed.constructionSkillPrerequisite = bed.constructionSkillPrerequisite < 2 ? 2 : bed.constructionSkillPrerequisite;
nBed.uiIconScale = 0.9f;
nBed.techLevel = TechLevel.Industrial;
nBed.shortHash = 0;
// as of 1.3 without this, it wont
// show the out of fuel icon
nBed.drawerType = DrawerType.RealtimeOnly;
nBed.designationCategory = DefDatabase <DesignationCategoryDef> .AllDefsListForReading.Find(x => x.defName == "Ogre_NanoRepairTech_DesignationCategory");
MethodInfo newBluePrintDef = typeof(RimWorld.ThingDefGenerator_Buildings).GetMethod("NewBlueprintDef_Thing", BindingFlags.Static | BindingFlags.NonPublic);
nBed.blueprintDef = (ThingDef)newBluePrintDef.Invoke(null, new object[] { nBed, false, null });
MethodInfo newFrameDef = typeof(RimWorld.ThingDefGenerator_Buildings).GetMethod("NewFrameDef_Thing", BindingFlags.Static | BindingFlags.NonPublic);
nBed.frameDef = (ThingDef)newFrameDef.Invoke(null, new object[] { nBed });
if (bed.building.bed_humanlike)
{
CompProperties_AffectedByFacilities abf = nBed.GetCompProperties <CompProperties_AffectedByFacilities>();
if (abf == null)
{
abf = new CompProperties_AffectedByFacilities();
nBed.comps.Add(abf);
}
if (abf.linkableFacilities == null)
{
abf.linkableFacilities = new List <ThingDef>();
}
abf.linkableFacilities.AddRange(linkableBuildings);
foreach (CompProperties_Facility f in facilities)
{
f.linkableBuildings.Add(nBed);
}
}
if (fnAdditionalProcessing != null)
{
fnAdditionalProcessing.Invoke(nBed);
}
typeof(ShortHashGiver).GetMethod("GiveShortHash", BindingFlags.NonPublic | BindingFlags.Static).Invoke(null, new object[] { nBed, typeof(ThingDef) });
return(nBed);
}
public override void TickRare()
{
//base.TickRare();
if (this.compPowerTrader.PowerOn)
{
bool flag = false;
//heating
float outsideTemp = this.Map.mapTemperature.OutdoorTemp;
//cooling
float ambientTemp = this.AmbientTemperature;
//hotside - coolside
float num = outsideTemp - ambientTemp;
//hotside - 40 greater than hotside - coolside
//coolside colder than -40
if (outsideTemp - 40f > num)
{
//num = hotside - 40
//min coldside operating temp == 40
num = outsideTemp - 40f;
}
//num2 = total efficiency
float num2 = 1f - num * EfficiencyLossPerDegreeDifference;
if (num2 < 0f)
{
num2 = 0f;
}
//num3 = EPS stat * efficiency * const// total heat push
float num3 = this.compTempControl.Props.energyPerSecond * num2 * 4.16666651f;
/*RoomGroup roomGroup = this.Position.GetRoomGroup(base.Map);
* if (roomGroup == null) {
* Messages.Message("null", MessageSound.Standard);
* } else if(roomGroup.UsesOutdoorTemperature){
* Messages.Message("outdoor", MessageSound.Standard);
* } else {
* Messages.Message("zilch", MessageSound.Standard);
* }
* //calibrating for room size etc., no changes yet
* Messages.Message("num3", MessageSound.Standard);
* Messages.Message(string.Format("{0:N8}", num3), MessageSound.Standard);
* float num4 = GenTemperature.ControlTemperatureTempChange(this.Position, base.Map, num3, this.compTempControl.targetTemperature);
* Messages.Message(this.Position.ToString(), MessageSound.Standard);
* Messages.Message("num4", MessageSound.Standard);
* Messages.Message(string.Format("{0:N8}", num4), MessageSound.Standard);*/
//check if close to zero
//flag = !UnityEngine.Mathf.Approximately(num4, 0f);
flag = Math.Abs(num3 / (float)this.compTempControl.Props.energyPerSecond) > HeatThreshold && ambientTemp > this.compTempControl.targetTemperature;
/*Messages.Message(string.Format("{0:N8}", num3 / (float)this.compTempControl.Props.energyPerSecond), MessageSound.Standard);
* Messages.Message(flag.ToString(), MessageSound.Standard);*/
if (flag)
{
//cool the room
//this.Position.GetRoomGroup(base.Map).Temperature += num4;
GenTemperature.PushHeat(this.Position, base.Map, num3);
//heat other side * efficiency factor
//GenTemperature.PushHeat(intVec2, base.Map, -num3 * HeatOutputMultiplier);
//removed due to exhausting to Outside
}
CompProperties_Power props = this.compPowerTrader.Props;
if (flag)
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption;
}
else
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption * this.compTempControl.Props.lowPowerConsumptionFactor;
}
this.compTempControl.operatingAtHighPower = flag;
}
}
public override void TickRare()
{
if (!compPowerTrader.PowerOn)
{
return;
}
IntVec3 intVec3_1 = Position + IntVec3Utility.RotatedBy(IntVec3.South, Rotation);
IntVec3 intVec3_2 = Position + IntVec3Utility.RotatedBy(IntVec3.North, Rotation);
bool flag = false;
if (!GenGrid.Impassable(intVec3_2, Map) && !GenGrid.Impassable(intVec3_1, Map))
{
float temperature1 = GridsUtility.GetTemperature(intVec3_2, Map);
float temperature2 = GridsUtility.GetTemperature(intVec3_1, Map);
//Check for Mode
bool _cooling = true;
if (m_Mode == EnumCoolerMode.Cooling)
{
_cooling = true;
}
else if (m_Mode == EnumCoolerMode.Heating)
{
_cooling = false;
}
else if (m_Mode == EnumCoolerMode.Auto)
{
if (temperature1 > compTempControl.targetTemperature)
{
//Log.Message("Auto Cooling");
_cooling = true;
}
else
{
//Log.Message("Auto Heating");
_cooling = false;
}
}
float a;
float energyLimit;
float _TemperatureDifferance;
float num2;
if (_cooling)
{
//Log.Message("Cooling");
_TemperatureDifferance = temperature1 - temperature2;
if (temperature1 - TemperatureDiffThreshold > _TemperatureDifferance)
{
_TemperatureDifferance = temperature1 - TemperatureDiffThreshold;
}
num2 = 1.0f - _TemperatureDifferance * EfficiencyLossPerDegreeDifference;
if (num2 < 0.0f)
{
num2 = 0.0f;
}
energyLimit = (float)(compTempControl.Props.energyPerSecond * (double)num2 * UnknownConst_2);
a = GenTemperature.ControlTemperatureTempChange(intVec3_1, Map, energyLimit, compTempControl.targetTemperature);
flag = !Mathf.Approximately(a, 0.0f);
}
else
{
//Log.Message("Heating");
_TemperatureDifferance = temperature1 - temperature2;
if (temperature1 + TemperatureDiffThreshold > _TemperatureDifferance)
{
_TemperatureDifferance = temperature1 + TemperatureDiffThreshold;
}
num2 = 1.0f - _TemperatureDifferance * EfficiencyLossPerDegreeDifference;
if (num2 < 0.0f)
{
num2 = 0.0f;
}
energyLimit = (float)(compTempControl.Props.energyPerSecond * -(double)num2 * UnknownConst_2);
a = GenTemperature.ControlTemperatureTempChange(intVec3_1, Map, energyLimit, compTempControl.targetTemperature);
flag = !Mathf.Approximately(a, 0.0f);
}
if (flag)
{
GridsUtility.GetRoomGroup(intVec3_2, Map).Temperature -= a;
GenTemperature.PushHeat(intVec3_1, Map, (float)(+(double)energyLimit * HeatOutputMultiplier));
}
}
CompProperties_Power props = compPowerTrader.Props;
if (flag)
{
compPowerTrader.PowerOutput = -props.basePowerConsumption;
}
else
{
compPowerTrader.PowerOutput = -props.basePowerConsumption * compTempControl.Props.lowPowerConsumptionFactor;
}
compTempControl.operatingAtHighPower = flag;
}
public override void TickRare()
{
if (!this.compPowerTrader.PowerOn)
{
return;
}
IntVec3 intVec3_1 = this.Position + IntVec3.South.RotatedBy(this.Rotation);
IntVec3 intVec3_2 = this.Position + IntVec3.North.RotatedBy(this.Rotation);
bool flag = false;
if (!intVec3_2.Impassable(this.Map) && !intVec3_1.Impassable(this.Map))
{
float temperature1 = GridsUtility.GetTemperature(intVec3_2, this.Map);
float temperature2 = GridsUtility.GetTemperature(intVec3_1, this.Map);
//Check for Mode
bool _cooling = true;
if (this.m_Mode == enumCoolerMode.Cooling)
{
_cooling = true;
}
else if (this.m_Mode == enumCoolerMode.Heating)
{
_cooling = false;
}
else if (this.m_Mode == enumCoolerMode.Auto)
{
//Log.Message("T1: " + temperature1 + "T2: " + temperature2 + "TT: " + this.compTempControl.targetTemperature);
if (temperature1 > this.compTempControl.targetTemperature)
{
//Log.Message("Auto Cooling");
_cooling = true;
}
else
{
//Log.Message("Auto Heating");
_cooling = false;
}
}
float a = 0.0f;
float energyLimit = 0.0f;
if (_cooling)
{
//Log.Message("Cooling");
float _TemperatureDifferance = temperature1 - temperature2;
if ((double)temperature1 - 40.0 > (double)_TemperatureDifferance)
{
_TemperatureDifferance = temperature1 - 40f;
}
float num2 = (float)(1.0 - (double)_TemperatureDifferance * (1.0 / 130.0));
if ((double)num2 < 0.0)
{
num2 = 0.0f;
}
energyLimit = (float)((double)this.compTempControl.Props.energyPerSecond * (double)num2 * 4.16666650772095);
a = GenTemperature.ControlTemperatureTempChange(intVec3_1, this.Map, energyLimit, this.compTempControl.targetTemperature);
flag = !Mathf.Approximately(a, 0.0f);
}
else
{
//Log.Message("Heating");
float _TemperatureDifferance = temperature1 - temperature2;
if ((double)temperature1 + 40.0 > (double)_TemperatureDifferance)
{
_TemperatureDifferance = temperature1 + 40f;
}
float num2 = (float)(1.0 - (double)_TemperatureDifferance * (1.0 / 130.0));
if ((double)num2 < 0.0)
{
num2 = 0.0f;
}
energyLimit = (float)((double)this.compTempControl.Props.energyPerSecond * -(double)num2 * 4.16666650772095);
//energyLimit = (float)((double)this.compTempControl.Props.energyPerSecond * 4.16666650772095 * -1);
a = GenTemperature.ControlTemperatureTempChange(intVec3_1, this.Map, energyLimit, this.compTempControl.targetTemperature);
flag = !Mathf.Approximately(a, 0.0f);
//Log.Message("TempDiff: " + _TemperatureDifferance + " num2: " + num2 + " EnergyLimit: " + energyLimit + " a: " + a);
}
if (flag)
{
GridsUtility.GetRoomGroup(intVec3_2, this.Map).Temperature -= a;
GenTemperature.PushHeat(intVec3_1, this.Map, (float)(+(double)energyLimit * 1.25));
}
}
CompProperties_Power props = this.compPowerTrader.Props;
if (flag)
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption;
}
else
{
this.compPowerTrader.PowerOutput = -props.basePowerConsumption * this.compTempControl.Props.lowPowerConsumptionFactor;
}
this.compTempControl.operatingAtHighPower = flag;
}
