static void fixDragonDisciple()
{
var dragon_disciple = library.Get <BlueprintCharacterClass>("72051275b1dbb2d42ba9118237794f7c");
dragon_disciple.AddComponent(Common.prerequisiteNoArchetype(archetype.GetParentClass(), archetype));
archetype.AddComponent(Helpers.Create <PrerequisiteMechanics.PrerequisiteNoClassLevelVisible>(p => p.CharacterClass = dragon_disciple));
}
static void createAcBonus()
{
var monk = library.Get <BlueprintCharacterClass>("e8f21e5b58e0569468e420ebea456124");
var ac_bonus = library.Get <BlueprintFeature>("e241bdfd6333b9843a7bfd674d607ac4");
ac_bonus.Ranks++;
foreach (var c in ac_bonus.GetComponents <ContextRankConfig>().ToArray())
{
if (c.IsBasedOnClassLevel)
{
ClassToProgression.addClassToContextRankConfig(archetype.GetParentClass(), new BlueprintArchetype[] { archetype }, c, "ElementalAscetic", monk);
}
if (c.IsBasedOnCustomProperty) //for balance fixes (class level limiter on wisdom)
{
var property = Helpers.GetField <BlueprintUnitProperty>(c, "m_CustomProperty");
var cfg = property.GetComponent <NewMechanics.ContextValueWithLimitProperty>().max_value;
ClassToProgression.addClassToContextRankConfig(archetype.GetParentClass(), new BlueprintArchetype[] { archetype }, cfg, "ElementalAscetic", monk);
}
}
unlock_ac_bonus = library.CopyAndAdd <BlueprintFeature>("2615c5f87b3d72b42ac0e73b56d895e0", "ElementalAsceticACBonusUnlockFeature", "");
unlock_ac_bonus.ReplaceComponent <MonkNoArmorFeatureUnlock>(m => m.NewFact = ac_bonus);
unlock_ac_bonus.SetDescription($"When unarmored and unencumbered, an elemental ascetic adds his Wisdom bonus (if any{(Main.settings.balance_fixes_monk_ac ? ", up to his elemental ascetic level" : "")}) to his AC and CMD. In addition, an elemental ascetic gains a +1 bonus to AC and CMD at 4th level. This bonus increases by 1 for every four elemental ascetic levels thereafter, up to a maximum of +5 at 20th level.\n"
+ "An elemental ascetic does not receive his element’s defensive wild talent and can never take the expanded defense utility wild talent.");
}
static void addToPrestigeClasses()
{
Common.addReplaceSpellbook(Common.EldritchKnightSpellbookSelection, spellbook, "EldritchKnightStygianSlayer",
Common.createPrerequisiteClassSpellLevel(archetype.GetParentClass(), 3));
Common.addReplaceSpellbook(Common.ArcaneTricksterSelection, spellbook, "ArcaneTricksterStygianSlayer",
Common.createPrerequisiteClassSpellLevel(archetype.GetParentClass(), 2));
Common.addReplaceSpellbook(Common.MysticTheurgeArcaneSpellbookSelection, spellbook, "MysticTheurgeStygianSlayer",
Common.createPrerequisiteClassSpellLevel(archetype.GetParentClass(), 2));
}
static void createDomainSelection()
{
paladin_deity = library.Get <BlueprintFeatureSelection>("a7c8b73528d34c2479b4bd638503da1d");
paladin_deity.Group = FeatureGroup.Deities;
var cleric_domain = library.Get <BlueprintFeatureSelection>("48525e5da45c9c243a343fc6545dbdb9");
domain_selection = library.CopyAndAdd(cleric_domain, "SacredServantDomainSelection", "");
ClassToProgression.addClassToDomains(archetype.GetParentClass(), new BlueprintArchetype[] { archetype }, ClassToProgression.DomainSpellsType.SpecialList, domain_selection);
domain_selection.SetDescription("Sacred Servant chooses one domain associated with her deity. At 4th level she also gains one domain spell slot for each level of paladin spells she can cast. Every day she must prepare the domain spell from her chosen domain in that spell slot.");
archetype.GetParentClass().Spellbook.CantripsType = CantripsType.Orisions; //to properly show domain slots
}
static void createKiPool()
{
var scaled_fist_archetype = library.Get <BlueprintArchetype>("5868fc82eb11a4244926363983897279");
var scaled_fist_ki_pool = library.Get <BlueprintFeature>("ae98ab7bda409ef4bb39149a212d6732");
var resource = library.Get <BlueprintAbilityResource>("7d002c1025fbfe2458f1509bf7a89ce1");
var amount = CallOfTheWild.ExtensionMethods.getMaxAmount(resource);
Helpers.SetField(amount, "ArchetypesDiv", new BlueprintArchetype[] { scaled_fist_archetype });
ClassToProgression.addClassToResource(archetype.GetParentClass(), new BlueprintArchetype[] { archetype }, resource, scaled_fist_archetype.GetParentClass());
ki_pool = Common.featureToFeature(scaled_fist_ki_pool, false, "", "IroranPaladin");
var ki_ignore_dr_buff = Helpers.CreateBuff("IroranPaladinKiIgnoreDRBuff",
"Ki Power: Ignore DR",
"By spending 1 point from his ki pool, an iroran paladin can ignore any damage reduction possessed by the target of his personal trial ability for 1 round.",
"",
Helpers.GetIcon("2c38da66e5a599347ac95b3294acbe00"),
null,
Helpers.Create <NewMechanics.IgnoreDamageReductionIfTargetHasFact>(i =>
{
i.fact = personal_trial_buff;
i.from_caster = true;
})
);
var ability = library.CopyAndAdd <BlueprintAbility>("ca948bb4ce1a2014fbf4d8d44b553074", "IroranPaladinKiPowerIgnoreDRBuff", "");
ability.SetNameDescriptionIcon(ki_ignore_dr_buff);
ability.ReplaceComponent <AbilityEffectRunAction>(Helpers.CreateRunActions(Common.createContextActionApplyBuff(ki_ignore_dr_buff, Helpers.CreateContextDuration(1), dispellable: false)));
ki_pool.AddComponent(Helpers.CreateAddFacts(ability));
ki_strike_magic = library.CopyAndAdd <BlueprintFeature>("1188005ee3160f84f8bed8b19a7d46cf", "IroranPaladinKiStrikeMagic", "");
ki_strike_magic.SetDescription("At 4th level, ki strike allows the iroran paladin's unarmed attacks to be treated as magic weapons for the purpose of overcoming damage reduction.");
ki_strike_cold_iron_silver = library.CopyAndAdd <BlueprintFeature>("7b657938fde78b14cae10fc0d3dcb991", "IroranPaladinKiStrikeColdIronSilver", "");
ki_strike_cold_iron_silver.SetDescription("At 7th level, the iroran paladin's unarmed attacks are treated as cold iron and silver for the purpose of overcoming damage reduction.");
ki_strike_lawful = library.CopyAndAdd <BlueprintFeature>("34439e527a8f5fb4588024e71960dd42", "IroranPaladinKiStrikeLawful", "");
ki_strike_lawful.SetDescription("At 10th level, the iroran paladin's unarmed attacks are treated as lawful weapons for the purpose of overcoming damage reduction.");
ki_strike_adamantine = library.CopyAndAdd <BlueprintFeature>("ddc10a3463bd4d54dbcbe993655cf64e", "IroranPaladinKiStrikeAdamantine", "");
ki_strike_adamantine.SetDescription("At 16th level, the iroran paladin's unarmed attacks are treated as adamantine weapons for the purpose of overcoming damage reduction and bypassing hardness.");
}
static public void create()
{
var alchemist_class = ResourcesLibrary.TryGetBlueprint <BlueprintCharacterClass>("0937bec61c0dabc468428f496580c721");
archetype = Helpers.Create <BlueprintArchetype>(a =>
{
a.name = "ToxicantArchetype";
a.LocalizedName = Helpers.CreateString($"{a.name}.Name", "Toxicant");
a.LocalizedDescription = Helpers.CreateString($"{a.name}.Description", "In lands where poisons are legal and may be openly studied and sold, some alchemists obsess over the myriad ways that poisons and venoms can be applied and delivered. Known as toxicants, these deadly artists induce the production of deadly secretions within their own bodies in order to better inflict crippling conditions upon their foes.");
});
Helpers.SetField(archetype, "m_ParentClass", alchemist_class);
library.AddAsset(archetype, "");
createPoisonBuffAndPoisonImprovements();
createToxicSecretionAndPoisonDiscoveries();
var mutagen = library.Get <BlueprintFeature>("cee8f65448ce71c4b8b8ca13751dd8ea");
var throw_anything = library.Get <BlueprintFeature>("65c538dcfd91930489ad3ab18ad9204b");
var bombs = library.Get <BlueprintFeature>("c59b2f256f5a70a4d896568658315b7d");
var discovery = library.Get <BlueprintFeatureSelection>("cd86c437488386f438dcc9ae727ea2a6");
var sneak_attack = library.Get <BlueprintFeature>("9b9eac6709e1c084cb18c3a366e0ec87");
var medical_discovery = library.Get <BlueprintFeatureSelection>("67f499218a0e22944abab6fe1c9eaeee");
var alchemist_discovery = library.Get <BlueprintFeatureSelection>("cd86c437488386f438dcc9ae727ea2a6");
var advance_talents = library.Get <BlueprintFeature>("a33b99f95322d6741af83e9381b2391c");
var poison_immunity = library.Get <BlueprintFeature>("202af59b918143a4ab7c33d72c8eb6d5");
var persistent_mutagen = library.Get <BlueprintFeature>("75ba281feb2b96547a3bfb12ecaff052");
archetype.RemoveFeatures = new LevelEntry[] { Helpers.LevelEntry(1, mutagen),
Helpers.LevelEntry(14, persistent_mutagen) };
archetype.AddFeatures = new LevelEntry[] { Helpers.LevelEntry(1, poison_secretion),
Helpers.LevelEntry(3, poison_improvement, poison_move_action),
Helpers.LevelEntry(6, poison_improvement, poison_swift_action),
Helpers.LevelEntry(9, poison_improvement),
Helpers.LevelEntry(12, poison_improvement),
Helpers.LevelEntry(15, poison_improvement),
Helpers.LevelEntry(18, poison_improvement), };
alchemist_class.Progression.UIGroups = alchemist_class.Progression.UIGroups.AddToArray(Helpers.CreateUIGroup(poison_secretion, poison_improvement));
alchemist_class.Progression.UIGroups = alchemist_class.Progression.UIGroups.AddToArray(Helpers.CreateUIGroup(poison_move_action, poison_swift_action));
alchemist_class.Archetypes = alchemist_class.Archetypes.AddToArray(archetype);
medical_discovery.AllFeatures = medical_discovery.AllFeatures.AddToArray(sticky_posion, celestial_poison, concentrate_poison);
alchemist_discovery.AllFeatures = alchemist_discovery.AllFeatures.AddToArray(sticky_posion, celestial_poison, concentrate_poison);
var dispelling_attack = library.Get <BlueprintFeature>("1b92146b8a9830d4bb97ab694335fa7c");
ClassToProgression.addClassToFeat(archetype.GetParentClass(), new BlueprintArchetype[] { archetype }, ClassToProgression.DomainSpellsType.NoSpells, dispelling_attack, archetype.GetParentClass());
var greater_mutagen = library.Get <BlueprintFeature>("76c61966afdd82048911f3d63c6fe0bc");
var cognatogen = library.Get <BlueprintFeature>("e3f460ea61fcc504183c7d6818bbbf7a");
var feral_mutagen = library.Get <BlueprintFeature>("fd5f7b37ab4301c48a88cc196ee5f0ce");
greater_mutagen.AddComponent(mutagen.PrerequisiteFeature());
cognatogen.AddComponent(mutagen.PrerequisiteFeature());
feral_mutagen.AddComponent(mutagen.PrerequisiteFeature());
}
static void createHolyWaterSprinkerAndDeathWard()
{
var enchantment = Common.createWeaponEnchantment("HolyWaterSprinklerEnhancement",
"Holy Water Sprinkler",
"As a swift action, a grave warden can open a flask of holy water and pour it onto a held or adjacent melee weapon. If the weapon successfully hits an undead creature before the end of the grave warden’s next turn, the undead takes damage as if it took a direct hit from the holy water, taking 2d4 points of damage in addition to the damage from the weapon, if any.\n"
+ "A grave warden can use this ability once per day per grave warden level.",
"",
"",
"",
0,
null,
Common.createWeaponDamageAgainstFact(DamageEnergyType.Holy, Common.undead,
Helpers.CreateContextDiceValue(DiceType.D4, 2))
);
var icon = LoadIcons.Image2Sprite.Create(@"AbilityIcons/HolyWaterJet.png");
var buff = Helpers.CreateBuff("HolyWaterSprinklerBuff",
enchantment.Name,
enchantment.Description,
"",
icon,
null,
Common.createBuffContextEnchantPrimaryHandWeapon(Common.createSimpleContextValue(1), false, true, enchantment)
);
var resource = Helpers.CreateAbilityResource("GraveWardenHolyWaterResource", "", "", "", null);
resource.SetIncreasedByLevel(0, 1, new BlueprintCharacterClass[] { archetype.GetParentClass() });
var ability = Helpers.CreateActivatableAbility("HolyWaterSprinklerAbility",
buff.Name,
buff.Description,
"",
buff.Icon,
buff,
AbilityActivationType.Immediately,
CommandType.Swift,
null,
resource.CreateActivatableResourceLogic(ResourceSpendType.NewRound),
Common.createActivatableAbilityUnitCommand(CommandType.Swift),
Helpers.Create <NewMechanics.ActivatableAbilityMeleeWeaponRestriction>()
);
holy_water_sprinkler = Common.ActivatableAbilityToFeature(ability, false);
holy_water_sprinkler.AddComponent(resource.CreateAddAbilityResource());
var death_ward_ability = Common.convertToSpellLike(library.Get <BlueprintAbility>("0413915f355a38146bc6ad40cdf27b3f"),
"GraveWarden",
new BlueprintCharacterClass[] { archetype.GetParentClass() },
StatType.Intelligence,
no_resource: true
);
death_ward_ability.setMiscAbilityParametersSelfOnly();
Common.setAsFullRoundAction(death_ward_ability);
death_ward_ability.Range = AbilityRange.Personal;
death_ward_ability.AddComponent(resource.CreateResourceLogic(amount: 4));
death_ward = Common.AbilityToFeature(death_ward_ability, false);
death_ward.SetDescription("At 7th level, a grave warden learns to perform a short ritual that grants the benefits of death ward, using his slayer level as his caster level. Performing this ritual requires a full-round action and consumes 4 uses of Holy Water Sprinkler ability. The grave warden can protect only himself with this ability.");
}
static void createBlessedHunterFeats()
{
blessed_hunter = Helpers.CreateFeature("BlessedHunterBloodHunterFeat",
"Blessed Hunter",
"While in his favored terrain, blood hunter gains +1 bonus on damage rolls and saving throws.",
"",
null,
FeatureGroup.None,
Helpers.Create <FavoredEnemyMechanics.BlessedHunterTerrain>(b => b.Settings = hunting_ground.GetComponent <FavoredTerrain>().Settings)
);
blessed_hunter_stride = library.CopyAndAdd <BlueprintFeature>("11f4072ea766a5840a46e6660894527d", "BlessedHunterStrideFeature", "");
blessed_hunter_stride.SetNameDescription("Blessed Hunter's Stride",
"Blood hunter's speed increases by 10 feet while he is in his favored terrain, and he ignores difficult terrain effects.");
blessed_hunter_stride.AddComponent(Helpers.CreateAddStatBonus(StatType.Speed, 10, ModifierDescriptor.UntypedStackable));
var animal_focus_engine = new AnimalFocusEngine();
animal_focus_engine.initialize(new BlueprintCharacterClass[] { archetype.GetParentClass() }, archetype, 0, "BloodHunter");
var animal_focus = animal_focus_engine.createAnimalFocus("At 13th level, while in his favored terrain, blood hunter gains the benefits of the hunter’s animal focus class feature, with an effective hunter level equal to his blood hunter level. If blood hunter formed a bond with animal companion, he can also apply animal focus to it.");
animal_focus.HideInCharacterSheetAndLevelUp = true;
var apply_focus_ability = animal_focus_engine.createApplyAnimalFocusAbility(animal_focus.name, "Apply Animal Focus (Permanent)", "This abilitiy applies selected animal foci.", animal_focus.Icon);
animal_focus.AddComponent(Helpers.CreateAddFact(apply_focus_ability));
blessed_hunters_focus = Helpers.CreateFeature("BlessedHunterFocusBloodHunterFeature",
"Blessed Hunter's Focus",
"At 13th level, while in his favored terrain, blood hunter gains the benefits of the hunter’s animal focus class feature, with an effective hunter level equal to his blood hunter level. The chosen aspect remains active until changed. If blood hunter formed a bond with animal companion, he can also apply animal focus to it. The blood hunter can apply extra animal focus if his animal companion is dead.",
"",
animal_focus.Icon,
FeatureGroup.None,
Helpers.CreateAddFact(animal_focus),
Common.createAddFeatToAnimalCompanion(animal_focus)
);
var ranger_ac_selection = library.Get <BlueprintFeatureSelection>("ee63330662126374e8785cc901941ac7");
var planar_focus = animal_focus_engine.createPlanarFocus("Blood Hunter", ranger_ac_selection);
planar_focus.AddComponents(Common.createPrerequisiteArchetypeLevel(archetype.GetParentClass(), archetype, 13));
}
public static PrerequisiteArchetypeLevel CreatePrerequisite(this BlueprintArchetype @class, int level, bool any = true)
{
var result = CallOfTheWild.Helpers.Create <PrerequisiteArchetypeLevel>();
result.CharacterClass = @class.GetParentClass();
result.Archetype = @class;
result.Level = level;
result.Group = any ? Prerequisite.GroupType.Any : Prerequisite.GroupType.All;
return(result);
}
static void createHolyMagic()
{
var cleric_spell_list = library.Get <BlueprintSpellList>("8443ce803d2d31347897a3d85cc32f53");
var inquisitor_spell_list = archetype.GetParentClass().Spellbook.SpellList;
var ravener_spell_list = Common.combineSpellLists("ReavenerHunterSpellList",
(spell, spell_list, lvl) =>
{
if ((spell.SpellDescriptor & (SpellDescriptor.Evil | SpellDescriptor.Law | SpellDescriptor.Chaos)) != 0)
{
return(false);
}
if (lvl > 6)
{
return(false);
}
if (spell_list == cleric_spell_list && (spell.SpellDescriptor & SpellDescriptor.Good) == 0)
{
return(false);
}
return(true);
},
inquisitor_spell_list, cleric_spell_list
);
spellbook = library.CopyAndAdd(archetype.GetParentClass().Spellbook, "RavenerHunterSpellbook", "");
spellbook.SpellList = ravener_spell_list;
var feature = Helpers.CreateFeature("RavenerHunterHolyMagic",
"Holy Magic",
"A demon hunter must be non-evil. She adds all spells of 6th-level and lower on the cleric spell list with the good descriptor to her inquisitor spell list as inquisitor spells of the same level. If a spell appears on both the cleric and inquisitor spell lists, the demon hunter uses the lower of the two spell levels listed for the spell. She cannot cast a spell with the chaotic, evil, or lawful descriptors, even from spell trigger or spell completion items.",
"",
Helpers.GetIcon("808ab74c12df8784ab4eeaf6a107dbea"), //protection from evil
FeatureGroup.None,
Common.createPrerequisiteAlignment(AlignmentMaskType.Good | AlignmentMaskType.ChaoticNeutral | AlignmentMaskType.TrueNeutral | AlignmentMaskType.LawfulNeutral)
);
holy_magic = Common.featureToSelection(feature);
holy_magic.Obligatory = true;
}
static BlueprintProgression createCurseProgression(BlueprintProgression oracle_curse)
{
var features = new BlueprintFeature[] { oracle_curse.LevelEntries[0].Features[0] as BlueprintFeature, //1 -> 5
oracle_curse.LevelEntries[1].Features[0] as BlueprintFeature, //5 -> 10,
oracle_curse.LevelEntries[2].Features[0] as BlueprintFeature, //10 -> 20
};
var curse = Helpers.CreateProgression("PactWizard" + oracle_curse.name,
oracle_curse.Name,
oracle_curse.Description,
"",
features[0].Icon,
FeatureGroup.None);
List <BlueprintAbility> curse_spells = new List <BlueprintAbility>();
for (int i = 0; i < features.Length; i++)
{
features[i] = library.CopyAndAdd(features[i], "PactWizard" + features[i].name, "");
foreach (var af in features[i].GetComponents <AddFeatureOnClassLevel>())
{
features[i].ReplaceComponent(af, af.CreateCopy(c => { c.Class = archetype.GetParentClass(); c.Level = c.Level * 2; }));
}
foreach (var aks in features[i].GetComponents <AddKnownSpell>())
{
features[i].ReplaceComponent(aks, aks.CreateCopy(c =>
{
c.CharacterClass = archetype.GetParentClass();
if (archetype.GetParentClass().Spellbook.SpellList.Contains(c.Spell) &&
archetype.GetParentClass().Spellbook.SpellList.GetLevel(c.Spell) != c.SpellLevel)
{
c.Spell = SpellDuplicates.addDuplicateSpell(c.Spell, "PactWizard" + c.Spell.name, "");
}
curse_spells.Add(c.Spell);
}
)
);
}
}
if (!curse_spells.Empty())
{
var feature2 = Helpers.CreateFeature(oracle_curse.name + "CurseMetamagicFeature",
"",
"",
"",
null,
FeatureGroup.None,
Helpers.Create <NewMechanics.MetamagicMechanics.ReduceMetamagicCostForSpecifiedSpells>(r => { r.reduction = 1; r.spells = curse_spells.ToArray(); })
);
feature2.HideInCharacterSheetAndLevelUp = true;
patron_metamagic.AddComponent(Common.createAddFeatureIfHasFact(curse, feature2));
}
curse.LevelEntries = new LevelEntry[] { Helpers.LevelEntry(5, features[0]), Helpers.LevelEntry(10, features[1]), Helpers.LevelEntry(20, features[2]) };
curse.UIGroups = Helpers.CreateUIGroups(features);
curse.Classes = new BlueprintCharacterClass[] { archetype.GetParentClass() };
return(curse);
}
static void createOverwhelmingPower()
{
overwhelming_power = library.CopyAndAdd <BlueprintFeature>("2496916d8465dbb4b9ddeafdf28c67d8", "OverwhelmingPowerOverwhelmingSoulFeature", "");
overwhelming_power.SetNameDescription("Overwhelming Power",
"At 3rd level, an overwhelming soul gains a +1 bonus on attack rolls and damage rolls with her kinetic blasts. The damage bonus doesn’t apply to kinetic blade, kinetic whip, or other infusions that don’t apply the damage bonus from elemental overflow.\n"
+ "This bonus increases by 1 at 6th level and every 3 levels thereafter."
);
overwhelming_power.RemoveComponents <RecalculateOnStatChange>();
overwhelming_power.RemoveComponents <ContextRankConfig>();
overwhelming_power.AddComponent(Helpers.CreateContextRankConfig(ContextRankBaseValueType.ClassLevel, classes: new BlueprintCharacterClass[] { archetype.GetParentClass() },
progression: ContextRankProgression.StartPlusDivStep, startLevel: 3, stepLevel: 3));
}
static void createKineticChirurgery()
{
var elemental_focus = library.Get <BlueprintFeatureSelection>("1f3a15a3ae8a5524ab8b97f469bf4e3d"); //to be able to pick talents
var kinetic_knight_elemental_focus = library.Get <BlueprintFeatureSelection>("b1f296f0bd16bc242ae35d0638df82eb"); //to be able to pick talents
var water = library.Get <BlueprintFeature>("7ab8947ce2e19c44a9edcf5fd1466686");
var kinetic_knight_water = library.Get <BlueprintFeature>("5e839c743c6da6649a43cdeb70b6018f");
var kinetic_healer = library.Get <BlueprintFeature>("3ef666973adfa8f40af6c0679bd98ba5");
kinetic_chirurgery = Helpers.CreateFeature("KineticChirurgeryFeature",
"Kinetic Chirurgery",
"A kinetic chirurgeon must select water as her primary element. She gains kinetic healer as a bonus wild talent at 1st level.",
"",
Helpers.GetIcon("3ef666973adfa8f40af6c0679bd98ba5"),
FeatureGroup.None,
Helpers.CreateAddFacts(kinetic_healer)
);
foreach (var e in elemental_focus.AllFeatures)
{
if (e == water)
{
continue;
}
e.AddComponent(Common.prerequisiteNoArchetype(archetype.GetParentClass(), archetype));
}
foreach (var e in kinetic_knight_elemental_focus.AllFeatures)
{
if (e == kinetic_knight_water)
{
continue;
}
e.AddComponent(Common.prerequisiteNoArchetype(archetype.GetParentClass(), archetype));
}
}
static void createDrakeCompanion()
{
var rank_profgression = library.CopyAndAdd <BlueprintProgression>("3853d5405ebfc0f4a86930bb7082b43b", "DrakeCompanionDraconicDruidProgression", "");
rank_profgression.Classes = new BlueprintCharacterClass[] { archetype.GetParentClass() };
drake_companion = library.CopyAndAdd(Shaman.drake_companion, "DraconicDruidDrakeCompanionFeatureSelection", "");
drake_companion.SetDescription("A draconic druid gains a drake companion instead of an animal companion.");
drake_companion.ComponentsArray = new BlueprintComponent[]
{
Helpers.Create <AddFeatureOnApply>(a => a.Feature = library.Get <BlueprintFeature>("1670990255e4fe948a863bafd5dbda5d")),
Helpers.Create <AddFeatureOnApply>(a => a.Feature = rank_profgression)
};
}
static void createDivineHexes()
{
var hex_engine = new HexEngine(new BlueprintCharacterClass[] { archetype.GetParentClass() }, StatType.Wisdom, StatType.Charisma, archetype: archetype);
var slumber_hex = hex_engine.createSlumber("DivineScourgeSlumber",
Witch.slumber_hex.Name,
Witch.slumber_hex.Description,
"", "", "");
var misfortune_hex = hex_engine.createMisfortune("DivineScourgeMisfortune",
Witch.misfortune_hex.Name,
Witch.misfortune_hex.Description,
"", "", "", "");
var evil_eye = hex_engine.createEvilEye("DivineScourgeEvilEye",
Witch.evil_eye.Name,
Witch.evil_eye.Description,
"", "", "", "", "", "", "", "");
var agony = hex_engine.createAgony("DivineScourgeAgony",
Witch.agony.Name,
Witch.agony.Description,
"", "", "", "");
var restless_slumber = hex_engine.createRestlessSlumber("DivineScourgeRestlessSlumber",
Witch.restless_slumber.Name,
Witch.restless_slumber.Description
);
restless_slumber.AddComponent(slumber_hex.PrerequisiteFeature());
var retribution = hex_engine.createRetribution("DivineScourgeRetribution",
Witch.retribution.Name,
Witch.retribution.Description,
"", "", ""
);
divine_hexes = Helpers.CreateFeatureSelection("DivineScourgeDivineHexSelection",
"Divine Hexes",
"At 3rd level and every 4 cleric levels thereafter, a divine scourge can select the following hexes from the witch class hex list, up to a maximum of five hexes at 19th level: evil eye, misfortune, and slumber.\n"
+ "At 11th level, a divine scourge can instead select from the following list of major hexes: agony, restless slumber, and retribution.\n"
+ "The divine scourge uses her Wisdom modifier instead of her Intelligence modifier to determine the save DCs of her hexes. Any hex that refers to using her Intelligence modifier to determine its duration or effect instead uses her Charisma modifier for that purpose.",
"",
null,
FeatureGroup.None);
divine_hexes.AllFeatures = new BlueprintFeature[] { slumber_hex, evil_eye, misfortune_hex, agony, restless_slumber, retribution };
}
internal static void create()
{
var kineticist_class = ResourcesLibrary.TryGetBlueprint <BlueprintCharacterClass>("42a455d9ec1ad924d889272429eb8391");
archetype = Helpers.Create <BlueprintArchetype>(a =>
{
a.name = "ElementalAsceticArchetype";
a.LocalizedName = Helpers.CreateString($"{a.name}.Name", "Elemental Ascetic");
a.LocalizedDescription = Helpers.CreateString($"{a.name}.Description", "Combining the elemental powers of a kineticist with the rigid physical discipline of a monk, an elemental ascetic channels his powers through his body to enhance himself in combat.");
});
Helpers.SetField(archetype, "m_ParentClass", kineticist_class);
library.AddAsset(archetype, "");
var element_selection = library.Get <BlueprintFeatureSelection>("1f3a15a3ae8a5524ab8b97f469bf4e3d");
var infusion_selection = library.Get <BlueprintFeatureSelection>("58d6f8e9eea63f6418b107ce64f315ea");
var proficiencies = library.Get <BlueprintFeature>("31ad04e4c767f5d4b96c13a71fd7ff15");
var improved_unarmed_strike = Common.featureToFeature(library.Get <BlueprintFeature>("7812ad3672a4b9a4fb894ea402095167"), false, prefix: "ElementalAscetic");
improved_unarmed_strike.SetDescription("At 1st level, an elemental ascetic gains Improved Unarmed Strike as a bonus feat.");
archetype.RemoveFeatures = new LevelEntry[] { Helpers.LevelEntry(1, element_selection, proficiencies, infusion_selection),
Helpers.LevelEntry(5, infusion_selection),
Helpers.LevelEntry(11, infusion_selection),
Helpers.LevelEntry(17, infusion_selection) };
createElementalFocus();
createElementalFlurry();
createAcBonus();
var elemental_ascetic_proficiencies = library.CopyAndAdd <BlueprintFeature>("31ad04e4c767f5d4b96c13a71fd7ff15", "ElementalAsceticProficienciesFeature", "");
elemental_ascetic_proficiencies.ReplaceComponent <AddFacts>(a => a.Facts = a.Facts.RemoveFromArray(library.Get <BlueprintFeature>("6d3728d4e9c9898458fe5e9532951132")));
elemental_ascetic_proficiencies.SetNameDescription("Elemental Ascetic Proficiencies", "Elemental ascetic is not proficient with any armor.");
archetype.AddFeatures = new LevelEntry[] { Helpers.LevelEntry(1, KineticistFix.kinetic_fist, elemental_focus, elemental_ascetic_proficiencies, unlock_ac_bonus, elemental_flurry, improved_unarmed_strike),
Helpers.LevelEntry(5, KineticistFix.powerful_fist[0]),
Helpers.LevelEntry(11, KineticistFix.powerful_fist[1], flurry11),
Helpers.LevelEntry(17, KineticistFix.powerful_fist[2]), };
archetype.OverrideAttributeRecommendations = true;
kineticist_class.Progression.UIGroups[1].Features.Add(elemental_focus);
kineticist_class.Progression.UIDeterminatorsGroup = kineticist_class.Progression.UIDeterminatorsGroup.AddToArray(proficiencies, improved_unarmed_strike, unlock_ac_bonus);
kineticist_class.Progression.UIGroups = kineticist_class.Progression.UIGroups.AddToArray(Helpers.CreateUIGroup(elemental_flurry, flurry11));
kineticist_class.Progression.UIGroups = kineticist_class.Progression.UIGroups.AddToArray(Helpers.CreateUIGroup(KineticistFix.powerful_fist.AddToArray(KineticistFix.kinetic_fist)));
kineticist_class.Archetypes = kineticist_class.Archetypes.AddToArray(archetype);
//remove leather armor
archetype.ReplaceStartingEquipment = true;
archetype.StartingItems = archetype.GetParentClass().StartingItems.Skip(1).ToArray();
}
static void fixRangerAbilitiesScaling()
{
ranger_casting_stat_property = NewMechanics.CastingStatPropertyGetter.createProperty("RangerCastingStatProperty", "", StatType.Wisdom, archetype.GetParentClass());
var hunters_bond_ability = library.Get <BlueprintAbility>("cd80ea8a7a07a9d4cb1a54e67a9390a5");
hunters_bond_ability.ReplaceComponent <ContextRankConfig>(c =>
{
Helpers.SetField(c, "m_BaseValueType", ContextRankBaseValueType.CustomProperty);
Helpers.SetField(c, "m_CustomProperty", ranger_casting_stat_property);
}
);
var master_hunter = library.Get <BlueprintFeature>("9d53ef63441b5d84297587d75f72fc17");
master_hunter.RemoveComponents <BindAbilitiesToClass>();
master_hunter.RemoveComponents <ReplaceCasterLevelOfAbility>();
master_hunter.RemoveComponents <ReplaceAbilitiesStat>();
var master_hunter_ability = library.Get <BlueprintAbility>("8a57e1072da4f6f4faaa55b7b7dc633c");
master_hunter_ability.AddComponent(Common.createContextCalculateAbilityParamsBasedOnClassesWithProperty(new BlueprintCharacterClass[] { archetype.GetParentClass() }, ranger_casting_stat_property));
//fix stromwreden weapon buff resource
var stromwarden_weapon_ability_resource = library.Get <BlueprintAbilityResource>("6bc707c120d6d38498ccb70767d55a69");
fey_touched.AddComponents(Helpers.Create <IncreaseResourceAmountBySharedValue>(i =>
{
i.Decrease = true;
i.Resource = stromwarden_weapon_ability_resource;
i.Value = Helpers.CreateContextValue(AbilityRankType.Default);
}
),
Helpers.Create <IncreaseResourceAmountBySharedValue>(i =>
{
i.Resource = stromwarden_weapon_ability_resource;
i.Value = Helpers.CreateContextValue(AbilityRankType.StatBonus);
}
),
Helpers.CreateContextRankConfig(ContextRankBaseValueType.StatBonus, type: AbilityRankType.StatBonus, stat: StatType.Charisma),
Helpers.CreateContextRankConfig(ContextRankBaseValueType.StatBonus, stat: StatType.Wisdom),
Helpers.Create <RecalculateOnStatChange>(r => r.Stat = StatType.Wisdom),
Helpers.Create <RecalculateOnStatChange>(r => r.Stat = StatType.Charisma)
);
//warpriest blessing have 3 + 1/2 level so no need to change
}
static BlueprintArchetype createCombinedArchetype(BlueprintArchetype archetype1, BlueprintArchetype archetype2)
{
var parent_class = archetype1.GetParentClass();
var combined_archetype = Helpers.Create <BlueprintArchetype>(a =>
{
a.name = archetype1.name + archetype2.name;
a.LocalizedName = Helpers.CreateString($"{a.name}.Name", $"{archetype1.Name} / {archetype2.Name}");
a.LocalizedDescription = Helpers.CreateString($"{a.name}.Description", $"This archetype represents a combination of {archetype1.Name} and {archetype2.Name} archetypes.\n{archetype1.Name}: {archetype1.Description}\n{archetype2.Name}: {archetype2.Description}");
});
Helpers.SetField(combined_archetype, "m_ParentClass", parent_class);
library.AddAsset(combined_archetype, Helpers.MergeIds(archetype1.AssetGuid, archetype2.AssetGuid));
combined_archetype.RemoveFeatures = new LevelEntry[] { };
combined_archetype.AddFeatures = new LevelEntry[] { Helpers.LevelEntry(1) };
parent_class.Archetypes = parent_class.Archetypes.AddToArray(combined_archetype);
var skills1 = archetype1.ReplaceClassSkills ? archetype1.ClassSkills : parent_class.ClassSkills;
var skills2 = archetype2.ReplaceClassSkills ? archetype2.ClassSkills : parent_class.ClassSkills;
combined_archetype.ReplaceClassSkills = archetype1.ReplaceClassSkills || archetype2.ReplaceClassSkills;
var missing_skills = parent_class.ClassSkills.Except(skills1).ToList();
missing_skills.AddRange(parent_class.ClassSkills.Except(skills2));
missing_skills = missing_skills.Distinct().ToList();
var extra_skills = skills1.Except(parent_class.ClassSkills).ToList();
extra_skills.AddRange(skills2.Except(parent_class.ClassSkills));
extra_skills = extra_skills.Distinct().ToList();
if (combined_archetype.ReplaceClassSkills)
{
combined_archetype.ClassSkills = parent_class.ClassSkills.AddToArray(extra_skills).Except(missing_skills).ToArray();
}
combined_archetype.IsArcaneCaster = archetype1.IsArcaneCaster || archetype2.IsArcaneCaster;
combined_archetype.IsDivineCaster = archetype1.IsDivineCaster || archetype2.IsDivineCaster;
combined_archetype.ChangeCasterType = archetype1.ChangeCasterType || archetype2.ChangeCasterType;
combined_archetype.AddComponent(Helpers.Create <CombineArchetypes>(c => c.archetypes = new BlueprintArchetype[] { archetype1, archetype2 }));
combined_archetypes[archetype1.name + archetype2.name] = combined_archetype;
return(combined_archetype);
}
internal static void create()
{
var inquisitor_class = ResourcesLibrary.TryGetBlueprint <BlueprintCharacterClass>("f1a70d9e1b0b41e49874e1fa9052a1ce");
archetype = Helpers.Create <BlueprintArchetype>(a =>
{
a.name = "RavenerHunterArchetype";
a.LocalizedName = Helpers.CreateString($"{a.name}.Name", "Demon Hunter");
a.LocalizedDescription = Helpers.CreateString($"{a.name}.Description", "The natural enemies of demoniacs and other cultists of fiendish forces, demon hunters are inquisitors who dedicate their lives to eradicating demonkind.");
});
Helpers.SetField(archetype, "m_ParentClass", inquisitor_class);
library.AddAsset(archetype, "");
var deity = library.Get <BlueprintFeatureSelection>("59e7a76987fe3b547b9cce045f4db3e4");
var domain = library.Get <BlueprintFeatureSelection>("48525e5da45c9c243a343fc6545dbdb9");
var teamwork_feat = library.Get <BlueprintFeature>("d87e2f6a9278ac04caeb0f93eff95fcb");
var solo_tactics = library.Get <BlueprintFeature>("5602845cd22683840a6f28ec46331051");
var solo_tactics_ravener = library.CopyAndAdd(solo_tactics, "SoloTacticsRavenerHunter", "");
solo_tactics_ravener.SetDescription("A demon hunter gains solo tactics at 6th level instead of 3rd level.");
createHolyMagic();
createDemonHunter();
createChargedByNatureAndRevelations();
archetype.RemoveFeatures = new LevelEntry[] { Helpers.LevelEntry(1, domain),
Helpers.LevelEntry(3, teamwork_feat, solo_tactics), };
archetype.AddFeatures = new LevelEntry[] { Helpers.LevelEntry(1, holy_magic, charged_by_nature, revelation_selection),
Helpers.LevelEntry(3, demon_hunter),
Helpers.LevelEntry(6, solo_tactics_ravener),
Helpers.LevelEntry(8, revelation_selection), };
archetype.ReplaceSpellbook = spellbook;
archetype.AddComponent(Common.createPrerequisiteAlignment((~Kingmaker.UnitLogic.Alignments.AlignmentMaskType.Evil) & Kingmaker.UnitLogic.Alignments.AlignmentMaskType.Any));
inquisitor_class.Progression.UIGroups = inquisitor_class.Progression.UIGroups.AddToArray(Helpers.CreateUIGroup(revelation_selection, demon_hunter, solo_tactics_ravener));
inquisitor_class.Progression.UIDeterminatorsGroup = inquisitor_class.Progression.UIDeterminatorsGroup.AddToArray(holy_magic, charged_by_nature);
inquisitor_class.Archetypes = inquisitor_class.Archetypes.AddToArray(archetype);
var mt_progression = library.Get <BlueprintProgression>("d21a104c204ed7348a51405e68387013");
mt_progression.AddComponent(Common.prerequisiteNoArchetype(archetype));
Common.addMTDivineSpellbookProgression(archetype.GetParentClass(), spellbook, "MysticTheurgeRavenerHunterProgression",
Common.createPrerequisiteArchetypeLevel(archetype, 1),
Common.createPrerequisiteClassSpellLevel(inquisitor_class, 2)
);
}
static void FixSpellbookSelection(BlueprintArchetype archetype, String spellSelectionId, String sorcererSelectionId, FeatureGroup group)
{
var spellSelection = (BlueprintFeatureSelection)library.BlueprintsByAssetId[spellSelectionId];
var sorcererClass = archetype.GetParentClass();
var sorcererFeature = spellSelection.AllFeatures.Cast <BlueprintFeatureReplaceSpellbook>()
.First(f => f.AssetGuid == sorcererSelectionId);
// Restrict sorcerer feat so it can't be selected with this archetype
var sorcererPrereqs = sorcererFeature.ComponentsArray.ToList();
sorcererPrereqs.Add(Helpers.Create <PrerequisiteNoArchetype>(p => { p.CharacterClass = sorcererClass; p.Archetype = archetype; }));
sorcererFeature.SetComponents(sorcererPrereqs);
// Create a new feature for this archetype's spellbook
var spellbookFeature = library.CopyAndAdd(sorcererFeature, group.ToString().Replace("Spellbook", archetype.name),
sorcererFeature.AssetGuid, "7d400c2c080947ecb0a1052b453bc107");
spellbookFeature.Spellbook = archetype.ReplaceSpellbook;
spellbookFeature.SetName(archetype.LocalizedName);
// Update the prerequisites.
spellbookFeature.SetComponents(
Helpers.Create <PrerequisiteArchetypeLevel>(p =>
{
p.CharacterClass = sorcererClass;
p.Archetype = archetype;
}),
Helpers.Create <PrerequisiteClassSpellLevel>(p =>
{
p.CharacterClass = sorcererClass;
p.RequiredSpellLevel = 1;
}));
// Add to the list of all features for this selector.
var allFeatures = spellSelection.AllFeatures.ToList();
allFeatures.Add(spellbookFeature);
spellSelection.AllFeatures = allFeatures.ToArray();
}
static void fixDragonDisciple()
{
var dragon_disciple = library.Get <BlueprintCharacterClass>("72051275b1dbb2d42ba9118237794f7c");
dragon_disciple.AddComponent(Common.prerequisiteNoArchetype(archetype.GetParentClass(), archetype));
}
static BlueprintCharacterClass[] getOccultistArray()
{
return(new BlueprintCharacterClass[] { archetype.GetParentClass() });
}
static void createCorpseCompanion()
{
var undead_class = library.Get <BlueprintCharacterClass>("19a2d9e58d916d04db4cd7ad2c7a3ee2");
corpse_companion_archetype = Helpers.Create <BlueprintArchetype>(a =>
{
a.name = "CorpseCompanionArchetype";
a.LocalizedName = Helpers.CreateString($"{a.name}.Name", "Corpse Companion");
a.LocalizedDescription = Helpers.CreateString($"{a.name}.Description", undead_class.Description);
});
Helpers.SetField(corpse_companion_archetype, "m_ParentClass", undead_class);
library.AddAsset(corpse_companion_archetype, "");
corpse_companion_archetype.RemoveFeatures = new LevelEntry[0];
var companion_proficiency = library.CopyAndAdd <BlueprintFeature>("a23591cc77086494ba20880f87e73970", "CorpseCompanionProficiency", "");
companion_proficiency.SetNameDescription("Proficiencies", "Your corpse companion is proficient with all simple and martial weapons and with all armor (heavy, light, and medium) and shields (including tower shields).");
var str_dex_bonus = library.CopyAndAdd <BlueprintFeature>("0c80276018694f24fbaf59ec7b841f2b", "CorpseCompanionStrDexIncreaseFeature", "");
str_dex_bonus.SetNameDescription("Physical Prowess", "Corpse companion receives +1 bonus to their Strength and Dexterity.");
var size_increase1 = Helpers.CreateFeature("CorpseCompanionLargeFeature",
"Size Increase: Large",
"Corpse companion growth in size and receives +4 to its strength, -2 to dexterity and +10 feet bonus to speed.",
"",
Helpers.GetIcon("c60969e7f264e6d4b84a1499fdcf9039"),
FeatureGroup.None,
Helpers.Create <SizeMechanics.PermanentSizeOverride>(a => a.size = Size.Large),
Helpers.CreateAddStatBonus(StatType.Strength, 4, ModifierDescriptor.Racial),
Helpers.CreateAddStatBonus(StatType.Dexterity, -2, ModifierDescriptor.Racial),
Helpers.CreateAddStatBonus(StatType.Speed, 10, ModifierDescriptor.Racial)
);
var size_increase2 = Helpers.CreateFeature("CorpseCompanionHugeFeature",
"Size Increase: Huge",
"Corpse companion growth in size and receives +4 to its strength, -2 to dexterity, +1 bonus to natural armor and +10 feet bonus to speed..",
"",
Helpers.GetIcon("c60969e7f264e6d4b84a1499fdcf9039"),
FeatureGroup.None,
Helpers.Create <SizeMechanics.PermanentSizeOverride>(a => a.size = Size.Huge),
Helpers.CreateAddStatBonus(StatType.Strength, 4, ModifierDescriptor.Racial),
Helpers.CreateAddStatBonus(StatType.Dexterity, -2, ModifierDescriptor.Racial),
Helpers.CreateAddStatBonus(StatType.AC, 1, ModifierDescriptor.NaturalArmor),
Helpers.CreateAddStatBonus(StatType.Speed, 10, ModifierDescriptor.Racial)
);
corpse_companion_archetype.AddFeatures = new LevelEntry[] { Helpers.LevelEntry(1, companion_proficiency),
Helpers.LevelEntry(2, str_dex_bonus),
Helpers.LevelEntry(4, str_dex_bonus),
Helpers.LevelEntry(6, str_dex_bonus),
Helpers.LevelEntry(7, size_increase1),
Helpers.LevelEntry(12, str_dex_bonus),
Helpers.LevelEntry(8, str_dex_bonus),
Helpers.LevelEntry(12, str_dex_bonus),
Helpers.LevelEntry(14, str_dex_bonus),
Helpers.LevelEntry(15, size_increase2),
Helpers.LevelEntry(16, str_dex_bonus),
Helpers.LevelEntry(18, str_dex_bonus),
Helpers.LevelEntry(20, str_dex_bonus) };
undead_class.Archetypes = undead_class.Archetypes.AddToArray(corpse_companion_archetype);
var skeleton = library.CopyAndAdd <BlueprintUnit>("6c94133d39dea8544a591836c78eaaf3", "CorpseCompanionSkeletonUnit", "");
skeleton.LocalizedName = skeleton.LocalizedName.CreateCopy();
skeleton.LocalizedName.String = Helpers.CreateString(skeleton.name + ".Name", "Corpse Companion");
skeleton.Body = skeleton.Body.CloneObject();
skeleton.Body.PrimaryHand = null;
skeleton.Body.Armor = null;
skeleton.Body.EmptyHandWeapon = library.Get <BlueprintItemWeapon>("118fdd03e569a66459ab01a20af6811a"); //claw 1d4
skeleton.Faction = library.Get <BlueprintFaction>("d8de50cc80eb4dc409a983991e0b77ad"); //neutrals
skeleton.RemoveComponents <Experience>();
skeleton.RemoveComponents <AddTags>();
skeleton.AddComponent(Helpers.Create <AllowDyingCondition>());
skeleton.AddComponent(Helpers.Create <AddResurrectOnRest>());
skeleton.AddComponent(Helpers.Create <Eidolon.CorpseCompanionComponent>());
skeleton.ReplaceComponent <AddClassLevels>(a =>
{
a.DoNotApplyAutomatically = true;
a.Archetypes = new BlueprintArchetype[] { corpse_companion_archetype };
a.Levels = 0;
a.Skills = new StatType[0];
}
);
Helpers.SetField(skeleton, "m_Portrait", Helpers.createPortrait("CorpseCompanionProtrait", "CorpseCompanion", ""));
corpse_companion = Helpers.CreateFeature("CorpseCompanionFeature",
"Corpse Companion",
"With a ritual requiring 8 hours, an undead lord can animate a single skeleton whose Hit Dice do not exceed her cleric level. This corpse companion automatically follows her commands and does not need to be controlled by her. She cannot have more than one corpse companion at a time. It does not count against the number of Hit Dice of undead controlled by other methods.",
"",
Helpers.GetIcon("a1a8bf61cadaa4143b2d4966f2d1142e"), //undead bloodline
FeatureGroup.AnimalCompanion,
library.Get <BlueprintFeature>("126712ef923ab204983d6f107629c895").ComponentsArray
);
corpse_companion.IsClassFeature = true;
corpse_companion.ReapplyOnLevelUp = true;
corpse_companion.ReplaceComponent <AddPet>(a => { a.Pet = skeleton; a.UpgradeLevel = 100; });
corpse_companion.AddComponent(Helpers.Create <CompanionMechanics.CustomLevelProgression>());
var rank_profgression = library.CopyAndAdd <BlueprintProgression>("3853d5405ebfc0f4a86930bb7082b43b", "CorpseCOmpanionClericProgression", "");
rank_profgression.Classes = new BlueprintCharacterClass[] { archetype.GetParentClass() };
corpse_companion_selection = Helpers.CreateFeatureSelection("CorpseCompanionFeatureSelection",
corpse_companion.Name,
corpse_companion.Description,
"",
corpse_companion.Icon,
FeatureGroup.None,
Helpers.Create <AddFeatureOnApply>(a => a.Feature = library.Get <BlueprintFeature>("1670990255e4fe948a863bafd5dbda5d")),
Helpers.Create <AddFeatureOnApply>(a => a.Feature = rank_profgression)
);
corpse_companion_selection.Group = FeatureGroup.AnimalCompanion;
corpse_companion_selection.AllFeatures = corpse_companion_selection.AllFeatures.AddToArray(corpse_companion);
}
static void createBottledAlly()
{
var spells = new BlueprintAbility[]
{
library.Get<BlueprintAbility>("c6147854641924442a3bb736080cfeb6"),//I
library.Get<BlueprintAbility>("298148133cdc3fd42889b99c82711986"),//II
library.Get<BlueprintAbility>("c83db50513abdf74ca103651931fac4b"),//VI
library.Get<BlueprintAbility>("8f98a22f35ca6684a983363d32e51bfe"),//V
library.Get<BlueprintAbility>("051b979e7d7f8ec41b9fa35d04746b33"),//VII
library.Get<BlueprintAbility>("a7469ef84ba50ac4cbf3d145e3173f8e"),//IX
};
var descriptions = new string[]
{
"At 2nd level, a preservationist adds Handle Animal to his list of class skills. He adds summon nature’s ally I to his formula book as a 1st-level extract. When he prepares that extract, he actually prepares a tiny, preserved specimen in a bottle (as with a caster casting the spell, the preservationist doesn’t have to choose the creature until he uses the extract). When the alchemist opens the bottle, the specimen animates and grows to normal size, serving the preservationist as per the spell and otherwise being treated as a summoned creature. When the duration expires, the preserved creature decays into powder. he Augment Summoning feat can be applied to these specimens.",
"At 5th level, a preservationist adds summon nature’s ally II to his formula book as a 2nd-level extract.",
"At 8th level, a preservationist adds summon nature’s ally IV to his formula book as a 3rd-level extract.",
"At 10th level, a preservationist adds summon nature’s ally V to his formula book as a 4th-level extract.",
"At 14th level, a preservationist adds summon nature’s ally VII to his formula book as a 5th-level extract.",
"At 18th level, a preservationist adds summon nature’s ally IX to his formula book as a 6th-level extract."
};
for (int i = 0; i < spells.Length; i++)
{
var base_spell = library.CopyAndAdd(spells[i], "Preservationist" + spells[i].name, "");
Common.unsetAsFullRoundAction(base_spell);
base_spell.RemoveComponents<SpellListComponent>();
if (base_spell.HasVariants)
{
var variants = new List<BlueprintAbility>();
foreach (var v in base_spell.Variants)
{
var new_variant = library.CopyAndAdd(v, "Preservationist" + v.name, "");
Common.unsetAsFullRoundAction(new_variant);
new_variant.RemoveComponents<SpellListComponent>();
variants.Add(new_variant);
}
base_spell.ReplaceComponent<AbilityVariants>(base_spell.CreateAbilityVariants(variants));
}
bottled_ally[i] = Helpers.CreateFeature($"PreservationistBottledAlly{i + 1}Feature",
"Bottled Ally " + Common.roman_id[i + 1],
descriptions[i],
"",
base_spell.Icon,
FeatureGroup.None,
Helpers.CreateAddKnownSpell(base_spell, archetype.GetParentClass(), i + 1)
);
}
}
internal static void create()
{
var paladin_class = ResourcesLibrary.TryGetBlueprint <BlueprintCharacterClass>("bfa11238e7ae3544bbeb4d0b92e897ec");
archetype = Helpers.Create <BlueprintArchetype>(a =>
{
a.name = "IroranPaladinArchetype";
a.LocalizedName = Helpers.CreateString($"{a.name}.Name", "Iroran Paladin");
a.LocalizedDescription = Helpers.CreateString($"{a.name}.Description", "Iroran paladins meditate on self-perfection and train relentlessly, knowing that their example can inspire others to excel. Irori offers no universal paladin code— each paladin in his service creates his own code as part of his spiritual journey, seeing the adherence to such a self-formulated creed as one of the many tests one must face to reach perfection.");
});
Helpers.SetField(archetype, "m_ParentClass", paladin_class);
library.AddAsset(archetype, "");
archetype.ReplaceClassSkills = true;
archetype.ClassSkills = archetype.GetParentClass().ClassSkills.AddToArray(StatType.SkillAthletics, StatType.SkillMobility);
createConfidentDefense();
createUnarmedStrike();
createPersonalTrial();
createDivineBody();
createKiPool();
createAuraOfExcellence();
createAuraOfPerfection();
var paladin_proficiencies = library.Get <BlueprintFeature>("b10ff88c03308b649b50c31611c2fefb");
var smite_evil = library.Get <BlueprintFeature>("3a6db57fce75b0244a6a5819528ddf26");
var smite_evil_extra = library.Get <BlueprintFeature>("0f5c99ffb9c084545bbbe960b825d137");
var weapon_bond_feature = library.Get <BlueprintFeature>("1c7cdc1605554954f838d85bbdd22d90");
var paladin_deity = library.Get <BlueprintFeatureSelection>("a7c8b73528d34c2479b4bd638503da1d");
var aura_of_courage = library.Get <BlueprintFeature>("e45ab30f49215054e83b4ea12165409f");
var weapon_bond_extra_use = library.Get <BlueprintFeature>("5a64de5435667da4eae2e4c95ec87917");
var aura_of_justice = library.Get <BlueprintFeature>("9f13fdd044ccb8a439f27417481cb00e");
var channel_energy = library.Get <BlueprintFeature>("cb6d55dda5ab906459d18a435994a760");
irori = Common.featureToFeature(library.Get <BlueprintFeature>("23a77a5985de08349820429ce1b5a234"), false, "", "IroranPaladin");
irori.SetDescription("Iroran paladin must worship Irori.");
var improved_unarmed_strike = library.Get <BlueprintFeature>("7812ad3672a4b9a4fb894ea402095167");
archetype.RemoveFeatures = new LevelEntry[] { Helpers.LevelEntry(1, paladin_proficiencies, paladin_deity, smite_evil),
Helpers.LevelEntry(3, aura_of_courage),
Helpers.LevelEntry(4, smite_evil_extra, channel_energy),
Helpers.LevelEntry(5, weapon_bond_feature),
Helpers.LevelEntry(7, smite_evil_extra),
Helpers.LevelEntry(10, smite_evil_extra),
Helpers.LevelEntry(11, aura_of_justice),
Helpers.LevelEntry(13, smite_evil_extra),
Helpers.LevelEntry(16, smite_evil_extra),
Helpers.LevelEntry(19, smite_evil_extra), };
archetype.AddFeatures = new LevelEntry[] { Helpers.LevelEntry(1, irori, personal_trial, confident_defense, unarmed_strike, improved_unarmed_strike),
Helpers.LevelEntry(3, aura_of_excellence),
Helpers.LevelEntry(4, ki_pool, ki_strike_magic, personal_trial_extra_use),
Helpers.LevelEntry(5, divine_body),
Helpers.LevelEntry(7, ki_strike_cold_iron_silver),
Helpers.LevelEntry(8, personal_trial_extra_use),
Helpers.LevelEntry(10, ki_strike_lawful),
Helpers.LevelEntry(11, aura_of_perfection),
Helpers.LevelEntry(12, personal_trial_extra_use),
Helpers.LevelEntry(16, ki_strike_adamantine, personal_trial_extra_use),
Helpers.LevelEntry(20, personal_trial_extra_use), };
paladin_class.Progression.UIDeterminatorsGroup = paladin_class.Progression.UIDeterminatorsGroup.AddToArray(irori, confident_defense);
paladin_class.Progression.UIGroups[0].Features.Add(divine_body);
paladin_class.Progression.UIGroups[1].Features.Add(personal_trial);
paladin_class.Progression.UIGroups[1].Features.Add(personal_trial_extra_use);
paladin_class.Progression.UIGroups[2].Features.Add(aura_of_excellence);
paladin_class.Progression.UIGroups[2].Features.Add(aura_of_perfection);
paladin_class.Progression.UIGroups[2].Features.Add(ki_pool);
paladin_class.Progression.UIGroups = paladin_class.Progression.UIGroups.AddToArray(Helpers.CreateUIGroup(ki_strike_magic, ki_strike_cold_iron_silver, ki_strike_lawful, ki_strike_adamantine));
paladin_class.Archetypes = paladin_class.Archetypes.AddToArray(archetype);
}
static void createPerformance()
{
var cleric = library.Get <BlueprintCharacterClass>("67819271767a9dd4fbfd4ae700befea0");
var resource = library.Get <BlueprintAbilityResource>("e190ba276831b5c4fa28737e5e49e6a6");
ClassToProgression.addClassToResource(cleric, new BlueprintArchetype[] { archetype }, resource, library.Get <BlueprintCharacterClass>("772c83a25e2268e448e841dcd548235f"));
var archatype_list_feature = Helpers.CreateFeature("BardicPerformanceArchetypeExtensionFeature",
"",
"",
"",
null,
FeatureGroup.None);
archatype_list_feature.AddComponent(Helpers.Create <ContextRankConfigArchetypeList>(c => c.archetypes = new BlueprintArchetype[] { archetype }));
archatype_list_feature.HideInCharacterSheetAndLevelUp = true;
var inspire_courage_ability = library.CopyAndAdd <BlueprintActivatableAbility>("70274c5aa9124424c984217b62dabee8", "EvangelistInspireCourageToggleAbility", "");
inspire_courage_ability.SetDescription("A 1st level evangelist can use his performance to inspire courage in his allies (including himself), bolstering them against fear and improving their combat abilities. To be affected, an ally must be able to perceive the evangelist's performance. An affected ally receives a +1 morale bonus on saving throws against charm and fear effects and a +1 competence bonus on attack and weapon damage rolls. At 5th level, and every six evangelist levels thereafter, this bonus increases by +1, to a maximum of +4 at 17th level.");
var inspire_courage_buff = library.Get <BlueprintBuff>("6d6d9e06b76f5204a8b7856c78607d5d");
ClassToProgression.addClassToBuff(cleric, new BlueprintArchetype[] { archetype }, inspire_courage_ability.Buff, library.Get <BlueprintCharacterClass>("772c83a25e2268e448e841dcd548235f"));
var inspire_competence_ability = library.CopyAndAdd <BlueprintActivatableAbility>("430ab3bb57f2cfc46b7b3a68afd4f74e", "EvangelistInspireCompetenceToggleAbility", "");
inspire_competence_ability.SetDescription("An evangelist of 3rd level or higher can use his performance to help allies succeed at a task. They must be within 30 feet and able to see and hear the evangelist. They get a +2 competence bonus on all skill checks as long as they continue to hear the evangelist's performance. This bonus increases by +1 for every four levels the evangelist has attained beyond 3rd (+3 at 7th, +4 at 11th, +5 at 15th, and +6 at 19th).");
ClassToProgression.addClassToBuff(cleric, new BlueprintArchetype[] { archetype }, inspire_competence_ability.Buff, library.Get <BlueprintCharacterClass>("772c83a25e2268e448e841dcd548235f"));
var inspire_greatness_ability = library.CopyAndAdd <BlueprintActivatableAbility>("be36959e44ac33641ba9e0204f3d227b", "EvangelistInspireGreatnessToggleAbility", "");
inspire_greatness_ability.SetDescription("An evangelist of 9th level or higher can use his performance to inspire greatness in all allies within 30 feet, granting extra fighting capability. A creature inspired with greatness gains 2 bonus Hit Dice (d10s), the commensurate number of temporary hit points (apply the target's Constitution modifier, if any, to these bonus Hit Dice), a +2 competence bonus on attack rolls, and a +1 competence bonus on Fortitude saves.");
var inspire_heroics_ability = library.CopyAndAdd <BlueprintActivatableAbility>("a4ce06371f09f504fa86fcf6d0e021e4", "EvangelistInspireHeroicsToggleAbility", "");
inspire_heroics_ability.SetDescription("An evangelist of 15th level or higher can inspire tremendous heroism in all allies within 30 feet. Inspired creatures gain a +4 morale bonus on saving throws and a +4 dodge bonus to AC. The effect lasts for as long as the targets are able to witness the performance.");
var fascinate_ability = library.CopyAndAdd <BlueprintActivatableAbility>("993908ad3fb81f34ba0ed168b7c61f58", "EvangelistFascinateToggleAbility", "");
fascinate_ability.SetDescription("At 6th level, an evangelist can use his performance to cause one or more creatures to become fascinated with him. Each creature to be fascinated must be within 30 feet.\nEach creature within range receives a Will save (DC 10 + 1/2 the evangelist's level + the evangelist's Cha modifier) to negate the effect. If a creature's saving throw succeeds, the evangelist cannot attempt to fascinate that creature again for 24 hours. If its saving throw fails, the creature stands quietly and observes the performance for as long as the bard continues to maintain it. Any damage to the target automatically breaks the effect.");
var fasciante_area = library.CopyAndAdd <BlueprintAbilityAreaEffect>("a4fc1c0798359974e99e1d790935501d", "EvangelistFascianteArea", "");
fasciante_area.ReplaceComponent <ContextCalculateAbilityParamsBasedOnClass>(c => c.CharacterClass = cleric);
var fascinate_buff = library.CopyAndAdd <BlueprintBuff>("555930f121b364a4e82670b433028728", "EvangelistFascianteBuff", "");
fascinate_buff.SetDescription(fascinate_ability.Description);
fascinate_buff.ReplaceComponent <AddAreaEffect>(a => a.AreaEffect = fasciante_area);
fascinate_ability.Buff = fascinate_buff;
inspire_courage = Common.ActivatableAbilityToFeature(inspire_courage_ability, false);
inspire_competence = Common.ActivatableAbilityToFeature(inspire_competence_ability, false);
inspire_heroics = Common.ActivatableAbilityToFeature(inspire_heroics_ability, false);
inspire_greatness = Common.ActivatableAbilityToFeature(inspire_greatness_ability, false);
fascinate = Common.ActivatableAbilityToFeature(fascinate_ability, false);
performance_resource = library.CopyAndAdd <BlueprintFeature>("b92bfc201c6a79e49afd0b5cfbfc269f", "EvangelistPerformanceResource", "");
performance_resource.ReplaceComponent <IncreaseResourcesByClass>(i => i.CharacterClass = cleric);
performance_resource = library.Get <BlueprintFeature>("b92bfc201c6a79e49afd0b5cfbfc269f");
performance_resource.AddComponent(Helpers.Create <NewMechanics.IncreaseResourcesByClassWithArchetype>(i =>
{
i.CharacterClass = archetype.GetParentClass();
i.Archetype = archetype;
i.Resource = resource;
}));
}
static void createPainStrike()
{
var sickened = library.Get <BlueprintBuff>("4e42460798665fd4cb9173ffa7ada323");
var apply_buff = Common.createContextActionApplyBuff(sickened, Helpers.CreateContextDuration(0, DurationRate.Rounds, DiceType.D4, 1), dispellable: false);
var apply_buff_saved = Helpers.CreateActionSavingThrow(SavingThrowType.Fortitude, Helpers.CreateConditionalSaved(null, apply_buff));
var buff = Helpers.CreateBuff("ExecutionerPainStrikeBuff",
"Painful Strike",
"Executioners are trained to cause excruciating pain when striking targets, often leaving them reeling in agony or completely incapacitated as they slowly bleed out. A creature that takes sneak attack damage from an executioner must make a successful a Fortitude save (DC = 10 + 1/2 the executioner’s class level + his Intelligence modifier) or become sickened for 1d4 rounds.",
"",
sickened.Icon,
null,
Helpers.Create <AddInitiatorAttackRollTrigger>(a =>
{
a.OnlyHit = true;
a.SneakAttack = true;
a.Action = Helpers.CreateActionList(apply_buff_saved);
}
),
Common.createContextCalculateAbilityParamsBasedOnClass(archetype.GetParentClass(), StatType.Intelligence)
);
Common.addToSlayerStudiedTargetDC(buff);
var toggle = Helpers.CreateActivatableAbility("ExecutionerPainStrikeToggleAbility",
buff.Name,
buff.Description,
"",
buff.Icon,
buff,
AbilityActivationType.Immediately,
UnitCommand.CommandType.Free,
null
);
toggle.Group = ActivatableAbilityGroupExtension.SneakAttack.ToActivatableAbilityGroup();
toggle.DeactivateImmediately = true;
pain_strike = Common.ActivatableAbilityToFeature(toggle, false);
pain_strike.SetDescription("At 4th level, an executioner automatically gains this talent. " + toggle.Description);
}
static void createPsychicPoolEnchants()
{
var brilliant_energy = Common.createEnchantmentAbility("MindBladeWeaponEnchancementBrilliantEnergy",
"Psychic Weapon - Brilliant Energy",
"A mindblade can add the brilliant energy property to her psychic weapon, but this consumes 4 points of enhancement bonus granted to this weapon.\nA brilliant energy weapon ignores nonliving matter.Armor and shield bonuses to AC (including any enhancement bonuses to that armor) do not count against it because the weapon passes through armor. (Dexterity, deflection, dodge, natural armor, and other such bonuses still apply.) A brilliant energy weapon cannot harm undead, constructs, or objects.",
library.Get <BlueprintActivatableAbility>("f1eec5cc68099384cbfc6964049b24fa").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("66e9e299c9002ea4bb65b6f300e43770"),
4, ActivatableAbilityGroup.ArcaneWeaponProperty);
var flaming = Common.createEnchantmentAbility("MindBladeWeaponEnchancementFlaming",
"Psychic Weapon - Flaming",
"A mindblade can add the flaming property to her psychic weapon, but this consumes 1 point of enhancement bonus granted to this weapon.\nA flaming weapon is sheathed in fire that deals an extra 1d6 points of fire damage on a successful hit. The fire does not harm the wielder.",
library.Get <BlueprintActivatableAbility>("7902941ef70a0dc44bcfc174d6193386").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("30f90becaaac51f41bf56641966c4121"),
1, ActivatableAbilityGroup.ArcaneWeaponProperty);
var speed = Common.createEnchantmentAbility("MindBladeWeaponEnchancementSpeed",
"Psychic Weapon - Speed",
"A mindblade can add the speed property to her psychic weapon, but this consumes 3 points of enhancement bonus granted to this weapon.\nWhen making a full attack, the wielder of a speed weapon may make one extra attack with it. The attack uses the wielder's full base attack bonus, plus any modifiers appropriate to the situation. (This benefit is not cumulative with similar effects, such as a haste spell.)",
library.Get <BlueprintActivatableAbility>("85742dd6788c6914f96ddc4628b23932").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("f1c0c50108025d546b2554674ea1c006"),
3, ActivatableAbilityGroup.ArcaneWeaponProperty);
var frost = Common.createEnchantmentAbility("MindBladeWeaponEnchancementFrost",
"Psychic Weapon - Frost",
"A mindblade can add the frost property to her psychic weapon, but this consumes 1 point of enhancement bonus granted to this weapon.\nA frost weapon is sheathed in a terrible, icy cold that deals an extra 1d6 points of cold damage on a successful hit. The cold does not harm the wielder.",
library.Get <BlueprintActivatableAbility>("b338e43a8f81a2f43a73a4ae676353a5").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("421e54078b7719d40915ce0672511d0b"),
1, ActivatableAbilityGroup.ArcaneWeaponProperty);
var shock = Common.createEnchantmentAbility("MindBladeWeaponEnchancementShock",
"Psychic Weapon - Shock",
"A mindblade can add the shock property to her psychic weapon, but this consumes 1 point of enhancement bonus granted to this weapon.\nA shock weapon is sheathed in crackling electricity that deals an extra 1d6 points of electricity damage on a successful hit. The electricity does not harm the wielder.",
library.Get <BlueprintActivatableAbility>("a3a9e9a2f909cd74e9aee7788a7ec0c6").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("7bda5277d36ad114f9f9fd21d0dab658"),
1, ActivatableAbilityGroup.ArcaneWeaponProperty);
var ghost_touch = Common.createEnchantmentAbility("MindBladeWeaponEnchancementGhostTouch",
"Psychic Weapon - Ghost Touch",
"A mindblade can add the ghost touch property to her psychic weapon, but this consumes 1 point of enhancement bonus granted to this weapon.\nA ghost touch weapon deals damage normally against incorporeal creatures, regardless of its bonus. An incorporeal creature's 50% reduction in damage from corporeal sources does not apply to attacks made against it with ghost touch weapons.",
library.Get <BlueprintActivatableAbility>("688d42200cbb2334c8e27191c123d18f").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("47857e1a5a3ec1a46adf6491b1423b4f"),
1, ActivatableAbilityGroup.ArcaneWeaponProperty,
AlignmentMaskType.TrueNeutral);
var keen = Common.createEnchantmentAbility("MindBladeWeaponEnchancementKeen",
"Psychic Weapon - Keen",
"A mindblade can add the keen property to her psychic weapon, but this consumes 1 point of enhancement bonus granted to this weapon.\nThe keen property doubles the threat range of a weapon. This benefit doesn't stack with any other effects that expand the threat range of a weapon (such as the keen edge spell or the Improved Critical feat).",
library.Get <BlueprintActivatableAbility>("27d76f1afda08a64d897cc81201b5218").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("102a9c8c9b7a75e4fb5844e79deaf4c0"),
1, ActivatableAbilityGroup.ArcaneWeaponProperty);
var holy = Common.createEnchantmentAbility("MindBladeWeaponEnchancementHoly",
"Psychic Weapon - Holy",
"A mindblade can add the holy property to her psychic weapon, but this consumes 2 points of enhancement bonus granted to this weapon.\nA holy weapon is imbued with holy power. This power makes the weapon good-aligned and thus overcomes the corresponding damage reduction. It deals an extra 2d6 points of damage against all creatures of evil alignment.",
library.Get <BlueprintActivatableAbility>("ce0ece459ebed9941bb096f559f36fa8").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("28a9964d81fedae44bae3ca45710c140"),
2, ActivatableAbilityGroup.ArcaneWeaponProperty,
AlignmentMaskType.Good);
var unholy = Common.createEnchantmentAbility("MindBladeWeaponEnchancementUnholy",
"Psychic Weapon - Unholy",
"A mindblade can add the unholy property to her psychic weapon, but this consumes 2 points of enhancement bonus granted to this weapon.\nAn unholy weapon is imbued with unholy power. This power makes the weapon evil-aligned and thus overcomes the corresponding damage reduction. It deals an extra 2d6 points of damage against all creatures of good alignment.",
library.Get <BlueprintActivatableAbility>("561803a819460f34ea1fe079edabecce").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("d05753b8df780fc4bb55b318f06af453"),
2, ActivatableAbilityGroup.ArcaneWeaponProperty,
AlignmentMaskType.Evil);
var axiomatic = Common.createEnchantmentAbility("MindBladeWeaponEnchancementAxiomatic",
"Psychic Weapon - Axiomatic",
"A mindblade can add the axiomatic property to her psychic weapon, but this consumes 2 points of enhancement bonus granted to this weapon.\nAn axiomatic weapon is infused with lawful power. It makes the weapon lawful-aligned and thus overcomes the corresponding damage reduction. It deals an extra 2d6 points of damage against chaotic creatures.",
library.Get <BlueprintActivatableAbility>("d76e8a80ab14ac942b6a9b8aaa5860b1").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("0ca43051edefcad4b9b2240aa36dc8d4"),
2, ActivatableAbilityGroup.ArcaneWeaponProperty,
AlignmentMaskType.Lawful);
var anarchic = Common.createEnchantmentAbility("MindBladeWeaponEnchancementAnarchic",
"Psychic Weapon - Anarchic",
"A mindblade can add the anarchic property to her psychic weapon, but this consumes 2 points of enhancement bonus granted to this weapon.\nAn anarchic weapon is infused with the power of chaos. It makes the weapon chaotic-aligned and thus overcomes the corresponding damage reduction. It deals an extra 2d6 points of damage against all creatures of lawful alignment.",
library.Get <BlueprintActivatableAbility>("8ed07b0cc56223c46953348f849f3309").Icon,
mind_blade_weapon_buffs.ToArray(),
library.Get <BlueprintWeaponEnchantment>("57315bc1e1f62a741be0efde688087e9"),
2, ActivatableAbilityGroup.ArcaneWeaponProperty,
AlignmentMaskType.Chaotic);
for (int i = 0; i < 6; i++)
{
psychic_pool_update[i] = Helpers.CreateFeature($"MindBladeWeaponEnhancement{i+1}Feature",
"Psychic Pool",
psychic_pool.Description,
"",
psychic_pool.Icon,
FeatureGroup.None,
Common.createIncreaseActivatableAbilityGroupSize(ActivatableAbilityGroup.ArcaneWeaponProperty)
);
}
psychic_pool_update[0].AddComponent(Helpers.CreateAddFacts(flaming, frost, shock, keen));
psychic_pool_update[2].AddComponent(Helpers.CreateAddFacts(speed));
var devoted_blade = library.CopyAndAdd <BlueprintFeature>("4be0bb10e110a35419e406da767bd1e3", "MindBladeDevotedBladeFeature", "");
devoted_blade.ComponentsArray = new BlueprintComponent[]
{
Helpers.CreateAddFacts(anarchic, axiomatic, holy, unholy),
Common.createPrerequisiteArchetypeLevel(archetype.GetParentClass(), archetype, 12)
};
var ghost_blade = library.CopyAndAdd <BlueprintFeature>("8896f327c59569c4eaf129bf35b96c1f", "MindBladeGhostBladeFeature", "");
ghost_blade.ComponentsArray = new BlueprintComponent[]
{
Helpers.CreateAddFacts(ghost_blade, brilliant_energy),
Common.createPrerequisiteArchetypeLevel(archetype.GetParentClass(), archetype, 9)
};
var arcana_selection = library.Get <BlueprintFeatureSelection>("e9dc4dfc73eaaf94aae27e0ed6cc9ada");
arcana_selection.AllFeatures = arcana_selection.AllFeatures.AddToArray(devoted_blade, ghost_blade);
}
static void createNatureBondAndWindLord()
{
var domains = new BlueprintProgression[] { library.Get <BlueprintProgression>("4a3516fdc4cda764ebd1279b22d10205"),
library.Get <BlueprintProgression>("3aef017b78329db4fa53fe8560069886") };
foreach (var d in domains)
{
var spell_list = d.LevelEntries[0].Features[1].GetComponent <AddSpecialSpellList>().SpellList;
var primary_domain = library.CopyAndAdd <BlueprintProgression>(d.AssetGuid, "StormLord" + d.name, "");
var spells = Common.getSpellsFromSpellList(spell_list);
var spells_array = Common.createSpelllistsForSpontaneousConversion(spells);
for (int i = 0; i < spells_array.Length; i++)
{
primary_domain.AddComponent(Common.createSpontaneousSpellConversion(archetype.GetParentClass(), spells_array[i].ToArray()));
}
var secondary_domain = library.CopyAndAdd <BlueprintProgression>(primary_domain.AssetGuid, "StormLordSecondary" + d.name, "");
List <LevelEntry> secondary_level_entries = new List <LevelEntry>();
secondary_level_entries.Add(Helpers.LevelEntry(9));
foreach (var level_entry in d.LevelEntries)
{
if (level_entry.Level <= 9)
{
secondary_level_entries[0].Features.AddRange(level_entry.Features);
}
else
{
secondary_level_entries.Add(level_entry);
}
}
secondary_domain.LevelEntries = secondary_level_entries.ToArray();
secondary_domain.AddComponent(Helpers.PrerequisiteNoFeature(primary_domain));
domain_primary_progressions.Add(primary_domain);
domain_secondary_progressions.Add(secondary_domain);
}
nature_bond = Helpers.CreateFeatureSelection("NatureBondStormLordFeatureSelection",
"Nature Bond",
"A storm druid may not choose an animal companion. A storm druid must choose the Air or Weather domain.",
"",
library.Get <BlueprintAbility>("7cfbefe0931257344b2cb7ddc4cdff6f").Icon, //storm bolts
FeatureGroup.DruidDomain);
nature_bond.AllFeatures = domain_primary_progressions.ToArray();
wind_lord = Helpers.CreateFeatureSelection("WindLordStormLordFeatureSelection",
"Wind Lord",
"At 9th level, a storm druid can select another domain or subdomain from those available to her through her nature bond.",
"",
library.Get <BlueprintFeature>("f2fa7541f18b8af4896fbaf9f2a21dfe").Icon, //cyclone
FeatureGroup.DruidDomain);
wind_lord.AllFeatures = domain_secondary_progressions.ToArray();
spontaneous_casting = Helpers.CreateFeature("SpontaneousCastingStormLord",
"Spontaneous Domain Casting",
"A storm druid can channel stored spell energy into domain spells that she has not prepared ahead of time. She can “lose” a prepared spell in order to cast any domain spell of the same level or lower.",
"",
library.Get <BlueprintAbility>("0bd54216d38852947930320f6269a9d7").Icon,
FeatureGroup.None
);
}
static public void create()
{
var ranger_class = ResourcesLibrary.TryGetBlueprint <BlueprintCharacterClass>("cda0615668a6df14eb36ba19ee881af6");
archetype = Helpers.Create <BlueprintArchetype>(a =>
{
a.name = "FeywardenArchetype";
a.LocalizedName = Helpers.CreateString($"{a.name}.Name", "Feywarden");
a.LocalizedDescription = Helpers.CreateString($"{a.name}.Description", "While most rangers have a spiritual connection to the natural world, some have a stronger connection to the First World and its denizens: the fey. Many of these feywardens have had some significant encounter with fey at some point in their lives, though some merely share the creatures’ spontaneity and wildly shifting emotions. ");
});
Helpers.SetField(archetype, "m_ParentClass", ranger_class);
library.AddAsset(archetype, "");
createSpellbook();
createFeyMagic();
resist_natures_lure = library.Get <BlueprintFeature>("ad6a5b0e1a65c3540986cf9a7b006388"); //description is already updated by hunter class
archetype.ReplaceClassSkills = true;
archetype.ReplaceSpellbook = spellbook;
archetype.ChangeCasterType = true;
archetype.IsDivineCaster = true;
archetype.ClassSkills = new StatType[] { StatType.SkillPersuasion, StatType.SkillLoreNature, StatType.SkillStealth, StatType.SkillThievery, StatType.SkillPerception, StatType.SkillKnowledgeArcana, StatType.SkillUseMagicDevice };
archetype.FortitudeSave = library.Get <BlueprintStatProgression>("dc0c7c1aba755c54f96c089cdf7d14a3"); //low
archetype.WillSave = library.Get <BlueprintStatProgression>("ff4662bde9e75f145853417313842751"); //low
var endurance = library.Get <BlueprintFeature>("54ee847996c25cd4ba8773d7b8555174");
archetype.RemoveFeatures = new LevelEntry[] { Helpers.LevelEntry(3, endurance) };
fey_touched = Helpers.CreateFeature("FeytouchedFeyWardenFeature",
"Feytouched",
"Any of the feywarden’s class abilities that make calculations based on her Wisdom (including bonus feats with DCs or uses per day, but not Wisdom-based skills or Will saving throws) are instead based on her Charisma. Additionally, a feywarden’s base Will save bonus from her ranger levels is equal to 2 + ½ her ranger level, but her base Fortitude save bonus is equal to ⅓ her ranger level.\n"
+ "The feywarden gains Trickery and Use Magic Device as class skills, in place of Athletics and Knowledge (World).",
"",
Helpers.GetIcon("e8445256abbdc45488c2d90373f7dae8"), //bloodline fey
FeatureGroup.None
);
fixRangerAbilitiesScaling();
archetype.AddFeatures = new LevelEntry[] { Helpers.LevelEntry(1, fey_touched),
Helpers.LevelEntry(3, resist_natures_lure),
Helpers.LevelEntry(4, fey_magic),
Helpers.LevelEntry(7, fey_magic_extra_spell[0]),
Helpers.LevelEntry(10, fey_magic_extra_spell[1]),
Helpers.LevelEntry(13, fey_magic_extra_spell[2]),
Helpers.LevelEntry(16, fey_magic_extra_spell[3]), };
ranger_class.Progression.UIGroups = ranger_class.Progression.UIGroups.AddToArray(Helpers.CreateUIGroup(fey_magic_extra_spell.AddToArray(resist_natures_lure, fey_magic)));
ranger_class.Progression.UIDeterminatorsGroup = ranger_class.Progression.UIDeterminatorsGroup.AddToArray(fey_touched);
ranger_class.Archetypes = ranger_class.Archetypes.AddToArray(archetype);
//need to create different progression for mt
var ranger_mt = library.Get <BlueprintProgression>("a823e7aa48bbec24f87f4a92a3ac0aa2");
ranger_mt.AddComponent(Common.prerequisiteNoArchetype(archetype));
Common.addMTDivineSpellbookProgression(archetype.GetParentClass(), spellbook, "MysticTheurgeFeyWardenProgression",
Common.createPrerequisiteArchetypeLevel(archetype, 1),
Common.createPrerequisiteClassSpellLevel(archetype.GetParentClass(), 2)
);
}