4fb9f2783b
Disabled Hidden Talent until it's actually finished. Fixed a few typos & some formatting.
586 lines
25 KiB
Plaintext
586 lines
25 KiB
Plaintext
//::///////////////////////////////////////////////
|
|
//:: PRC Bonus Domains
|
|
//:: prc_inc_domain.nss
|
|
//:://////////////////////////////////////////////
|
|
//:: Handles all of the code for bonus domains.
|
|
//:://////////////////////////////////////////////
|
|
//:: Created By: Stratovarius.
|
|
//:: Created On: August 31st, 2005
|
|
//:://////////////////////////////////////////////
|
|
|
|
//:: Updated for .35 by Jaysyn 2023/03/10
|
|
|
|
|
|
// Function returns the domain in the input slot.
|
|
// A person can have a maximum of 5 bonus domains.
|
|
int GetBonusDomain(object oPC, int nSlot);
|
|
|
|
// Function will add a bonus domain to the stored list on the character.
|
|
void AddBonusDomain(object oPC, int nDomain);
|
|
|
|
// Uses the slot and level to find the appropriate spell, then casts it using ActionCastSpell
|
|
// It will also decrement a spell from that level
|
|
// If the domain does not have an appropriate spell for that level, an error message appears and nothing happens
|
|
void CastDomainSpell(object oPC, int nSlot, int nLevel);
|
|
|
|
// Takes the domain and spell level and uses it to find the appropriate spell.
|
|
// Right now it uses 2da reads on the domains.2da, although it could be scripted if desired.
|
|
int GetDomainSpell(int nDomain, int nLevel, object oPC);
|
|
|
|
// Takes the spell level, and returns the radial feat for that level.
|
|
// Used in case there is no spell of the appropriate level.
|
|
int SpellLevelToFeat(int nLevel);
|
|
|
|
// Will return the domain name as a string
|
|
// This is used to tell a PC what domains he has in what slot
|
|
string GetDomainName(int nDomain);
|
|
|
|
// This is the starter function, and fires from Enter and Levelup
|
|
// It checks all of the bonus domain feats, and gives the PC the correct domains
|
|
void CheckBonusDomains(object oPC);
|
|
|
|
// Returns the spell to be burned for CastDomainSpell
|
|
int GetBurnableSpell(object oPC, int nLevel);
|
|
|
|
// Returns the Domain Power feat
|
|
int GetDomainFeat(int nDomain);
|
|
|
|
// Returns the Uses per day of the feat entered
|
|
int GetDomainFeatUsesPerDay(int nFeat, object oPC);
|
|
|
|
// This counts down the number of times a domain has been used in a day
|
|
// Returns TRUE if the domain use is valid
|
|
// Returns FALSE if the player is out of uses per day
|
|
int DecrementDomainUses(int nDomain, object oPC);
|
|
|
|
// Used to determine which domain has cast the Turn Undead spell
|
|
// Returns the domain constant
|
|
int GetTurningDomain(int nSpell);
|
|
|
|
// Checks to see if the player has a domain.
|
|
// Looks for the domain power constants since every domain has those
|
|
int GetHasDomain(object oPC, int nDomain);
|
|
|
|
// Cleans the ints that limit the domain spells to being cast 1/day
|
|
void BonusDomainRest(object oPC);
|
|
|
|
//#include "prc_inc_clsfunc"
|
|
#include "prc_alterations"
|
|
#include "prc_getbest_inc"
|
|
#include "inc_dynconv"
|
|
|
|
int GetBonusDomain(object oPC, int nSlot)
|
|
{
|
|
/*string sName = "PRCBonusDomain" + IntToString(nSlot);
|
|
// Return value in case there is nothing in the slot
|
|
int nDomain = 0;
|
|
nDomain = GetPersistantLocalInt(oPC, sName);*/
|
|
|
|
return GetPersistantLocalInt(oPC, "PRCBonusDomain" + IntToString(nSlot));
|
|
}
|
|
|
|
void AddBonusDomain(object oPC, int nDomain)
|
|
{
|
|
//if(DEBUG) DoDebug("AddBonusDomain is running.");
|
|
|
|
// Loop through the domain slots to see if there is an open one.
|
|
int nSlot = 1;
|
|
int nTest = GetBonusDomain(oPC, nSlot);
|
|
while(nTest > 0 && 5 >= nSlot)
|
|
{
|
|
nSlot += 1;
|
|
// If the test domain and the domain to be added are the same
|
|
// shut down the function, since you don't want to add a domain twice.
|
|
if(nTest == nDomain)
|
|
{
|
|
//FloatingTextStringOnCreature("You already have this domain as a bonus domain.", oPC, FALSE);
|
|
return;
|
|
}
|
|
nTest = GetBonusDomain(oPC, nSlot);
|
|
}
|
|
// If you run out of slots, display message and end function
|
|
if (nSlot > 5)
|
|
{
|
|
FloatingTextStringOnCreature("You have more than 5 bonus domains, your last domain is lost.", oPC, FALSE);
|
|
return;
|
|
}
|
|
|
|
// If we're here, we know we have an open slot, so we add the domain into it.
|
|
string sName = "PRCBonusDomain" + IntToString(nSlot);
|
|
SetPersistantLocalInt(oPC, sName, nDomain);
|
|
FloatingTextStringOnCreature("You have " + GetStringByStrRef(StringToInt(Get2DACache("prc_domains", "Name", nDomain - 1))) + " as a bonus domain", oPC, FALSE);
|
|
}
|
|
|
|
int TestSpellTarget(object oPC, object oTarget, int nSpell)
|
|
{
|
|
int nTargetType = ~(HexToInt(Get2DACache("spells", "TargetType", nSpell)));
|
|
|
|
if(oTarget == oPC && nTargetType & 1)
|
|
{
|
|
SendMessageToPC(oPC, "You cannot target yourself!");
|
|
return FALSE;
|
|
}
|
|
else if(GetIsObjectValid(oTarget))
|
|
{
|
|
int nObjectType = GetObjectType(oTarget);
|
|
if(nObjectType == OBJECT_TYPE_CREATURE && nTargetType & 2)
|
|
{
|
|
SendMessageToPC(oPC, "You cannot target creatures");
|
|
return FALSE;
|
|
}
|
|
else if(nObjectType == OBJECT_TYPE_ITEM && nTargetType & 8)
|
|
{
|
|
SendMessageToPC(oPC, "You cannot target items");
|
|
return FALSE;
|
|
}
|
|
else if(nObjectType == OBJECT_TYPE_DOOR && nTargetType & 16)
|
|
{
|
|
SendMessageToPC(oPC, "You cannot target doors");
|
|
return FALSE;
|
|
}
|
|
else if(nObjectType == OBJECT_TYPE_PLACEABLE && nTargetType & 32)
|
|
{
|
|
SendMessageToPC(oPC, "You cannot target placeables");
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if(nTargetType & 4)
|
|
{
|
|
SendMessageToPC(oPC, "You cannot target locations");
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
// Classes using new spellbook systems are handeled separately
|
|
int GetIsBioDivineClass(int nClass)
|
|
{
|
|
return nClass == CLASS_TYPE_CLERIC
|
|
|| nClass == CLASS_TYPE_DRUID
|
|
|| nClass == CLASS_TYPE_PALADIN
|
|
|| nClass == CLASS_TYPE_SHAMAN
|
|
|| nClass == CLASS_TYPE_UR_PRIEST
|
|
|| nClass == CLASS_TYPE_RANGER;
|
|
}
|
|
|
|
void CastDomainSpell(object oPC, int nSlot, int nLevel)
|
|
{
|
|
if(GetLocalInt(oPC, "DomainCastSpell" + IntToString(nLevel))) //Already cast a spell of this level?
|
|
{
|
|
FloatingTextStringOnCreature("You have already cast your domain spell for level " + IntToString(nLevel), oPC, FALSE);
|
|
return;
|
|
}
|
|
|
|
int nSpell = GetDomainSpell(GetBonusDomain(oPC, nSlot), nLevel, oPC);
|
|
// If there is no spell for that level, you cant cast it.
|
|
if(nSpell == -1)
|
|
return;
|
|
|
|
// Subradial spells are handled through conversation
|
|
int bSubRadial = Get2DACache("spells", "SubRadSpell1", nSpell) != "";
|
|
|
|
// Domain casting feats use generic targeting, so check if spell can be cast at selected target
|
|
object oTarget = GetSpellTargetObject();
|
|
if(!bSubRadial && !TestSpellTarget(oPC, oTarget, nSpell))
|
|
return;
|
|
|
|
int nClass, nCount, nMetamagic = METAMAGIC_NONE;
|
|
|
|
// Mystic is a special case - checked first
|
|
if(GetLevelByClass(CLASS_TYPE_MYSTIC, oPC) || GetLevelByClass(CLASS_TYPE_NIGHTSTALKER, oPC))
|
|
{
|
|
// Mystics can use metamagic with domain spells
|
|
nClass = GetLevelByClass(CLASS_TYPE_MYSTIC, oPC) ? CLASS_TYPE_MYSTIC : CLASS_TYPE_NIGHTSTALKER;
|
|
nMetamagic = GetLocalInt(oPC, "MetamagicFeatAdjust");
|
|
int nSpellLevel = nLevel;
|
|
if(nMetamagic)
|
|
{
|
|
//Need to check if metamagic can be applied to a spell
|
|
int nMetaTest;
|
|
int nMetaType = HexToInt(Get2DACache("spells", "MetaMagic", nSpell));
|
|
|
|
switch(nMetamagic)
|
|
{
|
|
case METAMAGIC_NONE: nMetaTest = 1; break; //no need to change anything
|
|
case METAMAGIC_EMPOWER: nMetaTest = nMetaType & 1; nSpellLevel += 2; break;
|
|
case METAMAGIC_EXTEND: nMetaTest = nMetaType & 2; nSpellLevel += 1; break;
|
|
case METAMAGIC_MAXIMIZE: nMetaTest = nMetaType & 4; nSpellLevel += 3; break;
|
|
case METAMAGIC_QUICKEN: nMetaTest = nMetaType & 8; nSpellLevel += 4; break;
|
|
case METAMAGIC_SILENT: nMetaTest = nMetaType & 16; nSpellLevel += 1; break;
|
|
case METAMAGIC_STILL: nMetaTest = nMetaType & 32; nSpellLevel += 1; break;
|
|
}
|
|
if(!nMetaTest)//can't use selected metamagic with this spell
|
|
{
|
|
nMetamagic = METAMAGIC_NONE;
|
|
ActionDoCommand(SendMessageToPC(oPC, "You can't use "+GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nSpell)))+"with selected metamagic."));
|
|
nSpellLevel = nLevel;
|
|
}
|
|
else if(nLevel > 9)//now test the spell level
|
|
{
|
|
nMetamagic = METAMAGIC_NONE;
|
|
ActionDoCommand(SendMessageToPC(oPC, "Modified spell level is to high! Casting spell without metamagic"));
|
|
nSpellLevel = nLevel;
|
|
}
|
|
else if(GetLocalInt(oPC, "PRC_metamagic_state") == 1)
|
|
SetLocalInt(oPC, "MetamagicFeatAdjust", 0);
|
|
}
|
|
|
|
nCount = persistant_array_get_int(oPC, "NewSpellbookMem_" + IntToString(CLASS_TYPE_MYSTIC), nSpellLevel);
|
|
// we can't cast metamagiced version of the spell - assuming that player want to cast the spell anyway
|
|
if(!nCount)
|
|
nCount = persistant_array_get_int(oPC, "NewSpellbookMem_" + IntToString(CLASS_TYPE_MYSTIC), nLevel);
|
|
// Do we have slots available?
|
|
if(nCount)
|
|
{
|
|
// Prepare to cast the spell
|
|
nLevel = nSpellLevel;//correct the spell level if we're using metamagic
|
|
SetLocalInt(oPC, "NSB_Class", nClass);
|
|
SetLocalInt(oPC, "NSB_SpellLevel", nLevel);
|
|
}
|
|
}
|
|
|
|
// checking 'newspellbook' classes is much faster than checking bioware spellbooks
|
|
if(!nCount)
|
|
{
|
|
int n;
|
|
for(n = 1; n < 9; n++)
|
|
{
|
|
nClass = GetClassByPosition(n, oPC);
|
|
|
|
// Check to see if you can burn a spell of that slot or if the person has already
|
|
// cast all of their level X spells for the day
|
|
if(!GetIsBioDivineClass(nClass))
|
|
{
|
|
int nSpellbook = GetSpellbookTypeForClass(nClass);
|
|
if(nSpellbook == SPELLBOOK_TYPE_SPONTANEOUS)
|
|
{
|
|
nCount = persistant_array_get_int(oPC, "NewSpellbookMem_" + IntToString(nClass), nLevel);
|
|
if(nCount)
|
|
{// Prepare to cast the spell
|
|
SetLocalInt(oPC, "NSB_Class", nClass);
|
|
SetLocalInt(oPC, "NSB_SpellLevel", nLevel);
|
|
}
|
|
}
|
|
else if(nSpellbook == SPELLBOOK_TYPE_PREPARED)
|
|
{
|
|
string sArray = "NewSpellbookMem_"+IntToString(nClass);
|
|
string sIDX = "SpellbookIDX" + IntToString(nLevel) + "_" + IntToString(nClass);
|
|
int i, nSpellbookID, nMax = persistant_array_get_size(oPC, sIDX);
|
|
for(i = 0; i < nMax; i++)
|
|
{
|
|
nSpellbookID = persistant_array_get_int(oPC, sIDX, i);
|
|
nCount = persistant_array_get_int(oPC, sArray, nSpellbookID);
|
|
if(nCount)
|
|
{
|
|
SetLocalInt(oPC, "NSB_Class", nClass);
|
|
SetLocalInt(oPC, "NSB_SpellbookID", nSpellbookID);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(nCount)
|
|
//we have found valid spell slot, no point in running this loop again
|
|
break;
|
|
}
|
|
}
|
|
|
|
// test bioware spellbooks
|
|
if(!nCount)
|
|
{
|
|
nCount = GetBurnableSpell(oPC, nLevel) + 1;//fix for Acid Fog spell
|
|
if(nCount)
|
|
{
|
|
SetLocalInt(oPC, "Domain_BurnableSpell", nCount);
|
|
nClass = GetPrimaryDivineClass(oPC);
|
|
}
|
|
}
|
|
|
|
//No spell left to burn? Tell the player that.
|
|
if(!nCount)
|
|
{
|
|
FloatingTextStringOnCreature("You have no spells left to trade for a domain spell.", oPC, FALSE);
|
|
return;
|
|
}
|
|
|
|
SetLocalInt(oPC, "DomainCast", nLevel);
|
|
if(bSubRadial)
|
|
{
|
|
SetLocalInt(oPC, "DomainOrigSpell", nSpell);
|
|
SetLocalInt(oPC, "DomainCastClass", nClass);
|
|
SetLocalObject(oPC, "DomainTarget", oTarget);
|
|
SetLocalLocation(oPC, "DomainTarget", GetSpellTargetLocation());
|
|
StartDynamicConversation("prc_domain_conv", oPC, DYNCONV_EXIT_NOT_ALLOWED, FALSE, TRUE, oPC);
|
|
}
|
|
else
|
|
{
|
|
if(nMetamagic & METAMAGIC_QUICKEN)
|
|
{
|
|
//Adding Auto-Quicken III for one round - deleted after casting is finished.
|
|
object oSkin = GetPCSkin(oPC);
|
|
int nCastDur = StringToInt(Get2DACache("spells", "ConjTime", nSpell)) + StringToInt(Get2DACache("spells", "CastTime", nSpell));
|
|
itemproperty ipAutoQuicken = ItemPropertyBonusFeat(IP_CONST_NSB_AUTO_QUICKEN);
|
|
ActionDoCommand(AddItemProperty(DURATION_TYPE_TEMPORARY, ipAutoQuicken, oSkin, nCastDur/1000.0f));
|
|
}
|
|
int nDC = 10 + nLevel + GetDCAbilityModForClass(nClass, oPC);
|
|
ActionCastSpell(nSpell, 0, nDC, 0, nMetamagic, nClass, FALSE, FALSE, OBJECT_INVALID, FALSE);
|
|
ActionDoCommand(DeleteLocalInt(oPC, "DomainCast"));
|
|
}
|
|
}
|
|
|
|
int GetDomainSpell(int nDomain, int nLevel, object oPC)
|
|
{
|
|
// The -1 on nDomains is to adjust from a base 1 to a base 0 system.
|
|
string sSpell = Get2DACache("prc_domains", "Level_" + IntToString(nLevel), (nDomain - 1));
|
|
if (DEBUG) DoDebug("Domain Spell: " + sSpell);
|
|
//if (DEBUG) DoDebug("GetDomainSpell has fired");
|
|
int nSpell = -1;
|
|
if(sSpell == "")
|
|
{
|
|
FloatingTextStringOnCreature("You do not have a domain spell of that level.", oPC, FALSE);
|
|
//int nFeat = SpellLevelToFeat(nLevel);
|
|
//IncrementRemainingFeatUses(oPC, nFeat);
|
|
}
|
|
else
|
|
{
|
|
nSpell = StringToInt(sSpell);
|
|
}
|
|
|
|
return nSpell;
|
|
}
|
|
|
|
int SpellLevelToFeat(int nLevel)
|
|
{
|
|
switch(nLevel)
|
|
{
|
|
case 1: return FEAT_CAST_DOMAIN_LEVEL_ONE;
|
|
case 2: return FEAT_CAST_DOMAIN_LEVEL_TWO;
|
|
case 3: return FEAT_CAST_DOMAIN_LEVEL_THREE;
|
|
case 4: return FEAT_CAST_DOMAIN_LEVEL_FOUR;
|
|
case 5: return FEAT_CAST_DOMAIN_LEVEL_FIVE;
|
|
case 6: return FEAT_CAST_DOMAIN_LEVEL_SIX;
|
|
case 7: return FEAT_CAST_DOMAIN_LEVEL_SEVEN;
|
|
case 8: return FEAT_CAST_DOMAIN_LEVEL_EIGHT;
|
|
case 9: return FEAT_CAST_DOMAIN_LEVEL_NINE;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
string GetDomainName(int nDomain)
|
|
{
|
|
string sName;
|
|
// Check that the domain slot is not empty
|
|
if(nDomain)
|
|
{
|
|
sName = Get2DACache("prc_domains", "Name", (nDomain - 1));
|
|
sName = GetStringByStrRef(StringToInt(sName));
|
|
}
|
|
else
|
|
sName = GetStringByStrRef(6497); // "Empty Slot"
|
|
|
|
return sName;
|
|
}
|
|
|
|
void CheckBonusDomains(object oPC)
|
|
{
|
|
int nBonusDomain, nDomainFeat;
|
|
int nSlot = 1;
|
|
while(nSlot < 6)
|
|
{
|
|
nBonusDomain = GetBonusDomain(oPC, nSlot);
|
|
nDomainFeat = GetDomainFeat(nBonusDomain);
|
|
if(!GetHasFeat(nDomainFeat, oPC)) SetPersistantLocalInt(oPC, "PRCBonusDomain" + IntToString(nSlot), 0);
|
|
//SendMessageToPC(oPC, "PRCBonusDomain"+IntToString(nSlot)" = "+IntToString(nBonusDomain));
|
|
//SendMessageToPC(oPC, "PRCBonusDomain"+IntToString(nSlot)" feat = "+IntToString(GetDomainFeat(nDomainFeat)));
|
|
nSlot += 1;
|
|
}
|
|
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_AIR, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_AIR);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_ANIMAL, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_ANIMAL);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_DEATH, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_DEATH);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_DESTRUCTION, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_DESTRUCTION);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_EARTH, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_EARTH);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_EVIL, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_EVIL);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_FIRE, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_FIRE);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_GOOD, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_GOOD);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_HEALING, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_HEALING);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_KNOWLEDGE, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_KNOWLEDGE);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_MAGIC, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_MAGIC);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_PLANT, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_PLANT);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_PROTECTION, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_PROTECTION);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_STRENGTH, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_STRENGTH);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_SUN, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_SUN);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_TRAVEL, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_TRAVEL);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_TRICKERY, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_TRICKERY);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_WAR, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_WAR);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_WATER, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_WATER);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_DARKNESS, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_DARKNESS);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_STORM, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_STORM);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_METAL, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_METAL);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_PORTAL, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_PORTAL);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_FORCE, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_FORCE);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_SLIME, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_SLIME);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_TYRANNY, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_TYRANNY);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_DOMINATION, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_DOMINATION);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_SPIDER, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_SPIDER);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_UNDEATH, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_UNDEATH);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_TIME, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_TIME);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_DWARF, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_DWARF);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_CHARM, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_CHARM);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_ELF, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_ELF);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_FAMILY, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_FAMILY);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_FATE, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_FATE);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_GNOME, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_GNOME);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_ILLUSION, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_ILLUSION);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_HATRED, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_HATRED);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_HALFLING, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_HALFLING);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_NOBILITY, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_NOBILITY);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_OCEAN, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_OCEAN);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_ORC, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_ORC);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_RENEWAL, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_RENEWAL);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_RETRIBUTION, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_RETRIBUTION);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_RUNE, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_RUNE);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_SPELLS, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_SPELLS);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_SCALEYKIND, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_SCALEYKIND);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_BLIGHTBRINGER, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_BLIGHTBRINGER);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_DRAGON, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_DRAGON);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_COLD, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_COLD);
|
|
if (GetHasFeat(FEAT_BONUS_DOMAIN_WINTER, oPC)) AddBonusDomain(oPC, PRC_DOMAIN_WINTER);
|
|
|
|
//if (DEBUG) FloatingTextStringOnCreature("Check Bonus Domains is running", oPC, FALSE);
|
|
}
|
|
|
|
int GetBurnableSpell(object oPC, int nLevel)
|
|
{
|
|
int nBurnableSpell = -1;
|
|
|
|
if (nLevel == 1) nBurnableSpell = GetBestL1Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 2) nBurnableSpell = GetBestL2Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 3) nBurnableSpell = GetBestL3Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 4) nBurnableSpell = GetBestL4Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 5) nBurnableSpell = GetBestL5Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 6) nBurnableSpell = GetBestL6Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 7) nBurnableSpell = GetBestL7Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 8) nBurnableSpell = GetBestL8Spell(oPC, nBurnableSpell);
|
|
else if (nLevel == 9) nBurnableSpell = GetBestL9Spell(oPC, nBurnableSpell);
|
|
|
|
return nBurnableSpell;
|
|
}
|
|
|
|
int GetDomainFeat(int nDomain)
|
|
{
|
|
// The -1 on nDomain is to adjust from a base 1 to a base 0 system.
|
|
// Returns the domain power feat
|
|
return StringToInt(Get2DACache("domains", "GrantedFeat", nDomain - 1));
|
|
}
|
|
|
|
int GetDomainFeatUsesPerDay(int nFeat, object oPC)
|
|
{
|
|
int nUses = StringToInt(Get2DACache("feat", "USESPERDAY", nFeat));
|
|
// These are the domains that have ability based uses per day
|
|
if (nUses == 33)
|
|
{
|
|
// The Strength domain, which uses Strength when the Cleric has Kord levels
|
|
// Without Kord levels, its 1 use per day
|
|
if(nFeat == FEAT_STRENGTH_DOMAIN_POWER)
|
|
{
|
|
nUses = 1;
|
|
if(GetLevelByClass(CLASS_TYPE_MIGHTY_CONTENDER_KORD, oPC)) nUses = GetAbilityModifier(ABILITY_STRENGTH, oPC);
|
|
// Catching exceptions
|
|
if(nUses < 1) nUses = 1;
|
|
}
|
|
if(nFeat == FEAT_SUN_DOMAIN_POWER)
|
|
{
|
|
if(GetHasFeat(FEAT_BONUS_DOMAIN_SUN, oPC) && GetLevelByClass(CLASS_TYPE_MYSTIC, oPC))
|
|
{
|
|
nUses = GetHasFeat(FEAT_EXTRA_TURNING, oPC) ? 7 : 3;
|
|
nUses += GetAbilityModifier(ABILITY_CHARISMA, oPC);
|
|
}
|
|
else
|
|
nUses = 1;
|
|
}
|
|
|
|
// All other ones so far are the Charisma based turning domains
|
|
nUses = 3 + GetAbilityModifier(ABILITY_CHARISMA, oPC);
|
|
}
|
|
|
|
return nUses;
|
|
}
|
|
|
|
int DecrementDomainUses(int nDomain, object oPC)
|
|
{
|
|
int nReturn = TRUE;
|
|
int nUses = GetLocalInt(oPC, "BonusDomainUsesPerDay" + GetDomainName(nDomain));
|
|
// If there is still a valid use left, remove it
|
|
if (nUses >= 1) SetLocalInt(oPC, "BonusDomainUsesPerDay" + GetDomainName(nDomain), (nUses - 1));
|
|
// Tell the player how many uses he has left
|
|
else // He has no more uses for the day
|
|
{
|
|
nReturn = FALSE;
|
|
}
|
|
|
|
FloatingTextStringOnCreature("You have " + IntToString(nUses - 1) + " uses per day left of the " + GetDomainName(nDomain) + " power.", oPC, FALSE);
|
|
|
|
return nReturn;
|
|
}
|
|
|
|
int GetTurningDomain(int nSpell)
|
|
{
|
|
switch(nSpell)
|
|
{
|
|
case SPELL_TURN_REPTILE: return PRC_DOMAIN_SCALEYKIND;
|
|
case SPELL_TURN_OOZE: return PRC_DOMAIN_SLIME;
|
|
case SPELL_TURN_SPIDER: return PRC_DOMAIN_SPIDER;
|
|
case SPELL_TURN_PLANT: return PRC_DOMAIN_PLANT;
|
|
case SPELL_TURN_AIR: return PRC_DOMAIN_AIR;
|
|
case SPELL_TURN_EARTH: return PRC_DOMAIN_EARTH;
|
|
case SPELL_TURN_FIRE: return PRC_DOMAIN_FIRE;
|
|
case SPELL_TURN_WATER: return PRC_DOMAIN_WATER;
|
|
case SPELL_TURN_BLIGHTSPAWNED: return PRC_DOMAIN_BLIGHTBRINGER;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
int GetHasDomain(object oPC, int nDomain)
|
|
{
|
|
// Get the domain power feat for the appropriate domain
|
|
int nFeat = GetDomainFeat(nDomain);
|
|
|
|
return GetHasFeat(nFeat, oPC);
|
|
}
|
|
|
|
void BonusDomainRest(object oPC)
|
|
{
|
|
// Bonus Domain ints that limit you to casting 1/day per level
|
|
int i;
|
|
for (i = 1; i < 10; i++)
|
|
{
|
|
DeleteLocalInt(oPC, "DomainCastSpell" + IntToString(i));
|
|
}
|
|
|
|
// This is code to stop you from using the Domain per day abilities more than you should be able to
|
|
int i2;
|
|
// Highest domain constant is 62
|
|
for (i2 = 1; i2 < 63; i2++)
|
|
{
|
|
// This is to ensure they only get the ints set for the domains they do have
|
|
if (GetHasDomain(oPC, i2))
|
|
{
|
|
// Store the number of uses a day here
|
|
SetLocalInt(oPC, "BonusDomainUsesPerDay" + GetDomainName(i2), GetDomainFeatUsesPerDay(GetDomainFeat(i2), oPC));
|
|
}
|
|
}
|
|
}
|
|
|
|
int GetDomainCasterLevel(object oPC)
|
|
{
|
|
return GetLevelByClass(CLASS_TYPE_CLERIC, oPC)
|
|
+ GetLevelByClass(CLASS_TYPE_MYSTIC, oPC)
|
|
+ GetLevelByClass(CLASS_TYPE_SHAMAN, oPC)
|
|
+ GetLevelByClass(CLASS_TYPE_TEMPLAR, oPC)
|
|
+ GetLevelByClass(CLASS_TYPE_BLIGHTLORD, oPC)
|
|
+ GetLevelByClass(CLASS_TYPE_CONTEMPLATIVE, oPC)
|
|
+ GetLevelByClass(CLASS_TYPE_MASTER_OF_SHROUDS, oPC);
|
|
} |