//::///////////////////////////////////////////////
//:: Psionics include: Psionic Core Files
//:: psi_inc_core
//::///////////////////////////////////////////////
/** @file
Core functions removed from
psi_inc_psifunc
psi_inc_focus (depreciated)
as they are required by many of the other psi groups
@author Ornedan/ElgarL
@date Created - 2005.11.10/23.07.2010
*/
//:://////////////////////////////////////////////
//:://////////////////////////////////////////////
//:: Updated for .35 by Jaysyn 2023/03/10
//////////////////////////////////////////////////
/* Constants */
//////////////////////////////////////////////////
// Included here to provide the values for the constants below
#include "prc_class_const"
const int POWER_LIST_PSION = CLASS_TYPE_PSION;
const int POWER_LIST_WILDER = CLASS_TYPE_WILDER;
const int POWER_LIST_PSYWAR = CLASS_TYPE_PSYWAR;
const int POWER_LIST_PSYROG = CLASS_TYPE_PSYCHIC_ROGUE;
const int POWER_LIST_FIST_OF_ZUOKEN = CLASS_TYPE_FIST_OF_ZUOKEN;
const int POWER_LIST_WARMIND = CLASS_TYPE_WARMIND;
#include "psi_inc_const"
//:: Test Main
//void main (){}
//////////////////////////////////////////////////
/* Function prototypes */
//////////////////////////////////////////////////
/**
* Attempts to use psionic focus. If the creature was focused, it
* loses the focus. If it has Epic Psionic Focus feats, it will
* be able to use the focus for a number of times equal to the
* number of those feats it has during the next 0.5s
*
* @param oUser Creature expending it's psionic focus
* @return TRUE if the creature was psionically focus or had
* Epic Psionic Focus uses remaining. FALSE otherwise.
*/
int UsePsionicFocus(object oUser = OBJECT_SELF);
/**
* Sets psionic focus active and triggers feats dependant
* on it.
*
* Feats currently keyed to activity of psionic focus:
* Psionic Dodge
* Speed of Thought
*
* @param oGainee Creature gaining psionic focus.
*/
void GainPsionicFocus(object oGainee = OBJECT_SELF);
/**
* Gets the number of psionic focus uses the creature has available
* to it at this moment. If the creature is psionically focused,
* the number equal to GetPsionicFocusUsesPerExpenditure(), otherwise
* it is however many focus uses the creature still has remaining of
* that number.
*
* @param oCreature Creaute whose psionic focus use count to evaluate
* @return The total number of times UsePsionicFocus() will
* return TRUE if called at this moment.
*/
int GetPsionicFocusesAvailable(object oCreature = OBJECT_SELF);
/**
* Calculates the number of times a creature may use it's psionic focus when expending it.
* Base is 1.
* In addition, 1 more use for each Epic Psionic Focus feat the creature has.
*
* @param oCreature Creaute whose psionic focus use count to evaluate
* @return The total number of times UsePsionicFocus() will return
* TRUE for a single expending of psionic focus.
*/
int GetPsionicFocusUsesPerExpenditure(object oCreature = OBJECT_SELF);
/**
* Sets the given creature's psionic focus off and deactivates all feats keyed to it.
*
* @param oLoser Creature losing it's psionic focus
*/
void LosePsionicFocus(object oLoser = OBJECT_SELF);
/**
* Checks whether the given creature is psionically focused.
*
* @param oCreature Creature whose psionic focus's state to examine
* @return TRUE if the creature is psionically focused, FALSE
* otherwise.
*/
int GetIsPsionicallyFocused(object oCreature = OBJECT_SELF);
/**
* Determines the number of feats that would use psionic focus
* when triggered the given creature has active.
*
* Currently accounts for:
* Talented
* Power Specialization
* Power Penetration
* Psionic Endowment
* Chain Power
* Empower Power
* Extend Power
* Maximize Power
* Split Psionic Ray
* Twin Power
* Widen Power
* Quicken Power
*
* @param oCreature Creature whose feats to examine
* @return How many of the listed feats are active
*/
int GetPsionicFocusUsingFeatsActive(object oCreature = OBJECT_SELF);
/**
* Calculates the DC of the power being currently manifested.
* Base value is 10 + power level + ability modifier in manifesting stat
*
* WARNING: Return value is not defined when a power is not being manifested.
*
*/
int GetManifesterDC(object oManifester = OBJECT_SELF);
/**
* Determines the spell school matching a discipline according to the
* standard transparency rules.
* Disciplines which have no matching spell school are matched with
* SPELL_SCHOOL_GENERAL.
*
* @param nDiscipline Discipline to find matching spell school for
* @return SPELL_SCHOOL_* of the match
*/
int DisciplineToSpellSchool(int nDiscipline);
/**
* Determines the discipline matching a spell school according to the
* standard transparency rules.
* Spell schools that have no matching disciplines are matched with
* DISCIPLINE_NONE.
*
* @param nSpellSchool Spell schools to find matching discipline for
* @return DISCIPLINE_* of the match
*/
int SpellSchoolToDiscipline(int nSpellSchool);
/**
* Determines the discipline of a power, using the School column of spells.2da.
*
* @param nSpellID The spellID of the power to determine the discipline of
* @return DISCIPLINE_* constant. DISCIPLINE_NONE if the power's
* School designation does not match any of the discipline's.
*/
int GetPowerDiscipline(int nSpellID);
/**
* Determines whether a given power is a power of the Telepahty discipline.
*
* @param nSpellID The spells.2da row of the power. If left to default,
* PRCGetSpellId() is used.
* @return TRUE if the power's discipline is Telepathy, FALSE otherwise
*/
int GetIsTelepathyPower(int nSpellID = -1);
/**
* Checks whether the PC possesses the feats the given feat has as it's
* prerequisites. Possession of a feat is checked using GetHasFeat().
*
*
* @param nFeat The feat for which determine the possession of prerequisites
* @param oPC The creature whose feats to check
* @return TRUE if the PC possesses the prerequisite feats AND does not
* already posses nFeat, FALSE otherwise.
*/
int CheckPowerPrereqs(int nFeat, object oPC);
/**
* Determines the manifester's level in regards to manifester checks to overcome
* spell resistance.
*
* WARNING: Return value is not defined when a power is not being manifested.
*
* @param oManifester A creature manifesting a power at the moment
* @return The creature's manifester level, adjusted to account for
* modifiers that affect spell resistance checks.
*/
int GetPsiPenetration(object oManifester = OBJECT_SELF);
/**
* Determines whether a given creature possesses the Psionic subtype.
* Ways of possessing the subtype:
* - Being of a naturally psionic race
* - Having class levels in a psionic class
* - Possessing the Wild Talent feat
*
* @param oCreature Creature to test
* @return TRUE if the creature is psionic, FALSE otherwise.
*/
int GetIsPsionicCharacter(object oCreature);
/**
* Creates the creature weapon for powers like Bite of the Wolf and Claws of the
* Beast. If a creature weapon of the correct type is already present, it is
* used instead of a new one.
*
* Preserving existing weapons may cause problems, if so, make the function instead delete the old object - Ornedan
*
* @param oCreature Creatue whose creature weapons to mess with.
* @param sResRef Resref of the creature weapon. Assumed to be one of the
* PRC creature weapons, so this considered to is also be
* the tag.
* @param nIventorySlot Inventory slot where the creature weapon is to be equipped.
* @param fDuration If a new weapon is created, it will be destroyed after
* this duration.
*
* @return The newly created creature weapon. Or an existing weapon,
* if there was one.
*/
object GetPsionicCreatureWeapon(object oCreature, string sResRef, int nInventorySlot, float fDuration);
/**
* Applies modifications to a power's damage that depend on some property
* of the target.
* Currently accounts for:
* - Mental Resistance
* - Greater Power Specialization
* - Intellect Fortress
*
* @param oTarget A creature being dealt damage by a power
* @param oManifester The creature manifesting the damaging power
* @param nDamage The amount of damage the creature would be dealt
*
* @param bIsHitPointDamage Is the damage HP damage or something else?
* @param bIsEnergyDamage Is the damage caused by energy or something else? Only relevant if the damage is HP damage.
*
* @return The amount of damage, modified by oTarget's abilities
*/
int GetTargetSpecificChangesToDamage(object oTarget, object oManifester, int nDamage,
int bIsHitPointDamage = TRUE, int bIsEnergyDamage = FALSE);
/**
* Gets the manifester level adjustment from the Practiced Manifester feats.
*
* @param oManifester The creature to check
* @param iManifestingClass The CLASS_TYPE* that the power was cast by.
* @param iManifestingLevels The manifester level for the power calculated so far
* ie. BEFORE Practiced Manifester.
*/
int PracticedManifesting(object oManifester, int iManifestingClass, int iManifestingLevels);
/**
* Determines the given creature's manifester level. If a class is specified,
* then returns the manifester level for that class. Otherwise, returns
* the manifester level for the currently active manifestation.
*
* @param oManifester The creature whose manifester level to determine
* @param nSpecificClass The class to determine the creature's manifester
* level in.
* DEFAULT: CLASS_TYPE_INVALID, which means the creature's
* manifester level in regards to an ongoing manifestation
* is determined instead.
* @param nMaxPowerLevel For learning powers. Practiced Manifester is breaking things otherwise.
* @return The manifester level
*/
int GetManifesterLevel(object oManifester, int nSpecificClass = CLASS_TYPE_INVALID, int nMaxPowerLevel = FALSE);
/**
* Determines the given creature's highest undmodified manifester level among it's
* manifesting classes.
*
* @param oCreature Creature whose highest manifester level to determine
* @return The highest unmodified manifester level the creature can have
*/
int GetHighestManifesterLevel(object oCreature);
/**
* Gets the level of the power being currently manifested.
* WARNING: Return value is not defined when a power is not being manifested.
*
* @param oManifester The creature currently manifesting a power
* @return The level of the power being manifested
*/
int GetPowerLevel(object oManifester);
/**
* Determines a creature's ability score in the manifesting ability of a given
* class.
*
* @param oManifester Creature whose ability score to get
* @param nClass CLASS_TYPE_* constant of a manifesting class
*/
int GetAbilityScoreOfClass(object oManifester, int nClass);
/**
* Determines from what class's power list the currently being manifested
* power is manifested from.
*
* @param oManifester A creature manifesting a power at this moment
* @return CLASS_TYPE_* constant of the class
*/
int GetManifestingClass(object oManifester = OBJECT_SELF);
/**
* Determines the manifesting ability of a class.
*
* @param nClass CLASS_TYPE_* constant of the class to determine the manifesting stat of
* @return ABILITY_* of the manifesting stat. ABILITY_CHARISMA for non-manifester
* classes.
*/
int GetAbilityOfClass(int nClass);
/**
* Determines which of the character's classes is their highest or first psionic
* manifesting class, if any. This is the one which gains manifester level raise
* benefits from prestige classes.
*
* @param oCreature Creature whose classes to test
* @return CLASS_TYPE_* of the first psionic manifesting class,
* CLASS_TYPE_INVALID if the creature does not posses any.
*/
int GetPrimaryPsionicClass(object oCreature = OBJECT_SELF);
/**
* Calculates how many manifester levels are gained by a given creature from
* it's levels in prestige classes.
*
* @param oCreature Creature to calculate added manifester levels for
* @return The number of manifester levels gained
*/
int GetPsionicPRCLevels(object oCreature);
/**
* Determines the position of a creature's first psionic manifesting class, if any.
*
* @param oCreature Creature whose classes to test
* @return The position of the first psionic class {1, 2, 3} or 0 if
* the creature possesses no levels in psionic classes.
*/
int GetFirstPsionicClassPosition(object oCreature = OBJECT_SELF);
/**
* Determines whether a given class is a psionic class or not. A psionic
* class is defined as one that gives base manifesting.
*
* @param nClass CLASS_TYPE_* of the class to test
* @return TRUE if the class is a psionic class, FALSE otherwise
*/
int GetIsPsionicClass(int nClass);
/**
* Gets the amount of manifester levels the given creature is Wild Surging by.
*
* @param oManifester The creature to test
* @return The number of manifester levels added by Wild Surge. 0 if
* Wild Surge is not active.
*/
int GetWildSurge(object oManifester);
/**
* Gets the highest power level the creature should know
*
* @param oManifester The creature to test
* @return Power level.
*/
int GetMaxPowerLevel(object oManifester);
//////////////////////////////////////////////////
/* Includes */
//////////////////////////////////////////////////
#include "prc_inc_unarmed"
//////////////////////////////////////////////////
/* Global Structures */
//////////////////////////////////////////////////
// These are used in psi_inc_psifunc and psi_inc_augment
/**
* A structure that contains common data used during power manifestation.
*/
struct manifestation{
/* Generic stuff */
/// The creature manifesting the power
object oManifester;
/// Whether the manifestation is successfull or not
int bCanManifest;
/// How much Power Points the manifestation costs
int nPPCost;
/// How many psionic focus uses the manifester would have remaining at a particular point in the manifestation
int nPsiFocUsesRemain;
/// The creature's manifester level in regards to this power
int nManifesterLevel;
/// The power's spell ID
int nSpellID;
/* Augmentation */
/// How many times the first augmentation option of the power is used
int nTimesAugOptUsed_1;
/// How many times the second augmentation option of the power is used
int nTimesAugOptUsed_2;
/// How many times the third augmentation option of the power is used
int nTimesAugOptUsed_3;
/// How many times the fourth augmentation option of the power is used
int nTimesAugOptUsed_4;
/// How many times the fifth augmentation option of the power is used
int nTimesAugOptUsed_5;
/// How many times the PP used for augmentation triggered the generic augmentation of the power
int nTimesGenericAugUsed;
/* Metapsionics */
/// Whether Chain Power was used with this manifestation
int bChain;
/// Whether Empower Power was used with this manifestation
int bEmpower;
/// Whether Extend Power was used with this manifestation
int bExtend;
/// Whether Maximize Power was used with this manifestation
int bMaximize;
/// Whether Split Psionic Ray was used with this manifestation
int bSplit;
/// Whether Twin Power was used with this manifestation
int bTwin;
/// Whether Widen Power was used with this manifestation
int bWiden;
/// Whether Quicken Power was used with this manifestation
int bQuicken;
};
//////////////////////////////////////////////////
/* Function definitions */
//////////////////////////////////////////////////
/* Begin PSI FOCUS */
//////////////////////////////////////////////////////
int UsePsionicFocus(object oUser = OBJECT_SELF)
{
int bToReturn = FALSE;
// This does not expend your psionic focus, but rather the item's
if (GetLocalInt(oUser, "SimpleBow_Focus"))
{
DeleteLocalInt(oUser, "SimpleBow_Focus");
return TRUE;
}
// Next, check if we have focus on
else if(GetLocalInt(oUser, PSIONIC_FOCUS))
{
SetLocalInt(oUser, "PsionicFocusUses", GetPsionicFocusUsesPerExpenditure(oUser) - 1);
DelayCommand(0.5f, DeleteLocalInt(oUser, "PsionicFocusUses"));
SendMessageToPCByStrRef(oUser, 16826414); // "You have used your Psionic Focus"
bToReturn = TRUE;
}
// We don't. Check if there are uses remaining
else if(GetLocalInt(oUser, "PsionicFocusUses"))
{
SetLocalInt(oUser, "PsionicFocusUses", GetLocalInt(oUser, "PsionicFocusUses") - 1);
bToReturn = TRUE;
}
// Lose focus if it was used
if(bToReturn) LosePsionicFocus(oUser);
return bToReturn;
}
void GainPsionicFocus(object oGainee = OBJECT_SELF)
{
SetLocalInt(oGainee, PSIONIC_FOCUS, TRUE);
// Speed Of Thought
if(GetHasFeat(FEAT_SPEED_OF_THOUGHT, oGainee))
{
// Check for heavy armor before adding the bonus now
if(GetBaseAC(GetItemInSlot(INVENTORY_SLOT_CHEST, oGainee)) < 6)
AssignCommand(oGainee, ActionCastSpellAtObject(SPELL_FEAT_SPEED_OF_THOUGHT_BONUS, oGainee, METAMAGIC_NONE, TRUE, 0, PROJECTILE_PATH_TYPE_DEFAULT, TRUE));
// Schedule a script to remove the bonus should they equip heavy armor
AddEventScript(oGainee, EVENT_ONPLAYEREQUIPITEM, "psi_spdfthgt_oeq", TRUE, FALSE);
// Schedule another script to add the bonus back if the unequip the armor
AddEventScript(oGainee, EVENT_ONPLAYERUNEQUIPITEM, "psi_spdfthgt_ueq", TRUE, FALSE);
}
// Psionic Dodge
if(GetHasFeat(FEAT_PSIONIC_DODGE, oGainee))
SetCompositeBonus(GetPCSkin(oGainee), "PsionicDodge", 1, ITEM_PROPERTY_AC_BONUS);
//Strength of Two - Kalashtar racial feat
if(GetHasFeat(FEAT_STRENGTH_OF_TWO, oGainee))
{
SetCompositeBonus(GetPCSkin(oGainee), "StrengthOfTwo", 1, ITEM_PROPERTY_SAVING_THROW_BONUS, SAVING_THROW_WILL);
}
// Danger Sense abilities for Psychic Rogue
if(GetLevelByClass(CLASS_TYPE_PSYCHIC_ROGUE, oGainee) >= 5)
ExecuteScript("psi_psyrog_dngr", oGainee);
if(GetLevelByClass(CLASS_TYPE_PSYCHIC_ROGUE, oGainee) >= 7) // Uncanny Dodge
IPSafeAddItemProperty(GetPCSkin(oGainee), PRCItemPropertyBonusFeat(IP_CONST_FEAT_UNCANNY_DODGE1), HoursToSeconds(24), X2_IP_ADDPROP_POLICY_KEEP_EXISTING, FALSE, FALSE);
if(GetLevelByClass(CLASS_TYPE_PSYCHIC_ROGUE, oGainee) >= 9) // Improved Uncanny Dodge
IPSafeAddItemProperty(GetPCSkin(oGainee), PRCItemPropertyBonusFeat(IP_CONST_FEAT_UNCANNY_DODGE2), HoursToSeconds(24), X2_IP_ADDPROP_POLICY_KEEP_EXISTING, FALSE, FALSE);
if(GetHasFeat(FEAT_PSY_SNEAK_ATTACK_1d6, oGainee))
{
int nPsySneak = 1;
if(GetHasFeat(FEAT_PSY_SNEAK_ATTACK_2d6, oGainee))
nPsySneak += 2;
if(GetHasFeat(FEAT_PSY_SNEAK_ATTACK_3d6, oGainee))
nPsySneak += 3;
SetLocalInt(oGainee, "PsyRogueSneak",nPsySneak);
DelayCommand(0.1, ExecuteScript("prc_sneak_att", oGainee));
}
}
int GetPsionicFocusesAvailable(object oCreature = OBJECT_SELF)
{
// If the creature has a psionic focus active, return the maximum
if(GetLocalInt(oCreature, PSIONIC_FOCUS))
return GetPsionicFocusUsesPerExpenditure(oCreature);
// Otherwise, return the amount currently remaining
else
return GetLocalInt(oCreature, "PsionicFocusUses");
}
int GetPsionicFocusUsesPerExpenditure(object oCreature = OBJECT_SELF)
{
int nFocusUses = 1;
int i;
for(i = FEAT_EPIC_PSIONIC_FOCUS_1; i <= FEAT_EPIC_PSIONIC_FOCUS_10; i++)
if(GetHasFeat(i, oCreature)) nFocusUses++;
return nFocusUses;
}
void LosePsionicFocus(object oLoser = OBJECT_SELF)
{
// Only remove focus if it's present
if(GetLocalInt(oLoser, PSIONIC_FOCUS))
{
SetLocalInt(oLoser, PSIONIC_FOCUS, FALSE);
// Loss of Speed of Thought effects
PRCRemoveSpellEffects(SPELL_FEAT_SPEED_OF_THOUGHT_BONUS, oLoser, oLoser);
RemoveEventScript(oLoser, EVENT_ONPLAYEREQUIPITEM, "psi_spdfthgt_oeq", TRUE);
RemoveEventScript(oLoser, EVENT_ONPLAYERUNEQUIPITEM, "psi_spdfthgt_ueq", TRUE);
// Loss of Psionic Dodge effects
SetCompositeBonus(GetPCSkin(oLoser), "PsionicDodge", 0, ITEM_PROPERTY_AC_BONUS);
// Loss of Strength of Two effects
SetCompositeBonus(GetPCSkin(oLoser), "StrengthOfTwo", 0, ITEM_PROPERTY_SAVING_THROW_BONUS, SAVING_THROW_WILL);
if(GetLevelByClass(CLASS_TYPE_PSYCHIC_ROGUE, oLoser) >= 5)
PRCRemoveSpellEffects(POWER_DANGERSENSE, oLoser, oLoser);
if(GetLevelByClass(CLASS_TYPE_PSYCHIC_ROGUE, oLoser) >= 7)
RemoveItemProperty(GetPCSkin(oLoser), ItemPropertyBonusFeat(IP_CONST_FEAT_UNCANNY_DODGE1));
if(GetLevelByClass(CLASS_TYPE_PSYCHIC_ROGUE, oLoser) >= 9)
RemoveItemProperty(GetPCSkin(oLoser), ItemPropertyBonusFeat(IP_CONST_FEAT_UNCANNY_DODGE2));
// Inform oLoser about the event
FloatingTextStrRefOnCreature(16826415, oLoser, FALSE); // "You have lost your Psionic Focus"
if(GetHasFeat(FEAT_PSY_SNEAK_ATTACK_1d6, oLoser))
{
DeleteLocalInt(oLoser, "PsyRogueSneak");
DelayCommand(0.1, ExecuteScript("prc_sneak_att", oLoser));
}
}
}
int GetIsPsionicallyFocused(object oCreature = OBJECT_SELF)
{
return GetLocalInt(oCreature, PSIONIC_FOCUS);
}
int GetPsionicFocusUsingFeatsActive(object oCreature = OBJECT_SELF)
{
int nFeats;
if(GetLocalInt(oCreature, "TalentedActive")) nFeats++;
if(GetLocalInt(oCreature, "PowerSpecializationActive")) nFeats++;
if(GetLocalInt(oCreature, "PowerPenetrationActive")) nFeats++;
if(GetLocalInt(oCreature, "PsionicEndowmentActive")) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_CHAIN_VAR)) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_EMPOWER_VAR)) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_EXTEND_VAR)) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_MAXIMIZE_VAR)) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_SPLIT_VAR)) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_TWIN_VAR)) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_WIDEN_VAR)) nFeats++;
if(GetLocalInt(oCreature, METAPSIONIC_QUICKEN_VAR)) nFeats++;
return nFeats;
}
//////////////////////////////////////////////////////
/* END PSI FOCUS */
//////////////////////////////////////////////////////
int GetManifesterDC(object oManifester = OBJECT_SELF)
{
int nClass = GetManifestingClass(oManifester);
int nDC = 10;
nDC += GetPowerLevel(oManifester);
nDC += GetAbilityModifier(GetAbilityOfClass(nClass), oManifester);
// Stuff that applies only to powers, not psi-like abilities goes inside
if(!GetLocalInt(oManifester, PRC_IS_PSILIKE))
{
if (GetLocalInt(oManifester, "PsionicEndowmentActive") == TRUE && UsePsionicFocus(oManifester))
{
nDC += GetHasFeat(FEAT_GREATER_PSIONIC_ENDOWMENT, oManifester) ? 4 : 2;
}
}
// Needed to do some adjustments here.
object oTarget = PRCGetSpellTargetObject();
int nPower = PRCGetSpellId();
// Other DC adjustments
// Soul Manifester
nDC += Soulcaster(oManifester, PRCGetSpellId());
// Charming Veil meld
if(GetHasSpellEffect(MELD_CHARMING_VEIL, oManifester) && (GetIsOfSubschool(nPower, SUBSCHOOL_CHARM) || GetIsOfSubschool(nPower, SUBSCHOOL_COMPULSION))) nDC += GetEssentiaInvested(oManifester, MELD_CHARMING_VEIL)+1;
// Soul Eater
nDC += (GetLocalInt(oManifester, "PRC_SoulEater_HasDrained") && GetLevelByClass(CLASS_TYPE_SOUL_EATER, oManifester) >= 10) ? 2 : 0;
// Closed Mind
if(GetHasFeat(FEAT_CLOSED_MIND, oTarget)) nDC -= 2;
// Strong Mind
if(GetHasFeat(FEAT_STRONG_MIND, oTarget)) nDC -= 3;
// Fist of Dal Quor
if(GetLevelByClass(CLASS_TYPE_FIST_DAL_QUOR, oTarget) >= 4) nDC -= 2;
return nDC;
}
int DisciplineToSpellSchool(int nDiscipline)
{
int nSpellSchool = SPELL_SCHOOL_GENERAL;
switch(nDiscipline)
{
case DISCIPLINE_CLAIRSENTIENCE: nSpellSchool = SPELL_SCHOOL_DIVINATION; break;
case DISCIPLINE_METACREATIVITY: nSpellSchool = SPELL_SCHOOL_CONJURATION; break;
case DISCIPLINE_PSYCHOKINESIS: nSpellSchool = SPELL_SCHOOL_EVOCATION; break;
case DISCIPLINE_PSYCHOMETABOLISM: nSpellSchool = SPELL_SCHOOL_TRANSMUTATION; break;
case DISCIPLINE_TELEPATHY: nSpellSchool = SPELL_SCHOOL_ENCHANTMENT; break;
default: nSpellSchool = SPELL_SCHOOL_GENERAL; break;
}
return nSpellSchool;
}
int SpellSchoolToDiscipline(int nSpellSchool)
{
int nDiscipline = DISCIPLINE_NONE;
switch(nSpellSchool)
{
case SPELL_SCHOOL_GENERAL: nDiscipline = DISCIPLINE_NONE; break;
case SPELL_SCHOOL_ABJURATION: nDiscipline = DISCIPLINE_NONE; break;
case SPELL_SCHOOL_CONJURATION: nDiscipline = DISCIPLINE_METACREATIVITY; break;
case SPELL_SCHOOL_DIVINATION: nDiscipline = DISCIPLINE_CLAIRSENTIENCE; break;
case SPELL_SCHOOL_ENCHANTMENT: nDiscipline = DISCIPLINE_TELEPATHY; break;
case SPELL_SCHOOL_EVOCATION: nDiscipline = DISCIPLINE_PSYCHOKINESIS; break;
case SPELL_SCHOOL_ILLUSION: nDiscipline = DISCIPLINE_NONE; break;
case SPELL_SCHOOL_NECROMANCY: nDiscipline = DISCIPLINE_NONE; break;
case SPELL_SCHOOL_TRANSMUTATION: nDiscipline = DISCIPLINE_PSYCHOMETABOLISM; break;
default: nDiscipline = DISCIPLINE_NONE;
}
return nDiscipline;
}
int GetPowerDiscipline(int nSpellID)
{
string sSpellSchool = Get2DACache("spells", "School", nSpellID);//lookup_spell_school(nSpellID);
int nDiscipline;
if (sSpellSchool == "A") nDiscipline = DISCIPLINE_NONE;
else if (sSpellSchool == "C") nDiscipline = DISCIPLINE_METACREATIVITY;
else if (sSpellSchool == "D") nDiscipline = DISCIPLINE_CLAIRSENTIENCE;
else if (sSpellSchool == "E") nDiscipline = DISCIPLINE_TELEPATHY;
else if (sSpellSchool == "V") nDiscipline = DISCIPLINE_PSYCHOKINESIS;
else if (sSpellSchool == "I") nDiscipline = DISCIPLINE_NONE;
else if (sSpellSchool == "N") nDiscipline = DISCIPLINE_NONE;
else if (sSpellSchool == "T") nDiscipline = DISCIPLINE_PSYCHOMETABOLISM;
else if (sSpellSchool == "G") nDiscipline = DISCIPLINE_PSYCHOPORTATION;
return nDiscipline;
}
int GetIsTelepathyPower(int nSpellID = -1)
{
if(nSpellID == -1) nSpellID = PRCGetSpellId();
return GetPowerDiscipline(nSpellID) == DISCIPLINE_TELEPATHY;
}
int CheckPowerPrereqs(int nFeat, object oPC)
{
// Having the power already automatically disqualifies one from taking it again
if(GetHasFeat(nFeat, oPC))
return FALSE;
// We assume that the 2da is correctly formatted, and as such, a prereq slot only contains
// data if the previous slots in order also contains data.
// ie, no PREREQFEAT2 if PREREQFEAT1 is empty
if(Get2DACache("feat", "PREREQFEAT1", nFeat) != "")
{
if(!GetHasFeat(StringToInt(Get2DACache("feat", "PREREQFEAT1", nFeat)), oPC))
return FALSE;
if(Get2DACache("feat", "PREREQFEAT2", nFeat) != ""
&& !GetHasFeat(StringToInt(Get2DACache("feat", "PREREQFEAT2", nFeat)), oPC))
return FALSE;
}
if(Get2DACache("feat", "OrReqFeat0", nFeat) != "")
{
if(!GetHasFeat(StringToInt(Get2DACache("feat", "OrReqFeat0", nFeat)), oPC))
return FALSE;
if(Get2DACache("feat", "OrReqFeat1", nFeat) != "")
{
if(!GetHasFeat(StringToInt(Get2DACache("feat", "OrReqFeat1", nFeat)), oPC))
return FALSE;
if(Get2DACache("feat", "OrReqFeat2", nFeat) != "")
{
if(!GetHasFeat(StringToInt(Get2DACache("feat", "OrReqFeat2", nFeat)), oPC))
return FALSE;
if(Get2DACache("feat", "OrReqFeat3", nFeat) != "")
{
if(!GetHasFeat(StringToInt(Get2DACache("feat", "OrReqFeat3", nFeat)), oPC))
return FALSE;
if(Get2DACache("feat", "OrReqFeat4", nFeat) != "")
{
if(!GetHasFeat(StringToInt(Get2DACache("feat", "OrReqFeat4", nFeat)), oPC))
return FALSE;
} } } } }
//if youve reached this far then return TRUE
return TRUE;
}
int GetPsiPenetration(object oManifester = OBJECT_SELF)
{
int nPen = GetManifesterLevel(oManifester);
// The stuff inside applies only to normal manifestation, not psi-like abilities
if(!GetLocalInt(oManifester, PRC_IS_PSILIKE))
{
// Check for Power Pen feats being used
if(GetLocalInt(oManifester, "PowerPenetrationActive") == TRUE && UsePsionicFocus(oManifester))
{
nPen += GetHasFeat(FEAT_GREATER_POWER_PENETRATION, oManifester) ? 8 : 4;
}
}
return nPen;
}
int GetIsPsionicCharacter(object oCreature)
{
return !!(GetLevelByClass(CLASS_TYPE_PSION, oCreature) ||
GetLevelByClass(CLASS_TYPE_PSYWAR, oCreature) ||
GetLevelByClass(CLASS_TYPE_PSYCHIC_ROGUE, oCreature) ||
GetLevelByClass(CLASS_TYPE_WILDER, oCreature) ||
GetLevelByClass(CLASS_TYPE_FIST_OF_ZUOKEN, oCreature) ||
GetLevelByClass(CLASS_TYPE_WARMIND, oCreature) ||
GetHasFeat(FEAT_WILD_TALENT, oCreature) ||
GetHasFeat(FEAT_KALASHTAR_PP, oCreature) ||
GetHasFeat(FEAT_NATPSIONIC_1, oCreature) ||
GetHasFeat(FEAT_NATPSIONIC_2, oCreature) ||
GetHasFeat(FEAT_NATPSIONIC_3, oCreature)
// Racial psionicity signifying feats go here
);
}
void LocalCleanExtraFists(object oCreature)
{
int iIsCWeap, iIsEquip;
object oClean = GetFirstItemInInventory(oCreature);
while (GetIsObjectValid(oClean))
{
iIsCWeap = GetIsPRCCreatureWeapon(oClean);
iIsEquip = oClean == GetItemInSlot(INVENTORY_SLOT_CWEAPON_L) ||
oClean == GetItemInSlot(INVENTORY_SLOT_CWEAPON_R) ||
oClean == GetItemInSlot(INVENTORY_SLOT_CWEAPON_B);
if (iIsCWeap && !iIsEquip)
{
DestroyObject(oClean);
}
oClean = GetNextItemInInventory(oCreature);
}
}
object GetPsionicCreatureWeapon(object oCreature, string sResRef, int nInventorySlot, float fDuration)
{
int bCreatedWeapon = FALSE;
object oCWeapon = GetItemInSlot(nInventorySlot, oCreature);
RemoveUnarmedAttackEffects(oCreature);
// Make sure they can actually equip them
UnarmedFeats(oCreature);
// Determine if a creature weapon of the proper type already exists in the slot
if(!GetIsObjectValid(oCWeapon) ||
GetStringUpperCase(GetTag(oCWeapon)) != GetStringUpperCase(sResRef) // Hack: The resref's and tags of the PRC creature weapons are the same
)
{
if (GetHasItem(oCreature, sResRef))
{
oCWeapon = GetItemPossessedBy(oCreature, sResRef);
SetIdentified(oCWeapon, TRUE);
//AssignCommand(oCreature, ActionEquipItem(oCWeapon, INVENTORY_SLOT_CWEAPON_L));
ForceEquip(oCreature, oCWeapon, nInventorySlot);
}
else
{
oCWeapon = CreateItemOnObject(sResRef, oCreature);
SetIdentified(oCWeapon, TRUE);
//AssignCommand(oCreature, ActionEquipItem(oCWeapon, INVENTORY_SLOT_CWEAPON_L));
ForceEquip(oCreature, oCWeapon, nInventorySlot);
bCreatedWeapon = TRUE;
}
}
// Clean up the mess of extra fists made on taking first level.
DelayCommand(6.0f, LocalCleanExtraFists(oCreature));
// Weapon finesse or intuitive attack?
SetLocalInt(oCreature, "UsingCreature", TRUE);
ExecuteScript("prc_intuiatk", oCreature);
DelayCommand(1.0f, DeleteLocalInt(oCreature, "UsingCreature"));
// Add OnHitCast: Unique if necessary
if(GetHasFeat(FEAT_REND, oCreature))
IPSafeAddItemProperty(oCWeapon, ItemPropertyOnHitCastSpell(IP_CONST_ONHIT_CASTSPELL_ONHIT_UNIQUEPOWER, 1), 0.0f, X2_IP_ADDPROP_POLICY_KEEP_EXISTING, FALSE, FALSE);
// This adds creature weapon finesse
ApplyUnarmedAttackEffects(oCreature);
// Destroy the weapon if it was created by this function
if(bCreatedWeapon)
DestroyObject(oCWeapon, (fDuration + 6.0));
return oCWeapon;
}
int GetTargetSpecificChangesToDamage(object oTarget, object oManifester, int nDamage,
int bIsHitPointDamage = TRUE, int bIsEnergyDamage = FALSE)
{
// Greater Power Specialization - +2 damage on all HP-damaging powers when target is within 30ft
if(bIsHitPointDamage &&
GetHasFeat(FEAT_GREATER_POWER_SPECIALIZATION, oManifester) &&
GetDistanceBetween(oTarget, oManifester) <= FeetToMeters(30.0f)
)
nDamage += 2;
// Intellect Fortress - Halve damage dealt by powers that allow PR. Goes before DR (-like) reductions
if(GetLocalInt(oTarget, "PRC_Power_IntellectFortress_Active") &&
Get2DACache("spells", "ItemImmunity", PRCGetSpellId()) == "1"
)
nDamage /= 2;
// Mental Resistance - 3 damage less for all non-energy damage and ability damage
if(GetHasFeat(FEAT_MENTAL_RESISTANCE, oTarget) && !bIsEnergyDamage)
nDamage -= 3;
// Reasonable return values only
if(nDamage < 0) nDamage = 0;
if (GetIsMeldBound(oManifester, MELD_PSYCHIC_FOCUS) == CHAKRA_THROAT && nDamage > 0 && !GetLocalInt(oManifester, "PsychicFocusMeld") && bIsHitPointDamage)
{
SetLocalInt(oManifester, "PsychicFocusMeld", TRUE);
DelayCommand(6.0, DeleteLocalInt(oManifester, "PsychicFocusMeld"));
int nClass = GetMeldShapedClass(oManifester, MELD_PSYCHIC_FOCUS);
int nDC = GetMeldshaperDC(oManifester, nClass, MELD_PSYCHIC_FOCUS);
if(PRCMySavingThrow(SAVING_THROW_FORT, oTarget, nDC, SAVING_THROW_TYPE_NONE))
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectDazed(), oTarget, 6.0);
}
return nDamage;
}
int PracticedManifesting(object oManifester, int iManifestingClass, int iManifestingLevels)
{
int nFeat;
int iAdjustment = GetHitDice(oManifester) - iManifestingLevels;
iAdjustment = iAdjustment > 4 ? 4 : iAdjustment < 0 ? 0 : iAdjustment;
switch(iManifestingClass)
{
case CLASS_TYPE_PSION: nFeat = FEAT_PRACTICED_MANIFESTER_PSION; break;
case CLASS_TYPE_PSYWAR: nFeat = FEAT_PRACTICED_MANIFESTER_PSYWAR; break;
case CLASS_TYPE_PSYCHIC_ROGUE: nFeat = FEAT_PRACTICED_MANIFESTER_PSYROG; break;
case CLASS_TYPE_WILDER: nFeat = FEAT_PRACTICED_MANIFESTER_WILDER; break;
case CLASS_TYPE_WARMIND: nFeat = FEAT_PRACTICED_MANIFESTER_WARMIND; break;
case CLASS_TYPE_FIST_OF_ZUOKEN: nFeat = FEAT_PRACTICED_MANIFESTER_FIST_OF_ZUOKEN; break;
default: nFeat = -1;
}
if(GetHasFeat(nFeat, oManifester))
return iAdjustment;
return 0;
}
int GetManifesterLevel(object oManifester, int nSpecificClass = CLASS_TYPE_INVALID, int nMaxPowerLevel = FALSE)
{
int nLevel;
int nAdjust = GetLocalInt(oManifester, PRC_CASTERLEVEL_ADJUSTMENT);
nAdjust -= GetLocalInt(oManifester, "WoLManifPenalty");
// The function user needs to know the character's manifester level in a specific class
// instead of whatever the character last manifested a power as
if(nSpecificClass != CLASS_TYPE_INVALID)
{
if(GetIsPsionicClass(nSpecificClass))
{
nLevel = GetLevelByClass(nSpecificClass, oManifester);
// Add levels from +ML PrCs only for the first manifesting class
if(nSpecificClass == GetPrimaryPsionicClass(oManifester))
nLevel += GetPsionicPRCLevels(oManifester);
// Psionic vestiges are tucked in here to override things.
// This assumes that there will never be a psion with this spell effect manifesting things
if (nSpecificClass == CLASS_TYPE_PSION && GetHasSpellEffect(VESTIGE_ARETE, oManifester) && !nMaxPowerLevel)
{
nLevel = GetLocalInt(oManifester, "AretePsion");
nMaxPowerLevel = TRUE;
}
if (nSpecificClass == CLASS_TYPE_PSION && GetHasSpellEffect(VESTIGE_THETRIAD, oManifester) && !nMaxPowerLevel)
{
nLevel = GetLocalInt(oManifester, "TheTriadPsion");
nMaxPowerLevel = TRUE;
}
if (nSpecificClass == CLASS_TYPE_PSION && GetHasSpellEffect(VESTIGE_ABYSM, oManifester) && !nMaxPowerLevel)
{
nLevel = GetLocalInt(oManifester, "AbysmPsion");
nMaxPowerLevel = TRUE;
}
// This is for learning powers, we need to ignore some adjustments
if (nMaxPowerLevel) return nLevel;
nLevel += PracticedManifesting(oManifester, nSpecificClass, nLevel); //gotta be the last one
return nLevel + nAdjust;
}
// A character's manifester level gained from non-manifesting classes is always a nice, round zero
else
return 0;
}
// Item Spells
if(GetItemPossessor(GetSpellCastItem()) == oManifester)
{
if(DEBUG) SendMessageToPC(oManifester, "Item casting at level " + IntToString(GetCasterLevel(oManifester)));
return GetCasterLevel(oManifester) + nAdjust;
}
// For when you want to assign the caster level.
else if(GetLocalInt(oManifester, PRC_CASTERLEVEL_OVERRIDE) != 0)
{
if(DEBUG) SendMessageToPC(oManifester, "Forced-level manifesting at level " + IntToString(GetCasterLevel(oManifester)));
DelayCommand(1.0, DeleteLocalInt(oManifester, PRC_CASTERLEVEL_OVERRIDE));
nLevel = GetLocalInt(oManifester, PRC_CASTERLEVEL_OVERRIDE);
}
else if(GetManifestingClass(oManifester) != CLASS_TYPE_INVALID)
{
//Gets the manifesting class
int nManifestingClass = GetManifestingClass(oManifester);
// if(DEBUG) DoDebug("Manifesting class: " + IntToString(nManifestingClass), oManifester);
nLevel = GetLevelByClass(nManifestingClass, oManifester);
// Add levels from +ML PrCs only for the first manifesting class
nLevel += nManifestingClass == GetPrimaryPsionicClass(oManifester) ? GetPsionicPRCLevels(oManifester) : 0;
// Psionic vestiges are tucked in here to override things.
// This assumes that there will never be a psion with this spell effect manifesting things
if (nManifestingClass == CLASS_TYPE_PSION && GetHasSpellEffect(VESTIGE_ARETE, oManifester) && !nMaxPowerLevel)
{
nLevel = GetLocalInt(oManifester, "AretePsion");
nMaxPowerLevel = TRUE;
}
if (nManifestingClass == CLASS_TYPE_PSION && GetHasSpellEffect(VESTIGE_THETRIAD, oManifester) && !nMaxPowerLevel)
{
nLevel = GetLocalInt(oManifester, "TheTriadPsion");
nMaxPowerLevel = TRUE;
}
if (nManifestingClass == CLASS_TYPE_PSION && GetHasSpellEffect(VESTIGE_ABYSM, oManifester) && !nMaxPowerLevel)
{
nLevel = GetLocalInt(oManifester, "AbysmPsion");
nMaxPowerLevel = TRUE;
}
// This is for learning powers, we need to ignore some adjustments
if (nMaxPowerLevel) return nLevel;
nLevel += PracticedManifesting(oManifester, nManifestingClass, nLevel); //gotta be the last one
// if(DEBUG) DoDebug("Level gotten via GetLevelByClass: " + IntToString(nLevel), oManifester);
}
// If you have a primary psionic class and no manifester level yet, get levels based on that
if (GetPrimaryPsionicClass(oManifester) && nLevel == 0)
{
int nClass = GetPrimaryPsionicClass(oManifester);
nLevel = GetLevelByClass(nClass, oManifester);
nLevel += GetPsionicPRCLevels(oManifester);
nLevel += PracticedManifesting(oManifester, nClass, nLevel); //gotta be the last one
}
// If everything else fails, you are not a manifester
if(nLevel == 0)
{
if(DEBUG) DoDebug("Failed to get manifester level for creature " + DebugObject2Str(oManifester) + ", using first class slot");
//else WriteTimestampedLogEntry("Failed to get manifester level for creature " + DebugObject2Str(oManifester) + ", using first class slot");
return 0;
}
// The bonuses inside only apply to normal manifestation
if(!GetLocalInt(oManifester, PRC_IS_PSILIKE))
{
//Adding wild surge
int nSurge = GetWildSurge(oManifester);
if (nSurge > 0) nLevel += nSurge;
// Adding overchannel
int nOverchannel = GetLocalInt(oManifester, PRC_OVERCHANNEL);
if(nOverchannel > 0) nLevel += nOverchannel;
// Adding Soul Manifester
nLevel += Soulcaster(oManifester, PRCGetSpellId());
}
nLevel += nAdjust;
// This spam is technically no longer necessary once the manifester level getting mechanism has been confirmed to work
// if(DEBUG) FloatingTextStringOnCreature("Manifester Level: " + IntToString(nLevel), oManifester, FALSE);
return nLevel;
}
int GetHighestManifesterLevel(object oCreature)
{
int n = 0;
int nHighest;
int nTemp;
while(n <= 8)
{
if(GetClassByPosition(n, oCreature) != CLASS_TYPE_INVALID)
{
nTemp = GetManifesterLevel(oCreature, GetClassByPosition(n, oCreature));
if(nTemp > nHighest)
nHighest = nTemp;
}
n++;
}
return nHighest;
}
/* int GetHighestManifesterLevel(object oCreature)
{
return max(max(GetClassByPosition(1, oCreature) != CLASS_TYPE_INVALID ? GetManifesterLevel(oCreature, GetClassByPosition(1, oCreature)) : 0,
GetClassByPosition(2, oCreature) != CLASS_TYPE_INVALID ? GetManifesterLevel(oCreature, GetClassByPosition(2, oCreature)) : 0
),
GetClassByPosition(3, oCreature) != CLASS_TYPE_INVALID ? GetManifesterLevel(oCreature, GetClassByPosition(3, oCreature)) : 0
);
} */
int GetPowerLevel(object oManifester)
{
return GetLocalInt(oManifester, PRC_POWER_LEVEL);
}
int GetAbilityScoreOfClass(object oManifester, int nClass)
{
return GetAbilityScore(oManifester, GetAbilityOfClass(nClass));
}
int GetManifestingClass(object oManifester = OBJECT_SELF)
{
return GetLocalInt(oManifester, PRC_MANIFESTING_CLASS) - 1;
}
int GetAbilityOfClass(int nClass)
{
switch(nClass)
{
case CLASS_TYPE_DIAMOND_DRAGON:
case CLASS_TYPE_PSION:
case CLASS_TYPE_PSYCHIC_ROGUE:
return ABILITY_INTELLIGENCE;
case CLASS_TYPE_PSYWAR:
case CLASS_TYPE_FIST_OF_ZUOKEN:
case CLASS_TYPE_WARMIND:
return ABILITY_WISDOM;
case CLASS_TYPE_WILDER:
return ABILITY_CHARISMA;
}
// If there's no class, it's racial. Use Charisma
return ABILITY_CHARISMA;
}
int GetPrimaryPsionicClass(object oCreature = OBJECT_SELF)
{
int nClass;
if(GetPRCSwitch(PRC_CASTERLEVEL_FIRST_CLASS_RULE))
{
int iPsionicPos = GetFirstPsionicClassPosition(oCreature);
if (!iPsionicPos) return CLASS_TYPE_INVALID; // no Psionic casting class
nClass = GetClassByPosition(iPsionicPos, oCreature);
}
else
{
int nClassLvl;
int nClass1, nClass2, nClass3, nClass4, nClass5, nClass6, nClass7, nClass8;
int nClass1Lvl, nClass2Lvl, nClass3Lvl, nClass4Lvl, nClass5Lvl, nClass6Lvl, nClass7Lvl, nClass8Lvl;
nClass1 = GetClassByPosition(1, oCreature);
nClass2 = GetClassByPosition(2, oCreature);
nClass3 = GetClassByPosition(3, oCreature);
nClass4 = GetClassByPosition(4, oCreature);
nClass5 = GetClassByPosition(5, oCreature);
nClass6 = GetClassByPosition(6, oCreature);
nClass7 = GetClassByPosition(7, oCreature);
nClass8 = GetClassByPosition(8, oCreature);
if(GetIsPsionicClass(nClass1)) nClass1Lvl = GetLevelByClass(nClass1, oCreature);
if(GetIsPsionicClass(nClass2)) nClass2Lvl = GetLevelByClass(nClass2, oCreature);
if(GetIsPsionicClass(nClass3)) nClass3Lvl = GetLevelByClass(nClass3, oCreature);
if(GetIsPsionicClass(nClass4)) nClass4Lvl = GetLevelByClass(nClass4, oCreature);
if(GetIsPsionicClass(nClass5)) nClass5Lvl = GetLevelByClass(nClass5, oCreature);
if(GetIsPsionicClass(nClass6)) nClass6Lvl = GetLevelByClass(nClass6, oCreature);
if(GetIsPsionicClass(nClass7)) nClass7Lvl = GetLevelByClass(nClass7, oCreature);
if(GetIsPsionicClass(nClass8)) nClass8Lvl = GetLevelByClass(nClass8, oCreature);
nClass = nClass1;
nClassLvl = nClass1Lvl;
if(nClass2Lvl > nClassLvl)
{
nClass = nClass2;
nClassLvl = nClass2Lvl;
}
if(nClass3Lvl > nClassLvl)
{
nClass = nClass3;
nClassLvl = nClass3Lvl;
}
if(nClass4Lvl > nClassLvl)
{
nClass = nClass4;
nClassLvl = nClass4Lvl;
}
if(nClass5Lvl > nClassLvl)
{
nClass = nClass5;
nClassLvl = nClass5Lvl;
}
if(nClass6Lvl > nClassLvl)
{
nClass = nClass6;
nClassLvl = nClass6Lvl;
}
if(nClass7Lvl > nClassLvl)
{
nClass = nClass7;
nClassLvl = nClass7Lvl;
}
if(nClass8Lvl > nClassLvl)
{
nClass = nClass8;
nClassLvl = nClass8Lvl;
}
if(nClassLvl == 0)
nClass = CLASS_TYPE_INVALID;
}
return nClass;
}
//:: [PRC .35] This needs to be updated for marker feats.
int GetPsionicPRCLevels(object oCreature)
{
int nLevel = 0;
// Cerebremancer and Psychic Theurge add manifester levels on each level
nLevel += GetLevelByClass(CLASS_TYPE_CEREBREMANCER, oCreature);
nLevel += GetLevelByClass(CLASS_TYPE_PSYCHIC_THEURGE, oCreature);
if (GetFirstPsionicClassPosition(oCreature)) nLevel += GetLevelByClass(CLASS_TYPE_SOULCASTER, oCreature);
// No manifester level boost at level 1 and 10 for Thrallherd
if(GetLevelByClass(CLASS_TYPE_THRALLHERD, oCreature))
{
nLevel += GetLevelByClass(CLASS_TYPE_THRALLHERD, oCreature) - 1;
if(GetLevelByClass(CLASS_TYPE_THRALLHERD, oCreature) >= 10) nLevel -= 1;
}
// No manifester level boost at levels 2, 5 and 8 for Shadow Mind
if(GetLevelByClass(CLASS_TYPE_SHADOWMIND, oCreature))
{
nLevel += GetLevelByClass(CLASS_TYPE_SHADOWMIND, oCreature);
if(GetLevelByClass(CLASS_TYPE_SHADOWMIND, oCreature) >= 2) nLevel -= 1;
if(GetLevelByClass(CLASS_TYPE_SHADOWMIND, oCreature) >= 5) nLevel -= 1;
if(GetLevelByClass(CLASS_TYPE_SHADOWMIND, oCreature) >= 8) nLevel -= 1;
}
// No manifester level boost at level 1 and 6 for Iron Mind
if(GetLevelByClass(CLASS_TYPE_IRONMIND, oCreature))
{
nLevel += GetLevelByClass(CLASS_TYPE_IRONMIND, oCreature) - 1;
if(GetLevelByClass(CLASS_TYPE_IRONMIND, oCreature) >= 6) nLevel -= 1;
}
// No manifester level boost at level 1 and 6 for Diamond Dragon
if(GetLevelByClass(CLASS_TYPE_DIAMOND_DRAGON, oCreature))
{
nLevel += GetLevelByClass(CLASS_TYPE_DIAMOND_DRAGON, oCreature) - 1;
if(GetLevelByClass(CLASS_TYPE_DIAMOND_DRAGON, oCreature) >= 6) nLevel -= 1;
}
// No manifester level boost at level 1 for Sanctified Mind
if(GetLevelByClass(CLASS_TYPE_SANCTIFIED_MIND, oCreature))
{
nLevel += GetLevelByClass(CLASS_TYPE_SANCTIFIED_MIND, oCreature) - 1;
}
return nLevel;
}
int GetFirstPsionicClassPosition(object oCreature = OBJECT_SELF)
{
if (GetIsPsionicClass(GetClassByPosition(1, oCreature)))
return 1;
if (GetIsPsionicClass(GetClassByPosition(2, oCreature)))
return 2;
if (GetIsPsionicClass(GetClassByPosition(3, oCreature)))
return 3;
if (GetIsPsionicClass(GetClassByPosition(4, oCreature)))
return 4;
if (GetIsPsionicClass(GetClassByPosition(5, oCreature)))
return 5;
if (GetIsPsionicClass(GetClassByPosition(6, oCreature)))
return 6;
if (GetIsPsionicClass(GetClassByPosition(7, oCreature)))
return 7;
if (GetIsPsionicClass(GetClassByPosition(8, oCreature)))
return 8;
return 0;
}
int GetIsPsionicClass(int nClass)
{
return (nClass==CLASS_TYPE_PSION
|| nClass==CLASS_TYPE_PSYWAR
|| nClass==CLASS_TYPE_PSYCHIC_ROGUE
|| nClass==CLASS_TYPE_WILDER
|| nClass==CLASS_TYPE_FIST_OF_ZUOKEN
|| nClass==CLASS_TYPE_WARMIND
);
}
int GetWildSurge(object oManifester)
{
int nWildSurge = GetLocalInt(oManifester, PRC_IS_PSILIKE) ?
0 : // Wild Surge does not apply to psi-like abilities
GetLocalInt(oManifester, PRC_WILD_SURGE);
if(DEBUG) DoDebug("GetWildSurge():\n"
+ "oManifester = " + DebugObject2Str(oManifester) + "\n"
+ "nWildSurge = " + IntToString(nWildSurge) + "\n"
);
return nWildSurge;
}
int GetMaxPowerLevel(object oManifester)
{
int nClass = GetPrimaryPsionicClass(oManifester);
string sFile = GetAMSKnownFileName(nClass);
int nLevel = GetHighestManifesterLevel(oManifester);
int nMax = StringToInt(Get2DACache(sFile, "MaxPowerLevel", nLevel));
if (DEBUG) DoDebug("GetMaxPowerLevel is "+IntToString(nMax));
return nMax;
}