Clean up Network Events

Beginning support for RTA

Lobby Server/Event/NotifyClientDiscovered.cpp

@@ -1,19 +0,0 @@
-#include "../../global_define.h"
-#include "NotifyClientDiscovered.h"
-
-NotifyClientDiscovered::NotifyClientDiscovered( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x40 )
-{
-	m_clientIp = clientIp;
-	m_clientPort = clientPort;
-}
-
-ByteStream &NotifyClientDiscovered::Serialize()
-{
-	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( 0 );
-
-	m_stream.write_sz_utf8( m_clientIp );
-	m_stream.write_u32( m_clientPort );
-
-	return m_stream;
-}

Lobby Server/Event/NotifyGameDiscovered.cpp

@@ -1,19 +0,0 @@
-#include "../../global_define.h"
-#include "NotifyGameDiscovered.h"
-
-NotifyGameDiscovered::NotifyGameDiscovered( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x3E )
-{
-	m_clientIp = clientIp;
-	m_clientPort = clientPort;
-}
-
-ByteStream &NotifyGameDiscovered::Serialize()
-{
-	m_stream.write_u16( m_packetId );
-	m_stream.write_u32( 0 );
-
-	m_stream.write_sz_utf8( m_clientIp );
-	m_stream.write_u32( m_clientPort );
-
-	return m_stream;
-}

Lobby Server/LobbyEvents.h

@@ -1,101 +0,0 @@
-#pragma once
-
-#include <map>
-#include <functional>
-
-#include "Event/RequestCancelGame.h"
-#include "Event/RequestCreateAccount.h"
-#include "Event/RequestCreatePrivateGame.h"
-#include "Event/RequestCreatePublicGame.h"
-#include "Event/RequestGetGame.h"
-#include "Event/RequestGetRealmStats.h"
-#include "Event/RequestLogin.h"
-#include "Event/RequestLogout.h"
-#include "Event/RequestMatchGame.h"
-#include "Event/RequestTouchSession.h"
-#include "Event/RequestDoClientDiscovery.h"
-#include "Event/RequestGetServerAddress.h"
-#include "Event/RequestGetEncryptionKey.h"
-#include "Event/RequestGetRules.h"
-#include "Event/RequestUpdateGameData.h"
-
-const std::map< int16_t, std::function< std::unique_ptr< GenericRequest >() > > LOBBY_REQUEST_EVENT =
-{
-	{ 0x0005, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestCancelGame >();
-		}
-	},
-	{ 0x0006, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestCreateAccount >();
-		}
-	},
-	{ 0x0008, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestCreatePrivateGame >();
-		}
-	},
-	{ 0x000A, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestCreatePublicGame >();
-		}
-	},
-	{ 0x000D, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestGetGame >();
-		}
-	},
-	{ 0x000F, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestGetRealmStats >();
-		}
-	},
-	{ 0x0016, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestLogin >();
-		}
-	},
-	{ 0x0017, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestLogout >();
-		}
-	},
-	{ 0x0018, []() -> std::unique_ptr< GenericRequest >
-		{
-			return std::make_unique< RequestMatchGame >();
-		}
-	},
-	{ 0x0024, []() -> std::unique_ptr< GenericRequest >
-		{
-		return std::make_unique< RequestTouchSession >();
-		}
-	},
-	{ 0x0025, []() -> std::unique_ptr< GenericRequest >
-		{
-		return std::make_unique< RequestDoClientDiscovery >();
-		}
-	},
-	{ 0x0027, []() -> std::unique_ptr< GenericRequest >
-		{
-		return std::make_unique< RequestGetEncryptionKey >();
-		}
-	},
-	{ 0x0042, []() -> std::unique_ptr< GenericRequest >
-		{
-		return std::make_unique< RequestGetRules >();
-		}
-	},
-	{ 0x0043, []() -> std::unique_ptr< GenericRequest >
-		{
-		return std::make_unique< RequestGetServerAddress >();
-		}
-	},
-	{
-	 0x0044, []() -> std::unique_ptr< GenericRequest >
-	  {
-	  return std::make_unique< RequestUpdateGameData >();
-	  }
-	}
-
-};

Lobby Server/LobbyServer.cpp

@@ -6,14 +6,15 @@
 // ╩═╝╚═╝╚═╝╚═╝ ╩   ╚═╝╚═╝╩╚═ ╚╝ ╚═╝╩╚═
 
 #include "../global_define.h"
+#include "../Network/Events.h"
 
-#include "LobbyEvents.h"
 #include "LobbyServer.h"
 
 LobbyServer::LobbyServer()
 {
 	m_running = false;
-	m_listenSocket = INVALID_SOCKET;
+	m_conSocket = INVALID_SOCKET;
+	m_rtaSocket = INVALID_SOCKET;
 
 	m_clientSockets.clear();
 	m_recvBuffer.resize( 1024 );
@@ -21,49 +22,33 @@ LobbyServer::LobbyServer()
 
 LobbyServer::~LobbyServer()
 {
+	Log::Info( "Lobby Server stopped." );
+	if( m_conSocket != INVALID_SOCKET )
+	{
+		closesocket( m_conSocket );
+		m_conSocket = INVALID_SOCKET;
+	}
+	if( m_rtaSocket != INVALID_SOCKET )
+	{
+		closesocket( m_rtaSocket );
+		m_rtaSocket = INVALID_SOCKET;
+	}
 }
 
-void LobbyServer::Start( std::string ip, int32_t port )
+void LobbyServer::Start( std::string ip )
 {
-	m_listenSocket = ::WSASocket( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
-	if( m_listenSocket == INVALID_SOCKET )
-	{
-		Log::Error( "WSASocket() failed" );
+	m_conSocket = OpenNetworkSocket( ip, 40801 );
+	if( m_conSocket == INVALID_SOCKET )
 		return;
-	}
 
-	// Bind the socket
-	sockaddr_in service;
-	service.sin_family = AF_INET;
-	service.sin_port = htons( port );
-
-	if( ip == "0.0.0.0" )
-	{
-		service.sin_addr.s_addr = ADDR_ANY;
-	}
-	else
-	{
-		service.sin_addr.s_addr = inet_addr( ip.c_str() );
-	}
-
-	if( bind( m_listenSocket, ( SOCKADDR * )&service, sizeof( service ) ) == SOCKET_ERROR )
-	{
-		Log::Error( "bind() failed" );
+	m_rtaSocket = OpenNetworkSocket( ip, 40810 );
+	if( m_rtaSocket == INVALID_SOCKET )
 		return;
-	}
 
-	// Listen on the socket
-	if( listen( m_listenSocket, SOMAXCONN ) == SOCKET_ERROR )
-	{
-		Log::Error( "listen() failed" );
-		return;
-	}
-
-	// Start the server
 	m_running = true;
 	m_thread = std::thread( &LobbyServer::Run, this );
 
-	Log::Info( "Lobby Server started on %s:%d", ip.c_str(), port );
+	Log::Info( "Lobby Server started" );
 }
 
 void LobbyServer::Stop()
@@ -75,6 +60,43 @@ void LobbyServer::Stop()
 	}
 }
 
+SOCKET LobbyServer::OpenNetworkSocket( std::string ip, int32_t port )
+{
+	SOCKET sock = ::WSASocket( AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED );
+	if( sock == INVALID_SOCKET )
+	{
+		Log::Error( "WSASocket() failed on port %u", port );
+		return INVALID_SOCKET;
+	}
+
+	sockaddr_in service{};
+	service.sin_family = AF_INET;
+	service.sin_port = htons( port );
+
+	if( ip == "0.0.0.0" )
+		service.sin_addr.s_addr = ADDR_ANY;
+	else
+		service.sin_addr.s_addr = inet_addr( ip.c_str() );
+
+	if( bind( sock, ( SOCKADDR * )&service, sizeof( service ) ) == SOCKET_ERROR )
+	{
+		Log::Error( "bind() failed on port %u", port );
+		closesocket( sock );
+		return INVALID_SOCKET;
+	}
+
+	if( listen( sock, SOMAXCONN ) == SOCKET_ERROR )
+	{
+		Log::Error( "listen() failed on port %u", port );
+		closesocket( sock );
+		return INVALID_SOCKET;
+	}
+
+	Log::Info( "Socket Opened on %s:%d", ip.c_str(), port );
+
+	return sock;
+}
+
 void LobbyServer::Run()
 {
 	FD_SET readSet;
@@ -87,18 +109,23 @@ void LobbyServer::Run()
 		FD_ZERO( &readSet );
 		FD_ZERO( &writeSet );
 
-		FD_SET( m_listenSocket, &readSet );
+		FD_SET( m_conSocket, &readSet );
+		FD_SET( m_rtaSocket, &readSet );
 
 		CheckSocketProblem();
 
-		// Process clients
-		for( auto &client : m_clientSockets )
+		auto maxfd = std::max< SOCKET >( m_conSocket, m_rtaSocket );
+
+		for( const auto &client : m_clientSockets )
 		{
 			FD_SET( client->fd, &readSet );
 			FD_SET( client->fd, &writeSet );
+
+			if( client->fd > maxfd )
+				maxfd = client->fd;
 		}
 
-		auto result = select( 0, &readSet, &writeSet, NULL, &timeout );
+		auto result = select( static_cast< int >( maxfd + 1 ), &readSet, &writeSet, NULL, &timeout );
 
 		if( result == SOCKET_ERROR )
 		{
@@ -106,9 +133,14 @@ void LobbyServer::Run()
 			continue;
 		}
 
-		if( FD_ISSET( m_listenSocket, &readSet ) )
+		if( FD_ISSET( m_conSocket, &readSet ) )
 		{
-			AcceptNewClient();
+			AcceptNewClient( m_conSocket, RealmClientType::CHAMPIONS_OF_NORRATH );
+		}
+
+		if( FD_ISSET( m_rtaSocket, &readSet ) )
+		{
+			AcceptNewClient( m_rtaSocket, RealmClientType::RETURN_TO_ARMS );
 		}
 
 		for( auto &client : m_clientSockets )
@@ -152,12 +184,12 @@ void LobbyServer::CheckSocketProblem()
 	}
 }
 
-void LobbyServer::AcceptNewClient()
+void LobbyServer::AcceptNewClient( SOCKET socket, RealmClientType clientType )
 {
 	sockaddr_in clientInfo{};
 	int32_t addrSize = sizeof( clientInfo );
 
-	SOCKET clientSocket = accept( m_listenSocket, ( SOCKADDR * )&clientInfo, &addrSize );
+	SOCKET clientSocket = accept( socket, ( SOCKADDR * )&clientInfo, &addrSize );
 	if( clientSocket == INVALID_SOCKET )
 	{
 		Log::Error( "accept() failed" );
@@ -172,7 +204,7 @@ void LobbyServer::AcceptNewClient()
 
 	m_clientSockets.push_back( new_socket );
 
-	RealmUserManager::Get().CreateUser( new_socket );
+	RealmUserManager::Get().CreateUser( new_socket, clientType );
 
 	Log::Info( "[LOBBY] New Client Connected : (%s)", new_socket->remote_ip.c_str() );
 }
@@ -213,7 +245,7 @@ void LobbyServer::ReadSocket( sptr_socket socket )
 	{
 		int32_t packetSize = ntohl( *reinterpret_cast< const int32_t * >( &socket->m_pendingReadBuffer[ 0 ] ) );
 
-		if( packetSize <= 0 || packetSize > 1024 )
+		if( packetSize <= 0 || packetSize > 2048 )
 		{
 			Log::Error( "Invalid packet size: %d. Disconnecting client.", packetSize );
 			socket->flag.disconnected = true;
@@ -298,8 +330,11 @@ void LobbyServer::HandleRequest( sptr_socket socket, sptr_byte_stream stream )
 	auto packetId = stream->read< uint16_t >();
 	stream->set_position( 0 );
 
-	auto it = LOBBY_REQUEST_EVENT.find( packetId );
-	if( it == LOBBY_REQUEST_EVENT.end() )
+	Log::Debug( "Event Request %04X", packetId );
+	Log::Packet( stream->data, stream->data.size(), false );
+
+	auto it = REQUEST_EVENT.find( packetId );
+	if( it == REQUEST_EVENT.end() )
 	{
 		Log::Error( "[LOBBY] Unknown packet id : 0x%04X", packetId );
 		Log::Packet( stream->data, stream->data.size(), false );

Lobby Server/LobbyServer.h

@@ -3,37 +3,6 @@
 #include <memory>
 #include <mutex>
 
-class GameRoom {
-public:
-	GameRoom()
-	{
-		m_gameType = GameType::PRIVATE;
-		m_roomId = 0;
-		m_ownerSessionId = L"";
-		m_gameName = L"";
-		m_minimumLevel = 0;
-		m_maximumLevel = 0;
-	}
-
-	~GameRoom()
-	{
-
-	}
-
-	enum GameType {
-		PRIVATE,
-		PUBLIC
-	} m_gameType;
-
-	int32_t m_roomId;
-	std::wstring m_ownerSessionId;
-	std::wstring m_gameName;
-	int32_t m_minimumLevel;
-	int32_t m_maximumLevel;
-};
-
-typedef std::shared_ptr< GameRoom > sptr_game_room;
-
 class LobbyServer
 {
 private:
@@ -60,7 +29,7 @@ public:
 	LobbyServer();
 	~LobbyServer();
 
-	void Start( std::string ip, int32_t port );
+	void Start( std::string ip );
 	void Stop();
 	bool isRunning() const
 	{
@@ -68,13 +37,16 @@ public:
 	}
 
 private:
-	SOCKET m_listenSocket;
+	SOCKET m_conSocket;
+	SOCKET m_rtaSocket;
 	std::vector< sptr_socket > m_clientSockets;
 	std::vector< uint8_t > m_recvBuffer;
 
+	SOCKET OpenNetworkSocket( std::string ip, int32_t port );
+
 	void Run();
 	void CheckSocketProblem();
-	void AcceptNewClient();
+	void AcceptNewClient( SOCKET socket, RealmClientType clientType );
 	void ReadSocket( sptr_socket socket );
 	void WriteSocket( sptr_socket socket );
 	void HandleRequest( sptr_socket socket, sptr_byte_stream stream );

Network/Event/NotifyClientDiscovered.cpp

@@ -0,0 +1,24 @@
+#include "../../global_define.h"
+#include "NotifyClientDiscovered.h"
+
+NotifyClientDiscovered::NotifyClientDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType ) : GenericMessage( 0x40 )
+{
+	this->m_clientIp = std::move( clientIp );
+	this->m_clientPort = clientPort;
+	this->m_clientType = clientType;
+}
+
+ByteStream &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

@@ -4,8 +4,9 @@ class NotifyClientDiscovered : public GenericMessage {
 private:
 	std::string m_clientIp;
 	int32_t m_clientPort;
+	RealmClientType m_clientType;
 
 public:
-	NotifyClientDiscovered( std::string clientIp, int32_t clientPort );
+	NotifyClientDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType );
 	ByteStream &Serialize() override;
 };

Network/Event/NotifyClientReqConnect.cpp

@@ -3,8 +3,8 @@
 
 NotifyClientRequestConnect::NotifyClientRequestConnect( std::string clientIp, int32_t clientPort ) : GenericMessage( 0x3F )
 {
-	m_clientIp = clientIp;
-	m_clientPort = clientPort;
+	this->m_clientIp = std::move( clientIp );
+	this->m_clientPort = clientPort;
 }
 
 ByteStream &NotifyClientRequestConnect::Serialize()

Network/Event/NotifyClientRequestConnect_RTA.cpp

@@ -0,0 +1,23 @@
+#include "../../global_define.h"
+#include "NotifyClientRequestConnect_RTA.h"
+
+NotifyClientRequestConnect_RTA::NotifyClientRequestConnect_RTA( std::string localAddr, std::string remoteAddr, int32_t port ) : GenericMessage( 0x65 )
+{
+	this->m_localAddr = localAddr;
+	this->m_remoteAddr = remoteAddr;
+	this->m_port = port;
+}
+
+ByteStream &NotifyClientRequestConnect_RTA::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_utf8( this->m_remoteAddr );
+	m_stream.write_u32( this->m_port );
+
+	m_stream.write_utf8( this->m_localAddr );
+	m_stream.write_u32( this->m_port );
+
+	return m_stream;
+}

Network/Event/NotifyClientRequestConnect_RTA.h

@@ -0,0 +1,12 @@
+#pragma once
+
+class NotifyClientRequestConnect_RTA : public GenericMessage {
+private:
+	std::string m_localAddr;
+	std::string m_remoteAddr;
+	int32_t m_port;
+
+public:
+	NotifyClientRequestConnect_RTA( std::string localAddr, std::string remoteAddr, int32_t port );
+	ByteStream &Serialize() override;
+};

Network/Event/NotifyForcedLogout.cpp

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

Network/Event/NotifyForcedLogout.h

@@ -0,0 +1,9 @@
+#pragma once
+
+class NotifyForcedLogout : public GenericMessage {
+private:
+
+public:
+	NotifyForcedLogout();
+	ByteStream &Serialize() override;
+};

Network/Event/NotifyGameDiscovered.cpp

@@ -0,0 +1,24 @@
+#include "../../global_define.h"
+#include "NotifyGameDiscovered.h"
+
+NotifyGameDiscovered::NotifyGameDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType ) : GenericMessage( 0x3E )
+{
+	this->m_clientIp = std::move( clientIp );
+	this->m_clientPort = clientPort;
+	this->m_clientType = clientType;
+}
+
+ByteStream &NotifyGameDiscovered::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/NotifyGameDiscovered.h

@@ -4,8 +4,9 @@ class NotifyGameDiscovered : public GenericMessage {
 private:
 	std::string m_clientIp;
 	int32_t m_clientPort;
+	RealmClientType m_clientType;
 
 public:
-	NotifyGameDiscovered( std::string clientIp, int32_t clientPort );
+	NotifyGameDiscovered( std::string clientIp, int32_t clientPort, RealmClientType clientType );
 	ByteStream &Serialize() override;
 };

Network/Event/Notify_4C.cpp

@@ -0,0 +1,52 @@
+#include "../../global_define.h"
+#include "Notify_4C.h"
+
+Notify_4C::Notify_4C() : GenericMessage( 0x4C )
+{
+}
+
+ByteStream &Notify_4C::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_u32( 0 ); // Unknown
+
+	m_stream.write_u32( 1 ); // Unknown
+	{
+		m_stream.write_utf16( L"Dummy 1" );
+	}
+
+	m_stream.write_u32( 1 ); // Unknown
+	{
+		m_stream.write_u32( 0 );
+		// Blob
+	}
+
+	m_stream.write_u32( 1 ); // Unknown
+	{
+		m_stream.write_u32( 0 );
+	}
+
+	m_stream.write_u16( 0 ); // Unknown
+
+	m_stream.write_u32( 1 ); // Unknown
+	{
+		m_stream.write_u16( 0 );
+		m_stream.write_u32( 0 );
+		m_stream.write_utf16( L"Dummy 2" );
+		m_stream.write_u32( 0 );
+		m_stream.write_u32( 0 );
+		m_stream.write_u32( 0 );
+		m_stream.write_u16( 1 );
+	}
+
+	m_stream.write_u32( 0 ); // Unknown
+
+	m_stream.write_utf8( "127.0.0.1" );
+
+	m_stream.write_u32( 0 ); // Unknown
+	m_stream.write_u32( 0 ); // Unknown
+
+	return m_stream;
+}

Network/Event/Notify_4C.h

@@ -0,0 +1,9 @@
+#pragma once
+
+class Notify_4C : public GenericMessage {
+private:
+
+public:
+	Notify_4C();
+	ByteStream &Serialize() override;
+};

Network/Event/RequestCancelGame_RTA.cpp

@@ -0,0 +1,38 @@
+#include "../../global_define.h"
+#include "RequestCancelGame_RTA.h"
+
+void RequestCancelGame_RTA::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestCancelGame_RTA::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultCancelGame_RTA >( this );
+	}
+
+	GameSessionManager::Get().RequestCancel( user );
+
+	return std::make_shared< ResultCancelGame_RTA >( this );
+}
+
+ResultCancelGame_RTA::ResultCancelGame_RTA( GenericRequest *request ) : GenericResponse( *request )
+{
+	
+}
+
+ByteStream &ResultCancelGame_RTA::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Network/Event/RequestCancelGame_RTA.h

@@ -0,0 +1,22 @@
+#pragma once
+
+class RequestCancelGame_RTA : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestCancelGame_RTA > Create()
+	{
+		return std::make_unique< RequestCancelGame_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCancelGame_RTA : public GenericResponse {
+public:
+	ResultCancelGame_RTA( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/RequestCreateAccount.cpp

@@ -9,6 +9,9 @@ void RequestCreateAccount::Deserialize( sptr_byte_stream stream )
 	auto password = stream->read_encrypted_utf16();
 	auto emailAddress = stream->read_encrypted_utf16();
 	auto dateOfBirth = stream->read_encrypted_utf16();
+	auto chatHandle = stream->read_encrypted_utf16();
+
+	int dbg = 0;
 }
 
 sptr_generic_response RequestCreateAccount::ProcessRequest( sptr_user user, sptr_byte_stream stream )
@@ -38,7 +41,8 @@ ByteStream &ResultCreateAccount::Serialize()
 	m_stream.write_u32( m_requestId );
 	m_stream.write_u32( m_reply );
 
-	m_stream.write_encrypted_utf16( m_sessionId );
+	m_stream.write_u32( 0 );
+	//m_stream.write_encrypted_utf16( m_sessionId );
 
 	return m_stream;
 }

Network/Event/RequestCreatePrivateGame.cpp

@@ -14,7 +14,7 @@ sptr_generic_response RequestCreatePrivateGame::ProcessRequest( sptr_user user,
 {
 	Deserialize( stream );
 
-	auto result = GameSessionManager::Get().CreatePrivateGameSession( user, m_gameInfo );
+	auto result = GameSessionManager::Get().CreatePrivateGameSession( user, m_gameInfo, user->m_clientType );
 
 	if( !result )
 	{

Network/Event/RequestCreatePrivateGame_RTA.cpp

@@ -0,0 +1,47 @@
+#include "../../global_define.h"
+
+#include "RequestCreatePrivateGame_RTA.h"
+
+void RequestCreatePrivateGame_RTA::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+	m_gameInfo = stream->read_utf16();
+}
+
+sptr_generic_response RequestCreatePrivateGame_RTA::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto result = GameSessionManager::Get().CreatePrivateGameSession( user, m_gameInfo, user->m_clientType );
+
+	if( !result )
+	{
+		Log::Error( "RequestCreatePrivateGame2::ProcessRequest() - Failed to create private game session!" );
+		return std::make_shared< ResultCreatePrivateGame2 >( this, CREATE_REPLY::GENERAL_ERROR, "", 0 );
+	}
+
+	Log::Info( "[%S] Create Private Game: %S", m_sessionId.c_str(), m_gameInfo.c_str() );
+
+	return std::make_shared< ResultCreatePrivateGame2 >( this, CREATE_REPLY::SUCCESS, Config::service_ip, Config::discovery_port );
+}
+
+ResultCreatePrivateGame2::ResultCreatePrivateGame2( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_discoveryIp = discoveryIp;
+	m_discoveryPort = discoveryPort;
+}
+
+ByteStream &ResultCreatePrivateGame2::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_sz_utf8( m_discoveryIp );
+	m_stream.write( m_discoveryPort );
+
+	return m_stream;
+}

Network/Event/RequestCreatePrivateGame_RTA.h

@@ -0,0 +1,36 @@
+#pragma once
+
+class RequestCreatePrivateGame_RTA : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameInfo;
+
+	enum CREATE_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+		GAME_NAME_IN_USE = 38,
+		GAME_PENDING = 40,
+	};
+
+public:
+	static std::unique_ptr< RequestCreatePrivateGame_RTA > Create()
+	{
+		return std::make_unique< RequestCreatePrivateGame_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCreatePrivateGame2 : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultCreatePrivateGame2( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
+	ByteStream &Serialize();
+};

Network/Event/RequestCreatePrivateRoom.cpp

@@ -0,0 +1,38 @@
+#include "../../global_define.h"
+#include "RequestCreatePrivateRoom.h"
+
+void RequestCreatePrivateRoom::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response RequestCreatePrivateRoom::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto sessionId = stream->read_encrypted_utf16();
+	auto roomName = stream->read_utf16();
+
+	auto result = ChatRoomManager::Get().CreatePrivateChatSession( user, roomName );
+
+	if( !result )
+	{
+		Log::Error( "RequestCreatePrivateRoom::ProcessRequest() - Failed to create private room!" );
+		return std::make_shared< ResultCreatePrivateRoom >( this );
+	}
+
+	return std::make_shared< ResultCreatePrivateRoom >( this );
+}
+
+ResultCreatePrivateRoom::ResultCreatePrivateRoom( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream&ResultCreatePrivateRoom::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Network/Event/RequestCreatePrivateRoom.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class RequestCreatePrivateRoom : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestCreatePrivateRoom > Create()
+	{
+		return std::make_unique< RequestCreatePrivateRoom >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCreatePrivateRoom : public GenericResponse {
+public:
+	ResultCreatePrivateRoom( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/RequestCreatePublicGame.cpp

@@ -22,7 +22,7 @@ sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_user user, s
 {
 	Deserialize( stream );
 
-	auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameInfo );
+	auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameInfo, user->m_clientType );
 
 	if( !result )
 	{

Network/Event/RequestCreatePublicGame_RTA.cpp

@@ -0,0 +1,64 @@
+#include "../../global_define.h"
+
+#include "RequestCreatePublicGame_RTA.h"
+
+// Request
+void RequestCreatePublicGame_RTA::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+
+	auto unknown_a = stream->read_u16();
+	auto unknown_b = stream->read_u32();
+	auto unknown_c = stream->read_u32();
+	auto unknown_d = stream->read_u32();
+
+	m_gameInfo = stream->read_utf16();
+
+	auto unknown_e = stream->read_u32();
+	auto unknown_f = stream->read_u32();
+
+	m_localAddr = stream->read_utf16();
+}
+
+sptr_generic_response RequestCreatePublicGame_RTA::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	Log::Packet( stream->data, stream->data.size(), false );
+
+	auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameInfo, user->m_clientType );
+
+	if( !result )
+	{
+		Log::Error( "RequestCreatePublicGame::ProcessRequest() - Failed to create public game session!" );
+		return std::make_shared< ResultCreatePublicGame_RTA >( this, CREATE_REPLY::GENERAL_ERROR, "", 0 );
+	}
+
+	user->m_localAddr = Utility::WideToUTF8( m_localAddr );
+
+	Log::Info( "[%S] Create Public Game: %S", m_sessionId.c_str(), m_gameInfo.c_str() );
+
+	return std::make_shared< ResultCreatePublicGame_RTA >( this, CREATE_REPLY::SUCCESS, Config::service_ip, Config::discovery_port );
+}
+
+// Result
+ResultCreatePublicGame_RTA::ResultCreatePublicGame_RTA( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_discoveryIp = discoveryIp;
+	m_discoveryPort = discoveryPort;
+}
+
+ByteStream &ResultCreatePublicGame_RTA::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_utf8( m_discoveryIp );
+	m_stream.write( m_discoveryPort );
+
+	return m_stream;
+}

Network/Event/RequestCreatePublicGame_RTA.h

@@ -0,0 +1,36 @@
+#pragma once
+
+class RequestCreatePublicGame_RTA : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameInfo;
+
+	std::wstring m_localAddr;
+
+	enum CREATE_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+		GAME_NAME_IN_USE = 38,
+		GAME_PENDING = 40,
+	};
+public:
+	static std::unique_ptr< RequestCreatePublicGame_RTA > Create()
+	{
+		return std::make_unique< RequestCreatePublicGame_RTA >();
+	}
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCreatePublicGame_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultCreatePublicGame_RTA( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
+	ByteStream &Serialize();
+};

Network/Event/RequestEnterRoom.cpp

@@ -0,0 +1,45 @@
+#include "../../global_define.h"
+#include "RequestEnterRoom.h"
+
+void RequestEnterRoom::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response RequestEnterRoom::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto publicKey = stream->read_utf8();
+	auto unknown = stream->read_u32();
+
+	return std::make_shared< ResultEnterRoom >( this );
+}
+
+ResultEnterRoom::ResultEnterRoom( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream& ResultEnterRoom::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_utf16( L"Room Name" );
+	m_stream.write_utf16( L"Room Banner" );
+
+	m_stream.write_u32( 3 );
+	{
+		m_stream.write_utf16( L"Name1" );
+		m_stream.write_utf16( L"Name2" );
+		m_stream.write_utf16( L"Name3" );
+	}
+
+	m_stream.write_u32( 1 );
+	{
+		m_stream.write_utf16( L"Name1" );
+	}
+
+	return m_stream;
+}

Network/Event/RequestEnterRoom.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class RequestEnterRoom : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestEnterRoom > Create()
+	{
+		return std::make_unique< RequestEnterRoom >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultEnterRoom : public GenericResponse {
+public:
+	ResultEnterRoom( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/RequestGetEncryptionKey.cpp

@@ -27,7 +27,11 @@ ByteStream& ResultGetEncryptionKey::Serialize()
 	m_stream.write_u32( m_requestId );
 	m_stream.write_u32( 0 );
 
-	m_stream.write_encrypted_bytes( m_symKey );
+	auto encrypted = RealmCrypt::encryptSymmetric( m_symKey );
+
+	m_stream.write_u32( encrypted.size() + 4 );
+	m_stream.write_u32( m_symKey.size() );
+	m_stream.write_bytes( encrypted );
 
 	return m_stream;
 }

Network/Event/RequestGetGame_RTA.cpp

@@ -0,0 +1,70 @@
+#include "../../global_define.h"
+#include "RequestGetGame_RTA.h"
+
+void RequestGetGame_RTA::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+	m_gameId = stream->read_u32();
+	m_localAddr = stream->read_utf16();
+}
+
+sptr_generic_response RequestGetGame_RTA::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	Log::Packet( stream->data, stream->data.size(), false );
+
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultGetGame_RTA >( this, TIMEOUT );
+	}
+
+	auto session = GameSessionManager::Get().FindGame( m_gameId );
+
+	if( session == nullptr )
+	{
+		Log::Error( "Game session not found! [%d]", m_gameId );
+		return std::make_shared< ResultGetGame_RTA >( this, NOT_FOUND );
+	}
+
+	if( session->m_currentPlayers >= session->m_maximumPlayers )
+	{
+		Log::Error( "Game session is full! [%d]", m_gameId );
+		return std::make_shared< ResultGetGame_RTA >( this, TIMEOUT );
+	}
+
+	auto host_user = session->m_owner.lock();
+
+	if( host_user == nullptr )
+	{
+		Log::Error( "Game session owner not found! [%d]", m_gameId );
+		return std::make_shared< ResultGetGame_RTA >( this, TIMEOUT );
+	}
+
+	user->m_isHost = false;
+	user->m_gameId = session->m_gameIndex;
+
+	return std::make_shared< ResultGetGame_RTA >( this, SUCCESS, Config::service_ip, Config::discovery_port );
+}
+
+ResultGetGame_RTA::ResultGetGame_RTA( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )
+{
+	m_reply = reply;
+	m_discoveryIp = discoveryIp;
+	m_discoveryPort = discoveryPort;
+}
+
+ByteStream &ResultGetGame_RTA::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( m_reply );
+
+	m_stream.write_utf8( m_discoveryIp );
+	m_stream.write_u32( m_discoveryPort );
+
+	return m_stream;
+}

Network/Event/RequestGetGame_RTA.h

@@ -0,0 +1,33 @@
+#pragma once
+
+class RequestGetGame_RTA : public GenericRequest {
+private:
+	std::wstring m_sessionId;
+	std::wstring m_localAddr;
+	uint32_t m_gameId;
+
+	enum REPLY {
+		SUCCESS = 0,
+		TIMEOUT,
+		NOT_FOUND
+	};
+
+public:
+	static std::unique_ptr< RequestGetGame_RTA > Create()
+	{
+		return std::make_unique< RequestGetGame_RTA >();
+	}
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetGame_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultGetGame_RTA( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0);
+	ByteStream &Serialize();
+};

Network/Event/RequestGetPublicRooms.cpp

@@ -0,0 +1,48 @@
+#include "../../global_define.h"
+#include "RequestGetPublicRooms.h"
+
+void RequestGetPublicRooms::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response RequestGetPublicRooms::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto publicKey = stream->read_utf8();
+
+	return std::make_shared< ResultGetPublicRooms >( this );
+}
+
+ResultGetPublicRooms::ResultGetPublicRooms( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream& ResultGetPublicRooms::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_u32( 0);
+	for( int i = 0; i < 0; i++ )
+	{
+		m_stream.write_utf16( L"Room Name" );
+		m_stream.write_utf16( L"Room Banner" );
+
+		m_stream.write_u32( 3 );
+		{
+			m_stream.write_utf16( L"Name1" );
+			m_stream.write_utf16( L"Name2" );
+			m_stream.write_utf16( L"Name3" );
+		}
+
+		m_stream.write_u32( 1 );
+		{
+			m_stream.write_utf16( L"Name1" );
+		}
+	}
+
+	return m_stream;
+}

Network/Event/RequestGetPublicRooms.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class RequestGetPublicRooms : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetPublicRooms > Create()
+	{
+		return std::make_unique< RequestGetPublicRooms >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetPublicRooms : public GenericResponse {
+public:
+	ResultGetPublicRooms( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/RequestGetRoom.cpp

@@ -0,0 +1,44 @@
+#include "../../global_define.h"
+#include "RequestGetRoom.h"
+
+void RequestGetRoom::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	auto sessionId = stream->read_encrypted_utf16();
+}
+
+sptr_generic_response RequestGetRoom::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	return std::make_shared< ResultGetRoom >( this );
+}
+
+ResultGetRoom::ResultGetRoom( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream &ResultGetRoom::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_utf16( L"Room Name" );
+	m_stream.write_utf16( L"Room Banner" );
+
+	m_stream.write_u32( 3 );
+	{
+		m_stream.write_utf16( L"Name1" );
+		m_stream.write_utf16( L"Name2" );
+		m_stream.write_utf16( L"Name3" );
+	}
+
+	m_stream.write_u32( 1 );
+	{
+		m_stream.write_utf16( L"Name1" );
+	}
+
+	return m_stream;
+}

Network/Event/RequestGetRoom.h

@@ -0,0 +1,18 @@
+#pragma once
+
+class RequestGetRoom : public GenericRequest {
+public:
+	static std::unique_ptr< RequestGetRoom > Create()
+	{
+		return std::make_unique< RequestGetRoom >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetRoom : public GenericResponse {
+public:
+	ResultGetRoom( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/RequestGetServerAddress.cpp

@@ -10,13 +10,14 @@ sptr_generic_response RequestGetServerAddress::ProcessRequest( sptr_user user, s
 {
 	Deserialize( stream );
 
-	return std::make_shared< ResultGetServerAddress >( this, Config::service_ip, Config::lobby_port );
+	return std::make_shared< ResultGetServerAddress >( this, Config::service_ip, Config::lobby_port, user->m_clientType );
 }
 
-ResultGetServerAddress::ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port ) : GenericResponse( *request )
+ResultGetServerAddress::ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port, RealmClientType clientType ) : GenericResponse( *request )
 {
 	m_ip = ip;
 	m_port = port;
+	m_clientType = clientType;
 }
 
 ByteStream &ResultGetServerAddress::Serialize()
@@ -25,7 +26,11 @@ ByteStream &ResultGetServerAddress::Serialize()
 	m_stream.write_u32( m_requestId );
 	m_stream.write_u32( 0 );
 
-	m_stream.write_sz_utf8( m_ip );
+	if( m_clientType == RealmClientType::RETURN_TO_ARMS )
+		m_stream.write_utf8( m_ip );
+	else
+		m_stream.write_sz_utf8( m_ip );
+
 	m_stream.write( m_port );
 
 	return m_stream;

Network/Event/RequestGetServerAddress.h

@@ -15,7 +15,8 @@ class ResultGetServerAddress : public GenericResponse {
 public:
 	std::string m_ip;
 	int32_t		m_port;
+	RealmClientType m_clientType;
 
-	ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port );
+	ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port, RealmClientType clientType );
 	ByteStream &Serialize();
 };

Network/Event/RequestLogin.cpp

@@ -13,21 +13,34 @@ sptr_generic_response RequestLogin::ProcessRequest( sptr_user user, sptr_byte_st
 {
 	Deserialize( stream );
 
+	Log::Packet( stream->data, stream->data.size(), false );
+
 	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"" );
 	}
 
-	if( m_username == L"foo" && m_password == L"bar" )
+	if( user->m_clientType == RealmClientType::CHAMPIONS_OF_NORRATH )
 	{
-		// Retail CoN does not use any login information.
-		Log::Debug( "RequestLogin : Champions of Norrath v2.0" );
+		if( m_username == L"foo" && m_password == L"bar" )
+		{
+			// 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.
+			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
 	{
-		// Network Beta CoN uses login information, but it's invalid because of version 2.0.
-		Log::Debug( "RequestLogin : Champions of Norrath v1.0" );
+		// Return to Arms uses login information.
+		Log::Debug( "RequestLogin : Return to Arms" );
 	}
 
 	return std::make_shared< ResultLogin >( this, LOGIN_REPLY::SUCCESS, user->m_sessionId );
@@ -46,6 +59,7 @@ ByteStream &ResultLogin::Serialize()
 	m_stream.write_u32( m_reply );
 
 	m_stream.write_encrypted_utf16( m_sessionId );
+	m_stream.write_encrypted_utf16( L"UNKNOWN DUMMY STRING" );
 
 	return m_stream;
 }

Network/Event/RequestMatchGame.cpp

@@ -31,8 +31,6 @@ void RequestMatchGame::Deserialize( sptr_byte_stream stream )
 	auto unknown_f = stream->read_u8();
 	auto unknown_g = stream->read_u32();
 	auto unknown_h = stream->read_u32();
-
-	int dbg = 0;
 }
 
 sptr_generic_response RequestMatchGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
@@ -53,13 +51,13 @@ ByteStream &ResultMatchGame::Serialize()
 	m_stream.write_u32( m_requestId );
 	m_stream.write_u32( 0 );
 
-	auto publicGameList = GameSessionManager::Get().GetAvailableGameSessionList();
+	auto publicGameList = GameSessionManager::Get().GetAvailableGameSessionList( RealmClientType::CHAMPIONS_OF_NORRATH );
 	auto publicGameCount = static_cast< uint32_t >( publicGameList.size() );
 
 	m_stream.write_u32( publicGameCount );
 	{
 		for( auto &game : publicGameList )
-			m_stream.write_utf16( game->m_gameAddress );
+			m_stream.write_utf16( std::format( L"{}:{}", game->m_hostExternalAddr, game->m_hostPort ) );
 	}
 
 	m_stream.write_u32( publicGameCount );

Network/Event/RequestMatchGame_RTA.cpp

@@ -0,0 +1,78 @@
+#include "../../global_define.h"
+#include "RequestMatchGame_RTA.h"
+
+void RequestMatchGame_RTA::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response RequestMatchGame_RTA::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	return std::make_shared< ResultMatchGame_RTA >( this );
+}
+
+ResultMatchGame_RTA::ResultMatchGame_RTA( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream&ResultMatchGame_RTA::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	auto publicGameList = GameSessionManager::Get().GetAvailableGameSessionList( RealmClientType::RETURN_TO_ARMS );
+	auto publicGameCount = static_cast< uint32_t >( publicGameList.size() );
+
+	m_stream.write_u32( publicGameCount );
+	{
+		for( auto &game : publicGameList )
+			m_stream.write_utf16( game->m_gameName );
+	}
+
+	m_stream.write_u32( publicGameCount );
+	{
+		for( auto &game : publicGameList )
+			m_stream.write_utf16( game->m_playerCount );
+	}
+
+	m_stream.write_u32( publicGameCount );
+	{
+		for( auto &game : publicGameList )
+			m_stream.write_u32( game->m_gameIndex );
+	}
+
+	m_stream.write_u32( publicGameCount );
+	{
+		m_stream.write_u32( 0 );	// Size
+		// Blob Data
+	}
+
+	m_stream.write_u32( publicGameCount );
+	{
+		for( auto &game : publicGameList )
+			m_stream.write_utf16( game->m_hostExternalAddr );
+	}
+
+	m_stream.write_u32( publicGameCount );
+	{
+		for( auto &game : publicGameList )
+			m_stream.write_u32( game->m_hostPort );
+	}
+
+	m_stream.write_u32( publicGameCount );
+	{
+		for( auto &game : publicGameList )
+			m_stream.write_utf16( game->m_hostLocalAddr );
+	}
+
+	m_stream.write_u32( publicGameCount );
+	{
+		for( auto &game : publicGameList )
+			m_stream.write_u32( game->m_hostPort );
+	}
+
+	return m_stream;
+}

Network/Event/RequestMatchGame_RTA.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class RequestMatchGame_RTA : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestMatchGame_RTA > Create()
+	{
+		return std::make_unique< RequestMatchGame_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultMatchGame_RTA : public GenericResponse {
+public:
+	ResultMatchGame_RTA( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/RequestSaveNewCharacter_RTA.cpp

@@ -0,0 +1,27 @@
+#include "../../global_define.h"
+#include "RequestSaveNewCharacter_RTA.h"
+
+void RequestSaveNewCharacter::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response RequestSaveNewCharacter::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	return std::make_shared< ResultSaveNewCharacter >( this );
+}
+
+ResultSaveNewCharacter::ResultSaveNewCharacter( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream&ResultSaveNewCharacter::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Network/Event/RequestSaveNewCharacter_RTA.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class RequestSaveNewCharacter : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestSaveNewCharacter > Create()
+	{
+		return std::make_unique< RequestSaveNewCharacter >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultSaveNewCharacter : public GenericResponse {
+public:
+	ResultSaveNewCharacter( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/Request_5B.cpp

@@ -0,0 +1,30 @@
+#include "../../global_define.h"
+#include "Request_5B.h"
+
+void Request_5B::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response Request_5B::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto publicKey = stream->read_utf8();
+	auto unknown = stream->read_u32();
+
+	return std::make_shared< Result_5B >( this );
+}
+
+Result_5B::Result_5B( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream&Result_5B::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Network/Event/Request_5B.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class Request_5B : public GenericRequest
+{
+public:
+	static std::unique_ptr< Request_5B > Create()
+	{
+		return std::make_unique< Request_5B >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class Result_5B : public GenericResponse {
+public:
+	Result_5B( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/Request_5D.cpp

@@ -0,0 +1,27 @@
+#include "../../global_define.h"
+#include "Request_5D.h"
+
+void Request_5D::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response Request_5D::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	return std::make_shared< Result_5D >( this );
+}
+
+Result_5D::Result_5D( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream&Result_5D::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Network/Event/Request_5D.h

@@ -0,0 +1,19 @@
+#pragma once
+
+class Request_5D : public GenericRequest
+{
+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;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class Result_5D : public GenericResponse {
+public:
+	Result_5D( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Event/Request_61.cpp

@@ -0,0 +1,30 @@
+#include "../../global_define.h"
+#include "Request_61.h"
+
+void Request_61::Deserialize( sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response Request_61::ProcessRequest( sptr_user user, sptr_byte_stream stream )
+{
+	Deserialize( stream );
+
+	auto publicKey = stream->read_utf8();
+	auto unknown = stream->read_u32();
+
+	return std::make_shared< Result_61 >( this );
+}
+
+Result_61::Result_61( GenericRequest *request ) : GenericResponse( *request )
+{
+}
+
+ByteStream&Result_61::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Network/Event/Request_61.h

@@ -0,0 +1,21 @@
+#pragma once
+
+// Potentially character data.
+
+class Request_61 : public GenericRequest
+{
+public:
+	static std::unique_ptr< Request_61 > Create()
+	{
+		return std::make_unique< Request_61 >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class Result_61 : public GenericResponse {
+public:
+	Result_61( GenericRequest *request );
+	ByteStream &Serialize();
+};

Network/Events.h

@@ -0,0 +1,190 @@
+#pragma once
+
+#include <map>
+#include <functional>
+
+/* 0005 */	#include "Event/RequestCancelGame.h"
+/* 0006 */	#include "Event/RequestCreateAccount.h"
+
+/* 0008 */	#include "Event/RequestCreatePrivateGame.h"
+/* 0009 */	#include "Event/RequestCreatePrivateRoom.h"
+
+/* 000A */	#include "Event/RequestCreatePublicGame.h"
+
+/* 000C */	#include "Event/RequestEnterRoom.h"
+/* 000D */	#include "Event/RequestGetGame.h"
+/* 000E */	#include "Event/RequestGetPublicRooms.h"
+/* 000F */	#include "Event/RequestGetRealmStats.h"
+
+/* 0011 */	#include "Event/RequestGetRoom.h"
+
+/* 0016 */	#include "Event/RequestLogin.h"
+/* 0017 */	#include "Event/RequestLogout.h"
+/* 0018 */	#include "Event/RequestMatchGame.h"
+
+/* 0024 */	#include "Event/RequestTouchSession.h"
+/* 0025 */	#include "Event/RequestDoClientDiscovery.h"
+
+/* 0027 */	#include "Event/RequestGetEncryptionKey.h"
+
+/* 0042 */	#include "Event/RequestGetRules.h"
+/* 0043 */	#include "Event/RequestGetServerAddress.h"
+/* 0044 */	#include "Event/RequestUpdateGameData.h"
+
+/* 0054 */	#include "Event/RequestCreatePublicGame_RTA.h"
+/* 0055 */	#include "Event/RequestMatchGame_RTA.h"
+/* 0056 */	#include "Event/RequestCreatePrivateGame_RTA.h"
+
+/* 0058 */	#include "Event/RequestSaveNewCharacter_RTA.h"
+/* 005B */	#include "Event/Request_5B.h"
+/* 005D */	#include "Event/Request_5D.h"
+/* 0060 */	#include "Event/RequestCancelGame_RTA.h"
+/* 0061 */	#include "Event/Request_61.h"
+
+/* 0066 */	#include "Event/RequestGetGame_RTA.h"
+
+
+const std::map< int16_t, std::function< std::unique_ptr< GenericRequest >() > > REQUEST_EVENT =
+{
+	{ 0x0005, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestCancelGame >();
+		}
+	},
+	{ 0x0006, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestCreateAccount >();
+		}
+	},
+	{ 0x0008, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestCreatePrivateGame >();
+		}
+	},
+	{ 0x0009, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestCreatePrivateRoom >();
+		}
+	},
+	{ 0x000A, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestCreatePublicGame >();
+		}
+	},
+	{ 0x000C, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestEnterRoom >();
+		}
+	},
+	{ 0x000D, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetGame >();
+		}
+	},
+	{ 0x000E, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetPublicRooms >();
+		}
+	},
+	{ 0x000F, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetRealmStats >();
+		}
+	},
+	{ 0x0011, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetRoom >();
+		}
+	},
+	{ 0x0016, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestLogin >();
+		}
+	},
+	{ 0x0017, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestLogout >();
+		}
+	},
+	{ 0x0018, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestMatchGame >();
+		}
+	},
+	{ 0x0024, []() -> std::unique_ptr< GenericRequest >
+		{
+		return std::make_unique< RequestTouchSession >();
+		}
+	},
+	{ 0x0025, []() -> std::unique_ptr< GenericRequest >
+		{
+		return std::make_unique< RequestDoClientDiscovery >();
+		}
+	},
+	{ 0x0027, []() -> std::unique_ptr< GenericRequest >
+		{
+		return std::make_unique< RequestGetEncryptionKey >();
+		}
+	},
+	{ 0x0042, []() -> std::unique_ptr< GenericRequest >
+		{
+		return std::make_unique< RequestGetRules >();
+		}
+	},
+	{ 0x0043, []() -> std::unique_ptr< GenericRequest >
+		{
+		return std::make_unique< RequestGetServerAddress >();
+		}
+	},
+	{ 0x0044, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< RequestUpdateGameData >();
+	  }
+	},
+
+	{ 0x0054, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< RequestCreatePublicGame_RTA >();
+	  }
+	},
+	{ 0x0055, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< RequestMatchGame_RTA >();
+	  }
+	},
+	{ 0x0056, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< RequestCreatePrivateGame_RTA >();
+	  }
+	},
+	{ 0x0058, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< RequestSaveNewCharacter >();
+	  }
+	},
+	{ 0x005B, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< Request_5B >();
+	  }
+	},
+	{ 0x005D, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< Request_5D >();
+	  }
+	},
+	{ 0x0060, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< RequestCancelGame_RTA >();
+	  }
+	},
+	{ 0x0061, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< Request_61 >();
+	  }
+	},
+	{ 0x0066, []() -> std::unique_ptr< GenericRequest >
+	 {
+		return std::make_unique< RequestGetGame_RTA >();
+	 }
+	},
+};