forked from Jaysyn/PRC8
750 lines
33 KiB
Plaintext
750 lines
33 KiB
Plaintext
/**
|
|
* @file
|
|
* This file contains SPApplyEffectToObject(). This was in inc_dispel, but that include should only be in
|
|
* dispel-type spells and not the core spell engine.
|
|
*/
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Function prototypes */
|
|
//////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Gets a creature that can apply an effect
|
|
* Useful to apply/remove specific effects rather than using spellID
|
|
* Remember to assigncommand the effect creation
|
|
*/
|
|
object GetObjectToApplyNewEffect(string sTag, object oPC, int nStripEffects = TRUE);
|
|
|
|
/**
|
|
* A wrapper for ApplyEffectToObject() that takes PRC feats into account.
|
|
*
|
|
* @param nDurationType One of the DURATION_TYPE_* constants
|
|
* @param eEffect The effect to apply
|
|
* @param oTarget The target of the effect
|
|
* @param fDuration The duration for temporary effects
|
|
* @param bDispellable TRUE if the effect should be dispellable, else FALSE
|
|
* @param nSpellID The Spell ID of the spell applying the effect. If default is used,
|
|
* PRCGetSpellId() is used internally to get the spell ID.
|
|
* @param nCasterLevel The caster level that the spell is cast with. If default is used,
|
|
* PRCGetCasterLevel() is used internally to get the caster level.
|
|
* @param oCaster The spell caster.
|
|
*/
|
|
void SPApplyEffectToObject(int nDurationType, effect eEffect, object oTarget, float fDuration = 0.0f,
|
|
int bDispellable = TRUE, int nSpellID = -1, int nCasterLevel = -1, object oCaster = OBJECT_SELF);
|
|
|
|
/**
|
|
* Removes all effects from target that are due to the given spell.
|
|
*
|
|
* Removes all effects caused by the spell nID regardless of caster. By
|
|
* default only removes magical effects.
|
|
*
|
|
* @author Georg Zoeller (presumably copied from a bio script somewhere)
|
|
*
|
|
* @param nID The spell ID whose effects to remove.
|
|
* @param oTarget The object to remove the effects from.
|
|
* @param bMagicalEffectsOnly Whether to remove only magical effects (TRUE, the default)
|
|
* or all effects (FALSE)
|
|
*/
|
|
void GZPRCRemoveSpellEffects(int nID,object oTarget, int bMagicalEffectsOnly = TRUE);
|
|
|
|
/**
|
|
* Tests to make sure the data in the effect arrays still refers to an actual effect.
|
|
*
|
|
* Called from withing ReorderEffects() and DispelMagicBestMod() (in inc_dispel). It's purpose
|
|
* is to verify that the effect referred to by an entry in the 3 arrays is still in effect, in
|
|
* case it has been dispelled or run out its duration since the data was put there.
|
|
*
|
|
* @param nSpellID SpellID of the effect to test
|
|
* @param oCaster Caster of the spell that caused the effectbeing tested
|
|
* @param oTarget The object whose effect arrays are being looked at.
|
|
*
|
|
* @return TRUE if the effect is still active, otherwise FALSE.
|
|
*/
|
|
int IsStillRealEffect(int nSpellID, object oCaster, object oTarget);
|
|
|
|
/**
|
|
* Checks if target is a Frenzied Bersker with Deathless Frenzy Active
|
|
* If so removes immortality flag so that the death effect from a
|
|
* Death Spell can kill them
|
|
*
|
|
* @param oTarget Creature to test for Deathless Frenzy
|
|
*/
|
|
void DeathlessFrenzyCheck(object oTarget);
|
|
|
|
// * Searchs through a persons effects and removes those from a particular spell by a particular caster.
|
|
// * PRC Version of a Bioware function to disable include loops
|
|
void PRCRemoveSpellEffects(int nSpell_ID, object oCaster, object oTarget);
|
|
|
|
/**
|
|
* Dazzles the target: -1 Attack, Search, Spot, and VFX
|
|
*
|
|
* @return the Dazzle effect
|
|
*/
|
|
effect EffectDazzle();
|
|
|
|
/**
|
|
* Shaken effect: -2 to attack, all skills and saving throws
|
|
*
|
|
* @return the Shaken effect
|
|
*/
|
|
effect EffectShaken();
|
|
|
|
/**
|
|
* Fatigue effect: -2 to Strength and Dexterity, 25% speed decrease. Can't be dispelled.
|
|
*
|
|
* @return the Fatigue effect
|
|
*/
|
|
effect EffectFatigue();
|
|
|
|
/**
|
|
* Exhausted effect: -6 to Strength and Dexterity, 50% speed decrease. Can't be dispelled.
|
|
*
|
|
* @return the Exhausted effect
|
|
*/
|
|
effect EffectExhausted();
|
|
|
|
/**
|
|
* Cowering effect: -2 to AC, takes no actions (dazed)
|
|
*
|
|
* @return the Cowering effect
|
|
*/
|
|
effect EffectCowering();
|
|
|
|
/**
|
|
* Sickened effect: -2 to attack, damage, all skills, ability checks and saving throws
|
|
*
|
|
* @return the Sickened effect
|
|
*/
|
|
effect EffectSickened();
|
|
|
|
/**
|
|
* Nausea effect: Nauseated creatures are unable to attack, cast spells, concentrate on spells, or do anything
|
|
* else requiring attention. The only action such a character can take is a single move action per turn.
|
|
* This function takes a duration and target because it sets the enemy's number of attacks in a round to 1
|
|
* Which means once it's called, the BAB effect is applied
|
|
*
|
|
* @return the Nausea effect
|
|
*/
|
|
effect EffectNausea(object oTarget, float fDur);
|
|
|
|
/**
|
|
* Fascinate effect: charmed, -4 to Listen and Spot
|
|
*
|
|
* @return the Fascinate effect
|
|
*/
|
|
effect EffectFascinate();
|
|
|
|
/**
|
|
* It's Confused, as per normal
|
|
*
|
|
* @return the Confused effect
|
|
*/
|
|
effect PRCEffectConfused();
|
|
|
|
/**
|
|
* It's EffectHeal, but allows us to manipulate the HP total healed
|
|
*
|
|
* @return the Heal effect
|
|
*/
|
|
effect PRCEffectHeal(int nHP, object oTarget);
|
|
|
|
/**
|
|
* Creates skill bonus for all skills based on particular ability.
|
|
* Should be updated if skills.2da file was edited.
|
|
*
|
|
* @param iAbility base ability
|
|
* @param iIncrease bonus applied to each skill
|
|
*
|
|
* @return Skill increase
|
|
*/
|
|
effect EffectAbilityBasedSkillIncrease(int iAbility, int iIncrease = 1);
|
|
|
|
/**
|
|
* Creates skill penalty for all skills based on particular ability
|
|
* Should be updated if skills.2da file was edited.
|
|
*
|
|
* @param iAbility base ability
|
|
* @param iDecrease penalty applied to each skill
|
|
*
|
|
* @return Skill decrease
|
|
*/
|
|
effect EffectAbilityBasedSkillDecrease(int iAbility, int iDecrease = 1);
|
|
|
|
//ebonfowl: adding this function to check if a target is already shaken
|
|
int GetIsShaken(object oTarget);
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Include section */
|
|
//////////////////////////////////////////////////
|
|
|
|
#include "prc_inc_castlvl" // get prc_racial_const, prc_inc_nwscript, prc_inc_newip
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Internal functions */
|
|
//////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Cleans up the 3 arrays used to store effect information on the object.
|
|
*
|
|
* Goes through the whole 3 stored lists of caster levels, spell id's, and casters,
|
|
* deletes any that aren't real anymore (refer to an effect no longer present), then
|
|
* builds a new list out of the ones that are still real/current (refer to effects that
|
|
* are still present)
|
|
* Thus, the list gets cleaned up every time it is added to.
|
|
*
|
|
* @param nSpellID Spell ID of the spell being cast.
|
|
* @param oTarget Object to modify the effect arrays of.
|
|
* @param oCaster The caster of the spell.
|
|
*
|
|
* @return The number of effects in the 3 new arrays
|
|
*/
|
|
int _ReorderEffects(int nSpellID, object oTarget, object oCaster = OBJECT_SELF){
|
|
int nIndex = GetLocalInt(oTarget, "X2_Effects_Index_Number");
|
|
int nEffectCastLevel;
|
|
int nEffectSpellID;
|
|
object oEffectCaster;
|
|
int nWeave ;
|
|
int nRealIndex = 0;
|
|
int nPlace;
|
|
|
|
for(nPlace = 0; nPlace <= nIndex; nPlace++)
|
|
{
|
|
nEffectSpellID = GetLocalInt(oTarget, " X2_Effect_Spell_ID_" + IntToString(nPlace));
|
|
oEffectCaster = GetLocalObject(oTarget, " X2_Effect_Caster_" + IntToString(nPlace));
|
|
nEffectCastLevel = GetLocalInt(oTarget, " X2_Effect_Cast_Level_" + IntToString(nPlace));
|
|
nWeave = GetLocalInt(oTarget, " X2_Effect_Weave_ID_" + IntToString(nPlace));
|
|
|
|
DeleteLocalInt(oTarget, " X2_Effect_Spell_ID_" + IntToString(nPlace));
|
|
DeleteLocalInt(oTarget, " X2_Effect_Cast_Level_" + IntToString(nPlace));
|
|
DeleteLocalObject(oTarget, " X2_Effect_Caster_" + IntToString(nPlace));
|
|
DeleteLocalInt(oTarget, " X2_Effect_Weave_ID_" + IntToString(nPlace));
|
|
if(IsStillRealEffect(nEffectSpellID, oEffectCaster, oTarget))
|
|
{
|
|
if(nEffectSpellID != nSpellID || oEffectCaster != oCaster)
|
|
// Take it out of the list if it's the spell now being cast, and by the same caster
|
|
// This way spells that don't self dispel when they're recast don't flood the list.
|
|
{
|
|
SetLocalInt(oTarget, " X2_Effect_Spell_ID_" + IntToString(nRealIndex), nEffectSpellID);
|
|
SetLocalInt(oTarget, " X2_Effect_Cast_Level_" + IntToString(nRealIndex), nEffectCastLevel);
|
|
SetLocalObject(oTarget, " X2_Effect_Caster_" + IntToString(nRealIndex),oEffectCaster );
|
|
SetLocalInt(oTarget, " X2_Effect_Weave_ID_" + IntToString(nRealIndex),nWeave);
|
|
nRealIndex++;
|
|
}// end of if is the same as the current spell and caster
|
|
}// end of if is valid effect statement
|
|
}// end of for statement
|
|
return nRealIndex; // This is the number of values currently in all 3 arrays -1.
|
|
}// end of function
|
|
|
|
//////////////////////////////////////////////////
|
|
/* Function Definitions */
|
|
//////////////////////////////////////////////////
|
|
|
|
object GetObjectToApplyNewEffect(string sTag, object oPC, int nStripEffects = TRUE){
|
|
object oWP = GetObjectByTag(sTag);
|
|
object oLimbo = GetObjectByTag("HEARTOFCHAOS");
|
|
location lLimbo = GetLocation(oLimbo);
|
|
if(!GetIsObjectValid(oLimbo))
|
|
lLimbo = GetStartingLocation();
|
|
//not valid, create it
|
|
if(!GetIsObjectValid(oWP))
|
|
{
|
|
//has to be a creature so it can be jumped around
|
|
//re-used the 2da cache blueprint since it has no scripts
|
|
oWP = CreateObject(OBJECT_TYPE_CREATURE, "prc_2da_cache", lLimbo, FALSE, sTag);
|
|
}
|
|
if(!GetIsObjectValid(oWP)
|
|
&& DEBUG)
|
|
{
|
|
DoDebug(sTag+" is not valid");
|
|
}
|
|
//make sure the player can never interact with WP
|
|
SetPlotFlag(oWP, TRUE);
|
|
SetCreatureAppearanceType(oWP, APPEARANCE_TYPE_INVISIBLE_HUMAN_MALE);
|
|
ApplyEffectToObject(DURATION_TYPE_PERMANENT, EffectVisualEffect(VFX_DUR_CUTSCENE_INVISIBILITY), oWP);
|
|
ApplyEffectToObject(DURATION_TYPE_PERMANENT, EffectCutsceneGhost(), oWP);
|
|
//remove previous effects
|
|
if(nStripEffects)
|
|
{
|
|
effect eTest = GetFirstEffect(oPC);
|
|
while(GetIsEffectValid(eTest))
|
|
{
|
|
if(GetEffectCreator(eTest) == oWP
|
|
&& GetEffectSubType(eTest) == SUBTYPE_SUPERNATURAL)
|
|
{
|
|
if(DEBUG) DoDebug("Stripping previous effect");
|
|
RemoveEffect(oPC, eTest);
|
|
}
|
|
eTest = GetNextEffect(oPC);
|
|
}
|
|
}
|
|
//jump to PC
|
|
//must be in same area to apply effect
|
|
if(GetArea(oWP) != GetArea(oPC))
|
|
AssignCommand(oWP,
|
|
ActionJumpToObject(oPC));
|
|
//jump back to limbo afterwards
|
|
DelayCommand(0.1,
|
|
AssignCommand(oWP,
|
|
ActionJumpToObject(oLimbo)));
|
|
return oWP;
|
|
}
|
|
|
|
void SPApplyEffectToObject(int nDurationType, effect eEffect, object oTarget, float fDuration = 0.0f,
|
|
int bDispellable = TRUE, int nSpellID = -1, int nCasterLevel = -1, object oCaster = OBJECT_SELF)
|
|
{
|
|
if (-1 == nSpellID) nSpellID = PRCGetSpellId();
|
|
|
|
//if it was cast from the new spellbook, remove previous effects
|
|
//if(GetLocalInt(OBJECT_SELF, "UsingActionCastSpell"))
|
|
// GZPRCRemoveSpellEffects(nSpellID, oTarget);
|
|
|
|
//Fearsome Necromancy check
|
|
if(GetHasFeat(FEAT_FEARSOME_NECROMANCY, oCaster))
|
|
{
|
|
if(GetSpellSchool(nSpellID) == SPELL_SCHOOL_NECROMANCY)
|
|
{
|
|
if(GetIsEnemy(oTarget, oCaster)
|
|
&& !GetIsImmune(oTarget, IMMUNITY_TYPE_MIND_SPELLS))
|
|
{
|
|
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectShaken(), oTarget, 6.0);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Illusion Veil Meld
|
|
if(GetHasSpellEffect(MELD_ILLUSION_VEIL, oCaster) && GetSpellSchool(nSpellID) == SPELL_SCHOOL_ILLUSION)
|
|
fDuration += GetEssentiaInvested(oCaster, MELD_ILLUSION_VEIL) * 6.0;
|
|
|
|
//Eldritch Spellweave
|
|
if(GetIsObjectValid(GetLocalObject(oCaster, "SPELLWEAVE_TARGET")))
|
|
ExecuteScript("inv_splweave", oCaster);
|
|
|
|
// Instant duration effects can use BioWare code, the PRC code doesn't care about those
|
|
if(DURATION_TYPE_INSTANT == nDurationType)
|
|
ApplyEffectToObject(nDurationType, eEffect, oTarget, fDuration);
|
|
else
|
|
{
|
|
// Extraordinary/Supernatural effects are not supposed to be dispellable.
|
|
if (GetEffectSubType(eEffect) == SUBTYPE_EXTRAORDINARY
|
|
|| GetEffectSubType(eEffect) == SUBTYPE_SUPERNATURAL)
|
|
{
|
|
bDispellable = FALSE;
|
|
}
|
|
|
|
// We need the extra arguments for the PRC code, get them if defaults were passed in.
|
|
if (-1 == nCasterLevel) nCasterLevel = PRCGetCasterLevel(oCaster);
|
|
|
|
// Invoke the PRC apply function passing the extra data.
|
|
int nIndex = _ReorderEffects(nSpellID, oTarget, oCaster);
|
|
// Add this new effect to the slot after the last effect already on the character.
|
|
|
|
//check if Master's Gift applies
|
|
if(GetHasFeat(FEAT_MASTERS_GIFT, oTarget) && GetIsArcaneClass(PRCGetLastSpellCastClass(), oCaster))
|
|
{
|
|
if(!StringToInt(Get2DACache("spells", "HostileSetting", nSpellID)))
|
|
fDuration *= 2;
|
|
}
|
|
|
|
ApplyEffectToObject(nDurationType, eEffect, oTarget, fDuration);
|
|
// may have code traverse the lists right here and not add the new effect
|
|
// if an identical one already appears in the list somewhere
|
|
|
|
SetLocalInt(oTarget, " X2_Effect_Spell_ID_" + IntToString(nIndex), nSpellID);
|
|
SetLocalInt(oTarget, " X2_Effect_Cast_Level_" + IntToString(nIndex), nCasterLevel);
|
|
SetLocalObject(oTarget, " X2_Effect_Caster_" + IntToString(nIndex), oCaster );
|
|
if(GetHasFeat(FEAT_SHADOWWEAVE, oCaster))
|
|
SetLocalInt(oTarget, " X2_Effect_Weave_ID_" + IntToString(nIndex), GetHasFeat(FEAT_TENACIOUSMAGIC,oCaster));
|
|
else
|
|
SetLocalInt(oTarget, " X2_Effect_Weave_ID_" + IntToString(nIndex), 0);
|
|
|
|
//nIndex++;
|
|
/// Set new index number to the character.
|
|
SetLocalInt(oTarget, "X2_Effects_Index_Number", nIndex);
|
|
}
|
|
}
|
|
|
|
void GZPRCRemoveSpellEffects(int nID,object oTarget, int bMagicalEffectsOnly = TRUE){
|
|
effect eEff = GetFirstEffect(oTarget);
|
|
while (GetIsEffectValid(eEff))
|
|
{
|
|
if (GetEffectSpellId(eEff) == nID)
|
|
{
|
|
if (GetEffectSubType(eEff) != SUBTYPE_MAGICAL && bMagicalEffectsOnly)
|
|
{
|
|
// ignore
|
|
}
|
|
else
|
|
{
|
|
RemoveEffect(oTarget,eEff);
|
|
}
|
|
}
|
|
eEff = GetNextEffect(oTarget);
|
|
}
|
|
}
|
|
|
|
int IsStillRealEffect(int nSpellID, object oCaster, object oTarget){
|
|
if(!GetHasSpellEffect(nSpellID, oTarget) || nSpellID == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
effect eTestSubject = GetFirstEffect(oTarget);
|
|
while(GetIsEffectValid(eTestSubject))
|
|
{
|
|
if(GetEffectSpellId(eTestSubject) == nSpellID)
|
|
{
|
|
if(GetEffectCreator(eTestSubject) == oCaster)
|
|
{
|
|
return TRUE;
|
|
}// end of if originates from oCaster.
|
|
}// end if originates from nSpellID.
|
|
eTestSubject = GetNextEffect(oTarget);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void DeathlessFrenzyCheck(object oTarget)
|
|
{
|
|
//if its immune to death, e.g via items
|
|
//then dont do this
|
|
if(GetIsImmune( oTarget, IMMUNITY_TYPE_DEATH))
|
|
return;
|
|
if(GetHasFeat(FEAT_DEATHLESS_FRENZY, oTarget)
|
|
&& GetHasFeatEffect(FEAT_FRENZY, oTarget)
|
|
&& GetImmortal(oTarget))
|
|
SetImmortal(oTarget, FALSE);
|
|
//mark them as being magically killed for death system
|
|
if(GetPRCSwitch(PRC_PNP_DEATH_ENABLE))
|
|
{
|
|
SetLocalInt(oTarget, "PRC_PNP_EfectDeathApplied",
|
|
GetLocalInt(oTarget, "PRC_PNP_EfectDeathApplied")+1);
|
|
AssignCommand(oTarget,
|
|
DelayCommand(1.0,
|
|
SetLocalInt(oTarget, "PRC_PNP_EfectDeathApplied",
|
|
GetLocalInt(oTarget, "PRC_PNP_EfectDeathApplied")-1)));
|
|
}
|
|
}
|
|
|
|
void PRCRemoveSpellEffects(int nSpell_ID, object oCaster, object oTarget){
|
|
//Declare major variables
|
|
int bValid = FALSE;
|
|
effect eAOE;
|
|
if(GetHasSpellEffect(nSpell_ID, oTarget))
|
|
{
|
|
//Search through the valid effects on the target.
|
|
eAOE = GetFirstEffect(oTarget);
|
|
while (GetIsEffectValid(eAOE) && bValid == FALSE)
|
|
{
|
|
if (GetEffectCreator(eAOE) == oCaster)
|
|
{
|
|
//If the effect was created by the spell then remove it
|
|
if(GetEffectSpellId(eAOE) == nSpell_ID)
|
|
{
|
|
RemoveEffect(oTarget, eAOE);
|
|
bValid = TRUE;
|
|
}
|
|
}
|
|
//Get next effect on the target
|
|
eAOE = GetNextEffect(oTarget);
|
|
}
|
|
}
|
|
}
|
|
|
|
// The creature is unable to see well because of overstimulation of the eyes. A dazzled
|
|
// creature takes a -1 penalty on attack rolls, Search checks, and Spot checks.
|
|
effect EffectDazzle(){
|
|
effect eBlank;
|
|
if (GetRacialType(PRCGetSpellTargetObject()) == RACIAL_TYPE_BHUKA) return eBlank;
|
|
|
|
effect eReturn = EffectLinkEffects(EffectAttackDecrease(1), EffectSkillDecrease(SKILL_SEARCH, 1));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_SPOT, 1));
|
|
eReturn = TagEffect(eReturn, "PRCDazzle");
|
|
return eReturn;
|
|
}
|
|
|
|
// A shaken character takes a -2 penalty on attack rolls, saving throws, skill checks,
|
|
// and ability checks.
|
|
// Shaken is a less severe state of fear than frightened or panicked.
|
|
effect EffectShaken(){
|
|
effect eBlank;
|
|
if (GetRacialType(PRCGetSpellTargetObject()) == RACIAL_TYPE_KRINTH) return eBlank;
|
|
|
|
effect eReturn = EffectVisualEffect(VFX_DUR_MIND_AFFECTING_FEAR);
|
|
eReturn = EffectLinkEffects(eReturn, EffectAttackDecrease(2));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSavingThrowDecrease(SAVING_THROW_ALL,2));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_ALL_SKILLS, 2));
|
|
eReturn = TagEffect(eReturn, "PRCShaken");
|
|
return eReturn;
|
|
}
|
|
|
|
// A fatigued character can neither run nor charge and takes a -2 penalty to Strength
|
|
// and Dexterity. Doing anything that would normally cause fatigue causes the fatigued
|
|
// character to become exhausted. After 8 hours of complete rest, fatigued characters
|
|
// are no longer fatigued.
|
|
effect EffectFatigue(){
|
|
effect eBlank;
|
|
if (GetLevelByClass(CLASS_TYPE_BATTLESMITH, PRCGetSpellTargetObject()) >= 3) return eBlank;
|
|
|
|
effect eReturn = EffectAbilityDecrease(ABILITY_STRENGTH, 2);
|
|
eReturn = EffectLinkEffects(eReturn, EffectAbilityDecrease(ABILITY_DEXTERITY, 2));
|
|
eReturn = EffectLinkEffects(eReturn, EffectMovementSpeedDecrease(25));
|
|
eReturn = TagEffect(eReturn, "PRCFatigue");
|
|
return eReturn;
|
|
}
|
|
|
|
// An exhausted character moves at half speed and takes a -6 penalty to Strength and
|
|
// Dexterity. After 1 hour of complete rest, an exhausted character becomes fatigued.
|
|
// A fatigued character becomes exhausted by doing something else that would normally
|
|
// cause fatigue.
|
|
effect EffectExhausted(){
|
|
effect eBlank;
|
|
if (GetLevelByClass(CLASS_TYPE_BATTLESMITH, PRCGetSpellTargetObject()) >= 3) return eBlank;
|
|
|
|
if (GetLocalInt(PRCGetSpellTargetObject(), "IncarnumDefenseLE")) return EffectFatigue();
|
|
|
|
effect eReturn = EffectAbilityDecrease(ABILITY_STRENGTH, 6);
|
|
eReturn = EffectLinkEffects(eReturn, EffectAbilityDecrease(ABILITY_DEXTERITY, 6));
|
|
eReturn = EffectLinkEffects(eReturn, EffectMovementSpeedDecrease(50));
|
|
eReturn = TagEffect(eReturn, "PRCExhausted");
|
|
return eReturn;
|
|
}
|
|
|
|
// The character is frozen in fear and can take no actions. A cowering character takes
|
|
// a -2 penalty to Armor Class and loses her Dexterity bonus (if any).
|
|
effect EffectCowering(){
|
|
effect eReturn = EffectACDecrease(2);
|
|
eReturn = EffectLinkEffects(eReturn, EffectDazed());
|
|
eReturn = TagEffect(eReturn, "PRCCowering");
|
|
return eReturn;
|
|
}
|
|
|
|
// The character takes a -2 penalty on all attack rolls, weapon damage rolls, saving
|
|
// throws, skill checks, and ability checks.
|
|
effect EffectSickened(){
|
|
effect eBlank;
|
|
if (GetHasFeat(FEAT_STRONG_STOMACH, PRCGetSpellTargetObject())) return eBlank;
|
|
|
|
if(GetHasSpellEffect(MELD_PAULDRONS_OF_HEALTH, PRCGetSpellTargetObject())) return eBlank;
|
|
|
|
effect eReturn = EffectAttackDecrease(2);
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageDecrease(2, DAMAGE_TYPE_BLUDGEONING|DAMAGE_TYPE_PIERCING|DAMAGE_TYPE_SLASHING));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSavingThrowDecrease(SAVING_THROW_ALL, 2));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_ALL_SKILLS, 2));
|
|
eReturn = TagEffect(eReturn, "PRCSickened");
|
|
return eReturn;
|
|
}
|
|
|
|
// Nauseated creatures are unable to attack, cast spells, concentrate on spells, or do anything
|
|
// else requiring attention. The only action such a character can take is a single move action per turn.
|
|
effect EffectNausea(object oTarget, float fDur){
|
|
effect eBlank;
|
|
if (GetHasFeat(FEAT_STRONG_STOMACH, PRCGetSpellTargetObject())) return EffectSickened();
|
|
|
|
if(GetHasSpellEffect(MELD_PAULDRONS_OF_HEALTH, PRCGetSpellTargetObject())) return eBlank;
|
|
|
|
effect eReturn = EffectLinkEffects(EffectSpellFailure(), EffectAttackDecrease(20));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSlow());
|
|
eReturn = EffectLinkEffects(EffectVisualEffect(VFX_IMP_DISEASE_S), eReturn);
|
|
eReturn = TagEffect(eReturn, "PRCNausea");
|
|
SetBaseAttackBonus(1, oTarget);
|
|
DelayCommand(fDur, RestoreBaseAttackBonus(oTarget));
|
|
return eReturn;
|
|
}
|
|
|
|
// The creature is fascinated by a magical effect. A fascinate creature
|
|
// is charmed and takes a -4 penalty to listen and spot
|
|
effect EffectFascinate(){
|
|
effect eReturn = EffectLinkEffects(EffectCharmed(), EffectSkillDecrease(SKILL_LISTEN, 4));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_SPOT, 4));
|
|
eReturn = TagEffect(eReturn, "PRCFascinate");
|
|
return eReturn;
|
|
}
|
|
|
|
// It's just Confused
|
|
effect PRCEffectConfused()
|
|
{
|
|
effect eBlank;
|
|
if (GetLevelByClass(CLASS_TYPE_WILD_MAGE, PRCGetSpellTargetObject()) >= 6 ||
|
|
(GetHasSpellEffect(VESTIGE_DAHLVERNAR, PRCGetSpellTargetObject()) && GetLocalInt(PRCGetSpellTargetObject(), "ExploitVestige") != VESTIGE_DAHLVERNAR_MAD_SOUL)
|
|
) return eBlank;
|
|
|
|
effect eEffect = EffectConfused();
|
|
eEffect = TagEffect(eEffect, "PRCConfused");
|
|
return eEffect;
|
|
}
|
|
|
|
// It's just Healing
|
|
effect PRCEffectHeal(int nHP, object oTarget)
|
|
{
|
|
// MELD_THERAPEUTIC_MANTLE
|
|
if (GetHasSpellEffect(MELD_THERAPEUTIC_MANTLE, oTarget))
|
|
nHP += (StringToInt(Get2DACache("spells", "Innate", PRCGetSpellId())) + (GetEssentiaInvested(oTarget, MELD_THERAPEUTIC_MANTLE) * 2));
|
|
|
|
return EffectHeal(nHP);
|
|
}
|
|
|
|
effect EffectAbilityBasedSkillIncrease(int iAbility, int iIncrease = 1){
|
|
effect eReturn;
|
|
switch(iAbility)
|
|
{
|
|
case ABILITY_STRENGTH:
|
|
eReturn = EffectSkillIncrease(SKILL_DISCIPLINE, iIncrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_JUMP, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_CLIMB, iIncrease));
|
|
break;
|
|
case ABILITY_DEXTERITY:
|
|
eReturn = EffectSkillIncrease(SKILL_HIDE, iIncrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_MOVE_SILENTLY, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_OPEN_LOCK, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_SET_TRAP, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_TUMBLE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_RIDE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_BALANCE, iIncrease));
|
|
break;
|
|
case ABILITY_CONSTITUTION:
|
|
eReturn = EffectSkillIncrease(SKILL_CONCENTRATION, iIncrease);
|
|
break;
|
|
case ABILITY_INTELLIGENCE:
|
|
eReturn = EffectSkillIncrease(SKILL_DISABLE_TRAP, iIncrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_LORE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_SEARCH, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_SPELLCRAFT, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_APPRAISE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_CRAFT_TRAP, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_CRAFT_ARMOR, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_CRAFT_WEAPON, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_TRUESPEAK, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_MARTIAL_LORE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_CRAFT_ALCHEMY, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_CRAFT_POISON, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_PSICRAFT, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_CRAFT_GENERAL, iIncrease));
|
|
break;
|
|
case ABILITY_WISDOM:
|
|
eReturn = EffectSkillIncrease(SKILL_HEAL, iIncrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_LISTEN, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_SPOT, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_SENSE_MOTIVE, iIncrease));
|
|
break;
|
|
case ABILITY_CHARISMA:
|
|
eReturn = EffectSkillIncrease(SKILL_ANIMAL_EMPATHY, iIncrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_PERFORM, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_PERSUADE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_USE_MAGIC_DEVICE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_BLUFF, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_INTIMIDATE, iIncrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillIncrease(SKILL_IAIJUTSU_FOCUS, iIncrease));
|
|
break;
|
|
}
|
|
return eReturn;
|
|
}
|
|
|
|
effect EffectAbilityBasedSkillDecrease(int iAbility, int iDecrease = 1){
|
|
effect eReturn;
|
|
switch(iAbility)
|
|
{
|
|
case ABILITY_STRENGTH:
|
|
eReturn = EffectSkillDecrease(SKILL_DISCIPLINE, iDecrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_JUMP, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_CLIMB, iDecrease));
|
|
break;
|
|
case ABILITY_DEXTERITY:
|
|
eReturn = EffectSkillIncrease(SKILL_HIDE, iDecrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_MOVE_SILENTLY, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_OPEN_LOCK, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_SET_TRAP, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_TUMBLE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_RIDE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_BALANCE, iDecrease));
|
|
break;
|
|
case ABILITY_CONSTITUTION:
|
|
eReturn = EffectSkillDecrease(SKILL_CONCENTRATION, iDecrease);
|
|
break;
|
|
case ABILITY_INTELLIGENCE:
|
|
eReturn = EffectSkillDecrease(SKILL_DISABLE_TRAP, iDecrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_LORE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_SEARCH, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_SPELLCRAFT, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_APPRAISE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_CRAFT_TRAP, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_CRAFT_ARMOR, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_CRAFT_WEAPON, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_TRUESPEAK, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_MARTIAL_LORE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_CRAFT_ALCHEMY, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_CRAFT_POISON, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_PSICRAFT, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_CRAFT_GENERAL, iDecrease));
|
|
break;
|
|
case ABILITY_WISDOM:
|
|
eReturn = EffectSkillDecrease(SKILL_HEAL, iDecrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_LISTEN, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_SPOT, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_SENSE_MOTIVE, iDecrease));
|
|
break;
|
|
case ABILITY_CHARISMA:
|
|
eReturn = EffectSkillDecrease(SKILL_ANIMAL_EMPATHY, iDecrease);
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_PERFORM, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_PERSUADE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_USE_MAGIC_DEVICE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_BLUFF, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_INTIMIDATE, iDecrease));
|
|
eReturn = EffectLinkEffects(eReturn, EffectSkillDecrease(SKILL_IAIJUTSU_FOCUS, iDecrease));
|
|
break;
|
|
}
|
|
return eReturn;
|
|
}
|
|
|
|
effect EffectDamageImmunityAll(){
|
|
effect eReturn = EffectDamageImmunityIncrease(DAMAGE_TYPE_ACID, 100);
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_BLUDGEONING, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_COLD, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_DIVINE, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_ELECTRICAL, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_FIRE, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_MAGICAL, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_NEGATIVE, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_PIERCING, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_POSITIVE, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_SLASHING, 100));
|
|
eReturn = EffectLinkEffects(eReturn, EffectDamageImmunityIncrease(DAMAGE_TYPE_SONIC, 100));
|
|
eReturn = TagEffect(eReturn, "PRCDamageImmunityAll");
|
|
return eReturn;
|
|
}
|
|
|
|
effect EffectImmunityMiscAll(){
|
|
effect eReturn = EffectImmunity(IMMUNITY_TYPE_ABILITY_DECREASE);
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_BLINDNESS));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_DEAFNESS));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_CRITICAL_HIT));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_DEATH));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_DISEASE));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_ENTANGLE));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_SLOW));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_KNOCKDOWN));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_NEGATIVE_LEVEL));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_PARALYSIS));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_SILENCE));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_SNEAK_ATTACK));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_TRAP));
|
|
eReturn = EffectLinkEffects(eReturn, EffectImmunity(IMMUNITY_TYPE_MIND_SPELLS));
|
|
eReturn = TagEffect(eReturn, "PRCImmunityMiscAll");
|
|
return eReturn;
|
|
}
|
|
|
|
int GetIsShaken(object oTarget)
|
|
{
|
|
effect eEffect = GetFirstEffect(oTarget);
|
|
|
|
string sTag;
|
|
|
|
while (GetIsEffectValid(eEffect))
|
|
{
|
|
sTag = GetEffectTag(eEffect);
|
|
|
|
if (sTag == "PRCShaken") return TRUE;
|
|
|
|
eEffect = GetNextEffect(oTarget);
|
|
}
|
|
return FALSE;
|
|
} |