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

void	DespawnLeviathanGauntlet ()

void	UnlockLeviathanVehicles ()

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	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

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	OnCreatureEvade (Creature *)

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	_algalonResummonPending

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

◆ 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().

◆ 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 <= 60) ? 1 : 0);
            packet.Worldstates.emplace_back(
                WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER,
                std::min<uint32>(algalonTimer, 60));
        }

References InstanceScript::GetPersistentData(), PERSISTENT_DATA_ALGALON_TIMER, 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;
            _algalonResummonPending = false;
        }

References _algalonResummonPending, _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);
 
            if (!data)
                StorePersistentData(PERSISTENT_DATA_UNBROKEN, 1);
 
            uint32 algalonTimer =
                GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
            if (algalonTimer == TIMER_ALGALON_SUMMONED)
            {
                StorePersistentData(
                    PERSISTENT_DATA_ALGALON_TIMER,
                    TIMER_ALGALON_TO_SUMMON);
            }
 
            algalonTimer =
                GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
            if (algalonTimer && algalonTimer <= 60
                && GetBossState(BOSS_ALGALON) != DONE)
            {
                DoUpdateWorldState(
                    WORLD_STATE_ULDUAR_ALGALON_TIMER_ENABLED, 1);
                DoUpdateWorldState(
                    WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER,
                    algalonTimer);
            }
        }

References BOSS_ALGALON, DONE, InstanceScript::DoUpdateWorldState(), InstanceScript::GetBossState(), InstanceScript::GetPersistentData(), InstanceScript::Load(), PERSISTENT_DATA_ALGALON_TIMER, PERSISTENT_DATA_UNBROKEN, InstanceScript::StorePersistentData(), 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:
                    if (!GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER))
                        creature->DespawnOrUnsummon();
                    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 _leviathanGauntletGUIDs, BOSS_ALGALON, BOSS_KOLOGARN, BOSS_LEVIATHAN, Corpse, DAY, Creature::DespawnOrUnsummon(), 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(), Creature::SetCorpseDelay(), Creature::SetCorpseRemoveTime(), Creature::setDeathState(), Unit::SetDisableGravity(), Unit::SetHealth(), Creature::SetPosition(), Unit::SetStandState(), Unit::SetUnitFlag(), Unit::StopMovingOnCurrentPos(), UNIT_FLAG_NOT_SELECTABLE, UNIT_STAND_STATE_STAND, and WAYPOINT_MOTION_TYPE.

◆ 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);
                }
            }
 
            // Spawn Observation Ring keepers for defeated bosses
            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]);
 
            uint32 algalonTimer =
                GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
            if (!GetObjectGuid(BOSS_ALGALON) && !_algalonResummonPending && algalonTimer
                && (algalonTimer <= 60
                    || algalonTimer == TIMER_ALGALON_TO_SUMMON))
            {
                TempSummon* algalon = instance->SummonCreature(NPC_ALGALON, AlgalonLandPos);
                if (!algalon)
                    return;
 
                if (algalonTimer <= 60)
                {
                    _events.RescheduleEvent(EVENT_UPDATE_ALGALON_TIMER, 1min);
                    algalon->AI()->DoAction(ACTION_INIT_ALGALON);
                }
                else // if (algalonTimer == TIMER_ALGALON_TO_SUMMON)
                {
                    StorePersistentData(
                        PERSISTENT_DATA_ALGALON_TIMER,
                        TIMER_ALGALON_SUMMONED);
                    algalon->SetImmuneToPC(false);
                }
            }
        }

References _algalonResummonPending, _events, _leviathanVehicleMode, ACTION_INIT_ALGALON, Creature::AI(), AlgalonLandPos, BOSS_ALGALON, BOSS_LEVIATHAN, DATA_MIMIRON_ACTIVATE_TRAM, DATA_MIMIRON_TRAM, DATA_MIMIRON_TRAM_ROCKET_BOOSTER, UnitAI::DoAction(), EVENT_UPDATE_ALGALON_TIMER, InstanceScript::GetBossState(), InstanceScript::GetGameObject(), InstanceScript::GetObjectGuid(), InstanceScript::GetPersistentData(), InstanceScript::instance, InstanceScript::IsBossDone(), KEEPER_FREYA, KEEPER_THORIM, NPC_ALGALON, ObservationRingKeeperBoss, ObservationRingKeeperData, ObservationRingKeeperEntry, ObservationRingKeepersPos, PERSISTENT_DATA_ALGALON_TIMER, PERSISTENT_DATA_WATCHERS_MASK, EventMap::RescheduleEvent(), Unit::SetImmuneToPC(), SpawnLeviathanEncounterVehicles(), SpawnLeviathanOutro(), SPECIAL, InstanceScript::StorePersistentData(), Map::SummonCreature(), TIMER_ALGALON_SUMMONED, 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)
                    {
                        uint8 keeperIdx = type - BOSS_FREYA;
                        instance->SummonCreature(
                            ObservationRingKeeperEntry[keeperIdx],
                            ObservationRingKeepersPos[keeperIdx]);
                    }
                    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, DATA_LEVIATHAN_DOORS, DAY, DespawnLeviathanGauntlet(), Map::DoForAllPlayers(), DONE, EMOTE_ANCIENT_GATE_UNLOCKED, InstanceScript::GetCreature(), InstanceScript::GetGameObject(), WorldObject::GetGameObjectListWithEntryInGrid(), Unit::GetVehicleCreatureBase(), GO_STATE_ACTIVE_ALTERNATIVE, IN_MILLISECONDS, IN_PROGRESS, InstanceScript::instance, MAX_ENCOUNTER, NPC_ANCIENT_GATE_WORLD_TRIGGER, ObservationRingKeeperEntry, ObservationRingKeepersPos, TaskScheduler::Schedule(), InstanceScript::scheduler, InstanceScript::SetBossState(), setChestsLootable(), SpawnLeviathanOutro(), 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, 60);
                    StorePersistentData(PERSISTENT_DATA_ALGALON_TIMER, 60);
                    _events.RescheduleEvent(EVENT_UPDATE_ALGALON_TIMER, 1min);
                    return;
                case DATA_RESUMMON_ALGALON:
                    _algalonResummonPending = true;
                    _events.RescheduleEvent(EVENT_RESUMMON_ALGALON, 2s);
                    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);
                    _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 _algalonResummonPending, _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_RESUMMON_ALGALON, DATA_SARA, DATA_VEHICLE_SPAWN, InstanceScript::DoStartTimedAchievement(), InstanceScript::DoUpdateAchievementCriteria(), InstanceScript::DoUpdateWorldState(), EVENT_KEEPER_TELEPORTED, EVENT_RESUMMON_ALGALON, 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(), GetHodirChest(), GO_FLAG_NOT_SELECTABLE, GO_STATE_ACTIVE, GO_STATE_READY, InstanceScript::instance, 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_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 ProcessEvent(), and Update().

◆ 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().

◆ 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:
                {
                    uint32 algalonTimer =
                        GetPersistentData(PERSISTENT_DATA_ALGALON_TIMER);
                    if (algalonTimer == TIMER_ALGALON_DEFEATED)
                        return;
 
                    StorePersistentData(
                        PERSISTENT_DATA_ALGALON_TIMER,
                        --algalonTimer);
                    DoUpdateWorldState(
                        WORLD_STATE_ULDUAR_ALGALON_DESPAWN_TIMER,
                        algalonTimer);
                    if (algalonTimer)
                    {
                        _events.Repeat(1min);
                        return;
                    }
 
                    SetData(DATA_ALGALON_DEFEATED, 1);
                    if (Creature* algalon = GetCreature(BOSS_ALGALON))
                        algalon->AI()->DoAction(ACTION_DESPAWN_ALGALON);
                    break;
                }
                case EVENT_RESUMMON_ALGALON:
                    _algalonResummonPending = false;
                    if (!GetCreature(BOSS_ALGALON))
                        if (Creature* algalon = instance->SummonCreature(NPC_ALGALON, AlgalonSummonPos))
                            algalon->AI()->DoAction(ACTION_START_INTRO);
                    break;
            }
        }