WorldState Class Reference

#include "WorldState.h"

Public Member Functions
	WorldState ()
virtual	~WorldState ()
void	Load ()
void	LoadWorldStates ()
void	setWorldState (uint32 index, uint64 value)
uint64	getWorldState (uint32 index) const
void	Save (WorldStateSaveIds saveId)
void	SaveHelper (std::string &stringToSave, WorldStateSaveIds saveId)
void	HandlePlayerEnterZone (Player *player, AreaTableIDs zoneId)
void	HandlePlayerLeaveZone (Player *player, AreaTableIDs zoneId)
bool	IsConditionFulfilled (WorldStateCondition conditionId, WorldStateConditionState state=WORLD_STATE_CONDITION_STATE_NONE) const
void	HandleConditionStateChange (WorldStateCondition conditionId, WorldStateConditionState state)
void	HandleExternalEvent (WorldStateEvent eventId, uint32 param)
void	Update (uint32 diff)
void	AddSunwellGateProgress (uint32 questId)
void	AddSunsReachProgress (uint32 questId)
std::string	GetSunsReachPrintout ()
void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &packet, uint32 zoneId, uint32)
void	HandleSunsReachPhaseTransition (uint32 newPhase)
void	HandleSunsReachSubPhaseTransition (int32 subPhaseMask, bool initial=false)
void	SetSunsReachCounter (SunsReachCounters index, uint32 value)
void	HandleSunwellGateTransition (uint32 newGate)
void	SetSunwellGateCounter (SunwellGateCounters index, uint32 value)

Static Public Member Functions
static WorldState *	instance ()

Private Types
typedef std::map< uint32, uint64 >	WorldStatesMap

Private Member Functions
void	SendWorldstateUpdate (std::mutex &mutex, GuidVector const &guids, uint32 value, uint32 worldStateId)
void	StopSunsReachPhase (bool forward)
void	StartSunsReachPhase (bool initial=false)
void	StartSunwellGatePhase ()
void	StopSunwellGatePhase ()
void	BuffAdalsSongOfBattle ()
void	DispelAdalsSongOfBattle ()
void	BuffMagtheridonTeam (TeamId team)
void	DispelMagtheridonTeam (TeamId team)

Private Attributes
WorldStatesMap	_worldstates
uint32	_adalSongOfBattleTimer
bool	_isMagtheridonHeadSpawnedHorde
bool	_isMagtheridonHeadSpawnedAlliance
SunsReachReclamationData	m_sunsReachData
std::map< WorldStateCondition, std::atomic< WorldStateConditionState > >	_transportStates
std::mutex	_mutex

Detailed Description

Member Typedef Documentation

WorldStatesMap

typedef std::map<uint32, uint64> WorldState::WorldStatesMap

private

Constructor & Destructor Documentation

WorldState()

WorldState::WorldState

(

)

                       : _isMagtheridonHeadSpawnedHorde(false), _isMagtheridonHeadSpawnedAlliance(false)
{
    _transportStates[WORLD_STATE_CONDITION_THE_IRON_EAGLE]      = WORLD_STATE_CONDITION_STATE_NONE;
    _transportStates[WORLD_STATE_CONDITION_THE_PURPLE_PRINCESS] = WORLD_STATE_CONDITION_STATE_NONE;
    _transportStates[WORLD_STATE_CONDITION_THE_THUNDERCALLER]   = WORLD_STATE_CONDITION_STATE_NONE;
}

References _transportStates, WORLD_STATE_CONDITION_STATE_NONE, WORLD_STATE_CONDITION_THE_IRON_EAGLE, WORLD_STATE_CONDITION_THE_PURPLE_PRINCESS, and WORLD_STATE_CONDITION_THE_THUNDERCALLER.

~WorldState()

WorldState::~WorldState ( )

virtual

{
}

Member Function Documentation

AddSunsReachProgress()

void WorldState::AddSunsReachProgress

(

uint32

questId

)

{
    uint32 counter = 0;
    int32 otherCounter = -1;
    int32 worldState = 0;
    uint32 subPhaseMask = 0;
    uint32 addedValue = 1;
    switch (questId)
    {
        case QUEST_ERRATIC_BEHAVIOR:
            counter = COUNTER_ERRATIC_BEHAVIOR;
            otherCounter = COUNTER_SANCTUM_WARDS;
            worldState = WORLD_STATE_QUEL_DANAS_SANCTUM;
            break;
        case QUEST_SANCTUM_WARDS:
            counter = COUNTER_SANCTUM_WARDS;
            otherCounter = COUNTER_ERRATIC_BEHAVIOR;
            worldState = WORLD_STATE_QUEL_DANAS_SANCTUM;
            break;
        case QUEST_BATTLE_FOR_THE_SUNS_REACH_ARMORY:
            counter = COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY;
            otherCounter = COUNTER_DISTRACTION_AT_THE_DEAD_SCAR;
            worldState = WORLD_STATE_QUEL_DANAS_ARMORY;
            break;
        case QUEST_DISTRACTION_AT_THE_DEAD_SCAR:
            counter = COUNTER_DISTRACTION_AT_THE_DEAD_SCAR;
            otherCounter = COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY;
            worldState = WORLD_STATE_QUEL_DANAS_ARMORY;
            break;
        case QUEST_INTERCEPTING_THE_MANA_CELLS:
            counter = COUNTER_INTERCEPTING_THE_MANA_CELLS;
            subPhaseMask = SUBPHASE_PORTAL;
            worldState = WORLD_STATE_QUEL_DANAS_PORTAL;
            break;
        case QUEST_INTERCEPT_THE_REINFORCEMENTS:
            counter = COUNTER_INTERCEPT_THE_REINFORCEMENTS;
            otherCounter = COUNTER_TAKING_THE_HARBOR;
            worldState = WORLD_STATE_QUEL_DANAS_HARBOR;
            break;
        case QUEST_TAKING_THE_HARBOR:
            counter = COUNTER_TAKING_THE_HARBOR;
            otherCounter = COUNTER_INTERCEPT_THE_REINFORCEMENTS;
            worldState = WORLD_STATE_QUEL_DANAS_HARBOR;
            break;
        case QUEST_MAKING_READY:
            counter = COUNTER_MAKING_READY;
            subPhaseMask = SUBPHASE_ANVIL;
            worldState = WORLD_STATE_QUEL_DANAS_ANVIL;
            break;
        case QUEST_DISCOVERING_YOUR_ROOTS:
            counter = COUNTER_DISCOVERING_YOUR_ROOTS;
            subPhaseMask = SUBPHASE_ALCHEMY_LAB;
            worldState = WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB;
            break;
        case QUEST_A_CHARITABLE_DONATION:
            counter = COUNTER_A_CHARITABLE_DONATION;
            subPhaseMask = SUBPHASE_MONUMENT;
            worldState = WORLD_STATE_QUEL_DANAS_MONUMENT;
            break;
        case QUEST_A_MAGNANIMOUS_BENEFACTOR:
            counter = COUNTER_A_CHARITABLE_DONATION;
            subPhaseMask = SUBPHASE_MONUMENT;
            worldState = WORLD_STATE_QUEL_DANAS_MONUMENT;
            addedValue = 150;
            break;
        default:
            return;
    }
 
    uint32 previousValue = 0;
    uint32 newValue = 0;
 
    if (!subPhaseMask)
        previousValue = m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
    else
        previousValue = m_sunsReachData.GetSubPhasePercentage(subPhaseMask);
    m_sunsReachData.m_sunsReachReclamationCounters[counter] += addedValue;
    if (!subPhaseMask)
        newValue = m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase);
    else
        newValue = m_sunsReachData.GetSubPhasePercentage(subPhaseMask);
    if (previousValue != newValue)
        SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, newValue, worldState);
 
    bool save = true;
    uint32 counterValue = m_sunsReachData.m_sunsReachReclamationCounters[counter];
    uint32 modifier = 1;
    if (otherCounter != -1)
    {
        modifier = 2;
        counterValue += m_sunsReachData.m_sunsReachReclamationCounters[otherCounter];
    }
    if (counterValue >= sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX) * modifier)
    {
        save = false;
        switch (questId)
        {
            case QUEST_ERRATIC_BEHAVIOR:
            case QUEST_SANCTUM_WARDS:
            {
                if (m_sunsReachData.m_phase == SUNS_REACH_PHASE_1_STAGING_AREA)
                    HandleSunsReachPhaseTransition(SUNS_REACH_PHASE_2_SANCTUM);
                break;
            }
            case QUEST_BATTLE_FOR_THE_SUNS_REACH_ARMORY:
            case QUEST_DISTRACTION_AT_THE_DEAD_SCAR:
            {
                if (m_sunsReachData.m_phase == SUNS_REACH_PHASE_2_SANCTUM)
                    HandleSunsReachPhaseTransition(SUNS_REACH_PHASE_3_ARMORY);
                break;
            }
            case QUEST_INTERCEPTING_THE_MANA_CELLS:
            {
                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_PORTAL) == 0)
                    HandleSunsReachSubPhaseTransition(SUBPHASE_PORTAL);
                break;
            }
            case QUEST_INTERCEPT_THE_REINFORCEMENTS:
            case QUEST_TAKING_THE_HARBOR:
            {
                if (m_sunsReachData.m_phase == SUNS_REACH_PHASE_3_ARMORY)
                    HandleSunsReachPhaseTransition(SUNS_REACH_PHASE_4_HARBOR);
                break;
            }
            case QUEST_MAKING_READY:
            {
                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ANVIL) == 0)
                    HandleSunsReachSubPhaseTransition(SUBPHASE_ANVIL);
                break;
            }
            case QUEST_DISCOVERING_YOUR_ROOTS:
            {
                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALCHEMY_LAB) == 0)
                    HandleSunsReachSubPhaseTransition(SUBPHASE_ALCHEMY_LAB);
                break;
            }
            case QUEST_A_CHARITABLE_DONATION:
            case QUEST_A_MAGNANIMOUS_BENEFACTOR:
            {
                if ((m_sunsReachData.m_subphaseMask & SUBPHASE_MONUMENT) == 0)
                    HandleSunsReachSubPhaseTransition(SUBPHASE_MONUMENT);
                break;
            }
        }
    }
    if (save)
        Save(SAVE_ID_QUEL_DANAS);
}

References CONFIG_SUNSREACH_COUNTER_MAX, COUNTER_A_CHARITABLE_DONATION, COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY, COUNTER_DISCOVERING_YOUR_ROOTS, COUNTER_DISTRACTION_AT_THE_DEAD_SCAR, COUNTER_ERRATIC_BEHAVIOR, COUNTER_INTERCEPT_THE_REINFORCEMENTS, COUNTER_INTERCEPTING_THE_MANA_CELLS, COUNTER_MAKING_READY, COUNTER_SANCTUM_WARDS, COUNTER_TAKING_THE_HARBOR, SunsReachReclamationData::GetPhasePercentage(), SunsReachReclamationData::GetSubPhasePercentage(), HandleSunsReachPhaseTransition(), HandleSunsReachSubPhaseTransition(), SunsReachReclamationData::m_phase, SunsReachReclamationData::m_subphaseMask, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationCounters, SunsReachReclamationData::m_sunsReachReclamationMutex, SunsReachReclamationData::m_sunsReachReclamationPlayers, QUEST_A_CHARITABLE_DONATION, QUEST_A_MAGNANIMOUS_BENEFACTOR, QUEST_BATTLE_FOR_THE_SUNS_REACH_ARMORY, QUEST_DISCOVERING_YOUR_ROOTS, QUEST_DISTRACTION_AT_THE_DEAD_SCAR, QUEST_ERRATIC_BEHAVIOR, QUEST_INTERCEPT_THE_REINFORCEMENTS, QUEST_INTERCEPTING_THE_MANA_CELLS, QUEST_MAKING_READY, QUEST_SANCTUM_WARDS, QUEST_TAKING_THE_HARBOR, Save(), SAVE_ID_QUEL_DANAS, SendWorldstateUpdate(), SUBPHASE_ALCHEMY_LAB, SUBPHASE_ANVIL, SUBPHASE_MONUMENT, SUBPHASE_PORTAL, SUNS_REACH_PHASE_1_STAGING_AREA, SUNS_REACH_PHASE_2_SANCTUM, SUNS_REACH_PHASE_3_ARMORY, SUNS_REACH_PHASE_4_HARBOR, sWorld, WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB, WORLD_STATE_QUEL_DANAS_ANVIL, WORLD_STATE_QUEL_DANAS_ARMORY, WORLD_STATE_QUEL_DANAS_HARBOR, WORLD_STATE_QUEL_DANAS_MONUMENT, WORLD_STATE_QUEL_DANAS_PORTAL, and WORLD_STATE_QUEL_DANAS_SANCTUM.

AddSunwellGateProgress()

void WorldState::AddSunwellGateProgress

(

uint32

questId

)

{
    uint32 counter = 0;
    int32 worldState = 0;
    uint32 addedValue = 1;
    switch (questId)
    {
        case QUEST_AGAMATH_THE_FIRST_GATE:
        case QUEST_ROHENDOR_THE_SECOND_GATE:
        case QUEST_ARCHONISUS_THE_FINAL_GATE:
            break;
        default: return;
    }
    switch (m_sunsReachData.m_gate)
    {
        case SUNWELL_ALL_GATES_CLOSED: counter = COUNTER_AGAMATH_THE_FIRST_GATE; worldState = WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH; break;
        case SUNWELL_AGAMATH_GATE1_OPEN: counter = COUNTER_ROHENDOR_THE_SECOND_GATE; worldState = WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH; break;
        case SUNWELL_ROHENDOR_GATE2_OPEN: counter = COUNTER_ARCHONISUS_THE_FINAL_GATE; worldState = WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH; break;
        default: return;
    }
    uint32 previousValue = m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
    uint32 newValue = 0;
    m_sunsReachData.m_gateCounters[counter] += addedValue;
    newValue = m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate);
    if (previousValue != newValue)
        SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, newValue, worldState);
    bool save = true;
    if (m_sunsReachData.m_gateCounters[counter] >= COUNTER_MAX_VAL_REQ_SWP_GATES)
    {
        save = false;
        switch (questId)
        {
            case QUEST_AGAMATH_THE_FIRST_GATE:
            {
                if (m_sunsReachData.m_gate == SUNWELL_ALL_GATES_CLOSED)
                    HandleSunwellGateTransition(SUNWELL_AGAMATH_GATE1_OPEN);
                break;
            }
            case QUEST_ROHENDOR_THE_SECOND_GATE:
            {
                if (m_sunsReachData.m_gate == SUNWELL_AGAMATH_GATE1_OPEN)
                    HandleSunwellGateTransition(SUNWELL_ROHENDOR_GATE2_OPEN);
                break;
            }
            case QUEST_ARCHONISUS_THE_FINAL_GATE:
            {
                if (m_sunsReachData.m_gate == SUNWELL_ROHENDOR_GATE2_OPEN)
                    HandleSunwellGateTransition(SUNWELL_ARCHONISUS_GATE3_OPEN);
                break;
            }
        }
    }
    if (save)
        Save(SAVE_ID_QUEL_DANAS);
}

References COUNTER_AGAMATH_THE_FIRST_GATE, COUNTER_ARCHONISUS_THE_FINAL_GATE, COUNTER_MAX_VAL_REQ_SWP_GATES, COUNTER_ROHENDOR_THE_SECOND_GATE, SunsReachReclamationData::GetSunwellGatePercentage(), HandleSunwellGateTransition(), SunsReachReclamationData::m_gate, SunsReachReclamationData::m_gateCounters, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationMutex, SunsReachReclamationData::m_sunsReachReclamationPlayers, QUEST_AGAMATH_THE_FIRST_GATE, QUEST_ARCHONISUS_THE_FINAL_GATE, QUEST_ROHENDOR_THE_SECOND_GATE, Save(), SAVE_ID_QUEL_DANAS, SendWorldstateUpdate(), SUNWELL_AGAMATH_GATE1_OPEN, SUNWELL_ALL_GATES_CLOSED, SUNWELL_ARCHONISUS_GATE3_OPEN, SUNWELL_ROHENDOR_GATE2_OPEN, WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH, WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH, and WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH.

BuffAdalsSongOfBattle()

void WorldState::BuffAdalsSongOfBattle ( )

private

{
    sMapMgr->DoForAllMaps([&](Map* map) -> void
    {
        switch (map->GetId())
        {
            case MAP_OUTLAND:
                map->DoForAllPlayers([&](Player* player)
                {
                    if (player->GetZoneId() == AREA_SHATTRATH_CITY)
                        player->CastSpell(player, SPELL_ADAL_SONG_OF_BATTLE, true);
                });
                break;
            case MAP_TEMPEST_KEEP_THE_ARCATRAZ:
            case MAP_TEMPEST_KEEP_THE_BOTANICA:
            case MAP_TEMPEST_KEEP_THE_MECHANAR:
                map->DoForAllPlayers([&](Player* player)
                {
                    player->CastSpell(player, SPELL_ADAL_SONG_OF_BATTLE, true);
                });
                break;
            default:
                break;
        }
    });
}

References Unit::CastSpell(), Map::DoForAllPlayers(), Map::GetId(), MAP_TEMPEST_KEEP_THE_ARCATRAZ, MAP_TEMPEST_KEEP_THE_BOTANICA, MAP_TEMPEST_KEEP_THE_MECHANAR, sMapMgr, and SPELL_ADAL_SONG_OF_BATTLE.

Referenced by HandleExternalEvent().

BuffMagtheridonTeam()

void WorldState::BuffMagtheridonTeam ( TeamId  team )

private

{
    sMapMgr->DoForAllMaps([&](Map* map) -> void
    {
        switch (map->GetId())
        {
            case MAP_OUTLAND:
                map->DoForAllPlayers([&](Player* player)
                {
                    if (player->GetZoneId() == AREA_HELLFIRE_PENINSULA && player->GetTeamId() == TEAM_ALLIANCE && team == TEAM_ALLIANCE)
                        player->CastSpell(player, SPELL_TROLLBANES_COMMAND, true);
                    else if (player->GetZoneId() == AREA_HELLFIRE_PENINSULA && player->GetTeamId() == TEAM_HORDE && team == TEAM_HORDE)
                        player->CastSpell(player, SPELL_NAZGRELS_FAVOR, true);
                });
                break;
            case MAP_HELLFIRE_CITADEL_THE_SHATTERED_HALLS:
            case MAP_HELLFIRE_CITADEL_THE_BLOOD_FURNACE:
            case MAP_HELLFIRE_CITADEL_RAMPARTS:
            case MAP_MAGTHERIDONS_LAIR:
                map->DoForAllPlayers([&](Player* player)
                {
                    if (player->GetTeamId() == TEAM_ALLIANCE && team == TEAM_ALLIANCE)
                        player->CastSpell(player, SPELL_TROLLBANES_COMMAND, true);
                    else if (player->GetTeamId() == TEAM_HORDE && team == TEAM_HORDE)
                        player->CastSpell(player, SPELL_NAZGRELS_FAVOR, true);
                });
                break;
            default:
                break;
        }
    });
}

References Unit::CastSpell(), Map::DoForAllPlayers(), Map::GetId(), Player::GetTeamId(), MAP_HELLFIRE_CITADEL_RAMPARTS, MAP_HELLFIRE_CITADEL_THE_BLOOD_FURNACE, MAP_HELLFIRE_CITADEL_THE_SHATTERED_HALLS, MAP_MAGTHERIDONS_LAIR, sMapMgr, SPELL_NAZGRELS_FAVOR, SPELL_TROLLBANES_COMMAND, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by HandleExternalEvent().

DispelAdalsSongOfBattle()

void WorldState::DispelAdalsSongOfBattle ( )

private

{
    sMapMgr->DoForAllMaps([&](Map* map) -> void
    {
        switch (map->GetId())
        {
            case MAP_OUTLAND:
                map->DoForAllPlayers([&](Player* player)
                {
                    if (player->GetZoneId() == AREA_SHATTRATH_CITY)
                        player->RemoveAurasDueToSpell(SPELL_ADAL_SONG_OF_BATTLE);
                });
                break;
            case MAP_TEMPEST_KEEP_THE_ARCATRAZ:
            case MAP_TEMPEST_KEEP_THE_BOTANICA:
            case MAP_TEMPEST_KEEP_THE_MECHANAR:
                map->DoForAllPlayers([&](Player* player)
                {
                    player->RemoveAurasDueToSpell(SPELL_ADAL_SONG_OF_BATTLE);
                });
                break;
            default:
                break;
        }
    });
}

References Map::DoForAllPlayers(), Map::GetId(), MAP_TEMPEST_KEEP_THE_ARCATRAZ, MAP_TEMPEST_KEEP_THE_BOTANICA, MAP_TEMPEST_KEEP_THE_MECHANAR, Unit::RemoveAurasDueToSpell(), sMapMgr, and SPELL_ADAL_SONG_OF_BATTLE.

Referenced by Update().

DispelMagtheridonTeam()

void WorldState::DispelMagtheridonTeam ( TeamId  team )

private

{
    sMapMgr->DoForAllMaps([&](Map* map) -> void
    {
        switch (map->GetId())
        {
            case MAP_OUTLAND:
                map->DoForAllPlayers([&](Player* player)
                {
                    if (player->GetZoneId() == AREA_HELLFIRE_PENINSULA && player->GetTeamId() == TEAM_ALLIANCE && team == TEAM_ALLIANCE)
                        player->RemoveAurasDueToSpell(SPELL_TROLLBANES_COMMAND);
                    else if (player->GetZoneId() == AREA_HELLFIRE_PENINSULA && player->GetTeamId() == TEAM_HORDE && team == TEAM_HORDE)
                        player->RemoveAurasDueToSpell(SPELL_NAZGRELS_FAVOR);
                });
                break;
            case MAP_HELLFIRE_CITADEL_THE_SHATTERED_HALLS:
            case MAP_HELLFIRE_CITADEL_THE_BLOOD_FURNACE:
            case MAP_HELLFIRE_CITADEL_RAMPARTS:
            case MAP_MAGTHERIDONS_LAIR:
                map->DoForAllPlayers([&](Player* player)
                {
                    if (player->GetTeamId() == TEAM_ALLIANCE && team == TEAM_ALLIANCE)
                        player->RemoveAurasDueToSpell(SPELL_TROLLBANES_COMMAND);
                    else if (player->GetTeamId() == TEAM_HORDE && team == TEAM_HORDE)
                        player->RemoveAurasDueToSpell(SPELL_NAZGRELS_FAVOR);
                });
                break;
            default:
                break;
        }
    });
}

References Map::DoForAllPlayers(), Map::GetId(), Player::GetTeamId(), MAP_HELLFIRE_CITADEL_RAMPARTS, MAP_HELLFIRE_CITADEL_THE_BLOOD_FURNACE, MAP_HELLFIRE_CITADEL_THE_SHATTERED_HALLS, MAP_MAGTHERIDONS_LAIR, Unit::RemoveAurasDueToSpell(), sMapMgr, SPELL_NAZGRELS_FAVOR, SPELL_TROLLBANES_COMMAND, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by HandleExternalEvent().

FillInitialWorldStates()

void WorldState::FillInitialWorldStates	(	WorldPackets::WorldState::InitWorldStates &	packet,
		uint32	zoneId,
		uint32
	)

{
    switch (zoneId)
    {
        case AREA_ISLE_OF_QUEL_DANAS:
        case AREA_MAGISTERS_TERRACE:
        case AREA_SUNWELL_PLATEAU:
        case AREA_SHATTRATH_CITY:
        {
            // Sunwell Reclamation
            switch (m_sunsReachData.m_phase)
            {
                case SUNS_REACH_PHASE_1_STAGING_AREA:
                    packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_SANCTUM, m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase));
                    break;
                case SUNS_REACH_PHASE_2_SANCTUM:
                    packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_ARMORY, m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase));
                    break;
                case SUNS_REACH_PHASE_3_ARMORY:
                    packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_HARBOR, m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase));
                    break;
                case SUNS_REACH_PHASE_4_HARBOR:
                    if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALCHEMY_LAB) == 0)
                        packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ALCHEMY_LAB));
                    if ((m_sunsReachData.m_subphaseMask & SUBPHASE_MONUMENT) == 0)
                        packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_MONUMENT, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_MONUMENT));
                    break;
            }
            if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_2_SANCTUM && (m_sunsReachData.m_subphaseMask & SUBPHASE_PORTAL) == 0)
                packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_PORTAL, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_PORTAL));
            if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_3_ARMORY && (m_sunsReachData.m_subphaseMask & SUBPHASE_ANVIL) == 0)
                packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_ANVIL, m_sunsReachData.GetSubPhasePercentage(SUBPHASE_ANVIL));
            packet.Worldstates.emplace_back(WORLD_STATE_QUEL_DANAS_MUSIC, m_sunsReachData.m_phase);
 
            // Sunwell Gates
            switch (m_sunsReachData.m_gate)
            {
                case SUNWELL_ALL_GATES_CLOSED:
                    packet.Worldstates.emplace_back(WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH, m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate));
                    break;
                case SUNWELL_AGAMATH_GATE1_OPEN:
                    packet.Worldstates.emplace_back(WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH, m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate));
                    break;
                case SUNWELL_ROHENDOR_GATE2_OPEN:
                    packet.Worldstates.emplace_back(WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH, m_sunsReachData.GetSunwellGatePercentage(m_sunsReachData.m_gate));
                    break;
            }
            break;
        }
    }
}

References AREA_ISLE_OF_QUEL_DANAS, AREA_MAGISTERS_TERRACE, AREA_SHATTRATH_CITY, AREA_SUNWELL_PLATEAU, SunsReachReclamationData::GetPhasePercentage(), SunsReachReclamationData::GetSubPhasePercentage(), SunsReachReclamationData::GetSunwellGatePercentage(), SunsReachReclamationData::m_gate, SunsReachReclamationData::m_phase, SunsReachReclamationData::m_subphaseMask, m_sunsReachData, SUBPHASE_ALCHEMY_LAB, SUBPHASE_ANVIL, SUBPHASE_MONUMENT, SUBPHASE_PORTAL, SUNS_REACH_PHASE_1_STAGING_AREA, SUNS_REACH_PHASE_2_SANCTUM, SUNS_REACH_PHASE_3_ARMORY, SUNS_REACH_PHASE_4_HARBOR, SUNWELL_AGAMATH_GATE1_OPEN, SUNWELL_ALL_GATES_CLOSED, SUNWELL_ROHENDOR_GATE2_OPEN, WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH, WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH, WORLD_STATE_QUEL_DANAS_ALCHEMY_LAB, WORLD_STATE_QUEL_DANAS_ANVIL, WORLD_STATE_QUEL_DANAS_ARMORY, WORLD_STATE_QUEL_DANAS_HARBOR, WORLD_STATE_QUEL_DANAS_MONUMENT, WORLD_STATE_QUEL_DANAS_MUSIC, WORLD_STATE_QUEL_DANAS_PORTAL, WORLD_STATE_QUEL_DANAS_SANCTUM, WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH, and WorldPackets::WorldState::InitWorldStates::Worldstates.

GetSunsReachPrintout()

std::string WorldState::GetSunsReachPrintout

(

)

{
    auto formatPhase = [this]() -> std::string {
        std::string name;
        switch (m_sunsReachData.m_phase)
        {
            case SUNS_REACH_PHASE_1_STAGING_AREA: name = "Phase 1: Staging Area"; break;
            case SUNS_REACH_PHASE_2_SANCTUM: name = "Phase 2: Sanctum"; break;
            case SUNS_REACH_PHASE_3_ARMORY: name = "Phase 3: Armory"; break;
            case SUNS_REACH_PHASE_4_HARBOR: name = "Phase 4: Harbor"; break;
            default: name = "Unknown"; break;
        }
        return "Phase: " + std::to_string(m_sunsReachData.m_phase) + " (" + name + ") " + std::to_string(m_sunsReachData.GetPhasePercentage(m_sunsReachData.m_phase)) + "%\n";
    };
 
    auto formatSubPhase = [this](uint32 subPhase) -> std::string {
        std::string name;
        switch (subPhase)
        {
            case SUBPHASE_PORTAL: name = "Portal"; break;
            case SUBPHASE_ANVIL: name = "Anvil"; break;
            case SUBPHASE_ALCHEMY_LAB: name = "Alchemy Lab"; break;
            case SUBPHASE_MONUMENT: name = "Monument"; break;
            default: name = "Unknown"; break;
        }
        return name + ": " + (m_sunsReachData.m_subphaseMask & subPhase ? "100%" : std::to_string(m_sunsReachData.GetSubPhasePercentage(subPhase)) + "%");
    };
 
    auto formatCounter = [](uint32 counter, uint32 value) -> std::string {
        switch (counter)
        {
            case COUNTER_ERRATIC_BEHAVIOR:
                return "Erratic Behavior: " + std::to_string(value) + " (counts towards Phase 2: Sanctum)";
            case COUNTER_SANCTUM_WARDS:
                return "Sanctum Wards: " + std::to_string(value) + " (counts towards Phase 2: Sanctum)";
            case COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY:
                return "Battle for the Sun's Reach Armory: " + std::to_string(value) + " (counts towards Phase 3: Armory)";
            case COUNTER_DISTRACTION_AT_THE_DEAD_SCAR:
                return "Distraction at the Dead Scar: " + std::to_string(value) + " (counts towards Phase 3: Armory)";
            case COUNTER_INTERCEPTING_THE_MANA_CELLS:
                return "Intercepting the Mana Cells: " + std::to_string(value) + " (counts towards Subphase: Portal)";
            case COUNTER_INTERCEPT_THE_REINFORCEMENTS:
                return "Intercept the Reinforcements: " + std::to_string(value) + " (counts towards Phase 4: Harbor)";
            case COUNTER_TAKING_THE_HARBOR:
                return "Taking the Harbor: " + std::to_string(value) + " (counts towards Phase 4: Harbor)";
            case COUNTER_MAKING_READY:
                return "Making Ready: " + std::to_string(value) + " (counts towards Subphase: Anvil)";
            case COUNTER_DISCOVERING_YOUR_ROOTS:
                return "Discovering Your Roots: " + std::to_string(value) + " (counts towards Subphase: Alchemy Lab)";
            case COUNTER_A_CHARITABLE_DONATION:
                return "A Charitable Donation: " + std::to_string(value) + " (counts towards Subphase: Monument)";
            default:
                return "Unknown: " + std::to_string(value) + " (Unknown goal)";
        }
    };
 
    std::string output = formatPhase();
    output += "Subphase mask: " + std::to_string(m_sunsReachData.m_subphaseMask) + "\n";
    for (uint32 i = 0; i < 4; ++i)
    {
        uint32 subPhaseMask = 1 << i;
        output += "  " + formatSubPhase(subPhaseMask) + "\n";
    }
    output += "Counters:\n";
    output += "  Sunsreach.CounterMax = " + std::to_string(sWorld->getIntConfig(CONFIG_SUNSREACH_COUNTER_MAX)) + "\n";
    for (uint32 i = 0; i < COUNTERS_MAX; ++i)
        output += "  " + std::to_string(i) + ". " + formatCounter(i, m_sunsReachData.m_sunsReachReclamationCounters[i]) + "\n";
 
    // Sunwell Gates
    auto formatGatePhase = [](uint32 gate) -> std::string {
        switch (gate)
        {
            case SUNWELL_ALL_GATES_CLOSED: return "All Gates Closed"; break;
            case SUNWELL_AGAMATH_GATE1_OPEN: return "Gate 1 Agamath Open"; break;
            case SUNWELL_ROHENDOR_GATE2_OPEN: return "Gate 2 Rohendar Open"; break;
            case SUNWELL_ARCHONISUS_GATE3_OPEN: return "Gate 3 Archonisus Open"; break;
            default: return "Unknown"; break;
        }
    };
    output += "Sunwell Plateau Gate Phase " + std::to_string(m_sunsReachData.m_gate) + " (" + formatGatePhase(m_sunsReachData.m_gate) + ")" + ":\n";
    output += "  0. Gate 1 (Agamath): " + std::string(m_sunsReachData.m_gate >= SUNWELL_AGAMATH_GATE1_OPEN ? "Open " : "Closed ") + std::to_string(m_sunsReachData.m_gateCounters[COUNTER_AGAMATH_THE_FIRST_GATE]) + " (" + std::to_string(m_sunsReachData.GetSunwellGatePercentage(SUNWELL_ALL_GATES_CLOSED)) + "%)\n";
    output += "  1. Gate 2 (Rohendor): " + std::string(m_sunsReachData.m_gate >= SUNWELL_ROHENDOR_GATE2_OPEN ? "Open " : "Closed ") + std::to_string(m_sunsReachData.m_gateCounters[COUNTER_ROHENDOR_THE_SECOND_GATE]) +  " (" + std::to_string(m_sunsReachData.GetSunwellGatePercentage(SUNWELL_AGAMATH_GATE1_OPEN)) + "%)\n";
    output += "  2. Gate 3 (Archonisus): " + std::string(m_sunsReachData.m_gate >= SUNWELL_ARCHONISUS_GATE3_OPEN ? "Open " : "Closed ") + std::to_string(m_sunsReachData.m_gateCounters[COUNTER_ARCHONISUS_THE_FINAL_GATE]) + " (" + std::to_string(m_sunsReachData.GetSunwellGatePercentage(SUNWELL_ROHENDOR_GATE2_OPEN)) + "%)\n";
    return output;
}

References CONFIG_SUNSREACH_COUNTER_MAX, COUNTER_A_CHARITABLE_DONATION, COUNTER_AGAMATH_THE_FIRST_GATE, COUNTER_ARCHONISUS_THE_FINAL_GATE, COUNTER_BATTLE_FOR_THE_SUNS_REACH_ARMORY, COUNTER_DISCOVERING_YOUR_ROOTS, COUNTER_DISTRACTION_AT_THE_DEAD_SCAR, COUNTER_ERRATIC_BEHAVIOR, COUNTER_INTERCEPT_THE_REINFORCEMENTS, COUNTER_INTERCEPTING_THE_MANA_CELLS, COUNTER_MAKING_READY, COUNTER_ROHENDOR_THE_SECOND_GATE, COUNTER_SANCTUM_WARDS, COUNTER_TAKING_THE_HARBOR, COUNTERS_MAX, SunsReachReclamationData::GetPhasePercentage(), SunsReachReclamationData::GetSubPhasePercentage(), SunsReachReclamationData::GetSunwellGatePercentage(), SunsReachReclamationData::m_gate, SunsReachReclamationData::m_gateCounters, SunsReachReclamationData::m_phase, SunsReachReclamationData::m_subphaseMask, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationCounters, SUBPHASE_ALCHEMY_LAB, SUBPHASE_ANVIL, SUBPHASE_MONUMENT, SUBPHASE_PORTAL, SUNS_REACH_PHASE_1_STAGING_AREA, SUNS_REACH_PHASE_2_SANCTUM, SUNS_REACH_PHASE_3_ARMORY, SUNS_REACH_PHASE_4_HARBOR, SUNWELL_AGAMATH_GATE1_OPEN, SUNWELL_ALL_GATES_CLOSED, SUNWELL_ARCHONISUS_GATE3_OPEN, SUNWELL_ROHENDOR_GATE2_OPEN, and sWorld.

getWorldState()

uint64 WorldState::getWorldState

(

uint32

index

)

const

{
    auto const& itr = _worldstates.find(index);
    return itr != _worldstates.end() ? itr->second : 0;
}

References _worldstates.

HandleConditionStateChange()

void WorldState::HandleConditionStateChange	(	WorldStateCondition	conditionId,
		WorldStateConditionState	state
	)

{
    _transportStates[conditionId] = state;
}

References _transportStates.

HandleExternalEvent()

void WorldState::HandleExternalEvent	(	WorldStateEvent	eventId,
		uint32	param
	)

{
    std::lock_guard<std::mutex> guard(_mutex);
    switch (eventId)
    {
        case WORLD_STATE_CUSTOM_EVENT_ON_ADALS_SONG_OF_BATTLE:
            if (!_adalSongOfBattleTimer)
            {
                _adalSongOfBattleTimer = 120 * MINUTE * IN_MILLISECONDS;
                BuffAdalsSongOfBattle();
            }
            break;
        case WORLD_STATE_CUSTOM_EVENT_ON_MAGTHERIDON_HEAD_SPAWN:
            if (param == TEAM_ALLIANCE)
            {
                _isMagtheridonHeadSpawnedAlliance = true;
                BuffMagtheridonTeam(TEAM_ALLIANCE);
            }
            else
            {
                _isMagtheridonHeadSpawnedHorde = true;
                BuffMagtheridonTeam(TEAM_HORDE);
            }
            break;
        case WORLD_STATE_CUSTOM_EVENT_ON_MAGTHERIDON_HEAD_DESPAWN:
            if (param == TEAM_ALLIANCE)
            {
                _isMagtheridonHeadSpawnedAlliance = false;
                DispelMagtheridonTeam(TEAM_ALLIANCE);
            }
            else
            {
                _isMagtheridonHeadSpawnedHorde = false;
                DispelMagtheridonTeam(TEAM_HORDE);
            }
            break;
        default:
            break;
    }
}

References _adalSongOfBattleTimer, _isMagtheridonHeadSpawnedAlliance, _isMagtheridonHeadSpawnedHorde, _mutex, BuffAdalsSongOfBattle(), BuffMagtheridonTeam(), DispelMagtheridonTeam(), IN_MILLISECONDS, MINUTE, TEAM_ALLIANCE, TEAM_HORDE, WORLD_STATE_CUSTOM_EVENT_ON_ADALS_SONG_OF_BATTLE, WORLD_STATE_CUSTOM_EVENT_ON_MAGTHERIDON_HEAD_DESPAWN, and WORLD_STATE_CUSTOM_EVENT_ON_MAGTHERIDON_HEAD_SPAWN.

HandlePlayerEnterZone()

void WorldState::HandlePlayerEnterZone	(	Player *	player,
		AreaTableIDs	zoneId
	)

{
    std::lock_guard<std::mutex> guard(_mutex);
    switch (zoneId)
    {
        case AREA_SHATTRATH_CITY:
        case AREA_THE_BOTANICA:
        case AREA_THE_MECHANAR:
        case AREA_THE_ARCATRAZ:
            if (_adalSongOfBattleTimer)
                player->CastSpell(player, SPELL_ADAL_SONG_OF_BATTLE, true);
            break;
        case AREA_HELLFIRE_PENINSULA:
        case AREA_HELLFIRE_RAMPARTS:
        case AREA_HELLFIRE_CITADEL:
        case AREA_THE_BLOOD_FURNACE:
        case AREA_THE_SHATTERED_HALLS:
        case AREA_MAGTHERIDONS_LAIR:
            if (_isMagtheridonHeadSpawnedAlliance && player->GetTeamId() == TEAM_ALLIANCE)
                player->CastSpell(player, SPELL_TROLLBANES_COMMAND, true);
            else if (_isMagtheridonHeadSpawnedHorde && player->GetTeamId() == TEAM_HORDE)
                player->CastSpell(player, SPELL_NAZGRELS_FAVOR, true);
            break;
        case AREA_ISLE_OF_QUEL_DANAS:
        case AREA_MAGISTERS_TERRACE:
        case AREA_SUNWELL_PLATEAU:
        {
            std::lock_guard<std::mutex> guard(m_sunsReachData.m_sunsReachReclamationMutex);
            m_sunsReachData.m_sunsReachReclamationPlayers.push_back(player->GetGUID());
            if (m_sunsReachData.m_subphaseMask == SUBPHASE_ALL)
                player->CastSpell(player, SPELL_KIRU_SONG_OF_VICTORY, true);
            break;
        }
        default:
            break;
    }
};

References _adalSongOfBattleTimer, _isMagtheridonHeadSpawnedAlliance, _isMagtheridonHeadSpawnedHorde, _mutex, AREA_HELLFIRE_CITADEL, AREA_HELLFIRE_PENINSULA, AREA_HELLFIRE_RAMPARTS, AREA_ISLE_OF_QUEL_DANAS, AREA_MAGISTERS_TERRACE, AREA_MAGTHERIDONS_LAIR, AREA_SHATTRATH_CITY, AREA_SUNWELL_PLATEAU, AREA_THE_ARCATRAZ, AREA_THE_BLOOD_FURNACE, AREA_THE_BOTANICA, AREA_THE_MECHANAR, AREA_THE_SHATTERED_HALLS, Unit::CastSpell(), Object::GetGUID(), Player::GetTeamId(), SunsReachReclamationData::m_subphaseMask, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationMutex, SunsReachReclamationData::m_sunsReachReclamationPlayers, SPELL_ADAL_SONG_OF_BATTLE, SPELL_KIRU_SONG_OF_VICTORY, SPELL_NAZGRELS_FAVOR, SPELL_TROLLBANES_COMMAND, SUBPHASE_ALL, TEAM_ALLIANCE, and TEAM_HORDE.

HandlePlayerLeaveZone()

void WorldState::HandlePlayerLeaveZone	(	Player *	player,
		AreaTableIDs	zoneId
	)

{
    std::lock_guard<std::mutex> guard(_mutex);
    switch (zoneId)
    {
        case AREA_SHATTRATH_CITY:
        case AREA_THE_BOTANICA:
        case AREA_THE_MECHANAR:
        case AREA_THE_ARCATRAZ:
            if (!_adalSongOfBattleTimer)
                player->RemoveAurasDueToSpell(SPELL_ADAL_SONG_OF_BATTLE);
            break;
        case AREA_HELLFIRE_PENINSULA:
        case AREA_HELLFIRE_RAMPARTS:
        case AREA_HELLFIRE_CITADEL:
        case AREA_THE_BLOOD_FURNACE:
        case AREA_THE_SHATTERED_HALLS:
        case AREA_MAGTHERIDONS_LAIR:
            if (player->GetTeamId() == TEAM_ALLIANCE)
                player->RemoveAurasDueToSpell(SPELL_TROLLBANES_COMMAND);
            else if (player->GetTeamId() == TEAM_HORDE)
                player->RemoveAurasDueToSpell(SPELL_NAZGRELS_FAVOR);
            break;
        case AREA_ISLE_OF_QUEL_DANAS:
        case AREA_MAGISTERS_TERRACE:
        case AREA_SUNWELL_PLATEAU:
        {
            std::lock_guard<std::mutex> guard(m_sunsReachData.m_sunsReachReclamationMutex);
            player->RemoveAurasDueToSpell(SPELL_KIRU_SONG_OF_VICTORY);
            auto position = std::find(m_sunsReachData.m_sunsReachReclamationPlayers.begin(), m_sunsReachData.m_sunsReachReclamationPlayers.end(), player->GetGUID());
            if (position != m_sunsReachData.m_sunsReachReclamationPlayers.end())
                m_sunsReachData.m_sunsReachReclamationPlayers.erase(position);
            break;
        }
        default:
            break;
    }
};

References _adalSongOfBattleTimer, _mutex, AREA_HELLFIRE_CITADEL, AREA_HELLFIRE_PENINSULA, AREA_HELLFIRE_RAMPARTS, AREA_ISLE_OF_QUEL_DANAS, AREA_MAGISTERS_TERRACE, AREA_MAGTHERIDONS_LAIR, AREA_SHATTRATH_CITY, AREA_SUNWELL_PLATEAU, AREA_THE_ARCATRAZ, AREA_THE_BLOOD_FURNACE, AREA_THE_BOTANICA, AREA_THE_MECHANAR, AREA_THE_SHATTERED_HALLS, Object::GetGUID(), Player::GetTeamId(), m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationMutex, SunsReachReclamationData::m_sunsReachReclamationPlayers, Unit::RemoveAurasDueToSpell(), SPELL_ADAL_SONG_OF_BATTLE, SPELL_KIRU_SONG_OF_VICTORY, SPELL_NAZGRELS_FAVOR, SPELL_TROLLBANES_COMMAND, TEAM_ALLIANCE, and TEAM_HORDE.

HandleSunsReachPhaseTransition()

void WorldState::HandleSunsReachPhaseTransition

(

uint32

newPhase

)

{
    if (newPhase < m_sunsReachData.m_phase)
    {
        while (newPhase != m_sunsReachData.m_phase)
        {
            StopSunsReachPhase(newPhase > m_sunsReachData.m_phase);
            --m_sunsReachData.m_phase;
        }
        StartSunsReachPhase();
    }
    else
    {
        StopSunsReachPhase(newPhase > m_sunsReachData.m_phase);
        bool moreThanOne = newPhase > m_sunsReachData.m_phase + 1; // custom command case
        m_sunsReachData.m_phase = newPhase;
        StartSunsReachPhase(moreThanOne);
    }
    switch (m_sunsReachData.m_phase)
    {
        case SUNS_REACH_PHASE_2_SANCTUM: if ((m_sunsReachData.m_subphaseMask & SUBPHASE_PORTAL) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL); break;
        case SUNS_REACH_PHASE_3_ARMORY: if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ANVIL) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL); break;
        case SUNS_REACH_PHASE_4_HARBOR:
            if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALCHEMY_LAB) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT);
            if ((m_sunsReachData.m_subphaseMask & SUBPHASE_MONUMENT) == 0) sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB);
            break;
        default: break;
    }
    SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, m_sunsReachData.m_phase, WORLD_STATE_QUEL_DANAS_MUSIC);
    Save(SAVE_ID_QUEL_DANAS);
}

References GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL, GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL, GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB, GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT, SunsReachReclamationData::m_phase, SunsReachReclamationData::m_subphaseMask, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationMutex, SunsReachReclamationData::m_sunsReachReclamationPlayers, Save(), SAVE_ID_QUEL_DANAS, SendWorldstateUpdate(), sGameEventMgr, StartSunsReachPhase(), StopSunsReachPhase(), SUBPHASE_ALCHEMY_LAB, SUBPHASE_ANVIL, SUBPHASE_MONUMENT, SUBPHASE_PORTAL, SUNS_REACH_PHASE_2_SANCTUM, SUNS_REACH_PHASE_3_ARMORY, SUNS_REACH_PHASE_4_HARBOR, and WORLD_STATE_QUEL_DANAS_MUSIC.

Referenced by AddSunsReachProgress().

HandleSunsReachSubPhaseTransition()

void WorldState::HandleSunsReachSubPhaseTransition	(	int32	subPhaseMask,
		bool	initial = false
	)

{
    bool start = true;
    if (subPhaseMask < 0)
    {
        start = false;
        subPhaseMask = -subPhaseMask;
    }
    bool all = false;
    if (start)
    {
        m_sunsReachData.m_subphaseMask |= subPhaseMask;
        if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALL) == SUBPHASE_ALL)
            all = true;
    }
    else
    {
        if ((m_sunsReachData.m_subphaseMask & SUBPHASE_ALL) == SUBPHASE_ALL)
            all = true;
        m_sunsReachData.m_subphaseMask &= ~subPhaseMask;
    }
    if (initial)
    {
        if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_2_SANCTUM)
            if ((subPhaseMask & SUBPHASE_PORTAL) == 0)
                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL);
        if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_3_ARMORY)
            if ((subPhaseMask & SUBPHASE_ANVIL) == 0)
                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL);
        if (m_sunsReachData.m_phase >= SUNS_REACH_PHASE_4_HARBOR)
        {
            if ((subPhaseMask & SUBPHASE_ALCHEMY_LAB) == 0)
                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB);
            if ((subPhaseMask & SUBPHASE_MONUMENT) == 0)
                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT);
        }
    }
    if ((subPhaseMask & SUBPHASE_PORTAL))
    {
        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL;
        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_2_PORTAL;
        if (start)
        {
            sGameEventMgr->StopEvent(first);
            sGameEventMgr->StartEvent(second);
        }
        else
        {
            sGameEventMgr->StopEvent(second);
            sGameEventMgr->StartEvent(first);
        }
    }
    if ((subPhaseMask & SUBPHASE_ANVIL))
    {
        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL;
        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_3_ANVIL;
        if (start)
        {
            sGameEventMgr->StopEvent(first);
            sGameEventMgr->StartEvent(second);
        }
        else
        {
            sGameEventMgr->StopEvent(second);
            sGameEventMgr->StartEvent(first);
        }
    }
    if ((subPhaseMask & SUBPHASE_ALCHEMY_LAB))
    {
        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB;
        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_4_ALCHEMY_LAB;
        if (start)
        {
            sGameEventMgr->StopEvent(first);
            sGameEventMgr->StartEvent(second);
        }
        else
        {
            sGameEventMgr->StopEvent(second);
            sGameEventMgr->StartEvent(first);
        }
    }
    if ((subPhaseMask & SUBPHASE_MONUMENT))
    {
        uint32 first = GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT;
        uint32 second = GAME_EVENT_QUEL_DANAS_PHASE_4_MONUMENT;
        if (start)
        {
            sGameEventMgr->StopEvent(first);
            sGameEventMgr->StartEvent(second);
        }
        else
        {
            sGameEventMgr->StopEvent(second);
            sGameEventMgr->StartEvent(first);
        }
    }
    if (all)
    {
        if (start)
            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_KIRU);
        else
            sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_4_KIRU);
 
        if (!initial)
        {
            std::lock_guard<std::mutex> guard(m_sunsReachData.m_sunsReachReclamationMutex);
            for (ObjectGuid& guid : m_sunsReachData.m_sunsReachReclamationPlayers)
                if (Player* player = ObjectAccessor::FindPlayer(guid))
                {
                    if (start)
                        player->CastSpell(player, SPELL_KIRU_SONG_OF_VICTORY, true);
                    else
                        player->RemoveAurasDueToSpell(SPELL_KIRU_SONG_OF_VICTORY);
                }
        }
    }
    if (!initial)
        Save(SAVE_ID_QUEL_DANAS);
}

References ObjectAccessor::FindPlayer(), GAME_EVENT_QUEL_DANAS_PHASE_2_NO_PORTAL, GAME_EVENT_QUEL_DANAS_PHASE_2_PORTAL, GAME_EVENT_QUEL_DANAS_PHASE_3_ANVIL, GAME_EVENT_QUEL_DANAS_PHASE_3_NO_ANVIL, GAME_EVENT_QUEL_DANAS_PHASE_4_ALCHEMY_LAB, GAME_EVENT_QUEL_DANAS_PHASE_4_KIRU, GAME_EVENT_QUEL_DANAS_PHASE_4_MONUMENT, GAME_EVENT_QUEL_DANAS_PHASE_4_NO_ALCHEMY_LAB, GAME_EVENT_QUEL_DANAS_PHASE_4_NO_MONUMENT, SunsReachReclamationData::m_phase, SunsReachReclamationData::m_subphaseMask, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationMutex, SunsReachReclamationData::m_sunsReachReclamationPlayers, Save(), SAVE_ID_QUEL_DANAS, sGameEventMgr, SPELL_KIRU_SONG_OF_VICTORY, SUBPHASE_ALCHEMY_LAB, SUBPHASE_ALL, SUBPHASE_ANVIL, SUBPHASE_MONUMENT, SUBPHASE_PORTAL, SUNS_REACH_PHASE_2_SANCTUM, SUNS_REACH_PHASE_3_ARMORY, and SUNS_REACH_PHASE_4_HARBOR.

Referenced by AddSunsReachProgress(), and Load().

HandleSunwellGateTransition()

void WorldState::HandleSunwellGateTransition

(

uint32

newGate

)

{
    if (newGate < m_sunsReachData.m_gate)
    {
        while (newGate != m_sunsReachData.m_gate)
        {
            StopSunwellGatePhase();
            --m_sunsReachData.m_gate;
        }
        StartSunwellGatePhase();
    }
    else
    {
        StopSunwellGatePhase();
        m_sunsReachData.m_gate = newGate;
        StartSunwellGatePhase();
    }
    int32 worldState = 0;
    switch (newGate)
    {
        case SUNWELL_AGAMATH_GATE1_OPEN: worldState = WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH; break;
        case SUNWELL_ROHENDOR_GATE2_OPEN: worldState = WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH; break;
        case SUNWELL_ARCHONISUS_GATE3_OPEN: worldState = WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH; break;
    }
    if (worldState)
        SendWorldstateUpdate(m_sunsReachData.m_sunsReachReclamationMutex, m_sunsReachData.m_sunsReachReclamationPlayers, m_sunsReachData.m_gate, worldState);
 
    Save(SAVE_ID_QUEL_DANAS);
}

References SunsReachReclamationData::m_gate, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationMutex, SunsReachReclamationData::m_sunsReachReclamationPlayers, Save(), SAVE_ID_QUEL_DANAS, SendWorldstateUpdate(), StartSunwellGatePhase(), StopSunwellGatePhase(), SUNWELL_AGAMATH_GATE1_OPEN, SUNWELL_ARCHONISUS_GATE3_OPEN, SUNWELL_ROHENDOR_GATE2_OPEN, WORLD_STATE_AGAMATH_THE_FIRST_GATE_HEALTH, WORLD_STATE_ARCHONISUS_THE_FINAL_GATE_HEALTH, and WORLD_STATE_ROHENDOR_THE_SECOND_GATE_HEALTH.

Referenced by AddSunwellGateProgress().

instance()

WorldState * WorldState::instance ( )

static

{
    static WorldState instance;
    return &instance;
}

References instance().

Referenced by instance().

IsConditionFulfilled()

bool WorldState::IsConditionFulfilled	(	WorldStateCondition	conditionId,
		WorldStateConditionState	state = WORLD_STATE_CONDITION_STATE_NONE
	)		const

{
    switch (conditionId)
    {
        case WORLD_STATE_CONDITION_TROLLBANES_COMMAND:
            return _isMagtheridonHeadSpawnedAlliance;
        case WORLD_STATE_CONDITION_NAZGRELS_FAVOR:
            return _isMagtheridonHeadSpawnedHorde;
        case WORLD_STATE_CONDITION_THE_IRON_EAGLE:
        case WORLD_STATE_CONDITION_THE_PURPLE_PRINCESS:
        case WORLD_STATE_CONDITION_THE_THUNDERCALLER:
            return _transportStates.at(conditionId) == state;
        default:
            LOG_ERROR("scripts", "WorldState::IsConditionFulfilled: Unhandled WorldStateCondition {}", conditionId);
            return false;
    }
}

References _isMagtheridonHeadSpawnedAlliance, _isMagtheridonHeadSpawnedHorde, _transportStates, LOG_ERROR, WORLD_STATE_CONDITION_NAZGRELS_FAVOR, WORLD_STATE_CONDITION_THE_IRON_EAGLE, WORLD_STATE_CONDITION_THE_PURPLE_PRINCESS, WORLD_STATE_CONDITION_THE_THUNDERCALLER, and WORLD_STATE_CONDITION_TROLLBANES_COMMAND.

Load()

void WorldState::Load

(

)

{
    QueryResult result = CharacterDatabase.Query("SELECT Id, Data FROM world_state");
    if (result)
    {
        do
        {
            Field* fields = result->Fetch();
            uint32 id = fields[0].Get<uint32>();
            std::string data = fields[1].Get<std::string>();
            std::istringstream loadStream(data);
 
            switch (id)
            {
                case SAVE_ID_QUEL_DANAS:
                {
                    if (data.size())
                    {
                        try
                        {
                            loadStream >> m_sunsReachData.m_phase >> m_sunsReachData.m_subphaseMask;
                            for (uint32 i = 0; i < COUNTERS_MAX; ++i)
                                loadStream >> m_sunsReachData.m_sunsReachReclamationCounters[i];
                            loadStream >> m_sunsReachData.m_gate;
                            for (uint32 i = 0; i < COUNTERS_MAX_GATES; ++i)
                                loadStream >> m_sunsReachData.m_gateCounters[i];
                        }
                        catch (std::exception& e)
                        {
                            LOG_ERROR("scripts", "WorldState::Load: Exception reading SunsReach data {}", e.what());
                            m_sunsReachData.m_phase = 0;
                            m_sunsReachData.m_subphaseMask = 0;
                            memset(m_sunsReachData.m_sunsReachReclamationCounters, 0, sizeof(m_sunsReachData.m_sunsReachReclamationCounters));
                            m_sunsReachData.m_gate = SUNWELL_ALL_GATES_CLOSED;
                            memset(m_sunsReachData.m_gateCounters, 0, sizeof(m_sunsReachData.m_gateCounters));
                        }
                    }
                    else
                    {
                        m_sunsReachData.m_phase = 0;
                        m_sunsReachData.m_subphaseMask = 0;
                        memset(m_sunsReachData.m_sunsReachReclamationCounters, 0, sizeof(m_sunsReachData.m_sunsReachReclamationCounters));
                        m_sunsReachData.m_gate = SUNWELL_ALL_GATES_CLOSED;
                        memset(m_sunsReachData.m_gateCounters, 0, sizeof(m_sunsReachData.m_gateCounters));
                    }
                    break;
                }
            }
        } while (result->NextRow());
    }
    StartSunsReachPhase(true);
    StartSunwellGatePhase();
    HandleSunsReachSubPhaseTransition(m_sunsReachData.m_subphaseMask, true);
}

References CharacterDatabase, COUNTERS_MAX, COUNTERS_MAX_GATES, Field::Get(), HandleSunsReachSubPhaseTransition(), LOG_ERROR, SunsReachReclamationData::m_gate, SunsReachReclamationData::m_gateCounters, SunsReachReclamationData::m_phase, SunsReachReclamationData::m_subphaseMask, m_sunsReachData, SunsReachReclamationData::m_sunsReachReclamationCounters, SAVE_ID_QUEL_DANAS, StartSunsReachPhase(), StartSunwellGatePhase(), and SUNWELL_ALL_GATES_CLOSED.

LoadWorldStates()

void WorldState::LoadWorldStates

(

)

{
    uint32 oldMSTime = getMSTime();
 
    QueryResult result = CharacterDatabase.Query("SELECT entry, value FROM worldstates");
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 world states. DB table `worldstates` is empty!");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    do
    {
        Field* fields = result->Fetch();
        _worldstates[fields[0].Get<uint32>()] = fields[1].Get<uint32>();
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} World States in {} ms", _worldstates.size(), GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _worldstates, CharacterDatabase, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_INFO, and LOG_WARN.

Save()

void WorldState::Save

(

WorldStateSaveIds

saveId

)

{
    switch (saveId)
    {
        case SAVE_ID_QUEL_DANAS:
        {
            std::string expansionData = m_sunsReachData.GetData();
            SaveHelper(expansionData, SAVE_ID_QUEL_DANAS);
            break;
        }
        default:
            break;
    }
}

References SunsReachReclamationData::GetData(), m_sunsReachData, SAVE_ID_QUEL_DANAS, and SaveHelper().

Referenced by AddSunsReachProgress(), AddSunwellGateProgress(), HandleSunsReachPhaseTransition(), HandleSunsReachSubPhaseTransition(), and HandleSunwellGateTransition().

SaveHelper()

void WorldState::SaveHelper	(	std::string &	stringToSave,
		WorldStateSaveIds	saveId
	)

{
    CharacterDatabase.Execute("DELETE FROM world_state WHERE Id='{}'", saveId);
    CharacterDatabase.Execute("INSERT INTO world_state(Id,Data) VALUES('{}','{}')", saveId, stringToSave.data());
}

References CharacterDatabase.

Referenced by Save().

SendWorldstateUpdate()

void WorldState::SendWorldstateUpdate ( std::mutex &  mutex, GuidVector const &  guids, uint32  value, uint32  worldStateId  )

private

{
    std::lock_guard<std::mutex> guard(mutex);
    for (ObjectGuid const& guid : guids)
        if (Player* player = ObjectAccessor::FindPlayer(guid))
            player->SendUpdateWorldState(worldStateId, value);
}

References ObjectAccessor::FindPlayer().

Referenced by AddSunsReachProgress(), AddSunwellGateProgress(), HandleSunsReachPhaseTransition(), and HandleSunwellGateTransition().

SetSunsReachCounter()

void WorldState::SetSunsReachCounter	(	SunsReachCounters	index,
		uint32	value
	)

{
    m_sunsReachData.m_sunsReachReclamationCounters[index] = value;
}

References m_sunsReachData, and SunsReachReclamationData::m_sunsReachReclamationCounters.

SetSunwellGateCounter()

void WorldState::SetSunwellGateCounter	(	SunwellGateCounters	index,
		uint32	value
	)

{
    m_sunsReachData.m_gateCounters[index] = value;
}

References SunsReachReclamationData::m_gateCounters, and m_sunsReachData.

setWorldState()

void WorldState::setWorldState	(	uint32	index,
		uint64	value
	)

{
    auto const& it = _worldstates.find(index);
    if (it != _worldstates.end())
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_WORLDSTATE);
        stmt->SetData(0, uint32(timeValue));
        stmt->SetData(1, index);
        CharacterDatabase.Execute(stmt);
    }
    else
    {
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_WORLDSTATE);
        stmt->SetData(0, index);
        stmt->SetData(1, uint32(timeValue));
        CharacterDatabase.Execute(stmt);
    }
 
    _worldstates[index] = timeValue;
}

References _worldstates, CHAR_INS_WORLDSTATE, CHAR_UPD_WORLDSTATE, CharacterDatabase, and PreparedStatementBase::SetData().

StartSunsReachPhase()

void WorldState::StartSunsReachPhase ( bool  initial = false )

private

{
    switch (m_sunsReachData.m_phase)
    {
        case SUNS_REACH_PHASE_1_STAGING_AREA:
            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_1);
            if (Map* map = sMapMgr->FindBaseNonInstanceMap(MAP_OUTLAND))
                map->SetZoneWeather(AREA_ISLE_OF_QUEL_DANAS, WEATHER_STATE_MEDIUM_RAIN, 0.75f);
            break;
        case SUNS_REACH_PHASE_2_SANCTUM:
            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_ONLY);
            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT);
            if (Map* map = sMapMgr->FindBaseNonInstanceMap(MAP_OUTLAND))
                map->SetZoneWeather(AREA_ISLE_OF_QUEL_DANAS, WEATHER_STATE_LIGHT_RAIN, 0.5f);
            break;
        case SUNS_REACH_PHASE_3_ARMORY:
            if (initial)
                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT);
            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_ONLY); sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT);
            // TODO: Should be id 2 0.25f?
            if (Map* map = sMapMgr->FindBaseNonInstanceMap(MAP_OUTLAND))
                map->SetZoneWeather(AREA_ISLE_OF_QUEL_DANAS, WEATHER_STATE_LIGHT_RAIN, 0.25f);
            break;
        case SUNS_REACH_PHASE_4_HARBOR:
            if (initial)
            {
                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT);
                sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT);
            }
            sGameEventMgr->StartEvent(GAME_EVENT_QUEL_DANAS_PHASE_4);
            if (Map* map = sMapMgr->FindBaseNonInstanceMap(MAP_OUTLAND))
                map->SetZoneWeather(AREA_ISLE_OF_QUEL_DANAS, WEATHER_STATE_FINE, 0.0f);
            break;
        default: break;
    }
}

References AREA_ISLE_OF_QUEL_DANAS, GAME_EVENT_QUEL_DANAS_PHASE_1, GAME_EVENT_QUEL_DANAS_PHASE_2_ONLY, GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT, GAME_EVENT_QUEL_DANAS_PHASE_3_ONLY, GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT, GAME_EVENT_QUEL_DANAS_PHASE_4, SunsReachReclamationData::m_phase, m_sunsReachData, MAP_OUTLAND, sGameEventMgr, sMapMgr, SUNS_REACH_PHASE_1_STAGING_AREA, SUNS_REACH_PHASE_2_SANCTUM, SUNS_REACH_PHASE_3_ARMORY, SUNS_REACH_PHASE_4_HARBOR, WEATHER_STATE_FINE, WEATHER_STATE_LIGHT_RAIN, and WEATHER_STATE_MEDIUM_RAIN.

Referenced by HandleSunsReachPhaseTransition(), and Load().

StartSunwellGatePhase()

void WorldState::StartSunwellGatePhase ( )

private

{
    switch (m_sunsReachData.m_gate)
    {
        case SUNWELL_ALL_GATES_CLOSED: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_0); break;
        case SUNWELL_AGAMATH_GATE1_OPEN: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_1); break;
        case SUNWELL_ROHENDOR_GATE2_OPEN: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_2); break;
        case SUNWELL_ARCHONISUS_GATE3_OPEN: sGameEventMgr->StartEvent(GAME_EVENT_SWP_GATES_PHASE_3); break;
        default: break;
    }
}

References GAME_EVENT_SWP_GATES_PHASE_0, GAME_EVENT_SWP_GATES_PHASE_1, GAME_EVENT_SWP_GATES_PHASE_2, GAME_EVENT_SWP_GATES_PHASE_3, SunsReachReclamationData::m_gate, m_sunsReachData, sGameEventMgr, SUNWELL_AGAMATH_GATE1_OPEN, SUNWELL_ALL_GATES_CLOSED, SUNWELL_ARCHONISUS_GATE3_OPEN, and SUNWELL_ROHENDOR_GATE2_OPEN.

Referenced by HandleSunwellGateTransition(), and Load().

StopSunsReachPhase()

void WorldState::StopSunsReachPhase ( bool  forward )

private

{
    switch (m_sunsReachData.m_phase)
    {
        case SUNS_REACH_PHASE_1_STAGING_AREA: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_1); break;
        case SUNS_REACH_PHASE_2_SANCTUM: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_ONLY); if (!forward) sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT); break;
        case SUNS_REACH_PHASE_3_ARMORY: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_ONLY); if (!forward) sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT); break;
        case SUNS_REACH_PHASE_4_HARBOR: sGameEventMgr->StopEvent(GAME_EVENT_QUEL_DANAS_PHASE_4); break;
        default: break;
    }
}

References GAME_EVENT_QUEL_DANAS_PHASE_1, GAME_EVENT_QUEL_DANAS_PHASE_2_ONLY, GAME_EVENT_QUEL_DANAS_PHASE_2_PERMANENT, GAME_EVENT_QUEL_DANAS_PHASE_3_ONLY, GAME_EVENT_QUEL_DANAS_PHASE_3_PERMANENT, GAME_EVENT_QUEL_DANAS_PHASE_4, SunsReachReclamationData::m_phase, m_sunsReachData, sGameEventMgr, SUNS_REACH_PHASE_1_STAGING_AREA, SUNS_REACH_PHASE_2_SANCTUM, SUNS_REACH_PHASE_3_ARMORY, and SUNS_REACH_PHASE_4_HARBOR.

Referenced by HandleSunsReachPhaseTransition().

StopSunwellGatePhase()

void WorldState::StopSunwellGatePhase ( )

private

{
    switch (m_sunsReachData.m_gate)
    {
        case SUNWELL_ALL_GATES_CLOSED: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_0); break;
        case SUNWELL_AGAMATH_GATE1_OPEN: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_1); break;
        case SUNWELL_ROHENDOR_GATE2_OPEN: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_2); break;
        case SUNWELL_ARCHONISUS_GATE3_OPEN: sGameEventMgr->StopEvent(GAME_EVENT_SWP_GATES_PHASE_3); break;
        default: break;
    }
}

References GAME_EVENT_SWP_GATES_PHASE_0, GAME_EVENT_SWP_GATES_PHASE_1, GAME_EVENT_SWP_GATES_PHASE_2, GAME_EVENT_SWP_GATES_PHASE_3, SunsReachReclamationData::m_gate, m_sunsReachData, sGameEventMgr, SUNWELL_AGAMATH_GATE1_OPEN, SUNWELL_ALL_GATES_CLOSED, SUNWELL_ARCHONISUS_GATE3_OPEN, and SUNWELL_ROHENDOR_GATE2_OPEN.

Referenced by HandleSunwellGateTransition().

Update()

void WorldState::Update

(

uint32

diff

)

{
    if (_adalSongOfBattleTimer)
    {
        if (_adalSongOfBattleTimer <= diff)
        {
            _adalSongOfBattleTimer = 0;
            DispelAdalsSongOfBattle();
        }
        else
        {
            _adalSongOfBattleTimer -= diff;
        }
    }
}

References _adalSongOfBattleTimer, and DispelAdalsSongOfBattle().

Member Data Documentation

_adalSongOfBattleTimer

uint32 WorldState::_adalSongOfBattleTimer

private

Referenced by HandleExternalEvent(), HandlePlayerEnterZone(), HandlePlayerLeaveZone(), and Update().

_isMagtheridonHeadSpawnedAlliance

bool WorldState::_isMagtheridonHeadSpawnedAlliance

private

Referenced by HandleExternalEvent(), HandlePlayerEnterZone(), and IsConditionFulfilled().

_isMagtheridonHeadSpawnedHorde

bool WorldState::_isMagtheridonHeadSpawnedHorde

private

Referenced by HandleExternalEvent(), HandlePlayerEnterZone(), and IsConditionFulfilled().

_mutex

std::mutex WorldState::_mutex

private

Referenced by HandleExternalEvent(), HandlePlayerEnterZone(), and HandlePlayerLeaveZone().

_transportStates

std::map<WorldStateCondition, std::atomic<WorldStateConditionState> > WorldState::_transportStates

private

Referenced by HandleConditionStateChange(), IsConditionFulfilled(), and WorldState().

_worldstates

WorldStatesMap WorldState::_worldstates

private

Referenced by getWorldState(), LoadWorldStates(), and setWorldState().

m_sunsReachData

SunsReachReclamationData WorldState::m_sunsReachData

private

Referenced by AddSunsReachProgress(), AddSunwellGateProgress(), FillInitialWorldStates(), GetSunsReachPrintout(), HandlePlayerEnterZone(), HandlePlayerLeaveZone(), HandleSunsReachPhaseTransition(), HandleSunsReachSubPhaseTransition(), HandleSunwellGateTransition(), Load(), Save(), SetSunsReachCounter(), SetSunwellGateCounter(), StartSunsReachPhase(), StartSunwellGatePhase(), StopSunsReachPhase(), and StopSunwellGatePhase().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/World/WorldState.h
• azerothcore-wotlk/src/server/game/World/WorldState.cpp