public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(unit.Ensure <UnitPartSelfEvolution>().hasEvolution(evolution) != not);;
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return((unit.Get <UnitPartFullProficiency>()?.hasFullProficiency(category)).GetValueOrDefault() != not);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(unit.GetSpellbook(character_class) != null);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(this.base_prerequsite.Check(selectionState, unit, state) || this.alternative_prerequsite.Check(selectionState, unit, state));
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(this.prerequisite1.Check(selectionState, unit, state) && this.prerequisite2.Check(selectionState, unit, state));
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(race == unit.Progression.Race);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(unit.Progression.GetClassLevel(this.CharacterClass) < 1);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(unit.Ensure <UnitPartSelfEvolution>().getNumEvolutionPoints() >= amount || unit.Progression.Features.HasFact((BlueprintFact)this.feature));
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
return(!unit.Ensure <UnitPartSelfEvolution>().hasPermanentEvolution(evolution));
}
public override bool Check(FeatureSelectionState selectionState, UnitDescriptor unit, LevelUpState state)
{
foreach (Spellbook Spellbook in unit.Spellbooks)
{
if ((CharacterClass == null || Spellbook.Blueprint.CharacterClass == CharacterClass) && Spellbook.IsKnown(Ability))
{
return(true);
}
}
return(false);
}
public override bool Check(FeatureSelectionState selectionState, UnitDescriptor unit, LevelUpState state)
{
foreach (var spellbook in unit.Spellbooks)
{
if (spellbook.IsKnown(Spell))
{
return(!Not);
}
}
return(Not);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
if (selectionState != (FeatureSelectionState)null && selectionState.IsSelectedInChildren((IFeatureSelectionItem)this.base_feature))
{
return(false);
}
return(unit.Progression.Features.Enumerable.Where(p => p.Blueprint == this.base_feature).Any(this.CheckFeature));
}
public override bool Check(FeatureSelectionState selectionState, UnitDescriptor unit, LevelUpState state)
{
foreach (Kingmaker.UnitLogic.Abilities.Ability unitAbility in unit.Abilities)
{
if (_abilityList.Contains(unitAbility.Blueprint))
{
return(true);
}
}
return(false);
}
public override bool Check(FeatureSelectionState selectionState, UnitDescriptor unit, LevelUpState state)
{
BlueprintFeature[] features = Features;
foreach (BlueprintFeature blueprintFeature in features)
{
if (blueprintFeature.MeetsPrerequisites(selectionState, unit, state))
{
return(true);
}
}
return(false);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
foreach (var p in prerequisites)
{
if (!p.Check(selectionState, unit, state))
{
return(false);
}
}
return(true);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
foreach (ClassData classData in unit.Progression.Classes)
{
BlueprintSpellbook spellbook = classData.Spellbook;
if (spellbook != null)
{
return(true);
}
}
return(false);
}
bool IFeatureSelection.CanSelect(UnitDescriptor unit, LevelUpState state, FeatureSelectionState selectionState, IFeatureSelectionItem item)
{
if (!item.Param.HasValue)
{
return(false);
}
if (HasNoSuchFeature)
{
var feat = item.Param.Value.Blueprint as BlueprintFeature;
if (feat != null && unit.HasFact(feat))
{
return(false);
}
}
return(CanSelect(unit, item.Param.Value));
}
public override void OnFactActivate()
{
try
{
var levelUp = Game.Instance.UI.CharacterBuildController.LevelUpController;
if (Owner == levelUp.Preview || Owner == levelUp.Unit)
{
int index = levelUp.State.Selections.Count <FeatureSelectionState>((Func <FeatureSelectionState, bool>)(s => s.Selection == selection));
FeatureSelectionState featureSelectionState = new FeatureSelectionState(null, null, selection, index, 0);
levelUp.State.Selections.Add(featureSelectionState);
}
}
catch (Exception e)
{
Main.logger.Error(e.ToString());
}
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
foreach (var f in Features)
{
if (unit.Logic.HasFact(f))
{
return(false);
}
if (unit.Progression.Features.HasFact(f))
{
return(false);
}
}
return(true);
}
public override bool Check(
FeatureSelectionState selectionState,
UnitDescriptor unit,
LevelUpState state)
{
foreach (ClassData classData in unit.Progression.Classes)
{
BlueprintSpellbook spellbook = classData.Spellbook;
if (spellbook != null &&
(!this.OnlySpontaneous || spellbook.Spontaneous) &&
spellbook.GetComponent <PsychicSpellbook>() != null &&
unit.DemandSpellbook(classData.CharacterClass).MaxSpellLevel >= this.RequiredSpellLevel)
{
return(true);
}
}
return(false);
}
static void Prefix(SelectFeature __instance, LevelUpState state, UnitDescriptor unit, ref StateReplacer __state)
{
if (IsAvailable())
{
if (__instance.Item != null)
{
FeatureSelectionState selectionState =
GetMethodDel <SelectFeature, Func <SelectFeature, LevelUpState, FeatureSelectionState> >
("GetSelectionState")(__instance, state);
if (selectionState != null)
{
BlueprintCharacterClass sourceClass = (selectionState.Source as BlueprintFeature)?.GetSourceClass(unit);
if (sourceClass != null)
{
__state = new StateReplacer(state);
__state.Replace(sourceClass, unit.Progression.GetClassLevel(sourceClass));
}
}
}
}
}
public static bool Prefix(ref bool __result, FeatureSelectionState __instance, LevelUpState state, UnitEntityData unit)
{
__result = false;
if (__instance.Selection.IsObligatory())
{
__result = true;
}
else if (__instance.Selection.IsSelectionProhibited(unit.Descriptor))
{
__result = false;
}
else
{
foreach (IFeatureSelectionItem featureSelectionItem in __instance.Selection.Items)
{
if (featureSelectionItem != __instance.SelectedItem && __instance.Selection.CanSelect(unit.Descriptor, state, __instance, featureSelectionItem))
{
__result = true;
}
}
}
return(true);
}
public override bool Check([CanBeNull] FeatureSelectionState selectionState, [NotNull] UnitDescriptor unit, [NotNull] LevelUpState state)
{
return(CheckUnit(unit));
}
public override bool Check(FeatureSelectionState selectionState, UnitDescriptor unit, LevelUpState state)
{
return(unit.GetSpellbook(CharacterClass)?.MaxSpellLevel >= RequiredSpellLevel);
}
public override bool Check(FeatureSelectionState selectionState, UnitDescriptor unit, LevelUpState state)
{
return(Main.ModSettings.IgnoreFeatCasterLevelRestriction || Main.CharacterCasterLevel(unit) >= minimumCasterLevel);
}
public bool SelectFeature([NotNull] FeatureSelectionState selection, [NotNull] IFeatureSelectionItem item)
{
return(this.AddAction(new SelectFeature(selection, item), false));
}
public void UnselectFeature([NotNull] FeatureSelectionState selectionState)
{
this.RemoveAction <SelectFeature>((SelectFeature a) => a.Selection == selectionState.Selection && a.SelectionIndex == selectionState.Index);
this.UpdatePreview();
}
private void PerformSelections(LevelUpController controller, Dictionary <SelectionEntry, HashSet <int> > selectionsHistory, LevelUpActionPriority?maxPriority = null)
{
SelectionEntry[] selections = instance.Selections;
int i = 0;
while (i < selections.Length)
{
SelectionEntry selectionEntry = selections[i];
if (maxPriority == null)
{
goto IL_66;
}
if (selectionEntry.IsParametrizedFeature)
{
if (SelectFeature.CalculatePriority(selectionEntry.ParametrizedFeature) <= maxPriority.Value)
{
goto IL_66;
}
}
else if (SelectFeature.CalculatePriority(selectionEntry.Selection) <= maxPriority.Value)
{
goto IL_66;
}
IL_253:
i++;
continue;
IL_66:
HashSet <int> hashSet;
if (!selectionsHistory.TryGetValue(selectionEntry, out hashSet))
{
hashSet = new HashSet <int>();
selectionsHistory[selectionEntry] = hashSet;
}
if (selectionEntry.IsParametrizedFeature)
{
FeatureSelectionState featureSelectionState = controller.State.FindSelection(selectionEntry.ParametrizedFeature, false);
if (featureSelectionState != null)
{
FeatureUIData item;
switch (selectionEntry.ParametrizedFeature.ParameterType)
{
case FeatureParameterType.Custom:
case FeatureParameterType.SpellSpecialization:
item = new FeatureUIData(selectionEntry.ParametrizedFeature, selectionEntry.ParamObject, string.Empty, string.Empty, null, selectionEntry.ParamObject.ToString());
break;
case FeatureParameterType.WeaponCategory:
item = new FeatureUIData(selectionEntry.ParametrizedFeature, selectionEntry.ParamWeaponCategory, string.Empty, string.Empty, null, selectionEntry.ParamWeaponCategory.ToString());
break;
case FeatureParameterType.SpellSchool:
item = new FeatureUIData(selectionEntry.ParametrizedFeature, selectionEntry.ParamSpellSchool, string.Empty, string.Empty, null, selectionEntry.ParamSpellSchool.ToString());
break;
case FeatureParameterType.LearnSpell:
goto IL_1BD;
case FeatureParameterType.Skill:
item = new FeatureUIData(selectionEntry.ParametrizedFeature, selectionEntry.Stat, string.Empty, string.Empty, null, selectionEntry.Stat.ToString());
break;
default:
goto IL_1BD;
}
controller.SelectFeature(featureSelectionState, item);
goto IL_1CE;
IL_1BD:
throw new ArgumentOutOfRangeException();
}
IL_1CE:
goto IL_253;
}
for (int j = 0; j < selectionEntry.Features.Length; j++)
{
if (!hashSet.Contains(j))
{
BlueprintFeature blueprintFeature = selectionEntry.Features[j];
FeatureSelectionState featureSelectionState2 = controller.State.FindSelection(selectionEntry.Selection, false);
if (featureSelectionState2 != null && blueprintFeature != null && controller.SelectFeature(featureSelectionState2, blueprintFeature))
{
hashSet.Add(j);
}
}
}
goto IL_253;
}
}
public override bool Check(FeatureSelectionState selectionState, UnitDescriptor unit, LevelUpState state)
{
return(unit.Progression.CharacterLevel == Level);
}
private static bool Prefix(BlueprintParametrizedFeatureWeaponTraining __instance, UnitDescriptor unit, LevelUpState state, FeatureSelectionState selectionState, IFeatureSelectionItem item, ref bool __result)
{
if (__instance.GetType() == typeof(BlueprintParametrizedFeatureWeaponTraining))
{
if (item.Param.WeaponCategory != null && !AdvancedWeaponTraining._weaponTrainingToWeaponCategory[__instance.WeaponTraining].Contains((WeaponCategory)item.Param.WeaponCategory))
{
__result = false;
return(false);
}
}
return(true);
}
