6ec137a24e
Updated AMS marker feats. Removed arcane & divine marker feats. Updated Dread Necromancer for epic progression. Updated weapon baseitem models. Updated new weapons for crafting & npc equip. Updated prefix. Updated release archive.
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;
|
|
}
|