Jaysyn/PRC8
Jaysyn/PRC8
1
1
Fork 1
Code Issues 42 Pull Requests Packages Projects Releases 16 Wiki Activity
PRC8/nwn/nwnprc/trunk/include/prc_nui_lv_inc.nss
Jaysyn904 a882749366 2025/06/22 Update 
Fixed Vow of Poverty.
Fixed Vow of Poverty bonus feats not being restored onClientEnter.
Added PRC option for spontaneous casters unlearning spells (@Rakiov)
Gloura was double dipping caster level.
Added NUI levelup spellpicker for most AMS classes (@Rakiov)
Tweaked Tactical Insight.
Updated ToB maneuver TLK entries to display correct prerequisites.
2025-06-22 19:40:24 -04:00

3337 lines
130 KiB
Plaintext
Raw Blame History

//::///////////////////////////////////////////////
//:: PRC Level Up NUI
//:: prc_nui_lv_inc
//:://////////////////////////////////////////////
/*
This is the logic for the Level Up NUI, holding all the functions needed for
the NUI to operate properly and allow leveling up in different classes.
*/
//:://////////////////////////////////////////////
//:: Created By: Rakiov
//:: Created On: 20.06.2005
//:://////////////////////////////////////////////
#include "prc_nui_com_inc"
#include "tob_inc_tobfunc"
#include "tob_inc_moveknwn"
#include "inv_inc_invfunc"
#include "shd_inc_mystknwn"
#include "shd_inc_shdfunc"
#include "true_inc_truknwn"
#include "true_inc_trufunc"
////////////////////////////////////////////////////////////////////////////
/// ///
/// Spont Casters / Base ///
/// ///
////////////////////////////////////////////////////////////////////////////
//
// GetSpellListObject
// Gets the JSON Object representation of a class's spellbook 2da. This function
// will cache it's result to the object given to it to avoid further calculations
// and will not clear itself since it does not change.
//
// Arguments:
// nClass:int the ClassID
// oPC:Object the player
//
// Returns:
// Json:Dictionary<String, List[]> a dictionary of each circle's spellbook Ids.
//
json GetSpellListObject(int nClass, object oPC=OBJECT_SELF);
//
// GetKnownSpellListObject
// Gets the JSON Object representation of a player's known spell list. This function
// will temporarily cache it's result to the object given to avoid further calculations.
// However this should be cleared after done using the level up screen or reset.
//
// Arguments:
// nClass:int the ClassID
// oPC:Object the player
//
// Returns:
// Json:Dictionary<String, List[]> a dictionary of each circle's known spellbook Ids.
//
json GetKnownSpellListObject(int nClass, object oPC=OBJECT_SELF);
//
// GetKnownSpellListObject
// Gets the JSON Object representation of a player's chosen spell list. This function
// will temporarily cache it's result to the object given to avoid further calculations.
// However this should be cleared after done using the level up screen or reset.
//
// Arguments:
// nClass:int the ClassID
// oPC:Object the player
//
// Returns:
// Json:Dictionary<String, List[]> a dictionary of each circle's chosen spellbook Ids.
//
json GetChosenSpellListObject(int nClass, object oPC=OBJECT_SELF);
//
// ShouldAddSpellToSpellButtons
// Given a classId and a spellbookId, if the player knows the spell already we
// should not add the spell, otherwise we should
//
// Arguments:
// nClass:int Class ID
// spellbookId:int the spell book ID
// oPC:object the player
//
// Returns:
// int:Boolean TRUE if spell should be added, FALSE otherwise
//
int ShouldAddSpellToSpellButtons(int nClass, int spellbookId, object oPC=OBJECT_SELF);
//
// OpenNUILevelUpWindow
// Opens the Level Up NUI window for the provided class
//
// Arguments:
// nClass:int the ClassID
//
void OpenNUILevelUpWindow(int nClass, object oPC=OBJECT_SELF);
//
// CloseNUILevelUpWindow
// Closes the NUI Level Up Window if its open
//
void CloseNUILevelUpWindow(object oPC=OBJECT_SELF);
//
// GetTrueClassType
// Gets the true class Id for a provided class Id, mostly for RHD and for
// ToB prestige classes
//
// Arguments:
// nClass:int classId
//
// Returns:
// int the true classId based off nClass
//
int GetTrueClassType(int nClass, object oPC=OBJECT_SELF);
//
// GetRemainingSpellChoices
// Gets the remaining spell choices for a class at the given circle by checking its
// chosen spells and comparing it against the total spells allowed. This value
// is cached on the player and cleared everytime the window is refreshed/closed
//
// Arguments:
// nClass:int the class id
// circleLevel:int the circle being checked
//
// Returns:
// int the amount of choices left at the circle
//
int GetRemainingSpellChoices(int nClass, int circleLevel, object oPC=OBJECT_SELF);
//
// ShouldSpellButtonBeEnabled
// Checks whether a spell button should be enabled either because all choices have
// been made, replacing spells isn't allowed, or for various other reasons
//
// Arguments:
// nClass:int class id
// circleLevel:int the chosen circle
// spellbookId:int the chosen spell
//
// Returns:
// int:Boolean TRUE if spell button should be enabled, FALSE otherwise
//
int ShouldSpellButtonBeEnabled(int nClass, int circleLevel, int spellbookId, object oPC=OBJECT_SELF);
//
// AddSpellToChosenList
// Adds spell to the chosen spells list
//
// Arguments:
// nClass:int the classId
// spellbookId:int the spellbook Id
// spellCircle:int the current circle of the spell
//
void AddSpellToChosenList(int nClass, int spellbookId, int spellCircle, object oPC=OBJECT_SELF);
//
// RemoveSpellFromChosenList
// Removes a spell from the chosen spell list
//
// Arguments:
// nClass:int the class id
// spellbookId:int the spellbook Id
// spellCircle:int the circle of the spell
//
void RemoveSpellFromChosenList(int nClass, int spellbookId, int spellCircle, object oPC=OBJECT_SELF);
//
// LearnSpells
// gives the player the spells they want to learn based off of the chosen spell
// list in a stored variable
//
// Arguments:
// nClass:int the classId
//
void LearnSpells(int nClass, object oPC=OBJECT_SELF);
//
// RemoveSpells
// removes spells from the player that they may know currently but aren't selected
// based off lists in stored variables
//
// Arguments:
// nClass:int the classId
//
void RemoveSpells(int nClass, object oPC=OBJECT_SELF);
//
// FinishLevelUp
// Finishes level up NUI by removing spells, learning spells, clearing cache, then closing the NUI
//
// Arguments:
// nClass:int the class id
//
void FinishLevelUp(int nClass, object oPC=OBJECT_SELF);
//
// ClearLevelUpNUICaches
// Clears the cache (stored local variables) for the level up NUI so it is
// ready to be used for a new level up
//
// Arguments:
// nClass:int class id
// oPC:object the player object this is stored under
//
void ClearLevelUpNUICaches(int nClass, object oPC=OBJECT_SELF);
//
// SpellIsWithinObject
// checks whether a spell is within a JSON Object structure used by the remaining
// spells object and known spells object, following this structure
// {
// "circleLevel:int": [ 1,2,3...,spellId],
// ...
// }
//
// Arguments
// nClass:int classId
// spellbookId:int the spellbook Id
// circleLevel:int the chosen circle of the spell
// spellList;JsonObject the spell list object being checked
//
// Returns:
// int:Boolean TRUE if it is in the object, FALSE otherwise
//
int SpellIsWithinObject(int nClass, int spellbookId, int circleLevel, json spellList, object oPC=OBJECT_SELF);
//
// IsLevelUpNUIOpen
// Checks if the Level Up NUI is open for the player or not
//
// Arguments:
// oPC:object the player object
//
// Returns:
// int:Boolean TRUE if it is, FALSE otherwise
//
int IsLevelUpNUIOpen(object oPC=OBJECT_SELF);
//
// IsClassAllowedToUseLevelUpNUI
// Is the provided class allowed to use the level up NUI
//
// Arguments:
// nClass:int class id
//
// Returns:
// int:Boolean TRUE if it can, FALSE otherwise
//
int IsClassAllowedToUseLevelUpNUI(int nClass);
//
// EnabledChosenButton
// determines if a chosen spell button should be enabled or not. It may not due to
// class restrictions, replacing is not enabled, or other reason
//
// Arguments:
// nClass:int the class id
// spellbookId: the spellbook Id
// circleLevel: the spell's circle
//
// Returns:
// int:Boolean TRUE if it should be enabled, FALSE otherwise
//
int EnableChosenButton(int nClass, int spellbookId, int circleLevel, object oPC=OBJECT_SELF);
//
// ResetChoices
// Action for the Level Up NUI's 'Reset' button, resets choices by clearing the cache of
// the user so their choices are forgotten and they can start over.
//
// Arguments:
// oPC:object the player object
//
void ResetChoices(object oPC=OBJECT_SELF);
//
// RemoveSpellKnown
// Removes a spell from a player based off class id. This is for classes that
// aren't spont casters where we have to go in and adjust persistant arrays
// to say if a spell is known or not.
//
// Arguments:
// nClass:int class id
// spellbookId:int the spellbook Id
// oPC:object the player object
// nList:int the list we are removing the spell from (extra invocations or expanded knowledge)
//
void RemoveSpellKnown(int nClass, int spellbookId, object oPC=OBJECT_SELF, int nList=0);
//
// GetSpellIDsKnown
// Gets the SpellIDs list of the given class and list and returns it as a JsonObject following this structure
// {
// "spellId:int": TRUE,
// ...
// }
//
// This is to keep lookups at O(1) processing time. This value is cached and is
// cleared when the player finishes level up
//
// Arguments:
// nClass:int class id
// oPC:object the player object
// nList:int the list we are checking if provided (extra invocations or expanded knowledge)
//
// Returns:
// JsonObject the list of spell ids the class knows in JsonObject format
//
json GetSpellIDsKnown(int nClass, object oPC=OBJECT_SELF, int nList=0);
//
// ReasonForDisabledSpell
// Provides the reason for why a spell choice is disabled
//
// Arguments:
// nClass:int the class id
// spellbookId:int the spellbook Id
//
// Returns:
// string the reason for the disabled button, empty string otherwise
//
string ReasonForDisabledSpell(int nClass, int spellbookId, object oPC=OBJECT_SELF);
//
// ReasonForDisabledChosen
// Provides the reason for why a chosen spell button is disabled
//
// Arguments:
// nClass:int the class id
// spellbookId:int the spellbook Id
//
// Returns:
// string the reason for the disabled button, empty string otherwise
//
string ReasonForDisabledChosen(int nClass, int spellbookId, object oPC=OBJECT_SELF);
//
// GetExpandedChoicesList
// Gets the expanded choices list for a class (the list of expanded knowledge or
// extra invocations). It follows this structure
//
// {
// "spellId:int": TRUE,
// ...
// }
// This is cached to reduce process times and is cleared everytime the window is refreshed/closed
//
// Arguments:
// nClass:int the class id
//
// Returns:
// JsonObject the object representation of the expanded choices
//
json GetExpandedChoicesList(int nClass, object oPC=OBJECT_SELF);
//
// GetExpandedChoicesList
// Gets the epic expanded choices list for a class (the list of expanded knowledge or
// extra invocations). It follows this structure
//
// {
// "spellId:int": TRUE,
// ...
// }
// This is cached to reduce process times and is cleared everytime the window is refreshed/closed
//
// Arguments:
// nClass:int the class id
//
// Returns:
// JsonObject the object representation of the expanded choices
//
json GetEpicExpandedChoicesList(int nClass, object oPC=OBJECT_SELF);
//
// GetRemainingExpandedChoices
// Gets the remaining expanded choices for a class based off list, comparing the
// total number of choices allowed and the total number chosen
//
// Arguments:
// nClass: class id
// nList: the list we are checking (extra invocations/expanded knowledge)
//
// Returns:
// int the amount of choices left
//
int GetRemainingExpandedChoices(int nClass, int nList, object oPC=OBJECT_SELF);
//
// IsSpellInExpandedChoices
// tells if a spell is in the expanded choices list or not
//
// Arguments:
// nClass:int class id
// nList:int the list we are checking (extra invocations/expanded knowledge)
// spellId:int the spell id (not the spellbook id)
//
// Returns
// int:Boolean TRUE if it is a expanded choice, FALSE otherwise
//
int IsSpellInExpandedChoices(int nClass, int nList, int spellId, object oPC=OBJECT_SELF);
//
// GetChosenReplaceListObject
// The chosen list of spells we wish to replace for PnP replacing if Bioware replacing
// is disabled. This is cached and is cleared when the player is finished leveling
// or resets their choices
//
// Arguments:
// oPC:object the player
//
// Returns:
// json the list of spells chosen to replace
//
json GetChosenReplaceListObject(object oPC=OBJECT_SELF);
////////////////////////////////////////////////////////////////////////////
/// ///
/// Psionics ///
/// ///
////////////////////////////////////////////////////////////////////////////
//
// IsExpKnowledgePower
// checks if a spell is a expanded knowledge spell
//
// Arguments:
// nClass:int class id
// spellbookId:int the spellbook Id
//
// Returns:
// int:Boolean TRUE if the spell is a expanded knowledge spell, FALSE otherwise
//
int IsExpKnowledgePower(int nClass, int spellbookId);
//
// GetExpKnowledgePowerListRequired
// Tells what list the spell should be added to based on if it was added to the
// expanded choices or epic expanded choices list
//
// Arguments:
// nClass:int the class id
// spellbookId:int the spellbook Id
//
// Returns:
// int -1 for the expanded knowledge list, -2 for the epic expanded knowledge
// list, 0 if just add it to the normal class list
//
int GetExpKnowledgePowerListRequired(int nClass, int spellbookId, object oPC=OBJECT_SELF);
//
// GetCurrentPowerList
// Gets the current chosen powers list. This is cached and is cleared when the
// player either finishs leveling up or resets.
//
// Arguments:
// oPC:object the player object
//
// Returns:
// JsonArray the list of chosen powers wanting to learn
//
json GetCurrentPowerList(object oPC=OBJECT_SELF);
//
// ShouldAddPower
// Tells if the power should be added to the list of choices or not. It may not
// be added because its an expanded knowledge choice and you have no more expanded
// knowledge slots, or it may be a restricted spell like psions list
//
// Arguments:
// nClass:int the class id
// spellbookId:int the spellbook id
//
// Returns:
// int:Boolean TRUE if it should be added, FALSE otherwise
//
int ShouldAddPower(int nClass, int spellbookId, object oPC=OBJECT_SELF);
//
// LearnPowers
// learns the list of chosen powers for the player based off their chosen power list
//
// Arguments:
// nClass:int class id
// oPC:object the player object where stored variables are
//
void LearnPowers(int nClass, object oPC=OBJECT_SELF);
//
// GetMaxPowerLevelForClass
// gets the max power level for the player based off their level and the class's
// known 2da
//
// Arguments:
// nClass:int the class id
// oPC:object the player
//
// Returns:
// int the max power level (circle) the player can achieve on that class
//
int GetMaxPowerLevelForClass(int nClass, object oPC=OBJECT_SELF);
//
// GetRemainingPowerChoices
// Gets the remaining power choices the character has at the given chosen circle/power level
//
// Arguments:
// nClass:int class id
// chosenCircle:int the chosen circle/power level
// oPC:object the player
// extra:int should we add the expanded knowledge choices or not
//
// Returns:
// int the number of choices left at the given circle
//
int GetRemainingPowerChoices(int nClass, int chosenCircle, object oPC=OBJECT_SELF, int extra=TRUE);
////////////////////////////////////////////////////////////////////////////
/// ///
/// Initiators ///
/// ///
////////////////////////////////////////////////////////////////////////////
//
// GetDisciplineInfoObject
// Gets the disciplien info for the given class, telling what the chosen spells
// disicpline is, what type of maneuever it is, the different totals, and prerequisites.
// This is cached and is cleared when the window is refreshed/closed
//
// Argument:
// nClass:int class id
//
// Returns:
// JsonObject the object representation of the chosen spells discipline info
//
json GetDisciplineInfoObject(int nClass, object oPC=OBJECT_SELF);
//
// HasPreRequisitesForManeuver
// Does the player have the prerequisites for the given spell based off their chosen
// spell list
//
// Arguments:
// nClass:int the class id
// spellbookId:int the spellbook id
// oPC:object the player object with stored variables
//
// Returns:
// int:Boolean, TRUE if you have the prerequisites, FALSE otherwise
//
int HasPreRequisitesForManeuver(int nClass, int spellbookId, object oPC=OBJECT_SELF);
//
// GetMaxInitiatorCircle
// gets the max circle/level a player can obtain with the given class
//
// Arguments:
// nClass:int the class id
// oPC:object the player
//
// Returns:
// int the highest circle the player can achieve with the class
//
int GetMaxInitiatorCircle(int nClass, object oPC=OBJECT_SELF);
//
// GetRemainingManeuverChoices
// Gets remaining maneuever choices for the player
//
// Arguments:
// nClass:int class id
// oPC:object the player
//
// Returns:
// int the remaining maneuevers choices
//
int GetRemainingManeuverChoices(int nClass, object oPC=OBJECT_SELF);
//
// GetRemainingStanceChoices
// Gets remaining stance choices for the player
//
// Arguments:
// nClass:int class id
// oPC:object the player
//
// Returns:
// int the remaining stance choices
//
int GetRemainingStanceChoices(int nClass, object oPC=OBJECT_SELF);
//
// IsRequiredForOtherManeuvers
// Checks the given prerequisite number and the chosen spells to see if removing it
// will cause it to fail the requirement for other maneuevers
//
// Arguments:
// nClass:int the class id
// prereq:int the chosen spells prerequisite number of maneuevers needed
// discipline:string the chosen spells discipline
//
// Returns:
// int:Boolean TRUE if it is required, FALSE otherwise
//
int IsRequiredForOtherManeuvers(int nClass, int prereq, string discipline, object oPC=OBJECT_SELF);
//
// IsAllowedDiscipline
// checks to see if the given spell is a allowed discipline for a class
//
// Arguments:
// nClass:int class id
// spellbookId:int the spellbook id
//
// Returns:
// int:boolean TRUE if it is allowed, FALSE otherwise
//
int IsAllowedDiscipline(int nClass, int spellbookId, object oPC=OBJECT_SELF);
//
// AddSpellDisciplineInfo
// Adds the maneuver's discipline info to the class's discpline object
//
// Arguments:
// sFile:string the class's spell 2da
// spellbookId:int the spellbook Id
// classDisc:JsonObject the class discipline object we are adding to
//
// Returns:
// json:Object the classDisc with the given spells information added
//
json AddSpellDisciplineInfo(string sFile, int spellbookId, json classDisc);
//
// IsRequiredForToBPRCClass
// tells if a given maneuver is needed to satisfy a PRC's prerequsitie
//
// Arguments:
// nClass:int class id
// spellbookId:int the spellbook id
//
// Returns:
// int:Boolean TRUE if the maneuver is required for a PRC, FALSE otherwise.
//
int IsRequiredForToBPRCClass(int nClass, int spellbookId, object oPC=OBJECT_SELF);
////////////////////////////////////////////////////////////////////////////
/// ///
/// Invokers ///
/// ///
////////////////////////////////////////////////////////////////////////////
//
// GetInvokerKnownListObject
// gets the invokers known invocations list in object format, needed to tell how many
// of each invocation level does a person know at a given level. This is cached on the
// player and not cleared since it never changes.
//
// Arguments:
// nClass:int class id
//
// Returns:
// json:Object the list of invocations known in json format
//
json GetInvokerKnownListObject(int nClass, object oPC=OBJECT_SELF);
//
// GetRemainingInvocationChoices
// Gets the remaining invocation choices left
//
// Arguments:
// nClass:int class id
// chosenCircle:int the chosen circle we are checking
// oPC:Object the player
// extra:int should we count the number of extra invocations we have left
//
// Returns:
// int the amount of choices left at the given circle
//
int GetRemainingInvocationChoices(int nClass, int chosenCircle, object oPC=OBJECT_SELF, int extra=TRUE);
//
// IsExtraChoiceInvocation
// tells if a given spell is a extra invocation choice
//
// Arguments:
// nClass:int class id
// spellbookId:int the spellbook id
//
// Returns:
// int;Boolean TRUE if it is a extra choice, FALSE otherwise
//
int IsExtraChoiceInvocation(int nClass, int spellbookId, object oPC=OBJECT_SELF);
////////////////////////////////////////////////////////////////////////////
/// ///
/// Truenamer ///
/// ///
////////////////////////////////////////////////////////////////////////////
//
// GetRemainingTruenameChoices
// gets the remaining truename choices left at the given lexicon type
//
// Arguments:
// nClass:int class id
// nType:int the lexicon
//
// Returns:
// int the amount of truename choices left for the given lexicon
//
int GetRemainingTruenameChoices(int nClass, int nType, object oPC=OBJECT_SELF);
//
// GetLexiconCircleKnownAtLevel
// gets the known circle level for a given lexicon
//
// Arguments:
// nLevel:int the level to check
// nType:int the lexicon we are checking
//
// Returns:
// int the highest circle we can achieve
//
int GetLexiconCircleKnownAtLevel(int nLevel, int nType);
////////////////////////////////////////////////////////////////////////////
/// ///
/// Archivist ///
/// ///
////////////////////////////////////////////////////////////////////////////
json GetArchivistNewSpellsList(object oPC=OBJECT_SELF);
////////////////////////////////////////////////////////////////////////////
/// ///
/// Spont Casters / Base ///
/// ///
////////////////////////////////////////////////////////////////////////////
int IsLevelUpNUIOpen(object oPC=OBJECT_SELF)
{
int nPreviousToken = NuiFindWindow(oPC, NUI_LEVEL_UP_WINDOW_ID);
if (nPreviousToken != 0)
{
return TRUE;
}
return FALSE;
}
int IsClassAllowedToUseLevelUpNUI(int nClass)
{
if (GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS)
return TRUE;
if (nClass == CLASS_TYPE_PSYWAR
|| nClass == CLASS_TYPE_PSYCHIC_ROGUE
|| nClass == CLASS_TYPE_PSION
|| nClass == CLASS_TYPE_FIST_OF_ZUOKEN
|| nClass == CLASS_TYPE_WILDER
|| nClass == CLASS_TYPE_WARMIND)
return TRUE;
if (nClass == CLASS_TYPE_WARBLADE
|| nClass == CLASS_TYPE_SWORDSAGE
|| nClass == CLASS_TYPE_CRUSADER)
return TRUE;
if (nClass == CLASS_TYPE_WARLOCK
|| nClass == CLASS_TYPE_DRAGONFIRE_ADEPT
|| nClass == CLASS_TYPE_DRAGON_SHAMAN)
return TRUE;
if (nClass == CLASS_TYPE_SHADOWCASTER
|| nClass == CLASS_TYPE_SHADOWSMITH)
return TRUE;
if (nClass == CLASS_TYPE_TRUENAMER)
return TRUE;
if (nClass == CLASS_TYPE_ARCHIVIST)
return TRUE;
return FALSE;
}
int SpellIsWithinObject(int nClass, int spellbookId, int circleLevel, json spellList, object oPC=OBJECT_SELF)
{
// check to see if the spell circle isn't empty
json currentList = JsonObjectGet(spellList, IntToString(circleLevel));
if (currentList == JsonNull())
return FALSE;
int totalSpells = JsonGetLength(currentList);
// then loop through the spell list and find the spell.
int i;
for (i = 0; i < totalSpells; i++)
{
int currentSpell = JsonGetInt(JsonArrayGet(currentList, i));
if (currentSpell == spellbookId)
return TRUE;
}
return FALSE;
}
int AllSpellsAreChosen(int nClass, object oPC=OBJECT_SELF)
{
// we need the max number of circles a class has.
json spellList = GetSpellListObject(nClass, oPC);
json spellCircles = JsonObjectKeys(spellList);
int totalCircles = JsonGetLength(spellCircles);
int i;
for (i = 0; i < totalCircles; i++)
{
// loop through each circle and check if you have any remaining choices left
// if you do or you have a deficit then you need to remove or add something
// until you get 0
int spellCircle = StringToInt(JsonGetString(JsonArrayGet(spellCircles, i)));
int remainingChoices = GetRemainingSpellChoices(nClass, spellCircle, oPC);
if (remainingChoices < 0 || remainingChoices > 0)
return FALSE;
}
return TRUE;
}
void AddSpellToChosenList(int nClass, int spellbookId, int spellCircle, object oPC=OBJECT_SELF)
{
if (GetIsInvocationClass(nClass))
{
// get the remaining invocation choices left without extra feats
// if it is 0 then we are adding the chosen invocation to the extra lists
int totalInvocations = GetRemainingInvocationChoices(nClass, spellCircle, oPC, FALSE);
if (totalInvocations == 0)
{
string sFile = GetClassSpellbookFile(nClass);
if (GetRemainingExpandedChoices(nClass, INVOCATION_LIST_EXTRA, oPC))
{
json expList = GetExpandedChoicesList(nClass, oPC);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
expList = JsonObjectSet(expList, spellId, JsonBool(TRUE));
SetLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR, expList);
}
else if (GetRemainingExpandedChoices(nClass, INVOCATION_LIST_EXTRA_EPIC, oPC))
{
json expList = GetEpicExpandedChoicesList(nClass, oPC);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
expList = JsonObjectSet(expList, spellId, JsonBool(TRUE));
SetLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR, expList);
}
}
}
if (GetIsPsionicClass(nClass))
{
// if the power is a expanded knowledge than we immediatly add it to the
// extra list, otherwise check to make sure we have made all choices in our
// base list first before adding it to the extra list.
if (IsExpKnowledgePower(nClass, spellbookId)
|| GetRemainingPowerChoices(nClass, spellCircle, oPC, FALSE) == 0)
{
string sFile = GetClassSpellbookFile(nClass);
if (GetRemainingExpandedChoices(nClass, POWER_LIST_EXP_KNOWLEDGE, oPC))
{
json expList = GetExpandedChoicesList(nClass, oPC);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
expList = JsonObjectSet(expList, spellId, JsonBool(TRUE));
SetLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR, expList);
}
else if (GetRemainingExpandedChoices(nClass, POWER_LIST_EPIC_EXP_KNOWLEDGE, oPC))
{
json expList = GetEpicExpandedChoicesList(nClass, oPC);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
expList = JsonObjectSet(expList, spellId, JsonBool(TRUE));
SetLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR, expList);
}
}
// add the power to the current power list.
json currPowerList = GetCurrentPowerList(oPC);
currPowerList = JsonArrayInsert(currPowerList, JsonInt(spellbookId));
SetLocalJson(oPC, NUI_LEVEL_UP_POWER_LIST_VAR, currPowerList);
}
if (nClass == CLASS_TYPE_ARCHIVIST)
{
json newSpells = GetArchivistNewSpellsList(oPC);
newSpells = JsonArrayInsert(newSpells, JsonInt(spellbookId));
SetLocalJson(oPC, NUI_LEVEL_UP_ARCHIVIST_NEW_SPELLS_LIST_VAR, newSpells);
}
// base logic for spont casters, add the spell to the ChosenSpells JSON object
// by adding it to it's appropriate circle.
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
json spellsAtCircle = JsonObjectGet(chosenSpells, IntToString(spellCircle));
if (spellsAtCircle == JsonNull())
spellsAtCircle = JsonArray();
spellsAtCircle = JsonArrayInsert(spellsAtCircle, JsonInt(spellbookId));
chosenSpells = JsonObjectSet(chosenSpells, IntToString(spellCircle), spellsAtCircle);
SetLocalJson(oPC, NUI_LEVEL_UP_CHOSEN_SPELLS_VAR, chosenSpells);
// if we are not using bioware unlearning logic, then we need to limit the
// amount of spells we can replace.
if (!GetPRCSwitch(PRC_BIO_UNLEARN))
{
json unlearnList = GetChosenReplaceListObject(oPC);
// if the spell belongs to the unlearn list, then remove it to make room
// for a new spell.
if (JsonObjectGet(unlearnList, IntToString(spellbookId)) != JsonNull())
{
unlearnList = JsonObjectDel(unlearnList, IntToString(spellbookId));
SetLocalJson(oPC, NUI_LEVEL_UP_RELEARN_LIST_VAR, unlearnList);
}
}
}
void RemoveSpellFromChosenList(int nClass, int spellbookId, int spellCircle, object oPC=OBJECT_SELF)
{
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
json spellsAtCircle = JsonObjectGet(chosenSpells, IntToString(spellCircle));
if (spellsAtCircle == JsonNull())
spellsAtCircle = JsonArray();
int totalSpells = JsonGetLength(spellsAtCircle);
// find the spell at the circle in the chosen list and remove it.
int i;
for (i = 0; i < totalSpells; i++)
{
if (spellbookId == JsonGetInt(JsonArrayGet(spellsAtCircle, i)))
{
spellsAtCircle = JsonArrayDel(spellsAtCircle, i);
break;
}
}
chosenSpells = JsonObjectSet(chosenSpells, IntToString(spellCircle), spellsAtCircle);
SetLocalJson(oPC, NUI_LEVEL_UP_CHOSEN_SPELLS_VAR, chosenSpells);
// if we re not using bioware unlearn logic we need to limit how many spells
// can be replaced
if (!GetPRCSwitch(PRC_BIO_UNLEARN))
{
json knownSpells = GetKnownSpellListObject(nClass, oPC);
json spellListAtCircle = JsonObjectGet(knownSpells, IntToString(spellCircle));
int totalSpells = JsonGetLength(spellListAtCircle);
// with the list of known spells, check the selected circle and see if the
// current spell belongs in the already known spell list.
for (i = 0; i < totalSpells; i++)
{
int chosenSpell = JsonGetInt(JsonArrayGet(spellListAtCircle, i));
if (chosenSpell == spellbookId)
{
// if it does we need to add the spell to the unlearn JSON object to track what spells
// are being replaced.
json unlearnList = GetChosenReplaceListObject(oPC);
unlearnList = JsonObjectSet(unlearnList, IntToString(spellbookId), JsonBool(TRUE));
SetLocalJson(oPC, NUI_LEVEL_UP_RELEARN_LIST_VAR, unlearnList);
break;
}
}
}
if (GetIsPsionicClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
// for psionics we need to check if the removed spell was a expanded knowledge choice
// or not. The id of the list is -1 or -2.
int i;
for (i == -1; i >= -2; i--)
{
json expList = (i == -1) ? GetExpandedChoicesList(nClass, oPC) :
GetEpicExpandedChoicesList(nClass, oPC);
//if the spell belongs in the expanded knowledge list, then we need
// to remove it.
if (JsonObjectGet(expList, spellId) != JsonNull())
{
expList = JsonObjectDel(expList, spellId);
if (i == POWER_LIST_EXP_KNOWLEDGE)
SetLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR, expList);
else
SetLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR, expList);
}
}
// then we need to remove the power from the selected powers list.
json currPowerChoices = GetCurrentPowerList(oPC);
int totalPowers = JsonGetLength(currPowerChoices);
for (i = 0; i < totalPowers; i++)
{
if (spellbookId == JsonGetInt(JsonArrayGet(currPowerChoices, i)))
{
currPowerChoices = JsonArrayDel(currPowerChoices, i);
break;
}
}
SetLocalJson(oPC, NUI_LEVEL_UP_POWER_LIST_VAR, currPowerChoices);
}
if (GetIsInvocationClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
// for invocations we need to check if the spell was added to the extra
// invocations list, the list ids are the invalid class id, and -2
int i;
for (i = 0; i <= 1; i++)
{
json expList = (i == 0) ? GetExpandedChoicesList(nClass, oPC) :
GetEpicExpandedChoicesList(nClass, oPC);
// if the spell was found, remove it.
if (JsonObjectGet(expList, spellId) != JsonNull())
{
expList = JsonObjectDel(expList, spellId);
if (i == 0)
SetLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR, expList);
else
SetLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR, expList);
}
}
}
if (nClass == CLASS_TYPE_ARCHIVIST)
{
json newSpells = GetArchivistNewSpellsList(oPC);
int totalNew = JsonGetLength(newSpells);
int i;
for (i = 0; i < totalNew; i++)
{
int newSpellbookId = JsonGetInt(JsonArrayGet(newSpells, i));
if (newSpellbookId == spellbookId)
{
newSpells = JsonArrayDel(newSpells, i);
SetLocalJson(oPC, NUI_LEVEL_UP_ARCHIVIST_NEW_SPELLS_LIST_VAR, newSpells);
break;
}
}
}
}
void OpenNUILevelUpWindow(int nClass, object oPC=OBJECT_SELF)
{
CloseNUILevelUpWindow(oPC);
// set the NUI to the given classId
int currentClass = GetLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CLASS_VAR);
// we need to clear the cache if it was used before to avoid weird behaviors
ClearLevelUpNUICaches(currentClass, oPC);
// sometimes we are given a different classId instead of the base, we need to
// figure out what the true base class is (mostly true for RHD)
int chosenClass = GetTrueClassType(nClass, oPC);
SetLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CLASS_VAR, chosenClass);
ExecuteScript("prc_nui_lv_view", oPC);
}
int GetTrueClassType(int nClass, object oPC=OBJECT_SELF)
{
if (nClass == CLASS_TYPE_JADE_PHOENIX_MAGE
|| nClass == CLASS_TYPE_MASTER_OF_NINE
|| nClass == CLASS_TYPE_DEEPSTONE_SENTINEL
|| nClass == CLASS_TYPE_BLOODCLAW_MASTER
|| nClass == CLASS_TYPE_RUBY_VINDICATOR
|| nClass == CLASS_TYPE_ETERNAL_BLADE
|| nClass == CLASS_TYPE_SHADOW_SUN_NINJA)
{
int trueClass = GetPrimaryBladeMagicClass(oPC);
return trueClass;
}
if ((nClass == CLASS_TYPE_SHAPECHANGER
&& GetRacialType(oPC) == RACIAL_TYPE_ARANEA)
|| (nClass == CLASS_TYPE_OUTSIDER
&& GetRacialType(oPC) == RACIAL_TYPE_RAKSHASA)
|| (nClass == CLASS_TYPE_ABERRATION
&& GetRacialType(oPC) == RACIAL_TYPE_DRIDER)
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPC) == RACIAL_TYPE_ARKAMOI)
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPC) == RACIAL_TYPE_HOBGOBLIN_WARSOUL)
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPC) == RACIAL_TYPE_REDSPAWN_ARCANISS)
|| (nClass == CLASS_TYPE_MONSTROUS
&& GetRacialType(oPC) == RACIAL_TYPE_MARRUTACT))
return CLASS_TYPE_SORCERER;
if (nClass == CLASS_TYPE_FEY
&& GetRacialType(oPC) == RACIAL_TYPE_GLOURA)
return CLASS_TYPE_BARD;
return nClass;
}
void CloseNUILevelUpWindow(object oPC=OBJECT_SELF)
{
int currentClass = GetLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CLASS_VAR);
// if we are refreshing the NUI but not finished we need to clear some caching done
// to save computation time as they will need to be reprocessed.
DeleteLocalJson(oPC, NUI_LEVEL_UP_DISCIPLINE_INFO_VAR + IntToString(currentClass));
SetLocalInt(oPC, NUI_LEVEL_UP_REMAINING_CHOICES_CACHE_VAR, -20);
int nPreviousToken = NuiFindWindow(oPC, NUI_LEVEL_UP_WINDOW_ID);
if (nPreviousToken != 0)
{
NuiDestroy(oPC, nPreviousToken);
}
}
int ShouldSpellButtonBeEnabled(int nClass, int circleLevel, int spellbookId, object oPC=OBJECT_SELF)
{
// logic for psionics
if (GetIsPsionicClass(nClass))
{
int maxLevel = GetMaxPowerLevelForClass(nClass, oPC);
if (circleLevel > maxLevel)
return FALSE;
// if its an expanded knowledge choice and we have already made all our
// exp knowledge choices then it needs to be disabled.
if (IsExpKnowledgePower(nClass, spellbookId))
{
int remainingExp = GetRemainingExpandedChoices(nClass, POWER_LIST_EXP_KNOWLEDGE, oPC)
+ GetRemainingExpandedChoices(nClass, POWER_LIST_EPIC_EXP_KNOWLEDGE, oPC);
if (!remainingExp)
return FALSE;
}
}
if (GetIsShadowMagicClass(nClass))
{
// mysteries are weird, the circles are sectioned by 1-3, 4-6, 7-9
// if you do not have at least 2 choices from a circle you can't progress up
// so you can have access to circles 1,2,4,7,8
int nType = 1;
if (circleLevel >= 4 && circleLevel <= 6)
nType = 2;
if (circleLevel >= 7 && circleLevel <= 9)
nType = 3;
int maxPossibleCircle = GetMaxMysteryLevelLearnable(oPC, nClass, nType);
if (circleLevel > maxPossibleCircle)
return FALSE;
}
if (GetIsTruenamingClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
int lexicon = StringToInt(Get2DACache(sFile, "Lexicon", spellbookId));
// each lexicon learns at different rates
int maxCircle = GetLexiconCircleKnownAtLevel(GetLevelByClass(nClass, oPC), lexicon);
if (circleLevel > maxCircle)
return FALSE;
if (GetRemainingTruenameChoices(nClass, lexicon, oPC))
return TRUE;
return FALSE;
}
// logic for ToB
if (GetIsBladeMagicClass(nClass))
{
if (circleLevel > GetMaxInitiatorCircle(nClass, oPC))
return FALSE;
// if you do not have the prerequisite amount of maneuevers to learn
// the maneuever, then you can't learn it.
if (!HasPreRequisitesForManeuver(nClass, spellbookId, oPC))
return FALSE;
// maneuvers and stances have their own seperate limits
string sFile = GetClassSpellbookFile(nClass);
int type = StringToInt(Get2DACache(sFile, "Type", spellbookId));
if (type == MANEUVER_TYPE_BOOST
|| type == MANEUVER_TYPE_COUNTER
|| type == MANEUVER_TYPE_STRIKE
|| type == MANEUVER_TYPE_MANEUVER)
{
int remainingMan = GetRemainingManeuverChoices(nClass, oPC);
if (remainingMan)
return TRUE;
return FALSE;
}
if (type == MANEUVER_TYPE_STANCE)
{
int remainingStance = GetRemainingStanceChoices(nClass, oPC);
if (remainingStance)
return TRUE;
return FALSE;
}
}
if (nClass == CLASS_TYPE_ARCHIVIST)
{
int maxLevel = GetMaxSpellLevelForCasterLevel(nClass, GetCasterLevelByClass(nClass, oPC));
if (circleLevel > maxLevel)
return FALSE;
}
// default logic
// determine remaining Spell/Power choices left for player, if there is any
// remaining, enable the buttons.
if (GetRemainingSpellChoices(nClass, circleLevel, oPC))
return TRUE;
return FALSE;
}
int ShouldAddSpellToSpellButtons(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
string sFile = GetClassSpellbookFile(nClass);
string spellLevel = Get2DACache(sFile, "Level", spellbookId);
json chosenSpellsAtCircle = JsonObjectGet(chosenSpells, spellLevel);
int chosenSpellCount = JsonGetLength(chosenSpellsAtCircle);
// if the spell is in the chosen list, then don't add it to the available list
int i;
for (i = 0; i < chosenSpellCount; i++)
{
int chosenSpellId = JsonGetInt(JsonArrayGet(chosenSpellsAtCircle, i));
if (chosenSpellId == spellbookId)
return FALSE;
}
if (GetIsBladeMagicClass(nClass))
return IsAllowedDiscipline(nClass, spellbookId, oPC);
// if a psionic class we need to see if the power is a expanded knowledge
// choice and if we should show it or not
if (GetIsPsionicClass(nClass))
return ShouldAddPower(nClass, spellbookId, oPC);
// for these set of classes we need to only allow 'advanced learning'
// spells to be added
if (nClass == CLASS_TYPE_BEGUILER
|| nClass == CLASS_TYPE_DREAD_NECROMANCER
|| nClass == CLASS_TYPE_WARMAGE)
{
int advancedLearning = StringToInt(Get2DACache(sFile, "AL", spellbookId));
if (advancedLearning)
return TRUE;
return FALSE;
}
if (nClass == CLASS_TYPE_ARCHIVIST)
{
int nLevel = GetLevelByClass(nClass, oPC);
if ((StringToInt(spellLevel) == 0) && (nLevel == 1))
return FALSE;
int advancedLearning = StringToInt(Get2DACache(sFile, "AL", spellbookId));
if (advancedLearning)
return FALSE;
}
return TRUE;
}
json GetChosenSpellListObject(int nClass, object oPC=OBJECT_SELF)
{
json retValue = GetLocalJson(oPC, NUI_LEVEL_UP_CHOSEN_SPELLS_VAR);
// if this isn't set yet then we the chosen currently is the known spells
if (retValue == JsonNull())
{
retValue = GetKnownSpellListObject(nClass, oPC);
SetLocalJson(oPC, NUI_LEVEL_UP_CHOSEN_SPELLS_VAR, retValue);
}
return retValue;
}
json GetKnownSpellListObject(int nClass, object oPC=OBJECT_SELF)
{
json retValue = GetLocalJson(oPC, NUI_LEVEL_UP_KNOWN_SPELLS_VAR);
if (retValue == JsonNull())
retValue = JsonObject();
else
return retValue;
string sFile = GetClassSpellbookFile(nClass);
int totalSpells = Get2DARowCount(sFile);
if (nClass == CLASS_TYPE_ARCHIVIST)
{
int i;
for (i = 0; i < 10; i++)
{
string sSpellbook = GetSpellsKnown_Array(nClass, i);
int nSize = persistant_array_get_size(oPC, sSpellbook);
int j;
for (j = 0; j < nSize; j++)
{
int knownSpellbookID = persistant_array_get_int(oPC, sSpellbook, j);
// we store things in a JSON Object where the spell circle
// is the key to a JsonArray of spellbookIds.
json spellList = JsonObjectGet(retValue, IntToString(i));
if (spellList == JsonNull())
spellList = JsonArray();
spellList = JsonArrayInsert(spellList, JsonInt(knownSpellbookID));
retValue = JsonObjectSet(retValue, IntToString(i), spellList);
}
}
}
else
{
// loop through all the spells in the class's 2da
int i;
for (i = 0; i < totalSpells; i++)
{
int featId = StringToInt(Get2DACache(sFile, "FeatID", i));
// if you have the feat, you know the spell
if (featId && GetHasFeat(featId, oPC, TRUE))
{
string spellLevel = Get2DACache(sFile, "Level", i);
int nSpellLevel = StringToInt(spellLevel);
// some spells have **** as their level, so make sure we have
// parsed it correctly
if (IntToString(nSpellLevel) == spellLevel)
{
// we store things in a JSON Object where the spell circle
// is the key to a JsonArray of spellbookIds.
json spellList = JsonObjectGet(retValue, spellLevel);
if (spellList == JsonNull())
spellList = JsonArray();
spellList = JsonArrayInsert(spellList, JsonInt(i));
retValue = JsonObjectSet(retValue, spellLevel, spellList);
}
}
}
}
SetLocalJson(oPC, NUI_LEVEL_UP_KNOWN_SPELLS_VAR, retValue);
return retValue;
}
json GetSpellListObject(int nClass, object oPC=OBJECT_SELF)
{
json retValue = GetLocalJson(oPC, NUI_LEVEL_UP_SPELLBOOK_OBJECT_CACHE_VAR + IntToString(nClass));
if (retValue == JsonNull())
retValue = JsonObject();
else
return retValue;
string sFile = GetClassSpellbookFile(nClass);
int totalSpells = Get2DARowCount(sFile);
// loop through all the spells in the 2da and convert it to a JSON Object representation
int i;
for (i = 0; i < totalSpells; i++)
{
string spellLevel = Get2DACache(sFile, "Level", i);
int nSpellLevel = StringToInt(spellLevel);
// some spells in the list have **** as spell level. We need to ignore them
if (IntToString(nSpellLevel) == spellLevel)
{
if (nClass == CLASS_TYPE_ARCHIVIST)
{
int reqFeat = StringToInt(Get2DACache(sFile, "ReqFeat", i));
if (!reqFeat)
{
json spellList = JsonObjectGet(retValue, spellLevel);
if (spellList == JsonNull())
spellList = JsonArray();
spellList = JsonArrayInsert(spellList, JsonInt(i));
retValue = JsonObjectSet(retValue, spellLevel, spellList);
}
}
else
{
json spellList = JsonObjectGet(retValue, spellLevel);
if (spellList == JsonNull())
spellList = JsonArray();
spellList = JsonArrayInsert(spellList, JsonInt(i));
retValue = JsonObjectSet(retValue, spellLevel, spellList);
}
}
}
SetLocalJson(oPC, NUI_LEVEL_UP_SPELLBOOK_OBJECT_CACHE_VAR + IntToString(nClass), retValue);
return retValue;
}
int GetRemainingSpellChoices(int nClass, int circleLevel, object oPC=OBJECT_SELF)
{
int chosenCircle = GetLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CIRCLE_VAR);
int remainingChoices = 0;
// we only want to cache on the current circle.
if (chosenCircle == circleLevel)
{
remainingChoices = GetLocalInt(oPC, NUI_LEVEL_UP_REMAINING_CHOICES_CACHE_VAR);
// -20 is the chosen number to say there is no cache set since 0 is
// a valid option
if (remainingChoices != -20)
return remainingChoices;
}
// logic for psionics
if (GetIsPsionicClass(nClass))
remainingChoices = GetRemainingPowerChoices(nClass, circleLevel, oPC);
// logic for ToB
if (GetIsBladeMagicClass(nClass))
remainingChoices = (GetRemainingManeuverChoices(nClass, oPC) +
GetRemainingStanceChoices(nClass, oPC));
// logic for Invokers
if (GetIsInvocationClass(nClass))
remainingChoices = GetRemainingInvocationChoices(nClass, circleLevel, oPC);
// logic for mysteries
if (GetIsShadowMagicClass(nClass))
{
int totalChosen = 0;
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
json circles = JsonObjectKeys(chosenSpells);
int totalCircles = JsonGetLength(circles);
int i;
for (i = 0; i < totalCircles; i++)
{
// loop through each circle and add its total spells together since
// we don't care about where you spend your spells, only the amount
string currentCircle = JsonGetString(JsonArrayGet(circles, i));
json spellList = JsonObjectGet(chosenSpells, currentCircle);
if (spellList != JsonNull())
totalChosen += JsonGetLength(spellList);
}
int maxKnown = GetMaxMysteryCount(oPC, nClass);
remainingChoices = (maxKnown - totalChosen);
}
if (GetIsTruenamingClass(nClass))
remainingChoices = GetRemainingTruenameChoices(nClass, -1, oPC);
if (nClass == CLASS_TYPE_ARCHIVIST)
{
int nLevel = GetLevelByClass(CLASS_TYPE_ARCHIVIST, oPC);
int spellsAvailable;
if (nLevel == 1)
spellsAvailable = (3 + GetAbilityModifier(ABILITY_INTELLIGENCE, oPC));
else
spellsAvailable = 2;
json newSpells = GetArchivistNewSpellsList(oPC);
int totalNewSpells = JsonGetLength(newSpells);
remainingChoices = (spellsAvailable - totalNewSpells);
}
if (GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS)
{
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
int totalSpellsKnown = 0;
int casterLevel = GetCasterLevelByClass(nClass, oPC);
// these specific classes only learn at specific rates
int advancedLearning = 0;
// beguiler learns every 4th level starting on 3
if (nClass == CLASS_TYPE_BEGUILER)
advancedLearning = ((casterLevel+1)/4);
// dread learns every 4th level
if (nClass == CLASS_TYPE_DREAD_NECROMANCER)
advancedLearning = (casterLevel/4);
// warmage is a bastard child that choses when it learns a spell whenever
// it decides it feels like it wants to
if (nClass == CLASS_TYPE_WARMAGE)
{
if (casterLevel >= 3) // 1 choice
advancedLearning++;
if (casterLevel >= 6) // 2 choice
advancedLearning++;
if (casterLevel >= 11) // 3 choice
advancedLearning++;
if (casterLevel >= 16) // 4 choice
advancedLearning++;
if (casterLevel >= 24) // 5 choice
advancedLearning++;
if (casterLevel >= 28) // 6 choice
advancedLearning++;
if (casterLevel >= 32) // 7 choice
advancedLearning++;
if (casterLevel >= 36) // 8 choice
advancedLearning++;
if (casterLevel >= 40) // 9 choice
advancedLearning++;
}
if (advancedLearning)
{
int maxSpellLevel = GetMaxSpellLevelForCasterLevel(nClass, casterLevel);
// can't learn what you can't achieve
if (circleLevel > maxSpellLevel)
remainingChoices = 0;
else
{
int chosenSpellsAmount = 0;
json circles = JsonObjectKeys(chosenSpells);
int totalCircles = JsonGetLength(circles);
string sFile = GetClassSpellbookFile(nClass);
int i;
for (i = 0; i <= totalCircles; i++)
{
string currentCircle = JsonGetString(JsonArrayGet(circles, i));
json spellList = JsonObjectGet(chosenSpells, currentCircle);
if ((spellList != JsonNull()))
{
// loop through the spells of a given circle and count how
// many advanced learning spells you know
int numOfSpells = JsonGetLength(spellList);
int j;
for (j = 0; j < numOfSpells; j++)
{
int nSpellbookID = JsonGetInt(JsonArrayGet(spellList, j));
int isAL = StringToInt(Get2DACache(sFile, "AL", nSpellbookID));
if (isAL)
chosenSpellsAmount++;
}
}
}
remainingChoices = (advancedLearning - chosenSpellsAmount);
}
}
else
{
// default logic for spont casters
totalSpellsKnown = GetSpellKnownMaxCount(casterLevel, circleLevel, nClass, oPC);
// Favoured Soul has more 0 choices than there are spells for some reason
if (nClass == CLASS_TYPE_FAVOURED_SOUL && circleLevel == 0 && totalSpellsKnown > 6)
totalSpellsKnown = 6;
// logic for spont casters
json selectedCircle = JsonObjectGet(chosenSpells, IntToString(circleLevel));
if (selectedCircle == JsonNull())
return totalSpellsKnown;
int selectedSpellCount = JsonGetLength(selectedCircle);
remainingChoices = (totalSpellsKnown - selectedSpellCount);
}
}
if (chosenCircle == circleLevel)
SetLocalInt(oPC, NUI_LEVEL_UP_REMAINING_CHOICES_CACHE_VAR, remainingChoices);
return remainingChoices;
}
void FinishLevelUp(int nClass, object oPC=OBJECT_SELF)
{
RemoveSpells(nClass, oPC);
LearnSpells(nClass, oPC);
if (nClass == CLASS_TYPE_ARCHIVIST)
{
int nLevel = GetLevelByClass(nClass, oPC);
SetPersistantLocalInt(oPC, "LastSpellGainLevel", nLevel);
}
ClearLevelUpNUICaches(nClass, oPC);
}
void ClearLevelUpNUICaches(int nClass, object oPC=OBJECT_SELF)
{
// clear the chosen spells you made
DeleteLocalJson(oPC, NUI_LEVEL_UP_CHOSEN_SPELLS_VAR);
// clear the known spells you have
DeleteLocalJson(oPC, NUI_LEVEL_UP_KNOWN_SPELLS_VAR);
SetLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CIRCLE_VAR, -1);
DeleteLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CLASS_VAR);
// clear the psionics selected choices
DeleteLocalJson(oPC, NUI_LEVEL_UP_POWER_LIST_VAR);
// clear the expanded choices for psionics and invokers
DeleteLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR);
DeleteLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR);
// clear the PnP replace list
DeleteLocalJson(oPC, NUI_LEVEL_UP_RELEARN_LIST_VAR);
DeleteLocalJson(oPC, NUI_LEVEL_UP_ARCHIVIST_NEW_SPELLS_LIST_VAR);
// for invocation and psionics we grab the list of known extra spells and cache it
// so we need to clear those caches
if (GetIsInvocationClass(nClass))
{
DeleteLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_0");
DeleteLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_" + IntToString(INVOCATION_LIST_EXTRA));
DeleteLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_" + IntToString(INVOCATION_LIST_EXTRA_EPIC));
}
if (GetIsPsionicClass(nClass))
{
DeleteLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_0");
DeleteLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_" + IntToString(POWER_LIST_EXP_KNOWLEDGE));
DeleteLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_" + IntToString(POWER_LIST_EPIC_EXP_KNOWLEDGE));
}
// for ToB we need to clear all the discipline info for determining PrC choice validity
if (GetIsBladeMagicClass(nClass))
{
DeleteLocalJson(oPC, NUI_LEVEL_UP_DISCIPLINE_INFO_VAR + IntToString(CLASS_TYPE_SWORDSAGE));
DeleteLocalJson(oPC, NUI_LEVEL_UP_DISCIPLINE_INFO_VAR + IntToString(CLASS_TYPE_WARBLADE));
DeleteLocalJson(oPC, NUI_LEVEL_UP_DISCIPLINE_INFO_VAR + IntToString(CLASS_TYPE_CRUSADER));
}
}
void RemoveSpells(int nClass, object oPC=OBJECT_SELF)
{
// we don't remove on psionic classes and archivist
if (GetIsPsionicClass(nClass) || nClass == CLASS_TYPE_ARCHIVIST)
return;
json knownSpells = GetKnownSpellListObject(nClass, oPC);
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
json spellCircles = JsonObjectKeys(knownSpells);
int totalCircles = JsonGetLength(spellCircles);
// loop through all the known spells circles
int i;
for (i = 0; i < totalCircles; i++)
{
string sSpellLevel = JsonGetString(JsonArrayGet(spellCircles, i));
int nSpellLevel = StringToInt(sSpellLevel);
json chosenCircle = JsonObjectGet(knownSpells, sSpellLevel);
int totalSpells = JsonGetLength(chosenCircle);
// loop through the spell list at the given circle
int y;
for (y = 0; y < totalSpells; y++)
{
int nSpellbookID = JsonGetInt(JsonArrayGet(chosenCircle, y));
// if the spell is not a chosen spell, then it was removed
if (!SpellIsWithinObject(nClass, nSpellbookID, nSpellLevel, chosenSpells, oPC))
{
if (GetIsInvocationClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
string spellId = Get2DACache(sFile, "SpellID", nSpellbookID);
int chosenList = 0;
// check to see if its a extra invocation choice and set it's chosen list
if (GetHasFeat(FEAT_EXTRA_INVOCATION_I, oPC))
{
json expList = GetSpellIDsKnown(nClass, oPC, INVOCATION_LIST_EXTRA);
if (JsonObjectGet(expList, spellId) != JsonNull())
chosenList = INVOCATION_LIST_EXTRA;
}
if (GetHasFeat(FEAT_EPIC_EXTRA_INVOCATION_I, oPC))
{
json expList = GetSpellIDsKnown(nClass, oPC, INVOCATION_LIST_EXTRA_EPIC);
if (JsonObjectGet(expList, spellId) != JsonNull())
chosenList = INVOCATION_LIST_EXTRA_EPIC;
}
RemoveSpellKnown(nClass, nSpellbookID, oPC, chosenList);
}
if (GetIsBladeMagicClass(nClass) || GetIsShadowMagicClass(nClass))
RemoveSpellKnown(nClass, nSpellbookID, oPC);
if (GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS)
{
string sFile = GetClassSpellbookFile(nClass);
string sSpellBook = GetSpellsKnown_Array(nClass);
// remove the spell from the spellbook
array_extract_int(oPC, sSpellBook, nSpellbookID);
// wipe the spell from the player
int ipFeatID = StringToInt(Get2DACache(sFile, "IPFeatID", nSpellbookID));
WipeSpellFromHide(ipFeatID, oPC);
}
}
}
}
}
void LearnSpells(int nClass, object oPC=OBJECT_SELF)
{
if (GetIsPsionicClass(nClass))
{
LearnPowers(nClass, oPC);
return;
}
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
json knownSpells = GetKnownSpellListObject(nClass, oPC);
json spellCircles = JsonObjectKeys(chosenSpells);
int totalCircles = JsonGetLength(spellCircles);
// loop through chosen spells circles
int i;
for (i = 0; i < totalCircles; i++)
{
string sSpellLevel = JsonGetString(JsonArrayGet(spellCircles, i));
int nSpellLevel = StringToInt(sSpellLevel);
json chosenCircle = JsonObjectGet(chosenSpells, sSpellLevel);
int totalSpells = JsonGetLength(chosenCircle);
// loop through the spell list at the circle
int y;
for (y = 0; y < totalSpells; y++)
{
int nSpellbookID = JsonGetInt(JsonArrayGet(chosenCircle, y));
// if the spell is not in the known spell list then it was newly added
if (!SpellIsWithinObject(nClass, nSpellbookID, nSpellLevel, knownSpells, oPC))
{
if (GetIsTruenamingClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
// find out what lexicon it belongs to and add it to that
int lexicon = StringToInt(Get2DACache(sFile, "Lexicon", nSpellbookID));
AddUtteranceKnown(oPC, nClass, nSpellbookID, lexicon, TRUE, GetHitDice(oPC));
}
if (GetIsShadowMagicClass(nClass))
AddMysteryKnown(oPC, nClass, nSpellbookID, TRUE, GetHitDice(oPC));
if (GetIsInvocationClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
string spellId = Get2DACache(sFile, "SpellID", nSpellbookID);
int chosenList = nClass;
json expList = GetExpandedChoicesList(nClass, oPC);
// if the invocation belongs to the extra or epic extra list
// then we need to provide those list ids instead.
if (JsonObjectGet(expList, spellId) != JsonNull())
chosenList = INVOCATION_LIST_EXTRA;
expList = GetEpicExpandedChoicesList(nClass, oPC);
if (JsonObjectGet(expList, spellId) != JsonNull())
chosenList = INVOCATION_LIST_EXTRA_EPIC;
AddInvocationKnown(oPC, chosenList, nSpellbookID, TRUE, GetHitDice(oPC));
}
if (GetIsBladeMagicClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
int maneuverType = StringToInt(Get2DACache(sFile, "Type", nSpellbookID));
// we save our moves either to stance or maneuever
if (maneuverType != MANEUVER_TYPE_STANCE)
maneuverType = MANEUVER_TYPE_MANEUVER;
AddManeuverKnown(oPC, nClass, nSpellbookID, maneuverType, TRUE, GetHitDice(oPC));
}
int nSpellbookType = GetSpellbookTypeForClass(nClass);
if (nSpellbookType == SPELLBOOK_TYPE_SPONTANEOUS
|| nClass == CLASS_TYPE_ARCHIVIST)
{
// these classes have their own syste,
if (nClass == CLASS_TYPE_BEGUILER
|| nClass == CLASS_TYPE_DREAD_NECROMANCER
|| nClass == CLASS_TYPE_WARMAGE)
{
int casterLevel = GetCasterLevelByClass(nClass, oPC);
// this is taken from prc_s_spellgain as it is coupled with the
// dynamic dialogue system
int advancedLearning = 0;
// beguilers learn every 4th level starting on 3rd
if (nClass == CLASS_TYPE_BEGUILER)
advancedLearning = ((casterLevel+1)/4);
// dread learns every 4th level
if (nClass == CLASS_TYPE_DREAD_NECROMANCER)
advancedLearning = (casterLevel/4);
if (nClass == CLASS_TYPE_WARMAGE)
{
if (casterLevel >= 3)
advancedLearning++;
}
if (advancedLearning)
{
// incremenet the total advanced learning known
int nAdvLearn = GetPersistantLocalInt(oPC, "AdvancedLearning_"+IntToString(nClass));
nAdvLearn++;
SetPersistantLocalInt(oPC, "AdvancedLearning_"+IntToString(nClass), nAdvLearn);
}
}
// get location of persistant storage on the hide
string sSpellbook = GetSpellsKnown_Array(nClass, nSpellLevel);
//object oToken = GetHideToken(oPC);
// Create spells known persistant array if it is missing
int nSize = persistant_array_get_size(oPC, sSpellbook);
if (nSize < 0)
{
persistant_array_create(oPC, sSpellbook);
nSize = 0;
}
// Mark the spell as known (e.g. add it to the end of oPCs spellbook)
persistant_array_set_int(oPC, sSpellbook, nSize, nSpellbookID);
if (nSpellbookType == SPELLBOOK_TYPE_SPONTANEOUS)
{
// add spell
string sFile = GetClassSpellbookFile(nClass);
string sArrayName = "NewSpellbookMem_" + IntToString(nClass);
int featId = StringToInt(Get2DACache(sFile, "FeatID", nSpellbookID));
int ipFeatID = StringToInt(Get2DACache(sFile, "IPFeatID", nSpellbookID));
AddSpellUse(oPC, nSpellbookID, nClass, sFile, sArrayName, nSpellbookType, GetPCSkin(oPC), featId, ipFeatID);
}
}
}
}
}
}
int EnableChosenButton(int nClass, int spellbookId, int circleLevel, object oPC=OBJECT_SELF)
{
if (GetIsPsionicClass(nClass)
|| GetIsShadowMagicClass(nClass)
|| GetIsTruenamingClass(nClass)
|| nClass == CLASS_TYPE_DREAD_NECROMANCER
|| nClass == CLASS_TYPE_BEGUILER
|| nClass == CLASS_TYPE_WARMAGE
|| nClass == CLASS_TYPE_ARCHIVIST)
{
json knownSpells = GetKnownSpellListObject(nClass, oPC);
json currentCircle = JsonObjectGet(knownSpells, IntToString(circleLevel));
int totalSpells = JsonGetLength(currentCircle);
int i;
for (i = 0; i < totalSpells; i++)
{
// if spell belongs to known spells, then disable, we don't allow
// replacing for these classes.
int currentSpellbookId = JsonGetInt(JsonArrayGet(currentCircle, i));
if (currentSpellbookId == spellbookId)
return FALSE;
}
}
if (GetIsBladeMagicClass(nClass))
{
string sFile = GetClassSpellbookFile(nClass);
int prereqs = StringToInt(Get2DACache(sFile, "Prereqs", spellbookId));
string discipline = Get2DACache(sFile, "Discipline", spellbookId);
// if the maneuver is required for others to exist, t hen disable it
if (IsRequiredForOtherManeuvers(nClass, prereqs, discipline, oPC))
return FALSE;
// if it is required for a PRC to exist, then disable it.
if (IsRequiredForToBPRCClass(nClass, spellbookId, oPC))
return FALSE;
}
if (GetIsInvocationClass(nClass))
{
// dragon Shamans can't replace
if (nClass == CLASS_TYPE_DRAGON_SHAMAN)
{
json invokKnown = GetSpellIDsKnown(nClass, oPC);
string sFile = GetClassSpellbookFile(nClass);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
json chosenSpell = JsonObjectGet(invokKnown, spellId);
if (chosenSpell != JsonNull())
return FALSE;
}
}
// If we do not use the bioware unlearn system, we follow PnP
if (!GetPRCSwitch(PRC_BIO_UNLEARN))
{
json knownSpells = GetKnownSpellListObject(nClass, oPC);
json currentCircle = JsonObjectGet(knownSpells, IntToString(circleLevel));
int totalSpells = JsonGetLength(currentCircle);
int i;
for (i = 0; i < totalSpells; i++)
{
int currentSpellbookId = JsonGetInt(JsonArrayGet(currentCircle, i));
// if the spell belongs to the known spell list, then we need to determine
if (currentSpellbookId == spellbookId)
{
json unlearnList = GetChosenReplaceListObject(oPC);
int totalUnlearned = JsonGetLength(unlearnList);
int totalAllowed = GetPRCSwitch(PRC_UNLEARN_SPELL_MAXNR);
// we default to 1 if no max number of unlearns is set
if (!totalAllowed)
totalAllowed = 1;
// we cannot replace a spell if we have more than or equal to the
// amount of relearns allowed, therefore disable.
return totalUnlearned < totalAllowed;
}
}
}
return TRUE;
}
void ResetChoices(object oPC=OBJECT_SELF)
{
// reset choices made so far
DeleteLocalJson(oPC, NUI_LEVEL_UP_CHOSEN_SPELLS_VAR);
DeleteLocalJson(oPC, NUI_LEVEL_UP_POWER_LIST_VAR);
DeleteLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR);
DeleteLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR);
DeleteLocalJson(oPC, NUI_LEVEL_UP_RELEARN_LIST_VAR);
DeleteLocalJson(oPC, NUI_LEVEL_UP_ARCHIVIST_NEW_SPELLS_LIST_VAR);
}
void RemoveSpellKnown(int nClass, int spellbookId, object oPC=OBJECT_SELF, int nList=0)
{
string sBase;
string levelArrayBaseId;
string generalArrayBaseId;
string totalCountId;
string sFile = GetClassSpellbookFile(nClass);
int chosenList = (nList != 0) ? nList : nClass;
int spellID = StringToInt(Get2DACache(sFile, "SpellID", spellbookId));
// if statements are to change the location of the spellbook we are grabbing
if (GetIsShadowMagicClass(nClass))
{
sBase = _MYSTERY_LIST_NAME_BASE + IntToString(chosenList);
levelArrayBaseId = _MYSTERY_LIST_LEVEL_ARRAY;
generalArrayBaseId = _MYSTERY_LIST_GENERAL_ARRAY;
totalCountId = _MYSTERY_LIST_TOTAL_KNOWN;
}
if (GetIsInvocationClass(nClass))
{
sBase = _INVOCATION_LIST_NAME_BASE + IntToString(chosenList);
levelArrayBaseId = _INVOCATION_LIST_LEVEL_ARRAY;
generalArrayBaseId = _INVOCATION_LIST_GENERAL_ARRAY;
totalCountId = _INVOCATION_LIST_TOTAL_KNOWN;
}
if (GetIsBladeMagicClass(nClass))
{
int maneuverType = StringToInt(Get2DACache(sFile, "Type", spellbookId));
if (maneuverType != MANEUVER_TYPE_STANCE) maneuverType = MANEUVER_TYPE_MANEUVER;
sBase = _MANEUVER_LIST_NAME_BASE + IntToString(chosenList) + IntToString(maneuverType);
levelArrayBaseId = _MANEUVER_LIST_LEVEL_ARRAY;
generalArrayBaseId = _MANEUVER_LIST_GENERAL_ARRAY;
totalCountId = _MANEUVER_LIST_TOTAL_KNOWN;
}
if (GetIsTruenamingClass(nClass))
{
string lexicon = Get2DACache(sFile, "Lexicon", spellbookId);
sBase = _UTTERANCE_LIST_NAME_BASE + IntToString(chosenList) + lexicon;
levelArrayBaseId = _UTTERANCE_LIST_LEVEL_ARRAY;
generalArrayBaseId = _UTTERANCE_LIST_GENERAL_ARRAY;
totalCountId = _UTTERANCE_LIST_TOTAL_KNOWN;
}
string sTestArray;
int found = FALSE;
int i;
for (i = 1; i <= GetHitDice(oPC); i++)
{
sTestArray = sBase + levelArrayBaseId + IntToString(i);
if (persistant_array_exists(oPC, sTestArray))
{
// if we found the spell, then we remove it.
if (persistant_array_extract_int(oPC, sTestArray, spellID) >= 0)
{
found = TRUE;
break;
}
}
}
if (!found)
{
// if not found we check the general list where spells aren't set to a level.
sTestArray = sBase + generalArrayBaseId;
if (persistant_array_exists(oPC, sTestArray))
{
//if we could not find the spell here, something went wrong
if (persistant_array_extract_int(oPC, sTestArray, spellID) < 0)
{
SendMessageToPC(oPC, "Could not find spellID " + IntToString(spellID) + " in the class's spellbook!");
return;
}
}
}
// decrement the amount of spells known.
SetPersistantLocalInt(oPC, sBase + totalCountId,
GetPersistantLocalInt(oPC, sBase + totalCountId) - 1
);
// if ToB we need to decrement the specific discipline as well.
if (GetIsBladeMagicClass(nClass))
{
int maneuverType = StringToInt(Get2DACache(sFile, "Type", spellbookId));
if (maneuverType == MANEUVER_TYPE_BOOST
|| maneuverType == MANEUVER_TYPE_COUNTER
|| maneuverType == MANEUVER_TYPE_STRIKE
|| maneuverType == MANEUVER_TYPE_MANEUVER)
maneuverType = MANEUVER_TYPE_MANEUVER;
string sDisciplineArray = _MANEUVER_LIST_DISCIPLINE + IntToString(maneuverType) + "_" + Get2DACache(sFile, "Discipline", spellbookId);
SetPersistantLocalInt(oPC, sDisciplineArray,
GetPersistantLocalInt(oPC, sDisciplineArray) - 1);
}
// remove spell from player
int ipFeatID = StringToInt(Get2DACache(sFile, "IPFeatID", spellbookId));
itemproperty ipFeat = PRCItemPropertyBonusFeat(ipFeatID);
object oSkin = GetPCSkin(oPC);
RemoveItemProperty(oSkin, ipFeat);
CheckAndRemoveFeat(oSkin, ipFeat);
}
json GetSpellIDsKnown(int nClass, object oPC=OBJECT_SELF, int nList=0)
{
json spellIds = GetLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_" + IntToString(nList));
if (spellIds == JsonNull())
spellIds = JsonObject();
else
return spellIds;
string sBase;
string levelArrayBaseId;
string generalArrayBaseId;
// if we are given a listId then use that instead, used for extra choices and
// expanded knowledge
int chosenList = (nList != 0) ? nList : nClass;
// these if checks are for setting class specific ids
if (nClass == CLASS_TYPE_DRAGON_SHAMAN
|| nClass == CLASS_TYPE_DRAGONFIRE_ADEPT
|| nClass == CLASS_TYPE_WARLOCK)
{
sBase = _INVOCATION_LIST_NAME_BASE + IntToString(chosenList);
levelArrayBaseId = _INVOCATION_LIST_LEVEL_ARRAY;
generalArrayBaseId = _INVOCATION_LIST_GENERAL_ARRAY;
}
if (GetIsPsionicClass(nClass))
{
sBase = _POWER_LIST_NAME_BASE + IntToString(chosenList);
levelArrayBaseId = _POWER_LIST_LEVEL_ARRAY;
generalArrayBaseId = _POWER_LIST_GENERAL_ARRAY;
}
// go through the level list and translate the spellIds into a JSON Object
// structure for easier access.
int i;
for (i = 1; i <= GetHitDice(oPC); i++)
{
string sTestArray = sBase + levelArrayBaseId + IntToString(i);
if (persistant_array_exists(oPC, sTestArray))
{
int nSize = persistant_array_get_size(oPC, sTestArray);
int j;
for (j = 0; j < nSize; j++)
{
spellIds = JsonObjectSet(spellIds, IntToString(persistant_array_get_int(oPC, sTestArray, j)), JsonBool(TRUE));
}
}
}
// go through the general list and translate the spellIds into a JSON Object
// structure for easier access.
string sTestArray = sBase + generalArrayBaseId;
if (persistant_array_exists(oPC, sTestArray))
{
int nSize = persistant_array_get_size(oPC, sTestArray);
int j;
for (j = 0; j < nSize; j++)
{
spellIds = JsonObjectSet(spellIds, IntToString(persistant_array_get_int(oPC, sTestArray, j)), JsonBool(TRUE));
}
}
SetLocalJson(oPC, NUI_LEVEL_UP_SPELLID_LIST_VAR + IntToString(nClass) + "_" + IntToString(nList), spellIds);
return spellIds;
}
string ReasonForDisabledSpell(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
string sFile = GetClassSpellbookFile(nClass);
int circleLevel = StringToInt(Get2DACache(sFile, "Level", spellbookId));
// logic for psionics
if (GetIsPsionicClass(nClass))
{
int maxLevel = GetMaxPowerLevelForClass(nClass, oPC);
if (circleLevel > maxLevel)
return "You are unable to learn at this level currently.";
// if its an expanded knowledge choice and we have already made all our
// exp knowledge choices then it needs to be disabled.
if (IsExpKnowledgePower(nClass, spellbookId))
{
int remainingExp = GetRemainingExpandedChoices(nClass, POWER_LIST_EXP_KNOWLEDGE, oPC)
+ GetRemainingExpandedChoices(nClass, POWER_LIST_EPIC_EXP_KNOWLEDGE, oPC);
if (!remainingExp)
return "You have no more expanded knowledge choices left.";
}
}
if (GetIsShadowMagicClass(nClass))
{
// mysteries are weird, the circles are sectioned by 1-3, 4-6, 7-9
// if you do not have at least 2 choices from a circle you can't progress up
// so you can have access to circles 1,2,4,7,8
int nType = 1;
if (circleLevel >= 4 && circleLevel <= 6)
nType = 2;
if (circleLevel >= 7 && circleLevel <= 9)
nType = 3;
int maxPossibleCircle = GetMaxMysteryLevelLearnable(oPC, nClass, nType);
if (circleLevel > maxPossibleCircle)
return "You are unable to learn at this level currently.";
}
if (GetIsTruenamingClass(nClass))
{
int lexicon = StringToInt(Get2DACache(sFile, "Lexicon", spellbookId));
// each lexicon learns at different rates
int maxCircle = GetLexiconCircleKnownAtLevel(GetLevelByClass(nClass, oPC), lexicon);
if (circleLevel > maxCircle)
return "You are unable to learn at this level currently.";
if (GetRemainingTruenameChoices(nClass, lexicon, oPC))
return "";
return "You have made all your truenaming choices.";
}
// logic for ToB
if (GetIsBladeMagicClass(nClass))
{
if (circleLevel > GetMaxInitiatorCircle(nClass, oPC))
return "You are unable to learn at this level currently.";
// if you do not have the prerequisite amount of maneuevers to learn
// the maneuever, then you can't learn it.
if (!HasPreRequisitesForManeuver(nClass, spellbookId, oPC))
return "You do not have the prerequisites for this maneuver.";
// maneuvers and stances have their own seperate limits
int type = StringToInt(Get2DACache(sFile, "Type", spellbookId));
if (type == MANEUVER_TYPE_BOOST
|| type == MANEUVER_TYPE_COUNTER
|| type == MANEUVER_TYPE_STRIKE
|| type == MANEUVER_TYPE_MANEUVER)
{
int remainingMan = GetRemainingManeuverChoices(nClass, oPC);
if (remainingMan)
return "";
return "You have made all your maneuver choices.";
}
if (type == MANEUVER_TYPE_STANCE)
{
int remainingStance = GetRemainingStanceChoices(nClass, oPC);
if (remainingStance)
return "";
return "You have made all your stance choices.";
}
}
// default logic
// determine remaining Spell/Power choices left for player, if there is any
// remaining, enable the buttons.
if (GetRemainingSpellChoices(nClass, circleLevel, oPC))
return "";
return "You have made all your spell choices.";
}
string ReasonForDisabledChosen(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
string sFile = GetClassSpellbookFile(nClass);
int circleLevel = StringToInt(Get2DACache(sFile, "Level", spellbookId));
if (GetIsPsionicClass(nClass)
|| GetIsShadowMagicClass(nClass)
|| GetIsTruenamingClass(nClass)
|| nClass == CLASS_TYPE_DREAD_NECROMANCER
|| nClass == CLASS_TYPE_BEGUILER
|| nClass == CLASS_TYPE_WARMAGE)
{
json knownSpells = GetKnownSpellListObject(nClass, oPC);
json currentCircle = JsonObjectGet(knownSpells, IntToString(circleLevel));
int totalSpells = JsonGetLength(currentCircle);
int i;
for (i = 0; i < totalSpells; i++)
{
// if spell belongs to known spells, then disable, we don't allow
// replacing for these classes.
int currentSpellbookId = JsonGetInt(JsonArrayGet(currentCircle, i));
if (currentSpellbookId == spellbookId)
return "You cannot replace spells as this class.";
}
}
if (GetIsBladeMagicClass(nClass))
{
int prereqs = StringToInt(Get2DACache(sFile, "Prereqs", spellbookId));
string discipline = Get2DACache(sFile, "Discipline", spellbookId);
// if the maneuver is required for others to exist, t hen disable it
if (IsRequiredForOtherManeuvers(nClass, prereqs, discipline, oPC))
return "This maneuver is required for another maneuver.";
// if it is required for a PRC to exist, then disable it.
if (IsRequiredForToBPRCClass(nClass, spellbookId, oPC))
return "This maneuver is reuquired for a PRC class.";
}
if (GetIsInvocationClass(nClass))
{
// dragon Shamans can't replace
if (nClass == CLASS_TYPE_DRAGON_SHAMAN)
{
json invokKnown = GetSpellIDsKnown(nClass, oPC);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
json chosenSpell = JsonObjectGet(invokKnown, spellId);
if (chosenSpell != JsonNull())
return "You cannot replace invocations as this class.";
}
}
// If we do not use the bioware unlearn system, we follow PnP
if (!GetPRCSwitch(PRC_BIO_UNLEARN))
{
json knownSpells = GetKnownSpellListObject(nClass, oPC);
json currentCircle = JsonObjectGet(knownSpells, IntToString(circleLevel));
int totalSpells = JsonGetLength(currentCircle);
int i;
for (i = 0; i < totalSpells; i++)
{
int currentSpellbookId = JsonGetInt(JsonArrayGet(currentCircle, i));
// if the spell belongs to the known spell list, then we need to determine
if (currentSpellbookId == spellbookId)
{
json unlearnList = GetChosenReplaceListObject(oPC);
int totalUnlearned = JsonGetLength(unlearnList);
int totalAllowed = GetPRCSwitch(PRC_UNLEARN_SPELL_MAXNR);
// we default to 1 if no max number of unlearns is set
if (!totalAllowed)
totalAllowed = 1;
// we cannot replace a spell if we have more than or equal to the
// amount of relearns allowed, therefore disable.
if (totalUnlearned < totalAllowed)
return "";
return "You can only replace " + IntToString(totalAllowed) + " spells during level up.";
}
}
}
return "";
}
json GetExpandedChoicesList(int nClass, object oPC=OBJECT_SELF)
{
json expandedChoices = GetLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR);
if (expandedChoices != JsonNull())
return expandedChoices;
if (GetIsPsionicClass(nClass))
expandedChoices = GetSpellIDsKnown(nClass, oPC, POWER_LIST_EXP_KNOWLEDGE);
else
expandedChoices = GetSpellIDsKnown(nClass, oPC, INVOCATION_LIST_EXTRA);
SetLocalJson(oPC, NUI_LEVEL_UP_EXPANDED_CHOICES_VAR, expandedChoices);
return expandedChoices;
}
int GetRemainingExpandedChoices(int nClass, int nList, object oPC=OBJECT_SELF)
{
int remainingChoices = 0;
json expandedList = (nList == INVOCATION_LIST_EXTRA || nList == POWER_LIST_EXP_KNOWLEDGE ) ? GetExpandedChoicesList(nClass, oPC)
: GetEpicExpandedChoicesList(nClass, oPC);
int expChoicesCount = JsonGetLength(JsonObjectKeys(expandedList));
int maxExpChoices = (GetIsPsionicClass(nClass)) ? GetMaxPowerCount(oPC, nList)
: GetMaxInvocationCount(oPC, nList);
remainingChoices += (maxExpChoices - expChoicesCount);
return remainingChoices;
}
json GetEpicExpandedChoicesList(int nClass, object oPC=OBJECT_SELF)
{
json expandedChoices = GetLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR);
if (expandedChoices != JsonNull())
return expandedChoices;
if (GetIsPsionicClass(nClass))
expandedChoices = GetSpellIDsKnown(nClass, oPC, POWER_LIST_EPIC_EXP_KNOWLEDGE);
else
expandedChoices = GetSpellIDsKnown(nClass, oPC, INVOCATION_LIST_EXTRA_EPIC);
SetLocalJson(oPC, NUI_LEVEL_UP_EPIC_EXPANDED_CHOICES_VAR, expandedChoices);
return expandedChoices;
}
int IsSpellInExpandedChoices(int nClass, int nList, int spellId, object oPC=OBJECT_SELF)
{
json expList = (nList == POWER_LIST_EXP_KNOWLEDGE || nList == INVOCATION_LIST_EXTRA) ? GetExpandedChoicesList(nClass, oPC)
: GetEpicExpandedChoicesList(nClass, oPC);
return (JsonObjectGet(expList, IntToString(spellId)) != JsonNull());
}
json GetChosenReplaceListObject(object oPC=OBJECT_SELF)
{
json replaceList = GetLocalJson(oPC, NUI_LEVEL_UP_RELEARN_LIST_VAR);
if (replaceList == JsonNull())
replaceList = JsonObject();
else
return replaceList;
SetLocalJson(oPC, NUI_LEVEL_UP_RELEARN_LIST_VAR, replaceList);
return replaceList;
}
////////////////////////////////////////////////////////////////////////////
/// ///
/// Psionics ///
/// ///
////////////////////////////////////////////////////////////////////////////
int IsExpKnowledgePower(int nClass, int spellbookId)
{
string sFile = GetClassSpellbookFile(nClass);
int isExp = StringToInt(Get2DACache(sFile, "Exp", spellbookId));
return isExp;
}
json GetCurrentPowerList(object oPC=OBJECT_SELF)
{
json retValue = GetLocalJson(oPC, NUI_LEVEL_UP_POWER_LIST_VAR);
if (retValue == JsonNull())
retValue = JsonArray();
else
return retValue;
SetLocalJson(oPC, NUI_LEVEL_UP_POWER_LIST_VAR, retValue);
return retValue;
}
int ShouldAddPower(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
string sFile = GetClassSpellbookFile(nClass);
int featId = StringToInt(Get2DACache(sFile, "FeatID", spellbookId));
int isExp = StringToInt(Get2DACache(sFile, "Exp", spellbookId));
// if you don't have the prereqs for a power then don't add it. Specific for
// psions
if (!CheckPowerPrereqs(featId, oPC))
return FALSE;
// if the power is a expanded knowledge power
if (isExp)
{
// and we have a expanded knowledge choice left to make then show
// the button
int addPower = FALSE;
int maxLevel = GetMaxPowerLevelForClass(nClass, oPC);
int currentCircle = GetLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CIRCLE_VAR);
int choicesLeft = GetRemainingExpandedChoices(nClass, POWER_LIST_EXP_KNOWLEDGE, oPC);
if (choicesLeft && (currentCircle <= (maxLevel-1)))
addPower = TRUE;
choicesLeft = GetRemainingExpandedChoices(nClass, POWER_LIST_EPIC_EXP_KNOWLEDGE, oPC);
if (choicesLeft)
addPower = TRUE;
// otherwise don't show the button.
return addPower;
}
return TRUE;
}
void LearnPowers(int nClass, object oPC=OBJECT_SELF)
{
// add normal powers
json powerList = GetCurrentPowerList(oPC);
int totalPowers = JsonGetLength(powerList);
int i;
for (i = 0; i < totalPowers; i++)
{
int nSpellbookID = JsonGetInt(JsonArrayGet(powerList, i));
// get the expanded knowledge list we are adding to if any
int expKnow = GetExpKnowledgePowerListRequired(nClass, nSpellbookID, oPC);
AddPowerKnown(oPC, nClass, nSpellbookID, TRUE, GetManifesterLevel(oPC, nClass, TRUE), expKnow);
}
}
int GetExpKnowledgePowerListRequired(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
string sFile = GetClassSpellbookFile(nClass);
int i;
// expanded knowledge is -1, epic epxanded knowledge is -2
for (i = -1; i >= -2; i--)
{
int spellId = StringToInt(Get2DACache(sFile, "SpellID", spellbookId));
if (IsSpellInExpandedChoices(nClass, i, spellId, oPC))
return i;
}
return 0;
}
int GetMaxPowerLevelForClass(int nClass, object oPC=OBJECT_SELF)
{
string sFile = GetAMSKnownFileName(nClass);
int nLevel = GetManifesterLevel(oPC, nClass, TRUE);
// index is level - 1 since it starts at 0.
int maxLevel = StringToInt(Get2DACache(sFile, "MaxPowerLevel", nLevel-1));
return maxLevel;
}
int GetRemainingPowerChoices(int nClass, int chosenCircle, object oPC=OBJECT_SELF, int extra=TRUE)
{
int remaining = 0;
int maxLevel = GetMaxPowerLevelForClass(nClass, oPC);
if (chosenCircle > maxLevel)
return 0;
json choices = GetCurrentPowerList(oPC);
int totalChoices = JsonGetLength(choices);
int allowedChoices = GetMaxPowerCount(oPC, nClass);
int alreadyChosen = GetPowerCount(oPC, nClass);
string sFile = GetClassSpellbookFile(nClass);
int i = 0;
for (i = 0; i < totalChoices; i++)
{
int spellbookId = JsonGetInt(JsonArrayGet(choices, i));
int spellId = StringToInt(Get2DACache(sFile, "SpellID", spellbookId));
//if the power is a expanded knowledge choice, don't count it
if (!IsSpellInExpandedChoices(nClass, POWER_LIST_EXP_KNOWLEDGE, spellId, oPC)
&& !IsSpellInExpandedChoices(nClass, POWER_LIST_EPIC_EXP_KNOWLEDGE, spellId, oPC))
remaining++;
}
remaining = (allowedChoices - remaining - alreadyChosen);
// if this is true we count expanded knowledge choices
if (extra)
{
if (GetHasFeat(FEAT_EXPANDED_KNOWLEDGE_1, oPC) && (chosenCircle <= (maxLevel-1)))
{
int totalExp = GetMaxPowerCount(oPC, POWER_LIST_EXP_KNOWLEDGE);
json expChoices = GetExpandedChoicesList(nClass, oPC);
int choicesCount = JsonGetLength(JsonObjectKeys(expChoices));
remaining += (totalExp - choicesCount);
}
if (GetHasFeat(FEAT_EPIC_EXPANDED_KNOWLEDGE_1, oPC))
{
int totalExp = GetMaxPowerCount(oPC, POWER_LIST_EPIC_EXP_KNOWLEDGE);
json expChoices = GetEpicExpandedChoicesList(nClass, oPC);
int choicesCount = JsonGetLength(JsonObjectKeys(expChoices));
remaining += (totalExp - choicesCount);
}
}
return remaining;
}
////////////////////////////////////////////////////////////////////////////
/// ///
/// Initiators ///
/// ///
////////////////////////////////////////////////////////////////////////////
json GetDisciplineInfoObject(int nClass, object oPC=OBJECT_SELF)
{
json disciplineInfo = GetLocalJson(oPC, NUI_LEVEL_UP_DISCIPLINE_INFO_VAR + IntToString(nClass));
if (disciplineInfo == JsonNull())
disciplineInfo = JsonObject();
else
return disciplineInfo;
int chosenClass = GetLocalInt(oPC, NUI_LEVEL_UP_SELECTED_CLASS_VAR);
string sFile = GetClassSpellbookFile(nClass);
//if this is not the chosen class then we do not have a chosen spell list
// need to go through the class's 2da and check if you know the spell or not.
if (nClass != chosenClass)
{
int totalSpells = Get2DARowCount(sFile);
int i;
for (i = 0; i < totalSpells; i++)
{
int featId = StringToInt(Get2DACache(sFile, "FeatID", i));
if (featId && GetHasFeat(featId, oPC, TRUE))
disciplineInfo = AddSpellDisciplineInfo(sFile, i, disciplineInfo);
}
}
else
{
json chosenMans = GetChosenSpellListObject(nClass, oPC);
json circles = JsonObjectKeys(chosenMans);
int totalCircles = JsonGetLength(circles);
int i;
for (i = 0; i < totalCircles; i++)
{
string currentCircle = JsonGetString(JsonArrayGet(circles, i));
json currentList = JsonObjectGet(chosenMans, currentCircle);
int totalSpells = JsonGetLength(currentList);
int y;
for (y = 0; y < totalSpells; y++)
{
int spellbookId = JsonGetInt(JsonArrayGet(currentList, y));
disciplineInfo = AddSpellDisciplineInfo(sFile, spellbookId, disciplineInfo);
}
}
}
SetLocalJson(oPC, NUI_LEVEL_UP_DISCIPLINE_INFO_VAR + IntToString(nClass), disciplineInfo);
return disciplineInfo;
}
int IsRequiredForOtherManeuvers(int nClass, int prereq, string discipline, object oPC=OBJECT_SELF)
{
json discInfo = GetDisciplineInfoObject(nClass, oPC);
int total = 0;
// loop through each prereq level and add up it's totals (ie how many maneuevrs
// do we know with 0,1,2...,n prereqs.
int i;
for (i = 0; i <= prereq; i++)
{
json currDisc = JsonObjectGet(discInfo, discipline);
string discKey = ("Prereq_" + IntToString(i));
int currentDiscPrereq = JsonGetInt(JsonObjectGet(currDisc, discKey));
total += currentDiscPrereq;
}
// then from above the given prereq check if we have any prereq maneuevers taken
for (i = (prereq+1); i < NUI_LEVEL_UP_MANEUVER_PREREQ_LIMIT; i++)
{
json currDisc = JsonObjectGet(discInfo, discipline);
string discKey = ("Prereq_" + IntToString(i));
json discPrereq = JsonObjectGet(currDisc, discKey);
if (discPrereq != JsonNull())
{
// if we do take the total and subtract by one, if it is lower than
// than the prereq needed, it is required
if (total - 1 < i)
return TRUE;
// otherwise add how many we have and move up and keep trying.
int currentDiscPrereq = JsonGetInt(discPrereq);
total += currentDiscPrereq;
}
}
return FALSE;
}
int HasPreRequisitesForManeuver(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
string sFile = GetClassSpellbookFile(nClass);
int prereqs = StringToInt(Get2DACache(sFile, "Prereqs", spellbookId));
if (!prereqs)
return TRUE;
string discipline = Get2DACache(sFile, "Discipline", spellbookId);
json discInfo = GetDisciplineInfoObject(nClass, oPC);
json chosenDisc = JsonObjectGet(discInfo, discipline);
if (chosenDisc != JsonNull())
{
int nManCount = JsonGetInt(JsonObjectGet(chosenDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
if (nManCount >= prereqs)
return TRUE;
}
return FALSE;
}
int GetMaxInitiatorCircle(int nClass, object oPC=OBJECT_SELF)
{
int initiatorLevel = GetInitiatorLevel(oPC, nClass);
// initiators learn by ceiling(classLevel)
int highestCircle = (initiatorLevel + 1) / 2;
if (highestCircle > 9)
return 9;
return highestCircle;
}
int GetRemainingManeuverChoices(int nClass, object oPC=OBJECT_SELF)
{
json discInfo = GetDisciplineInfoObject(nClass, oPC);
json jManAmount = JsonObjectGet(discInfo, NUI_LEVEL_UP_MANEUVER_TOTAL);
int nManAmount = 0;
if (jManAmount != JsonNull())
nManAmount = JsonGetInt(jManAmount);
int maxAmount = GetMaxManeuverCount(oPC, nClass, MANEUVER_TYPE_MANEUVER);
return maxAmount - nManAmount;
}
int GetRemainingStanceChoices(int nClass, object oPC=OBJECT_SELF)
{
json discInfo = GetDisciplineInfoObject(nClass, oPC);
json jStanceAmount = JsonObjectGet(discInfo, NUI_LEVEL_UP_STANCE_TOTAL);
int nStanceAmount = 0;
if (jStanceAmount != JsonNull())
nStanceAmount = JsonGetInt(jStanceAmount);
int maxAmount = GetMaxManeuverCount(oPC, nClass, MANEUVER_TYPE_STANCE);
return maxAmount - nStanceAmount;
}
int IsAllowedDiscipline(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
// logic carried over from private function in discipline inc functions
// uses bitwise matching to tell if the discipline is allowed or not
string sFile = GetClassSpellbookFile(nClass);
int discipline = StringToInt(Get2DACache(sFile, "Discipline", spellbookId));
int nOverride = GetPersistantLocalInt(oPC, "AllowedDisciplines");
if(nOverride == 0)
{
switch(nClass)
{
case CLASS_TYPE_CRUSADER: nOverride = 322; break;//DISCIPLINE_DEVOTED_SPIRIT + DISCIPLINE_STONE_DRAGON + DISCIPLINE_WHITE_RAVEN
case CLASS_TYPE_SWORDSAGE: nOverride = 245; break;//DISCIPLINE_DESERT_WIND + DISCIPLINE_DIAMOND_MIND + DISCIPLINE_SETTING_SUN + DISCIPLINE_SHADOW_HAND + DISCIPLINE_STONE_DRAGON + DISCIPLINE_TIGER_CLAW
case CLASS_TYPE_WARBLADE: nOverride = 460; break;//DISCIPLINE_DIAMOND_MIND + DISCIPLINE_IRON_HEART + DISCIPLINE_STONE_DRAGON + DISCIPLINE_TIGER_CLAW + DISCIPLINE_WHITE_RAVEN
}
}
return nOverride & discipline;
}
int IsRequiredForToBPRCClass(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
int currentClassPos = 1;
// loop through all the classes and look for a PRC
while (currentClassPos)
{
int currentClass = GetClassByPosition(currentClassPos, oPC);
// if we reached a non existant class, we reached the end.
if (currentClass != CLASS_TYPE_INVALID)
{
string sFile = GetClassSpellbookFile(nClass);
int discipline = StringToInt(Get2DACache(sFile, "Discipline", spellbookId));
// check if the class is a ToB PRC Class and if the current spell's
// discipline is used for it.
int isUsed = FALSE;
if (currentClass == CLASS_TYPE_DEEPSTONE_SENTINEL
&& (discipline == DISCIPLINE_STONE_DRAGON))
isUsed = TRUE;
if (currentClass == CLASS_TYPE_BLOODCLAW_MASTER
&& (discipline == DISCIPLINE_TIGER_CLAW))
isUsed = TRUE;
if (currentClass == CLASS_TYPE_RUBY_VINDICATOR
&& (discipline == DISCIPLINE_DEVOTED_SPIRIT))
isUsed = TRUE;
if (currentClass == CLASS_TYPE_JADE_PHOENIX_MAGE)
isUsed = TRUE;
if (currentClass == CLASS_TYPE_MASTER_OF_NINE)
isUsed = TRUE;
if (currentClass == CLASS_TYPE_ETERNAL_BLADE
&& (discipline == DISCIPLINE_DEVOTED_SPIRIT
|| discipline == DISCIPLINE_DIAMOND_MIND))
isUsed = TRUE;
if (currentClass == CLASS_TYPE_SHADOW_SUN_NINJA
&& (discipline == DISCIPLINE_SETTING_SUN
|| discipline == DISCIPLINE_SHADOW_HAND))
isUsed = TRUE;
// if any of the above was true than we need to check if this spell
// is required for a PRC
if (isUsed)
{
// get the discipline info for all BladeMagic classes if we have them.
json discInfo = GetDisciplineInfoObject(nClass, oPC);
json classDisc2Info = JsonObject();
json classDisc3Info = JsonObject();
if (nClass == CLASS_TYPE_SWORDSAGE)
{
if (GetLevelByClass(CLASS_TYPE_WARBLADE, oPC))
classDisc2Info = GetDisciplineInfoObject(CLASS_TYPE_WARBLADE, oPC);
if (GetLevelByClass(CLASS_TYPE_CRUSADER, oPC))
classDisc3Info = GetDisciplineInfoObject(CLASS_TYPE_CRUSADER, oPC);
}
if (nClass == CLASS_TYPE_CRUSADER)
{
if (GetLevelByClass(CLASS_TYPE_WARBLADE, oPC))
classDisc2Info = GetDisciplineInfoObject(CLASS_TYPE_WARBLADE, oPC);
if (GetLevelByClass(CLASS_TYPE_SWORDSAGE, oPC))
classDisc3Info = GetDisciplineInfoObject(CLASS_TYPE_SWORDSAGE, oPC);
}
if (nClass == CLASS_TYPE_WARBLADE)
{
if (GetLevelByClass(CLASS_TYPE_CRUSADER, oPC))
classDisc2Info = GetDisciplineInfoObject(CLASS_TYPE_CRUSADER, oPC);
if (GetLevelByClass(CLASS_TYPE_SWORDSAGE, oPC))
classDisc3Info = GetDisciplineInfoObject(CLASS_TYPE_SWORDSAGE, oPC);
}
// Time to begin checking the PRCs
// this should follow the same logic as here
// https://gitea.raptio.us/Jaysyn/PRC8/src/commit/797442d3da7c9c8e1fcf585b97e2ff1cbe56045b/nwn/nwnprc/trunk/scripts/prc_prereq.nss#L991
// Check Deepstone Sentinel
if (currentClass == CLASS_TYPE_DEEPSTONE_SENTINEL)
{
// we need to look for 2 Stone Dragon Maneuvers and 1 Stone Dragon
// Stance. So add up the other MagicBlade classes and see if it is satisfied.
int stoneDMan, stoneDStance = 0;
json currentDisc = JsonObjectGet(classDisc2Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
stoneDMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
stoneDStance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
if (stoneDMan >= 2 && stoneDStance >= 1)
return FALSE;
}
currentDisc = JsonObjectGet(classDisc3Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
stoneDMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
stoneDStance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
if (stoneDMan >= 2 && stoneDStance >= 1)
return FALSE;
}
// if it still isn't satisfied than the current class is required
// for it to exist. Check to see if it is safe to remove the maneuever
currentDisc = JsonObjectGet(discInfo, IntToString(discipline));
if (currentDisc != JsonNull())
{
stoneDMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
stoneDStance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
int type = StringToInt(Get2DACache(sFile, "Type", spellbookId));
//if the current maneuver is a stance, check to see if it is safe to remove
if (type == MANEUVER_TYPE_STANCE)
{
if (stoneDStance - 1 >= 1)
return FALSE;
}
else
{
// if it is not a stance we can just check the maneuevers in general
if (stoneDMan - 1 >= 2)
return FALSE;
}
// this maneuver is required and should not be removed.
return TRUE;
}
}
// Check Bloodclaw Master
if (currentClass == CLASS_TYPE_BLOODCLAW_MASTER)
{
// bloodclaw needs 3 Tiger Claw maneuevers
int tigerCMan = 0;
json currentDisc = JsonObjectGet(classDisc2Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
tigerCMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
tigerCMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
if (tigerCMan >= 3)
return FALSE;
}
currentDisc = JsonObjectGet(classDisc3Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
tigerCMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
tigerCMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
if (tigerCMan >= 3)
return FALSE;
}
currentDisc = JsonObjectGet(discInfo, IntToString(discipline));
if (currentDisc != JsonNull())
{
tigerCMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
tigerCMan += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
if (tigerCMan-1 >= 3)
return FALSE;
return TRUE;
}
}
if (currentClass == CLASS_TYPE_RUBY_VINDICATOR)
{
// Ruby Vindicator needs 1 stance and 1 maneuever from Devoted Spirit
int stance = 0;
int maneuver = 0;
json currentDisc = JsonObjectGet(classDisc2Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
stance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
maneuver += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
if (stance >= 1 && maneuver >= 1)
return FALSE;
}
currentDisc = JsonObjectGet(classDisc3Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
stance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
maneuver += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
if (stance >= 1 && maneuver >= 1)
return FALSE;
}
currentDisc = JsonObjectGet(discInfo, IntToString(discipline));
if (currentDisc != JsonNull())
{
stance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
maneuver += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
int type = StringToInt(Get2DACache(sFile, "Type", spellbookId));
if (type == MANEUVER_TYPE_STANCE)
{
if (stance - 1 >= 1)
return FALSE;
return TRUE;
}
if (maneuver - 1 >= 1)
return FALSE;
return TRUE;
}
}
if (currentClass == CLASS_TYPE_JADE_PHOENIX_MAGE)
{
// Jade Phoenix needs 1 stance and 2 maneuvers of any type
int stance = 0;
int maneuver = 0;
json currentDisc = JsonObjectGet(classDisc2Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
stance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
maneuver += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
if (stance >= 1 && maneuver >= 2)
return FALSE;
}
currentDisc = JsonObjectGet(classDisc3Info, IntToString(discipline));
if (currentDisc != JsonNull())
{
stance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
maneuver += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
if (stance >= 1 && maneuver >= 2)
return FALSE;
}
currentDisc = JsonObjectGet(discInfo, IntToString(discipline));
if (currentDisc != JsonNull())
{
stance += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
maneuver += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
int type = StringToInt(Get2DACache(sFile, "Type", spellbookId));
if (type == MANEUVER_TYPE_STANCE)
{
if ((stance - 1 >= 1) && (maneuver -1 >= 2))
return FALSE;
return TRUE;
}
if (maneuver - 1 >= 2)
return FALSE;
return TRUE;
}
}
if (currentClass == CLASS_TYPE_MASTER_OF_NINE)
{
// master of nine needs 1 maneuever from 6 different disciplines
int totalDiscCount = 0;
int currentClassAndDiscUsed = 0;
int i;
// loop through each possible discipline
for (i = 0; i <= 256; i++)
{
int found = 0;
// only disciplines that exist are stored, and only those
// that are used are stored, so we can loop through and
// find what disciplines we do or don't know.
json currentDisc = JsonObjectGet(classDisc2Info, IntToString(i));
if (currentDisc != JsonNull())
found = 1;
if (!found)
{
json currentDisc = JsonObjectGet(classDisc3Info, IntToString(i));
if (currentDisc != JsonNull())
found = 1;
}
if (!found)
{
json currentDisc = JsonObjectGet(discInfo, IntToString(i));
if (currentDisc != JsonNull())
{
if (i == discipline)
currentClassAndDiscUsed = 1;
found = 1;
}
}
totalDiscCount += found;
}
// if we have more maneuevers than 6, it is not required
if (totalDiscCount > 6)
return FALSE;
// however if we have 6 and this discipline was grabbed we need to make sure it is safe to remove
if (currentClassAndDiscUsed)
{
// if we were to remove this discipline and it is 5 or less total disciplines we have now
// it is important
if (totalDiscCount - 1 >= 6)
return FALSE;
json currentDisc = JsonObjectGet(discInfo, IntToString(discipline));
int stance = JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
int maneuver = JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
// if we were to remove this discipline and are left with no more than
// this was important and it can't be removed
if ((stance + maneuver - 1) >= 1)
return FALSE;
return TRUE;
}
return FALSE;
}
if (currentClass == CLASS_TYPE_ETERNAL_BLADE)
{
//Eternal blade 2 Devoted Spirits OR 2 Diamond Mind
int nTotal = 0;
json currentDisc = JsonObjectGet(classDisc2Info, IntToString(DISCIPLINE_DEVOTED_SPIRIT));
if (currentDisc != JsonNull())
{
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nTotal >= 2)
return FALSE;
}
currentDisc = JsonObjectGet(classDisc2Info, IntToString(DISCIPLINE_DIAMOND_MIND));
if (currentDisc != JsonNull())
{
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nTotal >= 2)
return FALSE;
}
currentDisc = JsonObjectGet(classDisc3Info, IntToString(DISCIPLINE_DEVOTED_SPIRIT));
if (currentDisc != JsonNull())
{
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nTotal >= 2)
return FALSE;
}
currentDisc = JsonObjectGet(classDisc3Info, IntToString(DISCIPLINE_DIAMOND_MIND));
if (currentDisc != JsonNull())
{
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nTotal >= 2)
return FALSE;
}
currentDisc = JsonObjectGet(discInfo, IntToString(discipline));
if (currentDisc != JsonNull())
{
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
nTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
if ((nTotal - 1) >= 2)
return FALSE;
return TRUE;
}
}
if (currentClass == CLASS_TYPE_SHADOW_SUN_NINJA)
{
// Shadow Sun Ninja needs 1 lvl2 Setting Sun OR Shadow Hand maneuever
// 1 Setting Sun maneuver AND 1 Shadow Hand maneuver
int nLvl2 = 0;
int shadowHTotal;
int settingSTotal;
json currentDisc = JsonObjectGet(classDisc2Info, IntToString(DISCIPLINE_SHADOW_HAND));
if (currentDisc != JsonNull())
{
shadowHTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
shadowHTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_STANCE)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nLvl2 && shadowHTotal && settingSTotal && (shadowHTotal >= 2 || settingSTotal >= 2))
return FALSE;
}
currentDisc = JsonObjectGet(classDisc2Info, IntToString(DISCIPLINE_SETTING_SUN));
if (currentDisc != JsonNull())
{
settingSTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
settingSTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_STANCE)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nLvl2 && shadowHTotal && settingSTotal && (shadowHTotal >= 2 || settingSTotal >= 2))
return FALSE;
}
currentDisc = JsonObjectGet(classDisc3Info, IntToString(DISCIPLINE_SHADOW_HAND));
if (currentDisc != JsonNull())
{
shadowHTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
shadowHTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_STANCE)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nLvl2 && shadowHTotal && settingSTotal && (shadowHTotal >= 2 || settingSTotal >= 2))
return FALSE;
}
currentDisc = JsonObjectGet(classDisc2Info, IntToString(DISCIPLINE_SETTING_SUN));
if (currentDisc != JsonNull())
{
settingSTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
settingSTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_STANCE)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_MANEUVER)));
// stances here count as a maneuver so we need to count 2
// to account for that
if (nLvl2 && shadowHTotal && settingSTotal && (shadowHTotal >= 2 || settingSTotal >= 2))
return FALSE;
}
currentDisc = JsonObjectGet(discInfo, IntToString(DISCIPLINE_SHADOW_HAND));
if (currentDisc != JsonNull())
{
shadowHTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
shadowHTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_STANCE)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_MANEUVER)));
}
currentDisc = JsonObjectGet(discInfo, IntToString(DISCIPLINE_SETTING_SUN));
if (currentDisc != JsonNull())
{
settingSTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_STANCE)));
settingSTotal += JsonGetInt(JsonObjectGet(currentDisc, IntToString(MANEUVER_TYPE_MANEUVER)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_STANCE)));
nLvl2 += JsonGetInt(JsonObjectGet(currentDisc, "Level2_" + IntToString(MANEUVER_TYPE_MANEUVER)));
}
int level = StringToInt(Get2DACache(sFile, "Level", spellbookId));
if (level == 2)
nLvl2 -= 1;
if (discipline == DISCIPLINE_SHADOW_HAND)
shadowHTotal -= 1;
else
settingSTotal -= 1;
return !(nLvl2 && shadowHTotal && settingSTotal && (shadowHTotal >= 2 || settingSTotal >= 2));
}
}
currentClassPos += 1;
}
else
currentClassPos = 0;
}
return FALSE;
}
json AddSpellDisciplineInfo(string sFile, int spellbookId, json classDisc)
{
json classDiscCopy = classDisc;
int discipline = StringToInt(Get2DACache(sFile, "Discipline", spellbookId));
int type = StringToInt(Get2DACache(sFile, "Type", spellbookId));
int level = StringToInt(Get2DACache(sFile, "Level", spellbookId));
int prereq = StringToInt(Get2DACache(sFile, "Prereqs", spellbookId));
json jDisc = JsonObjectGet(classDisc, IntToString(discipline));
if (jDisc == JsonNull())
jDisc = JsonObject();
string levelKey = "Level" + IntToString(level) + "_" + IntToString(type);
int nTypeTotal = (JsonGetInt(JsonObjectGet(jDisc, levelKey)) + 1);
jDisc = JsonObjectSet(jDisc, levelKey, JsonInt(nTypeTotal));
nTypeTotal = (JsonGetInt(JsonObjectGet(jDisc, IntToString(type))) + 1);
jDisc = JsonObjectSet(jDisc, IntToString(type), JsonInt(nTypeTotal));
if (type != MANEUVER_TYPE_MANEUVER
&& type != MANEUVER_TYPE_STANCE)
{
levelKey = "Level" + IntToString(level) + "_" + IntToString(MANEUVER_TYPE_MANEUVER);
nTypeTotal = (JsonGetInt(JsonObjectGet(jDisc, levelKey)) + 1);
jDisc = JsonObjectSet(jDisc, levelKey, JsonInt(nTypeTotal));
nTypeTotal = (JsonGetInt(JsonObjectGet(jDisc, IntToString(MANEUVER_TYPE_MANEUVER))) + 1);
jDisc = JsonObjectSet(jDisc, IntToString(MANEUVER_TYPE_MANEUVER), JsonInt(nTypeTotal));
}
string prereqKey = "Prereq_" + IntToString(prereq);
int nPrereqTotal = (JsonGetInt(JsonObjectGet(jDisc, prereqKey)) + 1);
jDisc = JsonObjectSet(jDisc, prereqKey, JsonInt(nPrereqTotal));
if (type == MANEUVER_TYPE_STANCE)
{
nTypeTotal = (JsonGetInt(JsonObjectGet(classDisc, NUI_LEVEL_UP_STANCE_TOTAL)) + 1);
classDiscCopy = JsonObjectSet(classDiscCopy, NUI_LEVEL_UP_STANCE_TOTAL, JsonInt(nTypeTotal));
}
else
{
nTypeTotal = (JsonGetInt(JsonObjectGet(classDisc, NUI_LEVEL_UP_MANEUVER_TOTAL)) + 1);
classDiscCopy = JsonObjectSet(classDiscCopy, NUI_LEVEL_UP_MANEUVER_TOTAL, JsonInt(nTypeTotal));
}
return JsonObjectSet(classDiscCopy, IntToString(discipline), jDisc);
}
////////////////////////////////////////////////////////////////////////////
/// ///
/// Invokers ///
/// ///
////////////////////////////////////////////////////////////////////////////
json GetInvokerKnownListObject(int nClass, object oPC=OBJECT_SELF)
{
json knownObject = GetLocalJson(oPC, NUI_LEVEL_UP_KNOWN_INVOCATIONS_CACHE_VAR + IntToString(nClass));
if (knownObject == JsonNull())
knownObject = JsonObject();
else
return knownObject;
string sFile = GetAMSKnownFileName(nClass);
int totalRows = Get2DARowCount(sFile);
int maxInvocLevel = StringToInt(Get2DACache(sFile, "MaxInvocationLevel", totalRows-1));
json previousInvocList = JsonObject();
int i;
for (i = 1; i <= maxInvocLevel; i++)
{
previousInvocList = JsonObjectSet(previousInvocList, IntToString(i), JsonInt(0));
}
for (i = 0; i < totalRows; i++)
{
int maxInvocation = StringToInt(Get2DACache(sFile, "MaxInvocationLevel", i));
int invocationKnown = StringToInt(Get2DACache(sFile, "InvocationKnown", i));
json invocList = previousInvocList;
int previousInvocTotal = 0;
if (i > 0)
previousInvocTotal = StringToInt(Get2DACache(sFile, "InvocationKnown", i-1));
int previousInvocAmount = JsonGetInt(JsonObjectGet(previousInvocList, IntToString(maxInvocation)));
int currentInvocationAmount = (invocationKnown - previousInvocTotal + previousInvocAmount);
invocList = JsonObjectSet(invocList, IntToString(maxInvocation), JsonInt(currentInvocationAmount));
knownObject = JsonObjectSet(knownObject, IntToString(i+1), invocList);
previousInvocList = invocList;
}
SetLocalJson(oPC, NUI_LEVEL_UP_KNOWN_INVOCATIONS_CACHE_VAR + IntToString(nClass), knownObject);
return knownObject;
}
int GetRemainingInvocationChoices(int nClass, int chosenCircle, object oPC=OBJECT_SELF, int extra=TRUE)
{
int remaining = 0;
int nLevel = GetInvokerLevel(oPC, nClass);
json knownObject = GetInvokerKnownListObject(nClass, oPC);
json chosenInv = GetChosenSpellListObject(nClass, oPC);
json currentLevelKnown = JsonObjectGet(knownObject, IntToString(nLevel));
int totalCircles = JsonGetLength(JsonObjectKeys(currentLevelKnown));
// logic goes we are given a set amount of invocations at each circle. We can
// take from a circle above us, but not below us. So we need to make sure
// we have a legal amount of choices
int i;
for (i = 1; i <= totalCircles; i++)
{
int currentChosen = 0;
json chosenSpells = JsonObjectGet(chosenInv, IntToString(i));
if (chosenSpells != JsonNull())
{
int totalChosen = JsonGetLength(chosenSpells);
int j;
for (j = 0; j < totalChosen; j++)
{
int spellbookId = JsonGetInt(JsonArrayGet(chosenSpells, j));
// only count non extra invocation choices
if (!IsExtraChoiceInvocation(nClass, spellbookId, oPC))
currentChosen += 1;
}
}
int allowedAtCircle = JsonGetInt(JsonObjectGet(currentLevelKnown, IntToString(i)));
remaining = (allowedAtCircle - currentChosen + remaining);
// if the circle is below the chosen circle and we have a positive remaining,
// we set it to 0 because we cannot use lower circle spells on higher circle.
// however if thge value is negative then we carry it over because we
// have a deficit and need to account for it by using the spells of the
// next circle.
if (i < chosenCircle && remaining > 0)
remaining = 0;
}
// count extra and epic invocation choices
if (extra)
{
string sFile = GetAMSKnownFileName(nClass);
int maxCircle = StringToInt(Get2DACache(sFile, "MaxInvocationLevel", nLevel-1));
if (GetHasFeat(FEAT_EXTRA_INVOCATION_I, oPC) && (chosenCircle <= (maxCircle-1)))
{
int totalExp = GetMaxInvocationCount(oPC, INVOCATION_LIST_EXTRA);
json expChoices = GetExpandedChoicesList(nClass, oPC);
int choicesCount = JsonGetLength(JsonObjectKeys(expChoices));
remaining += (totalExp - choicesCount);
}
if (GetHasFeat(FEAT_EPIC_EXTRA_INVOCATION_I, oPC))
{
int totalExp = GetMaxInvocationCount(oPC, INVOCATION_LIST_EXTRA_EPIC);
json expChoices = GetEpicExpandedChoicesList(nClass, oPC);
int choicesCount = JsonGetLength(JsonObjectKeys(expChoices));
remaining += (totalExp - choicesCount);
}
}
return remaining;
}
int IsExtraChoiceInvocation(int nClass, int spellbookId, object oPC=OBJECT_SELF)
{
string sFile = GetClassSpellbookFile(nClass);
string spellId = Get2DACache(sFile, "SpellID", spellbookId);
json extraChoices = GetExpandedChoicesList(nClass, oPC);
json chosenSpell = JsonObjectGet(extraChoices, spellId);
if (chosenSpell != JsonNull())
return TRUE;
extraChoices = GetEpicExpandedChoicesList(nClass, oPC);
chosenSpell = JsonObjectGet(extraChoices, spellId);
if (chosenSpell != JsonNull())
return TRUE;
return FALSE;
}
////////////////////////////////////////////////////////////////////////////
/// ///
/// Truenamer ///
/// ///
////////////////////////////////////////////////////////////////////////////
int GetRemainingTruenameChoices(int nClass, int nType, object oPC=OBJECT_SELF)
{
string sFile = GetClassSpellbookFile(nClass);
json chosenSpells = GetChosenSpellListObject(nClass, oPC);
json circles = JsonObjectKeys(chosenSpells);
int totalCircles = JsonGetLength(circles);
int remainingChoices = 0;
int i;
for (i = 0; i < totalCircles; i++)
{
json spellList = JsonObjectGet(chosenSpells, JsonGetString(JsonArrayGet(circles, i)));
if (spellList != JsonNull())
{
int totalChoices = JsonGetLength(spellList);
int j;
for (j = 0; j < totalChoices; j++)
{
int spellbookId = JsonGetInt(JsonArrayGet(spellList, j));
int lexicon = StringToInt(Get2DACache(sFile, "Lexicon", spellbookId));
// -1 means count all lexicons
if (nType == -1 || lexicon == nType)
remainingChoices += 1;
}
}
}
int maxChoices;
// if -1 we count all lexicons to get total remaining
if (nType == -1)
maxChoices = (GetMaxUtteranceCount(oPC, nClass, LEXICON_CRAFTED_TOOL)
+ GetMaxUtteranceCount(oPC, nClass, LEXICON_EVOLVING_MIND)
+ GetMaxUtteranceCount(oPC, nClass, LEXICON_PERFECTED_MAP));
else
maxChoices = GetMaxUtteranceCount(oPC, nClass, nType);
return (maxChoices - remainingChoices);
}
int GetLexiconCircleKnownAtLevel(int nLevel, int nType)
{
string sFile = "cls_true_maxlvl";
string columnName;
if (nType == LEXICON_EVOLVING_MIND)
columnName = "EvolvingMind";
else if (nType == LEXICON_CRAFTED_TOOL)
columnName = "CraftedTool";
else
columnName = "PerfectedMap";
return StringToInt(Get2DACache(sFile, columnName, nLevel-1));
}
////////////////////////////////////////////////////////////////////////////
/// ///
/// Archivist ///
/// ///
////////////////////////////////////////////////////////////////////////////
json GetArchivistNewSpellsList(object oPC=OBJECT_SELF)
{
json retValue = GetLocalJson(oPC, NUI_LEVEL_UP_ARCHIVIST_NEW_SPELLS_LIST_VAR);
if (retValue == JsonNull())
retValue = JsonArray();
else
return retValue;
SetLocalJson(oPC, NUI_LEVEL_UP_ARCHIVIST_NEW_SPELLS_LIST_VAR, retValue);
return retValue;
}
Reference in New Issue View Git Blame Copy Permalink