public static void Postfix(ref Spellbook __instance, ref int ___m_CasterLevelInternal, List <BlueprintSpellList> ___m_SpecialLists)
{
int maxSpellLevel = __instance.MaxSpellLevel;
___m_CasterLevelInternal += settings.addCasterLevel;
int maxSpellLevel2 = __instance.MaxSpellLevel;
if (__instance.Blueprint.AllSpellsKnown)
{
Traverse addSpecialMethod = Traverse.Create(__instance).Method("AddSpecial", new Type[] { typeof(int), typeof(BlueprintAbility) });
for (int i = maxSpellLevel + 1; i <= maxSpellLevel2; i++)
{
foreach (BlueprintAbility spell in __instance.Blueprint.SpellList.GetSpells(i))
{
__instance.AddKnown(i, spell);
}
foreach (BlueprintSpellList specialList in ___m_SpecialLists)
{
foreach (BlueprintAbility spell2 in specialList.GetSpells(i))
{
addSpecialMethod.GetValue(i, spell2);
}
}
}
}
}
static void Postfix(Spellbook __instance, int spellLevel, BlueprintAbility spell, bool isCopy)
{
if (in_action)
{//avoid running multiple instances
return;
}
bool added_replacement = false;
in_action = true;
var comp = spell?.GetComponent <SpellUndercast>();
if (comp != null)
{
var undercast_spells = comp.getExtraAbilities().Reverse().ToArray();
foreach (var us in undercast_spells)
{
var sl = __instance.Blueprint.SpellList.GetLevel(us);
if (!__instance.IsKnown(us) && sl > 0)
{
__instance.AddKnown(sl, us, false);
}
else if (!added_replacement && sl > 0)
{
added_replacement = true;
Main.logger.Log("Checking lvl up ok");
var levelUp = Kingmaker.Game.Instance.UI?.CharacterBuildController?.LevelUpController;
if (__instance.Owner == levelUp?.Preview || __instance.Owner == levelUp?.Unit)
{
Main.logger.Log("Level up ok");
var spellSelection = levelUp.State.DemandSpellSelection(__instance.Blueprint, __instance.Blueprint.SpellList);
int existingNewSpells = spellSelection.LevelCount[sl]?.SpellSelections.Length ?? 0;
spellSelection.SetLevelSpells(sl, 1 + existingNewSpells);
}
}
}
}
in_action = false;
}
public static bool Prefix(LevelUpState state, UnitDescriptor unit)
{
if (!settings.toggleMulticlass)
{
return(false);
}
if ((UnityEngine.Object)state.SelectedClass == (UnityEngine.Object)null)
{
return(true);
}
SkipLevelsForSpellProgression component1 = state.SelectedClass.GetComponent <SkipLevelsForSpellProgression>();
if ((UnityEngine.Object)component1 != (UnityEngine.Object)null && ((IEnumerable <int>)component1.Levels).Contains <int>(state.NextClassLevel))
{
return(true);
}
ClassData classData = unit.Progression.GetClassData(state.SelectedClass);
if (classData == null || !((UnityEngine.Object)classData.Spellbook != (UnityEngine.Object)null))
{
return(true);
}
Spellbook spellbook1 = unit.DemandSpellbook(classData.Spellbook);
if ((bool)(UnityEngine.Object)state.SelectedClass.Spellbook && (UnityEngine.Object)state.SelectedClass.Spellbook != (UnityEngine.Object)classData.Spellbook)
{
Spellbook spellbook2 = unit.Spellbooks.FirstOrDefault <Spellbook>((Func <Spellbook, bool>)(s => (UnityEngine.Object)s.Blueprint == (UnityEngine.Object)state.SelectedClass.Spellbook));
if (spellbook2 != null)
{
foreach (AbilityData allKnownSpell in spellbook2.GetAllKnownSpells())
{
spellbook1.AddKnown(allKnownSpell.SpellLevel, allKnownSpell.Blueprint);
}
unit.DeleteSpellbook(state.SelectedClass.Spellbook);
}
}
int casterLevelBefore = spellbook1.CasterLevel;
spellbook1.AddLevelFromClass(classData.CharacterClass);
int casterLevelAfter = spellbook1.CasterLevel;
if (casterLevelBefore == casterLevelAfter)
{
return(true); // Mod line
}
SpellSelectionData spellSelectionData = state.DemandSpellSelection(spellbook1.Blueprint, spellbook1.Blueprint.SpellList);
if ((UnityEngine.Object)spellbook1.Blueprint.SpellsKnown != (UnityEngine.Object)null)
{
for (int index = 0; index <= 10; ++index)
{
BlueprintSpellsTable spellsKnown = spellbook1.Blueprint.SpellsKnown;
int?count = spellsKnown.GetCount(casterLevelBefore, index);
int num1 = count ?? 0;
count = spellsKnown.GetCount(casterLevelAfter, index);
int num2 = count ?? 0;
spellSelectionData.SetLevelSpells(index, Math.Max(0, num2 - num1));
}
}
int maxSpellLevel = spellbook1.MaxSpellLevel;
if (spellbook1.Blueprint.SpellsPerLevel > 0)
{
if (casterLevelBefore == 0)
{
spellSelectionData.SetExtraSpells(0, maxSpellLevel);
spellSelectionData.ExtraByStat = true;
spellSelectionData.UpdateMaxLevelSpells(unit);
}
else
{
spellSelectionData.SetExtraSpells(spellbook1.Blueprint.SpellsPerLevel, maxSpellLevel);
}
}
foreach (AddCustomSpells component2 in spellbook1.Blueprint.GetComponents <AddCustomSpells>())
{
ApplySpellbook.TryApplyCustomSpells(spellbook1, component2, state, unit);
}
return(true);
}
static public bool Prefix(ApplySpellbook __instance, LevelUpState state, UnitDescriptor unit)
{
if (state.SelectedClass != ArcanistClass.arcanist)
{
return(true);
}
if (state.SelectedClass == null)
{
return(false);
}
SkipLevelsForSpellProgression component = state.SelectedClass.GetComponent <SkipLevelsForSpellProgression>();
if (component != null && component.Levels.Contains(state.NextClassLevel))
{
return(false);
}
ClassData classData = unit.Progression.GetClassData(state.SelectedClass);
if (classData == null)
{
return(false);
}
if (classData.Spellbook != null)
{
Spellbook spellbook = unit.DemandSpellbook(classData.Spellbook);
if (state.SelectedClass.Spellbook && state.SelectedClass.Spellbook != classData.Spellbook)
{
Spellbook spellbook2 = unit.Spellbooks.FirstOrDefault((Spellbook s) => s.Blueprint == state.SelectedClass.Spellbook);
if (spellbook2 != null)
{
foreach (AbilityData abilityData in spellbook2.GetAllKnownSpells())
{
spellbook.AddKnown(abilityData.SpellLevel, abilityData.Blueprint, false);
}
unit.DeleteSpellbook(state.SelectedClass.Spellbook);
}
}
int casterLevel = spellbook.CasterLevel;
spellbook.AddCasterLevel();
int casterLevel2 = spellbook.CasterLevel;
SpellSelectionData spellSelectionData = state.DemandSpellSelection(spellbook.Blueprint, spellbook.Blueprint.SpellList);
if (spellbook.Blueprint.SpellsKnown != null && 1 == 0)
{
// SelectedClass must be arcanist, arcanist requires wizard-like spell selection,
// while its SpellsKnown is not null
for (int i = 0; i <= 9; i++)
{
int?count = spellbook.Blueprint.SpellsKnown.GetCount(casterLevel, i);
int num = (count == null) ? 0 : count.Value;
int?count2 = spellbook.Blueprint.SpellsKnown.GetCount(casterLevel2, i);
int num2 = (count2 == null) ? 0 : count2.Value;
spellSelectionData.SetLevelSpells(i, num2 - num);
}
}
int maxSpellLevel = spellbook.MaxSpellLevel;
if (spellbook.Blueprint.SpellsPerLevel > 0)
{
if (casterLevel == 0)
{
spellSelectionData.SetExtraSpells(0, maxSpellLevel);
spellSelectionData.ExtraByStat = true;
spellSelectionData.UpdateMaxLevelSpells(unit);
}
else
{
spellSelectionData.SetExtraSpells(spellbook.Blueprint.SpellsPerLevel, maxSpellLevel);
}
}
foreach (AddCustomSpells customSpells in spellbook.Blueprint.GetComponents <AddCustomSpells>())
{
ApplySpellbook_TryApplyCustomSpells(__instance, spellbook, customSpells, state, unit);
}
}
return(false);
}
