instance_the_black_morass.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/>.
 */
 
/*
Name: Instance_The_Black_Morass
%Complete: 50
Comment: Quest support: 9836, 10297. Currently in progress.
Category: Caverns of Time, The Black Morass
*/
 
#include "ScriptMgr.h"
#include "EventMap.h"
#include "InstanceScript.h"
#include "Log.h"
#include "Map.h"
#include "Player.h"
#include "the_black_morass.h"
#include "TemporarySummon.h"
 
enum Misc
{
 SPELL_RIFT_CHANNEL = 31387,
 RIFT_BOSS = 1
};
 
inline uint32 RandRiftBoss() { return ((rand32() % 2) ? NPC_RIFT_KEEPER : NPC_RIFT_LORD); }
 
float PortalLocation[4][4]=
{
 {-2041.06f, 7042.08f, 29.99f, 1.30f},
 {-1968.18f, 7042.11f, 21.93f, 2.12f},
 {-1885.82f, 7107.36f, 22.32f, 3.07f},
 {-1928.11f, 7175.95f, 22.11f, 3.44f}
};
 
struct Wave
{
 uint32 PortalBoss; //protector of current portal
 Milliseconds NextPortalTime; //time to next portal, or 0 if portal boss need to be killed
};
 
static Wave RiftWaves[]=
{
 { RIFT_BOSS, 0s },
 { NPC_CRONO_LORD_DEJA, 0s },
 { RIFT_BOSS, 120s },
 { NPC_TEMPORUS, 140s },
 { RIFT_BOSS, 120s },
 { NPC_AEONUS, 0s }
};
 
enum EventIds
{
 EVENT_NEXT_PORTAL = 1
};
 
class instance_the_black_morass : public InstanceMapScript
{
public:
 instance_the_black_morass() : InstanceMapScript(TBMScriptName, 269) { }
 
 InstanceScript* GetInstanceScript(InstanceMap* map) const override
 {
 return new instance_the_black_morass_InstanceMapScript(map);
 }
 
 struct instance_the_black_morass_InstanceMapScript : public InstanceScript
 {
 instance_the_black_morass_InstanceMapScript(InstanceMap* map) : InstanceScript(map)
 {
 SetHeaders(DataHeader);
 Clear();
 }
 
 uint32 m_auiEncounter[EncounterCount];
 
 uint32 mRiftPortalCount;
 uint32 mShieldPercent;
 uint8 mRiftWaveCount;
 uint8 mRiftWaveId;
 
 ObjectGuid _medivhGUID;
 uint8 _currentRiftId;
 
 void Clear()
 {
 memset(&m_auiEncounter, 0, sizeof(m_auiEncounter));
 
 mRiftPortalCount = 0;
 mShieldPercent = 100;
 mRiftWaveCount = 0;
 mRiftWaveId = 0;
 
 _currentRiftId = 0;
 }
 
 bool IsEncounterInProgress() const override
 {
 if (GetData(TYPE_MEDIVH) == IN_PROGRESS)
 return true;
 
 return false;
 }
 
 void OnCreatureCreate(Creature* creature) override
 {
 if (creature->GetEntry() == NPC_MEDIVH)
 _medivhGUID = creature->GetGUID();
 }
 
 //what other conditions to check?
 bool CanProgressEvent()
 {
 if (instance->GetPlayers().isEmpty())
 return false;
 
 return true;
 }
 
 uint8 GetRiftWaveId()
 {
 switch (mRiftPortalCount)
 {
 case 6:
 mRiftWaveId = 2;
 return 1;
 case 12:
 mRiftWaveId = 4;
 return 3;
 case 18:
 return 5;
 default:
 return mRiftWaveId;
 }
 }
 
 void SetData(uint32 type, uint32 data) override
 {
 switch (type)
 {
 case TYPE_MEDIVH:
 if (data == SPECIAL && m_auiEncounter[0] == IN_PROGRESS)
 {
 --mShieldPercent;
 
 DoUpdateWorldState(WORLD_STATE_BM_SHIELD, mShieldPercent);
 
 if (!mShieldPercent)
 {
 if (Creature* medivh = instance->GetCreature(_medivhGUID))
 {
 if (medivh->IsAlive())
 {
 medivh->KillSelf();
 m_auiEncounter[0] = FAIL;
 m_auiEncounter[1] = NOT_STARTED;
 }
 }
 }
 }
 else
 {
 if (data == IN_PROGRESS)
 {
 TC_LOG_DEBUG("scripts", "Instance The Black Morass: Starting event.");
 DoUpdateWorldState(WORLD_STATE_BM, 1);
 m_auiEncounter[1] = IN_PROGRESS;
 ScheduleEventNextPortal(15s);
 }
 
 if (data == DONE)
 {
 //this may be completed further out in the post-event
 TC_LOG_DEBUG("scripts", "Instance The Black Morass: Event completed.");
 Map::PlayerList const& players = instance->GetPlayers();
 
 if (!players.isEmpty())
 {
 for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
 {
 if (Player* player = itr->GetSource())
 {
 if (player->GetQuestStatus(QUEST_OPENING_PORTAL) == QUEST_STATUS_INCOMPLETE)
 player->AreaExploredOrEventHappens(QUEST_OPENING_PORTAL);
 
 if (player->GetQuestStatus(QUEST_MASTER_TOUCH) == QUEST_STATUS_INCOMPLETE)
 player->AreaExploredOrEventHappens(QUEST_MASTER_TOUCH);
 }
 }
 }
 }
 
 m_auiEncounter[0] = data;
 }
 break;
 case TYPE_RIFT:
 if (data == SPECIAL)
 {
 if (mRiftPortalCount < 7)
 ScheduleEventNextPortal(5s);
 }
 else
 m_auiEncounter[1] = data;
 break;
 }
 }
 
 uint32 GetData(uint32 type) const override
 {
 switch (type)
 {
 case TYPE_MEDIVH:
 return m_auiEncounter[0];
 case TYPE_RIFT:
 return m_auiEncounter[1];
 case DATA_PORTAL_COUNT:
 return mRiftPortalCount;
 case DATA_SHIELD:
 return mShieldPercent;
 }
 return 0;
 }
 
 ObjectGuid GetGuidData(uint32 data) const override
 {
 if (data == DATA_MEDIVH)
 return _medivhGUID;
 
 return ObjectGuid::Empty;
 }
 
 Creature* SummonedPortalBoss(Creature* me)
 {
 uint32 entry = RiftWaves[GetRiftWaveId()].PortalBoss;
 
 if (entry == RIFT_BOSS)
 entry = RandRiftBoss();
 
 TC_LOG_DEBUG("scripts", "Instance The Black Morass: Summoning rift boss entry {}.", entry);
 
 Position pos = me->GetRandomNearPosition(10.0f);
 
 //normalize Z-level if we can, if rift is not at ground level.
 pos.m_positionZ = std::max(me->GetMap()->GetHeight(me->GetPhaseShift(), pos.m_positionX, pos.m_positionY, MAX_HEIGHT), me->GetMap()->GetWaterLevel(me->GetPhaseShift(), pos.m_positionX, pos.m_positionY));
 
 if (Creature* summon = me->SummonCreature(entry, pos, TEMPSUMMON_TIMED_OR_DEAD_DESPAWN, 10min))
 return summon;
 
 TC_LOG_DEBUG("scripts", "Instance The Black Morass: What just happened there? No boss, no loot, no fun...");
 return nullptr;
 }
 
 void DoSpawnPortal()
 {
 if (Creature* medivh = instance->GetCreature(_medivhGUID))
 {
 uint8 tmp = urand(0, 2);
 
 if (tmp >= _currentRiftId)
 ++tmp;
 
 TC_LOG_DEBUG("scripts", "Instance The Black Morass: Creating Time Rift at locationId {} (old locationId was {}).", tmp, _currentRiftId);
 
 _currentRiftId = tmp;
 
 Creature* temp = medivh->SummonCreature(NPC_TIME_RIFT,
 PortalLocation[tmp][0], PortalLocation[tmp][1], PortalLocation[tmp][2], PortalLocation[tmp][3],
 TEMPSUMMON_CORPSE_DESPAWN);
 if (temp)
 {
 if (Creature* boss = SummonedPortalBoss(temp))
 {
 if (boss->GetEntry() == NPC_AEONUS)
 boss->GetThreatManager().AddThreat(medivh, 0.0f);
 else
 {
 boss->GetThreatManager().AddThreat(temp, 0.0f);
 temp->CastSpell(boss, SPELL_RIFT_CHANNEL, false);
 }
 }
 }
 }
 }
 
 void Update(uint32 diff) override
 {
 if (m_auiEncounter[1] != IN_PROGRESS)
 return;
 
 //add delay timer?
 if (!CanProgressEvent())
 {
 Clear();
 return;
 }
 
 Events.Update(diff);
 
 if (Events.ExecuteEvent() == EVENT_NEXT_PORTAL)
 {
 ++mRiftPortalCount;
 DoUpdateWorldState(WORLD_STATE_BM_RIFT, mRiftPortalCount);
 DoSpawnPortal();
 ScheduleEventNextPortal(RiftWaves[GetRiftWaveId()].NextPortalTime);
 }
 }
 
 void ScheduleEventNextPortal(Milliseconds nextPortalTime)
 {
 if (nextPortalTime > 0s)
 Events.RescheduleEvent(EVENT_NEXT_PORTAL, nextPortalTime);
 }
 
 protected:
 EventMap Events;
 };
 
};
 
void AddSC_instance_the_black_morass()
{
 new instance_the_black_morass();
}