public override void CompPostTick(ref float severityAdjustment)
{
if (Pawn.NegligeablePawn())
{
return;
}
if (HasPendingTreatment)
{
if (currentHediff == null)
{
currentHT = this.InitHealingTask(out currentHediff, out HealingTickCounter);
return;
}
if (HealingTickCounter-- <= 0)
{
this.Dispatcher();
}
}
else
{
if (CheckingTickCounter-- <= 0)
{
NextHediff();
InitCheckCounter();
}
}
}
public void NextHediff()
{
Hediff oldHediff = currentHediff;
currentHT = this.InitHealingTask(out currentHediff, out HealingTickCounter);
this.ApplyProgressHediff(oldHediff);
}
public static bool RequiresCompleteHediff(this HediffComp_Regeneration comp, out HediffDef hediffToApply)
{
MyDefs.HealingTask curHT = comp.currentHT;
HealingParams HP = comp.GetParams();
hediffToApply = null;
if (HP == null || HP.HediffToApplyWhenComplete == null)
{
return(false);
}
hediffToApply = HP.HediffToApplyWhenComplete;
return(true);
}
public static bool RequiresProgressHediffRemoval(this HediffComp_Regeneration comp, out HediffDef hediffToRemove)
{
MyDefs.HealingTask curHT = comp.currentHT;
HealingParams HP = comp.GetParams();
hediffToRemove = null;
if (HP == null || HP.HediffToApplyDuringProgress == null)
{
return(false);
}
hediffToRemove = HP.HediffToApplyDuringProgress;
return(HP.RemoveHediffWhenProgressOver);
}
public static string GetTreatmentLabel(this HediffComp_Regeneration comp)
{
//Tools.Warn(comp.Pawn.LabelShort + " - Entering GetTreatmentLabel - cutHT=" + comp.currentHT.DescriptionAttr(), comp.MyDebug);
MyDefs.HealingTask curHT = comp.currentHT;
HealingParams HP = comp.GetParams();
if (HP == null || HP.TreatmentLabel.NullOrEmpty())
{
return(curHT.DescriptionAttr());
}
return(HP.TreatmentLabel);
}
public static int ResetHealingTicks(this HediffComp_Regeneration comp)
{
Tools.Warn(comp.Pawn.LabelShort + " - Entering ResetHealingTicks - cutHT=" + comp.currentHT.DescriptionAttr(), comp.MyDebug);
MyDefs.HealingTask curHT = comp.currentHT;
HealingParams HP = comp.GetParams();
if (HP == null)
{
Tools.Warn(comp.Pawn.LabelShort + " - ResetHealingTicks - Found not params for task=" + curHT.DescriptionAttr(), comp.MyDebug);
return(600);
}
return(HP.PeriodBase.RandomInRange);
}
public static MyDefs.HealingTask InitHealingTask(this HediffComp_Regeneration comp, out Hediff hediffToTreat, out int InitTicks)
{
//Tools.Warn(comp.Pawn.LabelShort + " - Entering InitHealingTask", comp.MyDebug);
//for (int i = 0; i < comp.regenerationPriority.DefaultPriority.Count; i++)
for (int i = 0; i < MyDefs.DefaultPriority.Count; i++)
{
//MyDefs.HealingTask curHealingTask = comp.regenerationPriority.DefaultPriority[i];
MyDefs.HealingTask curHealingTask = MyDefs.DefaultPriority[i];
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask task[" + i + "]: " + curHealingTask.DescriptionAttr(), comp.MyDebug);
// 00 bloodloss tending
if (comp.Effect_TendBleeding && curHealingTask.IsBloodLossTending())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_TendBleeding", comp.MyDebug);
if (comp.GetBleedingHediff(out hediffToTreat))
{
InitTicks = comp.Props.BloodLossTendingParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
// 01 chronic disease tending
else if (comp.Effect_TendChronicDisease && curHealingTask.IsChronicDiseaseTending())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_TendChronicDisease", comp.MyDebug);
if (comp.Pawn.GetTendableChronicDisease(out hediffToTreat))
{
InitTicks = comp.Props.ChronicHediffTendingParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
// 02 regular disease tending
else if (comp.Effect_TendRegularDisease && curHealingTask.IsRegularDiseaseTending())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_TendRegularDisease", comp.MyDebug);
if (comp.HasTendRegularDiseaseTargets)
{
if (comp.Pawn.GetTendableRegularDisease(out hediffToTreat, comp.Props.RegularDiseaseTendingParams.TargetedHediffDefs, comp.MyDebug))
{
InitTicks = comp.Props.RegularDiseaseTendingParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
else if (comp.Pawn.GetTendableRegularDisease(out hediffToTreat, null, comp.MyDebug))
{
InitTicks = comp.Props.RegularDiseaseTendingParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
// 03 regular injury
else if (comp.Effect_RegeneratePhysicalInjuries && curHealingTask.IsInjuryRegeneration())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_RegeneratePhysicalInjuries", comp.MyDebug);
if (comp.GetPhysicalHediff(out hediffToTreat))
{
InitTicks = comp.Props.PhysicalInjuryRegenParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
// 04 regular disease
else if (comp.Effect_HealDiseases && curHealingTask.IsDiseaseHealing())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_HealDiseases", comp.MyDebug);
if (comp.GetDiseaseHediff(out hediffToTreat))
{
InitTicks = comp.Props.DiseaseHediffRegenParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
// 05 chemicals
else if (comp.Effect_RemoveChemicals && curHealingTask.IsChemicalRemoval())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_RemoveChemicals", comp.MyDebug);
if (comp.GetChemicalHediff(out hediffToTreat))
{
InitTicks = comp.Props.ChemicalHediffRegenParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
// 06 permanent
else if (comp.Effect_RemoveScares && curHealingTask.IsPermanentInjuryRegeneration())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_RemoveScares", comp.MyDebug);
if (comp.Pawn.GetPermanentHediff(out hediffToTreat))
{
InitTicks = comp.Props.PermanentInjuryRegenParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
// 07 Bodypart regen
else if (comp.Effect_RegenerateBodyParts && curHealingTask.IsBodyPartRegeneration())
{
//Tools.Warn(comp.Pawn.LabelShort + " InitHealingTask Effect_RegenerateBodyParts", comp.MyDebug);
if (comp.Pawn.GetMissingBodyPart(out hediffToTreat))
{
InitTicks = comp.Props.BodyPartRegenParams.PeriodBase.RandomInRange;
return(curHealingTask);
}
}
}
//Tools.Warn(comp.Pawn.LabelShort + " - Exiting InitHealingTask: found nothing to do", comp.MyDebug);
InitTicks = 0;
hediffToTreat = null;
return(MyDefs.HealingTask.None);
}
public static void Dispatcher(this HediffComp_Regeneration comp)
{
MyDefs.HealingTask curHT = comp.currentHT;
HealingParams HP = comp.GetParams();
Pawn p = comp.Pawn;
bool MyDebug = comp.MyDebug;
bool DidIt = false;
bool DoneWithIt = false;
bool Impossible = false;
bool NextHediffIfDidIt = false;
bool NextHediffIfDoneWithIt = false;
bool ResetHealingTick = true;
FleckDef MyFleckDef = HP.FleckDef ?? null;
// 00 Tending - Blood loss
if (curHT.IsBloodLossTending())
{
NextHediffIfDidIt = true;
DidIt = comp.TryTendBleeding(out Impossible);
}
// 01 Tending - Chronic disease
else if (curHT.IsChronicDiseaseTending())
{
NextHediffIfDidIt = true;
DidIt = comp.TryTendChronic(out Impossible);
}
// 02 Tending - Regular disease
else if (curHT.IsRegularDiseaseTending())
{
NextHediffIfDidIt = true;
DidIt = comp.TryTendRegularDisease(out Impossible);
}
// 03 Regeneration - Injury
else if (curHT.IsDiseaseHealing())
{
NextHediffIfDoneWithIt = true;
DidIt = comp.TryCureDisease(out DoneWithIt, out Impossible);
}
// 04 Regeneration - Injury
else if (curHT.IsInjuryRegeneration())
{
NextHediffIfDoneWithIt = true;
DidIt = comp.TryRegenInjury(out DoneWithIt, out Impossible);
}
// 05 Regeneration - Chemical
else if (curHT.IsChemicalRemoval())
{
NextHediffIfDoneWithIt = true;
DidIt = comp.TryChemicalRemoval(out DoneWithIt, out Impossible);
}
// 06 Regeneration - Permanent injury
else if (curHT.IsPermanentInjuryRegeneration())
{
NextHediffIfDoneWithIt = true;
DidIt = comp.TryRemovePermanentInjury(out DoneWithIt, out Impossible);
}
// 07 Regeneration -Bodypart
else if (curHT.IsBodyPartRegeneration())
{
NextHediffIfDidIt = true;
bool AppliedProsthetic = false;
if (comp.Effect_GrowProsthetic)
{
HediffDef ProstheticHediff = comp.TryFindBodyPartProsthetic();
if (ProstheticHediff != null)
{
DidIt = AppliedProsthetic = comp.TryRegrowProsthetic(ProstheticHediff);
}
}
if (!AppliedProsthetic)
{
if (comp.Effect_RegenBodyPartChildrenAtOnce)
{
//DidIt = this.TryBodyPartFullRegeneration(out Impossible);
DidIt = comp.TryBodyPartRegeneration(out Impossible);
ResetHealingTick = false;
}
else
{
DidIt = comp.TryBodyPartRegeneration(out Impossible);
}
}
}
if (DidIt)
{
Tools.Warn(p.LabelShort + " had " + curHT.DescriptionAttr() + " performed", MyDebug);
}
if (DoneWithIt)
{
Tools.Warn(p.LabelShort + " had " + curHT.DescriptionAttr() + " fully cured/healed/regen", MyDebug);
}
if (NextHediffIfDidIt && DidIt || NextHediffIfDoneWithIt && DoneWithIt)
{
if (MyFleckDef != null)
{
FleckMaker.ThrowMetaIcon(p.Position, p.Map, MyFleckDef);
}
//MoteMaker.ThrowMetaIcon(p.Position, p.Map, MyMoteDef);
comp.RemoveProgressHediff();
comp.ApplyCompleteHediff();
if (ResetHealingTick)
{
comp.NextHediff();
}
else
{
comp.NextHediffWithoutTickReset();
}
Tools.Warn(p.LabelShort +
" ResetHealingTick:" + ResetHealingTick + "; HealingTicks:" + comp.HealingTickCounter +
"; new HT: " + curHT.DescriptionAttr() +
"; BP:" + comp.currentHediff?.Part?.def?.defName, MyDebug);
}
else if (Impossible)
{
comp.NextHediff();
Tools.Warn(p.LabelShort + " Impossible to heal hediff found - new HT: " + curHT.DescriptionAttr(), MyDebug);
}
if (comp.HasNoPendingTreatment)
{
Tools.Warn(
p.LabelShort +
"no pending treatment, InitCheckCounter", MyDebug);
comp.InitCheckCounter();
}
}
public void NextHediffWithoutTickReset()
{
currentHT = this.InitHealingTask(out currentHediff, out _);
HealingTickCounter = 5;
}
