Esempio n. 1
0
        private static void BeardRoulette(
            [NotNull] Pawn pawn,
            FactionDef factionType,
            out BeardDef mainBeard,
            out MoustacheDef moustache)
        {
            moustache = MoustacheDefOf.Shaved;
            IEnumerable <BeardDef> source;

            {
                source = from beard in DefDatabase <BeardDef> .AllDefs

                         // where !beard.forbiddenOnRace.Contains(pawn.def)
                         where beard.hairTags.SharesElementWith(factionType.hairTags)
                         select beard;
            }

            if (!source.Any())
            {
                source = from beard in DefDatabase <BeardDef> .AllDefs select beard;
            }

            BeardDef chosenBeard;
            float    rand = Rand.Value;
            bool     flag = false;

            if (pawn.ageTracker.AgeBiologicalYearsFloat < 19)
            {
                chosenBeard = BeardDefOf.Beard_Shaved;
                flag        = true;
            }
            else if (rand < 0.1f)
            {
                chosenBeard = BeardDefOf.Beard_Shaved;
            }
            else if (rand < 0.2f)
            {
                chosenBeard = BeardDefOf.Beard_Stubble;
            }
            else
            {
                chosenBeard = source.RandomElementByWeight(beard => BeardChoiceLikelihoodFor(beard, pawn));
            }

            mainBeard = chosenBeard;
            if (!flag && mainBeard.beardType != BeardType.FullBeard)
            {
                moustache = MoustacheRoulette(pawn, factionType);
            }
        }
Esempio n. 2
0
        public static void RandomBeardDefFor(
            [NotNull] CompFace face,
            [NotNull] FactionDef factionType,
            [NotNull] out BeardDef mainBeard,
            [NotNull] out MoustacheDef moustache)
        {
            if (!face.Props.hasBeard)
            {
                mainBeard = BeardDefOf.Beard_Shaved;
                moustache = MoustacheDefOf.Shaved;
                return;
            }

            BeardRoulette(face.Pawn, factionType, out mainBeard, out moustache);
        }
Esempio n. 3
0
        private static float BeardChoiceLikelihoodFor([NotNull] BeardDef beard, Pawn pawn)
        {
            if (beard.hairTags.Contains("MaleOld") && pawn.ageTracker.AgeBiologicalYears < 32)
            {
                return(30f);
            }

            switch (beard.hairGender)
            {
            case HairGender.Male: return(70f);

            case HairGender.MaleUsually: return(50f);
            }

            Log.Error(string.Concat("Unknown beard likelihood for ", beard, " with ", pawn));
            return(0f);
        }
        static HarmonyPatchesFS()
        {
            HarmonyLib.Harmony harmony = new HarmonyLib.Harmony("rimworld.facialstuff.mod");
            // HarmonyLib.Harmony.DEBUG = true;
            harmony.PatchAll(Assembly.GetExecutingAssembly());


            harmony.Patch(
                AccessTools.Method(typeof(Page_ConfigureStartingPawns), "DrawPortraitArea"),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(AddFaceEditButton)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnGraphicSet), nameof(PawnGraphicSet.ResolveAllGraphics)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(ResolveAllGraphics_Postfix)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnGraphicSet), nameof(PawnGraphicSet.ResolveApparelGraphics)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(ResolveApparelGraphics_Postfix)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnRenderer), nameof(PawnRenderer.DrawEquipmentAiming)),
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(DrawEquipmentAiming_Prefix)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS),
                                  nameof(DrawEquipmentAiming_Transpiler)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnRenderer), nameof(PawnRenderer.RenderPawnAt),
                                   new[] { typeof(Vector3), typeof(RotDrawMode), typeof(bool), typeof(bool) }),

                // new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(HarmonyPatchesFS.RenderPawnAt)),
                null,
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(RenderPawnAt_Transpiler))
                );

            harmony.Patch(
                AccessTools.Method(typeof(HediffSet), nameof(HediffSet.DirtyCache)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(DirtyCache_Postfix)));

            harmony.Patch(
                AccessTools.Method(typeof(GraphicDatabaseHeadRecords),
                                   nameof(GraphicDatabaseHeadRecords.Reset)),
                null,
                new HarmonyMethod(
                    typeof(GraphicDatabaseHeadRecordsModded),
                    nameof(GraphicDatabaseHeadRecordsModded.Reset)));

            harmony.Patch(
                AccessTools.Method(typeof(PawnHairChooser), nameof(PawnHairChooser.RandomHairDefFor)),
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(RandomHairDefFor_PreFix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors), "GetSkinDataIndexOfMelanin"),
                new HarmonyMethod(
                    typeof(PawnSkinColors_FS),
                    nameof(PawnSkinColors_FS.GetSkinDataIndexOfMelanin_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors), nameof(PawnSkinColors.GetSkinColor)),
                new HarmonyMethod(typeof(PawnSkinColors_FS), nameof(PawnSkinColors_FS.GetSkinColor_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors), nameof(PawnSkinColors.RandomMelanin)),
                new HarmonyMethod(typeof(PawnSkinColors_FS), nameof(PawnSkinColors_FS.RandomMelanin_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(PawnSkinColors),
                                   nameof(PawnSkinColors.GetMelaninCommonalityFactor)),
                new HarmonyMethod(
                    typeof(PawnSkinColors_FS),
                    nameof(PawnSkinColors_FS.GetMelaninCommonalityFactor_Prefix)),
                null);

            harmony.Patch(
                AccessTools.Method(typeof(Pawn_InteractionsTracker),
                                   nameof(Pawn_InteractionsTracker.TryInteractWith)),
                null,
                new HarmonyMethod(typeof(HarmonyPatchesFS), nameof(TryInteractWith_Postfix)));


            Log.Message(
                "Facial Stuff successfully completed " + harmony.GetPatchedMethods().Count()
                + " patches with harmony.");

            foreach (ThingDef def in DefDatabase <ThingDef> .AllDefsListForReading.Where(
                         td => td.category ==
                         ThingCategory.Pawn &&
                         td.race.Humanlike))
            {
                if (def.inspectorTabs == null || def.inspectorTabs.Count == 0)
                {
                    def.inspectorTabs         = new List <Type>();
                    def.inspectorTabsResolved = new List <InspectTabBase>();
                }

                if (def.inspectorTabs.Contains(typeof(ITab_Pawn_Weapons)))
                {
                    return;
                }

                def.inspectorTabs.Add(typeof(ITab_Pawn_Weapons));
                def.inspectorTabsResolved.Add(InspectTabManager.GetSharedInstance(typeof(ITab_Pawn_Weapons)));

                def.inspectorTabs.Add(typeof(ITab_Pawn_Face));
                def.inspectorTabsResolved.Add(InspectTabManager.GetSharedInstance(typeof(ITab_Pawn_Face)));
            }

            List <HairDef> beardyHairList =
                DefDatabase <HairDef> .AllDefsListForReading.Where(x => x.IsBeardNotHair()).ToList();

            for (int i = 0; i < beardyHairList.Count(); i++)
            {
                HairDef beardy = beardyHairList[i];
                if (beardy.label.Contains("shaven"))
                {
                    continue;
                }
                BeardDef beardDef = new BeardDef
                {
                    defName    = beardy.defName,
                    label      = "_VHE_" + beardy.label,
                    hairGender = beardy.hairGender,
                    texPath    = beardy.texPath.Replace("Things/Pawn/Humanlike/Beards/", ""),
                    hairTags   = beardy.hairTags,
                    beardType  = BeardType.FullBeard
                };
                if (beardDef.label.Contains("stubble") || beardDef.label.Contains("goatee") || beardDef.label.Contains("lincoln"))
                {
                    beardDef.drawMouth = true;
                }
                DefDatabase <BeardDef> .Add(beardDef);
            }
            Dialog_FaceStyling.FullBeardDefs = DefDatabase <BeardDef> .AllDefsListForReading.Where(x => x.beardType == BeardType.FullBeard)
                                               .ToList();

            Dialog_FaceStyling.LowerBeardDefs = DefDatabase <BeardDef> .AllDefsListForReading.Where(x => x.beardType != BeardType.FullBeard)
                                                .ToList();

            Dialog_FaceStyling.MoustacheDefs = DefDatabase <MoustacheDef> .AllDefsListForReading;

            CheckAllInjected();
        }