Example #1
0
    void Aggro(Unit *who)
    {
        if(!ghost)
        {
            DoScriptText(SAY_SKARVALD_AGGRO,m_creature);

            pInstance->SetData(DATA_SKARVALD_DALRONN_EVENT,IN_PROGRESS);
            Unit* dalronn = Unit::GetUnit((*m_creature),pInstance->GetData64(DATA_DALRONN));
            if(dalronn && dalronn->isAlive() && !dalronn->getVictim())
                dalronn->getThreatManager().addThreat(who,0.0f);
        }
    }
Example #2
0
		void EnterCombat(Unit * who) {
			if (!ghost && instance) {
				DoScriptText(YELL_SKARVALD_AGGRO, me);

				Unit* dalronn = Unit::GetUnit((*me),
						instance->GetData64(DATA_DALRONN));
				if (dalronn && dalronn->isAlive() && !dalronn->getVictim())
					dalronn->getThreatManager().addThreat(who, 0.0f);

				instance->SetData(DATA_SKARVALD_DALRONN_EVENT, IN_PROGRESS);
			}
		}
Example #3
0
    void EnterCombat(Unit *who)
    {
        if (!ghost && m_pInstance)
        {
            DoScriptText(YELL_SKARVALD_AGGRO,m_creature);

            Unit* dalronn = m_pInstance->GetSingleCreatureFromStorage(NPC_DALRONN);
            if (dalronn && dalronn->isAlive() && !dalronn->getVictim())
                dalronn->getThreatManager().addThreat(who,0.0f);

            m_pInstance->SetData(TYPE_SKARVALD_DALRONN, IN_PROGRESS);
        }
    }
    void EnterCombat(Unit *who)
    {
        if (!ghost && m_pInstance)
        {
            DoScriptText(YELL_SKARVALD_AGGRO,m_creature);

            Unit* dalronn = m_creature->GetMap()->GetUnit(ObjectGuid(m_pInstance->GetData64(DATA_DALRONN)));
            if (dalronn && dalronn->isAlive() && !dalronn->getVictim())
                dalronn->getThreatManager().addThreat(who,0.0f);

            m_pInstance->SetData(DATA_SKARVALD_DALRONN_EVENT, IN_PROGRESS);
        }
    }
        void EnterCombat(Unit* who)
        {
            if (!ghost && instance)
            {
                Unit* skarvald = Unit::GetUnit(*me, instance->GetData64(DATA_SKARVALD));
                if (skarvald && skarvald->IsAlive() && !skarvald->GetVictim())
                    skarvald->getThreatManager().addThreat(who, 0.0f);

                AggroYell_Timer = 5000;

                if (instance)
                    instance->SetData(DATA_SKARVALD_DALRONN_EVENT, IN_PROGRESS);
            }
        }
Example #6
0
            void HandleScriptEffect(SpellEffIndex /*effIndex*/)
            {
                if (GetCaster()->GetTypeId() != TYPEID_UNIT)
                    return;

                Unit* caster = GetCaster();
                CreatureAI* ickAI = caster->ToCreature()->AI();
                if (Unit* target = ickAI->SelectTarget(SELECT_TARGET_RANDOM, 0, 200.0f, true))
                {
                    DoScriptText(SAY_ICK_CHASE_1, caster, target);
                    caster->AddAura(GetSpellInfo()->Id, target);
                    CAST_AI(boss_ick::boss_ickAI, ickAI)->SetTempThreat(caster->getThreatManager().getThreat(target));
                    caster->AddThreat(target, float(GetEffectValue()));
                    target->AddThreat(caster, float(GetEffectValue()));
                }
            }
    void UpdateAI(const uint32 diff)
    {
        if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
            return;

        if (EnfeebleResetTimer)
        {
            if (EnfeebleResetTimer <= diff)                  //Let's not forget to reset that
            {
                EnfeebleResetHealth();
                EnfeebleResetTimer=0;
            } else EnfeebleResetTimer -= diff;
        }

        if (m_creature->hasUnitState(UNIT_STAT_STUNNED))    //While shifting to phase 2 malchezaar stuns himself
            return;

        if (m_creature->GetUInt64Value(UNIT_FIELD_TARGET)!=m_creature->getVictim()->GetGUID())
            m_creature->SetUInt64Value(UNIT_FIELD_TARGET, m_creature->getVictim()->GetGUID());

        if (phase == 1)
        {
            if (m_creature->GetHealthPercent() < 60.0f)
            {
                m_creature->InterruptNonMeleeSpells(false);

                phase = 2;

                //animation
                DoCastSpellIfCan(m_creature, SPELL_EQUIP_AXES);

                //text
                DoScriptText(SAY_AXE_TOSS1, m_creature);

                //passive thrash aura
                m_creature->CastSpell(m_creature, SPELL_THRASH_AURA, true);

                //models
                SetEquipmentSlots(false, EQUIP_ID_AXE, EQUIP_ID_AXE, EQUIP_NO_CHANGE);

                //damage
                const CreatureInfo *cinfo = m_creature->GetCreatureInfo();
                m_creature->SetBaseWeaponDamage(BASE_ATTACK, MINDAMAGE, 2*cinfo->mindmg);
                m_creature->SetBaseWeaponDamage(BASE_ATTACK, MAXDAMAGE, 2*cinfo->maxdmg);
                m_creature->UpdateDamagePhysical(BASE_ATTACK);

                m_creature->SetBaseWeaponDamage(OFF_ATTACK, MINDAMAGE, cinfo->mindmg);
                m_creature->SetBaseWeaponDamage(OFF_ATTACK, MAXDAMAGE, cinfo->maxdmg);
                //Sigh, updating only works on main attack , do it manually ....
                m_creature->SetFloatValue(UNIT_FIELD_MINOFFHANDDAMAGE, cinfo->mindmg);
                m_creature->SetFloatValue(UNIT_FIELD_MAXOFFHANDDAMAGE, cinfo->maxdmg);

                m_creature->SetAttackTime(OFF_ATTACK, (m_creature->GetAttackTime(BASE_ATTACK)*150)/100);
            }
        }
        else if (phase == 2)
        {
            if (m_creature->GetHealthPercent() < 30.0f)
            {
                InfernalTimer = 15000;

                phase = 3;

                ClearWeapons();

                //remove thrash
                m_creature->RemoveAurasDueToSpell(SPELL_THRASH_AURA);

                DoScriptText(SAY_AXE_TOSS2, m_creature);

                Unit *target = SelectUnit(SELECT_TARGET_RANDOM, 0);
                for(uint32 i=0; i<2; ++i)
                {
                    Creature *axe = m_creature->SummonCreature(MALCHEZARS_AXE, m_creature->GetPositionX(), m_creature->GetPositionY(), m_creature->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 1000);
                    if (axe)
                    {
                        axe->SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
                        axe->setFaction(m_creature->getFaction());

                        axes[i] = axe->GetGUID();
                        if (target)
                        {
                            axe->AI()->AttackStart(target);
                            // axe->getThreatManager().tauntApply(target); //Taunt Apply and fade out does not work properly
                                                            // So we'll use a hack to add a lot of threat to our target
                            axe->AddThreat(target, 10000000.0f);
                        }
                    }
                }

                if (ShadowNovaTimer > 35000)
                    ShadowNovaTimer = EnfeebleTimer + 5000;

                return;
            }

            if (SunderArmorTimer < diff)
            {
                DoCastSpellIfCan(m_creature->getVictim(), SPELL_SUNDER_ARMOR);
                SunderArmorTimer = urand(10000, 18000);

            }else SunderArmorTimer -= diff;

            if (Cleave_Timer < diff)
            {
                DoCastSpellIfCan(m_creature->getVictim(), SPELL_CLEAVE);
                Cleave_Timer = urand(6000, 12000);

            }else Cleave_Timer -= diff;
        }
        else
        {
            if (AxesTargetSwitchTimer < diff)
            {
                AxesTargetSwitchTimer = urand(7500, 20000);

                Unit *target = SelectUnit(SELECT_TARGET_RANDOM, 0);
                if (target)
                {
                    for(int i = 0; i < 2; ++i)
                    {
                        Unit *axe = Unit::GetUnit(*m_creature, axes[i]);
                        if (axe)
                        {
                            float threat = 1000000.0f;
                            if (axe->getVictim() && m_creature->getThreatManager().getThreat(axe->getVictim()))
                            {
                                threat = axe->getThreatManager().getThreat(axe->getVictim());
                                axe->getThreatManager().modifyThreatPercent(axe->getVictim(), -100);
                            }
                            if (target)
                                axe->AddThreat(target, threat);
                            //axe->getThreatManager().tauntFadeOut(axe->getVictim());
                            //axe->getThreatManager().tauntApply(target);
                        }
                    }
                }
            } else AxesTargetSwitchTimer -= diff;

            if (AmplifyDamageTimer < diff)
            {
                if (Unit* pTarget = SelectUnit(SELECT_TARGET_RANDOM, 0))
                    DoCastSpellIfCan(pTarget, SPELL_AMPLIFY_DAMAGE);

                AmplifyDamageTimer = urand(20000, 30000);
            }else AmplifyDamageTimer -= diff;
        }

        //Time for global and double timers
        if (InfernalTimer < diff)
        {
            SummonInfernal(diff);
            InfernalTimer =  phase == 3 ? 14500 : 44500;    //15 secs in phase 3, 45 otherwise
        }else InfernalTimer -= diff;

        if (ShadowNovaTimer < diff)
        {
            DoCastSpellIfCan(m_creature->getVictim(), SPELL_SHADOWNOVA);
            ShadowNovaTimer = phase == 3 ? 31000 : -1;
        } else ShadowNovaTimer -= diff;

        if (phase != 2)
        {
            if (SWPainTimer < diff)
            {
                Unit* target = NULL;
                if (phase == 1)
                    target = m_creature->getVictim();       // the tank
                else                                        //anyone but the tank
                    target = SelectUnit(SELECT_TARGET_RANDOM, 1);

                if (target)
                    DoCastSpellIfCan(target, SPELL_SW_PAIN);

                SWPainTimer = 20000;
            }else SWPainTimer -= diff;
        }

        if (phase != 3)
        {
            if (EnfeebleTimer < diff)
            {
                EnfeebleHealthEffect();
                EnfeebleTimer = 30000;
                ShadowNovaTimer = 5000;
                EnfeebleResetTimer = 9000;
            }else EnfeebleTimer -= diff;
        }

        if (phase==2)
            DoMeleeAttacksIfReady();
        else
            DoMeleeAttackIfReady();
    }