World Class Reference

The World. More...

#include "World.h"

Inheritance diagram for World:

Public Member Functions
	World ()
	World constructor.
	~World () override
	World destructor.
bool	IsClosed () const override
	Deny clients?
void	SetClosed (bool val) override
	Close world.
AccountTypes	GetPlayerSecurityLimit () const override
	Security level limitations.
void	SetPlayerSecurityLimit (AccountTypes sec) override
void	LoadDBAllowedSecurityLevel () override
bool	getAllowMovement () const override
void	SetAllowMovement (bool allow) override
	Allow/Disallow object movements.
LocaleConstant	GetDefaultDbcLocale () const override
std::string const &	GetDataPath () const override
	Get the path where data (dbc, maps) are stored on disk.
Seconds	GetNextDailyQuestsResetTime () const override
	Next daily quests and random bg reset time.
Seconds	GetNextWeeklyQuestsResetTime () const override
Seconds	GetNextRandomBGResetTime () const override
uint16	GetConfigMaxSkillValue () const override
	Get the maximum skill level a player can reach.
void	SetInitialWorldSettings () override
	Initialize the World.
void	LoadConfigSettings (bool reload=false) override
	Initialize config values.
bool	IsShuttingDown () const override
	Are we in the middle of a shutdown?
uint32	GetShutDownTimeLeft () const override
void	ShutdownServ (uint32 time, uint32 options, uint8 exitcode, std::string const &reason=std::string()) override
	Shutdown the server.
void	ShutdownCancel () override
	Cancel a planned server shutdown.
void	ShutdownMsg (bool show=false, Player *player=nullptr, std::string const &reason=std::string()) override
	Displays a shutdown message at specific intervals or immediately if required.
void	SaveSessionEnd (bool finished) override
	Records how this session ended in uptime; finished marks the shutdown as complete (not a crash)
Optional< PreviousSessionInfo > const &	GetPreviousSessionInfo () const override
uint32	GetLifetimeMaxPlayerCount () const override
void	Update (uint32 diff) override
	Update the World !
void	setRate (ServerConfigs index, float value) override
float	getRate (ServerConfigs index) const override
void	setBoolConfig (ServerConfigs index, bool value) override
bool	getBoolConfig (ServerConfigs index) const override
void	setFloatConfig (ServerConfigs index, float value) override
float	getFloatConfig (ServerConfigs index) const override
void	setIntConfig (ServerConfigs index, uint32 value) override
uint32	getIntConfig (ServerConfigs index) const override
void	setStringConfig (ServerConfigs index, std::string const &value) override
std::string_view	getStringConfig (ServerConfigs index) const override
bool	IsPvPRealm () const override
	Are we on a "Player versus Player" server?
bool	IsFFAPvPRealm () const override
uint32	GetNextWhoListUpdateDelaySecs () override
void	ProcessCliCommands () override
void	QueueCliCommand (CliCommandHolder *commandHolder) override
void	ForceGameEventUpdate () override
void	UpdateRealmCharCount (uint32 accid) override
LocaleConstant	GetAvailableDbcLocale (LocaleConstant locale) const override
void	LoadDBVersion () override
char const *	GetDBVersion () const override
void	UpdateAreaDependentAuras () override
uint32	GetCleaningFlags () const override
void	SetCleaningFlags (uint32 flags) override
void	ResetEventSeasonalQuests (uint16 event_id) override
void	ReloadRBAC () override
std::string const &	GetRealmName () const override
void	SetRealmName (std::string name) override
Public Member Functions inherited from IWorld
virtual	~IWorld ()=default

Static Public Member Functions
static World *	instance ()
static uint8	GetExitCode ()
static void	StopNow (uint8 exitcode)
static bool	IsStopped ()
static float	GetMaxVisibleDistanceOnContinents ()
static float	GetMaxVisibleDistanceInInstances ()
static float	GetMaxVisibleDistanceInBGArenas ()

Static Public Attributes
static uint32	m_worldLoopCounter = 0

Protected Member Functions
void	_UpdateGameTime ()
	Update the game time.
bool	RescheduleShutdownForWintergrasp ()
void	LoadPreviousSessionInfo ()
void	_UpdateRealmCharCount (PreparedQueryResult resultCharCount, uint32 accountId)
void	InitDailyQuestResetTime ()
void	InitWeeklyQuestResetTime ()
void	InitMonthlyQuestResetTime ()
void	InitRandomBGResetTime ()
void	InitCalendarOldEventsDeletionTime ()
void	InitGuildResetTime ()
void	ResetDailyQuests ()
void	ResetWeeklyQuests ()
void	ResetMonthlyQuests ()
void	ResetRandomBG ()
void	CalendarDeleteOldEvents ()
void	ResetGuildCap ()

Private Member Functions
void	DetectDBCLang ()
void	ProcessQueryCallbacks ()
void	FinalizePlayerWorldSession (WorldSession *session)
	Executed when a World Session is being finalized. Be it from a normal login or via queue popping.

Private Attributes
WorldConfig	_worldConfig
uint32	_shutdownTimer
uint32	_shutdownMask
std::string	_shutdownReason
Optional< PreviousSessionInfo >	_previousSession
uint32	_lifetimeMaxPlayerCount
Optional< SessionOutcome >	_sessionOutcome
uint32	_cleaningFlags
bool	_isClosed
IntervalTimer	_timers [WUPDATE_COUNT]
Seconds	_mail_expire_check_timer
AccountTypes	_allowedSecurityLevel
LocaleConstant	_defaultDbcLocale
uint32	_availableDbcLocaleMask
bool	_allowMovement
std::string	_dataPath
std::string	_realmName
LockedQueue< CliCommandHolder * >	_cliCmdQueue
Seconds	_nextDailyQuestReset
Seconds	_nextWeeklyQuestReset
Seconds	_nextMonthlyQuestReset
Seconds	_nextRandomBGReset
Seconds	_nextCalendarOldEventsDeletionTime
Seconds	_nextGuildReset
std::string	_dbVersion
uint32	_dbClientCacheVersion
QueryCallbackProcessor	_queryProcessor

Static Private Attributes
static std::atomic_long	_stopEvent = false
static std::atomic< uint8 >	_exitCode = SHUTDOWN_EXIT_CODE
static std::atomic< bool >	_stoppedByStopNow = false
static float	_maxVisibleDistanceOnContinents = DEFAULT_VISIBILITY_DISTANCE
static float	_maxVisibleDistanceInInstances = DEFAULT_VISIBILITY_INSTANCE
static float	_maxVisibleDistanceInBGArenas = DEFAULT_VISIBILITY_BGARENAS

Detailed Description

The World.

Constructor & Destructor Documentation

World()

World::World

(

)

World constructor.

{
    _allowedSecurityLevel = SEC_PLAYER;
    _allowMovement = true;
    _shutdownMask = 0;
    _shutdownTimer = 0;
    _lifetimeMaxPlayerCount = 0;
    _nextDailyQuestReset = 0s;
    _nextWeeklyQuestReset = 0s;
    _nextMonthlyQuestReset = 0s;
    _nextRandomBGReset = 0s;
    _nextCalendarOldEventsDeletionTime = 0s;
    _nextGuildReset = 0s;
    _defaultDbcLocale = LOCALE_enUS;
    _mail_expire_check_timer = 0s;
    _isClosed = false;
    _cleaningFlags = 0;
    _dbClientCacheVersion = 0;
}

References _allowedSecurityLevel, _allowMovement, _cleaningFlags, _dbClientCacheVersion, _defaultDbcLocale, _isClosed, _lifetimeMaxPlayerCount, _mail_expire_check_timer, _nextCalendarOldEventsDeletionTime, _nextDailyQuestReset, _nextGuildReset, _nextMonthlyQuestReset, _nextRandomBGReset, _nextWeeklyQuestReset, _shutdownMask, _shutdownTimer, LOCALE_enUS, and SEC_PLAYER.

~World()

World::~World ( )

override

World destructor.

{
    CliCommandHolder* command = nullptr;
    while (_cliCmdQueue.next(command))
        delete command;
 
    VMAP::VMapFactory::clear();
}

References _cliCmdQueue, VMAP::VMapFactory::clear(), and LockedQueue< T, StorageType >::next().

Member Function Documentation

_UpdateGameTime()

void World::_UpdateGameTime ( )

protected

Update the game time.

• update the time

• if there is a shutdown timer

• ... and it is overdue, stop the world (set m_stopEvent)

• ... unless a Wintergrasp battle is running and deferral is enabled, in which case the shutdown/restart is pushed past the end of the current battle and the world keeps running

• ... else decrease it and if necessary display a shutdown countdown to the users

{
    Seconds lastGameTime = GameTime::GetGameTime();
    GameTime::UpdateGameTimers();
 
    Seconds elapsed = GameTime::GetGameTime() - lastGameTime;
 
    if (!IsStopped() && _shutdownTimer > 0 && elapsed > 0s)
    {
        if (_shutdownTimer <= elapsed.count())
        {
            if (!RescheduleShutdownForWintergrasp())
            {
                if (!(_shutdownMask & SHUTDOWN_MASK_IDLE) || sWorldSessionMgr->GetActiveAndQueuedSessionCount() == 0)
                    _stopEvent = true;                     // exist code already set
                else
                    _shutdownTimer = 1;                    // minimum timer value to wait idle state
            }
        }
        else
        {
            _shutdownTimer -= elapsed.count();
 
            ShutdownMsg();
        }
    }
}

References _shutdownMask, _shutdownTimer, _stopEvent, GameTime::GetGameTime(), IsStopped(), RescheduleShutdownForWintergrasp(), SHUTDOWN_MASK_IDLE, ShutdownMsg(), sWorldSessionMgr, and GameTime::UpdateGameTimers().

Referenced by Update().

_UpdateRealmCharCount()

void World::_UpdateRealmCharCount ( PreparedQueryResult  resultCharCount, uint32  accountId  )

protected

{
    uint8 charCount{0};
    if (resultCharCount)
    {
        Field* fields = resultCharCount->Fetch();
        charCount = uint8(fields[1].Get<uint64>());
    }
 
    LoginDatabaseTransaction trans = LoginDatabase.BeginTransaction();
 
    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_REP_REALM_CHARACTERS);
    stmt->SetData(0, charCount);
    stmt->SetData(1, accountId);
    stmt->SetData(2, realm.Id.Realm);
    trans->Append(stmt);
 
    LoginDatabase.CommitTransaction(trans);
}

References Realm::Id, LOGIN_REP_REALM_CHARACTERS, LoginDatabase, realm, RealmHandle::Realm, and PreparedStatementBase::SetData().

Referenced by UpdateRealmCharCount().

CalendarDeleteOldEvents()

void World::CalendarDeleteOldEvents ( )

protected

{
    LOG_INFO("server.worldserver", "Calendar deletion of old events.");
 
    _nextCalendarOldEventsDeletionTime = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, getIntConfig(CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR)));
    sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME, _nextCalendarOldEventsDeletionTime.count());
    sCalendarMgr->DeleteOldEvents();
}

References _nextCalendarOldEventsDeletionTime, CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR, getIntConfig(), Acore::Time::GetNextTimeWithDayAndHour(), LOG_INFO, sCalendarMgr, sWorldState, and WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME.

Referenced by Update().

DetectDBCLang()

void World::DetectDBCLang ( )

private

{
    uint8 m_lang_confid = sConfigMgr->GetOption<int32>("DBC.Locale", 255);
 
    if (m_lang_confid != 255 && m_lang_confid >= TOTAL_LOCALES)
    {
        LOG_ERROR("server.loading", "Incorrect DBC.Locale! Must be >= 0 and < {} (set to 0)", TOTAL_LOCALES);
        m_lang_confid = LOCALE_enUS;
    }
 
    ChrRacesEntry const* race = sChrRacesStore.LookupEntry(1);
    std::string availableLocalsStr;
 
    uint8 default_locale = TOTAL_LOCALES;
    for (uint8 i = default_locale - 1; i < TOTAL_LOCALES; --i) // -1 will be 255 due to uint8
    {
        if (race->name[i][0] != '\0')                     // check by race names
        {
            default_locale = i;
            _availableDbcLocaleMask |= (1 << i);
            availableLocalsStr += localeNames[i];
            availableLocalsStr += " ";
        }
    }
 
    if (default_locale != m_lang_confid && m_lang_confid < TOTAL_LOCALES &&
            (_availableDbcLocaleMask & (1 << m_lang_confid)))
    {
        default_locale = m_lang_confid;
    }
 
    if (default_locale >= TOTAL_LOCALES)
    {
        LOG_ERROR("server.loading", "Unable to determine your DBC Locale! (corrupt DBC?)");
        exit(1);
    }
 
    _defaultDbcLocale = LocaleConstant(default_locale);
 
    LOG_INFO("server.loading", "Using {} DBC Locale As Default. All Available DBC locales: {}", localeNames[GetDefaultDbcLocale()], availableLocalsStr.empty() ? "<none>" : availableLocalsStr);
    LOG_INFO("server.loading", " ");
}

References _availableDbcLocaleMask, _defaultDbcLocale, GetDefaultDbcLocale(), LOCALE_enUS, localeNames, LOG_ERROR, LOG_INFO, ChrRacesEntry::name, sChrRacesStore, sConfigMgr, and TOTAL_LOCALES.

Referenced by SetInitialWorldSettings().

FinalizePlayerWorldSession()

void World::FinalizePlayerWorldSession ( WorldSession *  session )

inlineprivate

Executed when a World Session is being finalized. Be it from a normal login or via queue popping.

Parameters

session

The World Session that we are finalizing.

ForceGameEventUpdate()

void World::ForceGameEventUpdate ( )

overridevirtual

Implements IWorld.

{
    _timers[WUPDATE_EVENTS].Reset();                   // to give time for Update() to be processed
    uint32 nextGameEvent = sGameEventMgr->Update();
    _timers[WUPDATE_EVENTS].SetInterval(nextGameEvent);
    _timers[WUPDATE_EVENTS].Reset();
}

References _timers, IntervalTimer::Reset(), IntervalTimer::SetInterval(), sGameEventMgr, and WUPDATE_EVENTS.

getAllowMovement()

bool World::getAllowMovement ( ) const

inlineoverridevirtual

Todo:

Actions on m_allowMovement still to be implemented Is movement allowed?

Implements IWorld.

{ return _allowMovement; }

References _allowMovement.

GetAvailableDbcLocale()

LocaleConstant World::GetAvailableDbcLocale ( LocaleConstant  locale ) const

inlineoverridevirtual

Implements IWorld.

{ if (_availableDbcLocaleMask & (1 << locale)) return locale; else return _defaultDbcLocale; }

References _availableDbcLocaleMask, and _defaultDbcLocale.

getBoolConfig()

bool World::getBoolConfig ( ServerConfigs  index ) const

overridevirtual

Implements IWorld.

{
    return _worldConfig.GetConfigValue<bool>(index);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::GetConfigValue().

Referenced by LoadConfigSettings(), SetInitialWorldSettings(), and Update().

GetCleaningFlags()

uint32 World::GetCleaningFlags ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _cleaningFlags; }

References _cleaningFlags.

GetConfigMaxSkillValue()

uint16 World::GetConfigMaxSkillValue ( ) const

inlineoverridevirtual

Get the maximum skill level a player can reach.

Implements IWorld.

    {
        uint16 lvl = uint16(getIntConfig(CONFIG_MAX_PLAYER_LEVEL));
        return lvl > 60 ? 300 + ((lvl - 60) * 75) / 10 : lvl * 5;
    }

References CONFIG_MAX_PLAYER_LEVEL, and getIntConfig().

GetDataPath()

std::string const & World::GetDataPath ( ) const

inlineoverridevirtual

Get the path where data (dbc, maps) are stored on disk.

Implements IWorld.

{ return _dataPath; }

References _dataPath.

GetDBVersion()

char const * World::GetDBVersion ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _dbVersion.c_str(); }

References _dbVersion.

GetDefaultDbcLocale()

LocaleConstant World::GetDefaultDbcLocale ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _defaultDbcLocale; }

References _defaultDbcLocale.

Referenced by DetectDBCLang(), and SetInitialWorldSettings().

GetExitCode()

static uint8 World::GetExitCode ( )

inlinestatic

{ return _exitCode; }

References _exitCode.

Referenced by main().

getFloatConfig()

float World::getFloatConfig ( ServerConfigs  index ) const

overridevirtual

Implements IWorld.

{
    return _worldConfig.GetConfigValue<float>(index);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::GetConfigValue().

Referenced by getRate().

getIntConfig()

uint32 World::getIntConfig ( ServerConfigs  index ) const

overridevirtual

Implements IWorld.

{
    return _worldConfig.GetConfigValue<uint32>(index);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::GetConfigValue().

Referenced by CalendarDeleteOldEvents(), GetConfigMaxSkillValue(), InitCalendarOldEventsDeletionTime(), InitRandomBGResetTime(), IsFFAPvPRealm(), IsPvPRealm(), LoadConfigSettings(), RescheduleShutdownForWintergrasp(), ResetRandomBG(), SetInitialWorldSettings(), and Update().

GetLifetimeMaxPlayerCount()

uint32 World::GetLifetimeMaxPlayerCount ( ) const

overridevirtual

Implements IWorld.

{
    return std::max(_lifetimeMaxPlayerCount, sWorldSessionMgr->GetMaxPlayerCount());
}

References _lifetimeMaxPlayerCount, and sWorldSessionMgr.

GetMaxVisibleDistanceInBGArenas()

static float World::GetMaxVisibleDistanceInBGArenas ( )

inlinestatic

{ return _maxVisibleDistanceInBGArenas;   }

References _maxVisibleDistanceInBGArenas.

Referenced by Battleground::_ProcessJoin(), and BattlegroundMap::InitVisibilityDistance().

GetMaxVisibleDistanceInInstances()

static float World::GetMaxVisibleDistanceInInstances ( )

inlinestatic

{ return _maxVisibleDistanceInInstances;  }

References _maxVisibleDistanceInInstances.

Referenced by InstanceMap::InitVisibilityDistance().

GetMaxVisibleDistanceOnContinents()

static float World::GetMaxVisibleDistanceOnContinents ( )

inlinestatic

{ return _maxVisibleDistanceOnContinents; }

References _maxVisibleDistanceOnContinents.

Referenced by Map::InitVisibilityDistance().

GetNextDailyQuestsResetTime()

Seconds World::GetNextDailyQuestsResetTime ( ) const

inlineoverridevirtual

Next daily quests and random bg reset time.

Implements IWorld.

{ return _nextDailyQuestReset; }

References _nextDailyQuestReset.

GetNextRandomBGResetTime()

Seconds World::GetNextRandomBGResetTime ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _nextRandomBGReset; }

References _nextRandomBGReset.

GetNextWeeklyQuestsResetTime()

Seconds World::GetNextWeeklyQuestsResetTime ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _nextWeeklyQuestReset; }

References _nextWeeklyQuestReset.

GetNextWhoListUpdateDelaySecs()

uint32 World::GetNextWhoListUpdateDelaySecs ( )

overridevirtual

Implements IWorld.

{
    if (_timers[WUPDATE_5_SECS].Passed())
        return 1;
 
    uint32 t = _timers[WUPDATE_5_SECS].GetInterval() - _timers[WUPDATE_5_SECS].GetCurrent();
    t = std::min(t, (uint32)_timers[WUPDATE_5_SECS].GetInterval());
 
    return uint32(std::ceil(t / 1000.0f));
}

References _timers, IntervalTimer::GetCurrent(), IntervalTimer::GetInterval(), and WUPDATE_5_SECS.

GetPlayerSecurityLimit()

AccountTypes World::GetPlayerSecurityLimit ( ) const

inlineoverridevirtual

Security level limitations.

Implements IWorld.

{ return _allowedSecurityLevel; }

References _allowedSecurityLevel.

GetPreviousSessionInfo()

Optional< PreviousSessionInfo > const & World::GetPreviousSessionInfo ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _previousSession; }

References _previousSession.

getRate()

float World::getRate ( ServerConfigs  index ) const

overridevirtual

Implements IWorld.

{
    return getFloatConfig(index);
}

References getFloatConfig().

Referenced by LoadConfigSettings().

GetRealmName()

std::string const & World::GetRealmName ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _realmName; } // pussywizard

References _realmName.

GetShutDownTimeLeft()

uint32 World::GetShutDownTimeLeft ( ) const

inlineoverridevirtual

Implements IWorld.

{ return _shutdownTimer; }

References _shutdownTimer.

getStringConfig()

std::string_view World::getStringConfig ( ServerConfigs  index ) const

overridevirtual

Implements IWorld.

{
    return _worldConfig.GetConfigValue(index);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::GetConfigValue().

InitCalendarOldEventsDeletionTime()

void World::InitCalendarOldEventsDeletionTime ( )

protected

{
    Seconds currentDeletionTime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME));
    Seconds nextDeletionTime = currentDeletionTime > 0s ? currentDeletionTime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, getIntConfig(CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR)));
 
    if (currentDeletionTime == 0s)
    {
        sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME, nextDeletionTime.count());
    }
}

References CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR, getIntConfig(), Acore::Time::GetNextTimeWithDayAndHour(), sWorldState, and WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME.

Referenced by SetInitialWorldSettings().

InitDailyQuestResetTime()

void World::InitDailyQuestResetTime ( )

protected

{
    Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME));
    _nextDailyQuestReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
 
    if (wstime == 0s)
    {
        sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME, _nextDailyQuestReset.count());
    }
}

References _nextDailyQuestReset, Acore::Time::GetNextTimeWithDayAndHour(), sWorldState, and WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME.

Referenced by SetInitialWorldSettings().

InitGuildResetTime()

void World::InitGuildResetTime ( )

protected

{
    Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME));
    _nextGuildReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
 
    if (wstime == 0s)
    {
        sWorldState->setWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME, _nextGuildReset.count());
    }
}

References _nextGuildReset, Acore::Time::GetNextTimeWithDayAndHour(), sWorldState, and WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME.

Referenced by SetInitialWorldSettings().

InitMonthlyQuestResetTime()

void World::InitMonthlyQuestResetTime ( )

protected

{
    Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME));
    _nextMonthlyQuestReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
 
    if (wstime == 0s)
    {
        sWorldState->setWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME, _nextMonthlyQuestReset.count());
    }
}

References _nextMonthlyQuestReset, Acore::Time::GetNextTimeWithDayAndHour(), sWorldState, and WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME.

Referenced by SetInitialWorldSettings().

InitRandomBGResetTime()

void World::InitRandomBGResetTime ( )

protected

{
    Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME));
    _nextRandomBGReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, getIntConfig(CONFIG_RANDOM_BG_RESET_HOUR)));
 
    if (wstime == 0s)
    {
        sWorldState->setWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME, _nextRandomBGReset.count());
    }
}

References _nextRandomBGReset, CONFIG_RANDOM_BG_RESET_HOUR, getIntConfig(), Acore::Time::GetNextTimeWithDayAndHour(), sWorldState, and WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME.

Referenced by SetInitialWorldSettings().

InitWeeklyQuestResetTime()

void World::InitWeeklyQuestResetTime ( )

protected

{
    Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME));
    _nextWeeklyQuestReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(4, 6));
 
    if (wstime == 0s)
    {
        sWorldState->setWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME, _nextWeeklyQuestReset.count());
    }
}

References _nextWeeklyQuestReset, Acore::Time::GetNextTimeWithDayAndHour(), sWorldState, and WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME.

Referenced by SetInitialWorldSettings().

instance()

static World * World::instance ( )

static

IsClosed()

bool World::IsClosed ( ) const

overridevirtual

Deny clients?

Implements IWorld.

{
    return _isClosed;
}

References _isClosed.

IsFFAPvPRealm()

bool World::IsFFAPvPRealm ( ) const

overridevirtual

Implements IWorld.

{
    return getIntConfig(CONFIG_GAME_TYPE) == REALM_TYPE_FFA_PVP;
}

References CONFIG_GAME_TYPE, getIntConfig(), and REALM_TYPE_FFA_PVP.

Referenced by SetInitialWorldSettings().

IsPvPRealm()

bool World::IsPvPRealm ( ) const

overridevirtual

Are we on a "Player versus Player" server?

Implements IWorld.

{
    return getIntConfig(CONFIG_GAME_TYPE) == REALM_TYPE_PVP || getIntConfig(CONFIG_GAME_TYPE) == REALM_TYPE_RPPVP || getIntConfig(CONFIG_GAME_TYPE) == REALM_TYPE_FFA_PVP;
}

References CONFIG_GAME_TYPE, getIntConfig(), REALM_TYPE_FFA_PVP, REALM_TYPE_PVP, and REALM_TYPE_RPPVP.

IsShuttingDown()

bool World::IsShuttingDown ( ) const

inlineoverridevirtual

Are we in the middle of a shutdown?

Implements IWorld.

{ return _shutdownTimer > 0; }

References _shutdownTimer.

IsStopped()

static bool World::IsStopped ( )

inlinestatic

{ return _stopEvent; }

References _stopEvent.

Referenced by _UpdateGameTime(), ACSoapThread(), CliThread(), WorldSession::HandleSocketClosed(), ns1__executeCommand(), ShutdownServ(), and WorldUpdateLoop().

LoadConfigSettings()

void World::LoadConfigSettings ( bool  reload = false )

overridevirtual

Initialize config values.

• Read the player limit from the config file

• Read the "Data" directory from the config file

Implements IWorld.

{
    if (reload)
    {
        if (!sConfigMgr->Reload())
        {
            LOG_ERROR("server.loading", "World settings reload fail: can't read settings.");
            return;
        }
 
        sLog->LoadFromConfig();
        sMetric->LoadFromConfigs();
    }
 
    // Set realm id and enable db logging
    sLog->SetRealmId(realm.Id.Realm);
 
    sScriptMgr->OnBeforeConfigLoad(reload);
 
    // load update time related configs
    sWorldUpdateTime.LoadFromConfig();
 
    sWorldSessionMgr->SetPlayerAmountLimit(sConfigMgr->GetOption<int32>("PlayerLimit", 1000));
 
    _worldConfig.Initialize(reload);
 
    for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
        playerBaseMoveSpeed[i] = baseMoveSpeed[i] * getRate(RATE_MOVESPEED_PLAYER);
 
    for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i)
        baseMoveSpeed[i] *= getRate(RATE_MOVESPEED_NPC);
 
    if (reload)
    {
        sMapMgr->SetMapUpdateInterval(getIntConfig(CONFIG_INTERVAL_MAPUPDATE));
 
        _timers[WUPDATE_UPTIME].SetInterval(getIntConfig(CONFIG_UPTIME_UPDATE) * MINUTE* IN_MILLISECONDS);
        _timers[WUPDATE_UPTIME].Reset();
 
        _timers[WUPDATE_CLEANDB].SetInterval(getIntConfig(CONFIG_LOGDB_CLEARINTERVAL) * MINUTE * IN_MILLISECONDS);
        _timers[WUPDATE_CLEANDB].Reset();
 
        _timers[WUPDATE_AUTOBROADCAST].SetInterval(getIntConfig(CONFIG_AUTOBROADCAST_INTERVAL));
        _timers[WUPDATE_AUTOBROADCAST].Reset();
    }
 
    if (getIntConfig(CONFIG_CLIENTCACHE_VERSION) == 0)
    {
        _worldConfig.OverwriteConfigValue<uint32>(CONFIG_CLIENTCACHE_VERSION, _dbClientCacheVersion);
        LOG_INFO("server.loading", "Client cache version set to: {}", _dbClientCacheVersion);
    }
 
    //visibility on continents
    _maxVisibleDistanceOnContinents = sConfigMgr->GetOption<float>("Visibility.Distance.Continents", DEFAULT_VISIBILITY_DISTANCE);
    if (_maxVisibleDistanceOnContinents < 45 * getRate(RATE_CREATURE_AGGRO))
    {
        LOG_ERROR("server.loading", "Visibility.Distance.Continents can't be less max aggro radius {}", 45 * getRate(RATE_CREATURE_AGGRO));
        _maxVisibleDistanceOnContinents = 45 * getRate(RATE_CREATURE_AGGRO);
    }
    else if (_maxVisibleDistanceOnContinents > MAX_VISIBILITY_DISTANCE)
    {
        LOG_ERROR("server.loading", "Visibility.Distance.Continents can't be greater {}", MAX_VISIBILITY_DISTANCE);
        _maxVisibleDistanceOnContinents = MAX_VISIBILITY_DISTANCE;
    }
 
    //visibility in instances
    _maxVisibleDistanceInInstances = sConfigMgr->GetOption<float>("Visibility.Distance.Instances", DEFAULT_VISIBILITY_INSTANCE);
    if (_maxVisibleDistanceInInstances < 45 * getRate(RATE_CREATURE_AGGRO))
    {
        LOG_ERROR("server.loading", "Visibility.Distance.Instances can't be less max aggro radius {}", 45 * getRate(RATE_CREATURE_AGGRO));
        _maxVisibleDistanceInInstances = 45 * getRate(RATE_CREATURE_AGGRO);
    }
    else if (_maxVisibleDistanceInInstances > MAX_VISIBILITY_DISTANCE)
    {
        LOG_ERROR("server.loading", "Visibility.Distance.Instances can't be greater {}", MAX_VISIBILITY_DISTANCE);
        _maxVisibleDistanceInInstances = MAX_VISIBILITY_DISTANCE;
    }
 
    //visibility in BG/Arenas
    _maxVisibleDistanceInBGArenas = sConfigMgr->GetOption<float>("Visibility.Distance.BGArenas", DEFAULT_VISIBILITY_BGARENAS);
    if (_maxVisibleDistanceInBGArenas < 45 * getRate(RATE_CREATURE_AGGRO))
    {
        LOG_ERROR("server.loading", "Visibility.Distance.BGArenas can't be less max aggro radius {}", 45 * getRate(RATE_CREATURE_AGGRO));
        _maxVisibleDistanceInBGArenas = 45 * getRate(RATE_CREATURE_AGGRO);
    }
    else if (_maxVisibleDistanceInBGArenas > MAX_VISIBILITY_DISTANCE)
    {
        LOG_ERROR("server.loading", "Visibility.Distance.BGArenas can't be greater {}", MAX_VISIBILITY_DISTANCE);
        _maxVisibleDistanceInBGArenas = MAX_VISIBILITY_DISTANCE;
    }
 
    LOG_INFO("server.loading", "Will clear `logs` table of entries older than {} seconds every {} minutes.",
        getIntConfig(CONFIG_LOGDB_CLEARTIME), getIntConfig(CONFIG_LOGDB_CLEARINTERVAL));
 
    std::string dataPath = sConfigMgr->GetOption<std::string>("DataDir", "./");
    if (dataPath.empty() || (dataPath.at(dataPath.length() - 1) != '/' && dataPath.at(dataPath.length() - 1) != '\\'))
        dataPath.push_back('/');
 
#if AC_PLATFORM == AC_PLATFORM_UNIX || AC_PLATFORM == AC_PLATFORM_APPLE
    if (dataPath[0] == '~')
    {
        char const* home = getenv("HOME");
        if (home)
            dataPath.replace(0, 1, home);
    }
#endif
 
    if (reload)
    {
        if (dataPath != _dataPath)
            LOG_ERROR("server.loading", "DataDir option can't be changed at worldserver.conf reload, using current value ({}).", _dataPath);
    }
    else
    {
        _dataPath = dataPath;
        LOG_INFO("server.loading", "Using DataDir {}", _dataPath);
    }
 
    bool const enableIndoor = getBoolConfig(CONFIG_VMAP_INDOOR_CHECK);
    bool const enableLOS = getBoolConfig(CONFIG_VMAP_ENABLE_LOS);
    bool const enablePetLOS = getBoolConfig(CONFIG_PET_LOS);
    bool const enableHeight = getBoolConfig(CONFIG_VMAP_ENABLE_HEIGHT);
    if (!enableHeight)
        LOG_ERROR("server.loading", "VMap height checking disabled! Creatures movements and other various things WILL be broken! Expect no support.");
 
    VMAP::VMapFactory::createOrGetVMapMgr()->setEnableLineOfSightCalc(enableLOS);
    VMAP::VMapFactory::createOrGetVMapMgr()->setEnableHeightCalc(enableHeight);
    LOG_INFO("server.loading", "WORLD: VMap support included. LineOfSight:{}, getHeight:{}, indoorCheck:{} PetLOS:{}", enableLOS, enableHeight, enableIndoor, enablePetLOS);
 
    // call ScriptMgr if we're reloading the configuration
    sScriptMgr->OnAfterConfigLoad(reload);
}

References _dataPath, _dbClientCacheVersion, _maxVisibleDistanceInBGArenas, _maxVisibleDistanceInInstances, _maxVisibleDistanceOnContinents, _timers, _worldConfig, baseMoveSpeed, CONFIG_AUTOBROADCAST_INTERVAL, CONFIG_CLIENTCACHE_VERSION, CONFIG_INTERVAL_MAPUPDATE, CONFIG_LOGDB_CLEARINTERVAL, CONFIG_LOGDB_CLEARTIME, CONFIG_PET_LOS, CONFIG_UPTIME_UPDATE, CONFIG_VMAP_ENABLE_HEIGHT, CONFIG_VMAP_ENABLE_LOS, CONFIG_VMAP_INDOOR_CHECK, VMAP::VMapFactory::createOrGetVMapMgr(), DEFAULT_VISIBILITY_BGARENAS, DEFAULT_VISIBILITY_DISTANCE, DEFAULT_VISIBILITY_INSTANCE, getBoolConfig(), getIntConfig(), getRate(), Realm::Id, IN_MILLISECONDS, ConfigValueCache< ConfigEnum >::Initialize(), WorldUpdateTime::LoadFromConfig(), LOG_ERROR, LOG_INFO, MAX_MOVE_TYPE, MAX_VISIBILITY_DISTANCE, MINUTE, ConfigValueCache< ConfigEnum >::OverwriteConfigValue(), playerBaseMoveSpeed, RATE_CREATURE_AGGRO, RATE_MOVESPEED_NPC, RATE_MOVESPEED_PLAYER, realm, RealmHandle::Realm, IntervalTimer::Reset(), sConfigMgr, VMAP::IVMapMgr::setEnableHeightCalc(), VMAP::IVMapMgr::setEnableLineOfSightCalc(), IntervalTimer::SetInterval(), sLog, sMapMgr, sMetric, sScriptMgr, sWorldSessionMgr, sWorldUpdateTime, WUPDATE_AUTOBROADCAST, WUPDATE_CLEANDB, and WUPDATE_UPTIME.

Referenced by SetInitialWorldSettings().

LoadDBAllowedSecurityLevel()

void World::LoadDBAllowedSecurityLevel ( )

overridevirtual

Implements IWorld.

{
    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_REALMLIST_SECURITY_LEVEL);
    stmt->SetData(0, int32(realm.Id.Realm));
    PreparedQueryResult result = LoginDatabase.Query(stmt);
 
    if (result)
        SetPlayerSecurityLimit(AccountTypes(result->Fetch()->Get<uint8>()));
}

References Realm::Id, LOGIN_SEL_REALMLIST_SECURITY_LEVEL, LoginDatabase, realm, RealmHandle::Realm, PreparedStatementBase::SetData(), and SetPlayerSecurityLimit().

Referenced by SetInitialWorldSettings().

LoadDBVersion()

void World::LoadDBVersion ( )

overridevirtual

Implements IWorld.

{
    QueryResult result = WorldDatabase.Query("SELECT db_version, cache_id FROM version LIMIT 1");
    if (result)
    {
        Field* fields = result->Fetch();
 
        _dbVersion = fields[0].Get<std::string>();
 
        // will be overwrite by config values if different and non-0
        _dbClientCacheVersion = fields[1].Get<uint32>();
    }
 
    if (_dbVersion.empty())
        _dbVersion = "Unknown world database.";
}

References _dbClientCacheVersion, _dbVersion, Field::Get(), and WorldDatabase.

LoadPreviousSessionInfo()

void World::LoadPreviousSessionInfo ( )

protected

{
    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_UPTIME_PREVIOUS);
    stmt->SetData(0, realm.Id.Realm);
    PreparedQueryResult result = LoginDatabase.Query(stmt);
    if (!result)
        return;
 
    Field* fields = result->Fetch();
    PreviousSessionInfo& previous = _previousSession.emplace();
    previous.StartTime = Seconds(fields[0].Get<uint32>());
    previous.Uptime = Seconds(fields[1].Get<uint32>());
    previous.Crashed = fields[2].IsNull();
    previous.Type = SessionShutdownType(fields[3].Get<uint8>());
    previous.Reason = fields[4].Get<std::string>();
 
    if (previous.Crashed)
        LOG_WARN("server.loading", "Previous session did not shut down cleanly. Last online {}.",
            Acore::Time::TimeToTimestampStr(previous.StartTime + previous.Uptime));
 
    stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_UPTIME_MAXPLAYERS);
    stmt->SetData(0, realm.Id.Realm);
    if (PreparedQueryResult maxResult = LoginDatabase.Query(stmt))
        _lifetimeMaxPlayerCount = (*maxResult)[0].Get<uint16>();
}

References _lifetimeMaxPlayerCount, _previousSession, PreviousSessionInfo::Crashed, Field::Get(), Realm::Id, Field::IsNull(), LOG_WARN, LOGIN_SEL_UPTIME_MAXPLAYERS, LOGIN_SEL_UPTIME_PREVIOUS, LoginDatabase, realm, RealmHandle::Realm, PreviousSessionInfo::Reason, PreparedStatementBase::SetData(), PreviousSessionInfo::StartTime, Acore::Time::TimeToTimestampStr(), PreviousSessionInfo::Type, and PreviousSessionInfo::Uptime.

Referenced by SetInitialWorldSettings().

ProcessCliCommands()

void World::ProcessCliCommands ( )

overridevirtual

Implements IWorld.

{
    CliCommandHolder::Print zprint = nullptr;
    void* callbackArg = nullptr;
    CliCommandHolder* command = nullptr;
    while (_cliCmdQueue.next(command))
    {
        LOG_DEBUG("server.worldserver", "CLI command under processing...");
        zprint = command->m_print;
        callbackArg = command->m_callbackArg;
        CliHandler handler(callbackArg, zprint);
        handler.ParseCommands(command->m_command);
        if (command->m_commandFinished)
            command->m_commandFinished(callbackArg, !handler.HasSentErrorMessage());
        delete command;
    }
}

References _cliCmdQueue, ChatHandler::HasSentErrorMessage(), LOG_DEBUG, CliCommandHolder::m_callbackArg, CliCommandHolder::m_command, CliCommandHolder::m_commandFinished, CliCommandHolder::m_print, LockedQueue< T, StorageType >::next(), and CliHandler::ParseCommands().

Referenced by Update().

ProcessQueryCallbacks()

void World::ProcessQueryCallbacks ( )

private

{
    _queryProcessor.ProcessReadyCallbacks();
}

References _queryProcessor, and AsyncCallbackProcessor< T >::ProcessReadyCallbacks().

Referenced by Update().

QueueCliCommand()

void World::QueueCliCommand ( CliCommandHolder *  commandHolder )

inlineoverridevirtual

Implements IWorld.

{ _cliCmdQueue.add(commandHolder); }

References _cliCmdQueue, and LockedQueue< T, StorageType >::add().

ReloadRBAC()

void World::ReloadRBAC ( )

overridevirtual

Implements IWorld.

{
    // Passive reload, we mark the data as invalidated and next time a permission is checked it will be reloaded
    LOG_INFO("rbac", "World::ReloadRBAC()");
    WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
    for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
        if (WorldSession* session = itr->second)
            session->InvalidateRBACData();
}

References LOG_INFO, and sWorldSessionMgr.

RescheduleShutdownForWintergrasp()

bool World::RescheduleShutdownForWintergrasp ( )

protected

Defer a pending shutdown/restart if a Wintergrasp battle is currently running. Returns true when the shutdown timer was extended (world should keep running).

{
    uint32 const bufferMinutes = getIntConfig(CONFIG_WINTERGRASP_DEFER_SHUTDOWN);
    if (!bufferMinutes)
        return false;
 
    // Idle shutdowns wait for an empty server anyway; don't interfere with them
    if (_shutdownMask & SHUTDOWN_MASK_IDLE)
        return false;
 
    Battlefield* wg = sBattlefieldMgr->GetBattlefieldByBattleId(BATTLEFIELD_BATTLEID_WG);
    if (!wg || !wg->IsEnabled() || !wg->IsWarTime())
        return false;
 
    // GetTimer() is the battle time remaining in milliseconds
    _shutdownTimer = wg->GetTimer() / IN_MILLISECONDS + bufferMinutes * MINUTE;
 
    LOG_INFO("server.worldserver", "Server {} deferred: Wintergrasp battle in progress, rescheduled in {}",
        (_shutdownMask & SHUTDOWN_MASK_RESTART ? "restart" : "shutdown"), secsToTimeString(_shutdownTimer));
 
    sWorldSessionMgr->DoForAllOnlinePlayers([](Player* player)
    {
        LocaleConstant locale = player->GetSession()->GetSessionDbLocaleIndex();
        sWorldSessionMgr->SendServerMessage(SERVER_MSG_STRING, sObjectMgr->GetAcoreString(LANG_WG_SHUTDOWN_DEFERRED, locale), player);
    });
 
    ShutdownMsg(true);
    return true;
}

References _shutdownMask, _shutdownTimer, BATTLEFIELD_BATTLEID_WG, CONFIG_WINTERGRASP_DEFER_SHUTDOWN, getIntConfig(), Player::GetSession(), WorldSession::GetSessionDbLocaleIndex(), Battlefield::GetTimer(), IN_MILLISECONDS, Battlefield::IsEnabled(), Battlefield::IsWarTime(), LANG_WG_SHUTDOWN_DEFERRED, LOG_INFO, MINUTE, sBattlefieldMgr, secsToTimeString(), SERVER_MSG_STRING, SHUTDOWN_MASK_IDLE, SHUTDOWN_MASK_RESTART, ShutdownMsg(), sObjectMgr, and sWorldSessionMgr.

Referenced by _UpdateGameTime().

ResetDailyQuests()

void World::ResetDailyQuests ( )

protected

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_QUEST_STATUS_DAILY);
    CharacterDatabase.Execute(stmt);
 
    WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
    for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
        if (itr->second->GetPlayer())
            itr->second->GetPlayer()->ResetDailyQuestStatus();
 
    _nextDailyQuestReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
    sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME, _nextDailyQuestReset.count());
 
    // change available dailies
    sPoolMgr->ChangeDailyQuests();
}

References _nextDailyQuestReset, CHAR_DEL_QUEST_STATUS_DAILY, CharacterDatabase, Acore::Time::GetNextTimeWithDayAndHour(), sPoolMgr, sWorldSessionMgr, sWorldState, and WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME.

Referenced by Update().

ResetEventSeasonalQuests()

void World::ResetEventSeasonalQuests ( uint16  event_id )

overridevirtual

Implements IWorld.

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_QUEST_STATUS_SEASONAL);
    stmt->SetData(0, event_id);
    CharacterDatabase.Execute(stmt);
 
    WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
    for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
        if (itr->second->GetPlayer())
            itr->second->GetPlayer()->ResetSeasonalQuestStatus(event_id);
}

References CHAR_DEL_QUEST_STATUS_SEASONAL, CharacterDatabase, PreparedStatementBase::SetData(), and sWorldSessionMgr.

ResetGuildCap()

void World::ResetGuildCap ( )

protected

{
    LOG_INFO("server.worldserver", "Guild Daily Cap reset.");
 
    _nextGuildReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
    sWorldState->setWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME, _nextGuildReset.count());
 
    sGuildMgr->ResetTimes();
}

References _nextGuildReset, Acore::Time::GetNextTimeWithDayAndHour(), LOG_INFO, sGuildMgr, sWorldState, and WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME.

Referenced by Update().

ResetMonthlyQuests()

void World::ResetMonthlyQuests ( )

protected

{
    LOG_INFO("server.worldserver", "Monthly quests reset for all characters.");
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_QUEST_STATUS_MONTHLY);
    CharacterDatabase.Execute(stmt);
 
    WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
    for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
        if (itr->second->GetPlayer())
            itr->second->GetPlayer()->ResetMonthlyQuestStatus();
 
    _nextMonthlyQuestReset = Seconds(Acore::Time::GetNextTimeWithMonthAndHour(-1, 6));
    sWorldState->setWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME, _nextMonthlyQuestReset.count());
}

References _nextMonthlyQuestReset, CHAR_DEL_QUEST_STATUS_MONTHLY, CharacterDatabase, Acore::Time::GetNextTimeWithMonthAndHour(), LOG_INFO, sWorldSessionMgr, sWorldState, and WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME.

Referenced by Update().

ResetRandomBG()

void World::ResetRandomBG ( )

protected

{
    LOG_DEBUG("server.worldserver", "Random BG status reset for all characters.");
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_BATTLEGROUND_RANDOM);
    CharacterDatabase.Execute(stmt);
 
    WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
    for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
        if (itr->second->GetPlayer())
            itr->second->GetPlayer()->SetRandomWinner(false);
 
    _nextRandomBGReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, getIntConfig(CONFIG_RANDOM_BG_RESET_HOUR)));
    sWorldState->setWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME, _nextRandomBGReset.count());
}

References _nextRandomBGReset, CHAR_DEL_BATTLEGROUND_RANDOM, CharacterDatabase, CONFIG_RANDOM_BG_RESET_HOUR, getIntConfig(), Acore::Time::GetNextTimeWithDayAndHour(), LOG_DEBUG, sWorldSessionMgr, sWorldState, and WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME.

Referenced by Update().

ResetWeeklyQuests()

void World::ResetWeeklyQuests ( )

protected

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_QUEST_STATUS_WEEKLY);
    CharacterDatabase.Execute(stmt);
 
    WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
    for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
        if (itr->second->GetPlayer())
            itr->second->GetPlayer()->ResetWeeklyQuestStatus();
 
    _nextWeeklyQuestReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(4, 6));
    sWorldState->setWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME, _nextWeeklyQuestReset.count());
 
    // change available weeklies
    sPoolMgr->ChangeWeeklyQuests();
}

References _nextWeeklyQuestReset, CHAR_DEL_QUEST_STATUS_WEEKLY, CharacterDatabase, Acore::Time::GetNextTimeWithDayAndHour(), sPoolMgr, sWorldSessionMgr, sWorldState, and WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME.

Referenced by Update().

SaveSessionEnd()

void World::SaveSessionEnd ( bool  finished )

overridevirtual

Records how this session ended in uptime; finished marks the shutdown as complete (not a crash)

Implements IWorld.

{
    // Fixed by the first call: main() has picked its exit code by the final call, and a later StopNow
    // (e.g. the CLI thread failing its read during teardown) no longer reflects how the session ended
    if (!_sessionOutcome)
    {
        SessionOutcome& outcome = _sessionOutcome.emplace();
        outcome.ExitCode = _exitCode;
 
        bool restartScheduled = false;
        if (!_stoppedByStopNow)
        {
            restartScheduled = (_shutdownMask & SHUTDOWN_MASK_RESTART) != 0;
            outcome.Reason = _shutdownReason;
        }
 
        outcome.Type = SHUTDOWN_TYPE_SHUTDOWN;
        if (outcome.ExitCode == ERROR_EXIT_CODE)
            outcome.Type = SHUTDOWN_TYPE_ERROR;
        else if (outcome.ExitCode == RESTART_EXIT_CODE || restartScheduled)
            outcome.Type = SHUTDOWN_TYPE_RESTART;
 
        // Column limit; strict SQL mode rejects the whole UPDATE on overflow
        utf8truncate(outcome.Reason, 255);
    }
 
    LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_UPTIME_SHUTDOWN);
    stmt->SetData(0, uint32(GameTime::GetUptime().count()));
    stmt->SetData(1, uint16(sWorldSessionMgr->GetMaxPlayerCount()));
    if (finished)
        stmt->SetData(2, uint32(std::time(nullptr)));
    else
        stmt->SetData(2);
    stmt->SetData(3, uint8(_sessionOutcome->Type));
    stmt->SetData(4, _sessionOutcome->ExitCode);
    stmt->SetData(5, _sessionOutcome->Reason);
    stmt->SetData(6, realm.Id.Realm);
    stmt->SetData(7, uint32(GameTime::GetStartTime().count()));
    LoginDatabase.DirectExecute(stmt);
}

References _exitCode, _sessionOutcome, _shutdownMask, _shutdownReason, _stoppedByStopNow, ERROR_EXIT_CODE, SessionOutcome::ExitCode, GameTime::GetStartTime(), GameTime::GetUptime(), Realm::Id, LOGIN_UPD_UPTIME_SHUTDOWN, LoginDatabase, realm, RealmHandle::Realm, SessionOutcome::Reason, RESTART_EXIT_CODE, PreparedStatementBase::SetData(), SHUTDOWN_MASK_RESTART, SHUTDOWN_TYPE_ERROR, SHUTDOWN_TYPE_RESTART, SHUTDOWN_TYPE_SHUTDOWN, sWorldSessionMgr, SessionOutcome::Type, and utf8truncate().

SetAllowMovement()

void World::SetAllowMovement ( bool  allow )

inlineoverridevirtual

Allow/Disallow object movements.

Implements IWorld.

{ _allowMovement = allow; }

References _allowMovement.

setBoolConfig()

void World::setBoolConfig ( ServerConfigs  index, bool  value  )

overridevirtual

Implements IWorld.

{
    _worldConfig.OverwriteConfigValue<bool>(index, value);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::OverwriteConfigValue().

SetCleaningFlags()

void World::SetCleaningFlags ( uint32  flags )

inlineoverridevirtual

Implements IWorld.

{ _cleaningFlags = flags; }

References _cleaningFlags.

SetClosed()

void World::SetClosed ( bool  val )

overridevirtual

Close world.

Implements IWorld.

{
    _isClosed = val;
 
    // Invert the value, for simplicity for scripters.
    sScriptMgr->OnOpenStateChange(!val);
}

References _isClosed, and sScriptMgr.

setFloatConfig()

void World::setFloatConfig ( ServerConfigs  index, float  value  )

overridevirtual

Implements IWorld.

{
    _worldConfig.OverwriteConfigValue<float>(index, value);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::OverwriteConfigValue().

Referenced by setRate().

SetInitialWorldSettings()

void World::SetInitialWorldSettings ( )

overridevirtual

Initialize the World.

• Server startup begin

• Initialize the random number generator

• Initialize detour memory management

• Initialize VMapMgr function pointers (to untangle game/collision circular deps)

• Initialize config settings

• Initialize Allowed Security Level

• Init highest guids before any table loading to prevent using not initialized guids in some code.

• Check the existence of the map files for all starting areas.

• Initialize pool manager

• Initialize game event manager

• Loading strings. Getting no records means core load has to be canceled because no error message can be output.

• Update the realm entry in the database with the realm type from the config file

• Custom Hook for loading DB items

• Load the DBC files

• Initilize static helper structures

• Load dynamic data tables from the database

• Handle outdated emails (delete/return)

• Load AutoBroadCast

• Load Motd

• Load and initialize scripts

• Initialize game time and timers

• Initialize MapMgr

• Initialize Battlegrounds

• Initialize outdoor pvp

• Initialize Battlefield

• Initialize Warden

Implements IWorld.

{
    uint32 startupBegin = getMSTime();
 
    srand((unsigned int)GameTime::GetGameTime().count());
 
    dtAllocSetCustom(dtCustomAlloc, dtCustomFree);
 
    VMAP::VMapMgr2* vmmgr2 = VMAP::VMapFactory::createOrGetVMapMgr();
    vmmgr2->GetLiquidFlagsPtr = &GetLiquidFlags;
    vmmgr2->IsVMAPDisabledForPtr = &DisableMgr::IsVMAPDisabledFor;
 
    LoadConfigSettings();
 
    LoadDBAllowedSecurityLevel();
 
    sObjectMgr->SetHighestGuids();
 
    if (!sConfigMgr->isDryRun())
    {
        if (!MapMgr::ExistMapAndVMap(MAP_EASTERN_KINGDOMS, -6240.32f, 331.033f)
                || !MapMgr::ExistMapAndVMap(MAP_EASTERN_KINGDOMS, -8949.95f, -132.493f)
                || !MapMgr::ExistMapAndVMap(MAP_KALIMDOR, -618.518f, -4251.67f)
                || !MapMgr::ExistMapAndVMap(MAP_EASTERN_KINGDOMS, 1676.35f, 1677.45f)
                || !MapMgr::ExistMapAndVMap(MAP_KALIMDOR, 10311.3f, 832.463f)
                || !MapMgr::ExistMapAndVMap(MAP_KALIMDOR, -2917.58f, -257.98f)
                || (getIntConfig(CONFIG_EXPANSION) && (
                        !MapMgr::ExistMapAndVMap(MAP_OUTLAND, 10349.6f, -6357.29f) ||
                        !MapMgr::ExistMapAndVMap(MAP_OUTLAND, -3961.64f, -13931.2f))))
        {
            LOG_ERROR("server.loading", "Failed to find map files for starting areas");
            exit(1);
        }
    }
 
    sPoolMgr->Initialize();
 
    sGameEventMgr->Initialize();
 
    LOG_INFO("server.loading", " ");
    LOG_INFO("server.loading", "Loading Acore Strings...");
    if (!sObjectMgr->LoadAcoreStrings())
        exit(1);                                            // Error message displayed in function already
 
    LOG_INFO("server.loading", "Loading Module Strings...");
    sObjectMgr->LoadModuleStrings();
    LOG_INFO("server.loading", "Loading Module Strings Locale...");
    sObjectMgr->LoadModuleStringsLocale();
 
    //No SQL injection as values are treated as integers
 
    // not send custom type REALM_FFA_PVP to realm list
    uint32 server_type;
    if (IsFFAPvPRealm())
        server_type = REALM_TYPE_PVP;
    else
        server_type = getIntConfig(CONFIG_GAME_TYPE);
 
    uint32 realm_zone = getIntConfig(CONFIG_REALM_ZONE);
 
    LoginDatabase.Execute("UPDATE realmlist SET icon = {}, timezone = {} WHERE id = '{}'", server_type, realm_zone, realm.Id.Realm);      // One-time query
 
    sScriptMgr->OnLoadCustomDatabaseTable();
 
    LOG_INFO("server.loading", "Initialize Data Stores...");
    LoadDBCStores(_dataPath);
    DetectDBCLang();
 
    // Load cinematic cameras
    LoadM2Cameras(_dataPath);
 
    LOG_INFO("server.loading", "Loading Player race data...");
    sRaceMgr->LoadRaces();
 
    // Load IP Location Database
    sIPLocation->Load();
 
    LOG_INFO("server.loading", "Loading Game Graveyard...");
    sGraveyard->LoadGraveyardFromDB();
 
    LOG_INFO("server.loading", "Initializing PlayerDump Tables...");
    PlayerDump::InitializeTables();
 
    AIRegistry::Initialize();
 
    LOG_INFO("server.loading", "Loading SpellInfo Store...");
    sSpellMgr->LoadSpellInfoStore();
 
    LOG_INFO("server.loading", "Loading Spell Cooldown Overrides...");
    sSpellMgr->LoadSpellCooldownOverrides();
 
    LOG_INFO("server.loading", "Loading SpellInfo Data Corrections...");
    sSpellMgr->LoadSpellInfoCorrections();
 
    LOG_INFO("server.loading", "Loading Spell Rank Data...");
    sSpellMgr->LoadSpellRanks();
 
    LOG_INFO("server.loading", "Loading Spell Specific And Aura State...");
    sSpellMgr->LoadSpellSpecificAndAuraState();
 
    LOG_INFO("server.loading", "Loading SkillLineAbilityMultiMap Data...");
    sSpellMgr->LoadSkillLineAbilityMap();
 
    LOG_INFO("server.loading", "Loading SpellInfo Custom Attributes...");
    sSpellMgr->LoadSpellInfoCustomAttributes();
 
    LOG_INFO("server.loading", "Loading Spell Jump Distances...");
    sSpellMgr->LoadSpellJumpDistances();
 
    LOG_INFO("server.loading", "Loading SpellInfo Immunity infos...");
    sSpellMgr->LoadSpellInfoImmunities();
 
    LOG_INFO("server.loading", "Loading Player Totem models...");
    sObjectMgr->LoadPlayerTotemModels();
 
    LOG_INFO("server.loading", "Loading Player Shapeshift models...");
    sObjectMgr->LoadPlayerShapeshiftModels();
 
    LOG_INFO("server.loading", "Loading GameObject Models...");
    LoadGameObjectModelList(_dataPath);
 
    LOG_INFO("server.loading", "Loading Script Names...");
    sObjectMgr->LoadScriptNames();
 
    LOG_INFO("server.loading", "Loading Instance Template...");
    sObjectMgr->LoadInstanceTemplate();
 
    LOG_INFO("server.loading", "Loading Character Cache...");
    sCharacterCache->LoadCharacterCacheStorage();
 
    // Must be called before `creature_respawn`/`gameobject_respawn` tables
    LOG_INFO("server.loading", "Loading Instances...");
    sInstanceSaveMgr->LoadInstances();
 
    LOG_INFO("server.loading", "Loading Broadcast Texts...");
    sObjectMgr->LoadBroadcastTexts();
    sObjectMgr->LoadBroadcastTextLocales();
 
    LOG_INFO("server.loading", "Loading Localization Strings...");
    uint32 oldMSTime = getMSTime();
    sObjectMgr->LoadCreatureLocales();
    sObjectMgr->LoadGameObjectLocales();
    sObjectMgr->LoadItemLocales();
    sObjectMgr->LoadItemSetNameLocales();
    sObjectMgr->LoadQuestLocales();
    sObjectMgr->LoadQuestOfferRewardLocale();
    sObjectMgr->LoadQuestRequestItemsLocale();
    sObjectMgr->LoadNpcTextLocales();
    sObjectMgr->LoadPageTextLocales();
    sObjectMgr->LoadGossipMenuItemsLocales();
    sObjectMgr->LoadPointOfInterestLocales();
    sObjectMgr->LoadPetNamesLocales();
 
    sObjectMgr->SetDBCLocaleIndex(GetDefaultDbcLocale());        // Get once for all the locale index of DBC language (console/broadcasts)
    LOG_INFO("server.loading", ">> Localization Strings loaded in {} ms", GetMSTimeDiffToNow(oldMSTime));
    LOG_INFO("server.loading", " ");
 
    LOG_INFO("server.loading", "Loading Account Roles and Permissions...");
    sAccountMgr->LoadRBAC();
 
    LOG_INFO("server.loading", "Loading Page Texts...");
    sObjectMgr->LoadPageTexts();
 
    LOG_INFO("server.loading", "Loading Game Object Templates...");         // must be after LoadPageTexts
    sObjectMgr->LoadGameObjectTemplate();
 
    LOG_INFO("server.loading", "Loading Game Object Template Addons...");
    sObjectMgr->LoadGameObjectTemplateAddons();
 
    LOG_INFO("server.loading", "Loading Transport Templates...");
    sTransportMgr->LoadTransportTemplates();
 
    LOG_INFO("server.loading", "Loading Spell Required Data...");
    sSpellMgr->LoadSpellRequired();
 
    LOG_INFO("server.loading", "Loading Spell Group Types...");
    sSpellMgr->LoadSpellGroups();
 
    LOG_INFO("server.loading", "Loading Spell Learn Skills...");
    sSpellMgr->LoadSpellLearnSkills();                           // must be after LoadSpellRanks
 
    LOG_INFO("server.loading", "Loading Spell Proc Conditions and Data...");
    sSpellMgr->LoadSpellProcs();
 
    LOG_INFO("server.loading", "Loading Spell Bonus Data...");
    sSpellMgr->LoadSpellBonuses();
 
    LOG_INFO("server.loading", "Loading Aggro Spells Definitions...");
    sSpellMgr->LoadSpellThreats();
 
    LOG_INFO("server.loading", "Loading Mixology Bonuses...");
    sSpellMgr->LoadSpellMixology();
 
    LOG_INFO("server.loading", "Loading Spell Group Stack Rules...");
    sSpellMgr->LoadSpellGroupStackRules();
 
    LOG_INFO("server.loading", "Loading NPC Texts...");
    sObjectMgr->LoadGossipText();
 
    LOG_INFO("server.loading", "Loading Enchant Spells Proc Datas...");
    sSpellMgr->LoadSpellEnchantProcData();
 
    LOG_INFO("server.loading", "Loading Item Random Enchantments Table...");
    LoadRandomEnchantmentsTable();
 
    LOG_INFO("server.loading", "Loading Disables");
    sDisableMgr->LoadDisables();                                  // must be before loading quests and items
 
    LOG_INFO("server.loading", "Loading Items...");                         // must be after LoadRandomEnchantmentsTable and LoadPageTexts
    sObjectMgr->LoadItemTemplates();
 
    LOG_INFO("server.loading", "Loading Item Set Names...");                // must be after LoadItemPrototypes
    sObjectMgr->LoadItemSetNames();
 
    LOG_INFO("server.loading", "Loading Creature Model Based Info Data...");
    sObjectMgr->LoadCreatureModelInfo();
 
    LOG_INFO("server.loading", "Loading Creature Custom IDs Config...");
    sObjectMgr->LoadCreatureCustomIDs();
 
    LOG_INFO("server.loading", "Loading Creature Templates...");
    sObjectMgr->LoadCreatureTemplates();
 
    LOG_INFO("server.loading", "Loading Equipment Templates...");           // must be after LoadCreatureTemplates
    sObjectMgr->LoadEquipmentTemplates();
 
    LOG_INFO("server.loading", "Loading Creature Template Addons...");
    sObjectMgr->LoadCreatureTemplateAddons();
 
    LOG_INFO("server.loading", "Loading Reputation Reward Rates...");
    sObjectMgr->LoadReputationRewardRate();
 
    LOG_INFO("server.loading", "Loading Creature Reputation OnKill Data...");
    sObjectMgr->LoadReputationOnKill();
 
    LOG_INFO("server.loading", "Loading Reputation Spillover Data..." );
    sObjectMgr->LoadReputationSpilloverTemplate();
 
    LOG_INFO("server.loading", "Loading Points Of Interest Data...");
    sObjectMgr->LoadPointsOfInterest();
 
    LOG_INFO("server.loading", "Loading Creature Base Stats...");
    sObjectMgr->LoadCreatureClassLevelStats();
 
    LOG_INFO("server.loading", "Loading Spawn Group Templates...");
    sObjectMgr->LoadSpawnGroupTemplates();
 
    LOG_INFO("server.loading", "Loading Creature Data...");
    sObjectMgr->LoadCreatures();
 
    LOG_INFO("server.loading", "Loading Creature sparring...");
    sObjectMgr->LoadCreatureSparring();
 
    LOG_INFO("server.loading", "Loading Temporary Summon Data...");
    sObjectMgr->LoadTempSummons();                               // must be after LoadCreatureTemplates() and LoadGameObjectTemplates()
 
    LOG_INFO("server.loading", "Loading Gameobject Summon Data...");
    sObjectMgr->LoadGameObjectSummons();                         // must be after LoadCreatureTemplates() and LoadGameObjectTemplates()
 
    LOG_INFO("server.loading", "Loading Pet Levelup Spells...");
    sSpellMgr->LoadPetLevelupSpellMap();
 
    LOG_INFO("server.loading", "Loading Pet default Spells additional to Levelup Spells...");
    sSpellMgr->LoadPetDefaultSpells();
 
    LOG_INFO("server.loading", "Loading Creature Addon Data...");
    sObjectMgr->LoadCreatureAddons();                            // must be after LoadCreatureTemplates() and LoadCreatures()
 
    LOG_INFO("server.loading", "Loading Creature Movement Overrides...");
    sObjectMgr->LoadCreatureMovementOverrides(); // must be after LoadCreatures()
 
    LOG_INFO("server.loading", "Loading Gameobject Data...");
    sObjectMgr->LoadGameobjects();
 
    LOG_INFO("server.loading", "Loading Spawn Group Data...");
    sObjectMgr->LoadSpawnGroups();                                 // must be after LoadCreatures() and LoadGameobjects()
 
    LOG_INFO("server.loading", "Loading GameObject Addon Data...");
    sObjectMgr->LoadGameObjectAddons();                          // must be after LoadGameObjectTemplate() and LoadGameobjects()
 
    LOG_INFO("server.loading", "Loading GameObject Quest Items...");
    sObjectMgr->LoadGameObjectQuestItems();
 
    LOG_INFO("server.loading", "Loading Creature Quest Items...");
    sObjectMgr->LoadCreatureQuestItems();
 
    LOG_INFO("server.loading", "Loading Creature Linked Respawn...");
    sObjectMgr->LoadLinkedRespawn();                             // must be after LoadCreatures(), LoadGameObjects()
 
    LOG_INFO("server.loading", "Loading Weather Data...");
    WeatherMgr::LoadWeatherData();
 
    LOG_INFO("server.loading", "Loading Quests...");
    sObjectMgr->LoadQuests();                                    // must be loaded after DBCs, creature_template, item_template, gameobject tables
 
    LOG_INFO("server.loading", "Checking Quest Disables");
    sDisableMgr->CheckQuestDisables();                           // must be after loading quests
 
    LOG_INFO("server.loading", "Loading Quest POI");
    sObjectMgr->LoadQuestPOI();
 
    LOG_INFO("server.loading", "Loading Quests Starters and Enders...");
    sObjectMgr->LoadQuestStartersAndEnders();                    // must be after quest load
 
    LOG_INFO("server.loading", "Loading Quest Greetings...");
    sObjectMgr->LoadQuestGreetings();                               // must be loaded after creature_template, gameobject_template tables
    LOG_INFO("server.loading", "Loading Quest Greeting Locales...");
    sObjectMgr->LoadQuestGreetingsLocales();                        // must be loaded after creature_template, gameobject_template tables, quest_greeting
 
    LOG_INFO("server.loading", "Loading Quest Money Rewards...");
    sObjectMgr->LoadQuestMoneyRewards();
 
    LOG_INFO("server.loading", "Loading Objects Pooling Data...");
    sPoolMgr->LoadFromDB();
 
    LOG_INFO("server.loading", "Loading Game Event Data...");               // must be after loading pools fully
    sGameEventMgr->LoadHolidayDates();                           // Must be after loading DBC
    sGameEventMgr->LoadFromDB();                                 // Must be after loading holiday dates
 
    LOG_INFO("server.loading", "Loading UNIT_NPC_FLAG_SPELLCLICK Data..."); // must be after LoadQuests
    sObjectMgr->LoadNPCSpellClickSpells();
 
    LOG_INFO("server.loading", "Loading Vehicle Template Accessories...");
    sObjectMgr->LoadVehicleTemplateAccessories();                // must be after LoadCreatureTemplates() and LoadNPCSpellClickSpells()
 
    LOG_INFO("server.loading", "Loading Vehicle Accessories...");
    sObjectMgr->LoadVehicleAccessories();                       // must be after LoadCreatureTemplates() and LoadNPCSpellClickSpells()
 
    LOG_INFO("server.loading", "Loading Vehicle Seat Addon Data...");
    sObjectMgr->LoadVehicleSeatAddon();                         // must be after loading DBC
 
    LOG_INFO("server.loading", "Loading SpellArea Data...");                // must be after quest load
    sSpellMgr->LoadSpellAreas();
 
    LOG_INFO("server.loading", "Loading Area Trigger Definitions");
    sObjectMgr->LoadAreaTriggers();
 
    LOG_INFO("server.loading", "Loading Area Trigger Teleport Definitions...");
    sObjectMgr->LoadAreaTriggerTeleports();
 
    LOG_INFO("server.loading", "Loading Access Requirements...");
    sObjectMgr->LoadAccessRequirements();                        // must be after item template load
 
    LOG_INFO("server.loading", "Loading Quest Area Triggers...");
    sObjectMgr->LoadQuestAreaTriggers();                         // must be after LoadQuests
 
    LOG_INFO("server.loading", "Loading Tavern Area Triggers...");
    sObjectMgr->LoadTavernAreaTriggers();
 
    LOG_INFO("server.loading", "Loading AreaTrigger Script Names...");
    sObjectMgr->LoadAreaTriggerScripts();
 
    LOG_INFO("server.loading", "Loading LFG Entrance Positions..."); // Must be after areatriggers
    sLFGMgr->LoadLFGDungeons();
 
    LOG_INFO("server.loading", "Loading Dungeon Boss Data...");
    sObjectMgr->LoadInstanceEncounters();
 
    LOG_INFO("server.loading", "Loading LFG Rewards...");
    sLFGMgr->LoadRewards();
 
    LOG_INFO("server.loading", "Loading Graveyard-Zone Links...");
    sGraveyard->LoadGraveyardZones();
 
    LOG_INFO("server.loading", "Loading Spell Pet Auras...");
    sSpellMgr->LoadSpellPetAuras();
 
    LOG_INFO("server.loading", "Loading Spell Target Coordinates...");
    sSpellMgr->LoadSpellTargetPositions();
 
    LOG_INFO("server.loading", "Loading Spell Cone definitions...");
    sSpellMgr->LoadSpellCones();
 
    LOG_INFO("server.loading", "Loading Enchant Custom Attributes...");
    sSpellMgr->LoadEnchantCustomAttr();
 
    LOG_INFO("server.loading", "Loading linked Spells...");
    sSpellMgr->LoadSpellLinked();
 
    LOG_INFO("server.loading", "Loading Player Create Data...");
    sObjectMgr->LoadPlayerInfo();
 
    LOG_INFO("server.loading", "Loading Exploration BaseXP Data...");
    sObjectMgr->LoadExplorationBaseXP();
 
    LOG_INFO("server.loading", "Loading Pet Name Parts...");
    sObjectMgr->LoadPetNames();
 
    CharacterDatabaseCleaner::CleanDatabase();
 
    LOG_INFO("server.loading", "Loading The Max Pet Number...");
    sObjectMgr->LoadPetNumber();
 
    LOG_INFO("server.loading", "Loading Pet Level Stats...");
    sObjectMgr->LoadPetLevelInfo();
 
    LOG_INFO("server.loading", "Loading Player Level Dependent Mail Rewards...");
    sObjectMgr->LoadMailLevelRewards();
 
    LOG_INFO("server.loading", "Load Mail Server definitions...");
    sServerMailMgr->LoadMailServerTemplates();
 
    // Loot tables
    LoadLootTables();
 
    LOG_INFO("server.loading", "Loading Skill Discovery Table...");
    LoadSkillDiscoveryTable();
 
    LOG_INFO("server.loading", "Loading Skill Extra Item Table...");
    LoadSkillExtraItemTable();
 
    LOG_INFO("server.loading", "Loading Skill Perfection Data Table...");
    LoadSkillPerfectItemTable();
 
    LOG_INFO("server.loading", "Loading Skill Fishing Base Level Requirements...");
    sObjectMgr->LoadFishingBaseSkillLevel();
 
    LOG_INFO("server.loading", "Loading Achievements...");
    sAchievementMgr->LoadAchievementReferenceList();
    LOG_INFO("server.loading", "Loading Achievement Criteria Lists...");
    sAchievementMgr->LoadAchievementCriteriaList();
    LOG_INFO("server.loading", "Loading Achievement Criteria Data...");
    sAchievementMgr->LoadAchievementCriteriaData();
    LOG_INFO("server.loading", "Loading Achievement Rewards...");
    sAchievementMgr->LoadRewards();
    LOG_INFO("server.loading", "Loading Achievement Reward Locales...");
    sAchievementMgr->LoadRewardLocales();
    LOG_INFO("server.loading", "Loading Completed Achievements...");
    sAchievementMgr->LoadCompletedAchievements();
 
    LOG_INFO("server.loading", "Loading Item Auctions...");
    sAuctionMgr->LoadAuctionItems();
    LOG_INFO("server.loading", "Loading Auctions...");
    sAuctionMgr->LoadAuctions();
 
    sGuildMgr->LoadGuilds();
 
    LOG_INFO("server.loading", "Loading ArenaTeams...");
    sArenaTeamMgr->LoadArenaTeams();
 
    LOG_INFO("server.loading", "Loading Groups...");
    sGroupMgr->LoadGroups();
 
    LOG_INFO("server.loading", "Loading Reserved Names...");
    sObjectMgr->LoadReservedPlayerNamesDB();
    sObjectMgr->LoadReservedPlayerNamesDBC(); // Needs to be after LoadReservedPlayerNamesDB()
 
    LOG_INFO("server.loading", "Loading Profanity Names...");
    sObjectMgr->LoadProfanityNamesFromDB();
    sObjectMgr->LoadProfanityNamesFromDBC(); // Needs to be after LoadProfanityNamesFromDB()
 
    LOG_INFO("server.loading", "Loading Chat Filter...");
    sObjectMgr->LoadChatFilter();
 
    LOG_INFO("server.loading", "Loading GameObjects for Quests...");
    sObjectMgr->LoadGameObjectForQuests();
 
    LOG_INFO("server.loading", "Loading BattleMasters...");
    sBattlegroundMgr->LoadBattleMastersEntry();
 
    LOG_INFO("server.loading", "Loading GameTeleports...");
    sObjectMgr->LoadGameTele();
 
    LOG_INFO("server.loading", "Loading Trainers..."); // must be after LoadCreatureTemplates
    sObjectMgr->LoadTrainers();
 
    LOG_INFO("server.loading", "Loading Creature default trainers...");
    sObjectMgr->LoadCreatureDefaultTrainers();
 
    LOG_INFO("server.loading", "Loading Gossip Menu...");
    sObjectMgr->LoadGossipMenu();
 
    LOG_INFO("server.loading", "Loading Gossip Menu Options...");
    sObjectMgr->LoadGossipMenuItems();
 
    LOG_INFO("server.loading", "Loading Vendors...");
    sObjectMgr->LoadVendors();                                   // must be after load CreatureTemplate and ItemTemplate
 
    LOG_INFO("server.loading", "Loading Waypoints...");
    sWaypointMgr->Load();
 
    LOG_INFO("server.loading", "Loading Waypoint Addons...");
    sWaypointMgr->LoadWaypointAddons();
 
    LOG_INFO("server.loading", "Loading SmartAI Waypoints...");
    sSmartWaypointMgr->LoadFromDB();
 
    LOG_INFO("server.loading", "Loading Creature Formations...");
    sFormationMgr->LoadCreatureFormations();
 
    LOG_INFO("server.loading", "Loading WorldStates...");              // must be loaded before battleground, outdoor PvP and conditions
    sWorldState->LoadWorldStates();
 
    LOG_INFO("server.loading", "Loading Conditions...");
    sConditionMgr->LoadConditions();
 
    LOG_INFO("server.loading", "Loading Faction Change Achievement Pairs...");
    sObjectMgr->LoadFactionChangeAchievements();
 
    LOG_INFO("server.loading", "Loading Faction Change Spell Pairs...");
    sObjectMgr->LoadFactionChangeSpells();
 
    LOG_INFO("server.loading", "Loading Faction Change Item Pairs...");
    sObjectMgr->LoadFactionChangeItems();
 
    LOG_INFO("server.loading", "Loading Faction Change Reputation Pairs...");
    sObjectMgr->LoadFactionChangeReputations();
 
    LOG_INFO("server.loading", "Loading Faction Change Title Pairs...");
    sObjectMgr->LoadFactionChangeTitles();
 
    LOG_INFO("server.loading", "Loading Faction Change Quest Pairs...");
    sObjectMgr->LoadFactionChangeQuests();
 
    LOG_INFO("server.loading", "Loading GM Tickets...");
    sTicketMgr->LoadTickets();
 
    LOG_INFO("server.loading", "Loading GM Surveys...");
    sTicketMgr->LoadSurveys();
 
    LOG_INFO("server.loading", "Loading Client Addons...");
    AddonMgr::LoadFromDB();
 
    // pussywizard:
    LOG_INFO("server.loading", "Deleting Invalid Mail Items...");
    LOG_INFO("server.loading", " ");
    CharacterDatabase.Execute("DELETE mi FROM mail_items mi LEFT JOIN item_instance ii ON mi.item_guid = ii.guid WHERE ii.guid IS NULL");
    CharacterDatabase.Execute("DELETE mi FROM mail_items mi LEFT JOIN mail m ON mi.mail_id = m.id WHERE m.id IS NULL");
    CharacterDatabase.Execute("UPDATE mail m LEFT JOIN mail_items mi ON m.id = mi.mail_id SET m.has_items=0 WHERE m.has_items<>0 AND mi.mail_id IS NULL");
 
    LOG_INFO("server.loading", "Returning Old Mails...");
    LOG_INFO("server.loading", " ");
    sMailMgr->ReturnOrDeleteOldMails(false);
 
    LOG_INFO("server.loading", "Loading Autobroadcasts...");
    sAutobroadcastMgr->LoadAutobroadcasts();
    sAutobroadcastMgr->LoadAutobroadcastsLocalized();
 
    LOG_INFO("server.loading", "Loading Motd...");
    sMotdMgr->LoadMotd();
 
    sObjectMgr->LoadSpellScripts();                              // must be after load Creature/Gameobject(Template/Data)
    sObjectMgr->LoadEventScripts();                              // must be after load Creature/Gameobject(Template/Data)
    sObjectMgr->LoadWaypointScripts();
 
    LOG_INFO("server.loading", "Loading Spell Script Names...");
    sObjectMgr->LoadSpellScriptNames();
 
    LOG_INFO("server.loading", "Loading Creature Texts...");
    sCreatureTextMgr->LoadCreatureTexts();
 
    LOG_INFO("server.loading", "Loading Creature Text Options...");
    sCreatureTextMgr->LoadCreatureTextOptions();
 
    LOG_INFO("server.loading", "Loading Creature Text Locales...");
    sCreatureTextMgr->LoadCreatureTextLocales();
 
    LOG_INFO("server.loading", "Loading Scripts...");
    sScriptMgr->LoadDatabase();
 
    LOG_INFO("server.loading", "Validating Spell Scripts...");
    sObjectMgr->ValidateSpellScripts();
 
    LOG_INFO("server.loading", "Loading SmartAI Scripts...");
    sSmartScriptMgr->LoadSmartAIFromDB();
 
    LOG_INFO("server.loading", "Loading Calendar Data...");
    sCalendarMgr->LoadFromDB();
 
    LOG_INFO("server.loading", "Initializing SpellInfo Precomputed Data..."); // must be called after loading items, professions, spells and pretty much anything
    LOG_INFO("server.loading", " ");
    sObjectMgr->InitializeSpellInfoPrecomputedData();
 
    LOG_INFO("server.loading", "Initialize Commands...");
    Acore::ChatCommands::LoadCommandMap();
 
    LOG_INFO("server.loading", "Initialize Game Time and Timers");
    LOG_INFO("server.loading", " ");
 
    // A dry run exits below without unwinding main(), so its row would never be marked as cleanly ended
    if (!sConfigMgr->isDryRun())
    {
        // Must run before this session's row is inserted. Cluster nodes share the realm id, so the newest
        // row may be another node's live session. The sidecar isn't initialized yet, so read the config.
        if (!sConfigMgr->GetOption<bool>("Cluster.Enabled", false))
            LoadPreviousSessionInfo();
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_UPTIME);
        stmt->SetData(0, realm.Id.Realm);
        stmt->SetData(1, uint32(GameTime::GetStartTime().count()));
        stmt->SetData(2, GitRevision::GetFullVersion());
        // Synchronous so it can't land after the shutdown UPDATEs, which run on the synchronous connection
        LoginDatabase.DirectExecute(stmt);
    }
 
    _timers[WUPDATE_UPTIME].SetInterval(getIntConfig(CONFIG_UPTIME_UPDATE)*MINUTE * IN_MILLISECONDS);
    //Update "uptime" table based on configuration entry in minutes.
 
    _timers[WUPDATE_CLEANDB].SetInterval(getIntConfig(CONFIG_LOGDB_CLEARINTERVAL)*MINUTE * IN_MILLISECONDS);
    // clean logs table every 14 days by default
    _timers[WUPDATE_AUTOBROADCAST].SetInterval(getIntConfig(CONFIG_AUTOBROADCAST_INTERVAL));
 
    _timers[WUPDATE_PINGDB].SetInterval(getIntConfig(CONFIG_DB_PING_INTERVAL)*MINUTE * IN_MILLISECONDS);  // Mysql ping time in minutes
 
    // our speed up
    _timers[WUPDATE_5_SECS].SetInterval(5 * IN_MILLISECONDS);
 
    _timers[WUPDATE_WHO_LIST].SetInterval(5 * IN_MILLISECONDS); // update who list cache every 5 seconds
 
    _mail_expire_check_timer = GameTime::GetGameTime() + 6h;
 
    LOG_INFO("server.loading", "Starting Map System");
    LOG_INFO("server.loading", " ");
    sMapMgr->Initialize();
 
    LOG_INFO("server.loading", "Starting Game Event system...");
    LOG_INFO("server.loading", " ");
    uint32 nextGameEvent = sGameEventMgr->StartSystem();
    _timers[WUPDATE_EVENTS].SetInterval(nextGameEvent);    //depend on next event
 
    LOG_INFO("server.loading", "Loading WorldState...");
    sWorldState->Load(); // must be called after loading game events
 
    // Delete all characters which have been deleted X days before
    Player::DeleteOldCharacters();
 
    // Delete all items which have been deleted X days before
    Player::DeleteOldRecoveryItems();
 
    // Delete all custom channels which haven't been used for PreserveCustomChannelDuration days.
    Channel::CleanOldChannelsInDB();
 
    LOG_INFO("server.loading", "Initializing Opcodes...");
    opcodeTable.Initialize();
 
    LOG_INFO("server.loading", "Loading Arena Season Rewards...");
    sArenaSeasonMgr->LoadRewards();
    LOG_INFO("server.loading", "Loading Active Arena Season...");
    sArenaSeasonMgr->LoadActiveSeason();
 
    sTicketMgr->Initialize();
 
    LOG_INFO("server.loading", "Starting Battleground System");
    sBattlegroundMgr->LoadBattlegroundTemplates();
    sBattlegroundMgr->InitAutomaticArenaPointDistribution();
 
    LOG_INFO("server.loading", "Starting Outdoor PvP System");
    sOutdoorPvPMgr->InitOutdoorPvP();
 
    LOG_INFO("server.loading", "Starting Battlefield System");
    sBattlefieldMgr->InitBattlefield();
 
    LOG_INFO("server.loading", "Loading Transports...");
    sTransportMgr->SpawnContinentTransports();
 
    LOG_INFO("server.loading", "Loading Warden Checks..." );
    sWardenCheckMgr->LoadWardenChecks();
 
    LOG_INFO("server.loading", "Loading Warden Action Overrides..." );
    sWardenCheckMgr->LoadWardenOverrides();
 
    LOG_INFO("server.loading", "Deleting Expired Bans...");
    LoginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate <= UNIX_TIMESTAMP() AND unbandate<>bandate");      // One-time query
 
    LOG_INFO("server.loading", "Calculate Next Daily Quest Reset Time...");
    InitDailyQuestResetTime();
 
    LOG_INFO("server.loading", "Calculate Next Weekly Quest Reset Time..." );
    InitWeeklyQuestResetTime();
 
    LOG_INFO("server.loading", "Calculate Next Monthly Quest Reset Time...");
    InitMonthlyQuestResetTime();
 
    LOG_INFO("server.loading", "Calculate Random Battleground Reset Time..." );
    InitRandomBGResetTime();
 
    LOG_INFO("server.loading", "Calculate Deletion Of Old Calendar Events Time...");
    InitCalendarOldEventsDeletionTime();
 
    LOG_INFO("server.loading", "Calculate Guild Cap Reset Time...");
    LOG_INFO("server.loading", " ");
    InitGuildResetTime();
 
    LOG_INFO("server.loading", "Load Petitions...");
    sPetitionMgr->LoadPetitions();
 
    LOG_INFO("server.loading", "Load Petition Signs...");
    sPetitionMgr->LoadSignatures();
 
    LOG_INFO("server.loading", "Load Stored Loot Items...");
    sLootItemStorage->LoadStorageFromDB();
 
    LOG_INFO("server.loading", "Load Channel Rights...");
    ChannelMgr::LoadChannelRights();
 
    LOG_INFO("server.loading", "Load Channels...");
    ChannelMgr::LoadChannels();
 
    LOG_INFO("server.loading", "Loading AntiDos opcode policies");
    sWorldGlobals->LoadAntiDosOpcodePolicies();
 
    sScriptMgr->OnBeforeWorldInitialized();
 
    if (getBoolConfig(CONFIG_PRELOAD_ALL_NON_INSTANCED_MAP_GRIDS))
    {
        LOG_INFO("server.loading", "Loading All Grids For All Non-Instanced Maps...");
 
        for (uint32 i = 0; i < sMapStore.GetNumRows(); ++i)
        {
            MapEntry const* mapEntry = sMapStore.LookupEntry(i);
 
            if (mapEntry && !mapEntry->Instanceable())
            {
                if (sMapMgr->GetMapUpdater()->activated())
                    sMapMgr->GetMapUpdater()->schedule_map_preload(mapEntry->MapID);
                else
                {
                    Map* map = sMapMgr->CreateBaseMap(mapEntry->MapID);
 
                    if (map)
                    {
                        LOG_INFO("server.loading", ">> Loading All Grids For Map {}", map->GetId());
                        map->LoadAllGrids();
                    }
                }
            }
        }
 
        if (sMapMgr->GetMapUpdater()->activated())
            sMapMgr->GetMapUpdater()->wait();
    }
 
    uint32 startupDuration = GetMSTimeDiffToNow(startupBegin);
 
    LOG_INFO("server.loading", " ");
    LOG_INFO("server.loading", "WORLD: World Initialized In {} Minutes {} Seconds", (startupDuration / 60000), ((startupDuration % 60000) / 1000)); // outError for red color in console
    LOG_INFO("server.loading", " ");
 
    METRIC_EVENT("events", "World initialized", "World Initialized In " + std::to_string(startupDuration / 60000) + " Minutes " + std::to_string((startupDuration % 60000) / 1000) + " Seconds");
 
    if (sConfigMgr->isDryRun())
    {
        sMapMgr->UnloadAll();
 
        if (uint32 failed = DBUpdaterUtil::GetFailedUpdateCount())
        {
            LOG_FATAL("server.loading", "AzerothCore Dry Run Completed With {} Failed Database Update(s), Terminating.", failed);
            exit(1);
        }
 
        LOG_INFO("server.loading", "AzerothCore Dry Run Completed, Terminating.");
        exit(0);
    }
}

References _dataPath, _mail_expire_check_timer, _timers, CharacterDatabase, CharacterDatabaseCleaner::CleanDatabase(), Channel::CleanOldChannelsInDB(), CONFIG_AUTOBROADCAST_INTERVAL, CONFIG_DB_PING_INTERVAL, CONFIG_EXPANSION, CONFIG_GAME_TYPE, CONFIG_LOGDB_CLEARINTERVAL, CONFIG_PRELOAD_ALL_NON_INSTANCED_MAP_GRIDS, CONFIG_REALM_ZONE, CONFIG_UPTIME_UPDATE, VMAP::VMapFactory::createOrGetVMapMgr(), Player::DeleteOldCharacters(), Player::DeleteOldRecoveryItems(), DetectDBCLang(), dtCustomAlloc(), dtCustomFree(), MapMgr::ExistMapAndVMap(), getBoolConfig(), GetDefaultDbcLocale(), DBUpdaterUtil::GetFailedUpdateCount(), GitRevision::GetFullVersion(), GameTime::GetGameTime(), Map::GetId(), getIntConfig(), GetLiquidFlags(), VMAP::VMapMgr2::GetLiquidFlagsPtr, getMSTime(), GetMSTimeDiffToNow(), GameTime::GetStartTime(), Realm::Id, IN_MILLISECONDS, InitCalendarOldEventsDeletionTime(), InitDailyQuestResetTime(), InitGuildResetTime(), AIRegistry::Initialize(), OpcodeTable::Initialize(), PlayerDump::InitializeTables(), InitMonthlyQuestResetTime(), InitRandomBGResetTime(), InitWeeklyQuestResetTime(), MapEntry::Instanceable(), IsFFAPvPRealm(), DisableMgr::IsVMAPDisabledFor(), VMAP::VMapMgr2::IsVMAPDisabledForPtr, Map::LoadAllGrids(), ChannelMgr::LoadChannelRights(), ChannelMgr::LoadChannels(), Acore::ChatCommands::LoadCommandMap(), LoadConfigSettings(), LoadDBAllowedSecurityLevel(), LoadDBCStores(), AddonMgr::LoadFromDB(), LoadGameObjectModelList(), LoadLootTables(), LoadM2Cameras(), LoadPreviousSessionInfo(), LoadRandomEnchantmentsTable(), LoadSkillDiscoveryTable(), LoadSkillExtraItemTable(), LoadSkillPerfectItemTable(), WeatherMgr::LoadWeatherData(), LOG_ERROR, LOG_FATAL, LOG_INFO, LOGIN_INS_UPTIME, LoginDatabase, MAP_EASTERN_KINGDOMS, MAP_KALIMDOR, MAP_OUTLAND, MapEntry::MapID, METRIC_EVENT, MINUTE, opcodeTable, realm, RealmHandle::Realm, REALM_TYPE_PVP, sAccountMgr, sAchievementMgr, sArenaSeasonMgr, sArenaTeamMgr, sAuctionMgr, sAutobroadcastMgr, sBattlefieldMgr, sBattlegroundMgr, sCalendarMgr, sCharacterCache, sConditionMgr, sConfigMgr, sCreatureTextMgr, sDisableMgr, PreparedStatementBase::SetData(), IntervalTimer::SetInterval(), sFormationMgr, sGameEventMgr, sGraveyard, sGroupMgr, sGuildMgr, sInstanceSaveMgr, sIPLocation, sLFGMgr, sLootItemStorage, sMailMgr, sMapMgr, sMapStore, sMotdMgr, sObjectMgr, sOutdoorPvPMgr, sPetitionMgr, sPoolMgr, sRaceMgr, sScriptMgr, sServerMailMgr, sSmartScriptMgr, sSmartWaypointMgr, sSpellMgr, sTicketMgr, sTransportMgr, sWardenCheckMgr, sWaypointMgr, sWorldGlobals, sWorldState, WUPDATE_5_SECS, WUPDATE_AUTOBROADCAST, WUPDATE_CLEANDB, WUPDATE_EVENTS, WUPDATE_PINGDB, WUPDATE_UPTIME, and WUPDATE_WHO_LIST.

setIntConfig()

void World::setIntConfig ( ServerConfigs  index, uint32  value  )

overridevirtual

Implements IWorld.

{
    _worldConfig.OverwriteConfigValue<uint32>(index, value);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::OverwriteConfigValue().

SetPlayerSecurityLimit()

void World::SetPlayerSecurityLimit ( AccountTypes  sec )

overridevirtual

Implements IWorld.

{
    AccountTypes sec = _sec < SEC_CONSOLE ? _sec : SEC_PLAYER;
    bool update = sec > _allowedSecurityLevel;
    _allowedSecurityLevel = sec;
    if (update)
        sWorldSessionMgr->KickAllLess(_allowedSecurityLevel);
}

References _allowedSecurityLevel, SEC_CONSOLE, SEC_PLAYER, and sWorldSessionMgr.

Referenced by LoadDBAllowedSecurityLevel().

setRate()

void World::setRate ( ServerConfigs  index, float  value  )

overridevirtual

Implements IWorld.

{
    setFloatConfig(index, value);
}

References setFloatConfig().

SetRealmName()

void World::SetRealmName ( std::string  name )

inlineoverridevirtual

Implements IWorld.

{ _realmName = name; } // pussywizard

References _realmName.

setStringConfig()

void World::setStringConfig ( ServerConfigs  index, std::string const &  value  )

overridevirtual

Implements IWorld.

{
    _worldConfig.OverwriteConfigValue<std::string>(index, value);
}

References _worldConfig, and ConfigValueCache< ConfigEnum >::OverwriteConfigValue().

ShutdownCancel()

void World::ShutdownCancel ( )

overridevirtual

Cancel a planned server shutdown.

Implements IWorld.

{
    // nothing cancel or too later
    if (!_shutdownTimer || _stopEvent)
        return;
 
    ServerMessageType msgid = (_shutdownMask & SHUTDOWN_MASK_RESTART) ? SERVER_MSG_RESTART_CANCELLED : SERVER_MSG_SHUTDOWN_CANCELLED;
 
    _shutdownMask = 0;
    _shutdownTimer = 0;
    _exitCode = SHUTDOWN_EXIT_CODE;                       // to default value
    sWorldSessionMgr->SendServerMessage(msgid);
 
    LOG_DEBUG("server.worldserver", "Server {} cancelled.", (_shutdownMask & SHUTDOWN_MASK_RESTART ? "restart" : "shuttingdown"));
 
    sScriptMgr->OnShutdownCancel();
}

References _exitCode, _shutdownMask, _shutdownTimer, _stopEvent, LOG_DEBUG, SERVER_MSG_RESTART_CANCELLED, SERVER_MSG_SHUTDOWN_CANCELLED, SHUTDOWN_EXIT_CODE, SHUTDOWN_MASK_RESTART, sScriptMgr, and sWorldSessionMgr.

ShutdownMsg()

void World::ShutdownMsg ( bool  show = false, Player *  player = nullptr, std::string const &  reason = std::string()  )

overridevirtual

Displays a shutdown message at specific intervals or immediately if required.

Show the time remaining for a server shutdown/restart with a reason appended if one is provided. Messages are displayed at regular intervals such as every 12 hours, 1 hour, 5 minutes, 1 minute, 30 seconds, 10 seconds, and every second in the last 10 seconds.

Parameters

show	Forces the message to be displayed immediately.
player	The player who should recieve the message (can be nullptr for global messages).
reason	The reason for the shutdown, appended to the message if provided.

• Display a message every 12 hours, hour, 5 minutes, minute, 30 seconds, 10 seconds and finally seconds

Implements IWorld.

{
    // Do not show a message for idle shutdown
    if (_shutdownMask & SHUTDOWN_MASK_IDLE)
        return;
 
    bool twelveHours = (_shutdownTimer > 12 * HOUR && (_shutdownTimer % (12 * HOUR)) == 0); // > 12 h ; every 12 h
    bool oneHour = (_shutdownTimer < 12 * HOUR && (_shutdownTimer % HOUR) == 0); // < 12 h ; every 1 h
    bool fiveMin = (_shutdownTimer < 30 * MINUTE && (_shutdownTimer % (5 * MINUTE)) == 0); // < 30 min ; every 5 min
    bool oneMin = (_shutdownTimer < 15 * MINUTE && (_shutdownTimer % MINUTE) == 0); // < 15 min ; every 1 min
    bool thirtySec = (_shutdownTimer < 5 * MINUTE && (_shutdownTimer % 30) == 0); // < 5 min; every 30 sec
    bool tenSec = (_shutdownTimer < 1 * MINUTE && (_shutdownTimer % 10) == 0); // < 1 min; every 10 sec
    bool oneSec = (_shutdownTimer < 10 * SECOND && (_shutdownTimer % 1) == 0); // < 10 sec; every 1 sec
 
    if (show || twelveHours || oneHour || fiveMin || oneMin || thirtySec || tenSec || oneSec)
    {
        std::string str = secsToTimeString(_shutdownTimer).append(".");
        if (!reason.empty())
            str += " - " + reason;
        // Display the reason every 12 hours, hour, 5 minutes, minute. At 60 seconds and at 10 seconds
        else if (!_shutdownReason.empty() && (twelveHours || oneHour || fiveMin || oneMin || _shutdownTimer == 60 || _shutdownTimer == 10))
            str += " - " + _shutdownReason;
 
        ServerMessageType msgid = (_shutdownMask & SHUTDOWN_MASK_RESTART) ? SERVER_MSG_RESTART_TIME : SERVER_MSG_SHUTDOWN_TIME;
        sWorldSessionMgr->SendServerMessage(msgid, str, player);
        LOG_WARN("server.worldserver", "Server {} in {}", (_shutdownMask & SHUTDOWN_MASK_RESTART ? "restarting" : "shutdown"), str);
    }
}

References _shutdownMask, _shutdownReason, _shutdownTimer, HOUR, LOG_WARN, MINUTE, SECOND, secsToTimeString(), SERVER_MSG_RESTART_TIME, SERVER_MSG_SHUTDOWN_TIME, SHUTDOWN_MASK_IDLE, SHUTDOWN_MASK_RESTART, and sWorldSessionMgr.

Referenced by _UpdateGameTime(), RescheduleShutdownForWintergrasp(), and ShutdownServ().

ShutdownServ()

void World::ShutdownServ ( uint32  time, uint32  options, uint8  exitcode, std::string const &  reason = std::string()  )

overridevirtual

Shutdown the server.

• If the shutdown time is 0, set m_stopEvent (except if shutdown is 'idle' with remaining sessions)

• Else set the shutdown timer and warn users

Implements IWorld.

{
    // ignore if server shutdown at next tick
    if (IsStopped())
        return;
 
    _shutdownMask = options;
    _exitCode = exitcode;
    _shutdownReason = reason;
 
    LOG_DEBUG("server.worldserver", "Server shutdown called with ShutdownMask {}, ExitCode {}, Time {}, Reason {}", ShutdownMask(options), ShutdownExitCode(exitcode), secsToTimeString(time), reason);
 
    if (time == 0)
    {
        if (!(options & SHUTDOWN_MASK_IDLE) || sWorldSessionMgr->GetActiveAndQueuedSessionCount() == 0)
            _stopEvent = true;                             // exist code already set
        else
            _shutdownTimer = 1;                            //So that the session count is re-evaluated at next world tick
    }
    else
    {
        _shutdownTimer = time;
        ShutdownMsg(true, nullptr, reason);
    }
 
    sScriptMgr->OnShutdownInitiate(ShutdownExitCode(exitcode), ShutdownMask(options));
}

References _exitCode, _shutdownMask, _shutdownReason, _shutdownTimer, _stopEvent, IsStopped(), LOG_DEBUG, secsToTimeString(), SHUTDOWN_MASK_IDLE, ShutdownMsg(), sScriptMgr, and sWorldSessionMgr.

StopNow()

static void World::StopNow ( uint8  exitcode )

inlinestatic

{ _stoppedByStopNow = true; _stopEvent = true; _exitCode = exitcode; }

References _exitCode, _stopEvent, and _stoppedByStopNow.

Referenced by ACSoapThread(), CliThread(), ArenaTeamMgr::GenerateArenaTeamId(), ObjectMgr::GenerateAuctionID(), ObjectMgr::GenerateCreatureSpawnId(), ObjectMgr::GenerateEquipmentSetGuid(), ObjectMgr::GenerateGameObjectSpawnId(), GroupMgr::GenerateGroupId(), GuildMgr::GenerateGuildId(), MapMgr::GenerateInstanceId(), ObjectMgr::GenerateMailID(), ObjectGuidGeneratorBase::HandleCounterOverflow(), server_commandscript::HandleServerExitCommand(), main(), SignalHandler(), and WorldUpdateLoop().

Update()

void World::Update ( uint32  diff )

overridevirtual

Update the World !

• Update the game time and check for shutdown time

• Update the different timers

• Update Who List Cache

Handle daily quests reset time

Handle weekly quests reset time

Handle monthly quests reset time

Clean logs table

• Update objects when the timer has passed (maps, transport, creatures, ...)

Update uptime table

• Process Game events when necessary

• Ping to keep MySQL connections alive

Implements IWorld.

{
    METRIC_TIMER("world_update_time_total");
 
    _UpdateGameTime();
    Seconds currentGameTime = GameTime::GetGameTime();
 
    sWorldUpdateTime.UpdateWithDiff(diff);
 
    // Record update if recording set in log and diff is greater then minimum set in log
    sWorldUpdateTime.RecordUpdateTime(GameTime::GetGameTimeMS(), diff, sWorldSessionMgr->GetActiveSessionCount());
 
    DynamicVisibilityMgr::Update(sWorldSessionMgr->GetActiveSessionCount());
 
    for (int i = 0; i < WUPDATE_COUNT; ++i)
    {
        if (_timers[i].GetCurrent() >= 0)
            _timers[i].Update(diff);
        else
            _timers[i].SetCurrent(0);
    }
 
    // pussywizard: our speed up and functionality
    if (_timers[WUPDATE_5_SECS].Passed())
    {
        _timers[WUPDATE_5_SECS].Reset();
 
        // moved here from HandleCharEnumOpcode
        CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_EXPIRED_BANS);
        CharacterDatabase.Execute(stmt);
    }
 
    if (_timers[WUPDATE_WHO_LIST].Passed())
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update who list"));
        _timers[WUPDATE_WHO_LIST].Reset();
        sWhoListCacheMgr->Update();
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Check quest reset times"));
 
        if (currentGameTime > _nextDailyQuestReset)
        {
            ResetDailyQuests();
        }
 
        if (currentGameTime > _nextWeeklyQuestReset)
        {
            ResetWeeklyQuests();
        }
 
        if (currentGameTime > _nextMonthlyQuestReset)
        {
            ResetMonthlyQuests();
        }
    }
 
    if (currentGameTime > _nextRandomBGReset)
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Reset random BG"));
        ResetRandomBG();
    }
 
    if (currentGameTime > _nextCalendarOldEventsDeletionTime)
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Delete old calendar events"));
        CalendarDeleteOldEvents();
    }
 
    if (currentGameTime > _nextGuildReset)
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Reset guild cap"));
        ResetGuildCap();
    }
 
    {
        // pussywizard: handle expired auctions, auctions expired when realm was offline are also handled here (not during loading when many required things aren't loaded yet)
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update expired auctions"));
        sAuctionMgr->Update(diff);
    }
 
    if (currentGameTime > _mail_expire_check_timer)
    {
        sMailMgr->ReturnOrDeleteOldMails(true);
        _mail_expire_check_timer = currentGameTime + 6h;
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update sessions"));
        sWorldSessionMgr->UpdateSessions(diff);
    }
 
    if (getIntConfig(CONFIG_LOGDB_CLEARTIME) > 0) // if not enabled, ignore the timer
    {
        if (_timers[WUPDATE_CLEANDB].Passed())
        {
            METRIC_TIMER("world_update_time", METRIC_TAG("type", "Clean logs table"));
 
            _timers[WUPDATE_CLEANDB].Reset();
 
            LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_OLD_LOGS);
            stmt->SetData(0, getIntConfig(CONFIG_LOGDB_CLEARTIME));
            stmt->SetData(1, uint32(currentGameTime.count()));
            LoginDatabase.Execute(stmt);
        }
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update LFG 0"));
        sLFGMgr->Update(diff, 0); // pussywizard: remove obsolete stuff before finding compatibility during map update
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update maps"));
        sMapMgr->Update(diff);
    }
 
    if (getBoolConfig(CONFIG_AUTOBROADCAST))
    {
        if (_timers[WUPDATE_AUTOBROADCAST].Passed())
        {
            METRIC_TIMER("world_update_time", METRIC_TAG("type", "Send autobroadcast"));
            _timers[WUPDATE_AUTOBROADCAST].Reset();
            sAutobroadcastMgr->SendAutobroadcasts();
        }
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update battlegrounds"));
        sBattlegroundMgr->Update(diff);
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update outdoor pvp"));
        sOutdoorPvPMgr->Update(diff);
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update worldstate"));
        sWorldState->Update(diff);
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update battlefields"));
        sBattlefieldMgr->Update(diff);
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update LFG 2"));
        sLFGMgr->Update(diff, 2); // pussywizard: handle created proposals
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Process query callbacks"));
        // execute callbacks from sql queries that were queued recently
        ProcessQueryCallbacks();
    }
 
    if (_timers[WUPDATE_UPTIME].Passed())
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update uptime"));
 
        _timers[WUPDATE_UPTIME].Reset();
 
        LoginDatabasePreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_UPTIME_PLAYERS);
        stmt->SetData(0, uint32(GameTime::GetUptime().count()));
        stmt->SetData(1, uint16(sWorldSessionMgr->GetMaxPlayerCount()));
        stmt->SetData(2, realm.Id.Realm);
        stmt->SetData(3, uint32(GameTime::GetStartTime().count()));
        LoginDatabase.Execute(stmt);
 
        // Re-assert this realm as online in case the offline flag was set externally (e.g. an authserver restart).
        LoginDatabasePreparedStatement* onlineStmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_REALM_ONLINE);
        onlineStmt->SetData(0, uint8(REALM_FLAG_OFFLINE));
        onlineStmt->SetData(1, realm.Id.Realm);
        LoginDatabase.Execute(onlineStmt);
    }
 
    if (_timers[WUPDATE_EVENTS].Passed())
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update game events"));
        _timers[WUPDATE_EVENTS].Reset();                   // to give time for Update() to be processed
        uint32 nextGameEvent = sGameEventMgr->Update();
        _timers[WUPDATE_EVENTS].SetInterval(nextGameEvent);
        _timers[WUPDATE_EVENTS].Reset();
    }
 
    if (_timers[WUPDATE_PINGDB].Passed())
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Ping MySQL"));
        _timers[WUPDATE_PINGDB].Reset();
        LOG_DEBUG("sql.driver", "Ping MySQL to keep connection alive");
        CharacterDatabase.KeepAlive();
        LoginDatabase.KeepAlive();
        WorldDatabase.KeepAlive();
        sScriptMgr->OnModuleDatabasesKeepAlive();
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update instance reset times"));
        // update the instance reset times
        sInstanceSaveMgr->Update();
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Process cli commands"));
        // And last, but not least handle the issued cli commands
        ProcessCliCommands();
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update world scripts"));
        sScriptMgr->OnWorldUpdate(diff);
    }
 
    if (sToCloud9Sidecar->ClusterModeEnabled())
    {
        {
            METRIC_TIMER("world_update_time", METRIC_TAG("type", "Process TC9 async tasks"));
            sToCloud9Sidecar->ProcessAsyncTasks();
        }
 
        {
            METRIC_TIMER("world_update_time", METRIC_TAG("type", "Process TC9 hooks"));
            sToCloud9Sidecar->ProcessHooks();
        }
 
        {
            METRIC_TIMER("world_update_time", METRIC_TAG("type", "Process TC9 gRPC and HTTP requests"));
            sToCloud9Sidecar->ProcessGrpcOrHttpRequests();
        }
    }
 
    {
        METRIC_TIMER("world_update_time", METRIC_TAG("type", "Update metrics"));
        // Stats logger update
        sMetric->Update();
        METRIC_VALUE("update_time_diff", diff);
    }
}

References _mail_expire_check_timer, _nextCalendarOldEventsDeletionTime, _nextDailyQuestReset, _nextGuildReset, _nextMonthlyQuestReset, _nextRandomBGReset, _nextWeeklyQuestReset, _timers, _UpdateGameTime(), CalendarDeleteOldEvents(), CHAR_DEL_EXPIRED_BANS, CharacterDatabase, CONFIG_AUTOBROADCAST, CONFIG_LOGDB_CLEARTIME, getBoolConfig(), GameTime::GetGameTime(), GameTime::GetGameTimeMS(), getIntConfig(), GameTime::GetStartTime(), GameTime::GetUptime(), Realm::Id, LOG_DEBUG, LOGIN_DEL_OLD_LOGS, LOGIN_UPD_REALM_ONLINE, LOGIN_UPD_UPTIME_PLAYERS, LoginDatabase, METRIC_TAG, METRIC_TIMER, METRIC_VALUE, ProcessCliCommands(), ProcessQueryCallbacks(), realm, RealmHandle::Realm, REALM_FLAG_OFFLINE, WorldUpdateTime::RecordUpdateTime(), IntervalTimer::Reset(), ResetDailyQuests(), ResetGuildCap(), ResetMonthlyQuests(), ResetRandomBG(), ResetWeeklyQuests(), sAuctionMgr, sAutobroadcastMgr, sBattlefieldMgr, sBattlegroundMgr, IntervalTimer::SetCurrent(), PreparedStatementBase::SetData(), IntervalTimer::SetInterval(), sGameEventMgr, sInstanceSaveMgr, sLFGMgr, sMailMgr, sMapMgr, sMetric, sOutdoorPvPMgr, sScriptMgr, sToCloud9Sidecar, sWhoListCacheMgr, sWorldSessionMgr, sWorldState, sWorldUpdateTime, IntervalTimer::Update(), DynamicVisibilityMgr::Update(), UpdateTime::UpdateWithDiff(), WorldDatabase, WUPDATE_5_SECS, WUPDATE_AUTOBROADCAST, WUPDATE_CLEANDB, WUPDATE_COUNT, WUPDATE_EVENTS, WUPDATE_PINGDB, WUPDATE_UPTIME, and WUPDATE_WHO_LIST.

UpdateAreaDependentAuras()

void World::UpdateAreaDependentAuras ( )

overridevirtual

Implements IWorld.

{
    WorldSessionMgr::SessionMap const& sessionMap = sWorldSessionMgr->GetAllSessions();
    for (WorldSessionMgr::SessionMap::const_iterator itr = sessionMap.begin(); itr != sessionMap.end(); ++itr)
        if (itr->second && itr->second->GetPlayer() && itr->second->GetPlayer()->IsInWorld())
        {
            itr->second->GetPlayer()->UpdateAreaDependentAuras(itr->second->GetPlayer()->GetAreaId());
            itr->second->GetPlayer()->UpdateZoneDependentAuras(itr->second->GetPlayer()->GetZoneId());
        }
}

References sWorldSessionMgr.

UpdateRealmCharCount()

void World::UpdateRealmCharCount ( uint32  accid )

overridevirtual

Implements IWorld.

{
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_COUNT);
    stmt->SetData(0, accountId);
    _queryProcessor.AddCallback(CharacterDatabase.AsyncQuery(stmt).WithPreparedCallback(std::bind(&World::_UpdateRealmCharCount, this, std::placeholders::_1,accountId)));
}

References _queryProcessor, _UpdateRealmCharCount(), AsyncCallbackProcessor< T >::AddCallback(), CHAR_SEL_CHARACTER_COUNT, CharacterDatabase, and PreparedStatementBase::SetData().

Member Data Documentation

_allowedSecurityLevel

AccountTypes World::_allowedSecurityLevel

private

Referenced by GetPlayerSecurityLimit(), SetPlayerSecurityLimit(), and World().

_allowMovement

bool World::_allowMovement

private

Referenced by getAllowMovement(), SetAllowMovement(), and World().

_availableDbcLocaleMask

uint32 World::_availableDbcLocaleMask

private

Referenced by DetectDBCLang(), and GetAvailableDbcLocale().

_cleaningFlags

uint32 World::_cleaningFlags

private

Referenced by GetCleaningFlags(), SetCleaningFlags(), and World().

_cliCmdQueue

LockedQueue<CliCommandHolder*> World::_cliCmdQueue

private

Referenced by ProcessCliCommands(), QueueCliCommand(), and ~World().

_dataPath

std::string World::_dataPath

private

Referenced by GetDataPath(), LoadConfigSettings(), and SetInitialWorldSettings().

_dbClientCacheVersion

uint32 World::_dbClientCacheVersion

private

Referenced by LoadConfigSettings(), LoadDBVersion(), and World().

_dbVersion

std::string World::_dbVersion

private

Referenced by GetDBVersion(), and LoadDBVersion().

_defaultDbcLocale

LocaleConstant World::_defaultDbcLocale

private

Referenced by DetectDBCLang(), GetAvailableDbcLocale(), GetDefaultDbcLocale(), and World().

_exitCode

std::atomic< uint8 > World::_exitCode = SHUTDOWN_EXIT_CODE

staticprivate

Referenced by GetExitCode(), SaveSessionEnd(), ShutdownCancel(), ShutdownServ(), and StopNow().

_isClosed

bool World::_isClosed

private

Referenced by IsClosed(), SetClosed(), and World().

_lifetimeMaxPlayerCount

uint32 World::_lifetimeMaxPlayerCount

private

Referenced by GetLifetimeMaxPlayerCount(), LoadPreviousSessionInfo(), and World().

_mail_expire_check_timer

Seconds World::_mail_expire_check_timer

private

Referenced by SetInitialWorldSettings(), Update(), and World().

_maxVisibleDistanceInBGArenas

float World::_maxVisibleDistanceInBGArenas = DEFAULT_VISIBILITY_BGARENAS

staticprivate

Referenced by GetMaxVisibleDistanceInBGArenas(), and LoadConfigSettings().

_maxVisibleDistanceInInstances

float World::_maxVisibleDistanceInInstances = DEFAULT_VISIBILITY_INSTANCE

staticprivate

Referenced by GetMaxVisibleDistanceInInstances(), and LoadConfigSettings().

_maxVisibleDistanceOnContinents

float World::_maxVisibleDistanceOnContinents = DEFAULT_VISIBILITY_DISTANCE

staticprivate

Referenced by GetMaxVisibleDistanceOnContinents(), and LoadConfigSettings().

_nextCalendarOldEventsDeletionTime

Seconds World::_nextCalendarOldEventsDeletionTime

private

Referenced by CalendarDeleteOldEvents(), Update(), and World().

_nextDailyQuestReset

Seconds World::_nextDailyQuestReset

private

Referenced by GetNextDailyQuestsResetTime(), InitDailyQuestResetTime(), ResetDailyQuests(), Update(), and World().

_nextGuildReset

Seconds World::_nextGuildReset

private

Referenced by InitGuildResetTime(), ResetGuildCap(), Update(), and World().

_nextMonthlyQuestReset

Seconds World::_nextMonthlyQuestReset

private

Referenced by InitMonthlyQuestResetTime(), ResetMonthlyQuests(), Update(), and World().

_nextRandomBGReset

Seconds World::_nextRandomBGReset

private

Referenced by GetNextRandomBGResetTime(), InitRandomBGResetTime(), ResetRandomBG(), Update(), and World().

_nextWeeklyQuestReset

Seconds World::_nextWeeklyQuestReset

private

Referenced by GetNextWeeklyQuestsResetTime(), InitWeeklyQuestResetTime(), ResetWeeklyQuests(), Update(), and World().

_previousSession

Optional<PreviousSessionInfo> World::_previousSession

private

Referenced by GetPreviousSessionInfo(), and LoadPreviousSessionInfo().

_queryProcessor

QueryCallbackProcessor World::_queryProcessor

private

Referenced by ProcessQueryCallbacks(), and UpdateRealmCharCount().

_realmName

std::string World::_realmName

private

Referenced by GetRealmName(), and SetRealmName().

_sessionOutcome

Optional<SessionOutcome> World::_sessionOutcome

private

Referenced by SaveSessionEnd().

_shutdownMask

uint32 World::_shutdownMask

private

Referenced by _UpdateGameTime(), RescheduleShutdownForWintergrasp(), SaveSessionEnd(), ShutdownCancel(), ShutdownMsg(), ShutdownServ(), and World().

_shutdownReason

std::string World::_shutdownReason

private

Referenced by SaveSessionEnd(), ShutdownMsg(), and ShutdownServ().

_shutdownTimer

uint32 World::_shutdownTimer

private

Referenced by _UpdateGameTime(), GetShutDownTimeLeft(), IsShuttingDown(), RescheduleShutdownForWintergrasp(), ShutdownCancel(), ShutdownMsg(), ShutdownServ(), and World().

_stopEvent

std::atomic_long World::_stopEvent = false

staticprivate

Referenced by _UpdateGameTime(), IsStopped(), ShutdownCancel(), ShutdownServ(), and StopNow().

_stoppedByStopNow

std::atomic< bool > World::_stoppedByStopNow = false

staticprivate

Referenced by SaveSessionEnd(), and StopNow().

_timers

IntervalTimer World::_timers[WUPDATE_COUNT]

private

Referenced by ForceGameEventUpdate(), GetNextWhoListUpdateDelaySecs(), LoadConfigSettings(), SetInitialWorldSettings(), and Update().

_worldConfig

WorldConfig World::_worldConfig

private

Referenced by getBoolConfig(), getFloatConfig(), getIntConfig(), getStringConfig(), LoadConfigSettings(), setBoolConfig(), setFloatConfig(), setIntConfig(), and setStringConfig().

m_worldLoopCounter

uint32 World::m_worldLoopCounter = 0

static

Referenced by FreezeDetector::Handler(), and WorldUpdateLoop().

---

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

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