boss_slabhide.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/>.
 */
 
#include "ScriptMgr.h"
#include "GameObject.h"
#include "InstanceScript.h"
#include "Map.h"
#include "MotionMaster.h"
#include "ScriptedCreature.h"
#include "SpellScript.h"
#include "stonecore.h"
 
enum Spells
{
 SPELL_FACE_RANDOM_PLAYER = 82530,
 
 // Stalactite Trigger - Trash, On Ground
 SPELL_STALACTITE_SUMMON_TRIGGER = 81028,
 
 // Slabhide
 SPELL_LAVA_FISSURE = 80803,
 SPELL_SAND_BLAST = 80807,
 SPELL_STALACTITE_SUMMON = 80656,
// SPELL_COOLDOWN_5S = 95323, Cooldown: Creature Special 1 (5s)?
 SPELL_CRYSTAL_STORM = 92305,
 SPELL_CRYSTAL_STORM_TRIGGER = 92265,
 
 // Lava Fissure
 SPELL_LAVA_FISSURE_CRACK = 80798,
 SPELL_LAVA_FISSURE_ERUPTION = 80800,
 
 // Stalactite Trigger - Boss
 SPELL_STALACTITE_SHADE = 80654,
 SPELL_STALACTITE_MISSLE = 80643,
 SPELL_STALACTITE_CREATE = 80647,
};
 
enum Entries
{
 NPC_LAVA_FISSURE = 43242,
 NPC_STALACTITE_TRIGGER_GROUND = 43357,
 NPC_STALACTITE_TRIGGER = 43159,
 GO_STALACTITE = 204337,
};
 
enum Actions
{
 ACTION_STALACTITE_MISSLE,
};
 
enum Events
{
 EVENT_NONE,
 
 // Intro events
 EVENT_ROAR_EMOTE,
 
 // Slabhide combat
 EVENT_HANDLE_ROCK_WALLS,
 EVENT_LAVA_FISSURE,
 EVENT_SAND_BLAST,
 EVENT_AIR_PHASE,
 EVENT_TAKEOFF,
 EVENT_STALACTITE,
 EVENT_LAND,
 EVENT_ATTACK,
 
 // Lava Fissure
 EVENT_LAVA_FISSURE_ERUPTION,
 
 // Stalactite Trigger - Boss
 EVENT_STALACTITE_MISSLE,
};
 
enum MovementPoints
{
 POINT_NONE,
 
 POINT_SLABHIDE_INTRO,
 POINT_SLABHIDE_INTRO_LAND,
 
 POINT_SLABHIDE_MIDDLE,
 POINT_SLABHIDE_IN_AIR,
 POINT_SLABHIDE_LAND,
};
 
constexpr Position SlabhideIntroPos = { 1292.27f, 1226.16f, 265.573f };
constexpr Position SlabhideIntroLandPos = { 1292.352f, 1226.478f, 247.6368f, 3.630285f };
 
constexpr Position SlabhideMiddlePos = { 1280.73f, 1212.31f, 247.3837f };
constexpr Position SlabhideInAirPos = { 1280.73f, 1212.31f, 257.3837f };
 
class boss_slabhide : public CreatureScript
{
 public:
 boss_slabhide() : CreatureScript("boss_slabhide") { }
 
 struct boss_slabhideAI : public BossAI
 {
 boss_slabhideAI(Creature* creature) : BossAI(creature, DATA_SLABHIDE)
 {
 me->setActive(true);
 me->SetCanFly(true);
 me->SetDisableGravity(true);
 me->SetReactState(REACT_PASSIVE);
 instance->SetData(DATA_SLABHIDE_INTRO, NOT_STARTED);
 _isFlying = false;
 }
 
 void Reset() override
 {
 if (instance->GetData(DATA_SLABHIDE_INTRO) == NOT_STARTED)
 return;
 
 _Reset();
 DespawnAll();
 
 me->SetCanFly(false);
 me->SetDisableGravity(false);
 me->SetReactState(REACT_AGGRESSIVE);
 _isFlying = false;
 }
 
 void JustEngagedWith(Unit* who) override
 {
 BossAI::JustEngagedWith(who);
 
 events.ScheduleEvent(EVENT_HANDLE_ROCK_WALLS, 4s);
 events.ScheduleEvent(EVENT_LAVA_FISSURE, 6s, 8s);
 events.ScheduleEvent(EVENT_SAND_BLAST, 8s, 10s);
 events.ScheduleEvent(EVENT_AIR_PHASE, 10s);
 }
 
 void DamageTaken(Unit* /*attacker*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
 {
 if (_isFlying && damage >= me->GetHealth())
 damage = me->GetHealth() - 1; // Let creature health fall to 1 hp but prevent it from dying during air phase.
 }
 
 void JustDied(Unit* /*killer*/) override
 {
 _JustDied();
 
 // Despawn related npcs and gameobjects
 DespawnAll();
 }
 
 void DoAction(int32 action) override
 {
 switch (action)
 {
 case ACTION_SLABHIDE_INTRO:
 {
 if (instance->GetData(DATA_SLABHIDE_INTRO) != NOT_STARTED)
 return;
 
 instance->SetData(DATA_SLABHIDE_INTRO, IN_PROGRESS);
 
 // Execute Slabhide intro event
 me->GetMotionMaster()->MovePoint(POINT_SLABHIDE_INTRO, SlabhideIntroPos);
 break;
 }
 default:
 break;
 }
 }
 
 void MovementInform(uint32 type, uint32 id) override
 {
 if (type != POINT_MOTION_TYPE && type != EFFECT_MOTION_TYPE)
 return;
 
 switch (id)
 {
 case POINT_SLABHIDE_INTRO:
 me->SetFacingTo(SlabhideIntroLandPos.GetOrientation());
 me->GetMotionMaster()->MoveLand(POINT_SLABHIDE_INTRO_LAND, SlabhideIntroLandPos);
 break;
 case POINT_SLABHIDE_INTRO_LAND:
 me->SetCanFly(false);
 me->SetDisableGravity(false);
 me->SetHover(false);
 me->SetHomePosition(SlabhideIntroLandPos);
 me->HandleEmoteCommand(EMOTE_ONESHOT_ROAR);
 me->SetUninteractible(false);
 me->SetReactState(REACT_AGGRESSIVE);
 instance->SetData(DATA_SLABHIDE_INTRO, DONE);
 break;
 case POINT_SLABHIDE_MIDDLE:
 _isFlying = true;
 events.ScheduleEvent(EVENT_TAKEOFF, 100ms);
 break;
 case POINT_SLABHIDE_IN_AIR:
 events.ScheduleEvent(EVENT_STALACTITE, 400ms);
 break;
 case POINT_SLABHIDE_LAND:
 _isFlying = false;
 //DoCast(me, SPELL_COOLDOWN_5S); // unknown purpose
 events.ScheduleEvent(EVENT_ATTACK, 1200ms);
 break;
 default:
 break;
 }
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (!UpdateVictim())
 return;
 
 events.Update(diff);
 
 if (me->HasUnitState(UNIT_STATE_CASTING))
 return;
 
 while (uint32 eventId = events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_HANDLE_ROCK_WALLS: // Close rock walls
 instance->SetData(DATA_SLABHIDE_ROCK_WALL, false);
 break;
 case EVENT_LAVA_FISSURE:
 if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0, 100.0f, true))
 DoCast(target, SPELL_LAVA_FISSURE);
 events.ScheduleEvent(EVENT_LAVA_FISSURE, 6s, 8s);
 break;
 case EVENT_SAND_BLAST:
 DoCast(me, SPELL_SAND_BLAST);
 events.ScheduleEvent(EVENT_SAND_BLAST, 8s, 11s);
 break;
 case EVENT_AIR_PHASE:
 events.Reset();
 me->SetReactState(REACT_PASSIVE);
 me->AttackStop();
 me->GetMotionMaster()->MovePoint(POINT_SLABHIDE_MIDDLE, SlabhideMiddlePos);
 events.ScheduleEvent(EVENT_AIR_PHASE, 1min);
 break;
 case EVENT_TAKEOFF:
 me->GetMotionMaster()->MoveTakeoff(POINT_SLABHIDE_IN_AIR, SlabhideInAirPos);
 break;
 case EVENT_STALACTITE:
 me->SetCanFly(true);
 me->SetDisableGravity(true);
 me->SetHover(true);
 
 DoCast(me, SPELL_STALACTITE_SUMMON);
 
 events.ScheduleEvent(EVENT_LAND, 8s);
 break;
 case EVENT_LAND:
 {
 Position pos = me->GetPosition();
 me->UpdateGroundPositionZ(pos.GetPositionX(), pos.GetPositionY(), pos.m_positionZ);
 me->GetMotionMaster()->MoveLand(POINT_SLABHIDE_LAND, pos);
 break;
 }
 case EVENT_ATTACK:
 me->SetCanFly(false);
 me->SetDisableGravity(false);
 me->SetHover(false);
 
 events.ScheduleEvent(EVENT_LAVA_FISSURE, 6s, 8s);
 events.ScheduleEvent(EVENT_SAND_BLAST, 8s, 10s);
 DoCast(me, SPELL_CRYSTAL_STORM);
 me->SetReactState(REACT_AGGRESSIVE);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 void DespawnAll()
 {
 // Despawn stalactite triggers npcs
 std::list<Creature*> listStalactiteTrigger;
 me->GetCreatureListWithEntryInGrid(listStalactiteTrigger, NPC_STALACTITE_TRIGGER, 200.0f);
 if (!listStalactiteTrigger.empty())
 for (std::list<Creature*>::const_iterator itr = listStalactiteTrigger.begin(); itr != listStalactiteTrigger.end(); ++itr)
 (*itr)->DespawnOrUnsummon();
 
 // Despawn stalactite objects
 std::list<GameObject*> listStalactite;
 me->GetGameObjectListWithEntryInGrid(listStalactite, GO_STALACTITE, 200.0f);
 if (!listStalactite.empty())
 for (std::list<GameObject*>::const_iterator itr = listStalactite.begin(); itr != listStalactite.end(); ++itr)
 (*itr)->Delete();
 }
 
 bool _isFlying;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetStonecoreAI<boss_slabhideAI>(creature);
 }
};
 
// 43242 - Lava Fissure
class npc_lava_fissure : public CreatureScript
{
public:
 npc_lava_fissure() : CreatureScript("npc_lava_fissure") { }
 
 struct npc_lava_fissureAI : public ScriptedAI
 {
 npc_lava_fissureAI(Creature* creature) : ScriptedAI(creature)
 {
 DoCast(me, SPELL_LAVA_FISSURE_CRACK, true);
 events.ScheduleEvent(EVENT_LAVA_FISSURE_ERUPTION, 6s);
 }
 
 void UpdateAI(uint32 diff) override
 {
 events.Update(diff);
 
 while (uint32 eventId = events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_LAVA_FISSURE_ERUPTION:
 me->RemoveAurasDueToSpell(SPELL_LAVA_FISSURE_CRACK);
 DoCast(me, SPELL_LAVA_FISSURE_ERUPTION, true);
 me->DespawnOrUnsummon(14s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap events;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetStonecoreAI<npc_lava_fissureAI>(creature);
 }
};
 
// 43159 - Stalactite Trigger - Boss
class npc_stalactite_trigger : public CreatureScript
{
public:
 npc_stalactite_trigger() : CreatureScript("npc_stalactite_trigger") { }
 
 struct npc_stalactite_triggerAI : public ScriptedAI
 {
 npc_stalactite_triggerAI(Creature* creature) : ScriptedAI(creature)
 {
 me->SetDisableGravity(true);
 DoCast(me, SPELL_STALACTITE_SHADE, true);
 events.ScheduleEvent(EVENT_STALACTITE_MISSLE, 5600ms);
 }
 
 void UpdateAI(uint32 diff) override
 {
 if (events.Empty())
 return;
 
 events.Update(diff);
 
 while (uint32 eventId = events.ExecuteEvent())
 {
 switch (eventId)
 {
 case EVENT_STALACTITE_MISSLE:
 DoCast(me, SPELL_STALACTITE_MISSLE);
 me->DespawnOrUnsummon(11s);
 break;
 default:
 break;
 }
 }
 }
 
 private:
 EventMap events;
 };
 
 CreatureAI* GetAI(Creature* creature) const override
 {
 return GetStonecoreAI<npc_stalactite_triggerAI>(creature);
 }
};
 
// 81035 - Stalactite (check if player is near to summon stalactite)
class spell_s81035_stalactite : public SpellScriptLoader
{
public:
 spell_s81035_stalactite() : SpellScriptLoader("spell_s81035_stalactite") { }
 
 class spell_s81035_stalactite_SpellScript : public SpellScript
 {
 void SummonStalactiteTrigger()
 {
 Unit* caster = GetCaster();
 caster->CastSpell(caster, SPELL_STALACTITE_SUMMON_TRIGGER, true);
 }
 
 void Register() override
 {
 OnHit += SpellHitFn(spell_s81035_stalactite_SpellScript::SummonStalactiteTrigger);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_s81035_stalactite_SpellScript();
 }
};
 
// 81028 - Stalactite (summons "Stalactite Trigger - Boss", 20 yard radius)
// 80650 - Stalactite (summons "Stalactite Trigger - Boss", 40 yard radius)
class spell_s81028_s80650_stalactite : public SpellScriptLoader
{
public:
 spell_s81028_s80650_stalactite() : SpellScriptLoader("spell_s81028_s80650_stalactite") { }
 
 class spell_s81028_s80650_stalactite_SpellScript : public SpellScript
 {
 void ModDestHeight(SpellDestination& dest)
 {
 // All stalactite triggers should have Z position 301.3837f, but no way to relocate (not relocateoffset!) height only.
 Position offset = { 0.0f, 0.0f, 50.0f, 0.0f };
 dest.RelocateOffset(offset);
 }
 
 void Register() override
 {
 OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_s81028_s80650_stalactite_SpellScript::ModDestHeight, EFFECT_0, TARGET_DEST_CASTER_RANDOM);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_s81028_s80650_stalactite_SpellScript();
 }
};
 
// 80654 - Stalactite (creates visual shade on ground)
// 80643/92653 - Stalactite (launches missle to the ground)
// 80647/92309 - Stalactite (creates stalactite object)
class spell_stalactite_mod_dest_height : public SpellScriptLoader
{
public:
 spell_stalactite_mod_dest_height() : SpellScriptLoader("spell_stalactite_mod_dest_height") { }
 
 class spell_stalactite_mod_dest_height_SpellScript : public SpellScript
 {
 void ModDestHeight(SpellDestination& dest)
 {
 Unit* caster = GetCaster();
 Position pos = caster->GetPosition();
 pos.m_positionZ = caster->GetMap()->GetHeight(caster->GetPhaseShift(), pos.GetPositionX(), pos.GetPositionY(), pos.GetPositionZ(), true, 100.0f);
 dest.Relocate(pos);
 }
 
 void Register() override
 {
 OnDestinationTargetSelect += SpellDestinationTargetSelectFn(spell_stalactite_mod_dest_height_SpellScript::ModDestHeight, EFFECT_0, TARGET_DEST_CASTER);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_stalactite_mod_dest_height_SpellScript();
 }
};
 
// 92306 - Crystal storm (heroic mode check)
class spell_s92306_crystal_storm : public SpellScriptLoader
{
public:
 spell_s92306_crystal_storm() : SpellScriptLoader("spell_s92306_crystal_storm") { }
 
 class spell_s92306_crystal_storm_SpellScript : public SpellScript
 {
 bool Validate(SpellInfo const* /*spellInfo*/) override
 {
 return ValidateSpellInfo({ SPELL_CRYSTAL_STORM_TRIGGER });
 }
 
 void HandleDummyEffect(SpellEffIndex /*eff*/)
 {
 Unit* caster = GetCaster();
 if (caster->GetMap()->IsHeroic())
 caster->CastSpell(caster, SPELL_CRYSTAL_STORM_TRIGGER, true);
 }
 
 void Register() override
 {
 OnEffectHitTarget += SpellEffectFn(spell_s92306_crystal_storm_SpellScript::HandleDummyEffect, EFFECT_0, SPELL_EFFECT_APPLY_AURA);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_s92306_crystal_storm_SpellScript();
 }
};
 
// 92300 - Crystal Storm (damage)
class BehindObjectCheck
{
 public:
 BehindObjectCheck(Unit* caster, std::list<GameObject*> objectList) : caster(caster), objectList(objectList) { }
 
 bool operator()(WorldObject* unit)
 {
 for (std::list<GameObject*>::const_iterator itr = objectList.begin(); itr != objectList.end(); ++itr)
 if (!(*itr)->IsInvisibleDueToDespawn(unit) && (*itr)->IsInBetween(caster, unit, 1.5f))
 return true;
 return false;
 }
 
 private:
 Unit* caster;
 std::list<GameObject*> objectList;
};
 
class spell_s92300_crystal_storm : public SpellScriptLoader
{
public:
 spell_s92300_crystal_storm() : SpellScriptLoader("spell_s92300_crystal_storm") { }
 
 class spell_s92300_crystal_storm_SpellScript : public SpellScript
 {
 void FilterTargets(std::list<WorldObject*>& unitList)
 {
 Unit* caster = GetCaster();
 
 std::list<GameObject*> goList;
 caster->GetGameObjectListWithEntryInGrid(goList, GO_STALACTITE, 40.0f);
 if (goList.empty())
 return;
 
 unitList.remove_if(BehindObjectCheck(caster, goList));
 }
 
 void Register() override
 {
 OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_s92300_crystal_storm_SpellScript::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
 }
 };
 
 SpellScript* GetSpellScript() const override
 {
 return new spell_s92300_crystal_storm_SpellScript();
 }
};
 
void AddSC_boss_slabhide()
{
 new boss_slabhide();
 new npc_lava_fissure();
 new npc_stalactite_trigger();
 new spell_s81035_stalactite();
 new spell_s81028_s80650_stalactite();
 new spell_stalactite_mod_dest_height();
 new spell_s92306_crystal_storm();
 new spell_s92300_crystal_storm();
}