Updated all events to use sockets instead of user ptr.

Network/Event/NotifyClientDiscovered.cpp

@@ -1,23 +1,19 @@
-#include "../../global_define.h"
 #include "NotifyClientDiscovered.h"
 
-NotifyClientDiscovered::NotifyClientDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType ) : GenericMessage( 0x40 )
+#include "../../Common/Constant.h"
+
+NotifyClientDiscovered::NotifyClientDiscovered( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x40 )
 {
 	this->m_clientIp = std::move( clientIp );
 	this->m_clientPort = clientPort;
-	this->m_clientType = clientType;
 }
 
-ByteStream &NotifyClientDiscovered::Serialize()
+ByteBuffer &NotifyClientDiscovered::Serialize()
 {
 	m_stream.write_u16( m_packetId );
 	m_stream.write_u32( 0 );
 
-	if( m_clientType == RealmClientType::RETURN_TO_ARMS )
-		m_stream.write_utf8( m_clientIp );
-	else
 	m_stream.write_sz_utf8( m_clientIp );
-
 	m_stream.write_u32( m_clientPort );
 
 	return m_stream;

Network/Event/NotifyClientDiscovered.h

@@ -1,12 +1,16 @@
 #pragma once
 
+#include <string>
+
+#include "../GenericNetMessage.h"
+#include "../../Common/Constant.h"
+
 class NotifyClientDiscovered : public GenericMessage {
 private:
 	std::string m_clientIp;
 	int32_t m_clientPort;
-	RealmClientType m_clientType;
 
 public:
-	NotifyClientDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType );
+	NotifyClientDiscovered( std::string clientIp, int32_t clientPort );
-	ByteStream &Serialize() override;
+	ByteBuffer &Serialize() override;
 };

Network/Event/NotifyClientRequestConnect.cpp

@@ -1,5 +1,4 @@
-#include "../../global_define.h"
+#include "NotifyClientRequestConnect.h"
-#include "NotifyClientReqConnect.h"
 
 NotifyClientRequestConnect::NotifyClientRequestConnect( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x3F )
 {
@@ -7,7 +6,7 @@ NotifyClientRequestConnect::NotifyClientRequestConnect( std::string clientIp, in
 	this->m_clientPort = clientPort;
 }
 
-ByteStream &NotifyClientRequestConnect::Serialize()
+ByteBuffer &NotifyClientRequestConnect::Serialize()
 {
 	m_stream.write_u16( m_packetId );
 	m_stream.write_u32( 0 );

Network/Event/NotifyClientRequestConnect.h

@@ -1,5 +1,9 @@
 #pragma once
 
+#include <string>
+
+#include "../GenericNetMessage.h"
+
 class NotifyClientRequestConnect : public GenericMessage
 {
 private:
@@ -8,5 +12,5 @@ private:
 
 public:
 	NotifyClientRequestConnect( std::string clientIp, int32_t clientPort );
-	ByteStream &Serialize() override;
+	ByteBuffer &Serialize() override;
 };

Network/Event/NotifyForcedLogout.cpp

@@ -1,14 +1,15 @@
-#include "../../global_define.h"
 #include "NotifyForcedLogout.h"
 
 NotifyForcedLogout::NotifyForcedLogout() : GenericMessage( 0x41 )
 {
 }
 
-ByteStream &NotifyForcedLogout::Serialize()
+ByteBuffer &NotifyForcedLogout::Serialize()
 {
 	m_stream.write_u16( m_packetId );
 	m_stream.write_u32( 0 );
 
+	m_stream.write_u32( 0 );
+
 	return m_stream;
 }

Network/Event/NotifyForcedLogout.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include "../GenericNetMessage.h"
+
 class NotifyForcedLogout : public GenericMessage {
 private:
 
 public:
 	NotifyForcedLogout();
-	ByteStream &Serialize() override;
+	ByteBuffer &Serialize() override;
 };

Network/Event/NotifyGameDiscovered.cpp

@@ -1,19 +1,18 @@
-#include "../../global_define.h"
 #include "NotifyGameDiscovered.h"
 
-NotifyGameDiscovered::NotifyGameDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType ) : GenericMessage( 0x3E )
+NotifyGameDiscovered::NotifyGameDiscovered( std::string clientIp, int32_t clientPort, RealmGameType clientType ) : GenericMessage( 0x3E )
 {
 	this->m_clientIp = std::move( clientIp );
 	this->m_clientPort = clientPort;
 	this->m_clientType = clientType;
 }
 
-ByteStream &NotifyGameDiscovered::Serialize()
+ByteBuffer &NotifyGameDiscovered::Serialize()
 {
 	m_stream.write_u16( m_packetId );
 	m_stream.write_u32( 0 );
 
-	if( m_clientType == RealmClientType::RETURN_TO_ARMS )
+	if( m_clientType == RealmGameType::RETURN_TO_ARMS )
 		m_stream.write_utf8( m_clientIp );
 	else
 		m_stream.write_sz_utf8( m_clientIp );

Network/Event/NotifyGameDiscovered.h

@@ -1,12 +1,18 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetMessage.h"
+#include "../../Common/Constant.h"
+
 class NotifyGameDiscovered : public GenericMessage {
 private:
 	std::string m_clientIp;
 	int32_t m_clientPort;
-	RealmClientType m_clientType;
+	RealmGameType m_clientType;
 
 public:
-	NotifyGameDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType );
+	NotifyGameDiscovered( std::string clientIp, int32_t clientPort, RealmGameType clientType );
-	ByteStream &Serialize() override;
+	ByteBuffer &Serialize() override;
 };

Network/Event/Notify_4C.cpp

@@ -1,11 +1,10 @@
-#include "../../global_define.h"
 #include "Notify_4C.h"
 
 Notify_4C::Notify_4C() : GenericMessage( 0x4C )
 {
 }
 
-ByteStream &Notify_4C::Serialize()
+ByteBuffer &Notify_4C::Serialize()
 {
 	m_stream.write_u16( m_packetId );
 	m_stream.write_u32( 0 );

Network/Event/Notify_4C.h

@@ -1,9 +1,11 @@
 #pragma once
 
+#include "../GenericNetMessage.h"
+
 class Notify_4C : public GenericMessage {
 private:
 
 public:
 	Notify_4C();
-	ByteStream &Serialize() override;
+	ByteBuffer &Serialize() override;
 };

Network/Event/RequestCancelGame.cpp

@@ -1,6 +1,9 @@
-#include "../../global_define.h"
 #include "RequestCancelGame.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../logging.h"
+
 void RequestCancelGame::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -8,17 +11,32 @@ void RequestCancelGame::Deserialize( sptr_byte_stream stream )
 	m_sessionId = stream->read_encrypted_utf16();
 }
 
-sptr_generic_response RequestCancelGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestCancelGame::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+
 	if( user == nullptr )
 	{
 		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
 		return std::make_shared< ResultCancelGame >( this );
 	}
 
-	GameSessionManager::Get().RequestCancel( user );
+	if (user->m_isHost)
+	{
+		auto result = GameSessionManager::Get().RequestCancel(user);
+
+		if( false == result )
+		{
+			Log::Error( "Failed to cancel game session for user [%S]", user->m_sessionId.c_str() );
+		}
+	}
+	else
+	{
+		user->m_isHost = false;
+		user->m_gameId = -1;
+	}
 
 	return std::make_shared< ResultCancelGame >( this );
 }
@@ -28,10 +46,10 @@ ResultCancelGame::ResultCancelGame( GenericRequest *request ) : GenericResponse(
 	
 }
 
-ByteStream &ResultCancelGame::Serialize()
+ByteBuffer &ResultCancelGame::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	return m_stream;

Network/Event/RequestCancelGame.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestCancelGame : public GenericRequest
 {
 private:
@@ -11,12 +17,12 @@ public:
 		return std::make_unique< RequestCancelGame >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultCancelGame : public GenericResponse {
 public:
 	ResultCancelGame( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestCreateAccount.cpp

@@ -1,28 +1,74 @@
-#include "../../global_define.h"
 #include "RequestCreateAccount.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Crypto/PasswordHash.h"
+#include "../../Common/Constant.h"
+#include "../../Game/RealmUser.h"
+#include "../../Database/Database.h"
+#include "../../logging.h"
+
 void RequestCreateAccount::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
 
-	auto username = stream->read_encrypted_utf16();
+	m_username = Util::WideToUTF8( stream->read_encrypted_utf16() );
-	auto password = stream->read_encrypted_utf16();
+	m_password = Util::WideToUTF8( stream->read_encrypted_utf16() );
-	auto emailAddress = stream->read_encrypted_utf16();
+	m_emailAddress = Util::WideToUTF8( stream->read_encrypted_utf16() );
-	auto dateOfBirth = stream->read_encrypted_utf16();
+	m_dateOfBirth = Util::WideToUTF8( stream->read_encrypted_utf16() );
-	auto chatHandle = stream->read_encrypted_utf16();
+	m_chatHandle = Util::WideToUTF8( stream->read_encrypted_utf16() );
-
-	int dbg = 0;
 }
 
-sptr_generic_response RequestCreateAccount::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+bool RequestCreateAccount::VerifyUserData()
+{
+	if( m_username.empty() || m_password.empty() || m_emailAddress.empty() || m_dateOfBirth.empty() || m_chatHandle.empty() )
+	{
+		Log::Error( "RequestCreateAccount::VerifyUserData() - Missing required fields for account creation." );
+		return false;
+	}
+
+	if( m_username.length() < 3 || m_username.length() > 20 )
+	{
+		Log::Error( "RequestCreateAccount::VerifyUserData() - Username must be between 3 and 20 characters." );
+		return false;
+	}
+
+	if( m_password.length() < 6 || m_password.length() > 32 )
+	{
+		Log::Error( "RequestCreateAccount::VerifyUserData() - Password must be between 6 and 32 characters." );
+		return false;
+	}
+
+	return true;
+}
+
+sptr_generic_response RequestCreateAccount::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	Log::Debug( "Account creation isn't supported. Random SessionID generated." );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
-
+	if( nullptr == user || user->m_gameType != RealmGameType::RETURN_TO_ARMS )
-	if( nullptr == user )
 	{
-		Log::Error( "RequestCreateAccount::ProcessRequest() - User not found!" );
+		return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::ERROR_FATAL, L"" );
+	}
+
+	if( m_username.empty() || m_password.empty() || m_emailAddress.empty() || m_dateOfBirth.empty() || m_chatHandle.empty() )
+	{
+		Log::Error( "RequestCreateAccount::ProcessRequest() - Missing required fields for account creation." );
+		return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::ERROR_FATAL, L"" );
+	}
+
+	auto result = Database::Get().CreateNewAccount
+	(
+		m_username,
+		m_password,
+		m_emailAddress,
+		m_dateOfBirth,
+		m_chatHandle
+	);
+
+	if( !result )
+	{
+		Log::Error( "RequestCreateAccount::ProcessRequest() - Failed to create account for user: %s", m_username.c_str() );
 		return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::ERROR_FATAL, L"" );
 	}
 
@@ -35,14 +81,13 @@ ResultCreateAccount::ResultCreateAccount( GenericRequest *request, int32_t reply
 	m_sessionId = sessionId;
 }
 
-ByteStream &ResultCreateAccount::Serialize()
+ByteBuffer &ResultCreateAccount::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( m_reply );
 
-	m_stream.write_u32( 0 );
+	m_stream.write_encrypted_utf16( m_sessionId );
-	//m_stream.write_encrypted_utf16( m_sessionId );
 
 	return m_stream;
 }

Network/Event/RequestCreateAccount.h

@@ -1,8 +1,10 @@
 #pragma once
 
-// Account Creation is used in the Network Beta for CoN
+#include <memory>
-// but it isn't used or supported here because retail
+#include <string>
-// uses "foo" and "bar" to login without user data.
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
 
 class RequestCreateAccount : public GenericRequest
 {
@@ -11,6 +13,15 @@ class RequestCreateAccount : public GenericRequest
 		ERROR_FATAL,
 		ERROR_NOT_EXIST
 	};
+
+	std::string m_username;
+	std::string m_password;
+	std::string m_emailAddress;
+	std::string m_dateOfBirth;
+	std::string m_chatHandle;
+
+	bool VerifyUserData();
+
 public:
 	static std::unique_ptr< RequestCreateAccount > Create()
 	{
@@ -19,7 +30,7 @@ public:
 
 	CREATE_ACCOUNT_REPLY m_reply;
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -30,5 +41,5 @@ private:
 
 public:
 	ResultCreateAccount( GenericRequest *request, int32_t reply, std::wstring sessionId );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestCreatePrivateGame.cpp

@@ -1,7 +1,10 @@
-#include "../../global_define.h"
-
 #include "RequestCreatePrivateGame.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../configuration.h"
+#include "../../logging.h"
+
 void RequestCreatePrivateGame::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -10,11 +13,18 @@ void RequestCreatePrivateGame::Deserialize( sptr_byte_stream stream )
 	m_gameInfo = stream->read_utf16();
 }
 
-sptr_generic_response RequestCreatePrivateGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestCreatePrivateGame::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	auto result = GameSessionManager::Get().CreatePrivateGameSession( user, m_gameInfo, user->m_clientType );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::FATAL_ERROR, "", 0 );
+	}
+
+	auto result = GameSessionManager::Get().CreatePrivateGameSession( user, m_gameInfo, user->m_gameType );
 
 	if( !result )
 	{
@@ -34,10 +44,10 @@ ResultCreatePrivateGame::ResultCreatePrivateGame( GenericRequest *request, int32
 	m_discoveryPort = discoveryPort;
 }
 
-ByteStream &ResultCreatePrivateGame::Serialize()
+ByteBuffer &ResultCreatePrivateGame::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( m_reply );
 
 	m_stream.write_sz_utf8( m_discoveryIp );

Network/Event/RequestCreatePrivateGame.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestCreatePrivateGame : public GenericRequest
 {
 private:
@@ -20,7 +26,7 @@ public:
 		return std::make_unique< RequestCreatePrivateGame >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -32,5 +38,5 @@ private:
 
 public:
 	ResultCreatePrivateGame( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestCreatePrivateRoom.cpp

@@ -1,15 +1,24 @@
-#include "../../global_define.h"
 #include "RequestCreatePrivateRoom.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/ChatRoomManager.h"
+#include "../../logging.h"
+
 void RequestCreatePrivateRoom::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
 }
 
-sptr_generic_response RequestCreatePrivateRoom::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestCreatePrivateRoom::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		return std::make_shared< ResultCreatePrivateRoom >( this );
+	}
+
 	auto sessionId = stream->read_encrypted_utf16();
 	auto roomName = stream->read_utf16();
 
@@ -28,10 +37,10 @@ ResultCreatePrivateRoom::ResultCreatePrivateRoom( GenericRequest *request ) : Ge
 {
 }
 
-ByteStream&ResultCreatePrivateRoom::Serialize()
+ByteBuffer&ResultCreatePrivateRoom::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	return m_stream;

Network/Event/RequestCreatePrivateRoom.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestCreatePrivateRoom : public GenericRequest
 {
 public:
@@ -8,12 +14,12 @@ public:
 		return std::make_unique< RequestCreatePrivateRoom >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultCreatePrivateRoom : public GenericResponse {
 public:
 	ResultCreatePrivateRoom( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestCreatePublicGame.cpp

@@ -1,7 +1,10 @@
-#include "../../global_define.h"
-
 #include "RequestCreatePublicGame.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../configuration.h"
+#include "../../logging.h"
+
 // Request
 void RequestCreatePublicGame::Deserialize( sptr_byte_stream stream )
 {
@@ -18,11 +21,18 @@ void RequestCreatePublicGame::Deserialize( sptr_byte_stream stream )
 	m_gameInfo = stream->read_utf16();
 }
 
-sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameInfo, user->m_clientType );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::FATAL_ERROR, "", 0 );
+	}
+
+	auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameInfo, user->m_gameType );
 
 	if( !result )
 	{
@@ -43,10 +53,10 @@ ResultCreatePublicGame::ResultCreatePublicGame( GenericRequest *request, int32_t
 	m_discoveryPort = discoveryPort;
 }
 
-ByteStream &ResultCreatePublicGame::Serialize()
+ByteBuffer &ResultCreatePublicGame::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( m_reply );
 
 	m_stream.write_sz_utf8( m_discoveryIp );

Network/Event/RequestCreatePublicGame.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestCreatePublicGame : public GenericRequest
 {
 private:
@@ -21,7 +27,7 @@ public:
 	{
 		return std::make_unique< RequestCreatePublicGame >();
 	}
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -33,5 +39,5 @@ private:
 
 public:
 	ResultCreatePublicGame( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestDoClientDiscovery.cpp

@@ -1,6 +1,9 @@
-#include "../../global_define.h"
 #include "RequestDoClientDiscovery.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../configuration.h"
+
 void RequestDoClientDiscovery::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -9,11 +12,17 @@ void RequestDoClientDiscovery::Deserialize( sptr_byte_stream stream )
 	m_gameId = stream->read_u32();
 }
 
-sptr_generic_response RequestDoClientDiscovery::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestDoClientDiscovery::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	auto session = GameSessionManager::Get().FindGame( m_gameId );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
+	}
+
+	auto session = GameSessionManager::Get().FindGame( m_gameId, user->m_gameType );
 	if( session == nullptr )
 	{
 		return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
@@ -37,10 +46,10 @@ ResultDoClientDiscovery::ResultDoClientDiscovery( GenericRequest *request, int32
 	m_discoveryPort = port;
 }
 
-ByteStream &ResultDoClientDiscovery::Serialize()
+ByteBuffer &ResultDoClientDiscovery::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( m_reply );
 
 	m_stream.write_sz_utf8( m_discoveryIP );

Network/Event/RequestDoClientDiscovery.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestDoClientDiscovery : public GenericRequest
 {
 private:
@@ -18,7 +24,7 @@ public:
 		return std::make_unique< RequestDoClientDiscovery >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -30,5 +36,5 @@ private:
 
 public:
 	ResultDoClientDiscovery( GenericRequest *request, int32_t reply, std::string ip = "", int32_t port = 0);
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestEnterRoom.cpp

@@ -1,4 +1,3 @@
-#include "../../global_define.h"
 #include "RequestEnterRoom.h"
 
 void RequestEnterRoom::Deserialize( sptr_byte_stream stream )
@@ -6,7 +5,7 @@ void RequestEnterRoom::Deserialize( sptr_byte_stream stream )
 	DeserializeHeader( stream );
 }
 
-sptr_generic_response RequestEnterRoom::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestEnterRoom::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
@@ -20,10 +19,10 @@ ResultEnterRoom::ResultEnterRoom( GenericRequest *request ) : GenericResponse( *
 {
 }
 
-ByteStream& ResultEnterRoom::Serialize()
+ByteBuffer& ResultEnterRoom::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	m_stream.write_utf16( L"Room Name" );

Network/Event/RequestEnterRoom.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestEnterRoom : public GenericRequest
 {
 public:
@@ -8,12 +14,12 @@ public:
 		return std::make_unique< RequestEnterRoom >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultEnterRoom : public GenericResponse {
 public:
 	ResultEnterRoom( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestGetEncryptionKey.cpp

@@ -1,4 +1,3 @@
-#include "../../global_define.h"
 #include "RequestGetEncryptionKey.h"
 
 void RequestGetEncryptionKey::Deserialize( sptr_byte_stream stream )
@@ -6,7 +5,7 @@ void RequestGetEncryptionKey::Deserialize( sptr_byte_stream stream )
 	DeserializeHeader( stream );
 }
 
-sptr_generic_response RequestGetEncryptionKey::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestGetEncryptionKey::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
@@ -21,10 +20,10 @@ ResultGetEncryptionKey::ResultGetEncryptionKey( GenericRequest *request ) : Gene
 	m_symKey = RealmCrypt::getSymmetricKey();
 }
 
-ByteStream& ResultGetEncryptionKey::Serialize()
+ByteBuffer& ResultGetEncryptionKey::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	auto encrypted = RealmCrypt::encryptSymmetric( m_symKey );

Network/Event/RequestGetEncryptionKey.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestGetEncryptionKey : public GenericRequest
 {
 public:
@@ -8,7 +14,7 @@ public:
 		return std::make_unique< RequestGetEncryptionKey >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -17,5 +23,5 @@ public:
 	std::vector< uint8_t > m_symKey;
 
 	ResultGetEncryptionKey( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestGetGame.cpp

@@ -1,6 +1,10 @@
-#include "../../global_define.h"
 #include "RequestGetGame.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../logging.h"
+
 void RequestGetGame::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -9,17 +13,18 @@ void RequestGetGame::Deserialize( sptr_byte_stream stream )
 	m_gameName = stream->read_utf16();
 }
 
-sptr_generic_response RequestGetGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestGetGame::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
 	if( user == nullptr )
 	{
 		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
 		return std::make_shared< ResultGetGame >( this, TIMEOUT );
 	}
 
-	auto session = GameSessionManager::Get().FindGame( m_gameName );
+	auto session = GameSessionManager::Get().FindGame( m_gameName, user->m_gameType );
 
 	if( session == nullptr )
 	{
@@ -53,10 +58,10 @@ ResultGetGame::ResultGetGame( GenericRequest *request, int32_t reply, int32_t ga
 	m_gameId = gameId;
 }
 
-ByteStream &ResultGetGame::Serialize()
+ByteBuffer &ResultGetGame::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( m_reply );
 
 	// TODO: These may come in from the UpdateGameData event

Network/Event/RequestGetGame.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestGetGame : public GenericRequest {
 private:
 	std::wstring m_sessionId;
@@ -16,7 +22,7 @@ public:
 	{
 		return std::make_unique< RequestGetGame >();
 	}
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -27,5 +33,5 @@ private:
 
 public:
 	ResultGetGame( GenericRequest *request, int32_t reply, int32_t gameId = 0 );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestGetPublicRooms.cpp

@@ -1,4 +1,3 @@
-#include "../../global_define.h"
 #include "RequestGetPublicRooms.h"
 
 void RequestGetPublicRooms::Deserialize( sptr_byte_stream stream )
@@ -6,7 +5,7 @@ void RequestGetPublicRooms::Deserialize( sptr_byte_stream stream )
 	DeserializeHeader( stream );
 }
 
-sptr_generic_response RequestGetPublicRooms::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestGetPublicRooms::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
@@ -19,10 +18,10 @@ ResultGetPublicRooms::ResultGetPublicRooms( GenericRequest *request ) : GenericR
 {
 }
 
-ByteStream& ResultGetPublicRooms::Serialize()
+ByteBuffer& ResultGetPublicRooms::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	m_stream.write_u32( 0);

Network/Event/RequestGetPublicRooms.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestGetPublicRooms : public GenericRequest
 {
 public:
@@ -8,12 +14,12 @@ public:
 		return std::make_unique< RequestGetPublicRooms >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultGetPublicRooms : public GenericResponse {
 public:
 	ResultGetPublicRooms( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestGetRealmStats.cpp

@@ -1,12 +1,13 @@
-#include "../../global_define.h"
 #include "RequestGetRealmStats.h"
 
+#include "../../Game/RealmUserManager.h"
+
 void RequestGetRealmStats::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
 }
 
-sptr_generic_response RequestGetRealmStats::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestGetRealmStats::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
@@ -18,10 +19,10 @@ ResultGetRealmStats::ResultGetRealmStats( GenericRequest *request ) : GenericRes
 	
 }
 
-ByteStream &ResultGetRealmStats::Serialize()
+ByteBuffer &ResultGetRealmStats::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	// Player count on the game page.

Network/Event/RequestGetRealmStats.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestGetRealmStats : public GenericRequest
 {
 public:
@@ -7,12 +13,12 @@ public:
 	{
 		return std::make_unique< RequestGetRealmStats >();
 	}
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultGetRealmStats : public GenericResponse {
 public:
 	ResultGetRealmStats( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestGetRoom.cpp

@@ -1,4 +1,3 @@
-#include "../../global_define.h"
 #include "RequestGetRoom.h"
 
 void RequestGetRoom::Deserialize( sptr_byte_stream stream )
@@ -8,7 +7,7 @@ void RequestGetRoom::Deserialize( sptr_byte_stream stream )
 	auto sessionId = stream->read_encrypted_utf16();
 }
 
-sptr_generic_response RequestGetRoom::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestGetRoom::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
@@ -19,10 +18,10 @@ ResultGetRoom::ResultGetRoom( GenericRequest *request ) : GenericResponse( *requ
 {
 }
 
-ByteStream &ResultGetRoom::Serialize()
+ByteBuffer &ResultGetRoom::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	m_stream.write_utf16( L"Room Name" );

Network/Event/RequestGetRoom.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestGetRoom : public GenericRequest {
 public:
 	static std::unique_ptr< RequestGetRoom > Create()
@@ -7,12 +13,12 @@ public:
 		return std::make_unique< RequestGetRoom >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultGetRoom : public GenericResponse {
 public:
 	ResultGetRoom( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestGetRules.cpp

@@ -1,6 +1,10 @@
-#include "../../global_define.h"
 #include "RequestGetRules.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../Common/Constant.h"
+#include "../../logging.h"
+
 void RequestGetRules::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -8,15 +12,35 @@ void RequestGetRules::Deserialize( sptr_byte_stream stream )
 	m_language = stream->read_sz_utf8();
 }
 
-sptr_generic_response RequestGetRules::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestGetRules::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		return std::make_shared< ResultGetRules >( this, L"" );
+	}
+
 	// TODO: Get rules/eula based on language
-	std::wstring rules =
+	// and move it info a MOTD file.
-		L"Welcome to the Norrath Emulated Server!\n\n"
+	std::wstring rules;
+	
+	if (user->m_gameType == RealmGameType::RETURN_TO_ARMS)
+	{
+		rules = L"Welcome to the Norrath Emulated Server!\n\n"
+			L"RETURN TO ARMS network support is currently a\n"
+			L"work in progress and can not guarantee stability.\n\n"
+			L"[IMPORTANT]:\n"
+			L"Please note that ONLINE character data will not be saved.\n"
+			L"You must import an offline save file for now.\n";
+	}
+	else
+	{
+		rules = L"Welcome to the Norrath Emulated Server!\n\n"
 			L"This server is currently in development\n"
 			L"and may not be fully functional.\n\n";
+	}
 
 	 return std::make_shared< ResultGetRules >( this, rules );
 }
@@ -26,10 +50,10 @@ ResultGetRules::ResultGetRules( GenericRequest *request, std::wstring rules ) :
 	m_rules = rules;
 }
 
-ByteStream &ResultGetRules::Serialize()
+ByteBuffer &ResultGetRules::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	m_stream.write_utf16( m_rules );

Network/Event/RequestGetRules.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestGetRules : public GenericRequest
 {
 private:
@@ -11,7 +17,7 @@ public:
 		return std::make_unique< RequestGetRules >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -21,5 +27,5 @@ private:
 
 public:
 	ResultGetRules( GenericRequest *request, std::wstring rules );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestGetServerAddress.cpp

@@ -1,32 +1,50 @@
-#include "../../global_define.h"
 #include "RequestGetServerAddress.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../Common/Constant.h"
+#include "../../configuration.h"
+#include "../../logging.h"
+
 void RequestGetServerAddress::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
 }
 
-sptr_generic_response RequestGetServerAddress::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestGetServerAddress::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	return std::make_shared< ResultGetServerAddress >( this, Config::service_ip, Config::lobby_port, user->m_clientType );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		return std::make_shared< ResultGetServerAddress >( this, "", 0, RealmGameType::RETURN_TO_ARMS );
+	}
+
+	if (user->m_gameType == RealmGameType::RETURN_TO_ARMS)
+	{
+		return std::make_shared< ResultGetServerAddress >(this, Config::service_ip, Config::rta_lobby_port, user->m_gameType);
+	}
+	else
+	{
+		return std::make_shared< ResultGetServerAddress >(this, Config::service_ip, Config::con_lobby_port, user->m_gameType);
+	}
 }
 
-ResultGetServerAddress::ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port, RealmClientType clientType ) : GenericResponse( *request )
+ResultGetServerAddress::ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port, RealmGameType clientType ) : GenericResponse( *request )
 {
 	m_ip = ip;
 	m_port = port;
 	m_clientType = clientType;
 }
 
-ByteStream &ResultGetServerAddress::Serialize()
+ByteBuffer &ResultGetServerAddress::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
-	if( m_clientType == RealmClientType::RETURN_TO_ARMS )
+	if( m_clientType == RealmGameType::RETURN_TO_ARMS )
 		m_stream.write_utf8( m_ip );
 	else
 		m_stream.write_sz_utf8( m_ip );

Network/Event/RequestGetServerAddress.h

@@ -1,5 +1,12 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+#include "../../Common/Constant.h"
+
 class RequestGetServerAddress : public GenericRequest {
 public:
 	static std::unique_ptr< RequestGetServerAddress > Create()
@@ -7,7 +14,7 @@ public:
 		return std::make_unique< RequestGetServerAddress >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -15,8 +22,8 @@ class ResultGetServerAddress : public GenericResponse {
 public:
 	std::string m_ip;
 	int32_t		m_port;
-	RealmClientType m_clientType;
+	RealmGameType m_clientType;
 
-	ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port, RealmClientType clientType );
+	ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port, RealmGameType clientType );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestLogin.cpp

@@ -1,49 +1,87 @@
-#include "../../global_define.h"
 #include "RequestLogin.h"
 
+#include "../../Database/Database.h"
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../Common/Constant.h"
+#include "../../logging.h"
+
 void RequestLogin::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
 
-	m_username = stream->read_encrypted_utf16();
+	m_username =  Util::WideToUTF8( stream->read_encrypted_utf16() );
-	m_password = stream->read_encrypted_utf16();
+	m_password =  Util::WideToUTF8( stream->read_encrypted_utf16() );
 }
 
-sptr_generic_response RequestLogin::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestLogin::ProcessLoginCON(sptr_user user)
+{
+	if (m_username != "foo" && m_password != "bar")
+	{
+		// Network Beta CoN uses login information, but it's invalid because of version 2.0
+		// which used "foo" and "bar" as the login credentials.
+		Log::Debug("RequestLogin : Champions of Norrath v1.0");
+
+		// TODO: Either block this, or add support for the network beta.
+		return std::make_shared< ResultLogin >(this, LOGIN_REPLY::ACCOUNT_INVALID, L"");
+	}
+
+	user->m_accountId = -1;
+	user->m_sessionId = RealmUserManager::Get().GenerateSessionId();
+
+	return std::make_shared< ResultLogin >(this, SUCCESS, user->m_sessionId);
+}
+
+sptr_generic_response RequestLogin::ProcessLoginRTA(sptr_user user)
+{
+	// Return to Arms uses login information.
+	Log::Debug("RequestLogin : Return to Arms");
+
+	// Verify the account exists
+	auto accountId = Database::Get().VerifyAccount(m_username, m_password);
+
+	if (accountId < 0)
+	{
+		Log::Error("RequestLogin::ProcessRequest() - Invalid account ID: " + std::to_string(accountId));
+		return std::make_shared< ResultLogin >(this, ACCOUNT_INVALID, L"");
+	}
+
+	user->m_accountId = accountId;
+	user->m_sessionId = RealmUserManager::Get().GenerateSessionId();
+
+	Database::Get().CreateSession(
+		user->m_accountId,
+		user->m_sessionId,
+		user->sock->remote_ip);
+
+	return std::make_shared< ResultLogin >(this, SUCCESS, user->m_sessionId);
+}
+
+sptr_generic_response RequestLogin::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	Log::Packet( stream->data, stream->data.size(), false );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		Log::Error( "RequestLogin::ProcessRequest() - User not found" );
+		return std::make_shared< ResultLogin >( this, ACCOUNT_INVALID, L"" );
+	}
 
 	if( m_username.empty() || m_password.empty() )
 	{
 		Log::Error( "RequestLogin::ProcessRequest() - Username or password is empty" );
-		return std::make_shared< ResultLogin >( this, LOGIN_REPLY::NOT_EXIST, L"" );
+		return std::make_shared< ResultLogin >( this, ACCOUNT_INVALID, L"" );
 	}
 
-	if( user->m_clientType == RealmClientType::CHAMPIONS_OF_NORRATH )
+	if( user->m_gameType == RealmGameType::CHAMPIONS_OF_NORRATH )
 	{
-		if( m_username == L"foo" && m_password == L"bar" )
+		return ProcessLoginCON( user );
-		{
-			// Retail CoN does not use any login information.
-			Log::Debug( "RequestLogin : Champions of Norrath v2.0" );
 	}
 	else
 	{
-			// Network Beta CoN uses login information, but it's invalid because of version 2.0.
+		return ProcessLoginRTA( user );
-			Log::Debug( "RequestLogin : Champions of Norrath v1.0" );
-
-			// TODO: Either block this, or add support for the network beta.
-			return std::make_shared< ResultLogin >( this, LOGIN_REPLY::NOT_EXIST, L"" );
 	}
-	}
-	else
-	{
-		// Return to Arms uses login information.
-		Log::Debug( "RequestLogin : Return to Arms" );
-	}
-
-	return std::make_shared< ResultLogin >( this, LOGIN_REPLY::SUCCESS, user->m_sessionId );
 }
 
 ResultLogin::ResultLogin( GenericRequest *request, int32_t reply, std::wstring sessionId ) : GenericResponse( *request )
@@ -52,10 +90,10 @@ ResultLogin::ResultLogin( GenericRequest *request, int32_t reply, std::wstring s
 	m_sessionId = sessionId;
 }
 
-ByteStream &ResultLogin::Serialize()
+ByteBuffer &ResultLogin::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( m_reply );
 
 	m_stream.write_encrypted_utf16( m_sessionId );

Network/Event/RequestLogin.h

@@ -1,10 +1,10 @@
 #pragma once
 
-// Account Login is used in the Network Beta for CoN.
+#include <memory>
-// In the retail version, the game simply logs in with
+#include <string>
-// "foo" and "bar" as the username and password.
+
-//
+#include "../GenericNetRequest.h"
-// A unique Session ID is generated and assigned to the player.
+#include "../GenericNetResponse.h"
 
 class RequestLogin : public GenericRequest
 {
@@ -12,11 +12,11 @@ private:
 	enum LOGIN_REPLY {
 		SUCCESS = 0,
 		FATAL_ERROR,
-		NOT_EXIST,
+		ACCOUNT_INVALID = 4,
 	};
 
-	std::wstring m_username;
+	std::string m_username;
-	std::wstring m_password;
+	std::string m_password;
 	std::wstring m_sessionId;
 
 public:
@@ -25,8 +25,11 @@ public:
 		return std::make_unique< RequestLogin >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
+
+	sptr_generic_response ProcessLoginCON( sptr_user user );
+	sptr_generic_response ProcessLoginRTA( sptr_user user );
 };
 
 class ResultLogin : public GenericResponse {
@@ -36,5 +39,5 @@ private:
 
 public:
 	ResultLogin( GenericRequest *request, int32_t reply, std::wstring sessionId );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestLogout.cpp

@@ -1,16 +1,20 @@
-#include "../../global_define.h"
 #include "RequestLogout.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../logging.h"
+
 void RequestLogout::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
 	m_sessionId = stream->read_encrypted_utf16();
 }
 
-sptr_generic_response RequestLogout::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestLogout::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
+	RealmUserManager::Get().RemoveUser( socket );
+
 	Log::Debug( "[%S] Logout", m_sessionId.c_str() );
 
 	return std::make_shared< ResultLogout >( this, 0 );
@@ -21,10 +25,10 @@ ResultLogout::ResultLogout( GenericRequest *request, int32_t reply ) : GenericRe
 	m_reply = reply;
 }
 
-ByteStream &ResultLogout::Serialize()
+ByteBuffer &ResultLogout::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( m_reply );
 
 	return m_stream;

Network/Event/RequestLogout.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestLogout : public GenericRequest
 {
 private:
@@ -10,7 +16,7 @@ public:
 	{
 		return std::make_unique< RequestLogout >();
 	}
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
@@ -19,5 +25,5 @@ private:
 	int32_t m_reply;
 public:
 	ResultLogout( GenericRequest *request, int32_t reply );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestMatchGame.cpp

@@ -1,6 +1,12 @@
-#include "../../global_define.h"
 #include "RequestMatchGame.h"
 
+#include <format>
+
+#include "../../Common/Constant.h"
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../Game/RealmUser.h"
+
 void RequestMatchGame::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -33,54 +39,59 @@ void RequestMatchGame::Deserialize( sptr_byte_stream stream )
 	auto unknown_h = stream->read_u32();
 }
 
-sptr_generic_response RequestMatchGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestMatchGame::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	return std::make_shared< ResultMatchGame >( this );
+	return std::make_shared< ResultMatchGame >( this, socket->remote_ip );
 }
 
-ResultMatchGame::ResultMatchGame( GenericRequest *request ) : GenericResponse( *request )
+ResultMatchGame::ResultMatchGame( GenericRequest *request, std::string userIp ) : GenericResponse( *request )
 {
-
+	m_userIp = userIp;
 }
 
-ByteStream &ResultMatchGame::Serialize()
+ByteBuffer &ResultMatchGame::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
-	auto publicGameList = GameSessionManager::Get().GetAvailableGameSessionList( RealmClientType::CHAMPIONS_OF_NORRATH );
+	const auto publicGameList = GameSessionManager::Get().GetAvailableGameSessionList( RealmGameType::CHAMPIONS_OF_NORRATH );
-	auto publicGameCount = static_cast< uint32_t >( publicGameList.size() );
+	const auto publicGameCount = static_cast< uint32_t >( publicGameList.size() );
 
 	m_stream.write_u32( publicGameCount );
 	{
-		for( auto &game : publicGameList )
+		for( const auto &game : publicGameList )
-			m_stream.write_utf16( std::format( L"{}:{}", game->m_hostExternalAddr, game->m_hostPort ) );
+		{
+			if( m_userIp == game->m_hostExternalAddr )
+				m_stream.write_utf16( std::format( L"{}:{}", Util::UTF8ToWide( game->m_hostLocalAddr ), game->m_hostPort ) );
+			else
+				m_stream.write_utf16( std::format( L"{}:{}", Util::UTF8ToWide( game->m_hostExternalAddr ), game->m_hostPort ) );
+		}
 	}
 
 	m_stream.write_u32( publicGameCount );
 	{
-		for( auto &game : publicGameList )
+		for( const auto &game : publicGameList )
 			m_stream.write_utf16( game->m_gameName );
 	}
 
 	m_stream.write_u32( publicGameCount );
 	{
-		for( auto &game : publicGameList )
+		for( const auto &game : publicGameList )
 			m_stream.write_utf16( game->m_ownerName );
 	}
 
 	m_stream.write_u32( publicGameCount );
 	{
-		for( auto &game : publicGameList )
+		for( const auto &game : publicGameList )
 			m_stream.write_u32( game->m_gameIndex );
 	}
 
 	m_stream.write_u32( publicGameCount );
 	{
-		for( auto &game : publicGameList )
+		for( const auto &game : publicGameList )
 			m_stream.write_utf8( game->m_gameData );
 	}
 

Network/Event/RequestMatchGame.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestMatchGame : public GenericRequest
 {
 private:
@@ -10,12 +13,16 @@ public:
 	{
 		return std::make_unique< RequestMatchGame >();
 	}
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultMatchGame : public GenericResponse {
+private:
+	std::string m_userIp;
+
 public:
-	ResultMatchGame( GenericRequest *request );
+	ResultMatchGame( GenericRequest *request, std::string userIp );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestStartGame.cpp

@@ -0,0 +1,49 @@
+#include "RequestStartGame.h"
+
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../logging.h"
+
+void RequestStartGame::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	auto sessionId = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestStartGame::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		return std::make_shared< ResultStartGame >( this, FATAL_ERROR );
+	}
+
+	auto session = GameSessionManager::Get().FindGame( user->m_gameId, user->m_gameType );
+	if( session == nullptr )
+	{
+		Log::Error( "Game session not found! [%d]", user->m_gameId );
+		return std::make_shared< ResultStartGame >( this, FATAL_ERROR );
+	}
+
+	GameSessionManager::Get().RequestStart(user);
+
+	return std::make_shared< ResultStartGame >( this, SUCCESS );
+}
+
+ResultStartGame::ResultStartGame( GenericRequest *request, int32_t reply ) : GenericResponse( *request )
+{
+	m_reply = reply;
+}
+
+ByteBuffer& ResultStartGame::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_trackId );
+	m_stream.write_u32( m_reply );
+
+	return m_stream;
+}

Network/Event/RequestStartGame.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
+class RequestStartGame : public GenericRequest
+{
+private:
+	std::vector< uint8_t > m_data;
+
+	enum CREATE_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+public:
+	static std::unique_ptr< RequestStartGame > Create()
+	{
+		return std::make_unique< RequestStartGame >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultStartGame : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultStartGame( GenericRequest *request, int32_t reply );
+	ByteBuffer &Serialize();
+};

Network/Event/RequestTouchSession.cpp

@@ -1,6 +1,8 @@
-#include "../../global_define.h"
 #include "RequestTouchSession.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../logging.h"
+
 void RequestTouchSession::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -8,10 +10,18 @@ void RequestTouchSession::Deserialize( sptr_byte_stream stream )
 	m_sessionId = stream->read_encrypted_utf16();
 }
 
-sptr_generic_response RequestTouchSession::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestTouchSession::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultTouchSession >( this );
+	}
+
 	return std::make_shared< ResultTouchSession >( this );
 }
 
@@ -20,10 +30,10 @@ ResultTouchSession::ResultTouchSession( GenericRequest *request ) : GenericRespo
 	
 }
 
-ByteStream &ResultTouchSession::Serialize()
+ByteBuffer &ResultTouchSession::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	return m_stream;

Network/Event/RequestTouchSession.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestTouchSession : public GenericRequest
 {
 private:
@@ -10,12 +16,12 @@ public:
 	{
 		return std::make_unique< RequestTouchSession >();
 	}
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultTouchSession : public GenericResponse {
 public:
 	ResultTouchSession( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/RequestUpdateGameData.cpp

@@ -1,6 +1,10 @@
-#include "../../global_define.h"
 #include "RequestUpdateGameData.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/GameSessionManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../logging.h"
+
 void RequestUpdateGameData::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
@@ -9,11 +13,19 @@ void RequestUpdateGameData::Deserialize( sptr_byte_stream stream )
 	m_gameData = stream->read_utf8();
 }
 
-sptr_generic_response RequestUpdateGameData::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response RequestUpdateGameData::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	auto gameSession = GameSessionManager::Get().FindGame( user->m_gameId );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultUpdateGameData >( this );
+	}
+
+	auto gameSession = GameSessionManager::Get().FindGame( user->m_gameId, user->m_gameType );
 
 	if( gameSession == nullptr )
 	{
@@ -58,10 +70,10 @@ ResultUpdateGameData::ResultUpdateGameData( GenericRequest *request ) : GenericR
 
 }
 
-ByteStream &ResultUpdateGameData::Serialize()
+ByteBuffer &ResultUpdateGameData::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
 	return m_stream;

Network/Event/RequestUpdateGameData.h

@@ -1,5 +1,11 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class RequestUpdateGameData : public GenericRequest
 {
 private:
@@ -11,12 +17,12 @@ public:
 	{
 		return std::make_unique< RequestUpdateGameData >();
 	}
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class ResultUpdateGameData : public GenericResponse {
 public:
 	ResultUpdateGameData( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/Request_5D.cpp

@@ -1,27 +1,67 @@
-#include "../../global_define.h"
 #include "Request_5D.h"
 
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../Database/Database.h"
+#include "../../logging.h"
+
+#include "../../Common/RLEZ.hpp"
+
 void Request_5D::Deserialize( sptr_byte_stream stream )
 {
 	DeserializeHeader( stream );
+
+	auto sessionId = stream->read_encrypted_utf16();
+	auto length = stream->read_u32();
+	m_data = stream->read_bytes( length );
+	auto unknown = stream->read_u32();
 }
 
-sptr_generic_response Request_5D::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response Request_5D::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
-	return std::make_shared< Result_5D >( this );
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		return std::make_shared< Result_5D >( this, FATAL_ERROR );
+	}
+
+	//auto unpacked = RLEZ::Decompress( m_data );
+
+	//Log::PacketToFile( "5D_data_comp", m_data, m_data.size());
+	//Log::PacketToFile( "5D_data_decomp", unpacked, unpacked.size());
+
+	//auto &myCharacter = user->m_character;
+
+	//if( nullptr == myCharacter )
+	//{
+	//	return std::make_shared< Result_5D >( this, FATAL_ERROR );
+	//}
+
+	//myCharacter->SetInventoryData( m_data );
+
+	//auto result = Database::Get().SaveInventory( user->m_accountId, user->m_characterId, m_data );
+
+	//if( !result )
+	//{
+	//	Log::Error( "Failed to save inventory for account ID: " + std::to_string( user->m_accountId ) + ", character ID: " + std::to_string( user->m_characterId ) );
+	//	return std::make_shared< Result_5D >( this, FATAL_ERROR );
+	//}
+
+	return std::make_shared< Result_5D >( this, SUCCESS );
 }
 
-Result_5D::Result_5D( GenericRequest *request ) : GenericResponse( *request )
+Result_5D::Result_5D( GenericRequest *request, int32_t reply ) : GenericResponse( *request )
 {
+	m_reply = reply;
 }
 
-ByteStream&Result_5D::Serialize()
+ByteBuffer& Result_5D::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
-	m_stream.write_u32( 0 );
+	m_stream.write_u32( m_reply );
 
 	return m_stream;
 }

Network/Event/Request_5D.h

@@ -1,19 +1,36 @@
 #pragma once
 
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
 class Request_5D : public GenericRequest
 {
+private:
+	std::vector< uint8_t > m_data;
+
+	enum CREATE_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
 public:
 	static std::unique_ptr< Request_5D > Create()
 	{
 		return std::make_unique< Request_5D >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class Result_5D : public GenericResponse {
+private:
+	int32_t m_reply;
+
 public:
-	Result_5D( GenericRequest *request );
+	Result_5D( GenericRequest *request, int32_t reply );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };

Network/Event/Request_5F.cpp

@@ -0,0 +1,43 @@
+#include "Request_5F.h"
+
+#include "../../Game/RealmUserManager.h"
+#include "../../Game/RealmUser.h"
+#include "../../Database/Database.h"
+#include "../../logging.h"
+
+void Request_5F::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	auto sessionId_a = stream->read_encrypted_utf16();
+	auto sessionId_b = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response Request_5F::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto user = RealmUserManager::Get().FindUserBySocket( socket );
+	if( user == nullptr )
+	{
+		return std::make_shared< Result_5F >( this, FATAL_ERROR );
+	}
+
+	Log::Debug( "Request_5F From user ID : %d", user->m_accountId );
+
+	return std::make_shared< Result_5F >( this, SUCCESS );
+}
+
+Result_5F::Result_5F( GenericRequest *request, int32_t reply ) : GenericResponse( *request )
+{
+	m_reply = reply;
+}
+
+ByteBuffer& Result_5F::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_trackId );
+	m_stream.write_u32( m_reply );
+
+	return m_stream;
+}

Network/Event/Request_5F.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
+class Request_5F : public GenericRequest
+{
+private:
+	std::vector< uint8_t > m_data;
+
+	enum CREATE_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+public:
+	static std::unique_ptr< Request_5F > Create()
+	{
+		return std::make_unique< Request_5F >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class Result_5F : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	Result_5F( GenericRequest *request, int32_t reply );
+	ByteBuffer &Serialize();
+};

Network/Event/Request_61.cpp

@@ -1,4 +1,3 @@
-#include "../../global_define.h"
 #include "Request_61.h"
 
 void Request_61::Deserialize( sptr_byte_stream stream )
@@ -6,7 +5,7 @@ void Request_61::Deserialize( sptr_byte_stream stream )
 	DeserializeHeader( stream );
 }
 
-sptr_generic_response Request_61::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+sptr_generic_response Request_61::ProcessRequest( sptr_socket socket, sptr_byte_stream stream )
 {
 	Deserialize( stream );
 
@@ -20,11 +19,22 @@ Result_61::Result_61( GenericRequest *request ) : GenericResponse( *request )
 {
 }
 
-ByteStream&Result_61::Serialize()
+ByteBuffer&Result_61::Serialize()
 {
 	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_trackId );
 	m_stream.write_u32( 0 );
 
+	// Friends
+	m_stream.write_u32(1);
+	m_stream.write_utf16(L"String_1");
+
+	m_stream.write_u32(1);
+	m_stream.write_utf16(L"String_2");
+
+	// Ignore
+	m_stream.write_u32(1);
+	m_stream.write_utf16(L"String_3");
+
 	return m_stream;
 }

Network/Event/Request_61.h

@@ -1,6 +1,10 @@
 #pragma once
 
-// Potentially character data.
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
 
 class Request_61 : public GenericRequest
 {
@@ -10,12 +14,12 @@ public:
 		return std::make_unique< Request_61 >();
 	}
 
-	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
 	void Deserialize( sptr_byte_stream stream ) override;
 };
 
 class Result_61 : public GenericResponse {
 public:
 	Result_61( GenericRequest *request );
-	ByteStream &Serialize();
+	ByteBuffer &Serialize();
 };