boss_midnight.cpp

Go to the documentation of this file.

/*
* This file is part of Project SkyFire https://www.projectskyfire.org. 
* See LICENSE.md file for Copyright information
*/
 
/* ScriptData
SDName: Boss_Midnight
SD%Complete: 100
SDComment:
SDCategory: Karazhan
EndScriptData */
 
#include "ScriptMgr.h"
#include "ScriptedCreature.h"
#include "SpellInfo.h"
 
enum Midnight
{
    SAY_MIDNIGHT_KILL           = 0,
    SAY_APPEAR                  = 1,
    SAY_MOUNT                   = 2,
 
    SAY_KILL                    = 0,
    SAY_DISARMED                = 1,
    SAY_DEATH                   = 2,
    SAY_RANDOM                  = 3,
 
    SPELL_SHADOWCLEAVE          = 29832,
    SPELL_INTANGIBLE_PRESENCE   = 29833,
    SPELL_BERSERKER_CHARGE      = 26561,                   //Only when mounted
 
    MOUNTED_DISPLAYID           = 16040,
 
    //Attumen (@todo Use the summoning spell instead of Creature id. It works, but is not convenient for us)
    SUMMON_ATTUMEN              = 15550,
};
 
class boss_attumen : public CreatureScript
{
public:
    boss_attumen() : CreatureScript("boss_attumen") { }
 
    CreatureAI* GetAI(Creature* creature) const OVERRIDE
    {
        return new boss_attumenAI(creature);
    }
 
    struct boss_attumenAI : public ScriptedAI
    {
        boss_attumenAI(Creature* creature) : ScriptedAI(creature)
        {
            Phase = 1;
 
            CleaveTimer = std::rand() % 15000 + 10000;
            CurseTimer = 30000;
            RandomYellTimer = std::rand() % 60000 + 30000;              //Occasionally yell
            ChargeTimer = 20000;
            ResetTimer = 0;
        }
 
        uint64 Midnight;
        uint8 Phase;
        uint32 CleaveTimer;
        uint32 CurseTimer;
        uint32 RandomYellTimer;
        uint32 ChargeTimer;                                     //only when mounted
        uint32 ResetTimer;
 
        void Reset() OVERRIDE
        {
            ResetTimer = 0;
        }
 
        void EnterEvadeMode() OVERRIDE
        {
            ScriptedAI::EnterEvadeMode();
            ResetTimer = 2000;
        }
 
        void EnterCombat(Unit* /*who*/) OVERRIDE { }
 
        void KilledUnit(Unit* /*victim*/) OVERRIDE
        {
            Talk(SAY_KILL);
        }
 
        void JustDied(Unit* /*killer*/) OVERRIDE
        {
            Talk(SAY_DEATH);
            if (Unit* midnight = Unit::GetUnit(*me, Midnight))
                midnight->Kill(midnight);
        }
 
        void UpdateAI(uint32 diff) OVERRIDE;
 
        void SpellHit(Unit* /*source*/, const SpellInfo* spell) OVERRIDE
        {
            if (spell->Mechanic == MECHANIC_DISARM)
                Talk(SAY_DISARMED);
        }
    };
};
 
class boss_midnight : public CreatureScript
{
public:
    boss_midnight() : CreatureScript("boss_midnight") { }
 
    CreatureAI* GetAI(Creature* creature) const OVERRIDE
    {
        return new boss_midnightAI(creature);
    }
 
    struct boss_midnightAI : public ScriptedAI
    {
        boss_midnightAI(Creature* creature) : ScriptedAI(creature) { }
 
        uint64 Attumen;
        uint8 Phase;
        uint32 Mount_Timer;
 
        void Reset() OVERRIDE
        {
            Phase = 1;
            Attumen = 0;
            Mount_Timer = 0;
 
            me->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
            me->SetVisible(true);
        }
 
        void EnterCombat(Unit* /*who*/) OVERRIDE { }
 
        void KilledUnit(Unit* /*victim*/) OVERRIDE
        {
            if (Phase == 2)
            {
                if (Unit* unit = Unit::GetUnit(*me, Attumen))
                    Talk(SAY_MIDNIGHT_KILL, unit);
            }
        }
 
        void UpdateAI(uint32 diff) OVERRIDE
        {
            if (!UpdateVictim())
                return;
 
            if (Phase == 1 && HealthBelowPct(95))
            {
                Phase = 2;
                if (Creature* attumen = me->SummonCreature(SUMMON_ATTUMEN, 0.0f, 0.0f, 0.0f, 0.0f, TempSummonType::TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 30000))
                {
                    Attumen = attumen->GetGUID();
                    attumen->AI()->AttackStart(me->GetVictim());
                    SetMidnight(attumen, me->GetGUID());
                    Talk(SAY_APPEAR, attumen);
                }
            }
            else if (Phase == 2 && HealthBelowPct(25))
            {
                if (Unit* pAttumen = Unit::GetUnit(*me, Attumen))
                    Mount(pAttumen);
            }
            else if (Phase == 3)
            {
                if (Mount_Timer)
                {
                    if (Mount_Timer <= diff)
                    {
                        Mount_Timer = 0;
                        me->SetVisible(false);
                        me->GetMotionMaster()->MoveIdle();
                        if (Unit* pAttumen = Unit::GetUnit(*me, Attumen))
                        {
                            pAttumen->SetDisplayId(MOUNTED_DISPLAYID);
                            pAttumen->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                            if (pAttumen->GetVictim())
                            {
                                pAttumen->GetMotionMaster()->MoveChase(pAttumen->GetVictim());
                                pAttumen->SetTarget(pAttumen->GetVictim()->GetGUID());
                            }
                            pAttumen->SetObjectScale(1);
                        }
                    } else Mount_Timer -= diff;
                }
            }
 
            if (Phase != 3)
                DoMeleeAttackIfReady();
        }
 
        void Mount(Unit* pAttumen)
        {
            Talk(SAY_MOUNT, pAttumen);
            Phase = 3;
            me->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
            pAttumen->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
            float angle = me->GetAngle(pAttumen);
            float distance = me->GetDistance2d(pAttumen);
            float newX = me->GetPositionX() + std::cos(angle)*(distance/2);
            float newY = me->GetPositionY() + std::sin(angle)*(distance/2);
            float newZ = 50;
            //me->Relocate(newX, newY, newZ, angle);
            //me->SendMonsterMove(newX, newY, newZ, 0, true, 1000);
            me->GetMotionMaster()->Clear();
            me->GetMotionMaster()->MovePoint(0, newX, newY, newZ);
            distance += 10;
            newX = me->GetPositionX() + std::cos(angle)*(distance/2);
            newY = me->GetPositionY() + std::sin(angle)*(distance/2);
            pAttumen->GetMotionMaster()->Clear();
            pAttumen->GetMotionMaster()->MovePoint(0, newX, newY, newZ);
            //pAttumen->Relocate(newX, newY, newZ, -angle);
            //pAttumen->SendMonsterMove(newX, newY, newZ, 0, true, 1000);
            Mount_Timer = 1000;
        }
 
        void SetMidnight(Creature* pAttumen, uint64 value)
        {
            CAST_AI(boss_attumen::boss_attumenAI, pAttumen->AI())->Midnight = value;
        }
    };
};
 
void boss_attumen::boss_attumenAI::UpdateAI(uint32 diff)
{
    if (ResetTimer)
    {
        if (ResetTimer <= diff)
        {
            ResetTimer = 0;
            Unit* pMidnight = Unit::GetUnit(*me, Midnight);
            if (pMidnight)
            {
                pMidnight->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE);
                pMidnight->SetVisible(true);
            }
            Midnight = 0;
            me->SetVisible(false);
            me->Kill(me);
        } else ResetTimer -= diff;
    }
 
    //Return since we have no target
    if (!UpdateVictim())
        return;
 
    if (me->HasFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NON_ATTACKABLE | UNIT_FLAG_NOT_SELECTABLE))
        return;
 
    if (CleaveTimer <= diff)
    {
        DoCastVictim(SPELL_SHADOWCLEAVE);
        CleaveTimer = std::rand() % 15000 + 10000;
    } else CleaveTimer -= diff;
 
    if (CurseTimer <= diff)
    {
        DoCastVictim(SPELL_INTANGIBLE_PRESENCE);
        CurseTimer = 30000;
    } else CurseTimer -= diff;
 
    if (RandomYellTimer <= diff)
    {
        Talk(SAY_RANDOM);
        RandomYellTimer = std::rand() % 60000 + 30000;
    } else RandomYellTimer -= diff;
 
    if (me->GetUInt32Value(UNIT_FIELD_DISPLAY_ID) == MOUNTED_DISPLAYID)
    {
        if (ChargeTimer <= diff)
        {
            Unit* target = NULL;
            ThreatContainer::StorageType const &t_list = me->getThreatManager().getThreatList();
            std::vector<Unit*> target_list;
            for (ThreatContainer::StorageType::const_iterator itr = t_list.begin(); itr != t_list.end(); ++itr)
            {
                target = Unit::GetUnit(*me, (*itr)->getUnitGuid());
                if (target && !target->IsWithinDist(me, ATTACK_DISTANCE, false))
                    target_list.push_back(target);
                target = NULL;
            }
            if (!target_list.empty())
                target = *(target_list.begin()+rand()%target_list.size());
 
            DoCast(target, SPELL_BERSERKER_CHARGE);
            ChargeTimer = 20000;
        } else ChargeTimer -= diff;
    }
    else
    {
        if (HealthBelowPct(25))
        {
            Creature* pMidnight = Unit::GetCreature(*me, Midnight);
            if (pMidnight && pMidnight->GetTypeId() == TypeID::TYPEID_UNIT)
            {
                CAST_AI(boss_midnight::boss_midnightAI, (pMidnight->AI()))->Mount(me);
                me->SetHealth(pMidnight->GetHealth());
                DoResetThreat();
            }
        }
    }
 
    DoMeleeAttackIfReady();
}
 
void AddSC_boss_attumen()
{
    new boss_attumen();
    new boss_midnight();
}