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.
525 lines
23 KiB
Plaintext
525 lines
23 KiB
Plaintext
//::///////////////////////////////////////////////
|
|
//:: Truenaming include: Truespeaking
|
|
//:: true_inc_truespk
|
|
//::///////////////////////////////////////////////
|
|
/** @file
|
|
Defines functions for handling truespeaking.
|
|
|
|
@author Stratovarius
|
|
@date Created - 2006.18.07
|
|
*/
|
|
//:://////////////////////////////////////////////
|
|
//:://////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Constants */
|
|
//////////////////////////////////////////////////
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Function prototypes */
|
|
//////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Returns the base DC of an Utterance.
|
|
* This is where the various formulas can be chosen by switch
|
|
* Accounts for Speak Unto the Masses if used
|
|
*
|
|
* @param oTarget Target of the Utterance
|
|
* @param oTrueSpeaker Caster of the Utterance
|
|
* @param nLexicon Type of the Utterance: Evolving Mind, Crafted Tool, or Perfected Map
|
|
* @return The base DC via formula to hit the target
|
|
* This does not include MetaUtterances, increased DC to ignore SR, or the Laws.
|
|
*/
|
|
int GetBaseUtteranceDC(object oTarget, object oTrueSpeaker, int nLexicon);
|
|
|
|
/**
|
|
* Returns the Law of Resistance DC increase
|
|
*
|
|
* @param oTrueSpeaker Caster of the Utterance
|
|
* @param nSpellId SpellId of the Utterance
|
|
* @return The DC boost for this particular power from the Law of Resistance
|
|
*/
|
|
int GetLawOfResistanceDCIncrease(object oTrueSpeaker, int nSpellId);
|
|
|
|
/**
|
|
* Stores the Law Of Resistance DC increase
|
|
*
|
|
* @param oTrueSpeaker Caster of the Utterance
|
|
* @param nSpellId SpellId of the Utterance
|
|
*/
|
|
void DoLawOfResistanceDCIncrease(object oTrueSpeaker, int nSpellId);
|
|
|
|
/**
|
|
* Deletes all of the Local Ints stored by the laws.
|
|
* Called OnRest and OnEnter
|
|
*
|
|
* @param oTrueSpeaker Caster of the Utterance
|
|
*/
|
|
void ClearLawLocalVars(object oTrueSpeaker);
|
|
|
|
/**
|
|
* Returns the Personal Truename DC increase
|
|
* Right now this accounts for targeting self
|
|
* This also adds in the Acolyte of the Ego Alter Personal Truename
|
|
*
|
|
* @param oTrueSpeaker Caster of the Utterance
|
|
* @param oTarget Target of the Utterance
|
|
* @return The DC boost for using a personal truename
|
|
*/
|
|
int AddPersonalTruenameDC(object oTrueSpeaker, object oTarget);
|
|
|
|
/**
|
|
* Returns the DC increase if the TrueSpeaker ignores SR.
|
|
*
|
|
* @param oTrueSpeaker Caster of the Utterance
|
|
* @return The DC boost for using this ability
|
|
*/
|
|
int AddIgnoreSpellResistDC(object oTrueSpeaker);
|
|
|
|
/**
|
|
* Returns the DC increase from specific utterances
|
|
*
|
|
* @param oTrueSpeaker Caster of the Utterance
|
|
* @return The DC boost for using this ability
|
|
*/
|
|
int AddUtteranceSpecificDC(object oTrueSpeaker);
|
|
|
|
/**
|
|
* Returns the DC used for the Recitation feats
|
|
* This is a simplified version of the GetBaseUtteranceDC function
|
|
*
|
|
* @param oTrueSpeaker Caster/Target of the Recitation
|
|
* @return The DC to speak
|
|
*/
|
|
int GetRecitationDC(object oTrueSpeaker);
|
|
|
|
/*
|
|
* Returns TRUE if it is a Syllable (Bereft class ability).
|
|
* @param nSpellId Utterance to check
|
|
*
|
|
* @return TRUE or FALSE
|
|
*/
|
|
int GetIsSyllable(int nSpellId);
|
|
|
|
/*
|
|
* Returns TRUE if the Truespeaker passes a Truespeak check to affect the target
|
|
* @param nPersonal Personal Truename DC or not
|
|
*
|
|
* @return TRUE or FALSE
|
|
*/
|
|
int DoSpellTruenameCheck(object oTrueSpeaker, object oTarget, int nPersonal = FALSE);
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Includes */
|
|
//////////////////////////////////////////////////
|
|
|
|
#include "prc_inc_spells"
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Internal functions */
|
|
//////////////////////////////////////////////////
|
|
|
|
int GetCraftedToolCR(object oItem)
|
|
{
|
|
int nID=0;
|
|
if (!GetIdentified(oItem))
|
|
{
|
|
nID=1;
|
|
SetIdentified(oItem,TRUE);
|
|
}
|
|
int nGold = GetGoldPieceValue(oItem);
|
|
// If none of the statements trigger, the base is 0 (i.e, non-magical)
|
|
int nLore = 0;
|
|
|
|
if (nGold>1001) nLore= 1;
|
|
if (nGold>2501) nLore= 2;
|
|
if (nGold>3751) nLore= 3;
|
|
if (nGold>4801) nLore= 4;
|
|
if (nGold>6501) nLore= 5;
|
|
if (nGold>9501) nLore= 6;
|
|
if (nGold>13001) nLore= 7;
|
|
if (nGold>17001) nLore= 8;
|
|
if (nGold>20001) nLore= 9;
|
|
if (nGold>30001) nLore= 10;
|
|
if (nGold>40001) nLore= 11;
|
|
if (nGold>50001) nLore= 12;
|
|
if (nGold>60001) nLore= 13;
|
|
if (nGold>80001) nLore= 14;
|
|
if (nGold>100001) nLore= 15;
|
|
if (nGold>150001) nLore= 16;
|
|
if (nGold>200001) nLore= 17;
|
|
if (nGold>250001) nLore= 18;
|
|
if (nGold>300001) nLore= 19;
|
|
if (nGold>350001) nLore= 20;
|
|
if (nGold>400001) nLore= 21;
|
|
if (nGold>500001)
|
|
{
|
|
nGold = nGold - 500000;
|
|
nGold = nGold / 100000;
|
|
nLore = nGold + 22;
|
|
}
|
|
if (nID) SetIdentified(oItem,FALSE);
|
|
return nLore;
|
|
}
|
|
|
|
/**
|
|
* Takes the REVERSE SpellId of an Utterance and returns the NORMAL
|
|
* This is used for the Law of Resistance and the Law of Sequence so its always stored on the one SpellId
|
|
*
|
|
* @param nSpellId SpellId of the Utterance
|
|
* @return string SpellId of the NORMAL Utterance
|
|
*/
|
|
string GetNormalUtterSpellId(int nSpellId)
|
|
{
|
|
//All utterances have their 'normal' id in master column in spells.2da
|
|
string nReturn = Get2DACache("spells", "Master", nSpellId);
|
|
if (1 > StringToInt(nReturn)) nReturn = IntToString(nSpellId); // SpellId invalid for the Master column
|
|
|
|
return nReturn;
|
|
|
|
/* // Level 1 Utterances
|
|
if (nSpellId == UTTER_DEFENSIVE_EDGE_R || nSpellId == UTTER_DEFENSIVE_EDGE) return UTTER_DEFENSIVE_EDGE;
|
|
else if (nSpellId == UTTER_INERTIAL_SURGE_R || nSpellId == UTTER_INERTIAL_SURGE) return UTTER_INERTIAL_SURGE;
|
|
else if (nSpellId == UTTER_KNIGHTS_PUISSANCE_R || nSpellId == UTTER_KNIGHTS_PUISSANCE) return UTTER_KNIGHTS_PUISSANCE;
|
|
else if (nSpellId == UTTER_UNIVERSAL_APTITUDE_R || nSpellId == UTTER_UNIVERSAL_APTITUDE) return UTTER_UNIVERSAL_APTITUDE;
|
|
else if (nSpellId == UTTER_WORD_NURTURING_MINOR_R || nSpellId == UTTER_WORD_NURTURING_MINOR) return UTTER_WORD_NURTURING_MINOR;
|
|
else if (nSpellId == UTTER_FORTIFY_ARMOUR_SNEAK || nSpellId == UTTER_FORTIFY_ARMOUR_CRIT) return UTTER_FORTIFY_ARMOUR_SNEAK;
|
|
else if (nSpellId == UTTER_FOG_VOID_CLOUD || nSpellId == UTTER_FOG_VOID_SOLID) return UTTER_FOG_VOID_CLOUD;
|
|
|
|
// Level 2 Utterances
|
|
else if (nSpellId == UTTER_ARCHERS_EYE_R || nSpellId == UTTER_ARCHERS_EYE) return UTTER_ARCHERS_EYE;
|
|
else if (nSpellId == UTTER_HIDDEN_TRUTH_R || nSpellId == UTTER_HIDDEN_TRUTH) return UTTER_HIDDEN_TRUTH;
|
|
else if (nSpellId == UTTER_PERCEIVE_UNSEEN_R || nSpellId == UTTER_PERCEIVE_UNSEEN) return UTTER_PERCEIVE_UNSEEN;
|
|
else if (nSpellId == UTTER_SILENT_CASTER_R || nSpellId == UTTER_SILENT_CASTER) return UTTER_SILENT_CASTER;
|
|
else if (nSpellId == UTTER_SPEED_ZEPHYR_R || nSpellId == UTTER_SPEED_ZEPHYR) return UTTER_SPEED_ZEPHYR;
|
|
else if (nSpellId == UTTER_STRIKE_MIGHT_R || nSpellId == UTTER_STRIKE_MIGHT) return UTTER_STRIKE_MIGHT;
|
|
else if (nSpellId == UTTER_TEMPORAL_TWIST_R || nSpellId == UTTER_TEMPORAL_TWIST) return UTTER_TEMPORAL_TWIST;
|
|
else if (nSpellId == UTTER_WORD_NURTURING_LESSER_R || nSpellId == UTTER_WORD_NURTURING_LESSER) return UTTER_WORD_NURTURING_LESSER;
|
|
else if (nSpellId == UTTER_AGITATE_ITEM_HOT || nSpellId == UTTER_AGITATE_ITEM_COLD) return UTTER_AGITATE_ITEM_HOT;
|
|
else if (nSpellId == UTTER_ENERGY_VORTEX_ACID || nSpellId == UTTER_ENERGY_VORTEX_COLD || nSpellId == UTTER_ENERGY_VORTEX_ELEC || nSpellId == UTTER_ENERGY_VORTEX_FIRE) return UTTER_ENERGY_VORTEX_ACID;
|
|
|
|
// Level 3 Utterances
|
|
else if (nSpellId == UTTER_ACCELERATED_ATTACK_R || nSpellId == UTTER_ACCELERATED_ATTACK) return UTTER_ACCELERATED_ATTACK;
|
|
else if (nSpellId == UTTER_ENERGY_NEGATION_R || nSpellId == UTTER_ENERGY_NEGATION || nSpellId == UTTER_ENERGY_NEGATION_CHOICE) return UTTER_ENERGY_NEGATION;
|
|
else if (nSpellId == UTTER_INCARNATION_ANGELS_R || nSpellId == UTTER_INCARNATION_ANGELS) return UTTER_INCARNATION_ANGELS;
|
|
else if (nSpellId == UTTER_SPEED_ZEPHYR_GREATER_R || nSpellId == UTTER_SPEED_ZEPHYR_GREATER) return UTTER_SPEED_ZEPHYR_GREATER;
|
|
else if (nSpellId == UTTER_TEMPORAL_SPIRAL_R || nSpellId == UTTER_TEMPORAL_SPIRAL) return UTTER_TEMPORAL_SPIRAL;
|
|
else if (nSpellId == UTTER_VISION_SHARPENED_R || nSpellId == UTTER_VISION_SHARPENED) return UTTER_VISION_SHARPENED;
|
|
else if (nSpellId == UTTER_WORD_NURTURING_MODERATE_R || nSpellId == UTTER_WORD_NURTURING_MODERATE) return UTTER_WORD_NURTURING_MODERATE;
|
|
|
|
// Level 4 Utterances
|
|
else if (nSpellId == UTTER_BREATH_CLEANSING_R || nSpellId == UTTER_BREATH_CLEANSING) return UTTER_BREATH_CLEANSING;
|
|
else if (nSpellId == UTTER_CASTER_LENS_R || nSpellId == UTTER_CASTER_LENS) return UTTER_CASTER_LENS;
|
|
else if (nSpellId == UTTER_CONFOUNDING_RESISTANCE_R || nSpellId == UTTER_CONFOUNDING_RESISTANCE) return UTTER_CONFOUNDING_RESISTANCE;
|
|
else if (nSpellId == UTTER_MORALE_BOOST_R || nSpellId == UTTER_MORALE_BOOST) return UTTER_MORALE_BOOST;
|
|
else if (nSpellId == UTTER_MAGICAL_CONTRACTION_R || nSpellId == UTTER_MAGICAL_CONTRACTION) return UTTER_MAGICAL_CONTRACTION;
|
|
else if (nSpellId == UTTER_SPELL_REBIRTH_R || nSpellId == UTTER_SPELL_REBIRTH) return UTTER_SPELL_REBIRTH;
|
|
else if (nSpellId == UTTER_WORD_NURTURING_POTENT_R || nSpellId == UTTER_WORD_NURTURING_POTENT) return UTTER_WORD_NURTURING_POTENT;
|
|
|
|
// Level 5 Utterances
|
|
else if (nSpellId == UTTER_ELDRITCH_ATTRACTION_R || nSpellId == UTTER_ELDRITCH_ATTRACTION) return UTTER_ELDRITCH_ATTRACTION;
|
|
else if (nSpellId == UTTER_ENERGY_NEGATION_GREATER_R || nSpellId == UTTER_ENERGY_NEGATION_GREATER || nSpellId == UTTER_ENERGY_NEGATION_GREATER_CHOICE) return UTTER_ENERGY_NEGATION_GREATER;
|
|
else if (nSpellId == UTTER_ESSENCE_LIFESPARK_R || nSpellId == UTTER_ESSENCE_LIFESPARK) return UTTER_ESSENCE_LIFESPARK;
|
|
else if (nSpellId == UTTER_PRETERNATURAL_CLARITY_ATTACK || nSpellId == UTTER_PRETERNATURAL_CLARITY_SKILL || nSpellId == UTTER_PRETERNATURAL_CLARITY_SAVE || nSpellId == UTTER_PRETERNATURAL_CLARITY_R) return UTTER_PRETERNATURAL_CLARITY_ATTACK;
|
|
else if (nSpellId == UTTER_SENSORY_FOCUS_R || nSpellId == UTTER_SENSORY_FOCUS) return UTTER_SENSORY_FOCUS;
|
|
else if (nSpellId == UTTER_WARD_PEACE_R || nSpellId == UTTER_WARD_PEACE) return UTTER_WARD_PEACE;
|
|
else if (nSpellId == UTTER_WORD_NURTURING_CRITICAL_R || nSpellId == UTTER_WORD_NURTURING_CRITICAL) return UTTER_WORD_NURTURING_CRITICAL;
|
|
else if (nSpellId == UTTER_METAMAGIC_CATALYST_EMP || nSpellId == UTTER_METAMAGIC_CATALYST_EXT || nSpellId == UTTER_METAMAGIC_CATALYST_MAX) return UTTER_METAMAGIC_CATALYST_EMP;
|
|
|
|
// Level 6 Utterances
|
|
else if (nSpellId == UTTER_BREATH_RECOVERY_R || nSpellId == UTTER_BREATH_RECOVERY) return UTTER_BREATH_RECOVERY;
|
|
else if (nSpellId == UTTER_ETHER_REFORGED_R || nSpellId == UTTER_ETHER_REFORGED) return UTTER_ETHER_REFORGED;
|
|
else if (nSpellId == UTTER_KNIGHTS_PUISSANCE_GREATER_R || nSpellId == UTTER_KNIGHTS_PUISSANCE_GREATER) return UTTER_KNIGHTS_PUISSANCE_GREATER;
|
|
else if (nSpellId == UTTER_MYSTIC_RAMPART_R || nSpellId == UTTER_MYSTIC_RAMPART) return UTTER_MYSTIC_RAMPART;
|
|
else if (nSpellId == UTTER_SINGULAR_MIND_R || nSpellId == UTTER_SINGULAR_MIND) return UTTER_SINGULAR_MIND;
|
|
else if (nSpellId == UTTER_WORD_NURTURING_GREATER_R || nSpellId == UTTER_WORD_NURTURING_GREATER) return UTTER_WORD_NURTURING_GREATER;
|
|
|
|
// Class abilities
|
|
else if (nSpellId == SYLLABLE_AFFLICATION_SIGHT || nSpellId == SYLLABLE_AFFLICATION_SOUND || nSpellId == SYLLABLE_AFFLICATION_TOUCH) return SYLLABLE_AFFLICATION_SIGHT;
|
|
else if (nSpellId == BRIMSTONE_FIRE_3D6 || nSpellId == BRIMSTONE_FIRE_5D6 || nSpellId == BRIMSTONE_FIRE_8D6) return BRIMSTONE_FIRE_3D6;
|
|
else if (nSpellId == BRIMSTONE_HEAVEN_LESSER || nSpellId == BRIMSTONE_HEAVEN_NORMAL || nSpellId == BRIMSTONE_HEAVEN_GREATER) return BRIMSTONE_HEAVEN_LESSER;
|
|
|
|
// This is the return for those with no reverse.
|
|
return nSpellId;*/
|
|
}
|
|
|
|
int GetSwitchAdjustedDC(int nCR, int nTargets, object oTrueSpeaker)
|
|
{
|
|
int nClass = GetLevelByClass(CLASS_TYPE_TRUENAMER, oTrueSpeaker);
|
|
int nDC = 15 + (2 * nCR) + (2 * nTargets);
|
|
// Default is 0, off
|
|
int nMulti = GetPRCSwitch(PRC_TRUENAME_CR_MULTIPLIER);
|
|
int nBonus = GetPRCSwitch(PRC_TRUENAME_LEVEL_BONUS);
|
|
int nConst = GetPRCSwitch(PRC_TRUENAME_DC_CONSTANT);
|
|
// nMulti is stored as an int, divide by 100 to get the float
|
|
if(nMulti) nDC = FloatToInt(15 + ((IntToFloat(nMulti)/100) * nCR) + (2 * nTargets));
|
|
if(nBonus) nDC -= nClass/nBonus;
|
|
// Remove the existing constant and add the new one
|
|
if(nConst) nDC = (nDC - 15) + nConst;
|
|
|
|
return nDC;
|
|
}
|
|
|
|
int GetFeatAdjustedDC(object oTrueSpeaker)
|
|
{
|
|
int nDC = 0;
|
|
// Check for both, not either or
|
|
if(GetHasFeat(FEAT_SKILL_FOCUS_TRUESPEAK, oTrueSpeaker)) nDC += 3;
|
|
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_TRUESPEAK, oTrueSpeaker)) nDC += 10;
|
|
if(GetHasFeat(FEAT_TEMPLATE_SAINT_HOLY_POWER, oTrueSpeaker))
|
|
{
|
|
if (GetAlignmentGoodEvil(oTrueSpeaker) == ALIGNMENT_GOOD)
|
|
{
|
|
nDC += 2;
|
|
}
|
|
else
|
|
{
|
|
nDC += 0;
|
|
}
|
|
}
|
|
return nDC;
|
|
}
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Function definitions */
|
|
//////////////////////////////////////////////////
|
|
|
|
int GetBaseUtteranceDC(object oTarget, object oTrueSpeaker, int nLexicon)
|
|
{
|
|
int nDC;
|
|
|
|
// We're targetting a creature
|
|
if (nLexicon == LEXICON_EVOLVING_MIND)
|
|
{
|
|
// Check for Speak Unto the Masses. Syllables use the Evolving Mind formula, but can't Speak Unto Masses
|
|
if (GetLocalInt(oTrueSpeaker, TRUE_SPEAK_UNTO_MASSES) && !GetIsSyllable(PRCGetSpellId()))
|
|
{
|
|
if(DEBUG) DoDebug("GetBaseUtteranceDC: Entered");
|
|
// Speak to the Masses affects all creatures of the same race in the AoE
|
|
// Grants a +2 DC for each of them
|
|
int nRacial = MyPRCGetRacialType(oTarget);
|
|
// The creature with the same race as the target and the highest CR is used as the base
|
|
// So we loop through and count all the targets, as well as figure out the highest CR
|
|
int nMaxCR = FloatToInt(GetChallengeRating(oTarget));
|
|
int nCurCR, nTargets;
|
|
if(DEBUG) DoDebug("GetBaseUtteranceDC: Variables");
|
|
|
|
// Loop over targets
|
|
object oAreaTarget = MyFirstObjectInShape(SHAPE_SPHERE, FeetToMeters(30.0), GetLocation(oTarget), TRUE, OBJECT_TYPE_CREATURE);
|
|
while(GetIsObjectValid(oAreaTarget))
|
|
{
|
|
if(DEBUG) DoDebug("GetBaseUtteranceDC: While");
|
|
// Skip the original target, it doesn't count as a target
|
|
if (oAreaTarget != oTarget)
|
|
{
|
|
if(DEBUG) DoDebug("GetBaseUtteranceDC: Continue");
|
|
|
|
// Targeting limitations
|
|
if(MyPRCGetRacialType(oAreaTarget) == nRacial)
|
|
{
|
|
if(DEBUG) DoDebug("GetBaseUtteranceDC: race check");
|
|
// CR Check
|
|
nCurCR = FloatToInt(GetChallengeRating(oAreaTarget));
|
|
// Update if you find something bigger
|
|
if (nCurCR > nMaxCR) nMaxCR = nCurCR;
|
|
// Increment Targets
|
|
nTargets++;
|
|
}// end if - Targeting check
|
|
}
|
|
|
|
// Get next target
|
|
if(DEBUG) DoDebug("GetBaseUtteranceDC: Next Target");
|
|
oAreaTarget = MyNextObjectInShape(SHAPE_SPHERE, FeetToMeters(30.0), GetLocation(oTarget), TRUE, OBJECT_TYPE_CREATURE);
|
|
}// end while - Target loop
|
|
|
|
// Runs the function just above this that adjusts based on switches
|
|
nDC = GetSwitchAdjustedDC(nMaxCR, nTargets, oTrueSpeaker);
|
|
} // end if - Speak unto the Masses check
|
|
else // Single Target Utterance. The normal result
|
|
{
|
|
// CR does not take into account floats, so this is converted.
|
|
int nCR = FloatToInt(GetChallengeRating(oTarget));
|
|
// For PCs, use their HitDice
|
|
if (GetIsPC(oTarget)) nCR = GetHitDice(oTarget);
|
|
// Runs the function just above this that adjusts based on switches
|
|
nDC = GetSwitchAdjustedDC(nCR, 0, oTrueSpeaker);
|
|
}
|
|
}
|
|
// Targetting an Item here
|
|
else if (nLexicon == LEXICON_CRAFTED_TOOL)
|
|
{
|
|
// The formula isn't finished, because there isn't caster level on NWN items.
|
|
int nCasterLvl = GetCraftedToolCR(oTarget);
|
|
nDC = 15 + (2 * nCasterLvl);
|
|
}
|
|
// Targetting the land
|
|
else if (nLexicon == LEXICON_PERFECTED_MAP)
|
|
{
|
|
// Default is 0, off
|
|
int nMulti = GetPRCSwitch(PRC_PERFECTED_MAP_MULTIPLIER);
|
|
int nConst = GetPRCSwitch(PRC_PERFECTED_MAP_CONSTANT);
|
|
|
|
// Using Errata formula to prevent abuses
|
|
nDC = 25 + (GetUtteranceLevel(oTrueSpeaker) * 2);
|
|
|
|
// nMulti is stored as an int
|
|
if(nMulti) nDC = 25 + (GetUtteranceLevel(oTrueSpeaker) * nMulti);
|
|
// Remove the existing constant and add the new one
|
|
if(nConst) nDC = (nDC - 25) + nConst;
|
|
}
|
|
// Check to see if the PC has either of the Skill Focus feats.
|
|
// If so, subtract (They are a bonus to the PC) from the DC roll
|
|
nDC -= GetFeatAdjustedDC(oTrueSpeaker);
|
|
|
|
return nDC;
|
|
}
|
|
|
|
int GetLawOfResistanceDCIncrease(object oTrueSpeaker, int nSpellId)
|
|
{
|
|
// This makes sure everything is stored using the Normal, and not the reverse
|
|
// Law of resistance is stored for each utterance by SpellId
|
|
int nDC = GetLocalInt(oTrueSpeaker, LAW_OF_RESIST_VARNAME + GetNormalUtterSpellId(nSpellId));
|
|
// Its stored by the number of succesful attempts, so we double it to get the DC boost
|
|
nDC = nDC * 2;
|
|
|
|
if (GetPRCSwitch(PRC_LAW_OF_RESISTANCE)) nDC = 0;
|
|
return nDC;
|
|
}
|
|
|
|
void DoLawOfResistanceDCIncrease(object oTrueSpeaker, int nSpellId)
|
|
{
|
|
// This makes sure everything is stored using the Normal, and not the reverse
|
|
string sSpellId = GetNormalUtterSpellId(nSpellId);
|
|
// Law of resistance is stored for each utterance by SpellId
|
|
int nNum = GetLocalInt(oTrueSpeaker, LAW_OF_RESIST_VARNAME + sSpellId);
|
|
// Store the number of times per day its been cast succesfully
|
|
SetLocalInt(oTrueSpeaker, LAW_OF_RESIST_VARNAME + sSpellId, (nNum + 1));
|
|
}
|
|
|
|
void ClearLawLocalVars(object oTrueSpeaker)
|
|
{
|
|
// As long as the PC isn't a truenamer, don't run this.
|
|
if (GetLevelByClass(CLASS_TYPE_TRUENAMER, oTrueSpeaker))
|
|
{
|
|
// Law of resistance is stored for each utterance by SpellId
|
|
// So we loop em all and blow em away
|
|
// Because there are only about 60, this should not TMI
|
|
// i is the SpellId
|
|
// Replace numbers when done
|
|
int i;
|
|
for(i = 3526; i < 3639; i++)
|
|
{
|
|
DeleteLocalInt(oTrueSpeaker, LAW_OF_RESIST_VARNAME + IntToString(i));
|
|
DeleteLocalInt(oTrueSpeaker, LAW_OF_SEQUENCE_VARNAME + IntToString(i));
|
|
}
|
|
}
|
|
// As long as the PC isn't a brimstone speaker, don't run this.
|
|
if (GetLevelByClass(CLASS_TYPE_BRIMSTONE_SPEAKER, oTrueSpeaker))
|
|
{
|
|
// Law of resistance is stored for class features by SpellId
|
|
// So we loop em all and blow em away
|
|
// i is the SpellId
|
|
// Replace numbers when done
|
|
int i;
|
|
for(i = 3426; i < 3431; i++)
|
|
{
|
|
DeleteLocalInt(oTrueSpeaker, LAW_OF_RESIST_VARNAME + IntToString(i));
|
|
DeleteLocalInt(oTrueSpeaker, LAW_OF_SEQUENCE_VARNAME + IntToString(i));
|
|
}
|
|
}
|
|
// As long as the PC isn't a bereft, don't run this.
|
|
if (GetLevelByClass(CLASS_TYPE_BEREFT, oTrueSpeaker))
|
|
{
|
|
// Law of resistance is stored for each utterance by SpellId
|
|
// So we loop em all and blow em away
|
|
// Because there are only about 60, this should not TMI
|
|
// i is the SpellId
|
|
// Replace numbers when done
|
|
int i;
|
|
for(i = 3418; i < 3425; i++)
|
|
{
|
|
DeleteLocalInt(oTrueSpeaker, LAW_OF_RESIST_VARNAME + IntToString(i));
|
|
DeleteLocalInt(oTrueSpeaker, LAW_OF_SEQUENCE_VARNAME + IntToString(i));
|
|
}
|
|
}
|
|
}
|
|
|
|
int AddPersonalTruenameDC(object oTrueSpeaker, object oTarget)
|
|
{
|
|
// Targetting yourself increases the DC by 2
|
|
// But you get a +4 Bonus to speak your own truename
|
|
// Total Adjustment: -2
|
|
int nDC = oTrueSpeaker == oTarget ? -2 : 0;
|
|
|
|
///Increase the DC by 4
|
|
if (GetLevelByClass(CLASS_TYPE_ACOLYTE_EGO, oTrueSpeaker) > 6 && oTrueSpeaker != oTarget) nDC += 4;
|
|
///Increase the DC by another 4
|
|
if (GetLevelByClass(CLASS_TYPE_ACOLYTE_EGO, oTrueSpeaker) > 8 && oTrueSpeaker != oTarget) nDC += 4;
|
|
|
|
return nDC;
|
|
}
|
|
|
|
int AddIgnoreSpellResistDC(object oTrueSpeaker)
|
|
{
|
|
int nDC = GetLocalInt(oTrueSpeaker, TRUE_IGNORE_SR) ? 5 : 0;
|
|
|
|
return nDC;
|
|
}
|
|
|
|
int AddUtteranceSpecificDC(object oTrueSpeaker)
|
|
{
|
|
int nDC = 0;
|
|
int nSpellID = PRCGetSpellId();
|
|
// When using this utterance you add +10 to the DC to make yourself immune to crits
|
|
if(nSpellID == UTTER_FORTIFY_ARMOUR_CRIT) nDC += 10;
|
|
// When using this utterance you add +10 to the DC to maximize a potion or scroll
|
|
if(nSpellID == UTTER_METAMAGIC_CATALYST_MAX) nDC += 10;
|
|
// When using this utterance you add +10 to the DC to create a solid fog spell
|
|
if(nSpellID == UTTER_FOG_VOID_SOLID) nDC += 10;
|
|
|
|
return nDC;
|
|
}
|
|
|
|
int GetRecitationDC(object oTrueSpeaker)
|
|
{
|
|
int nCR = GetHitDice(oTrueSpeaker);
|
|
// Formula for the DC. The -2 is from speak your own Truename. See AddPersonalTruenameDC
|
|
int nDC = 15 + (2 * nCR) - 2;
|
|
|
|
return nDC;
|
|
}
|
|
|
|
int GetIsSyllable(int nSpellId)
|
|
{
|
|
switch(nSpellId)
|
|
{
|
|
case SYLLABLE_DETACHMENT:
|
|
case SYLLABLE_AFFLICATION_SIGHT:
|
|
case SYLLABLE_AFFLICATION_SOUND:
|
|
case SYLLABLE_AFFLICATION_TOUCH:
|
|
case SYLLABLE_EXILE:
|
|
case SYLLABLE_DISSOLUTION:
|
|
case SYLLABLE_ENERVATION:
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
int DoSpellTruenameCheck(object oTrueSpeaker, object oTarget, int nPersonal = FALSE)
|
|
{
|
|
// CR does not take into account floats, so this is converted.
|
|
int nCR = FloatToInt(GetChallengeRating(oTarget));
|
|
// For PCs, use their HitDice
|
|
if (GetIsPC(oTarget)) nCR = GetHitDice(oTarget);
|
|
// Runs the function just above this that adjusts based on switches
|
|
int nDC = GetSwitchAdjustedDC(nCR, 0, oTrueSpeaker);
|
|
// DC change for targeting self and using a Personal Truename
|
|
if (nPersonal)
|
|
nDC += AddPersonalTruenameDC(oTrueSpeaker, oTarget);
|
|
|
|
if(GetIsSkillSuccessful(oTrueSpeaker, SKILL_TRUESPEAK, nDC)) return TRUE;
|
|
|
|
return FALSE;
|
|
}
|