public void CompPostTock()
 {
     lastTockTick = Find.TickManager.TicksGame;
     if (MarkedhediffDef == null)
     {
         MarkedhediffDef = this.Def;
         corpse          = null;
         pawn            = null;
         pawnKindDef     = YautjaBloodedUtility.RandomMarked(MarkedhediffDef);
         //    Log.Message(string.Format("{0}: {1}", MarkedhediffDef, pawnKindDef));
         MarkHedifftype  = null;
         MarkHedifflabel = pawnKindDef.LabelCap;
         predator        = pawnKindDef.RaceProps.predator;
         combatPower     = pawnKindDef.combatPower;
         BodySize        = pawnKindDef.race.race.baseBodySize;
         Comp_Yautja _Yautja = this.Pawn.TryGetComp <Comp_Yautja>();
         if (_Yautja != null)
         {
             _Yautja.MarkHedifflabel = MarkHedifflabel;
             _Yautja.pawn            = pawn;
             _Yautja.corpse          = corpse;
             _Yautja.MarkedhediffDef = MarkedhediffDef;
             _Yautja.MarkHedifflabel = MarkHedifflabel;
             _Yautja.predator        = predator;
             _Yautja.BodySize        = BodySize;
             _Yautja.combatPower     = combatPower;
         }
     }
 }
        public override bool CanBeUsedBy(Pawn p, out string failReason)
        {
            bool selected = Find.Selector.SelectedObjects.Contains(p);

            if (p.health.hediffSet.HasHediff(YautjaDefOf.RRY_Hediff_BloodedUM))
            {
                Hediff                   blooded = p.health.hediffSet.GetFirstHediffOfDef(YautjaDefOf.RRY_Hediff_BloodedUM);
                Comp_Yautja              _Yautja = p.TryGetComp <Comp_Yautja>();
                HediffWithComps          hediff  = (HediffWithComps)blooded;
                HediffComp_BloodedYautja comp    = blooded.TryGetComp <HediffComp_BloodedYautja>();

                /*
                 * if (selected) Log.Message(string.Format("{0}", _Yautja.corpse));
                 * if (selected) Log.Message(string.Format("{0}", _Yautja.pawn.Corpse));
                 * if (selected) Log.Message(string.Format("{0}", _Yautja.pawn));
                 * if (selected) Log.Message(string.Format("{0}", _Yautja.MarkedhediffDef));
                 */
                ThingDef def = _Yautja.pawn.Corpse.InnerPawn.kindDef.race;
                if (this.parent is Corpse corpse)
                {
                    this.corpse = corpse;

                    /*
                     * Log.Message(string.Format("this.parent is Corpse corpse"));
                     * Log.Message(string.Format("corpse.InnerPawn.kindDef.race: {0}, def: {1}", corpse.InnerPawn.kindDef.race, def));
                     */
                    if (corpse.InnerPawn.kindDef.race == def)
                    {
                        failReason = null;
                        return(true);
                    }
                    else
                    {
                        failReason = "Wrong race";
                        return(false);
                    }
                }
                else
                {
                    failReason = "not a corpse";
                    return(false);
                }

                /*
                 * if (YautjaBloodedUtility.bloodmatch(marked, (Corpse)this.parent))
                 * {
                 *  failReason = null;
                 *  return true;
                 * }
                 */
            }
            else
            {
                failReason = "Doesnt need marking";
                return(false);
            }
        }
Exemple #3
0
        // Token: 0x06002ADC RID: 10972 RVA: 0x001433C0 File Offset: 0x001417C0
        public override void DoEffect(Pawn user)
        {
            bool selected = Find.Selector.SelectedObjects.Contains(user);
            //    base.DoEffect(user);
            Hediff         hediff;
            Comp_Yautja    _Yautja = user.TryGetComp <Comp_Yautja>();
            Hediff         blooded = user.health.hediffSet.GetFirstHediffOfDef(YautjaDefOf.RRY_Hediff_BloodedUM);
            BodyPartRecord part    = user.health.hediffSet.GetFirstHediffOfDef(YautjaDefOf.RRY_Hediff_BloodedUM).Part;
            HediffDef      marked  = _Yautja.MarkedhediffDef;

            if (YautjaBloodedUtility.Marked(user, out hediff))
            {
                user.health.RemoveHediff(hediff);
            }
            user.health.RemoveHediff(blooded);
            user.health.AddHediff(marked, part);
            ThingDef thingDef = null;

            foreach (var item in corpse.InnerPawn.health.hediffSet.GetNotMissingParts())
            {
                if (Rand.Chance(corpse.InnerPawn.health.hediffSet.GetPartHealth(item) / 3) && item.def == XenomorphDefOf.RRY_Xeno_TailSpike && !corpse.InnerPawn.health.hediffSet.PartIsMissing(item))
                {
                    partRecord = item;
                    thingDef   = XenomorphDefOf.RRY_Xenomorph_TailSpike;
                    corpse.InnerPawn.health.AddHediff(HediffMaker.MakeHediff(HediffDefOf.MissingBodyPart, corpse.InnerPawn, this.partRecord));
                    GenSpawn.Spawn(ThingMaker.MakeThing(thingDef), user.Position, user.Map);
                }
                if (Rand.Chance(corpse.InnerPawn.health.hediffSet.GetPartHealth(item) / 3) && item.def == XenomorphDefOf.RRY_Xeno_Shell && !corpse.InnerPawn.health.hediffSet.PartIsMissing(item))
                {
                    partRecord = item;
                    thingDef   = XenomorphDefOf.RRY_Xenomorph_HeadShell;
                    corpse.InnerPawn.health.AddHediff(HediffMaker.MakeHediff(HediffDefOf.MissingBodyPart, corpse.InnerPawn, this.partRecord));
                    GenSpawn.Spawn(ThingMaker.MakeThing(thingDef), user.Position, user.Map);
                }
            }
            if (user.story.adulthood.identifier == null || user.story.adulthood.identifier == "Yautja_YoungBlood")
            {
                AlienRace.BackstoryDef backstoryDef = DefDatabase <AlienRace.BackstoryDef> .GetNamed("Yautja_Blooded");

#if DEBUG
                if (selected)
                {
                    Log.Message(string.Format("changing {0}", user.story.adulthood.identifier));
                }
#endif

                user.story.adulthood = backstoryDef.backstory;
#if DEBUG
                if (selected)
                {
                    Log.Message(string.Format("to {0}", user.story.adulthood.identifier));
                }
#endif
            }
        }
        // Token: 0x06000393 RID: 915 RVA: 0x000245C8 File Offset: 0x000229C8
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnIncapable(PawnCapacityDefOf.Manipulation);
            yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));

            Toil prepare = Toils_General.Wait(this.useDuration, TargetIndex.A);

            prepare.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f);
            prepare.FailOnDespawnedNullOrForbidden(TargetIndex.A);
            prepare.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
            yield return(prepare);

            Toil use = new Toil();

            use.initAction = delegate()
            {
                Pawn        actor    = use.actor;
                Pawn        inductee = (Pawn)TargetB.Thing;
                Comp_Yautja _Yautja  = inductee.TryGetComp <Comp_Yautja>();
                _Yautja.inducted = true;
            };
            use.defaultCompleteMode = ToilCompleteMode.Instant;
            yield return(use);

            yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch));

            Toil prepare2 = Toils_General.Wait(this.useDuration, TargetIndex.B);

            prepare2.WithProgressBarToilDelay(TargetIndex.B, false, -0.5f);
            prepare2.FailOnDespawnedNullOrForbidden(TargetIndex.B);
            prepare2.FailOnCannotTouch(TargetIndex.B, PathEndMode.Touch);
            yield return(prepare2);

            Toil use2 = new Toil();

            use2.initAction = delegate()
            {
                Pawn actor    = use2.actor;
                Pawn inductee = (Pawn)TargetB.Thing;
                CompUseEffect_MarkSelf compUsable = actor.CurJob.targetA.Thing.TryGetComp <CompUseEffect_MarkSelf>();
                compUsable.DoEffect(inductee);
            };
            use2.defaultCompleteMode = ToilCompleteMode.Delay;
            yield return(use2);

            yield break;
        }
        public override void DoEffect(Pawn user)
        {
            bool selected = Find.Selector.SelectedObjects.Contains(user);
            //    base.DoEffect(user);
            Comp_Yautja    _Yautja   = user.TryGetComp <Comp_Yautja>();
            Hediff         blooded   = user.health.hediffSet.GetFirstHediffOfDef(YautjaDefOf.RRY_Hediff_BloodedUM);
            BodyPartRecord part      = user.health.hediffSet.GetFirstHediffOfDef(YautjaDefOf.RRY_Hediff_BloodedUM).Part;
            HediffDef      markedDef = _Yautja.MarkedhediffDef;

            if (YautjaBloodedUtility.Marked(user, out Hediff hediff))
            {
                user.health.RemoveHediff(hediff);
            }
            user.health.RemoveHediff(blooded);
            Hediff marked = HediffMaker.MakeHediff(markedDef, user, part);// user.health.hediffSet.GetFirstHediffOfDef(markedDef);
            HediffComp_MarkedYautja marked_Yautja = marked.TryGetComp <HediffComp_MarkedYautja>();

            corpse = (Corpse)this.parent;
            marked_Yautja.BodySize        = corpse.InnerPawn.BodySize;
            marked_Yautja.combatPower     = corpse.InnerPawn.kindDef.combatPower;
            marked_Yautja.corpse          = corpse;
            marked_Yautja.MarkHedifflabel = corpse.InnerPawn.KindLabel;
            marked_Yautja.pawn            = corpse.InnerPawn;
            marked_Yautja.pawnKindDef     = corpse.InnerPawn.kindDef;
            marked_Yautja.predator        = corpse.InnerPawn.kindDef.RaceProps.predator;
            marked_Yautja.props           = new HediffCompProperties_MarkedYautja
            {
                pawn            = corpse.InnerPawn,
                corpse          = corpse,
                MarkedhediffDef = markedDef,
                MarkHedifflabel = corpse.InnerPawn.KindLabel,
                predator        = corpse.InnerPawn.kindDef.RaceProps.predator,
                BodySize        = corpse.InnerPawn.BodySize,
                combatPower     = corpse.InnerPawn.kindDef.combatPower
            };
            Log.Message(string.Format(" 11 "));
            user.health.AddHediff(markedDef, part);
            Log.Message(string.Format(" 12 "));
            ThingDef thingDef = null;

            Log.Message(string.Format(" 13 "));
            foreach (var item in corpse.InnerPawn.health.hediffSet.GetNotMissingParts())
            {
                if (Rand.Chance(corpse.InnerPawn.health.hediffSet.GetPartHealth(item) / 3) && item.def == XenomorphDefOf.RRY_Xeno_TailSpike && !corpse.InnerPawn.health.hediffSet.PartIsMissing(item))
                {
                    partRecord = item;
                    thingDef   = XenomorphDefOf.RRY_Xenomorph_TailSpike;
                    corpse.InnerPawn.health.AddHediff(HediffMaker.MakeHediff(HediffDefOf.MissingBodyPart, corpse.InnerPawn, this.partRecord));
                    GenSpawn.Spawn(ThingMaker.MakeThing(thingDef), user.Position, user.Map);
                }
                if (Rand.Chance(corpse.InnerPawn.health.hediffSet.GetPartHealth(item) / 3) && item.def == XenomorphDefOf.RRY_Xeno_Shell && !corpse.InnerPawn.health.hediffSet.PartIsMissing(item))
                {
                    partRecord = item;
                    thingDef   = XenomorphDefOf.RRY_Xenomorph_HeadShell;
                    corpse.InnerPawn.health.AddHediff(HediffMaker.MakeHediff(HediffDefOf.MissingBodyPart, corpse.InnerPawn, this.partRecord));
                    GenSpawn.Spawn(ThingMaker.MakeThing(thingDef), user.Position, user.Map);
                }
            }
            if (user.story.adulthood.identifier == null || user.story.adulthood.identifier == "RRY_Yautja_YoungBlood")
            {
                if (marked.def == YautjaDefOf.RRY_Hediff_BloodedMXenomorph)
                {
                    AlienRace.BackstoryDef backstoryDef = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_Blooded");

#if DEBUG
                    //    if (selected) Log.Message(string.Format("changing {0}", user.story.adulthood.identifier));
#endif

                    user.story.adulthood = backstoryDef.backstory;
#if DEBUG
                    //    if (selected) Log.Message(string.Format("to {0}", user.story.adulthood.identifier));
#endif
                }
            }
        }
        public static bool BloodStatus(Pawn pawn, out Hediff BloodHD)
        {
            HediffSet      hediffSet = pawn.health.hediffSet;
            BodyPartRecord part      = pawn.RaceProps.body.AllParts.Find(x => x.def == BodyPartDefOf.Head);
            HediffDef      hediffDef;
            bool           result = false;

            BloodHD = null;
            bool hasbloodedM = hediffSet.hediffs.Any <Hediff>(x => x.def.defName.StartsWith(markedDef.defName));

            if (hasbloodedM)
            {
                BloodHD = hediffSet.hediffs.Find(x => x.def.defName.Contains(markedDef.defName));
                //    Log.Message(string.Format("hasbloodedM: {0}", BloodHD));
                result = true;
            }
            bool hasunblooded = hediffSet.HasHediff(unbloodedDef);

            if (hasunblooded)
            {
                BloodHD = hediffSet.GetFirstHediffOfDef(unbloodedDef);
                if (!PlayerKnowledgeDatabase.IsComplete(YautjaConceptDefOf.RRY_Concept_Unblooded) && pawn.IsColonist && pawn.Spawned && (pawn.Map != null || pawn.MapHeld != null))
                {
                    LessonAutoActivator.TeachOpportunity(YautjaConceptDefOf.RRY_Concept_Unblooded, OpportunityType.Important);
                }
                //    Log.Message(string.Format("hasunblooded: {0}", BloodHD));
                result = false;
            }
            bool hasbloodedUM = hediffSet.HasHediff(unmarkedDef);

            if (hasbloodedUM)
            {
                BloodHD = hediffSet.GetFirstHediffOfDef(unmarkedDef);
                if (!PlayerKnowledgeDatabase.IsComplete(YautjaConceptDefOf.RRY_Concept_Blooding) && pawn.IsColonist && pawn.Spawned && (pawn.Map != null || pawn.MapHeld != null))
                {
                    LessonAutoActivator.TeachOpportunity(YautjaConceptDefOf.RRY_Concept_Blooding, OpportunityType.Important);
                }
                //    Log.Message(string.Format("hasbloodedUM: {0}", BloodHD));
                result = true;
            }
            if (BloodHD == null)
            {
                //    Log.Message(string.Format("1"));
                Backstory pawnStoryC = pawn.story.childhood;
                Backstory pawnStoryA = pawn.story.adulthood ?? null;

                if (pawn.kindDef.race == YautjaDefOf.RRY_Alien_Yautja && pawnStoryA != null)
                {
                    //    Log.Message(string.Format("2"));
                    if (pawnStoryA != bsDefUnblooded.backstory)
                    {
                        //    Log.Message(string.Format("3"));
                        Comp_Yautja _Yautja = pawn.TryGetComp <Comp_Yautja>();
                        hediffDef = _Yautja.Props.bloodedDefs.RandomElement();

                        if (hediffDef != null)
                        {
                            //    Log.Message(string.Format("4"));
                            PawnKindDef pawnKindDef = YautjaBloodedUtility.RandomMarked(hediffDef);
                            if (_Yautja != null)
                            {
                                //    Log.Message(string.Format("5"));
                                _Yautja.MarkHedifflabel = pawnKindDef.LabelCap;
                                _Yautja.MarkedhediffDef = hediffDef;
                                _Yautja.predator        = pawnKindDef.RaceProps.predator;
                                _Yautja.BodySize        = pawnKindDef.RaceProps.baseBodySize;
                                _Yautja.combatPower     = pawnKindDef.combatPower;
                            }
                        }
                    }
                    else
                    {
                        //    Log.Message(string.Format("6"));
                        hediffDef = unbloodedDef;
                    }
                }
                else
                {
                    //    Log.Message(string.Format("7"));
                    hediffDef = unbloodedDef;
                }
                //    Log.Message(string.Format("8"));
                pawn.health.AddHediff(hediffDef, part);
                //    Log.Message(string.Format("9"));
                BloodHD = hediffSet.GetFirstHediffOfDef(hediffDef);
                //    Log.Message(string.Format("10"));
                result = true;
                //    Log.Message(string.Format("11"));
            }
            else
            {
                //    Log.Message(string.Format("12"));
                Comp_Yautja _Yautja = pawn.TryGetComp <Comp_Yautja>();
                //    Log.Message(string.Format("12 a {0}", BloodHD.def));
                if (hasbloodedM)
                {
                    PawnKindDef pawnKindDef = YautjaBloodedUtility.RandomMarked(BloodHD.def);
                    //    Log.Message(string.Format("12 B {0}", pawnKindDef));
                    if (_Yautja != null && _Yautja.MarkHedifflabel.NullOrEmpty())
                    {
                        //    Log.Message(string.Format("13 "));
                        _Yautja.MarkHedifflabel = pawnKindDef.LabelCap;
                        //    Log.Message(string.Format("13 a"));
                        _Yautja.MarkedhediffDef = BloodHD.def;
                        //    Log.Message(string.Format("13 b"));
                        _Yautja.predator = pawnKindDef.RaceProps.predator;
                        //    Log.Message(string.Format("13 c"));
                        _Yautja.BodySize = pawnKindDef.RaceProps.baseBodySize;
                        //    Log.Message(string.Format("13 d"));
                        _Yautja.combatPower = pawnKindDef.combatPower;
                        //    Log.Message(string.Format("13 f"));
                    }
                }
            }
            //    Log.Message(string.Format("14"));
            return(result);
        }
        public static void Postfix(PawnGenerationRequest request, ref Pawn __result)
        {
            Comp_Yautja _Yautja = __result.TryGetComp <Comp_Yautja>();

            if (_Yautja != null)
            {
                Backstory pawnStoryC = __result.story.childhood;
                Backstory pawnStoryA = __result.story.adulthood ?? null;

                AlienRace.BackstoryDef bsDefUnblooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_YoungBlood");

                AlienRace.BackstoryDef bsDefBlooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_Blooded");

                AlienRace.BackstoryDef bsDefBadbloodA = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodA");

                AlienRace.BackstoryDef bsDefBadblooBd = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodB");

                HediffDef unbloodedDef = YautjaDefOf.HMS_Hediff_Unblooded;
                HediffDef unmarkedDef  = YautjaDefOf.HMS_Hediff_BloodedUM;
                HediffDef markedDef    = YautjaDefOf.HMS_Hediff_BloodedM;

                bool hasunblooded = __result.health.hediffSet.HasHediff(unbloodedDef);
                bool hasbloodedUM = __result.health.hediffSet.HasHediff(unmarkedDef);
                bool hasbloodedM  = __result.health.hediffSet.hediffs.Any <Hediff>(x => x.def.defName.StartsWith(markedDef.defName));

                if (!hasunblooded && !hasbloodedUM && !hasbloodedM)
                {
                    HediffDef hediffDef;
                    if (pawnStoryA != null)
                    {
                        if (pawnStoryA != bsDefUnblooded.backstory && __result.kindDef.race == YautjaDefOf.RRY_Alien_Yautja)
                        {
                            hediffDef = _Yautja.Props.bloodedDefs.RandomElement();

                            if (hediffDef != null)
                            {
                                /*
                                 * PawnKindDef pawnKindDef = YautjaBloodedUtility.RandomMarked(hediffDef);
                                 * if (_Yautja != null)
                                 * {
                                 *  _Yautja.MarkHedifflabel = pawnKindDef.LabelCap;
                                 *  _Yautja.MarkedhediffDef = hediffDef;
                                 *  _Yautja.predator = pawnKindDef.RaceProps.predator;
                                 *  _Yautja.BodySize = pawnKindDef.RaceProps.baseBodySize;
                                 *  _Yautja.combatPower = pawnKindDef.combatPower;
                                 *  //    Log.Message(string.Format("{0}: {1}", hediffDef.stages[0].label, pawnKindDef.LabelCap));
                                 * }
                                 */
                            }
                        }
                        else
                        {
                            hediffDef = unbloodedDef;
                        }
                    }
                    else
                    {
                        hediffDef = unbloodedDef;
                    }
                    foreach (var item in __result.RaceProps.body.AllParts)
                    {
                        if (item.def == BodyPartDefOf.Head)
                        {
                            __result.health.AddHediff(hediffDef, item);
                        }
                    }
                }
                else
                {
                    //    Log.Message(string.Format("new pawn has hasunblooded:{0}, hasbloodedUM:{1}, hasbloodedM:{2}", hasunblooded, hasbloodedUM, hasbloodedM));
                }
            }
            if (__result.kindDef.race == YautjaDefOf.RRY_Alien_Yautja)
            {
                if (request.Faction.leader == null && request.Faction != Faction.OfPlayerSilentFail && request.KindDef.race == YautjaDefOf.RRY_Alien_Yautja)
                {
                    Rand.PushState();
                    bool upgradeWeapon = Rand.Chance(0.5f);
                    Rand.PopState();
                    if (__result.equipment.Primary != null && upgradeWeapon)
                    {
                        __result.equipment.Primary.TryGetQuality(out QualityCategory weaponQuality);
                        if (weaponQuality != QualityCategory.Legendary)
                        {
                            Thing       Weapon         = __result.equipment.Primary;
                            CompQuality Weapon_Quality = Weapon.TryGetComp <CompQuality>();
                            if (Weapon_Quality != null)
                            {
                                Weapon_Quality.SetQuality(QualityCategory.Legendary, ArtGenerationContext.Outsider);
                            }
                        }
                    }
                    else if (__result.apparel.WornApparelCount > 0 && !upgradeWeapon)
                    {
                        foreach (var item in __result.apparel.WornApparel)
                        {
                            item.TryGetQuality(out QualityCategory gearQuality);
                            float upgradeChance = 0.5f;
                            Rand.PushState();
                            bool upgradeGear = Rand.Chance(upgradeChance);
                            Rand.PopState();
                            if (gearQuality != QualityCategory.Legendary)
                            {
                                CompQuality Gear_Quality = item.TryGetComp <CompQuality>();
                                if (Gear_Quality != null)
                                {
                                    if (upgradeGear)
                                    {
                                        Gear_Quality.SetQuality(QualityCategory.Legendary, ArtGenerationContext.Outsider);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        public static void Post_GeneratePawn_Yautja(PawnGenerationRequest request, ref Pawn __result)
        {
            Comp_Yautja _Yautja = __result.TryGetComp <Comp_Yautja>();

            if (_Yautja != null)
            {
                Backstory pawnStoryC = __result.story.childhood;
                Backstory pawnStoryA = __result.story.adulthood ?? null;

                AlienRace.BackstoryDef bsDefUnblooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_YoungBlood");

                AlienRace.BackstoryDef bsDefBlooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_Blooded");

                AlienRace.BackstoryDef bsDefBadbloodA = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodA");

                AlienRace.BackstoryDef bsDefBadblooBd = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodB");

                HediffDef unbloodedDef = YautjaDefOf.RRY_Hediff_Unblooded;
                HediffDef unmarkedDef  = YautjaDefOf.RRY_Hediff_BloodedUM;
                HediffDef markedDef    = YautjaDefOf.RRY_Hediff_BloodedM;

                bool hasunblooded = __result.health.hediffSet.HasHediff(unbloodedDef);
                bool hasbloodedUM = __result.health.hediffSet.HasHediff(unmarkedDef);
                bool hasbloodedM  = __result.health.hediffSet.hediffs.Any <Hediff>(x => x.def.defName.StartsWith(markedDef.defName));

                if (!hasunblooded && !hasbloodedUM && !hasbloodedM)
                {
                    HediffDef hediffDef;
                    if (pawnStoryA != null)
                    {
                        if (pawnStoryA != bsDefUnblooded.backstory && __result.kindDef.race == YautjaDefOf.RRY_Alien_Yautja)
                        {
                            hediffDef = _Yautja.Props.bloodedDefs.RandomElement();

                            if (hediffDef != null)
                            {
                                PawnKindDef pawnKindDef = YautjaBloodedUtility.RandomMarked(hediffDef);
                                if (_Yautja != null)
                                {
                                    _Yautja.MarkHedifflabel = pawnKindDef.LabelCap;
                                    _Yautja.MarkedhediffDef = hediffDef;
                                    _Yautja.predator        = pawnKindDef.RaceProps.predator;
                                    _Yautja.BodySize        = pawnKindDef.RaceProps.baseBodySize;
                                    _Yautja.combatPower     = pawnKindDef.combatPower;
                                    //    Log.Message(string.Format("{0}: {1}", hediffDef.stages[0].label, pawnKindDef.LabelCap));
                                }
                            }
                        }
                        else
                        {
                            hediffDef = unbloodedDef;
                        }
                    }
                    else
                    {
                        hediffDef = unbloodedDef;
                    }
                    foreach (var item in __result.RaceProps.body.AllParts)
                    {
                        if (item.def == BodyPartDefOf.Head)
                        {
                            __result.health.AddHediff(hediffDef, item);
                        }
                    }
                }
                else
                {
                    //    Log.Message(string.Format("new pawn has hasunblooded:{0}, hasbloodedUM:{1}, hasbloodedM:{2}", hasunblooded, hasbloodedUM, hasbloodedM));
                }
            }
            if (__result.kindDef.race == YautjaDefOf.RRY_Alien_Yautja)
            {
                if (request.Faction.leader == null && request.Faction != Faction.OfPlayerSilentFail && request.KindDef.race == YautjaDefOf.RRY_Alien_Yautja)
                {
                    bool upgradeWeapon = Rand.Chance(0.5f);
                    if (__result.equipment.Primary != null && upgradeWeapon)
                    {
                        __result.equipment.Primary.TryGetQuality(out QualityCategory weaponQuality);
                        if (weaponQuality != QualityCategory.Legendary)
                        {
                            Thing       Weapon         = __result.equipment.Primary;
                            CompQuality Weapon_Quality = Weapon.TryGetComp <CompQuality>();
                            if (Weapon_Quality != null)
                            {
                                Weapon_Quality.SetQuality(QualityCategory.Legendary, ArtGenerationContext.Outsider);
                            }
                        }
                    }
                    else if (__result.apparel.WornApparelCount > 0 && !upgradeWeapon)
                    {
                        foreach (var item in __result.apparel.WornApparel)
                        {
                            item.TryGetQuality(out QualityCategory gearQuality);
                            float upgradeChance = 0.5f;
                            bool  upgradeGear   = Rand.Chance(0.5f);
                            if (gearQuality != QualityCategory.Legendary)
                            {
                                CompQuality Gear_Quality = item.TryGetComp <CompQuality>();
                                if (Gear_Quality != null)
                                {
                                    if (upgradeGear)
                                    {
                                        Gear_Quality.SetQuality(QualityCategory.Legendary, ArtGenerationContext.Outsider);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            /*
             * if (__result.Faction.def.defName.Contains("RRY_USCM"))
             * {
             *  __result.relations.ClearAllRelations();
             *
             *  if (__result.gender != Gender.Male)
             *  {
             *      PawnKindDef pawnKindDef = request.KindDef;
             *      if (pawnKindDef == request.KindDef) pawnKindDef = Rand.Chance(0.15f) ? AstartesOGDefOf.OG_Astartes_Neophyte : AstartesOGDefOf.OG_Astartes_Brother;
             *      if (pawnKindDef == request.KindDef) pawnKindDef = Rand.Chance(0.15f) ? AstartesOGDefOf.OG_Astartes_Sargent : AstartesOGDefOf.OG_Astartes_Brother;
             *      if (pawnKindDef == request.KindDef) pawnKindDef = Rand.Chance(0.15f) ? AstartesOGDefOf.OG_Astartes_Captain : AstartesOGDefOf.OG_Astartes_Brother;
             *      request = new PawnGenerationRequest(request.KindDef, request.Faction, request.Context, -1, true, false, false, false, false, true, 0f, fixedGender: Gender.Male, allowGay: false);
             *      __result = PawnGenerator.GeneratePawn(request);
             *  }
             *
             *  __result.story.bodyType = BodyTypeDefOf.Hulk;
             *  __result.gender = Gender.Male;
             *  //Log.Message(string.Format(__result.Drawer.renderer.graphics.headGraphic.data.texPath));
             *  //   __result.Drawer.renderer.graphics.headGraphic.data.texPath.ToString();
             *  HairDef hairdef = Rand.Chance(0.5f) ? AstartesOGDefOf.Shaved : AstartesOGDefOf.Topdog;
             *  __result.story.hairDef = hairdef;
             * }
             */
            if (__result.kindDef.RaceProps.FleshType == XenomorphRacesDefOf.RRY_Xenomorph)
            {
                if (request.KindDef == XenomorphDefOf.RRY_Xenomorph_Queen)
                {
                    __result.gender = Gender.Female;

                    /*
                     * bool QueenPresent = false;
                     *
                     * foreach (var p in Find.AnyPlayerHomeMap.mapPawns.AllPawns)
                     * {
                     *  if (p.kindDef == XenomorphDefOf.RRY_Xenomorph_Queen)
                     *  {
                     *  //    Log.Message(string.Format("Queen Found"));
                     *      QueenPresent = true;
                     *      break;
                     *  }
                     * }
                     * if (QueenPresent)
                     * {
                     *  request = new PawnGenerationRequest(XenomorphDefOf.RRY_Xenomorph_Warrior, request.Faction, request.Context, -1, true, false, false, false, false, true, 0f, fixedGender: Gender.None, allowGay: false);
                     *  __result = PawnGenerator.GeneratePawn(request);
                     *  __result.gender = Gender.None;
                     *  return;
                     * }
                     * else
                     * {
                     *  __result.gender = Gender.Female;
                     * }
                     */
                }
                else
                {
                    __result.gender = Gender.None;
                }
            }
            if (__result.kindDef.race != YautjaDefOf.RRY_Alien_Yautja && __result.RaceProps.Humanlike && (__result.story.hairDef == YautjaDefOf.RRY_Yaujta_Dreds || __result.story.hairDef == YautjaDefOf.RRY_Yaujta_Ponytail || __result.story.hairDef == YautjaDefOf.RRY_Yaujta_Bald))
            {
                Log.Message(string.Format("Non Yautja with Yautja Hair"));
                __result.story.hairDef = DefDatabase <HairDef> .AllDefsListForReading.FindAll(x => !x.hairTags.Contains("Yautja")).RandomElement();
            }
            if (Rand.Chance(0.005f) && XenomorphUtil.isInfectablePawn(__result) && SettingsHelper.latest.AllowHiddenInfections)
            {
                HediffDef def = Rand.Chance(0.75f) ? XenomorphDefOf.RRY_HiddenXenomorphImpregnation : XenomorphDefOf.RRY_HiddenNeomorphImpregnation;
                __result.health.AddHediff(def, __result.RaceProps.body.corePart, null);
            }
            var hediffGiverSet = __result?.def?.race?.hediffGiverSets;

            if (hediffGiverSet == null)
            {
                return;
            }
            foreach (var item in hediffGiverSet)
            {
                var hediffGivers = item.hediffGivers;
                if (hediffGivers == null)
                {
                    return;
                }
                if (hediffGivers.Any(y => y is HediffGiver_StartWithHediff))
                {
                    foreach (var hdg in hediffGivers.Where(x => x is HediffGiver_StartWithHediff))
                    {
                        HediffGiver_StartWithHediff hediffGiver_StartWith = (HediffGiver_StartWithHediff)hdg;
                        hediffGiver_StartWith.GiveHediff(__result);
                    }
                }
            }
        }
        public static void Post_GeneratePawn_Yautja(PawnGenerationRequest request, ref Pawn __result)
        {
            if (__result.kindDef.race == YautjaDefOf.RRY_Alien_Yautja)
            {
                Comp_Yautja _Yautja = __result.TryGetComp <Comp_Yautja>();
                if (_Yautja != null)
                {
                    Backstory pawnStoryC = __result.story.childhood;
                    Backstory pawnStoryA = __result.story.adulthood != null ? __result.story.adulthood : null;

                    AlienRace.BackstoryDef bsDefUnblooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_YoungBlood");

                    AlienRace.BackstoryDef bsDefBlooded = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_Blooded");

                    AlienRace.BackstoryDef bsDefBadbloodA = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodA");

                    AlienRace.BackstoryDef bsDefBadblooBd = DefDatabase <AlienRace.BackstoryDef> .GetNamed("RRY_Yautja_BadBloodB");

                    HediffDef unbloodedDef = YautjaDefOf.RRY_Hediff_Unblooded;
                    HediffDef unmarkedDef  = YautjaDefOf.RRY_Hediff_BloodedUM;
                    HediffDef markedDef    = YautjaDefOf.RRY_Hediff_BloodedM;

                    bool hasunblooded = __result.health.hediffSet.HasHediff(unbloodedDef);
                    bool hasbloodedUM = __result.health.hediffSet.HasHediff(unmarkedDef);
                    bool hasbloodedM  = __result.health.hediffSet.hediffs.Any <Hediff>(x => x.def.defName.StartsWith(markedDef.defName));

                    if (!hasunblooded && !hasbloodedUM && !hasbloodedM)
                    {
                        HediffDef hediffDef;
                        if (pawnStoryA != null)
                        {
                            if (pawnStoryA != bsDefUnblooded.backstory)
                            {
                                hediffDef = _Yautja.Props.bloodedDefs.RandomElement();
                            }
                            else
                            {
                                hediffDef = unbloodedDef;
                            }
                        }
                        else
                        {
                            hediffDef = unbloodedDef;
                        }
                        __result.health.AddHediff(hediffDef);
                    }
                    else
                    {
                        Log.Message(string.Format("new pawn has hasunblooded:{0}, hasbloodedUM:{1}, hasbloodedM:{2}", hasunblooded, hasbloodedUM, hasbloodedM));
                    }
                }
            }
            else if (request.Faction == Find.FactionManager.FirstFactionOfDef(XenomorphDefOf.RRY_Xenomorph))
            {
                Log.Message(string.Format("Xenomorph spawning"));
            }
            else if (__result.kindDef.race != YautjaDefOf.RRY_Alien_Yautja && __result.RaceProps.Humanlike && (__result.story.hairDef == YautjaDefOf.RRY_Yaujta_Dreds || __result.story.hairDef == YautjaDefOf.RRY_Yaujta_Ponytail || __result.story.hairDef == YautjaDefOf.RRY_Yaujta_Bald))
            {
                Log.Message(string.Format("Non Yautja with Yautja Hair"));
                __result.story.hairDef = DefDatabase <HairDef> .GetRandom();
            }
        }