public void OnEventAboutToTrigger(RuleCalculateDamage evt)
{
if (!apply_to_natural_attacks || !(evt.ParentRule?.AttackRoll?.Weapon?.Blueprint?.IsNatural).GetValueOrDefault())
{
MechanicsContext context = evt.Reason.Context;
if (context?.SourceAbility == null || !context.SourceAbility.IsSpell)
{
return;
}
if (!Helpers.checkSpellbook(spellbook, specific_class, context.SourceAbilityContext?.Ability?.Spellbook, evt.Initiator.Descriptor))
{
return;
}
var attack_roll = evt.ParentRule?.AttackRoll;
if (attack_roll == null)
{
return;
}
}
foreach (BaseDamage baseDamage in evt.DamageBundle)
{
baseDamage.AddBonus(baseDamage.Dice.Rolls);
}
}
public override void runActions(MechanicsContext context, UnitEntityData target, int dc, int check_result)
{
if (check_result <= dc + dc_bypass)
{
return;
}
var intimidate_value = context.MaybeCaster.Stats.GetStat <ModifiableValueSkill>(StatType.SkillPersuasion).BaseValue;
if (intimidate_value < min_value)
{
return;
}
RuleSavingThrow saving_throw = new RuleSavingThrow(target, SavingThrowType.Will, 10 + intimidate_value);
context.TriggerRule(saving_throw);
if (saving_throw.IsPassed)
{
return;
}
int duration = intimidate_value < upgrade_value ? 1 : RulebookEvent.Dice.D(new DiceFormula(1, DiceType.D4));
target.Descriptor.AddBuff(frightened_buff, context, new TimeSpan?(duration.Rounds().Seconds));
}
public override void RunAction()
{
MechanicsContext.Data data = ElementsContext.GetData <MechanicsContext.Data>();
MechanicsContext mechanicsContext = (data != null) ? data.Context : null;
if (mechanicsContext == null)
{
Main.Logger?.Error("Unable to drop weapons: no context found");
return;
}
UnitEntityData unit = mechanicsContext.MaybeCaster;
if (unit == null)
{
Main.Logger?.Error("Unable to drop weapons: caster is null");
}
if (unit.Descriptor.IsPet || unit.Body.IsPolymorphed)
{
return;
}
var currentWeaponSet = unit.Body.CurrentHandsEquipmentSet;
if (currentWeaponSet.PrimaryHand.CanDrop() || currentWeaponSet.SecondaryHand.CanDrop())
{
unit.Commands.InterruptAll();
unit.Descriptor.Body.DropCurrentWeaponSet();
}
}
public static void Postfix(ContextRankConfig __instance, ref int __result, MechanicsContext context, ref ContextRankBaseValueType ___m_BaseValueType)
{
if (!BloodArcanist.wantToModify_ContextRankConfig.Contains(__instance))
{
return;
}
if (___m_BaseValueType == ContextRankBaseValueType.SummClassLevelWithArchetype)
{
ClassData classdata = context.MaybeCaster.Descriptor.Progression.GetClassData(ArcanistClass.arcanist);
if (classdata != null && classdata.Archetypes.Contains(BloodArcanist.archetype))
{
__result += classdata.Level;
return;
}
}
if (___m_BaseValueType == ContextRankBaseValueType.OwnerSummClassLevelWithArchetype)
{
var maybeOwner = context.MaybeOwner;
if (maybeOwner == null)
{
return;
}
ClassData classdata = maybeOwner.Descriptor.Progression.GetClassData(ArcanistClass.arcanist);
if (classdata != null && classdata.Archetypes.Contains(BloodArcanist.archetype))
{
__result += classdata.Level;
return;
}
}
}
public static string GetDescription(this SimpleBlueprint bp)
// borrowed shamelessly and enhanced from Bag of Tricks https://www.nexusmods.com/pathfinderkingmaker/mods/26, which is under the MIT License
{
try {
// avoid exceptions on known broken items
var guid = bp.AssetGuid;
if (guid == "b60252a8ae028ba498340199f48ead67" || guid == "fb379e61500421143b52c739823b4082")
{
return(null);
}
var associatedBlueprint = bp as IUIDataProvider;
return(associatedBlueprint?.Description.StripHTML());
// Why did BoT do this instead of the above which is what MechanicsContext.SelectUIData() does for description
#if false
var description = bp.Des
UnitReference mainChar = Game.Instance.Player.MainCharacter;
if (mainChar == null)
{
return("");
}
MechanicsContext context = new MechanicsContext((UnitEntityData)null, mainChar.Value.Descriptor, bp, (MechanicsContext)null, (TargetWrapper)null);
return(context?.SelectUIData(UIDataType.Description)?.Description ?? "");
#endif
}
catch (Exception e) {
Console.Write($"{e}");
#if DEBUG
return("ERROR".red().bold() + $": caught exception {e}");
#else
return("");
#endif
}
}
private bool HasConditions(MechanicsContext context, UnitEntityData unit)
{
using (context.GetDataScope(unit))
{
return(this.alias_m_Condition.Check());
}
}
static bool Prefix(ContextRankConfig __instance, MechanicsContext context, ContextRankBaseValueType ___m_BaseValueType,
BlueprintFeature ___m_Feature, ref int __result)
{
if (___m_BaseValueType == ContextRankBaseValueTypeExtender.MasterClassLevel.ToContextRankBaseValueType() ||
___m_BaseValueType == ContextRankBaseValueTypeExtender.MasterMaxClassLevelWithArchetype.ToContextRankBaseValueType())
{
int rankBonus1 = context.Params.RankBonus;
var caster = context.MaybeCaster;
__result = rankBonus1 + getMasterRank(caster.Descriptor, __instance);
return(false);
}
else if (___m_BaseValueType == ContextRankBaseValueTypeExtender.MasterFeatureRank.ToContextRankBaseValueType())
{
if (context.MaybeCaster.Descriptor.IsPet)
{
__result = context.MaybeCaster.Descriptor.Master.Value.Descriptor.Progression.Features.GetRank(___m_Feature);
}
else
{
__result = context.MaybeCaster.Descriptor.Progression.Features.GetRank(___m_Feature);
}
return(false);
}
else
{
return(true);
}
}
public void runActions(MechanicsContext context, UnitEntityData target, int dc, int check_result)
{
foreach (var b in buffs)
{
b.CallComponents <ActionOnDemoralize>(c => c.runActions(context, target, dc, check_result));
}
}
public void OnEventAboutToTrigger(RuleCalculateDamage evt)
{
MechanicsContext context = evt.Reason.Context;
if (context?.SourceAbility == null || !context.SpellDescriptor.HasAnyFlag((Kingmaker.Blueprints.Classes.Spells.SpellDescriptor) this.SpellDescriptor) || !context.SourceAbility.IsSpell)
{
return;
}
if (!Helpers.checkSpellbook(spellbook, specific_class, context.SourceAbilityContext?.Ability?.Spellbook, context.MaybeCaster.Descriptor))
{
return;
}
if (!context.HasMetamagic((Metamagic)MetamagicFeats.MetamagicExtender.ForceFocus))
{
return;
}
foreach (BaseDamage baseDamage in evt.DamageBundle)
{
var dice_formula = baseDamage.Dice;
if (dice_formula.Dice == DiceType.Zero || dice_formula.Rolls <= 0)
{
continue;
}
var dice = dice_formula.Dice;
switch (dice)
{
case DiceType.D4:
{
dice = DiceType.D6;
break;
}
case DiceType.D6:
{
dice = DiceType.D8;
break;
}
case DiceType.D8:
{
dice = DiceType.D10;
break;
}
case DiceType.D10:
{
dice = DiceType.D12;
break;
}
}
baseDamage.ReplaceDice(new DiceFormula(dice_formula.Rolls, dice));
}
}
public override void OnEventDidTrigger(RuleAttackWithWeapon evt)
{
MechanicsContext context = ElementsContext.GetData <MechanicsContext.Data>()?.Context;
if (evt.IsAttackOfOpportunity && (evt.Weapon.Blueprint.Category == WeaponCategory.Dagger || evt.Weapon.Blueprint.Category == WeaponCategory.Starknife) && evt.Target.Descriptor.HasFact(enemy_flag) && evt.AttackRoll.IsHit)
{
evt.Target.Descriptor.AddBuff(debuff, context, new TimeSpan?(4.Seconds()));
}
}
static public bool makeDisbeliefSave(MechanicsContext context, UnitEntityData target)
{
disbelief_save_in_progress = true;
Common.AddBattleLogMessage(target.CharacterName + " attempts a disbelief saving throw");
RuleSavingThrow ruleSavingThrow = context.TriggerRule <RuleSavingThrow>(new RuleSavingThrow(target, SavingThrowType.Will, context.Params.DC));
bool res = ruleSavingThrow.IsPassed;
disbelief_save_in_progress = false;
return(res);
}
public override void RunAction()
{
MechanicsContext context = ElementsContext.GetData <MechanicsContext.Data>()?.Context;
EnchantPoolDataDescription description = new EnchantPoolDataDescription();
if (context == null)
{
UberDebug.LogError((UnityEngine.Object) this, (object)"Unable to apply buff: no context found", (object[])Array.Empty <object>());
}
else
{
Rounds rounds = this.DurationValue.Calculate(context);
UnitEntityData maybeCaster = context.MaybeCaster;
if (maybeCaster == null)
{
UberDebug.LogError((UnityEngine.Object) this, (object)"Can't apply buff: target is null", (object[])Array.Empty <object>());
}
else
{
maybeCaster.Ensure <UnitPartEnchantPoolData>().ClearEnchantPool(this.EnchantPool);
ItemEntity itemEntity = maybeCaster.Body.PrimaryHand.HasWeapon ? (ItemEntity)maybeCaster.Body.PrimaryHand.MaybeWeapon : (ItemEntity)maybeCaster.Body.EmptyHandWeapon;
if (itemEntity == null)
{
return;
}
int num1 = 0;
int groupSize = maybeCaster.Descriptor.Progression.Features.GetRank(Feature);
description.EnchantedItem = itemEntity;
description.EnchantPool = this.EnchantPool;
if (itemEntity.Enchantments.Any <ItemEnchantment>())
{
foreach (WeaponEnhancementBonus enhancementBonus in itemEntity.Enchantments.SelectMany <ItemEnchantment, WeaponEnhancementBonus>((Func <ItemEnchantment, IEnumerable <WeaponEnhancementBonus> >)(e => e.SelectComponents <WeaponEnhancementBonus>())))
{
num1 += enhancementBonus.EnhancementBonus;
}
}
foreach (AddBondProperty selectFactComponent in maybeCaster.Buffs.SelectFactComponents <AddBondProperty>())
{
if (selectFactComponent.EnchantPool == this.EnchantPool && !itemEntity.HasEnchantment(selectFactComponent.Enchant))
{
groupSize -= selectFactComponent.Enchant.EnchantmentCost;
description.Enchantments.Add(itemEntity.AddEnchantment(selectFactComponent.Enchant, context, new Rounds?(rounds)));
}
}
int num2 = Math.Min(Math.Max(0, 5 - num1), groupSize);
if (num2 > 0)
{
description.Enchantments.Add(itemEntity.AddEnchantment(this.DefaultEnchantments[num2 - 1], context, new Rounds?(rounds)));
}
maybeCaster.Ensure <UnitPartEnchantPoolData>().RecordEnchantPool(description);
}
}
}
public bool disbelieved(MechanicsContext context)
{
if (attemptedDisbelief(context))
{
return(disbelief_contexts[getContext(context)]);
}
else
{
return(false);
}
}
static public int getSpellReality(MechanicsContext context)
{
var shadow_spell_component = context?.SourceAbility?.GetComponent <ShadowSpell>();
if (shadow_spell_component != null)
{
return(shadow_spell_component.spell_reality);
}
return(-1);
}
static public MechanicsContext extractMainContext(MechanicsContext context, UnitEntityData context_caster)
{
var shadow_context = extractMainContextInternal(context, context_caster);
if (shadow_context != null && getSpellReality(shadow_context) <= 0)
{
return(null);
}
return(shadow_context);
}
static void Postfix(ContextRankConfig __instance, MechanicsContext context, ContextRankBaseValueType ___m_BaseValueType, bool ___m_ExceptClasses, StatType ___m_Stat,
BlueprintFeature ___m_Feature, BlueprintCharacterClass[] ___m_Class, BlueprintArchetype ___Archetype, ref int __result)
{
switch (___m_BaseValueType)
{
case ContextRankBaseValueType.ClassLevel:
__result += FakeClassLevelMechanics.Helpers.calculateFakeClassLevel(context.MaybeCaster.Descriptor, ___m_Class, new BlueprintArchetype[0]);
return;
case ContextRankBaseValueType.MaxClassLevelWithArchetype:
if (___m_ExceptClasses)
{
return;
}
__result = Math.Max(FakeClassLevelMechanics.Helpers.calculateFakeClassLevel(context.MaybeCaster.Descriptor, ___m_Class, new BlueprintArchetype[] { ___Archetype }) + context.Params.RankBonus, __result);
return;
case ContextRankBaseValueType.SummClassLevelWithArchetype:
int num3 = context.Params.RankBonus;
foreach (Kingmaker.UnitLogic.ClassData classData in context.MaybeCaster.Descriptor.Progression.Classes)
{
if ((___m_ExceptClasses && !(___m_Class).HasItem <BlueprintCharacterClass>(classData.CharacterClass) || !___m_ExceptClasses && (___m_Class).HasItem <BlueprintCharacterClass>(classData.CharacterClass)) && (!((IEnumerable <BlueprintArchetype>)classData.CharacterClass.Archetypes).Contains <BlueprintArchetype>(___Archetype) || classData.Archetypes.Contains(___Archetype)))
{
num3 += classData.Level + context.Params.RankBonus;
}
}
num3 += FakeClassLevelMechanics.Helpers.calculateFakeClassLevel(context.MaybeCaster.Descriptor, ___m_Class, new BlueprintArchetype[] { ___Archetype });
__result = num3;
return;
case ContextRankBaseValueType.OwnerSummClassLevelWithArchetype:
UnitEntityData maybeOwner = context.MaybeOwner;
if (maybeOwner == null)
{
return;
}
int num4 = context.Params.RankBonus;
foreach (Kingmaker.UnitLogic.ClassData classData in maybeOwner.Descriptor.Progression.Classes)
{
if ((___m_ExceptClasses && !(___m_Class).HasItem <BlueprintCharacterClass>(classData.CharacterClass) || !___m_ExceptClasses && (___m_Class).HasItem <BlueprintCharacterClass>(classData.CharacterClass)) && (!((IEnumerable <BlueprintArchetype>)classData.CharacterClass.Archetypes).Contains <BlueprintArchetype>(___Archetype) || classData.Archetypes.Contains(___Archetype)))
{
num4 += classData.Level;
}
}
num4 += FakeClassLevelMechanics.Helpers.calculateFakeClassLevel(maybeOwner.Descriptor, ___m_Class, new BlueprintArchetype[] { ___Archetype });
__result = num4;
return;
default:
return;
}
}
public override void runActions(MechanicsContext context, UnitEntityData target, int dc, int check_result)
{
if (check_result <= dc + dc_bypass)
{
return;
}
var intimidate_value = context.MaybeCaster.Stats.GetStat <ModifiableValueSkill>(StatType.SkillPersuasion).BaseValue;
if (intimidate_value < min_value)
{
return;
}
var spell_descriptors_to_add = new SpellDescriptor[]
{
SpellDescriptor.MindAffecting,
SpellDescriptor.Fear
};
for (int i = 0; i < spell_descriptors_to_add.Length; i++)
{
if ((context.SpellDescriptor & spell_descriptors_to_add[i]) > 0)
{
spell_descriptors_to_add[i] = SpellDescriptor.None;
}
else
{
context.AddSpellDescriptor(spell_descriptors_to_add[i]);
}
}
RuleSavingThrow saving_throw = new RuleSavingThrow(target, SavingThrowType.Will, 10 + intimidate_value);
context.TriggerRule(saving_throw);
foreach (var sd in spell_descriptors_to_add)
{
if (sd != SpellDescriptor.None)
{
context.RemoveSpellDescriptor(sd);
}
}
if (saving_throw.IsPassed)
{
return;
}
int duration = intimidate_value < upgrade_value ? 1 : RulebookEvent.Dice.D(new DiceFormula(1, DiceType.D4));
target.Descriptor.AddBuff(frightened_buff, context, new TimeSpan?(duration.Rounds().Seconds));
}
public override void OnEventDidTrigger(RuleAttackWithWeapon evt)
{
MechanicsContext context = ElementsContext.GetData <MechanicsContext.Data>()?.Context;
if (this.Owner.Body.PrimaryHand.MaybeWeapon != null && (this.Owner.Body.PrimaryHand.MaybeWeapon.Blueprint.Category == WeaponCategory.Dagger || this.Owner.Body.PrimaryHand.MaybeWeapon.Blueprint.Category == WeaponCategory.Starknife) && this.Owner.Unit.CombatState.IsEngage(evt.Initiator))
{
if (this.Owner.Resources.GetResourceAmount(Swashbuckler.panache_resource) > 0 && evt.Target.CombatState.AttackOfOpportunityCount > 0)
{
this.Owner.Resources.Spend(Swashbuckler.panache_resource, 1);
evt.Initiator.Descriptor.AddBuff(enemy_flag, context, new TimeSpan?(1.Seconds()));
Game.Instance.CombatEngagementController.ForceAttackOfOpportunity(this.Owner.Unit, evt.Initiator);
}
}
}
public static void Prefix(BlueprintBuff blueprint, MechanicsContext parentContext, ref Rounds?duration)
{
try {
if (!parentContext?.MaybeCaster?.IsPlayersEnemy ?? false && isGoodBuff(blueprint))
{
if (duration != null)
{
duration = new Rounds((int)(duration.Value.Value * settings.buffDurationMultiplierValue));
}
}
}
catch (Exception e) {
Mod.Error(e);
}
}
static bool Prefix(ContextRankConfig __instance, MechanicsContext context, ContextRankBaseValueType ___m_BaseValueType, ref int __result)
{
if (___m_BaseValueType == ContextRankBaseValueTypeExtender.MasterClassLevel.ToContextRankBaseValueType() ||
___m_BaseValueType == ContextRankBaseValueTypeExtender.MasterMaxClassLevelWithArchetype.ToContextRankBaseValueType())
{
int rankBonus1 = context.Params.RankBonus;
var caster = context.MaybeCaster;
__result = rankBonus1 + getMasterRank(caster.Descriptor, __instance);
return(false);
}
else
{
return(true);
}
}
static public MechanicsContext extractMainContext(MechanicsContext context, UnitEntityData context_caster)
{
var main_context = context?.SourceAbilityContext;
var caster = context_caster ?? main_context?.MaybeCaster;
var summoned_context = ShadowSpells.getShadowBuff(caster?.Descriptor)?.MaybeContext?.SourceAbilityContext;
if (summoned_context != null)
{
return(summoned_context);
}
var parent_context = caster?.Get <UnitPartUseShadowContext>()?.maybeGetShadowContext(main_context);
return(parent_context ?? main_context);
}
public override void OnTurnOff()
{
Main.logger.Log("AddSacredWordBonus OnTurnOff");
MechanicsContext context = ElementsContext.GetData <MechanicsContext.Data>()?.Context;
EnchantPoolDataDescription description = new EnchantPoolDataDescription();
if (context == null)
{
UberDebug.LogError((UnityEngine.Object) this, (object)"Unable to apply buff: no context found", (object[])Array.Empty <object>());
}
else
{
UnitEntityData maybeCaster = context.MaybeCaster;
maybeCaster.Remove <UnitPartEnchantPoolData>();
}
}
public override void OnEventAboutToTrigger(RuleAttackRoll evt)
{
if (!apply_to_natural_attacks || !(evt.Weapon?.Blueprint?.IsNatural).GetValueOrDefault())
{
MechanicsContext context = evt.Reason.Context;
if (context?.SourceAbility == null || !context.SourceAbility.IsSpell)
{
return;
}
if (!Helpers.checkSpellbook(spellbook, specific_class, context.SourceAbilityContext?.Ability?.Spellbook, evt.Initiator.Descriptor))
{
return;
}
}
evt.CriticalConfirmationBonus += value.Calculate(this.Fact.MaybeContext);
}
public override void RunAction()
{
MechanicsContext context = ElementsContext.GetData <MechanicsContext.Data>()?.Context;
if (context == null)
{
UberDebug.LogError((UnityEngine.Object) this, (object)"Unable to apply buff: no context found", (object[])Array.Empty <object>());
}
else
{
UnitEntityData caster = context.MaybeCaster;
UnitEntityData target = this.Target.Unit;
if (caster != null && target != null)
{
caster.Descriptor.Ensure <UnitPartStudiedTarget>().SetTarget(target.Descriptor);
}
}
}
int getUsedHD(MechanicsContext context, BlueprintSummonPool summon_pool)
{
ISummonPool pool = Game.Instance.SummonPools.GetPool(this.SummonPool);
if (pool == null)
{
return(0);
}
int used_hd = 0;
foreach (UnitEntityData unit in pool.Units)
{
if (unit.Get <UnitPartSummonedMonster>().Summoner == context.MaybeCaster)
{
used_hd += unit.Descriptor.Progression.CharacterLevel;
}
}
return(used_hd);
}
int getUsedUnits(MechanicsContext context, BlueprintSummonPool summon_pool)
{
ISummonPool pool = Game.Instance.SummonPools.GetPool(this.SummonPool);
if (pool == null)
{
return(0);
}
int units = 0;
foreach (UnitEntityData unit in pool.Units)
{
if (unit.Get <UnitPartSummonedMonster>().Summoner == context.MaybeCaster)
{
units += 1;
}
}
return(units);
}
public static void Prefix(BlueprintBuff blueprint, MechanicsContext parentContext, ref TimeSpan?duration)
{
float adjusted = 0;
try {
if (!parentContext.MaybeCaster.IsPlayersEnemy && isGoodBuff(blueprint))
{
if (duration != null)
{
adjusted = Math.Max(0, Math.Min((float)long.MaxValue, duration.Value.Ticks * settings.buffDurationMultiplierValue));
duration = TimeSpan.FromTicks(Convert.ToInt64(adjusted));
}
}
}
catch (Exception e) {
Mod.Error($"BuffCollection_AddBuff2_patch - duration: {duration} - ticks: {duration.Value.Ticks} * {settings.buffDurationMultiplierValue} => {adjusted}");
Mod.Error(e);
}
//Mod.Debug("Initiator: " + parentContext.MaybeCaster.CharacterName + "\nBlueprintBuff: " + blueprint.Name + "\nDuration: " + duration.ToString());
}
public static string GetDescription(this BlueprintScriptableObject bpObejct)
// borrowed shamelessly and enchanced from Bag of Tricks https://www.nexusmods.com/pathfinderkingmaker/mods/26, which is under the MIT License
{
try {
UnitReference mainChar = Game.Instance.Player.MainCharacter;
if (mainChar == null)
{
return("");
}
MechanicsContext context = new MechanicsContext((UnitEntityData)null, mainChar.Value.Descriptor, bpObejct, (MechanicsContext)null, (TargetWrapper)null);
return(context?.SelectUIData(UIDataType.Description)?.Description ?? "");
}
catch (Exception e) {
Console.Write($"{e}");
#if DEBUG
return("ERROR".red().bold() + $": caught exception {e}");
#else
return("");
#endif
}
}
public override void RunAction()
{
MechanicsContext.Data data = ElementsContext.GetData <MechanicsContext.Data>();
MechanicsContext mechanicsContext = (data != null) ? data.Context : null;
if (mechanicsContext == null)
{
Main.logger.Log("Unable to toggle weapon: no context found");
return;
}
UnitEntityData unitEntityData = mechanicsContext.MaybeCaster;
if (unitEntityData == null)
{
Main.logger.Log("Can't toggle weapon: target is null");
return;
}
ItemEntityWeapon weapon = main_hand ? unitEntityData.Body.PrimaryHand.MaybeWeapon : unitEntityData.Body.SecondaryHand.MaybeWeapon;
toggleThrown(weapon, unitEntityData);
}
public MechanicsContext maybeGetShadowContext(MechanicsContext context)
{
var blueprint = context?.SourceAbility;
if (blueprint == null)
{
return(context?.SourceAbilityContext);
}
foreach (var b in buffs)
{
var repalce_shadow_context = b.Get <ReplaceShadowContextForAbilities>();
if (repalce_shadow_context == null)
{
continue;
}
if (repalce_shadow_context.abilities.Contains(blueprint))
{
return(b.MaybeContext?.SourceAbilityContext);
}
}
return(null);
}
