WorldSessionMgr Class Reference

#include "WorldSessionMgr.h"

Public Types
typedef std::unordered_map< uint32, WorldSession * >	SessionMap

Public Member Functions
	WorldSessionMgr ()
	~WorldSessionMgr ()
WorldSession *	FindSession (uint32 id) const
	Find a session by its id.
WorldSession *	FindOfflineSession (uint32 id) const
WorldSession *	FindOfflineSessionForCharacterGUID (ObjectGuid::LowType guidLow) const
void	UpdateSessions (uint32 const diff)
bool	KickSession (uint32 id)
	Remove a given session.
void	KickAll ()
	Kick (and save) all players.
void	KickAllLess (AccountTypes sec)
	Kick (and save) all players with security level less sec
void	AddSession (WorldSession *session)
void	AddQueuedPlayer (WorldSession *session)
bool	RemoveQueuedPlayer (WorldSession *session)
int32	GetQueuePos (WorldSession *session)
bool	HasRecentlyDisconnected (WorldSession *session)
SessionMap const &	GetAllSessions () const
void	UpdateMaxSessionCounters ()
	Get the number of current active sessions.
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.
uint32	GetMaxActiveSessionCount () const
uint32	GetPlayerCount () const
	Get number of players.
uint32	GetMaxPlayerCount () const
void	SetPlayerAmountLimit (uint32 limit)
	Active session server limit.
uint32	GetPlayerAmountLimit () const
void	IncreasePlayerCount ()
	Increase/Decrease number of players.
void	DecreasePlayerCount ()
void	SendGlobalMessage (WorldPacket const *packet, WorldSession *self=nullptr, TeamId teamId=TEAM_NEUTRAL)
	Send a packet to all players (except self if mentioned)
void	SendGlobalGMMessage (WorldPacket const *packet, WorldSession *self=nullptr, TeamId teamId=TEAM_NEUTRAL)
	Send a packet to all GMs (except self if mentioned)
void	SendServerMessage (ServerMessageType messageID, std::string stringParam="", Player *player=nullptr)
	Send a server message to the user(s)
void	DoForAllOnlinePlayers (std::function< void(Player *)> exec)

Static Public Member Functions
static WorldSessionMgr *	Instance ()

Private Types
typedef std::unordered_map< uint32, time_t >	DisconnectMap
typedef std::list< WorldSession * >	Queue

Private Member Functions
void	AddSession_ (WorldSession *session)

Private Attributes
LockedQueue< WorldSession * >	_addSessQueue
SessionMap	_sessions
SessionMap	_offlineSessions
std::map< uint32, AccountPlayHistory >	_accountsPlayHistory
DisconnectMap	_disconnects
Queue	_queuedPlayer
uint32	_playerLimit
uint32	_maxActiveSessionCount
uint32	_maxQueuedSessionCount
uint32	_playerCount
uint32	_maxPlayerCount
uint32	_stalePruneTimer

Detailed Description

Member Typedef Documentation

DisconnectMap

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

private

Queue

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

private

SessionMap

typedef std::unordered_map<uint32, WorldSession*> WorldSessionMgr::SessionMap

Constructor & Destructor Documentation

WorldSessionMgr()

WorldSessionMgr::WorldSessionMgr

(

)

{
    _playerLimit = 0;
    _maxActiveSessionCount = 0;
    _maxQueuedSessionCount = 0;
    _playerCount = 0;
    _maxPlayerCount = 0;
    _stalePruneTimer = 0;
}

References _maxActiveSessionCount, _maxPlayerCount, _maxQueuedSessionCount, _playerCount, _playerLimit, and _stalePruneTimer.

~WorldSessionMgr()

WorldSessionMgr::~WorldSessionMgr

(

)

• Empty the kicked session set

{
    while (!_sessions.empty())
    {
        // not remove from queue, prevent loading new sessions
        delete _sessions.begin()->second;
        _sessions.erase(_sessions.begin());
    }
 
    while (!_offlineSessions.empty())
    {
        delete _offlineSessions.begin()->second;
        _offlineSessions.erase(_offlineSessions.begin());
    }
}

References _offlineSessions, and _sessions.

Member Function Documentation

AddQueuedPlayer()

void WorldSessionMgr::AddQueuedPlayer

(

WorldSession *

session

)

{
    session->SetInQueue(true);
    _queuedPlayer.push_back(session);
 
    // The 1st SMSG_AUTH_RESPONSE needs to contain other info too.
    session->SendAuthResponse(AUTH_WAIT_QUEUE, false, GetQueuePos(session));
}

References _queuedPlayer, AUTH_WAIT_QUEUE, GetQueuePos(), WorldSession::SendAuthResponse(), and WorldSession::SetInQueue().

Referenced by AddSession_().

AddSession()

void WorldSessionMgr::AddSession

(

WorldSession *

session

)

{
    _addSessQueue.add(session);
}

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

AddSession_()

void WorldSessionMgr::AddSession_ ( WorldSession *  session )

private

{
    ASSERT(session);
 
    // kick existing session with same account (if any)
    // if character on old session is being loaded, then return
    if (!KickSession(session->GetAccountId()))
    {
        session->KickPlayer("kick existing session with same account");
        delete session; // session not added yet in session list, so not listed in queue
        return;
    }
 
    SessionMap::const_iterator old = _sessions.find(session->GetAccountId());
    if (old != _sessions.end())
    {
        WorldSession* oldSession = old->second;
 
        if (!RemoveQueuedPlayer(oldSession) && sWorld->getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE))
            _disconnects[session->GetAccountId()] = GameTime::GetGameTime().count();
 
        // don't allow resetting consecutive play time on double login to same account
        session->SetPreviousPlayedTime(old->second->GetConsecutivePlayTime(GameTime::GetGameTime()));
 
        // pussywizard:
        if (oldSession->HandleSocketClosed())
        {
            // there should be no offline session if current one is logged onto a character
            SessionMap::iterator iter;
            if ((iter = _offlineSessions.find(oldSession->GetAccountId())) != _offlineSessions.end())
            {
                WorldSession* tmp = iter->second;
                _offlineSessions.erase(iter);
                delete tmp;
            }
            oldSession->SetOfflineTime(GameTime::GetGameTime().count());
            _offlineSessions[oldSession->GetAccountId()] = oldSession;
        }
        else
            delete oldSession;
    }
    else
    {
        auto itr = _accountsPlayHistory.find(session->GetAccountId());
        if (itr != _accountsPlayHistory.end())
        {
            // carry consecutive play time only if the offline gap was under the reset window
            if ((GameTime::GetGameTime() - itr->second.logoutTime) < PLAY_TIME_LIMIT_FULL)
                session->SetPreviousPlayedTime(itr->second.playedTime);
 
            // entry consumed on login; erase so _accountsPlayHistory cannot grow unbounded
            _accountsPlayHistory.erase(itr);
        }
    }
 
    _sessions[session->GetAccountId()] = session;
 
    uint32 Sessions = GetActiveAndQueuedSessionCount();
    uint32 pLimit = GetPlayerAmountLimit();
 
    // don't count this session when checking player limit
    --Sessions;
 
    // Trial accounts do not get account-flag queue priority. RBAC_PERM_SKIP_QUEUE is still honored
    // since it can be granted intentionally to specific accounts.
    bool trialQueueRestricted = sWorld->getBoolConfig(CONFIG_TRIAL_RESTRICTION_QUEUE) && session->IsTrialAccount();
    bool canSkipQueue = session->HasPermission(rbac::RBAC_PERM_SKIP_QUEUE) || (!trialQueueRestricted && session->CanSkipQueue());
 
    if (pLimit > 0 && Sessions >= pLimit && !canSkipQueue && !HasRecentlyDisconnected(session))
    {
        AddQueuedPlayer(session);
        UpdateMaxSessionCounters();
        return;
    }
 
    session->InitializeSession();
 
    UpdateMaxSessionCounters();
}

References _accountsPlayHistory, _disconnects, _offlineSessions, _sessions, AddQueuedPlayer(), ASSERT, WorldSession::CanSkipQueue(), CONFIG_INTERVAL_DISCONNECT_TOLERANCE, CONFIG_TRIAL_RESTRICTION_QUEUE, WorldSession::GetAccountId(), GetActiveAndQueuedSessionCount(), GameTime::GetGameTime(), GetPlayerAmountLimit(), WorldSession::HandleSocketClosed(), WorldSession::HasPermission(), HasRecentlyDisconnected(), WorldSession::InitializeSession(), WorldSession::IsTrialAccount(), WorldSession::KickPlayer(), KickSession(), PLAY_TIME_LIMIT_FULL, rbac::RBAC_PERM_SKIP_QUEUE, RemoveQueuedPlayer(), WorldSession::SetOfflineTime(), WorldSession::SetPreviousPlayedTime(), sWorld, and UpdateMaxSessionCounters().

Referenced by UpdateSessions().

DecreasePlayerCount()

void WorldSessionMgr::DecreasePlayerCount ( )

inline

{ _playerCount--; }

References _playerCount.

DoForAllOnlinePlayers()

void WorldSessionMgr::DoForAllOnlinePlayers

(

std::function< void(Player *)>

exec

)

{
    std::shared_lock lock(*HashMapHolder<Player>::GetLock());
    for (auto const& it : ObjectAccessor::GetPlayers())
    {
        if (Player* player = it.second)
        {
            if (!player->IsInWorld())
            {
                continue;
            }
 
            exec(player);
        }
    }
}

References ObjectAccessor::GetPlayers().

FindOfflineSession()

WorldSession * WorldSessionMgr::FindOfflineSession

(

uint32

id

)

const

{
    SessionMap::const_iterator itr = _offlineSessions.find(id);
    if (itr != _offlineSessions.end())
        return itr->second;
    else
        return nullptr;
}

References _offlineSessions.

FindOfflineSessionForCharacterGUID()

WorldSession * WorldSessionMgr::FindOfflineSessionForCharacterGUID

(

ObjectGuid::LowType

guidLow

)

const

{
    if (_offlineSessions.empty())
        return nullptr;
 
    for (SessionMap::const_iterator itr = _offlineSessions.begin(); itr != _offlineSessions.end(); ++itr)
        if (itr->second->GetGuidLow() == guidLow)
            return itr->second;
 
    return nullptr;
}

References _offlineSessions.

FindSession()

WorldSession * WorldSessionMgr::FindSession

(

uint32

id

)

const

Find a session by its id.

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

References _sessions.

GetActiveAndQueuedSessionCount()

uint32 WorldSessionMgr::GetActiveAndQueuedSessionCount ( ) const

inline

{ return _sessions.size(); }

References _sessions.

Referenced by AddSession_().

GetActiveSessionCount()

uint32 WorldSessionMgr::GetActiveSessionCount ( ) const

inline

{ return _sessions.size() - _queuedPlayer.size(); }

References _queuedPlayer, and _sessions.

Referenced by RemoveQueuedPlayer().

GetAllSessions()

SessionMap const & WorldSessionMgr::GetAllSessions ( ) const

inline

{ return _sessions; }

References _sessions.

GetMaxActiveSessionCount()

uint32 WorldSessionMgr::GetMaxActiveSessionCount ( ) const

inline

{ return _maxActiveSessionCount; }

References _maxActiveSessionCount.

GetMaxPlayerCount()

uint32 WorldSessionMgr::GetMaxPlayerCount ( ) const

inline

{ return _maxPlayerCount; }

References _maxPlayerCount.

GetMaxQueuedSessionCount()

uint32 WorldSessionMgr::GetMaxQueuedSessionCount ( ) const

inline

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

{ return _maxQueuedSessionCount; }

References _maxQueuedSessionCount.

GetPlayerAmountLimit()

uint32 WorldSessionMgr::GetPlayerAmountLimit ( ) const

inline

{ return _playerLimit; }

References _playerLimit.

Referenced by AddSession_(), and RemoveQueuedPlayer().

GetPlayerCount()

uint32 WorldSessionMgr::GetPlayerCount ( ) const

inline

Get number of players.

{ return _playerCount; }

References _playerCount.

GetQueuedSessionCount()

uint32 WorldSessionMgr::GetQueuedSessionCount ( ) const

inline

{ return _queuedPlayer.size(); }

References _queuedPlayer.

GetQueuePos()

int32 WorldSessionMgr::GetQueuePos

(

WorldSession *

session

)

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

References _queuedPlayer.

Referenced by AddQueuedPlayer().

HasRecentlyDisconnected()

bool WorldSessionMgr::HasRecentlyDisconnected

(

WorldSession *

session

)

{
    if (!session)
        return false;
 
    if (uint32 tolerance = sWorld->getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE))
    {
        for (DisconnectMap::iterator i = _disconnects.begin(); i != _disconnects.end();)
        {
            if ((GameTime::GetGameTime().count() - i->second) < tolerance)
            {
                if (i->first == session->GetAccountId())
                    return true;
                ++i;
            }
            else
                _disconnects.erase(i++);
        }
    }
    return false;
}

References _disconnects, CONFIG_INTERVAL_DISCONNECT_TOLERANCE, WorldSession::GetAccountId(), GameTime::GetGameTime(), and sWorld.

Referenced by AddSession_().

IncreasePlayerCount()

void WorldSessionMgr::IncreasePlayerCount ( )

inline

Increase/Decrease number of players.

    {
        _playerCount++;
        _maxPlayerCount = std::max(_maxPlayerCount, _playerCount);
    }

References _maxPlayerCount, and _playerCount.

Instance()

WorldSessionMgr * WorldSessionMgr::Instance ( )

static

{
    static WorldSessionMgr instance;
    return &instance;
}

KickAll()

void WorldSessionMgr::KickAll

(

)

Kick (and save) all players.

{
    _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 = _sessions.begin(); itr != _sessions.end(); ++itr)
        itr->second->KickPlayer("KickAll sessions");
 
    // pussywizard: kick offline sessions
    for (SessionMap::const_iterator itr = _offlineSessions.begin(); itr != _offlineSessions.end(); ++itr)
        itr->second->KickPlayer("KickAll offline sessions");
}

References _offlineSessions, _queuedPlayer, and _sessions.

KickAllLess()

void WorldSessionMgr::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 = _sessions.begin(); itr != _sessions.end(); ++itr)
        if (itr->second->GetSecurity() < sec)
            itr->second->KickPlayer("KickAllLess");
}

References _sessions.

KickSession()

bool WorldSessionMgr::KickSession

(

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 = _sessions.find(id);
 
    if (itr != _sessions.end() && itr->second)
    {
        if (itr->second->PlayerLoading())
            return false;
 
        itr->second->KickPlayer("KickSession", false);
    }
 
    return true;
}

References _sessions, and WorldSession::KickPlayer().

Referenced by AddSession_().

RemoveQueuedPlayer()

bool WorldSessionMgr::RemoveQueuedPlayer

(

WorldSession *

session

)

{
    uint32 sessions = GetActiveSessionCount();
 
    uint32 position = 1;
    Queue::iterator iter = _queuedPlayer.begin();
 
    // search to remove and count skipped positions
    bool found = false;
 
    for (; iter != _queuedPlayer.end(); ++iter, ++position)
    {
        if (*iter == session)
        {
            session->SetInQueue(false);
            session->ResetTimeOutTime(false);
            iter = _queuedPlayer.erase(iter);
            found = true;
            break;
        }
    }
 
    // if session not queued then it was an active session
    if (!found)
    {
        ASSERT(sessions > 0);
        --sessions;
    }
 
    // accept first in queue
    if ((!GetPlayerAmountLimit() || sessions < GetPlayerAmountLimit()) && !_queuedPlayer.empty())
    {
        WorldSession* pop_sess = _queuedPlayer.front();
        pop_sess->InitializeSession();
        _queuedPlayer.pop_front();
 
        // update iter to point first queued socket or end() if queue is empty now
        iter = _queuedPlayer.begin();
        position = 1;
    }
 
    // update queue position from iter to end()
    for (; iter != _queuedPlayer.end(); ++iter, ++position)
        (*iter)->SendAuthWaitQueue(position);
 
    return found;
}

References _queuedPlayer, ASSERT, GetActiveSessionCount(), GetPlayerAmountLimit(), WorldSession::InitializeSession(), WorldSession::ResetTimeOutTime(), and WorldSession::SetInQueue().

Referenced by AddSession_(), and UpdateSessions().

SendGlobalGMMessage()

void WorldSessionMgr::SendGlobalGMMessage	(	WorldPacket const *	packet,
		WorldSession *	self = nullptr,
		TeamId	teamId = TEAM_NEUTRAL
	)

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

{
    SessionMap::iterator itr;
    for (itr = _sessions.begin(); itr != _sessions.end(); ++itr)
    {
        if (itr->second &&
            itr->second->GetPlayer() &&
            itr->second->GetPlayer()->IsInWorld() &&
            itr->second != self &&
            itr->second->HasPermission(rbac::RBAC_PERM_RECEIVE_GLOBAL_GM_TEXTMESSAGE) &&
            (teamId == TEAM_NEUTRAL || itr->second->GetPlayer()->GetTeamId() == teamId))
        {
            itr->second->SendPacket(packet);
        }
    }
}

References _sessions, WorldSession::HasPermission(), rbac::RBAC_PERM_RECEIVE_GLOBAL_GM_TEXTMESSAGE, and TEAM_NEUTRAL.

SendGlobalMessage()

void WorldSessionMgr::SendGlobalMessage	(	WorldPacket const *	packet,
		WorldSession *	self = nullptr,
		TeamId	teamId = TEAM_NEUTRAL
	)

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

{
    SessionMap::const_iterator itr;
    for (itr = _sessions.begin(); itr != _sessions.end(); ++itr)
    {
        if (itr->second &&
            itr->second->GetPlayer() &&
            itr->second->GetPlayer()->IsInWorld() &&
            itr->second != self &&
            (teamId == TEAM_NEUTRAL || itr->second->GetPlayer()->GetTeamId() == teamId))
        {
            itr->second->SendPacket(packet);
        }
    }
}

References _sessions, and TEAM_NEUTRAL.

Referenced by SendServerMessage().

SendServerMessage()

void WorldSessionMgr::SendServerMessage	(	ServerMessageType	messageID,
		std::string	stringParam = "",
		Player *	player = nullptr
	)

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->SendDirectMessage(chatServerMessage.Write());
    else
        SendGlobalMessage(chatServerMessage.Write());
}

References WorldPackets::Chat::ChatServerMessage::MessageID, Player::SendDirectMessage(), SendGlobalMessage(), SERVER_MSG_STRING, WorldPackets::Chat::ChatServerMessage::StringParam, and WorldPackets::Chat::ChatServerMessage::Write().

SetPlayerAmountLimit()

void WorldSessionMgr::SetPlayerAmountLimit ( uint32  limit )

inline

Active session server limit.

{ _playerLimit = limit; }

References _playerLimit.

UpdateMaxSessionCounters()

void WorldSessionMgr::UpdateMaxSessionCounters

(

)

Get the number of current active sessions.

{
    _maxActiveSessionCount = std::max(_maxActiveSessionCount, uint32(_sessions.size() - _queuedPlayer.size()));
    _maxQueuedSessionCount = std::max(_maxQueuedSessionCount, uint32(_queuedPlayer.size()));
}

References _maxActiveSessionCount, _maxQueuedSessionCount, _queuedPlayer, and _sessions.

Referenced by AddSession_().

UpdateSessions()

void WorldSessionMgr::UpdateSessions

(

uint32 const

diff

)

• Add new sessions

• Then send an update signal to remaining ones

• and remove not active sessions from the list

{
    _stalePruneTimer += diff;
    if (_stalePruneTimer >= 10 * MINUTE * IN_MILLISECONDS)
    {
        _stalePruneTimer = 0;
        Seconds const now = GameTime::GetGameTime();
 
        // Drop play-history entries past the reset window so the map stays bounded even for
        // accounts that disconnect and never reconnect (login only erases their own entry).
        for (auto itr = _accountsPlayHistory.begin(); itr != _accountsPlayHistory.end();)
        {
            if ((now - itr->second.logoutTime) >= PLAY_TIME_LIMIT_FULL)
                itr = _accountsPlayHistory.erase(itr);
            else
                ++itr;
        }
 
        // Drop disconnect entries past the tolerance window so the map stays bounded on realms that never
        // reach PlayerLimit (HasRecentlyDisconnected only prunes _disconnects while the queue is active).
        time_t const tolerance = sWorld->getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE);
        for (auto itr = _disconnects.begin(); itr != _disconnects.end();)
        {
            if ((now.count() - itr->second) >= tolerance)
                itr = _disconnects.erase(itr);
            else
                ++itr;
        }
    }
 
    {
        METRIC_DETAILED_NO_THRESHOLD_TIMER("world_update_time",
            METRIC_TAG("type", "Add sessions"),
            METRIC_TAG("parent_type", "Update sessions"));
 
        WorldSession* sess = nullptr;
        while (_addSessQueue.next(sess))
        {
            AddSession_(sess);
        }
    }
 
    for (SessionMap::iterator itr = _sessions.begin(), next; itr != _sessions.end(); itr = next)
    {
        next = itr;
        ++next;
 
        WorldSession* pSession = itr->second;
        WorldSessionFilter updater(pSession);
 
        // pussywizard:
        if (pSession->HandleSocketClosed())
        {
            Seconds const now = GameTime::GetGameTime();
 
            if (pSession->IsAffectedByCAIS())
            {
                // a reconnect builds a fresh session and carries time from _accountsPlayHistory, so persist it
                // here at socket-close time rather than during offline cleanup (which runs ~60s later)
                AccountPlayHistory& history = _accountsPlayHistory[pSession->GetAccountId()];
                history.playedTime = pSession->GetConsecutivePlayTime(now);
                history.logoutTime = now;
            }
 
            if (!RemoveQueuedPlayer(pSession) && sWorld->getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE))
                _disconnects[pSession->GetAccountId()] = now.count();
            _sessions.erase(itr);
            // there should be no offline session if current one is logged onto a character
            SessionMap::iterator iter;
            if ((iter = _offlineSessions.find(pSession->GetAccountId())) != _offlineSessions.end())
            {
                WorldSession* tmp = iter->second;
                _offlineSessions.erase(iter);
                delete tmp;
            }
            pSession->SetOfflineTime(now.count());
            _offlineSessions[pSession->GetAccountId()] = pSession;
            continue;
        }
 
        [[maybe_unused]] uint32 currentSessionId = itr->first;
        METRIC_DETAILED_TIMER("world_update_sessions_time", METRIC_TAG("account_id", std::to_string(currentSessionId)));
 
        if (!pSession->Update(diff, updater))
        {
            Seconds const now = GameTime::GetGameTime();
 
            if (pSession->IsAffectedByCAIS())
            {
                AccountPlayHistory& history = _accountsPlayHistory[pSession->GetAccountId()];
                history.playedTime = pSession->GetConsecutivePlayTime(now);
                history.logoutTime = now;
            }
 
            if (!RemoveQueuedPlayer(pSession) && sWorld->getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE))
                _disconnects[pSession->GetAccountId()] = now.count();
            _sessions.erase(itr);
            delete pSession;
        }
    }
 
    // pussywizard:
    if (_offlineSessions.empty())
        return;
    uint32 currTime = GameTime::GetGameTime().count();
    for (SessionMap::iterator itr = _offlineSessions.begin(), next; itr != _offlineSessions.end(); itr = next)
    {
        next = itr;
        ++next;
        WorldSession* pSession = itr->second;
        // A session with a logout already running leaves when that countdown ends, so closing the client early
        // with EXIT NOW doesn't shorten it. A client crash (or sudden ALT+F4) waits out the full interval so a
        // dropped connection can be reclaimed.
        if (!pSession->GetPlayer() || pSession->IsKicked() || pSession->ShouldLogOut(currTime) ||
            pSession->GetOfflineTime() + sWorld->getIntConfig(CONFIG_INTERVAL_DISCONNECT_TOLERANCE) < currTime)
        {
            _offlineSessions.erase(itr);
            delete pSession;
        }
    }
}

References _accountsPlayHistory, _addSessQueue, _disconnects, _offlineSessions, _sessions, _stalePruneTimer, AddSession_(), CONFIG_INTERVAL_DISCONNECT_TOLERANCE, WorldSession::GetAccountId(), WorldSession::GetConsecutivePlayTime(), GameTime::GetGameTime(), WorldSession::GetOfflineTime(), WorldSession::GetPlayer(), WorldSession::HandleSocketClosed(), IN_MILLISECONDS, WorldSession::IsAffectedByCAIS(), WorldSession::IsKicked(), AccountPlayHistory::logoutTime, METRIC_DETAILED_NO_THRESHOLD_TIMER, METRIC_DETAILED_TIMER, METRIC_TAG, MINUTE, LockedQueue< T, StorageType >::next(), PLAY_TIME_LIMIT_FULL, AccountPlayHistory::playedTime, RemoveQueuedPlayer(), WorldSession::SetOfflineTime(), WorldSession::ShouldLogOut(), sWorld, and WorldSession::Update().

Member Data Documentation

_accountsPlayHistory

std::map<uint32 , AccountPlayHistory> WorldSessionMgr::_accountsPlayHistory

private

Referenced by AddSession_(), and UpdateSessions().

_addSessQueue

LockedQueue<WorldSession*> WorldSessionMgr::_addSessQueue

private

Referenced by AddSession(), and UpdateSessions().

_disconnects

DisconnectMap WorldSessionMgr::_disconnects

private

Referenced by AddSession_(), HasRecentlyDisconnected(), and UpdateSessions().

_maxActiveSessionCount

uint32 WorldSessionMgr::_maxActiveSessionCount

private

Referenced by GetMaxActiveSessionCount(), UpdateMaxSessionCounters(), and WorldSessionMgr().

_maxPlayerCount

uint32 WorldSessionMgr::_maxPlayerCount

private

Referenced by GetMaxPlayerCount(), IncreasePlayerCount(), and WorldSessionMgr().

_maxQueuedSessionCount

uint32 WorldSessionMgr::_maxQueuedSessionCount

private

Referenced by GetMaxQueuedSessionCount(), UpdateMaxSessionCounters(), and WorldSessionMgr().

_offlineSessions

SessionMap WorldSessionMgr::_offlineSessions

private

Referenced by AddSession_(), FindOfflineSession(), FindOfflineSessionForCharacterGUID(), KickAll(), UpdateSessions(), and ~WorldSessionMgr().

_playerCount

uint32 WorldSessionMgr::_playerCount

private

Referenced by DecreasePlayerCount(), GetPlayerCount(), IncreasePlayerCount(), and WorldSessionMgr().

_playerLimit

uint32 WorldSessionMgr::_playerLimit

private

Referenced by GetPlayerAmountLimit(), SetPlayerAmountLimit(), and WorldSessionMgr().

_queuedPlayer

Queue WorldSessionMgr::_queuedPlayer

private

Referenced by AddQueuedPlayer(), GetActiveSessionCount(), GetQueuedSessionCount(), GetQueuePos(), KickAll(), RemoveQueuedPlayer(), and UpdateMaxSessionCounters().

_sessions

SessionMap WorldSessionMgr::_sessions

private

Referenced by AddSession_(), FindSession(), GetActiveAndQueuedSessionCount(), GetActiveSessionCount(), GetAllSessions(), KickAll(), KickAllLess(), KickSession(), SendGlobalGMMessage(), SendGlobalMessage(), UpdateMaxSessionCounters(), UpdateSessions(), and ~WorldSessionMgr().

_stalePruneTimer

uint32 WorldSessionMgr::_stalePruneTimer

private

Referenced by UpdateSessions(), and WorldSessionMgr().

---

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

• azerothcore-wotlk/src/server/game/Server/WorldSessionMgr.h
• azerothcore-wotlk/src/server/game/Server/WorldSessionMgr.cpp