//:://///////////////////////////////////////////// //:: 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; }