Rune_PRC8/_module/nss/nw_c2_defaultb.nss
Jaysyn904 d1c309ae63 Initial commit
Initial commit
2024-09-13 09:10:39 -04:00

486 lines
17 KiB
Plaintext

/************************ [On Spell Cast At] ***********************************
Filename: j_ai_onspellcast or nw_c2_defaultb
************************* [On Spell Cast At] ***********************************
What does this do? Well...
- Any AOE spell effects are set in a timer, so we can react to them right
- Reacts to hostile casters, or allies in combat
And the normal attack :-)
************************* [History] ********************************************
1.3 - Added special AOE checks.
- Hide checks.
************************* [Workings] *******************************************
This is fired when EventSpellCastAt(object oCaster, int nSpell, int bHarmful=TRUE)
is signaled on the creature.
GetLastSpellCaster() = oCaster (Door, Placeable, Creature who cast it)
GetLastSpell() = nSpell (The spell cast at us)
GetLastSpellHarmful()= bHarmful (If it is harmful!)
************************* [Arguments] ******************************************
Arguments: GetLastSpellCaster, GetLastSpellHarmful GetLastSpell()
************************* [On Spell Cast At] **********************************/
#include "j_inc_other_ai"
// Sets a local timer if the spell is an AOE one
void SetAOESpell(int iSpellCast, object oCaster);
// Gets the nearest AOE cast by oCaster, of sTag.
object GetNearestAOECastBy(string sTag, object oCaster);
// Gets the amount of protections we have - IE globes
int GetOurSpellLevelImmunity();
void main()
{
ExecuteScript("prc_npc_spellat", OBJECT_SELF);
if (GetLevelByClass(CLASS_TYPE_COMMONER) > 0)
{
ExecuteScript("oai_defaultb", OBJECT_SELF);
return;
}
// Pre-heartbeat-event
if(FireUserEvent(AI_FLAG_UDE_SPELL_CAST_AT_PRE_EVENT, EVENT_SPELL_CAST_AT_PRE_EVENT))
// We may exit if it fires
if(ExitFromUDE(EVENT_SPELL_CAST_AT_PRE_EVENT)) return;
// AI status check. Is the AI on?
if(GetAIOff()) return;
object oCaster = GetLastSpellCaster();
int iHarmful = GetLastSpellHarmful();
int iSpellCast = GetLastSpell();
object oAttackerOfCaster;
// If harmful, we set the spell to a timer, if an AOE one.
if(iHarmful && GetIsObjectValid(oCaster))
{
// Might set AOE spell to cast.
SetAOESpell(iSpellCast, oCaster);
}
// If not a creature, probably an AOE or trap.
if(GetObjectType(oCaster) != OBJECT_TYPE_CREATURE)
{
// 67: "[Spell] Caster isn't a creature! May look for target [Caster] " + GetName(oCaster)
DebugActionSpeakByInt(67, oCaster);
// Attack anyone else around
if(!CannotPerformCombatRound())
{
DetermineCombatRound();
}
}
else if(GetIsObjectValid(oCaster) && !GetIsDM(oCaster) &&
!GetIgnore(oCaster) && oCaster != OBJECT_SELF && !GetIsDead(oCaster))
{
// 1.3 changes here:
// - We do NOT need to know if it is hostile or not, except if it is hostile
// and they are not our faction! We do, however, use iHarmful for speakstrings.
if(!GetFactionEqual(oCaster))
{
// If harmful, we attack anyone! (and if is enemy)
if(iHarmful || GetIsEnemy(oCaster))
{
if(iHarmful)
{
// Hostile spell speaksting, if set.
SpeakArrayString(AI_TALK_ON_HOSTILE_SPELL_CAST_AT);
}
// Turn of hiding check
TurnOffHiding(oCaster);
// Attack
AISpeakString(I_WAS_ATTACKED);
// We attack
if(!CannotPerformCombatRound())
{
// 68: "[Spell:Enemy/Hostile] Not in combat. Attacking: [Caster] " + GetName(oCaster)
DebugActionSpeakByInt(68, oCaster);
DetermineCombatRound(oCaster);
}
}
}
// Else, faction is equal, we normally ignore, and only move to attack.
else
{
// Spawn in condition hostile thingy
if(GetSpawnInCondition(AI_FLAG_OTHER_CHANGE_FACTIONS_TO_HOSTILE_ON_ATTACK, AI_OTHER_MASTER))
{
if(!GetIsEnemy(oCaster))
{
AdjustReputation(oCaster, OBJECT_SELF, -100);
}
}
// We move to the person, if they are attacking something we cannot see...
AISpeakString(CALL_TO_ARMS);
// Not in combat
if(!CannotPerformCombatRound())
{
// 69: "[Spell] (ally). Not in combat. May Attack/Move [Caster] " + GetName(oCaster)
DebugActionSpeakByInt(69, oCaster);
ClearAllActions();
// Check thier target. Might not be valid (IE AOE spell at location)
oAttackerOfCaster = GetAttackTarget(oCaster);
// - Faster then DetermineCombatRound(); and looping targets until
// we get this ally, and get this attacker! :-)
if(GetIsObjectValid(oAttackerOfCaster))
{
// Move to the attack target, and wait for a proper on
// perception event (as we are not currently in combat)
ActionMoveToObject(oCaster, TRUE);
}
else
{
// Move to the caster otherwise
ActionMoveToObject(oCaster, TRUE);
}
}
}
}
// Fire End-spell cast at-UDE
FireUserEvent(AI_FLAG_UDE_SPELL_CAST_AT_EVENT, EVENT_SPELL_CAST_AT_EVENT);
}
// Sets a local timer if the spell is an AOE one
void SetAOESpell(int iSpellCast, object oCaster)
{
// Check it is one we can check
int iImmuneLevel = GetOurSpellLevelImmunity();
switch(iSpellCast)
{
case SPELL_ACID_FOG:
case SPELL_MIND_FOG:
case SPELL_STORM_OF_VENGEANCE:
case SPELL_GREASE:
case SPELL_CREEPING_DOOM:
case SPELL_SILENCE:
case SPELL_BLADE_BARRIER:
case SPELL_CLOUDKILL:
case SPELL_STINKING_CLOUD:
case SPELL_WALL_OF_FIRE:
case SPELL_INCENDIARY_CLOUD:
case SPELL_ENTANGLE:
case SPELL_EVARDS_BLACK_TENTACLES:
case SPELL_CLOUD_OF_BEWILDERMENT:
case SPELL_STONEHOLD:
case SPELL_VINE_MINE:
case SPELL_SPIKE_GROWTH:
case SPELL_VINE_MINE_HAMPER_MOVEMENT:
case SPELL_VINE_MINE_ENTANGLE:
{
// Pass though, unless we are totally immune.
if(iImmuneLevel >= i9)
{
return;
}
}
break;
// Any other spell
default:
{
return;
}
break;
}
// We do use intelligence here...
int iAIInt = GetBoundriedAIInteger(AI_INTELLIGENCE);
int iIgnoreSaves;
int iIgnoreImmunities;
object oAOE;
// If it is low, we ignore all things that we could ignore with it...
if(iAIInt <= i3)
{
iIgnoreSaves = TRUE;
iIgnoreImmunities = TRUE;
}
// Average ignores saves
else if(iAIInt <= i7)
{
iIgnoreSaves = TRUE;
iIgnoreImmunities = FALSE;
}
// Else, we do both.
else
{
iIgnoreSaves = FALSE;
iIgnoreImmunities = FALSE;
}
int SetAOE = FALSE;// TRUE means set to timer
int iSaveDC = i11;
// Get the caster DC, the most out of WIS, INT or CHA...
int iInt = GetAbilityModifier(ABILITY_INTELLIGENCE, oCaster);
int iWis = GetAbilityModifier(ABILITY_WISDOM, oCaster);
int iCha = GetAbilityModifier(ABILITY_CHARISMA, oCaster);
if(iInt > iWis && iInt > iCha)
{
iSaveDC += iInt;
}
else if(iWis > iCha)
{
iSaveDC += iWis;
}
else
{
iSaveDC += iCha;
}
// Note:
// - No reaction type/friendly checks. Signal Event is only fired if the
// spell WILL pierce any PvP/Friendly/Area settings
// We check immunities here, please note...
switch(iSpellCast)
{
// First: IS GetIsReactionTypeHostile ones.
case SPELL_EVARDS_BLACK_TENTACLES:
// Fortitude save, but if we are immune to the hits, its impossible to hurt us
{
// If save immune OR AC immune, we ignore this.
if(i25 >= GetAC(OBJECT_SELF) && iImmuneLevel < i4 &&
((GetFortitudeSavingThrow(OBJECT_SELF) < iSaveDC + i2) || iIgnoreSaves))
{
SetAOE = TRUE;
// Nearest string of tag
oAOE = GetNearestAOECastBy(AI_AOE_PER_EVARDS_BLACK_TENTACLES, oCaster);
}
}
case SPELL_SPIKE_GROWTH:
case SPELL_VINE_MINE_HAMPER_MOVEMENT:
// d4 damage. LOTS of speed loss.
// Reflex save, or immunity, would stop the speed
{
if(iImmuneLevel < i3 &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_MOVEMENT_SPEED_DECREASE) || iIgnoreImmunities) &&
((GetReflexSavingThrow(OBJECT_SELF) < iSaveDC + i5) || iIgnoreSaves))
{
SetAOE = TRUE;
// Both use ENTANGLE AOE's
oAOE = GetNearestAOECastBy(AI_AOE_PER_ENTANGLE, oCaster);
}
}
break;
case SPELL_ENTANGLE:
case SPELL_VINE_MINE_ENTANGLE:
{
if(iImmuneLevel < i1 &&
(!GetHasFeat(FEAT_WOODLAND_STRIDE) || iIgnoreImmunities) &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_ENTANGLE) || iIgnoreImmunities) &&
((GetReflexSavingThrow(OBJECT_SELF) < iSaveDC + i4) || iIgnoreSaves))
{
SetAOE = TRUE;
// Both use ENTANGLE AOE's
oAOE = GetNearestAOECastBy(AI_AOE_PER_ENTANGLE, oCaster);
}
}
break;
case SPELL_WEB:
{
if(iImmuneLevel < i1 &&
(!GetHasFeat(FEAT_WOODLAND_STRIDE) || iIgnoreImmunities) &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_ENTANGLE) || iIgnoreImmunities) &&
((GetReflexSavingThrow(OBJECT_SELF) < iSaveDC + i4) || iIgnoreSaves))
{
SetAOE = TRUE;
// Web AOE
oAOE = GetNearestAOECastBy(AI_AOE_PER_WEB, oCaster);
}
}
break;
// Fort save
case SPELL_STINKING_CLOUD:
{
if(iImmuneLevel < i3 &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_POISON) || iIgnoreImmunities) &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_DAZED) || iIgnoreImmunities) &&
((GetFortitudeSavingThrow(OBJECT_SELF) < iSaveDC + i6) || iIgnoreSaves))
{
SetAOE = TRUE;
// Stinking cloud persistant AOE.
oAOE = GetNearestAOECastBy(AI_AOE_PER_FOGSTINK, oCaster);
}
}
break;
// Fort save
case SPELL_CLOUD_OF_BEWILDERMENT:
{
if(iImmuneLevel < i2 &&
((GetFortitudeSavingThrow(OBJECT_SELF) < iSaveDC + i7) || iIgnoreSaves))
{
SetAOE = TRUE;
// Bewilderment cloud persistant AOE.
oAOE = GetNearestAOECastBy(AI_AOE_PER_FOGBEWILDERMENT, oCaster);
}
}
break;
// Special: Mind save is the effect.
case SPELL_STONEHOLD:
{
if(iImmuneLevel < i6 &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_MIND_SPELLS) || iIgnoreImmunities) &&
((GetWillSavingThrow(OBJECT_SELF) < iSaveDC + i7) || iIgnoreSaves))
{
SetAOE = TRUE;
// Stonehold persistant AOE.
oAOE = GetNearestAOECastBy(AI_AOE_PER_STONEHOLD, oCaster);
}
}
break;
// Special: EFFECT_TYPE_SAVING_THROW_DECREASE is the effect.
case SPELL_MIND_FOG:
{
if(iImmuneLevel < i5 &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_SAVING_THROW_DECREASE) || iIgnoreImmunities) &&
((GetWillSavingThrow(OBJECT_SELF) < iSaveDC + i6) || iIgnoreSaves))
{
SetAOE = TRUE;
// Mind fog
oAOE = GetNearestAOECastBy(AI_AOE_PER_FOGMIND, oCaster);
}
}
break;
// Special: Feats, knockdown
case SPELL_GREASE:
{
if(iImmuneLevel < i1 &&
(!GetIsImmune(OBJECT_SELF, IMMUNITY_TYPE_KNOCKDOWN) || iIgnoreImmunities) &&
(!GetHasFeat(FEAT_WOODLAND_STRIDE, OBJECT_SELF) || iIgnoreImmunities) &&
((GetReflexSavingThrow(OBJECT_SELF) < iSaveDC + i2) || iIgnoreSaves))
{
SetAOE = TRUE;
// Grease
oAOE = GetNearestAOECastBy(AI_AOE_PER_GREASE, oCaster);
}
}
break;
// All other ReactionType ones. Some have different saves though!
case SPELL_BLADE_BARRIER: // Reflex
case SPELL_INCENDIARY_CLOUD:// reflex
case SPELL_WALL_OF_FIRE:// Reflex
{
if(iImmuneLevel < i6 &&
(((GetReflexSavingThrow(OBJECT_SELF) < iSaveDC + i6) &&
!GetHasFeat(FEAT_IMPROVED_EVASION) &&
!GetHasFeat(FEAT_EVASION)) || iIgnoreSaves))
{
SetAOE = TRUE;
if(iSpellCast == SPELL_BLADE_BARRIER)
{
// BB
oAOE = GetNearestAOECastBy(AI_AOE_PER_WALLBLADE, oCaster);
}
else if(iSpellCast == SPELL_INCENDIARY_CLOUD)
{
// Fog of fire
oAOE = GetNearestAOECastBy(AI_AOE_PER_FOGFIRE, oCaster);
}
else if(iSpellCast == SPELL_WALL_OF_FIRE)
{
// Wall of fire
oAOE = GetNearestAOECastBy(AI_AOE_PER_WALLFIRE, oCaster);
}
}
}
break;
case SPELL_ACID_FOG: // Fort: Half. No check, always damages.
case SPELL_CLOUDKILL:// No save!
case SPELL_CREEPING_DOOM: // No save!
{
if(iImmuneLevel < i6)
{
SetAOE = TRUE;
if(iSpellCast == SPELL_ACID_FOG)
{
// Acid fog
oAOE = GetNearestAOECastBy(AI_AOE_PER_FOGACID, oCaster);
}
else if(iSpellCast == SPELL_CLOUDKILL)
{
// Cloud Kill
oAOE = GetNearestAOECastBy(AI_AOE_PER_FOGKILL, oCaster);
}
else if(iSpellCast == SPELL_CREEPING_DOOM)
{
// Creeping doom
oAOE = GetNearestAOECastBy(AI_AOE_PER_CREEPING_DOOM, oCaster);
}
}
}
// Storm - because the AI likes it, we stay in it if it is ours :-)
case SPELL_STORM_OF_VENGEANCE: // Reflex partial. No check, always damages.
{
if(oCaster != OBJECT_SELF && iImmuneLevel < i9)
{
SetAOE = TRUE;
// Storm of vengance
oAOE = GetNearestAOECastBy(AI_AOE_PER_STORM, oCaster);
}
}
}
if(SetAOE)
{
if(!GetLocalTimer(AI_TIMER_AOE_SPELL_EVENT + IntToString(iSpellCast)))
{
SetLocalTimer(AI_TIMER_AOE_SPELL_EVENT + IntToString(iSpellCast), f18);
// Set nearest AOE
if(GetIsObjectValid(oAOE))
{
// Set nearest AOE of this spell to the local
object oNearest = GetAIObject(AI_TIMER_AOE_SPELL_EVENT + IntToString(iSpellCast));
if(GetDistanceToObject(oAOE) < GetDistanceToObject(oNearest) ||
!GetIsObjectValid(oNearest))
{
SetAIObject(AI_TIMER_AOE_SPELL_EVENT + IntToString(iSpellCast), oAOE);
}
}
}
}
}
// Gets the nearest AOE cast by oCaster, of sTag.
object GetNearestAOECastBy(string sTag, object oCaster)
{
int iCnt = i1;
object oAOE = GetNearestObjectByTag(sTag, OBJECT_SELF, iCnt);
object oReturn = OBJECT_INVALID;
// Loop
while(GetIsObjectValid(oAOE) && !GetIsObjectValid(oReturn))
{
// Check creator
if(GetAreaOfEffectCreator(oAOE) == oCaster)
{
oReturn = oAOE;
}
iCnt++;
oAOE = GetNearestObjectByTag(sTag, OBJECT_SELF, iCnt);
}
return oReturn;
}
// Gets the amount of protections we have - IE globes
int GetOurSpellLevelImmunity()
{
int iNatural = GetLocalInt(OBJECT_SELF, AI_SPELL_IMMUNE_LEVEL);
// Stop here, if natural is over 4
if(iNatural > i4) return iNatural;
// Big globe affects 4 or lower spells
if(GetHasSpellEffect(SPELL_GLOBE_OF_INVULNERABILITY, OBJECT_SELF) || iNatural >= i4)
return i4;
// Minor globe is 3 or under
if(GetHasSpellEffect(SPELL_MINOR_GLOBE_OF_INVULNERABILITY, OBJECT_SELF) ||
// Shadow con version
GetHasSpellEffect(SPELL_GREATER_SHADOW_CONJURATION_MINOR_GLOBE, OBJECT_SELF) ||
iNatural >= i3)
return i3;
// 2 and under is ethereal visage.
if(GetHasSpellEffect(SPELL_ETHEREAL_VISAGE, OBJECT_SELF) || iNatural >= i2)
return i2;
// Ghostly Visarge affects 1 or 0 level spells, and any spell immunity.
if(GetHasSpellEffect(SPELL_GHOSTLY_VISAGE, OBJECT_SELF) || iNatural >= i1 ||
// Or shadow con version.
GetHasSpellEffect(SPELL_GREATER_SHADOW_CONJURATION_MIRROR_IMAGE, OBJECT_SELF))
return i1;
// Return iNatural, which is 0-9
return FALSE;
}