Ejemplo n.º 1
0
        /// <summary>
        /// Similar method as GenerateVampire, except it initializes ghouls.
        /// </summary>
        /// <param name="generation"></param>
        /// <param name="bloodline"></param>
        /// <param name="domitor"></param>
        /// <param name="vampFaction"></param>
        /// <param name="isRevenant"></param>
        /// <returns></returns>
        public static Pawn GenerateGhoul(int generation, BloodlineDef bloodline, Pawn domitor,
                                         Faction vampFaction = null, bool isRevenant = false)
        {
            //Lower generation ghouls are impossibly old.
            float?math = domitor != null ?
                         domitor.ageTracker.AgeChronologicalYearsFloat + new FloatRange(100, 300).RandomInRange :
                         generation > 4 ? Mathf.Clamp(2000 - generation * Rand.Range(20, 200), 16, 2000) :
                         100000 - generation * Rand.Range(10000, 50000);

            Faction faction = vampFaction != null ? vampFaction :
                              generation < 7 ? Find.FactionManager.FirstFactionOfDef(VampDefOf.ROMV_LegendaryVampires) :
                              VampireUtility.RandVampFaction;
            PawnGenerationRequest request = new PawnGenerationRequest(
                PawnKindDefOf.SpaceRefugee, Faction.OfAncients, PawnGenerationContext.NonPlayer,
                -1, false, false, false, false, true, true, 20f, false, true,
                true, false, false, false, false, false, 0, null, 0, null, null, null, null, null);
            Pawn pawn = PawnGenerator.GeneratePawn(request);

            pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, 20);
            if (!bloodline.allowsHair)
            {
                pawn.story.hairDef = DefDatabase <HairDef> .GetNamed("Shaved");
            }
            pawn.VampComp().InitializeGhoul(domitor, isRevenant);
            return(pawn);
        }
        public static Pawn GenerateVampire(int generation, BloodlineDef bloodline, Pawn sire, Faction vampFaction = null, bool firstVampire = false)
        {
            //Lower generation vampires are impossibly old.
            float?math = sire != null ? sire.ageTracker.AgeChronologicalYearsFloat + new FloatRange(100, 300).RandomInRange :
                         generation > 4 ? Mathf.Clamp(2000 - generation * Rand.Range(20, 200), 16, 2000) :
                         100000 - generation * Rand.Range(10000, 50000);

            Faction faction = vampFaction != null ? vampFaction :
                              generation < 7 ? Find.FactionManager.FirstFactionOfDef(VampDefOf.ROMV_LegendaryVampires) : VampireUtility.RandVampFaction;
            PawnGenerationRequest request = new PawnGenerationRequest(
                PawnKindDefOf.SpaceRefugee, Faction.OfSpacer, PawnGenerationContext.NonPlayer,
                -1, false, false, false, false, true, true, 20f, false, true,
                true, false, false, false, false, null, null, null, null, null, null);
            Pawn pawn = PawnGenerator.GeneratePawn(request);

            if (firstVampire)
            {
                NameTriple caineName = new NameTriple("Caine", "Caine", "Darkfather");
                pawn.Name   = caineName;
                pawn.gender = Gender.Male;
            }
            pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, 20);
            if (!bloodline.allowsHair)
            {
                pawn.story.hairDef = DefDatabase <HairDef> .GetNamed("Shaved");
            }
            pawn.VampComp().InitializeVampirism(sire, bloodline, generation, firstVampire);
            //TryGiveVampirismHediff(pawn, generation, bloodline, sire, firstVampire);
            return(pawn);
        }
Ejemplo n.º 3
0
        public override void TryExecute()
        {
            if (pawn.gender == Gender.Female)
            {
                pawn.gender = Gender.Male;
            }
            else
            {
                pawn.gender = Gender.Female;
            }

            pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, pawn.ageTracker.AgeBiologicalYears);
            pawn.story.hairDef   = PawnHairChooser.RandomHairDefFor(pawn, FactionDefOf.PlayerColony);

            if (pawn.story.adulthood != null)
            {
                pawn.story.bodyType = pawn.story.adulthood.BodyTypeFor(pawn.gender);
            }
            else if (Rand.Value < 0.5f)
            {
                pawn.story.bodyType = BodyTypeDefOf.Thin;
            }
            else
            {
                pawn.story.bodyType = ((pawn.gender != Gender.Female) ? BodyTypeDefOf.Male : BodyTypeDefOf.Female);
            }

            viewer.TakeViewerCoins(storeIncident.cost);
            viewer.CalculateNewKarma(storeIncident.karmaType, storeIncident.cost);
            VariablesHelpers.SendPurchaseMessage($"@{viewer.username} has just swapped genders to " + pawn.gender.GetLabel() + ".", separateChannel);
            string text = $"{viewer.username} has just swapped genders to " + pawn.gender.GetLabel() + ".";

            Current.Game.letterStack.ReceiveLetter("GenderSwap", text, LetterDefOf.PositiveEvent, pawn);
        }
Ejemplo n.º 4
0
        public override void Execute()
        {
            _pawn.gender          = _pawn.gender == Gender.Female ? Gender.Male : Gender.Female;
            _pawn.story.hairColor = PawnHairColors.RandomHairColor(_pawn.story.SkinColor, _pawn.ageTracker.AgeBiologicalYears);

            if (_pawn.style.HasUnwantedBeard)
            {
                _pawn.style.beardDef = BeardDefOf.NoBeard;
                _pawn.style.Notify_StyleItemChanged();
            }

            _pawn.story.hairDef = PawnStyleItemChooser.RandomHairFor(_pawn);

            _pawn.story.bodyType = _pawn.story.adulthood == null?RandomBodyType(_pawn) : _pawn.story.adulthood.BodyTypeFor(_pawn.gender);

            Viewer.Charge(storeIncident);

            MessageHelper.SendConfirmation(Viewer.username, "TKUtils.GenderSwap.Complete".LocalizeKeyed(_pawn.gender.ToString()));

            Find.LetterStack.ReceiveLetter(
                "TKUtils.GenderSwapLetter.Title".Localize(),
                "TKUtils.GenderSwapLetter.Description".LocalizeKeyed(Viewer.username, _pawn.gender.ToString()),
                LetterDefOf.NeutralEvent,
                _pawn
                );
        }
Ejemplo n.º 5
0
        // see PawnGenerator
        private void generate_pawn()
        {
            Gender gender;

            if (Rand.Value < 0.5f)
            {
                gender = Gender.Male;
            }
            else
            {
                gender = Gender.Female;
            }

            Faction f = Faction.OfPlayer;

            float melanin = PawnSkinColors.RandomMelanin(f);

            skinColor = PawnSkinColors.GetSkinColor(melanin);
            int age = 20;

            hairColor = PawnHairColors.RandomHairColor(skinColor, age);
            hairDef   = RandomHairDefFor(gender, f.def);

            crownType = Rand.Value >= 0.5f ? CrownType.Narrow : CrownType.Average;

            headGraphicPath = GraphicDatabaseHeadRecords.GetHeadRandom(
                gender, skinColor, crownType).GraphicPath;

            bodyType = BodyType.Male;
        }
Ejemplo n.º 6
0
        public PawnGraphicRenderer(float melanin)
        {
            Color     skinColor = PawnSkinColors.GetSkinColor(this.melanin = melanin);
            Gender    gender    = (Rand.Value < 0.5f) ? Gender.Male : Gender.Female;
            CrownType crownType = (Rand.Value < 0.5f) ? CrownType.Average : CrownType.Narrow;
            HairDef   hairDef   = RandomHairDefFor(gender);
            Color     hairColor = PawnHairColors.RandomHairColor(skinColor, 18);

            headGraphic = GraphicDatabaseHeadRecords.GetHeadRandom(gender, skinColor, crownType, false);
            hairGraphic = GraphicDatabase.Get <Graphic_Multi>(hairDef.texPath, ShaderDatabase.Cutout, Vector2.one, hairColor);
        }
 public override void Notify_PawnGenerated(Pawn pawn, PawnGenerationContext context)
 {
     if (Find.VisibleMap == null)
     {
         curVampires = Find.GameInitData.startingPawns.FindAll(x => x?.health?.hediffSet?.hediffs.FirstOrDefault(y => y.def.defName.Contains("Vampirism")) != null)?.Count() ?? 0;
         BloodlineDef def = (randomBloodline) ? PossibleBloodlines().RandomElement() : bloodline;
         if (pawn.RaceProps.Humanlike && context == PawnGenerationContext.PlayerStarter)
         {
             if (Rand.Value < vampChance && curVampires < maxVampires)
             {
                 curVampires++;
                 HediffDef hediffDefToApply = VampDefOf.ROM_VampirismRandom;
                 if (def == VampDefOf.ROMV_ClanGargoyle)
                 {
                     hediffDefToApply = VampDefOf.ROM_VampirismGargoyle;
                 }
                 if (def == VampDefOf.ROMV_ClanLasombra)
                 {
                     hediffDefToApply = VampDefOf.ROM_VampirismLasombra;
                 }
                 if (def == VampDefOf.ROMV_ClanPijavica)
                 {
                     hediffDefToApply = VampDefOf.ROM_VampirismPijavica;
                 }
                 if (def == VampDefOf.ROMV_ClanTremere)
                 {
                     hediffDefToApply = VampDefOf.ROM_VampirismTremere;
                 }
                 if (def == VampDefOf.ROMV_ClanTzimize)
                 {
                     hediffDefToApply = VampDefOf.ROM_VampirismTzimisce;
                 }
                 HealthUtility.AdjustSeverity(pawn, hediffDefToApply, 0.5f);
                 pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, 20);
                 int ticksToAdd = Rand.Range(GenDate.TicksPerYear, GenDate.TicksPerYear * 200);
                 pawn.ageTracker.AgeBiologicalTicks    += ticksToAdd;
                 pawn.ageTracker.AgeChronologicalTicks += ticksToAdd;
                 if (pawn.health.hediffSet.hediffs is List <Hediff> hediffs)
                 {
                     hediffs.RemoveAll(x => x.IsOld() ||
                                       x.def == HediffDefOf.BadBack ||
                                       x.def == HediffDefOf.Frail ||
                                       x.def == HediffDefOf.Cataract ||
                                       x.def == HediffDef.Named("HearingLoss") ||
                                       x.def == HediffDef.Named("HeartArteryBlockage"));
                 }
                 //VampireGen.TryGiveVampirismHediff(pawn, generationRange.RandomInRange, def, null, false);
             }
         }
     }
 }
Ejemplo n.º 8
0
        public static Pawn GenerateVampire(int generation, BloodlineDef bloodline, Pawn sire, Faction vampFaction = null, bool firstVampire = false)
        {
            //Lower generation vampires are impossibly old.
            float?math = sire != null ? sire.ageTracker.AgeChronologicalYearsFloat + new FloatRange(100, 300).RandomInRange :
                         generation > 4 ? Mathf.Clamp(2000 - generation * Rand.Range(20, 200), 16, 2000) :
                         100000 - generation * Rand.Range(10000, 50000);

            Faction faction = vampFaction != null ? vampFaction :
                              generation < 7 ? Find.FactionManager.FirstFactionOfDef(VampDefOf.ROMV_LegendaryVampires) : VampireUtility.RandVampFaction;

            HarmonyPatches.VampireGenInProgress = true;
            PawnGenerationRequest request = new PawnGenerationRequest(
                DetermineKindDef(generation), faction, PawnGenerationContext.NonPlayer,
                -1, true, false, false, false, true, true, 20f, false, true,
                true, false, false, false, false, false, 0, 0, null, 0, null, null, null, null, null, math, null, null);
            Pawn pawn = PawnGenerator.GeneratePawn(request);

            if (DebugSettings.godMode)
            {
                Log.Message(pawn.Name + " Age:" + pawn.ageTracker.AgeNumberString + " Generation:" + generation);
            }
            HarmonyPatches.VampireGenInProgress = false;

            if (firstVampire)
            {
                NameTriple caineName = new NameTriple("Caine", "Caine", "Darkfather");
                pawn.Name   = caineName;
                pawn.gender = Gender.Male;
            }
            pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, 20);
            if (!bloodline.allowsHair)
            {
                pawn.story.hairDef = DefDatabase <HairDef> .GetNamed("Shaved");
            }
            pawn.VampComp().InitializeVampirism(sire, bloodline, generation, firstVampire);
            pawn.ageTracker.AgeBiologicalTicks = (long)(math * GenDate.TicksPerYear);
            //TryGiveVampirismHediff(pawn, generation, bloodline, sire, firstVampire);
            return(pawn);
        }
Ejemplo n.º 9
0
        private static Pawn DoGenerateNewNakedPawn(ref PawnGenerationRequest request, out string error, bool ignoreScenarioRequirements)
        {
            error = null;
            Pawn pawn = (Pawn)ThingMaker.MakeThing(request.KindDef.race, null);

            AlienPawnGenerator.pawnsBeingGenerated.Add(new AlienPawnGenerator.PawnGenerationStatus(pawn, null));
            Pawn result;

            try
            {
                pawn.kindDef = request.KindDef;
                pawn.SetFactionDirect(request.Faction);
                PawnComponentsUtility.CreateInitialComponents(pawn);
                if (request.FixedGender.HasValue)
                {
                    pawn.gender = request.FixedGender.Value;
                }
                else if (pawn.RaceProps.hasGenders)
                {
                    if (Rand.Value < 0.5f)
                    {
                        pawn.gender = Gender.Male;
                    }
                    else
                    {
                        pawn.gender = Gender.Female;
                    }
                }
                else
                {
                    pawn.gender = Gender.None;
                }
                AlienPawnGenerator.GenerateRandomAge(pawn, request);
                pawn.needs.SetInitialLevels();
                if (!request.Newborn && request.CanGeneratePawnRelations)
                {
                    AlienPawnGenerator.GeneratePawnRelations(pawn, ref request);
                }
                if (pawn.RaceProps.Humanlike)
                {
                    pawn.story.skinWhiteness = ((!request.FixedSkinWhiteness.HasValue) ? PawnSkinColors.RandomSkinWhiteness() : request.FixedSkinWhiteness.Value);
                    pawn.story.crownType     = ((Rand.Value >= 0.5f) ? CrownType.Narrow : CrownType.Average);
                    pawn.story.hairColor     = PawnHairColors.RandomHairColor(pawn.story.SkinColor, pawn.ageTracker.AgeBiologicalYears);
                    PawnBioGenerator.GiveAppropriateBioTo(pawn, request.FixedLastName);
                    pawn.story.hairDef = PawnHairChooser.RandomHairDefFor(pawn, request.Faction.def);
                    AlienPawnGenerator.GiveRandomTraits(pawn, request.AllowGay);
                    pawn.story.GenerateSkillsFromBackstory();
                }
                if (pawn.workSettings != null && request.Faction.IsPlayer)
                {
                    pawn.workSettings.EnableAndInitialize();
                }
                if (request.Faction != null && pawn.RaceProps.Animal)
                {
                    pawn.GenerateNecessaryName();
                }
                if (!request.AllowDead && (pawn.Dead || pawn.Destroyed))
                {
                    AlienPawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated dead pawn.";
                    result = null;
                }
                else if (!request.AllowDowned && pawn.Downed)
                {
                    AlienPawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated downed pawn.";
                    result = null;
                }
                else if (request.MustBeCapableOfViolence && pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent))
                {
                    AlienPawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated pawn incapable of violence.";
                    result = null;
                }
                else if (!ignoreScenarioRequirements && request.Context == PawnGenerationContext.PlayerStarter && !Find.Scenario.AllowPlayerStartingPawn(pawn))
                {
                    AlienPawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated pawn doesn't meet scenario requirements.";
                    result = null;
                }
                else if (request.Validator != null && !request.Validator(pawn))
                {
                    AlienPawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated pawn didn't pass validator check.";
                    result = null;
                }
                else
                {
                    for (int i = 0; i < AlienPawnGenerator.pawnsBeingGenerated.Count - 1; i++)
                    {
                        if (AlienPawnGenerator.pawnsBeingGenerated[i].PawnsGeneratedInTheMeantime == null)
                        {
                            AlienPawnGenerator.pawnsBeingGenerated[i] = new AlienPawnGenerator.PawnGenerationStatus(AlienPawnGenerator.pawnsBeingGenerated[i].Pawn, new List <Pawn>());
                        }
                        AlienPawnGenerator.pawnsBeingGenerated[i].PawnsGeneratedInTheMeantime.Add(pawn);
                    }
                    result = pawn;
                }
            }
            finally
            {
                AlienPawnGenerator.pawnsBeingGenerated.RemoveLast <AlienPawnGenerator.PawnGenerationStatus>();
            }
            return(result);
        }
        //public static AIPawn GeneratePawn(PawnKindDef kindDef, Faction faction, Map map, Gender gender = Gender.Female, int tries = 0)
        public static AIPawn GenerateAIPawn(ref PawnGenerationRequest request, Map map, int tries = 0)
        {
            BackstoryHelper.AddNewBackstoriesToDatabase(); // First add the new backstories to the database

            //Log.Error("0");

            AIPawn pawnAI = (AIPawn)ThingMaker.MakeThing(request.KindDef.race, null);

            //Log.Error("1");
            GetXMLData(pawnAI);

            //request.EnsureNonNullFaction();

            pawnAI.kindDef = request.KindDef;
            pawnAI.SetFactionDirect(request.Faction);

            PawnComponentsUtility.CreateInitialComponents(pawnAI);

            //Log.Error("2");

            // Needs to be set because of not flesh user
            if (pawnAI.ownership == null)
            {
                pawnAI.ownership = new Pawn_Ownership(pawnAI);
            }

            pawnAI.relations = new Pawn_RelationsTracker(pawnAI);
            pawnAI.guest     = new Pawn_GuestTracker(pawnAI);

            pawnAI.guilt     = new Pawn_GuiltTracker(pawnAI);
            pawnAI.royalty   = new Pawn_RoyaltyTracker(pawnAI);
            pawnAI.abilities = new Pawn_AbilityTracker(pawnAI);
            pawnAI.relations = new Pawn_RelationsTracker(pawnAI);

            if (request.FixedGender.HasValue)
            {
                pawnAI.gender = request.FixedGender.Value;
            }
            else if (pawnAI.RaceProps.hasGenders)
            {
                if (Rand.Value < 0.5f)
                {
                    pawnAI.gender = Gender.Male;
                }
                else
                {
                    pawnAI.gender = Gender.Female;
                }
            }
            else
            {
                pawnAI.gender = Gender.Female;
            }

            SetBirthday(pawnAI);
            pawnAI.needs.SetInitialLevels();


            //Log.Error("3");

            AIPawnGenerator.GenerateInitialHediffs(pawnAI);


            if (pawnAI.RaceProps.Humanlike)
            {
                pawnAI.story.melanin   = 0.1f;
                pawnAI.story.crownType = CrownType.Average;
                pawnAI.story.hairColor = PawnHairColors.RandomHairColor(pawnAI.story.SkinColor, pawnAI.ageTracker.AgeBiologicalYears);

                pawnAI.story.childhood = GetBackstory();
                //pawnAI.story.adulthood = GetBackstory();

                string headGraphicPath = GraphicDatabaseHeadRecords.GetHeadRandom(pawnAI.gender, pawnAI.story.SkinColor, pawnAI.story.crownType, false).GraphicPath;
                // With this Reflection you can access a private variable! Here: The private string "headGraphicPath" is set
                System.Reflection.FieldInfo fi = typeof(Pawn_StoryTracker).GetField("headGraphicPath", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                fi.SetValue(pawnAI.story, headGraphicPath);

                pawnAI.story.hairDef = GetHair();

                pawnAI.story.bodyType = ((pawnAI.gender != Gender.Female) ? BodyTypeDefOf.Male : BodyTypeDefOf.Female);

                MakeSkillsFromBackstory(pawnAI);
                GiveTraitsTo(pawnAI);

                if (pawnAI.workSettings != null && (request.Faction == Faction.OfPlayer))
                {
                    pawnAI.workSettings.EnableAndInitialize();
                }
            }

            if (pawnAI.RaceProps.ToolUser)
            {
                GenerateBaseApparel(pawnAI);
            }

            pawnAI.Name = GetName(pawnAI.def, map);

            pawnAI.royalty = null;

            //Log.Error("4");
            //PawnGenerationRequest request = new PawnGenerationRequest(pawnAI.kindDef , Faction.OfPlayer, PawnGenerationContext.All, true, true, false,false, false, false, 0, false, false, false,null, 0,0, pawnAI.gender, null, null);

            //PawnInventoryGenerator.GenerateInventoryFor(pawnAI, request);

            if (!pawnAI.Dead)
            {
                return(pawnAI);
            }

            if (tries < 10)
            {
                return(GenerateAIPawn(ref request, map, tries + 1));
            }

            return(null);
        }
Ejemplo n.º 11
0
        public static Droid GenerateDroid(Blueprint bp, Faction faction)
        {
            Droid droid = (Droid)ThingMaker.MakeThing(bp.KindDef.race);

            droid.SetFactionDirect(faction);
            droid.kindDef             = bp.KindDef;
            droid.RaceProps.corpseDef = ThingDef.Named("MD2DroidCorpse");

            #region Trackers
            droid.thinker          = new Pawn_Thinker(droid);
            droid.playerController = new Pawn_PlayerController(droid);
            droid.inventory        = new Pawn_InventoryTracker(droid);
            droid.pather           = new Pawn_PathFollower(droid);
            droid.jobs             = new Pawn_JobTracker(droid);
            droid.health           = new Pawn_HealthTracker(droid);
            droid.ageTracker       = new Pawn_AgeTracker(droid);
            droid.filth            = new Pawn_FilthTracker(droid);
            droid.mindState        = new Pawn_MindState(droid);
            droid.equipment        = new Pawn_EquipmentTracker(droid);
            droid.apparel          = new Pawn_ApparelTracker(droid);
            droid.natives          = new Pawn_NativeVerbs(droid);
            droid.meleeVerbs       = new Pawn_MeleeVerbs(droid);
            droid.carryHands       = new Pawn_CarryHands(droid);
            droid.ownership        = new Pawn_Ownership(droid);
            droid.skills           = new Pawn_SkillTracker(droid);
            droid.story            = new Pawn_StoryTracker(droid);
            droid.workSettings     = new Pawn_WorkSettings(droid);
            droid.guest            = new Pawn_GuestTracker(droid);
            droid.needs            = new Pawn_NeedsTracker(droid);
            droid.stances          = new Pawn_StanceTracker(droid);

            typeof(Pawn_NeedsTracker).GetMethod("AddNeed", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(droid.needs, new object[] { DefDatabase <NeedDef> .GetNamed("Mood") });
            #endregion

            droid.gender = droid.RaceProps.hasGenders ? Gender.Male : Gender.None;

            droid.ageTracker.SetChronologicalBirthDate(GenDate.CurrentYear, GenDate.DayOfMonth);
            droid.story.skinColor       = PawnSkinColors.PaleWhiteSkin;
            droid.story.crownType       = CrownType.Narrow;
            droid.story.headGraphicPath = GraphicDatabaseHeadRecords.GetHeadRandom(Gender.Male, droid.story.skinColor, droid.story.crownType).GraphicPath;
            droid.story.hairColor       = PawnHairColors.RandomHairColor(droid.story.skinColor, droid.ageTracker.AgeBiologicalYears);
            droid.story.name            = new PawnName()
            {
                first = "Droid",
                last  = "Droid",
                nick  = bp.Name
            };

            #region Managers

            droid.meta      = new MetaDataManager(droid, bp);
            droid.utilities = new UtilityManager(droid);

            WorkPackageDef        maintenance  = WorkPackageDef.Named("MD2MaintenancePackage");
            WorkPackageDef        firefighting = WorkPackageDef.Named("MD2FirefighterPackage");
            List <WorkPackageDef> list         = bp.WorkPackages;
            if (!list.Contains(maintenance))
            {
                list.Add(maintenance);
            }
            if (!list.Contains(firefighting))
            {
                list.Add(firefighting);
            }
            droid.work = new WorkManager(list, droid);

            droid.backstory = new BackstoryManager(droid);
            droid.backstory.SpawnSetup();

            droid.drawManager = new DrawManager(bp.BodyGraphicDef, bp.HeadGraphicDef, droid);
            droid.drawManager.SpawnSetup();

            droid.parts = new PartsManager(droid);
            #endregion

            foreach (SkillRecord sk in droid.skills.skills)
            {
                sk.level   = (bp.StartingSkillLevel > 20) ? 20 : (bp.StartingSkillLevel <= 0) ? 1 : bp.StartingSkillLevel;
                sk.passion = bp.SkillPassion;
            }
            droid.workSettings.EnableAndInitialize();

            foreach (var def in DefDatabase <WorkTypeDef> .AllDefs)
            {
                if (droid.work.Contains(def))
                {
                    droid.workSettings.SetPriority(def, 4);
                }
                else
                {
                    droid.workSettings.SetPriority(def, 0);
                    droid.workSettings.Disable(def);
                }
            }

            return(droid);
        }
Ejemplo n.º 12
0
        private static Pawn TryGenerateNewNakedPawn(ref PawnGenerationRequest request, out string error, bool ignoreScenarioRequirements)
        {
            error = null;
            Pawn pawn = (Pawn)ThingMaker.MakeThing(request.KindDef.race, null);

            PawnGenerator.pawnsBeingGenerated.Add(new PawnGenerationStatus(pawn, null));
            try
            {
                pawn.kindDef = request.KindDef;
                pawn.SetFactionDirect(request.Faction);
                PawnComponentsUtility.CreateInitialComponents(pawn);
                if (request.FixedGender.HasValue)
                {
                    pawn.gender = request.FixedGender.Value;
                }
                else if (pawn.RaceProps.hasGenders)
                {
                    if (Rand.Value < 0.5)
                    {
                        pawn.gender = Gender.Male;
                    }
                    else
                    {
                        pawn.gender = Gender.Female;
                    }
                }
                else
                {
                    pawn.gender = Gender.None;
                }
                PawnGenerator.GenerateRandomAge(pawn, request);
                pawn.needs.SetInitialLevels();
                if (!request.Newborn && request.CanGeneratePawnRelations)
                {
                    PawnGenerator.GeneratePawnRelations(pawn, ref request);
                }
                if (pawn.RaceProps.Humanlike)
                {
                    pawn.story.melanin   = ((!request.FixedMelanin.HasValue) ? PawnSkinColors.RandomMelanin(request.Faction) : request.FixedMelanin.Value);
                    pawn.story.crownType = (CrownType)((Rand.Value < 0.5) ? 1 : 2);
                    pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, pawn.ageTracker.AgeBiologicalYears);
                    PawnBioAndNameGenerator.GiveAppropriateBioAndNameTo(pawn, request.FixedLastName);
                    pawn.story.hairDef = PawnHairChooser.RandomHairDefFor(pawn, request.Faction.def);
                    PawnGenerator.GenerateTraits(pawn, request);
                    PawnGenerator.GenerateBodyType(pawn);
                    PawnGenerator.GenerateSkills(pawn);
                }
                PawnGenerator.GenerateInitialHediffs(pawn, request);
                if (pawn.workSettings != null && request.Faction.IsPlayer)
                {
                    pawn.workSettings.EnableAndInitialize();
                }
                if (request.Faction != null && pawn.RaceProps.Animal)
                {
                    pawn.GenerateNecessaryName();
                }
                if (!request.AllowDead && (pawn.Dead || pawn.Destroyed))
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error = "Generated dead pawn.";
                    return(null);
                }
                if (!request.AllowDowned && pawn.Downed)
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error = "Generated downed pawn.";
                    return(null);
                }
                if (request.MustBeCapableOfViolence)
                {
                    if (pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent))
                    {
                        goto IL_02b0;
                    }
                    if (!pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation))
                    {
                        goto IL_02b0;
                    }
                }
                if (!ignoreScenarioRequirements && request.Context == PawnGenerationContext.PlayerStarter && !Find.Scenario.AllowPlayerStartingPawn(pawn))
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error = "Generated pawn doesn't meet scenario requirements.";
                    return(null);
                }
                if (request.Validator != null && !request.Validator(pawn))
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error = "Generated pawn didn't pass validator check.";
                    return(null);
                }
                for (int i = 0; i < PawnGenerator.pawnsBeingGenerated.Count - 1; i++)
                {
                    if (PawnGenerator.pawnsBeingGenerated[i].PawnsGeneratedInTheMeantime == null)
                    {
                        PawnGenerator.pawnsBeingGenerated[i] = new PawnGenerationStatus(PawnGenerator.pawnsBeingGenerated[i].Pawn, new List <Pawn>());
                    }
                    PawnGenerator.pawnsBeingGenerated[i].PawnsGeneratedInTheMeantime.Add(pawn);
                }
                return(pawn);

IL_02b0:
                PawnGenerator.DiscardGeneratedPawn(pawn);
                error = "Generated pawn incapable of violence.";
                return(null);
            }
            finally
            {
                PawnGenerator.pawnsBeingGenerated.RemoveLast();
            }
        }
Ejemplo n.º 13
0
        private static Pawn TryGenerateNewPawnInternal(ref PawnGenerationRequest request, out string error, bool ignoreScenarioRequirements, bool ignoreValidator)
        {
            error = null;
            Pawn pawn = (Pawn)ThingMaker.MakeThing(request.KindDef.race, null);

            PawnGenerator.pawnsBeingGenerated.Add(new PawnGenerator.PawnGenerationStatus(pawn, null));
            Pawn result;

            try
            {
                pawn.kindDef = request.KindDef;
                pawn.SetFactionDirect(request.Faction);
                PawnComponentsUtility.CreateInitialComponents(pawn);
                if (request.FixedGender.HasValue)
                {
                    pawn.gender = request.FixedGender.Value;
                }
                else if (pawn.RaceProps.hasGenders)
                {
                    if (Rand.Value < 0.5f)
                    {
                        pawn.gender = Gender.Male;
                    }
                    else
                    {
                        pawn.gender = Gender.Female;
                    }
                }
                else
                {
                    pawn.gender = Gender.None;
                }
                PawnGenerator.GenerateRandomAge(pawn, request);
                pawn.needs.SetInitialLevels();
                if (!request.Newborn && request.CanGeneratePawnRelations)
                {
                    PawnGenerator.GeneratePawnRelations(pawn, ref request);
                }
                if (pawn.RaceProps.Humanlike)
                {
                    FactionDef def;
                    Faction    faction;
                    if (request.Faction != null)
                    {
                        def = request.Faction.def;
                    }
                    else if (Find.FactionManager.TryGetRandomNonColonyHumanlikeFaction(out faction, false, true, TechLevel.Undefined))
                    {
                        def = faction.def;
                    }
                    else
                    {
                        def = Faction.OfAncients.def;
                    }
                    pawn.story.melanin   = ((!request.FixedMelanin.HasValue) ? PawnSkinColors.RandomMelanin(request.Faction) : request.FixedMelanin.Value);
                    pawn.story.crownType = ((Rand.Value >= 0.5f) ? CrownType.Narrow : CrownType.Average);
                    pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, pawn.ageTracker.AgeBiologicalYears);
                    PawnBioAndNameGenerator.GiveAppropriateBioAndNameTo(pawn, request.FixedLastName, def);
                    pawn.story.hairDef = PawnHairChooser.RandomHairDefFor(pawn, def);
                    PawnGenerator.GenerateTraits(pawn, request);
                    PawnGenerator.GenerateBodyType(pawn);
                    PawnGenerator.GenerateSkills(pawn);
                }
                if (pawn.RaceProps.Animal && request.Faction != null && request.Faction.IsPlayer)
                {
                    pawn.training.SetWantedRecursive(TrainableDefOf.Tameness, true);
                    pawn.training.Train(TrainableDefOf.Tameness, null, true);
                }
                PawnGenerator.GenerateInitialHediffs(pawn, request);
                if (pawn.workSettings != null && request.Faction != null && request.Faction.IsPlayer)
                {
                    pawn.workSettings.EnableAndInitialize();
                }
                if (request.Faction != null && pawn.RaceProps.Animal)
                {
                    pawn.GenerateNecessaryName();
                }
                if (Find.Scenario != null)
                {
                    Find.Scenario.Notify_NewPawnGenerating(pawn, request.Context);
                }
                if (!request.AllowDead && (pawn.Dead || pawn.Destroyed))
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated dead pawn.";
                    result = null;
                }
                else if (!request.AllowDowned && pawn.Downed)
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated downed pawn.";
                    result = null;
                }
                else if (request.MustBeCapableOfViolence && ((pawn.story != null && pawn.story.WorkTagIsDisabled(WorkTags.Violent)) || (pawn.RaceProps.ToolUser && !pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation))))
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated pawn incapable of violence.";
                    result = null;
                }
                else if (!ignoreScenarioRequirements && request.Context == PawnGenerationContext.PlayerStarter && Find.Scenario != null && !Find.Scenario.AllowPlayerStartingPawn(pawn, false, request))
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated pawn doesn't meet scenario requirements.";
                    result = null;
                }
                else if (!ignoreValidator && request.ValidatorPreGear != null && !request.ValidatorPreGear(pawn))
                {
                    PawnGenerator.DiscardGeneratedPawn(pawn);
                    error  = "Generated pawn didn't pass validator check (pre-gear).";
                    result = null;
                }
                else
                {
                    if (!request.Newborn)
                    {
                        PawnGenerator.GenerateGearFor(pawn, request);
                    }
                    if (!ignoreValidator && request.ValidatorPostGear != null && !request.ValidatorPostGear(pawn))
                    {
                        PawnGenerator.DiscardGeneratedPawn(pawn);
                        error  = "Generated pawn didn't pass validator check (post-gear).";
                        result = null;
                    }
                    else
                    {
                        for (int i = 0; i < PawnGenerator.pawnsBeingGenerated.Count - 1; i++)
                        {
                            if (PawnGenerator.pawnsBeingGenerated[i].PawnsGeneratedInTheMeantime == null)
                            {
                                PawnGenerator.pawnsBeingGenerated[i] = new PawnGenerator.PawnGenerationStatus(PawnGenerator.pawnsBeingGenerated[i].Pawn, new List <Pawn>());
                            }
                            PawnGenerator.pawnsBeingGenerated[i].PawnsGeneratedInTheMeantime.Add(pawn);
                        }
                        result = pawn;
                    }
                }
            }
            finally
            {
                PawnGenerator.pawnsBeingGenerated.RemoveLast <PawnGenerator.PawnGenerationStatus>();
            }
            return(result);
        }
Ejemplo n.º 14
0
        private static Pawn TryGenerateNewPawnInternal(ref PawnGenerationRequest request, out string error, bool ignoreScenarioRequirements, bool ignoreValidator)
        {
            error = null;
            Pawn pawn = (Pawn)ThingMaker.MakeThing(request.KindDef.race);

            pawnsBeingGenerated.Add(new PawnGenerationStatus(pawn, null));
            try
            {
                pawn.kindDef = request.KindDef;
                pawn.SetFactionDirect(request.Faction);
                PawnComponentsUtility.CreateInitialComponents(pawn);
                if (request.FixedGender.HasValue)
                {
                    pawn.gender = request.FixedGender.Value;
                }
                else if (pawn.RaceProps.hasGenders)
                {
                    if (Rand.Value < 0.5f)
                    {
                        pawn.gender = Gender.Male;
                    }
                    else
                    {
                        pawn.gender = Gender.Female;
                    }
                }
                else
                {
                    pawn.gender = Gender.None;
                }
                GenerateRandomAge(pawn, request);
                pawn.needs.SetInitialLevels();
                if (!request.Newborn && request.CanGeneratePawnRelations)
                {
                    GeneratePawnRelations(pawn, ref request);
                }
                if (pawn.RaceProps.Humanlike)
                {
                    Faction    faction;
                    FactionDef factionType = ((request.Faction != null) ? request.Faction.def : ((!Find.FactionManager.TryGetRandomNonColonyHumanlikeFaction_NewTemp(out faction, tryMedievalOrBetter: false, allowDefeated: true)) ? Faction.OfAncients.def : faction.def));
                    pawn.story.melanin   = (request.FixedMelanin.HasValue ? request.FixedMelanin.Value : PawnSkinColors.RandomMelanin(request.Faction));
                    pawn.story.crownType = ((Rand.Value < 0.5f) ? CrownType.Average : CrownType.Narrow);
                    pawn.story.hairColor = PawnHairColors.RandomHairColor(pawn.story.SkinColor, pawn.ageTracker.AgeBiologicalYears);
                    PawnBioAndNameGenerator.GiveAppropriateBioAndNameTo(pawn, request.FixedLastName, factionType);
                    if (pawn.story != null)
                    {
                        if (request.FixedBirthName != null)
                        {
                            pawn.story.birthLastName = request.FixedBirthName;
                        }
                        else if (pawn.Name is NameTriple)
                        {
                            pawn.story.birthLastName = ((NameTriple)pawn.Name).Last;
                        }
                    }
                    pawn.story.hairDef = PawnHairChooser.RandomHairDefFor(pawn, factionType);
                    GenerateTraits(pawn, request);
                    GenerateBodyType_NewTemp(pawn, request);
                    GenerateSkills(pawn);
                }
                if (pawn.RaceProps.Animal && request.Faction != null && request.Faction.IsPlayer)
                {
                    pawn.training.SetWantedRecursive(TrainableDefOf.Tameness, checkOn: true);
                    pawn.training.Train(TrainableDefOf.Tameness, null, complete: true);
                }
                GenerateInitialHediffs(pawn, request);
                if (!request.ForbidAnyTitle)
                {
                    RoyalTitleDef royalTitleDef = request.FixedTitle;
                    if (royalTitleDef == null)
                    {
                        if (request.KindDef.titleRequired != null)
                        {
                            royalTitleDef = request.KindDef.titleRequired;
                        }
                        else if (!request.KindDef.titleSelectOne.NullOrEmpty() && Rand.Chance(request.KindDef.royalTitleChance))
                        {
                            royalTitleDef = request.KindDef.titleSelectOne.RandomElementByWeight((RoyalTitleDef t) => t.commonality);
                        }
                    }
                    if (request.KindDef.minTitleRequired != null && (royalTitleDef == null || royalTitleDef.seniority < request.KindDef.minTitleRequired.seniority))
                    {
                        royalTitleDef = request.KindDef.minTitleRequired;
                    }
                    if (royalTitleDef != null)
                    {
                        Faction faction2 = ((request.Faction != null && request.Faction.def.HasRoyalTitles) ? request.Faction : Find.FactionManager.RandomRoyalFaction());
                        pawn.royalty.SetTitle(faction2, royalTitleDef, grantRewards: false);
                        if (request.Faction != null && !request.Faction.IsPlayer)
                        {
                            PurchasePermits(pawn, faction2);
                        }
                        int amount = 0;
                        if (royalTitleDef.GetNextTitle(faction2) != null)
                        {
                            amount = Rand.Range(0, royalTitleDef.GetNextTitle(faction2).favorCost - 1);
                        }
                        pawn.royalty.SetFavor_NewTemp(faction2, amount);
                        if (royalTitleDef.maxPsylinkLevel > 0)
                        {
                            Hediff_ImplantWithLevel hediff_ImplantWithLevel = HediffMaker.MakeHediff(HediffDefOf.PsychicAmplifier, pawn, pawn.health.hediffSet.GetBrain()) as Hediff_ImplantWithLevel;
                            pawn.health.AddHediff(hediff_ImplantWithLevel);
                            hediff_ImplantWithLevel.SetLevelTo(royalTitleDef.maxPsylinkLevel);
                        }
                    }
                }
                if (pawn.royalty != null)
                {
                    pawn.royalty.allowRoomRequirements    = request.KindDef.allowRoyalRoomRequirements;
                    pawn.royalty.allowApparelRequirements = request.KindDef.allowRoyalApparelRequirements;
                }
                if (pawn.workSettings != null && request.Faction != null && request.Faction.IsPlayer)
                {
                    pawn.workSettings.EnableAndInitialize();
                }
                if (request.Faction != null && pawn.RaceProps.Animal)
                {
                    pawn.GenerateNecessaryName();
                }
                if (Find.Scenario != null)
                {
                    Find.Scenario.Notify_NewPawnGenerating(pawn, request.Context);
                }
                if (!request.AllowDead && (pawn.Dead || pawn.Destroyed))
                {
                    DiscardGeneratedPawn(pawn);
                    error = "Generated dead pawn.";
                    return(null);
                }
                if (!request.AllowDowned && pawn.Downed)
                {
                    DiscardGeneratedPawn(pawn);
                    error = "Generated downed pawn.";
                    return(null);
                }
                if (request.MustBeCapableOfViolence && ((pawn.story != null && pawn.WorkTagIsDisabled(WorkTags.Violent)) || (pawn.RaceProps.ToolUser && !pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation))))
                {
                    DiscardGeneratedPawn(pawn);
                    error = "Generated pawn incapable of violence.";
                    return(null);
                }
                if (request.KindDef != null && !request.KindDef.skills.NullOrEmpty())
                {
                    List <SkillRange> skills = request.KindDef.skills;
                    for (int i = 0; i < skills.Count; i++)
                    {
                        if (pawn.skills.GetSkill(skills[i].Skill).TotallyDisabled)
                        {
                            error = "Generated pawn incapable of required skill: " + skills[i].Skill.defName;
                            return(null);
                        }
                    }
                }
                if (request.KindDef.requiredWorkTags != 0 && (pawn.CombinedDisabledWorkTags & request.KindDef.requiredWorkTags) != 0)
                {
                    DiscardGeneratedPawn(pawn);
                    error = "Generated pawn with disabled requiredWorkTags.";
                    return(null);
                }
                if (!ignoreScenarioRequirements && request.Context == PawnGenerationContext.PlayerStarter && Find.Scenario != null && !Find.Scenario.AllowPlayerStartingPawn(pawn, tryingToRedress: false, request))
                {
                    DiscardGeneratedPawn(pawn);
                    error = "Generated pawn doesn't meet scenario requirements.";
                    return(null);
                }
                if (!ignoreValidator && request.ValidatorPreGear != null && !request.ValidatorPreGear(pawn))
                {
                    DiscardGeneratedPawn(pawn);
                    error = "Generated pawn didn't pass validator check (pre-gear).";
                    return(null);
                }
                if (!request.Newborn)
                {
                    GenerateGearFor(pawn, request);
                }
                if (!ignoreValidator && request.ValidatorPostGear != null && !request.ValidatorPostGear(pawn))
                {
                    DiscardGeneratedPawn(pawn);
                    error = "Generated pawn didn't pass validator check (post-gear).";
                    return(null);
                }
                for (int j = 0; j < pawnsBeingGenerated.Count - 1; j++)
                {
                    if (pawnsBeingGenerated[j].PawnsGeneratedInTheMeantime == null)
                    {
                        pawnsBeingGenerated[j] = new PawnGenerationStatus(pawnsBeingGenerated[j].Pawn, new List <Pawn>());
                    }
                    pawnsBeingGenerated[j].PawnsGeneratedInTheMeantime.Add(pawn);
                }
                return(pawn);
            }
            finally
            {
                pawnsBeingGenerated.RemoveLast();
            }
        }
Ejemplo n.º 15
0
        public static Pawn Copy(Pawn sourcePawn, PawnKindDef kindDef, Faction faction, bool forceBodyVisual = false, bool forceApparel = false, bool forceWeapon = false)
        {
            Pawn pawn = (Pawn)ThingMaker.MakeThing(kindDef.race, null);

            pawn.kindDef = kindDef;
            pawn.SetFactionDirect(faction);
            pawn.pather     = new Pawn_PathFollower(pawn);
            pawn.ageTracker = new Pawn_AgeTracker(pawn);
            pawn.health     = new Pawn_HealthTracker(pawn);
            pawn.jobs       = new Pawn_JobTracker(pawn);
            pawn.mindState  = new Pawn_MindState(pawn);
            pawn.filth      = new Pawn_FilthTracker(pawn);
            pawn.needs      = new Pawn_NeedsTracker(pawn);
            pawn.stances    = new Pawn_StanceTracker(pawn);
            pawn.InitUnsavedUniversalComponents();

            if (pawn.RaceProps.ToolUser)
            {
                pawn.equipment = new Pawn_EquipmentTracker(pawn);
                pawn.carrier   = new Pawn_CarryTracker(pawn);
                pawn.apparel   = new Pawn_ApparelTracker(pawn);
                pawn.inventory = new Pawn_InventoryTracker(pawn);
            }
            if (pawn.RaceProps.Humanlike)
            {
                pawn.ownership    = new Pawn_Ownership(pawn);
                pawn.skills       = new Pawn_SkillTracker(pawn);
                pawn.talker       = new Pawn_TalkTracker(pawn);
                pawn.story        = new Pawn_StoryTracker(pawn);
                pawn.workSettings = new Pawn_WorkSettings(pawn);
            }
            if (pawn.RaceProps.intelligence <= Intelligence.ToolUser)
            {
                pawn.caller = new Pawn_CallTracker(pawn);
            }
            PawnUtility.AddAndRemoveComponentsAsAppropriate(pawn);
            if (pawn.RaceProps.hasGenders)
            {
                if ((sourcePawn != null) &&
                    (sourcePawn.RaceProps.hasGenders) &&
                    (sourcePawn.gender != Gender.None))
                {
                    pawn.gender = sourcePawn.gender;
                }
                else
                {
                    if (Rand.Value < 0.5f)
                    {
                        pawn.gender = Gender.Male;
                    }
                    else
                    {
                        pawn.gender = Gender.Female;
                    }
                }
            }
            else
            {
                pawn.gender = Gender.None;
            }

            AbilityEffect_Revive.GenerateRandomAge_Coping(pawn, sourcePawn);
            AbilityEffect_Revive.GenerateInitialHediffs_Coping(pawn, sourcePawn);
            if (pawn.RaceProps.Humanlike)
            {
                if ((sourcePawn != null) &&
                    (forceBodyVisual))
                {
                    pawn.story.skinColor       = sourcePawn.story.skinColor;
                    pawn.story.crownType       = sourcePawn.story.crownType;
                    pawn.story.headGraphicPath = sourcePawn.story.headGraphicPath;
                    pawn.story.hairColor       = sourcePawn.story.hairColor;

                    AbilityEffect_Revive.GiveAppropriateBioTo_Coping(pawn, sourcePawn);
                    pawn.story.hairDef = sourcePawn.story.hairDef;
                    AbilityEffect_Revive.GiveRandomTraitsTo_Coping(pawn, sourcePawn);
                    pawn.story.GenerateSkillsFromBackstory();
                }
                else
                {
                    pawn.story.skinColor       = PawnSkinColors.RandomSkinColor();
                    pawn.story.crownType       = ((Rand.Value >= 0.5f) ? CrownType.Narrow : CrownType.Average);
                    pawn.story.headGraphicPath = GraphicDatabaseHeadRecords.GetHeadRandom(pawn.gender, pawn.story.skinColor, pawn.story.crownType).GraphicPath;
                    pawn.story.hairColor       = PawnHairColors.RandomHairColor(pawn.story.skinColor, pawn.ageTracker.AgeBiologicalYears);

                    PawnBioGenerator.GiveAppropriateBioTo(pawn, faction.def);
                    pawn.story.hairDef = PawnHairChooser.RandomHairDefFor(pawn, faction.def);
                    AbilityEffect_Revive.GiveRandomTraitsTo(pawn);
                    pawn.story.GenerateSkillsFromBackstory();
                }
            }

            AbilityEffect_Revive.GenerateStartingApparelFor_Coping(pawn, sourcePawn, forceApparel);
            AbilityEffect_Revive.TryGenerateWeaponFor_Coping(pawn, sourcePawn, forceWeapon);
            AbilityEffect_Revive.GenerateInventoryFor_Coping(pawn, sourcePawn);
            PawnUtility.AddAndRemoveComponentsAsAppropriate(pawn);
            return(pawn);
        }