Exemple #1
0
        bool OnGossipSelect(Player *player, Creature *npc, uint32 sender, uint32 uiAction)
        {
            InstanceScript* instance = npc->GetInstanceScript();

            if (sender != GOSSIP_SENDER_MAIN)
            {
                player->CLOSE_GOSSIP_MENU();
                return true;
            }

            switch (uiAction)
            {
            case 1:
                {
                    instance->SetData(DATA_BUFF, 4);
                    instance->DoRemoveAurasDueToSpellOnPlayers(73828);
                    instance->DoRemoveAurasDueToSpellOnPlayers(73762);
                    instance->DoRemoveAurasDueToSpellOnPlayers(73824);
                    instance->DoRemoveAurasDueToSpellOnPlayers(73825);
                    player->CLOSE_GOSSIP_MENU();
                }
                break;
            case 2:
                instance->SetData(DATA_BUFF, 3);
                instance->DoCastSpellOnPlayers(73762);
                player->CLOSE_GOSSIP_MENU();
                break;
            case 3:
                instance->SetData(DATA_BUFF, 2);
                instance->DoCastSpellOnPlayers(73824);
                player->CLOSE_GOSSIP_MENU();
                break;
            case 4:
                instance->SetData(DATA_BUFF, 1);
                instance->DoCastSpellOnPlayers(73825);
                player->CLOSE_GOSSIP_MENU();
                break;
            case 5:
                instance->SetData(DATA_BUFF, 0);
                instance->DoCastSpellOnPlayers(73828);
                player->CLOSE_GOSSIP_MENU();
                break;
            case 6: //Close
                {
                    player->CLOSE_GOSSIP_MENU();
                    return true;
                }

            default:
                player->CLOSE_GOSSIP_MENU();
                return true;
            }
            return true;
        }
 void DoAction(int32 const action)
 {
     switch (action)
     {
         case ACTION_ENTER_COMBAT:
             if (!me->isInCombat())
                 if (Player* victim = me->SelectNearestPlayerNotGM(100.0f))
                     AttackStart(victim);
             break;
         case ACTION_PETRIFICATION:
         {
             char buf[128];
             const char *name = me->GetName();
             sprintf(buf, "%s begins to petrify all players !", name);
             me->MonsterTextEmote(buf, 0, true);
             me->CastSpell(me, spellPetrificationId, true);
             pInstance->DoCastSpellOnPlayers(spellPetrificationBarId);
             break;
         }
         case ACTION_FAIL:
             EnterEvadeMode();
             break;
         default:
             break;
     }
 }
            void HandleProc(AuraEffect const* /*aurEff*/, ProcEventInfo& eventInfo)
            {
                InstanceScript* instance = eventInfo.GetActor()->GetInstanceScript();
                if (!instance)
                    return;

                instance->DoCastSpellOnPlayers(SPELL_ACHIEVEMENT_CREDIT_NERF_SCRAPBOTS);
            }
		void JustDied(Unit *pWho)
		{
			if (instance)
				if (Creature* strife = me->FindNearestCreature(NPC_STRIFE, 99999.0f, false))
					if (!strife->isAlive())
					{
						instance->SetBossState(DATA_BOSS_LOREWALKER_STONESTEP, DONE);
						instance->DoCastSpellOnPlayers(SPELL_LOREWALKER_S_ALACRITY);
					}
		}
		void DamageTaken(Unit* who, uint32& damage)
		{
			if (damage >= me->GetHealth())
			{
				damage = 0;
				me->SetHealth(1);

				if (!oneHp)
				{
					instance->DoCastSpellOnPlayers(SPELL_CAMERA_SHAKE);
					events.ScheduleEvent(EVENT_SUMMON_BOSSES, 4*IN_MILLISECONDS);
					oneHp = true;
				}
			}
		}
 void EnterCombat(Unit* victim)
 {   
     DoCastAOE(SPELL_ABILITATE_BALANCE_BAR);
     if (instance)
     {
         instance->DoCastSpellOnPlayers(SPELL_ABILITATE_BALANCE_BAR);
         instance->SetData(DATA_RHYOLITH_EVENT, IN_PROGRESS);
     }
     direction = 25;
     phase1=true;
     steertimer = 0;
     me->SetReactState(REACT_PASSIVE);
     me->SendMovementWalkMode();
     moving = true;
     me->SetSpeed(MOVE_WALK,   0.5f, true);
     me->SetSpeed(MOVE_RUN,    0.5f, true);
     me->SetWalk(true);
     obsidian = me->AddAura(SPELL_OBSIDIAN_ARMOR, me); 
     if (obsidian)
         obsidian->SetStackAmount(80);
     DoZoneInCombat(me);
     leftfoot = me->SummonCreature(LEFT_FOOT_RHYOLITH,
         me->GetPositionX(),
         me->GetPositionY(),
         me->GetPositionZ() + 12.0f,
         0,TEMPSUMMON_MANUAL_DESPAWN);
     if (leftfoot)
     {
         leftfoot->EnterVehicle(me, 0);
         leftfoot->ClearUnitState(UNIT_STATE_ONVEHICLE);
     }
     rightfoot = me->SummonCreature(RIGHT_FOOT_RHYOLITH,
         me->GetPositionX(),
         me->GetPositionY(),
         me->GetPositionZ() + 12.0f,
         0,TEMPSUMMON_MANUAL_DESPAWN);
     if (rightfoot)
     {
         rightfoot->EnterVehicle(me, 1);
         rightfoot->ClearUnitState(UNIT_STATE_ONVEHICLE);
     }
     
     events.ScheduleEvent(EVENT_UPDATE_PATH, 2000, 0, 0);
     events.ScheduleEvent(EVENT_STOMP, 2000, 0, 0);
 }
		void JustDied(Unit *pWho)
		{
			if (instance)
			{
				Talk(irand(SAY_DEATH_1, SAY_DEATH_3));

				instance->DoCastSpellOnPlayers(SPELL_BLESSING_OF_THE_WATERSPEAKER);

				Map* map = me->GetMap();
				if (me->GetMap()->IsHeroic())
				{
					me->CastSpell(me, SPELL_PURIFIED_WATER);

					Map::PlayerList const &PlayerList = map->GetPlayers();

					if (!PlayerList.isEmpty())
						for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
							if (Player* player = i->getSource())
								if (!player->HasAura(SPELL_PREVENTION_HYDROPHOBIA))
								{
									player->CompletedAchievement(sAchievementMgr->GetAchievement(ACHI_HYDROPHOBIA));
									player->RemoveAurasDueToSpell(SPELL_PREVENTION_HYDROPHOBIA, player->GetGUID());
								}
								else player->RemoveAurasDueToSpell(SPELL_PREVENTION_HYDROPHOBIA, player->GetGUID());
				}

				if (Creature* lorewalkerTrigger = me->FindNearestCreature(NPC_LOREWALKER_TRIGGER, 99999.0f, false))
				{
					if (GameObject* wiseDoor = me->FindNearestGameObject(GO_MARI_LOREWALKER_GATE, 99999.0f))
						wiseDoor->UseDoorOrButton();

					if (GameObject* lorewalkerDoor = lorewalkerTrigger->FindNearestGameObject(GO_MARI_LOREWALKER_GATE, 99999.0f))
						lorewalkerDoor->UseDoorOrButton();

					if (GameObject* go = me->FindNearestGameObject(GO_LIU_GATE, 99999.0f))
						go->UseDoorOrButton();
				}
			}
		}
Exemple #8
0
        void UpdateAI(const uint32 diff)
        {
            if (!InProgress)
                return;

            if (phase == PHASE_FILTHY_INVADERS_1)
            {
                me->SetOrientation(0.166467f);
                phase = PHASE_FILTHY_INVADERS_2;
                me->MonsterSay(SAY_1, LANG_UNIVERSAL, NULL);
            }

            if (summonMurlocTimer <= diff)
            {
                if (phase == PHASE_FILTHY_INVADERS_2)
                    SummonAdd(NPC_DEEP_MURLOC, 6);

                if (sumMurlocs.size() >= 6*3)
                    phase = PHASE_NULL;

                summonMurlocTimer = 5000;
            } else summonMurlocTimer -= diff;

            if (MindlasherTimer <= diff)
            {
                if (phase == PHASE_FILTHY_INVADERS_3)
                {
                    SummonAdd(NPC_MINDLASHER, 1);
                }

                if (sumMindlasher.size() >= 3 && !slasherphased)
                {
                    me->MonsterYell(SAY_2, LANG_UNIVERSAL, NULL);
                    phase = PHASE_NULL;
                    slasherphased = true;
                }

                if (phase != PHASE_FILTHY_INVADERS_3 && !sumonslasher)
                {
                    SummonAdd(NPC_MINDLASHER, 1);
                    phase = PHASE_FILTHY_INVADERS_3;
                    sumonslasher = true;
                }
                MindlasherTimer = 12000;
            } else MindlasherTimer -= diff;

            if (behemontTimer <= diff)
            {
                if (summonbehemont == false)
                {
                    SummonAdd(NPC_BEHEMOTH, 1);
                    summonbehemont = true;
                }
            } else behemontTimer -= diff;

            if (phase2_timer <= diff && phase != PHASE_BEAST_RETURN)
            {
                phase = PHASE_BEAST_RETURN;
                me->MonsterYell(SAY_3, LANG_UNIVERSAL, NULL);
            } else phase2_timer -= diff;

            if (phase == PHASE_BEAST_RETURN)
            {
                if (ozumatSummoned == false)
                {
                    SummonAdd(NPC_SAPPER, 3);
                    phase = PHASE_NULL;
                    ozumatSummoned = true;
                }
            }
            if (deadSappers >= 3 && phase != PHASE_TIDAL_SURGE)
                phase = PHASE_TIDAL_SURGE;

            if (phase == PHASE_TIDAL_SURGE)
            {
                if (flagged == false)
                {
                    SummonAdd(BOSS_OZUMAT, 1);
                    Ozumat->setFaction(14);
                    if (instance)
                        instance->DoCastSpellOnPlayers(76133);
                    me->MonsterYell(SAY_CLEANSED,LANG_UNIVERSAL, NULL);
                    flagged = true;
                }
            }
        }
Exemple #9
0
        void HandleWave()
        {
            if(waveCount < 6)
            { // Phase 1

                waveCount++;

                uint32 summonEntry;
                uint8 p = urand(0,2);

                if(waveCount == 1)
                {
                    me->MonsterSay(SAY_1,0,0);
                    DoCastAOE(SPELL_NEPTULON_BEAM_VISUAL,true);
                    DoZoneInCombat(me);

                    if (Creature* ozumat = ObjectAccessor::GetCreature(*me,instance->GetData64(BOSS_OZUMAT)))
                        ozumat->AI()->DoAction(ACTION_OZUMAT_PREPARE_EVENT);

                }else if (waveCount == 6)
                {
                    for(uint8 i = 3; i <= 5; i++)
                        if(Creature* summon = me->SummonCreature(NPC_FACELESS_SAPPER, SpawnPositions[i],TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000))
                        {
                            summon->AI()->DoZoneInCombat(summon);
                            summon->SetReactState(REACT_PASSIVE);
                            summon->SetFacingToObject(me);
                            summon->CastSpell(me, SPELL_ENTANGLING_GRASP, true);
                        }

                        if (Creature* ozumat = ObjectAccessor::GetCreature(*me, instance->GetData64(BOSS_OZUMAT)))
                            ozumat->AI()->DoAction(ACTION_OZUMAT_START_EVENT);

                        Position myPos;
                        me->GetPosition(&myPos);
                        me->SummonCreature(NPC_OZUMAT_VISUAL_TRIGGER, myPos, TEMPSUMMON_MANUAL_DESPAWN);

                        waveCount=7;
                        return;
                }

                switch(urand(0,2))
                {

                case 0:
                    summonEntry = NPC_DEEP_MURLOC_INVADER;
                    break;
                case 1:
                    summonEntry = NPC_UNYIELDING_BEHEMOTH;
                    break;
                case 2:
                    summonEntry = NPC_VICIOUS_MINDLASHER;
                    break;
                }

                for(uint8 i = 0; i <= (summonEntry == NPC_DEEP_MURLOC_INVADER ? 2 : 0); i++)
                    if(Creature* summon = me->SummonCreature(summonEntry, SpawnPositions[p],TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000))
                    {
                        summon->AI()->DoZoneInCombat(summon);
                    }

            }else if(waveCount == 7)
            { // Phase 2

                if(Creature* summon = me->SummonCreature(NPC_BLIGHT_BEAST, SpawnPositions[urand(0,2)],TEMPSUMMON_TIMED_DESPAWN_OUT_OF_COMBAT, 30000))
                    summon->AI()->DoZoneInCombat(summon);

            }else if(waveCount == 8)
            { // Phase 3

                if (Creature* ozumat = ObjectAccessor::GetCreature(*me, instance->GetData64(BOSS_OZUMAT)))
                    ozumat->AI()->DoAction(ACTION_OZUMAT_FINAL_PHASE);

                DespawnCreatures(NPC_BLIGHT_OF_OZUMAT);
                instance->DoCastSpellOnPlayers(SPELL_TIDAL_SURGE);
                waveCount= 9;

            }else if(waveCount == 9)
            { // End encounter and Spawn Chest
                DespawnCreatures(NPC_OZUMAT_VISUAL_TRIGGER);
            }
        }
Exemple #10
0
        void UpdateAI(const uint32 diff)
        {
            if (!UpdateVictim())
                return;

            if (me->HealthBelowPct(51) && Phase == PHASE_NORMAL && Phased == false)
            {
                me->SetReactState(REACT_PASSIVE);
                DoScriptText(RAND(SAY_REPETANCE_1,SAY_REPETANCE_2), me);
                DoCast(me, SPELL_REPENTANCE_AURA);
                DoCast(SPELL_PULL_ALL);
                pInstance->DoCastSpellOnPlayers(SPELL_REPENTANCE);
                Position pos;
                me->GetPosition(&pos);
                me->SummonCreature(CREATURE_HARBINGER_OF_DARKNESS, pos, TEMPSUMMON_CORPSE_TIMED_DESPAWN, 100);
                SetCombatMovement(false);
                Phase = PHASE_50_PRECENT;
                Phased = true;
                return;
            }

            if (PhaseChangeTimer <= diff && Phase == PHASE_50_PRECENT)
            {
                me->SetReactState(REACT_AGGRESSIVE);
                pInstance->DoRemoveAurasDueToSpellOnPlayers(SPELL_REPENTANCE);
                me->RemoveAurasDueToSpell(SPELL_REPENTANCE_AURA);
                PlagueOfAgesTimer = 7000;
                FiftyLashingsTimer = 2000;
                HeavensFuryTimer = 20000;
                Phase = PHASE_NORMAL;
            } else PhaseChangeTimer -= diff;

            if (FenixTimer <= diff && FenixSummoned == false && Phase == PHASE_NORMAL)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_BLAZE_SUMMON, true);
                FenixSummoned = true;
            } else FenixTimer -= diff;

            if (PlagueOfAgesTimer <= diff && Phase == PHASE_NORMAL)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_PLAGUE_OF_AGES, true);
                PlagueOfAgesTimer = urand(12000,16000);
            } else PlagueOfAgesTimer -= diff;

            if (FiftyLashingsTimer <= diff && Phase == PHASE_NORMAL)
            {
                DoCast(me, SPELL_FIFTY_LASHINGS);
                FiftyLashingsTimer = 20000;
            } else FiftyLashingsTimer -= diff;

            if (HeavensFuryTimer <= diff && Phase == PHASE_NORMAL)
            {
                if (Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 0))
                    DoCast(target, SPELL_HEAVENS_FURY, true);
                HeavensFuryTimer = urand(22000,35000);
            } else HeavensFuryTimer -= diff;

            DoMeleeAttackIfReady();
        }
 void UpdateAI(uint32 diff) override
 {
     if (!(thrallGUID || garroshGUID || varianGUID || proudmooreGUID || tirionGUID))
         return;
         
     events.Update(diff);
         
     while (uint32 eventId = events.ExecuteEvent())
     {
         switch (eventId)
         {
             case EVENT_INTRO_1:
                 instance->DoCastSpellOnPlayers(SPELL_HERALD_ARGENT);
                 Talk(SAY_INTRO_HERALD_1);
                 events.ScheduleEvent(EVENT_INTRO_2, 5000, 0, PHASE_INTRO);
                 break;
             case EVENT_INTRO_2:
                 if (Creature* tirion = ObjectAccessor::GetCreature(*me, tirionGUID))
                     tirion->AI()->Talk(SAY_INTRO_HERALD_2);
                 events.ScheduleEvent(EVENT_INTRO_3, 13000, 0, PHASE_INTRO);
                 break;
             case EVENT_INTRO_3:
                 if (instance->GetData(DATA_TEAM_IN_INSTANCE) == HORDE)
                 {
                     if (Creature* thrall = ObjectAccessor::GetCreature(*me, thrallGUID))
                         thrall->AI()->Talk(H_SAY_INTRO_HERALD_3);
                 }
                 else
                     if (Creature* varian = ObjectAccessor::GetCreature(*me, varianGUID))
                         varian->AI()->Talk(A_SAY_INTRO_HERALD_3);
                 events.ScheduleEvent(EVENT_INTRO_4, 4000, 0, PHASE_INTRO);
                 break;
             case EVENT_INTRO_4:
                 if (instance->GetData(DATA_TEAM_IN_INSTANCE) == HORDE)
                 {
                     if (Creature* garrosh = ObjectAccessor::GetCreature(*me, garroshGUID))
                         garrosh->AI()->Talk(H_SAY_INTRO_HERALD_4);
                 }
                 else
                     if (Creature* proudmoore = ObjectAccessor::GetCreature(*me, proudmooreGUID))
                         proudmoore->AI()->Talk(A_SAY_INTRO_HERALD_4);
                 events.ScheduleEvent(EVENT_INTRO_5, 4000, 0, PHASE_INTRO);
                 break;
             case EVENT_INTRO_5:
                 if (instance->GetData(DATA_TEAM_IN_INSTANCE) == HORDE)
                 {
                     if (Creature* varian = ObjectAccessor::GetCreature(*me, varianGUID))
                         varian->AI()->Talk(SAY_INTRO_HERALD_5);
                 }
                 else
                     if (Creature* garrosh = ObjectAccessor::GetCreature(*me, garroshGUID))
                         garrosh->AI()->Talk(SAY_INTRO_HERALD_5);
                 events.ScheduleEvent(EVENT_INTRO_6, 6000, 0, PHASE_INTRO);
                 break;
             case EVENT_INTRO_6:
                 if (instance->GetData(DATA_TEAM_IN_INSTANCE) == HORDE)
                 {
                     if (Creature* proudmoore = ObjectAccessor::GetCreature(*me, proudmooreGUID))
                         proudmoore->AI()->Talk(H_SAY_INTRO_HERALD_6);
                 }
                 else
                     if (Creature* thrall = ObjectAccessor::GetCreature(*me, thrallGUID))
                         thrall->AI()->Talk(A_SAY_INTRO_HERALD_6);
                 events.ScheduleEvent(EVENT_INTRO_7, 6000, 0, PHASE_INTRO);
                 break;
             case EVENT_INTRO_7:
                 if (Creature* tirion = ObjectAccessor::GetCreature(*me, tirionGUID))
                     tirion->AI()->Talk(SAY_INTRO_HERALD_7);
                 events.ScheduleEvent(EVENT_INTRO_8, 1000, 0, PHASE_INTRO);
                 break;
             case EVENT_INTRO_8:
                 me->SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_GOSSIP);
                 events.SetPhase(PHASE_INPROGRESS);
                 break;
             case EVENT_SUMMON_FACTION_2:
                 DoSummonGrandChampion(uiSecondBoss);
                 events.ScheduleEvent(EVENT_SUMMON_FACTION_3, 10000, 0, PHASE_INPROGRESS);
                 break;
             case EVENT_SUMMON_FACTION_3:
                 DoSummonGrandChampion(uiThirdBoss);
                 break;
             case EVENT_AGGRO_FACTION:
                 if (!Champion1List.empty())
                 {
                     for(std::list<uint64>::const_iterator itr = Champion1List.begin(); itr != Champion1List.end(); ++itr)
                         if (Creature* summon = ObjectAccessor::GetCreature(*me, *itr))
                             AggroAllPlayers(summon);
                 }
                 break;
             case EVENT_PALETRESS_1:
                 Talk(SAY_PALETRESS_INTRO_1);
                 Talk(SAY_PALETRESS_INTRO_2);
                 events.ScheduleEvent(EVENT_PALETRESS_2, 5000, 0, PHASE_INPROGRESS);
                 break;
             case EVENT_PALETRESS_2:
                 if (Creature* argentchamp = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_ARGENT_CHAMPION)))
                     argentchamp->AI()->Talk(SAY_PALETRESS_INTRO_3);
                 events.ScheduleEvent(EVENT_PALETRESS_3, 5000);
             case EVENT_PALETRESS_3:
                 if (Creature* argentchamp = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_ARGENT_CHAMPION)))
                     argentchamp->AI()->Talk(SAY_PALETRESS_INTRO_4);
                 events.CancelEvent(EVENT_PALETRESS_3);
                 break;
             case EVENT_EADRIC_1:
                 Talk(SAY_EADRIC_INTRO_1);
                 Talk(SAY_EADRIC_INTRO_2);
                 events.ScheduleEvent(EVENT_EADRIC_2, 5000);
                 break;
             case EVENT_EADRIC_2:
                 if (Creature* argentchamp = ObjectAccessor::GetCreature(*me, instance->GetData64(DATA_ARGENT_CHAMPION)))
                     argentchamp->AI()->Talk(SAY_EADRIC_INTRO_3);
                 break;
         }
     }
 }