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;
}
}
