5914ed2ab5
Updated Release Archive. Fixed Mage-killer prereqs. Removed old LETO & ConvoCC related files. Added organized spell scroll store. Fixed Gloura spellbook. Various TLK fixes. Reorganized Repo. Removed invalid user folders. Added DocGen back in.
515 lines
23 KiB
Plaintext
515 lines
23 KiB
Plaintext
//:://////////////////////////////////////////////
|
|
//:: Invocation gain conversation script
|
|
//:: inv_invokeconv
|
|
//:://////////////////////////////////////////////
|
|
/** @file
|
|
This script controls the invocation selection
|
|
conversation.
|
|
|
|
|
|
@author Primogenitor - Orinigal
|
|
@author Ornedan - Modifications
|
|
@author Fox - ripped from Psionics convo
|
|
@date Modified - 2005.03.13
|
|
@date Modified - 2005.09.23
|
|
@date Modified - 2008.01.25
|
|
*/
|
|
//:://////////////////////////////////////////////
|
|
//:://////////////////////////////////////////////
|
|
|
|
#include "prc_inc_function"
|
|
#include "inv_inc_invfunc"
|
|
#include "inc_dynconv"
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Constant defintions */
|
|
//////////////////////////////////////////////////
|
|
|
|
const int STAGE_SELECT_LEVEL = 0;
|
|
const int STAGE_SELECT_INVOCATION = 1;
|
|
const int STAGE_CONFIRM_SELECTION = 2;
|
|
const int STAGE_ALL_INVOCATIONS_SELECTED = 3;
|
|
const int STAGE_UNLEARN_INVOCATION = 4;
|
|
const int STAGE_UNLEARN_CONFIRM = 5;
|
|
|
|
const int CHOICE_BACK_TO_LSELECT = -1;
|
|
|
|
const int STRREF_BACK_TO_LSELECT = 16832971; // "Return to power level selection."
|
|
const int STRREF_LEVELLIST_HEADER = 16832972; // "Select level of power to gain.\n\nNOTE:\nThis may take a while when first browsing a particular level's powers."
|
|
const int STRREF_POWERLIST_HEADER1 = 16832973; // "Select a power to gain.\nYou can select"
|
|
const int STRREF_POWERLIST_HEADER2 = 16832974; // "more powers"
|
|
const int STRREF_SELECTED_HEADER1 = 16824209; // "You have selected:"
|
|
const int STRREF_SELECTED_HEADER2 = 16824210; // "Is this correct?"
|
|
const int STRREF_END_HEADER = 16832975; // "You will be able to select more powers after you gain another level in a psionic caster class."
|
|
const int STRREF_END_CONVO_SELECT = 16824212; // "Finish"
|
|
const int LEVEL_STRREF_START = 16832979;
|
|
const int STRREF_YES = 4752; // "Yes"
|
|
const int STRREF_NO = 4753; // "No"
|
|
|
|
|
|
const int SORT = FALSE; // Sorting was causing TMIs
|
|
const int DEBUG_LIST = FALSE;
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Function defintions */
|
|
//////////////////////////////////////////////////
|
|
|
|
void PrintList(object oPC)
|
|
{
|
|
string tp = "Printing list:\n";
|
|
string s = GetLocalString(oPC, "PRC_InvConvo_List_Head");
|
|
if(s == ""){
|
|
tp += "Empty\n";
|
|
}
|
|
else{
|
|
tp += s + "\n";
|
|
s = GetLocalString(oPC, "PRC_InvConvo_List_Next_" + s);
|
|
while(s != ""){
|
|
tp += "=> " + s + "\n";
|
|
s = GetLocalString(oPC, "PRC_InvConvo_List_Next_" + s);
|
|
}
|
|
}
|
|
|
|
DoDebug(tp);
|
|
}
|
|
|
|
/**
|
|
* Creates a linked list of entries that is sorted into alphabetical order
|
|
* as it is built.
|
|
* Assumption: Power names are unique.
|
|
*
|
|
* @param oPC The storage object aka whomever is gaining powers in this conversation
|
|
* @param sChoice The choice string
|
|
* @param nChoice The choice value
|
|
*/
|
|
void AddToTempList(object oPC, string sChoice, int nChoice)
|
|
{
|
|
if(DEBUG_LIST) DoDebug("\nAdding to temp list: '" + sChoice + "' - " + IntToString(nChoice));
|
|
if(DEBUG_LIST) PrintList(oPC);
|
|
// If there is nothing yet
|
|
if(!GetLocalInt(oPC, "PRC_InvConvo_ListInited"))
|
|
{
|
|
SetLocalString(oPC, "PRC_InvConvo_List_Head", sChoice);
|
|
SetLocalInt(oPC, "PRC_InvConvo_List_" + sChoice, nChoice);
|
|
|
|
SetLocalInt(oPC, "PRC_InvConvo_ListInited", TRUE);
|
|
}
|
|
else
|
|
{
|
|
// Find the location to instert into
|
|
string sPrev = "", sNext = GetLocalString(oPC, "PRC_InvConvo_List_Head");
|
|
while(sNext != "" && StringCompare(sChoice, sNext) >= 0)
|
|
{
|
|
if(DEBUG_LIST) DoDebug("Comparison between '" + sChoice + "' and '" + sNext + "' = " + IntToString(StringCompare(sChoice, sNext)));
|
|
sPrev = sNext;
|
|
sNext = GetLocalString(oPC, "PRC_InvConvo_List_Next_" + sNext);
|
|
}
|
|
|
|
/* Insert the new entry */
|
|
// Does it replace the head?
|
|
if(sPrev == "")
|
|
{
|
|
if(DEBUG_LIST) DoDebug("New head");
|
|
SetLocalString(oPC, "PRC_InvConvo_List_Head", sChoice);
|
|
}
|
|
else
|
|
{
|
|
if(DEBUG_LIST) DoDebug("Inserting into position between '" + sPrev + "' and '" + sNext + "'");
|
|
SetLocalString(oPC, "PRC_InvConvo_List_Next_" + sPrev, sChoice);
|
|
}
|
|
|
|
SetLocalString(oPC, "PRC_InvConvo_List_Next_" + sChoice, sNext);
|
|
SetLocalInt(oPC, "PRC_InvConvo_List_" + sChoice, nChoice);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reads the linked list built with AddToTempList() to AddChoice() and
|
|
* deletes it.
|
|
*
|
|
* @param oPC A PC gaining powers at the moment
|
|
*/
|
|
void TransferTempList(object oPC)
|
|
{
|
|
string sChoice = GetLocalString(oPC, "PRC_InvConvo_List_Head");
|
|
int nChoice = GetLocalInt (oPC, "PRC_InvConvo_List_" + sChoice);
|
|
|
|
DeleteLocalString(oPC, "PRC_InvConvo_List_Head");
|
|
string sPrev;
|
|
|
|
if(DEBUG_LIST) DoDebug("Head is: '" + sChoice + "' - " + IntToString(nChoice));
|
|
|
|
while(sChoice != "")
|
|
{
|
|
// Add the choice
|
|
AddChoice(sChoice, nChoice, oPC);
|
|
|
|
// Get next
|
|
sChoice = GetLocalString(oPC, "PRC_InvConvo_List_Next_" + (sPrev = sChoice));
|
|
nChoice = GetLocalInt (oPC, "PRC_InvConvo_List_" + sChoice);
|
|
|
|
if(DEBUG_LIST) DoDebug("Next is: '" + sChoice + "' - " + IntToString(nChoice) + "; previous = '" + sPrev + "'");
|
|
|
|
// Delete the already handled data
|
|
DeleteLocalString(oPC, "PRC_InvConvo_List_Next_" + sPrev);
|
|
DeleteLocalInt (oPC, "PRC_InvConvo_List_" + sPrev);
|
|
}
|
|
|
|
DeleteLocalInt(oPC, "PRC_InvConvo_ListInited");
|
|
}
|
|
|
|
void ListInvocationsKnown(object oPC, int nClass, int nMax)
|
|
{
|
|
// Loop over levels
|
|
string sBase = _INVOCATION_LIST_NAME_BASE + IntToString(nClass) + _INVOCATION_LIST_LEVEL_ARRAY;
|
|
string sArray, sFile = GetAMSDefinitionFileName(nClass);
|
|
int nHD = GetHitDice(oPC);
|
|
int i, j, nSize, nSpellID, nInv, nTest;
|
|
for(i = 1; i <= nHD; i++)
|
|
{
|
|
sArray = sBase + IntToString(i);
|
|
if(persistant_array_exists(oPC, sArray))
|
|
{
|
|
nSize = persistant_array_get_size(oPC, sArray);
|
|
for(j = 0; j < nSize; j++)
|
|
{
|
|
nSpellID = persistant_array_get_int(oPC, sArray, j);
|
|
nTest = GetPowerfileIndexFromSpellID(nSpellID);
|
|
if(nMax >= StringToInt(Get2DACache(sFile, "Level", nTest)))
|
|
{
|
|
// For easy data retrival combine level and invocation id (can store up to 255 invocatinids)
|
|
nInv = ((i & 0x3F) << 8) | (nTest & 0xFF);
|
|
AddChoice(GetInvocationName(nSpellID), nInv, oPC);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ReplaceInvocation(object oPC, int nClass, int nInvocation, int nUnlernInv, string sFile)
|
|
{
|
|
DeleteLocalInt(oPC, "InvUnlearn");
|
|
string sUnlearn = Get2DACache(sFile, "SpellID", nUnlernInv);
|
|
string sLearn = Get2DACache(sFile, "SpellID", nInvocation);
|
|
int ipFeat = StringToInt(Get2DACache(sFile, "IPFeatID", nInvocation));
|
|
int nLevel = GetLocalInt(oPC, "InvUnlearnLvl");
|
|
string sArray = _INVOCATION_LIST_NAME_BASE + IntToString(nClass) + _INVOCATION_LIST_LEVEL_ARRAY + IntToString(nLevel);
|
|
int nSize = persistant_array_get_size(oPC, sArray);
|
|
int i;
|
|
for(i = 0; i < nSize; i++)
|
|
{
|
|
if(persistant_array_get_string(oPC, sArray, i) == sUnlearn)
|
|
{
|
|
// Mark invocation as known
|
|
persistant_array_set_string(oPC, sArray, i, sLearn);
|
|
// Increment Invocations known total
|
|
sArray = _INVOCATION_LIST_NAME_BASE + IntToString(nClass) + _INVOCATION_LIST_TOTAL_KNOWN;
|
|
SetPersistantLocalInt(oPC, sArray, GetPersistantLocalInt(oPC, sArray) + 1);
|
|
// Give the invocation's control feats
|
|
object oSkin = GetPCSkin(oPC);
|
|
itemproperty invFeat = PRCItemPropertyBonusFeat(ipFeat);
|
|
IPSafeAddItemProperty(oSkin, invFeat, 0.0f, X2_IP_ADDPROP_POLICY_KEEP_EXISTING, FALSE, FALSE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void main()
|
|
{
|
|
object oPC = GetPCSpeaker();
|
|
int nValue = GetLocalInt(oPC, DYNCONV_VARIABLE);
|
|
int nStage = GetStage(oPC);
|
|
|
|
int nClass = GetLocalInt(oPC, "nClass");
|
|
string sInvFile = GetAMSKnownFileName(nClass);
|
|
string sInvocationFile = GetAMSDefinitionFileName(nClass);
|
|
if(nClass == -2 || nClass == CLASS_TYPE_INVALID)
|
|
{
|
|
sInvFile = GetAMSKnownFileName(GetPrimaryInvocationClass(oPC));
|
|
sInvocationFile = GetAMSDefinitionFileName(GetPrimaryInvocationClass(oPC));
|
|
}
|
|
|
|
// Check which of the conversation scripts called the scripts
|
|
if(nValue == 0) // All of them set the DynConv_Var to non-zero value, so something is wrong -> abort
|
|
return;
|
|
|
|
if(nValue == DYNCONV_SETUP_STAGE)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Running setup stage for stage " + IntToString(nStage));
|
|
// Check if this stage is marked as already set up
|
|
// This stops list duplication when scrolling
|
|
if(!GetIsStageSetUp(nStage, oPC))
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Stage was not set up already");
|
|
// Level selection stage
|
|
if(nStage == STAGE_SELECT_LEVEL)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Building level selection");
|
|
SetHeader(GetStringByStrRef(STRREF_LEVELLIST_HEADER));
|
|
|
|
// Determine maximum power level
|
|
int nInvokeLevel = GetInvokerLevel(oPC, nClass);
|
|
int bUnlearn = !GetLocalInt(oPC, "InvUnlearnLvl");
|
|
int nMaxLevel;
|
|
if(GetLocalInt(oPC, "InvUnlearn"))
|
|
nMaxLevel = StringToInt(Get2DACache(sInvocationFile, "Level", GetLocalInt(oPC, "InvUnlearn")));
|
|
else if(nClass == -2 || nClass == CLASS_TYPE_INVALID)
|
|
{
|
|
bUnlearn = FALSE;
|
|
nInvokeLevel = GetInvokerLevel(oPC, GetPrimaryInvocationClass(oPC));
|
|
nMaxLevel = StringToInt(Get2DACache(sInvFile, "MaxInvocationLevel", nInvokeLevel - 1));
|
|
if(nClass == CLASS_TYPE_INVALID) nMaxLevel--;
|
|
}
|
|
else
|
|
nMaxLevel = StringToInt(Get2DACache(sInvFile, "MaxInvocationLevel", nInvokeLevel - 1));
|
|
|
|
// Set the tokens
|
|
int i;
|
|
for(i = 0; i < nMaxLevel; i++){
|
|
AddChoice(GetStringByStrRef(LEVEL_STRREF_START - i), // The minus is correct, these are stored in inverse order in the TLK. Whoops
|
|
i + 1
|
|
);
|
|
}
|
|
if(bUnlearn && nMaxLevel > 1) AddChoice(PRC_TEXT_GREEN+"[Replace]", -1, oPC);
|
|
|
|
// Set the next, previous and wait tokens to default values
|
|
SetDefaultTokens();
|
|
// Set the convo quit text to "Abort"
|
|
SetCustomToken(DYNCONV_TOKEN_EXIT, GetStringByStrRef(DYNCONV_STRREF_ABORT_CONVO));
|
|
}
|
|
// Power selection stage
|
|
if(nStage == STAGE_SELECT_INVOCATION)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Building invocation selection");
|
|
int nCurrentInvocations = GetInvocationCount(oPC, nClass);
|
|
int nMaxInvocations = GetMaxInvocationCount(oPC, nClass);
|
|
//quick bugcheck in case the convo gets started when not needed
|
|
if(nCurrentInvocations >= nMaxInvocations)
|
|
AllowExit(DYNCONV_EXIT_ALLOWED_SHOW_CHOICE, FALSE, oPC);
|
|
string sToken = GetStringByStrRef(STRREF_POWERLIST_HEADER1) + " " + //"Select a power to gain.\n You can select "
|
|
IntToString(nMaxInvocations-nCurrentInvocations) + " " +
|
|
GetStringByStrRef(STRREF_POWERLIST_HEADER2); //" more powers"
|
|
SetHeader(sToken);
|
|
|
|
// Set the first choice to be return to level selection stage
|
|
AddChoice(GetStringByStrRef(STRREF_BACK_TO_LSELECT), CHOICE_BACK_TO_LSELECT, oPC);
|
|
|
|
// Determine maximum power level
|
|
int nInvokeLevel = GetInvokerLevel(oPC, nClass);
|
|
int nMaxLevel = StringToInt(Get2DACache(sInvFile, "MaxInvocationLevel", nInvokeLevel-1));
|
|
if(nClass == -2 || nClass == CLASS_TYPE_INVALID)
|
|
{
|
|
nInvokeLevel = GetInvokerLevel(oPC, GetPrimaryInvocationClass(oPC));
|
|
if(nClass == CLASS_TYPE_INVALID) nMaxLevel--;
|
|
}
|
|
|
|
|
|
int nInvocationLevelToBrowse = GetLocalInt(oPC, "nInvocationLevelToBrowse");
|
|
int i, nInvocationLevel;
|
|
string sFeatID;
|
|
for(i = 0; i < GetPRCSwitch(FILE_END_CLASS_POWER) ; i++)
|
|
{
|
|
nInvocationLevel = StringToInt(Get2DACache(sInvocationFile, "Level", i));
|
|
// Skip any powers of too low level
|
|
if(nInvocationLevel < nInvocationLevelToBrowse){
|
|
continue;
|
|
}
|
|
/* Due to the way the power list 2das are structured, we know that once
|
|
* the level of a read power is greater than the maximum manifestable
|
|
* it'll never be lower again. Therefore, we can skip reading the
|
|
* powers that wouldn't be shown anyway.
|
|
*/
|
|
if(nInvocationLevel > nInvocationLevelToBrowse){
|
|
break;
|
|
}
|
|
sFeatID = Get2DACache(sInvocationFile, "FeatID", i);
|
|
if(sFeatID != "" // Non-blank row
|
|
&& !GetHasFeat(StringToInt(sFeatID), oPC) // PC does not already posses the power
|
|
)
|
|
{
|
|
if(SORT) AddToTempList(oPC, GetStringByStrRef(StringToInt(Get2DACache("feat", "FEAT", StringToInt(sFeatID)))), i);
|
|
else AddChoice(GetStringByStrRef(StringToInt(Get2DACache("feat", "FEAT", StringToInt(sFeatID)))), i, oPC);
|
|
}
|
|
}
|
|
|
|
if(SORT) TransferTempList(oPC);
|
|
|
|
/* Hack - In the power selection stage, on returning from
|
|
* confirmation dialog where the answer was "No", restore the
|
|
* offset to be the same as on entering the confirmation dialog.
|
|
*/
|
|
if(GetLocalInt(oPC, "InvocationListChoiceOffset"))
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Running offset restoration hack");
|
|
SetLocalInt(oPC, DYNCONV_CHOICEOFFSET, GetLocalInt(oPC, "InvocationListChoiceOffset") - 1);
|
|
DeleteLocalInt(oPC, "InvocationListChoiceOffset");
|
|
}
|
|
|
|
MarkStageSetUp(STAGE_SELECT_INVOCATION, oPC);
|
|
}
|
|
// Selection confirmation stage
|
|
else if(nStage == STAGE_CONFIRM_SELECTION)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Building selection confirmation");
|
|
// Build the confirmantion query
|
|
string sToken = GetStringByStrRef(STRREF_SELECTED_HEADER1) + "\n\n"; // "You have selected:"
|
|
int nInvocation = GetLocalInt(oPC, "nInvocation");
|
|
int nFeatID = StringToInt(Get2DACache(sInvocationFile, "FeatID", nInvocation));
|
|
sToken += GetStringByStrRef(StringToInt(Get2DACache("feat", "FEAT", nFeatID)))+"\n";
|
|
sToken += GetStringByStrRef(StringToInt(Get2DACache("feat", "DESCRIPTION", nFeatID)))+"\n\n";
|
|
sToken += GetStringByStrRef(STRREF_SELECTED_HEADER2); // "Is this correct?"
|
|
SetHeader(sToken);
|
|
|
|
AddChoice(GetStringByStrRef(STRREF_YES), TRUE, oPC); // "Yes"
|
|
AddChoice(GetStringByStrRef(STRREF_NO), FALSE, oPC); // "No"
|
|
}
|
|
else if(nStage == STAGE_UNLEARN_INVOCATION)
|
|
{
|
|
// Determine maximum power level
|
|
int nInvokeLevel = GetInvokerLevel(oPC, nClass);
|
|
int nMaxLevel = StringToInt(Get2DACache(sInvFile, "MaxInvocationLevel", nInvokeLevel-1));
|
|
|
|
SetHeader("Select invocation to replace");
|
|
ListInvocationsKnown(oPC, nClass, nMaxLevel);
|
|
MarkStageSetUp(STAGE_UNLEARN_INVOCATION, oPC);
|
|
}
|
|
else if(nStage == STAGE_UNLEARN_CONFIRM)
|
|
{
|
|
// Build the confirmantion query
|
|
string sToken = GetStringByStrRef(STRREF_SELECTED_HEADER1) + "\n\n"; // "You have selected:"
|
|
int nInvocation = GetLocalInt(oPC, "InvUnlearn");
|
|
int nFeatID = StringToInt(Get2DACache(sInvocationFile, "FeatID", nInvocation));
|
|
sToken += GetStringByStrRef(StringToInt(Get2DACache("feat", "FEAT", nFeatID)))+"\n";
|
|
sToken += GetStringByStrRef(StringToInt(Get2DACache("feat", "DESCRIPTION", nFeatID)))+"\n\n";
|
|
sToken += GetStringByStrRef(STRREF_SELECTED_HEADER2); // "Is this correct?"
|
|
SetHeader(sToken);
|
|
|
|
AddChoice(GetStringByStrRef(STRREF_YES), TRUE, oPC); // "Yes"
|
|
AddChoice(GetStringByStrRef(STRREF_NO), FALSE, oPC); // "No"
|
|
}
|
|
// Conversation finished stage
|
|
else if(nStage == STAGE_ALL_INVOCATIONS_SELECTED)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Building finish note");
|
|
SetHeader(GetStringByStrRef(STRREF_END_HEADER));
|
|
// Set the convo quit text to "Finish"
|
|
SetCustomToken(DYNCONV_TOKEN_EXIT, GetStringByStrRef(STRREF_END_CONVO_SELECT));
|
|
AllowExit(DYNCONV_EXIT_ALLOWED_SHOW_CHOICE, FALSE, oPC);
|
|
}
|
|
}
|
|
|
|
// Do token setup
|
|
SetupTokens();
|
|
}
|
|
else if(nValue == DYNCONV_EXITED)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Running exit handler");
|
|
// End of conversation cleanup
|
|
DeleteLocalInt(oPC, "nClass");
|
|
DeleteLocalInt(oPC, "nInvocation");
|
|
DeleteLocalInt(oPC, "nInvocationLevelToBrowse");
|
|
DeleteLocalInt(oPC, "InvocationListChoiceOffset");
|
|
DeleteLocalInt(oPC, "InvUnlearn");
|
|
DeleteLocalInt(oPC, "InvUnlearnLvl");
|
|
|
|
// Restart the convo to pick next power if needed
|
|
// done via EvalPRCFFeats to avoid convlicts with new spellbooks
|
|
//ExecuteScript("psi_powergain", oPC);
|
|
DelayCommand(1.0, EvalPRCFeats(oPC));
|
|
}
|
|
else if(nValue == DYNCONV_ABORTED)
|
|
{
|
|
// This section should never be run, since aborting this conversation should
|
|
// always be forbidden and as such, any attempts to abort the conversation
|
|
// should be handled transparently by the system
|
|
if(DEBUG) DoDebug("inv_invokeconv: ERROR: Conversation abort section run");
|
|
}
|
|
// Handle PC response
|
|
else
|
|
{
|
|
int nChoice = GetChoice(oPC);
|
|
if(DEBUG) DoDebug("inv_invokeconv: Handling PC response, stage = " + IntToString(nStage) + "; nChoice = " + IntToString(nChoice) + "; choice text = '" + GetChoiceText(oPC) + "'");
|
|
if(nStage == STAGE_SELECT_LEVEL)
|
|
{
|
|
if(nChoice == -1)
|
|
nStage = STAGE_UNLEARN_INVOCATION;
|
|
else
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Level selected");
|
|
SetLocalInt(oPC, "nInvocationLevelToBrowse", nChoice);
|
|
nStage = STAGE_SELECT_INVOCATION;
|
|
}
|
|
}
|
|
else if(nStage == STAGE_SELECT_INVOCATION)
|
|
{
|
|
if(nChoice == CHOICE_BACK_TO_LSELECT)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Returning to level selection");
|
|
nStage = STAGE_SELECT_LEVEL;
|
|
DeleteLocalInt(oPC, "nInvocationLevelToBrowse");
|
|
}
|
|
else
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Entering invocation confirmation");
|
|
SetLocalInt(oPC, "nInvocation", nChoice);
|
|
// Store offset so that if the user decides not to take the power,
|
|
// we can return to the same page in the power list instead of resetting to the beginning
|
|
// Store the value +1 in order to be able to differentiate between offset 0 and undefined
|
|
SetLocalInt(oPC, "InvocationListChoiceOffset", GetLocalInt(oPC, DYNCONV_CHOICEOFFSET) + 1);
|
|
nStage = STAGE_CONFIRM_SELECTION;
|
|
}
|
|
MarkStageNotSetUp(STAGE_SELECT_INVOCATION, oPC);
|
|
}
|
|
else if(nStage == STAGE_CONFIRM_SELECTION)
|
|
{
|
|
if(DEBUG) DoDebug("inv_invokeconv: Handling invocation confirmation");
|
|
if(nChoice == TRUE)
|
|
{
|
|
int nInvocation = GetLocalInt(oPC, "nInvocation");
|
|
int nUnlernInv = GetLocalInt(oPC, "InvUnlearn");
|
|
if(DEBUG) DoDebug("inv_invokeconv: Adding invocation: " + IntToString(nInvocation));
|
|
if(nUnlernInv)
|
|
ReplaceInvocation(oPC, nClass, nInvocation, nUnlernInv, sInvocationFile);
|
|
else
|
|
AddInvocationKnown(oPC, nClass, nInvocation, TRUE, GetHitDice(oPC));
|
|
|
|
// Delete the stored offset
|
|
DeleteLocalInt(oPC, "InvocationListChoiceOffset");
|
|
}
|
|
|
|
int nCurrentInvocations = GetInvocationCount(oPC, nClass);
|
|
int nMaxInvocations = GetMaxInvocationCount(oPC, nClass);
|
|
if(nCurrentInvocations >= nMaxInvocations)
|
|
nStage = STAGE_ALL_INVOCATIONS_SELECTED;
|
|
else
|
|
nStage = STAGE_SELECT_INVOCATION;
|
|
}
|
|
else if(nStage == STAGE_UNLEARN_INVOCATION)
|
|
{
|
|
SetLocalInt(oPC, "InvUnlearn", (nChoice & 0xFF));
|
|
SetLocalInt(oPC, "InvUnlearnLvl", ((nChoice >>> 8) & 0x3F));
|
|
nStage = STAGE_UNLEARN_CONFIRM;
|
|
MarkStageNotSetUp(STAGE_UNLEARN_INVOCATION, oPC);
|
|
}
|
|
else if(STAGE_UNLEARN_CONFIRM)
|
|
{
|
|
if(nChoice == TRUE)
|
|
{
|
|
// Decrement Invocations known total
|
|
string sArray = _INVOCATION_LIST_NAME_BASE + IntToString(nClass) + _INVOCATION_LIST_TOTAL_KNOWN;
|
|
SetPersistantLocalInt(oPC, sArray, GetPersistantLocalInt(oPC, sArray) - 1);
|
|
// Remove invocation feat
|
|
int nInvocation = GetLocalInt(oPC, "InvUnlearn");
|
|
int ipFeat = StringToInt(Get2DACache(sInvocationFile, "IPFeatID", nInvocation));
|
|
RemoveSpecificProperty(GetPCSkin(oPC), ITEM_PROPERTY_BONUS_FEAT, ipFeat);
|
|
}
|
|
nStage = STAGE_SELECT_LEVEL;
|
|
}
|
|
|
|
if(DEBUG) DoDebug("inv_invokeconv: New stage: " + IntToString(nStage));
|
|
|
|
// Store the stage value. If it has been changed, this clears out the choices
|
|
SetStage(nStage, oPC);
|
|
}
|
|
}
|