The World. More...

#include <World.h>

Public Types
typedef std::list< WorldSession * >	Queue

Public Member Functions
WorldSession *	FindSession (uint32 id) const
	Find a session by its id. More...

void	AddSession (WorldSession *s)

void	AddInstanceSocket (std::weak_ptr< WorldSocket > sock, uint64 connectToKey)

void	SendAutoBroadcast ()

bool	RemoveSession (uint32 id)
	Remove a given session. More...

void	UpdateMaxSessionCounters ()
	Get the number of current active sessions. More...

const SessionMap &	GetAllSessions () const

uint32	GetActiveAndQueuedSessionCount () const

uint32	GetActiveSessionCount () const

uint32	GetQueuedSessionCount () const

uint32	GetMaxQueuedSessionCount () const
	Get the maximum number of parallel sessions on the server since last reboot. More...

uint32	GetMaxActiveSessionCount () const

uint32	GetPlayerCount () const
	Get number of players. More...

uint32	GetMaxPlayerCount () const

void	IncreasePlayerCount ()
	Increase/Decrease number of players. More...

void	DecreasePlayerCount ()

Player *	FindPlayerInZone (uint32 zone)
	Find a player in a specified zone. More...

bool	IsClosed () const
	Deny clients? More...

void	SetClosed (bool val)
	Close world. More...

AccountTypes	GetPlayerSecurityLimit () const
	Security level limitations. More...

void	SetPlayerSecurityLimit (AccountTypes sec)

void	LoadDBAllowedSecurityLevel ()

void	SetPlayerAmountLimit (uint32 limit)
	Active session server limit. More...

uint32	GetPlayerAmountLimit () const

void	AddQueuedPlayer (WorldSession *)

bool	RemoveQueuedPlayer (WorldSession *session)

int32	GetQueuePos (WorldSession *)

bool	HasRecentlyDisconnected (WorldSession *)

bool	getAllowMovement () const

void	SetAllowMovement (bool allow)
	Allow/Disallow object movements. More...

void	SetMotd (std::string motd)
	Set a new Message of the Day. More...

std::vector< std::string > const &	GetMotd () const
	Get the current Message of the Day. More...

void	SetNewCharString (std::string const &str)
	Set the string for new characters (first login) More...

std::string const &	GetNewCharString () const
	Get the string for new characters (first login) More...

LocaleConstant	GetDefaultDbcLocale () const

std::string const &	GetDataPath () const
	Get the path where data (dbc, maps) are stored on disk. More...

time_t const &	GetStartTime () const
	When server started? More...

time_t const &	GetGameTime () const
	What time is it? More...

uint32	GetUptime () const
	Uptime (in secs) More...

uint32	GetUpdateTime () const
	Update time. More...

void	SetRecordDiffInterval (int32 t)

time_t	GetNextDailyQuestsResetTime () const
	Next daily quests and random bg reset time. More...

time_t	GetNextWeeklyQuestsResetTime () const

time_t	GetNextRandomBGResetTime () const

uint16	GetConfigMaxSkillValue () const
	Get the maximum skill level a player can reach. More...

void	SetInitialWorldSettings ()
	Initialize the World. More...

void	LoadConfigSettings (bool reload=false)
	Initialize config values. More...

void	SendWorldText (uint32 string_id,...)
	Send a System Message to all players (except self if mentioned) More...

void	SendGlobalText (const char text, WorldSession self)
	DEPRECATED, only for debug purpose. Send a System Message to all players (except self if mentioned) More...

void	SendGMText (uint32 string_id,...)
	Send a System Message to all GMs (except self if mentioned) More...

void	SendServerMessage (ServerMessageType messageID, std::string stringParam="", Player *player=NULL)
	Send a server message to the user(s) More...

void	SendGlobalMessage (WorldPacket const packet, WorldSession self=nullptr, uint32 team=0)
	Send a packet to all players (except self if mentioned) More...

void	SendGlobalGMMessage (WorldPacket const packet, WorldSession self=nullptr, uint32 team=0)
	Send a packet to all GMs (except self if mentioned) More...

bool	SendZoneMessage (uint32 zone, WorldPacket const packet, WorldSession self=nullptr, uint32 team=0)
	Send a packet to all players (or players selected team) in the zone (except self if mentioned) More...

void	SendZoneText (uint32 zone, const char text, WorldSession self=nullptr, uint32 team=0)
	Send a System Message to all players in the zone (except self if mentioned) More...

bool	IsShuttingDown () const
	Are we in the middle of a shutdown? More...

uint32	GetShutDownTimeLeft () const

void	ShutdownServ (uint32 time, uint32 options, uint8 exitcode, const std::string &reason=std::string())
	Shutdown the server. More...

void	ShutdownCancel ()
	Cancel a planned server shutdown. More...

void	ShutdownMsg (bool show=false, Player *player=NULL, const std::string &reason=std::string())
	Display a shutdown message to the user(s) More...

void	Update (uint32 diff)
	Update the World ! More...

void	UpdateSessions (uint32 diff)

void	setRate (Rates rate, float value)
	Set a server rate (see Rates) More...

float	getRate (Rates rate) const
	Get a server rate (see Rates) More...

void	setBoolConfig (WorldBoolConfigs index, bool value)
	Set a server configuration element (see #WorldConfigs) More...

bool	getBoolConfig (WorldBoolConfigs index) const
	Get a server configuration element (see #WorldConfigs) More...

void	setFloatConfig (WorldFloatConfigs index, float value)
	Set a server configuration element (see #WorldConfigs) More...

float	getFloatConfig (WorldFloatConfigs index) const
	Get a server configuration element (see #WorldConfigs) More...

void	setIntConfig (WorldIntConfigs index, uint32 value)
	Set a server configuration element (see #WorldConfigs) More...

uint32	getIntConfig (WorldIntConfigs index) const
	Get a server configuration element (see #WorldConfigs) More...

void	setWorldState (uint32 index, uint64 value)

uint64	getWorldState (uint32 index) const

void	LoadWorldStates ()

bool	IsPvPRealm () const
	Are we on a "Player versus Player" server? More...

bool	IsFFAPvPRealm () const

void	KickAll ()
	Kick (and save) all players. More...

void	KickAllLess (AccountTypes sec)
	Kick (and save) all players with security level less `sec` More...

BanReturn	BanAccount (BanMode mode, std::string const &nameOrIP, std::string const &duration, std::string const &reason, std::string const &author)
	Ban an account or ban an IP address, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban. More...

BanReturn	BanAccount (BanMode mode, std::string const &nameOrIP, uint32 duration_secs, std::string const &reason, std::string const &author)
	Ban an account or ban an IP address, duration is in seconds if positive, otherwise permban. More...

bool	RemoveBanAccount (BanMode mode, std::string const &nameOrIP)
	Remove a ban from an account or IP address. More...

BanReturn	BanCharacter (std::string const &name, std::string const &duration, std::string const &reason, std::string const &author)
	Ban an account or ban an IP address, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban. More...

bool	RemoveBanCharacter (std::string const &name)
	Remove a ban from a character. More...

void	ProcessCliCommands ()

void	QueueCliCommand (CliCommandHolder *commandHolder)

void	ForceGameEventUpdate ()

void	UpdateRealmCharCount (uint32 accid)

LocaleConstant	GetAvailableDbcLocale (LocaleConstant locale) const

void	LoadDBVersion ()

char const *	GetDBVersion () const

void	ResetTimeDiffRecord ()

void	RecordTimeDiff (std::string const &text)

void	LoadAutobroadcasts ()

void	UpdateAreaDependentAuras ()

CharacterInfo const *	GetCharacterInfo (ObjectGuid const &guid) const
	Loads several pieces of information on server startup with the GUID There is no further database query necessary. These are a number of methods that work into the calling function. More...

void	AddCharacterInfo (ObjectGuid const &guid, uint32 accountId, std::string const &name, uint8 gender, uint8 race, uint8 playerClass, uint8 level, bool isDeleted)

void	DeleteCharacterInfo (ObjectGuid const &guid)

bool	HasCharacterInfo (ObjectGuid const &guid)

void	UpdateCharacterInfo (ObjectGuid const &guid, std::string const &name, uint8 gender=GENDER_NONE, uint8 race=RACE_NONE)

void	UpdateCharacterInfoLevel (ObjectGuid const &guid, uint8 level)

void	UpdateCharacterInfoDeleted (ObjectGuid const &guid, bool deleted, std::string const *name=nullptr)

uint32	GetCleaningFlags () const

void	SetCleaningFlags (uint32 flags)

void	ResetEventSeasonalQuests (uint16 event_id)

void	ReloadRBAC ()

void	RemoveOldCorpses ()

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 int32	GetVisibilityNotifyPeriodOnContinents ()

static int32	GetVisibilityNotifyPeriodInInstances ()

static int32	GetVisibilityNotifyPeriodInBGArenas ()

Static Public Attributes
static std::atomic< uint32 >	m_worldLoopCounter

Protected Member Functions
void	_UpdateGameTime ()
	Update the game time. More...

void	_UpdateRealmCharCount (PreparedQueryResult resultCharCount)

void	InitDailyQuestResetTime ()

void	InitWeeklyQuestResetTime ()

void	InitMonthlyQuestResetTime ()

void	InitRandomBGResetTime ()

void	InitGuildResetTime ()

void	InitCurrencyResetTime ()

void	DailyReset ()

void	ResetWeeklyQuests ()

void	ResetMonthlyQuests ()

void	ResetRandomBG ()

void	ResetGuildCap ()

void	ResetCurrencyWeekCap ()

Private Types
typedef std::unordered_map < uint32, time_t >	DisconnectMap

typedef std::map< uint32, uint64 >	WorldStatesMap

typedef std::map< uint8, std::string >	AutobroadcastsMap

typedef std::map< uint8, uint8 >	AutobroadcastsWeightMap

typedef std::map< ObjectGuid, CharacterInfo >	CharacterInfoContainer

Private Member Functions
	World ()
	World constructor. More...

	~World ()
	World destructor. More...

void	AddSession_ (WorldSession *s)

void	ProcessLinkInstanceSocket (std::pair< std::weak_ptr< WorldSocket >, uint64 > linkInfo)

void	LoadCharacterInfoStore ()

void	ProcessQueryCallbacks ()

Private Attributes
uint32	m_ShutdownTimer

uint32	m_ShutdownMask

uint32	m_CleaningFlags

bool	m_isClosed

time_t	m_startTime

time_t	m_gameTime

IntervalTimer	m_timers [WUPDATE_COUNT]

time_t	mail_timer

time_t	mail_timer_expires

uint32	m_updateTime

uint32	m_updateTimeSum

uint32	m_updateTimeCount

uint32	m_currentTime

SessionMap	m_sessions

DisconnectMap	m_disconnects

uint32	m_maxActiveSessionCount

uint32	m_maxQueuedSessionCount

uint32	m_PlayerCount

uint32	m_MaxPlayerCount

std::string	m_newCharString

float	rate_values [MAX_RATES]

uint32	m_int_configs [INT_CONFIG_VALUE_COUNT]

bool	m_bool_configs [BOOL_CONFIG_VALUE_COUNT]

float	m_float_configs [FLOAT_CONFIG_VALUE_COUNT]

WorldStatesMap	m_worldstates

uint32	m_playerLimit

AccountTypes	m_allowedSecurityLevel

LocaleConstant	m_defaultDbcLocale

uint32	m_availableDbcLocaleMask

bool	m_allowMovement

std::vector< std::string >	_motd

std::string	m_dataPath

LockedQueue< CliCommandHolder * >	cliCmdQueue

time_t	m_NextDailyQuestReset

time_t	m_NextWeeklyQuestReset

time_t	m_NextMonthlyQuestReset

time_t	m_NextRandomBGReset

time_t	m_NextGuildReset

time_t	m_NextCurrencyReset

Queue	m_QueuedPlayer

LockedQueue< WorldSession * >	addSessQueue

LockedQueue< std::pair < std::weak_ptr< WorldSocket > , uint64 > >	_linkSocketQueue

std::string	m_DBVersion

AutobroadcastsMap	m_Autobroadcasts

AutobroadcastsWeightMap	m_AutobroadcastsWeights

CharacterInfoContainer	_characterInfoStore

std::deque < PreparedQueryResultFuture >	m_realmCharCallbacks

Static Private Attributes
static std::atomic< bool >	m_stopEvent

static uint8	m_ExitCode = SHUTDOWN_EXIT_CODE

static float	m_MaxVisibleDistanceOnContinents = DEFAULT_VISIBILITY_DISTANCE

static float	m_MaxVisibleDistanceInInstances = DEFAULT_VISIBILITY_INSTANCE

static float	m_MaxVisibleDistanceInBGArenas = DEFAULT_VISIBILITY_BGARENAS

static int32	m_visibility_notify_periodOnContinents = DEFAULT_VISIBILITY_NOTIFY_PERIOD

static int32	m_visibility_notify_periodInInstances = DEFAULT_VISIBILITY_NOTIFY_PERIOD

static int32	m_visibility_notify_periodInBGArenas = DEFAULT_VISIBILITY_NOTIFY_PERIOD

Detailed Description

The World.

Member Typedef Documentation

typedef std::map<uint8, std::string> World::AutobroadcastsMap

private

typedef std::map<uint8, uint8> World::AutobroadcastsWeightMap

private

typedef std::map<ObjectGuid, CharacterInfo> World::CharacterInfoContainer

private

typedef std::unordered_map<uint32, time_t> World::DisconnectMap

private

typedef std::list<WorldSession*> World::Queue

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

private

Constructor & Destructor Documentation

World::World ( )

private

World constructor.

 {
  m_playerLimit = 0;
  m_allowedSecurityLevel = SEC_PLAYER;
  m_allowMovement = true;
  m_ShutdownMask = 0;
  m_ShutdownTimer = 0;
  m_gameTime = time(NULL);
  m_startTime = m_gameTime;
  m_maxActiveSessionCount = 0;
  m_maxQueuedSessionCount = 0;
  m_PlayerCount = 0;
  m_MaxPlayerCount = 0;
  m_NextDailyQuestReset = 0;
  m_NextWeeklyQuestReset = 0;
  m_NextMonthlyQuestReset = 0;
  m_NextRandomBGReset = 0;
  m_NextGuildReset = 0;
  m_NextCurrencyReset = 0;
 
  m_defaultDbcLocale = LOCALE_enUS;
  m_availableDbcLocaleMask = 0;
 
  mail_timer = 0;
  mail_timer_expires = 0;
  m_updateTime = 0;
  m_updateTimeSum = 0;
  m_updateTimeCount = 0;
  m_currentTime = 0;
 
  m_isClosed = false;
 
  m_CleaningFlags = 0;
 
  memset(rate_values, 0, sizeof(rate_values));
  memset(m_int_configs, 0, sizeof(m_int_configs));
  memset(m_bool_configs, 0, sizeof(m_bool_configs));
  memset(m_float_configs, 0, sizeof(m_float_configs));
 }

World::~World ( )

private

World destructor.

Empty the kicked session set

Todo:: free addSessQueue

 {
  while (!m_sessions.empty())
  {
  // not remove from queue, prevent loading new sessions
  delete m_sessions.begin()->second;
  m_sessions.erase(m_sessions.begin());
  }
 
  CliCommandHolder* command = NULL;
  while (cliCmdQueue.next(command))
  delete command;
 
  VMAP::VMapFactory::clear();
  MMAP::MMapFactory::clear();
 
 }

Here is the call graph for this function:

Member Function Documentation

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)
... else decrease it and if necessary display a shutdown countdown to the users

 {
  time_t thisTime = time(NULL);
  uint32 elapsed = uint32(thisTime - m_gameTime);
  m_gameTime = thisTime;
 
  if (!IsStopped() && m_ShutdownTimer > 0 && elapsed > 0)
  {
  if (m_ShutdownTimer <= elapsed)
  {
  if (!(m_ShutdownMask & SHUTDOWN_MASK_IDLE) || GetActiveAndQueuedSessionCount() == 0)
  m_stopEvent = true; // exist code already set
  else
  m_ShutdownTimer = 1; // minimum timer value to wait idle state
  }
  else
  {
  m_ShutdownTimer -= elapsed;
 
  ShutdownMsg();
  }
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::_UpdateRealmCharCount ( PreparedQueryResult resultCharCount )

protected

 {
  if (resultCharCount)
  {
  Field* fields = resultCharCount->Fetch();
  uint32 accountId = fields[0].GetUInt32();
  uint8 charCount = uint8(fields[1].GetUInt64());
 
  PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_REALM_CHARACTERS_BY_REALM);
  stmt->setUInt32(0, accountId);
  stmt->setUInt32(1, realm.Id.Realm);
  LoginDatabase.Execute(stmt);
 
  stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_REALM_CHARACTERS);
  stmt->setUInt8(0, charCount);
  stmt->setUInt32(1, accountId);
  stmt->setUInt32(2, realm.Id.Realm);
  LoginDatabase.Execute(stmt);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::AddCharacterInfo	(	ObjectGuid const &	guid,
		uint32	accountId,
		std::string const &	name,
		uint8	gender,
		uint8	race,
		uint8	playerClass,
		uint8	level,
		bool	isDeleted
	)

 {
  CharacterInfo& data = _characterInfoStore[guid];
  data.Name = name;
  data.AccountId = accountId;
  data.Race = race;
  data.Sex = gender;
  data.Class = playerClass;
  data.Level = level;
  data.IsDeleted = isDeleted;
 }

Here is the caller graph for this function:

void World::AddInstanceSocket	(	std::weak_ptr< WorldSocket >	sock,
		uint64	connectToKey
	)

 {
  _linkSocketQueue.add(std::make_pair(sock, connectToKey));
 }

Here is the call graph for this function:

void World::AddQueuedPlayer ( WorldSession * sess )

 {
  sess->SetInQueue(true);
  m_QueuedPlayer.push_back(sess);
 
  // The 1st SMSG_AUTH_RESPONSE needs to contain other info too.
  sess->SendAuthResponse(ERROR_OK, true, GetQueuePos(sess));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::AddSession ( WorldSession * s )

 {
  addSessQueue.add(s);
 }

Here is the call graph for this function:

void World::AddSession_ ( WorldSession * s )

private

kick already loaded player with same account (if any) and remove session
if player is in loading and want to load again, return

 {
  ASSERT(s);
 
  //NOTE - Still there is race condition in WorldSession* being used in the Sockets
 
  if (!RemoveSession (s->GetAccountId()))
  {
  s->KickPlayer();
  delete s; // session not added yet in session list, so not listed in queue
  return;
  }
 
  // decrease session counts only at not reconnection case
  bool decrease_session = true;
 
  // if session already exist, prepare to it deleting at next world update
  // NOTE - KickPlayer() should be called on "old" in RemoveSession()
  {
  SessionMap::const_iterator old = m_sessions.find(s->GetAccountId());
 
  if (old != m_sessions.end())
  {
  // prevent decrease sessions count if session queued
  if (RemoveQueuedPlayer(old->second))
  decrease_session = false;
  // not remove replaced session form queue if listed
  delete old->second;
  }
  }
 
  m_sessions[s->GetAccountId()] = s;
 
  uint32 Sessions = GetActiveAndQueuedSessionCount();
  uint32 pLimit = GetPlayerAmountLimit();
  uint32 QueueSize = GetQueuedSessionCount(); //number of players in the queue
 
  //so we don't count the user trying to
  //login as a session and queue the socket that we are using
  if (decrease_session)
  --Sessions;
 
  if (pLimit > 0 && Sessions >= pLimit && !s->HasPermission(rbac::RBAC_PERM_SKIP_QUEUE) && !HasRecentlyDisconnected(s))
  {
  AddQueuedPlayer(s);
  UpdateMaxSessionCounters();
  TC_LOG_INFO("misc", "PlayerQueue: Account id %u is in Queue Position (%u).", s->GetAccountId(), ++QueueSize);
  return;
  }
 
  s->InitializeSession();
 
  UpdateMaxSessionCounters();
 
  // Updates the population
  if (pLimit > 0)
  {
  float popu = (float)GetActiveSessionCount(); // updated number of users on the server
  popu /= pLimit;
  popu *= 2;
  TC_LOG_INFO("misc", "Server Population (%f).", popu);
  }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

BanReturn World::BanAccount	(	BanMode	mode,
		std::string const &	nameOrIP,
		std::string const &	duration,
		std::string const &	reason,
		std::string const &	author
	)

Ban an account or ban an IP address, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban.

 {
  uint32 duration_secs = TimeStringToSecs(duration);
  return BanAccount(mode, nameOrIP, duration_secs, reason, author);
 }

Here is the call graph for this function:

BanReturn World::BanAccount	(	BanMode	mode,
		std::string const &	nameOrIP,
		uint32	duration_secs,
		std::string const &	reason,
		std::string const &	author
	)

Ban an account or ban an IP address, duration is in seconds if positive, otherwise permban.

Update the database with ban information
Disconnect all affected players (for IP it can be several)

 {
  PreparedQueryResult resultAccounts = PreparedQueryResult(NULL); //used for kicking
  PreparedStatement* stmt = NULL;
 
  switch (mode)
  {
  case BAN_IP:
  // No SQL injection with prepared statements
  stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_BY_IP);
  stmt->setString(0, nameOrIP);
  resultAccounts = LoginDatabase.Query(stmt);
  stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_IP_BANNED);
  stmt->setString(0, nameOrIP);
  stmt->setUInt32(1, duration_secs);
  stmt->setString(2, author);
  stmt->setString(3, reason);
  LoginDatabase.Execute(stmt);
  break;
  case BAN_ACCOUNT:
  // No SQL injection with prepared statements
  stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_ACCOUNT_ID_BY_NAME);
  stmt->setString(0, nameOrIP);
  resultAccounts = LoginDatabase.Query(stmt);
  break;
  case BAN_CHARACTER:
  // No SQL injection with prepared statements
  stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ACCOUNT_BY_NAME);
  stmt->setString(0, nameOrIP);
  resultAccounts = CharacterDatabase.Query(stmt);
  break;
  default:
  return BAN_SYNTAX_ERROR;
  }
 
  if (!resultAccounts)
  {
  if (mode == BAN_IP)
  return BAN_SUCCESS; // ip correctly banned but nobody affected (yet)
  else
  return BAN_NOTFOUND; // Nobody to ban
  }
 
  SQLTransaction trans = LoginDatabase.BeginTransaction();
  do
  {
  Field* fieldsAccount = resultAccounts->Fetch();
  uint32 account = fieldsAccount[0].GetUInt32();
 
  if (mode != BAN_IP)
  {
  // make sure there is only one active ban
  stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_NOT_BANNED);
  stmt->setUInt32(0, account);
  trans->Append(stmt);
  // No SQL injection with prepared statements
  stmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_ACCOUNT_BANNED);
  stmt->setUInt32(0, account);
  stmt->setUInt32(1, duration_secs);
  stmt->setString(2, author);
  stmt->setString(3, reason);
  trans->Append(stmt);
  }
 
  if (WorldSession* sess = FindSession(account))
  if (std::string(sess->GetPlayerName()) != author)
  sess->KickPlayer();
  } while (resultAccounts->NextRow());
 
  LoginDatabase.CommitTransaction(trans);
 
  return BAN_SUCCESS;
 }

Here is the call graph for this function:

BanReturn World::BanCharacter	(	std::string const &	name,
		std::string const &	duration,
		std::string const &	reason,
		std::string const &	author
	)

Ban an account or ban an IP address, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban.

Pick a player to ban if not online

 {
  Player* pBanned = ObjectAccessor::FindConnectedPlayerByName(name);
  ObjectGuid guid;
 
  uint32 duration_secs = TimeStringToSecs(duration);
 
  if (!pBanned)
  {
  guid = ObjectMgr::GetPlayerGUIDByName(name);
  if (guid.IsEmpty())
  return BAN_NOTFOUND; // Nobody to ban
  }
  else
  guid = pBanned->GetGUID();
 
  // make sure there is only one active ban
  PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHARACTER_BAN);
  stmt->setUInt64(0, guid.GetCounter());
  CharacterDatabase.Execute(stmt);
 
  stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_CHARACTER_BAN);
  stmt->setUInt64(0, guid.GetCounter());
  stmt->setUInt32(1, duration_secs);
  stmt->setString(2, author);
  stmt->setString(3, reason);
  CharacterDatabase.Execute(stmt);
 
  if (pBanned)
  pBanned->GetSession()->KickPlayer();
 
  return BAN_SUCCESS;
 }

Here is the call graph for this function:

void World::DailyReset ( )

protected

 {
  TC_LOG_INFO("misc", "Daily quests reset for all characters.");
 
  PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RESET_CHARACTER_QUESTSTATUS_DAILY);
  CharacterDatabase.Execute(stmt);
 
  stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHARACTER_GARRISON_FOLLOWER_ACTIVATIONS);
  stmt->setUInt32(0, 1);
  CharacterDatabase.Execute(stmt);
 
  for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
  if (itr->second->GetPlayer())
  itr->second->GetPlayer()->DailyReset();
 
  // change available dailies
  sPoolMgr->ChangeDailyQuests();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::DecreasePlayerCount ( )

inline

574 { m_PlayerCount--; }

World::m_PlayerCount

uint32 m_PlayerCount

Definition: World.h:817

void World::DeleteCharacterInfo ( ObjectGuid const & guid )

inline

759 { _characterInfoStore.erase(guid); }

World::_characterInfoStore

CharacterInfoContainer _characterInfoStore

Definition: World.h:876

Player * World::FindPlayerInZone ( uint32 zone )

Find a player in a specified zone.

circle through active sessions and return the first player found in the zone

 {
  SessionMap::const_iterator itr;
  for (itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
  {
  if (!itr->second)
  continue;
 
  Player* player = itr->second->GetPlayer();
  if (!player)
  continue;
 
  if (player->IsInWorld() && player->GetZoneId() == zone)
  return player;
  }
  return NULL;
 }

WorldSession * World::FindSession ( uint32 id ) const

Find a session by its id.

 {
  SessionMap::const_iterator itr = m_sessions.find(id);
 
  if (itr != m_sessions.end())
  return itr->second; // also can return NULL for kicked session
  else
  return NULL;
 }

Here is the caller graph for this function:

void World::ForceGameEventUpdate ( )

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

Here is the call graph for this function:

uint32 World::GetActiveAndQueuedSessionCount ( ) const

inline

559 { return uint32(m_sessions.size()); }

World::m_sessions

SessionMap m_sessions

Definition: World.h:812

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Here is the caller graph for this function:

uint32 World::GetActiveSessionCount ( ) const

inline

560 { return uint32(m_sessions.size() - m_QueuedPlayer.size()); }

World::m_sessions

SessionMap m_sessions

Definition: World.h:812

World::m_QueuedPlayer

Queue m_QueuedPlayer

Definition: World.h:857

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Here is the caller graph for this function:

bool World::getAllowMovement ( ) const

inline

Todo:: Actions on m_allowMovement still to be implemented Is movement allowed?

602 { return m_allowMovement; }

World::m_allowMovement

bool m_allowMovement

Definition: World.h:832

const SessionMap& World::GetAllSessions ( ) const

inline

558 { return m_sessions; }

World::m_sessions

SessionMap m_sessions

Definition: World.h:812

LocaleConstant World::GetAvailableDbcLocale ( LocaleConstant locale ) const

inline

744 { if (m_availableDbcLocaleMask & (1 << locale)) return locale; else return m_defaultDbcLocale; }

World::m_availableDbcLocaleMask

uint32 m_availableDbcLocaleMask

Definition: World.h:831

World::m_defaultDbcLocale

LocaleConstant m_defaultDbcLocale

Definition: World.h:830

bool World::getBoolConfig ( WorldBoolConfigs index ) const

inline

Get a server configuration element (see #WorldConfigs)

  {
  return index < BOOL_CONFIG_VALUE_COUNT ? m_bool_configs[index] : 0;
  }

CharacterInfo const * World::GetCharacterInfo ( ObjectGuid const & guid ) const

Loads several pieces of information on server startup with the GUID There is no further database query necessary. These are a number of methods that work into the calling function.

Parameters

guid	Requires a guid to call

Returns: Name, Sex, Race, Class and Level of player character Example Usage:
CharacterInfo const* characterInfo = sWorld->GetCharacterInfo(GUID);

if (!nameData)

return;

std::string playerName = characterInfo->Name;

uint8 playerGender = characterInfo->Sex;

uint8 playerRace = characterInfo->Race;

uint8 playerClass = characterInfo->Class;

uint8 playerLevel = characterInfo->Level;

 {
  CharacterInfoContainer::const_iterator itr = _characterInfoStore.find(guid);
  if (itr != _characterInfoStore.end())
  return &itr->second;
 
  return nullptr;
 }

uint32 World::GetCleaningFlags ( ) const

inline

765 { return m_CleaningFlags; }

World::m_CleaningFlags

uint32 m_CleaningFlags

Definition: World.h:799

uint16 World::GetConfigMaxSkillValue ( ) const

inline

Get the maximum skill level a player can reach.

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

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

inline

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

619 { return m_dataPath; }

World::m_dataPath

std::string m_dataPath

Definition: World.h:834

char const* World::GetDBVersion ( ) const

inline

748 { return m_DBVersion.c_str(); }

World::m_DBVersion

std::string m_DBVersion

Definition: World.h:867

LocaleConstant World::GetDefaultDbcLocale ( ) const

inline

616 { return m_defaultDbcLocale; }

World::m_defaultDbcLocale

LocaleConstant m_defaultDbcLocale

Definition: World.h:830

Here is the caller graph for this function:

static uint8 World::GetExitCode ( )

inlinestatic

661 { return m_ExitCode; }

World::m_ExitCode

static uint8 m_ExitCode

Definition: World.h:795

Here is the caller graph for this function:

float World::getFloatConfig ( WorldFloatConfigs index ) const

inline

Get a server configuration element (see #WorldConfigs)

  {
  return index < FLOAT_CONFIG_VALUE_COUNT ? m_float_configs[index] : 0;
  }

time_t const& World::GetGameTime ( ) const

inline

What time is it?

624 { return m_gameTime; }

World::m_gameTime

time_t m_gameTime

Definition: World.h:804

uint32 World::getIntConfig ( WorldIntConfigs index ) const

inline

Get a server configuration element (see #WorldConfigs)

  {
  return index < INT_CONFIG_VALUE_COUNT ? m_int_configs[index] : 0;
  }

Here is the caller graph for this function:

uint32 World::GetMaxActiveSessionCount ( ) const

inline

564 { return m_maxActiveSessionCount; }

World::m_maxActiveSessionCount

uint32 m_maxActiveSessionCount

Definition: World.h:815

uint32 World::GetMaxPlayerCount ( ) const

inline

567 { return m_MaxPlayerCount; }

World::m_MaxPlayerCount

uint32 m_MaxPlayerCount

Definition: World.h:818

Here is the caller graph for this function:

uint32 World::GetMaxQueuedSessionCount ( ) const

inline

Get the maximum number of parallel sessions on the server since last reboot.

563 { return m_maxQueuedSessionCount; }

World::m_maxQueuedSessionCount

uint32 m_maxQueuedSessionCount

Definition: World.h:816

static float World::GetMaxVisibleDistanceInBGArenas ( )

inlinestatic

731 { return m_MaxVisibleDistanceInBGArenas; }

World::m_MaxVisibleDistanceInBGArenas

static float m_MaxVisibleDistanceInBGArenas

Definition: World.h:839

Here is the caller graph for this function:

static float World::GetMaxVisibleDistanceInInstances ( )

inlinestatic

730 { return m_MaxVisibleDistanceInInstances; }

World::m_MaxVisibleDistanceInInstances

static float m_MaxVisibleDistanceInInstances

Definition: World.h:838

Here is the caller graph for this function:

static float World::GetMaxVisibleDistanceOnContinents ( )

inlinestatic

729 { return m_MaxVisibleDistanceOnContinents; }

World::m_MaxVisibleDistanceOnContinents

static float m_MaxVisibleDistanceOnContinents

Definition: World.h:837

Here is the caller graph for this function:

std::vector< std::string > const & World::GetMotd ( ) const

Get the current Message of the Day.

 {
     return _motd;
 }

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

inline

Get the string for new characters (first login)

614 { return m_newCharString; }

World::m_newCharString

std::string m_newCharString

Definition: World.h:820

time_t World::GetNextDailyQuestsResetTime ( ) const

inline

Next daily quests and random bg reset time.

632 { return m_NextDailyQuestReset; }

World::m_NextDailyQuestReset

time_t m_NextDailyQuestReset

Definition: World.h:849

time_t World::GetNextRandomBGResetTime ( ) const

inline

634 { return m_NextRandomBGReset; }

World::m_NextRandomBGReset

time_t m_NextRandomBGReset

Definition: World.h:852

time_t World::GetNextWeeklyQuestsResetTime ( ) const

inline

633 { return m_NextWeeklyQuestReset; }

World::m_NextWeeklyQuestReset

time_t m_NextWeeklyQuestReset

Definition: World.h:850

uint32 World::GetPlayerAmountLimit ( ) const

inline

591 { return m_playerLimit; }

World::m_playerLimit

uint32 m_playerLimit

Definition: World.h:828

Here is the caller graph for this function:

uint32 World::GetPlayerCount ( ) const

inline

Get number of players.

566 { return m_PlayerCount; }

World::m_PlayerCount

uint32 m_PlayerCount

Definition: World.h:817

AccountTypes World::GetPlayerSecurityLimit ( ) const

inline

Security level limitations.

585 { return m_allowedSecurityLevel; }

World::m_allowedSecurityLevel

AccountTypes m_allowedSecurityLevel

Definition: World.h:829

uint32 World::GetQueuedSessionCount ( ) const

inline

561 { return uint32(m_QueuedPlayer.size()); }

World::m_QueuedPlayer

Queue m_QueuedPlayer

Definition: World.h:857

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

Here is the caller graph for this function:

int32 World::GetQueuePos ( WorldSession * sess )

 {
     uint32 position = 1;
 
     for (Queue::const_iterator iter = m_QueuedPlayer.begin(); iter != m_QueuedPlayer.end(); ++iter, ++position)
         if ((*iter) == sess)
             return position;
 
     return 0;
 }

Here is the caller graph for this function:

float World::getRate ( Rates rate ) const

inline

Get a server rate (see Rates)

671 { return rate_values[rate]; }

World::rate_values

float rate_values[MAX_RATES]

Definition: World.h:822

Here is the caller graph for this function:

uint32 World::GetShutDownTimeLeft ( ) const

inline

657 { return m_ShutdownTimer; }

World::m_ShutdownTimer

uint32 m_ShutdownTimer

Definition: World.h:796

time_t const& World::GetStartTime ( ) const

inline

When server started?

622 { return m_startTime; }

World::m_startTime

time_t m_startTime

Definition: World.h:803

uint32 World::GetUpdateTime ( ) const

inline

Update time.

628 { return m_updateTime; }

World::m_updateTime

uint32 m_updateTime

Definition: World.h:808

uint32 World::GetUptime ( ) const

inline

Uptime (in secs)

626 { return uint32(m_gameTime - m_startTime); }

World::m_gameTime

time_t m_gameTime

Definition: World.h:804

World::m_startTime

time_t m_startTime

Definition: World.h:803

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

static int32 World::GetVisibilityNotifyPeriodInBGArenas ( )

inlinestatic

735 { return m_visibility_notify_periodInBGArenas; }

World::m_visibility_notify_periodInBGArenas

static int32 m_visibility_notify_periodInBGArenas

Definition: World.h:843

Here is the caller graph for this function:

static int32 World::GetVisibilityNotifyPeriodInInstances ( )

inlinestatic

734 { return m_visibility_notify_periodInInstances; }

World::m_visibility_notify_periodInInstances

static int32 m_visibility_notify_periodInInstances

Definition: World.h:842

Here is the caller graph for this function:

static int32 World::GetVisibilityNotifyPeriodOnContinents ( )

inlinestatic

733 { return m_visibility_notify_periodOnContinents; }

World::m_visibility_notify_periodOnContinents

static int32 m_visibility_notify_periodOnContinents

Definition: World.h:841

Here is the caller graph for this function:

uint64 World::getWorldState ( uint32 index ) const

 {
     WorldStatesMap::const_iterator it = m_worldstates.find(index);
     return it != m_worldstates.end() ? it->second : 0;
 }

Here is the caller graph for this function:

bool World::HasCharacterInfo ( ObjectGuid const & guid )

inline

760 { return _characterInfoStore.find(guid) != _characterInfoStore.end(); }

World::_characterInfoStore

CharacterInfoContainer _characterInfoStore

Definition: World.h:876

bool World::HasRecentlyDisconnected ( WorldSession * session )

 {
     if (!session)
         return false;
 
     if (uint32 tolerance = getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE))
     {
         for (DisconnectMap::iterator i = m_disconnects.begin(); i != m_disconnects.end();)
         {
             if (difftime(i->second, time(NULL)) < tolerance)
             {
                 if (i->first == session->GetAccountId())
                     return true;
                 ++i;
             }
             else
                 m_disconnects.erase(i++);
         }
     }
     return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::IncreasePlayerCount ( )

inline

Increase/Decrease number of players.

         {
             m_PlayerCount++;
             m_MaxPlayerCount = std::max(m_MaxPlayerCount, m_PlayerCount);
         }

Here is the call graph for this function:

void World::InitCurrencyResetTime ( )

protected

 {
     time_t currencytime = sWorld->getWorldState(WS_CURRENCY_RESET_TIME);
     if (!currencytime)
         m_NextCurrencyReset = time(NULL);         // game time not yet init
 
     // generate time by config
     time_t curTime = time(NULL);
     tm localTm;
     localtime_r(&curTime, &localTm);
 
     localTm.tm_wday = getIntConfig(CONFIG_CURRENCY_RESET_DAY);
     localTm.tm_hour = getIntConfig(CONFIG_CURRENCY_RESET_HOUR);
     localTm.tm_min = 0;
     localTm.tm_sec = 0;
 
     // current week reset time
     time_t nextWeekResetTime = mktime(&localTm);
 
     // next reset time before current moment
     if (curTime >= nextWeekResetTime)
         nextWeekResetTime += getIntConfig(CONFIG_CURRENCY_RESET_INTERVAL) * DAY;
 
     // normalize reset time
     m_NextCurrencyReset = currencytime < curTime ? nextWeekResetTime - getIntConfig(CONFIG_CURRENCY_RESET_INTERVAL) * DAY : nextWeekResetTime;
 
     if (!currencytime)
         sWorld->setWorldState(WS_CURRENCY_RESET_TIME, uint64(m_NextCurrencyReset));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::InitDailyQuestResetTime ( )

protected

 {
     time_t mostRecentQuestTime;
 
     QueryResult result = CharacterDatabase.Query("SELECT MAX(time) FROM character_queststatus_daily");
     if (result)
     {
         Field* fields = result->Fetch();
         mostRecentQuestTime = time_t(fields[0].GetUInt32());
     }
     else
         mostRecentQuestTime = 0;
 
     // client built-in time for reset is 6:00 AM
     // FIX ME: client not show day start time
     time_t curTime = time(NULL);
     tm localTm;
     localtime_r(&curTime, &localTm);
     localTm.tm_hour = 6;
     localTm.tm_min  = 0;
     localTm.tm_sec  = 0;
 
     // current day reset time
     time_t curDayResetTime = mktime(&localTm);
 
     // last reset time before current moment
     time_t resetTime = (curTime < curDayResetTime) ? curDayResetTime - DAY : curDayResetTime;
 
     // need reset (if we have quest time before last reset time (not processed by some reason)
     if (mostRecentQuestTime && mostRecentQuestTime <= resetTime)
         m_NextDailyQuestReset = mostRecentQuestTime;
     else // plan next reset time
         m_NextDailyQuestReset = (curTime >= curDayResetTime) ? curDayResetTime + DAY : curDayResetTime;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::InitGuildResetTime ( )

protected

 {
     time_t gtime = getWorldState(WS_GUILD_DAILY_RESET_TIME);
     if (!gtime)
         m_NextGuildReset = time(NULL);         // game time not yet init
 
     // generate time by config
     time_t curTime = time(NULL);
     tm localTm;
     localtime_r(&curTime, &localTm);
     localTm.tm_hour = getIntConfig(CONFIG_GUILD_RESET_HOUR);
     localTm.tm_min = 0;
     localTm.tm_sec = 0;
 
     // current day reset time
     time_t nextDayResetTime = mktime(&localTm);
 
     // next reset time before current moment
     if (curTime >= nextDayResetTime)
         nextDayResetTime += DAY;
 
     // normalize reset time
     m_NextGuildReset = gtime < curTime ? nextDayResetTime - DAY : nextDayResetTime;
 
     if (!gtime)
         sWorld->setWorldState(WS_GUILD_DAILY_RESET_TIME, uint64(m_NextGuildReset));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::InitMonthlyQuestResetTime ( )

protected

 {
     time_t wstime = sWorld->getWorldState(WS_MONTHLY_QUEST_RESET_TIME);
     time_t curtime = time(NULL);
     m_NextMonthlyQuestReset = wstime < curtime ? curtime : wstime;
 }

Here is the caller graph for this function:

void World::InitRandomBGResetTime ( )

protected

 {
     time_t bgtime = sWorld->getWorldState(WS_BG_DAILY_RESET_TIME);
     if (!bgtime)
         m_NextRandomBGReset = time(NULL);         // game time not yet init
 
     // generate time by config
     time_t curTime = time(NULL);
     tm localTm;
     localtime_r(&curTime, &localTm);
     localTm.tm_hour = getIntConfig(CONFIG_RANDOM_BG_RESET_HOUR);
     localTm.tm_min = 0;
     localTm.tm_sec = 0;
 
     // current day reset time
     time_t nextDayResetTime = mktime(&localTm);
 
     // next reset time before current moment
     if (curTime >= nextDayResetTime)
         nextDayResetTime += DAY;
 
     // normalize reset time
     m_NextRandomBGReset = bgtime < curTime ? nextDayResetTime - DAY : nextDayResetTime;
 
     if (!bgtime)
         sWorld->setWorldState(WS_BG_DAILY_RESET_TIME, uint64(m_NextRandomBGReset));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::InitWeeklyQuestResetTime ( )

protected

 {
     time_t wstime = sWorld->getWorldState(WS_WEEKLY_QUEST_RESET_TIME);
     time_t curtime = time(NULL);
     m_NextWeeklyQuestReset = wstime < curtime ? curtime : wstime;
 }

Here is the caller graph for this function:

World * World::instance ( )

static

 {
     static World instance;
     return &instance;
 }

bool World::IsClosed ( ) const

Deny clients?

 {
     return m_isClosed;
 }

bool World::IsFFAPvPRealm ( ) const

inline

718 { return getIntConfig(CONFIG_GAME_TYPE) == REALM_TYPE_FFA_PVP; }

CONFIG_GAME_TYPE

Definition: World.h:219

World::getIntConfig

uint32 getIntConfig(WorldIntConfigs index) const

Get a server configuration element (see #WorldConfigs)

Definition: World.h:707

REALM_TYPE_FFA_PVP

Definition: Realm.h:79

Here is the caller graph for this function:

bool World::IsPvPRealm ( ) const

inline

Are we on a "Player versus Player" server?

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

REALM_TYPE_PVP

Definition: Realm.h:72

REALM_TYPE_RPPVP

Definition: Realm.h:75

CONFIG_GAME_TYPE

Definition: World.h:219

World::getIntConfig

uint32 getIntConfig(WorldIntConfigs index) const

Get a server configuration element (see #WorldConfigs)

Definition: World.h:707

REALM_TYPE_FFA_PVP

Definition: Realm.h:79

bool World::IsShuttingDown ( ) const

inline

Are we in the middle of a shutdown?

656 { return m_ShutdownTimer > 0; }

World::m_ShutdownTimer

uint32 m_ShutdownTimer

Definition: World.h:796

static bool World::IsStopped ( )

inlinestatic

663 { return m_stopEvent; }

World::m_stopEvent

static std::atomic< bool > m_stopEvent

Definition: World.h:794

Here is the caller graph for this function:

void World::KickAll ( )

Kick (and save) all players.

 {
     m_QueuedPlayer.clear();                                 // prevent send queue update packet and login queued sessions
 
     // session not removed at kick and will removed in next update tick
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
         itr->second->KickPlayer();
 }

void World::KickAllLess ( AccountTypes sec )

Kick (and save) all players with security level less sec

 {
     // session not removed at kick and will removed in next update tick
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
         if (itr->second->GetSecurity() < sec)
             itr->second->KickPlayer();
 }

Here is the caller graph for this function:

void World::LoadAutobroadcasts ( )

 {
     uint32 oldMSTime = getMSTime();
 
     m_Autobroadcasts.clear();
     m_AutobroadcastsWeights.clear();
 
     uint32 realmId = sConfigMgr->GetIntDefault("RealmID", 0);
     PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_AUTOBROADCAST);
     stmt->setInt32(0, realmId);
     PreparedQueryResult result = LoginDatabase.Query(stmt);
 
     if (!result)
     {
         TC_LOG_INFO("server.loading", ">> Loaded 0 autobroadcasts definitions. DB table `autobroadcast` is empty for this realm!");
         return;
     }
 
     uint32 count = 0;
 
     do
     {
         Field* fields = result->Fetch();
         uint8 id = fields[0].GetUInt8();
 
         m_Autobroadcasts[id] = fields[2].GetString();
         m_AutobroadcastsWeights[id] = fields[1].GetUInt8();
 
         ++count;
     } while (result->NextRow());
 
     TC_LOG_INFO("server.loading", ">> Loaded %u autobroadcast definitions in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::LoadCharacterInfoStore ( )

private

 {
     TC_LOG_INFO("server.loading", "Loading character info store");
 
     _characterInfoStore.clear();
 
     QueryResult result = CharacterDatabase.Query("SELECT guid, name, account, race, gender, class, level, deleteDate FROM characters");
     if (!result)
     {
         TC_LOG_INFO("server.loading", "No character name data loaded, empty query");
         return;
     }
 
     do
     {
         Field* fields = result->Fetch();
         AddCharacterInfo(ObjectGuid::Create<HighGuid::Player>(fields[0].GetUInt64()), fields[2].GetUInt32(), fields[1].GetString(),
             fields[4].GetUInt8() /*gender*/, fields[3].GetUInt8() /*race*/, fields[5].GetUInt8() /*class*/, fields[6].GetUInt8() /*level*/, fields[7].GetUInt32() != 0);
     }
     while (result->NextRow());
 
     TC_LOG_INFO("server.loading", "Loaded character infos for " SZFMTD " characters", _characterInfoStore.size());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::LoadConfigSettings ( bool reload = false )

Initialize config values.

Read the player limit and the Message of the day from the config file
Read support system setting from the config file
Get string for new logins (newly created characters)
Send server info on login?
Read all rates from the config file
Read other configuration items from the config file

Todo:: Add MonsterSight and GuarderSight (with meaning) in worldserver.conf or put them as define

Load the CharDelete related config options
Read the "Data" directory from the config file

 {
     if (reload)
     {
         std::string configError;
         if (!sConfigMgr->Reload(configError))
         {
             TC_LOG_ERROR("misc", "World settings reload fail: %s.", configError.c_str());
             return;
         }
         sLog->LoadFromConfig();
     }
 
     m_defaultDbcLocale = LocaleConstant(sConfigMgr->GetIntDefault("DBC.Locale", 0));
 
     if (m_defaultDbcLocale >= TOTAL_LOCALES || m_defaultDbcLocale < LOCALE_enUS || m_defaultDbcLocale == LOCALE_none)
     {
         TC_LOG_ERROR("server.loading", "Incorrect DBC.Locale! Must be >= 0 and < %d and not %d (set to 0)", TOTAL_LOCALES, LOCALE_none);
         m_defaultDbcLocale = LOCALE_enUS;
     }
 
     TC_LOG_INFO("server.loading", "Using %s DBC Locale", localeNames[m_defaultDbcLocale]);
 
     SetPlayerAmountLimit(sConfigMgr->GetIntDefault("PlayerLimit", 100));
     SetMotd(sConfigMgr->GetStringDefault("Motd", "Welcome to a Trinity Core Server."));
 
     m_bool_configs[CONFIG_SUPPORT_ENABLED] = sConfigMgr->GetBoolDefault("Support.Enabled", true);
     m_bool_configs[CONFIG_SUPPORT_TICKETS_ENABLED] = sConfigMgr->GetBoolDefault("Support.TicketsEnabled", false);
     m_bool_configs[CONFIG_SUPPORT_BUGS_ENABLED] = sConfigMgr->GetBoolDefault("Support.BugsEnabled", false);
     m_bool_configs[CONFIG_SUPPORT_COMPLAINTS_ENABLED] = sConfigMgr->GetBoolDefault("Support.ComplaintsEnabled", false);
     m_bool_configs[CONFIG_SUPPORT_SUGGESTIONS_ENABLED] = sConfigMgr->GetBoolDefault("Support.SuggestionsEnabled", false);
     if (reload)
     {
         sSupportMgr->SetSupportSystemStatus(m_bool_configs[CONFIG_SUPPORT_ENABLED]);
         sSupportMgr->SetTicketSystemStatus(m_bool_configs[CONFIG_SUPPORT_TICKETS_ENABLED]);
         sSupportMgr->SetBugSystemStatus(m_bool_configs[CONFIG_SUPPORT_BUGS_ENABLED]);
         sSupportMgr->SetComplaintSystemStatus(m_bool_configs[CONFIG_SUPPORT_COMPLAINTS_ENABLED]);
         sSupportMgr->SetSuggestionSystemStatus(m_bool_configs[CONFIG_SUPPORT_SUGGESTIONS_ENABLED]);
     }
 
 
     SetNewCharString(sConfigMgr->GetStringDefault("PlayerStart.String", ""));
 
     m_int_configs[CONFIG_ENABLE_SINFO_LOGIN] = sConfigMgr->GetIntDefault("Server.LoginInfo", 0);
 
     rate_values[RATE_HEALTH]      = sConfigMgr->GetFloatDefault("Rate.Health", 1.0f);
     if (rate_values[RATE_HEALTH] < 0)
     {
         TC_LOG_ERROR("server.loading", "Rate.Health (%f) must be > 0. Using 1 instead.", rate_values[RATE_HEALTH]);
         rate_values[RATE_HEALTH] = 1;
     }
     rate_values[RATE_POWER_MANA]  = sConfigMgr->GetFloatDefault("Rate.Mana", 1.0f);
     if (rate_values[RATE_POWER_MANA] < 0)
     {
         TC_LOG_ERROR("server.loading", "Rate.Mana (%f) must be > 0. Using 1 instead.", rate_values[RATE_POWER_MANA]);
         rate_values[RATE_POWER_MANA] = 1;
     }
     rate_values[RATE_POWER_RAGE_INCOME] = sConfigMgr->GetFloatDefault("Rate.Rage.Income", 1.0f);
     rate_values[RATE_POWER_RAGE_LOSS]   = sConfigMgr->GetFloatDefault("Rate.Rage.Loss", 1.0f);
     if (rate_values[RATE_POWER_RAGE_LOSS] < 0)
     {
         TC_LOG_ERROR("server.loading", "Rate.Rage.Loss (%f) must be > 0. Using 1 instead.", rate_values[RATE_POWER_RAGE_LOSS]);
         rate_values[RATE_POWER_RAGE_LOSS] = 1;
     }
     rate_values[RATE_POWER_RUNICPOWER_INCOME] = sConfigMgr->GetFloatDefault("Rate.RunicPower.Income", 1.0f);
     rate_values[RATE_POWER_RUNICPOWER_LOSS]   = sConfigMgr->GetFloatDefault("Rate.RunicPower.Loss", 1.0f);
     if (rate_values[RATE_POWER_RUNICPOWER_LOSS] < 0)
     {
         TC_LOG_ERROR("server.loading", "Rate.RunicPower.Loss (%f) must be > 0. Using 1 instead.", rate_values[RATE_POWER_RUNICPOWER_LOSS]);
         rate_values[RATE_POWER_RUNICPOWER_LOSS] = 1;
     }
     rate_values[RATE_POWER_FOCUS]  = sConfigMgr->GetFloatDefault("Rate.Focus", 1.0f);
     rate_values[RATE_POWER_ENERGY] = sConfigMgr->GetFloatDefault("Rate.Energy", 1.0f);
 
     rate_values[RATE_SKILL_DISCOVERY]      = sConfigMgr->GetFloatDefault("Rate.Skill.Discovery", 1.0f);
 
     rate_values[RATE_DROP_ITEM_POOR]       = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Poor", 1.0f);
     rate_values[RATE_DROP_ITEM_NORMAL]     = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Normal", 1.0f);
     rate_values[RATE_DROP_ITEM_UNCOMMON]   = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Uncommon", 1.0f);
     rate_values[RATE_DROP_ITEM_RARE]       = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Rare", 1.0f);
     rate_values[RATE_DROP_ITEM_EPIC]       = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Epic", 1.0f);
     rate_values[RATE_DROP_ITEM_LEGENDARY]  = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Legendary", 1.0f);
     rate_values[RATE_DROP_ITEM_ARTIFACT]   = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Artifact", 1.0f);
     rate_values[RATE_DROP_ITEM_REFERENCED] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Referenced", 1.0f);
     rate_values[RATE_DROP_ITEM_REFERENCED_AMOUNT] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.ReferencedAmount", 1.0f);
     rate_values[RATE_DROP_MONEY]  = sConfigMgr->GetFloatDefault("Rate.Drop.Money", 1.0f);
     rate_values[RATE_XP_KILL]     = sConfigMgr->GetFloatDefault("Rate.XP.Kill", 1.0f);
     rate_values[RATE_XP_BG_KILL]  = sConfigMgr->GetFloatDefault("Rate.XP.BattlegroundKill", 1.0f);
     rate_values[RATE_XP_QUEST]    = sConfigMgr->GetFloatDefault("Rate.XP.Quest", 1.0f);
     rate_values[RATE_XP_EXPLORE]  = sConfigMgr->GetFloatDefault("Rate.XP.Explore", 1.0f);
     rate_values[RATE_REPAIRCOST]  = sConfigMgr->GetFloatDefault("Rate.RepairCost", 1.0f);
     if (rate_values[RATE_REPAIRCOST] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "Rate.RepairCost (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_REPAIRCOST]);
         rate_values[RATE_REPAIRCOST] = 0.0f;
     }
     rate_values[RATE_REPUTATION_GAIN]  = sConfigMgr->GetFloatDefault("Rate.Reputation.Gain", 1.0f);
     rate_values[RATE_REPUTATION_LOWLEVEL_KILL]  = sConfigMgr->GetFloatDefault("Rate.Reputation.LowLevel.Kill", 1.0f);
     rate_values[RATE_REPUTATION_LOWLEVEL_QUEST]  = sConfigMgr->GetFloatDefault("Rate.Reputation.LowLevel.Quest", 1.0f);
     rate_values[RATE_REPUTATION_RECRUIT_A_FRIEND_BONUS] = sConfigMgr->GetFloatDefault("Rate.Reputation.RecruitAFriendBonus", 0.1f);
     rate_values[RATE_CREATURE_NORMAL_DAMAGE]          = sConfigMgr->GetFloatDefault("Rate.Creature.Normal.Damage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_ELITE_DAMAGE]     = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.Elite.Damage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_RAREELITE_DAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RAREELITE.Damage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_WORLDBOSS_DAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.WORLDBOSS.Damage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_RARE_DAMAGE]      = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RARE.Damage", 1.0f);
     rate_values[RATE_CREATURE_NORMAL_HP]          = sConfigMgr->GetFloatDefault("Rate.Creature.Normal.HP", 1.0f);
     rate_values[RATE_CREATURE_ELITE_ELITE_HP]     = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.Elite.HP", 1.0f);
     rate_values[RATE_CREATURE_ELITE_RAREELITE_HP] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RAREELITE.HP", 1.0f);
     rate_values[RATE_CREATURE_ELITE_WORLDBOSS_HP] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.WORLDBOSS.HP", 1.0f);
     rate_values[RATE_CREATURE_ELITE_RARE_HP]      = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RARE.HP", 1.0f);
     rate_values[RATE_CREATURE_NORMAL_SPELLDAMAGE]          = sConfigMgr->GetFloatDefault("Rate.Creature.Normal.SpellDamage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE]     = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.Elite.SpellDamage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_RAREELITE_SPELLDAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RAREELITE.SpellDamage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_WORLDBOSS_SPELLDAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.WORLDBOSS.SpellDamage", 1.0f);
     rate_values[RATE_CREATURE_ELITE_RARE_SPELLDAMAGE]      = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RARE.SpellDamage", 1.0f);
     rate_values[RATE_CREATURE_AGGRO]  = sConfigMgr->GetFloatDefault("Rate.Creature.Aggro", 1.0f);
     rate_values[RATE_REST_INGAME]                    = sConfigMgr->GetFloatDefault("Rate.Rest.InGame", 1.0f);
     rate_values[RATE_REST_OFFLINE_IN_TAVERN_OR_CITY] = sConfigMgr->GetFloatDefault("Rate.Rest.Offline.InTavernOrCity", 1.0f);
     rate_values[RATE_REST_OFFLINE_IN_WILDERNESS]     = sConfigMgr->GetFloatDefault("Rate.Rest.Offline.InWilderness", 1.0f);
     rate_values[RATE_DAMAGE_FALL]  = sConfigMgr->GetFloatDefault("Rate.Damage.Fall", 1.0f);
     rate_values[RATE_AUCTION_TIME]  = sConfigMgr->GetFloatDefault("Rate.Auction.Time", 1.0f);
     rate_values[RATE_AUCTION_DEPOSIT] = sConfigMgr->GetFloatDefault("Rate.Auction.Deposit", 1.0f);
     rate_values[RATE_AUCTION_CUT] = sConfigMgr->GetFloatDefault("Rate.Auction.Cut", 1.0f);
     rate_values[RATE_HONOR] = sConfigMgr->GetFloatDefault("Rate.Honor", 1.0f);
     rate_values[RATE_INSTANCE_RESET_TIME] = sConfigMgr->GetFloatDefault("Rate.InstanceResetTime", 1.0f);
     rate_values[RATE_TALENT] = sConfigMgr->GetFloatDefault("Rate.Talent", 1.0f);
     if (rate_values[RATE_TALENT] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "Rate.Talent (%f) must be > 0. Using 1 instead.", rate_values[RATE_TALENT]);
         rate_values[RATE_TALENT] = 1.0f;
     }
     rate_values[RATE_MOVESPEED] = sConfigMgr->GetFloatDefault("Rate.MoveSpeed", 1.0f);
     if (rate_values[RATE_MOVESPEED] < 0)
     {
         TC_LOG_ERROR("server.loading", "Rate.MoveSpeed (%f) must be > 0. Using 1 instead.", rate_values[RATE_MOVESPEED]);
         rate_values[RATE_MOVESPEED] = 1.0f;
     }
     for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i) playerBaseMoveSpeed[i] = baseMoveSpeed[i] * rate_values[RATE_MOVESPEED];
     rate_values[RATE_CORPSE_DECAY_LOOTED] = sConfigMgr->GetFloatDefault("Rate.Corpse.Decay.Looted", 0.5f);
 
     rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] = sConfigMgr->GetFloatDefault("TargetPosRecalculateRange", 1.5f);
     if (rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] < CONTACT_DISTANCE)
     {
         TC_LOG_ERROR("server.loading", "TargetPosRecalculateRange (%f) must be >= %f. Using %f instead.", rate_values[RATE_TARGET_POS_RECALCULATION_RANGE], CONTACT_DISTANCE, CONTACT_DISTANCE);
         rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] = CONTACT_DISTANCE;
     }
     else if (rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] > NOMINAL_MELEE_RANGE)
     {
         TC_LOG_ERROR("server.loading", "TargetPosRecalculateRange (%f) must be <= %f. Using %f instead.",
             rate_values[RATE_TARGET_POS_RECALCULATION_RANGE], NOMINAL_MELEE_RANGE, NOMINAL_MELEE_RANGE);
         rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] = NOMINAL_MELEE_RANGE;
     }
 
     rate_values[RATE_DURABILITY_LOSS_ON_DEATH]  = sConfigMgr->GetFloatDefault("DurabilityLoss.OnDeath", 10.0f);
     if (rate_values[RATE_DURABILITY_LOSS_ON_DEATH] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "DurabilityLoss.OnDeath (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_ON_DEATH]);
         rate_values[RATE_DURABILITY_LOSS_ON_DEATH] = 0.0f;
     }
     if (rate_values[RATE_DURABILITY_LOSS_ON_DEATH] > 100.0f)
     {
         TC_LOG_ERROR("server.loading", "DurabilityLoss.OnDeath (%f) must be <= 100. Using 100.0 instead.", rate_values[RATE_DURABILITY_LOSS_ON_DEATH]);
         rate_values[RATE_DURABILITY_LOSS_ON_DEATH] = 0.0f;
     }
     rate_values[RATE_DURABILITY_LOSS_ON_DEATH] = rate_values[RATE_DURABILITY_LOSS_ON_DEATH] / 100.0f;
 
     rate_values[RATE_DURABILITY_LOSS_DAMAGE] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Damage", 0.5f);
     if (rate_values[RATE_DURABILITY_LOSS_DAMAGE] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "DurabilityLossChance.Damage (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_DAMAGE]);
         rate_values[RATE_DURABILITY_LOSS_DAMAGE] = 0.0f;
     }
     rate_values[RATE_DURABILITY_LOSS_ABSORB] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Absorb", 0.5f);
     if (rate_values[RATE_DURABILITY_LOSS_ABSORB] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "DurabilityLossChance.Absorb (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_ABSORB]);
         rate_values[RATE_DURABILITY_LOSS_ABSORB] = 0.0f;
     }
     rate_values[RATE_DURABILITY_LOSS_PARRY] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Parry", 0.05f);
     if (rate_values[RATE_DURABILITY_LOSS_PARRY] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "DurabilityLossChance.Parry (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_PARRY]);
         rate_values[RATE_DURABILITY_LOSS_PARRY] = 0.0f;
     }
     rate_values[RATE_DURABILITY_LOSS_BLOCK] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Block", 0.05f);
     if (rate_values[RATE_DURABILITY_LOSS_BLOCK] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "DurabilityLossChance.Block (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_BLOCK]);
         rate_values[RATE_DURABILITY_LOSS_BLOCK] = 0.0f;
     }
     rate_values[RATE_MONEY_QUEST] = sConfigMgr->GetFloatDefault("Rate.Quest.Money.Reward", 1.0f);
     if (rate_values[RATE_MONEY_QUEST] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "Rate.Quest.Money.Reward (%f) must be >=0. Using 0 instead.", rate_values[RATE_MONEY_QUEST]);
         rate_values[RATE_MONEY_QUEST] = 0.0f;
     }
     rate_values[RATE_MONEY_MAX_LEVEL_QUEST] = sConfigMgr->GetFloatDefault("Rate.Quest.Money.Max.Level.Reward", 1.0f);
     if (rate_values[RATE_MONEY_MAX_LEVEL_QUEST] < 0.0f)
     {
         TC_LOG_ERROR("server.loading", "Rate.Quest.Money.Max.Level.Reward (%f) must be >=0. Using 0 instead.", rate_values[RATE_MONEY_MAX_LEVEL_QUEST]);
         rate_values[RATE_MONEY_MAX_LEVEL_QUEST] = 0.0f;
     }
 
     m_bool_configs[CONFIG_DURABILITY_LOSS_IN_PVP] = sConfigMgr->GetBoolDefault("DurabilityLoss.InPvP", false);
 
     m_int_configs[CONFIG_COMPRESSION] = sConfigMgr->GetIntDefault("Compression", 1);
     if (m_int_configs[CONFIG_COMPRESSION] < 1 || m_int_configs[CONFIG_COMPRESSION] > 9)
     {
         TC_LOG_ERROR("server.loading", "Compression level (%i) must be in range 1..9. Using default compression level (1).", m_int_configs[CONFIG_COMPRESSION]);
         m_int_configs[CONFIG_COMPRESSION] = 1;
     }
     m_bool_configs[CONFIG_ADDON_CHANNEL] = sConfigMgr->GetBoolDefault("AddonChannel", true);
     m_bool_configs[CONFIG_CLEAN_CHARACTER_DB] = sConfigMgr->GetBoolDefault("CleanCharacterDB", false);
     m_int_configs[CONFIG_PERSISTENT_CHARACTER_CLEAN_FLAGS] = sConfigMgr->GetIntDefault("PersistentCharacterCleanFlags", 0);
     m_int_configs[CONFIG_CHAT_CHANNEL_LEVEL_REQ] = sConfigMgr->GetIntDefault("ChatLevelReq.Channel", 1);
     m_int_configs[CONFIG_CHAT_WHISPER_LEVEL_REQ] = sConfigMgr->GetIntDefault("ChatLevelReq.Whisper", 1);
     m_int_configs[CONFIG_CHAT_SAY_LEVEL_REQ] = sConfigMgr->GetIntDefault("ChatLevelReq.Say", 1);
     m_int_configs[CONFIG_TRADE_LEVEL_REQ] = sConfigMgr->GetIntDefault("LevelReq.Trade", 1);
     m_int_configs[CONFIG_AUCTION_LEVEL_REQ] = sConfigMgr->GetIntDefault("LevelReq.Auction", 1);
     m_int_configs[CONFIG_MAIL_LEVEL_REQ] = sConfigMgr->GetIntDefault("LevelReq.Mail", 1);
     m_bool_configs[CONFIG_PRESERVE_CUSTOM_CHANNELS] = sConfigMgr->GetBoolDefault("PreserveCustomChannels", false);
     m_int_configs[CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION] = sConfigMgr->GetIntDefault("PreserveCustomChannelDuration", 14);
     m_bool_configs[CONFIG_GRID_UNLOAD] = sConfigMgr->GetBoolDefault("GridUnload", true);
     m_int_configs[CONFIG_INTERVAL_SAVE] = sConfigMgr->GetIntDefault("PlayerSaveInterval", 15 * MINUTE * IN_MILLISECONDS);
     m_int_configs[CONFIG_INTERVAL_DISCONNECT_TOLERANCE] = sConfigMgr->GetIntDefault("DisconnectToleranceInterval", 0);
     m_bool_configs[CONFIG_STATS_SAVE_ONLY_ON_LOGOUT] = sConfigMgr->GetBoolDefault("PlayerSave.Stats.SaveOnlyOnLogout", true);
 
     m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE] = sConfigMgr->GetIntDefault("PlayerSave.Stats.MinLevel", 0);
     if (m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE] > MAX_LEVEL)
     {
         TC_LOG_ERROR("server.loading", "PlayerSave.Stats.MinLevel (%i) must be in range 0..80. Using default, do not save character stats (0).", m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE]);
         m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE] = 0;
     }
 
     m_int_configs[CONFIG_INTERVAL_GRIDCLEAN] = sConfigMgr->GetIntDefault("GridCleanUpDelay", 5 * MINUTE * IN_MILLISECONDS);
     if (m_int_configs[CONFIG_INTERVAL_GRIDCLEAN] < MIN_GRID_DELAY)
     {
         TC_LOG_ERROR("server.loading", "GridCleanUpDelay (%i) must be greater %u. Use this minimal value.", m_int_configs[CONFIG_INTERVAL_GRIDCLEAN], MIN_GRID_DELAY);
         m_int_configs[CONFIG_INTERVAL_GRIDCLEAN] = MIN_GRID_DELAY;
     }
     if (reload)
         sMapMgr->SetGridCleanUpDelay(m_int_configs[CONFIG_INTERVAL_GRIDCLEAN]);
 
     m_int_configs[CONFIG_INTERVAL_MAPUPDATE] = sConfigMgr->GetIntDefault("MapUpdateInterval", 100);
     if (m_int_configs[CONFIG_INTERVAL_MAPUPDATE] < MIN_MAP_UPDATE_DELAY)
     {
         TC_LOG_ERROR("server.loading", "MapUpdateInterval (%i) must be greater %u. Use this minimal value.", m_int_configs[CONFIG_INTERVAL_MAPUPDATE], MIN_MAP_UPDATE_DELAY);
         m_int_configs[CONFIG_INTERVAL_MAPUPDATE] = MIN_MAP_UPDATE_DELAY;
     }
     if (reload)
         sMapMgr->SetMapUpdateInterval(m_int_configs[CONFIG_INTERVAL_MAPUPDATE]);
 
     m_int_configs[CONFIG_INTERVAL_CHANGEWEATHER] = sConfigMgr->GetIntDefault("ChangeWeatherInterval", 10 * MINUTE * IN_MILLISECONDS);
 
     if (reload)
     {
         uint32 val = sConfigMgr->GetIntDefault("WorldServerPort", 8085);
         if (val != m_int_configs[CONFIG_PORT_WORLD])
             TC_LOG_ERROR("server.loading", "WorldServerPort option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_PORT_WORLD]);
 
         val = sConfigMgr->GetIntDefault("InstanceServerPort", 8086);
         if (val != m_int_configs[CONFIG_PORT_INSTANCE])
             TC_LOG_ERROR("server.loading", "InstanceServerPort option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_PORT_INSTANCE]);
     }
     else
     {
         m_int_configs[CONFIG_PORT_WORLD] = sConfigMgr->GetIntDefault("WorldServerPort", 8085);
         m_int_configs[CONFIG_PORT_INSTANCE] = sConfigMgr->GetIntDefault("InstanceServerPort", 8086);
     }
 
     m_int_configs[CONFIG_SOCKET_TIMEOUTTIME] = sConfigMgr->GetIntDefault("SocketTimeOutTime", 900000);
     m_int_configs[CONFIG_SESSION_ADD_DELAY] = sConfigMgr->GetIntDefault("SessionAddDelay", 10000);
 
     m_float_configs[CONFIG_GROUP_XP_DISTANCE] = sConfigMgr->GetFloatDefault("MaxGroupXPDistance", 74.0f);
     m_float_configs[CONFIG_MAX_RECRUIT_A_FRIEND_DISTANCE] = sConfigMgr->GetFloatDefault("MaxRecruitAFriendBonusDistance", 100.0f);
 
     m_float_configs[CONFIG_SIGHT_MONSTER] = sConfigMgr->GetFloatDefault("MonsterSight", 50.0f);
     m_float_configs[CONFIG_SIGHT_GUARDER] = sConfigMgr->GetFloatDefault("GuarderSight", 50.0f);
 
     if (reload)
     {
         uint32 val = sConfigMgr->GetIntDefault("GameType", 0);
         if (val != m_int_configs[CONFIG_GAME_TYPE])
             TC_LOG_ERROR("server.loading", "GameType option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_GAME_TYPE]);
     }
     else
         m_int_configs[CONFIG_GAME_TYPE] = sConfigMgr->GetIntDefault("GameType", 0);
 
     if (reload)
     {
         uint32 val = sConfigMgr->GetIntDefault("RealmZone", REALM_ZONE_DEVELOPMENT);
         if (val != m_int_configs[CONFIG_REALM_ZONE])
             TC_LOG_ERROR("server.loading", "RealmZone option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_REALM_ZONE]);
     }
     else
         m_int_configs[CONFIG_REALM_ZONE] = sConfigMgr->GetIntDefault("RealmZone", REALM_ZONE_DEVELOPMENT);
 
     m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CALENDAR]= sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Calendar", false);
     m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Channel", false);
     m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP]   = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Group", false);
     m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD]   = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Guild", false);
     m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Auction", false);
     m_bool_configs[CONFIG_ALLOW_TWO_SIDE_TRADE]               = sConfigMgr->GetBoolDefault("AllowTwoSide.Trade", false);
     m_int_configs[CONFIG_STRICT_PLAYER_NAMES]                 = sConfigMgr->GetIntDefault ("StrictPlayerNames",  0);
     m_int_configs[CONFIG_STRICT_CHARTER_NAMES]                = sConfigMgr->GetIntDefault ("StrictCharterNames", 0);
     m_int_configs[CONFIG_STRICT_PET_NAMES]                    = sConfigMgr->GetIntDefault ("StrictPetNames",     0);
 
     m_int_configs[CONFIG_MIN_PLAYER_NAME]                     = sConfigMgr->GetIntDefault ("MinPlayerName",  2);
     if (m_int_configs[CONFIG_MIN_PLAYER_NAME] < 1 || m_int_configs[CONFIG_MIN_PLAYER_NAME] > MAX_PLAYER_NAME)
     {
         TC_LOG_ERROR("server.loading", "MinPlayerName (%i) must be in range 1..%u. Set to 2.", m_int_configs[CONFIG_MIN_PLAYER_NAME], MAX_PLAYER_NAME);
         m_int_configs[CONFIG_MIN_PLAYER_NAME] = 2;
     }
 
     m_int_configs[CONFIG_MIN_CHARTER_NAME]                    = sConfigMgr->GetIntDefault ("MinCharterName", 2);
     if (m_int_configs[CONFIG_MIN_CHARTER_NAME] < 1 || m_int_configs[CONFIG_MIN_CHARTER_NAME] > MAX_CHARTER_NAME)
     {
         TC_LOG_ERROR("server.loading", "MinCharterName (%i) must be in range 1..%u. Set to 2.", m_int_configs[CONFIG_MIN_CHARTER_NAME], MAX_CHARTER_NAME);
         m_int_configs[CONFIG_MIN_CHARTER_NAME] = 2;
     }
 
     m_int_configs[CONFIG_MIN_PET_NAME]                        = sConfigMgr->GetIntDefault ("MinPetName",     2);
     if (m_int_configs[CONFIG_MIN_PET_NAME] < 1 || m_int_configs[CONFIG_MIN_PET_NAME] > MAX_PET_NAME)
     {
         TC_LOG_ERROR("server.loading", "MinPetName (%i) must be in range 1..%u. Set to 2.", m_int_configs[CONFIG_MIN_PET_NAME], MAX_PET_NAME);
         m_int_configs[CONFIG_MIN_PET_NAME] = 2;
     }
 
     m_int_configs[CONFIG_CHARTER_COST_GUILD] = sConfigMgr->GetIntDefault("Guild.CharterCost", 1000);
     m_int_configs[CONFIG_CHARTER_COST_ARENA_2v2] = sConfigMgr->GetIntDefault("ArenaTeam.CharterCost.2v2", 800000);
     m_int_configs[CONFIG_CHARTER_COST_ARENA_3v3] = sConfigMgr->GetIntDefault("ArenaTeam.CharterCost.3v3", 1200000);
     m_int_configs[CONFIG_CHARTER_COST_ARENA_5v5] = sConfigMgr->GetIntDefault("ArenaTeam.CharterCost.5v5", 2000000);
 
     m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled", 0);
     m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled.RaceMask", 0);
     m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_CLASSMASK] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled.ClassMask", 0);
 
     m_int_configs[CONFIG_CHARACTERS_PER_REALM] = sConfigMgr->GetIntDefault("CharactersPerRealm", MAX_CHARACTERS_PER_REALM);
     if (m_int_configs[CONFIG_CHARACTERS_PER_REALM] < 1 || m_int_configs[CONFIG_CHARACTERS_PER_REALM] > MAX_CHARACTERS_PER_REALM)
     {
         TC_LOG_ERROR("server.loading", "CharactersPerRealm (%i) must be in range 1..10. Set to 10.", m_int_configs[CONFIG_CHARACTERS_PER_REALM]);
         m_int_configs[CONFIG_CHARACTERS_PER_REALM] = MAX_CHARACTERS_PER_REALM;
     }
 
     // must be after CONFIG_CHARACTERS_PER_REALM
     m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT] = sConfigMgr->GetIntDefault("CharactersPerAccount", 50);
     if (m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT] < m_int_configs[CONFIG_CHARACTERS_PER_REALM])
     {
         TC_LOG_ERROR("server.loading", "CharactersPerAccount (%i) can't be less than CharactersPerRealm (%i).", m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT], m_int_configs[CONFIG_CHARACTERS_PER_REALM]);
         m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT] = m_int_configs[CONFIG_CHARACTERS_PER_REALM];
     }
 
     m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM] = sConfigMgr->GetIntDefault("HeroicCharactersPerRealm", 1);
     if (int32(m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM]) < 0 || m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM] > 10)
     {
         TC_LOG_ERROR("server.loading", "HeroicCharactersPerRealm (%i) must be in range 0..10. Set to 1.", m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM]);
         m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM] = 1;
     }
 
     m_int_configs[CONFIG_CHARACTER_CREATING_MIN_LEVEL_FOR_HEROIC_CHARACTER] = sConfigMgr->GetIntDefault("CharacterCreating.MinLevelForHeroicCharacter", 55);
 
     m_int_configs[CONFIG_SKIP_CINEMATICS] = sConfigMgr->GetIntDefault("SkipCinematics", 0);
     if (int32(m_int_configs[CONFIG_SKIP_CINEMATICS]) < 0 || m_int_configs[CONFIG_SKIP_CINEMATICS] > 2)
     {
         TC_LOG_ERROR("server.loading", "SkipCinematics (%i) must be in range 0..2. Set to 0.", m_int_configs[CONFIG_SKIP_CINEMATICS]);
         m_int_configs[CONFIG_SKIP_CINEMATICS] = 0;
     }
 
     if (reload)
     {
         uint32 val = sConfigMgr->GetIntDefault("MaxPlayerLevel", DEFAULT_MAX_LEVEL);
         if (val != m_int_configs[CONFIG_MAX_PLAYER_LEVEL])
             TC_LOG_ERROR("server.loading", "MaxPlayerLevel option can't be changed at config reload, using current value (%u).", m_int_configs[CONFIG_MAX_PLAYER_LEVEL]);
     }
     else
         m_int_configs[CONFIG_MAX_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("MaxPlayerLevel", DEFAULT_MAX_LEVEL);
 
     if (m_int_configs[CONFIG_MAX_PLAYER_LEVEL] > MAX_LEVEL)
     {
         TC_LOG_ERROR("server.loading", "MaxPlayerLevel (%i) must be in range 1..%u. Set to %u.", m_int_configs[CONFIG_MAX_PLAYER_LEVEL], MAX_LEVEL, MAX_LEVEL);
         m_int_configs[CONFIG_MAX_PLAYER_LEVEL] = MAX_LEVEL;
     }
 
     m_int_configs[CONFIG_MIN_DUALSPEC_LEVEL] = sConfigMgr->GetIntDefault("MinDualSpecLevel", 40);
 
     m_int_configs[CONFIG_START_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("StartPlayerLevel", 1);
     if (m_int_configs[CONFIG_START_PLAYER_LEVEL] < 1)
     {
         TC_LOG_ERROR("server.loading", "StartPlayerLevel (%i) must be in range 1..MaxPlayerLevel(%u). Set to 1.", m_int_configs[CONFIG_START_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL]);
         m_int_configs[CONFIG_START_PLAYER_LEVEL] = 1;
     }
     else if (m_int_configs[CONFIG_START_PLAYER_LEVEL] > m_int_configs[CONFIG_MAX_PLAYER_LEVEL])
     {
         TC_LOG_ERROR("server.loading", "StartPlayerLevel (%i) must be in range 1..MaxPlayerLevel(%u). Set to %u.", m_int_configs[CONFIG_START_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL]);
         m_int_configs[CONFIG_START_PLAYER_LEVEL] = m_int_configs[CONFIG_MAX_PLAYER_LEVEL];
     }
 
     m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("StartHeroicPlayerLevel", 55);
     if (m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] < 1)
     {
         TC_LOG_ERROR("server.loading", "StartHeroicPlayerLevel (%i) must be in range 1..MaxPlayerLevel(%u). Set to 55.",
             m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL]);
         m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] = 55;
     }
     else if (m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] > m_int_configs[CONFIG_MAX_PLAYER_LEVEL])
     {
         TC_LOG_ERROR("server.loading", "StartHeroicPlayerLevel (%i) must be in range 1..MaxPlayerLevel(%u). Set to %u.",
             m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL]);
         m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] = m_int_configs[CONFIG_MAX_PLAYER_LEVEL];
     }
 
     m_int_configs[CONFIG_START_PLAYER_MONEY] = sConfigMgr->GetIntDefault("StartPlayerMoney", 0);
     if (int32(m_int_configs[CONFIG_START_PLAYER_MONEY]) < 0)
     {
         TC_LOG_ERROR("server.loading", "StartPlayerMoney (%i) must be in range 0.." UI64FMTD ". Set to %u.", m_int_configs[CONFIG_START_PLAYER_MONEY], uint64(MAX_MONEY_AMOUNT), 0);
         m_int_configs[CONFIG_START_PLAYER_MONEY] = 0;
     }
     else if (m_int_configs[CONFIG_START_PLAYER_MONEY] > 0x7FFFFFFF-1) // TODO: (See MAX_MONEY_AMOUNT)
     {
         TC_LOG_ERROR("server.loading", "StartPlayerMoney (%i) must be in range 0..%u. Set to %u.",
             m_int_configs[CONFIG_START_PLAYER_MONEY], 0x7FFFFFFF-1, 0x7FFFFFFF-1);
         m_int_configs[CONFIG_START_PLAYER_MONEY] = 0x7FFFFFFF-1;
     }
 
     m_int_configs[CONFIG_CURRENCY_RESET_HOUR] = sConfigMgr->GetIntDefault("Currency.ResetHour", 3);
     if (m_int_configs[CONFIG_CURRENCY_RESET_HOUR] > 23)
     {
         TC_LOG_ERROR("server.loading", "Currency.ResetHour (%i) can't be load. Set to 6.", m_int_configs[CONFIG_CURRENCY_RESET_HOUR]);
         m_int_configs[CONFIG_CURRENCY_RESET_HOUR] = 3;
     }
     m_int_configs[CONFIG_CURRENCY_RESET_DAY] = sConfigMgr->GetIntDefault("Currency.ResetDay", 3);
     if (m_int_configs[CONFIG_CURRENCY_RESET_DAY] > 6)
     {
         TC_LOG_ERROR("server.loading", "Currency.ResetDay (%i) can't be load. Set to 3.", m_int_configs[CONFIG_CURRENCY_RESET_DAY]);
         m_int_configs[CONFIG_CURRENCY_RESET_DAY] = 3;
     }
     m_int_configs[CONFIG_CURRENCY_RESET_INTERVAL] = sConfigMgr->GetIntDefault("Currency.ResetInterval", 7);
     if (int32(m_int_configs[CONFIG_CURRENCY_RESET_INTERVAL]) <= 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.ResetInterval (%i) must be > 0, set to default 7.", m_int_configs[CONFIG_CURRENCY_RESET_INTERVAL]);
         m_int_configs[CONFIG_CURRENCY_RESET_INTERVAL] = 7;
     }
 
     m_int_configs[CONFIG_CURRENCY_START_HONOR_POINTS] = sConfigMgr->GetIntDefault("Currency.StartHonorPoints", 0);
     if (int32(m_int_configs[CONFIG_CURRENCY_START_HONOR_POINTS]) < 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.StartHonorPoints (%i) must be >= 0, set to default 0.", m_int_configs[CONFIG_CURRENCY_START_HONOR_POINTS]);
         m_int_configs[CONFIG_CURRENCY_START_HONOR_POINTS] = 0;
     }
     m_int_configs[CONFIG_CURRENCY_MAX_HONOR_POINTS] = sConfigMgr->GetIntDefault("Currency.MaxHonorPoints", 4000);
     if (int32(m_int_configs[CONFIG_CURRENCY_MAX_HONOR_POINTS]) < 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.MaxHonorPoints (%i) can't be negative. Set to default 4000.", m_int_configs[CONFIG_CURRENCY_MAX_HONOR_POINTS]);
         m_int_configs[CONFIG_CURRENCY_MAX_HONOR_POINTS] = 4000;
     }
     m_int_configs[CONFIG_CURRENCY_MAX_HONOR_POINTS] *= 100;     //precision mod
 
     m_int_configs[CONFIG_CURRENCY_START_APEXIS_CRYSTALS] = sConfigMgr->GetIntDefault("Currency.StartApexisCrystals", 0);
     if (int32(m_int_configs[CONFIG_CURRENCY_START_APEXIS_CRYSTALS]) < 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.StartApexisCrystals (%i) must be >= 0, set to default 0.", m_int_configs[CONFIG_CURRENCY_START_APEXIS_CRYSTALS]);
         m_int_configs[CONFIG_CURRENCY_START_APEXIS_CRYSTALS] = 0;
     }
     m_int_configs[CONFIG_CURRENCY_MAX_APEXIS_CRYSTALS] = sConfigMgr->GetIntDefault("Currency.MaxApexisCrystals", 20000);
     if (int32(m_int_configs[CONFIG_CURRENCY_MAX_APEXIS_CRYSTALS]) < 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.MaxApexisCrystals (%i) can't be negative. Set to default 20000.", m_int_configs[CONFIG_CURRENCY_MAX_APEXIS_CRYSTALS]);
         m_int_configs[CONFIG_CURRENCY_MAX_APEXIS_CRYSTALS] = 20000;
     }
     m_int_configs[CONFIG_CURRENCY_MAX_APEXIS_CRYSTALS] *= 100;     //precision mod
 
     m_int_configs[CONFIG_CURRENCY_START_JUSTICE_POINTS] = sConfigMgr->GetIntDefault("Currency.StartJusticePoints", 0);
     if (int32(m_int_configs[CONFIG_CURRENCY_START_JUSTICE_POINTS]) < 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.StartJusticePoints (%i) must be >= 0, set to default 0.", m_int_configs[CONFIG_CURRENCY_START_JUSTICE_POINTS]);
         m_int_configs[CONFIG_CURRENCY_START_JUSTICE_POINTS] = 0;
     }
     m_int_configs[CONFIG_CURRENCY_MAX_JUSTICE_POINTS] = sConfigMgr->GetIntDefault("Currency.MaxJusticePoints", 4000);
     if (int32(m_int_configs[CONFIG_CURRENCY_MAX_JUSTICE_POINTS]) < 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.MaxJusticePoints (%i) can't be negative. Set to default 4000.", m_int_configs[CONFIG_CURRENCY_MAX_JUSTICE_POINTS]);
         m_int_configs[CONFIG_CURRENCY_MAX_JUSTICE_POINTS] = 4000;
     }
     m_int_configs[CONFIG_CURRENCY_MAX_JUSTICE_POINTS] *= 100;     //precision mod
 
     m_int_configs[CONFIG_CURRENCY_START_CONQUEST_POINTS] = sConfigMgr->GetIntDefault("Currency.StartConquestPoints", 0);
     if (int32(m_int_configs[CONFIG_CURRENCY_START_CONQUEST_POINTS]) < 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.StartConquestPoints (%i) must be >= 0, set to default 0.", m_int_configs[CONFIG_CURRENCY_START_CONQUEST_POINTS]);
         m_int_configs[CONFIG_CURRENCY_START_CONQUEST_POINTS] = 0;
     }
     m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_WEEK_CAP] = sConfigMgr->GetIntDefault("Currency.ConquestPointsWeekCap", 1650);
     if (int32(m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_WEEK_CAP]) <= 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.ConquestPointsWeekCap (%i) must be > 0, set to default 1650.", m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_WEEK_CAP]);
         m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_WEEK_CAP] = 1650;
     }
     m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_WEEK_CAP] *= 100;     //precision mod
 
     m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_ARENA_REWARD] = sConfigMgr->GetIntDefault("Currency.ConquestPointsArenaReward", 180);
     if (int32(m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_ARENA_REWARD]) <= 0)
     {
         TC_LOG_ERROR("server.loading", "Currency.ConquestPointsArenaReward (%i) must be > 0, set to default 180.", m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_ARENA_REWARD]);
         m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_ARENA_REWARD] = 180;
     }
     m_int_configs[CONFIG_CURRENCY_CONQUEST_POINTS_ARENA_REWARD] *= 100;     //precision mod
 
     m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("RecruitAFriend.MaxLevel", 85);
     if (m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] > m_int_configs[CONFIG_MAX_PLAYER_LEVEL])
     {
         TC_LOG_ERROR("server.loading", "RecruitAFriend.MaxLevel (%i) must be in the range 0..MaxLevel(%u). Set to %u.",
             m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL], 85);
         m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] = 85;
     }
 
     m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL_DIFFERENCE] = sConfigMgr->GetIntDefault("RecruitAFriend.MaxDifference", 4);
     m_bool_configs[CONFIG_ALL_TAXI_PATHS] = sConfigMgr->GetBoolDefault("AllFlightPaths", false);
     m_bool_configs[CONFIG_INSTANT_TAXI] = sConfigMgr->GetBoolDefault("InstantFlightPaths", false);
 
     m_bool_configs[CONFIG_INSTANCE_IGNORE_LEVEL] = sConfigMgr->GetBoolDefault("Instance.IgnoreLevel", false);
     m_bool_configs[CONFIG_INSTANCE_IGNORE_RAID]  = sConfigMgr->GetBoolDefault("Instance.IgnoreRaid", false);
 
     m_bool_configs[CONFIG_CAST_UNSTUCK] = sConfigMgr->GetBoolDefault("CastUnstuck", true);
     m_int_configs[CONFIG_INSTANCE_RESET_TIME_HOUR]  = sConfigMgr->GetIntDefault("Instance.ResetTimeHour", 4);
     m_int_configs[CONFIG_INSTANCE_UNLOAD_DELAY] = sConfigMgr->GetIntDefault("Instance.UnloadDelay", 30 * MINUTE * IN_MILLISECONDS);
 
     m_int_configs[CONFIG_MAX_PRIMARY_TRADE_SKILL] = sConfigMgr->GetIntDefault("MaxPrimaryTradeSkill", 2);
     m_int_configs[CONFIG_MIN_PETITION_SIGNS] = sConfigMgr->GetIntDefault("MinPetitionSigns", 4);
     if (m_int_configs[CONFIG_MIN_PETITION_SIGNS] > 4)
     {
         TC_LOG_ERROR("server.loading", "MinPetitionSigns (%i) must be in range 0..4. Set to 4.", m_int_configs[CONFIG_MIN_PETITION_SIGNS]);
         m_int_configs[CONFIG_MIN_PETITION_SIGNS] = 4;
     }
 
     m_int_configs[CONFIG_GM_LOGIN_STATE]        = sConfigMgr->GetIntDefault("GM.LoginState", 2);
     m_int_configs[CONFIG_GM_VISIBLE_STATE]      = sConfigMgr->GetIntDefault("GM.Visible", 2);
     m_int_configs[CONFIG_GM_CHAT]               = sConfigMgr->GetIntDefault("GM.Chat", 2);
     m_int_configs[CONFIG_GM_WHISPERING_TO]      = sConfigMgr->GetIntDefault("GM.WhisperingTo", 2);
     m_int_configs[CONFIG_GM_FREEZE_DURATION]    = sConfigMgr->GetIntDefault("GM.FreezeAuraDuration", 0);
 
     m_int_configs[CONFIG_GM_LEVEL_IN_GM_LIST]   = sConfigMgr->GetIntDefault("GM.InGMList.Level", SEC_ADMINISTRATOR);
     m_int_configs[CONFIG_GM_LEVEL_IN_WHO_LIST]  = sConfigMgr->GetIntDefault("GM.InWhoList.Level", SEC_ADMINISTRATOR);
     m_int_configs[CONFIG_START_GM_LEVEL]        = sConfigMgr->GetIntDefault("GM.StartLevel", 1);
     if (m_int_configs[CONFIG_START_GM_LEVEL] < m_int_configs[CONFIG_START_PLAYER_LEVEL])
     {
         TC_LOG_ERROR("server.loading", "GM.StartLevel (%i) must be in range StartPlayerLevel(%u)..%u. Set to %u.",
             m_int_configs[CONFIG_START_GM_LEVEL], m_int_configs[CONFIG_START_PLAYER_LEVEL], MAX_LEVEL, m_int_configs[CONFIG_START_PLAYER_LEVEL]);
         m_int_configs[CONFIG_START_GM_LEVEL] = m_int_configs[CONFIG_START_PLAYER_LEVEL];
     }
     else if (m_int_configs[CONFIG_START_GM_LEVEL] > MAX_LEVEL)
     {
         TC_LOG_ERROR("server.loading", "GM.StartLevel (%i) must be in range 1..%u. Set to %u.", m_int_configs[CONFIG_START_GM_LEVEL], MAX_LEVEL, MAX_LEVEL);
         m_int_configs[CONFIG_START_GM_LEVEL] = MAX_LEVEL;
     }
     m_bool_configs[CONFIG_ALLOW_GM_GROUP]       = sConfigMgr->GetBoolDefault("GM.AllowInvite", false);
     m_bool_configs[CONFIG_GM_LOWER_SECURITY] = sConfigMgr->GetBoolDefault("GM.LowerSecurity", false);
 
     m_int_configs[CONFIG_GROUP_VISIBILITY] = sConfigMgr->GetIntDefault("Visibility.GroupMode", 1);
 
     m_int_configs[CONFIG_MAIL_DELIVERY_DELAY] = sConfigMgr->GetIntDefault("MailDeliveryDelay", HOUR);
 
     m_int_configs[CONFIG_UPTIME_UPDATE] = sConfigMgr->GetIntDefault("UpdateUptimeInterval", 10);
     if (int32(m_int_configs[CONFIG_UPTIME_UPDATE]) <= 0)
     {
         TC_LOG_ERROR("server.loading", "UpdateUptimeInterval (%i) must be > 0, set to default 10.", m_int_configs[CONFIG_UPTIME_UPDATE]);
         m_int_configs[CONFIG_UPTIME_UPDATE] = 10;
     }
     if (reload)
     {
         m_timers[WUPDATE_UPTIME].SetInterval(m_int_configs[CONFIG_UPTIME_UPDATE]*MINUTE*IN_MILLISECONDS);
         m_timers[WUPDATE_UPTIME].Reset();
     }
 
     // log db cleanup interval
     m_int_configs[CONFIG_LOGDB_CLEARINTERVAL] = sConfigMgr->GetIntDefault("LogDB.Opt.ClearInterval", 10);
     if (int32(m_int_configs[CONFIG_LOGDB_CLEARINTERVAL]) <= 0)
     {
         TC_LOG_ERROR("server.loading", "LogDB.Opt.ClearInterval (%i) must be > 0, set to default 10.", m_int_configs[CONFIG_LOGDB_CLEARINTERVAL]);
         m_int_configs[CONFIG_LOGDB_CLEARINTERVAL] = 10;
     }
     if (reload)
     {
         m_timers[WUPDATE_CLEANDB].SetInterval(m_int_configs[CONFIG_LOGDB_CLEARINTERVAL] * MINUTE * IN_MILLISECONDS);
         m_timers[WUPDATE_CLEANDB].Reset();
     }
     m_int_configs[CONFIG_LOGDB_CLEARTIME] = sConfigMgr->GetIntDefault("LogDB.Opt.ClearTime", 1209600); // 14 days default
     TC_LOG_INFO("server.loading", "Will clear `logs` table of entries older than %i seconds every %u minutes.",
         m_int_configs[CONFIG_LOGDB_CLEARTIME], m_int_configs[CONFIG_LOGDB_CLEARINTERVAL]);
 
     m_int_configs[CONFIG_SKILL_CHANCE_ORANGE] = sConfigMgr->GetIntDefault("SkillChance.Orange", 100);
     m_int_configs[CONFIG_SKILL_CHANCE_YELLOW] = sConfigMgr->GetIntDefault("SkillChance.Yellow", 75);
     m_int_configs[CONFIG_SKILL_CHANCE_GREEN]  = sConfigMgr->GetIntDefault("SkillChance.Green", 25);
     m_int_configs[CONFIG_SKILL_CHANCE_GREY]   = sConfigMgr->GetIntDefault("SkillChance.Grey", 0);
 
     m_int_configs[CONFIG_SKILL_CHANCE_MINING_STEPS]  = sConfigMgr->GetIntDefault("SkillChance.MiningSteps", 75);
     m_int_configs[CONFIG_SKILL_CHANCE_SKINNING_STEPS]   = sConfigMgr->GetIntDefault("SkillChance.SkinningSteps", 75);
 
     m_bool_configs[CONFIG_SKILL_PROSPECTING] = sConfigMgr->GetBoolDefault("SkillChance.Prospecting", false);
     m_bool_configs[CONFIG_SKILL_MILLING] = sConfigMgr->GetBoolDefault("SkillChance.Milling", false);
 
     m_int_configs[CONFIG_SKILL_GAIN_CRAFTING]  = sConfigMgr->GetIntDefault("SkillGain.Crafting", 1);
 
     m_int_configs[CONFIG_SKILL_GAIN_GATHERING]  = sConfigMgr->GetIntDefault("SkillGain.Gathering", 1);
 
     m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] = sConfigMgr->GetIntDefault("MaxOverspeedPings", 2);
 
     if (m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] != 0 && m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] < 2)
     {
         TC_LOG_ERROR("server.loading", "MaxOverspeedPings (%i) must be in range 2..infinity (or 0 to disable check). Set to 2.", m_int_configs[CONFIG_MAX_OVERSPEED_PINGS]);
         m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] = 2;
     }
 
     m_bool_configs[CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY] = sConfigMgr->GetBoolDefault("SaveRespawnTimeImmediately", true);
     if (!m_bool_configs[CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY])
     {
         TC_LOG_WARN("server.loading", "SaveRespawnTimeImmediately triggers assertions when disabled, overridden to Enabled");
         m_bool_configs[CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY] = true;
     }
 
     m_bool_configs[CONFIG_WEATHER] = sConfigMgr->GetBoolDefault("ActivateWeather", true);
 
     m_int_configs[CONFIG_DISABLE_BREATHING] = sConfigMgr->GetIntDefault("DisableWaterBreath", SEC_CONSOLE);
 
     if (reload)
     {
         uint32 val = sConfigMgr->GetIntDefault("Expansion", CURRENT_EXPANSION);
         if (val != m_int_configs[CONFIG_EXPANSION])
             TC_LOG_ERROR("server.loading", "Expansion option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_EXPANSION]);
     }
     else
         m_int_configs[CONFIG_EXPANSION] = sConfigMgr->GetIntDefault("Expansion", CURRENT_EXPANSION);
 
     m_int_configs[CONFIG_CHATFLOOD_MESSAGE_COUNT] = sConfigMgr->GetIntDefault("ChatFlood.MessageCount", 10);
     m_int_configs[CONFIG_CHATFLOOD_MESSAGE_DELAY] = sConfigMgr->GetIntDefault("ChatFlood.MessageDelay", 1);
     m_int_configs[CONFIG_CHATFLOOD_MUTE_TIME]     = sConfigMgr->GetIntDefault("ChatFlood.MuteTime", 10);
 
     m_bool_configs[CONFIG_EVENT_ANNOUNCE] = sConfigMgr->GetBoolDefault("Event.Announce", false);
 
     m_float_configs[CONFIG_CREATURE_FAMILY_FLEE_ASSISTANCE_RADIUS] = sConfigMgr->GetFloatDefault("CreatureFamilyFleeAssistanceRadius", 30.0f);
     m_float_configs[CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS] = sConfigMgr->GetFloatDefault("CreatureFamilyAssistanceRadius", 10.0f);
     m_int_configs[CONFIG_CREATURE_FAMILY_ASSISTANCE_DELAY]  = sConfigMgr->GetIntDefault("CreatureFamilyAssistanceDelay", 1500);
     m_int_configs[CONFIG_CREATURE_FAMILY_FLEE_DELAY]        = sConfigMgr->GetIntDefault("CreatureFamilyFleeDelay", 7000);
 
     m_int_configs[CONFIG_WORLD_BOSS_LEVEL_DIFF] = sConfigMgr->GetIntDefault("WorldBossLevelDiff", 3);
 
     m_bool_configs[CONFIG_QUEST_ENABLE_QUEST_TRACKER] = sConfigMgr->GetBoolDefault("Quests.EnableQuestTracker", false);
 
     // note: disable value (-1) will assigned as 0xFFFFFFF, to prevent overflow at calculations limit it to max possible player level MAX_LEVEL(100)
     m_int_configs[CONFIG_QUEST_LOW_LEVEL_HIDE_DIFF] = sConfigMgr->GetIntDefault("Quests.LowLevelHideDiff", 4);
     if (m_int_configs[CONFIG_QUEST_LOW_LEVEL_HIDE_DIFF] > MAX_LEVEL)
         m_int_configs[CONFIG_QUEST_LOW_LEVEL_HIDE_DIFF] = MAX_LEVEL;
     m_int_configs[CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF] = sConfigMgr->GetIntDefault("Quests.HighLevelHideDiff", 7);
     if (m_int_configs[CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF] > MAX_LEVEL)
         m_int_configs[CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF] = MAX_LEVEL;
     m_bool_configs[CONFIG_QUEST_IGNORE_RAID] = sConfigMgr->GetBoolDefault("Quests.IgnoreRaid", false);
     m_bool_configs[CONFIG_QUEST_IGNORE_AUTO_ACCEPT] = sConfigMgr->GetBoolDefault("Quests.IgnoreAutoAccept", false);
     m_bool_configs[CONFIG_QUEST_IGNORE_AUTO_COMPLETE] = sConfigMgr->GetBoolDefault("Quests.IgnoreAutoComplete", false);
 
     m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR] = sConfigMgr->GetIntDefault("Battleground.Random.ResetHour", 6);
     if (m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR] > 23)
     {
         TC_LOG_ERROR("server.loading", "Battleground.Random.ResetHour (%i) can't be load. Set to 6.", m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR]);
         m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR] = 6;
     }
 
     m_int_configs[CONFIG_GUILD_RESET_HOUR] = sConfigMgr->GetIntDefault("Guild.ResetHour", 6);
     if (m_int_configs[CONFIG_GUILD_RESET_HOUR] > 23)
     {
         TC_LOG_ERROR("misc", "Guild.ResetHour (%i) can't be load. Set to 6.", m_int_configs[CONFIG_GUILD_RESET_HOUR]);
         m_int_configs[CONFIG_GUILD_RESET_HOUR] = 6;
     }
 
     m_bool_configs[CONFIG_DETECT_POS_COLLISION] = sConfigMgr->GetBoolDefault("DetectPosCollision", true);
 
     m_bool_configs[CONFIG_RESTRICTED_LFG_CHANNEL]      = sConfigMgr->GetBoolDefault("Channel.RestrictedLfg", true);
     m_bool_configs[CONFIG_TALENTS_INSPECTING]           = sConfigMgr->GetBoolDefault("TalentsInspecting", true);
     m_bool_configs[CONFIG_CHAT_FAKE_MESSAGE_PREVENTING] = sConfigMgr->GetBoolDefault("ChatFakeMessagePreventing", false);
     m_int_configs[CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY] = sConfigMgr->GetIntDefault("ChatStrictLinkChecking.Severity", 0);
     m_int_configs[CONFIG_CHAT_STRICT_LINK_CHECKING_KICK] = sConfigMgr->GetIntDefault("ChatStrictLinkChecking.Kick", 0);
 
     m_int_configs[CONFIG_CORPSE_DECAY_NORMAL]    = sConfigMgr->GetIntDefault("Corpse.Decay.NORMAL", 60);
     m_int_configs[CONFIG_CORPSE_DECAY_RARE]      = sConfigMgr->GetIntDefault("Corpse.Decay.RARE", 300);
     m_int_configs[CONFIG_CORPSE_DECAY_ELITE]     = sConfigMgr->GetIntDefault("Corpse.Decay.ELITE", 300);
     m_int_configs[CONFIG_CORPSE_DECAY_RAREELITE] = sConfigMgr->GetIntDefault("Corpse.Decay.RAREELITE", 300);
     m_int_configs[CONFIG_CORPSE_DECAY_WORLDBOSS] = sConfigMgr->GetIntDefault("Corpse.Decay.WORLDBOSS", 3600);
 
     m_int_configs[CONFIG_DEATH_SICKNESS_LEVEL]           = sConfigMgr->GetIntDefault ("Death.SicknessLevel", 11);
     m_bool_configs[CONFIG_DEATH_CORPSE_RECLAIM_DELAY_PVP] = sConfigMgr->GetBoolDefault("Death.CorpseReclaimDelay.PvP", true);
     m_bool_configs[CONFIG_DEATH_CORPSE_RECLAIM_DELAY_PVE] = sConfigMgr->GetBoolDefault("Death.CorpseReclaimDelay.PvE", true);
     m_bool_configs[CONFIG_DEATH_BONES_WORLD]              = sConfigMgr->GetBoolDefault("Death.Bones.World", true);
     m_bool_configs[CONFIG_DEATH_BONES_BG_OR_ARENA]        = sConfigMgr->GetBoolDefault("Death.Bones.BattlegroundOrArena", true);
 
     m_bool_configs[CONFIG_DIE_COMMAND_MODE] = sConfigMgr->GetBoolDefault("Die.Command.Mode", true);
 
     m_float_configs[CONFIG_THREAT_RADIUS] = sConfigMgr->GetFloatDefault("ThreatRadius", 60.0f);
 
     // always use declined names in the russian client
     m_bool_configs[CONFIG_DECLINED_NAMES_USED] =
 
         (m_int_configs[CONFIG_REALM_ZONE] == REALM_ZONE_RUSSIAN) ? true : sConfigMgr->GetBoolDefault("DeclinedNames", false);
 
     m_float_configs[CONFIG_LISTEN_RANGE_SAY]       = sConfigMgr->GetFloatDefault("ListenRange.Say", 25.0f);
     m_float_configs[CONFIG_LISTEN_RANGE_TEXTEMOTE] = sConfigMgr->GetFloatDefault("ListenRange.TextEmote", 25.0f);
     m_float_configs[CONFIG_LISTEN_RANGE_YELL]      = sConfigMgr->GetFloatDefault("ListenRange.Yell", 300.0f);
 
     m_bool_configs[CONFIG_BATTLEGROUND_CAST_DESERTER]                = sConfigMgr->GetBoolDefault("Battleground.CastDeserter", true);
     m_bool_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE]       = sConfigMgr->GetBoolDefault("Battleground.QueueAnnouncer.Enable", false);
     m_bool_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY]   = sConfigMgr->GetBoolDefault("Battleground.QueueAnnouncer.PlayerOnly", false);
     m_bool_configs[CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE]      = sConfigMgr->GetBoolDefault("Battleground.StoreStatistics.Enable", false);
     m_int_configs[CONFIG_BATTLEGROUND_INVITATION_TYPE]               = sConfigMgr->GetIntDefault ("Battleground.InvitationType", 0);
     m_int_configs[CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER]        = sConfigMgr->GetIntDefault ("Battleground.PrematureFinishTimer", 5 * MINUTE * IN_MILLISECONDS);
     m_int_configs[CONFIG_BATTLEGROUND_PREMADE_GROUP_WAIT_FOR_MATCH]  = sConfigMgr->GetIntDefault ("Battleground.PremadeGroupWaitForMatch", 30 * MINUTE * IN_MILLISECONDS);
     m_bool_configs[CONFIG_BG_XP_FOR_KILL]                            = sConfigMgr->GetBoolDefault("Battleground.GiveXPForKills", false);
     m_int_configs[CONFIG_ARENA_MAX_RATING_DIFFERENCE]                = sConfigMgr->GetIntDefault ("Arena.MaxRatingDifference", 150);
     m_int_configs[CONFIG_ARENA_RATING_DISCARD_TIMER]                 = sConfigMgr->GetIntDefault ("Arena.RatingDiscardTimer", 10 * MINUTE * IN_MILLISECONDS);
     m_int_configs[CONFIG_ARENA_RATED_UPDATE_TIMER]                   = sConfigMgr->GetIntDefault ("Arena.RatedUpdateTimer", 5 * IN_MILLISECONDS);
     m_bool_configs[CONFIG_ARENA_QUEUE_ANNOUNCER_ENABLE]              = sConfigMgr->GetBoolDefault("Arena.QueueAnnouncer.Enable", false);
     m_int_configs[CONFIG_ARENA_SEASON_ID]                            = sConfigMgr->GetIntDefault ("Arena.ArenaSeason.ID", 15);
     m_int_configs[CONFIG_ARENA_START_RATING]                         = sConfigMgr->GetIntDefault ("Arena.ArenaStartRating", 0);
     m_int_configs[CONFIG_ARENA_START_PERSONAL_RATING]                = sConfigMgr->GetIntDefault ("Arena.ArenaStartPersonalRating", 1000);
     m_int_configs[CONFIG_ARENA_START_MATCHMAKER_RATING]              = sConfigMgr->GetIntDefault ("Arena.ArenaStartMatchmakerRating", 1500);
     m_bool_configs[CONFIG_ARENA_SEASON_IN_PROGRESS]                  = sConfigMgr->GetBoolDefault("Arena.ArenaSeason.InProgress", false);
     m_bool_configs[CONFIG_ARENA_LOG_EXTENDED_INFO]                   = sConfigMgr->GetBoolDefault("ArenaLog.ExtendedInfo", false);
     m_float_configs[CONFIG_ARENA_WIN_RATING_MODIFIER_1]              = sConfigMgr->GetFloatDefault("Arena.ArenaWinRatingModifier1", 48.0f);
     m_float_configs[CONFIG_ARENA_WIN_RATING_MODIFIER_2]              = sConfigMgr->GetFloatDefault("Arena.ArenaWinRatingModifier2", 24.0f);
     m_float_configs[CONFIG_ARENA_LOSE_RATING_MODIFIER]               = sConfigMgr->GetFloatDefault("Arena.ArenaLoseRatingModifier", 24.0f);
     m_float_configs[CONFIG_ARENA_MATCHMAKER_RATING_MODIFIER]         = sConfigMgr->GetFloatDefault("Arena.ArenaMatchmakerRatingModifier", 24.0f);
 
     m_bool_configs[CONFIG_OFFHAND_CHECK_AT_SPELL_UNLEARN]            = sConfigMgr->GetBoolDefault("OffhandCheckAtSpellUnlearn", true);
 
     m_int_configs[CONFIG_CREATURE_PICKPOCKET_REFILL] = sConfigMgr->GetIntDefault("Creature.PickPocketRefillDelay", 10 * MINUTE);
 
     if (int32 clientCacheId = sConfigMgr->GetIntDefault("ClientCacheVersion", 0))
     {
         // overwrite DB/old value
         if (clientCacheId > 0)
         {
             m_int_configs[CONFIG_CLIENTCACHE_VERSION] = clientCacheId;
             TC_LOG_INFO("server.loading", "Client cache version set to: %u", clientCacheId);
         }
         else
             TC_LOG_ERROR("server.loading", "ClientCacheVersion can't be negative %d, ignored.", clientCacheId);
     }
 
     m_int_configs[CONFIG_GUILD_NEWS_LOG_COUNT] = sConfigMgr->GetIntDefault("Guild.NewsLogRecordsCount", GUILD_NEWSLOG_MAX_RECORDS);
     if (m_int_configs[CONFIG_GUILD_NEWS_LOG_COUNT] > GUILD_NEWSLOG_MAX_RECORDS)
         m_int_configs[CONFIG_GUILD_NEWS_LOG_COUNT] = GUILD_NEWSLOG_MAX_RECORDS;
     m_int_configs[CONFIG_GUILD_EVENT_LOG_COUNT] = sConfigMgr->GetIntDefault("Guild.EventLogRecordsCount", GUILD_EVENTLOG_MAX_RECORDS);
     if (m_int_configs[CONFIG_GUILD_EVENT_LOG_COUNT] > GUILD_EVENTLOG_MAX_RECORDS)
         m_int_configs[CONFIG_GUILD_EVENT_LOG_COUNT] = GUILD_EVENTLOG_MAX_RECORDS;
     m_int_configs[CONFIG_GUILD_BANK_EVENT_LOG_COUNT] = sConfigMgr->GetIntDefault("Guild.BankEventLogRecordsCount", GUILD_BANKLOG_MAX_RECORDS);
     if (m_int_configs[CONFIG_GUILD_BANK_EVENT_LOG_COUNT] > GUILD_BANKLOG_MAX_RECORDS)
         m_int_configs[CONFIG_GUILD_BANK_EVENT_LOG_COUNT] = GUILD_BANKLOG_MAX_RECORDS;
 
     //visibility on continents
     m_MaxVisibleDistanceOnContinents = sConfigMgr->GetFloatDefault("Visibility.Distance.Continents", DEFAULT_VISIBILITY_DISTANCE);
     if (m_MaxVisibleDistanceOnContinents < 45*sWorld->getRate(RATE_CREATURE_AGGRO))
     {
         TC_LOG_ERROR("server.loading", "Visibility.Distance.Continents can't be less max aggro radius %f", 45*sWorld->getRate(RATE_CREATURE_AGGRO));
         m_MaxVisibleDistanceOnContinents = 45*sWorld->getRate(RATE_CREATURE_AGGRO);
     }
     else if (m_MaxVisibleDistanceOnContinents > MAX_VISIBILITY_DISTANCE)
     {
         TC_LOG_ERROR("server.loading", "Visibility.Distance.Continents can't be greater %f", MAX_VISIBILITY_DISTANCE);
         m_MaxVisibleDistanceOnContinents = MAX_VISIBILITY_DISTANCE;
     }
 
     //visibility in instances
     m_MaxVisibleDistanceInInstances = sConfigMgr->GetFloatDefault("Visibility.Distance.Instances", DEFAULT_VISIBILITY_INSTANCE);
     if (m_MaxVisibleDistanceInInstances < 45*sWorld->getRate(RATE_CREATURE_AGGRO))
     {
         TC_LOG_ERROR("server.loading", "Visibility.Distance.Instances can't be less max aggro radius %f", 45*sWorld->getRate(RATE_CREATURE_AGGRO));
         m_MaxVisibleDistanceInInstances = 45*sWorld->getRate(RATE_CREATURE_AGGRO);
     }
     else if (m_MaxVisibleDistanceInInstances > MAX_VISIBILITY_DISTANCE)
     {
         TC_LOG_ERROR("server.loading", "Visibility.Distance.Instances can't be greater %f", MAX_VISIBILITY_DISTANCE);
         m_MaxVisibleDistanceInInstances = MAX_VISIBILITY_DISTANCE;
     }
 
     //visibility in BG/Arenas
     m_MaxVisibleDistanceInBGArenas = sConfigMgr->GetFloatDefault("Visibility.Distance.BGArenas", DEFAULT_VISIBILITY_BGARENAS);
     if (m_MaxVisibleDistanceInBGArenas < 45*sWorld->getRate(RATE_CREATURE_AGGRO))
     {
         TC_LOG_ERROR("server.loading", "Visibility.Distance.BGArenas can't be less max aggro radius %f", 45*sWorld->getRate(RATE_CREATURE_AGGRO));
         m_MaxVisibleDistanceInBGArenas = 45*sWorld->getRate(RATE_CREATURE_AGGRO);
     }
     else if (m_MaxVisibleDistanceInBGArenas > MAX_VISIBILITY_DISTANCE)
     {
         TC_LOG_ERROR("server.loading", "Visibility.Distance.BGArenas can't be greater %f", MAX_VISIBILITY_DISTANCE);
         m_MaxVisibleDistanceInBGArenas = MAX_VISIBILITY_DISTANCE;
     }
 
     m_visibility_notify_periodOnContinents = sConfigMgr->GetIntDefault("Visibility.Notify.Period.OnContinents", DEFAULT_VISIBILITY_NOTIFY_PERIOD);
     m_visibility_notify_periodInInstances = sConfigMgr->GetIntDefault("Visibility.Notify.Period.InInstances",   DEFAULT_VISIBILITY_NOTIFY_PERIOD);
     m_visibility_notify_periodInBGArenas = sConfigMgr->GetIntDefault("Visibility.Notify.Period.InBGArenas",    DEFAULT_VISIBILITY_NOTIFY_PERIOD);
 
     m_int_configs[CONFIG_CHARDELETE_METHOD] = sConfigMgr->GetIntDefault("CharDelete.Method", 0);
     m_int_configs[CONFIG_CHARDELETE_MIN_LEVEL] = sConfigMgr->GetIntDefault("CharDelete.MinLevel", 0);
     m_int_configs[CONFIG_CHARDELETE_HEROIC_MIN_LEVEL] = sConfigMgr->GetIntDefault("CharDelete.Heroic.MinLevel", 0);
     m_int_configs[CONFIG_CHARDELETE_KEEP_DAYS] = sConfigMgr->GetIntDefault("CharDelete.KeepDays", 30);
 
     // No aggro from gray mobs
     m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE] = sConfigMgr->GetIntDefault("NoGrayAggro.Above", 0);
     m_int_configs[CONFIG_NO_GRAY_AGGRO_BELOW] = sConfigMgr->GetIntDefault("NoGrayAggro.Below", 0);
     if (m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE] > m_int_configs[CONFIG_MAX_PLAYER_LEVEL])
     {
        TC_LOG_ERROR("server.loading", "NoGrayAggro.Above (%i) must be in range 0..%u. Set to %u.", m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE], m_int_configs[CONFIG_MAX_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL]);
        m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE] = m_int_configs[CONFIG_MAX_PLAYER_LEVEL];
     }
     if (m_int_configs[CONFIG_NO_GRAY_AGGRO_BELOW] > m_int_configs[CONFIG_MAX_PLAYER_LEVEL])
     {
        TC_LOG_ERROR("server.loading", "NoGrayAggro.Below (%i) must be in range 0..%u. Set to %u.", m_int_configs[CONFIG_NO_GRAY_AGGRO_BELOW], m_int_configs[CONFIG_MAX_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL]);
        m_int_configs[CONFIG_NO_GRAY_AGGRO_BELOW] = m_int_configs[CONFIG_MAX_PLAYER_LEVEL];
     }
     if (m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE] > 0 && m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE] < m_int_configs[CONFIG_NO_GRAY_AGGRO_BELOW])
     {
        TC_LOG_ERROR("server.loading", "NoGrayAggro.Below (%i) cannot be greater than NoGrayAggro.Above (%i). Set to %i.", m_int_configs[CONFIG_NO_GRAY_AGGRO_BELOW], m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE], m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE]);
        m_int_configs[CONFIG_NO_GRAY_AGGRO_BELOW] = m_int_configs[CONFIG_NO_GRAY_AGGRO_ABOVE];
     }
 
     std::string dataPath = sConfigMgr->GetStringDefault("DataDir", "./");
     if (dataPath.empty() || (dataPath.at(dataPath.length()-1) != '/' && dataPath.at(dataPath.length()-1) != '\\'))
         dataPath.push_back('/');
 
 #if PLATFORM == PLATFORM_UNIX || PLATFORM == PLATFORM_APPLE
     if (dataPath[0] == '~')
     {
         const char* home = getenv("HOME");
         if (home)
             dataPath.replace(0, 1, home);
     }
 #endif
 
     if (reload)
     {
         if (dataPath != m_dataPath)
             TC_LOG_ERROR("server.loading", "DataDir option can't be changed at worldserver.conf reload, using current value (%s).", m_dataPath.c_str());
     }
     else
     {
         m_dataPath = dataPath;
         TC_LOG_INFO("server.loading", "Using DataDir %s", m_dataPath.c_str());
     }
 
     m_bool_configs[CONFIG_ENABLE_MMAPS] = sConfigMgr->GetBoolDefault("mmap.enablePathFinding", false);
     TC_LOG_INFO("server.loading", "WORLD: MMap data directory is: %smmaps", m_dataPath.c_str());
 
     m_bool_configs[CONFIG_VMAP_INDOOR_CHECK] = sConfigMgr->GetBoolDefault("vmap.enableIndoorCheck", 0);
     bool enableIndoor = sConfigMgr->GetBoolDefault("vmap.enableIndoorCheck", true);
     bool enableLOS = sConfigMgr->GetBoolDefault("vmap.enableLOS", true);
     bool enableHeight = sConfigMgr->GetBoolDefault("vmap.enableHeight", true);
 
     if (!enableHeight)
         TC_LOG_ERROR("server.loading", "VMap height checking disabled! Creatures movements and other various things WILL be broken! Expect no support.");
 
     VMAP::VMapFactory::createOrGetVMapManager()->setEnableLineOfSightCalc(enableLOS);
     VMAP::VMapFactory::createOrGetVMapManager()->setEnableHeightCalc(enableHeight);
     TC_LOG_INFO("server.loading", "VMap support included. LineOfSight: %i, getHeight: %i, indoorCheck: %i", enableLOS, enableHeight, enableIndoor);
     TC_LOG_INFO("server.loading", "VMap data directory is: %svmaps", m_dataPath.c_str());
 
     m_int_configs[CONFIG_MAX_WHO] = sConfigMgr->GetIntDefault("MaxWhoListReturns", 49);
     m_bool_configs[CONFIG_START_ALL_SPELLS] = sConfigMgr->GetBoolDefault("PlayerStart.AllSpells", false);
     if (m_bool_configs[CONFIG_START_ALL_SPELLS])
         TC_LOG_WARN("server.loading", "PlayerStart.AllSpells enabled - may not function as intended!");
     m_int_configs[CONFIG_HONOR_AFTER_DUEL] = sConfigMgr->GetIntDefault("HonorPointsAfterDuel", 0);
     m_bool_configs[CONFIG_RESET_DUEL_COOLDOWNS] = sConfigMgr->GetBoolDefault("ResetDuelCooldowns", false);
     m_bool_configs[CONFIG_RESET_DUEL_HEALTH_MANA] = sConfigMgr->GetBoolDefault("ResetDuelHealthMana", false);
     m_bool_configs[CONFIG_START_ALL_EXPLORED] = sConfigMgr->GetBoolDefault("PlayerStart.MapsExplored", false);
     m_bool_configs[CONFIG_START_ALL_REP] = sConfigMgr->GetBoolDefault("PlayerStart.AllReputation", false);
     m_bool_configs[CONFIG_ALWAYS_MAXSKILL] = sConfigMgr->GetBoolDefault("AlwaysMaxWeaponSkill", false);
     m_bool_configs[CONFIG_PVP_TOKEN_ENABLE] = sConfigMgr->GetBoolDefault("PvPToken.Enable", false);
     m_int_configs[CONFIG_PVP_TOKEN_MAP_TYPE] = sConfigMgr->GetIntDefault("PvPToken.MapAllowType", 4);
     m_int_configs[CONFIG_PVP_TOKEN_ID] = sConfigMgr->GetIntDefault("PvPToken.ItemID", 29434);
     m_int_configs[CONFIG_PVP_TOKEN_COUNT] = sConfigMgr->GetIntDefault("PvPToken.ItemCount", 1);
     if (m_int_configs[CONFIG_PVP_TOKEN_COUNT] < 1)
         m_int_configs[CONFIG_PVP_TOKEN_COUNT] = 1;
 
     m_bool_configs[CONFIG_ALLOW_TRACK_BOTH_RESOURCES] = sConfigMgr->GetBoolDefault("AllowTrackBothResources", false);
     m_bool_configs[CONFIG_NO_RESET_TALENT_COST] = sConfigMgr->GetBoolDefault("NoResetTalentsCost", false);
     m_bool_configs[CONFIG_SHOW_KICK_IN_WORLD] = sConfigMgr->GetBoolDefault("ShowKickInWorld", false);
     m_bool_configs[CONFIG_SHOW_MUTE_IN_WORLD] = sConfigMgr->GetBoolDefault("ShowMuteInWorld", false);
     m_bool_configs[CONFIG_SHOW_BAN_IN_WORLD] = sConfigMgr->GetBoolDefault("ShowBanInWorld", false);
     m_int_configs[CONFIG_INTERVAL_LOG_UPDATE] = sConfigMgr->GetIntDefault("RecordUpdateTimeDiffInterval", 60000);
     m_int_configs[CONFIG_MIN_LOG_UPDATE] = sConfigMgr->GetIntDefault("MinRecordUpdateTimeDiff", 100);
     m_int_configs[CONFIG_NUMTHREADS] = sConfigMgr->GetIntDefault("MapUpdate.Threads", 1);
     m_int_configs[CONFIG_MAX_RESULTS_LOOKUP_COMMANDS] = sConfigMgr->GetIntDefault("Command.LookupMaxResults", 0);
 
     // Warden
     m_bool_configs[CONFIG_WARDEN_ENABLED]              = sConfigMgr->GetBoolDefault("Warden.Enabled", false);
     m_int_configs[CONFIG_WARDEN_NUM_MEM_CHECKS]        = sConfigMgr->GetIntDefault("Warden.NumMemChecks", 3);
     m_int_configs[CONFIG_WARDEN_NUM_OTHER_CHECKS]      = sConfigMgr->GetIntDefault("Warden.NumOtherChecks", 7);
     m_int_configs[CONFIG_WARDEN_CLIENT_BAN_DURATION]   = sConfigMgr->GetIntDefault("Warden.BanDuration", 86400);
     m_int_configs[CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF]  = sConfigMgr->GetIntDefault("Warden.ClientCheckHoldOff", 30);
     m_int_configs[CONFIG_WARDEN_CLIENT_FAIL_ACTION]    = sConfigMgr->GetIntDefault("Warden.ClientCheckFailAction", 0);
     m_int_configs[CONFIG_WARDEN_CLIENT_RESPONSE_DELAY] = sConfigMgr->GetIntDefault("Warden.ClientResponseDelay", 600);
 
     // Feature System
     m_bool_configs[CONFIG_FEATURE_SYSTEM_BPAY_STORE_ENABLED]         = sConfigMgr->GetBoolDefault("FeatureSystem.BpayStore.Enabled", false);
     m_bool_configs[CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_ENABLED] = sConfigMgr->GetBoolDefault("FeatureSystem.CharacterUndelete.Enabled", false);
     m_int_configs[CONFIG_FEATURE_SYSTEM_CHARACTER_UNDELETE_COOLDOWN] = sConfigMgr->GetIntDefault("FeatureSystem.CharacterUndelete.Cooldown", 2592000);
 
     // Dungeon finder
     m_int_configs[CONFIG_LFG_OPTIONSMASK] = sConfigMgr->GetIntDefault("DungeonFinder.OptionsMask", 1);
 
     // DBC_ItemAttributes
     m_bool_configs[CONFIG_DBC_ENFORCE_ITEM_ATTRIBUTES] = sConfigMgr->GetBoolDefault("DBC.EnforceItemAttributes", true);
 
     // Accountpassword Secruity
     m_int_configs[CONFIG_ACC_PASSCHANGESEC] = sConfigMgr->GetIntDefault("Account.PasswordChangeSecurity", 0);
 
     // Random Battleground Rewards
     m_int_configs[CONFIG_BG_REWARD_WINNER_HONOR_FIRST] = sConfigMgr->GetIntDefault("Battleground.RewardWinnerHonorFirst", 27000);
     m_int_configs[CONFIG_BG_REWARD_WINNER_CONQUEST_FIRST] = sConfigMgr->GetIntDefault("Battleground.RewardWinnerConquestFirst", 10000);
     m_int_configs[CONFIG_BG_REWARD_WINNER_HONOR_LAST]  = sConfigMgr->GetIntDefault("Battleground.RewardWinnerHonorLast", 13500);
     m_int_configs[CONFIG_BG_REWARD_WINNER_CONQUEST_LAST]  = sConfigMgr->GetIntDefault("Battleground.RewardWinnerConquestLast", 5000);
     m_int_configs[CONFIG_BG_REWARD_LOSER_HONOR_FIRST]  = sConfigMgr->GetIntDefault("Battleground.RewardLoserHonorFirst", 4500);
     m_int_configs[CONFIG_BG_REWARD_LOSER_HONOR_LAST]   = sConfigMgr->GetIntDefault("Battleground.RewardLoserHonorLast", 3500);
 
     // Max instances per hour
     m_int_configs[CONFIG_MAX_INSTANCES_PER_HOUR] = sConfigMgr->GetIntDefault("AccountInstancesPerHour", 5);
 
     // Anounce reset of instance to whole party
     m_bool_configs[CONFIG_INSTANCES_RESET_ANNOUNCE] = sConfigMgr->GetBoolDefault("InstancesResetAnnounce", false);
 
     // AutoBroadcast
     m_bool_configs[CONFIG_AUTOBROADCAST] = sConfigMgr->GetBoolDefault("AutoBroadcast.On", false);
     m_int_configs[CONFIG_AUTOBROADCAST_CENTER] = sConfigMgr->GetIntDefault("AutoBroadcast.Center", 0);
     m_int_configs[CONFIG_AUTOBROADCAST_INTERVAL] = sConfigMgr->GetIntDefault("AutoBroadcast.Timer", 60000);
     if (reload)
     {
         m_timers[WUPDATE_AUTOBROADCAST].SetInterval(m_int_configs[CONFIG_AUTOBROADCAST_INTERVAL]);
         m_timers[WUPDATE_AUTOBROADCAST].Reset();
     }
 
     // MySQL ping time interval
     m_int_configs[CONFIG_DB_PING_INTERVAL] = sConfigMgr->GetIntDefault("MaxPingTime", 30);
 
     // Guild save interval
     m_int_configs[CONFIG_GUILD_SAVE_INTERVAL] = sConfigMgr->GetIntDefault("Guild.SaveInterval", 15);
     m_int_configs[CONFIG_GUILD_UNDELETABLE_LEVEL] = sConfigMgr->GetIntDefault("Guild.UndeletableLevel", 4);
 
     // misc
     m_bool_configs[CONFIG_PDUMP_NO_PATHS] = sConfigMgr->GetBoolDefault("PlayerDump.DisallowPaths", true);
     m_bool_configs[CONFIG_PDUMP_NO_OVERWRITE] = sConfigMgr->GetBoolDefault("PlayerDump.DisallowOverwrite", true);
     m_bool_configs[CONFIG_UI_QUESTLEVELS_IN_DIALOGS] = sConfigMgr->GetBoolDefault("UI.ShowQuestLevelsInDialogs", false);
 
     // Wintergrasp battlefield
     m_bool_configs[CONFIG_WINTERGRASP_ENABLE] = sConfigMgr->GetBoolDefault("Wintergrasp.Enable", false);
     m_int_configs[CONFIG_WINTERGRASP_PLR_MAX] = sConfigMgr->GetIntDefault("Wintergrasp.PlayerMax", 100);
     m_int_configs[CONFIG_WINTERGRASP_PLR_MIN] = sConfigMgr->GetIntDefault("Wintergrasp.PlayerMin", 0);
     m_int_configs[CONFIG_WINTERGRASP_PLR_MIN_LVL] = sConfigMgr->GetIntDefault("Wintergrasp.PlayerMinLvl", 77);
     m_int_configs[CONFIG_WINTERGRASP_BATTLETIME] = sConfigMgr->GetIntDefault("Wintergrasp.BattleTimer", 30);
     m_int_configs[CONFIG_WINTERGRASP_NOBATTLETIME] = sConfigMgr->GetIntDefault("Wintergrasp.NoBattleTimer", 150);
     m_int_configs[CONFIG_WINTERGRASP_RESTART_AFTER_CRASH] = sConfigMgr->GetIntDefault("Wintergrasp.CrashRestartTimer", 10);
 
     // Stats limits
     m_bool_configs[CONFIG_STATS_LIMITS_ENABLE] = sConfigMgr->GetBoolDefault("Stats.Limits.Enable", false);
     m_float_configs[CONFIG_STATS_LIMITS_DODGE] = sConfigMgr->GetFloatDefault("Stats.Limits.Dodge", 95.0f);
     m_float_configs[CONFIG_STATS_LIMITS_PARRY] = sConfigMgr->GetFloatDefault("Stats.Limits.Parry", 95.0f);
     m_float_configs[CONFIG_STATS_LIMITS_BLOCK] = sConfigMgr->GetFloatDefault("Stats.Limits.Block", 95.0f);
     m_float_configs[CONFIG_STATS_LIMITS_CRIT] = sConfigMgr->GetFloatDefault("Stats.Limits.Crit", 95.0f);
 
     //packet spoof punishment
     m_int_configs[CONFIG_PACKET_SPOOF_POLICY] = sConfigMgr->GetIntDefault("PacketSpoof.Policy", (uint32)WorldSession::DosProtection::POLICY_KICK);
     m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] = sConfigMgr->GetIntDefault("PacketSpoof.BanMode", (uint32)BAN_ACCOUNT);
     if (m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] == BAN_CHARACTER || m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] > BAN_IP)
         m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] = BAN_ACCOUNT;
 
     m_int_configs[CONFIG_PACKET_SPOOF_BANDURATION] = sConfigMgr->GetIntDefault("PacketSpoof.BanDuration", 86400);
 
     m_bool_configs[CONFIG_IP_BASED_ACTION_LOGGING] = sConfigMgr->GetBoolDefault("Allow.IP.Based.Action.Logging", false);
 
     // AHBot
     m_int_configs[CONFIG_AHBOT_UPDATE_INTERVAL] = sConfigMgr->GetIntDefault("AuctionHouseBot.Update.Interval", 20);
 
     m_bool_configs[CONFIG_CALCULATE_CREATURE_ZONE_AREA_DATA] = sConfigMgr->GetBoolDefault("Calculate.Creature.Zone.Area.Data", false);
     m_bool_configs[CONFIG_CALCULATE_GAMEOBJECT_ZONE_AREA_DATA] = sConfigMgr->GetBoolDefault("Calculate.Gameoject.Zone.Area.Data", false);
 
     // call ScriptMgr if we're reloading the configuration
     if (reload)
         sScriptMgr->OnConfigLoad(reload);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::LoadDBAllowedSecurityLevel ( )

 {
     PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_REALMLIST_SECURITY_LEVEL);
     stmt->setInt32(0, int32(realm.Id.Realm));
     PreparedQueryResult result = LoginDatabase.Query(stmt);
 
     if (result)
         SetPlayerSecurityLimit(AccountTypes(result->Fetch()->GetUInt8()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::LoadDBVersion ( )

 {
     QueryResult result = WorldDatabase.Query("SELECT db_version, cache_id FROM version LIMIT 1");
     if (result)
     {
         Field* fields = result->Fetch();
 
         m_DBVersion = fields[0].GetString();
         // will be overwrite by config values if different and non-0
         m_int_configs[CONFIG_CLIENTCACHE_VERSION] = fields[1].GetUInt32();
     }
 
     if (m_DBVersion.empty())
         m_DBVersion = "Unknown world database.";
 }

Here is the call graph for this function:

void World::LoadWorldStates ( )

 {
     uint32 oldMSTime = getMSTime();
 
     QueryResult result = CharacterDatabase.Query("SELECT entry, value FROM worldstates");
 
     if (!result)
     {
         TC_LOG_INFO("server.loading", ">> Loaded 0 world states. DB table `worldstates` is empty!");
 
         return;
     }
 
     uint32 count = 0;
 
     do
     {
         Field* fields = result->Fetch();
         m_worldstates[fields[0].GetUInt32()] = fields[1].GetUInt32();
         ++count;
     }
     while (result->NextRow());
 
     TC_LOG_INFO("server.loading", ">> Loaded %u world states in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ProcessCliCommands ( )

 {
     CliCommandHolder::Print* zprint = NULL;
     void* callbackArg = NULL;
     CliCommandHolder* command = NULL;
     while (cliCmdQueue.next(command))
     {
         TC_LOG_INFO("misc", "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;
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ProcessLinkInstanceSocket ( std::pair< std::weak_ptr< WorldSocket >, uint64 > linkInfo )

private

 {
     if (std::shared_ptr<WorldSocket> sock = linkInfo.first.lock())
     {
         if (!sock->IsOpen())
             return;
 
         WorldSession::ConnectToKey key;
         key.Raw = linkInfo.second;
 
         WorldSession* session = FindSession(uint32(key.Fields.AccountId));
         if (!session || session->GetConnectToInstanceKey() != linkInfo.second)
         {
             sock->SendAuthResponseError(ERROR_TIMED_OUT);
             sock->DelayedCloseSocket();
             return;
         }
 
         sock->SetWorldSession(session);
         session->AddInstanceConnection(sock);
         session->HandleContinuePlayerLogin();
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ProcessQueryCallbacks ( )

private

 {
     PreparedQueryResult result;
 
     for (std::deque<PreparedQueryResultFuture>::iterator itr = m_realmCharCallbacks.begin(); itr != m_realmCharCallbacks.end(); )
     {
         if ((*itr).wait_for(std::chrono::seconds(0)) != std::future_status::ready)
         {
             ++itr;
             continue;
         }
 
         result = (*itr).get();
         _UpdateRealmCharCount(result);
         itr = m_realmCharCallbacks.erase(itr);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::QueueCliCommand ( CliCommandHolder * commandHolder )

inline

738 { cliCmdQueue.add(commandHolder); }

LockedQueue::add

void add(const T &item)

Adds an item to the queue.

Definition: LockedQueue.h:51

World::cliCmdQueue

LockedQueue< CliCommandHolder * > cliCmdQueue

Definition: World.h:846

void World::RecordTimeDiff ( std::string const & text )

 {
     if (m_updateTimeCount != 1)
         return;
 
     uint32 thisTime = getMSTime();
     uint32 diff = getMSTimeDiff(m_currentTime, thisTime);
 
     if (diff > m_int_configs[CONFIG_MIN_LOG_UPDATE])
         TC_LOG_INFO("misc", "Difftime %s: %u.", text.c_str(), diff);
 
     m_currentTime = thisTime;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ReloadRBAC ( )

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

bool World::RemoveBanAccount	(	BanMode	mode,
		std::string const &	nameOrIP
	)

Remove a ban from an account or IP address.

 {
     PreparedStatement* stmt = NULL;
     if (mode == BAN_IP)
     {
         stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_IP_NOT_BANNED);
         stmt->setString(0, nameOrIP);
         LoginDatabase.Execute(stmt);
     }
     else
     {
         uint32 account = 0;
         if (mode == BAN_ACCOUNT)
             account = AccountMgr::GetId(nameOrIP);
         else if (mode == BAN_CHARACTER)
             account = ObjectMgr::GetPlayerAccountIdByPlayerName(nameOrIP);
 
         if (!account)
             return false;
 
         //NO SQL injection as account is uint32
         stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_ACCOUNT_NOT_BANNED);
         stmt->setUInt32(0, account);
         LoginDatabase.Execute(stmt);
     }
     return true;
 }

Here is the call graph for this function:

bool World::RemoveBanCharacter ( std::string const & name )

Remove a ban from a character.

Pick a player to ban if not online

 {
     Player* pBanned = ObjectAccessor::FindConnectedPlayerByName(name);
     ObjectGuid guid;
 
     if (!pBanned)
     {
         guid = ObjectMgr::GetPlayerGUIDByName(name);
         if (guid.IsEmpty())
             return false;                                    // Nobody to ban
     }
     else
         guid = pBanned->GetGUID();
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_CHARACTER_BAN);
     stmt->setUInt64(0, guid.GetCounter());
     CharacterDatabase.Execute(stmt);
     return true;
 }

Here is the call graph for this function:

void World::RemoveOldCorpses ( )

 {
     m_timers[WUPDATE_CORPSES].SetCurrent(m_timers[WUPDATE_CORPSES].GetInterval());
 }

Here is the call graph for this function:

bool World::RemoveQueuedPlayer ( WorldSession * session )

 {
     // sessions count including queued to remove (if removed_session set)
     uint32 sessions = GetActiveSessionCount();
 
     uint32 position = 1;
     Queue::iterator iter = m_QueuedPlayer.begin();
 
     // search to remove and count skipped positions
     bool found = false;
 
     for (; iter != m_QueuedPlayer.end(); ++iter, ++position)
     {
         if (*iter == sess)
         {
             sess->SetInQueue(false);
             sess->ResetTimeOutTime();
             iter = m_QueuedPlayer.erase(iter);
             found = true;                                   // removing queued session
             break;
         }
     }
 
     // iter point to next socked after removed or end()
     // position store position of removed socket and then new position next socket after removed
 
     // if session not queued then we need decrease sessions count
     if (!found && sessions)
         --sessions;
 
     // accept first in queue
     if ((!m_playerLimit || sessions < m_playerLimit) && !m_QueuedPlayer.empty())
     {
         WorldSession* pop_sess = m_QueuedPlayer.front();
         pop_sess->InitializeSession();
         m_QueuedPlayer.pop_front();
 
         // update iter to point first queued socket or end() if queue is empty now
         iter = m_QueuedPlayer.begin();
         position = 1;
     }
 
     // update position from iter to end()
     // iter point to first not updated socket, position store new position
     for (; iter != m_QueuedPlayer.end(); ++iter, ++position)
         (*iter)->SendAuthWaitQue(position);
 
     return found;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool World::RemoveSession ( uint32 id )

Remove a given session.

Find the session, kick the user, but we can't delete session at this moment to prevent iterator invalidation

 {
     SessionMap::const_iterator itr = m_sessions.find(id);
 
     if (itr != m_sessions.end() && itr->second)
     {
         if (itr->second->PlayerLoading())
             return false;
 
         itr->second->KickPlayer();
     }
 
     return true;
 }

Here is the caller graph for this function:

void World::ResetCurrencyWeekCap ( )

protected

 {
     CharacterDatabase.Execute("UPDATE `character_currency` SET `WeeklyQuantity` = 0");
 
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
         if (itr->second->GetPlayer())
             itr->second->GetPlayer()->ResetCurrencyWeekCap();
 
     m_NextCurrencyReset = time_t(m_NextCurrencyReset + DAY * getIntConfig(CONFIG_CURRENCY_RESET_INTERVAL));
     sWorld->setWorldState(WS_CURRENCY_RESET_TIME, uint64(m_NextCurrencyReset));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ResetEventSeasonalQuests ( uint16 event_id )

 {
     TC_LOG_INFO("misc", "Seasonal quests reset for all characters.");
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RESET_CHARACTER_QUESTSTATUS_SEASONAL_BY_EVENT);
     stmt->setUInt16(0, event_id);
     CharacterDatabase.Execute(stmt);
 
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
         if (itr->second->GetPlayer())
             itr->second->GetPlayer()->ResetSeasonalQuestStatus(event_id);
 }

Here is the call graph for this function:

void World::ResetGuildCap ( )

protected

 {
     m_NextGuildReset = time_t(m_NextGuildReset + DAY);
     sWorld->setWorldState(WS_GUILD_DAILY_RESET_TIME, uint64(m_NextGuildReset));
     uint32 week = getWorldState(WS_GUILD_WEEKLY_RESET_TIME);
     week = week < 7 ? week + 1 : 1;
 
     TC_LOG_INFO("misc", "Guild Daily Cap reset. Week: %u", week == 1);
     sWorld->setWorldState(WS_GUILD_WEEKLY_RESET_TIME, week);
     sGuildMgr->ResetTimes(week == 1);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ResetMonthlyQuests ( )

protected

 {
     TC_LOG_INFO("misc", "Monthly quests reset for all characters.");
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RESET_CHARACTER_QUESTSTATUS_MONTHLY);
     CharacterDatabase.Execute(stmt);
 
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
         if (itr->second->GetPlayer())
             itr->second->GetPlayer()->ResetMonthlyQuestStatus();
 
     // generate time
     time_t curTime = time(NULL);
     tm localTm;
     localtime_r(&curTime, &localTm);
 
     int month   = localTm.tm_mon;
     int year    = localTm.tm_year;
 
     ++month;
 
     // month 11 is december, next is january (0)
     if (month > 11)
     {
         month = 0;
         year += 1;
     }
 
     // reset time for next month
     localTm.tm_year     = year;
     localTm.tm_mon      = month;
     localTm.tm_mday     = 1;        // don't know if we really need config option for day / hour
     localTm.tm_hour     = 0;
     localTm.tm_min      = 0;
     localTm.tm_sec      = 0;
 
     time_t nextMonthResetTime = mktime(&localTm);
 
     // plan next reset time
     m_NextMonthlyQuestReset = (curTime >= nextMonthResetTime) ? nextMonthResetTime + MONTH : nextMonthResetTime;
 
     sWorld->setWorldState(WS_MONTHLY_QUEST_RESET_TIME, uint64(m_NextMonthlyQuestReset));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ResetRandomBG ( )

protected

 {
     TC_LOG_INFO("misc", "Random BG status reset for all characters.");
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_BATTLEGROUND_RANDOM_ALL);
     CharacterDatabase.Execute(stmt);
 
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
         if (itr->second->GetPlayer())
             itr->second->GetPlayer()->SetRandomWinner(false);
 
     m_NextRandomBGReset = time_t(m_NextRandomBGReset + DAY);
     sWorld->setWorldState(WS_BG_DAILY_RESET_TIME, uint64(m_NextRandomBGReset));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ResetTimeDiffRecord ( )

 {
     if (m_updateTimeCount != 1)
         return;
 
     m_currentTime = getMSTime();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::ResetWeeklyQuests ( )

protected

 {
     TC_LOG_INFO("misc", "Weekly quests reset for all characters.");
 
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_DEL_RESET_CHARACTER_QUESTSTATUS_WEEKLY);
     CharacterDatabase.Execute(stmt);
 
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
         if (itr->second->GetPlayer())
             itr->second->GetPlayer()->ResetWeeklyQuestStatus();
 
     m_NextWeeklyQuestReset = time_t(m_NextWeeklyQuestReset + WEEK);
     sWorld->setWorldState(WS_WEEKLY_QUEST_RESET_TIME, uint64(m_NextWeeklyQuestReset));
 
     // change available weeklies
     sPoolMgr->ChangeWeeklyQuests();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::SendAutoBroadcast ( )

 {
     if (m_Autobroadcasts.empty())
         return;
 
     uint32 weight = 0;
     AutobroadcastsWeightMap selectionWeights;
     std::string msg;
 
     for (AutobroadcastsWeightMap::const_iterator it = m_AutobroadcastsWeights.begin(); it != m_AutobroadcastsWeights.end(); ++it)
     {
         if (it->second)
         {
             weight += it->second;
             selectionWeights[it->first] = it->second;
         }
     }
 
     if (weight)
     {
         uint32 selectedWeight = urand(0, weight - 1);
         weight = 0;
         for (AutobroadcastsWeightMap::const_iterator it = selectionWeights.begin(); it != selectionWeights.end(); ++it)
         {
             weight += it->second;
             if (selectedWeight < weight)
             {
                 msg = m_Autobroadcasts[it->first];
                 break;
             }
         }
     }
     else
         msg = m_Autobroadcasts[urand(0, m_Autobroadcasts.size())];
 
     uint32 abcenter = sWorld->getIntConfig(CONFIG_AUTOBROADCAST_CENTER);
 
     if (abcenter == 0)
         sWorld->SendWorldText(LANG_AUTO_BROADCAST, msg.c_str());
     else if (abcenter == 1)
         sWorld->SendGlobalMessage(WorldPackets::Chat::PrintNotification(msg).Write());
     else if (abcenter == 2)
     {
         sWorld->SendWorldText(LANG_AUTO_BROADCAST, msg.c_str());
         sWorld->SendGlobalMessage(WorldPackets::Chat::PrintNotification(msg).Write());
     }
 
     TC_LOG_DEBUG("misc", "AutoBroadcast: '%s'", msg.c_str());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::SendGlobalGMMessage	(	WorldPacket const *	packet,
		WorldSession *	self = `nullptr`,
		uint32	team = `0`
	)

Send a packet to all GMs (except self if mentioned)

 {
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
     {
         // check if session and can receive global GM Messages and its not self
         WorldSession* session = itr->second;
         if (!session || session == self || !session->HasPermission(rbac::RBAC_PERM_RECEIVE_GLOBAL_GM_TEXTMESSAGE))
             continue;
 
         // Player should be in world
         Player* player = session->GetPlayer();
         if (!player || !player->IsInWorld())
             continue;
 
         // Send only to same team, if team is given
         if (!team || player->GetTeam() == team)
             session->SendPacket(packet);
     }
 }

Here is the call graph for this function:

void World::SendGlobalMessage	(	WorldPacket const *	packet,
		WorldSession *	self = `nullptr`,
		uint32	team = `0`
	)

Send a packet to all players (except self if mentioned)

 {
     SessionMap::const_iterator itr;
     for (itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
     {
         if (itr->second &&
             itr->second->GetPlayer() &&
             itr->second->GetPlayer()->IsInWorld() &&
             itr->second != self &&
             (team == 0 || itr->second->GetPlayer()->GetTeam() == team))
         {
             itr->second->SendPacket(packet);
         }
     }
 }

Here is the caller graph for this function:

void World::SendGlobalText	(	const char *	text,
		WorldSession *	self
	)

DEPRECATED, only for debug purpose. Send a System Message to all players (except self if mentioned)

 {
     // need copy to prevent corruption by strtok call in LineFromMessage original string
     char* buf = strdup(text);
     char* pos = buf;
 
     while (char* line = ChatHandler::LineFromMessage(pos))
     {
         WorldPackets::Chat::Chat packet;
         packet.Initialize(CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, line);
         SendGlobalMessage(packet.Write(), self);
     }
 
     free(buf);
 }

Here is the call graph for this function:

void World::SendGMText	(	uint32	string_id,
			...
	)

Send a System Message to all GMs (except self if mentioned)

 {
     va_list ap;
     va_start(ap, string_id);
 
     Trinity::WorldWorldTextBuilder wt_builder(string_id, &ap);
     Trinity::LocalizedPacketListDo<Trinity::WorldWorldTextBuilder> wt_do(wt_builder);
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
     {
         // Session should have permissions to receive global gm messages
         WorldSession* session = itr->second;
         if (!session || !session->HasPermission(rbac::RBAC_PERM_RECEIVE_GLOBAL_GM_TEXTMESSAGE))
             continue;
 
         // Player should be in world
         Player* player = session->GetPlayer();
         if (!player || !player->IsInWorld())
             continue;
 
         wt_do(player);
     }
 
     va_end(ap);
 }

Here is the call graph for this function:

void World::SendServerMessage	(	ServerMessageType	messageID,
		std::string	stringParam = `""`,
		Player *	player = `NULL`
	)

Send a server message to the user(s)

 {
     WorldPackets::Chat::ChatServerMessage chatServerMessage;
     chatServerMessage.MessageID = int32(messageID);
     if (messageID <= SERVER_MSG_STRING)
         chatServerMessage.StringParam = stringParam;
 
     if (player)
         player->GetSession()->SendPacket(chatServerMessage.Write());
     else
         SendGlobalMessage(chatServerMessage.Write());
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::SendWorldText	(	uint32	string_id,
			...
	)

Send a System Message to all players (except self if mentioned)

 {
     va_list ap;
     va_start(ap, string_id);
 
     Trinity::WorldWorldTextBuilder wt_builder(string_id, &ap);
     Trinity::LocalizedPacketListDo<Trinity::WorldWorldTextBuilder> wt_do(wt_builder);
     for (SessionMap::const_iterator itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
     {
         if (!itr->second || !itr->second->GetPlayer() || !itr->second->GetPlayer()->IsInWorld())
             continue;
 
         wt_do(itr->second->GetPlayer());
     }
 
     va_end(ap);
 }

bool World::SendZoneMessage	(	uint32	zone,
		WorldPacket const *	packet,
		WorldSession *	self = `nullptr`,
		uint32	team = `0`
	)

Send a packet to all players (or players selected team) in the zone (except self if mentioned)

 {
     bool foundPlayerToSend = false;
     SessionMap::const_iterator itr;
 
     for (itr = m_sessions.begin(); itr != m_sessions.end(); ++itr)
     {
         if (itr->second &&
             itr->second->GetPlayer() &&
             itr->second->GetPlayer()->IsInWorld() &&
             itr->second->GetPlayer()->GetZoneId() == zone &&
             itr->second != self &&
             (team == 0 || itr->second->GetPlayer()->GetTeam() == team))
         {
             itr->second->SendPacket(packet);
             foundPlayerToSend = true;
         }
     }
 
     return foundPlayerToSend;
 }

Here is the caller graph for this function:

void World::SendZoneText	(	uint32	zone,
		const char *	text,
		WorldSession *	self = `nullptr`,
		uint32	team = `0`
	)

Send a System Message to all players in the zone (except self if mentioned)

 {
     WorldPackets::Chat::Chat packet;
     packet.Initialize(CHAT_MSG_SYSTEM, LANG_UNIVERSAL, nullptr, nullptr, text);
     SendZoneMessage(zone, packet.Write(), self, team);
 }

Here is the call graph for this function:

void World::SetAllowMovement ( bool allow )

inline

Allow/Disallow object movements.

604 { m_allowMovement = allow; }

World::m_allowMovement

bool m_allowMovement

Definition: World.h:832

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

inline

Set a server configuration element (see #WorldConfigs)

         {
             if (index < BOOL_CONFIG_VALUE_COUNT)
                 m_bool_configs[index] = value;
         }

void World::SetCleaningFlags ( uint32 flags )

inline

766 { m_CleaningFlags = flags; }

World::m_CleaningFlags

uint32 m_CleaningFlags

Definition: World.h:799

flags

uint8 flags

Definition: DisableMgr.cpp:44

void World::SetClosed ( bool val )

Close world.

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

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

inline

Set a server configuration element (see #WorldConfigs)

         {
             if (index < FLOAT_CONFIG_VALUE_COUNT)
                 m_float_configs[index] = value;
         }

void World::SetInitialWorldSettings ( )

Initialize the World.

Server startup begin
Initialize the random number generator
Initialize detour memory management
Initialize VMapManager 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 races' startup 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
Load DBCs
Load DB2s
Close hotfix database - it is only used during DB2 loading
Load GameTables
Load dynamic data tables from the database
Handle outdated emails (delete/return)
Load and initialize scripts
Initialize game time and timers

Todo:: Get rid of magic numbers

Initilize static helper structures
Initialize MapManager
Initialize Battlegrounds
Initialize outdoor pvp
Initialize Battlefield
Initialize Warden

 {
     uint32 startupBegin = getMSTime();
 
     srand((unsigned int)time(NULL));
 
     dtAllocSetCustom(dtCustomAlloc, dtCustomFree);
 
     if (VMAP::VMapManager2* vmmgr2 = dynamic_cast<VMAP::VMapManager2*>(VMAP::VMapFactory::createOrGetVMapManager()))
     {
         vmmgr2->GetLiquidFlagsPtr = &GetLiquidFlags;
         vmmgr2->IsVMAPDisabledForPtr = &DisableMgr::IsVMAPDisabledFor;
     }
 
     LoadConfigSettings();
 
     LoadDBAllowedSecurityLevel();
 
     sObjectMgr->SetHighestGuids();
 
     if (!MapManager::ExistMapAndVMap(0, -6240.32f, 331.033f)
         || !MapManager::ExistMapAndVMap(0, -8949.95f, -132.493f)
         || !MapManager::ExistMapAndVMap(1, -618.518f, -4251.67f)
         || !MapManager::ExistMapAndVMap(0, 1676.35f, 1677.45f)
         || !MapManager::ExistMapAndVMap(1, 10311.3f, 832.463f)
         || !MapManager::ExistMapAndVMap(1, -2917.58f, -257.98f)
         || (m_int_configs[CONFIG_EXPANSION] && (
             !MapManager::ExistMapAndVMap(530, 10349.6f, -6357.29f) ||
             !MapManager::ExistMapAndVMap(530, -3961.64f, -13931.2f))))
     {
         TC_LOG_FATAL("server.loading", "Unable to load critical files - server shutting down !!!");
         exit(1);
     }
 
     sPoolMgr->Initialize();
 
     sGameEventMgr->Initialize();
 
 
     TC_LOG_INFO("server.loading", "Loading Trinity strings...");
     if (!sObjectMgr->LoadTrinityStrings())
         exit(1);                                            // Error message displayed in function already
 
     //No SQL injection as values are treated as integers
 
     // not send custom type REALM_FFA_PVP to realm list
     uint32 server_type = IsFFAPvPRealm() ? uint32(REALM_TYPE_PVP) : getIntConfig(CONFIG_GAME_TYPE);
     uint32 realm_zone = getIntConfig(CONFIG_REALM_ZONE);
 
     LoginDatabase.PExecute("UPDATE realmlist SET icon = %u, timezone = %u WHERE id = '%d'", server_type, realm_zone, realm.Id.Realm);      // One-time query
 
     TC_LOG_INFO("server.loading", "Initialize data stores...");
     LoadDBCStores(m_dataPath, m_defaultDbcLocale);
     sDB2Manager.LoadStores(m_dataPath, m_defaultDbcLocale);
     TC_LOG_INFO("misc", "Loading hotfix info...");
     sDB2Manager.LoadHotfixData();
     HotfixDatabase.Close();
     LoadGameTables(m_dataPath, m_defaultDbcLocale);
 
     //Load weighted graph on taxi nodes path
     sTaxiPathGraph.Initialize();
 
     sSpellMgr->LoadPetFamilySpellsStore();
 
     std::unordered_map<uint32, std::vector<uint32>> mapData;
     for (MapEntry const* mapEntry : sMapStore)
     {
         mapData.insert(std::unordered_map<uint32, std::vector<uint32>>::value_type(mapEntry->ID, std::vector<uint32>()));
         if (mapEntry->ParentMapID != -1)
             mapData[mapEntry->ParentMapID].push_back(mapEntry->ID);
     }
 
     if (VMAP::VMapManager2* vmmgr2 = dynamic_cast<VMAP::VMapManager2*>(VMAP::VMapFactory::createOrGetVMapManager()))
         vmmgr2->InitializeThreadUnsafe(mapData);
 
     MMAP::MMapManager* mmmgr = MMAP::MMapFactory::createOrGetMMapManager();
     mmmgr->InitializeThreadUnsafe(mapData);
 
     TC_LOG_INFO("server.loading", "Loading SpellInfo store...");
     sSpellMgr->LoadSpellInfoStore();
 
     TC_LOG_INFO("server.loading", "Loading SpellInfo corrections...");
     sSpellMgr->LoadSpellInfoCorrections();
 
     TC_LOG_INFO("server.loading", "Loading SkillLineAbilityMultiMap Data...");
     sSpellMgr->LoadSkillLineAbilityMap();
 
     TC_LOG_INFO("server.loading", "Loading SpellInfo custom attributes...");
     sSpellMgr->LoadSpellInfoCustomAttributes();
 
     TC_LOG_INFO("server.loading", "Loading GameObject models...");
     LoadGameObjectModelList(m_dataPath);
 
     TC_LOG_INFO("server.loading", "Loading Script Names...");
     sObjectMgr->LoadScriptNames();
 
     TC_LOG_INFO("server.loading", "Loading Instance Template...");
     sObjectMgr->LoadInstanceTemplate();
 
     // Must be called before `creature_respawn`/`gameobject_respawn` tables
     TC_LOG_INFO("server.loading", "Loading instances...");
     sInstanceSaveMgr->LoadInstances();
 
     TC_LOG_INFO("server.loading", "Loading Localization strings...");
     uint32 oldMSTime = getMSTime();
     sObjectMgr->LoadCreatureLocales();
     sObjectMgr->LoadGameObjectLocales();
     sObjectMgr->LoadQuestTemplateLocale();
     sObjectMgr->LoadQuestObjectivesLocale();
     sObjectMgr->LoadPageTextLocales();
     sObjectMgr->LoadGossipMenuItemsLocales();
     sObjectMgr->LoadPointOfInterestLocales();
 
     sObjectMgr->SetDBCLocaleIndex(GetDefaultDbcLocale());        // Get once for all the locale index of DBC language (console/broadcasts)
     TC_LOG_INFO("server.loading", ">> Localization strings loaded in %u ms", GetMSTimeDiffToNow(oldMSTime));
 
     TC_LOG_INFO("server.loading", "Loading Account Roles and Permissions...");
     sAccountMgr->LoadRBAC();
 
     TC_LOG_INFO("server.loading", "Loading Page Texts...");
     sObjectMgr->LoadPageTexts();
 
     TC_LOG_INFO("server.loading", "Loading Game Object Templates...");         // must be after LoadPageTexts
     sObjectMgr->LoadGameObjectTemplate();
 
     TC_LOG_INFO("server.loading", "Loading Transport templates...");
     sTransportMgr->LoadTransportTemplates();
 
     TC_LOG_INFO("server.loading", "Loading Spell Rank Data...");
     sSpellMgr->LoadSpellRanks();
 
     TC_LOG_INFO("server.loading", "Loading Spell Required Data...");
     sSpellMgr->LoadSpellRequired();
 
     TC_LOG_INFO("server.loading", "Loading Spell Group types...");
     sSpellMgr->LoadSpellGroups();
 
     TC_LOG_INFO("server.loading", "Loading Spell Learn Skills...");
     sSpellMgr->LoadSpellLearnSkills();                           // must be after LoadSpellRanks
 
     TC_LOG_INFO("server.loading", "Loading Spell Learn Spells...");
     sSpellMgr->LoadSpellLearnSpells();
 
     TC_LOG_INFO("server.loading", "Loading Spell Proc Event conditions...");
     sSpellMgr->LoadSpellProcEvents();
 
     TC_LOG_INFO("server.loading", "Loading Spell Proc conditions and data...");
     sSpellMgr->LoadSpellProcs();
 
     TC_LOG_INFO("server.loading", "Loading Aggro Spells Definitions...");
     sSpellMgr->LoadSpellThreats();
 
     TC_LOG_INFO("server.loading", "Loading Spell Group Stack Rules...");
     sSpellMgr->LoadSpellGroupStackRules();
 
     TC_LOG_INFO("server.loading", "Loading NPC Texts...");
     sObjectMgr->LoadNPCText();
 
     TC_LOG_INFO("server.loading", "Loading Enchant Spells Proc datas...");
     sSpellMgr->LoadSpellEnchantProcData();
 
     TC_LOG_INFO("server.loading", "Loading Item Random Enchantments Table...");
     LoadRandomEnchantmentsTable();
 
     TC_LOG_INFO("server.loading", "Loading Disables");                         // must be before loading quests and items
     DisableMgr::LoadDisables();
 
     TC_LOG_INFO("server.loading", "Loading Items...");                         // must be after LoadRandomEnchantmentsTable and LoadPageTexts
     sObjectMgr->LoadItemTemplates();
 
     TC_LOG_INFO("server.loading", "Loading Item set names...");                // must be after LoadItemPrototypes
     sObjectMgr->LoadItemTemplateAddon();
 
     TC_LOG_INFO("misc", "Loading Item Scripts...");                 // must be after LoadItemPrototypes
     sObjectMgr->LoadItemScriptNames();
 
     TC_LOG_INFO("server.loading", "Loading Creature Model Based Info Data...");
     sObjectMgr->LoadCreatureModelInfo();
 
     TC_LOG_INFO("server.loading", "Loading Creature templates...");
     sObjectMgr->LoadCreatureTemplates();
 
     TC_LOG_INFO("server.loading", "Loading Equipment templates...");           // must be after LoadCreatureTemplates
     sObjectMgr->LoadEquipmentTemplates();
 
     TC_LOG_INFO("server.loading", "Loading Creature template addons...");
     sObjectMgr->LoadCreatureTemplateAddons();
 
     TC_LOG_INFO("server.loading", "Loading Reputation Reward Rates...");
     sObjectMgr->LoadReputationRewardRate();
 
     TC_LOG_INFO("server.loading", "Loading Creature Reputation OnKill Data...");
     sObjectMgr->LoadReputationOnKill();
 
     TC_LOG_INFO("server.loading", "Loading Reputation Spillover Data...");
     sObjectMgr->LoadReputationSpilloverTemplate();
 
     TC_LOG_INFO("server.loading", "Loading Points Of Interest Data...");
     sObjectMgr->LoadPointsOfInterest();
 
     TC_LOG_INFO("server.loading", "Loading Creature Base Stats...");
     sObjectMgr->LoadCreatureClassLevelStats();
 
     TC_LOG_INFO("server.loading", "Loading Creature Data...");
     sObjectMgr->LoadCreatures();
 
     TC_LOG_INFO("server.loading", "Loading Temporary Summon Data...");
     sObjectMgr->LoadTempSummons();                               // must be after LoadCreatureTemplates() and LoadGameObjectTemplates()
 
     TC_LOG_INFO("server.loading", "Loading pet levelup spells...");
     sSpellMgr->LoadPetLevelupSpellMap();
 
     TC_LOG_INFO("server.loading", "Loading pet default spells additional to levelup spells...");
     sSpellMgr->LoadPetDefaultSpells();
 
     TC_LOG_INFO("server.loading", "Loading Creature Addon Data...");
     sObjectMgr->LoadCreatureAddons();                            // must be after LoadCreatureTemplates() and LoadCreatures()
 
     TC_LOG_INFO("server.loading", "Loading Gameobject Data...");
     sObjectMgr->LoadGameobjects();
 
     TC_LOG_INFO("server.loading", "Loading GameObject Addon Data...");
     sObjectMgr->LoadGameObjectAddons();                          // must be after LoadGameObjectTemplate() and LoadGameobjects()
 
     TC_LOG_INFO("server.loading", "Loading GameObject Quest Items...");
     sObjectMgr->LoadGameObjectQuestItems();
 
     TC_LOG_INFO("server.loading", "Loading Creature Quest Items...");
     sObjectMgr->LoadCreatureQuestItems();
 
     TC_LOG_INFO("server.loading", "Loading Creature Linked Respawn...");
     sObjectMgr->LoadLinkedRespawn();                             // must be after LoadCreatures(), LoadGameObjects()
 
     TC_LOG_INFO("server.loading", "Loading Weather Data...");
     WeatherMgr::LoadWeatherData();
 
     TC_LOG_INFO("server.loading", "Loading Quests...");
     sObjectMgr->LoadQuests();                                    // must be loaded after DBCs, creature_template, item_template, gameobject tables
 
     TC_LOG_INFO("server.loading", "Checking Quest Disables");
     DisableMgr::CheckQuestDisables();                           // must be after loading quests
 
     TC_LOG_INFO("server.loading", "Loading Quest POI");
     sObjectMgr->LoadQuestPOI();
 
     TC_LOG_INFO("server.loading", "Loading Quests Starters and Enders...");
     sObjectMgr->LoadQuestStartersAndEnders();                    // must be after quest load
 
     TC_LOG_INFO("server.loading", "Loading Quest Greetings...");
     sObjectMgr->LoadQuestGreetings();
 
     TC_LOG_INFO("server.loading", "Loading Objects Pooling Data...");
     sPoolMgr->LoadFromDB();
 
     TC_LOG_INFO("server.loading", "Loading Game Event Data...");               // must be after loading pools fully
     sGameEventMgr->LoadFromDB();
 
     TC_LOG_INFO("server.loading", "Loading UNIT_NPC_FLAG_SPELLCLICK Data..."); // must be after LoadQuests
     sObjectMgr->LoadNPCSpellClickSpells();
 
     TC_LOG_INFO("server.loading", "Loading Vehicle Template Accessories...");
     sObjectMgr->LoadVehicleTemplateAccessories();                // must be after LoadCreatureTemplates() and LoadNPCSpellClickSpells()
 
     TC_LOG_INFO("server.loading", "Loading Vehicle Accessories...");
     sObjectMgr->LoadVehicleAccessories();                       // must be after LoadCreatureTemplates() and LoadNPCSpellClickSpells()
 
     TC_LOG_INFO("server.loading", "Loading SpellArea Data...");                // must be after quest load
     sSpellMgr->LoadSpellAreas();
 
     TC_LOG_INFO("server.loading", "Loading AreaTrigger definitions...");
     sObjectMgr->LoadAreaTriggerTeleports();
 
     TC_LOG_INFO("server.loading", "Loading Access Requirements...");
     sObjectMgr->LoadAccessRequirements();                        // must be after item template load
 
     TC_LOG_INFO("server.loading", "Loading Quest Area Triggers...");
     sObjectMgr->LoadQuestAreaTriggers();                         // must be after LoadQuests
 
     TC_LOG_INFO("server.loading", "Loading Tavern Area Triggers...");
     sObjectMgr->LoadTavernAreaTriggers();
 
     TC_LOG_INFO("server.loading", "Loading AreaTrigger script names...");
     sObjectMgr->LoadAreaTriggerScripts();
 
     TC_LOG_INFO("server.loading", "Loading LFG entrance positions..."); // Must be after areatriggers
     sLFGMgr->LoadLFGDungeons();
 
     TC_LOG_INFO("server.loading", "Loading Dungeon boss data...");
     sObjectMgr->LoadInstanceEncounters();
 
     TC_LOG_INFO("server.loading", "Loading LFG rewards...");
     sLFGMgr->LoadRewards();
 
     TC_LOG_INFO("server.loading", "Loading Graveyard-zone links...");
     sObjectMgr->LoadGraveyardZones();
 
     TC_LOG_INFO("server.loading", "Loading spell pet auras...");
     sSpellMgr->LoadSpellPetAuras();
 
     TC_LOG_INFO("server.loading", "Loading Spell target coordinates...");
     sSpellMgr->LoadSpellTargetPositions();
 
     TC_LOG_INFO("server.loading", "Loading enchant custom attributes...");
     sSpellMgr->LoadEnchantCustomAttr();
 
     TC_LOG_INFO("server.loading", "Loading linked spells...");
     sSpellMgr->LoadSpellLinked();
 
     TC_LOG_INFO("server.loading", "Loading Player Create Data...");
     sObjectMgr->LoadPlayerInfo();
 
     TC_LOG_INFO("server.loading", "Loading Exploration BaseXP Data...");
     sObjectMgr->LoadExplorationBaseXP();
 
     TC_LOG_INFO("server.loading", "Loading Pet Name Parts...");
     sObjectMgr->LoadPetNames();
 
     CharacterDatabaseCleaner::CleanDatabase();
 
     TC_LOG_INFO("server.loading", "Loading the max pet number...");
     sObjectMgr->LoadPetNumber();
 
     TC_LOG_INFO("server.loading", "Loading pet level stats...");
     sObjectMgr->LoadPetLevelInfo();
 
     TC_LOG_INFO("server.loading", "Loading Player level dependent mail rewards...");
     sObjectMgr->LoadMailLevelRewards();
 
     // Loot tables
     LoadLootTables();
 
     TC_LOG_INFO("server.loading", "Loading Skill Discovery Table...");
     LoadSkillDiscoveryTable();
 
     TC_LOG_INFO("server.loading", "Loading Skill Extra Item Table...");
     LoadSkillExtraItemTable();
 
     TC_LOG_INFO("server.loading", "Loading Skill Perfection Data Table...");
     LoadSkillPerfectItemTable();
 
     TC_LOG_INFO("server.loading", "Loading Skill Fishing base level requirements...");
     sObjectMgr->LoadFishingBaseSkillLevel();
 
     TC_LOG_INFO("server.loading", "Loading skill tier info...");
     sObjectMgr->LoadSkillTiers();
 
     TC_LOG_INFO("server.loading", "Loading Achievements...");
     sAchievementMgr->LoadAchievementReferenceList();
     TC_LOG_INFO("server.loading", "Loading Achievement Criteria Modifier trees...");
     sAchievementMgr->LoadAchievementCriteriaModifiersTree();
     TC_LOG_INFO("server.loading", "Loading Achievement Criteria Lists...");
     sAchievementMgr->LoadAchievementCriteriaList();
     TC_LOG_INFO("server.loading", "Loading Achievement Criteria Data...");
     sAchievementMgr->LoadAchievementCriteriaData();
     TC_LOG_INFO("server.loading", "Loading Achievement Rewards...");
     sAchievementMgr->LoadRewards();
     TC_LOG_INFO("server.loading", "Loading Achievement Reward Locales...");
     sAchievementMgr->LoadRewardLocales();
     TC_LOG_INFO("server.loading", "Loading Completed Achievements...");
     sAchievementMgr->LoadCompletedAchievements();
 
     TC_LOG_INFO("server.loading", "Loading Item Auctions...");
     sAuctionMgr->LoadAuctionItems();
 
     TC_LOG_INFO("server.loading", "Loading Auctions...");
     sAuctionMgr->LoadAuctions();
 
     TC_LOG_INFO("server.loading", "Loading Guild rewards...");
     sGuildMgr->LoadGuildRewards();
 
     TC_LOG_INFO("server.loading", "Loading Guilds...");
     sGuildMgr->LoadGuilds();
 
     sGuildFinderMgr->LoadFromDB();
 
     TC_LOG_INFO("server.loading", "Loading ArenaTeams...");
     sArenaTeamMgr->LoadArenaTeams();
 
     TC_LOG_INFO("server.loading", "Loading Groups...");
     sGroupMgr->LoadGroups();
 
     TC_LOG_INFO("server.loading", "Loading ReservedNames...");
     sObjectMgr->LoadReservedPlayersNames();
 
     TC_LOG_INFO("server.loading", "Loading GameObjects for quests...");
     sObjectMgr->LoadGameObjectForQuests();
 
     TC_LOG_INFO("server.loading", "Loading BattleMasters...");
     sBattlegroundMgr->LoadBattleMastersEntry();                 // must be after load CreatureTemplate
 
     TC_LOG_INFO("server.loading", "Loading GameTeleports...");
     sObjectMgr->LoadGameTele();
 
     TC_LOG_INFO("server.loading", "Loading Gossip menu...");
     sObjectMgr->LoadGossipMenu();
 
     TC_LOG_INFO("server.loading", "Loading Gossip menu options...");
     sObjectMgr->LoadGossipMenuItems();
 
     TC_LOG_INFO("server.loading", "Loading Vendors...");
     sObjectMgr->LoadVendors();                                   // must be after load CreatureTemplate and ItemTemplate
 
     TC_LOG_INFO("server.loading", "Loading Trainers...");
     sObjectMgr->LoadTrainerSpell();                              // must be after load CreatureTemplate
 
     TC_LOG_INFO("server.loading", "Loading Waypoints...");
     sWaypointMgr->Load();
 
     TC_LOG_INFO("server.loading", "Loading SmartAI Waypoints...");
     sSmartWaypointMgr->LoadFromDB();
 
     TC_LOG_INFO("server.loading", "Loading Creature Formations...");
     sFormationMgr->LoadCreatureFormations();
 
     TC_LOG_INFO("server.loading", "Loading World States...");              // must be loaded before battleground, outdoor PvP and conditions
     LoadWorldStates();
 
     TC_LOG_INFO("server.loading", "Loading Terrain Phase definitions...");
     sObjectMgr->LoadTerrainPhaseInfo();
 
     TC_LOG_INFO("server.loading", "Loading Terrain Swap Default definitions...");
     sObjectMgr->LoadTerrainSwapDefaults();
 
     TC_LOG_INFO("server.loading", "Loading Terrain World Map definitions...");
     sObjectMgr->LoadTerrainWorldMaps();
 
     TC_LOG_INFO("server.loading", "Loading Phase Area definitions...");
     sObjectMgr->LoadAreaPhases();
 
     TC_LOG_INFO("server.loading", "Loading Conditions...");
     sConditionMgr->LoadConditions();
 
     TC_LOG_INFO("server.loading", "Loading faction change achievement pairs...");
     sObjectMgr->LoadFactionChangeAchievements();
 
     TC_LOG_INFO("server.loading", "Loading faction change spell pairs...");
     sObjectMgr->LoadFactionChangeSpells();
 
     TC_LOG_INFO("server.loading", "Loading faction change quest pairs...");
     sObjectMgr->LoadFactionChangeQuests();
 
     TC_LOG_INFO("server.loading", "Loading faction change item pairs...");
     sObjectMgr->LoadFactionChangeItems();
 
     TC_LOG_INFO("server.loading", "Loading faction change reputation pairs...");
     sObjectMgr->LoadFactionChangeReputations();
 
     TC_LOG_INFO("server.loading", "Loading faction change title pairs...");
     sObjectMgr->LoadFactionChangeTitles();
 
     TC_LOG_INFO("server.loading", "Loading GM bugs...");
     sSupportMgr->LoadBugTickets();
 
     TC_LOG_INFO("server.loading", "Loading GM complaints...");
     sSupportMgr->LoadComplaintTickets();
 
     TC_LOG_INFO("server.loading", "Loading GM suggestions...");
     sSupportMgr->LoadSuggestionTickets();
 
     /*TC_LOG_INFO("server.loading", "Loading GM surveys...");
     sSupportMgr->LoadSurveys();*/
 
     TC_LOG_INFO("server.loading", "Loading client addons...");
     AddonMgr::LoadFromDB();
 
     TC_LOG_INFO("server.loading", "Loading garrison info...");
     sGarrisonMgr.Initialize();
 
     TC_LOG_INFO("server.loading", "Returning old mails...");
     sObjectMgr->ReturnOrDeleteOldMails(false);
 
     TC_LOG_INFO("server.loading", "Loading Autobroadcasts...");
     LoadAutobroadcasts();
 
     sObjectMgr->LoadSpellScripts();                              // must be after load Creature/Gameobject(Template/Data)
     sObjectMgr->LoadEventScripts();                              // must be after load Creature/Gameobject(Template/Data)
     sObjectMgr->LoadWaypointScripts();
 
     TC_LOG_INFO("server.loading", "Loading spell script names...");
     sObjectMgr->LoadSpellScriptNames();
 
     TC_LOG_INFO("server.loading", "Loading Creature Texts...");
     sCreatureTextMgr->LoadCreatureTexts();
 
     TC_LOG_INFO("server.loading", "Loading Creature Text Locales...");
     sCreatureTextMgr->LoadCreatureTextLocales();
 
     TC_LOG_INFO("server.loading", "Initializing Scripts...");
     sScriptMgr->Initialize();
     sScriptMgr->OnConfigLoad(false);                                // must be done after the ScriptMgr has been properly initialized
 
     TC_LOG_INFO("server.loading", "Validating spell scripts...");
     sObjectMgr->ValidateSpellScripts();
 
     TC_LOG_INFO("server.loading", "Loading SmartAI scripts...");
     sSmartScriptMgr->LoadSmartAIFromDB();
 
     TC_LOG_INFO("server.loading", "Loading Calendar data...");
     sCalendarMgr->LoadFromDB();
 
     TC_LOG_INFO("server.loading", "Initialize game time and timers");
     m_gameTime = time(NULL);
     m_startTime = m_gameTime;
 
     LoginDatabase.PExecute("INSERT INTO uptime (realmid, starttime, uptime, revision) VALUES(%u, %u, 0, '%s')",
                             realm.Id.Realm, uint32(m_startTime), GitRevision::GetFullVersion());       // One-time query
 
     m_timers[WUPDATE_WEATHERS].SetInterval(1*IN_MILLISECONDS);
     m_timers[WUPDATE_AUCTIONS].SetInterval(MINUTE*IN_MILLISECONDS);
     m_timers[WUPDATE_AUCTIONS_PENDING].SetInterval(250);
     m_timers[WUPDATE_UPTIME].SetInterval(m_int_configs[CONFIG_UPTIME_UPDATE]*MINUTE*IN_MILLISECONDS);
                                                             //Update "uptime" table based on configuration entry in minutes.
     m_timers[WUPDATE_CORPSES].SetInterval(20 * MINUTE * IN_MILLISECONDS);
                                                             //erase corpses every 20 minutes
     m_timers[WUPDATE_CLEANDB].SetInterval(m_int_configs[CONFIG_LOGDB_CLEARINTERVAL]*MINUTE*IN_MILLISECONDS);
                                                             // clean logs table every 14 days by default
     m_timers[WUPDATE_AUTOBROADCAST].SetInterval(getIntConfig(CONFIG_AUTOBROADCAST_INTERVAL));
     m_timers[WUPDATE_DELETECHARS].SetInterval(DAY*IN_MILLISECONDS); // check for chars to delete every day
 
     // for AhBot
     m_timers[WUPDATE_AHBOT].SetInterval(getIntConfig(CONFIG_AHBOT_UPDATE_INTERVAL) * IN_MILLISECONDS); // every 20 sec
 
     m_timers[WUPDATE_PINGDB].SetInterval(getIntConfig(CONFIG_DB_PING_INTERVAL)*MINUTE*IN_MILLISECONDS);    // Mysql ping time in minutes
 
     m_timers[WUPDATE_GUILDSAVE].SetInterval(getIntConfig(CONFIG_GUILD_SAVE_INTERVAL) * MINUTE * IN_MILLISECONDS);
 
     //to set mailtimer to return mails every day between 4 and 5 am
     //mailtimer is increased when updating auctions
     //one second is 1000 -(tested on win system)
     tm localTm;
     localtime_r(&m_gameTime, &localTm);
     mail_timer = ((((localTm.tm_hour + 20) % 24)* HOUR * IN_MILLISECONDS) / m_timers[WUPDATE_AUCTIONS].GetInterval());
                                                             //1440
     mail_timer_expires = ((DAY * IN_MILLISECONDS) / (m_timers[WUPDATE_AUCTIONS].GetInterval()));
     TC_LOG_INFO("server.loading", "Mail timer set to: " UI64FMTD ", mail return is called every " UI64FMTD " minutes", uint64(mail_timer), uint64(mail_timer_expires));
 
     AIRegistry::Initialize();
 
     TC_LOG_INFO("server.loading", "Starting Map System");
     sMapMgr->Initialize();
 
     TC_LOG_INFO("server.loading", "Starting Game Event system...");
     uint32 nextGameEvent = sGameEventMgr->StartSystem();
     m_timers[WUPDATE_EVENTS].SetInterval(nextGameEvent);    //depend on next event
 
     // Delete all characters which have been deleted X days before
     Player::DeleteOldCharacters();
 
     TC_LOG_INFO("server.loading", "Initialize AuctionHouseBot...");
     sAuctionBot->Initialize();
 
     // Delete all custom channels which haven't been used for PreserveCustomChannelDuration days.
     Channel::CleanOldChannelsInDB();
 
     TC_LOG_INFO("server.loading", "Initializing Opcodes...");
     opcodeTable.Initialize();
 
     TC_LOG_INFO("server.loading", "Starting Arena Season...");
     sGameEventMgr->StartArenaSeason();
 
     sSupportMgr->Initialize();
 
     TC_LOG_INFO("server.loading", "Starting Battleground System");
     sBattlegroundMgr->LoadBattlegroundTemplates();
 
     TC_LOG_INFO("server.loading", "Starting Outdoor PvP System");
     sOutdoorPvPMgr->InitOutdoorPvP();
 
     TC_LOG_INFO("server.loading", "Starting Battlefield System");
     sBattlefieldMgr->InitBattlefield();
 
     TC_LOG_INFO("server.loading", "Loading Transports...");
     sTransportMgr->SpawnContinentTransports();
 
     TC_LOG_INFO("server.loading", "Loading Warden Checks...");
     sWardenCheckMgr->LoadWardenChecks();
 
     TC_LOG_INFO("server.loading", "Loading Warden Action Overrides...");
     sWardenCheckMgr->LoadWardenOverrides();
 
     TC_LOG_INFO("server.loading", "Deleting expired bans...");
     LoginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate <= UNIX_TIMESTAMP() AND unbandate<>bandate");      // One-time query
 
     TC_LOG_INFO("server.loading", "Calculate next daily quest reset time...");
     InitDailyQuestResetTime();
 
     TC_LOG_INFO("server.loading", "Calculate next weekly quest reset time...");
     InitWeeklyQuestResetTime();
 
     TC_LOG_INFO("server.loading", "Calculate next monthly quest reset time...");
     InitMonthlyQuestResetTime();
 
     TC_LOG_INFO("server.loading", "Calculate random battleground reset time...");
     InitRandomBGResetTime();
 
     TC_LOG_INFO("server.loading", "Calculate guild limitation(s) reset time...");
     InitGuildResetTime();
 
     TC_LOG_INFO("server.loading", "Calculate next currency reset time...");
     InitCurrencyResetTime();
 
     LoadCharacterInfoStore();
 
     TC_LOG_INFO("server.loading", "Loading race and class expansion requirements...");
     sObjectMgr->LoadRaceAndClassExpansionRequirements();
 
     TC_LOG_INFO("server.loading", "Loading character templates...");
     sObjectMgr->LoadCharacterTemplates();
 
     TC_LOG_INFO("server.loading", "Loading realm names...");
     sObjectMgr->LoadRealmNames();
 
     TC_LOG_INFO("server.loading", "Loading battle pets info...");
     BattlePetMgr::Initialize();
 
     uint32 startupDuration = GetMSTimeDiffToNow(startupBegin);
 
     TC_LOG_INFO("server.worldserver", "World initialized in %u minutes %u seconds", (startupDuration / 60000), ((startupDuration % 60000) / 1000));
 
     if (uint32 realmId = sConfigMgr->GetIntDefault("RealmID", 0)) // 0 reserved for auth
         sLog->SetRealmId(realmId);
 }

Here is the call graph for this function:

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

inline

Set a server configuration element (see #WorldConfigs)

         {
             if (index < INT_CONFIG_VALUE_COUNT)
                 m_int_configs[index] = value;
         }

void World::SetMotd ( std::string motd )

Set a new Message of the Day.

we are using a string copy here to allow modifications in script hooks

 {
     sScriptMgr->OnMotdChange(motd);
 
     _motd.clear();
     boost::split(_motd, motd, boost::is_any_of("@"));
 }

Here is the caller graph for this function:

void World::SetNewCharString ( std::string const & str )

inline

Set the string for new characters (first login)

612 { m_newCharString = str; }

World::m_newCharString

std::string m_newCharString

Definition: World.h:820

Here is the caller graph for this function:

void World::SetPlayerAmountLimit ( uint32 limit )

inline

Active session server limit.

590 { m_playerLimit = limit; }

World::m_playerLimit

uint32 m_playerLimit

Definition: World.h:828

Here is the caller graph for this function:

void World::SetPlayerSecurityLimit ( AccountTypes sec )

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

Here is the call graph for this function:

Here is the caller graph for this function:

void World::setRate	(	Rates	rate,
		float	value
	)

inline

Set a server rate (see Rates)

669 { rate_values[rate]=value; }

World::rate_values

float rate_values[MAX_RATES]

Definition: World.h:822

google::protobuf::value

const FieldDescriptor value

Definition: descriptor.h:1522

void World::SetRecordDiffInterval ( int32 t )

inline

629 { if (t >= 0) m_int_configs[CONFIG_INTERVAL_LOG_UPDATE] = (uint32)t; }

CONFIG_INTERVAL_LOG_UPDATE

Definition: World.h:318

World::m_int_configs

uint32 m_int_configs[INT_CONFIG_VALUE_COUNT]

Definition: World.h:823

G3D::uint32

uint32_t uint32

Definition: g3dmath.h:168

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

 {
     WorldStatesMap::const_iterator it = m_worldstates.find(index);
     if (it != m_worldstates.end())
     {
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_WORLDSTATE);
 
         stmt->setUInt32(0, uint32(value));
         stmt->setUInt32(1, index);
 
         CharacterDatabase.Execute(stmt);
     }
     else
     {
         PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_WORLDSTATE);
 
         stmt->setUInt32(0, index);
         stmt->setUInt32(1, uint32(value));
 
         CharacterDatabase.Execute(stmt);
     }
     m_worldstates[index] = value;
 }

Here is the call graph for this function:

void World::ShutdownCancel ( )

Cancel a planned server shutdown.

 {
     // nothing cancel or too later
     if (!m_ShutdownTimer || m_stopEvent)
         return;
 
     ServerMessageType msgid = (m_ShutdownMask & SHUTDOWN_MASK_RESTART) ? SERVER_MSG_RESTART_CANCELLED : SERVER_MSG_SHUTDOWN_CANCELLED;
 
     m_ShutdownMask = 0;
     m_ShutdownTimer = 0;
     m_ExitCode = SHUTDOWN_EXIT_CODE;                       // to default value
     SendServerMessage(msgid);
 
     TC_LOG_DEBUG("misc", "Server %s cancelled.", (m_ShutdownMask & SHUTDOWN_MASK_RESTART ? "restart" : "shuttingdown"));
 
     sScriptMgr->OnShutdownCancel();
 }

Here is the call graph for this function:

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

Display a shutdown message to the user(s)

Display a message every 12 hours, hours, 5 minutes, minute, 5 seconds and finally seconds

 {
     // not show messages for idle shutdown mode
     if (m_ShutdownMask & SHUTDOWN_MASK_IDLE)
         return;
 
     if (show ||
         (m_ShutdownTimer < 5* MINUTE && (m_ShutdownTimer % 15) == 0) || // < 5 min; every 15 sec
         (m_ShutdownTimer < 15 * MINUTE && (m_ShutdownTimer % MINUTE) == 0) || // < 15 min ; every 1 min
         (m_ShutdownTimer < 30 * MINUTE && (m_ShutdownTimer % (5 * MINUTE)) == 0) || // < 30 min ; every 5 min
         (m_ShutdownTimer < 12 * HOUR && (m_ShutdownTimer % HOUR) == 0) || // < 12 h ; every 1 h
         (m_ShutdownTimer > 12 * HOUR && (m_ShutdownTimer % (12 * HOUR)) == 0)) // > 12 h ; every 12 h
     {
         std::string str = secsToTimeString(m_ShutdownTimer);
         if (!reason.empty())
             str += " - " + reason;
 
         ServerMessageType msgid = (m_ShutdownMask & SHUTDOWN_MASK_RESTART) ? SERVER_MSG_RESTART_TIME : SERVER_MSG_SHUTDOWN_TIME;
 
         SendServerMessage(msgid, str, player);
         TC_LOG_DEBUG("misc", "Server is %s in %s", (m_ShutdownMask & SHUTDOWN_MASK_RESTART ? "restart" : "shuttingdown"), str.c_str());
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

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

 {
     // ignore if server shutdown at next tick
     if (IsStopped())
         return;
 
     m_ShutdownMask = options;
     m_ExitCode = exitcode;
 
     if (time == 0)
     {
         if (!(options & SHUTDOWN_MASK_IDLE) || GetActiveAndQueuedSessionCount() == 0)
             m_stopEvent = true;                             // exist code already set
         else
             m_ShutdownTimer = 1;                            //So that the session count is re-evaluated at next world tick
     }
     else
     {
         m_ShutdownTimer = time;
         ShutdownMsg(true, nullptr, reason);
     }
 
     sScriptMgr->OnShutdownInitiate(ShutdownExitCode(exitcode), ShutdownMask(options));
 }

Here is the call graph for this function:

static void World::StopNow ( uint8 exitcode )

inlinestatic

662 { m_stopEvent = true; m_ExitCode = exitcode; }

World::m_stopEvent

static std::atomic< bool > m_stopEvent

Definition: World.h:794

World::m_ExitCode

static uint8 m_ExitCode

Definition: World.h:795

Here is the caller graph for this function:

void World::Update ( uint32 diff )

Update the World !

Update the different timers
Update the game time and check for shutdown time

Handle daily quests reset time

Handle weekly quests reset time

Handle monthly quests reset time

Handle auctions when the timer has passed
- Update mails (return old mails with item, or delete them)
- Handle expired auctions
Handle AHBot operations
Handle session updates when the timer has passed
Handle weather updates when the timer has passed
Update uptime table
Clean logs table
Handle all other objects
- Update objects when the timer has passed (maps, transport, creatures, ...)
- Delete all characters which have been deleted X days before
- Erase corpses once every 20 minutes
- Process Game events when necessary
- Ping to keep MySQL connections alive

 {
     m_updateTime = diff;
 
     if (m_int_configs[CONFIG_INTERVAL_LOG_UPDATE] && diff > m_int_configs[CONFIG_MIN_LOG_UPDATE])
     {
         if (m_updateTimeSum > m_int_configs[CONFIG_INTERVAL_LOG_UPDATE])
         {
             TC_LOG_DEBUG("misc", "Update time diff: %u. Players online: %u.", m_updateTimeSum / m_updateTimeCount, GetActiveSessionCount());
             m_updateTimeSum = m_updateTime;
             m_updateTimeCount = 1;
         }
         else
         {
             m_updateTimeSum += m_updateTime;
             ++m_updateTimeCount;
         }
     }
 
     for (int i = 0; i < WUPDATE_COUNT; ++i)
     {
         if (m_timers[i].GetCurrent() >= 0)
             m_timers[i].Update(diff);
         else
             m_timers[i].SetCurrent(0);
     }
 
     _UpdateGameTime();
 
     if (m_gameTime > m_NextDailyQuestReset)
     {
         DailyReset();
         m_NextDailyQuestReset += DAY;
     }
 
     if (m_gameTime > m_NextWeeklyQuestReset)
         ResetWeeklyQuests();
 
     if (m_gameTime > m_NextMonthlyQuestReset)
         ResetMonthlyQuests();
 
     if (m_gameTime > m_NextRandomBGReset)
         ResetRandomBG();
 
     if (m_gameTime > m_NextGuildReset)
         ResetGuildCap();
 
     if (m_gameTime > m_NextCurrencyReset)
         ResetCurrencyWeekCap();
 
     if (m_timers[WUPDATE_AUCTIONS].Passed())
     {
         m_timers[WUPDATE_AUCTIONS].Reset();
 
         //(tested... works on win)
         if (++mail_timer > mail_timer_expires)
         {
             mail_timer = 0;
             sObjectMgr->ReturnOrDeleteOldMails(true);
         }
 
         sAuctionMgr->Update();
     }
 
     if (m_timers[WUPDATE_AUCTIONS_PENDING].Passed())
     {
         m_timers[WUPDATE_AUCTIONS_PENDING].Reset();
 
         sAuctionMgr->UpdatePendingAuctions();
     }
 
     if (m_timers[WUPDATE_AHBOT].Passed())
     {
         sAuctionBot->Update();
         m_timers[WUPDATE_AHBOT].Reset();
     }
 
     ResetTimeDiffRecord();
     UpdateSessions(diff);
     RecordTimeDiff("UpdateSessions");
 
     if (m_timers[WUPDATE_WEATHERS].Passed())
     {
         m_timers[WUPDATE_WEATHERS].Reset();
         WeatherMgr::Update(uint32(m_timers[WUPDATE_WEATHERS].GetInterval()));
     }
 
     if (m_timers[WUPDATE_UPTIME].Passed())
     {
         uint32 tmpDiff = uint32(m_gameTime - m_startTime);
         uint32 maxOnlinePlayers = GetMaxPlayerCount();
 
         m_timers[WUPDATE_UPTIME].Reset();
 
         PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_UPD_UPTIME_PLAYERS);
 
         stmt->setUInt32(0, tmpDiff);
         stmt->setUInt16(1, uint16(maxOnlinePlayers));
         stmt->setUInt32(2, realm.Id.Realm);
         stmt->setUInt32(3, uint32(m_startTime));
 
         LoginDatabase.Execute(stmt);
     }
 
     if (sWorld->getIntConfig(CONFIG_LOGDB_CLEARTIME) > 0) // if not enabled, ignore the timer
     {
         if (m_timers[WUPDATE_CLEANDB].Passed())
         {
             m_timers[WUPDATE_CLEANDB].Reset();
 
             PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_DEL_OLD_LOGS);
 
             stmt->setUInt32(0, sWorld->getIntConfig(CONFIG_LOGDB_CLEARTIME));
             stmt->setUInt32(1, uint32(time(0)));
 
             LoginDatabase.Execute(stmt);
         }
     }
 
     ResetTimeDiffRecord();
     sMapMgr->Update(diff);
     RecordTimeDiff("UpdateMapMgr");
 
     if (sWorld->getBoolConfig(CONFIG_AUTOBROADCAST))
     {
         if (m_timers[WUPDATE_AUTOBROADCAST].Passed())
         {
             m_timers[WUPDATE_AUTOBROADCAST].Reset();
             SendAutoBroadcast();
         }
     }
 
     sBattlegroundMgr->Update(diff);
     RecordTimeDiff("UpdateBattlegroundMgr");
 
     sOutdoorPvPMgr->Update(diff);
     RecordTimeDiff("UpdateOutdoorPvPMgr");
 
     sBattlefieldMgr->Update(diff);
     RecordTimeDiff("BattlefieldMgr");
 
     if (m_timers[WUPDATE_DELETECHARS].Passed())
     {
         m_timers[WUPDATE_DELETECHARS].Reset();
         Player::DeleteOldCharacters();
     }
 
     sLFGMgr->Update(diff);
     RecordTimeDiff("UpdateLFGMgr");
 
     sGroupMgr->Update(diff);
     RecordTimeDiff("GroupMgr");
 
     // execute callbacks from sql queries that were queued recently
     ProcessQueryCallbacks();
     RecordTimeDiff("ProcessQueryCallbacks");
 
     if (m_timers[WUPDATE_CORPSES].Passed())
     {
         m_timers[WUPDATE_CORPSES].Reset();
         sMapMgr->DoForAllMaps([](Map* map)
         {
             map->RemoveOldCorpses();
         });
     }
 
     if (m_timers[WUPDATE_EVENTS].Passed())
     {
         m_timers[WUPDATE_EVENTS].Reset();                   // to give time for Update() to be processed
         uint32 nextGameEvent = sGameEventMgr->Update();
         m_timers[WUPDATE_EVENTS].SetInterval(nextGameEvent);
         m_timers[WUPDATE_EVENTS].Reset();
     }
 
     if (m_timers[WUPDATE_PINGDB].Passed())
     {
         m_timers[WUPDATE_PINGDB].Reset();
         TC_LOG_DEBUG("misc", "Ping MySQL to keep connection alive");
         CharacterDatabase.KeepAlive();
         LoginDatabase.KeepAlive();
         WorldDatabase.KeepAlive();
     }
 
     if (m_timers[WUPDATE_GUILDSAVE].Passed())
     {
         m_timers[WUPDATE_GUILDSAVE].Reset();
         sGuildMgr->SaveGuilds();
     }
 
     // update the instance reset times
     sInstanceSaveMgr->Update();
 
     // And last, but not least handle the issued cli commands
     ProcessCliCommands();
 
     sScriptMgr->OnWorldUpdate(diff);
 }

Here is the call graph for this function:

void World::UpdateAreaDependentAuras ( )

 {
     SessionMap::const_iterator itr;
     for (itr = m_sessions.begin(); itr != m_sessions.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());
         }
 }

void World::UpdateCharacterInfo	(	ObjectGuid const &	guid,
		std::string const &	name,
		uint8	gender = `GENDER_NONE`,
		uint8	race = `RACE_NONE`
	)

 {
     CharacterInfoContainer::iterator itr = _characterInfoStore.find(guid);
     if (itr == _characterInfoStore.end())
         return;
 
     itr->second.Name = name;
 
     if (gender != GENDER_NONE)
         itr->second.Sex = gender;
 
     if (race != RACE_NONE)
         itr->second.Race = race;
 
     WorldPackets::Misc::InvalidatePlayer data;
     data.Guid = guid;
     SendGlobalMessage(data.Write());
 }

Here is the call graph for this function:

void World::UpdateCharacterInfoDeleted	(	ObjectGuid const &	guid,
		bool	deleted,
		std::string const *	name = `nullptr`
	)

 {
     CharacterInfoContainer::iterator itr = _characterInfoStore.find(guid);
     if (itr == _characterInfoStore.end())
         return;
 
     itr->second.IsDeleted = deleted;
 
     if (name)
         itr->second.Name = *name;
 }

void World::UpdateCharacterInfoLevel	(	ObjectGuid const &	guid,
		uint8	level
	)

 {
     CharacterInfoContainer::iterator itr = _characterInfoStore.find(guid);
     if (itr == _characterInfoStore.end())
         return;
 
     itr->second.Level = level;
 }

void World::UpdateMaxSessionCounters ( )

Get the number of current active sessions.

 {
     m_maxActiveSessionCount = std::max(m_maxActiveSessionCount, uint32(m_sessions.size()-m_QueuedPlayer.size()));
     m_maxQueuedSessionCount = std::max(m_maxQueuedSessionCount, uint32(m_QueuedPlayer.size()));
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void World::UpdateRealmCharCount ( uint32 accid )

 {
     PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_CHARACTER_COUNT);
     stmt->setUInt32(0, accountId);
     m_realmCharCallbacks.push_back(CharacterDatabase.AsyncQuery(stmt));
 }

Here is the call graph for this function:

void World::UpdateSessions ( uint32 diff )

Add new sessions
Then send an update signal to remaining ones
and remove not active sessions from the list

 {
     std::pair<std::weak_ptr<WorldSocket>, uint64> linkInfo;
     while (_linkSocketQueue.next(linkInfo))
         ProcessLinkInstanceSocket(std::move(linkInfo));
 
     WorldSession* sess = NULL;
     while (addSessQueue.next(sess))
         AddSession_ (sess);
 
     for (SessionMap::iterator itr = m_sessions.begin(), next; itr != m_sessions.end(); itr = next)
     {
         next = itr;
         ++next;
 
         WorldSession* pSession = itr->second;
         WorldSessionFilter updater(pSession);
 
         if (!pSession->Update(diff, updater))    // As interval = 0
         {
             if (!RemoveQueuedPlayer(itr->second) && itr->second && getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE))
                 m_disconnects[itr->second->GetAccountId()] = time(NULL);
             RemoveQueuedPlayer(pSession);
             m_sessions.erase(itr);
             delete pSession;
 
         }
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

CharacterInfoContainer World::_characterInfoStore

private

LockedQueue<std::pair<std::weak_ptr<WorldSocket>, uint64> > World::_linkSocketQueue

private

std::vector<std::string> World::_motd

private

LockedQueue<WorldSession*> World::addSessQueue

private

LockedQueue<CliCommandHolder*> World::cliCmdQueue

private

AccountTypes World::m_allowedSecurityLevel

private

bool World::m_allowMovement

private

AutobroadcastsMap World::m_Autobroadcasts

private

AutobroadcastsWeightMap World::m_AutobroadcastsWeights

private

uint32 World::m_availableDbcLocaleMask

private

bool World::m_bool_configs[BOOL_CONFIG_VALUE_COUNT]

private

uint32 World::m_CleaningFlags

private

uint32 World::m_currentTime

private

std::string World::m_dataPath

private

std::string World::m_DBVersion

private

LocaleConstant World::m_defaultDbcLocale

private

DisconnectMap World::m_disconnects

private

TC_GAME_API uint8 World::m_ExitCode = SHUTDOWN_EXIT_CODE

staticprivate

float World::m_float_configs[FLOAT_CONFIG_VALUE_COUNT]

private

time_t World::m_gameTime

private

uint32 World::m_int_configs[INT_CONFIG_VALUE_COUNT]

private

bool World::m_isClosed

private

uint32 World::m_maxActiveSessionCount

private

uint32 World::m_MaxPlayerCount

private

uint32 World::m_maxQueuedSessionCount

private

TC_GAME_API float World::m_MaxVisibleDistanceInBGArenas = DEFAULT_VISIBILITY_BGARENAS

staticprivate

TC_GAME_API float World::m_MaxVisibleDistanceInInstances = DEFAULT_VISIBILITY_INSTANCE

staticprivate

TC_GAME_API float World::m_MaxVisibleDistanceOnContinents = DEFAULT_VISIBILITY_DISTANCE

staticprivate

std::string World::m_newCharString

private

time_t World::m_NextCurrencyReset

private

time_t World::m_NextDailyQuestReset

private

time_t World::m_NextGuildReset

private

time_t World::m_NextMonthlyQuestReset

private

time_t World::m_NextRandomBGReset

private

time_t World::m_NextWeeklyQuestReset

private

uint32 World::m_PlayerCount

private

uint32 World::m_playerLimit

private

Queue World::m_QueuedPlayer

private

std::deque<PreparedQueryResultFuture> World::m_realmCharCallbacks

private

SessionMap World::m_sessions

private

uint32 World::m_ShutdownMask

private

uint32 World::m_ShutdownTimer

private

time_t World::m_startTime

private

TC_GAME_API std::atomic< bool > World::m_stopEvent

staticprivate

IntervalTimer World::m_timers[WUPDATE_COUNT]

private

uint32 World::m_updateTime

private

uint32 World::m_updateTimeCount

private

uint32 World::m_updateTimeSum

private

TC_GAME_API int32 World::m_visibility_notify_periodInBGArenas = DEFAULT_VISIBILITY_NOTIFY_PERIOD

staticprivate

TC_GAME_API int32 World::m_visibility_notify_periodInInstances = DEFAULT_VISIBILITY_NOTIFY_PERIOD

staticprivate

TC_GAME_API int32 World::m_visibility_notify_periodOnContinents = DEFAULT_VISIBILITY_NOTIFY_PERIOD

staticprivate

TC_GAME_API std::atomic< uint32 > World::m_worldLoopCounter

static

WorldStatesMap World::m_worldstates

private

time_t World::mail_timer

private

time_t World::mail_timer_expires

private

float World::rate_values[MAX_RATES]

private

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

src/server/game/World/World.h
src/server/game/World/World.cpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation