//:://///////////////////////////////////////////// //:: Spell Hook Include File //:: x2_inc_spellhook //:: Copyright (c) 2003 Bioware Corp. //::////////////////////////////////////////////// /* This file acts as a hub for all code that is hooked into the nwn spellscripts' If you want to implement material components into spells or add restrictions to certain spells, this is the place to do it. */ //::////////////////////////////////////////////// //:: Created By: Georg Zoeller //:: Created On: 2003-06-04 //:: Updated On: 2003-10-25 //::////////////////////////////////////////////// //:: Modified By: Deva Winblood //:: Modified Date: January 15th-16th, 2008 //::////////////////////////////////////////////// /* Modified to insure no shapeshifting spells are castable upon mounted targets. This prevents problems that can occur due to dismounting after shape shifting, or other issues that can occur due to preserved appearances getting out of synch. This can additional check can be disabled by setting the variable X3_NO_SHAPESHIFT_SPELL_CHECK to 1 on the module object. If this variable is set then this script will function as it did prior to this modification. */ const int X2_EVENT_CONCENTRATION_BROKEN = 12400; // Removes spell use for new spellbook system, and calculates spell fail // chance from ASF or silence effects. int NSB_SpellCast(object oCaster, int nSpellID, int nCastingClass, int nMetamagic, int nSpellbookType, string sComponent, object oSpellCastItem); // This function checks for material components or gold // See switch PRC_MATERIAL_COMPONENTS int MaterialComponents(object oCaster, int nSpellID, int nCastingClass, object oSpellCastItem); // This function checks for the Red Wizard's restricted // spell school and prevents him from casting the spells // that he is banned from casting. int RedWizRestrictedSchool(object oCaster, int nSchool, int nCastingClass, object oSpellCastItem); // This function checks whether the Combat Medic's Healing Kicker // feats are active, and if so imbues the spell target with additional // beneficial effects. void CombatMedicHealingKicker(object oCaster, object oTarget, int nSpellID); // Duskblade channeling. While channeling, stops non-touch spells // from working int DuskbladeArcaneChanneling(object oCaster, object oTarget, int nSpellID, int nCasterLevel, int nMetamagic, object oSpellCastItem); // Handles the "When spell is cast do this" effects from the Draconic // series of feats void DraconicFeatsOnSpell(object oCaster, object oTarget, object oSpellCastItem, int nSpellLevel, int nCastingClass); // Bard / Sorc PrC handling // returns FALSE if it is a bard or a sorcerer spell from a character // with an arcane PrC via bioware spellcasting rather than via PrC spellcasting int BardSorcPrCCheck(object oCaster, int nCastingClass, object oSpellCastItem); // Grappling // Rolls a Concentration check to cast a spell while grappling. int GrappleConc(object oCaster, int nSpellLevel); // Blighters can't cast druid spells int Blighter(object oCaster, int nCastingClass, object oSpellCastItem); // Spelldance perform check int Spelldance(object oCaster, int nSpellLevel, int nCastingClass); // Dazzling Illusion feat // Dazzles enemies within radius void DazzlingIllusion(object oCaster, int nSchool); // Battle Blessing check int BattleBlessing(object oCaster, int nCastingClass); // Use Magic Device Check. // Returns TRUE if the Spell is allowed to be cast, either because the // character is allowed to cast it or he has won the required UMD check // Only active on spell scroll int X2UseMagicDeviceCheck(object oCaster); // check if the spell is prohibited from being cast on items // returns FALSE if the spell was cast on an item but is prevented // from being cast there by its corresponding entry in des_crft_spells // oItem - pass PRCGetSpellTargetObject in here int X2CastOnItemWasAllowed(object oItem); // Sequencer Item Property Handling // Returns TRUE (and charges the sequencer item) if the spell // ... was cast on an item AND // ... the item has the sequencer property // ... the spell was non hostile // ... the spell was not cast from an item // in any other case, FALSE is returned an the normal spellscript will be run // oItem - pass PRCGetSpellTargetObject in here int X2GetSpellCastOnSequencerItem(object oItem, object oCaster, int nSpellID, int nMetamagic, int nCasterLevel, int nSaveDC, int bSpellIsHostile, object oSpellCastItem); int X2RunUserDefinedSpellScript(); // Similar to SetModuleOverrideSpellscript but only applies to the user // of this spell. Basically tells the class to run this script when the // spell starts. void PRCSetUserSpecificSpellScript(string sScript); // Similar to SetModuleOverrideSpellscriptFinished but only applies to the // user of this spell. This prevents the spell from continuing on if the // ability dictates it. void PRCSetUserSpecificSpellScriptFinished(); // By setting user-defined spellscripts to the player only, we // avoid the nasty mess of spellhooking the entire module for one player's // activities. This function is mostly only useful inside this include. int PRCRunUserSpecificSpellScript(); // Useful functions for PRCRunUserSpecificSpellScript but not useful in spell // scripts. string PRCGetUserSpecificSpellScript(); int PRCGetUserSpecificSpellScriptFinished(); //#include "prc_x2_itemprop" - Inherited from prc_x2_craft //#include "prc_alterations" #include "prc_x2_craft" //#include "x3_inc_horse" #include "prc_inc_spells" #include "prc_inc_combat" //#include "inc_utility" #include "prc_inc_itmrstr" #include "prc_inc_burn" //#include "inc_newspellbook" //#include "prc_sp_func" //#include "psi_inc_manifest" //#include "prc_inc_combmove" #include "pnp_shft_main" #include "inc_dynconv" #include "inc_npc" int DruidSpontSummon(object oCaster, int nCastingClass, int nSpellID, int nSpellLevel) { if(nCastingClass != CLASS_TYPE_DRUID) return TRUE; if(GetLocalInt(oCaster, "PRC_SpontSummon")) { DeleteLocalInt(oCaster, "PRC_SpontSummon"); int nMetamagic = GetMetaMagicFeat();//we need bioware metamagic here int nSpellLevel = PRCGetSpellLevelForClass(nSpellID, CLASS_TYPE_DRUID); nSpellLevel += GetMetaMagicSpellLevelAdjustment(nMetamagic); int nSummonSpell; switch(nSpellLevel) { case 0: return TRUE; case 1: nSummonSpell = SPELL_SUMMON_CREATURE_I; break; case 2: nSummonSpell = SPELL_SUMMON_CREATURE_II; break; case 3: nSummonSpell = SPELL_SUMMON_CREATURE_III; break; case 4: nSummonSpell = SPELL_SUMMON_CREATURE_IV; break; case 5: nSummonSpell = SPELL_SUMMON_CREATURE_V; break; case 6: nSummonSpell = SPELL_SUMMON_CREATURE_VI; break; case 7: nSummonSpell = SPELL_SUMMON_CREATURE_VII; break; case 8: nSummonSpell = SPELL_SUMMON_CREATURE_VIII; break; case 9: nSummonSpell = SPELL_SUMMON_CREATURE_IX; break; } //subradial spells if(nSummonSpell == SPELL_SUMMON_CREATURE_VII || nSummonSpell == SPELL_SUMMON_CREATURE_VIII || nSummonSpell == SPELL_SUMMON_CREATURE_IX) { SetLocalInt(oCaster, "DomainOrigSpell", nSummonSpell); SetLocalInt(oCaster, "DomainCastLevel", nSpellLevel); SetLocalInt(oCaster, "DomainCastClass", CLASS_TYPE_DRUID); StartDynamicConversation("prc_domain_conv", oCaster, DYNCONV_EXIT_NOT_ALLOWED, FALSE, TRUE, oCaster); } else ActionCastSpell(nSummonSpell, 0, 0, 0, METAMAGIC_NONE, CLASS_TYPE_DRUID); //Don't cast original spell return FALSE; } return TRUE; } int ArcaneSpellFailure(object oCaster, int nCastingClass, int nSpellLevel, int nMetamagic, string sComponents) { if(!GetIsArcaneClass(nCastingClass)) return FALSE; // They don't suffer ASF if(nCastingClass == CLASS_TYPE_FACTOTUM) return FALSE; // Hammer of Witches - wielder cannot cast arcane spells if(GetIsObjectValid(GetItemPossessedBy(oCaster, "WOL_HammerWitches"))) return TRUE; if(FindSubString(sComponents, "S") == -1) return FALSE; object oArmor = GetItemInSlot(INVENTORY_SLOT_CHEST, oCaster); object oShield = GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oCaster); int nAC = GetBaseAC(oArmor); int nASF = GetArcaneSpellFailure(oCaster); int bBattleCaster = GetHasFeat(FEAT_BATTLE_CASTER, oCaster); //Classes with reduced ASF // Beguiler/Dread Necromancer/Sublime Chord can cast in light armor. if(nCastingClass == CLASS_TYPE_BEGUILER || nCastingClass == CLASS_TYPE_DREAD_NECROMANCER || nCastingClass == CLASS_TYPE_SUBLIME_CHORD) { //armors switch(nAC) { case 1: nASF -= 5; break;//light case 2: nASF -= 10; break;//light case 3: nASF -= 20; break;//light case 4: nASF -= bBattleCaster ? 20 : 0; break;//medium; case 5: nASF -= bBattleCaster ? 30 : 0; break;//medium default: break; } } // Hexblade can cast in light/medium armour and while using small shield. else if(nCastingClass == CLASS_TYPE_HEXBLADE) { //shields if(GetBaseItemType(oShield) == BASE_ITEM_SMALLSHIELD) nASF -= 5; //armors switch(nAC) { case 1: nASF -= 5; break; case 2: nASF -= 10; break; case 3: nASF -= 20; break; case 4: nASF -= 20; break; case 5: nASF -= 30; break; case 6: nASF -= bBattleCaster ? 40 : 0; break; case 7: nASF -= bBattleCaster ? 40 : 0; break; case 8: nASF -= bBattleCaster ? 45 : 0; break; default: break; } } // Duskblade can cast in light/medium armour and while using small/large shield. else if(nCastingClass == CLASS_TYPE_DUSKBLADE) { int nLvl = GetLevelByClass(CLASS_TYPE_DUSKBLADE, oCaster); int nShield = GetBaseItemType(oShield); //armors switch(nAC) { case 1: nASF -= 5; break; case 2: nASF -= 10; break; case 3: nASF -= 20; break; case 4: nASF -= (nLvl >= 4 || bBattleCaster) ? 20 : 0; break; case 5: nASF -= (nLvl >= 4 || bBattleCaster) ? 30 : 0; break; case 6: nASF -= (nLvl >= 4 && bBattleCaster) ? 40 : 0; break; case 7: nASF -= (nLvl >= 4 && bBattleCaster) ? 40 : 0; break; case 8: nASF -= (nLvl >= 4 && bBattleCaster) ? 45 : 0; break; default: break; } //shields switch(nShield) { case BASE_ITEM_SMALLSHIELD: nASF -= 5; break; case BASE_ITEM_LARGESHIELD: nASF -= 15; break; } } // Suel Archanamach gets the Ignore Spell Failure Chance feats else if(nCastingClass == CLASS_TYPE_SUEL_ARCHANAMACH) { int nLvl = GetLevelByClass(CLASS_TYPE_SUEL_ARCHANAMACH, oCaster); if (nLvl >= 10) nASF -= 20; else if(nLvl >= 7) nASF -= 15; else if(nLvl >= 4) nASF -= 10; else if(nLvl >= 1) nASF -= 5; } // Warmage can cast in light/medium armour and while using small shield. else if(nCastingClass == CLASS_TYPE_WARMAGE) { int nLvl = GetLevelByClass(CLASS_TYPE_WARMAGE, oCaster); //armors switch(nAC) { case 1: nASF -= 5; break; case 2: nASF -= 10; break; case 3: nASF -= 20; break; case 4: nASF -= (nLvl >= 8 || bBattleCaster) ? 20 : 0; break; case 5: nASF -= (nLvl >= 8 || bBattleCaster) ? 30 : 0; break; case 6: nASF -= (nLvl >= 8 && bBattleCaster) ? 40 : 0; break; case 7: nASF -= (nLvl >= 8 && bBattleCaster) ? 40 : 0; break; case 8: nASF -= (nLvl >= 8 && bBattleCaster) ? 45 : 0; break; default: break; } //shields if(GetBaseItemType(oShield) == BASE_ITEM_SMALLSHIELD) nASF -= 5; } // Knight of the Weave ignores spell failure in light/medium else if(nCastingClass == CLASS_TYPE_KNIGHT_WEAVE) { int nLvl = GetLevelByClass(CLASS_TYPE_KNIGHT_WEAVE, oCaster); if (nLvl >= 2) //Doesn't start until 2nd level { //armors switch(nAC) { case 1: nASF -= 5; break; case 2: nASF -= 10; break; case 3: nASF -= 20; break; case 4: nASF -= (nLvl >= 8 || bBattleCaster) ? 20 : 0; break; case 5: nASF -= (nLvl >= 8 || bBattleCaster) ? 30 : 0; break; case 6: nASF -= (nLvl >= 8 && bBattleCaster) ? 40 : 0; break; case 7: nASF -= (nLvl >= 8 && bBattleCaster) ? 40 : 0; break; case 8: nASF -= (nLvl >= 8 && bBattleCaster) ? 45 : 0; break; default: break; } } } // Redspawn Arcaniss can cast in light armour and while using small shields. else if(nCastingClass == CLASS_TYPE_SORCERER && !GetLevelByClass(CLASS_TYPE_SORCERER, oCaster) && GetRacialType(oCaster) == RACIAL_TYPE_REDSPAWN_ARCANISS) { int nShield = GetBaseItemType(oShield); //armors switch(nAC) { case 1: nASF -= 5; break; case 2: nASF -= 10; break; case 3: nASF -= 20; break; case 4: nASF -= (bBattleCaster) ? 20 : 0; break; case 5: nASF -= (bBattleCaster) ? 30 : 0; break; default: break; } //shields switch(nShield) { case BASE_ITEM_SMALLSHIELD: nASF -= 5; break; } } if(Random(100) < nASF) { int nFail = TRUE; // Still spell helps if(nMetamagic & METAMAGIC_STILL || (GetHasFeat(FEAT_EPIC_AUTOMATIC_STILL_SPELL_1, oCaster) && nSpellLevel <= 3) || (GetHasFeat(FEAT_EPIC_AUTOMATIC_STILL_SPELL_2, oCaster) && nSpellLevel <= 6) || (GetHasFeat(FEAT_EPIC_AUTOMATIC_STILL_SPELL_3, oCaster) && nSpellLevel <= 9)) { nFail = FALSE; } if(nFail) { //52946 = Spell failed due to arcane spell failure! FloatingTextStrRefOnCreature(52946, oCaster, FALSE); return TRUE; } } return FALSE; } int SilenceDeafnessFailure(object oCaster, int nSpellLevel, int nMetamagic, string sComponents) { if(FindSubString(sComponents, "V") == -1) return FALSE; if(PRCGetHasEffect(EFFECT_TYPE_SILENCE, oCaster) || (PRCGetHasEffect(EFFECT_TYPE_DEAF, oCaster) && Random(100) < 20)) { //auto-silent exceptions if(nMetamagic & METAMAGIC_SILENT || (GetHasFeat(FEAT_EPIC_AUTOMATIC_SILENT_SPELL_1, oCaster) && nSpellLevel <= 3) || (GetHasFeat(FEAT_EPIC_AUTOMATIC_SILENT_SPELL_2, oCaster) && nSpellLevel <= 6) || (GetHasFeat(FEAT_EPIC_AUTOMATIC_SILENT_SPELL_3, oCaster) && nSpellLevel <= 9)) { return FALSE; } else { //3734 = Spell failed! FloatingTextStrRefOnCreature(3734, oCaster, FALSE); return TRUE; } } return FALSE; } int Forsaker(object oCaster, object oTarget) { // Friendly spells autofail on Forsakers if (GetLevelByClass(CLASS_TYPE_FORSAKER, oTarget) && GetIsFriend(oTarget, oCaster)) { FloatingTextStringOnCreature("Target is a Forsaker, spell failed!", oCaster, FALSE); return FALSE; } // Forsakers can't use magic if (GetLevelByClass(CLASS_TYPE_FORSAKER, oCaster)) { FloatingTextStringOnCreature("Forsakers cannot cast spells!", oCaster, FALSE); return FALSE; } return TRUE; } int NSB_SpellCast(object oCaster, int nSpellID, int nCastingClass, int nMetamagic, int nSpellbookType, string sComponent, object oSpellCastItem) { //DoDebug("PRC last spell cast class = "+IntToString(PRCGetLastSpellCastClass())); //DoDebug("Primary Arcane Class = "+IntToString(GetPrimaryArcaneClass(oPC))); //DoDebug("Caster Level = "+IntToString(PRCGetCasterLevel(oPC))); //DoDebug("NSB_Class = "+GetStringByStrRef(StringToInt(Get2DACache("classes", "Name", NSB_Class)))); // check if the spell was cast from original spellbook or from item int bNormalCasting = (GetLastSpellCastClass() != CLASS_TYPE_INVALID || oSpellCastItem != OBJECT_INVALID || GetLocalInt(oCaster, "SpellIsSLA")); int NSB_Class = GetLocalInt(oCaster, "NSB_Class"); int nDomainCast = GetLocalInt(oCaster, "DomainCast"); if(nDomainCast) { int nBurnSpell = GetLocalInt(oCaster, "Domain_BurnableSpell") - 1; if(nBurnSpell != -1) { if(!GetHasSpell(nBurnSpell, oCaster)) { //Stop casting DeleteLocalInt(oCaster, "DomainCast"); DeleteLocalInt(oCaster, "Domain_BurnableSpell"); return FALSE; } else { DecrementRemainingSpellUses(oCaster, nBurnSpell); SetLocalInt(oCaster, "DomainCastSpell" + IntToString(nDomainCast), TRUE); } } else { DeleteLocalInt(oCaster, "NSB_Class"); if(NSB_Class != CLASS_TYPE_MYSTIC && NSB_Class != CLASS_TYPE_NIGHTSTALKER) SetLocalInt(oCaster, "DomainCastSpell" + IntToString(nDomainCast), TRUE); } DeleteLocalInt(oCaster, "DomainCast"); DeleteLocalInt(oCaster, "Domain_BurnableSpell"); } //if for some reason NSB variables were not removed and the player is not casting from new spellbook //remove the variables now if(bNormalCasting) { if(NSB_Class) { //clean local vars DeleteLocalInt(oCaster, "NSB_SpellLevel"); DeleteLocalInt(oCaster, "NSB_Class"); DeleteLocalInt(oCaster, "NSB_SpellbookID"); } return TRUE; } //this shuld be executed only for new spellbook spells else if(NSB_Class) { int nSpellLevel = GetLocalInt(oCaster, "NSB_SpellLevel"); int nCount; string sArray = "NewSpellbookMem_" + IntToString(nCastingClass); string sMessage; if(nSpellbookType == SPELLBOOK_TYPE_PREPARED) { int nSpellbookID = GetLocalInt(oCaster, "NSB_SpellbookID"); nCount = persistant_array_get_int(oCaster, sArray, nSpellbookID); if(nCount < 1) return FALSE; nCount--; persistant_array_set_int(oCaster, sArray, nSpellbookID, nCount); int nRealSpellID = StringToInt(Get2DACache(GetFileForClass(nCastingClass), "RealSpellID", nSpellbookID)); string sSpellName = GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nRealSpellID))); // "You have " + IntToString(nCount) + " castings of " + sSpellName + " remaining" sMessage = ReplaceChars(GetStringByStrRef(16828410), "", IntToString(nCount)); sMessage = ReplaceChars(sMessage, "", sSpellName); } else if(nSpellbookType == SPELLBOOK_TYPE_SPONTANEOUS) { nCount = persistant_array_get_int(oCaster, sArray, nSpellLevel); if(nCount < 1) return FALSE; nCount--; persistant_array_set_int(oCaster, sArray, nSpellLevel, nCount); // "You have " + IntToString(nCount) + " castings of spells of level " + IntToString(nSpellLevel) + " remaining" sMessage = ReplaceChars(GetStringByStrRef(16828408), "", IntToString(nCount)); sMessage = ReplaceChars(sMessage, "", IntToString(nSpellLevel)); } FloatingTextStringOnCreature(sMessage, oCaster, FALSE); // Arcane classes roll ASF if the spell has a somatic component // OR if the spell has a vocal component, silence and deafness can cause failure if(ArcaneSpellFailure(oCaster, nCastingClass, nSpellLevel, nMetamagic, sComponent) || SilenceDeafnessFailure(oCaster, nSpellLevel, nMetamagic, sComponent)) return FALSE; return TRUE; } return TRUE; } int MaterialComponents(object oCaster, int nSpellID, int nCastingClass, object oSpellCastItem) { int nSwitch = GetPRCSwitch(PRC_MATERIAL_COMPONENTS); if(!nSwitch) return TRUE; // exceptions if(GetHasFeat(FEAT_IGNORE_MATERIALS, oCaster) //caster has ignore material components feat || GetIsDM(oCaster) || GetIsDMPossessed(oCaster) //caster is DM || oSpellCastItem != OBJECT_INVALID //spell was cast from an item || nCastingClass == CLASS_TYPE_RUNESCARRED || GetLocalInt(oCaster, "SpellIsSLA"))//spell is a spell-like ability { return TRUE; } // Components and Names string sComp1 = Get2DACache("prc_spells", "Component1", nSpellID); string sCompName1 = Get2DACache("prc_spells", "CompName1", nSpellID); string sComp2 = Get2DACache("prc_spells", "Component2", nSpellID); string sCompName2 = Get2DACache("prc_spells", "CompName2", nSpellID); string sComp3 = Get2DACache("prc_spells", "Component3", nSpellID); string sCompName3 = Get2DACache("prc_spells", "CompName3", nSpellID); string sComp4 = Get2DACache("prc_spells", "Component4", nSpellID); string sCompName4 = Get2DACache("prc_spells", "CompName4", nSpellID); int nGold = StringToInt(Get2DACache("prc_spells", "GP", nSpellID)); // These are set to false if the spell has a component int nHasComp1 = sComp1 == "" ? TRUE: FALSE; int nHasComp2 = sComp2 == "" ? TRUE: FALSE; int nHasComp3 = sComp3 == "" ? TRUE: FALSE; int nHasComp4 = sComp4 == "" ? TRUE: FALSE; // The spell doesn't require any material components if(nHasComp1 && nHasComp2 && nHasComp3 && nHasComp4 && !nGold) return TRUE; // Set the return value to false int nReturn = FALSE; // Set test variables int nComponents = TRUE; int nCost = TRUE; // Component Objects to destroy object oComp1, oComp2, oComp3, oComp4; string sSpell = GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nSpellID))); if(nSwitch == 1 || nSwitch == 3) { nComponents = FALSE; // Check if caster has spell component pouch object oPouch = GetItemPossessedBy(oCaster, "prc_spellpouch"); if((GetHasFeat(FEAT_ESCHEW_MATERIALS, oCaster) || GetIsObjectValid(oPouch)) && nGold < 1) { nComponents = TRUE; } else { string sMes = "Material component missing: "; // Look for items in players inventory if(!nHasComp1) { oComp1 = GetItemPossessedBy(oCaster, sComp1); if(GetIsObjectValid(oComp1)) nHasComp1 = TRUE; else FloatingTextStringOnCreature(sMes + sCompName1, oCaster, FALSE); } if(!nHasComp2) { oComp2 = GetItemPossessedBy(oCaster, sComp2); if(GetIsObjectValid(oComp2)) nHasComp2 = TRUE; else FloatingTextStringOnCreature(sMes + sCompName2, oCaster, FALSE); } if(!nHasComp3) { oComp3 = GetItemPossessedBy(oCaster, sComp3); if(GetIsObjectValid(oComp3)) nHasComp3 = TRUE; else FloatingTextStringOnCreature(sMes + sCompName3, oCaster, FALSE); } if(!nHasComp4) { oComp4 = GetItemPossessedBy(oCaster, sComp4); if(GetIsObjectValid(oComp4)) nHasComp4 = TRUE; else FloatingTextStringOnCreature(sMes + sCompName4, oCaster, FALSE); } } if(nHasComp1 && nHasComp2 && nHasComp3 && nHasComp4) nComponents = TRUE; else FloatingTextStringOnCreature("You do not have the appropriate material components to cast " + sSpell, oCaster, FALSE); } if(nSwitch == 2 || nSwitch == 3) { nCost = FALSE; // Now check to see if they have enough gold if(GetGold(oCaster) >= nGold) nCost = TRUE; else FloatingTextStringOnCreature("You do not have enough gold to cast " + sSpell, oCaster, FALSE); } // Checked for the spell components, now the final test. if(nComponents && nCost) { // We've got all the components nReturn = TRUE; if(nSwitch == 1 || nSwitch == 3) { int nStack = 0; // Component 1 nStack = GetNumStackedItems(oComp1); if(nStack > 1) DelayCommand(0.6, SetItemStackSize (oComp1, --nStack)); else DelayCommand(0.6, DestroyObject(oComp1)); // Component 2 nStack = GetNumStackedItems(oComp2); if(nStack > 1) DelayCommand(0.6, SetItemStackSize (oComp2, --nStack)); else DelayCommand(0.6, DestroyObject(oComp2)); // Component 3 nStack = GetNumStackedItems(oComp3); if(nStack > 1) DelayCommand(0.6, SetItemStackSize (oComp3, --nStack)); else DelayCommand(0.6, DestroyObject(oComp3)); // Component 4 nStack = GetNumStackedItems(oComp4); if(nStack > 1) DelayCommand(0.6, SetItemStackSize (oComp4, --nStack)); else DelayCommand(0.6, DestroyObject(oComp4)); } if(nSwitch == 2 || nSwitch == 3) { TakeGoldFromCreature(nGold, oCaster, TRUE); } } // return our value return nReturn; } int SpellRestrictClass(int nCastingClass, int nSwitch) { if(nSwitch == 3) return TRUE; if(nSwitch == 1) return FALSE; //else nSwitch == 2 if(nCastingClass == CLASS_TYPE_CLERIC || nCastingClass == CLASS_TYPE_FAVOURED_SOUL || nCastingClass == CLASS_TYPE_OCULAR || nCastingClass == CLASS_TYPE_SHAMAN || nCastingClass == CLASS_TYPE_HEALER || nCastingClass == CLASS_TYPE_TEMPLAR) return TRUE; return FALSE; } int SpellAlignmentRestrictions(object oCaster, int nSpellID, int nCastingClass) { int nSwitch = GetPRCSwitch(PRC_SPELL_ALIGNMENT_RESTRICT); if(!nSwitch) return TRUE; int nShift = GetPRCSwitch(PRC_SPELL_ALIGNMENT_SHIFT); int nAlignGE = GetGoodEvilValue(oCaster); int nAlignLC = GetLawChaosValue(oCaster); int nAdjust; int nDescriptor = GetLocalInt(oCaster, PRC_DESCRIPTOR); if(!nDescriptor) nDescriptor = GetDescriptorFlags(nSpellID); if(nDescriptor & DESCRIPTOR_EVIL) { if(nAlignGE > 69 && SpellRestrictClass(nCastingClass, nSwitch)) { FloatingTextStringOnCreature("Your alignment prohibits casting spells with this descriptor!", oCaster, FALSE); return FALSE; } else if (nShift) { nAdjust = FloatToInt(sqrt(IntToFloat(nAlignGE)) / 2); if(nAdjust) AdjustAlignment(oCaster, ALIGNMENT_EVIL, nAdjust, FALSE); } } if(nDescriptor & DESCRIPTOR_GOOD) { if(nAlignGE < 31 && SpellRestrictClass(nCastingClass, nSwitch)) { FloatingTextStringOnCreature("Your alignment prohibits casting spells with this descriptor!", oCaster, FALSE); return FALSE; } else if (nShift) { nAdjust = FloatToInt(sqrt(IntToFloat(100 - nAlignGE)) / 2); if(nAdjust) AdjustAlignment(oCaster, ALIGNMENT_GOOD, nAdjust, FALSE); } } if(nDescriptor & DESCRIPTOR_LAWFUL) { if(nAlignLC < 31 && SpellRestrictClass(nCastingClass, nSwitch)) { FloatingTextStringOnCreature("Your alignment prohibits casting spells with this descriptor!", oCaster, FALSE); return FALSE; } else if (nShift) { nAdjust = FloatToInt(sqrt(IntToFloat(100 - nAlignLC)) / 2); if(nAdjust) AdjustAlignment(oCaster, ALIGNMENT_LAWFUL, nAdjust, FALSE); } } if(nDescriptor & DESCRIPTOR_CHAOTIC) { if(nAlignLC > 69 && SpellRestrictClass(nCastingClass, nSwitch)) { FloatingTextStringOnCreature("Your alignment prohibits casting spells with this descriptor!", oCaster, FALSE); return FALSE; } else if (nShift) { nAdjust = FloatToInt(sqrt(IntToFloat(nAlignLC)) / 2); if(nAdjust) AdjustAlignment(oCaster, ALIGNMENT_CHAOTIC, nAdjust, FALSE); } } return TRUE; } int RedWizRestrictedSchool(object oCaster, int nSchool, int nCastingClass, object oSpellCastItem) { // No need for wasting CPU on non-Red Wizards if(GetLevelByClass(CLASS_TYPE_RED_WIZARD, oCaster)) { //can’t cast prohibited spells from scrolls or fire them from wands if(GetIsObjectValid(oSpellCastItem)) { int nType = GetBaseItemType(oSpellCastItem); if(nType != BASE_ITEM_MAGICWAND && nType != BASE_ITEM_ENCHANTED_WAND && nType != BASE_ITEM_SCROLL && nType != BASE_ITEM_SPELLSCROLL && nType != BASE_ITEM_ENCHANTED_SCROLL) return TRUE; } // Determine forbidden schools int iRWRes; switch(nSchool) { case SPELL_SCHOOL_ABJURATION: iRWRes = FEAT_RW_RES_ABJ; break; case SPELL_SCHOOL_CONJURATION: iRWRes = FEAT_RW_RES_CON; break; case SPELL_SCHOOL_DIVINATION: iRWRes = FEAT_RW_RES_DIV; break; case SPELL_SCHOOL_ENCHANTMENT: iRWRes = FEAT_RW_RES_ENC; break; case SPELL_SCHOOL_EVOCATION: iRWRes = FEAT_RW_RES_EVO; break; case SPELL_SCHOOL_ILLUSION: iRWRes = FEAT_RW_RES_ILL; break; case SPELL_SCHOOL_NECROMANCY: iRWRes = FEAT_RW_RES_NEC; break; case SPELL_SCHOOL_TRANSMUTATION: iRWRes = FEAT_RW_RES_TRS; break; } // Compare the spell's school versus the restricted schools if(iRWRes && GetHasFeat(iRWRes, oCaster)) { FloatingTextStrRefOnCreature(16822359, oCaster, FALSE); // "You cannot cast spells of your prohibited schools. Spell terminated." return FALSE; } // Other arcane casters cannot benefit from red wizard bonuses if(GetIsArcaneClass(nCastingClass) && nCastingClass != CLASS_TYPE_WIZARD) { FloatingTextStringOnCreature("You have attempted to illegaly merge another arcane caster with a Red Wizard. All spellcasting will now fail.", oCaster, FALSE); return FALSE; } } return TRUE; } int PnPSpellSchools(object oCaster, int nCastingClass, int nSchool, object oSpellCastItem) { if(GetPRCSwitch(PRC_PNP_SPELL_SCHOOLS) && nCastingClass == CLASS_TYPE_WIZARD) { //can’t cast prohibited spells from scrolls or fire them from wands if(GetIsObjectValid(oSpellCastItem)) { int nType = GetBaseItemType(oSpellCastItem); if(nType != BASE_ITEM_MAGICWAND && nType != BASE_ITEM_ENCHANTED_WAND && nType != BASE_ITEM_SCROLL && nType != BASE_ITEM_SPELLSCROLL && nType != BASE_ITEM_ENCHANTED_SCROLL) return TRUE; } int nFeat; switch(nSchool) { case SPELL_SCHOOL_ABJURATION: nFeat = 2265; break; case SPELL_SCHOOL_CONJURATION: nFeat = 2266; break; case SPELL_SCHOOL_DIVINATION: nFeat = 2267; break; case SPELL_SCHOOL_ENCHANTMENT: nFeat = 2268; break; case SPELL_SCHOOL_EVOCATION: nFeat = 2269; break; case SPELL_SCHOOL_ILLUSION: nFeat = 2270; break; case SPELL_SCHOOL_NECROMANCY: nFeat = 2271; break; case SPELL_SCHOOL_TRANSMUTATION: nFeat = 2272; break; default: nFeat = 0; } if(nFeat && GetHasFeat(nFeat, oCaster)) { FloatingTextStringOnCreature("You cannot cast spells of an opposition school.", oCaster, FALSE); return FALSE; } } return TRUE; } int ShifterCasting(object oCaster, object oSpellCastItem, int nSpellLevel, int nMetamagic, string sComponent) { // The variable tells that the new form is unable to cast spells (very inaccurate, determined by racial type) // with somatic or vocal components and is lacking Natural Spell feat if(GetLocalInt(oCaster, "PRC_Shifting_RestrictSpells")) { if(GetIsObjectValid(oSpellCastItem)) { // Potion drinking is not restricted if(GetBaseItemType(oSpellCastItem) == BASE_ITEM_ENCHANTED_POTION || GetBaseItemType(oSpellCastItem) == BASE_ITEM_POTIONS) return TRUE; //OnHit properties on equipped items not restricted int nSlot; for(nSlot = 0; nSlot= 13) { nMax = 10; nVal = 2; } for(i=1; i<=nMax; i++) { SetLocalInt(oItem, "X2_L_CHANNELTRIGGER" + IntToString(i) , nSID); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_L" + IntToString(i), nCasterLevel); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_M" + IntToString(i), nMetamagic); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_D" + IntToString(i), PRCGetSaveDC(oTarget, oCaster)); } SetLocalInt(oItem, "X2_L_NUMCHANNELTRIGGERS", nMax); //mark it as discharging SetLocalInt(oItem, "DuskbladeChannelDischarge", nVal); DelayCommand(fDelay, DuskbladeCleanUp(oItem, nMax)); itemproperty ipTest = ItemPropertyOnHitCastSpell(IP_CONST_ONHIT_CASTSPELL_ONHIT_UNIQUEPOWER, 1); IPSafeAddItemProperty(oItem ,ipTest, fDelay); //make attack ClearAllActions(); effect eNone; if (nClass >= 13) PerformAttackRound(oTarget, oCaster, eNone, 0.0, 0, 0, 0, FALSE, "Arcane Channelling Hit", "Arcane Channelling Miss"); else if (nClass >= 13) PerformAttack(oTarget, oCaster, eNone, 0.0, 0, 0, 0, "Arcane Channelling Hit", "Arcane Channelling Miss"); // Target is valid and we know it's an enemy and we're in combat DelayCommand(0.25, AssignCommand(oCaster, ActionAttack(oTarget))); FloatingTextStringOnCreature("Duskblade Channeling Deactivated", oCaster, FALSE); DeleteLocalInt(oCaster, "DuskbladeChannelActive"); return FALSE; } } return TRUE; } //PnP familiar - deliver touch spell int DeliverTouchSpell(object oCaster, object oTarget, int nSpellID, int nCasterLevel, int nSaveDC, int nMetamagic, object oSpellCastItem) { if(GetPRCSwitch(PRC_PNP_FAMILIARS)) { // Don't channel from objects if(oSpellCastItem != OBJECT_INVALID) return TRUE; if(GetAssociateTypeNPC(oTarget) == ASSOCIATE_TYPE_FAMILIAR && GetMasterNPC(oTarget) == oCaster) { if(GetHitDice(oTarget) > 2) { if(!GetLocalInt(oCaster, "PRC_SPELL_HOLD") //holding the charge doesnt work && (Get2DACache("spells", "Range", nSpellID) == "T")) //only touch spells { //find the item object oItem = GetItemInSlot(INVENTORY_SLOT_CWEAPON_B, oTarget); if(!GetIsObjectValid(oItem)) oItem = GetItemInSlot(INVENTORY_SLOT_CWEAPON_L, oTarget); if(!GetIsObjectValid(oItem)) oItem = GetItemInSlot(INVENTORY_SLOT_CWEAPON_R, oTarget); if(GetIsObjectValid(oItem) && !GetLocalInt(oItem, "X2_L_NUMCHANNELTRIGGERS")) { //valid spell, store //very similar to duskblade chanelling effect eVisual = EffectVisualEffect(VFX_IMP_BREACH); ApplyEffectToObject(DURATION_TYPE_INSTANT, eVisual, oTarget); //NOTE: I add +1 to the SpellId to spell 0 can be used to trap failure int nSID = nSpellID + 1; SetLocalInt(oItem, "X2_L_CHANNELTRIGGER" , nSID); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_L", nCasterLevel); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_M", nMetamagic); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_D", nSaveDC); SetLocalInt(oItem, "X2_L_NUMCHANNELTRIGGERS", 1); DelayCommand(60.0, DuskbladeCleanUp(oItem, 1)); itemproperty ipTest = ItemPropertyOnHitCastSpell(IP_CONST_ONHIT_CASTSPELL_ONHIT_UNIQUEPOWER, 1); IPSafeAddItemProperty(oItem, ipTest, 60.0); return FALSE;//don't cast } } } } } return TRUE; } void SpellSharing(object oCaster, object oTarget, int nSpellID, int nCasterLevel, int nSaveDC, int nMetamagic, object oSpellCastItem) { if((Get2DACache("spells", "Range", nSpellID) == "P" || oTarget == oCaster) // Either of these is legal && (Get2DACache("prc_spells", "NoShare", nSpellID) != "1") && !GetLocalInt(oCaster, "PRC_SPELL_HOLD") //holding the charge doesnt work && !GetLocalInt(oCaster, "SpellIsSLA") // no spell-like abilities && !GetIsObjectValid(oSpellCastItem)) // no item spells { int bAll = GetPRCSwitch(PRC_ENABLE_SPELL_SHARING); //enables spell sharing for all compaions (bioware and PnP) int bFam = GetPRCSwitch(PRC_PNP_FAMILIARS); //enables spell sharing only for PnP familiars int bComp = GetPRCSwitch(PRC_PNP_ANIMAL_COMPANIONS); //enables spell sharing only for PnP animal companions int bBond = GetLevelByClass(CLASS_TYPE_BONDED_SUMMONNER, oCaster); location lCaster = GetLocation(oCaster); //RADIUS_SIZE_MEDIUM = 10 feet - the source book says it's 5, but that will make it very difficult to use in NWN object oComp = GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_MEDIUM, lCaster, TRUE, OBJECT_TYPE_CREATURE); while(GetIsObjectValid(oComp)) { if(GetMasterNPC(oComp) == oCaster) { int nType = GetAssociateTypeNPC(oComp); if((nType == ASSOCIATE_TYPE_FAMILIAR && (bAll || bFam || bBond)) || (nType == ASSOCIATE_TYPE_ANIMALCOMPANION && (bAll || bComp)) || nType == ASSOCIATE_TYPE_CELESTIALCOMPANION || oComp == GetLocalObject(oCaster, "oX3PaladinMount")) { AssignCommand(oComp, ClearAllActions()); AssignCommand(oComp, ActionCastSpell(nSpellID, nCasterLevel, 0, nSaveDC, nMetamagic, CLASS_TYPE_INVALID, FALSE, TRUE, oComp)); } } oComp = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_MEDIUM, lCaster, TRUE, OBJECT_TYPE_CREATURE); } } } void DraconicFeatsOnSpell(object oCaster, object oTarget, object oSpellCastItem, int nSpellLevel, int nCastingClass) { //ensure the spell is arcane if(!GetIsArcaneClass(nCastingClass, oCaster)) return; ///////Draconic Vigor//// if(GetHasFeat(FEAT_DRACONIC_VIGOR, oCaster)) { effect eHeal = EffectHeal(nSpellLevel); ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oCaster); } ///////Draconic Armor//// if(GetHasFeat(FEAT_DRACONIC_ARMOR, oCaster)) { effect eDamRed = EffectDamageReduction(nSpellLevel, DAMAGE_POWER_PLUS_ONE); ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eDamRed, oCaster, 6.0f); } ///////Draconic Persuasion//// if(GetHasFeat(FEAT_DRACONIC_PERSUADE, oCaster)) { int nBonus = FloatToInt(1.5f * IntToFloat(nSpellLevel)); effect eCha = EffectSkillIncrease(SKILL_BLUFF, nBonus); effect eCha2 = EffectSkillIncrease(SKILL_PERFORM, nBonus); effect eCha3 = EffectSkillIncrease(SKILL_INTIMIDATE, nBonus); effect eLink = EffectLinkEffects(eCha, eCha2); eLink = EffectLinkEffects(eLink, eCha3); ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oCaster, 6.0f); } ///////Draconic Presence//// if(GetHasFeat(FEAT_DRACONIC_PRESENCE, oCaster)) { //set up checks object oScare; int bCreaturesLeft = TRUE; int nNextCreature = 1; //set up fear effects effect eVis = EffectVisualEffect(VFX_IMP_FEAR_S); effect eDur = EffectVisualEffect(VFX_DUR_CESSATE_NEGATIVE); effect eLink = EffectLinkEffects(EffectShaken(), eDur); int nDC = 10 + nSpellLevel + GetAbilityModifier(ABILITY_CHARISMA, oCaster); int nDuration = 6 * nSpellLevel; //cycle through creatures within the AoE while(bCreaturesLeft) { oScare = GetNearestCreature(CREATURE_TYPE_IS_ALIVE, TRUE, oCaster, nNextCreature, CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY); if(oScare == OBJECT_INVALID) bCreaturesLeft = FALSE; if(oScare != oCaster && GetDistanceToObject(oScare) < FeetToMeters(15.0)) { //dragons are immune, so make sure it's not a dragon if(MyPRCGetRacialType(oScare)!= RACIAL_TYPE_DRAGON) { //Fire cast spell at event for the specified target SignalEvent(oScare, EventSpellCastAt(oCaster, SPELLABILITY_AURA_FEAR)); //Make a saving throw check if(!PRCMySavingThrow(SAVING_THROW_WILL, oScare, nDC, SAVING_THROW_TYPE_FEAR) && !GetIsImmune(oScare, IMMUNITY_TYPE_FEAR) && !GetIsImmune(oScare, IMMUNITY_TYPE_MIND_SPELLS)) { //Apply the VFX impact and effects ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oScare, RoundsToSeconds(nDuration)); ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oScare); }//end will save processing } //end dragon check nNextCreature++; }//end target check //if no more creatures within range, end it else bCreaturesLeft = FALSE; }//end while } ///////Draconic Claw//// if(GetHasFeat(FEAT_DRACONIC_CLAW, oCaster)) { // Clawswipes only work on powers manifested by the Diamond Dragon, not by items he uses. if(oSpellCastItem != OBJECT_INVALID) { FloatingTextStringOnCreature("You do not gain clawswipes from Items.", oCaster, FALSE); return; } //get the proper sized claw string sResRef = "prc_claw_1d6m_"; sResRef += GetAffixForSize(PRCGetCreatureSize(oCaster)); object oClaw = GetObjectByTag(sResRef); effect eInvalid; if(TakeSwiftAction(oCaster)) { //grab the closest enemy to swipe at oTarget = GetNearestCreature(CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN, oCaster, 1, CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY); if(oTarget != oCaster && GetDistanceToObject(oTarget) < FeetToMeters(15.0)) { PerformAttack(oTarget, oCaster, eInvalid, 0.0, 0, 0, DAMAGE_TYPE_SLASHING, "*Clawswipe Hit*", "*Clawswipe Missed*", FALSE, oClaw); } } } } void DazzlingIllusion(object oCaster, int nSchool) { // No need for wasting CPU on non-Dazzles if(GetHasFeat(FEAT_DAZZLING_ILLUSION, oCaster)) { if(nSchool == SPELL_SCHOOL_ILLUSION) { effect eLink = EffectLinkEffects(EffectDazzle(), EffectVisualEffect(VFX_IMP_BLINDDEAD_DN_CYAN)); location lTarget = GetLocation(oCaster); object oTarget = MyFirstObjectInShape(SHAPE_SPHERE, FeetToMeters(30.0), lTarget, TRUE, OBJECT_TYPE_CREATURE); //Cycle through the targets within the spell shape until an invalid object is captured. while(GetIsObjectValid(oTarget)) { if(!GetIsFriend(oTarget, oCaster) && !PRCGetHasEffect(EFFECT_TYPE_BLINDNESS, oTarget)) { ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oTarget, 6.0); } //Select the next target within the spell shape. oTarget = MyNextObjectInShape(SHAPE_SPHERE, FeetToMeters(30.0), lTarget, TRUE, OBJECT_TYPE_CREATURE); } } } } void EnergyAbjuration(object oCaster, int nSchool, int nSpellLevel) { // No need for wasting CPU on non-Abjures if(GetHasFeat(FEAT_ENERGY_ABJURATION, oCaster)) { if(nSchool == SPELL_SCHOOL_ABJURATION) { int nAmount = (1 + nSpellLevel) * 5; effect eLink = EffectDamageResistance(DAMAGE_TYPE_COLD, nAmount, nAmount); eLink = EffectLinkEffects(eLink, EffectDamageResistance(DAMAGE_TYPE_FIRE, nAmount, nAmount)); eLink = EffectLinkEffects(eLink, EffectDamageResistance(DAMAGE_TYPE_ACID, nAmount, nAmount)); eLink = EffectLinkEffects(eLink, EffectDamageResistance(DAMAGE_TYPE_SONIC, nAmount, nAmount)); eLink = EffectLinkEffects(eLink, EffectDamageResistance(DAMAGE_TYPE_ELECTRICAL, nAmount, nAmount)); eLink = EffectLinkEffects(eLink, EffectVisualEffect(VFX_DUR_PROTECTION_ELEMENTS)); eLink = EffectLinkEffects(eLink, EffectVisualEffect(VFX_IMP_ELEMENTAL_PROTECTION)); eLink = EffectLinkEffects(eLink, EffectVisualEffect(VFX_DUR_CESSATE_POSITIVE)); ApplyEffectToObject(DURATION_TYPE_PERMANENT, eLink, oCaster); } } } void InsightfulDivination(object oCaster, int nSchool, int nSpellLevel) { if(GetHasFeat(FEAT_INSIGHTFUL_DIVINATION, oCaster)) { if(nSchool == SPELL_SCHOOL_DIVINATION) { int nAmount = 1 + nSpellLevel; SetLocalInt(oCaster, "InsightfulDivination", nAmount); } } } void TougheningTransmutation(object oCaster, int nSchool) { if(GetHasFeat(FEAT_TOUGHENING_TRANSMUTATION, oCaster)) { if(nSchool == SPELL_SCHOOL_TRANSMUTATION) { ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectDamageReduction(5, DAMAGE_POWER_PLUS_ONE), oCaster, 6.0); } } } void CloudyConjuration(object oCaster, int nSchool, object oSpellCastItem) { if(GetHasFeat(FEAT_CLOUDY_CONJURATION, oCaster) && !GetIsObjectValid(oSpellCastItem)) // Doesn't work on spells cast from items. { if(nSchool == SPELL_SCHOOL_CONJURATION) { ApplyEffectAtLocation(DURATION_TYPE_TEMPORARY, EffectAreaOfEffect(VFX_MOB_CLOUDY_CONJURATION), PRCGetSpellTargetLocation(), 6.0); } } } //ebonfowl: runs the reserve feat script void OnePingOnly(object oCaster) { //Only works if you have a reserve feat if(GetLocalInt(oCaster, "ReserveFeatsRunning") == TRUE) { DelayCommand(1.0, ExecuteScript("prc_reservefeat", oCaster)); } } //ebonfowl: runs the damage backlash for Mystic Backlash void MysticBacklash(object oCaster) { int nDamage = GetLocalInt(oCaster, "DoMysticBacklash"); effect eBacklash = EffectDamage(nDamage, DAMAGE_TYPE_MAGICAL); eBacklash = SupernaturalEffect(eBacklash); ApplyEffectToObject(DURATION_TYPE_INSTANT, eBacklash, oCaster); } //spellweave affects only one target, mark it here void EldritchSpellweave(object oCaster, object oTarget, int nSpellLevel, int bSpellIsHostile) { if(GetLocalInt(oCaster, "INV_SPELLWEAVE")) { //we need a valid target if(!GetIsObjectValid(oTarget)) return; //hostile spell if(!GetIsEnemy(oTarget, oCaster)) return; //and active blast essence if(!GetLocalInt(oCaster, "BlastEssence") || GetLocalInt(oCaster, "BlastEssence") == INVOKE_CORRUPTING_BLAST) return; //final test: spell level >= essence level if(nSpellLevel >= (GetLocalInt(oCaster, "EssenceData") & 0xF)) { //everything is OK, mark the target for eldritch spellweave SetLocalObject(oCaster, "SPELLWEAVE_TARGET", oTarget); DeleteLocalInt(oCaster, "INV_SPELLWEAVE"); } else SendMessageToPC(oCaster, "Eldritch Spellweave: The level of this spell is too low to use with current blast essence."); } } int BardSorcPrCCheck(object oCaster, int nCastingClass, object oSpellCastItem) { // If it's an item, get the hell out of here if (GetIsObjectValid(oSpellCastItem)) return TRUE; // Eldritch Spellblast was breaking otherwise if (GetLocalInt(oCaster, "EldritchSpellBlast")) return TRUE; //check its a sorc spell if(nCastingClass == CLASS_TYPE_SORCERER) { //no need to check further if new spellbooks are disabled if(GetPRCSwitch(PRC_SORC_DISALLOW_NEWSPELLBOOK)) return TRUE; //check they have sorc levels if(!GetLevelByClass(CLASS_TYPE_SORCERER, oCaster)) return TRUE; //check if they are casting via new spellbook if(GetLocalInt(oCaster, "NSB_Class") != CLASS_TYPE_SORCERER && GetLevelByClass(CLASS_TYPE_ULTIMATE_MAGUS, oCaster)) return FALSE; //check if they are casting via new spellbook if(GetLocalInt(oCaster, "NSB_Class") == CLASS_TYPE_SORCERER) return TRUE; //check they have arcane PrC or Draconic Arcane Grace/Breath if(!(GetArcanePRCLevels(oCaster) - GetLevelByClass(CLASS_TYPE_SUBLIME_CHORD, oCaster)) && !(GetHasFeat(FEAT_DRACONIC_GRACE, oCaster) || GetHasFeat(FEAT_DRACONIC_BREATH, oCaster))) return TRUE; //check they have sorc in first arcane slot //if(GetPrimaryArcaneClass() != CLASS_TYPE_SORCERER) if(GetPrCAdjustedCasterLevelByType(TYPE_ARCANE, oCaster, TRUE) != GetPrCAdjustedCasterLevel(CLASS_TYPE_SORCERER, oCaster, TRUE)) return TRUE; //at this point, they must be using the bioware spellbook //from a class that adds to sorc FloatingTextStringOnCreature("You must use the new spellbook on the class radial.", oCaster, FALSE); return FALSE; } //check its a bard spell if(nCastingClass == CLASS_TYPE_BARD) { //no need to check further if new spellbooks are disabled if(GetPRCSwitch(PRC_BARD_DISALLOW_NEWSPELLBOOK)) return TRUE; //check they have bard levels if(!GetLevelByClass(CLASS_TYPE_BARD, oCaster)) return TRUE; //check if they are casting via new spellbook if(GetLocalInt(oCaster, "NSB_Class") == CLASS_TYPE_BARD) return TRUE; //check they have arcane PrC or Draconic Arcane Grace/Breath if(!(GetArcanePRCLevels(oCaster) - GetLevelByClass(CLASS_TYPE_SUBLIME_CHORD, oCaster)) && !(GetHasFeat(FEAT_DRACONIC_GRACE, oCaster) || GetHasFeat(FEAT_DRACONIC_BREATH, oCaster))) return TRUE; //check they have bard in first arcane slot //if(GetPrimaryArcaneClass() != CLASS_TYPE_BARD) if(GetPrCAdjustedCasterLevelByType(TYPE_ARCANE, oCaster, TRUE) != GetPrCAdjustedCasterLevel(CLASS_TYPE_BARD, oCaster, TRUE)) return TRUE; //at this point, they must be using the bioware spellbook //from a class that adds to bard FloatingTextStringOnCreature("You must use the new spellbook on the class radial.", oCaster, FALSE); return FALSE; } return TRUE; } int KOTCHeavenDevotion(object oCaster, object oTarget, int nCasterAlignment, int nSpellSchool) { if(GetLevelByClass(CLASS_TYPE_KNIGHT_CHALICE, oTarget) >= 5) { if(MyPRCGetRacialType(oCaster) == RACIAL_TYPE_OUTSIDER) { if(nCasterAlignment == ALIGNMENT_EVIL) { if(nSpellSchool == SPELL_SCHOOL_ENCHANTMENT) { return FALSE; } } } } return TRUE; } void CombatMedicHealingKicker(object oCaster, object oTarget, int nSpellID) { int nLevel = GetLevelByClass(CLASS_TYPE_COMBAT_MEDIC, oCaster); int nKicker = GetLocalInt(oCaster, "Heal_Kicker"); if(!nLevel || !nKicker || oTarget == oCaster) //Cannot use on self return; if(!GetIsOfSubschool(nSpellID, SUBSCHOOL_HEALING)) //If the spell that was just cast isn't healing, stop now return; //Three if/elseif statements. They check which of the healing kickers we use. //If no Healing Kicker localints are set, this if block should be ignored. int bRemoveUses; if(nKicker == 1) { /* Sanctuary effect, with special DC and 1 round duration * Script stuff taken from the spell by the same name */ int nDC = 15 + nLevel + GetAbilityModifier(ABILITY_WISDOM, oCaster); effect eLink = EffectLinkEffects(EffectVisualEffect(VFX_DUR_SANCTUARY), EffectSanctuary(nDC)); //Apply the Sanctuary VFX impact and effects ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oTarget, 6.0); bRemoveUses = TRUE; } else if(nKicker == 2) { /* Reflex save increase, 1 round duration */ ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_IMP_HASTE), oTarget); ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectSavingThrowIncrease(SAVING_THROW_REFLEX, nLevel), oTarget, 6.0); bRemoveUses = TRUE; } else if(nKicker == 3) { /* Aid effect, with special HP bonus and 1 minute duration * Script stuff taken from the spell by the same name */ int nBonus = 8 + nLevel; effect eLink = EffectLinkEffects(EffectAttackIncrease(1), EffectSavingThrowIncrease(SAVING_THROW_ALL, 1, SAVING_THROW_TYPE_FEAR)); //Apply the Aid VFX impact and effects ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_IMP_HOLY_AID), oTarget); ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oTarget, 60.0); ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectTemporaryHitpoints(nBonus), oTarget, 60.0); bRemoveUses = TRUE; } if(bRemoveUses) { DeleteLocalInt(oCaster, "Heal_Kicker"); DecrementRemainingFeatUses(oCaster, FEAT_HEALING_KICKER_1); DecrementRemainingFeatUses(oCaster, FEAT_HEALING_KICKER_2); DecrementRemainingFeatUses(oCaster, FEAT_HEALING_KICKER_3); } } // Performs the attack portion of the battlecast ability for the havoc mage void Battlecast(object oCaster, object oTarget, object oSpellCastItem, int nSpellLevel) { int nLevel = GetLevelByClass(CLASS_TYPE_HAVOC_MAGE, oCaster); // If battlecast is turned off, exit if(!nLevel || !GetLocalInt(oCaster, "HavocMageBattlecast")) return; // Battlecast only works on spells cast by the Havoc Mage, not by items he uses. if(oSpellCastItem != OBJECT_INVALID) { FloatingTextStringOnCreature("You do not gain Battlecast from Items.", oCaster, FALSE); return; } //if its not being cast on a hostile target or its at a location //get the nearest living seen hostile insead if(!spellsIsTarget(oTarget, SPELL_TARGET_SELECTIVEHOSTILE, oCaster) || !GetIsObjectValid(oTarget)) { oTarget = GetNearestCreature(CREATURE_TYPE_IS_ALIVE, TRUE, oCaster, 1, CREATURE_TYPE_REPUTATION, REPUTATION_TYPE_ENEMY, CREATURE_TYPE_PERCEPTION, PERCEPTION_SEEN); } effect eVis = EffectVisualEffect(VFX_IMP_DIVINE_STRIKE_HOLY); // Don't want to smack allies upside the head when casting a spell. if(spellsIsTarget(oTarget, SPELL_TARGET_SELECTIVEHOSTILE, oCaster) && oTarget != oCaster && GetDistanceToObject(oTarget) < FeetToMeters(15.0)) { // Make sure the levels are right for both the caster and the spells. // Level 8 spells and under at level 5 // Level 4 spells and under at level 3 // Level 2 spells and under at level 1 if((nLevel == 5 && 9 > nSpellLevel) || (nLevel > 2 && 5 > nSpellLevel) || (nLevel > 0 && 3 > nSpellLevel)) PerformAttack(oTarget, oCaster, eVis, 0.0, 0, 0, 0, "*Battlecast Hit*", "*Battlecast Missed*"); } } //Archmage and Heirophant SLA slection/storage setting int ClassSLAStore(object oCaster, int nSpellID, int nCastingClass, int nSpellLevel) { int nSLAID = GetLocalInt(oCaster, "PRC_SLA_Store"); if(nSLAID) { FloatingTextStringOnCreature("SLA "+IntToString(nSLAID)+" stored", oCaster, FALSE); int nMetamagic = GetMetaMagicFeat(); SetPersistantLocalInt(oCaster, "PRC_SLA_SpellID_"+IntToString(nSLAID), nSpellID+1); SetPersistantLocalInt(oCaster, "PRC_SLA_Class_"+IntToString(nSLAID), nCastingClass); SetPersistantLocalInt(oCaster, "PRC_SLA_Meta_"+IntToString(nSLAID), nMetamagic); if(nMetamagic & METAMAGIC_QUICKEN) nSpellLevel += 4; if(nMetamagic & METAMAGIC_STILL) nSpellLevel += 1; if(nMetamagic & METAMAGIC_SILENT) nSpellLevel += 1; if(nMetamagic & METAMAGIC_MAXIMIZE) nSpellLevel += 3; if(nMetamagic & METAMAGIC_EMPOWER) nSpellLevel += 2; if(nMetamagic & METAMAGIC_EXTEND) nSpellLevel += 1; int nUses = 1; switch(nSpellLevel) { default: case 9: case 8: nUses = 1; break; case 7: case 6: nUses = 2; break; case 5: case 4: nUses = 3; break; case 3: case 2: nUses = 4; break; case 1: case 0: nUses = 5; break; } SetPersistantLocalInt(oCaster, "PRC_SLA_Uses_"+IntToString(nSLAID), nUses); DeleteLocalInt(oCaster, "PRC_SLA_Store"); return FALSE; } return TRUE; } int PnPSomaticComponents(object oCaster, object oSpellCastItem, string sComponent, int nMetamagic) { if(GetPRCSwitch(PRC_PNP_SOMATIC_COMPOMENTS) || GetPRCSwitch(PRC_PNP_SOMATIC_ITEMS)) { object oItem = GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oCaster); int nHandFree; if(!GetIsObjectValid(oItem) || GetBaseItemType(oItem) == BASE_ITEM_SMALLSHIELD || GetBaseItemType(oItem) == BASE_ITEM_MAGICWAND || GetBaseItemType(oItem) == BASE_ITEM_ENCHANTED_WAND) nHandFree = TRUE; oItem = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oCaster); if(!GetIsObjectValid(oItem) || GetBaseItemType(oItem) == BASE_ITEM_SMALLSHIELD || GetBaseItemType(oItem) == BASE_ITEM_MAGICWAND || GetBaseItemType(oItem) == BASE_ITEM_ENCHANTED_WAND) nHandFree = TRUE; if(GetHasFeat(FEAT_SOMATIC_WEAPONRY, oCaster)) nHandFree = TRUE; if(nMetamagic & METAMAGIC_STILL) nHandFree = TRUE; if(!nHandFree) { int nHandRequired; oItem = oSpellCastItem; //check item is not equiped if(GetIsObjectValid(oItem) && GetPRCSwitch(PRC_PNP_SOMATIC_ITEMS)) { nHandRequired = TRUE; int nSlot; for(nSlot = 0; nSlot < NUM_INVENTORY_SLOTS; nSlot++) { if(GetItemInSlot(nSlot, oCaster) == oItem) nHandRequired = FALSE; } } //check its a real spell and that it requires a free hand if(!GetIsObjectValid(oItem) && GetPRCSwitch(PRC_PNP_SOMATIC_COMPOMENTS)) { if(sComponent == "VS" || sComponent == "SV" || sComponent == "S") nHandRequired = TRUE; } if(nHandRequired) { FloatingTextStringOnCreature("You do not have any free hands.", oCaster, FALSE); // Items were being consumed anyway. This should stop it. AssignCommand(oItem, SetIsDestroyable(FALSE, FALSE, FALSE)); AssignCommand(oItem, DelayCommand(0.3, SetIsDestroyable(TRUE, FALSE, FALSE))); return FALSE; } } } return TRUE; } int PRCSpellEffects(object oCaster, object oTarget, int nSpellID, int nSpellLevel, int nCastingClass, int bSpellIsHostile, int nMetamagic) { // Pnp Tensers Transformation if(GetPRCSwitch(PRC_PNP_TENSERS_TRANSFORMATION)) { if(GetHasSpellEffect(SPELL_TENSERS_TRANSFORMATION, oCaster)) return FALSE; } // Gaseous Form check if(GetHasSpellEffect(SPELL_GASEOUS_FORM, oCaster)) { if(nMetamagic & METAMAGIC_STILL && nMetamagic & METAMAGIC_SILENT) { } else if(GetIsDivineClass(nCastingClass, oCaster) || GetIsArcaneClass(nCastingClass, oCaster)) return FALSE; } // Violet Rain check if(GetHasSpellEffect(SPELL_EVIL_WEATHER_VIOLET_RAIN, oCaster)) { if(GetIsDivineClass(nCastingClass, oCaster)) return FALSE; } // PnP Timestop if(GetPRCSwitch(PRC_TIMESTOP_NO_HOSTILE)) { if(GetHasSpellEffect(SPELL_TIME_STOP, oCaster) || GetHasSpellEffect(4032, oCaster) //epic spell: Greater Timestop || GetHasSpellEffect(14236, oCaster) //psionic power: Temporal Acceleration || GetHasSpellEffect(18428, oCaster)) //Mystery MYST_SHADOW_TIME { if(!GetIsObjectValid(oTarget) || oTarget != oCaster || bSpellIsHostile) { return FALSE; } } } // Spell Barriers if(GetHasSpellEffect(SPELL_OTILUKES_RESILIENT_SPHERE, oTarget)) { if(GetDistanceBetween(oCaster, oTarget) > 1.524) { return FALSE; } } if(GetHasSpellEffect(SPELL_PRISMATIC_SPHERE, oTarget)) { if(GetDistanceBetween(oCaster, oTarget) > 3.048) { return FALSE; } } // Null Psionics Field/Anti-Magic Field if(GetHasSpellEffect(SPELL_ANTIMAGIC_FIELD, oCaster) || GetHasSpellEffect(POWER_NULL_PSIONICS_FIELD, oCaster)) { return FALSE; } // Scrying blocks all powers except for a few special case ones. int nScry = GetLocalInt(oCaster, "ScrySpellId"); if(nScry) { if(nScry == SPELL_GREATER_SCRYING || nScry == 18415) // MYST_FAR_SIGHT { if(nSpellID != SPELL_DETECT_EVIL && nSpellID != SPELL_DETECT_GOOD && nSpellID != SPELL_DETECT_LAW && nSpellID != SPELL_DETECT_CHAOS) return FALSE; } if(nScry == POWER_CLAIRTANGENT_HAND) { if(nSpellID != POWER_FARHAND) return FALSE; } if(nScry == 18410) // MYST_EPHEMERAL_IMAGE return TRUE; // Can cast anything through this one. // By default you can't cast anything while scrying return FALSE; } // Word of Peace if(GetLocalInt(oCaster, "TrueWardOfPeace") && bSpellIsHostile) { return FALSE; } // Dark Discorporation Check if(GetLocalInt(oCaster, "DarkDiscorporation")) { return FALSE; } // Ectoplasmic Shambler if(GetLocalInt(oCaster, "PRC_IsInEctoplasmicShambler")) { if(!GetIsSkillSuccessful(oCaster, SKILL_CONCENTRATION, (15 + nSpellLevel))) { FloatingTextStrRefOnCreature(16824061, oCaster, FALSE); // "Ectoplasmic Shambler has disrupted your concentration." return FALSE; } } // Jarring Song if(GetHasSpellEffect(SPELL_VIRTUOSO_JARRING_SONG, oCaster)) { if(!GetIsSkillSuccessful(oCaster, SKILL_CONCENTRATION, (15 + nSpellLevel))) { FloatingTextStringOnCreature("Jarring Song has disrupted your concentration.", oCaster, FALSE); return FALSE; } } //Aura of the Sun - shadow spells make check or fail if(GetHasSpellEffect(SPELL_AURA_OF_THE_SUN)) { if(GetIsOfSubschool(nSpellID, SUBSCHOOL_SHADOW) || GetHasDescriptor(nSpellID, DESCRIPTOR_DARKNESS)) { int nDC = GetLocalInt(oCaster, "PRCAuraSunDC"); int nCheck = d20(1) + PRCGetCasterLevel(oCaster); //caster level check if(nCheck < nDC) return FALSE; } } return TRUE; } int Spellfire(object oCaster, object oTarget) { if(GetHasFeat(FEAT_SPELLFIRE_WIELDER, oCaster)) { int nStored = GetPersistantLocalInt(oCaster, "SpellfireLevelStored"); int nCON = GetAbilityScore(oCaster, ABILITY_CONSTITUTION); int nTest = nStored > 4 * nCON ? 25 : nStored > 3 * nCON ? 20 : 0; if(nTest) { if(!GetIsSkillSuccessful(oCaster, SKILL_CONCENTRATION, nTest)) return FALSE; } } if(GetLocalInt(oTarget, "SpellfireAbsorbFriendly") && GetIsFriend(oTarget, oCaster)) { if(CheckSpellfire(oCaster, oTarget, TRUE)) { PRCShowSpellResist(oCaster, oTarget, SPELL_RESIST_MANTLE); return FALSE; } } return TRUE; } int Wildstrike(object oCaster) { // 50% chance if(GetLocalInt(oCaster, "WildMageStrike") && d2() == 2) { AssignCommand(oCaster, ClearAllActions()); AssignCommand(oCaster, ActionCastSpell(499)); return FALSE; } return TRUE; } int CorruptOrSanctified(object oCaster, int nSpellID, int nCasterAlignment, int nSpellbookType) { //Check for each Corrupt and Sanctified spell int bCorruptOrSanctified = 0; if(nSpellID == SPELL_AYAILLAS_RADIANT_BURST || nSpellID == SPELL_BRILLIANT_EMANATION || nSpellID == SPELL_DIVINE_INSPIRATION || nSpellID == SPELL_DIAMOND_SPRAY || nSpellID == SPELL_DRAGON_CLOUD || nSpellID == SPELL_EXALTED_FURY || nSpellID == SPELL_HAMMER_OF_RIGHTEOUSNESS || nSpellID == SPELL_PHIERANS_RESOLVE || nSpellID == SPELL_PHOENIX_FIRE || nSpellID == SPELL_RAIN_OF_EMBERS || nSpellID == SPELL_SICKEN_EVIL || nSpellID == SPELL_STORM_OF_SHARDS || nSpellID == SPELL_SUNMANTLE || nSpellID == SPELL_TWILIGHT_LUCK) bCorruptOrSanctified = 1; else if(nSpellID == SPELL_ABSORB_STRENGTH || nSpellID == SPELL_APOCALYPSE_FROM_THE_SKY || nSpellID == SPELL_CLAWS_OF_THE_BEBILITH || nSpellID == SPELL_DEATH_BY_THORNS || nSpellID == SPELL_EVIL_WEATHER || nSpellID == SPELL_FANGS_OF_THE_VAMPIRE_KING || nSpellID == SPELL_LAHMS_FINGER_DARTS || nSpellID == SPELL_POWER_LEECH || nSpellID == SPELL_RAPTURE_OF_RUPTURE || nSpellID == SPELL_RED_FESTER || nSpellID == SPELL_ROTTING_CURSE_OF_URFESTRA || nSpellID == SPELL_SEETHING_EYEBANE || nSpellID == SPELL_TOUCH_OF_JUIBLEX) bCorruptOrSanctified = 2; if(bCorruptOrSanctified) { // check if the caster is a spontaneous caster if(nSpellbookType == SPELLBOOK_TYPE_SPONTANEOUS) { SendMessageToPC(oCaster, "Spontaneous casters cannot cast this spell!"); return FALSE; } //check for immunity to ability damage - sorry undead buddies if(GetIsImmune(oCaster, IMMUNITY_TYPE_ABILITY_DECREASE)) { if(nSpellID != SPELL_TWILIGHT_LUCK && nSpellID != SPELL_DIAMOND_SPRAY) { SendMessageToPC(oCaster, "You must be able to take ability damage to cast this spell!"); return FALSE; } } //Check for alignment restrictions if(bCorruptOrSanctified == 1 && nCasterAlignment == ALIGNMENT_EVIL) { SendMessageToPC(oCaster, "You cannot cast Sanctified spells if you are evil."); return FALSE; } if(bCorruptOrSanctified == 2 && nCasterAlignment == ALIGNMENT_GOOD) { SendMessageToPC(oCaster, "You cannot cast Corrupt spells if you are good."); return FALSE; } } return TRUE; } int GrappleConc(object oCaster, int nSpellLevel) { if(GetLocalInt(oCaster, "IsGrappled")) { return GetIsSkillSuccessful(oCaster, SKILL_CONCENTRATION, (20 + nSpellLevel)); } return TRUE; } int X2UseMagicDeviceCheck(object oCaster) { int nRet = ExecuteScriptAndReturnInt("x2_pc_umdcheck", oCaster); return nRet; } //------------------------------------------------------------------------------ // GZ: This is a filter I added to prevent spells from firing their original spell // script when they were cast on items and do not have special coding for that // case. If you add spells that can be cast on items you need to put them into // des_crft_spells.2da //------------------------------------------------------------------------------ int X2CastOnItemWasAllowed(object oItem) { int bAllow = (Get2DACache(X2_CI_CRAFTING_SP_2DA,"CastOnItems",PRCGetSpellId()) == "1"); if (!bAllow) { FloatingTextStrRefOnCreature(83453, OBJECT_SELF); // not cast spell on item } return bAllow; } //------------------------------------------------------------------------------ // Execute a user overridden spell script. //------------------------------------------------------------------------------ int X2RunUserDefinedSpellScript() { // See x2_inc_switches for details on this code string sScript = GetModuleOverrideSpellscript(); if (sScript != "") { ExecuteScript(sScript,OBJECT_SELF); if (GetModuleOverrideSpellScriptFinished() == TRUE) { return FALSE; } } return TRUE; } //------------------------------------------------------------------------------ // Set the user-specific spell script //------------------------------------------------------------------------------ void PRCSetUserSpecificSpellScript(string sScript) { SetLocalString(OBJECT_SELF, "PRC_OVERRIDE_SPELLSCRIPT", sScript); } //------------------------------------------------------------------------------ // Get the user-specific spell script //------------------------------------------------------------------------------ string PRCGetUserSpecificSpellScript() { return GetLocalString(OBJECT_SELF, "PRC_OVERRIDE_SPELLSCRIPT"); } //------------------------------------------------------------------------------ // Finish the spell, if necessary //------------------------------------------------------------------------------ void PRCSetUserSpecificSpellScriptFinished() { SetLocalInt(OBJECT_SELF, "PRC_OVERRIDE_SPELLSCRIPT_DONE", TRUE); } //------------------------------------------------------------------------------ // Figure out if we should finish the spell. //------------------------------------------------------------------------------ int PRCGetUserSpecificSpellScriptFinished() { int iRet = GetLocalInt(OBJECT_SELF, "PRC_OVERRIDE_SPELLSCRIPT_DONE"); DeleteLocalInt(OBJECT_SELF, "PRC_OVERRIDE_SPELLSCRIPT_DONE"); return iRet; } //------------------------------------------------------------------------------ // Run a user-specific spell script for classes that use spellhooking. //------------------------------------------------------------------------------ int PRCRunUserSpecificSpellScript() { string sScript = PRCGetUserSpecificSpellScript(); if (sScript != "") { ExecuteScript(sScript,OBJECT_SELF); if (PRCGetUserSpecificSpellScriptFinished() == TRUE) { return FALSE; } } return TRUE; } //------------------------------------------------------------------------------ // Created Brent Knowles, Georg Zoeller 2003-07-31 // Returns TRUE (and charges the sequencer item) if the spell // ... was cast on an item AND // ... the item has the sequencer property // ... the spell was non hostile // ... the spell was not cast from an item // in any other case, FALSE is returned an the normal spellscript will be run //------------------------------------------------------------------------------ int X2GetSpellCastOnSequencerItem(object oItem, object oCaster, int nSpellID, int nMetamagic, int nCasterLevel, int nSaveDC, int bSpellIsHostile, object oSpellCastItem) { if(GetIsObjectValid(oSpellCastItem)) // spell cast from item? { // we allow scrolls int nBt = GetBaseItemType(oSpellCastItem); if(nBt !=BASE_ITEM_SPELLSCROLL && nBt != 105) { FloatingTextStrRefOnCreature(83373, oCaster); return TRUE; // wasted! } } if(bSpellIsHostile) { int nMaxChanSpells = IPGetItemChannelingProperty(oItem); if(nMaxChanSpells < 1) { FloatingTextStrRefOnCreature(83885, oCaster); return TRUE; // no hostile spells on sequencers, sorry ya munchkins :) } int nNumberOfTriggers = GetLocalInt(oItem, "X2_L_NUMCHANNELTRIGGERS"); // is there still space left on the sequencer? if (nNumberOfTriggers < nMaxChanSpells) { // success visual and store spell-id on item. effect eVisual = EffectVisualEffect(VFX_IMP_BREACH); nNumberOfTriggers++; //NOTE: I add +1 to the SpellId to spell 0 can be used to trap failure int nSID = nSpellID+1; SetLocalInt(oItem, "X2_L_CHANNELTRIGGER" +IntToString(nNumberOfTriggers), nSID); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_L"+IntToString(nNumberOfTriggers), nCasterLevel); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_M"+IntToString(nNumberOfTriggers), nMetamagic); SetLocalInt(oItem, "X2_L_CHANNELTRIGGER_D"+IntToString(nNumberOfTriggers), nSaveDC); SetLocalInt(oItem, "X2_L_NUMCHANNELTRIGGERS", nNumberOfTriggers); //add an OnHit:DischargeSequencer property itemproperty ipTest = ItemPropertyOnHitCastSpell(IP_CONST_ONHIT_CASTSPELL_ONHIT_UNIQUEPOWER, 1); IPSafeAddItemProperty(oItem ,ipTest, 99999999.9); ApplyEffectToObject(DURATION_TYPE_INSTANT, eVisual, oCaster); FloatingTextStrRefOnCreature(83884, oCaster); } else FloatingTextStrRefOnCreature(83859, oCaster); } else { int nMaxSeqSpells = IPGetItemSequencerProperty(oItem); // get number of maximum spells that can be stored if(nMaxSeqSpells < 1) { return FALSE; } int nNumberOfTriggers = GetLocalInt(oItem, "X2_L_NUMTRIGGERS"); // is there still space left on the sequencer? if (nNumberOfTriggers < nMaxSeqSpells) { // success visual and store spell-id on item. effect eVisual = EffectVisualEffect(VFX_IMP_BREACH); nNumberOfTriggers++; //NOTE: I add +1 to the SpellId to spell 0 can be used to trap failure int nSID = nSpellID+1; SetLocalInt(oItem, "X2_L_SPELLTRIGGER" +IntToString(nNumberOfTriggers), nSID); SetLocalInt(oItem, "X2_L_SPELLTRIGGER_L"+IntToString(nNumberOfTriggers), nCasterLevel); SetLocalInt(oItem, "X2_L_SPELLTRIGGER_M"+IntToString(nNumberOfTriggers), nMetamagic); SetLocalInt(oItem, "X2_L_SPELLTRIGGER_D"+IntToString(nNumberOfTriggers), nSaveDC); SetLocalInt(oItem, "X2_L_NUMTRIGGERS", nNumberOfTriggers); ApplyEffectToObject(DURATION_TYPE_INSTANT, eVisual, oCaster); FloatingTextStrRefOnCreature(83884, oCaster); } else FloatingTextStrRefOnCreature(83859, oCaster); } return TRUE; // in any case, spell is used up from here, so do not fire regular spellscript } //------------------------------------------------------------------------------ // * This is our little concentration system for black blade of disaster // * if the mage tries to cast any kind of spell, the blade is signaled an event to die //------------------------------------------------------------------------------ void X2BreakConcentrationSpells() { //end Dragonsong Lyrist songs DeleteLocalInt(OBJECT_SELF, "SpellConc"); if(GetPRCSwitch(PRC_PNP_BLACK_BLADE_OF_DISASTER)) { //this is also in summon HB //but needed here to handle quickend spells //Disintegrate is cast from the blade so doenst end the summon object oAssoc = GetAssociate(ASSOCIATE_TYPE_SUMMONED); if(GetIsObjectValid(oAssoc)) { if(GetTag(oAssoc) == "x2_s_bblade") // black blade of disaster { if(GetLocalInt(oAssoc, "X2_L_CREATURE_NEEDS_CONCENTRATION")) { SignalEvent(oAssoc, EventUserDefined(X2_EVENT_CONCENTRATION_BROKEN)); } } } } } //------------------------------------------------------------------------------ // being hit by any kind of negative effect affecting the caster's ability to concentrate // will cause a break condition for concentration spells //------------------------------------------------------------------------------ int X2GetBreakConcentrationCondition(object oPlayer) { effect e1 = GetFirstEffect(oPlayer); int nType; int bRet = FALSE; while (GetIsEffectValid(e1) && !bRet) { nType = GetEffectType(e1); if (nType == EFFECT_TYPE_STUNNED || nType == EFFECT_TYPE_PARALYZE || nType == EFFECT_TYPE_SLEEP || nType == EFFECT_TYPE_FRIGHTENED || nType == EFFECT_TYPE_PETRIFY || nType == EFFECT_TYPE_CONFUSED || nType == EFFECT_TYPE_DOMINATED || nType == EFFECT_TYPE_POLYMORPH) { bRet = TRUE; } e1 = GetNextEffect(oPlayer); } return bRet; } void X2DoBreakConcentrationCheck() { object oMaster = GetMaster(); if (GetLocalInt(OBJECT_SELF,"X2_L_CREATURE_NEEDS_CONCENTRATION")) { if (GetIsObjectValid(oMaster)) { int nAction = GetCurrentAction(oMaster); // master doing anything that requires attention and breaks concentration if (nAction == ACTION_DISABLETRAP || nAction == ACTION_TAUNT || nAction == ACTION_PICKPOCKET || nAction ==ACTION_ATTACKOBJECT || nAction == ACTION_COUNTERSPELL || nAction == ACTION_FLAGTRAP || nAction == ACTION_CASTSPELL || nAction == ACTION_ITEMCASTSPELL) { SignalEvent(OBJECT_SELF,EventUserDefined(X2_EVENT_CONCENTRATION_BROKEN)); } else if (X2GetBreakConcentrationCondition(oMaster)) { SignalEvent(OBJECT_SELF,EventUserDefined(X2_EVENT_CONCENTRATION_BROKEN)); } } } } //------------------------------------------------------------------------------ // This function will return TRUE if the spell that is cast is a shape shifting // spell. //------------------------------------------------------------------------------ int X3ShapeShiftSpell(object oTarget, int nSpellID) { string sUp = GetStringUpperCase(Get2DACache("x3restrict", "SHAPESHIFT", nSpellID)); if(sUp == "YES") return TRUE; return FALSE; } void VoidCounterspellExploitCheck(object oCaster) { if(GetCurrentAction(oCaster) == ACTION_COUNTERSPELL) { ClearAllActions(); SendMessageToPC(oCaster,"Because of the infinite spell casting exploit, you cannot use counterspell in this manner."); } } int CounterspellExploitCheck(object oCaster) { if(GetCurrentAction(oCaster) == ACTION_COUNTERSPELL) { ClearAllActions(); SendMessageToPC(oCaster,"Because of the infinite spell casting exploit, you cannot use counterspell in this manner."); return FALSE; } else { DelayCommand(0.1, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.2, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.3, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.4, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.5, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.6, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.7, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.8, VoidCounterspellExploitCheck(oCaster)); DelayCommand(0.9, VoidCounterspellExploitCheck(oCaster)); DelayCommand(1.0, VoidCounterspellExploitCheck(oCaster)); DelayCommand(2.0, VoidCounterspellExploitCheck(oCaster)); DelayCommand(3.0, VoidCounterspellExploitCheck(oCaster)); } return TRUE; } int Blighter(object oCaster, int nCastingClass, object oSpellCastItem) { // If it's an item, exit if (GetIsObjectValid(oSpellCastItem)) return TRUE; if (nCastingClass == CLASS_TYPE_DRUID && GetLevelByClass(CLASS_TYPE_BLIGHTER, oCaster) > 0) { SendMessageToPC(oCaster,"Blighters cannot cast druid spells."); return FALSE; } return TRUE; } int BattleBlessing(object oCaster, int nCastingClass) { if (nCastingClass != CLASS_TYPE_PALADIN && GetLocalInt(oCaster, "BattleBlessingActive")) { SendMessageToPC(oCaster,"You cannot cast non-Paladin spells with Battle Blessing active."); return FALSE; } return TRUE; } int Spelldance(object oCaster, int nSpellLevel, int nCastingClass) { //ensure the spell is arcane if(!GetIsArcaneClass(nCastingClass, oCaster)) return TRUE; if (DEBUG) FloatingTextStringOnCreature("Spelldance in Spellhook", oCaster, FALSE); int nDance = GetLocalInt(oCaster, "Spelldance"); if (DEBUG) FloatingTextStringOnCreature("Spelldance value in Spellhook: "+IntToString(nDance), oCaster, FALSE); if (nDance) { if(nDance & METAMAGIC_EXTEND) nSpellLevel += 1; if(nDance & METAMAGIC_EMPOWER) nSpellLevel += 2; if(nDance & METAMAGIC_MAXIMIZE) nSpellLevel += 3; if (DEBUG) FloatingTextStringOnCreature("Spelldances in Spellhook #2", oCaster, FALSE); if(!GetIsSkillSuccessful(oCaster, SKILL_PERFORM, 10+nSpellLevel)) //Failed { FloatingTextStringOnCreature("Spelldance failed", oCaster, FALSE); if (DEBUG) FloatingTextStringOnCreature("Spelldances in Spellhook #3", oCaster, FALSE); return FALSE; } } return TRUE; } // Does the counterspelling for Warp Spell, // and the storing of the spell for later use int WarpSpell(object oCaster, int nSpellId) { int nWarp = GetLocalInt(oCaster, "WarpSpell"); // If Warp Spell isn't set, just keep going if (!nWarp) return TRUE; object oShadow = GetLocalObject(oCaster, "WarpSpell"); // The one who cast Warp Spell DeleteLocalInt(oCaster, "WarpSpell"); DeleteLocalObject(oCaster, "WarpSpell"); // Done regardless of success or failure int nLevel = PRCGetCasterLevel(oCaster); if (d20() + nWarp > d20() + nLevel) // Won the caster level check { // Set a marker on the Shadowcaster SetLocalInt(oShadow, "WarpSpellSuccess", TRUE); FloatingTextStringOnCreature("You have successfully warped your opponent's "+GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nSpellId))), oShadow, FALSE); ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_SOUL_TRAP), oCaster); return FALSE; } FloatingTextStringOnCreature("Your warp spell has failed", oShadow, FALSE); return TRUE; } // Does the counterspelling for Innate Counterspell // and the storing of the spell for later use int InnateCounterspell(object oCaster, int nSpellId, int nSpellLevel) { int nWarp = GetLocalInt(oCaster, "InnateCounterspell"); // If Innate Counterspell isn't set, just keep going if (!nWarp) return TRUE; object oShadow = GetLocalObject(oCaster, "InnateCounterspell"); // The one who cast Innate Counterspell DeleteLocalInt(oCaster, "InnateCounterspell"); DeleteLocalObject(oCaster, "InnateCounterspell"); // Done regardless of success or failure int nLevel = PRCGetCasterLevel(oCaster); if (GetIsSkillSuccessful(oCaster, SKILL_SPELLCRAFT, 15 + nSpellLevel)) // Identified the spell to counter { SetLocalInt(oShadow, "BurnSpellLevel", nSpellLevel); if (BurnSpell(oShadow)) { DeleteLocalInt(oShadow, "BurnSpellLevel"); // Set a marker on the Noctumancer at the right level if (GetLevelByClass(CLASS_TYPE_NOCTUMANCER) >= 7) { int nStore = min(1, nSpellLevel/2); SetLocalInt(oShadow, "InnateCounterSuccess", nStore); FloatingTextStringOnCreature("You have one free mystery of "+IntToString(nStore)+" level", oShadow, FALSE); } if (GetLevelByClass(CLASS_TYPE_NOCTUMANCER) >= 10) ApplyEffectToObject(DURATION_TYPE_TEMPORARY, SupernaturalEffect(EffectSpellImmunity(nSpellId)), oShadow, 60.0); FloatingTextStringOnCreature("You have successfully counterspelled your opponent's "+GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nSpellId))), oShadow, FALSE); ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_SOUL_TRAP), oCaster); return FALSE; } } FloatingTextStringOnCreature("Your innate counterspell has failed", oShadow, FALSE); return TRUE; } // Stores the spell for use with Echo Spell void EchoSpell(object oCaster, int nSpellId) { int nEcho = GetLocalInt(oCaster, "EchoSpell"); // If Echo Spell isn't set, just skip if (nEcho) { object oShadow = GetLocalObject(oCaster, "EchoSpell"); // The one who cast Echo Spell SetLocalInt(oShadow, "EchoedSpell", nSpellId); FloatingTextStringOnCreature("You have echoed " + GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nSpellId))) + " and have one round to cast it", oShadow, FALSE); DelayCommand(9.0, DeleteLocalInt(oShadow, "EchoedSpell")); DeleteLocalInt(oCaster, "EchoSpell"); DeleteLocalObject(oCaster, "EchoSpell"); } } // Flood of Shadow int FloodShadow(object oCaster, int nSpellId) { if (!GetLocalInt(oCaster, "FloodShadow") || GetLocalInt(oCaster, "ShadowEvoking")) return TRUE; if (!GetIsSkillSuccessful(oCaster, SKILL_SPELLCRAFT, 15 + StringToInt(Get2DACache("spells", "Innate", nSpellId)))) // Skill check { if (GetIsPC(oCaster)) FloatingTextStringOnCreature("You have failed to overcome Flood of Shadow", oCaster, FALSE); return FALSE; } return TRUE; } void MasterWand(object oCaster, object oSpellCastItem, int nSpellLevel) { if (DEBUG) DoDebug("MasterWand - Entered"); if (!GetHasFeat(FEAT_MASTER_WAND, oCaster)) return; // Does nothing without the feat, obviously if (!GetLocalInt(oCaster, "MasterWand")) return; // Needs to be active as well if (DEBUG) DoDebug("MasterWand - Active"); int nType = GetBaseItemType(oSpellCastItem); if(nType == BASE_ITEM_MAGICWAND || nType == BASE_ITEM_ENCHANTED_WAND) // Has to be a wand, obv { if (DEBUG) DoDebug("MasterWand - Wand"); SetLocalInt(oCaster, "BurnSpellLevel", nSpellLevel); if (BurnSpell(oCaster)) // Burn a spell of the appropriate level { if (DEBUG) DoDebug("MasterWand - Burned Spell"); DeleteLocalInt(oCaster, "BurnSpellLevel"); SetItemCharges(oSpellCastItem, GetItemCharges(oSpellCastItem)+1); // add the use back to the item } } } int WandEquipped(object oCaster, object oSpellCastItem) { //if (!GetPRCSwitch(PRC_EQUIP_WAND)) return TRUE; // If this is set to anything other than 0, it skips the check. int nType = GetBaseItemType(oSpellCastItem); if(nType == BASE_ITEM_MAGICWAND || nType == BASE_ITEM_ENCHANTED_WAND) // Has to be a wand, obv { if(GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oCaster) == oSpellCastItem || GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oCaster) == oSpellCastItem) // Needs to be equipped { return TRUE; } else { FloatingTextStringOnCreature("You must equip a wand to cast from it.", oCaster, FALSE); return FALSE; // It's a wand not equipped } } return TRUE; } void DoubleWandWielder(object oCaster, object oSpellCastItem, object oTarget) { if (!GetHasFeat(FEAT_DOUBLE_WAND_WIELDER, oCaster)) return; // Does nothing without the feat, obviously if (!GetLocalInt(oCaster, "DoubleWand")) return; // Needs to be active as well int nType = GetBaseItemType(oSpellCastItem); if(nType == BASE_ITEM_MAGICWAND || nType == BASE_ITEM_ENCHANTED_WAND) // Has to be a wand, obv { object oOffHand; if(GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oCaster) == oSpellCastItem) // Find the other hand oOffHand = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oCaster); else oOffHand = GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oCaster); int nOffType = GetBaseItemType(oOffHand); if(nOffType == BASE_ITEM_MAGICWAND || nOffType == BASE_ITEM_ENCHANTED_WAND) // Has to be a wand, obv { int nCharges = GetItemCharges(oOffHand); if (nCharges > 1) // Need to have enough charges for this { //code for getting new ip type int nCasterLevel; int nSpell; itemproperty ipTest = GetFirstItemProperty(oOffHand); while(GetIsItemPropertyValid(ipTest)) { if(GetItemPropertyType(ipTest) == ITEM_PROPERTY_CAST_SPELL_CASTER_LEVEL) { nCasterLevel = GetItemPropertyCostTableValue(ipTest); if (DEBUG) DoDebug("DoubleWandWielder: caster level from item = "+IntToString(nCasterLevel)); } if(GetItemPropertyType(ipTest) == ITEM_PROPERTY_CAST_SPELL) { nSpell = GetItemPropertySubType(ipTest); if (DEBUG) DoDebug("DoubleWandWielder: iprop subtype = "+IntToString(nSpell)); nSpell = StringToInt(Get2DACache("iprp_spells", "SpellIndex", nSpell)); if (DEBUG) DoDebug("DoubleWandWielder: spell from item = "+IntToString(nSpell)); } ipTest = GetNextItemProperty(oOffHand); } // if we didn't find a caster level on the item, it must be Bioware item casting if(!nCasterLevel) { nCasterLevel = GetCasterLevel(oCaster); if (DEBUG) DoDebug("DoubleWandWielder: bioware item casting with caster level = "+IntToString(nCasterLevel)); } ActionCastSpell(nSpell, nCasterLevel, 0, 0, METAMAGIC_NONE, CLASS_TYPE_INVALID, FALSE, FALSE, oTarget, TRUE); SetItemCharges(oOffHand, nCharges - 2); } } } } void MeldArcaneFocus(object oCaster, object oTarget) { int nDC = GetLocalInt(oCaster, "ArcaneFocusBound"); if (nDC) // MELD_ARCANE_FOCUS { if(!PRCMySavingThrow(SAVING_THROW_WILL, oTarget, nDC, SAVING_THROW_TYPE_SPELL)) ApplyEffectToObject(DURATION_TYPE_TEMPORARY, EffectDazed(), oTarget, 6.0); } } // Does the caster level check for Witchborn Binder's Mage Shackles int MageShackles(object oCaster, int nSpellId) { int nWarp = GetLocalInt(oCaster, "MageShackles"); // If Mage Shackles aren't present, just keep going if (!nWarp) return TRUE; object oMeldshaper = GetLocalObject(oCaster, "MageShacklesShaper"); // The one who created the Shackles int nLevel = PRCGetCasterLevel(oCaster); if (nWarp > PRCGetCasterLevel(oCaster)+d20()) // Do they beat the DC for the caster level check or not? { FloatingTextStringOnCreature("Your mage shackles have successfully blocked your opponent's "+GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nSpellId))), oMeldshaper, FALSE); ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_SOUL_TRAP), oCaster); return FALSE; } return TRUE; } // Does the counterspelling for Word of Abrogation int Abrogation(object oCaster, int nCasterLevel, int nSpellId) { location lTarget = GetLocation(oCaster); int nCnt = 1; // Find the meldshaper object oMeldshaper = GetNearestCreatureToLocation(CREATURE_TYPE_PLAYER_CHAR, PLAYER_CHAR_IS_PC, lTarget, nCnt); while(GetIsObjectValid(oMeldshaper) && GetDistanceBetween(oMeldshaper, oCaster) <= FeetToMeters(60.0f)) { int nWarp = GetLocalInt(oMeldshaper, "Abrogation"); if(nWarp) { // Clean up the ability DeleteLocalInt(oMeldshaper, "Abrogation"); PRCRemoveSpellEffects(MELD_WITCH_ABROGATION, oMeldshaper, oMeldshaper); GZPRCRemoveSpellEffects(MELD_WITCH_ABROGATION, oMeldshaper, FALSE); if (nWarp+d20() >= nCasterLevel+11) // Do you beat their caster level? { FloatingTextStringOnCreature("Your word of abrogation has successfully blocked your opponent's "+GetStringByStrRef(StringToInt(Get2DACache("spells", "Name", nSpellId))), oMeldshaper, FALSE); ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_SOUL_TRAP), oCaster); return FALSE; } else FloatingTextStringOnCreature("Your word of abrogation has failed", oMeldshaper, FALSE); } nCnt++; oMeldshaper = GetNearestCreatureToLocation(CREATURE_TYPE_PLAYER_CHAR, PLAYER_CHAR_IS_PC, lTarget, nCnt); } return TRUE; } // Does damage for Grim Integument void Integument(object oCaster, int nCastingClass) { if (GetIsArcaneClass(nCastingClass) && GetHasSpellEffect(MELD_WITCH_INTEGUMENT, oCaster)) { int nEssentia = GetLocalInt(oCaster, "GIEssentia"); object oMeldshaper = GetLocalObject(oCaster, "GIMeldshaper"); // The one who created the Shackles int nDC = 10 + nEssentia + GetAbilityModifier(ABILITY_CONSTITUTION, oMeldshaper); int nDam = d6(nEssentia); if(PRCMySavingThrow(SAVING_THROW_FORT, oCaster, nDC, SAVING_THROW_TYPE_NONE)) { if (GetHasMettle(oCaster, SAVING_THROW_FORT)) nDam = 0; nDam /= 2; } ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectDamage(nDam, DAMAGE_TYPE_POSITIVE), oCaster); } } void WyrmbaneFrightful(object oPC) { object oWOL = GetItemPossessedBy(oPC, "WOL_Wyrmbane"); // You get nothing if you aren't wielding the legacy item if(oWOL != GetItemInSlot(INVENTORY_SLOT_HEAD, oPC)) return; if (GetHasFeat(FEAT_GREATER_LEGACY, oPC)) ExecuteScript("prc_fright_pres", oPC); } int Nondetection(object oTarget, object oCaster, int nSchool, int nCasterLevel) { int nReturn = TRUE; if (nSchool == SPELL_SCHOOL_DIVINATION) { if(GetHasSpellEffect(SPELL_NONDETECTION, oTarget) || GetLevelByClass(CLASS_TYPE_WILD_MAGE, oTarget) >= 6 || GetLevelByClass(CLASS_TYPE_UNSEEN_SEER, oTarget) >= 5 || GetHasSpellEffect(MELD_ENIGMA_HELM, oTarget) || GetRacialType(oTarget) == RACIAL_TYPE_SKULK) { // Caster level check or the Divination fails. int nTarget = PRCGetCasterLevel(oTarget) + 11; if (GetRacialType(oTarget) == RACIAL_TYPE_SKULK && 20 > nTarget) nTarget = 20; if(nTarget > nCasterLevel + d20()) { FloatingTextStringOnCreature(GetName(oTarget) + " has Nondetection active.", oCaster, FALSE); return FALSE; } } } return nReturn; } int AmonInfluence(object oTarget, object oCaster, int nSpellId, int nSpellLevel, int bSpellIsHostile) { // Have to have a bad pact with Amon for this to trigger on beneficial spells if (GetHasSpellEffect(VESTIGE_AMON, oTarget) && !GetLocalInt(oTarget, "PactQuality"+IntToString(VESTIGE_AMON)) && !bSpellIsHostile) { // Law, fire, and sun domain casters if (GetHasFeat(FEAT_FIRE_DOMAIN_POWER, oCaster) || GetHasFeat(FEAT_SUN_DOMAIN_POWER, oCaster)) { if(PRCMySavingThrow(SAVING_THROW_WILL, oTarget, PRCGetSaveDC(oTarget, oCaster, nSpellId), SAVING_THROW_TYPE_SPELL)) { FloatingTextStringOnCreature("You have made a poor pact, and Amon forces you to resist the spell", oTarget, FALSE); return FALSE; }//end will save processing } } return TRUE; } int RonoveInfluence(object oCaster, object oSpellCastItem) { if (GetHasSpellEffect(VESTIGE_RONOVE, oCaster) && !GetLocalInt(oCaster, "PactQuality"+IntToString(VESTIGE_RONOVE))) { if(GetIsObjectValid(oSpellCastItem)) { // Potion drinking is restricted if(GetBaseItemType(oSpellCastItem) == BASE_ITEM_ENCHANTED_POTION || GetBaseItemType(oSpellCastItem) == BASE_ITEM_POTIONS) return FALSE; } } return TRUE; } int HaagentiTransmutation(object oTarget, int nSpellID) { if (GetHasSpellEffect(VESTIGE_HAAGENTI, oTarget) && GetLocalInt(oTarget, "ExploitVestige") != VESTIGE_HAAGENTI_IMMUNE_TRANS) { if(GetIsOfSubschool(nSpellID, SUBSCHOOL_POLYMORPH)) return FALSE; } return TRUE; } int KarsiteInability(object oCaster, int nCastingClass) { if (GetRacialType(oCaster) == RACIAL_TYPE_KARSITE) { if(GetIsDivineClass(nCastingClass, oCaster) || GetIsArcaneClass(nCastingClass, oCaster)) return FALSE; } return TRUE; } int UrCleric(object oCaster, int nCastingClass) { if (GetLevelByClass(CLASS_TYPE_UR_PRIEST, oCaster) && GetIsDivineClass(nCastingClass, oCaster) && nCastingClass != CLASS_TYPE_UR_PRIEST) { return FALSE; } return TRUE; } int ShadowWeaveLightSpells(object oCaster, int nSpellID) { if(GetHasDescriptor(nSpellID, DESCRIPTOR_LIGHT) && GetHasFeat(FEAT_SHADOWWEAVE, oCaster)) { return FALSE; } return TRUE; } void ArkamoiStrength(object oCaster, int nCastingClass) { // This race only if (GetRacialType(oCaster) != RACIAL_TYPE_ARKAMOI) return; int nStrength = GetLocalInt(oCaster, "StrengthFromMagic"); // Only applies to arcane spells if (GetIsArcaneClass(nCastingClass, oCaster)) { // First time here if (!nStrength) { SetLocalInt(oCaster, "StrengthFromMagic", 1); DelayCommand(60.0, DeleteLocalInt(oCaster, "StrengthFromMagic")); DelayCommand(60.0, FloatingTextStringOnCreature("Arkamoi Strength from Magic reset", oCaster, FALSE)); } else if (5 > nStrength) // nStrength equals something, can't go above five SetLocalInt(oCaster, "StrengthFromMagic", nStrength + 1); PRCRemoveSpellEffects(SPELL_ARKAMOI_STRENGTH, oCaster, oCaster); GZPRCRemoveSpellEffects(SPELL_ARKAMOI_STRENGTH, oCaster, FALSE); ActionCastSpellOnSelf(SPELL_ARKAMOI_STRENGTH); FloatingTextStringOnCreature("Arkamoi Strength from Magic at "+IntToString(nStrength+1), oCaster, FALSE); } } void RedspawnHealing(object oCaster, int nSpellID, int nSpellLevel) { if(GetHasDescriptor(nSpellID, DESCRIPTOR_FIRE) && GetRacialType(oCaster) == RACIAL_TYPE_REDSPAWN_ARCANISS) { ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectHeal(nSpellLevel*2), oCaster); } } // this will execute the prespellcastcode, whose full functionality is incoded in X2PreSpellCastCode2(), // as a script, to save loading time for spells scripts and reduce memory usage of NWN // the prespellcode takes up roughly 250 kByte compiled code, meaning that every spell script that // calls it directly as a function (e.g.: X2PreSpellCastCode2) will be between 100 kByte to 250 kByte // larger, than a spell script calling the prespellcode via ExecuteScript (e.g. X2PreSpellCastCode) // Although ExecuteScript is slightly slower than a direct function call, quite likely overall performance is // increased, because for every new spell 100-250 kByte less code need to be loaded into memory // and NWN has more free memory available to keep more spells scripts (and other crucial scripts) //in RAM /*int X2PreSpellCastCode() { object oCaster = OBJECT_SELF; // SetLocalInt(oCaster, "PSCC_Ret", 0); ExecuteScript("prc_prespell", oCaster); int nReturn = GetLocalInt(oCaster, "PSCC_Ret"); // DeleteLocalInt(oCaster, "PSCC_Ret"); return nReturn; } moved to prc_spellhook */ //------------------------------------------------------------------------------ // if FALSE is returned by this function, the spell will not be cast // the order in which the functions are called here DOES MATTER, changing it // WILL break the crafting subsystems //------------------------------------------------------------------------------ int X2PreSpellCastCode2() { object oCaster = OBJECT_SELF; object oTarget = PRCGetSpellTargetObject(); object oSpellCastItem = PRCGetSpellCastItem(); int nOrigSpellID = GetSpellId(); int nSpellID = PRCGetSpellId(); int nCastingClass = PRCGetLastSpellCastClass(); int nSpellLevel = PRCGetSpellLevelForClass(nSpellID, nCastingClass); int nSchool = GetSpellSchool(nSpellID); int nCasterLevel = PRCGetCasterLevel(oCaster); int nMetamagic = PRCGetMetaMagicFeat(oCaster, FALSE); int nSaveDC = PRCGetSaveDC(OBJECT_INVALID, oCaster); int bSpellIsHostile = Get2DACache("spells", "HostileSetting", nOrigSpellID) == "1"; int nSpellbookType = GetSpellbookTypeForClass(nCastingClass); int nCasterAlignment = GetAlignmentGoodEvil(oCaster); string sComponent = GetStringUpperCase(Get2DACache("spells", "VS", nSpellID)); //--------------------------------------------------------------------------- // This small addition will check to see if the target is mounted and the // spell is therefor one that should not be permitted. //--------------------------------------------------------------------------- if(!GetLocalInt(GetModule(),"X3_NO_SHAPESHIFT_SPELL_CHECK")) { if(PRCHorseGetIsMounted(oTarget) && X3ShapeShiftSpell(oTarget, nSpellID)) { if(GetIsPC(oTarget)) { FloatingTextStrRefOnCreature(111982,oTarget,FALSE); } return FALSE; } } int nContinue = !ExecuteScriptAndReturnInt("prespellcode", oCaster); //--------------------------------------------------------------------------- // Now check if we cast from an item (scroll, staff etc) //--------------------------------------------------------------------------- if(GetIsObjectValid(oSpellCastItem)) { //--------------------------------------------------------------------------- // Check for the new restricted itemproperties //--------------------------------------------------------------------------- if(nContinue && !CheckPRCLimitations(oSpellCastItem, oCaster)) { SendMessageToPC(oCaster, "You cannot use "+GetName(oSpellCastItem)); nContinue = FALSE; } //--------------------------------------------------------------------------- // Baelnorn attempting to use items while projection //--------------------------------------------------------------------------- if(nContinue && GetLocalInt(oCaster, "BaelnornProjection_Active"))// If projection is active AND { nContinue = FALSE; // Prevent casting } //casting from staffs uses caster DC calculations if(nContinue && (GetBaseItemType(oSpellCastItem) == BASE_ITEM_MAGICSTAFF || GetBaseItemType(oSpellCastItem) == BASE_ITEM_CRAFTED_STAFF) && GetPRCSwitch(PRC_STAFF_CASTER_LEVEL)) { int nDC = 10 + StringToInt(lookup_spell_innate(nSpellID)); nDC += (GetAbilityScoreForClass(GetPrimaryArcaneClass(oCaster), oCaster)-10)/2; SetLocalInt(oCaster, PRC_DC_BASE_OVERRIDE, nDC); DelayCommand(0.01, DeleteLocalInt(oCaster, PRC_DC_BASE_OVERRIDE)); } } //--------------------------------------------------------------------------- // Break any spell require maintaining concentration //--------------------------------------------------------------------------- X2BreakConcentrationSpells(); //--------------------------------------------------------------------------- // No casting while using expertise //--------------------------------------------------------------------------- if(nContinue) if (GetActionMode(oCaster, ACTION_MODE_EXPERTISE) || GetActionMode(oCaster, ACTION_MODE_IMPROVED_EXPERTISE)) { SendMessageToPC(oCaster, "Combat Expertise only works with attack actions."); nContinue = FALSE; } //--------------------------------------------------------------------------- // Run Spelldance perform check //--------------------------------------------------------------------------- if(nContinue) nContinue = Spelldance(oCaster, nSpellLevel, nCastingClass); //--------------------------------------------------------------------------- // Check for PRC spell effects //--------------------------------------------------------------------------- if(nContinue) nContinue = PRCSpellEffects(oCaster, oTarget, nSpellID, nSpellLevel, nCastingClass, bSpellIsHostile, nMetamagic); //--------------------------------------------------------------------------- // Run Grappling Concentration Check //--------------------------------------------------------------------------- if(nContinue) nContinue = GrappleConc(oCaster, nSpellLevel); //--------------------------------------------------------------------------- // Blighters stop Druid casting //--------------------------------------------------------------------------- if(nContinue) nContinue = Blighter(oCaster, nCastingClass, oSpellCastItem); //--------------------------------------------------------------------------- // Karsite stop Arcane/Divine casting //--------------------------------------------------------------------------- if(nContinue) nContinue = KarsiteInability(oCaster, nCastingClass); //--------------------------------------------------------------------------- // Ur-Priest stops cleric casting //--------------------------------------------------------------------------- if(nContinue) nContinue = UrCleric(oCaster, nCastingClass); //--------------------------------------------------------------------------- // Shadow Weave blocks casting light descriptor spells //--------------------------------------------------------------------------- if(nContinue) nContinue = ShadowWeaveLightSpells(oCaster, nSpellID); //--------------------------------------------------------------------------- // Forsakers cancel friendly casting //--------------------------------------------------------------------------- if(nContinue) nContinue = Forsaker(oCaster, oTarget); //--------------------------------------------------------------------------- // Battle Blessing stops non-Paladin casting //--------------------------------------------------------------------------- if(nContinue) nContinue = BattleBlessing(oCaster, nCastingClass); //--------------------------------------------------------------------------- // Nondetection can block divinations //--------------------------------------------------------------------------- if (nContinue) nContinue = Nondetection(oTarget, oCaster, nSchool, nCasterLevel); //--------------------------------------------------------------------------- // Mystery Effects //--------------------------------------------------------------------------- if (nContinue) nContinue = WarpSpell(oCaster, nSpellID); if (nContinue) nContinue = InnateCounterspell(oCaster, nSpellID, nSpellLevel); if (nContinue) nContinue = FloodShadow(oCaster, nSpellID); //--------------------------------------------------------------------------- // Incarnum Effects //--------------------------------------------------------------------------- if (nContinue) nContinue = MageShackles(oCaster, nSpellID); if (nContinue) nContinue = Abrogation(oCaster, nCasterLevel, nSpellID); //--------------------------------------------------------------------------- // Binding Effects //--------------------------------------------------------------------------- if (nContinue) nContinue = AmonInfluence(oTarget, oCaster, nSpellID, nSpellLevel, bSpellIsHostile); if (nContinue) nContinue = RonoveInfluence(oCaster, oSpellCastItem); if (nContinue) nContinue = HaagentiTransmutation(oTarget, nSpellID); //--------------------------------------------------------------------------- // Check for Corrupt or Sanctified spells //--------------------------------------------------------------------------- if(nContinue) nContinue = CorruptOrSanctified(oCaster, nSpellID, nCasterAlignment, nSpellbookType); //--------------------------------------------------------------------------- // Run Knight of the Chalice Heavenly Devotion check //--------------------------------------------------------------------------- if(nContinue) nContinue = KOTCHeavenDevotion(oCaster, oTarget, nCasterAlignment, nSchool); //--------------------------------------------------------------------------- // Spellfire //--------------------------------------------------------------------------- if(nContinue) nContinue = Spellfire(oCaster, oTarget); //--------------------------------------------------------------------------- // This stuff is only interesting for player characters we assume that use // magic device always works and NPCs don't use the crafting feats or // sequencers anyway. Thus, any NON PC spellcaster always exits this script // with TRUE (unless they are DM possessed or in the Wild Magic Area in // Chapter 2 of Hordes of the Underdark. //--------------------------------------------------------------------------- int bIsPC = GetIsPC(oCaster) || GetPRCSwitch(PRC_NPC_HAS_PC_SPELLCASTING) || GetIsDMPossessed(oCaster) || GetLocalInt(GetArea(oCaster), "X2_L_WILD_MAGIC"); if(bIsPC) { //--------------------------------------------------------------------------- // Run Bard/Sorc PrC check //--------------------------------------------------------------------------- if(nContinue) nContinue = BardSorcPrCCheck(oCaster, nCastingClass, oSpellCastItem); //--------------------------------------------------------------------------- // Equipped Wand switches //--------------------------------------------------------------------------- if(nContinue) nContinue = WandEquipped(oCaster, oSpellCastItem); //--------------------------------------------------------------------------- // Alignment Restrictions Check //--------------------------------------------------------------------------- if (nContinue) nContinue = SpellAlignmentRestrictions(oCaster, nSpellID, nCastingClass); //--------------------------------------------------------------------------- // Druid spontaneous summoning //--------------------------------------------------------------------------- if(nContinue) nContinue = DruidSpontSummon(oCaster, nCastingClass, nSpellID, nSpellLevel); //--------------------------------------------------------------------------- // Run New Spellbook Spell Check //--------------------------------------------------------------------------- if (nContinue) nContinue = NSB_SpellCast(oCaster, nSpellID, nCastingClass, nMetamagic, nSpellbookType, sComponent, oSpellCastItem); //--------------------------------------------------------------------------- // Run counterspell exploit check //--------------------------------------------------------------------------- if(nContinue) nContinue = CounterspellExploitCheck(oCaster); //--------------------------------------------------------------------------- // PnP spellschools //--------------------------------------------------------------------------- if(nContinue) nContinue = PnPSpellSchools(oCaster, nCastingClass, nSchool, oSpellCastItem); //--------------------------------------------------------------------------- // Run Red Wizard School Restriction Check //--------------------------------------------------------------------------- if(nContinue) nContinue = RedWizRestrictedSchool(oCaster, nSchool, nCastingClass, oSpellCastItem); //--------------------------------------------------------------------------- // PnP somatic components //--------------------------------------------------------------------------- if(nContinue) nContinue = PnPSomaticComponents(oCaster, oSpellCastItem, sComponent, nMetamagic); //----------------------------------------------------------------------- // Shifting casting restrictions //----------------------------------------------------------------------- if(nContinue) nContinue = ShifterCasting(oCaster, oSpellCastItem, nSpellLevel, nMetamagic, sComponent); //--------------------------------------------------------------------------- // Run Material Component Check //--------------------------------------------------------------------------- if(nContinue) nContinue = MaterialComponents(oCaster, nSpellID, nCastingClass, oSpellCastItem); //--------------------------------------------------------------------------- // Run Class Spell-like-ability Check //--------------------------------------------------------------------------- if (nContinue) nContinue = ClassSLAStore(oCaster, nSpellID, nCastingClass, nSpellLevel); //--------------------------------------------------------------------------- // Run Wild Mage's Wildstrike //--------------------------------------------------------------------------- if (nContinue) nContinue = Wildstrike(oCaster); //--------------------------------------------------------------------------- // Run Inscribe Rune Check //--------------------------------------------------------------------------- if (nContinue) nContinue = InscribeRune(); //--------------------------------------------------------------------------- // Run Attune Gem Check //--------------------------------------------------------------------------- if (nContinue) nContinue = AttuneGem(); //--------------------------------------------------------------------------- // Run use magic device skill check //--------------------------------------------------------------------------- if (nContinue) nContinue = X2UseMagicDeviceCheck(oCaster); //----------------------------------------------------------------------- // run any user defined spellscript here //----------------------------------------------------------------------- if (nContinue) nContinue = X2RunUserDefinedSpellScript(); //----------------------------------------------------------------------- // run any object-specific spellscript here //----------------------------------------------------------------------- if (nContinue) nContinue = PRCRunUserSpecificSpellScript(); //----------------------------------------------------------------------- // Check if spell was used for Duskblade channeling //----------------------------------------------------------------------- if (nContinue) nContinue = DuskbladeArcaneChanneling(oCaster, oTarget, nSpellID, nCasterLevel, nMetamagic, oSpellCastItem); //----------------------------------------------------------------------- // PnP Familiar - deliver touch spell //----------------------------------------------------------------------- if(nContinue) nContinue = DeliverTouchSpell(oCaster, oTarget, nSpellID, nCasterLevel, nSaveDC, nMetamagic, oSpellCastItem); //--------------------------------------------------------------------------- // The following code is only of interest if an item was targeted //--------------------------------------------------------------------------- if(GetIsObjectValid(oTarget) && GetObjectType(oTarget) == OBJECT_TYPE_ITEM) { //----------------------------------------------------------------------- // Check if spell was used to trigger item creation feat //----------------------------------------------------------------------- if (nContinue) nContinue = !ExecuteScriptAndReturnInt("x2_pc_craft", oCaster); //----------------------------------------------------------------------- // Check if spell was used for on a sequencer item // Check if spell was used for Arcane Archer Imbue Arrow // Check if spell was used for Spellsword ChannelSpell //----------------------------------------------------------------------- if (nContinue) nContinue = (!X2GetSpellCastOnSequencerItem(oTarget, oCaster, nSpellID, nMetamagic, nCasterLevel, nSaveDC, bSpellIsHostile, oSpellCastItem)); //----------------------------------------------------------------------- // * Execute item OnSpellCast At routing script if activated //----------------------------------------------------------------------- if(nContinue) { SetUserDefinedItemEventNumber(X2_ITEM_EVENT_SPELLCAST_AT); //Tag-based PRC scripts first int nRet = ExecuteScriptAndReturnInt("is_"+GetTag(oTarget), OBJECT_SELF); if(nRet == X2_EXECUTE_SCRIPT_END) return FALSE; if(GetModuleSwitchValue(MODULE_SWITCH_ENABLE_TAGBASED_SCRIPTS) == TRUE) { nRet = ExecuteScriptAndReturnInt(GetUserDefinedItemEventScriptName(oTarget), OBJECT_SELF); if(nRet == X2_EXECUTE_SCRIPT_END) return FALSE; } } //----------------------------------------------------------------------- // Prevent any spell that has no special coding to handle targetting of items // from being cast on items. We do this because we can not predict how // all the hundreds spells in NWN will react when cast on items //----------------------------------------------------------------------- if (nContinue) nContinue = X2CastOnItemWasAllowed(oTarget); } } if(nContinue) { //eldritch spellweave EldritchSpellweave(oCaster, oTarget, nSpellLevel, bSpellIsHostile); //spellsharing SpellSharing(oCaster, oTarget, nSpellID, nCasterLevel, nSaveDC, nMetamagic, oSpellCastItem); // Combat medic healing kicker CombatMedicHealingKicker(oCaster, oTarget, nSpellID); // Wyrmbane Helm Frightful Presence WyrmbaneFrightful(oCaster); // Havoc Mage Battlecast Battlecast(oCaster, oTarget, oSpellCastItem, nSpellLevel); // Draconic Feat effects DraconicFeatsOnSpell(oCaster, oTarget, oSpellCastItem, nSpellLevel, nCastingClass); // Wand Feats MasterWand(oCaster, oSpellCastItem, nSpellLevel); DoubleWandWielder(oCaster, oSpellCastItem, oTarget); // Incarnum MeldArcaneFocus(oCaster, oTarget); Integument(oCaster, nCastingClass); // Mystery EchoSpell(oCaster, nSpellID); // Races ArkamoiStrength(oCaster, nCastingClass); RedspawnHealing(oCaster, nSpellID, nSpellLevel); // Feats DazzlingIllusion(oCaster, nSchool); EnergyAbjuration(oCaster, nSchool, nSpellLevel); InsightfulDivination(oCaster, nSchool, nSpellLevel); TougheningTransmutation(oCaster, nSchool); CloudyConjuration(oCaster, nSchool, oSpellCastItem); // Reserve Feats if(GetLocalInt(oCaster, "ReserveFeatsRunning")) OnePingOnly(oCaster); if(GetLocalInt(oCaster, "DoMysticBacklash")) MysticBacklash(oCaster); } if(bIsPC) { if(GetPRCSwitch(PRC_PW_SPELL_TRACKING)) { if(!GetLocalInt(oCaster, "UsingActionCastSpell")) { string sSpell = IntToString(nOrigSpellID)+"|"; //use original spellID string sStored = GetPersistantLocalString(oCaster, "persist_spells"); SetPersistantLocalString(oCaster, "persist_spells", sStored+sSpell); } } //Cleaning spell variables used for holding the charge if(!GetLocalInt(oCaster, "PRC_SPELL_EVENT")) { DeleteLocalInt(oCaster, "PRC_SPELL_CHARGE_COUNT"); DeleteLocalInt(oCaster, "PRC_SPELL_CHARGE_SPELLID"); DeleteLocalObject(oCaster, "PRC_SPELL_CONC_TARGET"); DeleteLocalInt(oCaster, "PRC_SPELL_METAMAGIC"); DeleteLocalManifestation(oCaster, "PRC_POWER_HOLD_MANIFESTATION"); DeleteLocalMystery(oCaster, "MYST_HOLD_MYST"); } else if(GetLocalInt(oCaster, "PRC_SPELL_CHARGE_SPELLID") != nSpellID) { //Sanity check, in case something goes wrong with the action queue DeleteLocalInt(oCaster, "PRC_SPELL_EVENT"); } DeleteLocalInt(oCaster, "SpellIsSLA"); } return nContinue; } // Test main // void main(){}