static bool Prefix(ContextRankConfig __instance, MechanicsContext context, ref int __result, bool ___m_UseMax, int ___m_Max, BlueprintCharacterClass[] ___m_Class)
{
try
{
var self = __instance;
var baseValue = GetBaseValue(self, context);
if (self.IsBasedOnClassLevel && ___m_Class.Contains(Helpers.sorcererClass))
{
var part = context.MaybeCaster.Get <UnitPartBloodline>();
Log.Write($"ContextRankConfig based on class level {self}, part {part}, blueprint {context.AssociatedBlueprint.name}, {context.AssociatedBlueprint.GetType().Name}");
var level = part?.CalcLevel(context.AssociatedBlueprint);
if (level.HasValue)
{
Log.Write($"ContextRankConfig: modify level of {context.AssociatedBlueprint.name}: {level}");
baseValue = context.Params.RankBonus + level.Value;
}
}
var value = (int)ApplyProgression(self, baseValue);
// TODO: this may allow intensifying something that isn't damage dice.
// We'd need to scan for ContextActionDealDamage, and then see if its ContextValue matches.
var spell = context.SourceAbility;
if (spell != null && ___m_UseMax)
{
if (context.HasMetamagic((Metamagic)ModMetamagic.Intensified))
{
// Intensified spell: increase the maximum damage dice by 5 levels.
int max = ___m_Max;
// Figure out what base value results in the max.
int maxBaseValue = 1;
for (; (int)ApplyProgression(self, maxBaseValue) < max && maxBaseValue <= 20; maxBaseValue++)
{
;
}
int newMax = (int)ApplyProgression(self, maxBaseValue + 5);
__result = Math.Min(value, newMax);
Log.Write($"Intensified spell: result {__result}, value {value}, max {max} (reached at level {maxBaseValue}), adjusted max {newMax}");
return(false);
}
if ((spell.SpellDescriptor & SpellDescriptor.Cure) != 0 && OracleClass.cureSpells.Value.Contains(spell))
{
var progressionData = context.MaybeCaster?.Descriptor.Progression;
if (progressionData?.Features.HasFact(LifeMystery.enhancedCures) == true)
{
__result = Math.Min(value, progressionData.GetClassLevel(OracleClass.oracle));
Log.Write($"Enhanced cures: result {__result}, value {value}, spell {spell.name}, caster {context.MaybeCaster}");
return(false);
}
}
}
__result = (int)ApplyMinMax(self, value);
return(false);
}
catch (Exception e)
{
Log.Error($"caught error in ApplyMinMax {e}");
}
return(true);
}
static bool Prefix(ContextRankConfig __instance, MechanicsContext context, ContextRankBaseValueType ___m_BaseValueType, bool ___m_ExceptClasses, StatType ___m_Stat,
BlueprintFeature ___m_Feature, BlueprintCharacterClass[] ___m_Class, BlueprintArchetype ___Archetype, ref int __result)
{
int rankBonus1 = context.Params.RankBonus;
if (___m_BaseValueType == ContextRankBaseValueTypeExtender.MasterClassLevel.ToContextRankBaseValueType() ||
___m_BaseValueType == ContextRankBaseValueTypeExtender.MasterMaxClassLevelWithArchetype.ToContextRankBaseValueType())
{
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 if (___m_BaseValueType == ContextRankBaseValueTypeExtender.ClassLevelPlusStatValue.ToContextRankBaseValueType())
{
foreach (Kingmaker.UnitLogic.ClassData classData in context.MaybeCaster.Descriptor.Progression.Classes)
{
if (___m_ExceptClasses && !((IList <BlueprintCharacterClass>)___m_Class).HasItem <BlueprintCharacterClass>(classData.CharacterClass) || !___m_ExceptClasses && ((IList <BlueprintCharacterClass>)___m_Class).HasItem <BlueprintCharacterClass>(classData.CharacterClass))
{
rankBonus1 += classData.Level;
}
}
int?bonus = context.MaybeCaster.Descriptor.Stats.GetStat <ModifiableValueAttributeStat>(___m_Stat)?.Bonus;
rankBonus1 = !bonus.HasValue ? rankBonus1 : rankBonus1 + bonus.Value;
__result = rankBonus1;
if (!___m_ExceptClasses)
{
__result += FakeClassLevelMechanics.Helpers.calculateFakeClassLevel(context.MaybeCaster.Descriptor, ___m_Class, new BlueprintArchetype[0]);
}
return(false);
}
else if (___m_BaseValueType == ContextRankBaseValueTypeExtender.SummClassLevelWithArchetypes.ToContextRankBaseValueType())
{
__result = 0;
var archetypes_list = ___m_Feature.GetComponent <ContextRankConfigArchetypeList>().archetypes;
if (___Archetype != null)
{
archetypes_list = archetypes_list.AddToArray(___Archetype);
}
foreach (var c in context.MaybeCaster.Descriptor.Progression.Classes)
{
if (!___m_Class.Contains(c.CharacterClass))
{
continue;
}
var class_archetypes = archetypes_list.Where(a => a.GetParentClass() == c.CharacterClass).ToArray();
if (class_archetypes.Empty())
{
__result += c.Level;
}
else
{
foreach (var a in c.Archetypes)
{
if (class_archetypes.Contains(a))
{
__result += c.Level;
break;
}
}
}
}
__result += FakeClassLevelMechanics.Helpers.calculateFakeClassLevel(context.MaybeCaster.Descriptor, ___m_Class, archetypes_list) + rankBonus1;
return(false);
}
else if (___m_BaseValueType == ContextRankBaseValueTypeExtender.MaxClassLevelWithArchetypes.ToContextRankBaseValueType())
{
__result = 0;
var archetypes_list = ___m_Feature.GetComponent <ContextRankConfigArchetypeList>().archetypes;
if (___Archetype != null)
{
archetypes_list = archetypes_list.AddToArray(___Archetype);
}
foreach (var c in context.MaybeCaster.Descriptor.Progression.Classes)
{
if (!___m_Class.Contains(c.CharacterClass))
{
continue;
}
var class_archetypes = archetypes_list.Where(a => a.GetParentClass() == c.CharacterClass).ToArray();
if (class_archetypes.Empty())
{
__result = Math.Max(c.Level, __result);
}
else
{
foreach (var a in c.Archetypes)
{
if (class_archetypes.Contains(a))
{
__result = Math.Max(c.Level, __result);
break;
}
}
}
}
__result = Math.Max(FakeClassLevelMechanics.Helpers.calculateFakeClassLevel(context.MaybeCaster.Descriptor, ___m_Class, archetypes_list), __result) + rankBonus1;
return(false);
}
else
{
return(true);
}
}
public static void SetProgression(this ContextRankConfig contextRankConfig, ContextRankProgression value)
{
contextRankConfig.SetFieldValue("m_Progression", value);
}
public static ContextRankProgression GetProgression(this ContextRankConfig contextRankConfig)
{
return(contextRankConfig.GetFieldValue <ContextRankConfig, ContextRankProgression>("m_Progression"));
}
public static void addClassToContextRankConfig(BlueprintCharacterClass class_to_add, BlueprintArchetype[] archetypes_to_add, ContextRankConfig c, string archetypes_list_prefix, BlueprintCharacterClass class_to_check)
{
var classes = Helpers.GetField <BlueprintCharacterClass[]>(c, "m_Class");
if (classes == null || classes.Empty() || !classes.Contains(class_to_check))
{
return;
}
classes = classes.AddToArray(class_to_add).Distinct().ToArray();
Helpers.SetField(c, "m_Class", classes);
if (!archetypes_to_add.Empty())
{
var base_value_type = Helpers.GetField <ContextRankBaseValueType>(c, "m_BaseValueType");
var rank_type = Helpers.GetField <AbilityRankType>(c, "m_Type");
if (base_value_type == ContextRankBaseValueType.ClassLevel || base_value_type == ContextRankBaseValueType.SummClassLevelWithArchetype)
{
var archetypes_list = Helpers.CreateFeature(archetypes_list_prefix + rank_type.ToString() + "ArchetypesListFeature",
"",
"",
"",
null,
FeatureGroup.None,
Helpers.Create <ContextRankConfigArchetypeList>(a => a.archetypes = archetypes_to_add)
);
Helpers.SetField(c, "m_BaseValueType", ContextRankBaseValueTypeExtender.SummClassLevelWithArchetypes.ToContextRankBaseValueType());
Helpers.SetField(c, "m_Feature", archetypes_list);
}
else if (base_value_type == ContextRankBaseValueType.MaxClassLevelWithArchetype)
{
var archetypes_list = Helpers.CreateFeature(archetypes_list_prefix + rank_type.ToString() + "ArchetypesListFeature",
"",
"",
"",
null,
FeatureGroup.None,
Helpers.Create <ContextRankConfigArchetypeList>(a => a.archetypes = archetypes_to_add)
);
Helpers.SetField(c, "m_BaseValueType", ContextRankBaseValueTypeExtender.MaxClassLevelWithArchetypes.ToContextRankBaseValueType());
Helpers.SetField(c, "m_Feature", archetypes_list);
}
else if (base_value_type == ContextRankBaseValueTypeExtender.SummClassLevelWithArchetypes.ToContextRankBaseValueType() ||
base_value_type == ContextRankBaseValueTypeExtender.MaxClassLevelWithArchetypes.ToContextRankBaseValueType())
{
var archetypes_list = Helpers.GetField <BlueprintFeature>(c, "m_Feature");
archetypes_list.ReplaceComponent <ContextRankConfigArchetypeList>(a => a.archetypes = a.archetypes.AddToArray(archetypes_to_add).Distinct().ToArray());
}
}
}
static void addClassToContextRankConfig(BlueprintCharacterClass class_to_add, BlueprintArchetype[] archetypes_to_add, ContextRankConfig c)
{
//BlueprintCharacterClass cleric_class = library.Get<BlueprintCharacterClass>("67819271767a9dd4fbfd4ae700befea0");
var classes = Helpers.GetField <BlueprintCharacterClass[]>(c, "m_Class");
//if (classes.Contains(cleric_class))
if (classes != null && !classes.Empty())
{
classes = classes.AddToArray(class_to_add);
Helpers.SetField(c, "m_Class", classes);
}
//TODO: account for archetypes
}
