GameEventMgr Class Reference

#include "GameEventMgr.h"

Public Types
typedef std::set< uint16 >	ActiveEvents
typedef std::vector< GameEventData >	GameEventDataMap

Public Member Functions
ActiveEvents const &	GetActiveEventList () const
GameEventDataMap const &	GetEventMap () const
bool	CheckOneGameEvent (uint16 entry) const
uint32	NextCheck (uint16 entry) const
void	LoadFromDB ()
void	LoadHolidayDates ()
uint32	Update ()
bool	IsActiveEvent (uint16 eventId)
uint32	StartSystem ()
void	Initialize ()
void	StartInternalEvent (uint16 event_id)
bool	StartEvent (uint16 event_id, bool overwrite=false)
void	StopEvent (uint16 event_id, bool overwrite=false)
void	HandleQuestComplete (uint32 quest_id)
uint32	GetNPCFlag (Creature *cr)
void	LoadEventVendors ()
uint32	GetHolidayEventId (uint32 holidayId) const
uint8	GetHolidayMainStage (uint32 holidayId) const

Static Public Member Functions
static GameEventMgr *	instance ()

Public Attributes
GameEventGuidMap	GameEventCreatureGuids
GameEventGuidMap	GameEventGameobjectGuids
std::vector< uint32 >	ModifiedHolidays

Private Types
typedef std::list< ObjectGuid::LowType >	GuidLowList
typedef std::list< uint32 >	IdList
typedef std::vector< GuidLowList >	GameEventGuidMap
typedef std::vector< IdList >	GameEventIdMap
typedef std::pair< ObjectGuid::LowType, ModelEquip >	ModelEquipPair
typedef std::list< ModelEquipPair >	ModelEquipList
typedef std::vector< ModelEquipList >	GameEventModelEquipMap
typedef std::pair< uint32, uint32 >	QuestRelation
typedef std::list< QuestRelation >	QuestRelList
typedef std::vector< QuestRelList >	GameEventQuestMap
typedef std::list< NPCVendorEntry >	NPCVendorList
typedef std::vector< NPCVendorList >	GameEventNPCVendorMap
typedef std::map< uint32, GameEventQuestToEventConditionNum >	QuestIdToEventConditionMap
typedef std::pair< ObjectGuid::LowType, uint32 >	GuidNPCFlagPair
typedef std::list< GuidNPCFlagPair >	NPCFlagList
typedef std::vector< NPCFlagList >	GameEventNPCFlagMap
typedef std::vector< uint32 >	GameEventBitmask
typedef std::unordered_map< uint32, std::vector< uint32 > >	GameEventSeasonalQuestsMap
typedef std::unordered_map< uint32, uint8 >	HolidayMainStageMap

Private Member Functions
	GameEventMgr ()
	~GameEventMgr ()=default
void	LoadEvents ()
void	LoadEventSaveData ()
void	LoadEventPrerequisiteData ()
void	LoadEventCreatureData ()
void	LoadEventGameObjectData ()
void	LoadEventModelEquipmentChangeData ()
void	LoadEventQuestData ()
void	LoadEventGameObjectQuestData ()
void	LoadEventQuestConditionData ()
void	LoadEventConditionData ()
void	LoadEventConditionSaveData ()
void	LoadEventNPCFlags ()
void	LoadEventSeasonalQuestRelations ()
void	LoadEventBattlegroundData ()
void	LoadEventPoolData ()
void	SendWorldStateUpdate (Player *player, uint16 eventId)
void	AddActiveEvent (uint16 eventId)
void	RemoveActiveEvent (uint16 eventId)
void	ApplyNewEvent (uint16 eventId)
void	UnApplyEvent (uint16 eventId)
void	GameEventSpawn (int16 eventId)
void	GameEventUnspawn (int16 eventId)
void	ChangeEquipOrModel (int16 eventId, bool activate)
void	UpdateEventQuests (uint16 eventId, bool activate)
void	UpdateWorldStates (uint16 eventId, bool Activate)
void	UpdateEventNPCFlags (uint16 eventId)
void	UpdateEventNPCVendor (uint16 eventId, bool activate)
void	UpdateBattlegroundSettings ()
void	RunSmartAIScripts (uint16 eventId, bool activate)
bool	CheckOneGameEventConditions (uint16 eventId)
	Runs SMART_EVENT_GAME_EVENT_START/_END SAI.
void	SaveWorldEventStateToDB (uint16 eventId)
bool	HasCreatureQuestActiveEventExcept (uint32 quest_id, uint16 eventId)
bool	HasGameObjectQuestActiveEventExcept (uint32 quest_id, uint16 eventId)
bool	HasCreatureActiveEventExcept (ObjectGuid::LowType creature_guid, uint16 eventId)
bool	HasGameObjectActiveEventExcept (ObjectGuid::LowType go_guid, uint16 eventId)
void	SetHolidayEventTime (GameEventData &event)

Private Attributes
GameEventQuestMap	_gameEventCreatureQuests
GameEventQuestMap	_gameEventGameObjectQuests
GameEventNPCVendorMap	_gameEventVendors
GameEventModelEquipMap	_gameEventModelEquip
GameEventIdMap	_gameEventPoolIds
GameEventDataMap	_gameEvent
GameEventBitmask	_gameEventBattlegroundHolidays
QuestIdToEventConditionMap	_questToEventConditions
GameEventNPCFlagMap	_gameEventNPCFlags
ActiveEvents	_activeEvents
bool	_isSystemInit
GameEventSeasonalQuestsMap	_gameEventSeasonalQuestsMap
HolidayMainStageMap	_holidayMainStages

Detailed Description

Member Typedef Documentation

ActiveEvents

typedef std::set<uint16> GameEventMgr::ActiveEvents

GameEventBitmask

typedef std::vector<uint32> GameEventMgr::GameEventBitmask

private

GameEventDataMap

typedef std::vector<GameEventData> GameEventMgr::GameEventDataMap

GameEventGuidMap

typedef std::vector<GuidLowList> GameEventMgr::GameEventGuidMap

private

GameEventIdMap

typedef std::vector<IdList> GameEventMgr::GameEventIdMap

private

GameEventModelEquipMap

typedef std::vector<ModelEquipList> GameEventMgr::GameEventModelEquipMap

private

GameEventNPCFlagMap

typedef std::vector<NPCFlagList> GameEventMgr::GameEventNPCFlagMap

private

GameEventNPCVendorMap

typedef std::vector<NPCVendorList> GameEventMgr::GameEventNPCVendorMap

private

GameEventQuestMap

typedef std::vector<QuestRelList> GameEventMgr::GameEventQuestMap

private

GameEventSeasonalQuestsMap

typedef std::unordered_map<uint32, std::vector<uint32> > GameEventMgr::GameEventSeasonalQuestsMap

private

GuidLowList

typedef std::list<ObjectGuid::LowType> GameEventMgr::GuidLowList

private

GuidNPCFlagPair

typedef std::pair<ObjectGuid::LowType , uint32 > GameEventMgr::GuidNPCFlagPair

private

HolidayMainStageMap

typedef std::unordered_map<uint32 , uint8 > GameEventMgr::HolidayMainStageMap

private

IdList

typedef std::list<uint32> GameEventMgr::IdList

private

ModelEquipList

typedef std::list<ModelEquipPair> GameEventMgr::ModelEquipList

private

ModelEquipPair

typedef std::pair<ObjectGuid::LowType, ModelEquip> GameEventMgr::ModelEquipPair

private

NPCFlagList

typedef std::list<GuidNPCFlagPair> GameEventMgr::NPCFlagList

private

NPCVendorList

typedef std::list<NPCVendorEntry> GameEventMgr::NPCVendorList

private

QuestIdToEventConditionMap

typedef std::map<uint32 , GameEventQuestToEventConditionNum> GameEventMgr::QuestIdToEventConditionMap

private

QuestRelation

typedef std::pair<uint32, uint32> GameEventMgr::QuestRelation

private

QuestRelList

typedef std::list<QuestRelation> GameEventMgr::QuestRelList

private

Constructor & Destructor Documentation

GameEventMgr()

GameEventMgr::GameEventMgr ( )

private

                           : _isSystemInit(false)
{
}

~GameEventMgr()

GameEventMgr::~GameEventMgr ( )

privatedefault

Member Function Documentation

AddActiveEvent()

void GameEventMgr::AddActiveEvent ( uint16  eventId )

inlineprivate

{ _activeEvents.insert(eventId); }

References _activeEvents.

Referenced by StartEvent().

ApplyNewEvent()

void GameEventMgr::ApplyNewEvent ( uint16  eventId )

private

Run SAI scripts with SMART_EVENT_GAME_EVENT_START

{
    uint8 announce = _gameEvent[eventId].Announce;
    if (announce == 1 || (announce == 2 && sWorld->getIntConfig(CONFIG_EVENT_ANNOUNCE)))
        ChatHandler(nullptr).SendWorldText(LANG_EVENTMESSAGE, _gameEvent[eventId].Description);
 
    LOG_DEBUG("gameevent", "GameEvent {} \"{}\" started.", eventId, _gameEvent[eventId].Description);
 
    // spawn positive event tagget objects
    GameEventSpawn(eventId);
    // un-spawn negative event tagged objects
    int16 numEventId = (-1) * eventId;
    GameEventUnspawn(numEventId);
    // Change equipement or model
    ChangeEquipOrModel(eventId, true);
    // Add quests that are events only to non event npc
    UpdateEventQuests(eventId, true);
    UpdateWorldStates(eventId, true);
    // update npcflags in this event
    UpdateEventNPCFlags(eventId);
    // add vendor items
    UpdateEventNPCVendor(eventId, true);
    // update bg holiday
    UpdateBattlegroundSettings();
 
    RunSmartAIScripts(eventId, true);
 
    // If event's worldstate is 0, it means the event hasn't been started yet. In that case, reset seasonal quests.
    // When event ends (if it expires or if it's stopped via commands) worldstate will be set to 0 again, ready for another seasonal quest reset.
    if (sWorldState->getWorldState(eventId) == 0)
    {
        sWorld->ResetEventSeasonalQuests(eventId);
    }
}

References _gameEvent, ChangeEquipOrModel(), CONFIG_EVENT_ANNOUNCE, GameEventSpawn(), GameEventUnspawn(), LANG_EVENTMESSAGE, LOG_DEBUG, RunSmartAIScripts(), ChatHandler::SendWorldText(), sWorld, sWorldState, UpdateBattlegroundSettings(), UpdateEventNPCFlags(), UpdateEventNPCVendor(), UpdateEventQuests(), and UpdateWorldStates().

Referenced by StartEvent().

ChangeEquipOrModel()

void GameEventMgr::ChangeEquipOrModel ( int16  eventId, bool  activate  )

private

{
    for (ModelEquipList::iterator itr = _gameEventModelEquip[eventId].begin(); itr != _gameEventModelEquip[eventId].end(); ++itr)
    {
        // Remove the creature from grid
        CreatureData const* data = sObjectMgr->GetCreatureData(itr->first);
        if (!data)
            continue;
 
        // Update if spawned
        sMapMgr->DoForAllMapsWithMapId(data->mapid, [&itr, activate](Map* map)
        {
            auto creatureBounds = map->GetCreatureBySpawnIdStore().equal_range(itr->first);
            for (auto itr2 = creatureBounds.first; itr2 != creatureBounds.second; ++itr2)
            {
                Creature* creature = itr2->second;
                if (activate)
                {
                    itr->second.EquipementIdPrev = creature->GetCurrentEquipmentId();
                    itr->second.ModelIdPrev = creature->GetDisplayId();
                    creature->LoadEquipment(itr->second.EquipmentId, true);
                    if (itr->second.ModelId > 0 && itr->second.ModelIdPrev != itr->second.ModelId && sObjectMgr->GetCreatureModelInfo(itr->second.ModelId))
                    {
                        creature->SetDisplayId(itr->second.ModelId);
                        creature->SetNativeDisplayId(itr->second.ModelId);
                    }
                }
                else
                {
                    creature->LoadEquipment(itr->second.EquipementIdPrev, true);
                    if (itr->second.ModelIdPrev > 0 && itr->second.ModelIdPrev != itr->second.ModelId && sObjectMgr->GetCreatureModelInfo(itr->second.ModelIdPrev))
                    {
                        creature->SetDisplayId(itr->second.ModelIdPrev);
                        creature->SetNativeDisplayId(itr->second.ModelIdPrev);
                    }
                }
            }
        });
 
        // now last step: put in data
        // just to have write access to it
        CreatureData& data2 = sObjectMgr->NewOrExistCreatureData(itr->first);
        if (activate)
        {
            itr->second.ModelIdPrev = data2.displayid;
            itr->second.EquipementIdPrev = data2.equipmentId;
            data2.displayid = itr->second.ModelId;
            data2.equipmentId = itr->second.EquipmentId;
        }
        else
        {
            data2.displayid = itr->second.ModelIdPrev;
            data2.equipmentId = itr->second.EquipementIdPrev;
        }
    }
}

References _gameEventModelEquip, CreatureData::displayid, CreatureData::equipmentId, SpawnData::mapid, sMapMgr, and sObjectMgr.

Referenced by ApplyNewEvent(), and UnApplyEvent().

CheckOneGameEvent()

bool GameEventMgr::CheckOneGameEvent

(

uint16

entry

)

const

{
    switch (_gameEvent[entry].State)
    {
        default:
        case GAMEEVENT_NORMAL:
            {
                time_t currenttime = GameTime::GetGameTime().count();
                // Get the event information
                return _gameEvent[entry].Start < currenttime
                       && currenttime < _gameEvent[entry].End
                       && (currenttime - _gameEvent[entry].Start) % (_gameEvent[entry].Occurence * MINUTE) < _gameEvent[entry].Length * MINUTE;
            }
        // if the state is conditions or nextphase, then the event should be active
        case GAMEEVENT_WORLD_CONDITIONS:
        case GAMEEVENT_WORLD_NEXTPHASE:
            return true;
        // finished world events are inactive
        case GAMEEVENT_WORLD_FINISHED:
        case GAMEEVENT_INTERNAL:
            return false;
        // if inactive world event, check the prerequisite events
        case GAMEEVENT_WORLD_INACTIVE:
            {
                time_t currenttime = GameTime::GetGameTime().count();
                for (std::set<uint16>::const_iterator itr = _gameEvent[entry].PrerequisiteEvents.begin(); itr != _gameEvent[entry].PrerequisiteEvents.end(); ++itr)
                {
                    if ((_gameEvent[*itr].State != GAMEEVENT_WORLD_NEXTPHASE && _gameEvent[*itr].State != GAMEEVENT_WORLD_FINISHED) ||   // if prereq not in nextphase or finished state, then can't start this one
                            _gameEvent[*itr].NextStart > currenttime)               // if not in nextphase state for long enough, can't start this one
                        return false;
                }
                // all prerequisite events are met
                // but if there are no prerequisites, this can be only activated through gm command
                return !(_gameEvent[entry].PrerequisiteEvents.empty());
            }
    }
}

References _gameEvent, GAMEEVENT_INTERNAL, GAMEEVENT_NORMAL, GAMEEVENT_WORLD_CONDITIONS, GAMEEVENT_WORLD_FINISHED, GAMEEVENT_WORLD_INACTIVE, GAMEEVENT_WORLD_NEXTPHASE, GameTime::GetGameTime(), and MINUTE.

Referenced by Update().

CheckOneGameEventConditions()

bool GameEventMgr::CheckOneGameEventConditions ( uint16  eventId )

private

Runs SMART_EVENT_GAME_EVENT_START/_END SAI.

{
    for (GameEventConditionMap::const_iterator itr = _gameEvent[eventId].Conditions.begin(); itr != _gameEvent[eventId].Conditions.end(); ++itr)
        if (itr->second.Done < itr->second.ReqNum)
            // return false if a condition doesn't match
            return false;
    // set the phase
    _gameEvent[eventId].State = GAMEEVENT_WORLD_NEXTPHASE;
    // set the followup events' start time
    if (!_gameEvent[eventId].NextStart)
    {
        time_t currenttime = GameTime::GetGameTime().count();
        _gameEvent[eventId].NextStart = currenttime + _gameEvent[eventId].Length * 60;
    }
    return true;
}

References _gameEvent, GAMEEVENT_WORLD_NEXTPHASE, and GameTime::GetGameTime().

Referenced by HandleQuestComplete(), StartEvent(), and Update().

GameEventSpawn()

void GameEventMgr::GameEventSpawn ( int16  eventId )

private

{
    int32 internal_event_id = _gameEvent.size() + eventId - 1;
 
    if (internal_event_id < 0 || internal_event_id >= int32(GameEventCreatureGuids.size()))
    {
        LOG_ERROR("gameevent", "GameEventMgr::GameEventSpawn attempt access to out of range mGameEventCreatureGuids element {} (size: {})",
                       internal_event_id, GameEventCreatureGuids.size());
        return;
    }
 
    for (GuidLowList::iterator itr = GameEventCreatureGuids[internal_event_id].begin(); itr != GameEventCreatureGuids[internal_event_id].end(); ++itr)
    {
        // Add to correct cell
        if (CreatureData const* data = sObjectMgr->GetCreatureData(*itr))
        {
            sObjectMgr->AddCreatureToGrid(*itr, data);
 
            // Spawn if necessary (loaded grids only)
            Map* map = sMapMgr->CreateBaseMap(data->mapid);
            // We use spawn coords to spawn
            if (!map->Instanceable() && map->IsGridLoaded(data->posX, data->posY))
            {
                Creature* creature = new Creature;
                if (!creature->LoadCreatureFromDB(*itr, map))
                    delete creature;
            }
        }
    }
 
    if (internal_event_id >= int32(GameEventGameobjectGuids.size()))
    {
        LOG_ERROR("gameevent", "GameEventMgr::GameEventSpawn attempt access to out of range mGameEventGameobjectGuids element {} (size: {})",
                       internal_event_id, GameEventGameobjectGuids.size());
        return;
    }
 
    for (GuidLowList::iterator itr = GameEventGameobjectGuids[internal_event_id].begin(); itr != GameEventGameobjectGuids[internal_event_id].end(); ++itr)
    {
        // Add to correct cell
        if (GameObjectData const* data = sObjectMgr->GetGameObjectData(*itr))
        {
            sObjectMgr->AddGameobjectToGrid(*itr, data);
            // Spawn if necessary (loaded grids only)
            // this base map checked as non-instanced and then only existed
            Map* map = sMapMgr->CreateBaseMap(data->mapid);
            // We use current coords to unspawn, not spawn coords since creature can have changed grid
            if (!map->Instanceable() && map->IsGridLoaded(data->posX, data->posY))
            {
                GameObject* pGameobject = sObjectMgr->IsGameObjectStaticTransport(data->id) ? new StaticTransport() : new GameObject();
                //TODO: find out when it is add to map
                if (!pGameobject->LoadGameObjectFromDB(*itr, map, false))
                    delete pGameobject;
                else
                {
                    if (pGameobject->isSpawnedByDefault())
                        map->AddToMap(pGameobject);
                }
            }
        }
    }
 
    if (internal_event_id >= int32(_gameEventPoolIds.size()))
    {
        LOG_ERROR("gameevent", "GameEventMgr::GameEventSpawn attempt access to out of range _gameEventPoolIds element {} (size: {})",
                       internal_event_id, _gameEventPoolIds.size());
        return;
    }
 
    for (IdList::iterator itr = _gameEventPoolIds[internal_event_id].begin(); itr != _gameEventPoolIds[internal_event_id].end(); ++itr)
        sPoolMgr->SpawnEventPool(*itr);
}

References _gameEvent, _gameEventPoolIds, Map::AddToMap(), GameEventCreatureGuids, GameEventGameobjectGuids, Map::Instanceable(), Map::IsGridLoaded(), GameObject::isSpawnedByDefault(), Creature::LoadCreatureFromDB(), GameObject::LoadGameObjectFromDB(), LOG_ERROR, sMapMgr, sObjectMgr, and sPoolMgr.

Referenced by ApplyNewEvent(), UnApplyEvent(), and Update().

GameEventUnspawn()

void GameEventMgr::GameEventUnspawn ( int16  eventId )

private

{
    int32 internal_event_id = _gameEvent.size() + eventId - 1;
 
    if (internal_event_id < 0 || internal_event_id >= int32(GameEventCreatureGuids.size()))
    {
        LOG_ERROR("gameevent", "GameEventMgr::GameEventUnspawn attempt access to out of range GameEventCreatureGuids element {} (size: {})",
                       internal_event_id, GameEventCreatureGuids.size());
        return;
    }
 
    for (GuidLowList::iterator itr = GameEventCreatureGuids[internal_event_id].begin(); itr != GameEventCreatureGuids[internal_event_id].end(); ++itr)
    {
        // check if it's needed by another event, if so, don't remove
        if (eventId > 0 && HasCreatureActiveEventExcept(*itr, eventId))
            continue;
 
        // Remove the creature from grid
        if (CreatureData const* data = sObjectMgr->GetCreatureData(*itr))
        {
            sObjectMgr->RemoveCreatureFromGrid(*itr, data);
 
            sMapMgr->DoForAllMapsWithMapId(data->mapid, [&itr](Map* map)
            {
                auto creatureBounds = map->GetCreatureBySpawnIdStore().equal_range(*itr);
                for (auto itr2 = creatureBounds.first; itr2 != creatureBounds.second;)
                {
                    Creature* creature = itr2->second;
                    ++itr2;
                    creature->AddObjectToRemoveList();
                }
            });
        }
    }
 
    if (internal_event_id >= int32(GameEventGameobjectGuids.size()))
    {
        LOG_ERROR("gameevent", "GameEventMgr::GameEventUnspawn attempt access to out of range GameEventGameobjectGuids element {} (size: {})",
                       internal_event_id, GameEventGameobjectGuids.size());
        return;
    }
 
    for (GuidLowList::iterator itr = GameEventGameobjectGuids[internal_event_id].begin(); itr != GameEventGameobjectGuids[internal_event_id].end(); ++itr)
    {
        // check if it's needed by another event, if so, don't remove
        if (eventId > 0 && HasGameObjectActiveEventExcept(*itr, eventId))
            continue;
        // Remove the gameobject from grid
        if (GameObjectData const* data = sObjectMgr->GetGameObjectData(*itr))
        {
            sObjectMgr->RemoveGameobjectFromGrid(*itr, data);
 
            sMapMgr->DoForAllMapsWithMapId(data->mapid, [&itr](Map* map)
            {
                auto gameobjectBounds = map->GetGameObjectBySpawnIdStore().equal_range(*itr);
                for (auto itr2 = gameobjectBounds.first; itr2 != gameobjectBounds.second;)
                {
                    GameObject* go = itr2->second;
                    ++itr2;
                    go->AddObjectToRemoveList();
                }
            });
        }
    }
    if (internal_event_id >= int32(_gameEventPoolIds.size()))
    {
        LOG_ERROR("gameevent", "GameEventMgr::GameEventUnspawn attempt access to out of range mGameEventPoolIds element {} (size: {})", internal_event_id, _gameEventPoolIds.size());
        return;
    }
 
    for (IdList::iterator itr = _gameEventPoolIds[internal_event_id].begin(); itr != _gameEventPoolIds[internal_event_id].end(); ++itr)
    {
        sPoolMgr->DespawnEventPool(*itr);
    }
}

References _gameEvent, GameEventCreatureGuids, HasCreatureActiveEventExcept(), LOG_ERROR, sMapMgr, and sObjectMgr.

Referenced by ApplyNewEvent(), and UnApplyEvent().

GetActiveEventList()

ActiveEvents const & GameEventMgr::GetActiveEventList ( ) const

inline

{ return _activeEvents; }

References _activeEvents.

GetEventMap()

GameEventDataMap const & GameEventMgr::GetEventMap ( ) const

inline

{ return _gameEvent; }

References _gameEvent.

Referenced by GetHolidayEventId().

GetHolidayEventId()

uint32 GameEventMgr::GetHolidayEventId

(

uint32

holidayId

)

const

{
    auto const& events = GetEventMap();
    uint8 mainStage = GetHolidayMainStage(holidayId);
 
    for (auto const& eventEntry : events)
    {
        if (eventEntry.HolidayId == holidayId && eventEntry.HolidayStage == mainStage)
        {
            return eventEntry.EventId;
        }
    }
 
    return 0;
}

References GetEventMap(), and GetHolidayMainStage().

GetHolidayMainStage()

uint8 GameEventMgr::GetHolidayMainStage

(

uint32

holidayId

)

const

{
    auto itr = _holidayMainStages.find(holidayId);
    return itr != _holidayMainStages.end() ? itr->second : 0;
}

References _holidayMainStages.

Referenced by GetHolidayEventId().

GetNPCFlag()

uint32 GameEventMgr::GetNPCFlag

(

Creature *

cr

)

{
    uint32 mask = 0;
    ObjectGuid::LowType spawnId = cr->GetSpawnId();
 
    for (ActiveEvents::iterator e_itr = _activeEvents.begin(); e_itr != _activeEvents.end(); ++e_itr)
    {
        for (NPCFlagList::iterator itr = _gameEventNPCFlags[*e_itr].begin(); itr != _gameEventNPCFlags[*e_itr].end(); ++ itr)
            if (itr->first == spawnId)
                mask |= itr->second;
    }
 
    return mask;
}

References _activeEvents, _gameEventNPCFlags, and Creature::GetSpawnId().

Referenced by UpdateEventNPCFlags().

HandleQuestComplete()

void GameEventMgr::HandleQuestComplete

(

uint32

quest_id

)

{
    // translate the quest to event and condition
    QuestIdToEventConditionMap::iterator itr = _questToEventConditions.find(quest_id);
    // quest is registered
    if (itr != _questToEventConditions.end())
    {
        uint16 eventId = itr->second.EventId;
        uint32 condition = itr->second.Condition;
        float num = itr->second.Num;
 
        // the event is not active, so return, don't increase condition finishes
        if (!IsActiveEvent(eventId))
            return;
        // not in correct phase, return
        if (_gameEvent[eventId].State != GAMEEVENT_WORLD_CONDITIONS)
            return;
        GameEventConditionMap::iterator citr = _gameEvent[eventId].Conditions.find(condition);
        // condition is registered
        if (citr != _gameEvent[eventId].Conditions.end())
        {
            // increase the done count, only if less then the req
            if (citr->second.Done < citr->second.ReqNum)
            {
                citr->second.Done += num;
                // check max limit
                if (citr->second.Done > citr->second.ReqNum)
                    citr->second.Done = citr->second.ReqNum;
                // save the change to db
                CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
                CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GAME_EVENT_CONDITION_SAVE);
                stmt->SetData(0, uint8(eventId));
                stmt->SetData(1, condition);
                trans->Append(stmt);
 
                stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GAME_EVENT_CONDITION_SAVE);
                stmt->SetData(0, uint8(eventId));
                stmt->SetData(1, condition);
                stmt->SetData(2, citr->second.Done);
                trans->Append(stmt);
                CharacterDatabase.CommitTransaction(trans);
                // check if all conditions are met, if so, update the event state
                if (CheckOneGameEventConditions(eventId))
                {
                    // changed, save to DB the gameevent state
                    SaveWorldEventStateToDB(eventId);
                    // force update events to set timer
                    sWorld->ForceGameEventUpdate();
                }
            }
        }
    }
}

References _gameEvent, _questToEventConditions, CHAR_DEL_GAME_EVENT_CONDITION_SAVE, CHAR_INS_GAME_EVENT_CONDITION_SAVE, CharacterDatabase, CheckOneGameEventConditions(), GAMEEVENT_WORLD_CONDITIONS, IsActiveEvent(), SaveWorldEventStateToDB(), PreparedStatementBase::SetData(), and sWorld.

HasCreatureActiveEventExcept()

bool GameEventMgr::HasCreatureActiveEventExcept ( ObjectGuid::LowType  creature_guid, uint16  eventId  )

private

{
    for (ActiveEvents::iterator e_itr = _activeEvents.begin(); e_itr != _activeEvents.end(); ++e_itr)
    {
        if ((*e_itr) != eventId)
        {
            int32 internal_event_id = _gameEvent.size() + (*e_itr) - 1;
            for (GuidLowList::iterator itr = GameEventCreatureGuids[internal_event_id].begin(); itr != GameEventCreatureGuids[internal_event_id].end(); ++ itr)
                if (*itr == creature_guid)
                    return true;
        }
    }
    return false;
}

References _activeEvents, _gameEvent, and GameEventCreatureGuids.

Referenced by GameEventUnspawn().

HasCreatureQuestActiveEventExcept()

bool GameEventMgr::HasCreatureQuestActiveEventExcept ( uint32  quest_id, uint16  eventId  )

private

{
    for (ActiveEvents::iterator e_itr = _activeEvents.begin(); e_itr != _activeEvents.end(); ++e_itr)
    {
        if ((*e_itr) != eventId)
            for (QuestRelList::iterator itr = _gameEventCreatureQuests[*e_itr].begin();
                    itr != _gameEventCreatureQuests[*e_itr].end();
                    ++ itr)
                if (itr->second == quest_id)
                    return true;
    }
    return false;
}

References _activeEvents, and _gameEventCreatureQuests.

Referenced by UpdateEventQuests().

HasGameObjectActiveEventExcept()

bool GameEventMgr::HasGameObjectActiveEventExcept ( ObjectGuid::LowType  go_guid, uint16  eventId  )

private

{
    for (ActiveEvents::iterator e_itr = _activeEvents.begin(); e_itr != _activeEvents.end(); ++e_itr)
    {
        if ((*e_itr) != eventId)
        {
            int32 internal_event_id = _gameEvent.size() + (*e_itr) - 1;
            for (GuidLowList::iterator itr = GameEventGameobjectGuids[internal_event_id].begin(); itr != GameEventGameobjectGuids[internal_event_id].end(); ++ itr)
                if (*itr == go_guid)
                    return true;
        }
    }
    return false;
}

References _activeEvents, _gameEvent, and GameEventGameobjectGuids.

HasGameObjectQuestActiveEventExcept()

bool GameEventMgr::HasGameObjectQuestActiveEventExcept ( uint32  quest_id, uint16  eventId  )

private

{
    for (ActiveEvents::iterator e_itr = _activeEvents.begin(); e_itr != _activeEvents.end(); ++e_itr)
    {
        if ((*e_itr) != eventId)
            for (QuestRelList::iterator itr = _gameEventGameObjectQuests[*e_itr].begin();
                    itr != _gameEventGameObjectQuests[*e_itr].end();
                    ++ itr)
                if (itr->second == quest_id)
                    return true;
    }
    return false;
}

References _activeEvents, and _gameEventGameObjectQuests.

Referenced by UpdateEventQuests().

Initialize()

void GameEventMgr::Initialize

(

)

{
    QueryResult result = WorldDatabase.Query("SELECT MAX(eventEntry) FROM game_event");
    if (result)
    {
        Field* fields = result->Fetch();
 
        uint32 maxEventId = fields[0].Get<uint8>();
 
        // Id starts with 1 and vector with 0, thus increment
        maxEventId++;
 
        _gameEvent.resize(maxEventId);
        GameEventCreatureGuids.resize(maxEventId * 2 - 1);
        GameEventGameobjectGuids.resize(maxEventId * 2 - 1);
        _gameEventCreatureQuests.resize(maxEventId);
        _gameEventGameObjectQuests.resize(maxEventId);
        _gameEventVendors.resize(maxEventId);
        _gameEventBattlegroundHolidays.resize(maxEventId, 0);
        _gameEventPoolIds.resize(maxEventId * 2 - 1);
        _gameEventNPCFlags.resize(maxEventId);
        _gameEventModelEquip.resize(maxEventId);
    }
}

References _gameEvent, _gameEventBattlegroundHolidays, _gameEventCreatureQuests, _gameEventGameObjectQuests, _gameEventModelEquip, _gameEventNPCFlags, _gameEventPoolIds, _gameEventVendors, GameEventCreatureGuids, GameEventGameobjectGuids, Field::Get(), and WorldDatabase.

instance()

GameEventMgr * GameEventMgr::instance ( )

static

{
    static GameEventMgr instance;
    return &instance;
}

References instance().

Referenced by instance().

IsActiveEvent()

bool GameEventMgr::IsActiveEvent ( uint16  eventId )

inline

{ return (_activeEvents.find(eventId) != _activeEvents.end()); }

References _activeEvents.

Referenced by HandleQuestComplete(), StartEvent(), StopEvent(), and Update().

LoadEventBattlegroundData()

void GameEventMgr::LoadEventBattlegroundData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Battleground Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_BATTLEGROUND_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Battleground Holidays In Game Events. DB table `game_event_battleground_holiday` is empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint16 eventId = fields[0].Get<uint8>();
 
            if (eventId >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_battleground_holiday` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            _gameEventBattlegroundHolidays[eventId] = fields[1].Get<uint32>();
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Battleground Holidays In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, _gameEventBattlegroundHolidays, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, WORLD_SEL_GAME_EVENT_BATTLEGROUND_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventConditionData()

void GameEventMgr::LoadEventConditionData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Condition Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_CONDITION_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Conditions In Game Events. DB table `game_event_condition` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint16 eventId = fields[0].Get<uint8>();
            uint32 condition = fields[1].Get<uint32>();
 
            if (eventId >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_condition` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            _gameEvent[eventId].Conditions[condition].ReqNum = fields[2].Get<float>();
            _gameEvent[eventId].Conditions[condition].Done = 0;
            _gameEvent[eventId].Conditions[condition].MaxWorldState = fields[3].Get<uint16>();
            _gameEvent[eventId].Conditions[condition].DoneWorldState = fields[4].Get<uint16>();
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} conditions in Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, WORLD_SEL_GAME_EVENT_CONDITION_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventConditionSaveData()

void GameEventMgr::LoadEventConditionSaveData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Condition Save Data...");
 
    uint32 oldMSTime = getMSTime();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GAME_EVENT_CONDITION_SAVE_DATA);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Condition Saves In Game Events. DB Table `game_event_condition_save` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint16 eventId = fields[0].Get<uint8>();
            uint32 condition = fields[1].Get<uint32>();
 
            if (eventId >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_condition_save` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            GameEventConditionMap::iterator itr = _gameEvent[eventId].Conditions.find(condition);
            if (itr != _gameEvent[eventId].Conditions.end())
            {
                itr->second.Done = fields[2].Get<float>();
            }
            else
            {
                LOG_ERROR("sql.sql", "game_event_condition_save contains not present condition evt id {} cond id {}", eventId, condition);
                continue;
            }
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Condition Saves In Game Events In {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, CHAR_SEL_GAME_EVENT_CONDITION_SAVE_DATA, CharacterDatabase, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, and LOG_WARN.

Referenced by LoadFromDB().

LoadEventCreatureData()

void GameEventMgr::LoadEventCreatureData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Creature Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_CREATURE_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 creatures in game events. DB table `game_event_creature` is empty");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            ObjectGuid::LowType guid = fields[0].Get<uint32>();
            int16 eventId = fields[1].Get<int16>();
 
            CreatureData const* data = sObjectMgr->GetCreatureData(guid);
            if (!data)
            {
                LOG_ERROR("sql.sql", "`game_event_creature` contains creature (GUID: {}) not found in `creature` table.", guid);
                continue;
            }
 
            int32 internal_event_id = _gameEvent.size() + eventId - 1;
 
            if (internal_event_id < 0 || internal_event_id >= int32(GameEventCreatureGuids.size()))
            {
                LOG_ERROR("sql.sql", "`game_event_creature` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            GuidLowList& crelist = GameEventCreatureGuids[internal_event_id];
            crelist.push_back(guid);
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Creatures In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, GameEventCreatureGuids, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, sObjectMgr, WORLD_SEL_GAME_EVENT_CREATURE_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventGameObjectData()

void GameEventMgr::LoadEventGameObjectData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event GO Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_GAMEOBJECT_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 gameobjects in game events. DB table `game_event_gameobject` is empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            ObjectGuid::LowType guid = fields[0].Get<uint32>();
            int16 eventId = fields[1].Get<int16>();
 
            int32 internal_event_id = _gameEvent.size() + eventId - 1;
 
            GameObjectData const* data = sObjectMgr->GetGameObjectData(guid);
            if (!data)
            {
                LOG_ERROR("sql.sql", "`game_event_gameobject` contains gameobject (GUID: {}) not found in `gameobject` table.", guid);
                continue;
            }
 
            if (internal_event_id < 0 || internal_event_id >= int32(GameEventGameobjectGuids.size()))
            {
                LOG_ERROR("sql.sql", "`game_event_gameobject` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            GuidLowList& golist = GameEventGameobjectGuids[internal_event_id];
            golist.push_back(guid);
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Gameobjects In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, GameEventGameobjectGuids, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, sObjectMgr, WORLD_SEL_GAME_EVENT_GAMEOBJECT_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventGameObjectQuestData()

void GameEventMgr::LoadEventGameObjectQuestData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event GO Quest Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_GAMEOBJECT_QUEST_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 go Quests Additions In Game Events. DB Table `game_event_gameobject_quest` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint32 id = fields[0].Get<uint32>();
            uint32 quest = fields[1].Get<uint32>();
            uint16 eventId = fields[2].Get<uint8>();
 
            if (eventId >= _gameEventGameObjectQuests.size())
            {
                LOG_ERROR("sql.sql", "`game_event_gameobject_quest` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            QuestRelList& questlist = _gameEventGameObjectQuests[eventId];
            questlist.push_back(QuestRelation(id, quest));
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Quests Additions In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEventGameObjectQuests, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, WORLD_SEL_GAME_EVENT_GAMEOBJECT_QUEST_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventModelEquipmentChangeData()

void GameEventMgr::LoadEventModelEquipmentChangeData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Model/Equipment Change Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_MODEL_EQUIPMENT_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Model/Equipment Changes In Game Events. DB Table `game_event_model_equip` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            ObjectGuid::LowType guid = fields[0].Get<uint32>();
            uint32 entry = fields[1].Get<uint32>();
            uint16 eventId = fields[2].Get<uint8>();
 
            if (eventId >= _gameEventModelEquip.size())
            {
                LOG_ERROR("sql.sql", "`game_event_model_equip` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            ModelEquipList& equiplist = _gameEventModelEquip[eventId];
            ModelEquip newModelEquipSet;
            newModelEquipSet.ModelId = fields[3].Get<uint32>();
            newModelEquipSet.EquipmentId = fields[4].Get<uint8>();
            newModelEquipSet.EquipementIdPrev = 0;
            newModelEquipSet.ModelIdPrev = 0;
 
            if (newModelEquipSet.EquipmentId > 0)
            {
                int8 equipId = static_cast<int8>(newModelEquipSet.EquipmentId);
                if (!sObjectMgr->GetEquipmentInfo(entry, equipId))
                {
                    LOG_ERROR("sql.sql", "Table `game_event_model_equip` have creature (Guid: {}) with equipment_id {} not found in table `creature_equip_template`, set to no equipment.",
                        guid, newModelEquipSet.EquipmentId);
                    continue;
                }
            }
 
            equiplist.push_back(std::pair<ObjectGuid::LowType, ModelEquip>(guid, newModelEquipSet));
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Model/Equipment Changes In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEventModelEquip, ModelEquip::EquipementIdPrev, ModelEquip::EquipmentId, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, ModelEquip::ModelId, ModelEquip::ModelIdPrev, sObjectMgr, WORLD_SEL_GAME_EVENT_MODEL_EQUIPMENT_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventNPCFlags()

void GameEventMgr::LoadEventNPCFlags ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event NPCflag Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement * stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_NPC_FLAGS);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Npcflags In Game Events. DB Table `game_event_npcflag` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            ObjectGuid::LowType guid = fields[0].Get<uint32>();
            uint16 eventId = fields[1].Get<uint8>();
            uint32 npcflag = fields[2].Get<uint32>();
 
            if (eventId >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_npcflag` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            _gameEventNPCFlags[eventId].push_back(GuidNPCFlagPair(guid, npcflag));
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Npcflags In Game Events In {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, _gameEventNPCFlags, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, WORLD_SEL_GAME_EVENT_NPC_FLAGS, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventPoolData()

void GameEventMgr::LoadEventPoolData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Pool Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_POOL_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Pools For Game Events. DB Table `game_event_pool` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint32 entry = fields[0].Get<uint32>();
            int16 eventId = fields[1].Get<int16>();
 
            int32 internal_event_id = _gameEvent.size() + eventId - 1;
 
            if (internal_event_id < 0 || internal_event_id >= int32(_gameEventPoolIds.size()))
            {
                LOG_ERROR("sql.sql", "`game_event_pool` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            if (!sPoolMgr->CheckPool(entry))
            {
                LOG_ERROR("sql.sql", "Pool Id ({}) has all creatures or gameobjects with explicit chance sum <>100 and no equal chance defined. The pool system cannot pick one to spawn.", entry);
                continue;
            }
 
            IdList& poollist = _gameEventPoolIds[internal_event_id];
            poollist.push_back(entry);
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Pools For Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, _gameEventPoolIds, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, sPoolMgr, WORLD_SEL_GAME_EVENT_POOL_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventPrerequisiteData()

void GameEventMgr::LoadEventPrerequisiteData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Prerequisite Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_PREREQUISITE_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Game Rvent Prerequisites in Game Events. DB Table `game_event_prerequisite` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint16 eventId = fields[0].Get<uint8>();
 
            if (eventId >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_prerequisite` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            if (_gameEvent[eventId].State != GAMEEVENT_NORMAL && _gameEvent[eventId].State != GAMEEVENT_INTERNAL)
            {
                uint16 prerequisite_event = fields[1].Get<uint32>();
                if (prerequisite_event >= _gameEvent.size())
                {
                    LOG_ERROR("sql.sql", "`game_event_prerequisite` game event prerequisite id ({}) is out of range compared to max event id in `game_event`", prerequisite_event);
                    continue;
                }
                _gameEvent[eventId].PrerequisiteEvents.insert(prerequisite_event);
            }
            else
            {
                LOG_ERROR("sql.sql", "game_event_prerequisiste includes event entry for non-worldevent id {}", eventId);
                continue;
            }
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} game event prerequisites in Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, GAMEEVENT_INTERNAL, GAMEEVENT_NORMAL, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, WORLD_SEL_GAME_EVENT_PREREQUISITE_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventQuestConditionData()

void GameEventMgr::LoadEventQuestConditionData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Quest Condition Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_QUEST_CONDITION_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 quest event Conditions In Game Events. DB Table `game_event_quest_condition` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint32 quest = fields[0].Get<uint32>();
            uint16 eventId = fields[1].Get<uint8>();
            uint32 condition = fields[2].Get<uint32>();
            float num = fields[3].Get<float>();
 
            if (eventId >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_quest_condition` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            _questToEventConditions[quest].EventId = eventId;
            _questToEventConditions[quest].Condition = condition;
            _questToEventConditions[quest].Num = num;
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} quest event conditions in Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, _questToEventConditions, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, WORLD_SEL_GAME_EVENT_QUEST_CONDITION_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventQuestData()

void GameEventMgr::LoadEventQuestData ( )

private

{
    LOG_INFO("server.loading", "Loading Game Event Quest Data...");
 
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_QUEST_DATA);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Quests Additions In Game Events. DB Table `game_event_creature_quest` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint32 id = fields[0].Get<uint32>();
            uint32 quest = fields[1].Get<uint32>();
            uint16 eventId = fields[2].Get<uint8>();
 
            if (eventId >= _gameEventCreatureQuests.size())
            {
                LOG_ERROR("sql.sql", "`game_event_creature_quest` game event id ({}) is out of range compared to max event id in `game_event`", eventId);
                continue;
            }
 
            QuestRelList& questlist = _gameEventCreatureQuests[eventId];
            questlist.push_back(QuestRelation(id, quest));
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Quests Additions In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEventCreatureQuests, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, WORLD_SEL_GAME_EVENT_QUEST_DATA, and WorldDatabase.

Referenced by LoadFromDB().

LoadEvents()

void GameEventMgr::LoadEvents ( )

private

{
    LOG_INFO("server.loading", "Loading Game Events...");
    uint32 oldMSTime = getMSTime();
    _holidayMainStages.clear();
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENTS);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        _gameEvent.clear();
        LOG_WARN("server.loading", ">> Loaded 0 game events. DB table `game_event` is empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    do
    {
        Field* fields = result->Fetch();
 
        uint8 eventId = fields[0].Get<uint8>();
        if (eventId == 0)
        {
            LOG_ERROR("sql.sql", "`game_event` game event entry 0 is reserved and can't be used.");
            continue;
        }
 
        GameEventData& pGameEvent = _gameEvent[eventId];
        pGameEvent.EventId      = fields[0].Get<uint32>();
        uint64 starttime        = fields[1].Get<uint64>();
        pGameEvent.Start        = time_t(starttime);
        uint64 endtime          = fields[2].Get<uint64>();
        if (fields[2].IsNull())
            endtime             = GameTime::GetGameTime().count() + 63072000; // add 2 years to current date
        pGameEvent.End          = time_t(endtime);
        pGameEvent.Occurence    = fields[3].Get<uint64>();
        pGameEvent.Length       = fields[4].Get<uint64>();
        pGameEvent.HolidayId    = HolidayIds(fields[5].Get<uint32>());
        pGameEvent.HolidayStage = fields[6].Get<uint8>();
        pGameEvent.Description  = fields[7].Get<std::string>();
        pGameEvent.State        = (GameEventState)(fields[8].Get<uint8>());
        pGameEvent.Announce     = fields[9].Get<uint8>();
        pGameEvent.NextStart    = 0;
 
        ++count;
 
        if (pGameEvent.Length == 0 && pGameEvent.State == GAMEEVENT_NORMAL)                            // length>0 is validity check
        {
            LOG_ERROR("sql.sql", "`game_event` game event id ({}) isn't a world event and has length = 0, thus it can't be used.", eventId);
            continue;
        }
 
        if (pGameEvent.HolidayId != HOLIDAY_NONE)
        {
            HolidaysEntry const* holiday = sHolidaysStore.LookupEntry(pGameEvent.HolidayId);
            if (!holiday)
            {
                LOG_ERROR("sql.sql", "`game_event` game event id ({}) have not existed holiday id {}.", eventId, pGameEvent.HolidayId);
                pGameEvent.HolidayId = HOLIDAY_NONE;
                continue;
            }
 
            // a stage the holiday does not define leaves the event with length 0, which keeps it from ever starting
            if (pGameEvent.HolidayStage > MAX_HOLIDAY_DURATIONS
                || (pGameEvent.HolidayStage && !holiday->Duration[pGameEvent.HolidayStage - 1]))
            {
                LOG_ERROR("sql.sql", "`game_event` game event id ({}) has out of range holidayStage {}.", eventId, pGameEvent.HolidayStage);
                pGameEvent.HolidayStage = 0;
            }
 
            uint8& mainStage = _holidayMainStages[pGameEvent.HolidayId];
            if (pGameEvent.HolidayStage > mainStage)
                mainStage = pGameEvent.HolidayStage;
 
            SetHolidayEventTime(pGameEvent);
        }
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
}

References _gameEvent, _holidayMainStages, GameEventData::Announce, GameEventData::Description, HolidaysEntry::Duration, GameEventData::End, GameEventData::EventId, GAMEEVENT_NORMAL, Field::Get(), GameTime::GetGameTime(), getMSTime(), GetMSTimeDiffToNow(), HOLIDAY_NONE, GameEventData::HolidayId, GameEventData::HolidayStage, GameEventData::Length, LOG_ERROR, LOG_INFO, LOG_WARN, MAX_HOLIDAY_DURATIONS, GameEventData::NextStart, GameEventData::Occurence, SetHolidayEventTime(), sHolidaysStore, GameEventData::Start, GameEventData::State, WORLD_SEL_GAME_EVENTS, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventSaveData()

void GameEventMgr::LoadEventSaveData ( )

private

{
    uint32 oldMSTime = getMSTime();
    LOG_INFO("server.loading", "Loading Game Event Saves Data...");
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_GAME_EVENT_SAVE_DATA);
    PreparedQueryResult result = CharacterDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Game Event Saves In Game Events. DB Table `game_event_save` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint8 eventId = fields[0].Get<uint8>();
 
            if (eventId >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_save` game event entry ({}) is out of range compared to max event entry in `game_event`", eventId);
                continue;
            }
 
            if (_gameEvent[eventId].State != GAMEEVENT_NORMAL && _gameEvent[eventId].State != GAMEEVENT_INTERNAL)
            {
                _gameEvent[eventId].State = (GameEventState)(fields[1].Get<uint8>());
                _gameEvent[eventId].NextStart = time_t(fields[2].Get<uint32>());
            }
            else
            {
                LOG_ERROR("sql.sql", "game_event_save includes event save for non-worldevent id {}", eventId);
                continue;
            }
 
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Game Event Saves In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, CHAR_SEL_GAME_EVENT_SAVE_DATA, CharacterDatabase, GAMEEVENT_INTERNAL, GAMEEVENT_NORMAL, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, and LOG_WARN.

Referenced by LoadFromDB().

LoadEventSeasonalQuestRelations()

void GameEventMgr::LoadEventSeasonalQuestRelations ( )

private

Todo:

: Change to uint8

{
    LOG_INFO("server.loading", "Loading Game Event Seasonal Quest Relations...");
    uint32 oldMSTime = getMSTime();
 
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_QUEST_SEASONAL_RELATIONS);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Seasonal Quests Additions In Game Events. DB Table `game_event_seasonal_questrelation` Is Empty.");
        LOG_INFO("server.loading", " ");
    }
    else
    {
        uint32 count = 0;
        do
        {
            Field* fields = result->Fetch();
 
            uint32 questId = fields[0].Get<uint32>();
            uint32 eventEntry = fields[1].Get<uint32>(); 
 
            Quest* questTemplate = const_cast<Quest*>(sObjectMgr->GetQuestTemplate(questId));
 
            if (!questTemplate)
            {
                LOG_ERROR("sql.sql", "`game_event_seasonal_questrelation` quest id ({}) does not exist in `quest_template`", questId);
                continue;
            }
 
            if (eventEntry >= _gameEvent.size())
            {
                LOG_ERROR("sql.sql", "`game_event_seasonal_questrelation` event id ({}) is out of range compared to max event in `game_event`", eventEntry);
                continue;
            }
 
            questTemplate->SetEventIdForQuest((uint16)eventEntry);
            _gameEventSeasonalQuestsMap[eventEntry].push_back(questId);
            ++count;
        } while (result->NextRow());
 
        LOG_INFO("server.loading", ">> Loaded {} Quests Additions In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
        LOG_INFO("server.loading", " ");
    }
}

References _gameEvent, _gameEventSeasonalQuestsMap, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), LOG_ERROR, LOG_INFO, LOG_WARN, sObjectMgr, WORLD_SEL_GAME_EVENT_QUEST_SEASONAL_RELATIONS, and WorldDatabase.

Referenced by LoadFromDB().

LoadEventVendors()

void GameEventMgr::LoadEventVendors

(

)

{
    LOG_INFO("server.loading", "Loading Game Event Vendor Additions Data...");
    uint32 oldMSTime = getMSTime();
    WorldDatabasePreparedStatement* stmt = WorldDatabase.GetPreparedStatement(WORLD_SEL_GAME_EVENT_NPC_VENDOR);
    PreparedQueryResult result = WorldDatabase.Query(stmt);
 
    if (!result)
    {
        LOG_WARN("server.loading", ">> Loaded 0 Vendor Additions In Game Events. DB Table `game_event_npc_vendor` Is Empty.");
        LOG_INFO("server.loading", " ");
        return;
    }
 
    uint32 count = 0;
    std::unordered_set<uint8> processedEvents;
 
    do
    {
        Field* fields = result->Fetch();
        uint8 eventId = fields[0].Get<uint8>();
        ObjectGuid::LowType guid = fields[1].Get<uint32>();
 
        if (eventId >= _gameEventVendors.size())
        {
            LOG_ERROR("sql.sql", "Table `game_event_npc_vendor` has invalid eventEntry ({}) for GUID ({}), skipped.", eventId, guid);
            continue;
        }
 
        // Clear existing vendors for this event only once
        if (processedEvents.find(eventId) == processedEvents.end())
        {
            // Remove vendor items from in-memory data
            for (auto& entry : _gameEventVendors[eventId])
            {
                sObjectMgr->RemoveVendorItem(entry.Entry, entry.Item, false);
            }
            _gameEventVendors[eventId].clear();
            processedEvents.insert(eventId);
        }
 
        NPCVendorList& vendors = _gameEventVendors[eventId];
        NPCVendorEntry newEntry;
        newEntry.Item = fields[2].Get<uint32>();
        newEntry.MaxCount = fields[3].Get<uint32>();
        newEntry.Incrtime = fields[4].Get<uint32>();
        newEntry.ExtendedCost = fields[5].Get<uint32>();
 
        // Get the event NPC flag for validity check
        uint32 event_npc_flag = 0;
        NPCFlagList& flist = _gameEventNPCFlags[eventId];
        for (NPCFlagList::const_iterator itr = flist.begin(); itr != flist.end(); ++itr)
        {
            if (itr->first == guid)
            {
                event_npc_flag = itr->second;
                break;
            }
        }
 
        // Get creature entry
        newEntry.Entry = 0;
        if (CreatureData const* data = sObjectMgr->GetCreatureData(guid))
            newEntry.Entry = data->id;
 
        // Validate vendor item
        if (!sObjectMgr->IsVendorItemValid(newEntry.Entry, newEntry.Item, newEntry.MaxCount, newEntry.Incrtime, newEntry.ExtendedCost, nullptr, nullptr, event_npc_flag))
        {
            LOG_ERROR("sql.sql", "Table `game_event_npc_vendor` has invalid item ({}) for guid ({}) for event ({}), skipped.",
                newEntry.Item, newEntry.Entry, eventId);
            continue;
        }
 
        // Add the item to the vendor if event is active
        if (IsEventActive(eventId))
            sObjectMgr->AddVendorItem(newEntry.Entry, newEntry.Item, newEntry.MaxCount, newEntry.Incrtime, newEntry.ExtendedCost, false);
 
        vendors.push_back(newEntry);
 
        ++count;
    } while (result->NextRow());
 
    LOG_INFO("server.loading", ">> Loaded {} Vendor Additions In Game Events in {} ms", count, GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
 
}

References _gameEventNPCFlags, _gameEventVendors, NPCVendorEntry::Entry, NPCVendorEntry::ExtendedCost, Field::Get(), getMSTime(), GetMSTimeDiffToNow(), NPCVendorEntry::Incrtime, IsEventActive(), NPCVendorEntry::Item, LOG_ERROR, LOG_INFO, LOG_WARN, NPCVendorEntry::MaxCount, sObjectMgr, WORLD_SEL_GAME_EVENT_NPC_VENDOR, and WorldDatabase.

Referenced by LoadFromDB().

LoadFromDB()

void GameEventMgr::LoadFromDB

(

)

{
    // The order of these functions matter. Do not change
    LoadEvents();
    LoadEventSaveData();
    LoadEventPrerequisiteData();
    LoadEventCreatureData();
    LoadEventGameObjectData();
    LoadEventModelEquipmentChangeData();
    LoadEventQuestData();
    LoadEventGameObjectQuestData();
    LoadEventQuestConditionData();
    LoadEventConditionData();
    LoadEventConditionSaveData();
    LoadEventNPCFlags();
    LoadEventSeasonalQuestRelations();
    LoadEventVendors();
    LoadEventBattlegroundData();
    LoadEventPoolData();
}

References LoadEventBattlegroundData(), LoadEventConditionData(), LoadEventConditionSaveData(), LoadEventCreatureData(), LoadEventGameObjectData(), LoadEventGameObjectQuestData(), LoadEventModelEquipmentChangeData(), LoadEventNPCFlags(), LoadEventPoolData(), LoadEventPrerequisiteData(), LoadEventQuestConditionData(), LoadEventQuestData(), LoadEvents(), LoadEventSaveData(), LoadEventSeasonalQuestRelations(), and LoadEventVendors().

LoadHolidayDates()

void GameEventMgr::LoadHolidayDates

(

)

{
    uint32 const oldMSTime = getMSTime();
    uint32 dynamicCount = 0;
    uint32 dbCount = 0;
 
    // Step 1: Generate dynamic holiday dates based on current year
    std::chrono::system_clock::time_point const now = std::chrono::system_clock::now();
    std::time_t const nowTime = std::chrono::system_clock::to_time_t(now);
    std::tm localTime = {};
#ifdef _WIN32
    localtime_s(&localTime, &nowTime);
#else
    localtime_r(&nowTime, &localTime);
#endif
    int const currentYear = localTime.tm_year + 1900;
 
    for (auto const& rule : HolidayDateCalculator::GetHolidayRules())
    {
        HolidaysEntry* entry = const_cast<HolidaysEntry*>(sHolidaysStore.LookupEntry(rule.holidayId));
        if (!entry)
        {
            LOG_INFO("server.loading", ">> Holiday {} not found in DBC - cannot set dynamic dates", rule.holidayId);
            continue;
        }
 
        // Special handling for Darkmoon Faire - needs multiple dates per year (4 occurrences)
        if (rule.type == HolidayCalculationType::DARKMOON_FAIRE)
        {
            int const locationOffset = rule.month;
            std::vector<uint32_t> const dates = HolidayDateCalculator::GetDarkmoonFaireDates(locationOffset, currentYear - 1, 4, rule.offset);
 
            uint8 dateId = 0;
            for (auto const& packedDate : dates)
            {
                if (dateId >= MAX_HOLIDAY_DATES)
                    break;
 
                entry->Date[dateId++] = packedDate;
                ++dynamicCount;
            }
 
            // Darkmoon Faire lasts 7 days (168 hours) - set Duration if not already set
            if (!entry->Duration[0])
                entry->Duration[0] = 168; // 7 days in hours
 
            auto itr = std::lower_bound(ModifiedHolidays.begin(), ModifiedHolidays.end(), entry->Id);
            if (itr == ModifiedHolidays.end() || *itr != entry->Id)
                ModifiedHolidays.insert(itr, entry->Id);
 
            continue;
        }
 
        // Generate dates for current year + 2 ahead (year capped at 2030 due to 5-bit client limitation)
        for (int yearOffset = -1; yearOffset <= 2; ++yearOffset)
        {
            int const year = currentYear + yearOffset;
            if (year > 2030)
                break;
 
            uint8 const dateId = static_cast<uint8>(yearOffset + 1);
            if (dateId >= MAX_HOLIDAY_DATES)
                break;
 
            uint32_t const packedDate = HolidayDateCalculator::GetPackedHolidayDate(rule.holidayId, year);
            entry->Date[dateId] = packedDate;
 
            // Debug: decode and log the date
            std::tm const date = HolidayDateCalculator::UnpackDate(packedDate);
            LOG_DEBUG("server.loading", ">> Holiday {} Date[{}] = {}-{:02d}-{:02d}",
                rule.holidayId, dateId, date.tm_year + 1900, date.tm_mon + 1, date.tm_mday);
 
            ++dynamicCount;
        }
 
        auto itr = std::lower_bound(ModifiedHolidays.begin(), ModifiedHolidays.end(), entry->Id);
        if (itr == ModifiedHolidays.end() || *itr != entry->Id)
            ModifiedHolidays.insert(itr, entry->Id);
    }
 
    // Step 2: Check game_event.start_time for overrides (allows custom servers to override calculated dates)
    // Only use as override if start_time year >= current year (ignore old static dates)
    QueryResult result = WorldDatabase.Query("SELECT holiday, UNIX_TIMESTAMP(start_time) FROM game_event WHERE holiday != 0 AND start_time > '2000-12-31'");
 
    if (result)
    {
        do
        {
            Field* fields = result->Fetch();
 
            uint32 const holidayId = fields[0].Get<uint32>();
            HolidaysEntry* entry = const_cast<HolidaysEntry*>(sHolidaysStore.LookupEntry(holidayId));
            if (!entry)
                continue;
 
            if (fields[1].IsNull())
                continue;
 
            time_t const startTime = fields[1].Get<uint64>();
            if (startTime == 0)
                continue;
 
            std::tm const timeInfo = Acore::Time::TimeBreakdown(startTime);
 
            int const year = timeInfo.tm_year + 1900;
            // Only override if start_time is current year or later (ignore old static dates)
            if (year < currentYear || year > 2030)
                continue;
 
            // Pack the date in WoW format and override Date[0]
            uint32_t const yearOffset = static_cast<uint32_t>(year - 2000);
            uint32_t const month = static_cast<uint32_t>(timeInfo.tm_mon);
            uint32_t const day = static_cast<uint32_t>(timeInfo.tm_mday - 1);
            uint32_t const weekday = static_cast<uint32_t>(timeInfo.tm_wday);
            entry->Date[0] = (yearOffset << 24) | (month << 20) | (day << 14) | (weekday << 11);
 
            ++dbCount;
        } while (result->NextRow());
    }
 
    LOG_INFO("server.loading", ">> Loaded {} Holiday Dates ({} dynamic, {} game_event overrides) in {} ms",
        dynamicCount + dbCount, dynamicCount, dbCount, GetMSTimeDiffToNow(oldMSTime));
}

References DARKMOON_FAIRE, HolidaysEntry::Date, HolidaysEntry::Duration, Field::Get(), HolidayDateCalculator::GetDarkmoonFaireDates(), HolidayDateCalculator::GetHolidayRules(), getMSTime(), GetMSTimeDiffToNow(), HolidayDateCalculator::GetPackedHolidayDate(), HolidaysEntry::Id, localtime_r(), LOG_DEBUG, LOG_INFO, MAX_HOLIDAY_DATES, ModifiedHolidays, sHolidaysStore, Acore::Time::TimeBreakdown(), HolidayDateCalculator::UnpackDate(), and WorldDatabase.

NextCheck()

uint32 GameEventMgr::NextCheck

(

uint16

entry

)

const

{
    time_t currenttime = GameTime::GetGameTime().count();
 
    // for NEXTPHASE state world events, return the delay to start the next event, so the followup event will be checked correctly
    if ((_gameEvent[entry].State == GAMEEVENT_WORLD_NEXTPHASE || _gameEvent[entry].State == GAMEEVENT_WORLD_FINISHED) && _gameEvent[entry].NextStart >= currenttime)
        return uint32(_gameEvent[entry].NextStart - currenttime);
 
    // for CONDITIONS state world events, return the length of the wait period, so if the conditions are met, this check will be called again to set the timer as NEXTPHASE event
    if (_gameEvent[entry].State == GAMEEVENT_WORLD_CONDITIONS)
    {
        if (_gameEvent[entry].Length)
            return _gameEvent[entry].Length * 60;
        else
            return max_ge_check_delay;
    }
 
    // outdated event: we return max
    if (currenttime > _gameEvent[entry].End)
        return max_ge_check_delay;
 
    // never started event, we return delay before start
    if (_gameEvent[entry].Start > currenttime)
        return uint32(_gameEvent[entry].Start - currenttime);
 
    uint32 delay;
    // in event, we return the end of it
    if ((((currenttime - _gameEvent[entry].Start) % (_gameEvent[entry].Occurence * 60)) < (_gameEvent[entry].Length * 60)))
        // we return the delay before it ends
        delay = (_gameEvent[entry].Length * MINUTE) - ((currenttime - _gameEvent[entry].Start) % (_gameEvent[entry].Occurence * MINUTE));
    else                                                    // not in window, we return the delay before next start
        delay = (_gameEvent[entry].Occurence * MINUTE) - ((currenttime - _gameEvent[entry].Start) % (_gameEvent[entry].Occurence * MINUTE));
    // In case the end is before next check
    if (_gameEvent[entry].End < time_t(currenttime + delay))
        return uint32(_gameEvent[entry].End - currenttime);
    else
        return delay;
}

References _gameEvent, GAMEEVENT_WORLD_CONDITIONS, GAMEEVENT_WORLD_FINISHED, GAMEEVENT_WORLD_NEXTPHASE, GameTime::GetGameTime(), max_ge_check_delay, and MINUTE.

Referenced by Update().

RemoveActiveEvent()

void GameEventMgr::RemoveActiveEvent ( uint16  eventId )

inlineprivate

{ _activeEvents.erase(eventId); }

References _activeEvents.

Referenced by StopEvent().

RunSmartAIScripts()

void GameEventMgr::RunSmartAIScripts ( uint16  eventId, bool  activate  )

private

Iterate over every supported source type (creature and gameobject) Not entirely sure how this will affect units in non-loaded grids.

{
    sMapMgr->DoForAllMaps([eventId, activate](Map* map)
    {
        GameEventAIHookWorker worker(eventId, activate);
        TypeContainerVisitor<GameEventAIHookWorker, MapStoredObjectTypesContainer> visitor(worker);
        visitor.Visit(map->GetObjectsStore());
    });
}

References Map::GetObjectsStore(), sMapMgr, and TypeContainerVisitor< VISITOR, TYPE_CONTAINER >::Visit().

Referenced by ApplyNewEvent(), and UnApplyEvent().

SaveWorldEventStateToDB()

void GameEventMgr::SaveWorldEventStateToDB ( uint16  eventId )

private

{
    CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GAME_EVENT_SAVE);
    stmt->SetData(0, uint8(eventId));
    trans->Append(stmt);
 
    stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_GAME_EVENT_SAVE);
    stmt->SetData(0, uint8(eventId));
    stmt->SetData(1, _gameEvent[eventId].State);
    stmt->SetData(2, _gameEvent[eventId].NextStart ? uint32(_gameEvent[eventId].NextStart) : 0);
    trans->Append(stmt);
    CharacterDatabase.CommitTransaction(trans);
}

References _gameEvent, CHAR_DEL_GAME_EVENT_SAVE, CHAR_INS_GAME_EVENT_SAVE, CharacterDatabase, and PreparedStatementBase::SetData().

Referenced by HandleQuestComplete(), StartEvent(), and Update().

SendWorldStateUpdate()

void GameEventMgr::SendWorldStateUpdate ( Player *  player, uint16  eventId  )

private

{
    GameEventConditionMap::const_iterator itr;
    for (itr = _gameEvent[eventId].Conditions.begin(); itr != _gameEvent[eventId].Conditions.end(); ++itr)
    {
        if (itr->second.DoneWorldState)
            player->SendUpdateWorldState(itr->second.DoneWorldState, (uint32)(itr->second.Done));
        if (itr->second.MaxWorldState)
            player->SendUpdateWorldState(itr->second.MaxWorldState, (uint32)(itr->second.ReqNum));
    }
}

References _gameEvent, and Player::SendUpdateWorldState().

SetHolidayEventTime()

void GameEventMgr::SetHolidayEventTime ( GameEventData &  event )

private

{
    if (!event.HolidayStage) // Ignore holiday
        return;
 
    HolidaysEntry const* holiday = sHolidaysStore.LookupEntry(event.HolidayId);
 
    if (!holiday->Date[0] || !holiday->Duration[0]) // Invalid definitions
    {
        LOG_ERROR("sql.sql", "Missing date or duration for holiday {}.", event.HolidayId);
        return;
    }
 
    uint8 stageIndex = event.HolidayStage - 1;
    event.Length = holiday->Duration[stageIndex] * HOUR / MINUTE;
 
    time_t stageOffset = 0;
    for (uint8 i = 0; i < stageIndex; ++i)
    {
        stageOffset += holiday->Duration[i] * HOUR;
    }
 
    switch (holiday->CalendarFilterType)
    {
        case -1: // Yearly
            event.Occurence = YEAR / MINUTE; // Not all too useful
            break;
        case 0: // Weekly
            event.Occurence = WEEK / MINUTE;
            break;
        case 1: // Defined dates only (Darkmoon Faire)
            break;
        case 2: // Only used for looping events (Call to Arms)
            break;
    }
 
    if (holiday->Looping)
    {
        event.Occurence = 0;
        for (uint8 i = 0; i < MAX_HOLIDAY_DURATIONS && holiday->Duration[i]; ++i)
        {
            event.Occurence += holiday->Duration[i] * HOUR / MINUTE;
        }
    }
 
    bool singleDate = ((holiday->Date[0] >> 24) & 0x1F) == 31; // Events with fixed date within year have - 1
 
    time_t curTime = GameTime::GetGameTime().count();
 
    if (holiday->Looping)
    {
        // Looping events (Battleground Call to Arms) carry a single past anchor in the DBC and
        // recur via event.Occurence. Anchor to that DBC date so the window keeps the correct phase
        // instead of inheriting the wrong time of day from a stale game_event.start_time.
        if (time_t start = HolidayDateCalculator::FindLoopingStartTime(holiday->Date[0], stageOffset, event.Occurence, curTime))
            event.Start = start;
 
        return;
    }
 
    if (!singleDate)
    {
        time_t start = HolidayDateCalculator::FindStartTimeForStage(
            holiday->Date, MAX_HOLIDAY_DATES, stageOffset, event.Length, curTime);
        if (start)
            event.Start = start;
 
        return;
    }
 
    for (uint8 i = 0; i < MAX_HOLIDAY_DATES && holiday->Date[i]; ++i)
    {
        uint32 date = holiday->Date[i];
 
        tm timeInfo = Acore::Time::TimeBreakdown(curTime);
        timeInfo.tm_year -= 1; // First try last year (event active through New Year)
 
        timeInfo.tm_mon = (date >> 20) & 0xF;
        timeInfo.tm_mday = ((date >> 14) & 0x3F) + 1;
        timeInfo.tm_hour = (date >> 6) & 0x1F;
        timeInfo.tm_min = date & 0x3F;
        timeInfo.tm_sec = 0;
        timeInfo.tm_isdst = -1;
 
        // try to get next start time (skip past dates)
        time_t startTime = mktime(&timeInfo);
        if (curTime < startTime + stageOffset + event.Length * MINUTE)
        {
            event.Start = startTime + stageOffset;
            break;
        }
        else
        {
            tm tmCopy = Acore::Time::TimeBreakdown(curTime);
            int year = tmCopy.tm_year; // This year
            tmCopy = timeInfo;
            tmCopy.tm_year = year;
            event.Start = mktime(&tmCopy) + stageOffset;
            break;
        }
    }
}

References HolidaysEntry::CalendarFilterType, HolidaysEntry::Date, HolidaysEntry::Duration, HolidayDateCalculator::FindLoopingStartTime(), HolidayDateCalculator::FindStartTimeForStage(), GameTime::GetGameTime(), GameEventData::HolidayId, GameEventData::HolidayStage, HOUR, GameEventData::Length, LOG_ERROR, HolidaysEntry::Looping, MAX_HOLIDAY_DATES, MAX_HOLIDAY_DURATIONS, MINUTE, GameEventData::Occurence, sHolidaysStore, Acore::Time::TimeBreakdown(), WEEK, and YEAR.

Referenced by LoadEvents().

StartEvent()

bool GameEventMgr::StartEvent	(	uint16	event_id,
		bool	overwrite = false
	)

{
    if (sDisableMgr->IsDisabledFor(DISABLE_TYPE_GAME_EVENT, eventId, nullptr) && !overwrite)
        return false;
 
    GameEventData& data = _gameEvent[eventId];
    if (data.State == GAMEEVENT_NORMAL || data.State == GAMEEVENT_INTERNAL)
    {
        AddActiveEvent(eventId);
        ApplyNewEvent(eventId);
        if (overwrite)
        {
            _gameEvent[eventId].Start = GameTime::GetGameTime().count();
            if (data.End <= data.Start)
                data.End = data.Start + data.Length;
        }
 
        if (IsActiveEvent(eventId))
            sScriptMgr->OnGameEventStart(eventId);
 
        // When event is started, set its worldstate to current time
        auto itr = _gameEventSeasonalQuestsMap.find(eventId);
        if (itr != _gameEventSeasonalQuestsMap.end() && !itr->second.empty())
        {
            sWorldState->setWorldState(eventId, GameTime::GetGameTime().count());
        }
 
        return false;
    }
    else
    {
        if (data.State == GAMEEVENT_WORLD_INACTIVE)
            // set to conditions phase
            data.State = GAMEEVENT_WORLD_CONDITIONS;
 
        // add to active events
        AddActiveEvent(eventId);
        // add spawns
        ApplyNewEvent(eventId);
 
        // check if can go to next state
        bool conditions_met = CheckOneGameEventConditions(eventId);
        // save to db
        SaveWorldEventStateToDB(eventId);
        // force game event update to set the update timer if conditions were met from a command
        // this update is needed to possibly start events dependent on the started one
        // or to scedule another update where the next event will be started
        if (overwrite && conditions_met)
            sWorld->ForceGameEventUpdate();
 
        if (IsActiveEvent(eventId))
            sScriptMgr->OnGameEventStart(eventId);
 
        return conditions_met;
    }
}

References _gameEvent, _gameEventSeasonalQuestsMap, AddActiveEvent(), ApplyNewEvent(), CheckOneGameEventConditions(), DISABLE_TYPE_GAME_EVENT, GameEventData::End, GAMEEVENT_INTERNAL, GAMEEVENT_NORMAL, GAMEEVENT_WORLD_CONDITIONS, GAMEEVENT_WORLD_INACTIVE, GameTime::GetGameTime(), IsActiveEvent(), GameEventData::Length, SaveWorldEventStateToDB(), sDisableMgr, sScriptMgr, GameEventData::Start, GameEventData::State, sWorld, and sWorldState.

Referenced by StartInternalEvent(), and Update().

StartInternalEvent()

void GameEventMgr::StartInternalEvent

(

uint16

event_id

)

{
    if (eventId < 1 || eventId >= _gameEvent.size())
        return;
 
    if (!_gameEvent[eventId].isValid())
        return;
 
    if (_activeEvents.find(eventId) != _activeEvents.end())
        return;
 
    StartEvent(eventId);
}

References _activeEvents, _gameEvent, and StartEvent().

StartSystem()

uint32 GameEventMgr::StartSystem

(

)

{
    _activeEvents.clear();
    uint32 delay = Update();
    _isSystemInit = true;
    return delay;
}

References _activeEvents, _isSystemInit, and Update().

StopEvent()

void GameEventMgr::StopEvent	(	uint16	event_id,
		bool	overwrite = false
	)

{
    GameEventData& data = _gameEvent[eventId];
    bool serverwide_evt = data.State != GAMEEVENT_NORMAL && data.State != GAMEEVENT_INTERNAL;
 
    RemoveActiveEvent(eventId);
    UnApplyEvent(eventId);
 
     // When event is stopped, clean up its worldstate
    sWorldState->setWorldState(eventId, 0);
 
    if (overwrite && !serverwide_evt)
    {
        data.Start = GameTime::GetGameTime().count() - data.Length * MINUTE;
        if (data.End <= data.Start)
            data.End = data.Start + data.Length;
    }
    else if (serverwide_evt)
    {
        // if finished world event, then only gm command can stop it
        if (overwrite || data.State != GAMEEVENT_WORLD_FINISHED)
        {
            // reset conditions
            data.NextStart = 0;
            data.State = GAMEEVENT_WORLD_INACTIVE;
            GameEventConditionMap::iterator itr;
            for (itr = data.Conditions.begin(); itr != data.Conditions.end(); ++itr)
                itr->second.Done = 0;
 
            CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
            CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_ALL_GAME_EVENT_CONDITION_SAVE);
            stmt->SetData(0, uint8(eventId));
            trans->Append(stmt);
 
            stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_GAME_EVENT_SAVE);
            stmt->SetData(0, uint8(eventId));
            trans->Append(stmt);
 
            CharacterDatabase.CommitTransaction(trans);
        }
    }
 
    if (!IsActiveEvent(eventId))
        sScriptMgr->OnGameEventStop(eventId);
}

References _gameEvent, CHAR_DEL_ALL_GAME_EVENT_CONDITION_SAVE, CHAR_DEL_GAME_EVENT_SAVE, CharacterDatabase, GameEventData::Conditions, GameEventData::End, GAMEEVENT_INTERNAL, GAMEEVENT_NORMAL, GAMEEVENT_WORLD_FINISHED, GAMEEVENT_WORLD_INACTIVE, GameTime::GetGameTime(), IsActiveEvent(), GameEventData::Length, MINUTE, GameEventData::NextStart, RemoveActiveEvent(), PreparedStatementBase::SetData(), sScriptMgr, GameEventData::Start, GameEventData::State, sWorldState, and UnApplyEvent().

Referenced by Update().

UnApplyEvent()

void GameEventMgr::UnApplyEvent ( uint16  eventId )

private

Run SAI scripts with SMART_EVENT_GAME_EVENT_END

{
    LOG_DEBUG("gameevent", "GameEvent {} \"{}\" removed.", eventId, _gameEvent[eventId].Description);
    RunSmartAIScripts(eventId, false);
    // un-spawn positive event tagged objects
    GameEventUnspawn(eventId);
    // spawn negative event tagget objects
    int16 numEventId = (-1) * eventId;
    GameEventSpawn(numEventId);
    // restore equipment or model
    ChangeEquipOrModel(eventId, false);
    // Remove quests that are events only to non event npc
    UpdateEventQuests(eventId, false);
    UpdateWorldStates(eventId, false);
    // update npcflags in this event
    UpdateEventNPCFlags(eventId);
    // remove vendor items
    UpdateEventNPCVendor(eventId, false);
    // update bg holiday
    UpdateBattlegroundSettings();
}

References _gameEvent, ChangeEquipOrModel(), GameEventSpawn(), GameEventUnspawn(), LOG_DEBUG, RunSmartAIScripts(), UpdateBattlegroundSettings(), UpdateEventNPCFlags(), UpdateEventNPCVendor(), UpdateEventQuests(), and UpdateWorldStates().

Referenced by StopEvent().

Update()

uint32 GameEventMgr::Update

(

)

{
    time_t currenttime = GameTime::GetGameTime().count();
    uint32 nextEventDelay = max_ge_check_delay;             // 1 day
    uint32 calcDelay;
    std::set<uint16> activate, deactivate;
    for (uint16 itr = 1; itr < _gameEvent.size(); ++itr)
    {
        // must do the activating first, and after that the deactivating
        // so first queue it
        //LOG_ERROR("sql.sql", "Checking event {}", itr);
 
        sScriptMgr->OnGameEventCheck(itr);
 
        if (CheckOneGameEvent(itr))
        {
            // if the world event is in NEXTPHASE state, and the time has passed to finish this event, then do so
            if (_gameEvent[itr].State == GAMEEVENT_WORLD_NEXTPHASE && _gameEvent[itr].NextStart <= currenttime)
            {
                // set this event to finished, null the nextstart time
                _gameEvent[itr].State = GAMEEVENT_WORLD_FINISHED;
                _gameEvent[itr].NextStart = 0;
                // save the state of this gameevent
                SaveWorldEventStateToDB(itr);
                // queue for deactivation
                if (IsActiveEvent(itr))
                    deactivate.insert(itr);
                // go to next event, this no longer needs an event update timer
                continue;
            }
            else if (_gameEvent[itr].State == GAMEEVENT_WORLD_CONDITIONS && CheckOneGameEventConditions(itr))
                // changed, save to DB the gameevent state, will be updated in next update cycle
                SaveWorldEventStateToDB(itr);
 
            // queue for activation
            if (!IsActiveEvent(itr))
                activate.insert(itr);
        }
        else
        {
            // If event is inactive, periodically clean up its worldstate
            sWorldState->setWorldState(itr, 0);
 
            if (IsActiveEvent(itr))
            {
                // Xinef: do not deactivate internal events on whim
                if (_gameEvent[itr].State != GAMEEVENT_INTERNAL)
                    deactivate.insert(itr);
            }
            else
            {
                if (!_isSystemInit)
                {
                    int16 event_nid = (-1) * (itr);
                    // spawn all negative ones for this event
                    GameEventSpawn(event_nid);
                }
            }
        }
        calcDelay = NextCheck(itr);
        if (calcDelay < nextEventDelay)
            nextEventDelay = calcDelay;
    }
    // now activate the queue
    // a now activated event can contain a spawn of a to-be-deactivated one
    // following the activate - deactivate order, deactivating the first event later will leave the spawn in (wont disappear then reappear clientside)
    for (std::set<uint16>::iterator itr = activate.begin(); itr != activate.end(); ++itr)
        // start the event
        // returns true the started event completed
        // in that case, initiate next update in 1 second
        if (StartEvent(*itr))
            nextEventDelay = 0;
    for (std::set<uint16>::iterator itr = deactivate.begin(); itr != deactivate.end(); ++itr)
        StopEvent(*itr);
 
    LOG_DEBUG("gameevent", "Next game event check in {} seconds.", nextEventDelay + 1);
    return (nextEventDelay + 1) * IN_MILLISECONDS;           // Add 1 second to be sure event has started/stopped at next call
}

References _gameEvent, _isSystemInit, CheckOneGameEvent(), CheckOneGameEventConditions(), GAMEEVENT_INTERNAL, GAMEEVENT_WORLD_CONDITIONS, GAMEEVENT_WORLD_FINISHED, GAMEEVENT_WORLD_NEXTPHASE, GameEventSpawn(), GameTime::GetGameTime(), IN_MILLISECONDS, IsActiveEvent(), LOG_DEBUG, max_ge_check_delay, NextCheck(), SaveWorldEventStateToDB(), sScriptMgr, StartEvent(), StopEvent(), and sWorldState.

Referenced by StartSystem().

UpdateBattlegroundSettings()

void GameEventMgr::UpdateBattlegroundSettings ( )

private

{
    uint32 mask = 0;
    for (ActiveEvents::const_iterator itr = _activeEvents.begin(); itr != _activeEvents.end(); ++itr)
        mask |= _gameEventBattlegroundHolidays[*itr];
    sBattlegroundMgr->SetHolidayWeekends(mask);
}

References _activeEvents, _gameEventBattlegroundHolidays, and sBattlegroundMgr.

Referenced by ApplyNewEvent(), and UnApplyEvent().

UpdateEventNPCFlags()

void GameEventMgr::UpdateEventNPCFlags ( uint16  eventId )

private

{
    std::unordered_map<uint32, std::unordered_set<ObjectGuid::LowType>> creaturesByMap;
 
    // go through the creatures whose npcflags are changed in the event
    for (NPCFlagList::iterator itr = _gameEventNPCFlags[eventId].begin(); itr != _gameEventNPCFlags[eventId].end(); ++itr)
    {
        // get the creature data from the low guid to get the entry, to be able to find out the whole guid
        if (CreatureData const* data = sObjectMgr->GetCreatureData(itr->first))
            creaturesByMap[data->mapid].insert(itr->first);
    }
 
    for (auto const& p : creaturesByMap)
    {
        sMapMgr->DoForAllMapsWithMapId(p.first, [this, &p](Map* map)
        {
            for (auto& spawnId : p.second)
            {
                auto creatureBounds = map->GetCreatureBySpawnIdStore().equal_range(spawnId);
                for (auto itr = creatureBounds.first; itr != creatureBounds.second; ++itr)
                {
                    Creature* creature = itr->second;
                    uint32 npcflag = GetNPCFlag(creature);
                    if (CreatureTemplate const* creatureTemplate = creature->GetCreatureTemplate())
                        npcflag |= creatureTemplate->npcflag;
 
                    creature->ReplaceAllNpcFlags(NPCFlags(npcflag));
                    // reset gossip options, since the flag change might have added / removed some
                    //cr->ResetGossipOptions();
                }
            }
        });
    }
}

References _gameEventNPCFlags, Map::GetCreatureBySpawnIdStore(), Creature::GetCreatureTemplate(), GetNPCFlag(), Unit::ReplaceAllNpcFlags(), sMapMgr, and sObjectMgr.

Referenced by ApplyNewEvent(), and UnApplyEvent().

UpdateEventNPCVendor()

void GameEventMgr::UpdateEventNPCVendor ( uint16  eventId, bool  activate  )

private

{
    for (NPCVendorList::iterator itr = _gameEventVendors[eventId].begin(); itr != _gameEventVendors[eventId].end(); ++itr)
    {
        if (activate)
            sObjectMgr->AddVendorItem(itr->Entry, itr->Item, itr->MaxCount, itr->Incrtime, itr->ExtendedCost, false);
        else
            sObjectMgr->RemoveVendorItem(itr->Entry, itr->Item, false);
    }
}

References _gameEventVendors, and sObjectMgr.

Referenced by ApplyNewEvent(), and UnApplyEvent().

UpdateEventQuests()

void GameEventMgr::UpdateEventQuests ( uint16  eventId, bool  activate  )

private

{
    QuestRelList::iterator itr;
    for (itr = _gameEventCreatureQuests[eventId].begin(); itr != _gameEventCreatureQuests[eventId].end(); ++itr)
    {
        QuestRelations* CreatureQuestMap = sObjectMgr->GetCreatureQuestRelationMap();
        if (activate)                                           // Add the pair(id, quest) to the multimap
            CreatureQuestMap->insert(QuestRelations::value_type(itr->first, itr->second));
        else
        {
            if (!HasCreatureQuestActiveEventExcept(itr->second, eventId))
            {
                // Remove the pair(id, quest) from the multimap
                QuestRelations::iterator qitr = CreatureQuestMap->find(itr->first);
                if (qitr == CreatureQuestMap->end())
                    continue;
                QuestRelations::iterator lastElement = CreatureQuestMap->upper_bound(itr->first);
                for (; qitr != lastElement; ++qitr)
                {
                    if (qitr->second == itr->second)
                    {
                        CreatureQuestMap->erase(qitr);          // iterator is now no more valid
                        break;                                  // but we can exit loop since the element is found
                    }
                }
            }
        }
    }
    for (itr = _gameEventGameObjectQuests[eventId].begin(); itr != _gameEventGameObjectQuests[eventId].end(); ++itr)
    {
        QuestRelations* GameObjectQuestMap = sObjectMgr->GetGOQuestRelationMap();
        if (activate)                                           // Add the pair(id, quest) to the multimap
            GameObjectQuestMap->insert(QuestRelations::value_type(itr->first, itr->second));
        else
        {
            if (!HasGameObjectQuestActiveEventExcept(itr->second, eventId))
            {
                // Remove the pair(id, quest) from the multimap
                QuestRelations::iterator qitr = GameObjectQuestMap->find(itr->first);
                if (qitr == GameObjectQuestMap->end())
                    continue;
                QuestRelations::iterator lastElement = GameObjectQuestMap->upper_bound(itr->first);
                for (; qitr != lastElement; ++qitr)
                {
                    if (qitr->second == itr->second)
                    {
                        GameObjectQuestMap->erase(qitr);        // iterator is now no more valid
                        break;                                  // but we can exit loop since the element is found
                    }
                }
            }
        }
    }
}

References _gameEventCreatureQuests, _gameEventGameObjectQuests, HasCreatureQuestActiveEventExcept(), HasGameObjectQuestActiveEventExcept(), and sObjectMgr.

Referenced by ApplyNewEvent(), and UnApplyEvent().

UpdateWorldStates()

void GameEventMgr::UpdateWorldStates ( uint16  eventId, bool  Activate  )

private

{
    GameEventData const& event = _gameEvent[eventId];
    if (event.HolidayId != HOLIDAY_NONE)
    {
        BattlegroundTypeId bgTypeId = BattlegroundMgr::WeekendHolidayIdToBGType(event.HolidayId);
        if (bgTypeId != BATTLEGROUND_TYPE_NONE)
        {
            BattlemasterListEntry const* bl = sBattlemasterListStore.LookupEntry(bgTypeId);
            if (bl && bl->HolidayWorldStateId)
            {
                WorldPackets::WorldState::UpdateWorldState worldstate;
                worldstate.VariableID = bl->HolidayWorldStateId;
                worldstate.Value = Activate ? 1 : 0;
                sWorldSessionMgr->SendGlobalMessage(worldstate.Write());
            }
        }
    }
}

References _gameEvent, BATTLEGROUND_TYPE_NONE, HOLIDAY_NONE, BattlemasterListEntry::HolidayWorldStateId, sBattlemasterListStore, sWorldSessionMgr, WorldPackets::WorldState::UpdateWorldState::Value, WorldPackets::WorldState::UpdateWorldState::VariableID, BattlegroundMgr::WeekendHolidayIdToBGType(), and WorldPackets::WorldState::UpdateWorldState::Write().

Referenced by ApplyNewEvent(), and UnApplyEvent().

Member Data Documentation

_activeEvents

ActiveEvents GameEventMgr::_activeEvents

private

Referenced by AddActiveEvent(), GetActiveEventList(), GetNPCFlag(), HasCreatureActiveEventExcept(), HasCreatureQuestActiveEventExcept(), HasGameObjectActiveEventExcept(), HasGameObjectQuestActiveEventExcept(), IsActiveEvent(), RemoveActiveEvent(), StartInternalEvent(), StartSystem(), and UpdateBattlegroundSettings().

_gameEvent

GameEventDataMap GameEventMgr::_gameEvent

private

Referenced by ApplyNewEvent(), CheckOneGameEvent(), CheckOneGameEventConditions(), GameEventSpawn(), GameEventUnspawn(), GetEventMap(), HandleQuestComplete(), HasCreatureActiveEventExcept(), HasGameObjectActiveEventExcept(), Initialize(), LoadEventBattlegroundData(), LoadEventConditionData(), LoadEventConditionSaveData(), LoadEventCreatureData(), LoadEventGameObjectData(), LoadEventNPCFlags(), LoadEventPoolData(), LoadEventPrerequisiteData(), LoadEventQuestConditionData(), LoadEvents(), LoadEventSaveData(), LoadEventSeasonalQuestRelations(), NextCheck(), SaveWorldEventStateToDB(), SendWorldStateUpdate(), StartEvent(), StartInternalEvent(), StopEvent(), UnApplyEvent(), Update(), and UpdateWorldStates().

_gameEventBattlegroundHolidays

GameEventBitmask GameEventMgr::_gameEventBattlegroundHolidays

private

Referenced by Initialize(), LoadEventBattlegroundData(), and UpdateBattlegroundSettings().

_gameEventCreatureQuests

GameEventQuestMap GameEventMgr::_gameEventCreatureQuests

private

Referenced by HasCreatureQuestActiveEventExcept(), Initialize(), LoadEventQuestData(), and UpdateEventQuests().

_gameEventGameObjectQuests

GameEventQuestMap GameEventMgr::_gameEventGameObjectQuests

private

Referenced by HasGameObjectQuestActiveEventExcept(), Initialize(), LoadEventGameObjectQuestData(), and UpdateEventQuests().

_gameEventModelEquip

GameEventModelEquipMap GameEventMgr::_gameEventModelEquip

private

Referenced by ChangeEquipOrModel(), Initialize(), and LoadEventModelEquipmentChangeData().

_gameEventNPCFlags

GameEventNPCFlagMap GameEventMgr::_gameEventNPCFlags

private

Referenced by GetNPCFlag(), Initialize(), LoadEventNPCFlags(), LoadEventVendors(), and UpdateEventNPCFlags().

_gameEventPoolIds

GameEventIdMap GameEventMgr::_gameEventPoolIds

private

Referenced by GameEventSpawn(), Initialize(), and LoadEventPoolData().

_gameEventSeasonalQuestsMap

GameEventSeasonalQuestsMap GameEventMgr::_gameEventSeasonalQuestsMap

private

Referenced by LoadEventSeasonalQuestRelations(), and StartEvent().

_gameEventVendors

GameEventNPCVendorMap GameEventMgr::_gameEventVendors

private

Referenced by Initialize(), LoadEventVendors(), and UpdateEventNPCVendor().

_holidayMainStages

HolidayMainStageMap GameEventMgr::_holidayMainStages

private

Referenced by GetHolidayMainStage(), and LoadEvents().

_isSystemInit

bool GameEventMgr::_isSystemInit

private

Referenced by StartSystem(), and Update().

_questToEventConditions

QuestIdToEventConditionMap GameEventMgr::_questToEventConditions

private

Referenced by HandleQuestComplete(), and LoadEventQuestConditionData().

GameEventCreatureGuids

GameEventGuidMap GameEventMgr::GameEventCreatureGuids

Referenced by GameEventSpawn(), GameEventUnspawn(), HasCreatureActiveEventExcept(), Initialize(), and LoadEventCreatureData().

GameEventGameobjectGuids

GameEventGuidMap GameEventMgr::GameEventGameobjectGuids

Referenced by GameEventSpawn(), HasGameObjectActiveEventExcept(), Initialize(), and LoadEventGameObjectData().

ModifiedHolidays

std::vector<uint32> GameEventMgr::ModifiedHolidays

Referenced by LoadHolidayDates().

---

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

• azerothcore-wotlk/src/server/game/Events/GameEventMgr.h
• azerothcore-wotlk/src/server/game/Events/GameEventMgr.cpp