Inheritance diagram for instance_ulduar::instance_ulduar_InstanceMapScript:

Public Member Functions
	instance_ulduar_InstanceMapScript (Map *map)

void	Initialize () override

void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &packet) override

uint32	AlgalonMinutesLeft () const

void	ExpireAlgalonCountdown ()

void	DespawnLeviathanGauntlet ()

void	UnlockLeviathanVehicles ()

void	SpawnObservationRingKeepers ()

void	SpawnLeviathanOutro (bool justKilled)

void	StartLeviathanOutroSequence ()

void	PlayBrannRhydianLine (uint8 index)

void	OnPlayerEnter (Player *player) override

bool	IsEncounterInProgress () const override

void	ProcessEvent (WorldObject *, uint32 eventId) override

bool	SetBossState (uint32 type, EncounterState state) override

void	OnCreatureCreate (Creature *creature) override

void	OnCreatureEvade (Creature *creature) override

void	OpenIfDone (uint32 encounter, GameObject *go, GOState state)

GameObject *	GetHodirChest (bool hardmode)

void	OnGameObjectCreate (GameObject *gameObject) override

void	respawnHodirHardmodeChest ()

void	setChestsLootable (uint32 boss)

void	SetData (uint32 type, uint32 data) override

ObjectGuid	GetGuidData (uint32 data) const override

uint32	GetData (uint32 type) const override

void	OnUnitDeath (Unit *unit) override

void	Load (char const *data) override

void	Update (uint32 diff) override

void	SpawnLeviathanEncounterVehicles (uint8 mode)

void	SummonLeviathanVehicle (uint32 entry, uint32 index)

void	ScheduleLeviathanVehicleRespawn (Creature *vehicle)

bool	CheckAchievementCriteriaMeet (uint32 criteria_id, Player const , Unit const , uint32) override

bool	CheckRequiredBosses (uint32 bossId, Player const *player) const override

Public Member Functions inherited from InstanceScript
	InstanceScript (Map *map)

	~InstanceScript () override

virtual void	CreatureLooted (Creature *, LootType)

virtual std::string	GetSaveData ()

void	SaveToDB ()

void	OnCreatureCreate (Creature *creature) override

void	OnCreatureRemove (Creature *creature) override

void	OnGameObjectCreate (GameObject *go) override

void	OnGameObjectRemove (GameObject *go) override

ObjectGuid	GetObjectGuid (uint32 type) const

ObjectGuid	GetGuidData (uint32 type) const override

Creature *	GetCreature (uint32 type)

GameObject *	GetGameObject (uint32 type)

virtual void	OnPlayerLeave (Player *)

virtual void	OnPlayerAreaUpdate (Player *, uint32, uint32)

virtual void	OnPlayerInWaterStateUpdate (Player *, bool)

void	HandleGameObject (ObjectGuid guid, bool open, GameObject *go=nullptr)
	Open or close a GameObject by GUID.

void	HandleGameObject (uint32 type, bool open)
	Open or close a GameObject registered via LoadObjectData.

void	DoUseDoorOrButton (ObjectGuid guid, uint32 withRestoreTime=0, bool useAlternativeState=false)

void	DoRespawnGameObject (ObjectGuid guid, uint32 timeToDespawn=MINUTE)

void	DoRespawnGameObject (uint32 type)

void	DoRespawnCreature (ObjectGuid guid, bool force=false)

void	DoRespawnCreature (uint32 type, bool force=false)

void	DoUpdateWorldState (uint32 worldstateId, uint32 worldstateValue)

void	DoSendNotifyToInstance (char const *format,...)

void	DoUpdateAchievementCriteria (AchievementCriteriaTypes type, uint32 miscValue1=0, uint32 miscValue2=0, Unit *unit=nullptr)

void	DoStartTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

void	DoStopTimedAchievement (AchievementCriteriaTimedTypes type, uint32 entry)

void	DoRemoveAurasDueToSpellOnPlayers (uint32 spell)

void	DoCastSpellOnPlayers (uint32 spell)

void	DoCastSpellOnPlayer (Player *player, uint32 spell, bool includePets, bool includeControlled)

bool	ServerAllowsTwoSideGroups ()

EncounterState	GetBossState (uint32 id) const

void	RegisterBossSpawn (ObjectGuid::LowType spawnId, uint32 bossId)

bool	IsBossSpawnDone (ObjectGuid::LowType spawnId) const

CreatureBoundary const *	GetBossBoundary (uint32 id) const

BossInfo const *	GetBossInfo (uint32 id) const

uint32	GetPersistentData (uint32 index) const

void	StorePersistentData (uint32 index, uint32 data)

bool	_SkipCheckRequiredBosses (Player const *player=nullptr) const

void	SetCompletedEncountersMask (uint32 newMask, bool save)

uint32	GetCompletedEncounterMask () const

void	SendEncounterUnit (uint32 type, Unit *unit=nullptr, uint8 param1=0, uint8 param2=0)

uint32	GetEncounterCount () const

void	MarkAreaTriggerDone (uint32 id)

void	ResetAreaTriggerDone (uint32 id)

bool	IsAreaTriggerDone (uint32 id) const

virtual void	DoAction (int32)

void	DoForAllMinions (uint32 id, std::function< void(Creature *)> exec)

void	StoreGameObjectState (ObjectGuid::LowType spawnId, uint8 state)

uint8	GetStoredGameObjectState (ObjectGuid::LowType spawnId) const

void	LoadInstanceSavedGameobjectStateData ()

bool	IsBossDone (uint32 bossId) const

bool	AllBossesDone () const

bool	AllBossesDone (std::initializer_list< uint32 > bossIds) const

TeamId	GetTeamIdInInstance () const

void	SetTeamIdInInstance (TeamId teamId)

bool	IsTwoFactionInstance () const

Public Member Functions inherited from ZoneScript
	ZoneScript ()

virtual	~ZoneScript ()

virtual uint32	GetCreatureEntry (ObjectGuid::LowType, CreatureData const *data)

virtual uint32	GetGameObjectEntry (ObjectGuid::LowType, uint32 entry)

virtual void	SetGuidData (uint32, ObjectGuid)

virtual uint64	GetData64 (uint32) const

virtual void	SetData64 (uint32, uint64)

Public Attributes
ObjectGuid	_leviathanVisualTowers [4][2]

ObjectGuid	_repairSGUID [2]

bool	_leviathanTowers [4]

std::vector< LeviathanVehicle >	_leviathanVehicles

uint8	_leviathanVehicleMode

bool	_leviathanVehiclesUsable

GuidUnorderedSet	_leviathanGauntletGUIDs

GuidUnorderedSet	_leviathanBeaconGUIDs

GuidList	_leviathanCrewGUIDs

bool	_leviathanOutroSpawned

bool	_leviathanSequenceStarted

ObjectGuid	_formationRhydianGUID

ObjectGuid	_leviathanMachineGUID

bool	_hmHodir

Position const	triggerAncientGatePosition = { 1883.65f, 269.272f, 418.406f }

EventMap	_events

bool	_mimironTramUsed

bool	_algalonArrivalPending

Public Attributes inherited from InstanceScript
Map *	instance

TaskScheduler	scheduler

Additional Inherited Members
Static Public Member Functions inherited from InstanceScript
static std::string	GetBossStateName (uint8 state)

Protected Member Functions inherited from InstanceScript
void	SetHeaders (std::string const &dataHeaders)

void	SetBossNumber (uint32 number)

void	SetPersistentDataCount (uint32 number)

void	LoadBossBoundaries (BossBoundaryData const &data)

void	LoadDoorData (DoorData const *data)

void	LoadMinionData (MinionData const *data)

void	LoadObjectData (ObjectData const creatureData, ObjectData const gameObjectData)

void	LoadSummonData (ObjectData const *data)

void	SetSummoner (Creature *creature)

void	AddObject (Creature *obj, bool add=true)

void	RemoveObject (Creature *obj)

void	AddObject (GameObject *obj, bool add=true)

void	RemoveObject (GameObject *obj)

void	AddObject (WorldObject *obj, uint32 type, bool add=true)

void	RemoveObject (WorldObject *obj, uint32 type)

void	AddDoor (GameObject *door, bool add=true)

void	RemoveDoor (GameObject *door)

void	AddMinion (Creature *minion, bool add=true)

void	RemoveMinion (Creature *minion)

void	UpdateDoorState (GameObject *door)

void	UpdateMinionState (Creature *minion, EncounterState state)

bool	ReadSaveDataHeaders (std::istringstream &data)

void	ReadSaveDataBossStates (std::istringstream &data)

void	ReadSavePersistentData (std::istringstream &data)

virtual void	ReadSaveDataMore (std::istringstream &)

void	WriteSaveDataHeaders (std::ostringstream &data)

void	WriteSaveDataBossStates (std::ostringstream &data)

void	WritePersistentData (std::ostringstream &data)

virtual void	WriteSaveDataMore (std::ostringstream &)

Detailed Description

Constructor & Destructor Documentation

◆ instance_ulduar_InstanceMapScript()

instance_ulduar::instance_ulduar_InstanceMapScript::instance_ulduar_InstanceMapScript ( Map * map )

inline

                                                    : InstanceScript(map)
        {
            SetHeaders(DataHeader);
            SetBossNumber(MAX_ENCOUNTER);
            SetPersistentDataCount(MAX_PERSISTENT_DATA);
            LoadDoorData(doorData);
            LoadObjectData(creatureData, gameobjectData);
            LoadSummonData(summonData);
            LoadBossBoundaries(boundaries);
            Initialize();
        };

References boundaries, creatureData, DataHeader, doorData, gameobjectData, Initialize(), InstanceScript::LoadBossBoundaries(), InstanceScript::LoadDoorData(), InstanceScript::LoadObjectData(), InstanceScript::LoadSummonData(), MAX_ENCOUNTER, MAX_PERSISTENT_DATA, InstanceScript::SetBossNumber(), InstanceScript::SetHeaders(), InstanceScript::SetPersistentDataCount(), and summonData.

Member Function Documentation

◆ AlgalonMinutesLeft()

uint32 instance_ulduar::instance_ulduar_InstanceMapScript::AlgalonMinutesLeft ( ) const

inline

        {
            uint32 now = uint32(GameTime::GetGameTime().count());
            uint32 deadline = GetPersistentData(PERSISTENT_DATA_ALGALON_DEADLINE);
            if (deadline <= now)
                return 0;
            return std::min<uint32>((deadline - now + MINUTE - 1) / MINUTE, TIMER_ALGALON_MINUTES);
        }

References GameTime::GetGameTime(), InstanceScript::GetPersistentData(), MINUTE, PERSISTENT_DATA_ALGALON_DEADLINE, and TIMER_ALGALON_MINUTES.

Referenced by Load(), and Update().

◆ CheckAchievementCriteriaMeet()

bool instance_ulduar::instance_ulduar_InstanceMapScript::CheckAchievementCriteriaMeet	(	uint32	criteria_id,
		Player const *	,
		Unit const *	,
		uint32
	)

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            uint32 mask = GetPersistentData(PERSISTENT_DATA_C_OF_ULDUAR_MASK);
            switch (criteria_id)
            {
                case 10042:
                case 10352:
                    return (mask & (1 << BOSS_LEVIATHAN)) == 0;
                case 10342:
                case 10355:
                    return (mask & (1 << BOSS_IGNIS)) == 0;
                case 10340:
                case 10353:
                    return (mask & (1 << BOSS_RAZORSCALE)) == 0;
                case 10341:
                case 10354:
                    return (mask & (1 << BOSS_XT002)) == 0;
                case 10598:
                case 10599:
                    return (mask & (1 << BOSS_ASSEMBLY)) == 0;
                case 10348:
                case 10357:
                    return (mask & (1 << BOSS_KOLOGARN)) == 0;
                case 10351:
                case 10363:
                    return (mask & (1 << BOSS_AURIAYA)) == 0;
                case 10439:
                case 10719:
                    return (mask & (1 << BOSS_HODIR)) == 0;
                case 10403:
                case 10404:
                    return (mask & (1 << BOSS_THORIM)) == 0;
                case 10582:
                case 10583:
                    return (mask & (1 << BOSS_FREYA)) == 0;
                case 10347:
                case 10361:
                    return (mask & (1 << BOSS_MIMIRON)) == 0;
                case 10349:
                case 10362:
                    return (mask & (1 << BOSS_VEZAX)) == 0;
                case 10350:
                case 10364:
                    return (mask & (1 << BOSS_YOGGSARON)) == 0;
            }
            return false;
        }

References BOSS_ASSEMBLY, BOSS_AURIAYA, BOSS_FREYA, BOSS_HODIR, BOSS_IGNIS, BOSS_KOLOGARN, BOSS_LEVIATHAN, BOSS_MIMIRON, BOSS_RAZORSCALE, BOSS_THORIM, BOSS_VEZAX, BOSS_XT002, BOSS_YOGGSARON, InstanceScript::GetPersistentData(), and PERSISTENT_DATA_C_OF_ULDUAR_MASK.

◆ CheckRequiredBosses()

bool instance_ulduar::instance_ulduar_InstanceMapScript::CheckRequiredBosses	(	uint32	bossId,
		Player const *	player
	)		const

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            if (_SkipCheckRequiredBosses(player))
                return true;
 
            switch (bossId)
            {
                case BOSS_YOGGSARON:
                    if (GetBossState(BOSS_VEZAX) != DONE)
                        return false;
                    break;
                default:
                    break;
            }
 
            return true;
        }

References InstanceScript::_SkipCheckRequiredBosses(), BOSS_VEZAX, BOSS_YOGGSARON, DONE, and InstanceScript::GetBossState().

◆ DespawnLeviathanGauntlet()

void instance_ulduar::instance_ulduar_InstanceMapScript::DespawnLeviathanGauntlet ( )

inline

        {
            for (ObjectGuid const& guid : _leviathanGauntletGUIDs)
                if (Creature* creature = instance->GetCreature(guid))
                    creature->DespawnOrUnsummon(0ms, 7_days);
            _leviathanGauntletGUIDs.clear();
 
            for (ObjectGuid const& guid : _leviathanBeaconGUIDs)
                if (GameObject* beacon = instance->GetGameObject(guid))
                    beacon->SetDestructibleState(GO_DESTRUCTIBLE_DESTROYED, nullptr, true);
            _leviathanBeaconGUIDs.clear();
        }

References _leviathanBeaconGUIDs, _leviathanGauntletGUIDs, Map::GetCreature(), Map::GetGameObject(), GO_DESTRUCTIBLE_DESTROYED, and InstanceScript::instance.

Referenced by SetBossState().

◆ ExpireAlgalonCountdown()

void instance_ulduar::instance_ulduar_InstanceMapScript::ExpireAlgalonCountdown ( )

inline

        {
            SetData(DATA_ALGALON_DEFEATED, 1);
            if (Creature* algalon = GetCreature(BOSS_ALGALON))
                algalon->AI()->DoAction(ACTION_DESPAWN_ALGALON);
        }

References ACTION_DESPAWN_ALGALON, BOSS_ALGALON, DATA_ALGALON_DEFEATED, InstanceScript::GetCreature(), and SetData().

Referenced by Load(), and Update().

◆ FillInitialWorldStates()

void instance_ulduar::instance_ulduar_InstanceMapScript::FillInitialWorldStates ( WorldPackets::WorldState::InitWorldStates & packet )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            uint32 algalonTimer =
                GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
            packet.Worldstates.reserve(2);
            packet.Worldstates.emplace_back(
                WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED,
                (algalonTimer && algalonTimer <= TIMER_ALGALON_MINUTES) ? 1 : 0);
            packet.Worldstates.emplace_back(
                WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER,
                std::min<uint32>(algalonTimer, TIMER_ALGALON_MINUTES));
        }

References InstanceScript::GetPersistentData(), PERSISTENT_DATA_ALGALON_TIMER, TIMER_ALGALON_MINUTES, WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER, WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED, and WorldPackets::WorldState::InitWorldStates::Worldstates.

◆ GetData()

uint32 instance_ulduar::instance_ulduar_InstanceMapScript::GetData ( uint32 type ) const

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            switch (type)
            {
                case EVENT_TOWER_OF_LIFE_DESTROYED:
                case EVENT_TOWER_OF_STORM_DESTROYED:
                case EVENT_TOWER_OF_FROST_DESTROYED:
                case EVENT_TOWER_OF_FLAMES_DESTROYED:
                    return _leviathanTowers[type - EVENT_TOWER_OF_LIFE_DESTROYED];
 
                case DATA_MAGE_BARRIER:
                    return GetPersistentData(
                        PERSISTENT_DATA_MAGE_BARRIER);
 
                case DATA_CALL_TRAM:
                    return _mimironTramUsed;
            }
 
            return 0;
        }

References _leviathanTowers, _mimironTramUsed, DATA_CALL_TRAM, DATA_MAGE_BARRIER, EVENT_TOWER_OF_FLAMES_DESTROYED, EVENT_TOWER_OF_FROST_DESTROYED, EVENT_TOWER_OF_LIFE_DESTROYED, EVENT_TOWER_OF_STORM_DESTROYED, InstanceScript::GetPersistentData(), and PERSISTENT_DATA_MAGE_BARRIER.

◆ GetGuidData()

ObjectGuid instance_ulduar::instance_ulduar_InstanceMapScript::GetGuidData ( uint32 data ) const

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            switch (data)
            {
                // Flame Leviathan
                case DATA_REPAIR_STATION1:
                    return _repairSGUID[0];
                case DATA_REPAIR_STATION2:
                    return _repairSGUID[1];
 
            }
 
            return GetObjectGuid(data);
        }

References _repairSGUID, DATA_REPAIR_STATION1, DATA_REPAIR_STATION2, and InstanceScript::GetObjectGuid().

◆ GetHodirChest()

GameObject * instance_ulduar::instance_ulduar_InstanceMapScript::GetHodirChest ( bool hardmode )

inline

        {
            if (hardmode)
            {
                if (GameObject* go = GetGameObject(DATA_HODIR_CHEST_HARD))
                    return go;
                return GetGameObject(DATA_HODIR_CHEST_HARD_HERO);
            }
 
            if (GameObject* go = GetGameObject(DATA_HODIR_CHEST_NORMAL))
                return go;
            return GetGameObject(DATA_HODIR_CHEST_NORMAL_HERO);
        }

References DATA_HODIR_CHEST_HARD, DATA_HODIR_CHEST_HARD_HERO, DATA_HODIR_CHEST_NORMAL, DATA_HODIR_CHEST_NORMAL_HERO, and InstanceScript::GetGameObject().

Referenced by ProcessEvent(), respawnHodirHardmodeChest(), setChestsLootable(), and SetData().

◆ Initialize()

void instance_ulduar::instance_ulduar_InstanceMapScript::Initialize ( )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            // Flame Leviathan
            for (uint8 i = 0; i < 4; ++i)
                _leviathanTowers[i] = true;
 
            _leviathanVehicles.clear();
            _leviathanVehicleMode = VEHICLE_POS_NONE;
            _leviathanVehiclesUsable = false;
            _leviathanGauntletGUIDs.clear();
            _leviathanBeaconGUIDs.clear();
            _leviathanCrewGUIDs.clear();
            _leviathanOutroSpawned = false;
            _leviathanSequenceStarted = false;
            _formationRhydianGUID.Clear();
            _leviathanMachineGUID.Clear();
 
            // Hodir
            _hmHodir = true; // If players fail the Hardmode then becomes false
 
            // Shared
            _events.Reset();
            _mimironTramUsed       = false;
            _algalonArrivalPending = false;
        }

References _algalonArrivalPending, _events, _formationRhydianGUID, _hmHodir, _leviathanBeaconGUIDs, _leviathanCrewGUIDs, _leviathanGauntletGUIDs, _leviathanMachineGUID, _leviathanOutroSpawned, _leviathanSequenceStarted, _leviathanTowers, _leviathanVehicleMode, _leviathanVehicles, _leviathanVehiclesUsable, _mimironTramUsed, ObjectGuid::Clear(), EventMap::Reset(), and VEHICLE_POS_NONE.

Referenced by instance_ulduar_InstanceMapScript().

◆ IsEncounterInProgress()

bool instance_ulduar::instance_ulduar_InstanceMapScript::IsEncounterInProgress ( ) const

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            for (uint8 i = 0; i < MAX_ENCOUNTER; ++i)
            {
                if (GetBossState(i) == IN_PROGRESS)
                    return true;
            }
 
            // Leviathan does not use IN_PROGRESS type, instead SPECIAL is set and never reset,
            // Check if he is in combat.
            if (Creature* l = instance->GetCreature(GetObjectGuid(BOSS_LEVIATHAN)))
                if (l->IsInCombat())
                    return true;
 
            return false;
        }

References BOSS_LEVIATHAN, InstanceScript::GetBossState(), Map::GetCreature(), InstanceScript::GetObjectGuid(), IN_PROGRESS, InstanceScript::instance, and MAX_ENCOUNTER.

◆ Load()

void instance_ulduar::instance_ulduar_InstanceMapScript::Load ( char const * data )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            InstanceScript::Load(data);
 
            uint32 algalonTimer =
                GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
            if (algalonTimer == TIMER_ALGALON_SUMMONED)
            {
                StorePersistentData(
                    PERSISTENT_DATA_ALGALON_TIMER,
                    TIMER_ALGALON_TO_SUMMON);
                algalonTimer = TIMER_ALGALON_TO_SUMMON;
            }
 
            if (!algalonTimer || algalonTimer > TIMER_ALGALON_MINUTES
                || GetBossState(BOSS_ALGALON) == DONE)
                return;
 
            if (!GetPersistentData(PERSISTENT_DATA_ALGALON_DEADLINE))
                StorePersistentData(PERSISTENT_DATA_ALGALON_DEADLINE,
                    uint32(GameTime::GetGameTime().count()) + algalonTimer * MINUTE);
 
            uint32 minutesLeft = AlgalonMinutesLeft();
            if (!minutesLeft)
            {
                ExpireAlgalonCountdown();
                return;
            }
 
            StorePersistentData(PERSISTENT_DATA_ALGALON_TIMER, minutesLeft);
            DoUpdateWorldState(WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED, 1);
            DoUpdateWorldState(WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER, minutesLeft);
            _events.RescheduleEvent(EVENT_UPDATE_ALGALON_TIMER, 1min);
        }

References _events, AlgalonMinutesLeft(), BOSS_ALGALON, DONE, InstanceScript::DoUpdateWorldState(), EVENT_UPDATE_ALGALON_TIMER, ExpireAlgalonCountdown(), InstanceScript::GetBossState(), GameTime::GetGameTime(), InstanceScript::GetPersistentData(), InstanceScript::Load(), MINUTE, PERSISTENT_DATA_ALGALON_DEADLINE, PERSISTENT_DATA_ALGALON_TIMER, EventMap::RescheduleEvent(), InstanceScript::StorePersistentData(), TIMER_ALGALON_MINUTES, TIMER_ALGALON_SUMMONED, TIMER_ALGALON_TO_SUMMON, WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER, and WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED.

◆ OnCreatureCreate()

void instance_ulduar::instance_ulduar_InstanceMapScript::OnCreatureCreate ( Creature * creature )

inlineoverridevirtual

These creatures are summoned by something else than Algalon but need to be controlled/despawned by him - so they need to be registered in his summon list

Reimplemented from ZoneScript.

        {
            InstanceScript::OnCreatureCreate(creature);
 
            switch (creature->GetEntry())
            {
                case NPC_KOLOGARN:
                    if (GetBossState(BOSS_KOLOGARN) == DONE)
                    {
                        creature->SetDisableGravity(true);
                        creature->SetPosition(creature->GetHomePosition());
                        creature->setDeathState(DeathState::Corpse);
                        creature->SetHealth(0);
                        creature->SetStandState(UNIT_STAND_STATE_STAND);
                        creature->ReplaceAllDynamicFlags(0);
                        creature->SetCorpseDelay(7 * DAY);
                        creature->SetCorpseRemoveTime(7 * DAY);
                        creature->SetUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
                        creature->StopMovingOnCurrentPos();
                    }
                    break;
                case NPC_ALGALON:
                {
                    uint32 algalonTimer = GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
                    if (!algalonTimer || (algalonTimer == TIMER_ALGALON_DEFEATED && GetBossState(BOSS_ALGALON) == DONE))
                    {
                        _algalonArrivalPending = false;
                        creature->DespawnOrUnsummon();
                    }
                    else if (algalonTimer == TIMER_ALGALON_DEFEATED)
                    {
                        _algalonArrivalPending = false;
                        creature->AI()->DoAction(ACTION_START_INTRO);
                        scheduler.Schedule(6s, [this, guid = creature->GetGUID()](TaskContext /*context*/)
                        {
                            if (Creature* algalon = instance->GetCreature(guid))
                                algalon->AI()->DoAction(ACTION_DESPAWN_ALGALON);
                        });
                    }
                    else if (_algalonArrivalPending)
                    {
                        _algalonArrivalPending = false;
                        creature->AI()->DoAction(ACTION_START_INTRO);
                    }
                    break;
                }
                // Gone for good once Flame Leviathan is defeated
                case NPC_STEELFORGED_DEFENDER:
                case NPC_DEFENDER_GENERATED:
                case NPC_ULDUAR_GAUNTLET_GENERATOR:
                case NPC_IRONWORK_CANNON:
                    if (IsBossDone(BOSS_LEVIATHAN))
                        creature->DespawnOrUnsummon(0ms, 7_days);
                    else
                        _leviathanGauntletGUIDs.insert(creature->GetGUID());
                    break;
                case NPC_ULDUAR_COLOSSUS:
                case NPC_RUNEFORGED_SENTRY:
                {
                    // Waypoint patrols survive the kill (sniffed); only the static spawns are cleared
                    CreatureData const* data = creature->GetCreatureData();
                    if (data && data->movementType == WAYPOINT_MOTION_TYPE)
                        break;
                    if (IsBossDone(BOSS_LEVIATHAN))
                        creature->DespawnOrUnsummon(0ms, 7_days);
                    else
                        _leviathanGauntletGUIDs.insert(creature->GetGUID());
                    break;
                }
                case NPC_ALGALON_VOID_ZONE_VISUAL_STALKER:
                case NPC_ALGALON_STALKER_ASTEROID_TARGET_01:
                case NPC_ALGALON_STALKER_ASTEROID_TARGET_02:
                case NPC_UNLEASHED_DARK_MATTER:
                    if (Creature* algalon = GetCreature(BOSS_ALGALON))
                        algalon->AI()->JustSummoned(creature);
                    break;
            }
        }

References _algalonArrivalPending, _leviathanGauntletGUIDs, ACTION_START_INTRO, Creature::AI(), BOSS_ALGALON, BOSS_KOLOGARN, BOSS_LEVIATHAN, Corpse, DAY, Creature::DespawnOrUnsummon(), UnitAI::DoAction(), DONE, InstanceScript::GetBossState(), InstanceScript::GetCreature(), Creature::GetCreatureData(), Object::GetEntry(), Object::GetGUID(), Creature::GetHomePosition(), InstanceScript::GetPersistentData(), InstanceScript::IsBossDone(), CreatureData::movementType, NPC_ALGALON, NPC_ALGALON_STALKER_ASTEROID_TARGET_01, NPC_ALGALON_STALKER_ASTEROID_TARGET_02, NPC_ALGALON_VOID_ZONE_VISUAL_STALKER, NPC_DEFENDER_GENERATED, NPC_IRONWORK_CANNON, NPC_KOLOGARN, NPC_RUNEFORGED_SENTRY, NPC_STEELFORGED_DEFENDER, NPC_ULDUAR_COLOSSUS, NPC_ULDUAR_GAUNTLET_GENERATOR, NPC_UNLEASHED_DARK_MATTER, InstanceScript::OnCreatureCreate(), PERSISTENT_DATA_ALGALON_TIMER, Unit::ReplaceAllDynamicFlags(), TaskScheduler::Schedule(), InstanceScript::scheduler, Creature::SetCorpseDelay(), Creature::SetCorpseRemoveTime(), Creature::setDeathState(), Unit::SetDisableGravity(), Unit::SetHealth(), Creature::SetPosition(), Unit::SetStandState(), Unit::SetUnitFlag(), Unit::StopMovingOnCurrentPos(), TIMER_ALGALON_DEFEATED, UNIT_FLAG_NOT_SELECTABLE, UNIT_STAND_STATE_STAND, and WAYPOINT_MOTION_TYPE.

◆ OnCreatureEvade()

void instance_ulduar::instance_ulduar_InstanceMapScript::OnCreatureEvade ( Creature * creature )

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            // The map re-summons Algalon 20s after his hard-reset evade; the new one replays the arrival
            if (creature->GetEntry() == NPC_ALGALON && GetBossState(BOSS_ALGALON) != DONE)
                _algalonArrivalPending = true;
        }

References _algalonArrivalPending, BOSS_ALGALON, DONE, InstanceScript::GetBossState(), Object::GetEntry(), and NPC_ALGALON.

◆ OnGameObjectCreate()

void instance_ulduar::instance_ulduar_InstanceMapScript::OnGameObjectCreate ( GameObject * gameObject )

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            InstanceScript::OnGameObjectCreate(gameObject);
 
            if ((gameObject->GetEntry() >= GO_STORM_BEACON_FIRST && gameObject->GetEntry() <= GO_STORM_BEACON_LAST)
                || gameObject->GetEntry() == GO_STORM_BEACON_FORMATION_GROUNDS)
            {
                if (IsBossDone(BOSS_LEVIATHAN))
                {
                    // Deferred: this hook runs before the object is in world, where SetDestructibleState
                    // cannot swap the collision model and AddToWorld would re-enable collision
                    scheduler.Schedule(1ms, [this, guid = gameObject->GetGUID()](TaskContext /*context*/)
                    {
                        if (GameObject* beacon = instance->GetGameObject(guid))
                            beacon->SetDestructibleState(GO_DESTRUCTIBLE_DESTROYED, nullptr, true);
                    });
                }
                else
                    _leviathanBeaconGUIDs.insert(gameObject->GetGUID());
                return;
            }
 
            switch (gameObject->GetEntry())
            {
                // Flame Leviathan
                case GO_REPAIR_STATION_TRAP:
                    {
                        if (_repairSGUID[0])
                            _repairSGUID[1] = gameObject->GetGUID();
                        else
                            _repairSGUID[0] = gameObject->GetGUID();
                        break;
                    }
                case GO_MIMIRONS_TARGETTING_CRYSTAL:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[3][0] = gameObject->GetGUID();
                    break;
                case GO_FREYAS_TARGETTING_CRYSTAL:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[0][0] = gameObject->GetGUID();
                    break;
                case GO_HODIRS_TARGETTING_CRYSTAL:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[2][0] = gameObject->GetGUID();
                    break;
                case GO_THORIMS_TARGETTING_CRYSTAL:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[1][0] = gameObject->GetGUID();
                    break;
                case GO_MIMIRONS_GENERATOR:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[3][1] = gameObject->GetGUID();
                    break;
                case GO_FREYAS_GENERATOR:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[0][1] = gameObject->GetGUID();
                    break;
                case GO_HODIRS_GENERATOR:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[2][1] = gameObject->GetGUID();
                    break;
                case GO_THORIMS_GENERATOR:
                    OpenIfDone(BOSS_LEVIATHAN, gameObject, GO_STATE_ACTIVE);
                    _leviathanVisualTowers[1][1] = gameObject->GetGUID();
                    break;
                case GO_LEVIATHAN_DOORS:
                    if (GetBossState(BOSS_LEVIATHAN) >= DONE)
                        gameObject->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
                    break;
                case GO_ULDUAR_PROTECTIVE_BUBBLE:
                    if (GetPersistentData(PERSISTENT_DATA_MAGE_BARRIER) == MAGE_BARRIER_LOWERED
                        || GetPersistentData(PERSISTENT_DATA_LEVIATHAN_VEHICLES_USABLE) != 0
                        || IsBossDone(BOSS_LEVIATHAN))
                        gameObject->DespawnOrUnsummon(0ms, 7_days);
                    break;
                case GO_KOLOGARN_BRIDGE:
                    OpenIfDone(BOSS_KOLOGARN, gameObject, GO_STATE_READY);
                    break;
                case GO_KEEPERS_GATE:
                    if (AllBossesDone({BOSS_MIMIRON, BOSS_FREYA, BOSS_HODIR, BOSS_THORIM}))
                        gameObject->RemoveGameObjectFlag(GO_FLAG_LOCKED);
                    break;
                // Mimiron, Hodir, Vezax
                case GO_MIMIRON_ELEVATOR:
                    gameObject->EnableCollision(false);
                    break;
                case GO_SNOW_MOUND:
                    gameObject->EnableCollision(false);
                    break;
                // Hodir loot chests: spawned locked via gameobject_template_addon,
                // unlocked by setChestsLootable() when the encounter is defeated
                case GO_HODIR_CHEST_NORMAL:
                case GO_HODIR_CHEST_NORMAL_HERO:
                case GO_HODIR_CHEST_HARD:
                case GO_HODIR_CHEST_HARD_HERO:
                    if (GetBossState(BOSS_HODIR) == DONE)
                    {
                        gameObject->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                        gameObject->SetLootRecipient(instance);
                    }
                    break;
                // Mimiron Tram
                case GO_MIMIRON_TRAM:
                    if (GetBossState(BOSS_MIMIRON) == DONE)
                        _mimironTramUsed = true;
                    break;
                // Algalon the Observer
                case GO_CELESTIAL_PLANETARIUM_ACCESS_10:
                case GO_CELESTIAL_PLANETARIUM_ACCESS_25:
                    if (GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER))
                        gameObject->SetGameObjectFlag(GO_FLAG_IN_USE);
                    break;
                case GO_DOODAD_UL_SIGILDOOR_03:
                case GO_DOODAD_UL_UNIVERSEFLOOR_01:
                case GO_DOODAD_UL_UNIVERSEFLOOR_02:
                case GO_DOODAD_UL_UNIVERSEGLOBE01:
                case GO_DOODAD_UL_ULDUAR_TRAPDOOR_03:
                    gameObject->EnableCollision(false);
                    break;
                case GO_DOODAD_UL_SIGILDOOR_01:
                    if (GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER))
                        gameObject->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_DOODAD_UL_SIGILDOOR_02:
                    if (GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER))
                        gameObject->SetGoState(GO_STATE_ACTIVE);
                    break;
                // Herbs
                case 191019: // Adder's Tongue
                case 190176: // Frost Lotus
                case 190171: // Lichbloom
                case 190170: // Talandra's Rose
                case 189973: // Goldclover
                    if (GetBossState(BOSS_FREYA) == DONE)
                        gameObject->SetRespawnTime(7 * DAY);
                    break;
                // Freya Loot
                case 194324:
                case 194325:
                case 194326:
                case 194327:
                case 194328:
                case 194329:
                case 194330:
                case 194331:
                    gameObject->SetLootRecipient(instance);
                    break;
            }
        }

References _leviathanBeaconGUIDs, _leviathanVisualTowers, _mimironTramUsed, _repairSGUID, InstanceScript::AllBossesDone(), BOSS_FREYA, BOSS_HODIR, BOSS_KOLOGARN, BOSS_LEVIATHAN, BOSS_MIMIRON, BOSS_THORIM, DAY, GameObject::DespawnOrUnsummon(), DONE, GameObject::EnableCollision(), InstanceScript::GetBossState(), Object::GetEntry(), Object::GetGUID(), InstanceScript::GetPersistentData(), GO_CELESTIAL_PLANETARIUM_ACCESS_10, GO_CELESTIAL_PLANETARIUM_ACCESS_25, GO_DOODAD_UL_SIGILDOOR_01, GO_DOODAD_UL_SIGILDOOR_02, GO_DOODAD_UL_SIGILDOOR_03, GO_DOODAD_UL_ULDUAR_TRAPDOOR_03, GO_DOODAD_UL_UNIVERSEFLOOR_01, GO_DOODAD_UL_UNIVERSEFLOOR_02, GO_DOODAD_UL_UNIVERSEGLOBE01, GO_FLAG_IN_USE, GO_FLAG_LOCKED, GO_FLAG_NOT_SELECTABLE, GO_FREYAS_GENERATOR, GO_FREYAS_TARGETTING_CRYSTAL, GO_HODIR_CHEST_HARD, GO_HODIR_CHEST_HARD_HERO, GO_HODIR_CHEST_NORMAL, GO_HODIR_CHEST_NORMAL_HERO, GO_HODIRS_GENERATOR, GO_HODIRS_TARGETTING_CRYSTAL, GO_KEEPERS_GATE, GO_KOLOGARN_BRIDGE, GO_LEVIATHAN_DOORS, GO_MIMIRON_ELEVATOR, GO_MIMIRON_TRAM, GO_MIMIRONS_GENERATOR, GO_MIMIRONS_TARGETTING_CRYSTAL, GO_REPAIR_STATION_TRAP, GO_SNOW_MOUND, GO_STATE_ACTIVE, GO_STATE_ACTIVE_ALTERNATIVE, GO_STATE_READY, GO_STORM_BEACON_FIRST, GO_STORM_BEACON_FORMATION_GROUNDS, GO_STORM_BEACON_LAST, GO_THORIMS_GENERATOR, GO_THORIMS_TARGETTING_CRYSTAL, GO_ULDUAR_PROTECTIVE_BUBBLE, InstanceScript::instance, InstanceScript::IsBossDone(), MAGE_BARRIER_LOWERED, InstanceScript::OnGameObjectCreate(), OpenIfDone(), PERSISTENT_DATA_ALGALON_TIMER, PERSISTENT_DATA_LEVIATHAN_VEHICLES_USABLE, PERSISTENT_DATA_MAGE_BARRIER, GameObject::RemoveGameObjectFlag(), TaskScheduler::Schedule(), InstanceScript::scheduler, GameObject::SetGameObjectFlag(), GameObject::SetGoState(), GameObject::SetLootRecipient(), and GameObject::SetRespawnTime().

◆ OnPlayerEnter()

void instance_ulduar::instance_ulduar_InstanceMapScript::OnPlayerEnter ( Player * player )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            if (IsBossDone(BOSS_LEVIATHAN))
                SpawnLeviathanOutro(false);
            // The salvaged vehicles wait for the raid at the Expedition Base Camp, they are not tied to Brann's intro.
            // Keyed on the mode rather than on the pool being empty: a pool whose wrecks are all pending replacement
            // is empty too, and respawning over it would leave the camp with a double set once the timers fire.
            else if (GetBossState(BOSS_LEVIATHAN) != SPECIAL && _leviathanVehicleMode == VEHICLE_POS_NONE)
                SpawnLeviathanEncounterVehicles(VEHICLE_POS_START);
 
            // mimiron tram:
            if (GameObject* MimironTram = GetGameObject(DATA_MIMIRON_TRAM))
            {
                player->UpdateVisibilityOf(MimironTram);
                if (StaticTransport* t = MimironTram->ToStaticTransport())
                {
                    if (GameObject* go = GetGameObject(DATA_MIMIRON_TRAM_ROCKET_BOOSTER))
                        if (!go->GetTransport())
                            t->AddPassenger(go, true);
                    if (GameObject* go = GetGameObject(DATA_MIMIRON_ACTIVATE_TRAM))
                        if (!go->GetTransport())
                            t->AddPassenger(go, true);
                }
            }
 
            SpawnObservationRingKeepers();
 
            // Only covers an instance reload: after a wipe the map re-summons Algalon itself 20s after
            // the evade, so wait long enough for that respawn to land first.
            uint32 algalonTimer = GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
            if (!GetCreature(BOSS_ALGALON) && algalonTimer
                && (algalonTimer <= TIMER_ALGALON_MINUTES || algalonTimer == TIMER_ALGALON_TO_SUMMON)
                && !_events.HasTimeUntilEvent(EVENT_RESUMMON_ALGALON))
                _events.ScheduleEvent(EVENT_RESUMMON_ALGALON, 30s);
        }

References _events, _leviathanVehicleMode, BOSS_ALGALON, BOSS_LEVIATHAN, DATA_MIMIRON_ACTIVATE_TRAM, DATA_MIMIRON_TRAM, DATA_MIMIRON_TRAM_ROCKET_BOOSTER, EVENT_RESUMMON_ALGALON, InstanceScript::GetBossState(), InstanceScript::GetCreature(), InstanceScript::GetGameObject(), InstanceScript::GetPersistentData(), EventMap::HasTimeUntilEvent(), InstanceScript::IsBossDone(), PERSISTENT_DATA_ALGALON_TIMER, EventMap::ScheduleEvent(), SpawnLeviathanEncounterVehicles(), SpawnLeviathanOutro(), SpawnObservationRingKeepers(), SPECIAL, TIMER_ALGALON_MINUTES, TIMER_ALGALON_TO_SUMMON, GameObject::ToStaticTransport(), Player::UpdateVisibilityOf(), VEHICLE_POS_NONE, and VEHICLE_POS_START.

◆ OnUnitDeath()

void instance_ulduar::instance_ulduar_InstanceMapScript::OnUnitDeath ( Unit * unit )

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            if (Creature* creature = unit->ToCreature())
                ScheduleLeviathanVehicleRespawn(creature);
 
            // Feeds on Tears achievement
            if (unit->IsPlayer())
            {
                if (GetBossState(BOSS_ALGALON) == IN_PROGRESS)
                    if (Creature* algalon = GetCreature(BOSS_ALGALON))
                        algalon->AI()->DoAction(ACTION_FEEDS_ON_TEARS_FAILED);
            }
            else if (unit->IsCreature() && unit->GetAreaId() == AREA_THE_CONSERVATORY_OF_LIFE)
            {
                uint32 conspeedatory =
                    GetPersistentData(PERSISTENT_DATA_CONSPEEDATORY);
                if (GameTime::GetGameTime().count() > (conspeedatory + DAY))
                {
                    DoStartTimedAchievement(
                        ACHIEVEMENT_TIMED_TYPE_EVENT,
                        21597 /*CON-SPEED-ATORY_TIMED_CRITERIA*/);
                    StorePersistentData(PERSISTENT_DATA_CONSPEEDATORY,
                        GameTime::GetGameTime().count());
                }
            }
 
            // achievement Champion/Conqueror of Ulduar
            if (unit->IsPlayer())
                for (uint8 i = 0; i <= 12; ++i)
                {
                    bool inCombat = false;
                    if (i == BOSS_LEVIATHAN)
                    {
                        if (Creature* c = GetCreature(BOSS_LEVIATHAN))
                            if (c->IsInCombat())
                                inCombat = true;
                    }
                    else
                        inCombat = (GetBossState(i) == IN_PROGRESS);
 
                    uint32 mask =
                        GetPersistentData(PERSISTENT_DATA_C_OF_ULDUAR_MASK);
                    if (inCombat && (mask & (1 << i)) == 0)
                        StorePersistentData(
                            PERSISTENT_DATA_C_OF_ULDUAR_MASK,
                            mask | (1 << i));
                }
        }

References ACHIEVEMENT_TIMED_TYPE_EVENT, ACTION_FEEDS_ON_TEARS_FAILED, AREA_THE_CONSERVATORY_OF_LIFE, BOSS_ALGALON, BOSS_LEVIATHAN, DAY, InstanceScript::DoStartTimedAchievement(), WorldObject::GetAreaId(), InstanceScript::GetBossState(), InstanceScript::GetCreature(), GameTime::GetGameTime(), InstanceScript::GetPersistentData(), IN_PROGRESS, Object::IsCreature(), Object::IsPlayer(), PERSISTENT_DATA_C_OF_ULDUAR_MASK, PERSISTENT_DATA_CONSPEEDATORY, ScheduleLeviathanVehicleRespawn(), InstanceScript::StorePersistentData(), and Object::ToCreature().

◆ OpenIfDone()

void instance_ulduar::instance_ulduar_InstanceMapScript::OpenIfDone	(	uint32	encounter,
		GameObject *	go,
		GOState	state
	)

inline

        {
            if (GetBossState(encounter) == DONE)
                go->SetGoState(state);
        }

References DONE, InstanceScript::GetBossState(), and GameObject::SetGoState().

Referenced by OnGameObjectCreate().

◆ PlayBrannRhydianLine()

void instance_ulduar::instance_ulduar_InstanceMapScript::PlayBrannRhydianLine ( uint8 index )

inline

        {
            auto const& line = BrannRhydianDialogue[index];
            Creature* speaker = line.rhydian
                ? instance->GetCreature(_formationRhydianGUID)
                : GetCreature(DATA_BRANN_FORMATION_GROUNDS);
            if (speaker)
                speaker->AI()->Talk(line.textGroup);
 
            uint8 const next = static_cast<uint8>(index + 1);
            if (next < static_cast<uint8>(sizeof(BrannRhydianDialogue) / sizeof(BrannRhydianDialogue[0])))
                scheduler.Schedule(line.nextDelay, [this, next](TaskContext /*context*/)
                {
                    PlayBrannRhydianLine(next);
                });
        }

References _formationRhydianGUID, Creature::AI(), BrannRhydianDialogue, DATA_BRANN_FORMATION_GROUNDS, Map::GetCreature(), InstanceScript::GetCreature(), InstanceScript::instance, PlayBrannRhydianLine(), TaskScheduler::Schedule(), InstanceScript::scheduler, and CreatureAI::Talk().

Referenced by PlayBrannRhydianLine(), and StartLeviathanOutroSequence().

◆ ProcessEvent()

void instance_ulduar::instance_ulduar_InstanceMapScript::ProcessEvent	(	WorldObject *	,
		uint32	eventId
	)

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            // destory towers
            if (eventId >= EVENT_TOWER_OF_LIFE_DESTROYED && eventId <= EVENT_TOWER_OF_FLAMES_DESTROYED)
                SetData(eventId, 0);
            else if (eventId == EVENT_HODIR_SHATTER_CHEST)
            {
                if (GameObject* go = GetHodirChest(true))
                {
                    go->SetGoState(GO_STATE_ACTIVE);
                    scheduler.Schedule(3s, [this](TaskContext /*context*/)
                    {
                        if (GetBossState(BOSS_HODIR) != DONE)
                            SetData(TYPE_HODIR_HM_FAIL, 0);
                    });
                }
            }
        }

References BOSS_HODIR, DONE, EVENT_HODIR_SHATTER_CHEST, EVENT_TOWER_OF_FLAMES_DESTROYED, EVENT_TOWER_OF_LIFE_DESTROYED, InstanceScript::GetBossState(), GetHodirChest(), GO_STATE_ACTIVE, TaskScheduler::Schedule(), InstanceScript::scheduler, SetData(), and TYPE_HODIR_HM_FAIL.

Referenced by SetData().

◆ respawnHodirHardmodeChest()

void instance_ulduar::instance_ulduar_InstanceMapScript::respawnHodirHardmodeChest ( )

inline

        {
            if (GetBossState(BOSS_HODIR) == DONE)
                return;
 
            _hmHodir = true;
 
            if (GameObject* go = GetHodirChest(true))
                go->Respawn();
        }

References _hmHodir, BOSS_HODIR, DONE, InstanceScript::GetBossState(), and GetHodirChest().

Referenced by SetData().

◆ ScheduleLeviathanVehicleRespawn()

void instance_ulduar::instance_ulduar_InstanceMapScript::ScheduleLeviathanVehicleRespawn ( Creature * vehicle )

{
    // The Expedition Base Camp keeps its motor pool stocked. The trigger that ends it is the pool itself being
    // relocated to the Formation Grounds on the first Reset() after the boss has been engaged, not the raid
    // driving up there: for the whole first attempt wrecks are still replaced back at the camp. From the
    // relocation on, a wreck stays where it fell and only the next reset lays out a fresh set
    if (_leviathanVehicleMode != VEHICLE_POS_START)
        return;
 
    for (auto itr = _leviathanVehicles.begin(); itr != _leviathanVehicles.end(); ++itr)
    {
        if (itr->guid != vehicle->GetGUID())
            continue;
 
        uint32 entry = itr->entry;
        uint32 index = itr->index;
        _leviathanVehicles.erase(itr);
 
        // A replacement rolls out of the camp 40 seconds after the wreck has decayed
        Seconds respawnDelay = Seconds(vehicle->GetCorpseDelay()) + LEVIATHAN_VEHICLE_RESPAWN_DELAY;
        scheduler.Schedule(respawnDelay, [this, entry, index](TaskContext /*context*/)
        {
            if (_leviathanVehicleMode == VEHICLE_POS_START)
                SummonLeviathanVehicle(entry, index);
        });
 
        return;
    }
}

References Creature::GetCorpseDelay(), Object::GetGUID(), LEVIATHAN_VEHICLE_RESPAWN_DELAY, and VEHICLE_POS_START.

Referenced by OnUnitDeath().

◆ SetBossState()

bool instance_ulduar::instance_ulduar_InstanceMapScript::SetBossState	(	uint32	type,
		EncounterState	state
	)

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            if (!InstanceScript::SetBossState(type, state))
                return false;
 
            switch (type)
            {
                case BOSS_LEVIATHAN:
                    if (state == DONE)
                    {
                        instance->DoForAllPlayers([&](Player* player)
                        {
                            if (Creature* vehicleCreature = player->GetVehicleCreatureBase())
                                vehicleCreature->DespawnOrUnsummon();
                        });
 
                        if (GameObject* go = GetGameObject(DATA_LEVIATHAN_DOORS))
                            go->SetGoState(GO_STATE_ACTIVE_ALTERNATIVE);
 
                        DespawnLeviathanGauntlet();
                        SpawnLeviathanOutro(true);
                    }
                    break;
                case BOSS_MIMIRON:
                    if (state == IN_PROGRESS)
                        _mimironTramUsed = true;
                    [[fallthrough]];
                case BOSS_HODIR:
                case BOSS_THORIM:
                case BOSS_FREYA:
                    if (AllBossesDone({BOSS_MIMIRON, BOSS_FREYA, BOSS_HODIR, BOSS_THORIM}))
                    {
                        scheduler.Schedule(45s, [this](TaskContext /*context*/)
                        {
                            if (Creature* trigger = instance->SummonCreature(NPC_ANCIENT_GATE_WORLD_TRIGGER, triggerAncientGatePosition, nullptr, 10 * IN_MILLISECONDS))
                                trigger->AI()->Talk(EMOTE_ANCIENT_GATE_UNLOCKED);
                        });
                    }
                    if (type == BOSS_HODIR && state == DONE)
                        setChestsLootable(BOSS_HODIR);
                    if (state == DONE)
                        for (uint8 i = KEEPER_FREYA; i <= KEEPER_THORIM; ++i)
                            if (ObservationRingKeeperBoss[i] == type)
                                instance->SummonCreature(
                                    ObservationRingKeeperEntry[i],
                                    ObservationRingKeepersPos[i]);
                    break;
                case BOSS_YOGGSARON:
                    // Sara despawns the unchosen keepers on pull, bring them back after a wipe
                    if (state == NOT_STARTED)
                        SpawnObservationRingKeepers();
                    break;
                default:
                    break;
            }
 
            // take care of herbs
            if (type == BOSS_FREYA && state == DONE)
            {
                std::list<GameObject*> goList;
                if (Creature* freya = GetCreature(BOSS_FREYA))
                {
                    freya->GetGameObjectListWithEntryInGrid(goList, { 191019, 190176, 190171, 190170, 189973 }, 333.0f);
 
                    for (GameObject* herb : goList)
                        herb->SetRespawnTime(7 * DAY);
                }
            }
 
            if (type > BOSS_LEVIATHAN && type < MAX_ENCOUNTER && state == IN_PROGRESS)
            {
                instance->DoForAllPlayers([&](Player* player)
                {
                    if (Creature* vehicleCreature = player->GetVehicleCreatureBase())
                        vehicleCreature->DespawnOrUnsummon();
                });
            }
 
            return true;
        }

References _mimironTramUsed, InstanceScript::AllBossesDone(), BOSS_FREYA, BOSS_HODIR, BOSS_LEVIATHAN, BOSS_MIMIRON, BOSS_THORIM, BOSS_YOGGSARON, DATA_LEVIATHAN_DOORS, DAY, DespawnLeviathanGauntlet(), Map::DoForAllPlayers(), DONE, EMOTE_ANCIENT_GATE_UNLOCKED, InstanceScript::GetCreature(), InstanceScript::GetGameObject(), Unit::GetVehicleCreatureBase(), GO_STATE_ACTIVE_ALTERNATIVE, IN_MILLISECONDS, IN_PROGRESS, InstanceScript::instance, KEEPER_FREYA, KEEPER_THORIM, MAX_ENCOUNTER, NOT_STARTED, NPC_ANCIENT_GATE_WORLD_TRIGGER, ObservationRingKeeperBoss, ObservationRingKeeperEntry, ObservationRingKeepersPos, TaskScheduler::Schedule(), InstanceScript::scheduler, InstanceScript::SetBossState(), setChestsLootable(), SpawnLeviathanOutro(), SpawnObservationRingKeepers(), Map::SummonCreature(), and triggerAncientGatePosition.

◆ setChestsLootable()

void instance_ulduar::instance_ulduar_InstanceMapScript::setChestsLootable ( uint32 boss )

inline

        {
            if (boss)
            {
                switch (boss)
                {
                    case BOSS_HODIR:
                        if (_hmHodir)
                        {
                            if (GameObject* go = GetHodirChest(true))
                            {
                                go->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                go->SetLootRecipient(instance);
                            }
                        }
                        if (GameObject* go = GetHodirChest(false))
                        {
                            go->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                            go->SetLootRecipient(instance);
                        }
                        break;
                }
            }
        }

References _hmHodir, BOSS_HODIR, GetHodirChest(), GO_FLAG_NOT_SELECTABLE, and InstanceScript::instance.

Referenced by SetBossState().

◆ SetData()

void instance_ulduar::instance_ulduar_InstanceMapScript::SetData	(	uint32	type,
		uint32	data
	)

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            switch (type)
            {
                case TYPE_HODIR_HM_RESET:
                    respawnHodirHardmodeChest();
                    break;
                case TYPE_HODIR_HM_FAIL:
                    if (GameObject* go = GetHodirChest(true))
                    {
                        _hmHodir = false;
                        go->DespawnOrUnsummon(0ms, 7_days);
                    }
                    break;
                case DATA_MAGE_BARRIER:
                    StorePersistentData(
                        PERSISTENT_DATA_MAGE_BARRIER, data);
                    break;
                case EVENT_KEEPER_TELEPORTED:
                    if (Creature* sara = GetCreature(DATA_SARA))
                        sara->AI()->DoAction(ACTION_SARA_UPDATE_SUMMON_KEEPERS);
                    break;
                case EVENT_TOWER_OF_LIFE_DESTROYED:
                case EVENT_TOWER_OF_STORM_DESTROYED:
                case EVENT_TOWER_OF_FROST_DESTROYED:
                case EVENT_TOWER_OF_FLAMES_DESTROYED:
                    {
                        _leviathanTowers[type - EVENT_TOWER_OF_LIFE_DESTROYED] = data;
                        for (uint8 i = 0; i < 2; ++i)
                        {
                            if (GameObject *gameObject = instance->GetGameObject(_leviathanVisualTowers[type - EVENT_TOWER_OF_LIFE_DESTROYED][i]))
                            {
                                gameObject->SetGoState(GO_STATE_ACTIVE);
                            }
                        }
                        return;
                    }
 
                case DATA_VEHICLE_SPAWN:
                    SpawnLeviathanEncounterVehicles(data);
                    return;
                case DATA_LEVIATHAN_VEHICLES_USABLE:
                    // Archmage Pentarus has just answered Brann, the crews get a moment to reach the vehicles
                    scheduler.Schedule(3s, [this](TaskContext /*context*/)
                    {
                        UnlockLeviathanVehicles();
                    });
                    return;
                case DATA_DESPAWN_ALGALON:
                    DoUpdateWorldState(WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED, 1);
                    DoUpdateWorldState(WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER, TIMER_ALGALON_MINUTES);
                    StorePersistentData(PERSISTENT_DATA_ALGALON_TIMER, TIMER_ALGALON_MINUTES);
                    StorePersistentData(PERSISTENT_DATA_ALGALON_DEADLINE,
                        uint32(GameTime::GetGameTime().count()) + TIMER_ALGALON_MINUTES * MINUTE);
                    _events.RescheduleEvent(EVENT_UPDATE_ALGALON_TIMER, 1min);
                    return;
                case DATA_ALGALON_SUMMON_STATE:
                case DATA_ALGALON_DEFEATED:
                    DoUpdateWorldState(WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED, 0);
                    StorePersistentData(PERSISTENT_DATA_ALGALON_TIMER,
                        type == DATA_ALGALON_DEFEATED
                            ? TIMER_ALGALON_DEFEATED
                            : TIMER_ALGALON_SUMMONED);
                    StorePersistentData(PERSISTENT_DATA_ALGALON_DEADLINE, 0);
                    _events.CancelEvent(EVENT_UPDATE_ALGALON_TIMER);
                    return;
                // Achievement
                case DATA_DWARFAGEDDON:
                    DoStartTimedAchievement(ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, SPELL_DWARFAGEDDON);
                    DoUpdateAchievementCriteria(ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, SPELL_DWARFAGEDDON);
                    return;
                case DATA_CALL_TRAM:
                    if (GameObject* MimironTram = GetGameObject(DATA_MIMIRON_TRAM))
                        if (StaticTransport* t = MimironTram->ToStaticTransport())
                        {
                            if (data == 0 && t->GetGoState() == GO_STATE_ACTIVE && t->GetPathProgress() == t->GetPauseTime())
                            {
                                MimironTram->SetGoState(GO_STATE_READY);
                                if (GameObject* rocketBooster = GetGameObject(DATA_MIMIRON_TRAM_ROCKET_BOOSTER))
                                    rocketBooster->SetGoState(GO_STATE_ACTIVE);
                                if (GameObject* activateTramButton = GetGameObject(DATA_MIMIRON_ACTIVATE_TRAM))
                                    activateTramButton->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                if (GameObject* callTramCenterButton = GetGameObject(DATA_MIMIRON_CALL_TRAM_CENTER))
                                    callTramCenterButton->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                scheduler.Schedule(30s, [this](TaskContext /*context*/)
                                {
                                    if (GameObject* turnaround1 = GetGameObject(DATA_MIMIRON_TRAM_TURNAROUND_1))
                                        turnaround1->UseDoorOrButton();
                                    if (GameObject* rocketBooster = GetGameObject(DATA_MIMIRON_TRAM_ROCKET_BOOSTER))
                                        rocketBooster->SetGoState(GO_STATE_READY);
                                }).Schedule(60s, [this](TaskContext /*context*/)
                                {
                                    if (GameObject* activateTramButton = GetGameObject(DATA_MIMIRON_ACTIVATE_TRAM))
                                        activateTramButton->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                    if (GameObject* callTramMimironButton = GetGameObject(DATA_MIMIRON_CALL_TRAM_MIMIRON))
                                        callTramMimironButton->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                });
                            }
                            if (data == 1 && t->GetGoState() == GO_STATE_READY && t->GetPathProgress() == 0)
                            {
                                MimironTram->SetGoState(GO_STATE_ACTIVE);
                                if (GameObject* rocketBooster = GetGameObject(DATA_MIMIRON_TRAM_ROCKET_BOOSTER))
                                    rocketBooster->SetGoState(GO_STATE_ACTIVE);
                                if (GameObject* activateTramButton = GetGameObject(DATA_MIMIRON_ACTIVATE_TRAM))
                                    activateTramButton->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                if (GameObject* callTramMimironButton = GetGameObject(DATA_MIMIRON_CALL_TRAM_MIMIRON))
                                    callTramMimironButton->SetGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                scheduler.Schedule(33s, [this](TaskContext /*context*/)
                                {
                                    if (GameObject* turnaround2 = GetGameObject(DATA_MIMIRON_TRAM_TURNAROUND_2))
                                        turnaround2->UseDoorOrButton();
                                    if (GameObject* rocketBooster = GetGameObject(DATA_MIMIRON_TRAM_ROCKET_BOOSTER))
                                        rocketBooster->SetGoState(GO_STATE_READY);
                                }).Schedule(63s, [this](TaskContext /*context*/)
                                {
                                    if (GameObject* activateTramButton = GetGameObject(DATA_MIMIRON_ACTIVATE_TRAM))
                                        activateTramButton->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                    if (GameObject* callTramCenterButton = GetGameObject(DATA_MIMIRON_CALL_TRAM_CENTER))
                                        callTramCenterButton->RemoveGameObjectFlag(GO_FLAG_NOT_SELECTABLE);
                                });
                            }
                        }
                    break;
                case DATA_BRANN_MEMOTESAY:
                    if (Creature* cr = GetCreature(DATA_BRANN_BASE_CAMP))
                        cr->TextEmote("Go to your vehicles!", nullptr, true);
                    break;
                case DATA_BRANN_EASY_MODE:
                    ProcessEvent(nullptr, EVENT_TOWER_OF_STORM_DESTROYED);
                    ProcessEvent(nullptr, EVENT_TOWER_OF_FROST_DESTROYED);
                    ProcessEvent(nullptr, EVENT_TOWER_OF_FLAMES_DESTROYED);
                    ProcessEvent(nullptr, EVENT_TOWER_OF_LIFE_DESTROYED);
                    break;
            }
 
        }

References _events, _hmHodir, _leviathanTowers, _leviathanVisualTowers, ACHIEVEMENT_CRITERIA_TYPE_BE_SPELL_TARGET, ACHIEVEMENT_TIMED_TYPE_SPELL_TARGET, ACTION_SARA_UPDATE_SUMMON_KEEPERS, EventMap::CancelEvent(), DATA_ALGALON_DEFEATED, DATA_ALGALON_SUMMON_STATE, DATA_BRANN_BASE_CAMP, DATA_BRANN_EASY_MODE, DATA_BRANN_MEMOTESAY, DATA_CALL_TRAM, DATA_DESPAWN_ALGALON, DATA_DWARFAGEDDON, DATA_LEVIATHAN_VEHICLES_USABLE, DATA_MAGE_BARRIER, DATA_MIMIRON_ACTIVATE_TRAM, DATA_MIMIRON_CALL_TRAM_CENTER, DATA_MIMIRON_CALL_TRAM_MIMIRON, DATA_MIMIRON_TRAM, DATA_MIMIRON_TRAM_ROCKET_BOOSTER, DATA_MIMIRON_TRAM_TURNAROUND_1, DATA_MIMIRON_TRAM_TURNAROUND_2, DATA_SARA, DATA_VEHICLE_SPAWN, InstanceScript::DoStartTimedAchievement(), InstanceScript::DoUpdateAchievementCriteria(), InstanceScript::DoUpdateWorldState(), EVENT_KEEPER_TELEPORTED, EVENT_TOWER_OF_FLAMES_DESTROYED, EVENT_TOWER_OF_FROST_DESTROYED, EVENT_TOWER_OF_LIFE_DESTROYED, EVENT_TOWER_OF_STORM_DESTROYED, EVENT_UPDATE_ALGALON_TIMER, InstanceScript::GetCreature(), Map::GetGameObject(), InstanceScript::GetGameObject(), GameTime::GetGameTime(), GetHodirChest(), GO_FLAG_NOT_SELECTABLE, GO_STATE_ACTIVE, GO_STATE_READY, InstanceScript::instance, MINUTE, PERSISTENT_DATA_ALGALON_DEADLINE, PERSISTENT_DATA_ALGALON_TIMER, PERSISTENT_DATA_MAGE_BARRIER, ProcessEvent(), EventMap::RescheduleEvent(), respawnHodirHardmodeChest(), TaskScheduler::Schedule(), InstanceScript::scheduler, SpawnLeviathanEncounterVehicles(), SPELL_DWARFAGEDDON, InstanceScript::StorePersistentData(), TIMER_ALGALON_DEFEATED, TIMER_ALGALON_MINUTES, TIMER_ALGALON_SUMMONED, GameObject::ToStaticTransport(), TYPE_HODIR_HM_FAIL, TYPE_HODIR_HM_RESET, UnlockLeviathanVehicles(), WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER, and WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED.

Referenced by ExpireAlgalonCountdown(), and ProcessEvent().

◆ SpawnLeviathanEncounterVehicles()

void instance_ulduar::instance_ulduar_InstanceMapScript::SpawnLeviathanEncounterVehicles ( uint8 mode )

{
    // Retire the old set first: despawning it must not queue replacements for a set that is going away
    std::vector<LeviathanVehicle> retired;
    retired.swap(_leviathanVehicles);
    _leviathanVehicleMode = mode;
 
    for (LeviathanVehicle const& summoned : retired)
    {
        if (Creature* cr = instance->GetCreature(summoned.guid))
        {
            cr->DespawnOrUnsummon();
        }
    }
 
    if (mode >= VEHICLE_POS_NONE)
        return;
 
    // The raid may look the vehicles over on arrival, but cannot board them until the Kirin Tor say so.
    // MAGE_BARRIER_LOWERED covers lockouts saved before the unlock got its own flag.
    _leviathanVehiclesUsable = mode != VEHICLE_POS_START
        || GetPersistentData(PERSISTENT_DATA_LEVIATHAN_VEHICLES_USABLE) != 0
        || GetPersistentData(PERSISTENT_DATA_MAGE_BARRIER) == MAGE_BARRIER_LOWERED;
 
    for (uint32 i = 0; i < (instance->Is25ManRaid() ? 5u : 2u); ++i)
    {
        SummonLeviathanVehicle(NPC_SALVAGED_SIEGE_ENGINE, 15 * mode + i);
        SummonLeviathanVehicle(NPC_VEHICLE_CHOPPER, 15 * mode + i + 5);
        SummonLeviathanVehicle(NPC_SALVAGED_DEMOLISHER, 15 * mode + i + 10);
    }
}

References _leviathanVehicleMode, _leviathanVehicles, _leviathanVehiclesUsable, Map::GetCreature(), InstanceScript::GetPersistentData(), InstanceScript::instance, Map::Is25ManRaid(), MAGE_BARRIER_LOWERED, NPC_SALVAGED_DEMOLISHER, NPC_SALVAGED_SIEGE_ENGINE, NPC_VEHICLE_CHOPPER, PERSISTENT_DATA_LEVIATHAN_VEHICLES_USABLE, PERSISTENT_DATA_MAGE_BARRIER, SummonLeviathanVehicle(), VEHICLE_POS_NONE, and VEHICLE_POS_START.

Referenced by OnPlayerEnter(), and SetData().

◆ SpawnLeviathanOutro()

void instance_ulduar::instance_ulduar_InstanceMapScript::SpawnLeviathanOutro ( bool justKilled )

inline

        {
            if (_leviathanOutroSpawned)
                return;
 
            _leviathanOutroSpawned = true;
 
            std::list<TempSummon*> summons;
            instance->SummonCreatureGroup(SUMMON_GROUP_LEVIATHAN_OUTRO_RHYDIAN, &summons);
            if (!summons.empty())
                _formationRhydianGUID = summons.front()->GetGUID();
 
            summons.clear();
            instance->SummonCreatureGroup(SUMMON_GROUP_LEVIATHAN_OUTRO_MAGES, &summons);
            if (justKilled)
                for (TempSummon* mage : summons)
                    mage->CastSpell(mage, SPELL_SIMPLE_TELEPORT_VISUAL, true);
 
            summons.clear();
            instance->SummonCreatureGroup(SUMMON_GROUP_LEVIATHAN_OUTRO_BATTLE_MAGES, &summons);
            for (TempSummon* battleMage : summons)
            {
                if (justKilled)
                    battleMage->CastSpell(battleMage, SPELL_SIMPLE_TELEPORT_VISUAL, true);
                // The two by the portal sustain it; the one at the Formation Grounds teleporter does not
                if (battleMage->GetPositionX() > 200.0f)
                    battleMage->CastSpell(battleMage, SPELL_ARCANE_CHANNELING, false);
            }
 
            instance->SummonGameObjectGroup(GO_SUMMON_GROUP_LEVIATHAN_PORTAL);
 
            // The crew stands by the Leviathan gate until the sequence sends it into formation
            summons.clear();
            instance->SummonCreatureGroup(SUMMON_GROUP_LEVIATHAN_OUTRO_MARCH, &summons);
            for (TempSummon* crew : summons)
                _leviathanCrewGUIDs.push_back(crew->GetGUID());
 
            if (justKilled)
            {
                StartLeviathanOutroSequence();
                return;
            }
 
            // On later visits the landing, march and dialogue replay once someone approaches the Formation Grounds
            scheduler.Schedule(2s, [this](TaskContext context)
            {
                if (_leviathanSequenceStarted)
                    return;
 
                bool triggered = false;
                instance->DoForAllPlayers([&](Player* player)
                {
                    if (player->IsAlive() && player->GetExactDist2d(234.0f, -100.0f) < 150.0f)
                        triggered = true;
                });
 
                if (triggered)
                    StartLeviathanOutroSequence();
                else
                    context.Repeat(2s);
            });
        }

References _formationRhydianGUID, _leviathanCrewGUIDs, _leviathanOutroSpawned, _leviathanSequenceStarted, Map::DoForAllPlayers(), Position::GetExactDist2d(), GO_SUMMON_GROUP_LEVIATHAN_PORTAL, InstanceScript::instance, Unit::IsAlive(), TaskContext::Repeat(), TaskScheduler::Schedule(), InstanceScript::scheduler, SPELL_ARCANE_CHANNELING, SPELL_SIMPLE_TELEPORT_VISUAL, StartLeviathanOutroSequence(), SUMMON_GROUP_LEVIATHAN_OUTRO_BATTLE_MAGES, SUMMON_GROUP_LEVIATHAN_OUTRO_MAGES, SUMMON_GROUP_LEVIATHAN_OUTRO_MARCH, SUMMON_GROUP_LEVIATHAN_OUTRO_RHYDIAN, Map::SummonCreatureGroup(), Map::SummonGameObjectGroup(), and summons.

Referenced by OnPlayerEnter(), and SetBossState().

◆ SpawnObservationRingKeepers()

void instance_ulduar::instance_ulduar_InstanceMapScript::SpawnObservationRingKeepers ( )

inline

        {
            uint32 watchersMask =
                GetPersistentData(PERSISTENT_DATA_WATCHERS_MASK);
            for (uint8 i = KEEPER_FREYA; i <= KEEPER_THORIM; ++i)
                if (IsBossDone(ObservationRingKeeperBoss[i])
                    && !(watchersMask & (1 << i))
                    && !GetObjectGuid(ObservationRingKeeperData[i]))
                    instance->SummonCreature(
                        ObservationRingKeeperEntry[i],
                        ObservationRingKeepersPos[i]);
        }

References InstanceScript::GetObjectGuid(), InstanceScript::GetPersistentData(), InstanceScript::instance, InstanceScript::IsBossDone(), KEEPER_FREYA, KEEPER_THORIM, ObservationRingKeeperBoss, ObservationRingKeeperData, ObservationRingKeeperEntry, ObservationRingKeepersPos, PERSISTENT_DATA_WATCHERS_MASK, and Map::SummonCreature().

Referenced by OnPlayerEnter(), and SetBossState().

◆ StartLeviathanOutroSequence()

void instance_ulduar::instance_ulduar_InstanceMapScript::StartLeviathanOutroSequence ( )

inline

        {
            if (_leviathanSequenceStarted)
                return;
 
            _leviathanSequenceStarted = true;
 
            // The crew runs its sniffed column routes into the formation slots, paired by group row order
            static uint32 const marchPaths[] =
            {
                3414401, 3414402, 3414403, 3414404, 3414405, 3414406,
                3414501, 3414502, 3414503, 3414504, 3414505, 3414506
            };
            if (std::vector<TempSummonData> const* formation = sObjectMgr->GetSummonGroup(MAP_ULDUAR, SUMMONER_TYPE_MAP, SUMMON_GROUP_LEVIATHAN_OUTRO))
            {
                auto slot = formation->begin();
                uint8 pathIndex = 0;
                for (ObjectGuid const& guid : _leviathanCrewGUIDs)
                {
                    Creature* crew = instance->GetCreature(guid);
                    if (!crew)
                        continue;
                    while (slot != formation->end() && slot->entry != crew->GetEntry())
                        ++slot;
                    if (slot == formation->end() || pathIndex >= sizeof(marchPaths) / sizeof(marchPaths[0]))
                        break;
                    crew->SetHomePosition(slot->pos);
                    crew->GetMotionMaster()->MovePath(marchPaths[pathIndex], FORCED_MOVEMENT_RUN);
                    ++slot;
                    ++pathIndex;
                }
            }
            _leviathanCrewGUIDs.clear();
 
            // The machine flies its sniffed arc over the grounds and reaches the descent point at ~36s
            std::list<TempSummon*> machine;
            instance->SummonCreatureGroup(SUMMON_GROUP_LEVIATHAN_OUTRO_MACHINE, &machine);
            if (!machine.empty())
            {
                _leviathanMachineGUID = machine.front()->GetGUID();
                machine.front()->SetCanFly(true);
                machine.front()->GetMotionMaster()->MovePath(PATH_FLYING_MACHINE_APPROACH);
            }
 
            scheduler.Schedule(13s, [this](TaskContext /*context*/)
            {
                if (Creature* rhydian = instance->GetCreature(_formationRhydianGUID))
                {
                    rhydian->SetHomePosition({ 239.31581f, -123.64426f, 409.80365f, 3.104f });
                    rhydian->GetMotionMaster()->MovePath(PATH_RHYDIAN_TO_BRANN, FORCED_MOVEMENT_WALK);
                }
            }).Schedule(36s, [this](TaskContext /*context*/)
            {
                if (Creature* flyingMachine = instance->GetCreature(_leviathanMachineGUID))
                    flyingMachine->GetMotionMaster()->MoveLand(0, { 246.4216f, -80.03793f, 409.80365f });
            }).Schedule(39s, [this](TaskContext /*context*/)
            {
                std::list<TempSummon*> brann;
                instance->SummonCreatureGroup(SUMMON_GROUP_LEVIATHAN_OUTRO_BRANN, &brann);
                if (brann.empty())
                    return;
 
                if (std::vector<TempSummonData> const* formation = sObjectMgr->GetSummonGroup(MAP_ULDUAR, SUMMONER_TYPE_MAP, SUMMON_GROUP_LEVIATHAN_OUTRO))
                    for (TempSummonData const& slot : *formation)
                        if (slot.entry == NPC_BRANN_FORMATION_GROUNDS)
                        {
                            brann.front()->SetHomePosition(slot.pos);
                            break;
                        }
 
                brann.front()->GetMotionMaster()->MovePath(PATH_BRANN_FORMATION_GROUNDS, FORCED_MOVEMENT_WALK);
            }).Schedule(59500ms, [this](TaskContext /*context*/)
            {
                PlayBrannRhydianLine(0);
            });
        }

References _formationRhydianGUID, _leviathanCrewGUIDs, _leviathanMachineGUID, _leviathanSequenceStarted, FORCED_MOVEMENT_RUN, FORCED_MOVEMENT_WALK, Map::GetCreature(), Object::GetEntry(), Unit::GetMotionMaster(), InstanceScript::instance, MAP_ULDUAR, MotionMaster::MovePath(), NPC_BRANN_FORMATION_GROUNDS, PATH_BRANN_FORMATION_GROUNDS, PATH_FLYING_MACHINE_APPROACH, PATH_RHYDIAN_TO_BRANN, PlayBrannRhydianLine(), rhydian, TaskScheduler::Schedule(), InstanceScript::scheduler, Creature::SetHomePosition(), sObjectMgr, SUMMON_GROUP_LEVIATHAN_OUTRO, SUMMON_GROUP_LEVIATHAN_OUTRO_BRANN, SUMMON_GROUP_LEVIATHAN_OUTRO_MACHINE, Map::SummonCreatureGroup(), and SUMMONER_TYPE_MAP.

Referenced by SpawnLeviathanOutro().

◆ SummonLeviathanVehicle()

void instance_ulduar::instance_ulduar_InstanceMapScript::SummonLeviathanVehicle	(	uint32	entry,
		uint32	index
	)

{
    if (TempSummon* veh = instance->SummonCreature(entry, vehiclePositions[index]))
    {
        // The vehicle kit hands out the spell click on install, take it back while the barrier is still up
        if (!_leviathanVehiclesUsable)
            veh->RemoveNpcFlag(UNIT_NPC_FLAG_SPELLCLICK);
 
        _leviathanVehicles.push_back({ veh->GetGUID(), entry, index });
    }
}

References WorldObject::SummonCreature(), UNIT_NPC_FLAG_SPELLCLICK, and vehiclePositions.

Referenced by SpawnLeviathanEncounterVehicles().

◆ UnlockLeviathanVehicles()

void instance_ulduar::instance_ulduar_InstanceMapScript::UnlockLeviathanVehicles ( )

inline

        {
            _leviathanVehiclesUsable = true;
            StorePersistentData(PERSISTENT_DATA_LEVIATHAN_VEHICLES_USABLE, 1);
 
            for (LeviathanVehicle const& summoned : _leviathanVehicles)
                if (Creature* vehicle = instance->GetCreature(summoned.guid))
                    vehicle->SetNpcFlag(UNIT_NPC_FLAG_SPELLCLICK);
        }

References _leviathanVehicles, _leviathanVehiclesUsable, Map::GetCreature(), InstanceScript::instance, PERSISTENT_DATA_LEVIATHAN_VEHICLES_USABLE, InstanceScript::StorePersistentData(), and UNIT_NPC_FLAG_SPELLCLICK.

Referenced by SetData().

◆ Update()

void instance_ulduar::instance_ulduar_InstanceMapScript::Update ( uint32 diff )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            InstanceScript::Update(diff);
 
            if (_events.Empty())
                return;
 
            _events.Update(diff);
            switch (_events.ExecuteEvent())
            {
                case EVENT_UPDATE_ALGALON_TIMER:
                {
                    if (GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER) == TIMER_ALGALON_DEFEATED)
                        return;
 
                    uint32 minutesLeft = AlgalonMinutesLeft();
                    if (!minutesLeft)
                    {
                        ExpireAlgalonCountdown();
                        break;
                    }
 
                    StorePersistentData(PERSISTENT_DATA_ALGALON_TIMER, minutesLeft);
                    DoUpdateWorldState(WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER, minutesLeft);
                    _events.Repeat(1min);
                    break;
                }
                case EVENT_RESUMMON_ALGALON:
                {
                    uint32 algalonTimer = GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
                    if (GetCreature(BOSS_ALGALON) || !algalonTimer
                        || (algalonTimer > TIMER_ALGALON_MINUTES && algalonTimer != TIMER_ALGALON_TO_SUMMON))
                        break;
 
                    TempSummon* algalon = instance->SummonCreature(NPC_ALGALON, AlgalonLandPos);
                    if (!algalon)
                        break;
 
                    if (algalonTimer <= TIMER_ALGALON_MINUTES)
                    {
                        _events.RescheduleEvent(EVENT_UPDATE_ALGALON_TIMER, 1min);
                        algalon->AI()->DoAction(ACTION_INIT_ALGALON);
                    }
                    else // TIMER_ALGALON_TO_SUMMON
                    {
                        StorePersistentData(PERSISTENT_DATA_ALGALON_TIMER, TIMER_ALGALON_SUMMONED);
                        algalon->SetImmuneToPC(false);
                    }
                    break;
                }
            }
        }