boss_ionar.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/>.
 */
 
/*
 * Comment: Timer check pending
 */
 
#include "ScriptMgr.h"
#include "halls_of_lightning.h"
#include "InstanceScript.h"
#include "MotionMaster.h"
#include "ObjectAccessor.h"
#include "ScriptedCreature.h"
#include "SpellInfo.h"
 
enum Spells
{
    SPELL_BALL_LIGHTNING                          = 52780,
    SPELL_STATIC_OVERLOAD                         = 52658,
 
    SPELL_DISPERSE                                = 52770,
    SPELL_SUMMON_SPARK                            = 52746,
    SPELL_SPARK_DESPAWN                           = 52776,
 
    // Spark of Ionar
    SPELL_RANDOM_LIGHTNING_VISUAL                 = 52663
};
 
#define SPELL_SPARK_VISUAL_TRIGGER DUNGEON_MODE<uint32>(52667,59833)
 
enum Yells
{
    SAY_AGGRO                                     = 0,
    SAY_SPLIT                                     = 1,
    SAY_SLAY                                      = 2,
    SAY_DEATH                                     = 3
};
 
enum Creatures
{
    NPC_SPARK_OF_IONAR                            = 28926
};
 
enum Misc
{
    DATA_MAX_SPARKS                               = 5,
    DATA_POINT_CALLBACK                           = 0
};
 
static constexpr float DATA_MAX_SPARK_DISTANCE = 90; // Distance to boss - prevent runs through the whole instance
 
/*######
## Boss Ionar
######*/
 
struct boss_ionar : public BossAI
{
    boss_ionar(Creature* creature) : BossAI(creature, DATA_IONAR)
    {
        Initialize();
    }
 
    void Initialize()
    {
        bIsSplitPhase = true;
        bHasDispersed = false;
 
        uiSplitTimer = 25 * IN_MILLISECONDS;
 
        uiStaticOverloadTimer = urand(5 * IN_MILLISECONDS, 6 * IN_MILLISECONDS);
        uiBallLightningTimer = urand(10 * IN_MILLISECONDS, 11 * IN_MILLISECONDS);
 
        uiDisperseHealth = 45 + urand(0, 10);
    }
 
    void Reset() override
    {
        BossAI::Reset();
 
        Initialize();
 
        me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
        me->SetUninteractible(false);
        me->SetControlled(false, UNIT_STATE_ROOT);
 
        if (!me->IsVisible())
            me->SetVisible(true);
 
        instance->SetBossState(DATA_IONAR, NOT_STARTED);
    }
 
    void JustEngagedWith(Unit* who) override
    {
        BossAI::JustEngagedWith(who);
        Talk(SAY_AGGRO);
    }
 
    void JustDied(Unit* killer) override
    {
        BossAI::JustDied(killer);
        Talk(SAY_DEATH);
    }
 
    void KilledUnit(Unit* who) override
    {
        if (who->GetTypeId() == TYPEID_PLAYER)
            Talk(SAY_SLAY);
    }
 
    void SpellHit(WorldObject* /*caster*/, SpellInfo const* spellInfo) override
    {
        if (spellInfo->Id == SPELL_DISPERSE)
        {
            for (uint8 i = 0; i < DATA_MAX_SPARKS; ++i)
                me->CastSpell(me, SPELL_SUMMON_SPARK, true);
 
            me->AttackStop();
            me->SetVisible(false);
            me->SetUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
            me->SetUninteractible(true);
            me->SetControlled(true, UNIT_STATE_ROOT);
 
            me->GetMotionMaster()->Clear();
            me->GetMotionMaster()->MoveIdle();
        }
    }
 
    //make sparks come back
    void CallBackSparks()
    {
        //should never be empty here, but check
        if (summons.empty())
            return;
 
        Position pos = me->GetPosition();
 
        for (ObjectGuid guid : summons)
        {
            if (Creature* pSpark = ObjectAccessor::GetCreature(*me, guid))
            {
                if (pSpark->IsAlive())
                {
                    pSpark->SetReactState(REACT_PASSIVE);
                    pSpark->SetSpeedRate(MOVE_RUN, 2.0f);
                    pSpark->GetMotionMaster()->Clear();
                    pSpark->GetMotionMaster()->MovePoint(DATA_POINT_CALLBACK, pos);
                }
                else
                    pSpark->DespawnOrUnsummon();
            }
        }
    }
 
    void DamageTaken(Unit* /*pDoneBy*/, uint32 &uiDamage, DamageEffectType /*damageType*/, SpellInfo const* /*spellInfo = nullptr*/) override
    {
        if (!me->IsVisible())
            uiDamage = 0;
    }
 
    void JustSummoned(Creature* summoned) override
    {
        if (summoned->GetEntry() == NPC_SPARK_OF_IONAR)
        {
            summons.Summon(summoned);
 
            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
            {
                summoned->SetInCombatWith(target);
                summoned->GetMotionMaster()->Clear();
                summoned->GetMotionMaster()->MoveFollow(target, 0.0f, 0.0f);
            }
        }
    }
 
    void SummonedCreatureDespawn(Creature* summoned) override
    {
        if (summoned->GetEntry() == NPC_SPARK_OF_IONAR)
            summons.Despawn(summoned);
    }
 
    void UpdateAI(uint32 uiDiff) override
    {
        //Return since we have no target
        if (!UpdateVictim())
            return;
 
        // Splitted
        if (!me->IsVisible())
        {
            if (uiSplitTimer <= uiDiff)
            {
                uiSplitTimer = 2500;
 
                // Return sparks to where Ionar splitted
                if (bIsSplitPhase)
                {
                    CallBackSparks();
                    bIsSplitPhase = false;
                }
                // Lightning effect and restore Ionar
                else if (summons.empty())
                {
                    me->SetVisible(true);
                    me->RemoveUnitFlag(UNIT_FLAG_NON_ATTACKABLE);
                    me->SetUninteractible(false);
                    me->SetControlled(false, UNIT_STATE_ROOT);
 
                    DoCast(me, SPELL_SPARK_DESPAWN, false);
 
                    uiSplitTimer = 25*IN_MILLISECONDS;
                    bIsSplitPhase = true;
 
                    if (me->GetVictim())
                        me->GetMotionMaster()->MoveChase(me->GetVictim());
                }
            }
            else
                uiSplitTimer -= uiDiff;
 
            return;
        }
 
        if (uiStaticOverloadTimer <= uiDiff)
        {
            if (Unit* target = SelectTarget(SelectTargetMethod::Random, 0))
                DoCast(target, SPELL_STATIC_OVERLOAD);
 
            uiStaticOverloadTimer = urand(5*IN_MILLISECONDS, 6*IN_MILLISECONDS);
        }
        else
            uiStaticOverloadTimer -= uiDiff;
 
        if (uiBallLightningTimer <= uiDiff)
        {
            DoCastVictim(SPELL_BALL_LIGHTNING);
            uiBallLightningTimer = urand(10*IN_MILLISECONDS, 11*IN_MILLISECONDS);
        }
        else
            uiBallLightningTimer -= uiDiff;
 
        // Health check
        if (!bHasDispersed && HealthBelowPct(uiDisperseHealth))
        {
            bHasDispersed = true;
 
            Talk(SAY_SPLIT);
 
            if (me->IsNonMeleeSpellCast(false))
                me->InterruptNonMeleeSpells(false);
 
            DoCast(me, SPELL_DISPERSE, false);
        }
    }
 
private:
    bool bIsSplitPhase;
    bool bHasDispersed;
 
    uint32 uiSplitTimer;
 
    uint32 uiStaticOverloadTimer;
    uint32 uiBallLightningTimer;
 
    uint32 uiDisperseHealth;
};
 
/*######
## npc_spark_of_ionar
######*/
 
struct npc_spark_of_ionar : public ScriptedAI
{
    npc_spark_of_ionar(Creature* creature) : ScriptedAI(creature)
    {
        Initialize();
        _instance = creature->GetInstanceScript();
    }
 
    void Initialize()
    {
        uiCheckTimer = 2 * IN_MILLISECONDS;
    }
 
    void Reset() override
    {
        Initialize();
        DoCastSelf(SPELL_SPARK_VISUAL_TRIGGER);
        DoCastSelf(SPELL_RANDOM_LIGHTNING_VISUAL);
    }
 
    void MovementInform(uint32 uiType, uint32 uiPointId) override
    {
        if (uiType != POINT_MOTION_TYPE || !_instance)
            return;
 
        if (uiPointId == DATA_POINT_CALLBACK)
            me->DespawnOrUnsummon();
    }
 
    void UpdateAI(uint32 uiDiff) override
    {
        // Despawn if the encounter is not running
        if (_instance->GetBossState(DATA_IONAR) != IN_PROGRESS)
        {
            me->DespawnOrUnsummon();
            return;
        }
 
        // Prevent them to follow players through the whole instance
        if (uiCheckTimer <= uiDiff)
        {
            Creature* ionar = _instance->GetCreature(DATA_IONAR);
            if (ionar && ionar->IsAlive())
            {
                if (me->GetDistance(ionar) > DATA_MAX_SPARK_DISTANCE)
                {
                    Position pos = ionar->GetPosition();
 
                    me->SetReactState(REACT_PASSIVE);
                    me->SetSpeedRate(MOVE_RUN, 2.0f);
                    me->GetMotionMaster()->Clear();
                    me->GetMotionMaster()->MovePoint(DATA_POINT_CALLBACK, pos);
                }
            }
            else
                me->DespawnOrUnsummon();
            uiCheckTimer = 2*IN_MILLISECONDS;
        }
        else
            uiCheckTimer -= uiDiff;
 
        // No melee attack at all!
    }
 
private:
    InstanceScript* _instance;
    uint32 uiCheckTimer;
};
 
void AddSC_boss_ionar()
{
    RegisterHallsOfLightningCreatureAI(boss_ionar);
    RegisterHallsOfLightningCreatureAI(npc_spark_of_ionar);
}