private static void AddGas_FloodFill(IntVec3 pos, Map map, ThingDef gasDef, ref float amount) { // flood-fill gas into target cell and surrounding area // prep data structures var room = pos.GetRoomGroup(map); _queue.Clear(); _checked.Clear(); // start the process _queue.Enqueue(pos); _checked.Add(pos); while (_queue.Count > 0 && amount > Mathf.Epsilon) { var cell = _queue.Dequeue(); AddGas_Cell(cell, map, gasDef, ref amount); foreach (var adj in GenAdjFast.AdjacentCellsCardinal(cell) .Where(adj => !_checked.Contains(adj) && !adj.Impassable(map) && adj.GetRoomGroup(map) == room)) { _queue.Enqueue(adj); _checked.Add(adj); } } }
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot) { Map visibleMap = Find.VisibleMap; IntVec3 intVec = center + IntVec3.South.RotatedBy(rot); IntVec3 intVec2 = center + IntVec3.North.RotatedBy(rot); List <IntVec3> list = new List <IntVec3>(); list.Add(intVec); GenDraw.DrawFieldEdges(list, Color.white); list = new List <IntVec3>(); list.Add(intVec2); GenDraw.DrawFieldEdges(list, Color.white); RoomGroup roomGroup = intVec2.GetRoomGroup(visibleMap); RoomGroup roomGroup2 = intVec.GetRoomGroup(visibleMap); if (roomGroup != null && roomGroup2 != null) { if (roomGroup == roomGroup2 && !roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), Color.white); } else { if (!roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), Color.white); } if (!roomGroup2.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup2.Cells.ToList(), Color.white); } } } }
public override string GetExplanationUnfinalized(StatRequest req, ToStringNumberSense numberSense) { CompTempControl tempControl = req.Thing.TryGetComp <CompTempControl>(); Thing tempController = req.Thing; IntVec3 intVec3_2 = tempController.Position + IntVec3.North.RotatedBy(tempController.Rotation); IntVec3 intVec3_1 = tempController.Position + IntVec3.South.RotatedBy(tempController.Rotation); float cooledRoomTemp = intVec3_1.GetTemperature(tempController.Map); float extRoomTemp = intVec3_2.GetTemperature(tempController.Map); float efficiencyLossPerDegree = 1.0f / 130.0f; // SOS2 internal value, means loss of efficiency for each degree above targettemp, lose 50% at 65C above targetTemp, 100% at 130+ float energyPerSecond = tempControl.Props.energyPerSecond; // the power of the radiator float roomSurface = intVec3_1.GetRoomGroup(tempController.Map).CellCount; float coolingConversionRate = 4.16666651f; // Celsius cooled per Joules*Second*Meter^2 conversion rate float sidesTempGradient = extRoomTemp - (cooledRoomTemp < 40 ? cooledRoomTemp : 40); float efficiency = (1f - sidesTempGradient * efficiencyLossPerDegree); // a negative value indicates heat generation float maxACPerSecond = energyPerSecond * efficiency / roomSurface * coolingConversionRate; // max cooling power possible, positive value indicates heat generation SEB seb = new SEB("StatsReport_RWHS"); seb.Simple("CooledRoomTemp", cooledRoomTemp); seb.Simple("ExteriorRoomTemp", extRoomTemp); seb.Simple("EfficiencyLossPerDegree", efficiencyLossPerDegree); seb.Simple("EnergyPerSecond", energyPerSecond); seb.Simple("CooledRoomSurface", roomSurface); seb.Simple("ACConversionRate", coolingConversionRate); seb.Full("SidesTempGradient", sidesTempGradient, extRoomTemp, cooledRoomTemp); seb.Full("RelativeEfficiency", efficiency * 100, sidesTempGradient, efficiencyLossPerDegree); seb.Full("MaxACPerSecond", maxACPerSecond, energyPerSecond, efficiency, roomSurface, coolingConversionRate); return(seb.ToString()); }
public override void Tick() { base.Tick(); if (this.compPowerTrader.PowerOn) { timeTillEval--; if (timeTillEval <= 0) { IntVec3 intVec3_1 = this.Position + IntVec3.North.RotatedBy(this.Rotation); IntVec3 intVec3_2 = this.Position + IntVec3.South.RotatedBy(this.Rotation); IntVec3 intVec3_3 = this.Position + (IntVec3.South.RotatedBy(this.Rotation) * 2); IntVec3 intVec3_4 = this.Position + (IntVec3.South.RotatedBy(this.Rotation) * 3); bool flag = false; if (!intVec3_4.Impassable(this.Map) && !intVec3_3.Impassable(this.Map) && !intVec3_2.Impassable(this.Map) && !intVec3_1.Impassable(this.Map)) { float temperature1 = intVec3_2.GetTemperature(this.Map); float temperature2 = intVec3_1.GetTemperature(this.Map); float num1 = temperature1 - temperature2; if ((double)temperature1 - 40.0 > (double)num1) { num1 = temperature1 - 40f; } float num2 = (float)(1.0 - (double)num1 * (1.0 / 130.0)); if ((double)num2 < 0.0) { num2 = 0.0f; } float energyLimit = (float)(((double)this.compTempControl.Props.energyPerSecond) * (double)num2 * 4.16666650772095); float a = GenTemperature.ControlTemperatureTempChange(intVec3_1, this.Map, energyLimit, this.compTempControl.targetTemperature); flag = !Mathf.Approximately(a, 0.0f); if (flag) { intVec3_1.GetRoomGroup(this.Map).Temperature += a; GenTemperature.PushHeat(intVec3_2, this.Map, (float)(-(double)energyLimit * 1.25)); GenTemperature.PushHeat(intVec3_3, this.Map, (float)(-(double)energyLimit * 1.25)); GenTemperature.PushHeat(intVec3_4, 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; unfoldComponent.Target = flag ? 1.0f : 0.0f; timeTillEval = EVAL_TIME; } } else { unfoldComponent.Target = 0.0f; } }
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol) { Map currentMap = Find.CurrentMap; IntVec3 intVec = center + IntVec3.South.RotatedBy(rot); IntVec3 intVec2 = center + IntVec3.North.RotatedBy(rot); List <IntVec3> list = new List <IntVec3>(); list.Add(intVec); GenDraw.DrawFieldEdges(list, GenTemperature.ColorSpotCold); list = new List <IntVec3>(); list.Add(intVec2); GenDraw.DrawFieldEdges(list, GenTemperature.ColorSpotHot); RoomGroup roomGroup = intVec2.GetRoomGroup(currentMap); RoomGroup roomGroup2 = intVec.GetRoomGroup(currentMap); if (roomGroup != null && roomGroup2 != null) { if (roomGroup == roomGroup2 && !roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), new Color(1f, 0.7f, 0f, 0.5f)); } else { if (!roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), GenTemperature.ColorRoomHot); } if (!roomGroup2.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup2.Cells.ToList(), GenTemperature.ColorRoomCold); } } } }
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol, Thing thing = null) { Map currentMap = Find.CurrentMap; IntVec3 intVec = center + IntVec3.South.RotatedBy(rot); IntVec3 intVec2 = center + IntVec3.North.RotatedBy(rot); GenDraw.DrawFieldEdges(new List <IntVec3> { intVec }, GenTemperature.ColorSpotCold); GenDraw.DrawFieldEdges(new List <IntVec3> { intVec2 }, GenTemperature.ColorSpotHot); RoomGroup roomGroup = intVec2.GetRoomGroup(currentMap); RoomGroup roomGroup2 = intVec.GetRoomGroup(currentMap); if (roomGroup == null || roomGroup2 == null) { return; } if (roomGroup == roomGroup2 && !roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), new Color(1f, 0.7f, 0f, 0.5f)); return; } if (!roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), GenTemperature.ColorRoomHot); } if (!roomGroup2.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup2.Cells.ToList(), GenTemperature.ColorRoomCold); } }
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot) { Map visibleMap = Find.VisibleMap; RoomGroup roomGroup = center.GetRoomGroup(visibleMap); if (roomGroup != null && !roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), GenTemperature.ColorRoomCold); } }
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol) { Map currentMap = Find.CurrentMap; RoomGroup roomGroup = center.GetRoomGroup(currentMap); if (roomGroup != null && !roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList <IntVec3>(), GenTemperature.ColorRoomHot); } }
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 DrawGhost(ThingDef def, IntVec3 center, Rot4 rot) { foreach ( var unit in Find.VisibleMap.listerBuildings.AllBuildingsColonistOfClass <Building_ClimateControl>() .Where(unit => unit.Position == center)) { _climateControl = unit; break; } var roomGroup = center.GetRoomGroup(Find.VisibleMap); if (roomGroup == null || roomGroup.UsesOutdoorTemperature) { return; } if (_climateControl == null) { return; } var status = _climateControl.WorkStatus; Color color; switch (status) { case Status.Waiting: color = new Color(1f, 0.7f, 0.0f, 0.5f); break; case Status.Heating: color = new Color(1f, 0.0f, 0.0f, 0.3f); break; case Status.Cooling: color = new Color(0.0f, 0.0f, 1f, 0.3f); break; case Status.Outdoor: return; default: throw new ArgumentOutOfRangeException(); } GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), color); }
public static float GetMaxACPerSecond(StatRequest req, bool applyPostProcess = true) { CompTempControl tempControl = req.Thing.TryGetComp <CompTempControl>(); Thing tempController = req.Thing; IntVec3 intVec3_1 = tempController.Position + IntVec3.South.RotatedBy(tempController.Rotation); float energyPerSecond = tempControl.Props.energyPerSecond; // the power of the radiator float roomSurface = intVec3_1.GetRoomGroup(tempController.Map).CellCount; float coolingConversionRate = 4.16666651f; // Celsius cooled per Joules*Second*Meter^2 conversion rate float efficiency = GetCurrentEfficiency(req); float maxACPerSecond = energyPerSecond * efficiency / roomSurface * coolingConversionRate; // max cooling power possible return(maxACPerSecond); }
public static void DesensitizeViaCorpse(PawnObserver __instance) { Pawn pawn = Traverse.Create(__instance).Field("pawn").GetValue <Pawn>(); if (!pawn.health.capacities.CapableOf(PawnCapacityDefOf.Sight)) { return; } RoomGroup roomGroup = pawn.GetRoomGroup(); Map map = pawn.Map; int num = 0; while ((float)num < 100f) { IntVec3 intVec = pawn.Position + GenRadial.RadialPattern[num]; if (intVec.InBounds(map)) { if (intVec.GetRoomGroup(map) == roomGroup) { if (GenSight.LineOfSight(intVec, pawn.Position, map, true, null, 0, 0)) { List <Thing> thingList = intVec.GetThingList(map); for (int i = 0; i < thingList.Count; i++) { IThoughtGiver thoughtGiver = thingList[i] as IThoughtGiver; if (thoughtGiver != null) { Thought_Memory thought_Memory = thoughtGiver.GiveObservedThought(); if (thought_Memory != null && thought_Memory.def == ThoughtDefOf.ObservedLayingCorpse) { if (!pawn.story.traits.HasTrait(TraitDefOfPsychology.BleedingHeart) && !pawn.story.traits.HasTrait(TraitDefOf.Psychopath) && !pawn.story.traits.HasTrait(TraitDefOf.Bloodlust) && !pawn.story.traits.HasTrait(TraitDefOfPsychology.Desensitized)) { if (((pawn.GetHashCode() ^ (GenLocalDate.DayOfYear(pawn) + GenLocalDate.Year(pawn) + (int)(GenLocalDate.DayPercent(pawn) * 5) * 60) * 391) % 1000) == 0) { pawn.story.traits.GainTrait(new Trait(TraitDefOfPsychology.Desensitized)); pawn.needs.mood.thoughts.memories.TryGainMemory(ThoughtDefOfPsychology.RecentlyDesensitized, null); } } } } } } } } num++; } }
public override void TickRare() { if (!compPowerTrader.PowerOn) { return; } IntVec3 intVec = base.Position + IntVec3.South.RotatedBy(base.Rotation); IntVec3 intVec2 = base.Position + IntVec3.North.RotatedBy(base.Rotation); bool flag = false; if (!intVec2.Impassable(base.Map) && !intVec.Impassable(base.Map)) { float temperature = intVec2.GetTemperature(base.Map); float temperature2 = intVec.GetTemperature(base.Map); float num = temperature - temperature2; if (temperature - 40f > num) { num = temperature - 40f; } float num2 = 1f - num * 0.0076923077f; if (num2 < 0f) { num2 = 0f; } float num3 = compTempControl.Props.energyPerSecond * num2 * 4.16666651f; float num4 = GenTemperature.ControlTemperatureTempChange(intVec, base.Map, num3, compTempControl.targetTemperature); flag = !Mathf.Approximately(num4, 0f); if (flag) { intVec.GetRoomGroup(base.Map).Temperature += num4; GenTemperature.PushHeat(intVec2, base.Map, (0f - num3) * 1.25f); } } CompProperties_Power props = compPowerTrader.Props; if (flag) { compPowerTrader.PowerOutput = 0f - props.basePowerConsumption; } else { compPowerTrader.PowerOutput = (0f - props.basePowerConsumption) * compTempControl.Props.lowPowerConsumptionFactor; } compTempControl.operatingAtHighPower = flag; }
public override void TickRare() { if (base.compPowerTrader.PowerOn) { IntVec3 intVec = base.Position + IntVec3.South.RotatedBy(base.Rotation); IntVec3 intVec2 = base.Position + IntVec3.North.RotatedBy(base.Rotation); bool flag = false; if (!intVec2.Impassable(base.Map) && !intVec.Impassable(base.Map)) { float temperature = intVec2.GetTemperature(base.Map); float temperature2 = intVec.GetTemperature(base.Map); float num = temperature - temperature2; if (temperature - 40.0 > num) { num = (float)(temperature - 40.0); } float num2 = (float)(1.0 - num * 0.0076923076994717121); if (num2 < 0.0) { num2 = 0f; } float num3 = (float)(base.compTempControl.Props.energyPerSecond * num2 * 4.1666665077209473); float num4 = GenTemperature.ControlTemperatureTempChange(intVec, base.Map, num3, base.compTempControl.targetTemperature); flag = !Mathf.Approximately(num4, 0f); if (flag) { intVec.GetRoomGroup(base.Map).Temperature += num4; GenTemperature.PushHeat(intVec2, base.Map, (float)((0.0 - num3) * 1.25)); } } CompProperties_Power props = base.compPowerTrader.Props; if (flag) { base.compPowerTrader.PowerOutput = (float)(0.0 - props.basePowerConsumption); } else { base.compPowerTrader.PowerOutput = (float)((0.0 - props.basePowerConsumption) * base.compTempControl.Props.lowPowerConsumptionFactor); } base.compTempControl.operatingAtHighPower = flag; } }
public static bool PushHeat(ref bool __result, IntVec3 c, Map map, float energy) { if (map == null) { Log.Error("Added heat to null map.", false); __result = false; return(false); } RoomGroup roomGroup1 = c.GetRoomGroup(map); if (roomGroup1 != null) { __result = roomGroup1.PushHeat(energy); return(false); } List <RoomGroup> neighRoomGroups = new List <RoomGroup>(); for (int index = 0; index < 8; ++index) { IntVec3 intVec3 = c + GenAdj.AdjacentCells[index]; if (intVec3.InBounds(map)) { RoomGroup roomGroup2 = intVec3.GetRoomGroup(map); if (roomGroup2 != null) { neighRoomGroups.Add(roomGroup2); } } } float energy1 = energy / (float)neighRoomGroups.Count; for (int index = 0; index < neighRoomGroups.Count; ++index) { neighRoomGroups[index].PushHeat(energy1); } int num = neighRoomGroups.Count > 0 ? 1 : 0; neighRoomGroups.Clear(); __result = num != 0; return(false); }
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol) { Map currentMap = Find.CurrentMap; IntVec3 loc1 = center + IntVec3.North.RotatedBy(rot); IntVec3 loc2 = center + IntVec3.South.RotatedBy(rot); IntVec3 loc3 = center + (IntVec3.South.RotatedBy(rot) * 2); IntVec3 loc4 = center + (IntVec3.South.RotatedBy(rot) * 3); GenDraw.DrawFieldEdges(new List <IntVec3>() { loc1 }, GenTemperature.ColorSpotCold); GenDraw.DrawFieldEdges(new List <IntVec3>() { loc2, loc3, loc4 }, GenTemperature.ColorSpotHot); RoomGroup roomGroup1 = loc2.GetRoomGroup(currentMap); RoomGroup roomGroup2 = loc1.GetRoomGroup(currentMap); if (roomGroup1 == null || roomGroup2 == null) { return; } if (roomGroup1 == roomGroup2 && !roomGroup1.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup1.Cells.ToList <IntVec3>(), new Color(1f, 0.7f, 0.0f, 0.5f)); } else { if (!roomGroup1.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup1.Cells.ToList <IntVec3>(), GenTemperature.ColorRoomHot); } if (roomGroup2.UsesOutdoorTemperature) { return; } GenDraw.DrawFieldEdges(roomGroup2.Cells.ToList <IntVec3>(), GenTemperature.ColorRoomCold); } }
public static List <IntVec3> GetGasVentArea(IntVec3 ventPos, Map map, float radius) { // simple flood fill implementation. // Note that we use this over GenRadial because that set of functions does // not and cannot take blockers into account (e.g. walls). // A FIFO flood fill will produce what is essentially a diamond pattern, if // unconstrained by walls. Ideally, we'd want to use a priority queue for // distance from the center, but that becomes tricky in a constrained sit- // uation, as you'd have to take line-of-sight into account. // return number of cells based on radius. var cellCount = GenRadial.NumCellsInRadius(radius); var room = ventPos.GetRoomGroup(map); // prep data structures _queue.Clear(); _cells.Clear(); _checked.Clear(); // start the process _queue.Enqueue(ventPos); _checked.Add(ventPos); while (_queue.Count > 0 && _cells.Count < cellCount) { var cell = _queue.Dequeue(); _cells.Add(cell); foreach (var adj in GenAdjFast.AdjacentCellsCardinal(cell) .Where(adj => !adj.Impassable(map) && !_checked.Contains(adj) && adj.GetRoomGroup(map) == room)) { _queue.Enqueue(adj); _checked.Add(adj); } } return(_cells.ToList()); }
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol) { Map currentMap = Find.CurrentMap; IntVec3 intVec = center + IntVec3.South.RotatedBy(rot); IntVec3 intVec2 = center + IntVec3.North.RotatedBy(rot); GenDraw.DrawFieldEdges(new List <IntVec3> { intVec }, Color.white); GenDraw.DrawFieldEdges(new List <IntVec3> { intVec2 }, Color.white); RoomGroup roomGroup = intVec2.GetRoomGroup(currentMap); RoomGroup roomGroup2 = intVec.GetRoomGroup(currentMap); if (roomGroup != null && roomGroup2 != null) { if (roomGroup == roomGroup2 && !roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList <IntVec3>(), Color.white); } else { if (!roomGroup.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup.Cells.ToList <IntVec3>(), Color.white); } if (!roomGroup2.UsesOutdoorTemperature) { GenDraw.DrawFieldEdges(roomGroup2.Cells.ToList <IntVec3>(), Color.white); } } } }
public static bool EqualizeTemperaturesThroughBuilding(Building b, float rate, bool twoWay) { int num = 0; float num2 = 0f; if (twoWay) { for (int i = 0; i < 2; i++) { IntVec3 intVec = (i == 0) ? (b.Position + b.Rotation.FacingCell) : (b.Position - b.Rotation.FacingCell); if (intVec.InBounds(b.Map)) { RoomGroup roomGroup = intVec.GetRoomGroup(b.Map); if (roomGroup != null) { num2 += roomGroup.Temperature; beqRoomGroups[num] = roomGroup; num++; } } } } else { for (int j = 0; j < 4; j++) { IntVec3 intVec2 = b.Position + GenAdj.CardinalDirections[j]; if (intVec2.InBounds(b.Map)) { RoomGroup roomGroup2 = intVec2.GetRoomGroup(b.Map); if (roomGroup2 != null) { num2 += roomGroup2.Temperature; beqRoomGroups[num] = roomGroup2; num++; } } } } if (num == 0) { return(false); } float num3 = num2 / (float)num; RoomGroup roomGroup3 = b.GetRoomGroup(); if (roomGroup3 != null) { roomGroup3.Temperature = num3; } if (num == 1) { return(false); } float num4 = 1f; for (int k = 0; k < num; k++) { RoomGroup roomGroupK = beqRoomGroups[k]; if (null != roomGroupK) { if (!roomGroupK.UsesOutdoorTemperature) { float temperature = roomGroupK.Temperature; float num5 = (num3 - temperature) * rate; float num6 = num5 / (float)roomGroupK.CellCount; float num7 = roomGroupK.Temperature + num6; if (num5 > 0f && num7 > num3) { num7 = num3; } else if (num5 < 0f && num7 < num3) { num7 = num3; } float num8 = Mathf.Abs((num7 - temperature) * (float)roomGroupK.CellCount / num5); if (num8 < num4) { num4 = num8; } } } } for (int l = 0; l < num; l++) { RoomGroup roomGroupL = beqRoomGroups[l]; if (null != roomGroupL && !roomGroupL.UsesOutdoorTemperature) { float temperature2 = roomGroupL.Temperature; float num9 = (num3 - temperature2) * rate * num4 / (float)roomGroupL.CellCount; roomGroupL.Temperature += num9; beqRoomGroups[l] = roomGroupL; } } for (int m = 0; m < beqRoomGroups.Length; m++) { beqRoomGroups[m] = null; } return(false); }
/// <summary> /// Tick function for Air Vents /// Main code for chaning temperature at the Rooms. We take the Converted Temperature from the Air Network. /// </summary> public override void TickRare() { CompAirFlowConsumer.TickRare(); if (!CompAirFlowConsumer.IsOperating()) { return; } if (!CompAirFlowConsumer.IsActive()) { return; } IntVec3 intVec = Position + IntVec3.North.RotatedBy(Rotation); if (intVec.Impassable(Map)) { return; } //var insideTemp = intVec.GetTemperature(Map); //var tempDiff = outsideTemp - insideTemp; var outsideTemp = CompAirFlowConsumer.ConvertedTemperature; var tempDiff = outsideTemp - intVec.GetTemperature(Map); var magnitudeChange = Mathf.Abs(tempDiff); // Cap change at 10.0f if (magnitudeChange > 10.0f) { magnitudeChange = 10.0f; } float signChanger = 1; if (tempDiff < 0) { signChanger = -1; } var thermalFlag = 1; if (CompAirFlowConsumer.ThermalEfficiency <= 0) { thermalFlag = 0; } // Flow Efficiency is capped at 1.0f. Squaring will only keep it less than or equal to 1.0f. Smaller the number more drastic the square. var efficiencyImpact = CompAirFlowConsumer.FlowEfficiency * CompAirFlowConsumer.FlowEfficiency * thermalFlag; var smoothMagnitude = magnitudeChange * 0.25f * (CompAirFlowConsumer.Props.baseAirExhaust / 100.0f); var energyLimit = smoothMagnitude * efficiencyImpact * 4.16666651f * 12f * signChanger; var tempChange = GenTemperature.ControlTemperatureTempChange(intVec, Map, energyLimit, outsideTemp); //var flag = !Mathf.Approximately(tempChange, 0f); //if (flag) if (!Mathf.Approximately(tempChange, 0f)) { intVec.GetRoomGroup(Map).Temperature += tempChange; } }