Beispiel #1
0
        public static BlueprintFeatureSelection CreateEmotionDrawbacks()
        {
            //string[]  = new string[] { };
            string[] EmotionGuids = new string[200];
            //EmotionGuids = guids;
            string baseguid = "CB54279F30DA4802833F";
            int    x        = 0;

            for (long i = 542922691494; i < 542922691644; i++)
            {
                EmotionGuids[x] = baseguid + i.ToString();
                x++;
            }
            //int rnd = DateTime.Now.Millisecond%4;

            var noFeature        = Helpers.PrerequisiteNoFeature(null);
            var EmotionDrawbacks = Helpers.CreateFeatureSelection("EmotionDrawback", RES.EmotionDrawbackName_info,
                                                                  RES.EmotionDrawbackDescription_info,
                                                                  EmotionGuids[0], null, FeatureGroup.None, noFeature);

            noFeature.Feature = EmotionDrawbacks;

            var choices = new List <BlueprintFeature>
            {
                Helpers.CreateFeature("AnxiousDrawback", RES.AnxiousDrawbackName_info,
                                      RES.AnxiousDrawbackDescription_info,
                                      EmotionGuids[1],
                                      Helpers.NiceIcons(16), // great fortitude
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty)),

                //var tieflingHeritageDemodand = library.Get<BlueprintFeature>("a53d760a364cd90429e16aa1e7048d0a");
                Helpers.CreateFeature("AttachedDrawback", RES.AttachedDrawbackName_info,
                                      RES.AttachedDrawbackDescription_info,
                                      EmotionGuids[2],
                                      Helpers.GetIcon("2483a523984f44944a7cf157b21bf79c"), // Elven Immunities
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SaveWill, -1, ModifierDescriptor.Penalty),
                                      Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fear; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })),


                Helpers.CreateFeature("BetrayedDrawback", RES.BetrayedDrawbackName_info,
                                      RES.BetrayedDrawbackDescription_info,
                                      EmotionGuids[3],
                                      Helpers.NiceIcons(2), // Accomplished Sneak Attacker
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.CheckDiplomacy, -3, ModifierDescriptor.Penalty)),


                Helpers.CreateFeature("BitterDrawback", RES.BitterDrawbackName_info,
                                      RES.BitterDrawbackDescription_info,
                                      EmotionGuids[4],
                                      Helpers.NiceIcons(5), // great fortitude
                                      FeatureGroup.None,
                                      Helpers.Create <FeyFoundlingLogic>(s => { s.dieModefier = 0; s.flatModefier = -1; })),

                Helpers.CreateFeature("CondescendingDrawback", RES.CondescendingDrawbackName_info,
                                      RES.CondescendingDrawbackDescription_info,
                                      EmotionGuids[5],
                                      Helpers.NiceIcons(10), // enchantment
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.CheckDiplomacy, -5, ModifierDescriptor.Penalty),
                                      Helpers.CreateAddStatBonus(StatType.CheckIntimidate, -5, ModifierDescriptor.Penalty)),

                //Effect Your base speed when frightened and fleeing increases by 5 feet, and the penalties you take from having the cowering, frightened, panicked, or shaken conditions increase by 1.If you would normally be immune to fear, you do not take these penalties but instead lose your immunity to fear(regardless of its source).
                Helpers.CreateFeature("CowardlyDrawback", RES.CowardlyDrawbackName_info,
                                      RES.CowardlyDrawbackDescription_info,
                                      EmotionGuids[6],
                                      Helpers.NiceIcons(6), //invisiblilty
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SaveFortitude, -2, ModifierDescriptor.Penalty),
                                      Helpers.CreateAddStatBonus(StatType.Speed, 5, ModifierDescriptor.FearPenalty),
                                      Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fear; s.Value = -4; s.ModifierDescriptor = ModifierDescriptor.Penalty; })),

                Helpers.CreateFeature("CrueltyDrawback", RES.CrueltyDrawbackName_info,
                                      RES.CrueltyDrawbackDescription_info,
                                      EmotionGuids[7],
                                      Helpers.NiceIcons(9), // breakbone
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.BaseAttackBonus, -2, ModifierDescriptor.Penalty),
                                      DamageBonusAgainstFlankedTarget.Create(4)),

                Helpers.CreateFeature("EmptyMaskDrawback", RES.EmptyMaskDrawbackName_info,
                                      RES.EmptyMaskDrawbackDescription_info,
                                      EmotionGuids[8],
                                      Helpers.NiceIcons(14), // mask
                                      FeatureGroup.None,
                                                             //Helpers.CreateAddStatBonus(StatType.SaveWill, -1, ModifierDescriptor.Penalty),
                                      Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Compulsion; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; }))
            };

            var debuff = Helpers.CreateBuff("EnvyDeBuff", RES.EnvyDrawbackName_info,
                                            RES.EnvyDebuffDescription_info,
                                            EmotionGuids[9],
                                            Helpers.NiceIcons(1), null,
                                            Helpers.Create <ConcentrationBonus>(a => { a.Value = -2; a.CheckFact = true; }));

            choices.Add(Helpers.CreateFeature("EnvyDrawback", RES.EnvyDrawbackName_info,
                                              RES.EnvyDrawbackDescription_info,
                                              EmotionGuids[10],
                                              Helpers.NiceIcons(1),                //grab
                                              FeatureGroup.None,
                                              CovetousCurseLogic.Create(debuff))); //
            //
            //int rnd = DateTime.Now.Millisecond % 64;
            var Fraud = Helpers.CreateFeatureSelection("GuiltyFraudDrawback", RES.GuiltyFraudDrawbackName_info,
                                                       RES.GuiltyFraudDrawbackDescription_info,
                                                       EmotionGuids[11],
                                                       Helpers.NiceIcons(999), // great fortitude
                                                       FeatureGroup.None,
                                                                               //WeaponCategory.LightRepeatingCrossbow
                                                       Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty));

            //var weap = WeaponCategory.Dart;
            var hoi = new List <BlueprintFeature>()
            {
            };

            x = 11;//x is just a cheat value we use to ged guids
            //foreach (WeaponCategory weap in (WeaponCategory[])Enum.GetValues(typeof(WeaponCategory)))
            var Onehandedweapons = new Dictionary <WeaponCategory, String> {
                { WeaponCategory.Club, RES.WeaponCategoryClubName_info },
                { WeaponCategory.Dagger, RES.WeaponCategoryDaggerName_info },
                { WeaponCategory.Dart, RES.WeaponCategoryDartName_info },
                { WeaponCategory.DuelingSword, RES.WeaponCategoryDuelingSwordName_info },
                { WeaponCategory.ElvenCurvedBlade, RES.WeaponCategoryElvenCurveBladeName_info },
                { WeaponCategory.Falcata, RES.WeaponCategoryFalcataName_info },
                { WeaponCategory.Flail, RES.WeaponCategoryFlailName_info },
                { WeaponCategory.Handaxe, RES.WeaponCategoryHandaxeName_info },
                { WeaponCategory.HeavyMace, RES.WeaponCategoryHeavyMaceName_info },
                { WeaponCategory.Javelin, RES.WeaponCategoryJavelinName_info },
                { WeaponCategory.LightMace, RES.WeaponCategoryLightMaceName_info },
                { WeaponCategory.Shuriken, RES.WeaponCategoryShurikenName_info },
                { WeaponCategory.Sickle, RES.WeaponCategorySickleName_info },
                { WeaponCategory.Sling, RES.WeaponCategorySlingName_info },
                { WeaponCategory.Kama, RES.WeaponCategoryKamaName_info },
                { WeaponCategory.Kukri, RES.WeaponCategoryKukriName_info },
                { WeaponCategory.Starknife, RES.WeaponCategoryStarknifeName_info },
                { WeaponCategory.ThrowingAxe, RES.WeaponCategoryThrowingAxeName_info },
                { WeaponCategory.LightPick, RES.WeaponCategoryLightPickName_info },
                { WeaponCategory.DwarvenWaraxe, RES.WeaponCategoryDwarvenWaraxeName_info },
                { WeaponCategory.Trident, RES.WeaponCategoryTridentName_info },
                { WeaponCategory.BastardSword, RES.WeaponCategoryBastardSwordName_info },
                { WeaponCategory.Battleaxe, RES.WeaponCategoryBattleaxeName_info },
                { WeaponCategory.Longsword, RES.WeaponCategoryLongswordName_info },
                { WeaponCategory.Nunchaku, RES.WeaponCategoryNunchakuName_info },
                { WeaponCategory.Rapier, RES.WeaponCategoryRapierName_info },
                { WeaponCategory.Estoc, RES.WeaponCategoryEstocName_info },
                { WeaponCategory.Sai, RES.WeaponCategorySaiName_info },
                { WeaponCategory.Scimitar, RES.WeaponCategoryScimitarName_info },
                { WeaponCategory.Shortsword, RES.WeaponCategoryShortswordName_info },
                { WeaponCategory.Warhammer, RES.WeaponCategoryWarhammerName_info },
                { WeaponCategory.LightHammer, RES.WeaponCategoryLightHammerName_info },
                { WeaponCategory.WeaponLightShield, RES.WeaponCategoryLightShieldName_info },
                { WeaponCategory.WeaponHeavyShield, RES.WeaponCategoryHeavyShieldName_info },
            };

            foreach (KeyValuePair <WeaponCategory, String> weap in Onehandedweapons)
            {
                x++;
                hoi.Add(Helpers.CreateFeature(
                            $"Greedy{weap.Key}Drawback",
                            string.Format(RES.GuiltyFraudDrawbackWeaponFeat_info, weap.Value),
                            string.Format(RES.GuiltyFraudDrawbackWeaponDescription_info, weap.Value),
                            EmotionGuids[x],
                            Helpers.NiceIcons(999), FeatureGroup.None,
                            Helpers.Create <AddStartingEquipment>(a =>
                {
                    a.CategoryItems     = new WeaponCategory[] { weap.Key, weap.Key };
                    a.RestrictedByClass = Array.Empty <BlueprintCharacterClass>();
                    a.BasicItems        = Array.Empty <BlueprintItem>();
                })));

                //Log.Write(x.ToString());
            }
            //Log.Write(x.ToString());

            x++;
            choices.Add(Helpers.CreateFeature("HauntedDrawback", RES.HauntedDrawbackName_info,
                                              RES.HauntedDrawbackDescription_info,
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(39), // fatigue
                                              FeatureGroup.None,
                                                                     //Helpers.CreateAddStatBonus(StatType.SaveWill, -1, ModifierDescriptor.Penalty),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Evil; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            x++;
            choices.Add(Helpers.CreateFeature("HauntedRegretDrawback", RES.HauntedRegretDrawbackName_info,
                                              RES.HauntedRegretDrawbackDescription_info,
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(7),//fatigue//
                                              FeatureGroup.None,
                                              Helpers.Create <ConcentrationBonus>(a => a.Value = -2),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.MindAffecting; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            x++;
            choices.Add(Helpers.CreateFeature("ImpatientDrawback", RES.ImpatientDrawbackName_info,
                                              RES.ImpatientDrawbackDescription_info,
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(33), //rush
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.BaseAttackBonus, -1, ModifierDescriptor.Penalty),
                                              Helpers.CreateAddStatBonus(StatType.Initiative, 1, ModifierDescriptor.Insight),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Evil; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            x++;
            choices.Add(Helpers.CreateFeature("DaydreamerDrawback", RES.DaydreamerDrawbackName_info,
                                              RES.DaydreamerDrawbackDescription_info,
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(6), //rush
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.Initiative, -1, ModifierDescriptor.Penalty),
                                              Helpers.CreateAddStatBonus(StatType.SkillPerception, -2, ModifierDescriptor.Penalty)));

            x++;
            choices.Add(Helpers.CreateFeature("ShadowDrawback", RES.ShadowDrawbackName_info,
                                              RES.ShadowDrawbackDescription_info,
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(6), //rush
                                              FeatureGroup.None,
                                              Helpers.Create <ShadowSensitivity>()));
            x++;
            var debuff2 = Helpers.CreateBuff("ShadowDeBuff", RES.ShadowDrawbackName_info,
                                             RES.ShadowDeBuffDescription_info,
                                             EmotionGuids[x],
                                             Helpers.NiceIcons(22), null);
            var components = new List <BlueprintComponent> {
            };

            components.AddRange((new SpellSchool[]
            {
                SpellSchool.Abjuration,
                SpellSchool.Conjuration,
                SpellSchool.Divination,
                SpellSchool.Enchantment,
                SpellSchool.Evocation,
                SpellSchool.Illusion,
                SpellSchool.Necromancy,
                SpellSchool.Transmutation,
                SpellSchool.Universalist
            }).Select((school) => Helpers.Create <SavingThrowBonusAgainstSchool>(a =>
            {
                a.School             = school;
                a.Value              = -1;
                a.ModifierDescriptor = ModifierDescriptor.Penalty;
            })));
            debuff2.AddComponents(components);
            ShadowSensitivity.ShadowBuff = debuff2;

            x++;
            choices.Add(Helpers.CreateFeature("SleepyDrawback", RES.SleepyDrawbackName_info,
                                              RES.SleepyDrawbackDescription_info,
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(7),
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.Bonus = -2; s.SpellDescriptor = SpellDescriptor.Sleep; })));

            x++;
            choices.Add(Helpers.CreateFeature("ZealousDrawback", RES.ZealousDrawbackName_info,
                                              RES.ZealousDrawbackDescription_info,
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(48),
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.AdditionalAttackBonus, -5, ModifierDescriptor.Sacred),
                                              Helpers.CreateAddStatBonus(StatType.AdditionalDamage, 2, ModifierDescriptor.Trait)
                                              ));

            Fraud.SetFeatures(hoi);
            choices.Add(Fraud);

            choices.Add(UndoSelection.Feature.Value);
            EmotionDrawbacks.SetFeatures(choices);
            return(EmotionDrawbacks);
        }
Beispiel #2
0
        public static BlueprintFeatureSelection CreatePhysiqueDrawbacks()
        {
            string[] PhysiqueGuids = new string[100];
            string   baseguid      = "CB54279F30DA4802833F";
            int      x             = 0;

            for (long i = 432922691494; i < 432922691544; i++)
            {
                PhysiqueGuids[x] = baseguid + i.ToString();
                x++;
            }

            var noFeature         = Helpers.PrerequisiteNoFeature(null);
            var PhysiqueDrawbacks = Helpers.CreateFeatureSelection("PhysiqueDrawback", "Physique Drawback",
                                                                   "Physique Drawbacks puts the focus on bodily cripling aspects of your character’s background.",
                                                                   PhysiqueGuids[0], null, FeatureGroup.None, noFeature);

            noFeature.Feature = PhysiqueDrawbacks;
            var components = new List <BlueprintComponent> {
            };

            //components.Add(Helpers.Create<ArmorClassBonusAgainstAlignment>(s => { s.alignment= AlignmentComponent.Neutral; s.Value = -2; s.Descriptor = ModifierDescriptor.FearPenalty; }));
            components.Add(Helpers.Create <ACBonusAgainstWeaponCategory>(w => { w.Category = WeaponCategory.Bite; w.ArmorClassBonus = -2; w.Descriptor = ModifierDescriptor.Penalty; }));
            components.Add(Helpers.Create <ACBonusAgainstWeaponCategory>(w => { w.Category = WeaponCategory.Claw; w.ArmorClassBonus = -2; w.Descriptor = ModifierDescriptor.Penalty; }));
            components.AddRange((new String[] {
                // Animal companions
                "f6f1cdcc404f10c4493dc1e51208fd6f", "afb817d80b843cc4fa7b12289e6ebe3d",
                "f9ef7717531f5914a9b6ecacfad63f46", "f894e003d31461f48a02f5caec4e3359",
                "e992949eba096644784592dc7f51a5c7", "aa92fea676be33d4dafd176d699d7996",
                "2ee2ba60850dd064e8b98bf5c2c946ba", "6adc3aab7cde56b40aa189a797254271",
                "ece6bde3dfc76ba4791376428e70621a", "126712ef923ab204983d6f107629c895",
                "67a9dc42b15d0954ca4689b13e8dedea",                // Familiars
                "1cb0b559ca2e31e4d9dc65de012fa82f", "791d888c3f87da042a0a4d0f5c43641c",
                "1bbca102706408b4cb97281c984be5d5", "f111037444d5b6243bbbeb7fc9056ed3",
                "7ba93e2b888a3bd4ba5795ae001049f8", "97dff21a036e80948b07097ad3df2b30",
                "952f342f26e2a27468a7826da426f3e7", "61aeb92c176193e48b0c9c50294ab290",
                "5551dd90b1480e84a9caf4c5fd5adf65", "adf124729a6e01f4aaf746abbed9901d",
                "4d48365690ea9a746a74d19c31562788", "689b16790354c4c4c9b0f671f68d85fc",
                "3c0b706c526e0654b8af90ded235a089",
            }).Select(id => Helpers.Create <AddStatBonusIfHasFact>(a =>
            {
                a.Stat        = StatType.AC;
                a.Value       = -2;
                a.Descriptor  = ModifierDescriptor.Penalty;
                a.CheckedFact = Traits.library.Get <BlueprintFeature>(id);
            })));

            var choices = new List <BlueprintFeature>();

            choices.Add(Helpers.CreateFeature("NatureWardDrawback", "Warded Against Nature",
                                              "You look scary, Animals see you as a predator and do not willingly approach within 30 feet of you." +
                                              "\nBenefit: Chance of wild animals not engaging you is greater." +                                                           //not actualy implemented but great for rp and you have an entire party
                                              "\nDrawback: You take a -2 penalty on AC against animal bites and claw attack, and for each animal you have you lose 2 AC.", //implemented
                                              PhysiqueGuids[1],
                                              Helpers.GetIcon("1670990255e4fe948a863bafd5dbda5d"),                                                                         // Boon Companion
                                              FeatureGroup.None,
                                              components.ToArray()));



            var burningHands = Traits.library.Get <BlueprintAbility>("4783c3709a74a794dbe7c8e7e0b1b038");


            choices.Add(Helpers.CreateFeature("BurnedDrawback", "Burned",
                                              "You were badly burned once by volcanic ash, torch-wielding mobs, or some fiery accident, and the scars pain you terribly you whenever you are too near to fire." +
                                              "\nDrawback: You take a –2 penalty on saves against fire effects.",
                                              PhysiqueGuids[2],
                                              burningHands.Icon,
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fire; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));


            //var burningHands = Traits.library.Get<BlueprintAbility>("4783c3709a74a794dbe7c8e7e0b1b038");
            choices.Add(Helpers.CreateFeature("EntomophobeDrawback", "Entomophobe",
                                              "A harrowing experience with insects when you were young instilled in you a deep-seated fear of vermin of all description, especially when they swarm together." +
                                              "\nDrawback: You take a –2 penalty on attacks against vermin, and you take a –2 penalty on saving throws against the nauseated condition of a swarm’s distraction ability.",
                                              PhysiqueGuids[3],
                                              Helpers.NiceIcons(8),//spider web//
                                              FeatureGroup.None,
                                              Helpers.Create <SwarmAoeVulnerability>(),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Poison; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));


            //Family Ties is a little silly

            choices.Add(Helpers.CreateFeature("OrphanDrawback", "Family Died",
                                              "Your family is extremely important to you, and you feel disheartened becouse they died." +
                                              "\nDrawback: You take a -2 penalty on Will saves.",
                                              PhysiqueGuids[4],
                                              Helpers.NiceIcons(7), // Accomplished Sneak Attacker
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.SaveWill, -2, ModifierDescriptor.Penalty)));


            choices.Add(Helpers.CreateFeature("FeyTakenDrawback", "Fey-taken",
                                              "As a child, you were whisked away by mischievous fey for a time. When you returned, you were ever after considered odd and distant. You long to return there, and find the mortal world dull and at times revolting, so you do not eat as you should and do not question strange visions." +
                                              "\nDrawback: You take a –2 penalty on saving throws against disease, illusions, and poison of all kinds, as well as against the spells, spell-like abilities, and supernatural abilities of fey.",
                                              PhysiqueGuids[5],
                                              Helpers.GetIcon("2483a523984f44944a7cf157b21bf79c"), // Elven Immunities
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Poison; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstSchool>(a => { a.School = SpellSchool.Illusion; a.Value = -2; a.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Disease; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            //Foul Brand
            //As a child, you were whisked away by mischievous fey for a time. When you returned, you were ever after considered odd and distant. You long to return there, and find the mortal world dull and at times revolting, so you do not eat as you should and do not question strange visions.
            var FoulBrand = Helpers.CreateFeatureSelection("FoulBrandDrawback", "Foul Brand",
                                                           "You have the symbol of an evil deity burned into your flesh. The place where the symbol is decides what the penalty is.",
                                                           PhysiqueGuids[6],
                                                           burningHands.Icon,
                                                           FeatureGroup.None);


            var BrandedFeatures = new List <BlueprintFeature>()
            {
                Helpers.CreateFeature("LegDrawback", "Leg",
                                      "The symbol is on your leg." +
                                      "\nDrawback: Your movement speed is 5ft slower.",
                                      PhysiqueGuids[7],
                                      Helpers.NiceIcons(5), // Accomplished Sneak Attacker
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.Speed, -5, ModifierDescriptor.Penalty))
                ,
                Helpers.CreateFeature("FaceDrawback", "Face",
                                      "The symbol is on your face." +
                                      "\nDrawback: You take a -2 penalty on Persuasion.",
                                      PhysiqueGuids[8],
                                      Helpers.NiceIcons(3), // fear
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty))
                ,
                Helpers.CreateFeature("HandsDrawback", "Hands",
                                      "The symbol is on your hands." +
                                      "\nDrawback: You take a -2 penalty on Trickery.",
                                      PhysiqueGuids[9],
                                      Helpers.NiceIcons(13), // Accomplished Sneak Attacker
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SkillThievery, -2, ModifierDescriptor.Penalty))
            };


            FoulBrand.SetFeatures(BrandedFeatures);
            choices.Add(FoulBrand);

            var Hedonisticdebuff = Helpers.CreateBuff("HedonisticDeBuff", "HedonisticDebuff",
                                                      "You have feel like you are fatigued.",
                                                      PhysiqueGuids[10],
                                                      Helpers.NiceIcons(7), null,
                                                      Helpers.CreateAddStatBonus(StatType.Strength, -2, ModifierDescriptor.Penalty),
                                                      Helpers.CreateAddStatBonus(StatType.Dexterity, -2, ModifierDescriptor.Penalty));

            choices.Add(Helpers.CreateFeature("HedonisticDrawback", "Hedonistic",
                                              "You are a creature of pleasure and comfort." +
                                              "\nDrawback: You take a -2 penalty on Strength and Dexterity if you do not possess at least 100 + 200 per level gold.",
                                              PhysiqueGuids[11],
                                              Helpers.NiceIcons(10), // needs sloth icon
                                              FeatureGroup.None,
                                              CovetousCurseLogic.Create(Hedonisticdebuff)));

            choices.Add(Helpers.CreateFeature("HelplessDrawback", "Helpless",
                                              "You once stood helpless as great harm befell a loved one, and that paralysis sometimes returns when an ally is in a dire position." +
                                              "\nDrawback: You take a -2 penalty on saving throws vs paralysis and petrification.",
                                              PhysiqueGuids[12],
                                              Helpers.NiceIcons(3),//spider web//
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Paralysis; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Petrified; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            var UndeadImmunities = Traits.library.Get <BlueprintFeature>("8a75eb16bfff86949a4ddcb3dd2f83ae");
            var UndeadType       = Traits.library.Get <BlueprintFeature>("734a29b693e9ec346ba2951b27987e33");
            var Undeadcurse      = Traits.library.CopyAndAdd <BlueprintFeature>(
                UndeadType.AssetGuid,
                "UndeadCurseDrawback",
                PhysiqueGuids[13]);

            //UndeadImmunities.SetDescription("undead immunitys");
            //Sprite frailsprite = Image2Sprite.Create("images_sprites/frail.png");
            //Urgathoa
            var UrgathoaFeature      = Traits.library.Get <BlueprintFeature>("812f6c07148088e41a9ac94b56ac2fc8");
            var SpellFocus           = Traits.library.Get <BlueprintFeature>("16fa59cc9a72a6043b566b49184f53fe");
            var SpellFocusNecromancy = Traits.library.Get <BlueprintFeature>("8791da25011fd1844ad61a3fea6ece54");
            //var AsmodeusFeature = Traits.library.Get<BlueprintFeature>("a3a5ccc9c670e6f4ca4a686d23b89900");

            //Zon - Kuthon.aae911217c5105244bbfddca6a58d77c
            //NorgorberFeature.805b6bdc8c96f4749afc687a003f9628
            //8791da25011fd1844ad61a3fea6ece54


            var CurseOptions = Helpers.CreateFeatureSelection("CurseOptions", "You Were Cursed[HB]",
                                                              "You were cursed. Select a Curse.",
                                                              PhysiqueGuids[14],
                                                              Helpers.NiceIcons(10),
                                                              FeatureGroup.None);
            //Undeadcurse.SetName("you were cursed to be an undead");

            var ElementalWeaknesListFeature = (new DamageEnergyType[] {
                DamageEnergyType.Fire,
                DamageEnergyType.Holy,
                DamageEnergyType.Divine,
            }).Select((element) =>
                      Helpers.Create <AddEnergyVulnerability>(a => { a.Type = element; }));



            var RangedWeaponsDebuff = (new WeaponCategory[] {
                WeaponCategory.LightCrossbow,
                WeaponCategory.HeavyCrossbow,
                WeaponCategory.Javelin,
                WeaponCategory.KineticBlast,
                WeaponCategory.Longbow,
                WeaponCategory.Shortbow,
                WeaponCategory.Ray,
                WeaponCategory.Dart,
                WeaponCategory.Shuriken,
                WeaponCategory.ThrowingAxe,
            }).Select((WeapCat) =>
                      Helpers.Create <WeaponCategoryAttackBonus>(a => { a.Category = WeapCat; a.AttackBonus = -2; }));

            var RangedWeaponsBuff = (new WeaponCategory[] {
                WeaponCategory.LightCrossbow,
                WeaponCategory.HeavyCrossbow,
                WeaponCategory.Javelin,
                WeaponCategory.KineticBlast,
                WeaponCategory.Longbow,
                WeaponCategory.Shortbow,
                WeaponCategory.Ray,
                WeaponCategory.Dart,
                WeaponCategory.Shuriken,
                WeaponCategory.ThrowingAxe,
            }).Select((WeapCat) =>
                      Helpers.Create <WeaponCategoryAttackBonus>(a => { a.Category = WeapCat; a.AttackBonus = 1; }));



            UndeadType.SetNameDescriptionIcon("Undead Curse", "This creature is Changed by Urgothoa to be an undead.\nCreature is vulnerable to Fire,Holy And divine attacks.", Helpers.NiceIcons(44));
            Undeadcurse.SetNameDescriptionIcon("Undead Curse(inccorrect version)", "This version just changes con and cha the new version also changes necrotic and healing to function correctly this version still exists for save compatibility and its not a big deal.", Helpers.NiceIcons(44));
            //Undeadcurse.AddComponent(Helpers.PrerequisiteFeature(UrgathoaFeature));
            var lijstjelief = new List <BlueprintFeature> {
                SpellFocus, SpellFocusNecromancy, UrgathoaFeature
            };

            UndeadType.AddComponent(Helpers.PrerequisiteFeaturesFromList(lijstjelief, any: false));
            UndeadType.AddComponents(ElementalWeaknesListFeature);

            //Undeadcurse.SetFeatures(new List<BlueprintFeature> { UndeadImmunities});
            //Undeadcurse.SetNameDescription("","You where cursed to be an undead");
            foreach (BlueprintComponent bob in UndeadImmunities.GetComponents <BlueprintComponent>())
            {
                Undeadcurse.AddComponent(bob);
            }

            var FrogPolymorphBuff = Traits.library.Get <BlueprintBuff>("662aa00fd6242e643b60ac8336ff39e6");

            var CurseFeatures = new List <BlueprintFeature>()
            {
                //UndeadImmunities,
                //Undeadcurse,
                UndeadType,

                /*
                 * Helpers.CreateFeature("LycantropyDrawback", "Lycantropy",
                 * "lycantropy.description" +
                 * "\nDrawback:???",
                 * PhysiqueGuids[15],
                 * Helpers.NiceIcons(3), // fear
                 * FeatureGroup.None,
                 * Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty))
                 * ,*/
                Helpers.CreateFeature("PolymorphDrawback", "Witch's Curse",
                                      "You were cursed by a witch to become a frog. You did not like this and you killed the witch." +
                                      "The curse is almost broken, but if you are in a moment of weakness, you transform back into a frog." +
                                      "Drawback: If you attack someone when you are below 40 % health, you are transformed into a frog for 2 rounds.",
                                      PhysiqueGuids[16],
                                      Helpers.NiceIcons(45),
                                      FeatureGroup.None,
                                      Helpers.Create <BuffIfHealth>(a =>
                {
                    a.Descriptor      = ModifierDescriptor.Penalty;
                    a.Value           = -2;
                    a.HitPointPercent = 0.5f;
                }))
            };

            CurseOptions.SetFeatures(CurseFeatures);
            choices.Add(CurseOptions);



            choices.Add(Helpers.CreateFeature("AsthmaticDrawback", "Asthmatic",
                                              "Asthma, because out of all the things you could be bad at... you suck at breathing." +
                                              "\nDrawback: You suffer a -2 penalty against any effect that will cause you to be fatigued or exhausted, and any effect with cloud, dust, fog, or smoke in its name. You hold your breath for only half the normal duration. Additionally, sleeping in light or heavier armor fatigues you.",
                                              PhysiqueGuids[17],
                                              Helpers.NiceIcons(7),
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fatigue; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Bomb; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            var Badvision = Helpers.CreateFeatureSelection("BadvisionDrawback", "Bad Vision",
                                                           "You cannot see as well as others." +
                                                           "\nDrawback: You take a –1 penalty on Perception checks. and you gain an other penalty depending on the type of bad vision you have. select from the options",
                                                           PhysiqueGuids[18],
                                                           Helpers.NiceIcons(46),
                                                           FeatureGroup.None,
                                                           Helpers.CreateAddStatBonus(StatType.SkillPerception, -1, ModifierDescriptor.Crippled));

            var BadvisionFeatures = new List <BlueprintFeature>()
            {
                Helpers.CreateFeature("BadvisionDrawbackNear", "Nearsighted",
                                      "You cannot see well far in the distance." +
                                      "\nDrawback: All ranged attacks you make suffer an -2 penalty.",
                                      PhysiqueGuids[19],
                                      Helpers.NiceIcons(46),
                                      FeatureGroup.None
                                      )
                ,
                Helpers.CreateFeature("BadvisionDrawbackFar", "Farsighted",
                                      "You cannot see well close to you." +
                                      "\nDrawback:Bane: All melee attacks you make suffer a -1 attack penalty.",
                                      PhysiqueGuids[20],
                                      Helpers.NiceIcons(46),
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.AdditionalAttackBonus, -1, ModifierDescriptor.Penalty))
                ,
                Helpers.CreateFeature("BadvisionDrawbackBookwurm", "Bookworm[hb]",
                                      "You have spent way to much time reading up close with bad light and it ruined your eyesight. you can however fill in the blanks in your vision by recognizing paterns you have learned from books." +
                                      "\nBenefit: You use your inteligence modefier instead of wisdom on perception checks" +
                                      "\nDrawback: You take an additional -1 on perception checks.",
                                      PhysiqueGuids[21],
                                      Helpers.NiceIcons(46),
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SkillPerception, -1, ModifierDescriptor.Penalty),
                                      Helpers.Create <ReplaceBaseStatForStatTypeLogic>(v =>
                {
                    v.StatTypeToReplaceBastStatFor = StatType.SkillPerception;
                    v.NewBaseStatType = StatType.Intelligence;
                }))
            };

            BadvisionFeatures[0].AddComponents(RangedWeaponsDebuff);
            BadvisionFeatures[1].AddComponents(RangedWeaponsBuff);

            Badvision.SetFeatures(BadvisionFeatures);
            choices.Add(Badvision);



            choices.Add(Helpers.CreateFeature("MisbegottenDrawback", "Misbegotten",
                                              "Whether due to the influence of malign magic, disease, or the scorn of the gods, you were born with a troublesome deformity that interferes with your movement." +
                                              "\nDrawback: You take a –2 penalty on all Dexterity-based skill checks.",
                                              PhysiqueGuids[22],
                                              Helpers.NiceIcons(29),
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.SkillStealth, -2, ModifierDescriptor.Crippled),
                                              Helpers.CreateAddStatBonus(StatType.SkillMobility, -2, ModifierDescriptor.Crippled),
                                              Helpers.CreateAddStatBonus(StatType.SkillThievery, -2, ModifierDescriptor.Crippled)));


            //choices.Add(
            //var CultistsVillage_Cultists = Traits.library.Get<BlueprintFaction>("0dd3f77814cc7bf4e9cfb1c96f2a4b4e");
            var LamashtusCurse = Traits.library.Get <BlueprintFeature>("ef3c653365c4a0a46b0d43a44f930186");
            var Occult         = Helpers.CreateFeature("OccultBargainDrawback", "Occult Bargain",
                                                       "You draw magical power from a source who insists that its identity remains secret." +
                                                       "\nDrawback: You take a –1 penalty on concentration checks. and you have - 2 on saves and ac vs people that worship lamashtus",
                                                       PhysiqueGuids[23],
                                                       Helpers.NiceIcons(47),
                                                       FeatureGroup.None,
                                                       Helpers.Create <ConcentrationBonus>(a => { a.Value = -1; a.CheckFact = true; }),
                                                       Helpers.Create <ACBonusAgainstFactOwner>(t => { t.CheckedFact = LamashtusCurse; t.Bonus = -2; }));

            //occult.pre
            choices.Add(Occult);

            var feyfeature = Traits.library.Get <BlueprintFeature>("018af8005220ac94a9a4f47b3e9c2b4e");//FeyType.

            choices.Add(Helpers.CreateFeature("SpookedDrawback", "Spooked",
                                              "You had a traumatic experience with a spirit at a young age that colors your reactions to such creatures even to this day." +
                                              "\nDrawback: You take a –4 penalty on attackrolls vs fey creatures. and a -2 on rolls vs fear",
                                              PhysiqueGuids[24],
                                              Helpers.NiceIcons(39),
                                              FeatureGroup.None,
                                              Helpers.Create <AttackBonusAgainstFactOwner>(a => { a.Bonus = -4; a.CheckedFact = feyfeature; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(f => { f.Bonus = -2; f.SpellDescriptor = SpellDescriptor.Fear; })));

            /*
             * foreach (var choice in choices)
             * {
             *  Log.Write(choice.Name);
             *  Log.Write(choice.Description);
             * }*/


            PhysiqueDrawbacks.SetFeatures(choices);
            return(PhysiqueDrawbacks);
        }
        public static BlueprintFeatureSelection CreateEmotionDrawbacks()
        {
            //string[]  = new string[] { };
            string[] EmotionGuids = new string[200];
            //EmotionGuids = guids;
            string baseguid = "CB54279F30DA4802833F";
            int    x        = 0;

            for (long i = 542922691494; i < 542922691644; i++)
            {
                EmotionGuids[x] = baseguid + i.ToString();
                x++;
            }
            //int rnd = DateTime.Now.Millisecond%4;

            var noFeature        = Helpers.PrerequisiteNoFeature(null);
            var EmotionDrawbacks = Helpers.CreateFeatureSelection("EmotionDrawback", "Emotion Drawback",
                                                                  "Emotion Drawbacks put the focus on mental aspects of your character’s background.",
                                                                  EmotionGuids[0], null, FeatureGroup.None, noFeature);

            noFeature.Feature = EmotionDrawbacks;

            var choices = new List <BlueprintFeature>();

            choices.Add(Helpers.CreateFeature("AnxiousDrawback", "Anxious",
                                              "After suffering terribly for not being tight-lipped enough as a child, such as when you accidentally exposed your family to enemy inquisitors, you developed a habit of being overly cautious with your words." +
                                              "\nDrawback: You take a –2 penalty on Persuasion checks and must speak slowly due to the concentration required. Unless stated otherwise, you are assumed to not be speaking at a volume above a whisper.",
                                              EmotionGuids[1],
                                              Helpers.NiceIcons(16), // great fortitude
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty)));

            //var tieflingHeritageDemodand = library.Get<BlueprintFeature>("a53d760a364cd90429e16aa1e7048d0a");
            choices.Add(Helpers.CreateFeature("AttachedDrawback", "Attached",
                                              "You are attached to yourself. Whenever the object of your attachment is either threatened, in danger, or in someone else’s possession, you take a –1 penalty on Will saves and a –2 penalty on saves against fear effects." +
                                              "\nDrawback: You take a –1 penalty on Will saves and a –2 penalty on saves against fear effects.",
                                              EmotionGuids[2],
                                              Helpers.GetIcon("2483a523984f44944a7cf157b21bf79c"), // Elven Immunities
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.SaveWill, -1, ModifierDescriptor.Penalty),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fear; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));


            choices.Add(Helpers.CreateFeature("BetrayedDrawback", "Betrayed",
                                              "You can roll twice and take the lower result on Sense Motive checks to get hunches. You cannot reroll this result, even if you have another ability that would normally allow you to do so." +
                                              "\nDrawback: You take a -3 penalty on Diplomacy checks.",
                                              EmotionGuids[3],
                                              Helpers.NiceIcons(2), // Accomplished Sneak Attacker
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.CheckDiplomacy, -3, ModifierDescriptor.Penalty)));


            choices.Add(Helpers.CreateFeature("BitterDrawback", "Bitter",
                                              "You have been hurt repeatedly by those you trusted, and it has become difficult for you to accept help." +
                                              "\nDrawback: When you receive healing from an ally’s class feature, spell, or spell-like ability, reduce the amount of that healing by 1 hit point.",
                                              EmotionGuids[4],
                                              Helpers.NiceIcons(5), // great fortitude
                                              FeatureGroup.None,
                                              Helpers.Create <FeyFoundlingLogic>(s => { s.dieModefier = 0; s.flatModefier = -1; })));

            choices.Add(Helpers.CreateFeature("CondescendingDrawback", "Condescending",
                                              "Raised with the assurance that only those like you are truly worthy of respect, you have an off-putting way of demonstrating that you look down on those not of your race and ethnicity or nationality." +
                                              "\nDrawback: You take a –5 penalty on Diplomacy and Intimidate checks.",
                                              EmotionGuids[5],
                                              Helpers.NiceIcons(10), // enchantment
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.CheckDiplomacy, -5, ModifierDescriptor.Penalty),
                                              Helpers.CreateAddStatBonus(StatType.CheckIntimidate, -5, ModifierDescriptor.Penalty)));

            //Effect Your base speed when frightened and fleeing increases by 5 feet, and the penalties you take from having the cowering, frightened, panicked, or shaken conditions increase by 1.If you would normally be immune to fear, you do not take these penalties but instead lose your immunity to fear(regardless of its source).
            choices.Add(Helpers.CreateFeature("CowardlyDrawback", "Cowardly",
                                              "You might face dangerous situations with bravado, but you are constantly afraid. And if you see a dead body you might just throw up." +
                                              "\nBenefit: Your movementspeed increases by 5" +
                                              "\nDrawback: You take a –4 penalty on saves against fear effects. And -2 to all Fortitude saves.",
                                              EmotionGuids[6],
                                              Helpers.NiceIcons(6), //invisiblilty
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.SaveFortitude, -2, ModifierDescriptor.Penalty),
                                              Helpers.CreateAddStatBonus(StatType.Speed, 5, ModifierDescriptor.FearPenalty),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fear; s.Value = -4; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            choices.Add(Helpers.CreateFeature("CrueltyDrawback", "Cruelty",
                                              "You were rewarded as a child for flaunting your victory over others as completely as possible, and you discovered you enjoyed the feeling of rubbing your foes’ faces in the dirt." +
                                              "\nBenefit: You have +1 on damage rolls against flanked targets." +
                                              "\nDrawback: You take a –2 penalty on all attack rolls.", // against someone that is not flanked
                                              EmotionGuids[7],
                                              Helpers.NiceIcons(9),                                     // breakbone
                                              FeatureGroup.None,
                                                                                                        //Helpers.CreateAddStatBonus(StatType.BaseAttackBonus, -2, ModifierDescriptor.Penalty),
                                              Helpers.CreateAddStatBonus(StatType.AdditionalAttackBonus, -2, ModifierDescriptor.Trait),
                                              DamageBonusAgainstFlankedTarget.Create(1)));

            choices.Add(Helpers.CreateFeature("EmptyMaskDrawback", "Empty Mask",
                                              "You have spent so long hiding your true identity to escape political enemies that you have lost much of your sense of self." +
                                              "\nDrawback: you take a –1 penalty on Will saves vs compulsion and a –2 vs people that know your identity.",
                                              EmotionGuids[8],
                                              Helpers.NiceIcons(14), // mask
                                              FeatureGroup.None,
                                                                     //Helpers.CreateAddStatBonus(StatType.SaveWill, -1, ModifierDescriptor.Penalty),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Compulsion; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            var debuff = Helpers.CreateBuff("EnvyDeBuff", "Envy",
                                            "You have 2 less on concentration checks.",
                                            EmotionGuids[9],
                                            Helpers.NiceIcons(1), null,
                                            Helpers.Create <ConcentrationBonus>(a => { a.Value = -2; a.CheckFact = true; }));

            choices.Add(Helpers.CreateFeature("EnvyDrawback", "Envy",
                                              "You grew up in or near an opulent, decadent culture that valued nothing more than showing up the material wealth or accomplishments of others, causing the seed of envy to be planted in your heart." +
                                              "\nDrawback: You have 2 less on concentration checks. if you do not posses at least 100 + 200 per level gold.",
                                              EmotionGuids[10],
                                              Helpers.NiceIcons(1),                //grab
                                              FeatureGroup.None,
                                              CovetousCurseLogic.Create(debuff))); //
            //
            //int rnd = DateTime.Now.Millisecond % 64;
            var Fraud = Helpers.CreateFeatureSelection("GuiltyFraudDrawback", "Guilty Fraud",
                                                       "You received something through trickery that you did not deserve, and your guilt for the misdeed distracts you from dangers around you." +
                                                       "\nBenefit: Start the game dual wielding a one handed weapon." +
                                                       "\nDrawback: You take a –2 penalty on Persuasion checks.",
                                                       EmotionGuids[11],
                                                       Helpers.NiceIcons(999), // great fortitude
                                                       FeatureGroup.None,
                                                                               //WeaponCategory.LightRepeatingCrossbow
                                                       Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty));

            //var weap = WeaponCategory.Dart;
            var hoi = new List <BlueprintFeature>()
            {
            };

            x = 11;//x is just a cheat value we use to ged guids
            //foreach (WeaponCategory weap in (WeaponCategory[])Enum.GetValues(typeof(WeaponCategory)))
            var Onehandedweapons = new WeaponCategory[] {
                WeaponCategory.Dagger, WeaponCategory.Dart,
                WeaponCategory.DuelingSword, WeaponCategory.ElvenCurvedBlade,
                WeaponCategory.Flail, WeaponCategory.Greataxe,
                WeaponCategory.Javelin, WeaponCategory.LightMace,
                WeaponCategory.Shuriken, WeaponCategory.Sickle,
                WeaponCategory.Sling, WeaponCategory.Kama,
                WeaponCategory.Kukri, WeaponCategory.Starknife,
                WeaponCategory.ThrowingAxe, WeaponCategory.LightPick,
                WeaponCategory.DwarvenWaraxe, WeaponCategory.Trident,
                WeaponCategory.BastardSword, WeaponCategory.Battleaxe,
                WeaponCategory.Longsword, WeaponCategory.Nunchaku,
                WeaponCategory.Rapier, WeaponCategory.Sai,
                WeaponCategory.Scimitar, WeaponCategory.Shortsword,
                WeaponCategory.Club, WeaponCategory.WeaponLightShield,
                WeaponCategory.WeaponHeavyShield, WeaponCategory.HeavyMace,
                WeaponCategory.LightHammer, WeaponCategory.LightPick,
            };

            foreach (WeaponCategory weap in Onehandedweapons)
            {
                x++;
                hoi.Add(Helpers.CreateFeature(
                            $"Greedy{weap}Drawback",
                            $"your scram reward — {weap}",
                            $"{weap}", EmotionGuids[x]
                            ,
                            Helpers.NiceIcons(999), FeatureGroup.None,
                            Helpers.Create <AddStartingEquipment>(a =>
                {
                    a.CategoryItems     = new WeaponCategory[] { weap, weap };
                    a.RestrictedByClass = Array.Empty <BlueprintCharacterClass>();

                    a.BasicItems = Array.Empty <BlueprintItem>();
                })));

                //Log.Write(x.ToString());
            }
            //Log.Write(x.ToString());
            x++;
            choices.Add(Helpers.CreateFeature("HauntedDrawback", "Haunted",
                                              "Something from your past—or a dark secret you presently hold—makes it difficult for you to ever be at peace, and your chronic worry that you might fall to evil influence has become a self-fulfilling prophecy." +
                                              "\nDrawback: You take a –2 penalty on spells with the evil descriptor.",
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(39), // fatigue
                                              FeatureGroup.None,
                                                                     //Helpers.CreateAddStatBonus(StatType.SaveWill, -1, ModifierDescriptor.Penalty),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Evil; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));
            x++;
            choices.Add(Helpers.CreateFeature("HauntedRegretDrawback", "Haunting Regret",
                                              "When you were young, a relative with whom you had frequently quarreled passed away where his or her soul could not rest. Now, the unquiet spirit appears around you at inconvenient times, distracting you with regret for being unable to help." +
                                              "\nDrawback: You take a –2 penalty on saving throws against the distraction ability of swarms and mind-affecting effects and on concentration checks.",
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(7),//fatigue//
                                              FeatureGroup.None,
                                              Helpers.Create <ConcentrationBonus>(a => a.Value = -2),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.MindAffecting; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));
            x++;
            choices.Add(Helpers.CreateFeature("ImpatientDrawback", "Impatient",
                                              "You love leaping into battle at the earliest opportunity, and it frustrates you to wait for others to act." +
                                              "\nBenefit: You take a +1 Insight bonus on Initiative." +
                                              "\nDrawback: You take a -2 penalty on saves against evil spells, and a -1 penalty to all attack rolls.",
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(33), //rush
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.BaseAttackBonus, -1, ModifierDescriptor.Penalty),
                                              Helpers.CreateAddStatBonus(StatType.Initiative, 1, ModifierDescriptor.Insight),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Evil; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));
            x++;
            choices.Add(Helpers.CreateFeature("DaydreamerDrawback", "Daydreamer",
                                              "You always have your head in the clouds." +
                                              "\nDrawback: You suffer a -1 penalty to initiative checks and a -2 penalty to Perception checks to avoid being surprised.",
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(6), //rush
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.Initiative, -1, ModifierDescriptor.Penalty),
                                              Helpers.CreateAddStatBonus(StatType.SkillPerception, -2, ModifierDescriptor.Penalty)));

            x++;
            choices.Add(Helpers.CreateFeature("ShadowDrawback", "Shadow-Scarred",
                                              "You were touched by terrible horrors that live in the darkness just outside the human sphere and feel your life-force ebb away ever so slightly whenever you return to the shadows." +
                                              "\nDrawback: Whenever you are in an area of dim light or darkness, you take a –1 penalty on saving throws.",
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(6), //rush
                                              FeatureGroup.None,
                                              Helpers.Create <ShadowSensitivity>()));
            x++;
            var debuff2 = Helpers.CreateBuff("ShadowDeBuff", "Shadow-Scarred",
                                             "You have 1 less on saving throws.",
                                             EmotionGuids[x],
                                             Helpers.NiceIcons(22), null);
            var components = new List <BlueprintComponent> {
            };

            components.AddRange((new SpellSchool[]
            {
                SpellSchool.Abjuration,
                SpellSchool.Conjuration,
                SpellSchool.Divination,
                SpellSchool.Enchantment,
                SpellSchool.Evocation,
                SpellSchool.Illusion,
                SpellSchool.Necromancy,
                SpellSchool.Transmutation,
                SpellSchool.Universalist
            }).Select((school) => Helpers.Create <SavingThrowBonusAgainstSchool>(a =>
            {
                a.School             = school;
                a.Value              = -1;
                a.ModifierDescriptor = ModifierDescriptor.Penalty;
            })));
            debuff2.AddComponents(components);
            ShadowSensitivity.ShadowBuff = debuff2;


            x++;
            choices.Add(Helpers.CreateFeature("SleepyDrawback", "Sleepy",
                                              "You must sleep or rest for at least 8 hours each night to get the benefits of a full night’s rest." +
                                              "\nDrawback: You take a –2 penalty on saving throws against sleep effects.",
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(7),
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.Bonus = -2; s.SpellDescriptor = SpellDescriptor.Sleep; })));

            x++;
            choices.Add(Helpers.CreateFeature("ZealousDrawback", "Zealous",
                                              "You are fanatical in your beliefs, ruled by emotion over reason." +
                                              "\nDrawback: When you attack a creature that you know worships a different religion than you do, you take a –5 penalty on the attack roll and a +2 trait bonus on the damage roll.",
                                              EmotionGuids[x],
                                              Helpers.NiceIcons(48),
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.AdditionalAttackBonus, -5, ModifierDescriptor.Sacred),
                                              Helpers.CreateAddStatBonus(StatType.AdditionalDamage, 2, ModifierDescriptor.Sacred)
                                              ));



            Fraud.SetFeatures(hoi);
            choices.Add(Fraud);

            EmotionDrawbacks.SetFeatures(choices);
            return(EmotionDrawbacks);
        }
        public static BlueprintFeatureSelection CreatePhysiqueDrawbacks()
        {
            string[] PhysiqueGuids = new string[100];
            string   baseguid      = "CB54279F30DA4802833F";
            int      x             = 0;

            for (long i = 432922691494; i < 432922691544; i++)
            {
                PhysiqueGuids[x] = baseguid + i.ToString();
                x++;
            }

            var noFeature         = Helpers.PrerequisiteNoFeature(null);
            var PhysiqueDrawbacks = Helpers.CreateFeatureSelection("PhysiqueDrawback", RES.PhysiqueDrawbackName_info,
                                                                   RES.PhysiqueDrawbackDescription_info,
                                                                   PhysiqueGuids[0], null, FeatureGroup.None, noFeature);

            noFeature.Feature = PhysiqueDrawbacks;
            var components = new List <BlueprintComponent> {
            };

            //components.Add(Helpers.Create<ArmorClassBonusAgainstAlignment>(s => { s.alignment= AlignmentComponent.Neutral; s.Value = -2; s.Descriptor = ModifierDescriptor.FearPenalty; }));
            components.Add(Helpers.Create <ACBonusAgainstWeaponCategory>(w => { w.Category = WeaponCategory.Bite; w.ArmorClassBonus = -2; w.Descriptor = ModifierDescriptor.Penalty; }));
            components.Add(Helpers.Create <ACBonusAgainstWeaponCategory>(w => { w.Category = WeaponCategory.Claw; w.ArmorClassBonus = -2; w.Descriptor = ModifierDescriptor.Penalty; }));
            components.AddRange((new String[] {
                // Animal companions
                "f6f1cdcc404f10c4493dc1e51208fd6f", "afb817d80b843cc4fa7b12289e6ebe3d",
                "f9ef7717531f5914a9b6ecacfad63f46", "f894e003d31461f48a02f5caec4e3359",
                "e992949eba096644784592dc7f51a5c7", "aa92fea676be33d4dafd176d699d7996",
                "2ee2ba60850dd064e8b98bf5c2c946ba", "6adc3aab7cde56b40aa189a797254271",
                "ece6bde3dfc76ba4791376428e70621a", "126712ef923ab204983d6f107629c895",
                "67a9dc42b15d0954ca4689b13e8dedea",                // Familiars
                "1cb0b559ca2e31e4d9dc65de012fa82f", "791d888c3f87da042a0a4d0f5c43641c",
                "1bbca102706408b4cb97281c984be5d5", "f111037444d5b6243bbbeb7fc9056ed3",
                "7ba93e2b888a3bd4ba5795ae001049f8", "97dff21a036e80948b07097ad3df2b30",
                "952f342f26e2a27468a7826da426f3e7", "61aeb92c176193e48b0c9c50294ab290",
                "5551dd90b1480e84a9caf4c5fd5adf65", "adf124729a6e01f4aaf746abbed9901d",
                "4d48365690ea9a746a74d19c31562788", "689b16790354c4c4c9b0f671f68d85fc",
                "3c0b706c526e0654b8af90ded235a089",
            }).Select(id => Helpers.Create <AddStatBonusIfHasFact>(a =>
            {
                a.Stat        = StatType.AC;
                a.Value       = -2;
                a.Descriptor  = ModifierDescriptor.Penalty;
                a.CheckedFact = Traits.library.Get <BlueprintFeature>(id);
            })));

            var choices = new List <BlueprintFeature>();

            choices.Add(Helpers.CreateFeature("NatureWardDrawback", RES.NatureWardDrawbackName_info,
                                              RES.NatureWardDrawbackDescription_info,
                                              PhysiqueGuids[1],
                                              Helpers.GetIcon("1670990255e4fe948a863bafd5dbda5d"), // Boon Companion
                                              FeatureGroup.None,
                                              components.ToArray()));

            var burningHands = Traits.library.Get <BlueprintAbility>("4783c3709a74a794dbe7c8e7e0b1b038");

            choices.Add(Helpers.CreateFeature("BurnedDrawback", RES.BurnedDrawbackName_info,
                                              RES.BurnedDrawbackDescription_info,
                                              PhysiqueGuids[2],
                                              burningHands.Icon,
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fire; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            //var burningHands = Traits.library.Get<BlueprintAbility>("4783c3709a74a794dbe7c8e7e0b1b038");
            choices.Add(Helpers.CreateFeature("EntomophobeDrawback", RES.EntomophobeDrawbackName_info,
                                              RES.EntomophobeDrawbackDescription_info,
                                              PhysiqueGuids[3],
                                              Helpers.NiceIcons(8),//spider web//
                                              FeatureGroup.None,
                                              Helpers.Create <SwarmAoeVulnerability>(),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Poison; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            //Family Ties is a little silly
            choices.Add(Helpers.CreateFeature("OrphanDrawback", RES.OrphanDrawbackName_info,
                                              RES.OrphanDrawbackDescription_info,
                                              PhysiqueGuids[4],
                                              Helpers.NiceIcons(7), // Accomplished Sneak Attacker
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.SaveWill, -2, ModifierDescriptor.Penalty)));

            choices.Add(Helpers.CreateFeature("FeyTakenDrawback", RES.Fey_takenDrawbackName_info,
                                              RES.Fey_takenDrawbackDescription_info,
                                              PhysiqueGuids[5],
                                              Helpers.GetIcon("2483a523984f44944a7cf157b21bf79c"), // Elven Immunities
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Poison; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstSchool>(a => { a.School = SpellSchool.Illusion; a.Value = -2; a.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Disease; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            //Foul Brand
            //As a child, you were whisked away by mischievous fey for a time. When you returned, you were ever after considered odd and distant. You long to return there, and find the mortal world dull and at times revolting, so you do not eat as you should and do not question strange visions.
            var FoulBrand = Helpers.CreateFeatureSelection("FoulBrandDrawback", RES.FoulBrandDrawbackName,
                                                           RES.FoulBrandDrawbackDescription_info,
                                                           PhysiqueGuids[6],
                                                           burningHands.Icon,
                                                           FeatureGroup.None);

            var BrandedFeatures = new List <BlueprintFeature>()
            {
                Helpers.CreateFeature("LegDrawback", RES.FoulBrandLegDrawbackName_info,
                                      RES.FoulBrandLegDrawbackDescription_info,
                                      PhysiqueGuids[7],
                                      Helpers.NiceIcons(5), // Accomplished Sneak Attacker
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.Speed, -5, ModifierDescriptor.Penalty))
                ,
                Helpers.CreateFeature("FaceDrawback", RES.FoulBrandFaceDrawbackName_info,
                                      RES.FoulBrandFaceDrawbackDescription_info,
                                      PhysiqueGuids[8],
                                      Helpers.NiceIcons(3), // fear
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty))
                ,
                Helpers.CreateFeature("HandsDrawback", RES.FoulBrandHandsDrawbackName_info,
                                      RES.FoulBrandHandsDrawbackDescription_info,
                                      PhysiqueGuids[9],
                                      Helpers.NiceIcons(13), // Accomplished Sneak Attacker
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SkillThievery, -2, ModifierDescriptor.Penalty))
            };

            FoulBrand.SetFeatures(BrandedFeatures);
            choices.Add(FoulBrand);

            var Hedonisticdebuff = Helpers.CreateBuff("HedonisticDeBuff", RES.HedonisticDebuffName_info,
                                                      RES.HedonisticDebuffDescription_info,
                                                      PhysiqueGuids[10],
                                                      Helpers.NiceIcons(7), null,
                                                      Helpers.CreateAddStatBonus(StatType.Strength, -2, ModifierDescriptor.Penalty),
                                                      Helpers.CreateAddStatBonus(StatType.Dexterity, -2, ModifierDescriptor.Penalty));

            choices.Add(Helpers.CreateFeature("HedonisticDrawback", RES.HedonisticDrawbackName_info,
                                              RES.HedonisticDrawbackDescription_info,
                                              PhysiqueGuids[11],
                                              Helpers.NiceIcons(10), // needs sloth icon
                                              FeatureGroup.None,
                                              CovetousCurseLogic.Create(Hedonisticdebuff)));

            choices.Add(Helpers.CreateFeature("HelplessDrawback", RES.HelplessDrawbackName_info,
                                              RES.HelplessDrawbackDescription_info,
                                              PhysiqueGuids[12],
                                              Helpers.NiceIcons(3),//spider web//
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Paralysis; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Petrified; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            var UndeadImmunities = Traits.library.Get <BlueprintFeature>("8a75eb16bfff86949a4ddcb3dd2f83ae");
            var UndeadType       = Traits.library.Get <BlueprintFeature>("734a29b693e9ec346ba2951b27987e33");
            var Undeadcurse      = Traits.library.CopyAndAdd <BlueprintFeature>(
                UndeadType.AssetGuid,
                "UndeadCurseDrawback",
                PhysiqueGuids[13]);

            //UndeadImmunities.SetDescription("undead immunitys");
            //Sprite frailsprite = Image2Sprite.Create("images_sprites/frail.png");
            //Urgathoa
            var UrgathoaFeature      = Traits.library.Get <BlueprintFeature>("812f6c07148088e41a9ac94b56ac2fc8");
            var SpellFocus           = Traits.library.Get <BlueprintFeature>("16fa59cc9a72a6043b566b49184f53fe");
            var SpellFocusNecromancy = Traits.library.Get <BlueprintFeature>("8791da25011fd1844ad61a3fea6ece54");
            //var AsmodeusFeature = Traits.library.Get<BlueprintFeature>("a3a5ccc9c670e6f4ca4a686d23b89900");

            //Zon - Kuthon.aae911217c5105244bbfddca6a58d77c
            //NorgorberFeature.805b6bdc8c96f4749afc687a003f9628
            //8791da25011fd1844ad61a3fea6ece54


            var CurseOptions = Helpers.CreateFeatureSelection("CurseOptions", RES.CurseDrawbackOptionsName_info,
                                                              RES.CurseDrawbackOptionsDescription_info,
                                                              PhysiqueGuids[14],
                                                              Helpers.NiceIcons(10),
                                                              FeatureGroup.None);
            //Undeadcurse.SetName("you were cursed to be an undead");

            var ElementalWeaknesListFeature = (new DamageEnergyType[] {
                DamageEnergyType.Fire,
                DamageEnergyType.Holy,
                DamageEnergyType.Divine,
            }).Select((element) =>
                      Helpers.Create <AddEnergyVulnerability>(a => { a.Type = element; }));

            var RangedWeaponsDebuff = (new WeaponCategory[] {
                WeaponCategory.LightCrossbow,
                WeaponCategory.HeavyCrossbow,
                WeaponCategory.Javelin,
                WeaponCategory.KineticBlast,
                WeaponCategory.Longbow,
                WeaponCategory.Shortbow,
                WeaponCategory.Ray,
                WeaponCategory.Dart,
                WeaponCategory.Shuriken,
                WeaponCategory.ThrowingAxe,
            }).Select((WeapCat) =>
                      Helpers.Create <WeaponCategoryAttackBonus>(a => { a.Category = WeapCat; a.AttackBonus = -2; }));

            var RangedWeaponsBuff = (new WeaponCategory[] {
                WeaponCategory.LightCrossbow,
                WeaponCategory.HeavyCrossbow,
                WeaponCategory.Javelin,
                WeaponCategory.KineticBlast,
                WeaponCategory.Longbow,
                WeaponCategory.Shortbow,
                WeaponCategory.Ray,
                WeaponCategory.Dart,
                WeaponCategory.Shuriken,
                WeaponCategory.ThrowingAxe,
            }).Select((WeapCat) =>
                      Helpers.Create <WeaponCategoryAttackBonus>(a => { a.Category = WeapCat; a.AttackBonus = 1; }));

            UndeadType.SetNameDescriptionIcon(RES.UndeadCurseDrawbackName_info, RES.UndeadCurseDrawbackDescription_info, Helpers.NiceIcons(44));
            //Undeadcurse.SetNameDescriptionIcon("Undead Curse(inccorrect version)", "This version just changes con and cha the new version also changes necrotic and healing to function correctly this version still exists for save compatibility and its not a big deal.", Helpers.NiceIcons(44));
            //Undeadcurse.AddComponent(Helpers.PrerequisiteFeature(UrgathoaFeature));
            var lijstjelief = new List <BlueprintFeature> {
                SpellFocus, SpellFocusNecromancy, UrgathoaFeature
            };

            UndeadType.AddComponent(Helpers.PrerequisiteFeaturesFromList(lijstjelief, any: false));
            UndeadType.AddComponents(ElementalWeaknesListFeature);
            //Undeadcurse.SetFeatures(new List<BlueprintFeature> { UndeadImmunities});
            //Undeadcurse.SetNameDescription("","You where cursed to be an undead");
            foreach (BlueprintComponent bob in UndeadImmunities.GetComponents <BlueprintComponent>())
            {
                Undeadcurse.AddComponent(bob);
            }

            var FrogPolymorphBuff = Traits.library.Get <BlueprintBuff>("662aa00fd6242e643b60ac8336ff39e6");

            var CurseFeatures = new List <BlueprintFeature>()
            {
                //UndeadImmunities,
                //Undeadcurse,
                UndeadType,

                /*
                 * Helpers.CreateFeature("LycantropyDrawback", "Lycantropy",
                 * "lycantropy.description" +
                 * "\nDrawback:???",
                 * PhysiqueGuids[15],
                 * Helpers.NiceIcons(3), // fear
                 * FeatureGroup.None,
                 * Helpers.CreateAddStatBonus(StatType.SkillPersuasion, -2, ModifierDescriptor.Penalty))
                 * ,*/
                Helpers.CreateFeature("PolymorphDrawback", RES.PolymorphDrawbackName_info,
                                      RES.PolymorphDrawbackDescription_info,
                                      PhysiqueGuids[16],
                                      Helpers.NiceIcons(45),
                                      FeatureGroup.None,
                                      Helpers.Create <BuffIfHealth>(a =>
                {
                    a.Descriptor      = ModifierDescriptor.Penalty;
                    a.Value           = -2;
                    a.HitPointPercent = 0.5f;
                }))
            };

            CurseOptions.SetFeatures(CurseFeatures);
            choices.Add(CurseOptions);

            choices.Add(Helpers.CreateFeature("AsthmaticDrawback", RES.AsthmaticDrawbackName_info,
                                              RES.AsthmaticDrawbackDescription_info,
                                              PhysiqueGuids[17],
                                              Helpers.NiceIcons(7),
                                              FeatureGroup.None,
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Fatigue; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(s => { s.SpellDescriptor = SpellDescriptor.Bomb; s.Value = -2; s.ModifierDescriptor = ModifierDescriptor.Penalty; })));

            var Badvision = Helpers.CreateFeatureSelection("BadvisionDrawback", RES.BadvisionDrawbackName_info,
                                                           RES.BadvisionDrawbackDescription_info,
                                                           PhysiqueGuids[18],
                                                           Helpers.NiceIcons(46),
                                                           FeatureGroup.None,
                                                           Helpers.CreateAddStatBonus(StatType.SkillPerception, -1, ModifierDescriptor.Crippled));

            var BadvisionFeatures = new List <BlueprintFeature>()
            {
                Helpers.CreateFeature("BadvisionDrawbackNear", RES.BadvisionDrawbackNearName_info,
                                      RES.BadvisionDrawbackNearDescription_info,
                                      PhysiqueGuids[19],
                                      Helpers.NiceIcons(46),
                                      FeatureGroup.None
                                      )
                ,
                Helpers.CreateFeature("BadvisionDrawbackFar", RES.BadvisionDrawbackFarName_info,
                                      RES.BadvisionDrawbackFarDescription_info,
                                      PhysiqueGuids[20],
                                      Helpers.NiceIcons(46),
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.AdditionalAttackBonus, -1, ModifierDescriptor.Penalty))
                ,
                Helpers.CreateFeature("BadvisionDrawbackBookworm", RES.BadvisionDrawbackBookwormName_info,
                                      RES.BadvisionDrawbackBookwormDescription_info,
                                      PhysiqueGuids[21],
                                      Helpers.NiceIcons(46),
                                      FeatureGroup.None,
                                      Helpers.CreateAddStatBonus(StatType.SkillPerception, -1, ModifierDescriptor.Penalty),
                                      Helpers.Create <ReplaceBaseStatForStatTypeLogic>(v =>
                {
                    v.StatTypeToReplaceBastStatFor = StatType.SkillPerception;
                    v.NewBaseStatType = StatType.Intelligence;
                }))
            };

            BadvisionFeatures[0].AddComponents(RangedWeaponsDebuff);
            BadvisionFeatures[1].AddComponents(RangedWeaponsBuff);

            Badvision.SetFeatures(BadvisionFeatures);
            choices.Add(Badvision);

            choices.Add(Helpers.CreateFeature("MisbegottenDrawback", RES.MisbegottenDrawbackName_info,
                                              RES.MisbegottenDrawbackDescription_info,
                                              PhysiqueGuids[22],
                                              Helpers.NiceIcons(29),
                                              FeatureGroup.None,
                                              Helpers.CreateAddStatBonus(StatType.SkillStealth, -2, ModifierDescriptor.Crippled),
                                              Helpers.CreateAddStatBonus(StatType.SkillMobility, -2, ModifierDescriptor.Crippled),
                                              Helpers.CreateAddStatBonus(StatType.SkillThievery, -2, ModifierDescriptor.Crippled)));


            //choices.Add(
            //var CultistsVillage_Cultists = Traits.library.Get<BlueprintFaction>("0dd3f77814cc7bf4e9cfb1c96f2a4b4e");
            var LamashtusCurse = Traits.library.Get <BlueprintFeature>("ef3c653365c4a0a46b0d43a44f930186");
            var Occult         = Helpers.CreateFeature("OccultBargainDrawback", RES.OccultBargainDrawbackName_info,
                                                       RES.OccultBargainDrawbackDescription_info,
                                                       PhysiqueGuids[23],
                                                       Helpers.NiceIcons(47),
                                                       FeatureGroup.None,
                                                       Helpers.Create <ConcentrationBonus>(a => { a.Value = -1; a.CheckFact = true; }),
                                                       Helpers.Create <ACBonusAgainstFactOwner>(t => { t.CheckedFact = LamashtusCurse; t.Bonus = -2; }));

            //occult.pre
            choices.Add(Occult);

            var feyfeature = Traits.library.Get <BlueprintFeature>("018af8005220ac94a9a4f47b3e9c2b4e");//FeyType.

            choices.Add(Helpers.CreateFeature("SpookedDrawback", RES.SpookedDrawbackName_info,
                                              RES.SpookedDrawbackDescription_info,
                                              PhysiqueGuids[24],
                                              Helpers.NiceIcons(39),
                                              FeatureGroup.None,
                                              Helpers.Create <AttackBonusAgainstFactOwner>(a => { a.Bonus = -4; a.CheckedFact = feyfeature; }),
                                              Helpers.Create <SavingThrowBonusAgainstDescriptor>(f => { f.Bonus = -2; f.SpellDescriptor = SpellDescriptor.Fear; })));

            choices.Add(UndoSelection.Feature.Value);
            PhysiqueDrawbacks.SetFeatures(choices);
            return(PhysiqueDrawbacks);
        }