instance_stratholme::instance_stratholme_InstanceMapScript Struct Reference

Inheritance diagram for instance_stratholme::instance_stratholme_InstanceMapScript:

Public Member Functions
	instance_stratholme_InstanceMapScript (Map *map)
void	Initialize () override
void	OnPlayerEnter (Player *player) override
void	OnCreatureCreate (Creature *creature) override
void	ProcessSlaughterEvent ()
void	OnUnitDeath (Unit *unit) override
void	OnGameObjectCreate (GameObject *go) override
void	CheckZiggurats ()
void	DoSpawnPlaguedCritters (uint8, Player *player)
void	SetData (uint32 type, uint32 data) override
void	ReadSaveDataMore (std::istringstream &data) override
void	WriteSaveDataMore (std::ostringstream &data) override
uint32	GetData (uint32 type) const override
void	Update (uint32 diff) override
Public Member Functions inherited from InstanceScript
	InstanceScript (Map *map)
	~InstanceScript () override
virtual void	Initialize ()
virtual void	Load (char const *data)
virtual void	CreatureLooted (Creature *, LootType)
virtual std::string	GetSaveData ()
void	SaveToDB ()
virtual void	Update (uint32)
virtual bool	IsEncounterInProgress () const
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	OnPlayerEnter (Player *)
virtual void	OnPlayerAreaUpdate (Player *, uint32, uint32)
void	HandleGameObject (ObjectGuid guid, bool open, GameObject *go=nullptr)
void	DoUseDoorOrButton (ObjectGuid guid, uint32 withRestoreTime=0, bool useAlternativeState=false)
void	DoRespawnGameObject (ObjectGuid guid, uint32 timeToDespawn=MINUTE)
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 ()
virtual bool	SetBossState (uint32 id, EncounterState state)
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)
virtual bool	CheckAchievementCriteriaMeet (uint32, Player const *, Unit const *=nullptr, uint32=0)
virtual bool	CheckRequiredBosses (uint32, Player const *=nullptr) const
void	SetCompletedEncountersMask (uint32 newMask, bool save)
uint32	GetCompletedEncounterMask () const
void	SendEncounterUnit (uint32 type, Unit *unit=nullptr, uint8 param1=0, uint8 param2=0)
virtual void	FillInitialWorldStates (WorldPacket &)
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)
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	OnCreatureCreate (Creature *)
virtual void	OnCreatureRemove (Creature *)
virtual void	OnGameObjectCreate (GameObject *)
virtual void	OnGameObjectRemove (GameObject *)
virtual void	OnUnitDeath (Unit *)
virtual void	OnCreatureEvade (Creature *)
virtual ObjectGuid	GetGuidData (uint32) const
virtual void	SetGuidData (uint32, ObjectGuid)
virtual uint64	GetData64 (uint32) const
virtual void	SetData64 (uint32, uint64)
virtual uint32	GetData (uint32) const
virtual void	SetData (uint32, uint32)
virtual void	ProcessEvent (WorldObject *, uint32)

Private Member Functions
void	gate_delay (int gate)
void	gate_critter_delay (int gate)

Private Attributes
uint32	_baronRunProgress
uint32	_baronRunTime
uint32	_zigguratState1
uint32	_zigguratState2
uint32	_zigguratState3
uint32	_slaughterProgress
uint32	_slaughterNPCs
uint32	_postboxesOpened
EventMap	events
ObjectGuid	_zigguratDoorsGUID1
ObjectGuid	_zigguratDoorsGUID2
ObjectGuid	_zigguratDoorsGUID3
ObjectGuid	_zigguratDoorsGUID4
ObjectGuid	_zigguratDoorsGUID5
ObjectGuid	_slaughterGateGUID
ObjectGuid	_gauntletGateGUID
ObjectGuid	_baronRivendareGUID
bool	_gateTrapsCooldown [2]
ObjectGuid	_trappedPlayerGUID
ObjectGuid	_trapGatesGUIDs [4]

Additional Inherited Members
Static Public Member Functions inherited from InstanceScript
static std::string	GetBossStateName (uint8 state)
Public Attributes inherited from InstanceScript
Map *	instance
TaskScheduler	scheduler
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	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_stratholme_InstanceMapScript()

instance_stratholme::instance_stratholme_InstanceMapScript::instance_stratholme_InstanceMapScript ( Map *  map )

inline

                                                        : InstanceScript(map)
        {
            SetHeaders(DataHeader);
        }

References DataHeader, and InstanceScript::SetHeaders().

Member Function Documentation

CheckZiggurats()

void instance_stratholme::instance_stratholme_InstanceMapScript::CheckZiggurats ( )

inline

        {
            if (_zigguratState1 == 2 && _zigguratState2 == 2 && _zigguratState3 == 2)
            {
                instance->LoadGrid(4035.83f, -3336.31f);
                if (Creature* baron = instance->GetCreature(_baronRivendareGUID))
                    baron->AI()->Talk(SAY_BRAON_ZIGGURAT_FALL_YELL);
 
                if (GameObject* gate = instance->GetGameObject(_gauntletGateGUID))
                    gate->SetGoState(GO_STATE_ACTIVE);
                if (GameObject* gate = instance->GetGameObject(_slaughterGateGUID))
                    gate->SetGoState(GO_STATE_ACTIVE);
            }
        }

References _baronRivendareGUID, _gauntletGateGUID, _slaughterGateGUID, _zigguratState1, _zigguratState2, _zigguratState3, Map::GetCreature(), Map::GetGameObject(), GO_STATE_ACTIVE, InstanceScript::instance, Map::LoadGrid(), and SAY_BRAON_ZIGGURAT_FALL_YELL.

Referenced by SetData().

DoSpawnPlaguedCritters()

void instance_stratholme::instance_stratholme_InstanceMapScript::DoSpawnPlaguedCritters ( uint8  , Player *  player  )

inline

        {
            if (!player)
                return;
 
            uint32 uiEntry = aPlaguedCritters[urand(0, 2)];
            for (uint8 i = 0; i < 30; ++i)
            {
                float x, y, z;
                const Position pPos = { player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetOrientation() };
                player->GetRandomPoint(pPos, 8.0f, x, y, z);
                z = player->GetPositionZ() + 1;
                player->SummonCreature(uiEntry, x, y, z, 0, TEMPSUMMON_DEAD_DESPAWN, 0)->AI()->AttackStart(player);
            }
        }

References Creature::AI(), aPlaguedCritters, UnitAI::AttackStart(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Position::GetPositionZ(), WorldObject::GetRandomPoint(), WorldObject::SummonCreature(), TEMPSUMMON_DEAD_DESPAWN, and urand().

Referenced by gate_critter_delay().

gate_critter_delay()

void instance_stratholme::instance_stratholme_InstanceMapScript::gate_critter_delay ( int  gate )

inlineprivate

        {
            if (_trappedPlayerGUID)
            {
                if (Player* pPlayer = ObjectAccessor::GetPlayer(instance, _trappedPlayerGUID))
                {
                    DoSpawnPlaguedCritters(gate, pPlayer);
                }
            }
        }

References _trappedPlayerGUID, DoSpawnPlaguedCritters(), ObjectAccessor::GetPlayer(), and InstanceScript::instance.

Referenced by Update().

gate_delay()

void instance_stratholme::instance_stratholme_InstanceMapScript::gate_delay ( int  gate )

inlineprivate

        {
            if (_trapGatesGUIDs[2 * gate])
            {
                DoUseDoorOrButton(_trapGatesGUIDs[2 * gate]);
            }
            if (_trapGatesGUIDs[2 * gate + 1])
            {
                DoUseDoorOrButton(_trapGatesGUIDs[2 * gate + 1]);
            }
        }

References _trapGatesGUIDs, and InstanceScript::DoUseDoorOrButton().

Referenced by Update().

GetData()

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::GetData ( uint32  type ) const

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            switch (type)
            {
                case TYPE_ZIGGURAT1:
                    return _zigguratState1;
                case TYPE_ZIGGURAT2:
                    return _zigguratState2;
                case TYPE_ZIGGURAT3:
                    return _zigguratState3;
                case TYPE_MALLOW:
                    return _postboxesOpened;
            }
            return 0;
        }

References _postboxesOpened, _zigguratState1, _zigguratState2, _zigguratState3, TYPE_MALLOW, TYPE_ZIGGURAT1, TYPE_ZIGGURAT2, and TYPE_ZIGGURAT3.

Referenced by OnGameObjectCreate().

Initialize()

void instance_stratholme::instance_stratholme_InstanceMapScript::Initialize ( )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            _baronRunProgress = 0;
            _baronRunTime = 0;
            _zigguratState1 = 0;
            _zigguratState2 = 0;
            _zigguratState3 = 0;
            _slaughterProgress = 0;
            _slaughterNPCs = 0;
            _postboxesOpened = 0;
 
            _gateTrapsCooldown[0] = false;
            _gateTrapsCooldown[1] = false;
 
            events.Reset();
        }

References _baronRunProgress, _baronRunTime, _gateTrapsCooldown, _postboxesOpened, _slaughterNPCs, _slaughterProgress, _zigguratState1, _zigguratState2, and _zigguratState3.

OnCreatureCreate()

void instance_stratholme::instance_stratholme_InstanceMapScript::OnCreatureCreate ( Creature *  creature )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            switch (creature->GetEntry())
            {
                case NPC_BARON_RIVENDARE:
                    _baronRivendareGUID = creature->GetGUID();
                    break;
                case NPC_VENOM_BELCHER:
                case NPC_BILE_SPEWER:
                    if (_slaughterProgress == 0)
                        ++_slaughterNPCs;
                    break;
                case NPC_RAMSTEIN_THE_GORGER:
                    if (_slaughterProgress == 1)
                        ++_slaughterNPCs;
                    break;
                case NPC_MINDLESS_UNDEAD:
                    if (_slaughterProgress == 2)
                        ++_slaughterNPCs;
                    break;
                case NPC_BLACK_GUARD:
                    if (_slaughterProgress == 3)
                        ++_slaughterNPCs;
                    break;
            }
        }

References _baronRivendareGUID, _slaughterNPCs, _slaughterProgress, Object::GetEntry(), Object::GetGUID(), NPC_BARON_RIVENDARE, NPC_BILE_SPEWER, NPC_BLACK_GUARD, NPC_MINDLESS_UNDEAD, NPC_RAMSTEIN_THE_GORGER, and NPC_VENOM_BELCHER.

OnGameObjectCreate()

void instance_stratholme::instance_stratholme_InstanceMapScript::OnGameObjectCreate ( GameObject *  go )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            switch (go->GetEntry())
            {
                case GO_CRUSADER_SQUARE_DOOR:
                case GO_HOARD_DOOR:
                case GO_HALL_OF_HIGH_COMMAND:
                case GO_GAUNTLET_DOOR_1:
                case GO_GAUNTLET_DOOR_2:
                    go->UpdateSaveToDb(true);
                    break;
                case GO_ZIGGURAT_DOORS1:
                    go->UpdateSaveToDb(true);
                    _zigguratDoorsGUID1 = go->GetGUID();
                    if (GetData(TYPE_ZIGGURAT1) >= 1)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_ZIGGURAT_DOORS2:
                    go->UpdateSaveToDb(true);
                    _zigguratDoorsGUID2 = go->GetGUID();
                    if (GetData(TYPE_ZIGGURAT2) >= 1)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_ZIGGURAT_DOORS3:
                    go->UpdateSaveToDb(true);
                    _zigguratDoorsGUID3 = go->GetGUID();
                    if (GetData(TYPE_ZIGGURAT3) >= 1)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_GAUNTLET_GATE:
                    go->UpdateSaveToDb(true);
                    _gauntletGateGUID = go->GetGUID();
                    if (_zigguratState1 == 2 && _zigguratState2 == 2 && _zigguratState3 == 2)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_SLAUGTHER_GATE:
                    go->UpdateSaveToDb(true);
                    _slaughterGateGUID = go->GetGUID();
                    if (_zigguratState1 == 2 && _zigguratState2 == 2 && _zigguratState3 == 2)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_ZIGGURAT_DOORS4:
                    go->UpdateSaveToDb(true);
                    _zigguratDoorsGUID4 = go->GetGUID();
                    if (_slaughterProgress == 4)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_ZIGGURAT_DOORS5:
                    go->UpdateSaveToDb(true);
                    _zigguratDoorsGUID5 = go->GetGUID();
                    if (_slaughterProgress == 4)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_SLAUGHTER_GATE_SIDE:
                    go->UpdateSaveToDb(true);
                    if (_slaughterProgress >= 2)
                        go->SetGoState(GO_STATE_ACTIVE);
                    break;
                case GO_PORT_TRAP_GATE_1:
                    go->UpdateSaveToDb(true);
                    _trapGatesGUIDs[0] = go->GetGUID();
                    break;
                case GO_PORT_TRAP_GATE_2:
                    go->UpdateSaveToDb(true);
                    _trapGatesGUIDs[1] = go->GetGUID();
                    break;
                case GO_PORT_TRAP_GATE_3:
                    go->UpdateSaveToDb(true);
                    _trapGatesGUIDs[2] = go->GetGUID();
                    break;
                case GO_PORT_TRAP_GATE_4:
                    go->UpdateSaveToDb(true);
                    _trapGatesGUIDs[3] = go->GetGUID();
                    break;
            }
        }

References _gauntletGateGUID, _slaughterGateGUID, _slaughterProgress, _trapGatesGUIDs, _zigguratDoorsGUID1, _zigguratDoorsGUID2, _zigguratDoorsGUID3, _zigguratDoorsGUID4, _zigguratDoorsGUID5, _zigguratState1, _zigguratState2, _zigguratState3, GetData(), Object::GetEntry(), Object::GetGUID(), GO_CRUSADER_SQUARE_DOOR, GO_GAUNTLET_DOOR_1, GO_GAUNTLET_DOOR_2, GO_GAUNTLET_GATE, GO_HALL_OF_HIGH_COMMAND, GO_HOARD_DOOR, GO_PORT_TRAP_GATE_1, GO_PORT_TRAP_GATE_2, GO_PORT_TRAP_GATE_3, GO_PORT_TRAP_GATE_4, GO_SLAUGHTER_GATE_SIDE, GO_SLAUGTHER_GATE, GO_STATE_ACTIVE, GO_ZIGGURAT_DOORS1, GO_ZIGGURAT_DOORS2, GO_ZIGGURAT_DOORS3, GO_ZIGGURAT_DOORS4, GO_ZIGGURAT_DOORS5, GameObject::SetGoState(), TYPE_ZIGGURAT1, TYPE_ZIGGURAT2, TYPE_ZIGGURAT3, and GameObject::UpdateSaveToDb().

OnPlayerEnter()

void instance_stratholme::instance_stratholme_InstanceMapScript::OnPlayerEnter ( Player *  player )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            if (_baronRunTime > 0)
                if (Aura* aura = player->AddAura(SPELL_BARON_ULTIMATUM, player))
                    aura->SetDuration(_baronRunTime * MINUTE * IN_MILLISECONDS);
        }

References _baronRunTime, Unit::AddAura(), IN_MILLISECONDS, MINUTE, and SPELL_BARON_ULTIMATUM.

OnUnitDeath()

void instance_stratholme::instance_stratholme_InstanceMapScript::OnUnitDeath ( Unit *  unit )

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            switch (unit->GetEntry())
            {
                case NPC_VENOM_BELCHER:
                case NPC_BILE_SPEWER:
                case NPC_RAMSTEIN_THE_GORGER:
                case NPC_MINDLESS_UNDEAD:
                case NPC_BLACK_GUARD:
                    if (--_slaughterNPCs == 0)
                    {
                        ++_slaughterProgress;
                        ProcessSlaughterEvent();
                        SaveToDB();
                    }
                    break;
                case NPC_BARON_RIVENDARE:
                    events.CancelEvent(EVENT_BARON_TIME);
                    DoRemoveAurasDueToSpellOnPlayers(SPELL_BARON_ULTIMATUM);
                    break;
            }
        }

References _slaughterNPCs, _slaughterProgress, InstanceScript::DoRemoveAurasDueToSpellOnPlayers(), EVENT_BARON_TIME, Object::GetEntry(), NPC_BARON_RIVENDARE, NPC_BILE_SPEWER, NPC_BLACK_GUARD, NPC_MINDLESS_UNDEAD, NPC_RAMSTEIN_THE_GORGER, NPC_VENOM_BELCHER, ProcessSlaughterEvent(), InstanceScript::SaveToDB(), and SPELL_BARON_ULTIMATUM.

ProcessSlaughterEvent()

void instance_stratholme::instance_stratholme_InstanceMapScript::ProcessSlaughterEvent ( )

inline

        {
            if (_slaughterProgress == 1)
            {
                if (Creature* baron = instance->GetCreature(_baronRivendareGUID))
                    baron->AI()->Talk(SAY_BRAON_SUMMON_RAMSTEIN);
 
                Position pos = {4032.20f, -3378.06f, 119.75f, 4.67f};
                instance->SummonCreature(NPC_RAMSTEIN_THE_GORGER, pos);
            }
            if (_slaughterProgress == 2)
            {
                for (uint32 i = 0; i < 33; ++i)
                    events.ScheduleEvent(EVENT_SPAWN_MINDLESS, 5000 + i * 210);
                if (Creature* baron = instance->GetCreature(_baronRivendareGUID))
                    if (GameObject* gate = baron->FindNearestGameObject(GO_SLAUGHTER_GATE_SIDE, 200.0f))
                        gate->SetGoState(GO_STATE_ACTIVE);
            }
            if (_slaughterProgress == 3)
            {
                events.ScheduleEvent(EVENT_SPAWN_BLACK_GUARD, 20000);
            }
            if (_slaughterProgress == 4)
            {
                if (Creature* baron = instance->GetCreature(_baronRivendareGUID))
                    baron->AI()->Talk(SAY_BARON_GUARD_DEAD);
                if (GameObject* gate = instance->GetGameObject(_zigguratDoorsGUID5))
                    gate->SetGoState(GO_STATE_ACTIVE);
            }
        }

References _baronRivendareGUID, _slaughterProgress, _zigguratDoorsGUID5, Creature::AI(), EVENT_SPAWN_BLACK_GUARD, EVENT_SPAWN_MINDLESS, WorldObject::FindNearestGameObject(), Map::GetCreature(), Map::GetGameObject(), GO_SLAUGHTER_GATE_SIDE, GO_STATE_ACTIVE, InstanceScript::instance, NPC_RAMSTEIN_THE_GORGER, SAY_BARON_GUARD_DEAD, SAY_BRAON_SUMMON_RAMSTEIN, Map::SummonCreature(), and CreatureAI::Talk().

Referenced by OnUnitDeath(), and Update().

ReadSaveDataMore()

void instance_stratholme::instance_stratholme_InstanceMapScript::ReadSaveDataMore ( std::istringstream &  data )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            data >> _baronRunProgress;
            data >> _baronRunTime;
            data >> _zigguratState1;
            data >> _zigguratState2;
            data >> _zigguratState3;
            data >> _slaughterProgress;
            data >> _postboxesOpened;
 
            if (_baronRunTime)
            {
                events.ScheduleEvent(EVENT_BARON_TIME, 60000);
            }
 
            if (_slaughterProgress > 0 && _slaughterProgress < 4)
            {
                events.ScheduleEvent(EVENT_FORCE_SLAUGHTER_EVENT, 5000);
            }
        }

References _baronRunProgress, _baronRunTime, _postboxesOpened, _slaughterProgress, _zigguratState1, _zigguratState2, _zigguratState3, EVENT_BARON_TIME, and EVENT_FORCE_SLAUGHTER_EVENT.

SetData()

void instance_stratholme::instance_stratholme_InstanceMapScript::SetData ( uint32  type, uint32  data  )

inlineoverridevirtual

Reimplemented from ZoneScript.

        {
            switch (type)
            {
                case TYPE_BARON_RUN:
                    {
                        if (_baronRunProgress == DATA_BARON_RUN_NONE)
                        {
                            _baronRunProgress = DATA_BARON_RUN_GATE;
                            _baronRunTime = 45;
                            DoCastSpellOnPlayers(SPELL_BARON_ULTIMATUM);
                            events.ScheduleEvent(EVENT_BARON_TIME, 60000);
 
                            instance->LoadGrid(4035.83f, -3336.31f);
                            if (Creature* baron = instance->GetCreature(_baronRivendareGUID))
                                baron->AI()->Talk(SAY_BARON_INIT_YELL);
                        }
                        break;
                    }
                case TYPE_ZIGGURAT1:
                    {
                        if (data == _zigguratState1 + 1)
                            ++_zigguratState1;
 
                        if (_zigguratState1 == 1)
                            if (GameObject* ziggurat = instance->GetGameObject(_zigguratDoorsGUID1))
                                ziggurat->SetGoState(GO_STATE_ACTIVE);
 
                        CheckZiggurats();
                        break;
                    }
                case TYPE_ZIGGURAT2:
                    {
                        if (data == _zigguratState2 + 1)
                            ++_zigguratState2;
 
                        if (_zigguratState2 == 1)
                            if (GameObject* ziggurat = instance->GetGameObject(_zigguratDoorsGUID2))
                                ziggurat->SetGoState(GO_STATE_ACTIVE);
 
                        CheckZiggurats();
                        break;
                    }
                case TYPE_ZIGGURAT3:
                    {
                        if (data == _zigguratState3 + 1)
                            ++_zigguratState3;
 
                        if (_zigguratState3 == 1)
                            if (GameObject* ziggurat = instance->GetGameObject(_zigguratDoorsGUID3))
                                ziggurat->SetGoState(GO_STATE_ACTIVE);
 
                        CheckZiggurats();
                        break;
                    }
                case TYPE_BARON_FIGHT:
                    {
                        if (GameObject* gate = instance->GetGameObject(_zigguratDoorsGUID5))
                            gate->SetGoState(data == IN_PROGRESS ? GO_STATE_READY : GO_STATE_ACTIVE);
                        return;
                    }
                case TYPE_MALLOW:
                    ++_postboxesOpened;
                    break;
            }
 
            SaveToDB();
        }

References _baronRivendareGUID, _baronRunProgress, _baronRunTime, _postboxesOpened, _zigguratDoorsGUID1, _zigguratDoorsGUID2, _zigguratDoorsGUID3, _zigguratDoorsGUID5, _zigguratState1, _zigguratState2, _zigguratState3, CheckZiggurats(), DATA_BARON_RUN_GATE, DATA_BARON_RUN_NONE, InstanceScript::DoCastSpellOnPlayers(), EVENT_BARON_TIME, Map::GetCreature(), Map::GetGameObject(), GO_STATE_ACTIVE, GO_STATE_READY, IN_PROGRESS, InstanceScript::instance, Map::LoadGrid(), InstanceScript::SaveToDB(), SAY_BARON_INIT_YELL, SPELL_BARON_ULTIMATUM, TYPE_BARON_FIGHT, TYPE_BARON_RUN, TYPE_MALLOW, TYPE_ZIGGURAT1, TYPE_ZIGGURAT2, and TYPE_ZIGGURAT3.

Update()

void instance_stratholme::instance_stratholme_InstanceMapScript::Update ( uint32  diff )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            events.Update(diff);
 
            Map::PlayerList const& players = instance->GetPlayers();
            // Loop over the two Gate traps, each one has up to three timers (trap reset, gate opening delay, critters spawning delay)
            for (uint8 i = 0; i < 2; i++)
            {
                // if the gate is in cooldown, skip the other checks
                if (_gateTrapsCooldown[i])
                    break;
 
                // Check that the trap is not on cooldown, if so check if player/pet is in range
                for (Map::PlayerList::const_iterator itr = players.begin(); itr != players.end(); ++itr)
                {
                    if (Player* player = itr->GetSource())
                    {
                        // should pet also trigger the trap? could not find any source for it
                        if (!player->IsGameMaster() && player->IsWithinDist2d(aGateTrap[i].m_positionX, aGateTrap[i].m_positionY, 5.5f))
                        {
                            // Check if timer was not already set by another player/pet a few milliseconds before
                            if (_gateTrapsCooldown[i])
                                return;
 
                            _gateTrapsCooldown[i] = true;
 
                            // close the gates
                            if (_trapGatesGUIDs[2 * i])
                                DoUseDoorOrButton(_trapGatesGUIDs[2 * i]);
                            if (_trapGatesGUIDs[2 * i + 1])
                                DoUseDoorOrButton(_trapGatesGUIDs[2 * i + 1]);
 
                            _trappedPlayerGUID = player->GetGUID();
 
                            if (i == 0)
                            {
                                // set timer to reset the trap
                                events.ScheduleEvent(EVENT_GATE1_TRAP, 30 * MINUTE * IN_MILLISECONDS);
                                // set timer to reopen gates
                                events.ScheduleEvent(EVENT_GATE1_DELAY, 20 * IN_MILLISECONDS);
                                // set timer to spawn the plagued critters
                                events.ScheduleEvent(EVENT_GATE1_CRITTER_DELAY, 2 * IN_MILLISECONDS);
                            }
                            else if (i == 1)
                            {
                                // set timer to reset the trap
                                events.ScheduleEvent(EVENT_GATE2_TRAP, 30 * MINUTE * IN_MILLISECONDS);
                                // set timer to reopen gates
                                events.ScheduleEvent(EVENT_GATE2_DELAY, 20 * IN_MILLISECONDS);
                                // set timer to spawn the plagued critters
                                events.ScheduleEvent(EVENT_GATE2_CRITTER_DELAY, 2 * IN_MILLISECONDS);
                            }
                        }
                    }
                }
            }
 
            const int GATE1 = 0;
            const int GATE2 = 1;
 
            switch (events.ExecuteEvent())
            {
                case EVENT_GATE1_TRAP:
                    _gateTrapsCooldown[GATE1] = false;
                    break;
                case EVENT_GATE2_TRAP:
                    _gateTrapsCooldown[GATE2] = false;
                    break;
                case EVENT_GATE1_DELAY:
                    gate_delay(GATE1);
                    break;
                case EVENT_GATE2_DELAY:
                    gate_delay(GATE2);
                    break;
                case EVENT_GATE1_CRITTER_DELAY:
                    gate_critter_delay(GATE1);
                    break;
                case EVENT_GATE2_CRITTER_DELAY:
                    gate_critter_delay(GATE2);
                    break;
                case EVENT_BARON_TIME:
                    {
                        --_baronRunTime;
                        instance->LoadGrid(4035.83f, -3336.31f);
                        Creature* baron = instance->GetCreature(_baronRivendareGUID);
                        if (baron && !baron->IsInCombat())
                        {
                            switch (_baronRunTime)
                            {
                                case 10:
                                    baron->AI()->Talk(SAY_BARON_10M);
                                    break;
                                case 5:
                                    baron->AI()->Talk(SAY_BARON_5M);
                                    if (Creature* ysida = baron->FindNearestCreature(NPC_YSIDA, 50.0f))
                                        ysida->AI()->SetData(1, 1);
                                    break;
                                case 0:
                                    baron->AI()->Talk(SAY_BARON_0M);
                                    DoRemoveAurasDueToSpellOnPlayers(SPELL_BARON_ULTIMATUM);
                                    break;
                            }
                        }
 
                        if (_baronRunTime > 0)
                            events.ScheduleEvent(EVENT_BARON_TIME, 60s);
                        else
                            events.ScheduleEvent(EVENT_EXECUTE_PRISONER, 0ms);
 
                        SaveToDB();
                        break;
                    }
                case EVENT_EXECUTE_PRISONER:
                    {
                        instance->LoadGrid(4035.83f, -3336.31f);
                        Creature* baron = instance->GetCreature(_baronRivendareGUID);
                        if (baron && baron->IsAlive())
                        {
                            if (!baron->IsInCombat())
                            {
                                baron->HandleEmoteCommand(EMOTE_ONESHOT_ATTACK1H);
                                if (Creature* ysida = baron->FindNearestCreature(NPC_YSIDA, 50.0f))
                                    Unit::Kill(baron, ysida);
                            }
                            else
                                events.ScheduleEvent(EVENT_EXECUTE_PRISONER, 1s);
                        }
                        break;
                    }
                case EVENT_SPAWN_MINDLESS:
                    {
                        Position pos = {3941.75f, -3393.06f, 119.70f, 0.0f};
                        instance->SummonCreature(NPC_MINDLESS_UNDEAD, pos);
                        break;
                    }
                case EVENT_FORCE_SLAUGHTER_EVENT:
                    {
                        Map::PlayerList const& PlayerList = instance->GetPlayers();
                        if (!PlayerList.IsEmpty())
                            for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
                                if (Player* player = i->GetSource())
                                    if (player->GetDistance2d(4034.97f, -3402.13f) < 50.0f)
                                    {
                                        ProcessSlaughterEvent();
                                        return;
                                    }
 
                        events.ScheduleEvent(EVENT_FORCE_SLAUGHTER_EVENT, 3s);
                        break;
                    }
                case EVENT_SPAWN_BLACK_GUARD:
                    {
                        for (uint8 i = 0; i < 5; ++i)
                            if (Creature* guard = instance->SummonCreature(NPC_BLACK_GUARD, BlackGuardPos[i]))
                            {
                                guard->SetWalk(true);
                                guard->GetMotionMaster()->MovePoint(0, BlackGuardPos[i + 5]);
                                guard->SetHomePosition(BlackGuardPos[i + 5]);
                                if (i == 0 && guard->AI())
                                    guard->AI()->Talk(SAY_BLACK_GUARD_INIT);
                            }
 
                        if (GameObject* gate = instance->GetGameObject(_zigguratDoorsGUID4))
                            gate->SetGoState(GO_STATE_ACTIVE);
                        break;
                    }
            }
        }

References _baronRivendareGUID, _baronRunTime, _gateTrapsCooldown, _trapGatesGUIDs, _trappedPlayerGUID, _zigguratDoorsGUID4, aGateTrap, Creature::AI(), MapRefMgr::begin(), BlackGuardPos, InstanceScript::DoRemoveAurasDueToSpellOnPlayers(), InstanceScript::DoUseDoorOrButton(), EMOTE_ONESHOT_ATTACK1H, MapRefMgr::end(), EVENT_BARON_TIME, EVENT_EXECUTE_PRISONER, EVENT_FORCE_SLAUGHTER_EVENT, EVENT_GATE1_CRITTER_DELAY, EVENT_GATE1_DELAY, EVENT_GATE1_TRAP, EVENT_GATE2_CRITTER_DELAY, EVENT_GATE2_DELAY, EVENT_GATE2_TRAP, EVENT_SPAWN_BLACK_GUARD, EVENT_SPAWN_MINDLESS, WorldObject::FindNearestCreature(), gate_critter_delay(), gate_delay(), Map::GetCreature(), Map::GetGameObject(), Map::GetPlayers(), GO_STATE_ACTIVE, Unit::HandleEmoteCommand(), IN_MILLISECONDS, InstanceScript::instance, Unit::IsAlive(), LinkedListHead::IsEmpty(), Unit::IsInCombat(), Unit::Kill(), Map::LoadGrid(), Position::m_positionX, Position::m_positionY, MINUTE, NPC_BLACK_GUARD, NPC_MINDLESS_UNDEAD, NPC_YSIDA, ProcessSlaughterEvent(), InstanceScript::SaveToDB(), SAY_BARON_0M, SAY_BARON_10M, SAY_BARON_5M, SAY_BLACK_GUARD_INIT, SPELL_BARON_ULTIMATUM, Map::SummonCreature(), and CreatureAI::Talk().

WriteSaveDataMore()

void instance_stratholme::instance_stratholme_InstanceMapScript::WriteSaveDataMore ( std::ostringstream &  data )

inlineoverridevirtual

Reimplemented from InstanceScript.

        {
            data << _baronRunProgress << ' '
                << _baronRunTime << ' '
                << _zigguratState1 << ' '
                << _zigguratState2 << ' '
                << _zigguratState3 << ' '
                << _slaughterProgress << ' '
                << _postboxesOpened;
        }

References _baronRunProgress, _baronRunTime, _postboxesOpened, _slaughterProgress, _zigguratState1, _zigguratState2, and _zigguratState3.

Member Data Documentation

_baronRivendareGUID

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_baronRivendareGUID

private

Referenced by CheckZiggurats(), OnCreatureCreate(), ProcessSlaughterEvent(), SetData(), and Update().

_baronRunProgress

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_baronRunProgress

private

Referenced by Initialize(), ReadSaveDataMore(), SetData(), and WriteSaveDataMore().

_baronRunTime

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_baronRunTime

private

Referenced by Initialize(), OnPlayerEnter(), ReadSaveDataMore(), SetData(), Update(), and WriteSaveDataMore().

_gateTrapsCooldown

bool instance_stratholme::instance_stratholme_InstanceMapScript::_gateTrapsCooldown[2]

private

Referenced by Initialize(), and Update().

_gauntletGateGUID

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_gauntletGateGUID

private

Referenced by CheckZiggurats(), and OnGameObjectCreate().

_postboxesOpened

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_postboxesOpened

private

Referenced by GetData(), Initialize(), ReadSaveDataMore(), SetData(), and WriteSaveDataMore().

_slaughterGateGUID

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_slaughterGateGUID

private

Referenced by CheckZiggurats(), and OnGameObjectCreate().

_slaughterNPCs

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_slaughterNPCs

private

Referenced by Initialize(), OnCreatureCreate(), and OnUnitDeath().

_slaughterProgress

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_slaughterProgress

private

Referenced by Initialize(), OnCreatureCreate(), OnGameObjectCreate(), OnUnitDeath(), ProcessSlaughterEvent(), ReadSaveDataMore(), and WriteSaveDataMore().

_trapGatesGUIDs

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_trapGatesGUIDs[4]

private

Referenced by gate_delay(), OnGameObjectCreate(), and Update().

_trappedPlayerGUID

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_trappedPlayerGUID

private

Referenced by gate_critter_delay(), and Update().

_zigguratDoorsGUID1

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratDoorsGUID1

private

Referenced by OnGameObjectCreate(), and SetData().

_zigguratDoorsGUID2

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratDoorsGUID2

private

Referenced by OnGameObjectCreate(), and SetData().

_zigguratDoorsGUID3

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratDoorsGUID3

private

Referenced by OnGameObjectCreate(), and SetData().

_zigguratDoorsGUID4

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratDoorsGUID4

private

Referenced by OnGameObjectCreate(), and Update().

_zigguratDoorsGUID5

ObjectGuid instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratDoorsGUID5

private

Referenced by OnGameObjectCreate(), ProcessSlaughterEvent(), and SetData().

_zigguratState1

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratState1

private

Referenced by CheckZiggurats(), GetData(), Initialize(), OnGameObjectCreate(), ReadSaveDataMore(), SetData(), and WriteSaveDataMore().

_zigguratState2

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratState2

private

Referenced by CheckZiggurats(), GetData(), Initialize(), OnGameObjectCreate(), ReadSaveDataMore(), SetData(), and WriteSaveDataMore().

_zigguratState3

uint32 instance_stratholme::instance_stratholme_InstanceMapScript::_zigguratState3

private

Referenced by CheckZiggurats(), GetData(), Initialize(), OnGameObjectCreate(), ReadSaveDataMore(), SetData(), and WriteSaveDataMore().

events

EventMap instance_stratholme::instance_stratholme_InstanceMapScript::events

private