Horizon::Zone::ZoneSession Class Reference

#include <ZoneSession.hpp>

Inheritance diagram for Horizon::Zone::ZoneSession:

Collaboration diagram for Horizon::Zone::ZoneSession:

Public Member Functions
	ZoneSession (uint64_t uid)
	~ZoneSession ()
void	transmit_buffer (ByteBuffer _buffer, std::size_t size)
	Queues a buffer to be sent to the client. More...
void	update (uint32_t diff)
	Update loop for each Zone Session. More...
void	perform_cleanup ()
	Performs generic logout of player in cases where the connection was closed abruptly or by instruction. More...
void	initialize ()
	Initializes the zone session's members. More...
std::unique_ptr< ZoneClientInterface > &	clif ()
std::unique_ptr< ClientPacketLengthTable > &	pkt_tbl ()
std::shared_ptr< Units::Player >	player ()
void	set_player (std::shared_ptr< Units::Player > pl)
std::string	get_map_name ()
void	set_map_name (std::string map_name)
Public Member Functions inherited from Horizon::Networking::Session< ZoneSocket, ZoneSession >
	Session (uint64_t uid)
virtual	~Session ()
std::shared_ptr< ZoneSocket >	get_socket ()
	Get the socket. More...
void	set_socket (std::weak_ptr< ZoneSocket > socket)
	Set the socket. More...
virtual void	update (uint32_t diff)=0
virtual void	initialize ()=0
bool	is_initialized ()
	Called to verify if the session is initialized. More...
void	set_initialized (bool initialized)
	Set whether the session is initialized or not. More...
uint64_t	get_session_id ()
	Get the unique id of the session. More...
ThreadSafeQueue< ByteBuffer > &	get_recv_queue ()
	Receive queue of the buffer received by the socket. More...

Protected Attributes
std::unique_ptr< ZoneClientInterface >	_clif
std::unique_ptr< ClientPacketLengthTable >	_pkt_tbl
std::shared_ptr< Units::Player >	_player
std::string	_map_name {""}

Detailed Description

ZoneSession is responsible for handling the session of a client.

Constructor & Destructor Documentation

ZoneSession()

ZoneSession::ZoneSession

(

uint64_t

uid

)

This is the constructor of the class ZoneSession.

Parameters

uid	is a int64_t variable which is used to handle the unique id of the session.
socket	is a shared pointer of type ZoneSocket which is used to handle the socket.

: Session(uid)
{
}

~ZoneSession()

ZoneSession::~ZoneSession

(

)

This is the destructor of the class ZoneSession.

Returns

void

{
    //
}

Member Function Documentation

clif()

std::unique_ptr< ZoneClientInterface > & Horizon::Zone::ZoneSession::clif ( )

inline

This function is a getter function which is used to get the client interface.

Returns

std::unique_ptr<ZoneClientInterface> &

{ return _clif; }

References _clif.

get_map_name()

std::string Horizon::Zone::ZoneSession::get_map_name ( )

inline

This function is a getter function which is used to get the map name.

{ return _map_name; }

References _map_name.

initialize()

void ZoneSession::initialize ( )

virtual

Initializes the zone session's members.

This function is used to handle the initialization of the session.

Returns

void

@thread Initialized from the Network Thread after socket and session creation.

Implements Horizon::Networking::Session< ZoneSocket, ZoneSession >.

{
    try {
        // Initialize the packet length table. This is used to determine the length of the packet from the packet id.
        _pkt_tbl = std::make_unique<ClientPacketLengthTable>(shared_from_this());
        // Initialize the packet handler. This is used to handle the packets received from the client.
        _clif = std::make_unique<ZoneClientInterface>(shared_from_this());
        // It is the responsibility of this method to initialize the player, but 
        // since player is the map owning thread's responsibility, we wait for the
        // session to start by letting the client send a CZ_ENTER packet.
        // When the packet is sent, the player will be created by the Networking Thread.
        // Initialized by the GameLogicProcess.
        set_initialized(true);
    }
    catch (std::exception& error) {
        HLog(error) << "ZoneSession::initialize: " << error.what();
    }
}

References _clif, _pkt_tbl, HLog, and Horizon::Networking::Session< ZoneSocket, ZoneSession >::set_initialized().

Here is the call graph for this function:

perform_cleanup()

void ZoneSession::perform_cleanup

(

)

Performs generic logout of player in cases where the connection was closed abruptly or by instruction.

This function is used to handle the cleanup of the session.

Returns

void

Also marks the player for removal from the MapContainerThread. @thread Called from the NetworkThread.

{
    //sZone->get_component_of_type<GameLogicProcess>(Horizon::System::RUNTIME_GAMELOGIC)->manage_session_in_map(SESSION_ACTION_LOGOUT_AND_REMOVE, get_map_name(), shared_from_this());
}

pkt_tbl()

std::unique_ptr< ClientPacketLengthTable > & Horizon::Zone::ZoneSession::pkt_tbl ( )

inline

This function is a getter function which is used to get the client packet length table.

Returns

std::unique_ptr<ClientPacketLengthTable> &

{ return _pkt_tbl; }

References _pkt_tbl.

player()

std::shared_ptr< Units::Player > Horizon::Zone::ZoneSession::player ( )

inline

This function is a getter function which is used to get the player.

Returns

std::shared_ptr<Units::Player>

{ return _player; }

References _player.

set_map_name()

void Horizon::Zone::ZoneSession::set_map_name ( std::string  map_name )

inline

{ _map_name = map_name; }

References _map_name.

set_player()

void Horizon::Zone::ZoneSession::set_player ( std::shared_ptr< Units::Player >  pl )

inline

This function is a setter function which is used to set the player.

Parameters

pl	is a shared pointer of type Player which is used to set the _player variable.

Returns

void

{ _player = pl; }

References _player.

transmit_buffer()

void ZoneSession::transmit_buffer	(	ByteBuffer	_buffer,
		std::size_t	size
	)

Queues a buffer to be sent to the client.

This function is used to queue the buffer to be sent to the client.

Parameters

_buffer	is a reference to a ByteBuffer which is used to handle the buffer.
size	is a size_t variable which is used to handle the size of the buffer.

Returns

void

Return values

None

Side Effects: None

Thread Safety: None

Sync/Async: None

Reentrancy: None

Parameters

_buffer	The buffer to be sent.
size	The size of the buffer.

Returns

void

{
    if (get_socket() == nullptr || !get_socket()->is_open())
        return;
    
    if (!_buffer.is_empty()) {
        uint16_t packet_id = 0x0;
        int16_t packet_len = 0;
        
        memcpy(&packet_id, _buffer.get_read_pointer(), sizeof(int16_t));
        
        TPacketTablePairType p = _pkt_tbl->get_tpacket_info(packet_id);
 
        if (p.first == -1) {
            memcpy(&packet_len, _buffer.get_read_pointer() + 2, sizeof(int16_t));
        } else {
            packet_len = p.first;
        }
 
        // Warns when the packet length is not the same as the buffer length.
        if (packet_len != _buffer.active_length()) {
            HLog(warning) << "Packet 0x" << std::hex << packet_id << " has length " << std::dec << packet_len << " but buffer has " << _buffer.active_length() << " bytes... ignoring.";
            return;
        }
 
        // Queue the buffer for the Network Thread to send.
        get_socket()->queue_buffer(std::move(_buffer));
    }
}

References _pkt_tbl, ByteBuffer::active_length(), ByteBuffer::get_read_pointer(), Horizon::Networking::Session< ZoneSocket, ZoneSession >::get_socket(), HLog, and ByteBuffer::is_empty().

Here is the call graph for this function:

update()

void ZoneSession::update ( uint32_t  diff )

virtual

Update loop for each Zone Session.

This function is used to handle the incoming packets from the client and categorize the packets to be processed by the server.

Parameters

diff	is a uint32_t variable which is used to handle the time difference.

Returns

void

@thread called from Runtime.

See also

Horizon::System::RUNTIME_RUNTIME

Implements Horizon::Networking::Session< ZoneSocket, ZoneSession >.

{
    std::shared_ptr<ByteBuffer> read_buf;
    
    if (get_socket() == nullptr || !get_socket()->is_open())
        return;
 
    while ((read_buf = get_recv_queue().try_pop())) {
        while (read_buf->active_length()) {
            uint16_t packet_id = 0x0;
            memcpy(&packet_id, read_buf->get_read_pointer(), sizeof(int16_t));
            HPacketTablePairType p = _pkt_tbl->get_hpacket_info(packet_id);
 
            int16_t packet_len = p.first;
 
            if (packet_len == -1) {
                memcpy(&packet_len, read_buf->get_read_pointer() + 2, sizeof(int16_t));
            }
 
            ByteBuffer buf(*read_buf, packet_len);
            HLog(debug) << "Handling packet 0x" << std::hex << packet_id << " - len:" << std::dec << p.first << std::endl;
            p.second->handle(std::move(buf));
        }
    }
}

References _pkt_tbl, Horizon::Networking::Session< ZoneSocket, ZoneSession >::get_recv_queue(), Horizon::Networking::Session< ZoneSocket, ZoneSession >::get_socket(), and HLog.

Here is the call graph for this function:

Member Data Documentation

_clif

std::unique_ptr<ZoneClientInterface> Horizon::Zone::ZoneSession::_clif

protected

Referenced by clif(), and initialize().

_map_name

std::string Horizon::Zone::ZoneSession::_map_name {""}

protected

Referenced by get_map_name(), and set_map_name().

_pkt_tbl

std::unique_ptr<ClientPacketLengthTable> Horizon::Zone::ZoneSession::_pkt_tbl

protected

Referenced by initialize(), pkt_tbl(), transmit_buffer(), and update().

_player

std::shared_ptr<Units::Player> Horizon::Zone::ZoneSession::_player

protected

Referenced by player(), and set_player().

---

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

• src/Server/Zone/Session/ZoneSession.hpp
• src/Server/Zone/Session/ZoneSession.cpp