public override string CompInspectStringExtra()
{
StringBuilder sb = new StringBuilder();
switch (base.Stage)
{
case RotStage.Fresh:
sb.Append("RotStateFresh".Translate());
break;
case RotStage.Rotting:
sb.Append("RotStateRotting".Translate());
break;
case RotStage.Dessicated:
sb.Append("RotStateDessicated".Translate());
break;
}
float num = (float)this.PropsRot.TicksToRotStart - base.RotProgress;
if (num > 0f)
{
float num2 = GenTemperature.GetTemperatureForCell(this.parent.PositionHeld, this.parent.Map);
List <Thing> thingList = GridsUtility.GetThingList(this.parent.PositionHeld, this.parent.Map);
for (int i = 0; i < thingList.Count; i++)
{
if (thingList[i] is Building_Refrigerator)
{
Building_Refrigerator building_Refrigerator = thingList[i] as Building_Refrigerator;
num2 = building_Refrigerator.CurrentTemp;
break;
}
}
num2 = (float)Mathf.RoundToInt(num2);
float num3 = GenTemperature.RotRateAtTemperature(num2);
int ticksUntilRotAtCurrentTemp = base.TicksUntilRotAtCurrentTemp;
if (num3 < 0.001f)
{
sb.Append(Translator.Translate("CurrentlyFrozen") + ".");
}
else
{
if (num3 < 0.999f)
{
sb.Append(Translator.Translate("CurrentlyRefrigerated", new object[]
{
GenDate.ToStringTicksToPeriodVague(ticksUntilRotAtCurrentTemp)
}) + ".");
}
else
{
sb.Append(Translator.Translate("NotRefrigerated", new object[]
{
GenDate.ToStringTicksToPeriodVague(ticksUntilRotAtCurrentTemp)
}) + ".");
}
}
}
return(sb.ToString().TrimEndNewlines());
}
public void TickRottables()
{
if (storedDef == null || Find.TickManager.TicksAbs % 250 != 0)
{
return;
}
if (StoredIsRottable)
{
float rotProgress = rotProgressInt;
float num = 1f;
float temperatureForCell = GenTemperature.GetTemperatureForCell(Position, Map);
num *= GenTemperature.RotRateAtTemperature(temperatureForCell);
rotProgressInt += Mathf.Round(num * 250f);
if (rotProgressInt >= storedDef.GetCompProperties <CompProperties_Rottable>().TicksToRotStart)
{
Messages.Message("MessageRottedAwayInStorage".Translate(storedDef.label).CapitalizeFirst(), MessageTypeDefOf.SilentInput);
storedDef = null;
ThingCount = 0;
rotProgressInt = 1;
}
}
else
{
rotProgressInt = 0;
}
}
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 override string CompInspectStringExtra()
{
if (!this.Active)
{
return(null);
}
StringBuilder stringBuilder = new StringBuilder();
switch (this.Stage)
{
case RotStage.Fresh:
stringBuilder.Append("VCE_PlumsDrying".Translate() + ".");
break;
}
if ((float)this.PropsRot.TicksToRotStart - this.RotProgress > 0f)
{
float num = GenTemperature.RotRateAtTemperature((float)Mathf.RoundToInt(this.parent.AmbientTemperature));
int ticksUntilRotAtCurrentTemp = this.TicksUntilRotAtCurrentTemp;
stringBuilder.AppendLine();
if (num < 0.001f)
{
stringBuilder.Append("VCE_PlumsCurrentlyFrozen".Translate() + ".");
}
else if (num < 0.999f)
{
stringBuilder.Append("VCE_PlumsCurrentlyRefrigerated".Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod(true, false, true, true)) + ".");
}
else
{
stringBuilder.Append("VCE_PlumsDryingCorrectly".Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod(true, false, true, true)) + ".");
}
}
return(stringBuilder.ToString());
}
private void Tick(int interval)
{
if (this.Active)
{
float rotProgress = this.RotProgress;
float ambientTemperature = base.parent.AmbientTemperature;
float num = GenTemperature.RotRateAtTemperature(ambientTemperature);
this.RotProgress += num * (float)interval;
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDestroys)
{
if (base.parent.Spawned && base.parent.Map.slotGroupManager.SlotGroupAt(base.parent.Position) != null)
{
Messages.Message("MessageRottedAwayInStorage".Translate(base.parent.Label).CapitalizeFirst(), MessageTypeDefOf.NegativeEvent);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers, OpportunityType.GoodToKnow);
}
base.parent.Destroy(DestroyMode.Vanish);
}
else if (Mathf.FloorToInt((float)(rotProgress / 60000.0)) != Mathf.FloorToInt((float)(this.RotProgress / 60000.0)) && this.ShouldTakeRotDamage())
{
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDamagePerDay > 0.0)
{
base.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, GenMath.RoundRandom(this.PropsRot.rotDamagePerDay), -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown));
}
else if (this.Stage == RotStage.Dessicated && this.PropsRot.dessicatedDamagePerDay > 0.0)
{
base.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, GenMath.RoundRandom(this.PropsRot.dessicatedDamagePerDay), -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown));
}
}
}
}
public int TicksUntilRotAtTemp(float temp)
{
int result;
if (!this.Active)
{
result = 72000000;
}
else
{
float num = GenTemperature.RotRateAtTemperature(temp);
if (num <= 0f)
{
result = 72000000;
}
else
{
float num2 = (float)this.PropsRot.TicksToRotStart - this.RotProgress;
if (num2 <= 0f)
{
result = 0;
}
else
{
result = Mathf.RoundToInt(num2 / num);
}
}
}
return(result);
}
private void Tick(int interval)
{
if (!this.Active)
{
return;
}
float rotProgress = this.RotProgress;
float ambientTemperature = this.parent.AmbientTemperature;
float num = GenTemperature.RotRateAtTemperature(ambientTemperature);
this.RotProgress += num * (float)interval;
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDestroys)
{
if (this.parent.IsInAnyStorage() && this.parent.SpawnedOrAnyParentSpawned)
{
Messages.Message("MessageRottedAwayInStorage".Translate(this.parent.Label, this.parent).CapitalizeFirst(), new TargetInfo(this.parent.PositionHeld, this.parent.MapHeld, false), MessageTypeDefOf.NegativeEvent, true);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers, OpportunityType.GoodToKnow);
}
this.parent.Destroy(DestroyMode.Vanish);
return;
}
bool flag = Mathf.FloorToInt(rotProgress / 60000f) != Mathf.FloorToInt(this.RotProgress / 60000f);
if (flag && this.ShouldTakeRotDamage())
{
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.rotDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null));
}
else if (this.Stage == RotStage.Dessicated && this.PropsRot.dessicatedDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.dessicatedDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null));
}
}
}
private void Tick(int interval)
{
if (Active)
{
float rotProgress = RotProgress;
float ambientTemperature = parent.AmbientTemperature;
float num = GenTemperature.RotRateAtTemperature(ambientTemperature);
RotProgress += num * (float)interval;
if (Stage == RotStage.Rotting && PropsRot.rotDestroys)
{
if (parent.IsInAnyStorage() && parent.SpawnedOrAnyParentSpawned)
{
Messages.Message("MessageRottedAwayInStorage".Translate(parent.Label, parent).CapitalizeFirst(), new TargetInfo(parent.PositionHeld, parent.MapHeld), MessageTypeDefOf.NegativeEvent);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers, OpportunityType.GoodToKnow);
}
parent.Destroy();
}
else if (Mathf.FloorToInt(rotProgress / 60000f) != Mathf.FloorToInt(RotProgress / 60000f) && ShouldTakeRotDamage())
{
if (Stage == RotStage.Rotting && PropsRot.rotDamagePerDay > 0f)
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(PropsRot.rotDamagePerDay)));
}
else if (Stage == RotStage.Dessicated && PropsRot.dessicatedDamagePerDay > 0f)
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(PropsRot.dessicatedDamagePerDay)));
}
}
}
}
public override void CompTickRare()
{
if (this.parent.MapHeld != null && this.parent.Map != null)
{
HashSet <Thing> list = new HashSet <Thing>(this.parent.MapHeld.thingGrid.ThingsListAtFast(this.parent.PositionHeld));
var isMeat = this?.parent?.def.IsMeat ?? false;
var isSalted = this?.parent?.def?.defName?.ToLowerInvariant()?.Contains("salted") ?? false;
var pantryShelf = list.FirstOrDefault(x => x is Building_RottableFixer && x.def.defName == "LotR_PantryShelf");
var saltPot = list.FirstOrDefault(x => x is Building_RottableFixer && x.def.defName == "LotR_SaltBarrel");
if (isMeat && !isSalted && saltPot != null)
{
HandleMeatThatNeedsSalting(this.parent);
return;
}
float rotProgress = this.RotProgress;
float num = 1f;
float temperatureForCell = GenTemperature.GetTemperatureForCell(this.parent.PositionHeld, this.parent.MapHeld);
var b = list.FirstOrDefault(x => x is Building_RottableFixer);
if (b != null)
{
if (!isMeat && b.def.defName == "LotR_PantryShelf")
{
num = 0.3f;
}
if (b.def.defName == "LotR_SaltBarrel")
{
num = 0.0666667f;
}
}
num *= GenTemperature.RotRateAtTemperature(temperatureForCell);
this.RotProgress += Mathf.Round(num * 250f);
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDestroys)
{
if (this.parent.Position.GetSlotGroup(this.parent.Map) != null)
{
Messages.Message("MessageRottedAwayInStorage".Translate(new object[]
{
this.parent.Label
}).CapitalizeFirst(), MessageTypeDefOf.SilentInput);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers, OpportunityType.GoodToKnow);
}
this.parent.Destroy(DestroyMode.Vanish);
return;
}
if (Mathf.FloorToInt(rotProgress / 60000f) != Mathf.FloorToInt(this.RotProgress / 60000f))
{
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.rotDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown));
}
else if (this.Stage == RotStage.Dessicated && this.PropsRot.dessicatedDamagePerDay > 0f && this.ShouldTakeDessicateDamage())
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.dessicatedDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown));
}
}
}
}
public override void CompTickRare()
{
if (parent.MapHeld == null || parent.Map == null)
{
return;
}
var rotProgress = RotProgress;
var num = 1f;
var temperatureForCell =
GenTemperature.GetTemperatureForCell(parent.PositionHeld, parent.MapHeld);
var list = parent.MapHeld.thingGrid.ThingsListAtFast(parent.PositionHeld);
foreach (var thing in list)
{
if (thing is not Building_Refrigerator bf)
{
continue;
}
temperatureForCell = bf.CurrentTemp;
break;
}
num *= GenTemperature.RotRateAtTemperature(temperatureForCell);
RotProgress += Mathf.Round(num * 250f);
if (Stage == RotStage.Rotting && PropsRot.rotDestroys)
{
if (parent.IsInAnyStorage() && parent.SpawnedOrAnyParentSpawned)
{
Messages.Message("MessageRottedAwayInStorage".Translate(parent.Label).CapitalizeFirst(),
new TargetInfo(parent.PositionHeld, parent.MapHeld),
MessageTypeDefOf.NegativeEvent);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers,
OpportunityType.GoodToKnow);
}
parent.Destroy();
return;
}
if (Mathf.FloorToInt(rotProgress / 60000f) == Mathf.FloorToInt(RotProgress / 60000f) ||
!ShouldTakeRotDamage())
{
return;
}
if (Stage == RotStage.Rotting && PropsRot.rotDamagePerDay > 0f)
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
GenMath.RoundRandom(PropsRot.rotDamagePerDay)));
}
else if (Stage == RotStage.Dessicated && PropsRot.dessicatedDamagePerDay > 0f)
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
GenMath.RoundRandom(PropsRot.dessicatedDamagePerDay)));
}
}
public override string CompInspectStringExtra()
{
if (!this.Active)
{
return(null);
}
StringBuilder stringBuilder = new StringBuilder();
RotStage stage = this.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)this.PropsRot.TicksToRotStart - this.RotProgress;
if (num > 0f)
{
float num2 = this.parent.AmbientTemperature;
num2 = (float)Mathf.RoundToInt(num2);
float num3 = GenTemperature.RotRateAtTemperature(num2);
int ticksUntilRotAtCurrentTemp = this.TicksUntilRotAtCurrentTemp;
stringBuilder.AppendLine();
if (num3 < 0.001f)
{
stringBuilder.Append("CurrentlyFrozen".Translate() + ".");
}
else if (num3 < 0.999f)
{
stringBuilder.Append("CurrentlyRefrigerated".Translate(new object[]
{
ticksUntilRotAtCurrentTemp.ToStringTicksToPeriodVague(true, true)
}) + ".");
}
else
{
stringBuilder.Append("NotRefrigerated".Translate(new object[]
{
ticksUntilRotAtCurrentTemp.ToStringTicksToPeriodVague(true, true)
}) + ".");
}
}
return(stringBuilder.ToString());
}
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 CompTickRare()
{
if (this.parent.MapHeld != null && this.parent.Map != null)
{
float rotProgress = this.RotProgress;
float num = 1f;
float temperatureForCell =
GenTemperature.GetTemperatureForCell(this.parent.PositionHeld, this.parent.MapHeld);
List <Thing> list = this.parent.MapHeld.thingGrid.ThingsListAtFast(this.parent.PositionHeld);
for (int i = 0; i < list.Count; i++)
{
if (list[i] is Building_Refrigerator)
{
var bf = list[i] as Building_Refrigerator;
temperatureForCell = bf.CurrentTemp;
break;
}
}
num *= GenTemperature.RotRateAtTemperature(temperatureForCell);
this.RotProgress += Mathf.Round(num * 250f);
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDestroys)
{
if (this.parent.IsInAnyStorage() && this.parent.SpawnedOrAnyParentSpawned)
{
Messages.Message("MessageRottedAwayInStorage".Translate(new object[]
{
this.parent.Label
}).CapitalizeFirst(), new TargetInfo(this.parent.PositionHeld, this.parent.MapHeld, false),
MessageTypeDefOf.NegativeEvent, true);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers,
OpportunityType.GoodToKnow);
}
this.parent.Destroy(DestroyMode.Vanish);
return;
}
bool flag = Mathf.FloorToInt(rotProgress / 60000f) != Mathf.FloorToInt(this.RotProgress / 60000f);
if (flag && ShouldTakeRotDamage())
{
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
(float)GenMath.RoundRandom(this.PropsRot.rotDamagePerDay), 0f, -1f, null, null, null,
DamageInfo.SourceCategory.ThingOrUnknown, null));
}
else if (this.Stage == RotStage.Dessicated && this.PropsRot.dessicatedDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
(float)GenMath.RoundRandom(this.PropsRot.dessicatedDamagePerDay), 0f, -1f, null, null,
null, DamageInfo.SourceCategory.ThingOrUnknown, null));
}
}
}
}
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 static void Postfix(ref CompRottable __instance, ref int __result, float temp)
{
if (__result >= 72000000 || __result <= 0 || !__instance.parent.Spawned ||
__instance.parent.Position.GetFirstThingWithComp <CompAYPreserve>(__instance.parent.Map) == null)
{
return;
}
var num = GenTemperature.RotRateAtTemperature(temp);
var num2 = __instance.PropsRot.TicksToRotStart - __instance.RotProgress;
__result = Mathf.RoundToInt(num2 / num) * 2;
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
this.compPowerTrader = base.GetComp <CompPowerTrader>();
this.compDTempControl = base.GetComp <CompDTempControl>();
this.compRefuelable = base.GetComp <CompRefuelable>();
if (unrefrigeratedRotRate < 0)
{
unrefrigeratedRotRate = GenTemperature.RotRateAtTemperature(999f);
}
if (slowRotRateAmount < 0)
{
slowRotRateAmount = unrefrigeratedRotRate - GenTemperature.RotRateAtTemperature(1f);
}
}
public override string CompInspectStringExtra()
{
if (!Active)
{
return(null);
}
var sb = new StringBuilder();
switch (Stage)
{
case RotStage.Fresh: sb.Append("RotStateFresh".Translate() + "."); break;
case RotStage.Rotting: sb.Append("RotStateRotting".Translate() + "."); break;
case RotStage.Dessicated: sb.Append("RotStateDessicated".Translate() + "."); break;
}
float progressUntilStartRot = PropsRot.TicksToRotStart - RotProgress;
if (progressUntilStartRot > 0)
{
float cellTemp = parent.AmbientTemperature;
cellTemp = Mathf.RoundToInt(cellTemp); //Rounding here reduces dithering
float rotRate = GenTemperature.RotRateAtTemperature(cellTemp);
int ticksUntilStartRot = TicksUntilRotAtCurrentTemp;
sb.AppendLine();
if (rotRate < 0.001f)
{
// frozen
sb.Append("CurrentlyFrozen".Translate() + ".");
}
else if (rotRate < 0.999f)
{
// refrigerated
sb.Append("CurrentlyRefrigerated".Translate(ticksUntilStartRot.ToStringTicksToPeriod()) + ".");
}
else
{
// not refrigerated
sb.Append("NotRefrigerated".Translate(ticksUntilStartRot.ToStringTicksToPeriod()) + ".");
}
}
return(sb.ToString());
}
private void Tick(int interval)
{
if (!this.Active)
{
return;
}
float rotProgress = this.RotProgress;
float num = GenTemperature.RotRateAtTemperature(this.parent.AmbientTemperature);
this.RotProgress += num * (float)interval;
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDestroys)
{
//The first main change from the rotting code is here
//If the item reaches it's rotting time, a new item with the same stackCount is spawned on its location, and this item is destroyed
//The map check is done... just in case
if (this.parent.Map != null)
{
int stackCount = this.parent.stackCount;
ThingDef newThingDef = ThingDef.Named(PropsRot.thingToTransformTo);
Thing newThing = GenSpawn.Spawn(newThingDef, this.parent.Position, this.parent.Map, WipeMode.Vanish);
newThing.stackCount = stackCount;
this.parent.Destroy(DestroyMode.Vanish);
}
else
{
this.parent.Destroy(DestroyMode.Vanish);
}
return;
}
if (Mathf.FloorToInt(rotProgress / 60000f) != Mathf.FloorToInt(this.RotProgress / 60000f) && this.ShouldTakeRotDamage())
{
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.rotDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null));
return;
}
if (this.Stage == RotStage.Dessicated && this.PropsRot.dessicatedDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.dessicatedDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null));
}
}
}
public override string CompInspectStringExtra()
{
if (!Active)
{
return(null);
}
StringBuilder stringBuilder = new StringBuilder();
switch (Stage)
{
case RotStage.Fresh:
stringBuilder.Append("RotStateFresh".Translate() + ".");
break;
case RotStage.Rotting:
stringBuilder.Append("RotStateRotting".Translate() + ".");
break;
case RotStage.Dessicated:
stringBuilder.Append("RotStateDessicated".Translate() + ".");
break;
}
float num = (float)PropsRot.TicksToRotStart - RotProgress;
if (num > 0f)
{
float ambientTemperature = parent.AmbientTemperature;
ambientTemperature = (float)Mathf.RoundToInt(ambientTemperature);
float num2 = GenTemperature.RotRateAtTemperature(ambientTemperature);
int ticksUntilRotAtCurrentTemp = TicksUntilRotAtCurrentTemp;
stringBuilder.AppendLine();
if (num2 < 0.001f)
{
stringBuilder.Append("CurrentlyFrozen".Translate() + ".");
}
else if (num2 < 0.999f)
{
stringBuilder.Append("CurrentlyRefrigerated".Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod()) + ".");
}
else
{
stringBuilder.Append("NotRefrigerated".Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod()) + ".");
}
}
return(stringBuilder.ToString());
}
// Token: 0x06000038 RID: 56 RVA: 0x00003884 File Offset: 0x00001A84
private static void Ticky(CompRottable CR, int interval)
{
if (!CR.Active)
{
return;
}
interval = (int)(interval / 2f);
var rotProgress = CR.RotProgress;
var num = GenTemperature.RotRateAtTemperature(CR.parent.AmbientTemperature);
CR.RotProgress += num * interval;
if (CR.Stage == RotStage.Rotting && CR.PropsRot.rotDestroys)
{
if (CR.parent.IsInAnyStorage() && CR.parent.SpawnedOrAnyParentSpawned)
{
Messages.Message(
"MessageRottedAwayInStorage".Translate(CR.parent.Label, CR.parent).CapitalizeFirst(),
new TargetInfo(CR.parent.PositionHeld, CR.parent.MapHeld), MessageTypeDefOf.NegativeEvent);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers, OpportunityType.GoodToKnow);
}
CR.parent.Destroy();
return;
}
if (Mathf.FloorToInt(rotProgress / 60000f) == Mathf.FloorToInt(CR.RotProgress / 60000f) ||
!ShouldTakeRotDamage(CR))
{
return;
}
if (CR.Stage == RotStage.Rotting && CR.PropsRot.rotDamagePerDay > 0f)
{
CR.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
GenMath.RoundRandom(CR.PropsRot.rotDamagePerDay)));
return;
}
if (CR.Stage == RotStage.Dessicated && CR.PropsRot.dessicatedDamagePerDay > 0f)
{
CR.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
GenMath.RoundRandom(CR.PropsRot.dessicatedDamagePerDay)));
}
}
private void Tick(int interval)
{
if (!Active)
{
return;
}
float previousProgress = RotProgress;
// Do rotting progress according to temperature
float cellTemp = parent.AmbientTemperature;
float rotRate = GenTemperature.RotRateAtTemperature(cellTemp);
RotProgress += rotRate * interval;
//Destroy if needed
//Should this be in StageChanged?
if (Stage == RotStage.Rotting && PropsRot.rotDestroys)
{
if (parent.IsInAnyStorage() && parent.SpawnedOrAnyParentSpawned)
{
Messages.Message("MessageRottedAwayInStorage".Translate(parent.Label, parent).CapitalizeFirst(), new TargetInfo(parent.PositionHeld, parent.MapHeld), MessageTypeDefOf.NegativeEvent);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers, OpportunityType.GoodToKnow);
}
parent.Destroy();
return;
}
//Once per day...
bool isNewDay = Mathf.FloorToInt(previousProgress / GenDate.TicksPerDay) != Mathf.FloorToInt(RotProgress / GenDate.TicksPerDay);
if (isNewDay && ShouldTakeRotDamage())
{
if (Stage == RotStage.Rotting && PropsRot.rotDamagePerDay > 0)
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, GenMath.RoundRandom(PropsRot.rotDamagePerDay)));
}
else if (Stage == RotStage.Dessicated && PropsRot.dessicatedDamagePerDay > 0)
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, GenMath.RoundRandom(PropsRot.dessicatedDamagePerDay)));
}
}
}
internal static void _CompTickRare(this CompRottable obj)
{
if (obj.InRefrigerator())
{
return;
}
float num = obj.rotProgress;
obj.rotProgress += (float)Mathf.RoundToInt(1f * GenTemperature.RotRateAtTemperature(GenTemperature.GetTemperatureForCell(obj.parent.PositionHeld)) * 250f);
if (
(obj.Stage == RotStage.Rotting) &&
(obj.PropsRot().rotDestroys)
)
{
obj.parent.Destroy(DestroyMode.Vanish);
}
else
{
if (Mathf.FloorToInt(num / 60000f) == Mathf.FloorToInt(obj.rotProgress / 60000f))
{
return;
}
if (
(obj.Stage == RotStage.Rotting) &&
(obj.PropsRot().rotDamagePerDay > 0.0f)
)
{
obj.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, GenMath.RoundRandom(obj.PropsRot().rotDamagePerDay), (Thing)null, new BodyPartDamageInfo?(), (ThingDef)null));
}
else
{
if (
(obj.Stage != RotStage.Dessicated) ||
(obj.PropsRot().dessicatedDamagePerDay <= 0.0f) ||
(!obj.ShouldTakeDessicateDamage())
)
{
return;
}
obj.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, GenMath.RoundRandom(obj.PropsRot().dessicatedDamagePerDay), (Thing)null, new BodyPartDamageInfo?(), (ThingDef)null));
}
}
}
private void Tick(int interval)
{
if (!this.Active)
{
return;
}
float rotProgress = this.RotProgress;
float num = GenTemperature.RotRateAtTemperature(this.parent.AmbientTemperature);
this.RotProgress += num * (float)interval;
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDestroys)
{
if (this.parent.Map != null)
{
int stackCount = this.parent.stackCount;
ThingDef newThingDef = ThingDef.Named("VCE_RawPrunes");
Thing newThing = GenSpawn.Spawn(newThingDef, this.parent.Position, this.parent.Map, WipeMode.Vanish);
newThing.stackCount = stackCount;
this.parent.Destroy(DestroyMode.Vanish);
}
else
{
this.parent.Destroy(DestroyMode.Vanish);
}
return;
}
if (Mathf.FloorToInt(rotProgress / 60000f) != Mathf.FloorToInt(this.RotProgress / 60000f) && this.ShouldTakeRotDamage())
{
if (this.Stage == RotStage.Rotting && this.PropsRot.rotDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.rotDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null));
return;
}
if (this.Stage == RotStage.Dessicated && this.PropsRot.dessicatedDamagePerDay > 0f)
{
this.parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting, (float)GenMath.RoundRandom(this.PropsRot.dessicatedDamagePerDay), 0f, -1f, null, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null));
}
}
}
public int TicksUntilRotAtTemp(float temp)
{
if (!this.Active)
{
return(72000000);
}
float num = GenTemperature.RotRateAtTemperature(temp);
if (num <= 0f)
{
return(72000000);
}
float num2 = (float)this.PropsRot.TicksToRotStart - this.RotProgress;
if (num2 <= 0f)
{
return(0);
}
return(Mathf.RoundToInt(num2 / num));
}
internal static string _CompInspectStringExtra(this CompRottable obj)
{
var stringBuilder = new StringBuilder();
switch (obj.Stage)
{
case RotStage.Fresh:
stringBuilder.AppendLine("RotStateFresh".Translate());
break;
case RotStage.Rotting:
stringBuilder.AppendLine("RotStateRotting".Translate());
break;
case RotStage.Dessicated:
stringBuilder.AppendLine("RotStateDessicated".Translate());
break;
}
if (obj.InRefrigerator())
{
stringBuilder.AppendLine("RefrigeratedStorage".Translate());
}
else if ((obj.PropsRot().TicksToRotStart - obj.rotProgress) > 0.0f)
{
float num = GenTemperature.RotRateAtTemperature(Mathf.RoundToInt(GenTemperature.GetTemperatureForCell(obj.parent.Position)));
int rotAtCurrentTemp = obj.TicksUntilRotAtCurrentTemp;
if (num < 1.0f / 1000.0f)
{
stringBuilder.AppendLine("CurrentlyFrozen".Translate());
}
else if (num < 0.999000012874603f)
{
stringBuilder.AppendLine("CurrentlyRefrigerated".Translate(rotAtCurrentTemp.TickstoDaysString()));
}
else
{
stringBuilder.AppendLine("NotRefrigerated".Translate(rotAtCurrentTemp.TickstoDaysString()));
}
}
return(stringBuilder.ToString());
}
public int TicksUntilRotAtTemp(float temp)
{
if (!Active)
{
return(GenDate.TicksPerYear * 20);
}
float rotRate = GenTemperature.RotRateAtTemperature(temp);
if (rotRate <= 0)
{
return(GenDate.TicksPerYear * 20); //Will never rot. Just return a huge value. Hacky
}
float progressUntilStartRot = PropsRot.TicksToRotStart - RotProgress;
if (progressUntilStartRot <= 0)
{
return(0); //Already rotten
}
return(Mathf.RoundToInt(progressUntilStartRot / rotRate));
}
public override string CompInspectStringExtra()
{
//The other changes are made here, to display custom strings regarding how well the item is "rotting" into the new one. No default, so they NEED
//to be defined via XML
if (!this.Active)
{
return(null);
}
StringBuilder stringBuilder = new StringBuilder();
switch (this.Stage)
{
case RotStage.Fresh:
stringBuilder.Append(PropsRot.maturingString.Translate() + ".");
break;
}
if ((float)this.PropsRot.TicksToRotStart - this.RotProgress > 0f)
{
float num = GenTemperature.RotRateAtTemperature((float)Mathf.RoundToInt(this.parent.AmbientTemperature));
int ticksUntilRotAtCurrentTemp = this.TicksUntilRotAtCurrentTemp;
stringBuilder.AppendLine();
if (num < 0.001f)
{
stringBuilder.Append(PropsRot.maturingStopped.Translate() + ".");
}
else if (num < 0.999f)
{
stringBuilder.Append(PropsRot.maturingSlowly.Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod(true, false, true, true)) + ".");
}
else
{
stringBuilder.Append(PropsRot.maturingProperly.Translate(ticksUntilRotAtCurrentTemp.ToStringTicksToPeriod(true, false, true, true)) + ".");
}
}
return(stringBuilder.ToString());
}
private static bool HopperTick(int interval, CompRottable __instance)
{
IEnumerable <Thing> things = GetCompRottableThings(__instance);
if (!(things is null) && things.OfType <NPDHopper_Storage>().Any())
{
Thing t = things.OfType <NPDHopper_Storage>().First();
foreach (Thing thing in things)
{
NPDHopper_Storage hopper = thing as NPDHopper_Storage;
if (!(hopper is null))
{
float rotProgress = __instance.RotProgress;
float hopperTemp = t.TryGetComp <CompPowerTrader>().PowerOn ? hopper.def.GetModExtension <HopperCustom>().setTemperature : __instance.parent.AmbientTemperature;
float num = GenTemperature.RotRateAtTemperature(hopperTemp);
__instance.RotProgress += num * (float)interval;
if (__instance.Stage == RotStage.Rotting && __instance.PropsRot.rotDestroys)
{
if (__instance.parent.IsInAnyStorage() && __instance.parent.SpawnedOrAnyParentSpawned)
{
Messages.Message("MessageRottedAwayInStorage".Translate(__instance.parent.Label, __instance.parent).CapitalizeFirst(),
new TargetInfo(__instance.parent.PositionHeld, __instance.parent.MapHeld, false), MessageTypeDefOf.NegativeEvent, true);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers, OpportunityType.GoodToKnow);
}
__instance.parent.Destroy(DestroyMode.Vanish);
return(false);
}
bool flag = Mathf.FloorToInt(rotProgress / 60000f) != Mathf.FloorToInt(__instance.RotProgress / 60000f);
//Should Take Rot Damage?
return(false);
}
}
}
return(true);
}
public override void CompTickRare()
{
if (parent.MapHeld == null || parent.Map == null)
{
return;
}
var list = new HashSet <Thing>(parent.MapHeld.thingGrid.ThingsListAtFast(parent.PositionHeld));
var isMeat = parent?.def.IsMeat ?? false;
var isSalted = parent?.def?.defName?.ToLowerInvariant().Contains("salted") ?? false;
var saltPot =
list.FirstOrDefault(x => x is Building_RottableFixer && x.def.defName == "LotR_SaltBarrel");
if (isMeat && !isSalted && saltPot != null)
{
HandleMeatThatNeedsSalting(parent);
return;
}
var rotProgress = RotProgress;
var num = 1f;
var temperatureForCell = GenTemperature.GetTemperatureForCell(parent.PositionHeld, parent.MapHeld);
var b = list.FirstOrDefault(x => x is Building_RottableFixer);
if (b != null)
{
if (!isMeat && b.def.defName == "LotR_PantryShelf")
{
num = 0.3f;
}
if (b.def.defName == "LotR_SaltBarrel")
{
num = 0.0666667f;
}
}
num *= GenTemperature.RotRateAtTemperature(temperatureForCell);
RotProgress += Mathf.Round(num * 250f);
if (Stage == RotStage.Rotting && PropsRot.rotDestroys)
{
if (parent.Position.GetSlotGroup(parent.Map) != null)
{
Messages.Message("MessageRottedAwayInStorage".Translate(parent.Label).CapitalizeFirst(),
MessageTypeDefOf.SilentInput);
LessonAutoActivator.TeachOpportunity(ConceptDefOf.SpoilageAndFreezers,
OpportunityType.GoodToKnow);
}
parent.Destroy();
return;
}
if (Mathf.FloorToInt(rotProgress / 60000f) == Mathf.FloorToInt(RotProgress / 60000f))
{
return;
}
if (Stage == RotStage.Rotting && PropsRot.rotDamagePerDay > 0f)
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
GenMath.RoundRandom(PropsRot.rotDamagePerDay)));
}
else if (Stage == RotStage.Dessicated && PropsRot.dessicatedDamagePerDay > 0f &&
ShouldTakeDessicateDamage())
{
parent.TakeDamage(new DamageInfo(DamageDefOf.Rotting,
GenMath.RoundRandom(PropsRot.dessicatedDamagePerDay)));
}
}
public override string CompInspectStringExtra()
{
StringBuilder sb = new StringBuilder();
switch (base.Stage)
{
case RotStage.Fresh:
sb.AppendLine("RotStateFresh".Translate());
break;
case RotStage.Rotting:
sb.AppendLine("RotStateRotting".Translate());
break;
case RotStage.Dessicated:
sb.AppendLine("RotStateDessicated".Translate());
break;
}
float num = (float)this.PropsRot.TicksToRotStart - base.RotProgress;
if (num > 0f)
{
float num2 = GenTemperature.GetTemperatureForCell(this.parent.PositionHeld, this.parent.Map);
List <Thing> thingList = GridsUtility.GetThingList(this.parent.PositionHeld, this.parent.Map);
var factor = 1f;
for (int i = 0; i < thingList.Count; i++)
{
if (thingList[i] is Building_RottableFixer)
{
var b = thingList[i] as Building_RottableFixer;
var isMeat = this?.parent?.def.IsMeat ?? false;
if (!isMeat && b.def.defName == "LotR_PantryShelf")
{
factor = 3f;
}
if (b.def.defName == "LotR_SaltBarrel")
{
factor = 15f;
}
//num2 = building_Refrigerator.CurrentTemp;
break;
}
}
num2 = (float)Mathf.RoundToInt(num2);
float num3 = GenTemperature.RotRateAtTemperature(num2);
int ticksUntilRotAtCurrentTemp = (int)(base.TicksUntilRotAtCurrentTemp * factor);
if (num3 < 0.001f)
{
sb.Append("CurrentlyFrozen".Translate() + ".");
}
else
{
if (num3 < 0.999f)
{
sb.Append("CurrentlyRefrigerated".Translate(new object[]
{
ticksUntilRotAtCurrentTemp.ToStringTicksToPeriodVague()
}) + ".");
}
else
{
sb.Append("NotRefrigerated".Translate(new object[]
{
ticksUntilRotAtCurrentTemp.ToStringTicksToPeriodVague()
}) + ".");
}
}
}
return(sb.ToString().TrimEndNewlines());
}
