boss_xt002.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 "Containers.h"
#include "InstanceScript.h"
#include "Map.h"
#include "MotionMaster.h"
#include "PassiveAI.h"
#include "ScriptedCreature.h"
#include "SpellAuraEffects.h"
#include "SpellMgr.h"
#include "SpellScript.h"
#include "ulduar.h"
#include "Vehicle.h"
 
enum Spells
{
    SPELL_TYMPANIC_TANTRUM                  = 62776,
    SPELL_SEARING_LIGHT                     = 63018,
    SPELL_SUMMON_LIFE_SPARK                 = 64210,
    SPELL_SUMMON_VOID_ZONE                  = 64203,
    SPELL_GRAVITY_BOMB                      = 63024,
    SPELL_HEARTBREAK                        = 65737,
    SPELL_STAND                             = 37752,
    SPELL_SUBMERGE                          = 37751,
    SPELL_ENRAGE                            = 26662,
    SPELL_COOLDOWN_CREATURE_SPECIAL_2       = 64404,
    SPELL_SCRAP_REPAIR                      = 62832,
 
    // XT-Toy Pile
    SPELL_RECHARGE_PUMMELER                 = 62831,
    SPELL_RECHARGE_SCRAPBOT                 = 62828,
    SPELL_RECHARGE_BOOMBOT                  = 62835,
 
    // Heart of the Deconstructor
    SPELL_ENERGY_ORB                        = 62790,
    SPELL_RIDE_VEHICLE_EXPOSED              = 63313,
    SPELL_EXPOSED_HEART                     = 63849,
    SPELL_HEART_RIDE_VEHICLE                = 63852,
    SPELL_SCRAPBOT_RIDE_VEHICLE             = 47020,
    SPELL_FULL_HEAL                         = 17683,
    SPELL_HEART_OVERLOAD                    = 62789,
    SPELL_HEART_LIGHTNING_TETHER            = 64799,
 
    // Void Zone
    SPELL_CONSUMPTION                       = 64209,
 
    // Life Spark
    SPELL_ARCANE_POWER_STATE                = 49411,
    SPELL_STATIC_CHARGED                    = 64227,
    SPELL_SHOCK                             = 64230,
 
    // XM-024 Pummeller
    SPELL_ARCING_SMASH                      = 8374,
    SPELL_TRAMPLE                           = 5568,
    SPELL_UPPERCUT                          = 10966,
 
    //Boombot
    SPELL_321_BOOMBOT_AURA                  = 65032,
    SPELL_BOOM                              = 62834,
 
    // Achievement-related spells
    SPELL_ACHIEVEMENT_CREDIT_NERF_SCRAPBOTS = 65037
};
 
enum Events
{
    EVENT_TYMPANIC_TANTRUM = 1,
    EVENT_PHASE_CHECK,
    EVENT_SEARING_LIGHT,
    EVENT_GRAVITY_BOMB,
    EVENT_SUBMERGE,
    EVENT_DISPOSE_HEART,
    EVENT_ENRAGE,
    EVENT_ENTER_HARD_MODE,
    EVENT_RESUME_ATTACK
};
 
enum XT002Phases
{
    PHASE_1 = 1,
    PHASE_HEART
};
 
enum Actions
{
    ACTION_ENTER_HARD_MODE,
    ACTION_START_PHASE_HEART,
    ACTION_DISPOSE_HEART
};
 
enum XT002Data
{
    DATA_TRANSFERED_HEALTH,
    DATA_HARD_MODE,
    DATA_HEALTH_RECOVERED,
    DATA_GRAVITY_BOMB_CASUALTY
};
 
enum Yells
{
    SAY_AGGRO              = 0,
    SAY_HEART_OPENED       = 1,
    SAY_HEART_CLOSED       = 2,
    SAY_TYMPANIC_TANTRUM   = 3,
    SAY_SLAY               = 4,
    SAY_BERSERK            = 5,
    SAY_DEATH              = 6,
    SAY_SUMMON             = 7,
    EMOTE_HEART_OPENED     = 8,
    EMOTE_HEART_CLOSED     = 9,
    EMOTE_TYMPANIC_TANTRUM = 10,
    EMOTE_SCRAPBOT         = 11
};
 
enum Misc
{
    ACHIEV_MUST_DECONSTRUCT_FASTER = 21027,
    HEART_VEHICLE_SEAT_EXPOSED     = 1,
    GROUP_SEARING_GRAVITY          = 1
};
 
enum XT002Paths
{
    PATH_XT002_IDLE = 10884320
};
 
struct boss_xt002 : public BossAI
{
    boss_xt002(Creature* creature) : BossAI(creature, DATA_XT002)
    {
        Initialize();
    }
 
    void Initialize()
    {
        _healthRecovered = false;
        _gravityBombCasualty = false;
        _hardMode = false;
        _exposeHeartPercent = 75;
    }
 
    void ChangeNextExpose()
    {
        switch (_exposeHeartPercent)
        {
            case 75:
                _exposeHeartPercent = 50;
                break;
            case 50:
                _exposeHeartPercent = 25;
                break;
            default:
                _exposeHeartPercent = 0;
                break;
        }
    }
 
    void Reset() override
    {
        _Reset();
        events.SetPhase(PHASE_1);
        me->SetReactState(REACT_DEFENSIVE);
        Initialize();
    }
 
    void EnterEvadeMode(EvadeReason /*why*/) override
    {
        summons.DespawnAll();
        _DespawnAtEvade();
    }
 
    void JustEngagedWith(Unit* who) override
    {
        scheduler.CancelAll();
 
        Talk(SAY_AGGRO);
        BossAI::JustEngagedWith(who);
        events.ScheduleEvent(EVENT_SEARING_LIGHT, Is25ManRaid() ? 9s : 11s, GROUP_SEARING_GRAVITY, PHASE_1);
        events.ScheduleEvent(EVENT_GRAVITY_BOMB, Is25ManRaid() ? 18s : 21s, GROUP_SEARING_GRAVITY, PHASE_1);
        events.ScheduleEvent(EVENT_ENRAGE, 10min);
        events.ScheduleEvent(EVENT_TYMPANIC_TANTRUM, 60s, 0, PHASE_1);
        events.ScheduleEvent(EVENT_PHASE_CHECK, 1s, 0, PHASE_1);
        instance->TriggerGameEvent(ACHIEV_MUST_DECONSTRUCT_FASTER);
    }
 
    void DoAction(int32 action) override
    {
        if (action == ACTION_ENTER_HARD_MODE)
            events.ScheduleEvent(EVENT_ENTER_HARD_MODE, 1ms);
    }
 
    void KilledUnit(Unit* who) override
    {
        if (who->GetTypeId() == TYPEID_PLAYER)
            Talk(SAY_SLAY);
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        Talk(SAY_DEATH);
        _JustDied();
        me->SetUninteractible(false);
    }
 
    void ExposeHeart()
    {
        events.SetPhase(PHASE_HEART);
        me->SetReactState(REACT_PASSIVE);
        me->AttackStop();
        Talk(SAY_HEART_OPENED);
        events.CancelEvent(EVENT_TYMPANIC_TANTRUM);
        events.ScheduleEvent(EVENT_SUBMERGE, 6s, 0, PHASE_HEART);
        ChangeNextExpose();
    }
 
    void DisposeHeart(bool isHardMode = false)
    {
        Talk(SAY_HEART_CLOSED);
 
        if (isHardMode)
        {
            me->SetReactState(REACT_AGGRESSIVE);
            RescheduleEvents();
        }
        else
        {
            Talk(EMOTE_HEART_CLOSED);
            events.ScheduleEvent(EVENT_RESUME_ATTACK, 1s, 0, PHASE_HEART);
        }
 
        DoCastSelf(SPELL_STAND);
        DoCastSelf(SPELL_COOLDOWN_CREATURE_SPECIAL_2);
        me->SetUninteractible(false);
        if (Creature* heart = instance->GetCreature(DATA_XT002_HEART))
        {
            if (heart->IsAlive())
                heart->AI()->DoAction(ACTION_DISPOSE_HEART);
            else
                heart->DespawnOrUnsummon();
        }
    }
 
    void RescheduleEvents()
    {
        events.SetPhase(PHASE_1);
        events.ScheduleEvent(EVENT_SEARING_LIGHT, 25s, GROUP_SEARING_GRAVITY, PHASE_1);
        events.ScheduleEvent(EVENT_GRAVITY_BOMB, Is25ManRaid() ? 33s : 15s, GROUP_SEARING_GRAVITY, PHASE_1);
        events.ScheduleEvent(EVENT_TYMPANIC_TANTRUM, 25s, 0, PHASE_1);
        if (!_hardMode)
            events.ScheduleEvent(EVENT_PHASE_CHECK, 1s, 0, PHASE_1);
    }
 
    void PassengerBoarded(Unit* who, int8 seatId, bool apply) override
    {
        if (!apply)
            return;
 
        if (who->GetEntry() == NPC_XS013_SCRAPBOT)
        {
            Talk(EMOTE_SCRAPBOT);
            _healthRecovered = true;
        }
        else if (seatId == HEART_VEHICLE_SEAT_EXPOSED)
            who->CastSpell(who, SPELL_EXPOSED_HEART);   // Channeled
    }
 
    uint32 GetData(uint32 type) const override
    {
        switch (type)
        {
            case DATA_HARD_MODE:
                return _hardMode ? 1 : 0;
            case DATA_HEALTH_RECOVERED:
                return _healthRecovered ? 1 : 0;
            case DATA_GRAVITY_BOMB_CASUALTY:
                return _gravityBombCasualty ? 1 : 0;
            default:
                return 0;
        }
    }
 
    void SetData(uint32 type, uint32 data) override
    {
        switch (type)
        {
            case DATA_TRANSFERED_HEALTH:
                if (!_hardMode)
                {
                    uint32 transferHealth = data;
                    if (transferHealth >= me->GetHealth())
                        transferHealth = me->GetHealth() - 1;
 
                    me->ModifyHealth(-static_cast<int32>(transferHealth));
                    me->LowerPlayerDamageReq(transferHealth);
                }
                break;
            case DATA_GRAVITY_BOMB_CASUALTY:
                _gravityBombCasualty = (data > 0) ? true : false;
                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_SEARING_LIGHT:
                    DoCastSelf(SPELL_SEARING_LIGHT);
                    events.Repeat(Is25ManRaid() ? 16s : 20s);
                    break;
                case EVENT_GRAVITY_BOMB:
                    DoCastSelf(SPELL_GRAVITY_BOMB);
                    events.Repeat(Is25ManRaid() ? 16s : 20s);
                    break;
                case EVENT_TYMPANIC_TANTRUM:
                    Talk(SAY_TYMPANIC_TANTRUM);
                    Talk(EMOTE_TYMPANIC_TANTRUM);
                    events.DelayEvents(10s, GROUP_SEARING_GRAVITY);
                    DoCastSelf(SPELL_TYMPANIC_TANTRUM);
                    events.Repeat(1min);
                    break;
                case EVENT_PHASE_CHECK:
                    if (me->HealthBelowPct(_exposeHeartPercent))
                        ExposeHeart();
                    events.Repeat(1s);
                    break;
                case EVENT_SUBMERGE:
                    DoCastSelf(SPELL_SUBMERGE);
                    me->SetUninteractible(true);
                    Talk(EMOTE_HEART_OPENED);
                    if (Creature* heart = instance->GetCreature(DATA_XT002_HEART))
                        heart->AI()->DoAction(ACTION_START_PHASE_HEART);
                    events.ScheduleEvent(EVENT_DISPOSE_HEART, 30s, PHASE_HEART);
                    break;
                case EVENT_DISPOSE_HEART:
                    DisposeHeart();
                    break;
                case EVENT_ENRAGE:
                    Talk(SAY_BERSERK);
                    DoCastSelf(SPELL_ENRAGE);
                    break;
                case EVENT_ENTER_HARD_MODE:
                    me->SetFullHealth();
                    DoCastSelf(SPELL_HEARTBREAK, true);
                    me->AddLootMode(LOOT_MODE_HARD_MODE_1);
                    _hardMode = true;
                    DisposeHeart(_hardMode);
                    break;
                case EVENT_RESUME_ATTACK:
                    me->SetReactState(REACT_AGGRESSIVE);
                    RescheduleEvents();
                    break;
                default:
                    break;
            }
 
            if (me->HasUnitState(UNIT_STATE_CASTING))
                return;
        }
    }
 
    void WaypointReached(uint32 waypointId, uint32 pathId) override
    {
        if (pathId != PATH_XT002_IDLE)
            return;
 
        if (waypointId == 3 || waypointId == 9)
        {
            me->SetEmoteState(EMOTE_STATE_SPELL_CHANNEL_OMNI);
 
            scheduler.Schedule(11s, [this](TaskContext const& /*task*/)
            {
                me->SetEmoteState(EMOTE_ONESHOT_NONE);
            });
        }
        else if (waypointId == 13)
        {
            me->SetEmoteState(EMOTE_STATE_DANCE);
 
            scheduler.Schedule(30s, [this](TaskContext const& /*task*/)
            {
                me->SetEmoteState(EMOTE_ONESHOT_NONE);
            });
        }
    }
 
private:
    bool _healthRecovered;       // Did a scrapbot recover XT-002's health during the encounter?
    bool _hardMode;              // Are we in hard mode? Or: was the heart killed during phase 2?
    bool _gravityBombCasualty;   // Did someone die because of Gravity Bomb damage?
    uint8 _exposeHeartPercent;
};
 
struct npc_xt002_heart : public NullCreatureAI
{
    npc_xt002_heart(Creature* creature) : NullCreatureAI(creature), _instance(creature->GetInstanceScript()) { }
 
    void Reset() override
    {
        me->SetRegenerateHealth(false);
    }
 
    void DoAction(int32 action) override
    {
        Creature* xt002 = _instance->GetCreature(DATA_XT002);
        if (!xt002)
            return;
 
        if (action == ACTION_START_PHASE_HEART)
        {
            DoCastSelf(SPELL_FULL_HEAL);
            DoCast(xt002, SPELL_RIDE_VEHICLE_EXPOSED, true);
            DoCastSelf(SPELL_HEART_OVERLOAD);
            me->SetUninteractible(false);
            me->SetUnitFlag(UNIT_FLAG_PREVENT_EMOTES_FROM_CHAT_TEXT);
        }
        else if (action == ACTION_DISPOSE_HEART)
        {
            DoCast(xt002, SPELL_HEART_RIDE_VEHICLE, true);
            me->SetUninteractible(true);
            me->RemoveUnitFlag(UNIT_FLAG_PREVENT_EMOTES_FROM_CHAT_TEXT);
        }
    }
 
    void JustDied(Unit* /*killer*/) override
    {
        if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
            xt002->AI()->DoAction(ACTION_ENTER_HARD_MODE);
    }
 
private:
    InstanceScript* _instance;
};
 
struct npc_scrapbot : public ScriptedAI
{
    npc_scrapbot(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
    void Reset() override
    {
        me->SetReactState(REACT_PASSIVE);
        _scheduler.CancelAll();
 
        if (_instance->GetBossState(DATA_XT002) != IN_PROGRESS)
        {
            me->DespawnOrUnsummon();
            return;
        }
 
        if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
            xt002->AI()->JustSummoned(me);
 
        _scheduler.
            Schedule(2s, [this](TaskContext const& /*StartMove*/)
            {
                if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
                    me->GetMotionMaster()->MoveFollow(xt002, 0.0f, 0.0f);
            })
            .Schedule(1s, [this](TaskContext& checkXt002)
            {
                if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
                {
                    if (me->IsWithinMeleeRange(xt002))
                    {
                        DoCast(xt002, SPELL_SCRAPBOT_RIDE_VEHICLE);
                        _scheduler.Schedule(1s, [this](TaskContext const& /*ScrapRepair*/)
                        {
                            if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
                                xt002->CastSpell(me, SPELL_SCRAP_REPAIR, true);
                            me->DespawnOrUnsummon(1s);
                        });
                    }
                    else
                        checkXt002.Repeat();
                }
                else
                    me->DespawnOrUnsummon();
            });
    }
 
    void UpdateAI(uint32 diff) override
    {
        _scheduler.Update(diff);
    }
 
private:
    InstanceScript* _instance;
    TaskScheduler _scheduler;
 
};
 
struct npc_pummeller : public ScriptedAI
{
    npc_pummeller(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()) { }
 
    void Reset() override
    {
        me->SetReactState(REACT_PASSIVE);
        _scheduler.CancelAll();
 
        if (_instance->GetBossState(DATA_XT002) != IN_PROGRESS)
        {
            me->DespawnOrUnsummon();
            return;
        }
 
        if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
            xt002->AI()->JustSummoned(me);
 
        _scheduler.
            Schedule(1s, [this](TaskContext const& /*StartMove*/)
            {
                me->SetReactState(REACT_AGGRESSIVE);
                DoZoneInCombat();
            })
            .Schedule(17s, [this](TaskContext& trample)
            {
                DoCastSelf(SPELL_TRAMPLE);
                trample.Repeat(11s);
            })
            .Schedule(19s, [this](TaskContext& arcingSmash)
            {
                DoCastSelf(SPELL_ARCING_SMASH);
                arcingSmash.Repeat(8s);
            })
            .Schedule(19s, [this](TaskContext& upperCut)
            {
                DoCastVictim(SPELL_UPPERCUT);
                upperCut.Repeat(14s);
            });
 
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        _scheduler.Update(diff);
    }
 
private:
    InstanceScript* _instance;
    TaskScheduler _scheduler;
};
 
struct npc_boombot : public ScriptedAI
{
    npc_boombot(Creature* creature) : ScriptedAI(creature), _instance(creature->GetInstanceScript()), _boomed(false) { }
 
    void Reset() override
    {
        DoCastSelf(SPELL_321_BOOMBOT_AURA);
        me->SetReactState(REACT_PASSIVE);
        _scheduler.CancelAll();
 
        if (_instance->GetBossState(DATA_XT002) != IN_PROGRESS)
        {
            me->DespawnOrUnsummon();
            return;
        }
 
        if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
            xt002->AI()->JustSummoned(me);
 
        _scheduler.
            Schedule(4s, [this](TaskContext const& /*StartMove*/)
            {
                if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
                    me->GetMotionMaster()->MoveFollow(xt002, 0.0f, 0.0f);
 
            })
            .Schedule(1s, [this](TaskContext& checkXt002)
            {
                if (Creature* xt002 = _instance->GetCreature(DATA_XT002))
                {
                    if (me->IsWithinMeleeRange(xt002))
                        DoCastAOE(SPELL_BOOM);
                    else
                        checkXt002.Repeat();
                }
                else
                    me->DespawnOrUnsummon();
            });
    }
 
    void DamageTaken(Unit* /*who*/, uint32& damage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (damage >= (me->GetHealth() - me->GetMaxHealth() * 0.5f) && !_boomed)
        {
            _boomed = true; // Prevent recursive call
            damage = 0;
            DoCastAOE(SPELL_BOOM);
        }
    }
 
    void UpdateAI(uint32 diff) override
    {
        _scheduler.Update(diff);
    }
 
private:
    InstanceScript* _instance;
    bool _boomed;
    TaskScheduler _scheduler;
};
 
struct npc_life_spark : public ScriptedAI
{
    npc_life_spark(Creature* creature) : ScriptedAI(creature) { }
 
    void Reset() override
    {
        DoCastSelf(SPELL_ARCANE_POWER_STATE);
        _scheduler.CancelAll();
    }
 
    void JustEngagedWith(Unit* /*who*/) override
    {
        DoCastSelf(SPELL_STATIC_CHARGED);
        _scheduler.Schedule(12s, [this](TaskContext& spellShock)
        {
            DoCastVictim(SPELL_SHOCK);
            spellShock.Repeat();
        });
    }
 
    void UpdateAI(uint32 diff) override
    {
        if (!UpdateVictim())
            return;
 
        if (me->HasUnitState(UNIT_STATE_CASTING))
            return;
 
        _scheduler.Update(diff);
    }
 
private:
    TaskScheduler _scheduler;
};
 
struct npc_xt_void_zone : public PassiveAI
{
    npc_xt_void_zone(Creature* creature) : PassiveAI(creature) { }
 
    void JustAppeared() override
    {
        _scheduler.Schedule(2500ms, [this](TaskContext const& /*task*/)
        {
            DoCastSelf(SPELL_CONSUMPTION);
        });
    }
 
    void UpdateAI(uint32 diff) override
    {
        _scheduler.Update(diff);
    }
 
private:
    TaskScheduler _scheduler;
};
 
// 63018, 65121 - Searing Light
class spell_xt002_searing_light_spawn_life_spark : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_SUMMON_LIFE_SPARK });
    }
 
    void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
    {
        if (Unit* xt002 = GetCaster())
            if (xt002->HasAura(aurEff->GetAmountAsInt()))   // Heartbreak aura indicating hard mode
                xt002->CastSpell(GetOwner(), SPELL_SUMMON_LIFE_SPARK, true);
    }
 
    void Register() override
    {
        AfterEffectRemove += AuraEffectRemoveFn(spell_xt002_searing_light_spawn_life_spark::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 63024, 64234 - Gravity Bomb
class spell_xt002_gravity_bomb_aura : public AuraScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo({ SPELL_SUMMON_VOID_ZONE });
    }
 
    void OnRemove(AuraEffect const* aurEff, AuraEffectHandleModes /*mode*/)
    {
        if (Unit* xt002 = GetCaster())
            if (xt002->HasAura(aurEff->GetAmountAsInt()))   // Heartbreak aura indicating hard mode
                xt002->CastSpell(GetOwner(), SPELL_SUMMON_VOID_ZONE, true);
    }
 
    void OnPeriodic(AuraEffect const* aurEff)
    {
        Unit* xt002 = GetCaster();
        Unit* owner = GetTarget();
        if (!xt002)
            return;
 
        if (aurEff->GetAmount() >= static_cast<SpellEffectValue>(owner->GetHealth()))
            xt002->GetAI()->SetData(DATA_GRAVITY_BOMB_CASUALTY, 1);
    }
 
    void Register() override
    {
        OnEffectPeriodic += AuraEffectPeriodicFn(spell_xt002_gravity_bomb_aura::OnPeriodic, EFFECT_2, SPELL_AURA_PERIODIC_DAMAGE);
        AfterEffectRemove += AuraEffectRemoveFn(spell_xt002_gravity_bomb_aura::OnRemove, EFFECT_0, SPELL_AURA_PERIODIC_TRIGGER_SPELL, AURA_EFFECT_HANDLE_REAL);
    }
};
 
// 63025, 64233 - Gravity Bomb (Damage)
class spell_xt002_gravity_bomb_damage : public SpellScript
{
    void HandleScript(SpellEffIndex /*effIndex*/)
    {
        if (GetHitDamage() >= int32(GetHitUnit()->GetHealth()))
            if (InstanceScript* instance = GetCaster()->GetInstanceScript())
                if (Creature* xt002 = instance->GetCreature(DATA_XT002))
                    xt002->AI()->SetData(DATA_GRAVITY_BOMB_CASUALTY, 1);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_xt002_gravity_bomb_damage::HandleScript, EFFECT_0, SPELL_EFFECT_SCHOOL_DAMAGE);
    }
};
 
// 62791 - XT-002 Heart Overload Trigger Spell (SERVERSIDE)
class spell_xt002_heart_overload_periodic : public SpellScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo
        ({
            SPELL_ENERGY_ORB,
            SPELL_HEART_LIGHTNING_TETHER
         });
    }
 
    Creature* GetRandomToyPile()
    {
        std::list<Creature*> possibleCreatures;
        Unit* caster = GetCaster();
        caster->GetCreatureListWithEntryInGrid(possibleCreatures, NPC_XT_TOY_PILE);
        possibleCreatures.remove_if([caster](Creature* creature)
        {
            return caster->GetDistance2d(creature) < 60.0f;
        });
 
        if (possibleCreatures.empty())
            return nullptr;
 
        return Trinity::Containers::SelectRandomContainerElement(possibleCreatures);
    }
 
    void HandleScript(SpellEffIndex /*effIndex*/)
    {
        Unit* caster = GetCaster();
        if (Creature* toyPile = GetRandomToyPile())
        {
            caster->CastSpell(toyPile, SPELL_ENERGY_ORB, true);
            caster->CastSpell(nullptr, SPELL_HEART_LIGHTNING_TETHER, true);
        }
    }
 
    void Register() override
    {
        OnEffectHit += SpellEffectFn(spell_xt002_heart_overload_periodic::HandleScript, EFFECT_0, SPELL_EFFECT_DUMMY);
    }
};
 
// 62826 - Energy Orb
class spell_xt002_energy_orb : public SpellScript
{
    bool Validate(SpellInfo const* /*spell*/) override
    {
        return ValidateSpellInfo
        ({
            SPELL_RECHARGE_BOOMBOT,
            SPELL_RECHARGE_PUMMELER,
            SPELL_RECHARGE_SCRAPBOT
        });
    }
 
    void HandleSummons(SpellEffIndex /*effIndex*/)
    {
        Unit* target = GetHitUnit();
        if (target->GetEntry() != NPC_XT_TOY_PILE)
            return;
 
        target->CastSpell(target, SPELL_RECHARGE_BOOMBOT, true);
 
        if (roll_chance(30))
            target->CastSpell(target, SPELL_RECHARGE_PUMMELER, true);
 
        for (uint8 i = 0; i < urand(5, 7); ++i)
            target->CastSpell(target, SPELL_RECHARGE_SCRAPBOT, true);
 
        if (Creature* base = GetCaster()->GetVehicleCreatureBase())
            base->AI()->Talk(SAY_SUMMON);
    }
 
    void Register() override
    {
        OnEffectHitTarget += SpellEffectFn(spell_xt002_energy_orb::HandleSummons, EFFECT_2, SPELL_EFFECT_DUMMY);
    }
};
 
// 62775 - Tympanic Tantrum
class spell_xt002_tympanic_tantrum : public SpellScript
{
    void FilterTargets(std::list<WorldObject*>& targets)
    {
        targets.remove_if([](WorldObject* object) -> bool
        {
            if (object->GetTypeId() == TYPEID_PLAYER)
                return false;
 
            if (Creature* creature = object->ToCreature())
                return !creature->IsPet();
 
            return true;
        });
    }
 
    void RecalculateDamage()
    {
        SetHitDamage(GetHitUnit()->CountPctFromMaxHealth(GetHitDamage()));
    }
 
    void Register() override
    {
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_xt002_tympanic_tantrum::FilterTargets, EFFECT_0, TARGET_UNIT_SRC_AREA_ENEMY);
        OnObjectAreaTargetSelect += SpellObjectAreaTargetSelectFn(spell_xt002_tympanic_tantrum::FilterTargets, EFFECT_1, TARGET_UNIT_SRC_AREA_ENEMY);
        OnHit += SpellHitFn(spell_xt002_tympanic_tantrum::RecalculateDamage);
    }
};
 
// 65032 - 321-Boombot Aura
class spell_xt002_321_boombot_aura : public AuraScript
{
    bool Validate(SpellInfo const* /*spellInfo*/) override
    {
        return ValidateSpellInfo({ SPELL_ACHIEVEMENT_CREDIT_NERF_SCRAPBOTS });
    }
 
    bool CheckProc(ProcEventInfo& eventInfo)
    {
        if (eventInfo.GetActionTarget()->GetEntry() != NPC_XS013_SCRAPBOT)
            return false;
        return true;
    }
 
    void HandleProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
    {
        if (InstanceScript* instance = eventInfo.GetActor()->GetInstanceScript())
            instance->DoCastSpellOnPlayers(SPELL_ACHIEVEMENT_CREDIT_NERF_SCRAPBOTS);
    }
 
    void Register() override
    {
        DoCheckProc += AuraCheckProcFn(spell_xt002_321_boombot_aura::CheckProc);
        OnEffectProc += AuraEffectProcFn(spell_xt002_321_boombot_aura::HandleProc, EFFECT_0, SPELL_AURA_DUMMY);
    }
};
 
// 63849 - Exposed Heart
class spell_xt002_exposed_heart : public AuraScript
{
    bool Load() override
    {
        _damageAmount = 0;
        return true;
    }
 
    void OnProc(AuraEffect* /*aurEff*/, ProcEventInfo& eventInfo)
    {
        PreventDefaultAction();
        DamageInfo* damageInfo = eventInfo.GetDamageInfo();
        if (!damageInfo || !damageInfo->GetDamage())
            return;
 
        _damageAmount += damageInfo->GetDamage();
    }
 
    void HandleLifeTransfer(AuraEffect const* /*aurEff*/, AuraEffectHandleModes /*mode*/)
    {
        if (InstanceScript* instance = GetTarget()->GetInstanceScript())
            if (Creature* xt002 = instance->GetCreature(DATA_XT002))
                xt002->AI()->SetData(DATA_TRANSFERED_HEALTH, _damageAmount);
    }
 
    void Register() override
    {
        OnEffectProc += AuraEffectProcFn(spell_xt002_exposed_heart::OnProc, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN);
        AfterEffectRemove += AuraEffectRemoveFn(spell_xt002_exposed_heart::HandleLifeTransfer, EFFECT_0, SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN, AURA_EFFECT_HANDLE_REAL);
    }
 
private:
    uint32 _damageAmount = 0;
};
 
class achievement_nerf_engineering : public AchievementCriteriaScript
{
    public:
        achievement_nerf_engineering() : AchievementCriteriaScript("achievement_nerf_engineering") { }
 
        bool OnCheck(Player* /*source*/, Unit* target) override
        {
            if (!target || !target->GetAI())
                return false;
 
            return !(target->GetAI()->GetData(DATA_HEALTH_RECOVERED));
        }
};
 
class achievement_heartbreaker : public AchievementCriteriaScript
{
    public:
        achievement_heartbreaker() : AchievementCriteriaScript("achievement_heartbreaker") { }
 
        bool OnCheck(Player* /*source*/, Unit* target) override
        {
            if (!target || !target->GetAI())
                return false;
 
            return target->GetAI()->GetData(DATA_HARD_MODE) != 0;
        }
};
 
class achievement_nerf_gravity_bombs : public AchievementCriteriaScript
{
    public:
        achievement_nerf_gravity_bombs() : AchievementCriteriaScript("achievement_nerf_gravity_bombs") { }
 
        bool OnCheck(Player* /*source*/, Unit* target) override
        {
            if (!target || !target->GetAI())
                return false;
 
            return !(target->GetAI()->GetData(DATA_GRAVITY_BOMB_CASUALTY));
        }
};
 
void AddSC_boss_xt002()
{
    RegisterUlduarCreatureAI(boss_xt002);
    RegisterUlduarCreatureAI(npc_xt002_heart);
    RegisterUlduarCreatureAI(npc_scrapbot);
    RegisterUlduarCreatureAI(npc_pummeller);
    RegisterUlduarCreatureAI(npc_boombot);
    RegisterUlduarCreatureAI(npc_life_spark);
    RegisterUlduarCreatureAI(npc_xt_void_zone);
 
    RegisterSpellScript(spell_xt002_searing_light_spawn_life_spark);
    RegisterSpellScript(spell_xt002_gravity_bomb_aura);
    RegisterSpellScript(spell_xt002_gravity_bomb_damage);
    RegisterSpellScript(spell_xt002_heart_overload_periodic);
    RegisterSpellScript(spell_xt002_energy_orb);
    RegisterSpellScript(spell_xt002_tympanic_tantrum);
    RegisterSpellScript(spell_xt002_321_boombot_aura);
    RegisterSpellScript(spell_xt002_exposed_heart);
 
    new achievement_nerf_engineering();
    new achievement_heartbreaker();
    new achievement_nerf_gravity_bombs();
}