static BlueprintFeature CreateFearless(BlueprintProgression bloodline)
{
var dazzled = library.CopyAndAdd <BlueprintBuff>("df6d1025da07524429afbae248845ecc",
"LightSensitivityDazzled", "949ae82dd5a441b08da1390c1c3c8d84");
// Add Light Sensitivity until we get fearless rank 2.
var lightSensitive = Helpers.CreateFeature("BloodlineOrcLightSensitivity", "Light Sensitivity",
"Creatures with light sensitivity are dazzled in areas of bright sunlight or within the radius of a daylight spell.",
"6a25396d38094003b6492648891abbf4",
Helpers.GetIcon("bf0accce250381a44b857d4af6c8e10d"), // searing light
FeatureGroup.None,
Helpers.Create <OrcLightSensitivity>());
OrcLightSensitivity.DazzledBuff = dazzled;
dazzled.SetDescription($"{dazzled.Description}\n{lightSensitive.Name}: {lightSensitive.Description}");
var fearless1 = Helpers.CreateFeature("BloodlineOrcFearlessLevel1",
"Fearless",
"At 3rd level, you gain a +4 bonus on saving throws made against fear and a +1 natural armor bonus. At 9th level, you lose your light sensitivity, gain immunity to fear, and your natural armor bonus increases to +2.",
"6c28b22514804978adcc4223c4c37791",
Helpers.GetIcon("e45ab30f49215054e83b4ea12165409f"), // Aura of Courage
FeatureGroup.None,
Helpers.Create <SavingThrowBonusAgainstDescriptor>(a =>
{
a.Bonus = 4;
a.ModifierDescriptor = ModifierDescriptor.Inherent;
a.SpellDescriptor = SpellDescriptor.Fear;
}),
Helpers.CreateAddStatBonus(StatType.AC, 1, ModifierDescriptor.NaturalArmor));
var fearless2 = Helpers.CreateFeature("BloodlineOrcFearlessLevel2",
fearless1.Name,
fearless1.Description,
"37224d428eac41cebba8b5710872401c",
fearless1.Icon,
FeatureGroup.None,
SpellDescriptor.Fear.CreateBuffImmunity(),
SpellDescriptor.Fear.CreateSpellImmunity(),
Helpers.CreateAddStatBonus(StatType.AC, 2, ModifierDescriptor.NaturalArmor),
Helpers.Create <RemoveFeatureOnApply>(r => r.Feature = lightSensitive));
orcArcana.AddComponent(Helpers.Create <AddFeatureIfHasFact>(a =>
{
a.Feature = lightSensitive;
a.CheckedFact = fearless2;
a.Not = true;
}));
var addFeat = Helpers.CreateFeature($"BloodlineOrcFearlessAdd",
fearless1.Name, fearless1.Description,
"1afbd239a03744f39a8e66ad8ae74f75",
fearless1.Icon,
FeatureGroup.None,
fearless1.CreateAddFeatureOnClassLevel(9, bloodline.Classes, bloodline.Archetypes, before: true),
fearless2.CreateAddFeatureOnClassLevel(9, bloodline.Classes, bloodline.Archetypes));
return(addFeat);
}
void createSpiritAbility()
{
var resource = Helpers.CreateAbilityResource(prefix + "ChannelResource", "", "", "", null);
resource.SetIncreasedByStat(1, hex_engine.hex_secondary_stat);
var positive_energy_feature = library.Get <BlueprintFeature>("a79013ff4bcd4864cb669622a29ddafb");
var context_rank_config = Helpers.CreateContextRankConfig(baseValueType: ContextRankBaseValueType.ClassLevel, progression: ContextRankProgression.StartPlusDivStep,
type: AbilityRankType.Default, classes: hex_engine.hex_classes, startLevel: 1, stepLevel: 2);
var dc_scaling = Common.createContextCalculateAbilityParamsBasedOnClasses(hex_engine.hex_classes, hex_engine.hex_secondary_stat);
spirit_ability = Helpers.CreateFeature(prefix + "LifeSpiritChannelPositiveEnergyFeature",
"Channel Positive Energy",
"Shaman channels positive energy and can choose to deal damage to undead creatures or to heal living creatures.\nChanneling energy causes a burst that either heals all living creatures or damages all undead creatures in a 30-foot radius centered on the shaman. The amount of damage dealt or healed is equal to 1d6 points of damage plus 1d6 points of damage for every two shaman levels beyond 1st (2d6 at 3rd, 3d6 at 5th, and so on). Creatures that take damage from channeled energy receive a Will save to halve the damage. The DC of this save is equal to 10 + 1/2 the shaman's level + the shaman's Charisma modifier. Creatures healed by channel energy cannot exceed their maximum hit point total—all excess healing is lost. A shaman may channel energy a number of times per day equal to 1 + her Charisma modifier. This is a standard action that does not provoke an attack of opportunity. A shaman can choose whether or not to include herself in this effect.",
"",
positive_energy_feature.Icon,
FeatureGroup.None);
heal_living = ChannelEnergyEngine.createChannelEnergy(ChannelEnergyEngine.ChannelType.PositiveHeal,
prefix + "LifeSpiritChannelEnergyHealLiving",
"",
"Channeling positive energy causes a burst that heals all living creatures in a 30 - foot radius centered on the shaman. The amount of damage healed is equal to 1d6 plus 1d6 for every two shaman levels beyond first.",
"",
context_rank_config,
dc_scaling,
Helpers.CreateResourceLogic(resource));
harm_undead = ChannelEnergyEngine.createChannelEnergy(ChannelEnergyEngine.ChannelType.PositiveHarm,
prefix + "LifeSpiritChannelEnergyHarmUndead",
"",
"Channeling energy causes a burst that damages all undead creatures in a 30 - foot radius centered on the shaman. The amount of damage dealt is equal to 1d6 plus 1d6 for every two shaman levels beyond first. Creatures that take damage from channeled energy receive a Will save to halve the damage. The DC of this save is equal to 10 + 1 / 2 the shaman's level + the shaman's Charisma modifier.",
"",
context_rank_config,
dc_scaling,
Helpers.CreateResourceLogic(resource));
var heal_living_base = Common.createVariantWrapper(prefix + "LifeSpiritPositiveHealBase", "", heal_living);
var harm_undead_base = Common.createVariantWrapper(prefix + "LifeSpiritPositiveHarmBase", "", harm_undead);
ChannelEnergyEngine.storeChannel(heal_living, spirit_ability, ChannelEnergyEngine.ChannelType.PositiveHeal);
ChannelEnergyEngine.storeChannel(harm_undead, spirit_ability, ChannelEnergyEngine.ChannelType.PositiveHarm);
spirit_ability.AddComponent(Helpers.CreateAddFacts(heal_living_base, harm_undead_base));
spirit_ability.AddComponent(Helpers.CreateAddAbilityResource(resource));
extra_channel = ChannelEnergyEngine.createExtraChannelFeat(heal_living, spirit_ability, extra_channel_prefix + "ExtraChannelShamanLifeSpirit", extra_channel_name, "");
}
static void createTinkering()
{
tinkering = library.CopyAndAdd <BlueprintFeature>("dbb6b3bffe6db3547b31c3711653838e", "SeekerSorcererTinkeringFeature", "");
tinkering.SetNameDescription("Tinkering",
"Seekers often look to ancient devices, old tomes, and strange magical items in order to learn more about their sorcerous bloodlines. As a result of this curiosity and thanks to an innate knack at deciphering the strange and weird, a seeker gains Disable Device as a class skill. In addition, at 1st level, a seeker adds half his oracle or sorcerer level on Perception checks made to locate traps and on all Disable Device skill checks (minimum +1). A seeker can use Disable Device to disarm magical traps. If the seeker also possesses levels in rogue or another class that provides the trapfinding ability, those levels stack with his sorcerer levels for determining his overall bonus on these skill checks."
);
tinkering.ReplaceComponent <ContextRankConfig>(c => Helpers.SetField(c, "m_Class", new BlueprintCharacterClass[] { archetype.GetParentClass() }));
tinkering.AddComponent(Helpers.Create <AddClassSkill>(a => a.Skill = StatType.SkillThievery));
}
static void createBleedingAttack()
{
var bleed1d6 = library.Get <BlueprintBuff>("75039846c3d85d940aa96c249b97e562");
var icon = NewSpells.deadly_juggernaut.Icon;
var effect_buff = Helpers.CreateBuff("RogueBleedingAttackEffectBuff",
"Bleeding Attack Effect",
"A rogue with this ability can cause living opponents to bleed by hitting them with a sneak attack. This attack causes the target to take 1 additional point of damage each round for each die of the rogue’s sneak attack (e.g., 4d6 equals 4 points of bleed). Bleeding creatures take that amount of damage every round at the start of each of their turns. The bleeding can be stopped by a successful DC 15 Heal check or the application of any effect that heals hit point damage. Bleed damage from this ability does not stack with itself. Bleed damage bypasses any damage reduction the creature might possess.",
"",
icon,
null,
Helpers.Create <BleedMechanics.BleedBuff>(b => b.dice_value = Helpers.CreateContextDiceValue(DiceType.Zero, 0, Helpers.CreateContextValue(AbilityRankType.Default))),
Helpers.CreateContextRankConfig(ContextRankBaseValueType.CustomProperty, customProperty: NewMechanics.SneakAttackDiceGetter.Blueprint.Value),
Helpers.CreateSpellDescriptor(SpellDescriptor.Bleed),
bleed1d6.GetComponent <CombatStateTrigger>(),
bleed1d6.GetComponent <AddHealTrigger>()
);
var apply_buff = Common.createContextActionApplyBuff(effect_buff, Helpers.CreateContextDuration(), dispellable: false, is_permanent: true);
var buff = Helpers.CreateBuff("RogueBleedingAttackBuff",
"Bleeding Attack",
effect_buff.Description,
"",
icon,
null,
Helpers.Create <AddInitiatorAttackRollTrigger>(a =>
{
a.OnlyHit = true;
a.SneakAttack = true;
a.Action = Helpers.CreateActionList(apply_buff);
}
)
);
var toggle = Helpers.CreateActivatableAbility("RogueBleedingAttackToggleAbility",
buff.Name,
buff.Description,
"",
buff.Icon,
buff,
AbilityActivationType.Immediately,
UnitCommand.CommandType.Free,
null
);
toggle.Group = ActivatableAbilityGroupExtension.SneakAttack.ToActivatableAbilityGroup();
toggle.DeactivateImmediately = true;
bleeding_attack = Common.ActivatableAbilityToFeature(toggle, false);
bleeding_attack.AddComponent(Helpers.PrerequisiteFeature(library.Get <BlueprintFeature>("9b9eac6709e1c084cb18c3a366e0ec87")));//sneak attack
addToTalentSelection(bleeding_attack, for_investigator: false);
var medical_discoveries = library.Get <BlueprintFeatureSelection>("67f499218a0e22944abab6fe1c9eaeee");
medical_discoveries.AllFeatures = medical_discoveries.AllFeatures.AddToArray(bleeding_attack);
}
static void createChannelEnergyDomainProgression()
{
//add to domains
var druid = library.Get <BlueprintCharacterClass>("610d836f3a3a9ed42a4349b62f002e96");
var domain_selection = library.Get <BlueprintFeatureSelection>("48525e5da45c9c243a343fc6545dbdb9");
var cleric_secondary_domain_selection = library.Get <BlueprintFeatureSelection>("43281c3d7fe18cc4d91928395837cd1e");
var druid_domain_selection = library.Get <BlueprintFeatureSelection>("5edfe84c93823d04f8c40ca2b4e0f039");
var blight_druid_domain_selection = library.Get <BlueprintFeatureSelection>("096fc02f6cc817a43991c4b437e12b8e");
var cleric = library.Get <BlueprintCharacterClass>("67819271767a9dd4fbfd4ae700befea0");
ClassToProgression.addClassToDomains(dawnflower_anchorite, new BlueprintArchetype[0], ClassToProgression.DomainSpellsType.NoSpells, domain_selection, cleric);
ClassToProgression.addClassToDomains(dawnflower_anchorite, new BlueprintArchetype[0], ClassToProgression.DomainSpellsType.NoSpells, cleric_secondary_domain_selection, cleric);
ClassToProgression.addClassToDomains(dawnflower_anchorite, new BlueprintArchetype[0], ClassToProgression.DomainSpellsType.NoSpells, blight_druid_domain_selection, druid);
ClassToProgression.addClassToDomains(dawnflower_anchorite, new BlueprintArchetype[0], ClassToProgression.DomainSpellsType.NoSpells, druid_domain_selection, druid);
ChannelEnergyEngine.addClassToChannelEnergyProgression(dawnflower_anchorite);
foreach (var p in Archetypes.StormDruid.domain_secondary_progressions)
{
ClassToProgression.addClassToProgression(dawnflower_anchorite, new BlueprintArchetype[0], ClassToProgression.DomainSpellsType.NoSpells, p, druid);
}
foreach (var p in Wildshape.wildshape_progressions)
{
ClassToProgression.addClassToProgression(dawnflower_anchorite, new BlueprintArchetype[0], ClassToProgression.DomainSpellsType.NoSpells, p, p.Classes[0]);
}
//remove dawnflower anchorite from animal domains
var domain_animal_companion_progression = library.Get <BlueprintProgression>("125af359f8bc9a145968b5d8fd8159b8");
domain_animal_companion_progression.Classes = domain_animal_companion_progression.Classes.RemoveFromArray(dawnflower_anchorite);
var druid_animal_domain_selection = library.Get <BlueprintProgression>("a75ad4936e099c54881cf553e2110703");
foreach (var a in druid_animal_domain_selection.GetComponents <AddFeatureOnClassLevel>())
{
a.AdditionalClasses = a.AdditionalClasses.RemoveFromArray(dawnflower_anchorite);
}
channel_energy_domain_progression = Helpers.CreateFeature("DawnflowerAnchoriteChannelDomainProgressionFeature",
"Focused",
"The character adds his Dawnflower anchorite class levels to his effective class level in the corresponding class for the purpose of determining the effects of the following features: "
+ "Domains, Channel Energy, Animal Companion and Wildshape.",
"",
Helpers.GetIcon("a5e23522eda32dc45801e32c05dc9f96"), //good hope
FeatureGroup.None
);
var animal_companion_rank = library.Get <BlueprintFeature>("1670990255e4fe948a863bafd5dbda5d");
for (int i = 1; i <= 10; i++)
{
channel_energy_domain_progression.AddComponent(Helpers.CreateAddFeatureOnClassLevelIfHasFact(animal_companion_rank, i, getDawnflowerAcnchoriteArray(), animal_companion_rank));
}
}
static public void Test()
{
BlueprintFeature abjurationFeat = library.Get <BlueprintFeature>("30f20e6f850519b48aa59e8c0ff66ae9");
BlueprintSpellList abjurationSpellList = library.Get <BlueprintSpellList>("c7a55e475659a944f9229d89c4dc3a8e");
abjurationFeat.AddComponent(Helpers.Create <AddSpecialSpellList>(a => {
a.CharacterClass = ArcanistClass.arcanist;
a.SpellList = abjurationSpellList;
}));
}
static void createBondedItem()
{
var item_bond_ability = library.CopyAndAdd <BlueprintAbility>("e5dcf71e02e08fc448d9745653845df1", "SkirnirItemBond", "");
item_bond_ability.SetDescription("At 1st level, a skirnir gains a shield (except for a tower shield) as an arcane bond item. This is identical to the wizard class ability, but the skirnir may only bond with a shield, not a familiar or other item.");
item_bond_ability.AddComponent(Helpers.Create <NewMechanics.AbilityCasterHasShield>());
bonded_item = Common.AbilityToFeature(item_bond_ability, false);
bonded_item.AddComponent(item_bond_ability.GetComponent <AbilityResourceLogic>().RequiredResource.CreateAddAbilityResource());
}
static void createFamiliar()
{
familiar = library.CopyAndAdd <BlueprintFeatureSelection>("363cab72f77c47745bf3a8807074d183", "MagusFamiliarFeatureSelection", "");
familiar.ComponentsArray = new BlueprintComponent[0];
familiar.Groups = new FeatureGroup[] { FeatureGroup.MagusArcana };
familiar.SetDescription("The magus gains a familiar.");
familiar.AddComponent(Helpers.PrerequisiteNoFeature(familiar));
magus_arcana.AllFeatures = magus_arcana.AllFeatures.AddToArray(familiar);
eldritch_magus_arcana.AllFeatures = eldritch_magus_arcana.AllFeatures.AddToArray(familiar);
}
static void createRostlandBravoProficiencies()
{
rostland_bravo_proficiencies = library.CopyAndAdd <BlueprintFeature>("8f8c2640ffad89349883fc2e5ff2091e", //magus proficiencies
"RostlandBravoSwashbucklerProficiencies",
"12f3c40bac26460f97ec10e3e5e28035");
rostland_bravo_proficiencies.RemoveComponents <ArcaneArmorProficiency>();
rostland_bravo_proficiencies.AddComponent(Common.createAddWeaponProficiencies(WeaponCategory.DuelingSword));
rostland_bravo_proficiencies.SetName("Rostland Bravo Proficiencies");
rostland_bravo_proficiencies.SetDescription("The Rostland bravo is not proficient with bucklers.");
}
static void addToNinjaTricks(BlueprintFeature feature, bool advanced = false)
{
var advanced_talents = library.Get <BlueprintFeature>("a33b99f95322d6741af83e9381b2391c");
feature.Groups = feature.Groups.AddToArray(FeatureGroup.RogueTalent);
ninja_trick.AllFeatures = ninja_trick.AllFeatures.AddToArray(feature);
if (advanced)
{
feature.AddComponent(Helpers.PrerequisiteFeature(advanced_talents));
}
}
static void createHeraldicExpertise()
{
var resource = Helpers.CreateAbilityResource("HeraldicExpertiseResource", "", "", "", null);
resource.SetIncreasedByLevelStartPlusDivStep(1, 10, 1, 5, 1, 0, 0.0f, new BlueprintCharacterClass[] { archetype.GetParentClass() });
heraldic_expertise = Helpers.CreateFeature("HeraldicExpertiseFeature",
"Heraldic Expertise",
"A court bard gains a bonus equal to half his bard level on Persuasion and Knowledge (World) checks (minimum +1). Once per day, the court bard can also reroll a check against one of these skills, though he must take the result of the second roll even if it is worse. He can reroll one additional time per day at 5th level and every five levels thereafter.",
"",
Helpers.GetIcon("446f7bf201dc1934f96ac0a26e324803"), //eagles splendor
FeatureGroup.None,
Helpers.CreateAddContextStatBonus(StatType.SkillPersuasion, ModifierDescriptor.UntypedStackable),
Helpers.CreateAddContextStatBonus(StatType.SkillKnowledgeWorld, ModifierDescriptor.UntypedStackable),
Helpers.CreateContextRankConfig(ContextRankBaseValueType.ClassLevel, classes: new BlueprintCharacterClass[] { archetype.GetParentClass() },
progression: ContextRankProgression.Div2, min: 1),
resource.CreateAddAbilityResource()
);
var buff = Helpers.CreateBuff("HeraldicExpertiseBuff",
heraldic_expertise.Name,
heraldic_expertise.Description,
"",
heraldic_expertise.Icon,
null,
Helpers.Create <NewMechanics.ModifyD20WithActions>(m => {
m.SpecificSkill = true;
m.Skill = new StatType[] { StatType.CheckDiplomacy, StatType.CheckIntimidate, StatType.CheckBluff, StatType.SkillKnowledgeWorld };
m.RollsAmount = 1;
m.TakeBest = true;
m.Rule = NewMechanics.ModifyD20WithActions.RuleType.SkillCheck;
m.RerollOnlyIfFailed = true;
//m.DispellOnRerollFinished = true;
m.required_resource = resource;
m.actions = Helpers.CreateActionList(Common.createContextActionSpendResource(resource, 1));
})
);
var ability = Helpers.CreateActivatableAbility("HeraldicExpertiseToggleAbility",
buff.Name,
buff.Description,
"",
buff.Icon,
buff,
AbilityActivationType.Immediately,
Kingmaker.UnitLogic.Commands.Base.UnitCommand.CommandType.Free,
null,
Helpers.CreateActivatableResourceLogic(resource, ActivatableAbilityResourceLogic.ResourceSpendType.Never)
);
ability.DeactivateImmediately = true;
heraldic_expertise.AddComponent(Helpers.CreateAddFact(ability));
}
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 private void FixOppositionSchoolFeats()
{
//fix opposition school feats so that they can function on arcanist class
foreach (string featId in config.SchoolOppositionFeatureIds)
{
BlueprintFeature feat = library.Get <BlueprintFeature>(featId);
SpellSchool school = feat.GetComponent <AddOppositionSchool>().School;
feat.AddComponent(Helpers.Create <AddOppositionSchool>(a => {
a.CharacterClass = ArcanistClass.arcanist;
a.School = school;
}));
}
}
static void createFlurry()
{
flurry1 = Helpers.CreateFeature("ZenArcherFlurry1Feature",
"Flurry of Blows",
"Starting at 1st level, a zen archer can make a flurry of blows as a full-attack action, but only when using a bow (even though it is a ranged weapon). He may not make a flurry of blows with his unarmed attacks or any other weapons. A zen archer does not apply his Strength bonus on damage rolls made with flurry of blows unless he is using a composite bow with a Strength rating.\n"
+ "A zen archer’s flurry of blows otherwise functions as normal for a monk of his level. (One additional attack at highest base attack bonus. Stacks with bonus attacks from haste and other similar effects. At 11th level, one additional attack at highest base attack bonus).\n"
+ "A zen archer cannot use Rapid Shot or Manyshot when making a flurry of blows with his bow.",
"",
zen_archer_proficiencies.Icon,
FeatureGroup.None);
flurry11 = Helpers.CreateFeature("ZenArcherFlurry11Feature",
flurry1.Name,
flurry1.Description,
"",
zen_archer_proficiencies.Icon,
FeatureGroup.None);
var buff = Helpers.CreateBuff("ZenArcherFlurryBuff",
flurry11.Name,
flurry1.Description,
"",
flurry1.Icon,
null,
Helpers.Create <NewMechanics.BuffExtraAttackCategorySpecific>(b =>
{
b.categories = new WeaponCategory[] { WeaponCategory.Longbow, WeaponCategory.Shortbow };
b.num_attacks = Helpers.CreateContextValue(AbilityRankType.Default);
}
),
Helpers.CreateContextRankConfig(ContextRankBaseValueType.FeatureList, featureList: new BlueprintFeature[] { flurry1, flurry11 }),
Helpers.Create <FeatureMechanics.DeactivateManyshot>()
);
var ability = Helpers.CreateActivatableAbility("ZenarcherFlurryToggleAbility",
buff.Name,
buff.Description,
"",
buff.Icon,
buff,
AbilityActivationType.Immediately,
CommandType.Free,
null);
ability.IsOnByDefault = true;
ability.Group = ActivatableAbilityGroupExtension.RapidShot.ToActivatableAbilityGroup();
//fix rapid shot
library.Get <BlueprintActivatableAbility>("90a77bfe25ec2e14caf8bd5cde9febf2").Group = ability.Group;
flurry1.AddComponent(Helpers.CreateAddFact(ability));
}
static void addToQuickChannel(BlueprintAbility channel, BlueprintFeature parent_feature, ChannelType channel_type)
{
if (quick_channel == null)
{
return;
}
var features_from_list = quick_channel.GetComponent <PrerequisiteFeaturesFromList>();
if (features_from_list == null)
{
features_from_list = Helpers.PrerequisiteFeaturesFromList(parent_feature);
quick_channel.AddComponent(features_from_list);
}
if (!features_from_list.Features.Contains(parent_feature))
{
features_from_list.Features = features_from_list.Features.AddToArray(parent_feature);
}
var quicken_ability = library.CopyAndAdd <BlueprintAbility>(channel.AssetGuid, "Quick" + channel.name, channel.AssetGuid, "e936d73a1dfe42efb1765b980c80e113");
quicken_ability.ActionType = Kingmaker.UnitLogic.Commands.Base.UnitCommand.CommandType.Move;
quicken_ability.SetName(quicken_ability.Name + $" ({quick_channel.Name})");
var resource_logic = quicken_ability.GetComponent <AbilityResourceLogic>();
var amount = resource_logic.Amount;
quicken_ability.ReplaceComponent <AbilityResourceLogic>(c => { c.Amount = amount * 2; });
updateItemsForQuick(channel, quicken_ability);
var quicken_feature = Common.AbilityToFeature(quicken_ability, guid: Helpers.MergeIds(quicken_ability.AssetGuid, parent_feature.AssetGuid));
quick_channel.AddComponent(Common.createAddFeatureIfHasFact(parent_feature, quicken_feature));
parent_feature.AddComponent(Common.createAddFeatureIfHasFact(quick_channel, quicken_feature));
storeChannel(quicken_ability, parent_feature, channel_type);
}
void createSpiritAbility()
{
var resource = Helpers.CreateAbilityResource(prefix + "MonstrousInsightResource", "", "", "", null);
resource.SetIncreasedByStat(3, secondary_stat);
var icon = library.Get <BlueprintFeature>("ee0b69e90bac14446a4cf9a050f87f2e").Icon; //detect magic
var lore_action = Helpers.Create <NewMechanics.MonsterLore.ContextMonsterLoreCheck>(c =>
{
c.value = Helpers.CreateContextValue(AbilityRankType.Default);
c.descriptor = ModifierDescriptor.Insight;
}
);
var buff = Helpers.CreateBuff(prefix + "MonstrousInsightBuff",
"Monstrous Insight",
"The shaman can identify creatures and gain insight into their strengths and weaknesses. As a standard action, the shaman can attempt a Knowledge skill check to identify a creature and its abilities (using the appropriate skill for the monster’s type) with an insight bonus equal to her shaman level. Whether or not the check is successful, she also gains a +2 insight bonus for 1 minute on attack rolls made against that creature and a +2 insight bonus to her AC against attacks made by that creature. The shaman can use this ability a number of times per day equal to 3 + her Charisma modifier.",
"",
icon,
null,
Helpers.Create <AttackBonusAgainstTarget>(c => { c.Value = Common.createSimpleContextValue(2); c.CheckCaster = true; }),
Helpers.Create <ACBonusAgainstTarget>(c => { c.Value = Common.createSimpleContextValue(2); c.CheckCaster = true; c.Descriptor = ModifierDescriptor.Insight; })
);
var apply_buff = Common.createContextActionApplyBuff(buff, Helpers.CreateContextDuration(1, DurationRate.Minutes), dispellable: false);
var ability = Helpers.CreateAbility(prefix + "MonstrousInsightAbility",
buff.Name,
buff.Description,
"",
buff.Icon,
AbilityType.Supernatural,
CommandType.Standard,
AbilityRange.Touch,
Helpers.oneMinuteDuration,
Helpers.savingThrowNone,
Helpers.CreateDeliverTouch(),
Helpers.CreateRunActions(lore_action, apply_buff),
Helpers.Create <NewMechanics.MonsterLore.AbilityTargetCanBeInspected>(a => a.allow_reinspect = true),
Common.createAbilitySpawnFx("749bb96fb50ee5b4685645472d718465", anchor: AbilitySpawnFxAnchor.SelectedTarget),
Helpers.CreateContextRankConfig(baseValueType: ContextRankBaseValueType.ClassLevel, classes: hex_engine.hex_classes)
);
ability.setMiscAbilityParametersTouchHarmful();
var sticky_touch = Helpers.CreateTouchSpellCast(ability, resource);
sticky_touch.AddComponent(Helpers.Create <NewMechanics.MonsterLore.AbilityTargetCanBeInspected>(a => a.allow_reinspect = true));
spirit_ability = Common.AbilityToFeature(sticky_touch, hide: false);
spirit_ability.AddComponent(Helpers.CreateAddAbilityResource(resource));
}
static void createFeralAppearance()
{
feral_appearance = Helpers.CreateFeature("FeralAppearanceUntamedRagerFeature",
"Feral Appearance",
"At 3rd level, the untamed rager gains a +1 bonus on Intimidate checks. This bonus increases by 1 every 3 barbarian levels thereafter.",
"",
Helpers.GetIcon("d2aeac47450c76347aebbc02e4f463e0"), //fear
FeatureGroup.None,
Helpers.CreateAddContextStatBonus(StatType.CheckIntimidate, ModifierDescriptor.UntypedStackable)
);
feral_appearance.Ranks = 6;
feral_appearance.ReapplyOnLevelUp = true;
feral_appearance.AddComponent(Helpers.CreateContextRankConfig(ContextRankBaseValueType.FeatureRank, feature: feral_appearance));
}
static void createNoTrace()
{
no_trace = Helpers.CreateFeature("NoTraceNinjaFeature",
"No Trace",
"At 3rd level, a ninja gains a +1 bonus on Stealth checks. This bonus increases by 1 every 3 ninja levels thereafter.",
"",
Helpers.GetIcon("97a6aa2b64dd21a4fac67658a91067d7"), //fast stealth
FeatureGroup.None,
Helpers.CreateAddContextStatBonus(StatType.SkillStealth, ModifierDescriptor.UntypedStackable)
);
no_trace.Ranks = 6;
no_trace.ReapplyOnLevelUp = true;
no_trace.AddComponent(Helpers.CreateContextRankConfig(ContextRankBaseValueType.FeatureRank, feature: no_trace));
}
static void createSymbiosis()
{
symbiosis = Helpers.CreateFeature("SymbiosisNatureBondedMagusFeature",
"Symbiosis",
"A 4th level, a nature-bonded magus gains +1 bonus to its natural AC. This bonus increases by 1 at 7th level and every 4 levels thereafter.",
"",
Helpers.GetIcon("5b77d7cc65b8ab74688e74a37fc2f553"), //barkskin
FeatureGroup.None,
Helpers.CreateAddContextStatBonus(StatType.AC, ModifierDescriptor.NaturalArmor)
);
symbiosis.Ranks = 5;
symbiosis.ReapplyOnLevelUp = true;
symbiosis.AddComponent(Helpers.CreateContextRankConfig(ContextRankBaseValueType.FeatureRank, feature: symbiosis));
}
static void createAuraOfExcellence()
{
var ally_buff = Helpers.CreateBuff("AuraOfExcellenceBuff",
"Aura of Excellence",
"At 3rd level, an Iroran paladin is immune to any effect that would force him to reroll a die against his will or roll twice and take the lower result. Whenever an ally within 10 feet of him would reroll a die against her will, she can roll twice and take the higher result. Whenever an ally within 10 feet would be forced to roll twice and take the lower result, she can instead roll three times and take the second-lowest result. This ability functions only while the Iroran paladin is conscious.",
"",
Helpers.GetIcon("d316d3d94d20c674db2c24d7de96f6a7"),
null,
Helpers.Create <RerollsMechanics.ExtraGoodRerollOnTakeWorst>()
);
aura_of_excellence = Common.createAuraEffectFeature(ally_buff.Name, ally_buff.Description, ally_buff.Icon, ally_buff, 13.Feet(), Helpers.CreateConditionsCheckerAnd(Helpers.Create <ContextConditionIsAlly>()));
aura_of_excellence.AddComponent(Helpers.Create <RerollsMechanics.IgnoreTakeWorstRerolls>());
}
static void createCallCelestialAlly()
{
var resource = Helpers.CreateAbilityResource("SacredServantCelestialAllyResource", "", "", "", null);
resource.SetFixedResource(1);
var summons = new BlueprintAbility[]
{
library.Get <BlueprintAbility>("0964bf88b582bed41b74e79596c4f6d9"), //sm v
library.Get <BlueprintAbility>("eb6df7ddfc0669d4fb3fc9af4bd34bca"), //sm vii
library.Get <BlueprintAbility>("e96593e67d206ab49ad1b567327d1e75") //sm ix
};
var summon_actions = new List <ActionList>();
foreach (var s in summons)
{
var sa = s.GetComponent <AbilityEffectRunAction>().Actions.Actions;
sa = Common.changeAction <ContextActionSpawnMonster>(sa, c => c.DurationValue = Helpers.CreateContextDuration(c.DurationValue.BonusValue, DurationRate.Minutes, c.DurationValue.DiceType, c.DurationValue.DiceCountValue));
summon_actions.Add(Helpers.CreateActionList(sa));
}
var ability = Helpers.CreateAbility("SacredServantCallCelestialAllyAbility",
"Call Celestial Ally",
"At 8th level, a sacred servant can call upon her deity for aid, in the form of a powerful servant. This allows the sacred servant to bralani azata once per day as a spell-like ability for 1 minute per sacred servant level. At 12th level, she can summon movanic deva instead. Finally, at 16th level, a sacred servant can summon ghaelle azata.",
"",
Helpers.GetIcon("b1c7576bd06812b42bda3f09ab202f14"),
AbilityType.SpellLike,
CommandType.Standard,
AbilityRange.Close,
Helpers.minutesPerLevelDuration,
"",
resource.CreateResourceLogic(),
Helpers.CreateContextRankConfig(ContextRankBaseValueType.ClassLevel, classes: new BlueprintCharacterClass[] { archetype.GetParentClass() }),
Helpers.CreateContextRankConfig(ContextRankBaseValueType.ClassLevel, ContextRankProgression.DelayedStartPlusDivStep, AbilityRankType.SpeedBonus,
classes: new BlueprintCharacterClass[] { archetype.GetParentClass() }, startLevel: 8, stepLevel: 4),
Helpers.CreateSpellComponent(SpellSchool.Conjuration),
Helpers.CreateSpellDescriptor(SpellDescriptor.Summoning),
Helpers.CreateRunActions(Common.createRunActionsDependingOnContextValue(Helpers.CreateContextValue(AbilityRankType.SpeedBonus),
summon_actions.ToArray()
)
)
);
Common.setAsFullRoundAction(ability);
ability.setMiscAbilityParametersRangedDirectional();
call_celestial_ally = Common.AbilityToFeature(ability, false);
call_celestial_ally.AddComponent(resource.CreateAddAbilityResource());
}
static void createRakesSmile()
{
rakes_smile = Helpers.CreateFeature("RakesSmileFeature",
"Rake’s Smile",
"At 3rd level, a rake gains a +1 morale bonus on Bluff and Diplomacy checks. This bonus increases by +1 for every 3 levels beyond 3rd.",
"",
Helpers.GetIcon("fd4d9fd7f87575d47aafe2a64a6e2d8d"), //hideous laughter
FeatureGroup.None,
Helpers.CreateAddContextStatBonus(StatType.CheckDiplomacy, ModifierDescriptor.Morale),
Helpers.CreateAddContextStatBonus(StatType.CheckBluff, ModifierDescriptor.Morale)
);
rakes_smile.Ranks = 6;
rakes_smile.ReapplyOnLevelUp = true;
rakes_smile.AddComponent(Helpers.CreateContextRankConfig(ContextRankBaseValueType.FeatureRank, feature: rakes_smile));
}
static void createSunbeam()
{
var sunbeam_resource = Helpers.CreateAbilityResource("DawnflowerAnchoriteSunbeamResource", "", "", "", null);
sunbeam_resource.SetIncreasedByLevelStartPlusDivStep(1, 10, 1, 100, 0, 0, 0.0f, getDawnflowerAcnchoriteArray());
var sunbeam_ability = library.CopyAndAdd <BlueprintAbility>("1fca0ba2fdfe2994a8c8bc1f0f2fc5b1", "DawnflowerAnchoriteSunbeam", "");
sunbeam_ability.Type = AbilityType.SpellLike;
sunbeam_ability.AddComponent(sunbeam_resource.CreateResourceLogic());
sunbeam = Common.AbilityToFeature(sunbeam_ability, false);
sunbeam.AddComponent(sunbeam_resource.CreateAddAbilityResource());
sunbeam.SetDescription("At 7th level, a Dawnflower anchorite gains the ability to cast sunbeam once per day as a spell-like ability. His caster level is equal to his Hit Dice, and the save DC is Charisma-based. At 10th level, the Dawnflower anchorite can use this ability twice per day.");
}
static void createDaring()
{
daring = Helpers.CreateFeature("SwshbucklerRogueDaringFeature",
"Daring",
"At 3rd level, a swashbuckler gains a +1 morale bonus on Acrobatics checks and saving throws against fear. This bonus increases by +1 for every 3 levels beyond 3rd. ",
"",
Helpers.GetIcon("4be5757b85af47545a5789f1d03abda9"), //mobility ability
FeatureGroup.None,
Helpers.CreateAddContextStatBonus(StatType.SkillMobility, ModifierDescriptor.Morale),
Common.createContextSavingThrowBonusAgainstDescriptor(Helpers.CreateContextValue(AbilityRankType.Default), ModifierDescriptor.Morale, SpellDescriptor.Fear)
);
daring.Ranks = 6;
daring.ReapplyOnLevelUp = true;
daring.AddComponent(Helpers.CreateContextRankConfig(ContextRankBaseValueType.FeatureRank, feature: daring));
}
static void createCoordiantedShot()
{
var point_blank_shot = library.Get <BlueprintFeature>("0da0c194d6e1d43419eb8d990b28e0ab");
coordinated_shot = Helpers.CreateFeature("CoordinatedShotFeature",
"Coordinated Shot",
"If your ally with this feat is threatening an opponent and is not providing cover to that opponent against your ranged attacks, you gain a +1 bonus on ranged attacks against that opponent. If your ally with this feat is flanking that opponent with another ally (even if that other ally doesn’t have this feat), this bonus increases to +2.",
"",
point_blank_shot.Icon,
FeatureGroup.Feat,
Helpers.PrerequisiteFeature(point_blank_shot));
coordinated_shot.AddComponent(Helpers.Create <NewMechanics.CoordinatedShotAttackBonus>(c =>
{
c.AttackBonus = 1;
c.AdditionalFlankBonus = 1;
c.CoordinatedShotFact = coordinated_shot;
})
);
coordinated_shot.Groups = coordinated_shot.Groups.AddToArray(FeatureGroup.CombatFeat, FeatureGroup.TeamworkFeat);
coordinated_shot.AddComponent(Helpers.PrerequisiteFeature(point_blank_shot));
library.AddCombatFeats(coordinated_shot);
Common.addTemworkFeats(coordinated_shot);
}
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 void createNinjaProficiencies()
{
ninja_proficiencies = library.CopyAndAdd <BlueprintFeature>("33e2a7e4ad9daa54eaf808e1483bb43c", "NinjaProficiencies", "");
ninja_proficiencies.ReplaceComponent <AddProficiencies>(a => a.WeaponProficiencies = new WeaponCategory[]
{
WeaponCategory.Kama,
WeaponCategory.Nunchaku,
WeaponCategory.Sai,
WeaponCategory.Shortbow,
WeaponCategory.Shortsword,
WeaponCategory.Shuriken,
WeaponCategory.Scimitar
});
ninja_proficiencies.AddComponent(Helpers.CreateAddFact(library.Get <BlueprintFeature>("9c37279588fd9e34e9c4cb234857492c")));//duelling sword proficiency
ninja_proficiencies.SetNameDescription("Ninja Proficiencies",
"Ninja are proficient with all simple weapons, plus the kama, dueling sword, nunchaku, sai, shortbow, short sword, shuriken, and scimitar. Ninjas are proficient with light armor but not with shields.");
}
static void addToSelection(BlueprintFeature rage_power, bool is_totem = false)
{
extra_rage_power_selection.AllFeatures = extra_rage_power_selection.AllFeatures.AddToArray(rage_power);
rage_powers_selection.AllFeatures = rage_powers_selection.AllFeatures.AddToArray(rage_power);
if (!is_totem)
{
return;
}
foreach (var t in totems)
{
t.AddComponent(Helpers.PrerequisiteNoFeature(rage_power));
rage_power.AddComponent(Helpers.PrerequisiteNoFeature(t));
}
totems.Add(rage_power);
}
void createManifestation()
{
manifestation = Helpers.CreateFeature(prefix + "StoneManifestationFeature",
"Manifestation",
"Upon reaching 20th level, the shaman becomes a being of acid and earth. The shaman gains acid resistance 30. She can also apply any one of the following feats to any acid or earth spell she casts without increasing the spell’s level or casting time: Reach Spell, Extend Spell. She doesn’t need to possess these feats to use this ability.",
"",
library.Get <BlueprintProgression>("32393034410fb2f4d9c8beaa5c8c8ab7").Icon, //wall of acid
FeatureGroup.None,
Common.createEnergyDR(30, DamageEnergyType.Acid));
var extend = Common.CreateMetamagicAbility(manifestation, "Extend", "Extend Spell (Acid)", Kingmaker.UnitLogic.Abilities.Metamagic.Extend, SpellDescriptor.Acid, "", "");
extend.Group = ActivatableAbilityGroupExtension.ShamanStoneMetamagic.ToActivatableAbilityGroup();
var reach = Common.CreateMetamagicAbility(manifestation, "Reach", "Reach Spell (Acid)", Kingmaker.UnitLogic.Abilities.Metamagic.Reach, SpellDescriptor.Acid, "", "");
reach.Group = ActivatableAbilityGroupExtension.ShamanStoneMetamagic.ToActivatableAbilityGroup();
manifestation.AddComponent(Helpers.CreateAddFacts(extend, reach));
}
void createManifestation()
{
manifestation = Helpers.CreateFeature(prefix + "WavesManifestationFeature",
"Manifestation",
"Upon reaching 20th level, the shaman becomes a spirit of water. The shaman gains cold resistance 30. She can also apply any one of the following feats to any cold spell she casts without increasing the spell’s level or casting time: Reach Spell, Extend Spell. She doesn’t need to possess these feats to use this ability.",
"",
library.Get <BlueprintProgression>("7c692e90592257a4e901d12ae6ec1e41").Icon, //cold wall
FeatureGroup.None,
Common.createEnergyDR(30, DamageEnergyType.Cold));
var extend = Common.CreateMetamagicAbility(manifestation, "Extend", "Extend Spell (Cold)", Kingmaker.UnitLogic.Abilities.Metamagic.Extend, SpellDescriptor.Cold, "", "");
extend.Group = ActivatableAbilityGroupExtension.ShamanWavesMetamagic.ToActivatableAbilityGroup();
var reach = Common.CreateMetamagicAbility(manifestation, "Reach", "Reach Spell (Cold)", Kingmaker.UnitLogic.Abilities.Metamagic.Reach, SpellDescriptor.Cold, "", "");
reach.Group = ActivatableAbilityGroupExtension.ShamanWavesMetamagic.ToActivatableAbilityGroup();
manifestation.AddComponent(Helpers.CreateAddFacts(extend, reach));
}
