Beispiel #1
0
        public static List <IncidentDef> AllDiseases(this BiomeDef biome)
        {
            var list      = new List <IncidentDef>();
            var incidents = DefDatabase <IncidentDef> .AllDefsListForReading;

            if (!incidents.NullOrEmpty())
            {
                foreach (var incident in incidents)
                {
                    var commonality = biome.CommonalityOfDisease(incident);
                    if (commonality > 0.0f)
                    {
                        list.Add(incident);
                    }
                }
            }
            return(list);
        }
        public static bool HealthTick(Pawn_HealthTracker __instance)
        {
            if (__instance.Dead)
            {
                return(false);
            }
            for (int index = __instance.hediffSet.hediffs.Count - 1; index >= 0; --index)
            {
                Hediff hediff = __instance.hediffSet.hediffs[index];
                try
                {
                    hediff.Tick();
                    hediff.PostTick();
                }
                catch (Exception ex1)
                {
                    Log.Error("Exception ticking hediff " + hediff.ToStringSafe <Hediff>() + " for pawn " + __instance.pawn.ToStringSafe <Pawn>() + ". Removing hediff... Exception: " + (object)ex1);
                    try
                    {
                        __instance.RemoveHediff(hediff);
                    }
                    catch (Exception ex2)
                    {
                        Log.Error("Error while removing hediff: " + (object)ex2);
                    }
                }
                if (__instance.Dead)
                {
                    return(false);
                }
            }
            bool flag1 = false;

            lock (__instance.hediffSet)                                                     //added
            {
                List <Hediff> newHediffs = new List <Hediff>(__instance.hediffSet.hediffs); //added
                for (int index = newHediffs.Count - 1; index >= 0; --index)                 //changed
                {
                    Hediff hediff = newHediffs[index];
                    if (hediff.ShouldRemove)
                    {
                        newHediffs.RemoveAt(index);                //changed
                        __instance.hediffSet.hediffs = newHediffs; //added
                        hediff.PostRemoved();
                        flag1 = true;
                    }
                }
            }
            if (flag1)
            {
                __instance.Notify_HediffChanged((Hediff)null);
            }
            if (__instance.Dead)
            {
                return(false);
            }
            __instance.immunity.ImmunityHandlerTick();
            if (__instance.pawn.RaceProps.IsFlesh && __instance.pawn.IsHashIntervalTick(600) && (__instance.pawn.needs.food == null || !__instance.pawn.needs.food.Starving))
            {
                bool flag2 = false;
                if (__instance.hediffSet.HasNaturallyHealingInjury())
                {
                    float num = 8f;
                    if (__instance.pawn.GetPosture() != PawnPosture.Standing)
                    {
                        num += 4f;
                        Building_Bed buildingBed = __instance.pawn.CurrentBed();
                        if (buildingBed != null)
                        {
                            num += buildingBed.def.building.bed_healPerDay;
                        }
                    }
                    foreach (Hediff hediff in __instance.hediffSet.hediffs)
                    {
                        HediffStage curStage = hediff.CurStage;
                        if (curStage != null && (double)curStage.naturalHealingFactor != -1.0)
                        {
                            num *= curStage.naturalHealingFactor;
                        }
                    }
                    __instance.hediffSet.GetHediffs <Hediff_Injury>().Where <Hediff_Injury>((Func <Hediff_Injury, bool>)(x => x.CanHealNaturally())).RandomElement <Hediff_Injury>().Heal((float)((double)num * (double)__instance.pawn.HealthScale * 0.00999999977648258) * __instance.pawn.GetStatValue(StatDefOf.InjuryHealingFactor));
                    flag2 = true;
                }
                if (__instance.hediffSet.HasTendedAndHealingInjury() && (__instance.pawn.needs.food == null || !__instance.pawn.needs.food.Starving))
                {
                    Hediff_Injury hd = __instance.hediffSet.GetHediffs <Hediff_Injury>().Where <Hediff_Injury>((Func <Hediff_Injury, bool>)(x => x.CanHealFromTending())).RandomElement <Hediff_Injury>();
                    hd.Heal((float)(8.0 * (double)GenMath.LerpDouble(0.0f, 1f, 0.5f, 1.5f, Mathf.Clamp01(hd.TryGetComp <HediffComp_TendDuration>().tendQuality)) * (double)__instance.pawn.HealthScale * 0.00999999977648258) * __instance.pawn.GetStatValue(StatDefOf.InjuryHealingFactor));
                    flag2 = true;
                }
                if (flag2 && !__instance.HasHediffsNeedingTendByPlayer() && (!HealthAIUtility.ShouldSeekMedicalRest(__instance.pawn) && !__instance.hediffSet.HasTendedAndHealingInjury()) && PawnUtility.ShouldSendNotificationAbout(__instance.pawn))
                {
                    Messages.Message((string)"MessageFullyHealed".Translate((NamedArgument)__instance.pawn.LabelCap, (NamedArgument)(Thing)__instance.pawn), (LookTargets)(Thing)__instance.pawn, MessageTypeDefOf.PositiveEvent);
                }
            }
            if (__instance.pawn.RaceProps.IsFlesh && (double)__instance.hediffSet.BleedRateTotal >= 0.100000001490116)
            {
                float num = __instance.hediffSet.BleedRateTotal * __instance.pawn.BodySize;
                if ((double)Rand.Value < (__instance.pawn.GetPosture() != PawnPosture.Standing ? (double)(num * 0.0004f) : (double)(num * 0.004f)))
                {
                    __instance.DropBloodFilth();
                }
            }
            if (!__instance.pawn.IsHashIntervalTick(60))
            {
                return(false);
            }
            List <HediffGiverSetDef> hediffGiverSets = __instance.pawn.RaceProps.hediffGiverSets;

            if (hediffGiverSets != null)
            {
                for (int index1 = 0; index1 < hediffGiverSets.Count; ++index1)
                {
                    List <HediffGiver> hediffGivers = hediffGiverSets[index1].hediffGivers;
                    for (int index2 = 0; index2 < hediffGivers.Count; ++index2)
                    {
                        hediffGivers[index2].OnIntervalPassed(__instance.pawn, (Hediff)null);
                        if (__instance.pawn.Dead)
                        {
                            return(false);
                        }
                    }
                }
            }
            if (__instance.pawn.story == null)
            {
                return(false);
            }
            List <Trait> allTraits = __instance.pawn.story.traits.allTraits;

            for (int index = 0; index < allTraits.Count; ++index)
            {
                TraitDegreeData currentData = allTraits[index].CurrentData;
                if ((double)currentData.randomDiseaseMtbDays > 0.0 && Rand.MTBEventOccurs(currentData.randomDiseaseMtbDays, 60000f, 60f))
                {
                    BiomeDef biome = __instance.pawn.Tile == -1 ? DefDatabase <BiomeDef> .GetRandom() : Find.WorldGrid[__instance.pawn.Tile].biome;

                    IncidentDef incidentDef = DefDatabase <IncidentDef> .AllDefs.Where <IncidentDef>((Func <IncidentDef, bool>)(d => d.category == IncidentCategoryDefOf.DiseaseHuman)).RandomElementByWeightWithFallback <IncidentDef>((Func <IncidentDef, float>)(d => biome.CommonalityOfDisease(d)));

                    if (incidentDef != null)
                    {
                        string      blockedInfo;
                        List <Pawn> pawns = ((IncidentWorker_Disease)incidentDef.Worker).ApplyToPawns(Gen.YieldSingle <Pawn>(__instance.pawn), out blockedInfo);
                        if (PawnUtility.ShouldSendNotificationAbout(__instance.pawn))
                        {
                            if (pawns.Contains(__instance.pawn))
                            {
                                Find.LetterStack.ReceiveLetter("LetterLabelTraitDisease".Translate((NamedArgument)incidentDef.diseaseIncident.label), "LetterTraitDisease".Translate((NamedArgument)__instance.pawn.LabelCap, (NamedArgument)incidentDef.diseaseIncident.label, __instance.pawn.Named("PAWN")).AdjustedFor(__instance.pawn), LetterDefOf.NegativeEvent, (LookTargets)(Thing)__instance.pawn);
                            }
                            else if (!blockedInfo.NullOrEmpty())
                            {
                                Messages.Message(blockedInfo, (LookTargets)(Thing)__instance.pawn, MessageTypeDefOf.NeutralEvent);
                            }
                        }
                    }
                }
            }
            return(false);
        }