Jaysyn/Aschbourne_PRC8
Jaysyn/Aschbourne_PRC8
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Initial commit

Browse Source 
Initial commit
This commit is contained in:
Jaysyn904 2024-06-14 10:08:16 -04:00
parent 33dc5c6755
commit 079830314c
35 changed files with 10539 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
_release/Aschbourne [PRC8-CEP3].7z Normal file
View File

Binary file not shown.

116
_removed/nw_c2_default7.nss Normal file
View File

@ -0,0 +1,116 @@
#include "NW_I0_GENERIC"
void main()
{
object oKiller = GetLastKiller();
int noleech = 0;
int nClass = GetLevelByClass(CLASS_TYPE_COMMONER);
int nAlign = GetAlignmentGoodEvil(OBJECT_SELF);
if(nClass > 0 && (nAlign == ALIGNMENT_GOOD || nAlign == ALIGNMENT_NEUTRAL))
{
AdjustAlignment(oKiller, ALIGNMENT_EVIL, 5);
}
SpeakString("NW_I_AM_DEAD", TALKVOLUME_SILENT_TALK);
//Shout Attack my target, only works with the On Spawn In setup
SpeakString("NW_ATTACK_MY_TARGET", TALKVOLUME_SILENT_TALK);
if(GetSpawnInCondition(NW_FLAG_DEATH_EVENT))
{
SignalEvent(OBJECT_SELF, EventUserDefined(1007));
}
float BaseEXP = ((GetChallengeRating(OBJECT_SELF)*3.0)+5);
float BonusEXP = GetChallengeRating(OBJECT_SELF)+5;
float BaseMonEXP = BaseEXP;
int NumOfParty = 0;
float PartyLevelSum = 0.0;
object oPartyMember = GetFirstFactionMember(oKiller, TRUE);
while(GetIsObjectValid(oPartyMember)) {
if (GetArea(OBJECT_SELF) == GetArea(oPartyMember))
{
int leech = GetHitDice(oPartyMember);
if (leech >= noleech){
noleech = leech;
}
NumOfParty++;
PartyLevelSum += GetCharacterLevel(oPartyMember);
}
oPartyMember = GetNextFactionMember(oKiller, TRUE);
}
if (PartyLevelSum <= 1.0)
{
PartyLevelSum = 1.0;
}
if (NumOfParty <= 1)
{
NumOfParty = 1;
}
float PartyAvgLvl = PartyLevelSum / NumOfParty;
//Calculate Adjustment Value
if (PartyAvgLvl <= 1.0)
{
PartyAvgLvl = 1.0;
}
float x = GetChallengeRating(OBJECT_SELF);
if (x <= 1.0)
{
x = 1.0;
}
float z = (x / PartyAvgLvl);
float AdjustValue = ((z+2)/3);
float FinalMonValue;
//Determine Final Experience Value
if (AdjustValue == 0.0) {
FinalMonValue = BaseMonEXP;
} else {
if (AdjustValue < 1.0) {
FinalMonValue = BaseMonEXP * AdjustValue;
} else {
FinalMonValue = BaseMonEXP + (BonusEXP * (AdjustValue * (1.10)));
}
}
//Determine the value of the Split EXP
if (NumOfParty >= 6)
{
NumOfParty = 5;
}
if (NumOfParty <= 1)
{
NumOfParty = 1;
}
if (FinalMonValue <= 1.0)
{
FinalMonValue = 1.0;
}
float SplitFinalEXP = FinalMonValue / NumOfParty;
if (SplitFinalEXP <= 1.0)
{
SplitFinalEXP = 1.0;
}
float y = (FinalMonValue - SplitFinalEXP);
if (y <= 1.0)
{
y = 1.0;
}
if (PartyAvgLvl >= 15.0)
{
FinalMonValue = FinalMonValue - ( PartyAvgLvl);
}
float PartyBonus = ((y +1)/ 1.75) + (FinalMonValue + ((21-PartyAvgLvl)/3));
int SFEint = FloatToInt(PartyBonus);
//Distribute EXP to all PCs in the Party
oPartyMember = GetFirstFactionMember(oKiller, TRUE);
while (GetIsObjectValid(oPartyMember)) {
if (GetArea(OBJECT_SELF) == GetArea(oPartyMember)) {
int nHD = GetHitDice(oPartyMember) + 1;
int nMax = (((nHD * (nHD - 1)) / 2) * 1000)+1;
if (nMax <= GetXP(oPartyMember) && nHD <= 40) {
SendMessageToPC(oPartyMember, "You cannot gain experience until you have leveled.");
} else if (GetIsDead(oPartyMember)) {
SendMessageToPC(oPartyMember, "You cannot gain experience while dead. Your XP has been reset.");
} else if ((GetHitDice(oPartyMember)) <= (noleech - 7) || (GetHitDice(oPartyMember)) >= FloatToInt(PartyAvgLvl) + 7) {
SendMessageToPC(oPartyMember, "All party members must be within 6 levels of each other.");
} else {
GiveXPToCreature(oPartyMember, SFEint);
}
}
oPartyMember = GetNextFactionMember(oKiller, TRUE);
}
}

323
_removed/nw_c2_default9.nss Normal file
View File

@ -0,0 +1,323 @@
//:://////////////////////////////////////////////////
//:: NW_C2_DEFAULT9
/*
* Default OnSpawn handler with XP1 revisions.
* This corresponds to and produces the same results
* as the default OnSpawn handler in the OC.
*
* This can be used to customize creature behavior in three main ways:
*
* - Uncomment the existing lines of code to activate certain
* common desired behaviors from the moment when the creature
* spawns in.
*
* - Uncomment the user-defined event signals to cause the
* creature to fire events that you can then handle with
* a custom OnUserDefined event handler script.
*
* - Add new code _at the end_ to alter the initial
* behavior in a more customized way.
*/
//:://////////////////////////////////////////////////
//:: Copyright (c) 2002 Floodgate Entertainment
//:: Created By: Naomi Novik
//:: Created On: 12/11/2002
//:://////////////////////////////////////////////////
//:: Updated 2003-08-20 Georg Zoeller: Added check for variables to active spawn in conditions without changing the spawnscript
#include "x0_i0_anims"
// #include "x0_i0_walkway" - in x0_i0_anims
#include "x0_i0_treasure"
#include "x2_inc_switches"
//DMFI CODE ADDITIONS BEGIN HERE
#include "dmfi_dmw_inc"
//DMFI CODE ADDITIONS END HERE
void main()
{
// ***** Spawn-In Conditions ***** //
// * REMOVE COMMENTS (// ) before the "Set..." functions to activate
// * them. Do NOT touch lines commented out with // *, those are
// * real comments for information.
// * This causes the creature to say a one-line greeting in their
// * conversation file upon perceiving the player. Put [NW_D2_GenCheck]
// * in the "Text Seen When" field of the greeting in the conversation
// * file. Don't attach any player responses.
// *
// SetSpawnInCondition(NW_FLAG_SPECIAL_CONVERSATION);
// * Same as above, but for hostile creatures to make them say
// * a line before attacking.
// *
// SetSpawnInCondition(NW_FLAG_SPECIAL_COMBAT_CONVERSATION);
// * This NPC will attack when its allies call for help
// *
// SetSpawnInCondition(NW_FLAG_SHOUT_ATTACK_MY_TARGET);
// * If the NPC has the Hide skill they will go into stealth mode
// * while doing WalkWayPoints().
// *
// SetSpawnInCondition(NW_FLAG_STEALTH);
//--------------------------------------------------------------------------
// Enable stealth mode by setting a variable on the creature
// Great for ambushes
// See x2_inc_switches for more information about this
//--------------------------------------------------------------------------
if (GetCreatureFlag(OBJECT_SELF, CREATURE_VAR_USE_SPAWN_STEALTH) == TRUE)
{
SetSpawnInCondition(NW_FLAG_STEALTH);
}
// * Same, but for Search mode
// *
// SetSpawnInCondition(NW_FLAG_SEARCH);
//--------------------------------------------------------------------------
// Make creature enter search mode after spawning by setting a variable
// Great for guards, etc
// See x2_inc_switches for more information about this
//--------------------------------------------------------------------------
if (GetCreatureFlag(OBJECT_SELF, CREATURE_VAR_USE_SPAWN_SEARCH) == TRUE)
{
SetSpawnInCondition(NW_FLAG_SEARCH);
}
// * This will set the NPC to give a warning to non-enemies
// * before attacking.
// * NN -- no clue what this really does yet
// *
// SetSpawnInCondition(NW_FLAG_SET_WARNINGS);
// * Separate the NPC's waypoints into day & night.
// * See comment on WalkWayPoints() for use.
// *
// SetSpawnInCondition(NW_FLAG_DAY_NIGHT_POSTING);
// * If this is set, the NPC will appear using the "EffectAppear"
// * animation instead of fading in, *IF* SetListeningPatterns()
// * is called below.
// *
//SetSpawnInCondition(NW_FLAG_APPEAR_SPAWN_IN_ANIMATION);
// * This will cause an NPC to use common animations it possesses,
// * and use social ones to any other nearby friendly NPCs.
// *
// SetSpawnInCondition(NW_FLAG_IMMOBILE_AMBIENT_ANIMATIONS);
//--------------------------------------------------------------------------
// Enable immobile ambient animations by setting a variable
// See x2_inc_switches for more information about this
//--------------------------------------------------------------------------
if (GetCreatureFlag(OBJECT_SELF, CREATURE_VAR_USE_SPAWN_AMBIENT_IMMOBILE) == TRUE)
{
SetSpawnInCondition(NW_FLAG_IMMOBILE_AMBIENT_ANIMATIONS);
}
// * Same as above, except NPC will wander randomly around the
// * area.
// *
// SetSpawnInCondition(NW_FLAG_AMBIENT_ANIMATIONS);
//--------------------------------------------------------------------------
// Enable mobile ambient animations by setting a variable
// See x2_inc_switches for more information about this
//--------------------------------------------------------------------------
if (GetCreatureFlag(OBJECT_SELF, CREATURE_VAR_USE_SPAWN_AMBIENT) == TRUE)
{
SetSpawnInCondition(NW_FLAG_AMBIENT_ANIMATIONS);
}
// **** Animation Conditions **** //
// * These are extra conditions you can put on creatures with ambient
// * animations.
// * Civilized creatures interact with placeables in
// * their area that have the tag "NW_INTERACTIVE"
// * and "talk" to each other.
// *
// * Humanoid races are civilized by default, so only
// * set this flag for monster races that you want to
// * behave the same way.
// SetAnimationCondition(NW_ANIM_FLAG_IS_CIVILIZED);
// * If this flag is set, this creature will constantly
// * be acting. Otherwise, creatures will only start
// * performing their ambient animations when they
// * first perceive a player, and they will stop when
// * the player moves away.
// SetAnimationCondition(NW_ANIM_FLAG_CONSTANT);
// * Civilized creatures with this flag set will
// * randomly use a few voicechats. It's a good
// * idea to avoid putting this on multiple
// * creatures using the same voiceset.
// SetAnimationCondition(NW_ANIM_FLAG_CHATTER);
// * Creatures with _immobile_ ambient animations
// * can have this flag set to make them mobile in a
// * close range. They will never leave their immediate
// * area, but will move around in it, frequently
// * returning to their starting point.
// *
// * Note that creatures spawned inside interior areas
// * that contain a waypoint with one of the tags
// * "NW_HOME", "NW_TAVERN", "NW_SHOP" will automatically
// * have this condition set.
// SetAnimationCondition(NW_ANIM_FLAG_IS_MOBILE_CLOSE_RANGE);
// **** Special Combat Tactics *****//
// * These are special flags that can be set on creatures to
// * make them follow certain specialized combat tactics.
// * NOTE: ONLY ONE OF THESE SHOULD BE SET ON A SINGLE CREATURE.
// * Ranged attacker
// * Will attempt to stay at ranged distance from their
// * target.
// SetCombatCondition(X0_COMBAT_FLAG_RANGED);
// * Defensive attacker
// * Will use defensive combat feats and parry
// SetCombatCondition(X0_COMBAT_FLAG_DEFENSIVE);
// * Ambusher
// * Will go stealthy/invisible and attack, then
// * run away and try to go stealthy again before
// * attacking anew.
// SetCombatCondition(X0_COMBAT_FLAG_AMBUSHER);
// * Cowardly
// * Cowardly creatures will attempt to flee
// * attackers.
// SetCombatCondition(X0_COMBAT_FLAG_COWARDLY);
// **** Escape Commands ***** //
// * NOTE: ONLY ONE OF THE FOLLOWING SHOULD EVER BE SET AT ONE TIME.
// * NOTE2: Not clear that these actually work. -- NN
// * Flee to a way point and return a short time later.
// *
// SetSpawnInCondition(NW_FLAG_ESCAPE_RETURN);
// * Flee to a way point and do not return.
// *
// SetSpawnInCondition(NW_FLAG_ESCAPE_LEAVE);
// * Teleport to safety and do not return.
// *
// SetSpawnInCondition(NW_FLAG_TELEPORT_LEAVE);
// * Teleport to safety and return a short time later.
// *
// SetSpawnInCondition(NW_FLAG_TELEPORT_RETURN);
// ***** CUSTOM USER DEFINED EVENTS ***** /
/*
If you uncomment any of these conditions, the creature will fire
a specific user-defined event number on each event. That will then
allow you to write custom code in the "OnUserDefinedEvent" handler
script to go on top of the default NPC behaviors for that event.
Example: I want to add some custom behavior to my NPC when they
are damaged. I uncomment the "NW_FLAG_DAMAGED_EVENT", then create
a new user-defined script that has something like this in it:
if (GetUserDefinedEventNumber() == 1006) {
// Custom code for my NPC to execute when it's damaged
}
These user-defined events are in the range 1001-1007.
*/
// * Fire User Defined Event 1001 in the OnHeartbeat
// *
// SetSpawnInCondition(NW_FLAG_HEARTBEAT_EVENT);
// * Fire User Defined Event 1002
// *
// SetSpawnInCondition(NW_FLAG_PERCIEVE_EVENT);
// * Fire User Defined Event 1005
// *
// SetSpawnInCondition(NW_FLAG_ATTACK_EVENT);
// * Fire User Defined Event 1006
// *
// SetSpawnInCondition(NW_FLAG_DAMAGED_EVENT);
// * Fire User Defined Event 1008
// *
// SetSpawnInCondition(NW_FLAG_DISTURBED_EVENT);
// * Fire User Defined Event 1003
// *
// SetSpawnInCondition(NW_FLAG_END_COMBAT_ROUND_EVENT);
// * Fire User Defined Event 1004
// *
// SetSpawnInCondition(NW_FLAG_ON_DIALOGUE_EVENT);
// ***** DEFAULT GENERIC BEHAVIOR (DO NOT TOUCH) ***** //
// * Goes through and sets up which shouts the NPC will listen to.
// *
SetListeningPatterns();
// * Walk among a set of waypoints.
// * 1. Find waypoints with the tag "WP_" + NPC TAG + "_##" and walk
// * among them in order.
// * 2. If the tag of the Way Point is "POST_" + NPC TAG, stay there
// * and return to it after combat.
//
// * Optional Parameters:
// * void WalkWayPoints(int nRun = FALSE, float fPause = 1.0)
//
// * If "NW_FLAG_DAY_NIGHT_POSTING" is set above, you can also
// * create waypoints with the tags "WN_" + NPC Tag + "_##"
// * and those will be walked at night. (The standard waypoints
// * will be walked during the day.)
// * The night "posting" waypoint tag is simply "NIGHT_" + NPC tag.
WalkWayPoints();
//* Create a small amount of treasure on the creature
if ((GetLocalInt(GetModule(), "X2_L_NOTREASURE") == FALSE) &&
(GetLocalInt(OBJECT_SELF, "X2_L_NOTREASURE") == FALSE) )
{
CTG_GenerateNPCTreasure(TREASURE_TYPE_MONSTER, OBJECT_SELF);
}
// ***** ADD ANY SPECIAL ON-SPAWN CODE HERE ***** //
// * If Incorporeal, apply changes
if (GetCreatureFlag(OBJECT_SELF, CREATURE_VAR_IS_INCORPOREAL) == TRUE)
{
effect eConceal = EffectConcealment(50, MISS_CHANCE_TYPE_NORMAL);
eConceal = ExtraordinaryEffect(eConceal);
effect eGhost = EffectCutsceneGhost();
eGhost = ExtraordinaryEffect(eGhost);
ApplyEffectToObject(DURATION_TYPE_PERMANENT, eConceal, OBJECT_SELF);
ApplyEffectToObject(DURATION_TYPE_PERMANENT, eGhost, OBJECT_SELF);
}
//DMFI CODE ADDITIONS BEGIN HERE
if ((DMFI_LISTENING_GLOBAL) || (GetLocalInt(OBJECT_SELF, "DMFI_LISTEN")==1))
{
SetListening(OBJECT_SELF, TRUE);
SetListenPattern(OBJECT_SELF, "**", 20600);
SetLocalInt(OBJECT_SELF, "hls_Listening", 1); //listen to all text
}
//DMFI CODE ADDITIONS END HERE
}

857
_removed/nw_i0_spells.nss Normal file
View File

@ -0,0 +1,857 @@
//::///////////////////////////////////////////////
//:: Spells Include
//:: NW_I0_SPELLS
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Jan 2, 2002
//:: Updated By: 2003/20/10 Georg Zoeller
//:://////////////////////////////////////////////
// GZ: Number of spells in GetSpellBreachProtections
const int NW_I0_SPELLS_MAX_BREACH = 33;
// * Function for doing electrical traps
void TrapDoElectricalDamage(int ngDamageMaster, int nSaveDC, int nSecondary);
// * Used to route the resist magic checks into this function to check for spell countering by SR, Globes or Mantles.
// Return value if oCaster or oTarget is an invalid object: FALSE
// Return value if spell cast is not a player spell: - 1
// Return value if spell resisted: 1
// Return value if spell resisted via magic immunity: 2
// Return value if spell resisted via spell absorption: 3
int MyResistSpell(object oCaster, object oTarget, float fDelay = 0.0);
// * Used to route the saving throws through this function to check for spell countering by a saving throw.
// Returns: 0 if the saving throw roll failed
// Returns: 1 if the saving throw roll succeeded
// Returns: 2 if the target was immune to the save type specified
// Note: If used within an Area of Effect Object Script (On Enter, OnExit, OnHeartbeat), you MUST pass
// GetAreaOfEffectCreator() into oSaveVersus!! \
int MySavingThrow(int nSavingThrow, object oTarget, int nDC, int nSaveType=SAVING_THROW_TYPE_NONE, object oSaveVersus = OBJECT_SELF, float fDelay = 0.0);
// * Will pass back a linked effect for all the protection from alignment spells. The power represents the multiplier of strength.
// * That is instead of +3 AC and +2 Saves a power of 2 will yield +6 AC and +4 Saves.
effect CreateProtectionFromAlignmentLink(int nAlignment, int nPower = 1);
// * Will pass back a linked effect for all of the doom effects.
effect CreateDoomEffectsLink();
// * Searchs through a persons effects and removes those from a particular spell by a particular caster.
void RemoveSpellEffects(int nSpell_ID, object oCaster, object oTarget);
// * Searchs through a persons effects and removes all those of a specific type.
void RemoveSpecificEffect(int nEffectTypeID, object oTarget);
// * Returns the time in seconds that the effect should be delayed before application.
float GetSpellEffectDelay(location SpellTargetLocation, object oTarget);
// * This allows the application of a random delay to effects based on time parameters passed in. Min default = 0.4, Max default = 1.1
float GetRandomDelay(float fMinimumTime = 0.4, float MaximumTime = 1.1);
// * Get Difficulty Duration
int GetScaledDuration(int nActualDuration, object oTarget);
// * Get Scaled Effect
effect GetScaledEffect(effect eStandard, object oTarget);
// * Remove all spell protections of a specific type
int RemoveProtections(int nSpell_ID, object oTarget, int nCount);
// * Performs a spell breach up to nTotal spells are removed and nSR spell
// * resistance is lowered.
int GetSpellBreachProtection(int nLastChecked);
//* Assigns a debug string to the Area of Effect Creator
void AssignAOEDebugString(string sString);
// * Plays a random dragon battlecry based on age.
void PlayDragonBattleCry();
// * Returns true if Target is a humanoid
int AmIAHumanoid(object oTarget);
// * Performs a spell breach up to nTotal spell are removed and
// * nSR spell resistance is lowered. nSpellId can be used to override
// * the originating spell ID. If not specified, SPELL_GREATER_SPELL_BREACH
// * is used
void DoSpellBreach(object oTarget, int nTotal, int nSR, int nSpellId = -1);
// * Returns true if Target is a humanoid
int AmIAHumanoid(object oTarget)
{
int nRacial = GetRacialType(oTarget);
if((nRacial == RACIAL_TYPE_DWARF) ||
(nRacial == RACIAL_TYPE_HALFELF) ||
(nRacial == RACIAL_TYPE_HALFORC) ||
(nRacial == RACIAL_TYPE_ELF) ||
(nRacial == RACIAL_TYPE_GNOME) ||
(nRacial == RACIAL_TYPE_HUMANOID_GOBLINOID) ||
(nRacial == RACIAL_TYPE_HALFLING) ||
(nRacial == RACIAL_TYPE_HUMAN) ||
(nRacial == RACIAL_TYPE_HUMANOID_MONSTROUS) ||
(nRacial == RACIAL_TYPE_HUMANOID_ORC) ||
(nRacial == RACIAL_TYPE_HUMANOID_REPTILIAN))
{
return TRUE;
}
return FALSE;
}
//::///////////////////////////////////////////////
//:: spellsCure
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Used by the 'cure' series of spells.
Will do max heal/damage if at normal or low
difficulty.
Random rolls occur at higher difficulties.
*/
//:://////////////////////////////////////////////
//:: Created By:
//:: Created On:
//:://////////////////////////////////////////////
void spellsCure(int nDamage, int nMaxExtraDamage, int nMaximized, int vfx_impactHurt, int vfx_impactHeal, int nSpellID)
{
//Declare major variables
object oTarget = GetSpellTargetObject();
int nHeal;
int nMetaMagic = GetMetaMagicFeat();
effect eVis = EffectVisualEffect(vfx_impactHurt);
effect eVis2 = EffectVisualEffect(vfx_impactHeal);
effect eHeal, eDam;
PrintString("nw_i0_spells: spellsCure() called");
int nExtraDamage = GetCasterLevel(OBJECT_SELF); // * figure out the bonus damage
if (nExtraDamage > nMaxExtraDamage)
{
nExtraDamage = nMaxExtraDamage;
}
// * if low or normal difficulty is treated as MAXIMIZED
if(GetIsPC(oTarget) && GetGameDifficulty() < GAME_DIFFICULTY_CORE_RULES)
{
nDamage = nMaximized + nExtraDamage;
}
else
{
nDamage = nDamage + nExtraDamage;
}
//Make metamagic checks
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = 8 + nExtraDamage;
// * if low or normal difficulty then MAXMIZED is doubled.
if(GetIsPC(OBJECT_SELF) && GetGameDifficulty() < GAME_DIFFICULTY_CORE_RULES)
{
nDamage = nDamage + nExtraDamage;
}
}
if (nMetaMagic == METAMAGIC_EMPOWER || GetHasFeat(FEAT_HEALING_DOMAIN_POWER))
{
nDamage = nDamage + (nDamage/2);
}
PrintString("nw_i0_spells: RACE["+IntToString(GetRacialType(oTarget))+"] SUBRACE["+GetSubRace(oTarget)+"] NAME["+GetName(oTarget)+"]");
if ((GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD)||(GetSubRace(oTarget)=="Vampire"))
{
PrintString("nw_i0_spells: NAME["+GetName(oTarget)+"] was undead or Vampire.");
int nTouch = TouchAttackMelee(oTarget);
if (nTouch > 0)
{
PrintString("nw_i0_spells: NAME["+GetName(oTarget)+"] was HIT.");
if(!GetIsReactionTypeFriendly(oTarget))
{
PrintString("nw_i0_spells: NAME["+GetName(oTarget)+"] is not friendly with the attacker.");
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, nSpellID));
if (!MyResistSpell(OBJECT_SELF, oTarget))
{
PrintString("nw_i0_spells: NAME["+GetName(oTarget)+"] did not resist the spell attack.");
eDam = EffectDamage(nDamage,DAMAGE_TYPE_NEGATIVE);
//Apply the VFX impact and effects
DelayCommand(1.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
}
}
}
//Check that the target is undead
else
{
PrintString("nw_i0_spells: NAME["+GetName(oTarget)+"] was NOT undead or Vampire.");
//Figure out the amount of damage to heal
nHeal = nDamage;
//Set the heal effect
eHeal = EffectHeal(nHeal);
//Apply heal effect and VFX impact
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, nSpellID, FALSE));
}
}
//::///////////////////////////////////////////////
//:: DoSpelLBreach
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Performs a spell breach up to nTotal spells
are removed and nSR spell resistance is
lowered.
*/
//:://////////////////////////////////////////////
//:: Created By: Brent
//:: Created On: September 2002
//:: Modified : Georg, Oct 31, 2003
//:://////////////////////////////////////////////
void DoSpellBreach(object oTarget, int nTotal, int nSR, int nSpellId = -1)
{
if (nSpellId == -1)
{
nSpellId = SPELL_GREATER_SPELL_BREACH;
}
effect eSR = EffectSpellResistanceDecrease(nSR);
effect eDur = EffectVisualEffect(VFX_DUR_CESSATE_NEGATIVE);
effect eVis = EffectVisualEffect(VFX_IMP_BREACH);
int nCnt, nIdx;
if(!GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, nSpellId ));
//Search through and remove protections.
while(nCnt <= NW_I0_SPELLS_MAX_BREACH && nIdx < nTotal)
{
nIdx = nIdx + RemoveProtections(GetSpellBreachProtection(nCnt), oTarget, nCnt);
nCnt++;
}
effect eLink = EffectLinkEffects(eDur, eSR);
//--------------------------------------------------------------------------
// This can not be dispelled
//--------------------------------------------------------------------------
eLink = ExtraordinaryEffect(eLink);
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oTarget, RoundsToSeconds(10));
}
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
//::///////////////////////////////////////////////
//:: GetDragonFearDC
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Adding a function, we were using two different
sets of numbers before. Standardizing it to be
closer to 3e.
nAge - hit dice
*/
//:://////////////////////////////////////////////
//:: Created By: Brent
//:: Created On: Sep 13, 2002
//:://////////////////////////////////////////////
int GetDragonFearDC(int nAge)
{
//hmm... not sure what's up with all these nCount variables, they're not
//actually used... so I'm gonna comment them out
int nDC = 13;
// int nCount = 1;
//Determine the duration and save DC
//wyrmling meant no change from default, so we don't need it
/*
if (nAge <= 6) //Wyrmling
{
nDC = 13;
nCount = 1;
}
else
*/
if (nAge >= 7 && nAge <= 9) //Very Young
{
nDC = 15;
// nCount = 2;
}
else if (/*nAge >= 10 &&*/ nAge <= 12) //Young
{
nDC = 17;
// nCount = 3;
}
else if (/*nAge >= 13 &&*/ nAge <= 15) //Juvenile
{
nDC = 19;
// nCount = 4;
}
else if (/*nAge >= 16 &&*/ nAge <= 18) //Young Adult
{
nDC = 21;
// nCount = 5;
}
else if (/*nAge >= 19 &&*/ nAge <= 21) //Adult
{
nDC = 24;
// nCount = 6;
}
else if (/*nAge >= 22 &&*/ nAge <= 24) //Mature Adult
{
nDC = 27;
// nCount = 7;
}
else if (/*nAge >= 25 &&*/ nAge <= 27) //Old
{
nDC = 28;
// nCount = 8;
}
else if (/*nAge >= 28 &&*/ nAge <= 30) //Very Old
{
nDC = 30;
// nCount = 9;
}
else if (/*nAge >= 31 &&*/ nAge <= 33) //Ancient
{
nDC = 32;
// nCount = 10;
}
else if (/*nAge >= 34 &&*/ nAge <= 37) //Wyrm
{
nDC = 34;
// nCount = 11;
}
else if (nAge > 37) //Great Wyrm
{
nDC = 37;
// nCount = 12;
}
return nDC;
}
//------------------------------------------------------------------------------
// Kovi function: calculates the appropriate base number of attacks
// for spells that increase this (tensers, divine power)
//------------------------------------------------------------------------------
int CalcNumberOfAttacks()
{
int n = GetCasterLevel(OBJECT_SELF);
int nBAB1 = GetLevelByClass(CLASS_TYPE_RANGER)
+ GetLevelByClass(CLASS_TYPE_FIGHTER)
+ GetLevelByClass(CLASS_TYPE_PALADIN)
+ GetLevelByClass(CLASS_TYPE_BARBARIAN);
int nBAB2 = GetLevelByClass(CLASS_TYPE_DRUID)
+ GetLevelByClass(CLASS_TYPE_MONK)
+ GetLevelByClass(CLASS_TYPE_ROGUE)
+ GetLevelByClass(CLASS_TYPE_BARD);
int nBAB3 = GetLevelByClass(CLASS_TYPE_WIZARD)
+ GetLevelByClass(CLASS_TYPE_SORCERER);
int nOldBAB = nBAB1 + (nBAB2 + n) * 3 / 4 + nBAB3 / 2;
int nNewBAB = nBAB1 + n + nBAB2 * 3 / 4 + nBAB3 / 2;
if (nNewBAB / 5 > nOldBAB / 5)
return 2; // additional attack
else
return 1; // everything is normal
}
//------------------------------------------------------------------------------
// GZ: gets rids of temporary hit points so that they will not stack
//------------------------------------------------------------------------------
void RemoveTempHitPoints()
{
effect eProtection;
int nCnt = 0;
eProtection = GetFirstEffect(OBJECT_SELF);
while (GetIsEffectValid(eProtection))
{
if(GetEffectType(eProtection) == EFFECT_TYPE_TEMPORARY_HITPOINTS)
RemoveEffect(OBJECT_SELF, eProtection);
eProtection = GetNextEffect(OBJECT_SELF);
}
}
// * Kovi. removes any effects from this type of spell
// * i.e., used in Mage Armor to remove any previous
// * mage armors
void RemoveEffectsFromSpell(object oTarget, int SpellID)
{
effect eLook = GetFirstEffect(oTarget);
while (GetIsEffectValid(eLook)) {
if (GetEffectSpellId(eLook) == SpellID)
RemoveEffect(oTarget, eLook);
eLook = GetNextEffect(oTarget);
}
}
int MyResistSpell(object oCaster, object oTarget, float fDelay = 0.0)
{
if (fDelay > 0.5)
{
fDelay = fDelay - 0.1;
}
int nResist = ResistSpell(oCaster, oTarget);
effect eSR = EffectVisualEffect(VFX_IMP_MAGIC_RESISTANCE_USE);
effect eGlobe = EffectVisualEffect(VFX_IMP_GLOBE_USE);
effect eMantle = EffectVisualEffect(VFX_IMP_SPELL_MANTLE_USE);
if(nResist == 1) //Spell Resistance
{
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eSR, oTarget));
}
else if(nResist == 2) //Globe
{
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eGlobe, oTarget));
}
else if(nResist == 3) //Spell Mantle
{
if (fDelay > 0.5)
{
fDelay = fDelay - 0.1;
}
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eMantle, oTarget));
}
return nResist;
}
int MySavingThrow(int nSavingThrow, object oTarget, int nDC, int nSaveType=SAVING_THROW_TYPE_NONE, object oSaveVersus = OBJECT_SELF, float fDelay = 0.0)
{
// -------------------------------------------------------------------------
// GZ: sanity checks to prevent wrapping around
// -------------------------------------------------------------------------
if (nDC<1)
{
nDC = 1;
}
else if (nDC > 255)
{
nDC = 255;
}
effect eVis;
int bValid = FALSE;
int nSpellID;
if(nSavingThrow == SAVING_THROW_FORT)
{
bValid = FortitudeSave(oTarget, nDC, nSaveType, oSaveVersus);
if(bValid == 1)
{
eVis = EffectVisualEffect(VFX_IMP_FORTITUDE_SAVING_THROW_USE);
}
}
else if(nSavingThrow == SAVING_THROW_REFLEX)
{
bValid = ReflexSave(oTarget, nDC, nSaveType, oSaveVersus);
if(bValid == 1)
{
eVis = EffectVisualEffect(VFX_IMP_REFLEX_SAVE_THROW_USE);
}
}
else if(nSavingThrow == SAVING_THROW_WILL)
{
bValid = WillSave(oTarget, nDC, nSaveType, oSaveVersus);
if(bValid == 1)
{
eVis = EffectVisualEffect(VFX_IMP_WILL_SAVING_THROW_USE);
}
}
nSpellID = GetSpellId();
/*
return 0 = FAILED SAVE
return 1 = SAVE SUCCESSFUL
return 2 = IMMUNE TO WHAT WAS BEING SAVED AGAINST
*/
if(bValid == 0)
{
if((nSaveType == SAVING_THROW_TYPE_DEATH
|| nSpellID == SPELL_WEIRD
|| nSpellID == SPELL_FINGER_OF_DEATH) &&
nSpellID != SPELL_HORRID_WILTING)
{
eVis = EffectVisualEffect(VFX_IMP_DEATH);
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
}
}
//redundant comparison on bValid, let's move the eVis line down below
/* if(bValid == 2)
{
eVis = EffectVisualEffect(VFX_IMP_MAGIC_RESISTANCE_USE);
}*/
if(bValid == 1 || bValid == 2)
{
if(bValid == 2)
{
eVis = EffectVisualEffect(VFX_IMP_MAGIC_RESISTANCE_USE);
/*
If the spell is save immune then the link must be applied in order to get the true immunity
to be resisted. That is the reason for returing false and not true. True blocks the
application of effects.
*/
bValid = FALSE;
}
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
}
return bValid;
}
effect CreateProtectionFromAlignmentLink(int nAlignment, int nPower = 1)
{
int nFinal = nPower * 2;
effect eAC = EffectACIncrease(nFinal, AC_DEFLECTION_BONUS);
eAC = VersusAlignmentEffect(eAC, ALIGNMENT_ALL, nAlignment);
effect eSave = EffectSavingThrowIncrease(SAVING_THROW_ALL, nFinal);
eSave = VersusAlignmentEffect(eSave,ALIGNMENT_ALL, nAlignment);
effect eImmune = EffectImmunity(IMMUNITY_TYPE_MIND_SPELLS);
eImmune = VersusAlignmentEffect(eImmune,ALIGNMENT_ALL, nAlignment);
effect eDur;
if(nAlignment == ALIGNMENT_EVIL)
{
eDur = EffectVisualEffect(VFX_DUR_PROTECTION_GOOD_MINOR);
}
else if(nAlignment == ALIGNMENT_GOOD)
{
eDur = EffectVisualEffect(VFX_DUR_PROTECTION_EVIL_MINOR);
}
effect eDur2 = EffectVisualEffect(VFX_DUR_CESSATE_POSITIVE);
effect eLink = EffectLinkEffects(eImmune, eSave);
eLink = EffectLinkEffects(eLink, eAC);
eLink = EffectLinkEffects(eLink, eDur);
eLink = EffectLinkEffects(eLink, eDur2);
return eLink;
}
effect CreateDoomEffectsLink()
{
//Declare major variables
effect eSaves = EffectSavingThrowDecrease(SAVING_THROW_ALL, 2);
effect eAttack = EffectAttackDecrease(2);
effect eDamage = EffectDamageDecrease(2);
effect eSkill = EffectSkillDecrease(SKILL_ALL_SKILLS, 2);
effect eDur = EffectVisualEffect(VFX_DUR_CESSATE_NEGATIVE);
effect eLink = EffectLinkEffects(eAttack, eDamage);
eLink = EffectLinkEffects(eLink, eSaves);
eLink = EffectLinkEffects(eLink, eSkill);
eLink = EffectLinkEffects(eLink, eDur);
return eLink;
}
void RemoveSpellEffects(int nSpell_ID, object oCaster, object oTarget)
{
//Declare major variables
int bValid = FALSE;
effect eAOE;
if(GetHasSpellEffect(nSpell_ID, oTarget))
{
//Search through the valid effects on the target.
eAOE = GetFirstEffect(oTarget);
while (GetIsEffectValid(eAOE) && bValid == FALSE)
{
if (GetEffectCreator(eAOE) == oCaster)
{
//If the effect was created by the spell then remove it
if(GetEffectSpellId(eAOE) == nSpell_ID)
{
RemoveEffect(oTarget, eAOE);
bValid = TRUE;
}
}
//Get next effect on the target
eAOE = GetNextEffect(oTarget);
}
}
}
void RemoveSpecificEffect(int nEffectTypeID, object oTarget)
{
//Declare major variables
//Get the object that is exiting the AOE
int bValid = FALSE;
effect eAOE;
//Search through the valid effects on the target.
eAOE = GetFirstEffect(oTarget);
while (GetIsEffectValid(eAOE))
{
if (GetEffectType(eAOE) == nEffectTypeID)
{
//If the effect was created by the spell then remove it
bValid = TRUE;
RemoveEffect(oTarget, eAOE);
}
//Get next effect on the target
eAOE = GetNextEffect(oTarget);
}
}
float GetSpellEffectDelay(location SpellTargetLocation, object oTarget)
{
float fDelay;
return fDelay = GetDistanceBetweenLocations(SpellTargetLocation, GetLocation(oTarget))/20;
}
float GetRandomDelay(float fMinimumTime = 0.4, float MaximumTime = 1.1)
{
float fRandom = MaximumTime - fMinimumTime;
if(fRandom < 0.0)
{
return 0.0;
}
else
{
int nRandom;
nRandom = FloatToInt(fRandom * 10.0);
nRandom = Random(nRandom) + 1;
fRandom = IntToFloat(nRandom);
fRandom /= 10.0;
return fRandom + fMinimumTime;
}
}
int GetScaledDuration(int nActualDuration, object oTarget)
{
int nDiff = GetGameDifficulty();
int nNew = nActualDuration;
if(GetIsPC(oTarget) && nActualDuration > 3)
{
if(nDiff == GAME_DIFFICULTY_VERY_EASY || nDiff == GAME_DIFFICULTY_EASY)
{
nNew = nActualDuration / 4;
}
else if(nDiff == GAME_DIFFICULTY_NORMAL)
{
nNew = nActualDuration / 2;
}
if(nNew == 0)
{
nNew = 1;
}
}
return nNew;
}
effect GetScaledEffect(effect eStandard, object oTarget)
{
int nDiff = GetGameDifficulty();
effect eNew = eStandard;
object oMaster = GetMaster(oTarget);
if(GetIsPC(oTarget) || (GetIsObjectValid(oMaster) && GetIsPC(oMaster)))
{
if(GetEffectType(eStandard) == EFFECT_TYPE_FRIGHTENED && nDiff == GAME_DIFFICULTY_VERY_EASY)
{
eNew = EffectAttackDecrease(-2);
return eNew;
}
if(GetEffectType(eStandard) == EFFECT_TYPE_FRIGHTENED && nDiff == GAME_DIFFICULTY_EASY)
{
eNew = EffectAttackDecrease(-4);
return eNew;
}
if(nDiff == GAME_DIFFICULTY_VERY_EASY &&
(GetEffectType(eStandard) == EFFECT_TYPE_PARALYZE ||
GetEffectType(eStandard) == EFFECT_TYPE_STUNNED ||
GetEffectType(eStandard) == EFFECT_TYPE_CONFUSED))
{
eNew = EffectDazed();
return eNew;
}
else if(GetEffectType(eStandard) == EFFECT_TYPE_CHARMED || GetEffectType(eStandard) == EFFECT_TYPE_DOMINATED)
{
eNew = EffectDazed();
return eNew;
}
}
return eNew;
}
int RemoveProtections(int nSpell_ID, object oTarget, int nCount)
{
//Declare major variables
effect eProtection;
int nCnt = 0;
if(GetHasSpellEffect(nSpell_ID, oTarget))
{
//Search through the valid effects on the target.
eProtection = GetFirstEffect(oTarget);
while (GetIsEffectValid(eProtection))
{
//If the effect was created by the spell then remove it
if(GetEffectSpellId(eProtection) == nSpell_ID)
{
RemoveEffect(oTarget, eProtection);
//return 1;
nCnt++;
}
//Get next effect on the target
eProtection = GetNextEffect(oTarget);
}
}
if(nCnt > 0)
{
return 1;
}
else
{
return 0;
}
}
//------------------------------------------------------------------------------
// Returns the nLastChecked-nth highest spell on the creature for use in
// the spell breach routines
// Please modify the constatn NW_I0_SPELLS_MAX_BREACH at the top of this file
// if you change the number of spells.
//------------------------------------------------------------------------------
int GetSpellBreachProtection(int nLastChecked)
{
//--------------------------------------------------------------------------
// GZ: Protections are stripped in the order they appear here
//--------------------------------------------------------------------------
if(nLastChecked == 1) {return SPELL_GREATER_SPELL_MANTLE;}
else if (nLastChecked == 2){return SPELL_PREMONITION;}
else if(nLastChecked == 3) {return SPELL_SPELL_MANTLE;}
else if(nLastChecked == 4) {return SPELL_SHADOW_SHIELD;}
else if(nLastChecked == 5) {return SPELL_GREATER_STONESKIN;}
else if(nLastChecked == 6) {return SPELL_ETHEREAL_VISAGE;}
else if(nLastChecked == 7) {return SPELL_GLOBE_OF_INVULNERABILITY;}
else if(nLastChecked == 8) {return SPELL_ENERGY_BUFFER;}
else if(nLastChecked == 9) {return 443;} // greater sanctuary
else if(nLastChecked == 10) {return SPELL_MINOR_GLOBE_OF_INVULNERABILITY;}
else if(nLastChecked == 11) {return SPELL_SPELL_RESISTANCE;}
else if(nLastChecked == 12) {return SPELL_STONESKIN;}
else if(nLastChecked == 13) {return SPELL_LESSER_SPELL_MANTLE;}
else if(nLastChecked == 14) {return SPELL_MESTILS_ACID_SHEATH;}
else if(nLastChecked == 15) {return SPELL_MIND_BLANK;}
else if(nLastChecked == 16) {return SPELL_ELEMENTAL_SHIELD;}
else if(nLastChecked == 17) {return SPELL_PROTECTION_FROM_SPELLS;}
else if(nLastChecked == 18) {return SPELL_PROTECTION_FROM_ELEMENTS;}
else if(nLastChecked == 19) {return SPELL_RESIST_ELEMENTS;}
else if(nLastChecked == 20) {return SPELL_DEATH_ARMOR;}
else if(nLastChecked == 21) {return SPELL_GHOSTLY_VISAGE;}
else if(nLastChecked == 22) {return SPELL_ENDURE_ELEMENTS;}
else if(nLastChecked == 23) {return SPELL_SHADOW_SHIELD;}
else if(nLastChecked == 24) {return SPELL_SHADOW_CONJURATION_MAGE_ARMOR;}
else if(nLastChecked == 25) {return SPELL_NEGATIVE_ENERGY_PROTECTION;}
else if(nLastChecked == 26) {return SPELL_SANCTUARY;}
else if(nLastChecked == 27) {return SPELL_MAGE_ARMOR;}
else if(nLastChecked == 28) {return SPELL_STONE_BONES;}
else if(nLastChecked == 29) {return SPELL_SHIELD;}
else if(nLastChecked == 30) {return SPELL_SHIELD_OF_FAITH;}
else if(nLastChecked == 31) {return SPELL_LESSER_MIND_BLANK;}
else if(nLastChecked == 32) {return SPELL_IRONGUTS;}
else if(nLastChecked == 33) {return SPELL_RESISTANCE;}
return nLastChecked;
}
void AssignAOEDebugString(string sString)
{
object oTarget = GetAreaOfEffectCreator();
AssignCommand(oTarget, SpeakString(sString));
}
void PlayDragonBattleCry()
{
if(d100() > 50)
{
PlayVoiceChat(VOICE_CHAT_BATTLECRY1);
}
else
{
PlayVoiceChat(VOICE_CHAT_BATTLECRY2);
}
}
void TrapDoElectricalDamage(int ngDamageMaster, int nSaveDC, int nSecondary)
{
//Declare major variables
object oTarget = GetEnteringObject();
object o2ndTarget;
effect eLightning = EffectBeam(VFX_BEAM_LIGHTNING, oTarget, BODY_NODE_CHEST);
int nDamageMaster = ngDamageMaster;
int nDamage = nDamageMaster;
effect eDam;
effect eVis = EffectVisualEffect(VFX_IMP_LIGHTNING_S);
location lTarget = GetLocation(oTarget);
int nCount = 0;
//Adjust the trap damage based on the feats of the target
if(!MySavingThrow(SAVING_THROW_REFLEX, oTarget, nSaveDC, SAVING_THROW_TYPE_TRAP))
{
if (GetHasFeat(FEAT_IMPROVED_EVASION, oTarget))
{
nDamage /= 2;
}
}
else if (GetHasFeat(FEAT_EVASION, oTarget) || GetHasFeat(FEAT_IMPROVED_EVASION, oTarget))
{
nDamage = 0;
}
else
{
nDamage /= 2;
}
if (nDamage > 0)
{
eDam = EffectDamage(nDamage, DAMAGE_TYPE_ELECTRICAL);
DelayCommand(0.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
//Reset the damage;
nDamage = nDamageMaster;
o2ndTarget = GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_LARGE, lTarget);
while (GetIsObjectValid(o2ndTarget) && nCount <= nSecondary)
{
if(!GetIsReactionTypeFriendly(oTarget))
{
//check to see that the original target is not hit again.
if(o2ndTarget != oTarget)
{
//Adjust the trap damage based on the feats of the target
if(!MySavingThrow(SAVING_THROW_REFLEX, o2ndTarget, nSaveDC, SAVING_THROW_TYPE_ELECTRICITY))
{
if (GetHasFeat(FEAT_IMPROVED_EVASION, o2ndTarget))
{
nDamage /= 2;
}
}
else if (GetHasFeat(FEAT_EVASION, o2ndTarget) || GetHasFeat(FEAT_IMPROVED_EVASION, o2ndTarget))
{
nDamage = 0;
}
else
{
nDamage /= 2;
}
if (nDamage > 0)
{
//Set the damage effect
eDam = EffectDamage(nDamage, DAMAGE_TYPE_ELECTRICAL);
//Apply the VFX impact and damage effect
DelayCommand(0.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, o2ndTarget));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, o2ndTarget);
//Connect the lightning stream from one target to another.
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLightning, o2ndTarget, 0.75);
//Set the last target as the new start for the lightning stream
eLightning = EffectBeam(VFX_BEAM_LIGHTNING, o2ndTarget, BODY_NODE_CHEST);
}
}
//Reset the damage
nDamage = nDamageMaster;
//Increment the count
nCount++;
}
//Get next target in the shape.
o2ndTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_LARGE, lTarget);
}
}

4626
_removed/nw_o2_coninclude.nss Normal file
View File

File diff suppressed because it is too large Load Diff

108
_removed/nw_s0_circdoom.nss Normal file
View File

@ -0,0 +1,108 @@
//::///////////////////////////////////////////////
//:: [Circle of Doom]
//:: [NW_S0_CircDoom.nss]
//:: Copyright (c) 2000 Bioware Corp.
//:://////////////////////////////////////////////
//:: All enemies of the caster take 1d8 damage +1
//:: per caster level (max 20). Undead are healed
//:: for the same amount
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk and Keith Soleski
//:: Created On: Jan 31, 2001
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 20, 2001
//:: Update Pass By: Preston W, On: July 25, 2001
#include "X0_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget;
effect eDam;
effect eVis = EffectVisualEffect(VFX_IMP_NEGATIVE_ENERGY);
effect eVis2 = EffectVisualEffect(VFX_IMP_HEALING_M);
effect eFNF = EffectVisualEffect(VFX_FNF_LOS_EVIL_10);
effect eHeal;
int nCasterLevel = GetCasterLevel(OBJECT_SELF);
//Limit Caster Level
if(nCasterLevel > 20)
{
nCasterLevel = 20;
}
int nMetaMagic = GetMetaMagicFeat();
int nDamage;
float fDelay;
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eFNF, GetSpellTargetLocation());
//Get first target in the specified area
oTarget =GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_MEDIUM, GetSpellTargetLocation());
while (GetIsObjectValid(oTarget))
{
fDelay = GetRandomDelay();
//Roll damage
nDamage = d8() + nCasterLevel;
//Make metamagic checks
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = 8 + nCasterLevel;
}
else if (nMetaMagic == METAMAGIC_EMPOWER)
{
nDamage = nDamage + (nDamage/2) + nCasterLevel;
}
//If the target is an allied undead it is healed
if(GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD||(GetSubRace(oTarget)=="Vampire"))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_CIRCLE_OF_DOOM, FALSE));
//Set the heal effect
eHeal = EffectHeal(nDamage);
//Apply the impact VFX and healing effect
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget));
}
else
{
if (spellsIsTarget(oTarget, SPELL_TARGET_STANDARDHOSTILE, OBJECT_SELF))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_CIRCLE_OF_DOOM));
//Make an SR Check
if (!MyResistSpell(OBJECT_SELF, oTarget, fDelay))
{
if (MySavingThrow(SAVING_THROW_FORT, oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_NEGATIVE, OBJECT_SELF, fDelay))
{
nDamage = nDamage/2;
}
//Set Damage
eDam = EffectDamage(nDamage, DAMAGE_TYPE_NEGATIVE);
//Apply impact VFX and damage
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
}
}
}
//Get next target in the specified area
oTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_MEDIUM, GetSpellTargetLocation());
}
}

43
_removed/nw_s0_curcrwn.nss Normal file
View File

@ -0,0 +1,43 @@
//::///////////////////////////////////////////////
//:: Cure Critical Wounds
//:: NW_S0_CurCrWn
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
// As cure light wounds, except cure critical wounds
// cures 4d8 points of damage plus 1 point per
// caster level (up to +20).
*/
//:://////////////////////////////////////////////
//:: Created By: Noel Borstad
//:: Created On: Oct 18, 2000
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 20, 2001
//:: Update Pass By: Preston W, On: July 26, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
spellsCure(d8(4), 20, 32, VFX_IMP_SUNSTRIKE, VFX_IMP_HEALING_G, GetSpellId());
}

45
_removed/nw_s0_curlgtw.nss Normal file
View File

@ -0,0 +1,45 @@
//::///////////////////////////////////////////////
//:: Cure Light Wounds
//:: NW_S0_CurLgtW
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
// When laying your hand upon a living creature,
// you channel positive energy that cures 1d8 points
// of damage plus 1 point per caster level (up to +5).
// Since undead are powered by negative energy, this
// spell inflicts damage on them instead of curing
// their wounds. An undead creature can attempt a
// Will save to take half damage.
*/
//:://////////////////////////////////////////////
//:: Created By: Brennon Holmes
//:: Created On: Oct 12, 2000
//:://////////////////////////////////////////////
//:: Update Pass By: Preston W, On: July 26, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
spellsCure(d8(), 5, 8, VFX_IMP_SUNSTRIKE, VFX_IMP_HEALING_S, GetSpellId());
}

41
_removed/nw_s0_curminw.nss Normal file
View File

@ -0,0 +1,41 @@
//::///////////////////////////////////////////////
//:: Cure Minor Wounds
//:: NW_S0_CurMinW
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
// As cure light wounds, except cure minor wounds
// cures only 1 point of damage
*/
//:://////////////////////////////////////////////
//:: Created By: Noel Borstad
//:: Created On: Oct 18, 2000
//:://////////////////////////////////////////////
//:: Last Updated By: Preston Watamaniuk, On: Feb 22, 2001
//:: Last Updated By: Preston Watamaniuk, On: April 6, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
spellsCure(4, 0, 4, VFX_IMP_SUNSTRIKE, VFX_IMP_HEAD_HEAL, GetSpellId());
}

42
_removed/nw_s0_curmodw.nss Normal file
View File

@ -0,0 +1,42 @@
//::///////////////////////////////////////////////
//:: Cure Moderate Wounds
//:: NW_S0_CurModW
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
// As cure light wounds, except cure moderate wounds
// cures 2d8 points of damage plus 1 point per
// caster level (up to +10).
*/
//:://////////////////////////////////////////////
//:: Created By: Noel Borstad
//:: Created On: Oct 18, 2001
//:://////////////////////////////////////////////
//:: Update Pass By: Preston W, On: July 25, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
spellsCure(d8(2), 10, 16, VFX_IMP_SUNSTRIKE, VFX_IMP_HEALING_M, GetSpellId());
}

42
_removed/nw_s0_curserw.nss Normal file
View File

@ -0,0 +1,42 @@
//::///////////////////////////////////////////////
//:: Cure Serious Wounds
//:: NW_S0_CurSerW
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
// As cure light wounds, except cure moderate wounds
// cures 3d8 points of damage plus 1 point per caster
// level (up to +15).
*/
//:://////////////////////////////////////////////
//:: Created By: Noel Borstad
//:: Created On: Oct 18, 2000
//:://////////////////////////////////////////////
//:: Update Pass By: Preston W, On: July 25, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
spellsCure(d8(3), 15, 24, VFX_IMP_SUNSTRIKE, VFX_IMP_HEALING_L, GetSpellId());
}

82
_removed/nw_s0_harm.nss Normal file
View File

@ -0,0 +1,82 @@
//::///////////////////////////////////////////////
//:: [Harm]
//:: [NW_S0_Harm.nss]
//:: Copyright (c) 2000 Bioware Corp.
//:://////////////////////////////////////////////
//:: Reduces target to 1d4 HP on successful touch
//:: attack. If the target is undead it is healed.
//:://////////////////////////////////////////////
//:: Created By: Keith Soleski
//:: Created On: Jan 18, 2001
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 20, 2001
//:: Update Pass By: Preston W, On: Aug 1, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-23 by GeorgZ
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget = GetSpellTargetObject();
int nDamage, nHeal;
int nMetaMagic = GetMetaMagicFeat();
int nTouch = TouchAttackMelee(oTarget);
effect eVis = EffectVisualEffect(246);
effect eVis2 = EffectVisualEffect(VFX_IMP_HEALING_G);
effect eHeal, eDam;
//Check that the target is undead
if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD||(GetSubRace(oTarget)=="Vampire"))
{
//Figure out the amount of damage to heal
nHeal = GetMaxHitPoints(oTarget)/2;
if (nHeal + GetCurrentHitPoints(oTarget) > GetMaxHitPoints(oTarget))
{ nHeal = GetMaxHitPoints(oTarget); }
//Set the heal effect
eHeal = EffectHeal(nHeal);
//Apply heal effect and VFX impact
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_HARM, FALSE));
}
else if (nTouch) //== TRUE) 1 or 2 are valid return numbers from TouchAttackMelee
{
if(!GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_HARM));
if (!MyResistSpell(OBJECT_SELF, oTarget))
{
nDamage = (GetCurrentHitPoints(oTarget)/2) - d4(1);// - d4(1);
//Check for metamagic
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = GetCurrentHitPoints(oTarget)/2;// - 1;
}
eDam = EffectDamage(nDamage,DAMAGE_TYPE_NEGATIVE);
//Apply the VFX impact and effects
DelayCommand(1.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
}
}
}

95
_removed/nw_s0_heal.nss Normal file
View File

@ -0,0 +1,95 @@
//::///////////////////////////////////////////////
//:: Heal
//:: [NW_S0_Heal.nss]
//:: Copyright (c) 2000 Bioware Corp.
//:://////////////////////////////////////////////
//:: Heals the target to full unless they are undead.
//:: If undead they reduced to 1d4 HP.
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Jan 12, 2001
//:://////////////////////////////////////////////
//:: Update Pass By: Preston W, On: Aug 1, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
#include "werewolf_cure"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-23 by GeorgZ
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget = GetSpellTargetObject();
effect eKill, eHeal;
int nDamage, nHeal, nModify, nMetaMagic, nTouch;
effect eSun = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eHealVis = EffectVisualEffect(VFX_IMP_HEALING_X);
//Check to see if the target is an undead
if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD||(GetSubRace(oTarget)=="Vampire"))
{
if(!GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_HEAL));
//Make a touch attack
if (TouchAttackMelee(oTarget))
{
//Make SR check
if (!MyResistSpell(OBJECT_SELF, oTarget))
{
//Roll damage
nModify = d4();
nMetaMagic = GetMetaMagicFeat();
//Make metamagic check
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nModify = 1;
}
//Figure out the amount of damage to inflict
nDamage = (GetCurrentHitPoints(oTarget)/2) - nModify;
//Set damage
eKill = EffectDamage(nDamage, DAMAGE_TYPE_POSITIVE);
//Apply damage effect and VFX impact
ApplyEffectToObject(DURATION_TYPE_INSTANT, eKill, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eSun, oTarget);
}
}
}
}
else
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_HEAL, FALSE));
//Figure out how much to heal
//nHeal = GetMaxHitPoints(oTarget);
nHeal = GetMaxHitPoints(oTarget)/2;
if (nHeal + GetCurrentHitPoints(oTarget) > GetMaxHitPoints(oTarget))
{ nHeal = GetMaxHitPoints(oTarget); }
//Set the heal effect
eHeal = EffectHeal(nHeal);
//Apply the heal effect and the VFX impact
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHealVis, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget);
}
werewolf();
}

127
_removed/nw_s0_healcirc.nss Normal file
View File

@ -0,0 +1,127 @@
//::///////////////////////////////////////////////
//:: Healing Circle
//:: NW_S0_HealCirc
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
// Positive energy spreads out in all directions
// from the point of origin, curing 1d8 points of
// damage plus 1 point per caster level (maximum +20)
// to nearby living allies.
//
// Like cure spells, healing circle damages undead in
// its area rather than curing them.
*/
//:://////////////////////////////////////////////
//:: Created By: Noel Borstad
//:: Created On: Oct 18,2000
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 20, 2001
//:: Update Pass By: Preston W, On: Aug 1, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget;
int nCasterLvl = GetCasterLevel(OBJECT_SELF);
int nDamagen, nModify, nHurt, nHP;
int nMetaMagic = GetMetaMagicFeat();
effect eKill;
effect eHeal;
effect eVis = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eVis2 = EffectVisualEffect(VFX_IMP_HEALING_M);
effect eImpact = EffectVisualEffect(VFX_FNF_LOS_HOLY_20);
float fDelay;
//Limit caster level
if (nCasterLvl > 20)
{
nCasterLvl = 20;
}
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eImpact, GetSpellTargetLocation());
//Get first target in shape
oTarget = GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_LARGE, GetSpellTargetLocation());
while (GetIsObjectValid(oTarget))
{
fDelay = GetRandomDelay();
//Check if racial type is undead
if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD ||(GetSubRace(oTarget)=="Vampire"))
{
if(!GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_HEALING_CIRCLE));
//Make SR check
if (!MyResistSpell(OBJECT_SELF, oTarget, fDelay))
{
nModify = d8() + nCasterLvl;
//Make metamagic check
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nModify = 8 + nCasterLvl;
}
//Make Fort save
if (MySavingThrow(SAVING_THROW_FORT, oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_NONE, OBJECT_SELF, fDelay))
{
nModify /= 2;
}
//Calculate damage
nHurt = nModify;
//Set damage effect
eKill = EffectDamage(nHurt, DAMAGE_TYPE_POSITIVE);
//Apply damage effect and VFX impact
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eKill, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
}
}
}
else
{
// * May 2003: Heal Neutrals as well
if(!GetIsReactionTypeHostile(oTarget) || GetFactionEqual(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_HEALING_CIRCLE, FALSE));
nHP = d8();
//Enter Metamagic conditions
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nHP =8;//Damage is at max
}
if (nMetaMagic == METAMAGIC_EMPOWER)
{
nHP = nHP + (nHP/2); //Damage/Healing is +50%
}
//Set healing effect
nHP = nHP + nCasterLvl;
eHeal = EffectHeal(nHP);
//Apply heal effect and VFX impact
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget));
}
}
//Get next target in the shape
oTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_LARGE, GetSpellTargetLocation());
}
}

101
_removed/nw_s0_horrwilt.nss Normal file
View File

@ -0,0 +1,101 @@
//::///////////////////////////////////////////////
//:: Horrid Wilting
//:: NW_S0_HorrWilt
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
All living creatures (not undead or constructs)
suffer 1d8 damage per caster level to a maximum
of 25d8 damage.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Sept 12 , 2001
//:://////////////////////////////////////////////
#include "X0_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oCaster = OBJECT_SELF;
int nCasterLvl = GetCasterLevel(oCaster);
int nMetaMagic = GetMetaMagicFeat();
int nDamage;
float fDelay;
effect eExplode = EffectVisualEffect(VFX_FNF_HORRID_WILTING);
effect eVis = EffectVisualEffect(VFX_IMP_NEGATIVE_ENERGY);
effect eDam;
//Get the spell target location as opposed to the spell target.
location lTarget = GetSpellTargetLocation();
//Limit Caster level for the purposes of damage
if (nCasterLvl > 25)
{
nCasterLvl = 25;
}
//Apply the horrid wilting explosion at the location captured above.
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eExplode, lTarget);
//Declare the spell shape, size and the location. Capture the first target object in the shape.
object oTarget = GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_HUGE, lTarget);
//Cycle through the targets within the spell shape until an invalid object is captured.
while (GetIsObjectValid(oTarget))
{
// GZ: Not much fun if the caster is always killing himself
if (spellsIsTarget(oTarget, SPELL_TARGET_STANDARDHOSTILE, OBJECT_SELF) && oTarget != OBJECT_SELF)
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_HORRID_WILTING));
//Get the distance between the explosion and the target to calculate delay
fDelay = GetRandomDelay(1.5, 2.5);
if (!MyResistSpell(OBJECT_SELF, oTarget, fDelay))
{
if(GetRacialType(oTarget) != RACIAL_TYPE_CONSTRUCT && GetRacialType(oTarget) != RACIAL_TYPE_UNDEAD &&(GetSubRace(oTarget)!="Vampire"))
{
//Roll damage for each target
nDamage = d8(nCasterLvl);
//Resolve metamagic
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = 8 * nCasterLvl;
}
else if (nMetaMagic == METAMAGIC_EMPOWER)
{
nDamage = nDamage + nDamage / 2;
}
if(/*Fort Save*/ MySavingThrow(SAVING_THROW_FORT, oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_NONE, OBJECT_SELF, fDelay))
{
nDamage = nDamage/2;
}
//Set the damage effect
eDam = EffectDamage(nDamage, DAMAGE_TYPE_MAGICAL);
// Apply effects to the currently selected target.
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
//This visual effect is applied to the target object not the location as above. This visual effect
//represents the flame that erupts on the target not on the ground.
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
}
}
}
//Select the next target within the spell shape.
oTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_HUGE, lTarget);
}
}

110
_removed/nw_s0_masheal.nss Normal file
View File

@ -0,0 +1,110 @@
//::///////////////////////////////////////////////
//:: Mass Heal
//:: [NW_S0_MasHeal.nss]
//:: Copyright (c) 2000 Bioware Corp.
//:://////////////////////////////////////////////
//:: Heals all friendly targets within 10ft to full
//:: unless they are undead.
//:: If undead they reduced to 1d4 HP.
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: April 11, 2001
//:://////////////////////////////////////////////
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
#include "werewolf_cure"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-23 by GeorgZ
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
effect eKill;
effect eVis = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eHeal;
effect eVis2 = EffectVisualEffect(VFX_IMP_HEALING_G);
effect eStrike = EffectVisualEffect(VFX_FNF_LOS_HOLY_10);
int nTouch, nModify, nDamage, nHeal;
int nMetaMagic = GetMetaMagicFeat();
float fDelay;
//Apply VFX area impact
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eStrike, GetSpellTargetLocation());
//Get first target in spell area
object oTarget = GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_MEDIUM, GetSpellTargetLocation());
while(GetIsObjectValid(oTarget))
{
fDelay = GetRandomDelay();
//Check to see if the target is an undead
if ((GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD && !GetIsReactionTypeFriendly(oTarget))||(GetSubRace(oTarget)=="Vampire" && !GetIsReactionTypeFriendly(oTarget)))
// if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD && !GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_MASS_HEAL));
//Make a touch attack
nTouch = TouchAttackRanged(oTarget);
if (nTouch == 1)
{
if(!GetIsReactionTypeFriendly(oTarget))
{
//Make an SR check
if (!MyResistSpell(OBJECT_SELF, oTarget, fDelay))
{
//Roll damage
nModify = d4();
//make metamagic check
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nModify = 1;
}
//Detemine the damage to inflict to the undead
nDamage = GetCurrentHitPoints(oTarget) - nModify;
//Set the damage effect
eKill = EffectDamage(nDamage, DAMAGE_TYPE_POSITIVE);
//Apply the VFX impact and damage effect
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eKill, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
}
}
}
}
else
{
//Make a faction check
if(GetIsFriend(oTarget) && GetRacialType(oTarget) != RACIAL_TYPE_UNDEAD)
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_MASS_HEAL, FALSE));
//Determine amount to heal
nHeal = GetMaxHitPoints(oTarget);
//Set the damage effect
eHeal = EffectHeal(nHeal);
//Apply the VFX impact and heal effect
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget));
}
}
//Get next target in the spell area
oTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_MEDIUM, GetSpellTargetLocation());
}
werewolf();
}

130
_removed/nw_s0_negburst.nss Normal file
View File

@ -0,0 +1,130 @@
//::///////////////////////////////////////////////
//:: Negative Energy Burst
//:: NW_S0_NegBurst
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
The caster releases a burst of negative energy
at a specified point doing 1d8 + 1 / level
negative energy damage
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Sept 13, 2001
//:://////////////////////////////////////////////
#include "X0_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oCaster = OBJECT_SELF;
int nCasterLvl = GetCasterLevel(oCaster);
int nMetaMagic = GetMetaMagicFeat();
int nDamage;
float fDelay;
effect eExplode = EffectVisualEffect(VFX_FNF_LOS_EVIL_20); //Replace with Negative Pulse
effect eVis = EffectVisualEffect(VFX_IMP_NEGATIVE_ENERGY);
effect eVisHeal = EffectVisualEffect(VFX_IMP_HEALING_M);
effect eDam, eHeal;
int nStr = nCasterLvl / 4;
if (nStr == 0)
{
nStr = 1;
}
effect eStr = EffectAbilityIncrease(ABILITY_STRENGTH, nStr);
effect eStr_Low = EffectAbilityDecrease(ABILITY_STRENGTH, nStr);
effect eDur = EffectVisualEffect(VFX_DUR_CESSATE_POSITIVE);
effect eDur2 = EffectVisualEffect(VFX_DUR_CESSATE_NEGATIVE);
effect eGood = EffectLinkEffects(eStr, eDur);
effect eBad = EffectLinkEffects(eStr_Low, eDur2);
//Get the spell target location as opposed to the spell target.
location lTarget = GetSpellTargetLocation();
//Apply the explosion at the location captured above.
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eExplode, lTarget);
//Declare the spell shape, size and the location. Capture the first target object in the shape.
object oTarget = GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_HUGE, lTarget);
//Cycle through the targets within the spell shape until an invalid object is captured.
while (GetIsObjectValid(oTarget))
{
if(spellsIsTarget(oTarget, SPELL_TARGET_STANDARDHOSTILE, OBJECT_SELF))
{
//Roll damage for each target
nDamage = d8() + nCasterLvl;
//Resolve metamagic
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = 8 + nCasterLvl;
}
else if (nMetaMagic == METAMAGIC_EMPOWER)
{
nDamage = nDamage + (nDamage / 2);
}
if(MySavingThrow(SAVING_THROW_WILL, oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_NEGATIVE, OBJECT_SELF, fDelay))
{
nDamage /= 2;
}
//Get the distance between the explosion and the target to calculate delay
fDelay = GetDistanceBetweenLocations(lTarget, GetLocation(oTarget))/20;
// * any undead should be healed, not just Friendlies
// if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD)
if ((GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD)||(GetSubRace(oTarget)=="Vampire"))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_NEGATIVE_ENERGY_BURST, FALSE));
//Set the heal effect
eHeal = EffectHeal(nDamage);
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget));
//This visual effect is applied to the target object not the location as above. This visual effect
//represents the flame that erupts on the target not on the ground.
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVisHeal, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_PERMANENT, eGood, oTarget));
}
else
if(spellsIsTarget(oTarget, SPELL_TARGET_STANDARDHOSTILE, OBJECT_SELF))
{
if(GetRacialType(oTarget) != RACIAL_TYPE_UNDEAD)
{
if(!MyResistSpell(OBJECT_SELF, oTarget, fDelay))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_NEGATIVE_ENERGY_BURST));
//Set the damage effect
eDam = EffectDamage(nDamage, DAMAGE_TYPE_NEGATIVE);
// Apply effects to the currently selected target.
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
//This visual effect is applied to the target object not the location as above. This visual effect
//represents the flame that erupts on the target not on the ground.
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_PERMANENT, eBad, oTarget));
}
}
}
}
//Select the next target within the spell shape.
oTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_HUGE, lTarget);
}
}

96
_removed/nw_s0_negray.nss Normal file
View File

@ -0,0 +1,96 @@
//::///////////////////////////////////////////////
//:: Negative Energy Ray
//:: NW_S0_NegRay
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Fires a bolt of negative energy at the target
doing 1d6 damage. Does an additional 1d6
damage for 2 levels after level 1 (3,5,7,9) to
a maximum of 5d6 at level 9.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Sept 13, 2001
//:://////////////////////////////////////////////
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-23 by GeorgZ
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget = GetSpellTargetObject();
int nCasterLevel = GetCasterLevel(OBJECT_SELF);
int nMetaMagic = GetMetaMagicFeat();
if(nCasterLevel > 9)
{
nCasterLevel = 9;
}
nCasterLevel = (nCasterLevel + 1) / 2;
int nDamage = d6(nCasterLevel);
//Enter Metamagic conditions
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = 6 * nCasterLevel;//Damage is at max
}
else if (nMetaMagic == METAMAGIC_EMPOWER)
{
nDamage = nDamage + (nDamage/2); //Damage/Healing is +50%
}
effect eVis = EffectVisualEffect(VFX_IMP_NEGATIVE_ENERGY);
effect eDam = EffectDamage(nDamage, DAMAGE_TYPE_NEGATIVE);
effect eHeal = EffectHeal(nDamage);
effect eVisHeal = EffectVisualEffect(VFX_IMP_HEALING_M);
effect eRay;
if(GetRacialType(oTarget) != RACIAL_TYPE_UNDEAD || GetSubRace(oTarget) != "Vampire")
{
if(!GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_NEGATIVE_ENERGY_RAY));
eRay = EffectBeam(VFX_BEAM_EVIL, OBJECT_SELF, BODY_NODE_HAND);
if (!MyResistSpell(OBJECT_SELF, oTarget))
{
//Make a saving throw check
if(/*Will Save*/ MySavingThrow(SAVING_THROW_WILL, oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_NEGATIVE))
{
nDamage /= 2;
}
//Apply the VFX impact and effects
//DelayCommand(0.5, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
DelayCommand(0.5, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget);
}
}
}
else
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_NEGATIVE_ENERGY_RAY, FALSE));
eRay = EffectBeam(VFX_BEAM_EVIL, OBJECT_SELF, BODY_NODE_HAND);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVisHeal, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget);
}
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eRay, oTarget, 1.7);
}

51
_removed/nw_s0_raisdead.nss Normal file
View File

@ -0,0 +1,51 @@
//::///////////////////////////////////////////////
//:: [Raise Dead]
//:: [NW_S0_RaisDead.nss]
//:: Copyright (c) 2000 Bioware Corp.
//:://////////////////////////////////////////////
//:: Brings a character back to life with 1 HP.
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Jan 31, 2001
//:://////////////////////////////////////////////
//:: Last Updated By: Preston Watamaniuk, On: April 11, 2001
//:: VFX Pass By: Preston W, On: June 22, 2001
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget = GetSpellTargetObject();
effect eRaise = EffectResurrection();
effect eVis = EffectVisualEffect(VFX_IMP_RAISE_DEAD);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_RAISE_DEAD, FALSE));
//if(GetIsDead(oTarget))
if((GetIsDead(oTarget))&&(GetSubRace(oTarget) != "Vampire"))
{
//Apply raise dead effect and VFX impact
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eVis, GetLocation(oTarget));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eRaise, oTarget);
}
}

69
_removed/nw_s0_remeffect.nss Normal file
View File

@ -0,0 +1,69 @@
//::///////////////////////////////////////////////
//:: Remove Effects
//:: NW_SO_RemEffect
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Takes the place of
Remove Disease
Neutralize Poison
Remove Paralysis
Remove Curse
Remove Blindness / Deafness
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Jan 8, 2002
//:://////////////////////////////////////////////
#include "NW_I0_SPELLS"
#include "werewolf_cure"
void main()
{
// Werewolf Addon
werewolf();
//Declare major variables
int nSpellID = GetSpellId();
object oTarget = GetSpellTargetObject();
int nEffect1;
int nEffect2;
int nEffect3;
effect eVis = EffectVisualEffect(VFX_IMP_REMOVE_CONDITION);
//Check for which removal spell is being cast.
if(nSpellID == SPELL_REMOVE_BLINDNESS_AND_DEAFNESS)
{
nEffect1 = EFFECT_TYPE_BLINDNESS;
nEffect2 = EFFECT_TYPE_DEAF;
}
else if(nSpellID == SPELL_REMOVE_CURSE)
{
nEffect1 = EFFECT_TYPE_CURSE;
}
else if(nSpellID == SPELL_REMOVE_DISEASE || nSpellID == SPELLABILITY_REMOVE_DISEASE)
{
nEffect1 = EFFECT_TYPE_DISEASE;
nEffect2 = EFFECT_TYPE_ABILITY_DECREASE;
}
else if(nSpellID == SPELL_NEUTRALIZE_POISON)
{
nEffect1 = EFFECT_TYPE_POISON;
nEffect2 = EFFECT_TYPE_DISEASE;
nEffect3 = EFFECT_TYPE_ABILITY_DECREASE;
}
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, nSpellID, FALSE));
//Remove effects
RemoveSpecificEffect(nEffect1, oTarget);
if(nEffect2 != 0)
{
RemoveSpecificEffect(nEffect2, oTarget);
}
if(nEffect3 != 0)
{
RemoveSpecificEffect(nEffect3, oTarget);
}
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}

79
_removed/nw_s0_resserec.nss Normal file
View File

@ -0,0 +1,79 @@
//::///////////////////////////////////////////////
//:: [Ressurection]
//:: [NW_S0_Ressurec.nss]
//:: Copyright (c) 2000 Bioware Corp.
//:://////////////////////////////////////////////
//:: Brings a character back to life with full
//:: health.
//:: When cast on placeables, you get a default error message.
//:: * You can specify a different message in
//:: X2_L_RESURRECT_SPELL_MSG_RESREF
//:: * You can turn off the message by setting the variable
//:: to -1
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Jan 31, 2001
//:://////////////////////////////////////////////
//:: Last Updated By: Georg Z on 2003-07-31
//:: VFX Pass By: Preston W, On: June 22, 2001
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Get the spell target
object oTarget = GetSpellTargetObject();
//Check to make sure the target is dead first
//Fire cast spell at event for the specified target
if (GetIsObjectValid(oTarget))
{
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_RESURRECTION, FALSE));
//if (GetIsDead(oTarget))
if((GetIsDead(oTarget))&&(GetSubRace(oTarget) != "Vampire"))
{
//Declare major variables
int nHealed = GetMaxHitPoints(oTarget);
effect eRaise = EffectResurrection();
effect eHeal = EffectHeal(nHealed + 10);
effect eVis = EffectVisualEffect(VFX_IMP_RAISE_DEAD);
//Apply the heal, raise dead and VFX impact effect
ApplyEffectToObject(DURATION_TYPE_INSTANT, eRaise, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget);
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eVis, GetLocation(oTarget));
}
else
{
if (GetObjectType(oTarget) == OBJECT_TYPE_PLACEABLE)
{
int nStrRef = GetLocalInt(oTarget,"X2_L_RESURRECT_SPELL_MSG_RESREF");
if (nStrRef == 0)
{
nStrRef = 83861;
}
if (nStrRef != -1)
{
FloatingTextStrRefOnCreature(nStrRef,OBJECT_SELF);
}
}
}
}
}

89
_removed/nw_s0_restore.nss Normal file
View File

@ -0,0 +1,89 @@
//::///////////////////////////////////////////////
//:: Restoration
//:: NW_S0_Restore.nss
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Removes all negative effects unless they come
from Poison, Disease or Curses.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Jan 7, 2002
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 22, 2001
#include "x2_inc_spellhook"
// return TRUE if the effect created by a supernatural force and can't be dispelled by spells
int GetIsSupernaturalCurse(effect eEff);
void main()
{
/*
Spellcast Hook Code
Added 2003-06-23 by GeorgZ
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget = GetSpellTargetObject();
effect eVisual = EffectVisualEffect(VFX_IMP_RESTORATION);
int bValid;
effect eBad = GetFirstEffect(oTarget);
//Search for negative effects
while(GetIsEffectValid(eBad))
{
if (GetEffectType(eBad) == EFFECT_TYPE_ABILITY_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_AC_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_ATTACK_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_DAMAGE_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_DAMAGE_IMMUNITY_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_SAVING_THROW_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_SPELL_RESISTANCE_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_SKILL_DECREASE ||
GetEffectType(eBad) == EFFECT_TYPE_BLINDNESS ||
GetEffectType(eBad) == EFFECT_TYPE_DEAF ||
GetEffectType(eBad) == EFFECT_TYPE_PARALYZE ||
GetEffectType(eBad) == EFFECT_TYPE_NEGATIVELEVEL)
{
//Remove effect if it is negative.
if(!GetIsSupernaturalCurse(eBad))
{
RemoveEffect(oTarget, eBad);
}
effect eLevelDrain = SupernaturalEffect(EffectNegativeLevel(1));
if(GetLocalInt(oTarget,"LevelDrain")==1)
{
RemoveEffect(oTarget, eLevelDrain);
SetLocalInt(oTarget,"LevelDrain", 0);
}
}
eBad = GetNextEffect(oTarget);
}
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_RESTORATION, FALSE));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVisual, oTarget);
}
int GetIsSupernaturalCurse(effect eEff)
{
object oCreator = GetEffectCreator(eEff);
if(GetTag(oCreator) == "q6e_ShaorisFellTemple")
return TRUE;
return FALSE;
}

43
_removed/nw_s0_rmvcurse.nss Normal file
View File

@ -0,0 +1,43 @@
//::///////////////////////////////////////////////
//:: Remove Curse
//:: NW_S0_RmvCurse.nss
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Goes through the effects on a character and removes
all curse effects.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Aug 7, 2001
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 22, 2001
#include "werewolf_cure"
void main()
{
//Declare major variables
object oTarget = GetSpellTargetObject();
int nType;
effect eRemove = GetFirstEffect(oTarget);
effect eVis = EffectVisualEffect(VFX_IMP_REMOVE_CONDITION);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_REMOVE_CURSE, FALSE));
//Get the first effect on the target
while(GetIsEffectValid(eRemove))
{
//Check if the current effect is of correct type
if (GetEffectType(eRemove) == EFFECT_TYPE_CURSE)
{
//Remove the effect and apply VFX impact
RemoveEffect(oTarget, eRemove);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
//Get the next effect on the target
GetNextEffect(oTarget);
}
werewolf();
}

48
_removed/nw_s0_rmvdiseas.nss Normal file
View File

@ -0,0 +1,48 @@
//::///////////////////////////////////////////////
//:: Remove Disease
//:: NW_S0_RmvDiseas.nss
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Removes all disease effects on the character.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Aug 7, 2001
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 22, 2001
#include "werewolf_cure"
void main()
{
//Declare major variables
object oTarget = GetSpellTargetObject();
int nType;
int bValid = FALSE;
effect eParal = GetFirstEffect(oTarget);
effect eVis = EffectVisualEffect(VFX_IMP_REMOVE_CONDITION);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_REMOVE_DISEASE, FALSE));
//Get the first effect on the target
while(GetIsEffectValid(eParal))
{
//Check if the current effect is of correct type
if (GetEffectType(eParal) == EFFECT_TYPE_DISEASE)
{
//Remove the effect
RemoveEffect(oTarget, eParal);
bValid = TRUE;
}
//Get the next effect on the target
GetNextEffect(oTarget);
}
if (bValid)
{
//Apply VFX Impact
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
werewolf();
}

116
_removed/nw_s0_searlght.nss Normal file
View File

@ -0,0 +1,116 @@
//::///////////////////////////////////////////////
//:: Searing Light
//:: NW_S0_SearLght.nss
//:: Copyright (c) 2000 Bioware Corp.
//:://////////////////////////////////////////////
//:: Focusing holy power like a ray of the sun, you project
//:: a blast of light from your open palm. You must succeed
//:: at a ranged touch attack to strike your target. A creature
//:: struck by this ray of light suffers 1d8 points of damage
//:: per two caster levels (maximum 5d8). Undead creatures suffer
//:: 1d6 points of damage per caster level (maximum 10d6), and
//:: undead creatures particularly vulnerable to sunlight, such
//:: as vampires, suffer 1d8 points of damage per caster level
//:: (maximum 10d8). Constructs and inanimate objects suffer only
//:: 1d6 points of damage per two caster levels (maximum 5d6).
//:://////////////////////////////////////////////
//:: Created By: Keith Soleski
//:: Created On: 02/05/2001
//:://////////////////////////////////////////////
//:: VFX Pass By: Preston W, On: June 25, 2001
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-23 by GeorgZ
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oCaster = OBJECT_SELF;
object oTarget = GetSpellTargetObject();
int nMetaMagic = GetMetaMagicFeat();
int nCasterLevel = GetCasterLevel(oCaster);
int nDamage;
int nMax;
effect eDam;
effect eVis = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eRay = EffectBeam(VFX_BEAM_HOLY, OBJECT_SELF, BODY_NODE_HAND);
if(!GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_SEARING_LIGHT));
eRay = EffectBeam(VFX_BEAM_HOLY, OBJECT_SELF, BODY_NODE_HAND);
//Make an SR Check
if (!MyResistSpell(oCaster, oTarget))
{
//Limit caster level
if (nCasterLevel > 10)
{
nCasterLevel = 10;
}
//Check for racial type undead
//if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD)
if ((GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD)||(GetSubRace(oTarget)=="Vampire"))
{
nDamage = d6(nCasterLevel);
nMax = 6;
}
//Check for racial type construct
else if (GetRacialType(oTarget) == RACIAL_TYPE_CONSTRUCT)
{
nCasterLevel /= 2;
if(nCasterLevel == 0)
{
nCasterLevel = 1;
}
nDamage = d6(nCasterLevel);
nMax = 6;
}
else
{
nCasterLevel = nCasterLevel/2;
if(nCasterLevel == 0)
{
nCasterLevel = 1;
}
nDamage = d8(nCasterLevel);
nMax = 8;
}
//Make metamagic checks
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = nMax * nCasterLevel;
}
if (nMetaMagic == METAMAGIC_EMPOWER)
{
nDamage = nDamage + (nDamage/2);
}
//Set the damage effect
eDam = EffectDamage(nDamage, DAMAGE_TYPE_DIVINE);
//Apply the damage effect and VFX impact
ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget);
DelayCommand(0.5, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget));
//ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eRay, oTarget, 1.0);
}
}
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eRay, oTarget, 1.7);
}

125
_removed/nw_s0_sunbeam.nss Normal file
View File

@ -0,0 +1,125 @@
//::///////////////////////////////////////////////
//:: Sunbeam
//:: NW_S0_Sunbeam.nss
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
//:: All creatures in the beam are struck blind and suffer 4d6 points of damage. (A successful
//:: Reflex save negates the blindness and reduces the damage by half.) Creatures to whom sunlight
//:: is harmful or unnatural suffer double damage.
//::
//:: Undead creatures caught within the ray are dealt 1d6 points of damage per caster level
//:: (maximum 20d6), or half damage if a Reflex save is successful. In addition, the ray results in
//:: the total destruction of undead creatures specifically affected by sunlight if they fail their saves.
//:://////////////////////////////////////////////
//:: Created By: Keith Soleski
//:: Created On: Feb 22, 2001
//:://////////////////////////////////////////////
//:: Last Modified By: Keith Soleski, On: March 21, 2001
//:: VFX Pass By: Preston W, On: June 25, 2001
#include "X0_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
int nMetaMagic = GetMetaMagicFeat();
effect eVis = EffectVisualEffect(VFX_IMP_DEATH);
effect eVis2 = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eStrike = EffectVisualEffect(VFX_FNF_SUNBEAM);
effect eDam;
effect eBlind = EffectBlindness();
effect eDur = EffectVisualEffect(VFX_DUR_CESSATE_NEGATIVE);
effect eLink = EffectLinkEffects(eBlind, eDur);
int nCasterLevel= GetCasterLevel(OBJECT_SELF);
int nDamage;
int nOrgDam;
int nMax;
float fDelay;
int nBlindLength = 3;
//Limit caster level
if (nCasterLevel > 20)
{
nCasterLevel = 20;
}
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eStrike, GetSpellTargetLocation());
//Get the first target in the spell area
object oTarget = GetFirstObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_COLOSSAL, GetSpellTargetLocation());
while(GetIsObjectValid(oTarget))
{
// Make a faction check
if (spellsIsTarget(oTarget, SPELL_TARGET_STANDARDHOSTILE, OBJECT_SELF))
{
fDelay = GetRandomDelay(1.0, 2.0);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_SUNBEAM));
//Make an SR check
if ( ! MyResistSpell(OBJECT_SELF, oTarget, 1.0))
{
//Check if the target is an undead
//if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD)
if ((GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD) || (GetSubRace(oTarget)=="Vampire"))
{
//Roll damage and save
nDamage = d6(nCasterLevel);
nMax = 6;
}
else
{
//Roll damage and save
nDamage = d6(3);
nOrgDam = nDamage;
nMax = 6;
nCasterLevel = 3;
//Get the adjusted damage due to Reflex Save, Evasion or Improved Evasion
}
//Do metamagic checks
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = nMax * nCasterLevel;
}
if (nMetaMagic == METAMAGIC_EMPOWER)
{
nDamage = nDamage + (nDamage/2);
}
//Check that a reflex save was made.
if(MySavingThrow(SAVING_THROW_REFLEX, oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_DIVINE, OBJECT_SELF, 1.0) == 0)
{
DelayCommand(1.0, ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oTarget, RoundsToSeconds(nBlindLength)));
nDamage = GetReflexAdjustedDamage(nDamage, oTarget, 0, SAVING_THROW_TYPE_DIVINE);
}
//Set damage effect
eDam = EffectDamage(nDamage, DAMAGE_TYPE_DIVINE);
if(nDamage > 0)
{
//Apply the damage effect and VFX impact
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget));
DelayCommand(fDelay, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
}
}
}
//Get the next target in the spell area
oTarget = GetNextObjectInShape(SHAPE_SPHERE, RADIUS_SIZE_COLOSSAL, GetSpellTargetLocation());
}
}

95
_removed/nw_s0_timestop.nss Normal file
View File

@ -0,0 +1,95 @@
//::////////////////////////////////////////////////////:://
//:: Invizible420's Alternate Time Stop Spell //:://
//:: //:://
//:: By: Invizible420 //:://
//:: (Created 12/20/02 updated 06/13/04 (v 1.75) //:://
//::////////////////////////////////////////////////////:://
//:: //:://
//:: Persistent World Workaround for Bioware's //:://
//:: Default Time Stop Spell. This will //:://
//:: CutSceneDominate creatures within a radius //:://
//:: of the caster. //:://
//:: //:://
//:: This version will not Time Stop the caster's //:://
//:: familiar, summons, animal companion, and only //:://
//:: the caster's first henchman (Does not support //:://
//:: multiple henchmens. Has been thoroughly tested //:://
//:: and will Time Stop creature's with Immunity to //:://
//:: Mind Affecting spells. //:://
//:: //:://
//:: Contact info/Bug Reports: Digiddy777@yahoo.com //:://
//::////////////////////////////////////////////////////:://
#include "NW_I0_GENERIC"
// Customize User Defined Variables
//float fDur = 15.0; // Duration in seconds -- Change this to however long you want Time Stop to last Uncomment and Comment out 3rd ed duration
// This is the formula for accurate 3rd ed. Duration
float fDur = IntToFloat(d4(1)+1)*6.0; // Least duration is 12 seconds, maximum duration is 30 seconds
float fDist = 20.0; // Radius in meters -- for a wider area of affect increase this float
// Function to resume creature(s) previous actions wrapped for Delay
void ResumeLast(object oResumee, object oIntruder)
{
// Delay DetermineCombatRound
DelayCommand(fDur+0.25,AssignCommand(oResumee,DetermineCombatRound(oIntruder)));
}
// Function to control Time Stop effects
void TSEffects(object oEffector, object oCaster)
{
// Check if stopped creature is a hostile
if (GetIsReactionTypeHostile(oCaster,oEffector) == TRUE)
{
// Start the resume combat round after Time Stop
ResumeLast(oEffector, oCaster);
}
// Clear the creature(s) action que
AssignCommand(oEffector,ClearAllActions(TRUE));
// Make module dominate the creature(s) for fDur seconds & Freeze the Animation to look like time stopped
AssignCommand(GetModule(),ApplyEffectToObject(DURATION_TYPE_TEMPORARY,EffectCutsceneDominated(),oEffector,fDur));
ApplyEffectToObject(DURATION_TYPE_TEMPORARY,EffectVisualEffect(VFX_DUR_FREEZE_ANIMATION),oEffector,fDur);
}
// Function to get creature(s) within radius and apply the alternate Time Stop
void TimeStop(object oTarget)
{
object oNearestC; // Define nearest creature
// Begin loop to find all creatures within the fDist meter radius
oNearestC = GetFirstObjectInShape(SHAPE_SPHERE, fDist, GetSpellTargetLocation(), FALSE, OBJECT_TYPE_CREATURE);
while(GetIsObjectValid(oNearestC))
{
// To make sure it doesn't stop the caster or caster's familiar, first henchman, or summons
if ((oNearestC != oTarget) &&
(GetAssociate(ASSOCIATE_TYPE_ANIMALCOMPANION, oTarget) != oNearestC) &&
(GetAssociate(ASSOCIATE_TYPE_FAMILIAR, oTarget) != oNearestC) &&
(GetAssociate(ASSOCIATE_TYPE_HENCHMAN, oTarget) != oNearestC) &&
(GetAssociate(ASSOCIATE_TYPE_SUMMONED, oTarget) != oNearestC))
{
// Start the Time Stop effects
DelayCommand(0.75,TSEffects(oNearestC,oTarget));
}
// Get the next creature in the fDist meter radius and continue loop
oNearestC = GetNextObjectInShape(SHAPE_SPHERE, fDist, GetSpellTargetLocation(), FALSE, OBJECT_TYPE_CREATURE);
}
}
// Begin Main Function
void main()
{
//Signal event to start the Time Stop
SignalEvent(OBJECT_SELF, EventSpellCastAt(OBJECT_SELF, SPELL_TIME_STOP, FALSE));
// Begin custom Time Stop
TimeStop(OBJECT_SELF);
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_FNF_TIME_STOP), GetSpellTargetLocation());
}

126
_removed/nw_s0_vamptch.nss Normal file
View File

@ -0,0 +1,126 @@
//::///////////////////////////////////////////////
//:: Vampiric Touch
//:: NW_S0_VampTch
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
drain 1d6
HP per 2 caster levels from the target.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Oct 29, 2001
//:://////////////////////////////////////////////
/*
bugfix by Kovi 2002.07.22
- did double damage with maximize
- temporary hp was stacked
2002.08.25
- got temporary hp some immune creatures (Negative Energy Protection), lost
temporary hp against other resistant (SR, Shadow Shield)
Georg 2003-09-11
- Put in melee touch attack check, as the fixed attack bonus is now calculated correctly
*/
#include "x0_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
//--------------------------------------------------------------------------
/* Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
//--------------------------------------------------------------------------
if (!X2PreSpellCastCode())
{
return;
}
//--------------------------------------------------------------------------
// End of Spell Cast Hook
//--------------------------------------------------------------------------
object oTarget = GetSpellTargetObject();
int nMetaMagic = GetMetaMagicFeat();
int nCasterLevel = GetCasterLevel(OBJECT_SELF);
int nDDice = nCasterLevel /2;
if ((nDDice) == 0)
{
nDDice = 1;
}
//--------------------------------------------------------------------------
// GZ: Cap according to the book
//--------------------------------------------------------------------------
else if (nDDice>10)
{
nDDice = 10;
}
int nDamage = d6(nDDice);
//--------------------------------------------------------------------------
//Enter Metamagic conditions
//--------------------------------------------------------------------------
nDamage = MaximizeOrEmpower(6,nDDice,nMetaMagic);
int nDuration = nCasterLevel/2;
if (nMetaMagic == METAMAGIC_EXTEND)
{
nDuration *= 2;
}
//--------------------------------------------------------------------------
//Limit damage to max hp + 10
//--------------------------------------------------------------------------
int nMax = GetCurrentHitPoints(oTarget) + 10;
if(nMax < nDamage)
{
nDamage = nMax;
}
effect eHeal = EffectTemporaryHitpoints(nDamage);
effect eDur = EffectVisualEffect(VFX_DUR_CESSATE_POSITIVE);
effect eLink = EffectLinkEffects(eHeal, eDur);
effect eDamage = EffectDamage(nDamage, DAMAGE_TYPE_NEGATIVE);
effect eVis = EffectVisualEffect(VFX_IMP_NEGATIVE_ENERGY);
effect eVisHeal = EffectVisualEffect(VFX_IMP_HEALING_M);
if(GetObjectType(oTarget) == OBJECT_TYPE_CREATURE)
{
if(!GetIsReactionTypeFriendly(oTarget) &&
GetRacialType(oTarget) != RACIAL_TYPE_UNDEAD &&
GetRacialType(oTarget) != RACIAL_TYPE_CONSTRUCT &&
!GetHasSpellEffect(SPELL_NEGATIVE_ENERGY_PROTECTION, oTarget)&&
(GetSubRace(oTarget)!="Vampire"))
{
SignalEvent(OBJECT_SELF, EventSpellCastAt(OBJECT_SELF, SPELL_VAMPIRIC_TOUCH, FALSE));
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_VAMPIRIC_TOUCH, TRUE));
// GZ: * GetSpellCastItem() == OBJECT_INVALID is used to prevent feedback from showing up when used as OnHitCastSpell property
if (TouchAttackMelee(oTarget,GetSpellCastItem() == OBJECT_INVALID)>0)
{
if(MyResistSpell(OBJECT_SELF, oTarget) == 0)
{
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eDamage, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVisHeal, OBJECT_SELF);
RemoveTempHitPoints();
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, OBJECT_SELF, HoursToSeconds(nDuration));
}
}
}
}
}

88
_removed/nw_s2_layonhand.nss Normal file
View File

@ -0,0 +1,88 @@
//::///////////////////////////////////////////////
//:: Lay_On_Hands
//:: NW_S2_LayOnHand.nss
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
The Paladin is able to heal his Chr Bonus times
his level.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Aug 15, 2001
//:: Updated On: Oct 20, 2003
//:://////////////////////////////////////////////
#include "NW_I0_SPELLS"
void main()
{
object oTarget = GetSpellTargetObject();
int nChr = GetAbilityModifier(ABILITY_CHARISMA);
if (nChr < 0)
{
nChr = 0;
}
int nLevel = GetLevelByClass(CLASS_TYPE_PALADIN);
//--------------------------------------------------------------------------
// July 2003: Add Divine Champion levels to lay on hands ability
//--------------------------------------------------------------------------
nLevel = nLevel + GetLevelByClass(CLASS_TYPE_DIVINECHAMPION);
//--------------------------------------------------------------------------
// Caluclate the amount to heal, min is 1 hp
//--------------------------------------------------------------------------
int nHeal = nLevel * nChr;
if(nHeal <= 0)
{
nHeal = 1;
}
effect eHeal = EffectHeal(nHeal);
effect eVis = EffectVisualEffect(VFX_IMP_HEALING_M);
effect eVis2 = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eDam;
int nTouch;
//--------------------------------------------------------------------------
// A paladine can use his lay on hands ability to damage undead creatures
// having undead class levels qualifies as undead as well
//--------------------------------------------------------------------------
//if(GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD || GetLevelByClass(CLASS_TYPE_UNDEAD,oTarget)>0)
if((GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD)||(GetSubRace(oTarget)=="Vampire") || GetLevelByClass(CLASS_TYPE_UNDEAD,oTarget)>0)
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELLABILITY_LAY_ON_HANDS));
//Make a ranged touch attack
nTouch = TouchAttackMelee(oTarget,TRUE);
//----------------------------------------------------------------------
// GZ: The PhB classifies Lay on Hands as spell like ability, so it is
// subject to SR. No more cheesy demi lich kills on touch, sorry.
//----------------------------------------------------------------------
int nResist = MyResistSpell(OBJECT_SELF,oTarget);
if (nResist == 0 )
{
if(nTouch > 0)
{
if(nTouch == 2)
{
nHeal *= 2;
}
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELLABILITY_LAY_ON_HANDS));
eDam = EffectDamage(nHeal, DAMAGE_TYPE_DIVINE);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget);
}
}
}
else
{
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELLABILITY_LAY_ON_HANDS, FALSE));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
}

229
_removed/nw_s2_turndead.nss Normal file
View File

@ -0,0 +1,229 @@
//::///////////////////////////////////////////////
//:: Turn Undead
//:: NW_S2_TurnDead
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Checks domain powers and class to determine
the proper turning abilities of the casting
character.
*/
//:://////////////////////////////////////////////
//:: Created By: Preston Watamaniuk
//:: Created On: Nov 2, 2001
//:: Updated On: Jul 15, 2003 - Georg Zoeller
//:://////////////////////////////////////////////
//:: MODIFIED MARCH 5 2003 for Blackguards
//:: MODIFIED JULY 24 2003 for Planar Turning to include turn resistance hd
void main()
{
int nClericLevel = GetLevelByClass(CLASS_TYPE_CLERIC);
int nPaladinLevel = GetLevelByClass(CLASS_TYPE_PALADIN);
int nBlackguardlevel = GetLevelByClass(CLASS_TYPE_BLACKGUARD);
int nTotalLevel = GetHitDice(OBJECT_SELF);
int nTurnLevel = nClericLevel;
int nClassLevel = nClericLevel;
// GZ: Since paladin levels stack when turning, blackguard levels should stack as well
// GZ: but not with the paladin levels (thus else if).
if((nBlackguardlevel - 2) > 0 && (nBlackguardlevel > nPaladinLevel))
{
nClassLevel += (nBlackguardlevel - 2);
nTurnLevel += (nBlackguardlevel - 2);
}
else if((nPaladinLevel - 2) > 0)
{
nClassLevel += (nPaladinLevel -2);
nTurnLevel += (nPaladinLevel - 2);
}
//Flags for bonus turning types
int nElemental = GetHasFeat(FEAT_AIR_DOMAIN_POWER) + GetHasFeat(FEAT_EARTH_DOMAIN_POWER) + GetHasFeat(FEAT_FIRE_DOMAIN_POWER) + GetHasFeat(FEAT_WATER_DOMAIN_POWER);
int nVermin = GetHasFeat(FEAT_PLANT_DOMAIN_POWER);// + GetHasFeat(FEAT_ANIMAL_COMPANION);
int nConstructs = GetHasFeat(FEAT_DESTRUCTION_DOMAIN_POWER);
int nGoodOrEvilDomain = GetHasFeat(FEAT_GOOD_DOMAIN_POWER) + GetHasFeat(FEAT_EVIL_DOMAIN_POWER);
int nPlanar = GetHasFeat(854);
//Flag for improved turning ability
int nSun = GetHasFeat(FEAT_SUN_DOMAIN_POWER);
//Make a turning check roll, modify if have the Sun Domain
int nChrMod = GetAbilityModifier(ABILITY_CHARISMA);
int nTurnCheck = d20() + nChrMod; //The roll to apply to the max HD of undead that can be turned --> nTurnLevel
int nTurnHD = d6(2) + nChrMod + nClassLevel; //The number of HD of undead that can be turned.
if(nSun == TRUE)
{
nTurnCheck += d4();
nTurnHD += d6();
}
//Determine the maximum HD of the undead that can be turned.
if(nTurnCheck <= 0)
{
nTurnLevel -= 4;
}
else if(nTurnCheck >= 1 && nTurnCheck <= 3)
{
nTurnLevel -= 3;
}
else if(nTurnCheck >= 4 && nTurnCheck <= 6)
{
nTurnLevel -= 2;
}
else if(nTurnCheck >= 7 && nTurnCheck <= 9)
{
nTurnLevel -= 1;
}
else if(nTurnCheck >= 10 && nTurnCheck <= 12)
{
//Stays the same
}
else if(nTurnCheck >= 13 && nTurnCheck <= 15)
{
nTurnLevel += 1;
}
else if(nTurnCheck >= 16 && nTurnCheck <= 18)
{
nTurnLevel += 2;
}
else if(nTurnCheck >= 19 && nTurnCheck <= 21)
{
nTurnLevel += 3;
}
else if(nTurnCheck >= 22)
{
nTurnLevel += 4;
}
//Gets all creatures in a 20m radius around the caster and turns them or not. If the creatures
//HD are 1/2 or less of the nClassLevel then the creature is destroyed.
int nCnt = 1;
int nHD, nRacial, nHDCount, bValid, nDamage;
nHDCount = 0;
effect eVis = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eVisTurn = EffectVisualEffect(VFX_DUR_MIND_AFFECTING_FEAR);
effect eDamage;
effect eTurned = EffectTurned();
effect eDur = EffectVisualEffect(VFX_DUR_CESSATE_NEGATIVE);
effect eLink = EffectLinkEffects(eVisTurn, eTurned);
eLink = EffectLinkEffects(eLink, eDur);
effect eDeath = SupernaturalEffect(EffectDeath(TRUE));
effect eImpactVis = EffectVisualEffect(VFX_FNF_LOS_HOLY_30);
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eImpactVis, GetLocation(OBJECT_SELF));
//Get nearest enemy within 20m (60ft)
//Why are you using GetNearest instead of GetFirstObjectInShape
object oTarget = GetNearestCreature(CREATURE_TYPE_IS_ALIVE, TRUE , OBJECT_SELF, nCnt,CREATURE_TYPE_PERCEPTION , PERCEPTION_SEEN);
while(GetIsObjectValid(oTarget) && nHDCount < nTurnHD && GetDistanceToObject(oTarget) <= 20.0)
{
if(!GetIsFriend(oTarget))
{
nRacial = GetRacialType(oTarget);
if (nRacial == RACIAL_TYPE_OUTSIDER )
{
if (nPlanar)
{
//Planar turning decreases spell resistance against turning by 1/2
nHD = GetHitDice(oTarget) + (GetSpellResistance(oTarget) /2) + GetTurnResistanceHD(oTarget);
}
else
{
nHD = GetHitDice(oTarget) + (GetSpellResistance(oTarget) + GetTurnResistanceHD(oTarget) );
}
}
else //(full turn resistance)
{
nHD = GetHitDice(oTarget) + GetTurnResistanceHD(oTarget);
}
if(nHD <= nTurnLevel && nHD <= (nTurnHD - nHDCount))
{
//Check the various domain turning types
//if(nRacial == RACIAL_TYPE_UNDEAD)
if((nRacial == RACIAL_TYPE_UNDEAD)||(GetSubRace(oTarget)=="Vampire"))
{
bValid = TRUE;
}
else if (nRacial == RACIAL_TYPE_VERMIN && nVermin > 0)
{
bValid = TRUE;
}
else if (nRacial == RACIAL_TYPE_ELEMENTAL && nElemental > 0)
{
bValid = TRUE;
}
else if (nRacial == RACIAL_TYPE_CONSTRUCT && nConstructs > 0)
{
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELLABILITY_TURN_UNDEAD));
nDamage = d3(nTurnLevel);
eDamage = EffectDamage(nDamage, DAMAGE_TYPE_MAGICAL);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eDamage, oTarget);
nHDCount += nHD;
}
else if (nRacial == RACIAL_TYPE_OUTSIDER && (nGoodOrEvilDomain+nPlanar > 0) )
{
bValid = TRUE;
}
// * if wearing gauntlets of the lich,then can be turned
else if (GetIsObjectValid(GetItemPossessedBy(oTarget, "x2_gauntletlich")) == TRUE)
{
if (GetTag(GetItemInSlot(INVENTORY_SLOT_ARMS)) == "x2_gauntletlich")
{
bValid = TRUE;
}
}
//Apply results of the turn
if( bValid == TRUE)
{
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
if (nPlanar>0 && nRacial == RACIAL_TYPE_OUTSIDER)
{
effect ePlane = EffectVisualEffect(VFX_IMP_DIVINE_STRIKE_HOLY);
ApplyEffectToObject(DURATION_TYPE_INSTANT, ePlane, oTarget);
}
//if(IntToFloat(nClassLevel)/2.0 >= IntToFloat(nHD))
//{
if((nClassLevel/2) >= nHD)
{
if (nPlanar>0 && nRacial == RACIAL_TYPE_OUTSIDER)
{
effect ePlane2 = EffectVisualEffect(VFX_IMP_UNSUMMON);
ApplyEffectToObject(DURATION_TYPE_INSTANT, ePlane2, oTarget);
}
effect ePlane2 = EffectVisualEffect(VFX_IMP_DIVINE_STRIKE_HOLY);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELLABILITY_TURN_UNDEAD));
//Destroy the target
DelayCommand(0.1f, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDeath, oTarget));
}
else
{
//Turn the target
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELLABILITY_TURN_UNDEAD));
AssignCommand(oTarget, ActionMoveAwayFromObject(OBJECT_SELF, TRUE));
ApplyEffectToObject(DURATION_TYPE_TEMPORARY, eLink, oTarget, RoundsToSeconds(nClassLevel + 5));
}
nHDCount = nHDCount + nHD;
}
}
bValid = FALSE;
}
nCnt++;
oTarget = GetNearestCreature(CREATURE_TYPE_IS_ALIVE,TRUE, OBJECT_SELF, nCnt,CREATURE_TYPE_PERCEPTION , PERCEPTION_SEEN);
}
}

1920
_removed/x0_i0_spells.nss Normal file
View File

File diff suppressed because it is too large Load Diff

48
_removed/x0_s0_inflict.nss Normal file
View File

@ -0,0 +1,48 @@
//::///////////////////////////////////////////////
//:: [Inflict Wounds]
//:: [X0_S0_Inflict.nss]
//:: Copyright (c) 2002 Bioware Corp.
//:://////////////////////////////////////////////
//:: This script is used by all the inflict spells
//::
//:://////////////////////////////////////////////
//:: Created By: Brent
//:: Created On: July 2002
//:://////////////////////////////////////////////
//:: VFX Pass By:
#include "X0_I0_SPELLS" // * this is the new spells include for expansion packs
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
int nSpellID = GetSpellId();
switch (nSpellID)
{
/*Minor*/ case 431: spellsInflictTouchAttack(1, 0, 1, 246, VFX_IMP_HEALING_G, nSpellID); break;
/*Light*/ case 432: case 609: spellsInflictTouchAttack(d8(), 5, 8, 246, VFX_IMP_HEALING_G, nSpellID); break;
/*Moderate*/ case 433: case 610: spellsInflictTouchAttack(d8(2), 10, 16, 246, VFX_IMP_HEALING_G, nSpellID); break;
/*Serious*/ case 434: case 611: spellsInflictTouchAttack(d8(3), 15, 24, 246, VFX_IMP_HEALING_G, nSpellID); break;
/*Critical*/ case 435: case 612: spellsInflictTouchAttack(d8(4), 20, 32, 246, VFX_IMP_HEALING_G, nSpellID); break;
}
}

154
_removed/x0_s0_sunburst.nss Normal file
View File

@ -0,0 +1,154 @@
//::///////////////////////////////////////////////
//:: Sunburst
//:: X0_S0_Sunburst
//:: Copyright (c) 2002 Bioware Corp.
//:://////////////////////////////////////////////
/*
// Brilliant globe of heat
// All creatures in the globe are blinded and
// take 6d6 damage
// Undead creatures take 1d6 damage (max 25d6)
// The blindness is permanent unless cast to remove it
*/
//:://////////////////////////////////////////////
//:: Created By: Brent
//:: Created On: July 23 2002
//:://////////////////////////////////////////////
//:: Last Updated By: Andrew Nobbs May 14, 2003
//:: Notes: Changed damage to non-undead to 6d6
//:: 2003-10-09: GZ Added Subrace check for vampire special case, bugfix
#include "X0_I0_SPELLS"
#include "x2_inc_spellhook"
float nSize = RADIUS_SIZE_COLOSSAL;
void main()
{
/*
Spellcast Hook Code
Added 2003-06-20 by Georg
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oCaster = OBJECT_SELF;
int nCasterLvl = GetCasterLevel(oCaster);
int nMetaMagic = GetMetaMagicFeat();
int nDamage = 0;
float fDelay;
effect eExplode = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eVis = EffectVisualEffect(VFX_IMP_HEAD_HOLY);
effect eHitVis = EffectVisualEffect(VFX_IMP_DIVINE_STRIKE_FIRE);
effect eLOS = EffectVisualEffect(VFX_FNF_LOS_HOLY_30);
effect eDam;
//Get the spell target location as opposed to the spell target.
location lTarget = GetSpellTargetLocation();
//Limit Caster level for the purposes of damage
if (nCasterLvl > 25)
{
nCasterLvl = 25;
}
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, OBJECT_SELF);
ApplyEffectAtLocation(DURATION_TYPE_INSTANT, eLOS, GetSpellTargetLocation());
int bDoNotDoDamage = FALSE;
//Declare the spell shape, size and the location. Capture the first target object in the shape.
object oTarget = GetFirstObjectInShape(SHAPE_SPHERE, nSize, lTarget, TRUE, OBJECT_TYPE_CREATURE);
//Cycle through the targets within the spell shape until an invalid object is captured.
while (GetIsObjectValid(oTarget))
{
if (spellsIsTarget(oTarget, SPELL_TARGET_SELECTIVEHOSTILE, OBJECT_SELF))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, SPELL_SUNBURST));
//This visual effect is applied to the target object not the location as above. This visual effect
//represents the flame that erupts on the target not on the ground.
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHitVis, oTarget);
if (!MyResistSpell(OBJECT_SELF, oTarget, fDelay))
{
if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD || GetSubRace(oTarget)=="Vampire")
{
//Roll damage for each target
nDamage = MaximizeOrEmpower(6, nCasterLvl, nMetaMagic);
}
else
{
nDamage = MaximizeOrEmpower(6, 6, nMetaMagic);
}
// * if a vampire then destroy it
if (GetAppearanceType(oTarget) == APPEARANCE_TYPE_VAMPIRE_MALE || GetAppearanceType(oTarget) == APPEARANCE_TYPE_VAMPIRE_FEMALE || GetStringLowerCase(GetSubRace(oTarget)) == "vampire" )
{
// SpeakString("I vampire");
// * if reflex saving throw fails no blindness
if (!ReflexSave(oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_SPELL))
{
effect eDead = EffectDamage(GetCurrentHitPoints(oTarget));
//ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectVisualEffect(VFX_IMP_FLAME_M), oTarget);
//Apply epicenter explosion on caster
ApplyEffectToObject(DURATION_TYPE_INSTANT, eExplode, oTarget);
DelayCommand(0.5, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDead, oTarget));
bDoNotDoDamage = TRUE;
}
}
if (bDoNotDoDamage == FALSE)
//Adjust the damage based on the Reflex Save, Evasion and Improved Evasion.
nDamage = GetReflexAdjustedDamage(nDamage, oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_SPELL);
// * Do damage
if ((nDamage > 0) && (bDoNotDoDamage == FALSE))
{
//Set the damage effect
eDam = EffectDamage(nDamage, DAMAGE_TYPE_MAGICAL);
// Apply effects to the currently selected target.
ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget);
if (GetRacialType(oTarget) != RACIAL_TYPE_UNDEAD && (GetSubRace(oTarget)!="Vampire"))
{
// * if reflex saving throw fails no blindness
if (!ReflexSave(oTarget, GetSpellSaveDC(), SAVING_THROW_TYPE_SPELL))
{
effect eBlindness = EffectBlindness();
ApplyEffectToObject(DURATION_TYPE_PERMANENT, eBlindness, oTarget);
}
}
} // nDamage > 0
}
//-----------------------------------------------------------------
// GZ: Bugfix, reenable damage for next object
//-----------------------------------------------------------------
bDoNotDoDamage = FALSE;
}
//Select the next target within the spell shape.
oTarget = GetNextObjectInShape(SHAPE_SPHERE, nSize, lTarget, TRUE, OBJECT_TYPE_CREATURE);
}
}

122
_removed/x2_s0_cureother.nss Normal file
View File

@ -0,0 +1,122 @@
//::///////////////////////////////////////////////
//:: x2_s0_cureother
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
Cure Critical Wounds on Others - causes 5 points
of damage to the spell caster as well.
*/
//:://////////////////////////////////////////////
//:: Created By: Keith Warner
//:: Created On: Jan 2/03
//:://////////////////////////////////////////////
#include "NW_I0_SPELLS"
#include "x2_inc_spellhook"
void main()
{
/*
Spellcast Hook Code
Added 2003-07-07 by Georg Zoeller
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
// End of Spell Cast Hook
//Declare major variables
object oTarget = GetSpellTargetObject();
int nHeal;
int nDamage = d8(4);
int nMetaMagic = GetMetaMagicFeat();
effect eVis = EffectVisualEffect(VFX_IMP_SUNSTRIKE);
effect eVis2 = EffectVisualEffect(VFX_IMP_SUPER_HEROISM);
effect eHeal, eDam;
int nExtraDamage = GetCasterLevel(OBJECT_SELF); // * figure out the bonus damage
if (nExtraDamage > 20)
{
nExtraDamage = 20;
}
// * if low or normal difficulty is treated as MAXIMIZED
if(GetIsPC(oTarget) && GetGameDifficulty() < GAME_DIFFICULTY_CORE_RULES)
{
nDamage = 32 + nExtraDamage;
}
else
{
nDamage = nDamage + nExtraDamage;
}
//Make metamagic checks
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nDamage = 8 + nExtraDamage;
// * if low or normal difficulty then MAXMIZED is doubled.
if(GetIsPC(OBJECT_SELF) && GetGameDifficulty() < GAME_DIFFICULTY_CORE_RULES)
{
nDamage = nDamage + nExtraDamage;
}
}
if (nMetaMagic == METAMAGIC_EMPOWER || GetHasFeat(FEAT_HEALING_DOMAIN_POWER))
{
nDamage = nDamage + (nDamage/2);
}
if (GetRacialType(oTarget) != RACIAL_TYPE_UNDEAD || (GetSubRace(oTarget)=="Vampire"))
{
if (oTarget != OBJECT_SELF)
{
//Figure out the amount of damage to heal
nHeal = nDamage;
//Set the heal effect
eHeal = EffectHeal(nHeal);
//Apply heal effect and VFX impact
ApplyEffectToObject(DURATION_TYPE_INSTANT, eHeal, oTarget);
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis2, oTarget);
//Apply Damage Effect to the Caster
ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectDamage(5), OBJECT_SELF);
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, 31, FALSE));
}
}
//Check that the target is undead
else
{
int nTouch = TouchAttackMelee(oTarget);
if (nTouch > 0)
{
if(!GetIsReactionTypeFriendly(oTarget))
{
//Fire cast spell at event for the specified target
SignalEvent(oTarget, EventSpellCastAt(OBJECT_SELF, 31));
if (!MyResistSpell(OBJECT_SELF, oTarget))
{
eDam = EffectDamage(nDamage,DAMAGE_TYPE_NEGATIVE);
//Apply the VFX impact and effects
DelayCommand(1.0, ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oTarget));
ApplyEffectToObject(DURATION_TYPE_INSTANT, eVis, oTarget);
}
}
//Apply Damage Effect to the Caster
ApplyEffectToObject(DURATION_TYPE_INSTANT, EffectDamage(5), OBJECT_SELF);
}
}
}

153
_removed/x2_s0_undeath.nss Normal file
View File

@ -0,0 +1,153 @@
//::///////////////////////////////////////////////
//:: Undeath to Death
//:: X2_S0_Undeath
//:: Copyright (c) 2001 Bioware Corp.
//:://////////////////////////////////////////////
/*
This spell slays 1d4 HD worth of undead creatures
per caster level (maximum 20d4). Creatures with
the fewest HD are affected first;
*/
//:://////////////////////////////////////////////
//:: Created By: Georg Zoeller
//:: Created On: August 13,2003
//:://////////////////////////////////////////////
#include "NW_I0_SPELLS"
#include "x0_i0_spells"
#include "x2_inc_toollib"
#include "x2_inc_spellhook"
void DoUndeadToDeath(object oCreature)
{
SignalEvent(oCreature, EventSpellCastAt(OBJECT_SELF, GetSpellId()));
SetLocalInt(oCreature,"X2_EBLIGHT_I_AM_DEAD", TRUE);
if (!MySavingThrow(SAVING_THROW_WILL,oCreature,GetSpellSaveDC(),SAVING_THROW_TYPE_NONE,OBJECT_SELF))
{
float fDelay = GetRandomDelay(0.2f,0.4f);
if (!MyResistSpell(OBJECT_SELF, oCreature, fDelay))
{
effect eDeath = EffectDamage(GetCurrentHitPoints(oCreature),DAMAGE_TYPE_DIVINE,DAMAGE_POWER_ENERGY);
effect eVis = EffectVisualEffect(VFX_IMP_DEATH);
DelayCommand(fDelay+0.5f,ApplyEffectToObject(DURATION_TYPE_INSTANT,eDeath,oCreature));
DelayCommand(fDelay,ApplyEffectToObject(DURATION_TYPE_INSTANT,eVis,oCreature));
}
else
{
DelayCommand(1.0f,DeleteLocalInt(oCreature,"X2_EBLIGHT_I_AM_DEAD"));
}
}
else
{
DelayCommand(1.0f,DeleteLocalInt(oCreature,"X2_EBLIGHT_I_AM_DEAD"));
}
}
void main()
{
/*
Spellcast Hook Code
Added 2003-07-07 by Georg Zoeller
If you want to make changes to all spells,
check x2_inc_spellhook.nss to find out more
*/
if (!X2PreSpellCastCode())
{
// If code within the PreSpellCastHook (i.e. UMD) reports FALSE, do not run this spell
return;
}
int nMetaMagic = GetMetaMagicFeat();
// End of Spell Cast Hook
// Impact VFX
location lLoc = GetSpellTargetLocation();
ApplyEffectAtLocation(DURATION_TYPE_INSTANT,EffectVisualEffect(VFX_FNF_STRIKE_HOLY),lLoc);
TLVFXPillar(VFX_FNF_LOS_HOLY_20, lLoc,3,0.0f);
// build list with affected creatures
// calculation
int nLevel = GetCasterLevel(OBJECT_SELF);
if (nLevel>20)
{
nLevel = 20;
}
// calculate number of hitdice affected
int nLow = 9999;
object oLow;
int nHDLeft = nLevel *d4();
//Enter Metamagic conditions
if (nMetaMagic == METAMAGIC_MAXIMIZE)
{
nHDLeft = 4 * GetCasterLevel(OBJECT_SELF);//Damage is at max
}
if (nMetaMagic == METAMAGIC_EMPOWER)
{
nHDLeft += (nHDLeft/2); //Damage/Healing is +50%
}
int nCurHD;
object oFirst = GetFirstObjectInShape(SHAPE_SPHERE, 20.0f,lLoc );
// Only start loop if there is a creature in the area of effect
if (GetIsObjectValid(oFirst))
{
object oTarget = oFirst;
while (GetIsObjectValid(oTarget) && nHDLeft >0)
{
if (GetRacialType(oTarget) == RACIAL_TYPE_UNDEAD || GetSubRace(oTarget)=="Vampire")
{
nCurHD = GetHitDice(oTarget);
if (nCurHD <= nHDLeft )
{
if(spellsIsTarget(oTarget, SPELL_TARGET_STANDARDHOSTILE, OBJECT_SELF))
{
// ignore creatures already affected
if (GetLocalInt(oTarget,"X2_EBLIGHT_I_AM_DEAD") == 0 && !GetPlotFlag(oTarget) && !GetIsDead(oTarget))
{
// store the creature with the lowest HD
if (GetHitDice(oTarget) <= nLow)
{
nLow = GetHitDice(oTarget);
oLow = oTarget;
}
}
}
}
}
// Get next target
oTarget = GetNextObjectInShape(SHAPE_SPHERE, 20.0f ,lLoc);
// End of cycle, time to kill the lowest creature
if (!GetIsObjectValid(oTarget))
{
// we have a valid lowest creature we can affect with the remaining HD
if (GetIsObjectValid(oLow) && nHDLeft >= nLow)
{
DoUndeadToDeath(oLow);
// decrement remaining HD
nHDLeft -= nLow;
// restart the loop
oTarget = GetFirstObjectInShape(SHAPE_SPHERE, 20.0f, GetSpellTargetLocation());
}
// reset counters
oLow = OBJECT_INVALID;
nLow = 9999;
}
}
}
}