zone_nagrand.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
/* ScriptData
SDName: Nagrand
SD%Complete: 90
SDComment: Quest support: 9868, 9874, 10085. TextId's unknown for altruis_the_sufferer and greatmother_geyah (npc_text)
SDCategory: Nagrand
EndScriptData */
 
/* ContentData
npc_maghar_captive
EndContentData */
 
#include "ScriptMgr.h"
#include "ConditionMgr.h"
#include "GameObjectAI.h"
#include "MotionMaster.h"
#include "Player.h"
#include "ScriptedEscortAI.h"
#include "SpellInfo.h"
#include "SpellScript.h"
#include "TemporarySummon.h"
 
/*######
## npc_maghar_captive
#####*/
 
enum MagharCaptive
{
 SAY_MAG_START = 0,
 SAY_MAG_NO_ESCAPE = 0,
 SAY_MAG_MORE = 1,
 SAY_MAG_MORE_REPLY = 0,
 SAY_MAG_LIGHTNING = 2,
 SAY_MAG_SHOCK = 3,
 SAY_MAG_COMPLETE = 4,
 
 SPELL_CHAIN_LIGHTNING = 16006,
 SPELL_EARTHBIND_TOTEM = 15786,
 SPELL_FROST_SHOCK = 12548,
 SPELL_HEALING_WAVE = 12491,
 
 QUEST_TOTEM_KARDASH_H = 9868,
 
 NPC_MURK_RAIDER = 18203,
 NPC_MURK_BRUTE = 18211,
 NPC_MURK_SCAVENGER = 18207,
 NPC_MURK_PUTRIFIER = 18202,
 
 PATH_ESCORT_MAGHAR_CAPTIVE = 145682,
};
 
static float m_afAmbushA[]= {-1568.805786f, 8533.873047f, 1.958f};
static float m_afAmbushB[]= {-1491.554321f, 8506.483398f, 1.248f};
 
class npc_maghar_captive : public CreatureScript
{
public:
 npc_maghar_captive() : CreatureScript("npc_maghar_captive") { }
 
 struct npc_maghar_captiveAI : public EscortAI
 {
 npc_maghar_captiveAI(Creature* creature) : EscortAI(creature)
 {
 Initialize();
 }
 
 void Initialize()
 {
 ChainLightningTimer = 1000;
 HealTimer = 0;
 FrostShockTimer = 6000;
 }
 
 uint32 ChainLightningTimer;
 uint32 HealTimer;
 uint32 FrostShockTimer;
 
 void Reset() override
 {
 Initialize();
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 DoCast(me, SPELL_EARTHBIND_TOTEM, false);
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 if (!HasEscortState(STATE_ESCORT_ESCORTING))
 return;
 
 if (Player* player = GetPlayerForEscort())
 {
 if (player->GetQuestStatus(QUEST_TOTEM_KARDASH_H) != QUEST_STATUS_COMPLETE)
 player->FailQuest(QUEST_TOTEM_KARDASH_H);
 }
 }
 
 void WaypointReached(uint32 waypointId, uint32 /*pathId*/) override
 {
 switch (waypointId)
 {
 case 7:
 Talk(SAY_MAG_MORE);
 
 if (Creature* temp = me->SummonCreature(NPC_MURK_PUTRIFIER, m_afAmbushB[0], m_afAmbushB[1], m_afAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s))
 temp->AI()->Talk(SAY_MAG_MORE_REPLY);
 
 me->SummonCreature(NPC_MURK_PUTRIFIER, m_afAmbushB[0]-2.5f, m_afAmbushB[1]-2.5f, m_afAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_MURK_SCAVENGER, m_afAmbushB[0]+2.5f, m_afAmbushB[1]+2.5f, m_afAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_MURK_SCAVENGER, m_afAmbushB[0]+2.5f, m_afAmbushB[1]-2.5f, m_afAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 break;
 case 16:
 Talk(SAY_MAG_COMPLETE);
 
 if (Player* player = GetPlayerForEscort())
 player->GroupEventHappens(QUEST_TOTEM_KARDASH_H, me);
 break;
 }
 }
 
 void JustSummoned(Creature* summoned) override
 {
 if (summoned->GetEntry() == NPC_MURK_BRUTE)
 summoned->AI()->Talk(SAY_MAG_NO_ESCAPE);
 
 if (summoned->IsTotem())
 return;
 
 summoned->SetWalk(false);
 summoned->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ());
 summoned->AI()->AttackStart(me);
 
 }
 
 void SpellHitTarget(WorldObject* /*target*/, SpellInfo const* spellInfo) override
 {
 if (spellInfo->Id == SPELL_CHAIN_LIGHTNING)
 {
 if (rand32() % 10)
 return;
 
 Talk(SAY_MAG_LIGHTNING);
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 EscortAI::UpdateAI(diff);
 
 if (!UpdateVictim())
 return;
 
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 
 if (ChainLightningTimer <= diff)
 {
 DoCastVictim(SPELL_CHAIN_LIGHTNING);
 ChainLightningTimer = urand(7000, 14000);
 }
 else
 ChainLightningTimer -= diff;
 
 if (HealthBelowPct(30))
 {
 if (HealTimer <= diff)
 {
 DoCast(me, SPELL_HEALING_WAVE);
 HealTimer = 5000;
 }
 else
 HealTimer -= diff;
 }
 
 if (FrostShockTimer <= diff)
 {
 DoCastVictim(SPELL_FROST_SHOCK);
 FrostShockTimer = urand(7500, 15000);
 }
 else
 FrostShockTimer -= diff;
 }
 
 void OnQuestAccept(Player* player, Quest const* quest) override
 {
 if (quest->GetQuestId() == QUEST_TOTEM_KARDASH_H)
 {
 me->SetStandState(UNIT_STAND_STATE_STAND);
 me->SetFaction(FACTION_ESCORTEE_H_NEUTRAL_ACTIVE);
 LoadPath(PATH_ESCORT_MAGHAR_CAPTIVE);
 Start(true, player->GetGUID(), quest);
 Talk(SAY_MAG_START);
 
 me->SummonCreature(NPC_MURK_RAIDER, m_afAmbushA[0] + 2.5f, m_afAmbushA[1] - 2.5f, m_afAmbushA[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_MURK_PUTRIFIER, m_afAmbushA[0] - 2.5f, m_afAmbushA[1] + 2.5f, m_afAmbushA[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_MURK_BRUTE, m_afAmbushA[0], m_afAmbushA[1], m_afAmbushA[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 }
 }
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return new npc_maghar_captiveAI(creature);
 }
 
};
 
/*#####
## npc_kurenai_captive
#####*/
 
enum KurenaiCaptive
{
 SAY_KUR_START = 0,
 SAY_KUR_NO_ESCAPE = 1,
 SAY_KUR_MORE = 2,
 SAY_KUR_MORE_TWO = 3,
 SAY_KUR_LIGHTNING = 4,
 SAY_KUR_SHOCK = 5,
 SAY_KUR_COMPLETE = 6,
 
 SPELL_KUR_CHAIN_LIGHTNING = 16006,
 SPELL_KUR_EARTHBIND_TOTEM = 15786,
 SPELL_KUR_FROST_SHOCK = 12548,
 SPELL_KUR_HEALING_WAVE = 12491,
 
 QUEST_TOTEM_KARDASH_A = 9879,
 
 NPC_KUR_MURK_RAIDER = 18203,
 NPC_KUR_MURK_BRUTE = 18211,
 NPC_KUR_MURK_SCAVENGER = 18207,
 NPC_KUR_MURK_PUTRIFIER = 18202,
 
 PATH_ESCORT_KURENAI_CAPTIVE = 145674,
};
 
static float kurenaiAmbushA[]= {-1568.805786f, 8533.873047f, 1.958f};
static float kurenaiAmbushB[]= {-1491.554321f, 8506.483398f, 1.248f};
 
class npc_kurenai_captive : public CreatureScript
{
public:
 npc_kurenai_captive() : CreatureScript("npc_kurenai_captive") { }
 
 struct npc_kurenai_captiveAI : public EscortAI
 {
 npc_kurenai_captiveAI(Creature* creature) : EscortAI(creature)
 {
 Initialize();
 }
 
 void Initialize()
 {
 ChainLightningTimer = 1000;
 HealTimer = 0;
 FrostShockTimer = 6000;
 }
 
 uint32 ChainLightningTimer;
 uint32 HealTimer;
 uint32 FrostShockTimer;
 
 void Reset() override
 {
 Initialize();
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 DoCast(me, SPELL_KUR_EARTHBIND_TOTEM, false);
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 if (!HasEscortState(STATE_ESCORT_ESCORTING))
 return;
 
 if (Player* player = GetPlayerForEscort())
 {
 if (player->GetQuestStatus(QUEST_TOTEM_KARDASH_A) != QUEST_STATUS_COMPLETE)
 player->FailQuest(QUEST_TOTEM_KARDASH_A);
 }
 }
 
 void WaypointReached(uint32 waypointId, uint32 /*pathId*/) override
 {
 switch (waypointId)
 {
 case 3:
 {
 Talk(SAY_KUR_MORE);
 
 if (me->SummonCreature(NPC_KUR_MURK_PUTRIFIER, kurenaiAmbushB[0], kurenaiAmbushB[1], kurenaiAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s))
 Talk(SAY_KUR_MORE_TWO);
 
 me->SummonCreature(NPC_KUR_MURK_PUTRIFIER, kurenaiAmbushB[0]-2.5f, kurenaiAmbushB[1]-2.5f, kurenaiAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_KUR_MURK_SCAVENGER, kurenaiAmbushB[0]+2.5f, kurenaiAmbushB[1]+2.5f, kurenaiAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_KUR_MURK_SCAVENGER, kurenaiAmbushB[0]+2.5f, kurenaiAmbushB[1]-2.5f, kurenaiAmbushB[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 break;
 }
 case 7:
 {
 Talk(SAY_KUR_COMPLETE);
 
 if (Player* player = GetPlayerForEscort())
 player->GroupEventHappens(QUEST_TOTEM_KARDASH_A, me);
 break;
 }
 }
 }
 
 void JustSummoned(Creature* summoned) override
 {
 if (summoned->GetEntry() == NPC_KUR_MURK_BRUTE)
 Talk(SAY_KUR_NO_ESCAPE);
 
 // This function is for when we summoned enemies to fight - so that does NOT mean we should make our totem count in this!
 if (summoned->IsTotem())
 return;
 
 summoned->SetWalk(false);
 summoned->GetMotionMaster()->MovePoint(0, me->GetPositionX(), me->GetPositionY(), me->GetPositionZ());
 summoned->AI()->AttackStart(me);
 }
 
 void SpellHitTarget(WorldObject* /*target*/, SpellInfo const* spellInfo) override
 {
 if (spellInfo->Id == SPELL_KUR_CHAIN_LIGHTNING)
 {
 if (rand32() % 30)
 return;
 
 Talk(SAY_KUR_LIGHTNING);
 }
 
 if (spellInfo->Id == SPELL_KUR_FROST_SHOCK)
 {
 if (rand32() % 30)
 return;
 
 Talk(SAY_KUR_SHOCK);
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 EscortAI::UpdateAI(diff);
 
 if (!UpdateVictim())
 return;
 
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 
 if (ChainLightningTimer <= diff)
 {
 DoCastVictim(SPELL_KUR_CHAIN_LIGHTNING);
 ChainLightningTimer = urand(7000, 14000);
 } else ChainLightningTimer -= diff;
 
 if (HealthBelowPct(30))
 {
 if (HealTimer <= diff)
 {
 DoCast(me, SPELL_KUR_HEALING_WAVE);
 HealTimer = 5000;
 } else HealTimer -= diff;
 }
 
 if (FrostShockTimer <= diff)
 {
 DoCastVictim(SPELL_KUR_FROST_SHOCK);
 FrostShockTimer = urand(7500, 15000);
 } else FrostShockTimer -= diff;
 }
 
 void OnQuestAccept(Player* player, Quest const* quest) override
 {
 if (quest->GetQuestId() == QUEST_TOTEM_KARDASH_A)
 {
 me->SetStandState(UNIT_STAND_STATE_STAND);
 me->SetFaction(FACTION_ESCORTEE_A_NEUTRAL_ACTIVE);
 LoadPath(PATH_ESCORT_KURENAI_CAPTIVE);
 Start(true, player->GetGUID(), quest);
 Talk(SAY_KUR_START);
 
 me->SummonCreature(NPC_KUR_MURK_RAIDER, kurenaiAmbushA[0] + 2.5f, kurenaiAmbushA[1] - 2.5f, kurenaiAmbushA[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_KUR_MURK_BRUTE, kurenaiAmbushA[0] - 2.5f, kurenaiAmbushA[1] + 2.5f, kurenaiAmbushA[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 me->SummonCreature(NPC_KUR_MURK_SCAVENGER, kurenaiAmbushA[0], kurenaiAmbushA[1], kurenaiAmbushA[2], 0.0f, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 25s);
 }
 }
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return new npc_kurenai_captiveAI(creature);
 }
};
 
enum PlantBannerQuests
{
 SPELL_PLANT_WARMAUL_OGRE_BANNER = 32307,
 SPELL_PLANT_KIL_SORROW_BANNER = 32314,
 
 NPC_KIL_SORROW_SPELLBINDER = 17146,
 NPC_KIL_SORROW_CULTIST = 17147,
 NPC_KIL_SORROW_DEATHSWORN = 17148,
 NPC_GISELDA_THE_CRONE = 18391,
 NPC_WARMAUL_REAVER = 17138,
 NPC_WARMAUL_SHAMAN = 18064,
 
 PATH_NAGRAND_BANNER = 4816480,
};
 
class npc_nagrand_banner : public CreatureScript
{
public:
 npc_nagrand_banner() : CreatureScript("npc_nagrand_banner") { }
 
 struct npc_nagrand_bannerAI : public ScriptedAI
 {
 npc_nagrand_bannerAI(Creature* creature) : ScriptedAI(creature), bannered(false)
 {
 scheduler.SetValidator([this]
 {
 return !me->HasUnitState(UNIT_STATE_CASTING);
 });
 }
 
 void Reset() override
 {
 scheduler.CancelAll();
 }
 
 void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
 {
 if (spellInfo->Id == SPELL_PLANT_WARMAUL_OGRE_BANNER || spellInfo->Id == SPELL_PLANT_KIL_SORROW_BANNER)
 bannered = true;
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim())
 return;
 
 scheduler.Update(diff);
 }
 
 bool IsBannered()
 {
 return bannered;
 }
 
 void WaypointReached(uint32 waypointId, uint32 pathId) override
 {
 if (pathId != PATH_NAGRAND_BANNER)
 return;
 
 if (waypointId == 11)
 me->HandleEmoteCommand(EMOTE_ONESHOT_APPLAUD);
 else if (waypointId == 4 || waypointId == 8)
 me->HandleEmoteCommand(EMOTE_ONESHOT_TALK);
 else if (waypointId == 10)
 me->HandleEmoteCommand(EMOTE_ONESHOT_POINT);
 else if (waypointId == 3 || waypointId == 7)
 me->HandleEmoteCommand(EMOTE_STATE_USE_STANDING);
 }
 
 protected:
 TaskScheduler scheduler;
 
 private:
 bool bannered;
 };
 
 struct npc_kil_sorrow_spellbinderAI : public npc_nagrand_bannerAI
 {
 enum KilSorrowSpellBinder
 {
 SPELL_ARCANE_MISSILES = 34447,
 SPELL_CHAINS_OF_ICE = 22744,
 SPELL_COUNTERSPELL = 31999
 };
 
 npc_kil_sorrow_spellbinderAI(Creature* creature) : npc_nagrand_bannerAI(creature), has_fled(false), interrupt_cooldown(20000)
 {
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 has_fled = false;
 interrupt_cooldown = 20000;
 scheduler
 .Schedule(Seconds(0), [this](TaskContext ArcaneMissiles)
 {
 DoCastVictim(SPELL_ARCANE_MISSILES);
 ArcaneMissiles.Repeat(Milliseconds(2400), Milliseconds(3800));
 })
 .Schedule(Seconds(3), Seconds(6), [this](TaskContext ChainsOfIce)
 {
 if (Unit* target = SelectTarget(SelectTargetMethod::Random))
 DoCast(target, SPELL_CHAINS_OF_ICE, true);
 ChainsOfIce.Repeat(Seconds(20),Seconds(25));
 });
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim() || !me->GetVictim())
 return;
 
 interrupt_cooldown += diff;
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 
 if (me->EnsureVictim()->HasUnitState(UNIT_STATE_CASTING) && interrupt_cooldown > 25000)
 {
 DoCastVictim(SPELL_COUNTERSPELL);
 interrupt_cooldown = 0;
 }
 
 scheduler.Update(diff);
 }
 
 void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (!has_fled && me->GetHealth() > damage && me->HealthBelowPctDamaged(15, damage))
 {
 me->DoFleeToGetAssistance();
 has_fled = true;
 }
 }
 
 private:
 bool has_fled;
 uint32 interrupt_cooldown;
 };
 
 struct npc_kil_sorrow_cultistAI : public npc_nagrand_bannerAI
 {
 enum KilSorrowCultist
 {
 SPELL_MIND_SEAR = 32000
 };
 
 npc_kil_sorrow_cultistAI(Creature* creature) : npc_nagrand_bannerAI(creature)
 {
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 scheduler
 .Schedule(Milliseconds(4500), [this](TaskContext MindSear)
 {
 DoCastVictim(SPELL_MIND_SEAR);
 MindSear.Repeat(Milliseconds(7000), Milliseconds(11000));
 });
 }
 };
 
 struct npc_kil_sorrow_deathswornAI : public npc_nagrand_bannerAI
 {
 enum KilSorrowDeathsworn
 {
 SPELL_BLOODTHIRST = 31996
 };
 
 npc_kil_sorrow_deathswornAI(Creature* creature) : npc_nagrand_bannerAI(creature), used_bloodthirst(false)
 {
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 used_bloodthirst = false;
 }
 
 void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (!used_bloodthirst && me->GetHealth() > damage && me->HealthBelowPctDamaged(50, damage))
 {
 DoCastVictim(SPELL_BLOODTHIRST);
 used_bloodthirst = true;
 }
 }
 
 private:
 bool used_bloodthirst;
 };
 
 struct npc_giselda_the_croneAI : public npc_nagrand_bannerAI
 {
 enum GiseldaTheCrone
 {
 SPELL_GISELDA_TRANSFORM_DND = 33316
 };
 
 npc_giselda_the_croneAI(Creature* creature) : npc_nagrand_bannerAI(creature), used_transform(false)
 {
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 used_transform = false;
 }
 
 void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (!used_transform && me->GetHealth() > damage && me->HealthBelowPctDamaged(65, damage))
 {
 DoCastVictim(SPELL_GISELDA_TRANSFORM_DND);
 used_transform = true;
 }
 }
 
 private:
 bool used_transform;
 };
 
 struct npc_warmaul_shamanAI : public npc_nagrand_bannerAI
 {
 enum WarmaulShaman
 {
 SPELL_SCORCHING_TOTEM = 15038,
 SPELL_FROST_SHOCK = 12548,
 SPELL_HEALING_WAVE = 11986
 };
 
 npc_warmaul_shamanAI(Creature* creature) : npc_nagrand_bannerAI(creature), used_healing(false)
 {
 }
 
 void JustEngagedWith(Unit* /*who*/) override
 {
 used_healing = false;
 scheduler
 .Schedule(Seconds(2), [this](TaskContext /*SearingTotem*/)
 {
 DoCast(SPELL_SCORCHING_TOTEM);
 })
 .Schedule(Seconds(6), [this](TaskContext FrostShock)
 {
 DoCastVictim(SPELL_FROST_SHOCK);
 FrostShock.Repeat(Seconds(12));
 });
 }
 
 void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (!used_healing && me->GetHealth() > damage && me->HealthBelowPctDamaged(50, damage))
 {
 DoCastSelf(SPELL_HEALING_WAVE);
 used_healing = true;
 }
 }
 
 private:
 uint32 used_healing;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 switch (creature->GetEntry())
 {
 case NPC_KIL_SORROW_SPELLBINDER:
 return new npc_kil_sorrow_spellbinderAI(creature);
 case NPC_KIL_SORROW_CULTIST:
 return new npc_kil_sorrow_cultistAI(creature);
 case NPC_KIL_SORROW_DEATHSWORN:
 return new npc_kil_sorrow_deathswornAI(creature);
 case NPC_GISELDA_THE_CRONE:
 return new npc_giselda_the_croneAI(creature);
 case NPC_WARMAUL_SHAMAN:
 return new npc_warmaul_shamanAI(creature);
 default:
 return new npc_nagrand_bannerAI(creature);
 }
 }
};
 
class condition_nagrand_banner : public ConditionScript
{
public:
 condition_nagrand_banner() : ConditionScript("conditition_nagrand_banner") {}
 
 bool OnConditionCheck(Condition const* condition, ConditionSourceInfo& sourceInfo) override
 {
 WorldObject const* target = sourceInfo.mConditionTargets[condition->ConditionTarget];
 if (Creature const* creature = target->ToCreature())
 {
 if (npc_nagrand_banner::npc_nagrand_bannerAI *ai = CAST_AI(npc_nagrand_banner::npc_nagrand_bannerAI, creature->AI()))
 return !ai->IsBannered();
 }
 return false;
 }
};
 
enum FireBomb
{
 SPELL_FIRE_BOMB_TARGET_SUMMON_EFFECT = 31960,
 SPELL_FIRE_BOMB_DAMAGE_MISSILE = 31961,
 SPELL_FIRE_BOMB_SUMMON_CATAPULT_BLAZE = 31963,
 SPELL_FIRE_BOMB_FLAMES = 34658
};
 
// 31959 - Fire Bomb Target Summon Trigger
class spell_nagrand_fire_bomb_target_summon_trigger : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_FIRE_BOMB_TARGET_SUMMON_EFFECT });
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 if (TempSummon* casterSummon = GetCaster()->ToTempSummon())
 if (Unit* summoner = casterSummon->GetSummonerUnit())
 casterSummon->CastSpell(summoner, SPELL_FIRE_BOMB_TARGET_SUMMON_EFFECT);
 }
 
 void Register() override
 {
 OnEffectHit += SpellEffectFn(spell_nagrand_fire_bomb_target_summon_trigger::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 31960 - Fire Bomb Target Summon Effect
class spell_nagrand_fire_bomb_target_summon_effect : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_FIRE_BOMB_DAMAGE_MISSILE });
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 GetHitUnit()->CastSpell(GetCaster(), SPELL_FIRE_BOMB_DAMAGE_MISSILE);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_nagrand_fire_bomb_target_summon_effect::HandleScript, EFFECT_0, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
// 31961 - Fire Bomb
class spell_nagrand_fire_bomb_damage_missile : public SpellScript
{
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_FIRE_BOMB_SUMMON_CATAPULT_BLAZE, SPELL_FIRE_BOMB_FLAMES });
 }
 
 void HandleScript(SpellEffIndex /*effIndex*/)
 {
 Unit* target = GetHitUnit();
 target->CastSpell(target, SPELL_FIRE_BOMB_SUMMON_CATAPULT_BLAZE);
 target->CastSpell(target, SPELL_FIRE_BOMB_FLAMES);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_nagrand_fire_bomb_damage_missile::HandleScript, EFFECT_2, SPELL_EFFECT_SCRIPT_EFFECT);
 }
};
 
void AddSC_nagrand()
{
 new npc_maghar_captive();
 new npc_kurenai_captive();
 new npc_nagrand_banner();
 new condition_nagrand_banner();
 RegisterSpellScript(spell_nagrand_fire_bomb_target_summon_trigger);
 RegisterSpellScript(spell_nagrand_fire_bomb_target_summon_effect);
 RegisterSpellScript(spell_nagrand_fire_bomb_damage_missile);
}