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.
1313 lines
50 KiB
Plaintext
1313 lines
50 KiB
Plaintext
//::///////////////////////////////////////////////
|
|
//:: 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;
|
|
} |