public static bool TryGetParts(Corpse corpse, RecipeInfo recipeInfo, BodyPartRecord part, float skillChance,
ref List <Thing> result, ref List <BodyPartRecord> damagedParts)
{
if (IsCleanAndDroppable(corpse.InnerPawn, part))
{
damagedParts.Add(part);
CompRottable rot = corpse.TryGetComp <CompRottable>();
if (rot == null
? corpse.Age <= recipeInfo.CorpseValidAge
: rot.RotProgress + (corpse.Age - rot.RotProgress) * recipeInfo.FrozenDecay <=
recipeInfo.CorpseValidAge)
{
if (Rand.Chance(Math.Min(skillChance, recipeInfo.NaturalChance)))
{
result.Add(ThingMaker.MakeThing(part.def.spawnThingOnRemoved));
}
return(true);
}
}
List <Hediff> bion = corpse.InnerPawn.health.hediffSet.hediffs.Where(x =>
part.Equals(x.Part) && x.def.spawnThingOnRemoved != null &&
(x is Hediff_Implant || x is Hediff_AddedPart)).ToList();
if (bion.Count > 0)
{
result.AddRange(bion.Where(x => Rand.Chance(Math.Min(skillChance, recipeInfo.BionicChance)))
.Select(x => ThingMaker.MakeThing(x.def.spawnThingOnRemoved)));
damagedParts.Add(part);
return(true);
}
return(false);
}
private void RefrigerateContents()
{
// Only refrigerate if it has power
// Don't worry about idle power though
if (compPower.PowerOn == false)
{
// Clear it out
if (contents.Count > 0)
{
contents = new List <RefrigeratorContents>();
}
// Now leave
return;
}
// Look for things
ScanForRottables();
// Refrigerate the items
foreach (RefrigeratorContents item in contents)
{
CompRottable compRottable = item.thing.TryGetComp <CompRottable>();
item.thing.HitPoints = item.HitPoints;
compRottable.rotProgress = item.rotProgress;
}
}
public static void IsAllowed_Postfix(ThingFilter __instance, ref bool __result, Thing t)
{
if (!__result)
{
return;
}
MyWorldComponent world = Find.World.GetComponent <MyWorldComponent>();
CompRottable rot = t.TryGetComp <CompRottable>();
if (rot != null && world.ShowSpoilTime(__instance))
{
IntRange spoilTickRange = SpoilTimeCalc.convertToTicks(world.getSpoilTime(__instance));
int spoilTicks = rot.TicksUntilRotAtTemp(25.0f);
if (spoilTickRange.min == -1 || spoilTicks < spoilTickRange.min)
{
__result = false;
}
else if (spoilTickRange.max != -1 && spoilTicks > spoilTickRange.max)
{
__result = false;
}
}
}
private void AgeCorpse(Thing thing)
{
CompRottable compRot = thing.TryGetComp <CompRottable>();
if (compRot != null)
{
if (compRot.RotProgress <= (5000 + (5000 * pwrVal)))
{
Corpse corpse = thing as Corpse;
if (corpse != null && verVal >= 3)
{
TransmutateEffects(corpse.Position, 10);
Pawn innerPawn = corpse.InnerPawn;
ResurrectionUtility.ResurrectWithSideEffects(innerPawn);
AgePawn(innerPawn, Mathf.RoundToInt((6 * 2500) * (1 + (.1f * verVal))), false);
HealthUtility.AdjustSeverity(innerPawn, HediffDef.Named("TM_ResurrectionHD"), 1f);
HealthUtility.AdjustSeverity(this.CasterPawn, HediffDef.Named("TM_ResurrectionHD"), 1f);
}
}
else
{
compRot.RotProgress = compRot.RotProgress * (.4f - (.125f * pwrVal));
if (compRot.RotProgress <= 20000)
{
compRot.RotProgress = 20001;
}
}
}
}
private void DrawDaysUntilRot(Rect rect, TransferableOneWay trad)
{
if (!trad.HasAnyThing)
{
return;
}
if (!trad.ThingDef.IsNutritionGivingIngestible)
{
return;
}
if (!cachedTicksUntilRot.TryGetValue(trad, out int num))
{
num = int.MaxValue;
for (int i = 0; i < trad.things.Count; i++)
{
CompRottable compRottable = trad.things[i].TryGetComp <CompRottable>();
if (compRottable != null)
{
num = Mathf.Min(num, DaysUntilRotCalculator.ApproxTicksUntilRot_AssumeTimePassesBy(compRottable, tile, null));
}
}
cachedTicksUntilRot.Add(trad, num);
}
if (num >= 36000000 || num >= 36000000f)
{
return;
}
Widgets.DrawHighlightIfMouseover(rect);
float num2 = num / 60000f;
GUI.color = Color.yellow;
Widgets.Label(rect, num2.ToString("0.#"));
GUI.color = Color.white;
TooltipHandler.TipRegionByKey(rect, "DaysUntilRotTip");
}
public static void Postfix(Pawn __instance, DamageInfo?dinfo, Hediff exactCulprit)
{
if (dinfo.HasValue)
{
if (dinfo.Value.Instigator != null)
{
Thing inst = dinfo.Value.Instigator;
DessicatorExt desicator = inst.def.GetModExtension <DessicatorExt>();
if (desicator != null)
{
if (desicator.desicatedDef != null)
{
FieldInfo corpse = typeof(Pawn).GetField("Corpse", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.GetField);
Traverse.Create(__instance);
corpse.SetValue(__instance, ThingMaker.MakeThing(desicator.desicatedDef));
}
else
{
CompRottable compRottable = __instance.Corpse.TryGetComp <CompRottable>();
compRottable.RotImmediately();
}
}
}
}
HediffDef def = DefDatabase <HediffDef> .GetNamed("RT_HuskTouch");
if (__instance.health.hediffSet.HasHediff(def))
{
// Log.Message("husktouch present");
CompRottable compRottable = __instance.Corpse.TryGetComp <CompRottable>();
compRottable.RotImmediately();
}
}
public static float ApproxDaysUntilRot(List <ThingCount> potentiallyFood, int tile, WorldPath path = null, float nextTileCostLeft = 0f, int caravanTicksPerMove = 3300)
{
DaysUntilRotCalculator.tmpTicksToArrive.Clear();
if (path != null && path.Found)
{
CaravanArrivalTimeEstimator.EstimatedTicksToArriveToEvery(tile, path.LastNode, path, nextTileCostLeft, caravanTicksPerMove, Find.TickManager.TicksAbs, DaysUntilRotCalculator.tmpTicksToArrive);
}
DaysUntilRotCalculator.tmpNutritions.Clear();
for (int i = 0; i < potentiallyFood.Count; i++)
{
ThingCount thingCount = potentiallyFood[i];
if (thingCount.Count > 0 && thingCount.Thing.def.IsNutritionGivingIngestible)
{
CompRottable compRottable = thingCount.Thing.TryGetComp <CompRottable>();
float first;
if (compRottable != null && compRottable.Active)
{
first = (float)DaysUntilRotCalculator.ApproxTicksUntilRot_AssumeTimePassesBy(compRottable, tile, DaysUntilRotCalculator.tmpTicksToArrive) / 60000f;
}
else
{
first = 600f;
}
float second = thingCount.Thing.GetStatValue(StatDefOf.Nutrition, true) * (float)thingCount.Count;
DaysUntilRotCalculator.tmpNutritions.Add(new Pair <float, float>(first, second));
}
}
return(GenMath.WeightedMedian(DaysUntilRotCalculator.tmpNutritions, 600f, 0.5f));
}
public override void TickRare()
{
base.TickRare();
if (innerContainer.Count >= 5)
{
tickCounter++;
if (tickCounter > digestionPeriod)
{
foreach (Thing thing in innerContainer)
{
Pawn pawnSwallowed = thing as Pawn;
if (pawnSwallowed != null)
{
if (!pawnSwallowed.Dead)
{
pawnSwallowed.Kill(null);
}
CompRottable compRottable = pawnSwallowed.Corpse.TryGetComp <CompRottable>();
if (compRottable != null && compRottable.Stage == RotStage.Fresh)
{
compRottable.RotProgress += 100000000;
}
}
}
EjectContents();
tickCounter = 0;
}
}
}
public override void DoCellSteadyEffects(IntVec3 c, Map map)
{
if (!c.Roofed(map))
{
List <Thing> thingList = c.GetThingList(map);
for (int i = 0; i < thingList.Count; i++)
{
Thing thing = thingList[i];
if (thing is Plant && thing.def.defName != PurpleIvyDefOf.PurpleIvy.defName)
{
if (Rand.Value < 0.0065f)
{
thing.Kill(null, null);
}
}
else if (thing.def.category == ThingCategory.Item)
{
CompRottable compRottable = thing.TryGetComp <CompRottable>();
if (compRottable != null && compRottable.Stage < RotStage.Dessicated)
{
compRottable.RotProgress += 3000f;
}
}
}
}
}
public static void Postfix(ref string __result, CompRottable __instance)
{
if (!ThermodynamicsSettings.warmersSlowRot)
{
return;
}
ThingWithComps rotter = __instance.parent;
Map map = rotter.Map;
if (map != null)
{
List <Thing> thingList = map.thingGrid.ThingsListAt(rotter.PositionHeld);
if (thingList != null)
{
foreach (Thing thing in thingList)
{
if (thing is Building_HeatedStorage bhs && bhs.IsActive())
{
__result = __result.Replace("Not refrigerated", "Warmed");
break;
}
}
}
}
}
private bool CanHarvest(Corpse corpse)
{
int maxage = Mathf.Max(Mod.BasicAutopsyCorpseAge.Value, Mod.AdvancedAutopsyCorpseAge.Value,
Mod.GlitterAutopsyCorpseAge.Value);
float decay = Mathf.Min(Mod.BasicAutopsyFrozenDecay.Value, Mod.AdvancedAutopsyFrozenDecay.Value,
Mod.GlitterAutopsyFrozenDecay.Value);
CompRottable rot = corpse.TryGetComp <CompRottable>();
bool notRotten = rot == null
? corpse.Age <= maxage * 2500
: rot.RotProgress + (corpse.Age - rot.RotProgress) * decay <=
maxage * 2500;
Pawn pawn = corpse.InnerPawn;
BodyPartRecord core = pawn.RaceProps.body.corePart;
List <BodyPartRecord> queue = new List <BodyPartRecord> {
core
};
HediffSet hediffSet = pawn.health.hediffSet;
while (queue.Count > 0)
{
BodyPartRecord part = queue.First();
queue.Remove(part);
if (CanGetPart(pawn, part, notRotten) && core != part)
{
return(true);
}
queue.AddRange(part.parts.Where(x => !hediffSet.PartIsMissing(x)));
}
return(false);
}
public static bool TryGetParts(Corpse corpse, RecipeInfo recipeInfo, BodyPartRecord part, float skillChance,
ref List <Thing> result)
{
if (IsCleanAndDroppable(corpse.InnerPawn, part))
{
CompRottable rot = corpse.TryGetComp <CompRottable>();
if ((rot == null
? corpse.Age <= recipeInfo.CorpseValidAge
: rot.RotProgress <= recipeInfo.CorpseValidAge) &&
Rand.Chance(Math.Min(skillChance, recipeInfo.NaturalChance)))
{
result.Add(ThingMaker.MakeThing(part.def.spawnThingOnRemoved));
}
return(true);
}
if (corpse.InnerPawn.health.hediffSet.hediffs.Any(x =>
x.Part == part && x.def.spawnThingOnRemoved != null &&
(x is Hediff_Implant || x is Hediff_AddedPart)))
{
result.AddRange(from hediff in corpse.InnerPawn.health.hediffSet.hediffs
where hediff.Part == part && hediff.def.spawnThingOnRemoved != null &&
(hediff is Hediff_Implant || hediff is Hediff_AddedPart) &&
Rand.Chance(Math.Min(skillChance, recipeInfo.BionicChance))
select ThingMaker.MakeThing(hediff.def.spawnThingOnRemoved));
return(true);
}
return(false);
}
private void AgeCorpse(Thing thing)
{
CompRottable compRot = thing.TryGetComp <CompRottable>();
if (compRot != null)
{
if (compRot.RotProgress <= (5000 + (5000 * pwrVal)))
{
Corpse corpse = thing as Corpse;
if (corpse != null && verVal >= 3)
{
TransmutateEffects(corpse.Position, 10);
Pawn innerPawn = corpse.InnerPawn;
ResurrectionUtility.ResurrectWithSideEffects(innerPawn);
AgePawn(innerPawn, Mathf.RoundToInt(6 * 2500 * (1 + (.1f * verVal))), false);
HealthUtility.AdjustSeverity(innerPawn, TorannMagicDefOf.TM_DeathReversalHD, 1f);
Projectile_Resurrection.ApplyHealthDefects(innerPawn, .25f, .3f);
Projectile_Resurrection.ReduceSkillsOfPawn(innerPawn, Rand.Range(.30f, .40f));
HealthUtility.AdjustSeverity(this.CasterPawn, TorannMagicDefOf.TM_DeathReversalHD, Rand.Range(.4f, .6f));
//Projectile_Resurrection.ApplyHealthDefects(this.CasterPawn, .15f, .2f);
Projectile_Resurrection.ReduceSkillsOfPawn(this.CasterPawn, Rand.Range(.15f, .25f));
}
}
else
{
compRot.RotProgress = compRot.RotProgress * (.4f - (.125f * pwrVal));
if (compRot.RotProgress <= 20000)
{
compRot.RotProgress = 20001;
}
}
}
}
public virtual void ChangeHeat(int ticks)
{
if (!IsActive())
{
return;
}
float targetTemp = GetTargetTemp();
foreach (Thing thing in base.slotGroup.HeldThings)
{
CompDTemperature comp = thing.TryGetComp <CompDTemperature>();
if (comp != null && comp.curTemp < targetTemp)
{
comp.Diffuse(targetTemp * 2f, ticks);
}
if (ThermodynamicsSettings.warmersSlowRot)
{
CompRottable rot = thing.TryGetComp <CompRottable>();
if (rot != null && GenTemperature.RotRateAtTemperature(thing.AmbientTemperature) == unrefrigeratedRotRate)
{
rot.RotProgress = rot.RotProgress - ticks * slowRotRateAmount;
}
}
}
}
public void ScanForRottables()
{
// Check for things removed
for (int i = 0; i < contents.Count; ++i)
{
var item = contents[i];
if ((item.thing == null) &&
(item.thingID != null))
{
//Log.Message( "thingID.resolve: '" + item.thingID + "'" );
item.thing = Find.ListerThings.AllThings.Find(t => t.ThingID == item.thingID);
//Log.Message( "thing.resolved: '" + item.thing + "'" );
}
if ((item.thing.Destroyed) ||
(item.thing.StoringBuilding() != Building_Storage))
{
// Modifing list, continue scan
contents.Remove(item);
continue;
}
}
// Add new things
foreach (Thing t in Building_Storage.slotGroup.HeldThings)
{
CompRottable compRottable = t.TryGetComp <CompRottable>();
if ((compRottable != null) &&
(contents.Find(item => item.thing == t) == null))
{
contents.Add(new RefrigeratorContents(t, compRottable));
}
}
}
public static void CheckIfPawnShouldUnloadInventory(Pawn pawn, bool forced = false)
{
Job job = JobMaker.MakeJob(PickUpAndHaulJobDefOf.UnloadYourHauledInventory, pawn);
CompHauledToInventory itemsTakenToInventory = pawn.TryGetComp <CompHauledToInventory>();
if (itemsTakenToInventory == null)
{
return;
}
HashSet <Thing> carriedThing = itemsTakenToInventory.GetHashSet();
if (pawn.Faction != Faction.OfPlayer || !pawn.RaceProps.Humanlike)
{
return;
}
if (carriedThing == null || carriedThing.Count == 0 || pawn.inventory.innerContainer.Count == 0)
{
return;
}
if (forced)
{
if (job.TryMakePreToilReservations(pawn, false))
{
pawn.jobs.jobQueue.EnqueueFirst(job, JobTag.Misc);
return;
}
}
if (MassUtility.EncumbrancePercent(pawn) >= 0.90f || carriedThing.Count >= 1)
{
if (job.TryMakePreToilReservations(pawn, false))
{
pawn.jobs.jobQueue.EnqueueFirst(job, JobTag.Misc);
return;
}
}
if (pawn.inventory.innerContainer?.Count >= 1)
{
foreach (Thing rottable in pawn.inventory.innerContainer)
{
CompRottable compRottable = rottable.TryGetComp <CompRottable>();
if (compRottable?.TicksUntilRotAtCurrentTemp < 30000)
{
pawn.jobs.jobQueue.EnqueueFirst(job, JobTag.Misc);
return;
}
}
}
if (Find.TickManager.TicksGame % 50 == 0 && pawn.inventory.innerContainer.Count < carriedThing.Count)
{
Verse.Log.Warning("[PickUpAndHaul] " + pawn + " inventory was found out of sync with haul index. Pawn will drop their inventory.");
carriedThing.Clear();
pawn.inventory.UnloadEverything = true;
}
}
public static bool Prefix(ref float temp, CompRottable __instance)
{
if (!ThermodynamicsSettings.warmersSlowRot)
{
return(true);
}
ThingWithComps rotter = __instance.parent;
Map map = rotter.Map;
if (map != null)
{
List <Thing> thingList = map.thingGrid.ThingsListAt(rotter.PositionHeld);
if (thingList != null)
{
foreach (Thing thing in thingList)
{
if (thing is Building_HeatedStorage bhs && bhs.IsActive())
{
temp = 1f;
break;
}
}
}
}
return(true);
}
internal static CompRefrigerated CompRefrigerated(this CompRottable obj)
{
IntVec3 checkPos = IntVec3.Invalid;
if (obj.parent.holder != null)
{
checkPos = obj.parent.PositionHeld;
}
else
{
checkPos = obj.parent.Position;
}
if (
(checkPos == IntVec3.Invalid) ||
(!checkPos.InBounds())
)
{
return(null);
}
var refrigerator = checkPos.GetThingList().FirstOrDefault(t => (
(t.TryGetComp <CompRefrigerated>() != null)
));
return(refrigerator?.TryGetComp <CompRefrigerated>());
}
static void Postfix(CompRottable __instance)
{
if (Multiplayer.Client == null)
{
return;
}
Multiplayer.WorldComp.DirtyColonyTradeForMap(__instance.parent.Map);
}
internal static bool ShouldTakeDessicateDamage(this CompRottable obj)
{
if (_ShouldTakeDessicateDamage == null)
{
_ShouldTakeDessicateDamage = typeof(CompRottable).GetMethod("ShouldTakeDessicateDamage", BindingFlags.Instance | BindingFlags.NonPublic);
}
return((bool)_ShouldTakeDessicateDamage.Invoke(obj, null));
}
public static void MakeColony(params ColonyMakerFlag[] flags)
{
bool godMode = DebugSettings.godMode;
DebugSettings.godMode = true;
Thing.allowDestroyNonDestroyable = true;
if (FixedColonyAnimalsDebug.usedCells == null)
{
FixedColonyAnimalsDebug.usedCells = new BoolGrid(FixedColonyAnimalsDebug.Map);
}
else
{
FixedColonyAnimalsDebug.usedCells.ClearAndResizeTo(FixedColonyAnimalsDebug.Map);
}
FixedColonyAnimalsDebug.overRect = new CellRect(FixedColonyAnimalsDebug.Map.Center.x - 50, FixedColonyAnimalsDebug.Map.Center.z - 50, 100, 100);
FixedColonyAnimalsDebug.DeleteAllSpawnedPawns();
GenDebug.ClearArea(FixedColonyAnimalsDebug.overRect, Find.CurrentMap);
if (flags.Contains(ColonyMakerFlag.Animals))
{
foreach (PawnKindDef pawnKindDef in from k in DefDatabase <PawnKindDef> .AllDefs
where k.RaceProps.Animal && k != InternalDefOf.GR_FleshFlies
select k)
{
CellRect cellRect;
if (!FixedColonyAnimalsDebug.TryGetFreeRect(6, 3, out cellRect))
{
return;
}
cellRect = cellRect.ContractedBy(1);
foreach (IntVec3 c in cellRect)
{
FixedColonyAnimalsDebug.Map.terrainGrid.SetTerrain(c, TerrainDefOf.Concrete);
}
GenSpawn.Spawn(PawnGenerator.GeneratePawn(pawnKindDef, null), cellRect.Cells.ElementAt(0), FixedColonyAnimalsDebug.Map, WipeMode.Vanish);
IntVec3 intVec = cellRect.Cells.ElementAt(1);
Pawn deadpawn = (Pawn)GenSpawn.Spawn(PawnGenerator.GeneratePawn(pawnKindDef, null), intVec, FixedColonyAnimalsDebug.Map, WipeMode.Vanish);
deadpawn.Kill(null);
CompRottable compRottable = ((Corpse)intVec.GetThingList(Find.CurrentMap).First((Thing t) => t is Corpse)).TryGetComp <CompRottable>();
if (compRottable != null)
{
compRottable.RotProgress += 1200000f;
}
if (pawnKindDef.RaceProps.leatherDef != null)
{
GenSpawn.Spawn(pawnKindDef.RaceProps.leatherDef, cellRect.Cells.ElementAt(2), FixedColonyAnimalsDebug.Map, WipeMode.Vanish);
}
if (pawnKindDef.RaceProps.meatDef != null)
{
GenSpawn.Spawn(pawnKindDef.RaceProps.meatDef, cellRect.Cells.ElementAt(3), FixedColonyAnimalsDebug.Map, WipeMode.Vanish);
}
}
}
FixedColonyAnimalsDebug.ClearAllHomeArea();
FixedColonyAnimalsDebug.FillWithHomeArea(FixedColonyAnimalsDebug.overRect);
DebugSettings.godMode = godMode;
Thing.allowDestroyNonDestroyable = false;
}
private void AgeFood(Thing thing)
{
CompRottable compRot = thing.TryGetComp <CompRottable>();
if (compRot != null)
{
compRot.RotProgress = compRot.RotProgress * (.4f - (.125f * pwrVal));
}
}
public override bool FilterApplies(Thing thing)
{
CompRottable rot = thing.TryGetComp <CompRottable>();
return
(extraOption == 1 ? rot != null :
extraOption == 2 ? GenTemperature.RotRateAtTemperature(thing.AmbientTemperature) is float r && r > 0 && r < 1 :
extraOption == 3 ? GenTemperature.RotRateAtTemperature(thing.AmbientTemperature) <= 0 :
rot?.Stage == sel);
}
public override void TickRare()
{
if (this.CurrentTemp < -2000f)
{
this.CurrentTemp = GridsUtility.GetTemperature(base.Position, base.Map);
}
foreach (IntVec3 cell in this.AllSlotCells())
{
foreach (Thing thing in GridsUtility.GetThingList(cell, base.Map))
{
CompRottable rottable = ThingCompUtility.TryGetComp <CompRottable>(thing);
if (rottable != null && !(rottable is CompBetterRottable))
{
ThingWithComps thingWithComps = thing as ThingWithComps;
CompBetterRottable compBetterRottable = new CompBetterRottable();
thingWithComps.AllComps.Remove(rottable);
thingWithComps.AllComps.Add(compBetterRottable);
compBetterRottable.props = rottable.props;
compBetterRottable.parent = thingWithComps;
compBetterRottable.RotProgress = rottable.RotProgress;
}
if (ThingCompUtility.TryGetComp <CompFrosty>(thing) == null && thing.def.defName == "Beer")
{
ThingWithComps thingWithComps = thing as ThingWithComps;
CompFrosty compFrosty = new CompFrosty();
thingWithComps.AllComps.Add(compFrosty);
compFrosty.props = CompProperties_Frosty.Beer;
compFrosty.parent = thingWithComps;
((TickList)typeof(TickManager).GetField("tickListRare", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(Find.TickManager)).RegisterThing(thingWithComps);
}
}
}
float roomTemperature = GridsUtility.GetTemperature(base.Position, base.Map);
float changetemperature = (roomTemperature - this.CurrentTemp) * 0.01f;
float changeEnergy = -changetemperature;
float powerMultiplier = 0f;
if (this.CurrentTemp + changetemperature > this.DesiredTemp)
{
float change = Mathf.Max(this.DesiredTemp - (this.CurrentTemp + changetemperature), -1f);
if (this.powerComp != null && this.powerComp.PowerOn)
{
changetemperature += change;
changeEnergy -= change * 1.25f;
}
powerMultiplier = change * -1f;
}
this.CurrentTemp += changetemperature;
IntVec3 pos = base.Position + IntVec3.North.RotatedBy(base.Rotation);
GenTemperature.PushHeat(pos, base.Map, changeEnergy * 1.25f);
this.powerComp.PowerOutput = -((CompProperties_Power)this.powerComp.props).basePowerConsumption * (powerMultiplier * 0.9f + 0.1f);
}
public static bool Prefix(ref CompRottable __instance)
{
if (!__instance.parent.Spawned ||
__instance.parent.Position.GetFirstThingWithComp <CompRottable>(__instance.parent.Map) == null)
{
return(true);
}
Ticky(__instance, 250);
return(false);
}
public static void Postfix(CompRottable __instance, RotStage __result)
{
if (__result == RotStage.Dessicated && __instance.parent is Corpse corpse &&
(corpse.InnerPawn?.health?.hediffSet?.HasHediff(AlteredCarbonDefOf.AC_CorticalStack) ?? true))
{
var corticalStack = ThingMaker.MakeThing(AlteredCarbonDefOf.AC_FilledCorticalStack) as CorticalStack;
corticalStack.SavePawnToCorticalStack(corpse.InnerPawn);
GenPlace.TryPlaceThing(corticalStack, corpse.Position, corpse.Map, ThingPlaceMode.Near);
corpse.InnerPawn.health.hediffSet.hediffs.RemoveAll(x => x.def == AlteredCarbonDefOf.AC_CorticalStack);
}
}
private static void Rot1Day()
{
foreach (Thing item in Find.CurrentMap.thingGrid.ThingsAt(UI.MouseCell()))
{
CompRottable compRottable = item.TryGetComp <CompRottable>();
if (compRottable != null)
{
compRottable.RotProgress += 60000f;
}
}
}
public override bool Matches(Thing t)
{
ThingWithComps thingWithComps = t as ThingWithComps;
if (thingWithComps == null)
{
return(false);
}
CompRottable comp = thingWithComps.GetComp <CompRottable>();
return(comp != null && !((CompProperties_Rottable)comp.props).rotDestroys && comp.Stage == RotStage.Fresh);
}
public static float GetRotDays(Thing t)
{
float result = 99999f;
CompRottable compRottable = t.TryGetComp <CompRottable>();
bool hasRottableComp = compRottable != null;
if (hasRottableComp)
{
result = compRottable.TicksUntilRotAtCurrentTemp.TicksToDays();
}
return(result);
}
public static bool CompInspectStringCustomHopper(CompRottable __instance, ref string __result)
{
IEnumerable <Thing> things = GetCompRottableThings(__instance);
if (things.OfType <NPDHopper_Storage>().Any())
{
Thing t = things.OfType <NPDHopper_Storage>().First();
StringBuilder stringBuilder = new StringBuilder();
RotStage stage = __instance.Stage;
if (stage != RotStage.Fresh)
{
if (stage != RotStage.Rotting)
{
if (stage == RotStage.Dessicated)
{
stringBuilder.Append("RotStateDessicated".Translate() + ".");
}
}
else
{
stringBuilder.Append("RotStateRotting".Translate() + ".");
}
}
else
{
stringBuilder.Append("RotStateFresh".Translate() + ".");
}
float num = (float)__instance.PropsRot.TicksToRotStart - __instance.RotProgress;
if (num > 0f)
{
float num2 = t.TryGetComp <CompPowerTrader>().PowerOn ? (float)Mathf.RoundToInt(things.OfType <NPDHopper_Storage>().First().def.GetModExtension <HopperCustom>().setTemperature)
: __instance.parent.AmbientTemperature;
float num3 = GenTemperature.RotRateAtTemperature(num2);
int ticksUntilRotAtCurrentTemp = TicksUntilRotAtSetTemp(__instance, num2);
stringBuilder.AppendLine();
if (num3 < 0.001f)
{
stringBuilder.Append("CurrentlyFrozen".Translate() + ".");
}
else if (num3 < 0.999f)
{
stringBuilder.Append("CurrentlyRefrigerated".Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod()) + ".");
}
else
{
stringBuilder.Append("NotRefrigerated".Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod()) + ".");
}
}
__result = stringBuilder.ToString();
return(false);
}
return(true);
}
public RefrigeratorContents( Thing t, CompRottable compRottable )
{
thing = t;
HitPoints = t.HitPoints;
rotProgress = compRottable.rotProgress;
}
