static void createFocusedKiller()
        {
            var non_humanoids = new BlueprintUnitFact[] { Common.dragon, Common.elemental, Common.magical_beast, Common.animal, Common.monstrous_humanoid,
                                                          Common.aberration, Common.plant };


            var studied_target_buff = library.Get <BlueprintBuff>("45548967b714e254aa83f23354f174b0");

            focused_killer = Helpers.CreateFeature("FocusedKillerFeature",
                                                   "Focused Killer",
                                                   "At 1st level, an executioner’s studied target bonuses increase by 1 against humanoid opponents, but decrease by 1 against non-humanoid targets.",
                                                   "",
                                                   RogueTalents.bleeding_attack.Icon,
                                                   FeatureGroup.None);

            var focused_killer_action = Helpers.CreateConditional(Common.createContextConditionCasterHasFact(focused_killer),
                                                                  Helpers.CreateConditional(Common.createContextConditionHasFacts(false, non_humanoids),
                                                                                            Helpers.Create <ContextActionChangeSharedValue>(c =>
            {
                c.Type        = SharedValueChangeType.Add;
                c.AddValue    = -1;
                c.SharedValue = AbilitySharedValue.DamageBonus;
            }),
                                                                                            Helpers.Create <ContextActionChangeSharedValue>(c =>
            {
                c.Type        = SharedValueChangeType.Add;
                c.AddValue    = 1;
                c.SharedValue = AbilitySharedValue.DamageBonus;
            })
                                                                                            )
                                                                  );

            studied_target_buff.ReplaceComponent <AddFactContextActions>(a => a.Activated = Helpers.CreateActionList(a.Activated.Actions.AddToArray(focused_killer_action)));
        }
Example #2
0
        public static ContextConditionHasFact CreateContextConditionHasFact(BlueprintUnitFact fact)
        {
            var c = Helpers.Create <ContextConditionHasFact>();

            c.Fact = fact;
            return(c);
        }
Example #3
0
        static private void FixExistingBlueprintFacts()
        {
            FastGetter classes_Getter = Helpers.CreateFieldGetter <ContextRankConfig>("m_Class");
            FastSetter classes_Setter = Helpers.CreateFieldSetter <ContextRankConfig>("m_Class");

            foreach (string factId in config.FactsWithContextRankConfig)
            {
                BlueprintUnitFact fact = library.Get <BlueprintUnitFact>(factId);
                foreach (ContextRankConfig comp in fact.GetComponents <ContextRankConfig>())
                {
                    if (comp.IsBasedOnClassLevel)
                    {
                        BlueprintCharacterClass[] classes = classes_Getter(comp) as BlueprintCharacterClass[];
                        if (classes == null)
                        {
                            throw new Exception($"Error! get null classes for IsBasedOnClassLevel ContextRankConfig named {fact.name}!");
                        }
                        List <BlueprintCharacterClass> classesList = classes.ToList <BlueprintCharacterClass>();
                        if (classesList.Contains(wizard))
                        {
                            classesList.Add(ArcanistClass.arcanist);
                        }
                        classes_Setter(comp, classesList.ToArray());
                    }
                }
            }
        }
        public static CoordinatedShotAttackBonus Create(BlueprintUnitFact coordinatedShotFact, int attackBonus = 1, int additionalFlankBonus = 1)
        {
            var instance = Library.Create <CoordinatedShotAttackBonus>();

            instance.AttackBonus          = attackBonus;
            instance.AdditionalFlankBonus = additionalFlankBonus;
            instance.CoordinatedShotFact  = coordinatedShotFact;
            return(instance);
        }
Example #5
0
        public static AddFactOnBloodlineLevel Create(BlueprintUnitFact feat, string name, int min = 1, int max = 20)
        {
            var a = Helpers.Create <AddFactOnBloodlineLevel>();

            a.name              = $"AddFactOnBloodlineLevel${name}";
            a.Feature           = feat;
            a.MinLevel          = min;
            a.MaxLevelInclusive = max;
            return(a);
        }
Example #6
0
        public static void SetIcon(this BlueprintUnitFact fact, string iconAssetGuid)
        {
            var iconFact = Main.Library?.Get <BlueprintUnitFact>(iconAssetGuid);

            if (iconFact == null)
            {
                Main.Logger?.Error($"SetIcon: asset of type {typeof(BlueprintUnitFact).Name} with guid {iconAssetGuid} not found in library.");
                return;
            }
            fact.SetIcon(iconFact.Icon);
        }
Example #7
0
        internal static void OnEventDidTrigger(OutflankAttackBonus outflankAttackBonusInstance, RuleCalculateAttackBonus evt)
        {
            BlueprintUnitFact outflankFact = outflankAttackBonusInstance.OutflankFact;

            Func <UnitEntityData, UnitEntityData, UnitEntityData, bool> outflankPreconditions =
                (target, owner, flankingPartner) => owner.Descriptor.State.Features.SoloTactics || flankingPartner.Descriptor.HasFact(outflankFact);

            if (evt.Target.IsFlankedByUnit(outflankAttackBonusInstance.Owner.Unit, outflankPreconditions))
            {
                evt.IncreaseFlankingBonusTo(4);
            }
        }
        static bool Prefix(PreciseStrike __instance, RulePrepareDamage evt)
        {
            BlueprintUnitFact preciseStrikeFact = __instance.PreciseStrikeFact;

            Func <UnitEntityData, UnitEntityData, UnitEntityData, bool> hasPreciseStrike =
                (target, owner, flankingPartner) => owner.Descriptor.State.Features.SoloTactics || flankingPartner.Descriptor.HasFact(preciseStrikeFact);

            FlankingParameters flankingParameters = new FlankingParameters(typeof(PreciseStrike_OnEventAboutToTrigger_Patch), __instance.Owner.Unit, hasPreciseStrike);

            UnitCombatState_get_IsFlanked_Patch.PushFlankingParameters(flankingParameters);

            return(true);
        }
Example #9
0
        internal static void giveDifficultTerrainImmunityToAirborneUnits()
        {
            var airborne = library.Get <BlueprintFeature>("70cffb448c132fa409e49156d013b175");

            airborne.AddComponent(Common.createAddConditionImmunity(Kingmaker.UnitLogic.UnitCondition.DifficultTerrain));
            airborne.AddComponent(Common.createBuffDescriptorImmunity(Kingmaker.Blueprints.Classes.Spells.SpellDescriptor.Ground));
            airborne.AddComponent(Common.createSpellImmunityToSpellDescriptor(Kingmaker.Blueprints.Classes.Spells.SpellDescriptor.Ground));
            var air_mastery = library.Get <BlueprintFeature>("be52ced7ae1c7354a8ee12d9bad47805");

            BlueprintUnitFact[] facts = new BlueprintUnitFact[] {
                library.Get <BlueprintBuff>("3689b69a30d6d7c48b90e28228fb7b7c"),                                                  //transmuter air elemental 1
                library.Get <BlueprintBuff>("2b2060036a20108448299f3ee2b14015"),                                                  //transmuter air elemental 2
                library.Get <BlueprintBuff>("2641f73f8d7864f4bba0bd6134018094"),                                                  //polymorph air elemental greater
                library.Get <BlueprintBuff>("933c5cd1113d2ef4a84f55660a744008"),                                                  //polymorph air elemental
                library.Get <BlueprintBuff>("70828d40058f2d3428bb767eb6e3e561"),                                                  //air elemental body 1
                library.Get <BlueprintBuff>("3af4d4bc55fa0ae4e851708d7395f1dd"),                                                  //air elemental body 2
                library.Get <BlueprintBuff>("db00581a03e6947419648dfba6aa03b2"),                                                  //air elemental body 3
                library.Get <BlueprintBuff>("ba06b8cff52da9e4d8432144ed6a6d19"),                                                  //air elemental body 4
                library.Get <BlueprintBuff>("dc1ef6f6d52b9fd49bc0696ab1a4f18b"),                                                  //air wildshape 1
                library.Get <BlueprintBuff>("65fdf187fea97c94b9cf4ff6746901a6"),                                                  //air wildshape 2
                library.Get <BlueprintBuff>("814bc75e74f969641bf110addf076ff9"),                                                  //air wildshape 3
                library.Get <BlueprintBuff>("eb52d24d6f60fc742b32fe943b919180"),                                                  //air wildshape 4
                library.Get <BlueprintBuff>("1a482859d9513e4418f57abcd396d315"),                                                  //wyvern
            };
            for (int i = 0; i < facts.Length; i++)
            {
                facts[i].AddComponent(Helpers.CreateAddFact(airborne));
                if (i < 12)
                {
                    facts[i].AddComponent(Helpers.CreateAddFact(air_mastery));
                }
            }

            var airborne_types = new BlueprintUnitType[] { library.Get <BlueprintUnitType>("b012216cc6867354fb088d0c36968ea3"), //black dragon
                                                           library.Get <BlueprintUnitType>("f52b75839bb928242b6108df9d7f35a2"), //wyvern
                                                           library.Get <BlueprintUnitType>("284b6fd0b67688a4bb3ec28b15152d69"), //ankou
                                                           library.Get <BlueprintUnitType>("a574fa56e67623d41b538bdeae291fd5"), //gargoyle
                                                           library.Get <BlueprintUnitType>("535823c600a2c8f4a906063b7b949eb5")  //jabberwok
            };

            var units = library.GetAllBlueprints().OfType <BlueprintUnit>();

            foreach (var unit in units)
            {
                if (airborne_types.Contains(unit.Type))
                {
                    unit.AddFacts = unit.AddFacts.AddToArray(airborne);
                }
            }
        }
Example #10
0
        private static void RemoveExcessiveLichImmunities()
        {
            //        "Blueprint:efe0344bca1290244a277ed5c45d9ff2:ImmunityToEnergyDrain",
            //"Blueprint:bd9df2d4a4cef274285b8827b6769bde:ImmunityToStun",
            //"Blueprint:c263f44f72df009489409af122b5eefc:ImmunityToSleep",
            //"Blueprint:7e3f3228be49cce49bda37f7901bf246:ImmunityToPoison",
            //            "Blueprint:52f8ef060a751a247964adae7fcb7e64:ImmunityToBleed",
            //            "Blueprint:3eb606c0564d0814ea01a824dbe42fb0:ImmunityToMindAffecting",
            //"Blueprint:ced0f4e5d02d5914a9f9ff74acacf26d:ImmunityToCritical",
            BlueprintUnitFact energyDrainImmunity   = library.Get <BlueprintUnitFact>("efe0344bca1290244a277ed5c45d9ff2");
            BlueprintUnitFact stunImmunity          = library.Get <BlueprintUnitFact>("bd9df2d4a4cef274285b8827b6769bde");
            BlueprintUnitFact sleepImmunity         = library.Get <BlueprintUnitFact>("c263f44f72df009489409af122b5eefc");
            BlueprintUnitFact poisonImmunity        = library.Get <BlueprintUnitFact>("7e3f3228be49cce49bda37f7901bf246");
            BlueprintUnitFact bleedImmunity         = library.Get <BlueprintUnitFact>("52f8ef060a751a247964adae7fcb7e64");
            BlueprintUnitFact mindAffectingImmunity = library.Get <BlueprintUnitFact>("3eb606c0564d0814ea01a824dbe42fb0");
            //BlueprintUnitFact undeadImmunities = library.Get<BlueprintUnitFact>("8a75eb16bfff86949a4ddcb3dd2f83ae");
            BlueprintUnit lich = library.Get <BlueprintUnit>("d58b4a0df3282b84c97b751590053bcf");

            foreach (BlueprintUnitFact buf in lich.AddFacts)
            {
                Main.logger.Log($"lich facts {buf.name}");
            }
            List <BlueprintUnitFact> lichFacts = new List <BlueprintUnitFact>();

            foreach (BlueprintUnitFact buf in lich.AddFacts)
            {
                if (buf != energyDrainImmunity &&
                    buf != stunImmunity &&
                    buf != sleepImmunity &&
                    buf != poisonImmunity &&
                    buf != bleedImmunity &&
                    buf != mindAffectingImmunity)
                {
                    //&& buf != undeadImmunities)
                    lichFacts.Add(buf);
                }
            }
            lich.AddFacts = lichFacts.ToArray();
            //lich.AddFacts.RemoveFromArray(energyDrainImmunity);
            //lich.AddFacts.RemoveFromArray(stunImmunity);
            //lich.AddFacts.RemoveFromArray(sleepImmunity);
            //lich.AddFacts.RemoveFromArray(poisonImmunity);
            //lich.AddFacts.RemoveFromArray(bleedImmunity);
            //lich.AddFacts.RemoveFromArray(mindAffectingImmunity);
            Main.logger.Log($"     lich facts after change");
            foreach (BlueprintUnitFact buf in lich.AddFacts)
            {
                Main.logger.Log($"lich facts {buf.name}");
            }
        }
Example #11
0
 public static bool HasFeatureWithId(this BlueprintUnitFact fact, String id)
 {
     if (fact.AssetGuid == id)
     {
         return(true);
     }
     foreach (var c in fact.ComponentsArray)
     {
         var addFacts = c as AddFacts;
         if (addFacts != null)
         {
             return(addFacts.Facts.Any(f => HasFeatureWithId(f, id)));
         }
     }
     return(false);
 }
            public static void storeSpell(UnitDescriptor unit, BlueprintUnitFact fact, AbilityData spell)
            {
                var store_buff = unit.Buffs.GetFact(fact);

                if (store_buff == null)
                {
                    store_buff = unit.Progression.Features.GetFact(fact);
                }
                if (store_buff != null)
                {
                    var sticky_touch = spell.Blueprint.GetComponent <AbilityEffectStickyTouch>();
                    if (sticky_touch != null)
                    {
                        var touch_spell = new AbilityData(spell, sticky_touch.TouchDeliveryAbility);
                        store_buff.CallComponents <FactStoreSpell>(c => c.storeSpell(touch_spell));
                    }
                    else
                    {
                        store_buff.CallComponents <FactStoreSpell>(c => c.storeSpell(spell));
                    }
                }
            }
            public static AbilityData getSpellStoredInFact(UnitDescriptor unit, BlueprintUnitFact fact)
            {
                if (unit == null || fact == null)
                {
                    return(null);
                }

                var stored_buff = unit.Buffs.GetFact(fact);

                if (stored_buff == null)
                {
                    stored_buff = unit.Progression.Features.GetFact(fact);
                }

                if (stored_buff == null)
                {
                    return(null);
                }
                AbilityData data = null;

                stored_buff.CallComponents <FactStoreSpell>(c => c.getStoredSpell(out data));
                return(data);
            }
        static bool Prefix(CallOfTheWild.TeamworkMechanics.CoordinatedShotAttackBonus __instance, RuleCalculateAttackBonus evt)
        {
            if (evt.Weapon == null)
            {
                return(false);
            }
            if (!evt.Weapon.Blueprint.IsRanged)
            {
                return(false);
            }

            int attack_bonus           = __instance.AttackBonus;
            int additional_flank_bonus = __instance.AdditionalFlankBonus;
            BlueprintUnitFact coordinated_shot_fact = __instance.CoordinatedShotFact;
            UnitDescriptor    owner = __instance.Owner;

            int  bonus        = 0;
            bool solo_tactics = owner.State.Features.SoloTactics;

            foreach (UnitEntityData unitEntityData in evt.Target.CombatState.EngagedBy)
            {
                AttackType attack_type = evt.Weapon == null ? AttackType.Melee : evt.Weapon.Blueprint.AttackType;
                if ((unitEntityData.Descriptor.HasFact(coordinated_shot_fact) || solo_tactics) &&
                    unitEntityData != owner.Unit && unitEntityData.providesCoverToFrom(evt.Target, owner.Unit, attack_type) == Cover.CoverType.None)
                {
                    bonus = Math.Max(bonus, (evt.Target.isFlankedByAttacker(unitEntityData) ? attack_bonus + additional_flank_bonus : attack_bonus));
                }
            }

            if (bonus == 0)
            {
                return(false);
            }

            evt.AddBonus(bonus, __instance.Fact);
            return(false);
        }
Example #15
0
 public static void SetIcon(this BlueprintUnitFact feature, Sprite icon)
 {
     blueprintUnitFact_set_Icon(feature, icon);
 }
Example #16
0
 public static LocalizedString GetDescription(this BlueprintUnitFact fact) => (LocalizedString)blueprintUnitFact_get_Description(fact);
Example #17
0
 public static LocalizedString GetName(this BlueprintUnitFact fact) => (LocalizedString)blueprintUnitFact_get_DisplayName(fact);
Example #18
0
 public static void SetNameDescription(this BlueprintUnitFact feature, BlueprintUnitFact other)
 {
     blueprintUnitFact_set_DisplayName(feature, other.GetName());
     blueprintUnitFact_set_Description(feature, other.GetDescription());
 }
Example #19
0
 public static void SetNameDescription(this BlueprintUnitFact feature, String displayName, String description)
 {
     feature.SetName(Helpers.CreateString(feature.name + ".Name", displayName));
     feature.SetDescription(description);
 }
Example #20
0
        static void fixFlyingCreatures()
        {
            airborne.AddComponent(Common.createAddConditionImmunity(Kingmaker.UnitLogic.UnitCondition.DifficultTerrain));
            airborne.AddComponent(Common.createBuffDescriptorImmunity(Kingmaker.Blueprints.Classes.Spells.SpellDescriptor.Ground));
            airborne.AddComponent(Common.createSpellImmunityToSpellDescriptor(Kingmaker.Blueprints.Classes.Spells.SpellDescriptor.Ground));
            airborne.AddComponent(Helpers.Create <AddFlying>());
            airborne.AddComponent(Helpers.Create <ManeuverImmunity>(m => m.Type = CombatManeuver.Trip));
            airborne.RemoveComponents <DamageBonusConditional>();
            airborne.RemoveComponents <AttackBonusConditional>();


            BlueprintUnitFact[] facts = new BlueprintUnitFact[] {
                library.Get <BlueprintBuff>("3689b69a30d6d7c48b90e28228fb7b7c"),                                                  //transmuter air elemental 1
                library.Get <BlueprintBuff>("2b2060036a20108448299f3ee2b14015"),                                                  //transmuter air elemental 2
                library.Get <BlueprintBuff>("2641f73f8d7864f4bba0bd6134018094"),                                                  //polymorph air elemental greater
                library.Get <BlueprintBuff>("933c5cd1113d2ef4a84f55660a744008"),                                                  //polymorph air elemental
                library.Get <BlueprintBuff>("70828d40058f2d3428bb767eb6e3e561"),                                                  //air elemental body 1
                library.Get <BlueprintBuff>("3af4d4bc55fa0ae4e851708d7395f1dd"),                                                  //air elemental body 2
                library.Get <BlueprintBuff>("db00581a03e6947419648dfba6aa03b2"),                                                  //air elemental body 3
                library.Get <BlueprintBuff>("ba06b8cff52da9e4d8432144ed6a6d19"),                                                  //air elemental body 4
                library.Get <BlueprintBuff>("dc1ef6f6d52b9fd49bc0696ab1a4f18b"),                                                  //air wildshape 1
                library.Get <BlueprintBuff>("65fdf187fea97c94b9cf4ff6746901a6"),                                                  //air wildshape 2
                library.Get <BlueprintBuff>("814bc75e74f969641bf110addf076ff9"),                                                  //air wildshape 3
                library.Get <BlueprintBuff>("eb52d24d6f60fc742b32fe943b919180"),                                                  //air wildshape 4
                library.Get <BlueprintBuff>("1a482859d9513e4418f57abcd396d315"),                                                  //wyvern

                library.Get <BlueprintBuff>("268fafac0a5b78c42a58bd9c1ae78bcf"),                                                  //black dragon I
                library.Get <BlueprintBuff>("b117bc8b41735924dba3fb23318f39ff"),                                                  //blue dragon I
                library.Get <BlueprintBuff>("17d330af03f5b3042a4417ab1d45e484"),                                                  //brass dragon I
                library.Get <BlueprintBuff>("1032d4ffb1c56444ca5bfce2c778614d"),                                                  //bronze dragon I
                library.Get <BlueprintBuff>("a4cc7169fb7e64a4a8f53bdc774341b1"),                                                  //copper dragon I
                library.Get <BlueprintBuff>("89669cfba3d9c15448c23b79dd604c41"),                                                  //gold dragon I
                library.Get <BlueprintBuff>("02611a12f38bed340920d1d427865917"),                                                  //green dragon buff I
                library.Get <BlueprintBuff>("294cbb3e1d547f341a5d7ec8500ffa44"),                                                  //red dragon I
                library.Get <BlueprintBuff>("feb2ab7613e563e45bcf9f7ffe4e05c6"),                                                  //silver dragon I
                library.Get <BlueprintBuff>("a6acd3ad1e9fa6c45998d43fd5dcd86d"),                                                  //white dragon buff I

                library.Get <BlueprintBuff>("9eb5ba8c396d2c74c8bfabd3f5e91050"),                                                  //black dragon II
                library.Get <BlueprintBuff>("cf8b4e861226e0545a6805036ab2a21b"),                                                  //blue dragon II
                library.Get <BlueprintBuff>("f7fdc15aa0219104a8b38c9891cac17b"),                                                  //brass dragon II
                library.Get <BlueprintBuff>("53e408cab2331bd48a3db846e531dfe8"),                                                  //bronze dragon II
                library.Get <BlueprintBuff>("799c8b6ae43c7d741ac7887c984f2aa2"),                                                  //copper dragon II
                library.Get <BlueprintBuff>("4300f60c00ecabc439deab11ce6d738a"),                                                  //gold dragon II
                library.Get <BlueprintBuff>("070543328d3e9af49bb514641c56911d"),                                                  //green dragon buff II
                library.Get <BlueprintBuff>("40a96969339f3c241b4d989910f255e1"),                                                  //red dragon II
                library.Get <BlueprintBuff>("16857109dafc2b94eafd1e888552ef76"),                                                  //silver dragon II
                library.Get <BlueprintBuff>("2652c61dff50a24479520c84005ede8b"),                                                  //white dragon buff II

                library.Get <BlueprintBuff>("c231e0cf7c203644d81e665d6115ae69"),                                                  //black dragon III
                library.Get <BlueprintBuff>("a4993affb4c4ad6429eca6daeb7b86a8"),                                                  //blue dragon III
                library.Get <BlueprintBuff>("8acd6ac6f89c73b4180191eb63768009"),                                                  //brass dragon III
                library.Get <BlueprintBuff>("1d3d388fd7b740842bde43dfb0aa56bb"),                                                  //bronze dragon III
                library.Get <BlueprintBuff>("c0e8f767f87ac354495865ce3dc3ee46"),                                                  //copper dragon III
                library.Get <BlueprintBuff>("ec6ad3612c4f0e340b54a11a0e78793d"),                                                  //gold dragon III
                library.Get <BlueprintBuff>("2d294863adf81f944a7558f7ae248448"),                                                  //green dragon buff III
                library.Get <BlueprintBuff>("782d09044e895fa44b9b6d9cca3a52b5"),                                                  //red dragon III
                library.Get <BlueprintBuff>("80babfb32011f384ea865d768857da79"),                                                  //silver dragon III
                library.Get <BlueprintBuff>("8dae421e48035a044a4b1a7b9208c5db"),                                                  //white dragon buff III
            };
            for (int i = 0; i < facts.Length; i++)
            {
                facts[i].AddComponents(airborne.ComponentsArray);
                if (i < 12)
                {
                    facts[i].AddComponent(Helpers.CreateAddFact(air_mastery));
                }
            }

            var airborne_types = new BlueprintUnitType[] { library.Get <BlueprintUnitType>("b012216cc6867354fb088d0c36968ea3"), //black dragon
                                                           library.Get <BlueprintUnitType>("f52b75839bb928242b6108df9d7f35a2"), //wyvern
                                                           library.Get <BlueprintUnitType>("284b6fd0b67688a4bb3ec28b15152d69"), //ankou
                                                           library.Get <BlueprintUnitType>("a574fa56e67623d41b538bdeae291fd5"), //gargoyle
                                                           library.Get <BlueprintUnitType>("535823c600a2c8f4a906063b7b949eb5"), //jabberwok
                                                           library.Get <BlueprintUnitType>("248c45d90c2f6e7429358fbe503e9c08")  //manticore
            };

            var units = library.GetAllBlueprints().OfType <BlueprintUnit>();

            foreach (var unit in units)
            {
                if (airborne_types.Contains(unit.Type))
                {
                    unit.AddFacts = unit.AddFacts.AddToArray(airborne);
                }
            }
        }
Example #21
0
 public static void SetDescription(this BlueprintUnitFact feature, String description)
 {
     blueprintUnitFact_set_Description(feature, Helpers.CreateString(feature.name + ".Description", description));
 }
        private static BlueprintFeature AddSpiderCompanion()
        {
            PortraitData portraitData = new PortraitData("AdvancedMartialArtsSpider");

            BlueprintPortrait portrait = Helpers.Create <BlueprintPortrait>();

            portrait.Data = portraitData;
            Main.library.AddAsset(portrait, Helpers.getGuid("GiantSpiderPortrait"));

            BlueprintUnitFact reducedReachFact = Main.library.Get <BlueprintUnitFact>("c33f2d68d93ceee488aa4004347dffca");
            BlueprintFeature  weaponFinesse    = Main.library.Get <BlueprintFeature>("90e54424d682d104ab36436bd527af09");

            BlueprintFeature animalCompanionUpgradeCentipede = Main.library.Get <BlueprintFeature>("c938099ca0438b242b3edecfa9083e9f");
            BlueprintUnit    animalCompanionUnitCentipede    = Main.library.Get <BlueprintUnit>("f9df16ffd0c8cec4d99a0ae6f025a3f8");

            BlueprintUnit giantSpider = Main.library.CopyAndAdd <BlueprintUnit>("c4b33e5fd3d3a6f46b2aade647b0bf25", "GiantSpiderCompanion", Helpers.getGuid("GiantSpiderCompanion"));

            BlueprintItemWeapon Bite1d6         = Main.library.Get <BlueprintItemWeapon>("a000716f88c969c499a535dadcf09286");
            BlueprintItemWeapon EmptyHandWeapon = Main.library.Get <BlueprintItemWeapon>("20375b5a0c9243d45966bd72c690ab74");

            giantSpider.Brain           = animalCompanionUnitCentipede.Brain;
            giantSpider.ComponentsArray = animalCompanionUnitCentipede.ComponentsArray;
            giantSpider.Body            = animalCompanionUnitCentipede.Body;
            giantSpider.AddFacts        = giantSpider.AddFacts.AddToArray(weaponFinesse);
            giantSpider.Faction         = Main.library.Get <BlueprintFaction>("d8de50cc80eb4dc409a983991e0b77ad"); // Neutral faction

            Helpers.SetField(giantSpider, "m_Portrait", portrait);

            BlueprintUnitAsksList giantSpiderBarks = Main.library.CopyAndAdd <BlueprintUnitAsksList>("7d340f75a57c47d45b0e79200a6b5eac", "SpiderAnimalCompanionBarks", Helpers.getGuid("SpiderAnimalCompanionBarks"));
            UnitAsksComponent     component        = giantSpiderBarks.GetComponent <UnitAsksComponent>();

            foreach (var componentAnimationBark in component.AnimationBarks)
            {
                if (componentAnimationBark.AnimationEvent == MappedAnimationEventType.AlertSound1 || componentAnimationBark.AnimationEvent == MappedAnimationEventType.AlertSound2)
                {
                    componentAnimationBark.Cooldown = 10f;
                    componentAnimationBark.DelayMin = 5f;
                }
            }

            ChangeUnitSize unitSize = Helpers.Create <ChangeUnitSize>(x => x.SizeDelta = 1);

            FieldInfo typeField = unitSize.GetType().GetField("m_Type", BindingFlags.NonPublic | BindingFlags.Instance);
            object    delta     = unitSize.GetType().GetNestedType("ChangeType", BindingFlags.NonPublic).GetField("Delta").GetValue(unitSize);

            typeField.SetValue(unitSize, delta);

            AddMechanicsFeature addMechanicsFeature = Helpers.Create <AddMechanicsFeature>();

            Traverse traverse = Traverse.Create(addMechanicsFeature);

            traverse.Field("m_Feature").SetValue(AddMechanicsFeature.MechanicsFeatureType.IterativeNaturalAttacks);


            typeField.SetValue(unitSize, delta);

            BlueprintFeature animalCompanionFeatureSpider = Main.library.CopyAndAdd <BlueprintFeature>("f9ef7717531f5914a9b6ecacfad63f46", "AnimalCompanionFeatureGiantSpider", Helpers.getGuid("AnimalCompanionFeatureGiantSpider"));

            animalCompanionFeatureSpider.SetNameDescription("Animal Companion — Giant Spider", "Size Medium\nSpeed 30 ft.\nAC +1 natural armor\nAttack bite (1d6 plus poison)\nAbility Scores Str 11, Dex 17, Con 12, Int 1, Wis 10, Cha 2\nSpecial Attacks poison (frequency 1 round (4); effect 1d2 Str damage; cure 1 save; Con-based DC)\nCMD +8 vs. trip.\nAt 7th level size becomes Large, Str +2, Dex +8, Con +4, +2 natural armor.");

            AddPet addPetFact = animalCompanionFeatureSpider.ComponentsArray.OfType <AddPet>().First();

            animalCompanionFeatureSpider.RemoveComponent(addPetFact);
            addPetFact = UnityEngine.Object.Instantiate(addPetFact);
            animalCompanionFeatureSpider.AddComponent(addPetFact);

            addPetFact.Pet            = giantSpider;
            addPetFact.UpgradeFeature = Helpers.CreateFeature(
                "AnimalCompanionUpgradeGiantSpider",
                "",
                "",
                Helpers.getGuid("AnimalCompanionUpgradeGiantSpider"),
                animalCompanionUpgradeCentipede.Icon,
                FeatureGroup.None,
                unitSize,
                Helpers.Create <AddStatBonus>(x =>
            {
                x.Stat       = StatType.AC;
                x.Value      = 2;
                x.Descriptor = ModifierDescriptor.NaturalArmor;
            }),
                Helpers.Create <AddStatBonus>(x =>
            {
                x.Stat  = StatType.Strength;
                x.Value = 2;
            }),
                Helpers.Create <AddStatBonus>(x =>
            {
                x.Stat  = StatType.Dexterity;
                x.Value = 8;
            }),
                Helpers.Create <AddStatBonus>(x =>
            {
                x.Stat  = StatType.Constitution;
                x.Value = 4;
            }),
                addMechanicsFeature,
                Helpers.CreateAddFacts(reducedReachFact)
                );
            addPetFact.UpgradeLevel = 7;
            return(animalCompanionFeatureSpider);
        }
 public static bool hasSpellStoredInFact(UnitDescriptor unit, BlueprintUnitFact fact)
 {
     return(getSpellStoredInFact(unit, fact) != null);
 }
 public bool SelectDefaultClassBuild()
 {
     if (!this.HasNextLevelPlan)
     {
         return(false);
     }
     if (!this.State.IsFirstLevel)
     {
         this.RemoveAction <SelectClass>(null);
         bool flag = this.ApplyLevelUpPlan(true);
         if (flag)
         {
             this.m_PlanChanged = false;
             this.UpdateDifficulty();
             return(true);
         }
         return(false);
     }
     else
     {
         if (this.State.SelectedClass == null)
         {
             return(false);
         }
         BlueprintUnitFact defaultBuild = this.State.SelectedClass.DefaultBuild;
         if (defaultBuild == null)
         {
             return(false);
         }
         BlueprintRace race = this.Preview.Progression.Race;
         if (race == null || this.State.CanSelectRace)
         {
             return(false);
         }
         bool result;
         try
         {
             using (new DefaultBuildData(race))
             {
                 this.Unit.Ensure <LevelUpPlanUnitHolder>();
                 this.Unit.Progression.DropLevelPlans();
                 this.Unit.AddFact(defaultBuild, null, null);
                 LevelPlanData levelPlan = this.Unit.Progression.GetLevelPlan(this.State.NextLevel);
                 if (levelPlan == null)
                 {
                     result = false;
                 }
                 else
                 {
                     this.m_RecalculatePreview = true;
                     this.LevelUpActions.RemoveAll((ILevelUpAction a) => TestLevelUpController.IsDefaultBuildPriority(a.Priority));
                     this.LevelUpActions.AddRange(from a in levelPlan.Actions
                                                  where TestLevelUpController.IsDefaultBuildPriority(a.Priority)
                                                  select a);
                     this.LevelUpActions = (from a in this.LevelUpActions
                                            orderby a.Priority
                                            select a).ToList <ILevelUpAction>();
                     this.UpdatePreview();
                     this.m_HasPlan     = true;
                     this.m_PlanChanged = false;
                     this.UpdateDifficulty();
                     result = true;
                 }
             }
         }
         finally
         {
             this.Unit.RemoveFact(defaultBuild);
             this.Unit.Remove <LevelUpPlanUnitHolder>();
         }
         return(result);
     }
 }
Example #25
0
 static public void addClassToFact(BlueprintCharacterClass class_to_add, BlueprintArchetype[] archetypes_to_add, DomainSpellsType spells_type, BlueprintUnitFact f)
 {
     if (f is BlueprintAbility)
     {
         addClassToAbility(class_to_add, archetypes_to_add, (f as BlueprintAbility));
     }
     else if (f is BlueprintActivatableAbility)
     {
         addClassToBuff(class_to_add, archetypes_to_add, (f as BlueprintActivatableAbility).Buff);
     }
     else if (f is BlueprintFeatureSelection)
     {
         if ((f as BlueprintFeatureSelection).Group == FeatureGroup.Feat ||
             (f as BlueprintFeatureSelection).Group == FeatureGroup.WizardFeat ||
             (f as BlueprintFeatureSelection).Group == FeatureGroup.RogueTalent
             )
         {
             return;
         }
         foreach (var af in (f as BlueprintFeatureSelection).AllFeatures)
         {
             if (af.HasGroup(FeatureGroup.Feat, FeatureGroup.WizardFeat, FeatureGroup.RagePower, FeatureGroup.RogueTalent))
             {
                 return;
             }
             addClassToFact(class_to_add, archetypes_to_add, spells_type, af);
         }
         addClassToFeat(class_to_add, archetypes_to_add, spells_type, (f as BlueprintFeatureBase));
     }
     else if (f is BlueprintProgression)
     {
         addClassToProgression(class_to_add, archetypes_to_add, spells_type, (f as BlueprintProgression));
     }
     else if (f is BlueprintFeature)
     {
         addClassToFeat(class_to_add, archetypes_to_add, spells_type, (f as BlueprintFeatureBase));
     }
 }
Example #26
0
 public static void SetName(this BlueprintUnitFact feature, LocalizedString name)
 {
     blueprintUnitFact_set_DisplayName(feature, name);
 }
Example #27
0
 public static void SetName(this BlueprintUnitFact feature, String name)
 {
     blueprintUnitFact_set_DisplayName(feature, Helpers.CreateString(feature.name + ".Name", name));
 }
Example #28
0
 public static void SetNameDescriptionIcon(this BlueprintUnitFact feature, String displayName, String description, Sprite icon)
 {
     SetNameDescription(feature, displayName, description);
     feature.SetIcon(icon);
 }
Example #29
0
 public static void SetNameDescriptionIcon(this BlueprintUnitFact feature, BlueprintUnitFact other)
 {
     SetNameDescription(feature, other);
     feature.SetIcon(other.Icon);
 }
 static private Kingmaker.UnitLogic.Feature maybeAddFact(UnitDescriptor descriptor, BlueprintUnitFact feature, MechanicsContext context, FeatureParam param)
 {
     if (descriptor.Progression.Features.Enumerable.Where <Kingmaker.UnitLogic.Feature>(p => p.Blueprint == feature).Any(a => a.Param == param))
     {
         return(null);
     }
     return(descriptor.AddFact <Kingmaker.UnitLogic.Feature>(feature, context, param));
 }