Reorganized and cleaned up the solution.

Include/Network/Event/NotifyClientDiscovered.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+
+#include "../GenericNetMessage.hpp"
+#include "Common/ForwardDecl.hpp"
+
+class NotifyClientDiscovered : public GenericMessage {
+private:
+	std::string m_clientIp;
+	int32_t m_clientPort;
+
+public:
+	NotifyClientDiscovered( sptr_user user );
+	void Serialize( ByteBuffer &out ) const override;
+};

Include/Network/Event/NotifyClientDiscovered_RTA.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <string>
+
+#include "../GenericNetMessage.hpp"
+#include "Common/Constant.hpp"
+#include "Common/ForwardDecl.hpp"
+
+class NotifyClientDiscovered_RTA : public GenericMessage {
+private:
+	std::string m_clientIp;
+	int32_t m_clientPort;
+
+public:
+	NotifyClientDiscovered_RTA( sptr_user user );
+	void Serialize( ByteBuffer &out ) const override;
+};

Include/Network/Event/NotifyClientReqConnect.h

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

Include/Network/Event/NotifyClientRequestConnect.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+
+#include "../GenericNetMessage.hpp"
+#include "Common/ForwardDecl.hpp"
+
+class NotifyClientRequestConnect : public GenericMessage {
+private:
+	std::string m_clientIp;
+	int32_t m_clientPort;
+
+public:
+	NotifyClientRequestConnect( sptr_user user );
+	void Serialize( ByteBuffer &out ) const override;
+};

Include/Network/Event/NotifyClientRequestConnect_RTA.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetMessage.hpp"
+#include "Common/ForwardDecl.hpp"
+
+class NotifyClientRequestConnect_RTA : public GenericMessage {
+private:
+	std::string m_localAddr;
+	std::string m_remoteAddr;
+	int32_t m_localPort;
+	int32_t m_remotePort;
+
+public:
+	NotifyClientRequestConnect_RTA( sptr_user user );
+	void Serialize( ByteBuffer &out ) const override;
+};

Include/Network/Event/NotifyForcedLogout.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "../GenericNetMessage.hpp"
+
+class NotifyForcedLogout : public GenericMessage {
+private:
+
+public:
+	NotifyForcedLogout();
+	void Serialize( ByteBuffer &out ) const override;
+};

Include/Network/Event/NotifyFriendStatus.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../GenericNetMessage.hpp"
+
+class NotifyFriendStatus : public GenericMessage {
+private:
+	std::wstring m_handle;
+	bool m_status;
+
+public:
+	NotifyFriendStatus( std::wstring handle, bool status );
+	void Serialize( ByteBuffer &out ) const override;
+};

Include/Network/Event/NotifyGameDiscovered.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetMessage.hpp"
+#include "Common/Constant.hpp"
+#include "Common/ForwardDecl.hpp"
+
+class NotifyGameDiscovered : public GenericMessage {
+private:
+	std::string m_clientIp;
+	int32_t m_clientPort;
+	RealmGameType m_clientType;
+
+public:
+	NotifyGameDiscovered( sptr_user user );
+	void Serialize(ByteBuffer &out) const override;
+};

Include/Network/Event/NotifyInstantMessage.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "../GenericNetMessage.hpp"
+
+class NotifyInstantMessage : public GenericMessage {
+private:
+	std::wstring m_message;
+	std::wstring m_chatHandle;
+
+public:
+	NotifyInstantMessage( std::wstring chatHandle, std::wstring message );
+	void Serialize(ByteBuffer &out) const override;
+};

Include/Network/Event/NotifyReserveUserSlot_RTA.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../GenericNetMessage.h"
+
+class NotifyReserveUserSlot_RTA : public GenericMessage {
+private:
+	std::string m_discoveryAddr;
+	int32_t m_port;
+	int32_t m_memberId;
+
+public:
+	NotifyReserveUserSlot_RTA( int32_t memberId, std::string discoveryAddr, int32_t discoveryPort );
+	void Serialize(ByteBuffer &out) const override;
+};

Include/Network/Event/NotifyRoomMessage.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../GenericNetMessage.hpp"
+
+class NotifyRoomMessage : public GenericMessage {
+private:
+	std::wstring m_message;
+	std::wstring m_chatHandle;
+	std::wstring m_roomName;
+
+public:
+	NotifyRoomMessage( std::wstring roomName, std::wstring chatHandle, std::wstring message );
+	void Serialize(ByteBuffer &out) const override;
+};

Include/Network/Event/Notify_4C.h

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

Include/Network/Event/Notify_65.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "../GenericNetMessage.h"
+
+class NotifyClientRequestsConnect2 : public GenericMessage {
+private:
+	std::string m_discoveryAddr;
+	std::string m_localAddr;
+	int32_t m_port;
+
+public:
+	NotifyClientRequestsConnect2( std::string discoveryAddr, std::string localAddr, int32_t port );
+	ByteBuffer &Serialize() override;
+};

Include/Network/Event/RequestAddFriend.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestAddFriend : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_chatHandle;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		DATABASE_ERROR = 2,
+		FRIEND_IGNORING = 19,
+		FRIEND_INVALID = 20,
+		FRIEND_DUPLICATE = 21,
+	};
+public:
+	static std::unique_ptr< RequestAddFriend > Create()
+	{
+		return std::make_unique< RequestAddFriend >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultAddFriend : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultAddFriend( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestAddIgnore.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestAddIgnore : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_chatHandle;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		DATABASE_ERROR = 2,
+		IGNORE_INVALID = 20,
+		IGNORE_FRIEND = 24,
+		IGNORE_DUPLICATE = 25,
+	};
+
+public:
+	static std::unique_ptr< RequestAddIgnore > Create()
+	{
+		return std::make_unique< RequestAddIgnore >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultAddIgnore : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultAddIgnore( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestAppendCharacterData.hpp

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

Include/Network/Event/RequestCancelGame.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestCancelGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestCancelGame > Create()
+	{
+		return std::make_unique< RequestCancelGame >();
+	}
+
+	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 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCancelGame_RTA.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+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_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCancelGame_RTA : public GenericResponse {
+public:
+	ResultCancelGame_RTA( GenericRequest *request );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCreateAccount.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestCreateAccount : public GenericRequest
+{
+private:
+	enum CREATE_ACCOUNT_REPLY {
+		SUCCESS = 0,
+		ERROR_FATAL,
+		ERROR_NOT_EXIST
+	};
+
+	std::wstring m_username;
+	std::wstring m_password;
+	std::wstring m_emailAddress;
+	std::wstring m_dateOfBirth;
+	std::wstring m_chatHandle;
+
+	bool VerifyUserData();
+
+public:
+	static std::unique_ptr< RequestCreateAccount > Create()
+	{
+		return std::make_unique< RequestCreateAccount >();
+	}
+
+	CREATE_ACCOUNT_REPLY m_reply;
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCreateAccount : public GenericResponse {
+private:
+	std::wstring m_sessionId;
+	int32_t m_reply;
+
+public:
+	ResultCreateAccount( GenericRequest *request, int32_t reply, std::wstring sessionId );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCreateNewCharacter_RTA.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+#include "Game/RealmCharacter.hpp"
+
+class RequestCreateNewCharacter_RTA : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	CharacterSlotData m_metaData;
+	std::vector< uint8_t > m_characterData;
+	
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+
+public:
+	static std::unique_ptr< RequestCreateNewCharacter_RTA > Create()
+	{
+		return std::make_unique< RequestCreateNewCharacter_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCreateNewCharacter_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultCreateNewCharacter_RTA( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCreatePrivateGame.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestCreatePrivateGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameName;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+		GAME_NAME_IN_USE = 38,
+		GAME_PENDING = 40,
+	};
+
+public:
+	static std::unique_ptr< RequestCreatePrivateGame > Create()
+	{
+		return std::make_unique< RequestCreatePrivateGame >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCreatePrivateGame : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultCreatePrivateGame( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCreatePrivateGame_RTA.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <array>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestCreatePrivateGame_RTA : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameName;
+	std::string m_localAddr;
+	int32_t m_localPort;
+
+	enum ERROR_CODE {
+		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_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultCreatePrivateGame_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultCreatePrivateGame_RTA( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCreatePrivateRoom.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestCreatePrivateRoom : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_roomName;
+
+public:
+	static std::unique_ptr< RequestCreatePrivateRoom > Create()
+	{
+		return std::make_unique< RequestCreatePrivateRoom >();
+	}
+
+	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 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCreatePublicGame.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestCreatePublicGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameInfo;
+	std::wstring m_gameName;
+	std::wstring m_stageName;
+
+	int32_t m_minimumLevel;
+	int32_t m_maximumLevel;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+		GAME_NAME_IN_USE = 38,
+		GAME_PENDING = 40,
+	};
+
+public:
+	static std::unique_ptr< RequestCreatePublicGame > Create()
+	{
+		return std::make_unique< RequestCreatePublicGame >();
+	}
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+
+	std::tuple< std::wstring, std::wstring > ParseNameAndStage( const std::wstring &gameInfo );
+};
+
+class ResultCreatePublicGame : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultCreatePublicGame( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestCreatePublicGame_RTA.hpp

@@ -0,0 +1,48 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <array>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestCreatePublicGame_RTA : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameInfo;
+	std::wstring m_gameName;
+	std::string m_localAddr;
+	int32_t m_localPort;
+
+	std::array< int8_t, 5 > m_attributes;
+
+	enum ERROR_CODE {
+		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_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+	bool ParseGameInfo();
+};
+
+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 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestDoClientDiscovery.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestDoClientDiscovery : public GenericRequest
+{
+private:
+	enum DISCOVERY_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR = 1,
+		GAME_FULL = 2,
+	};
+
+	std::wstring m_sessionId;
+	int32_t m_gameId;
+
+public:
+	static std::unique_ptr< RequestDoClientDiscovery > Create()
+	{
+		return std::make_unique< RequestDoClientDiscovery >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultDoClientDiscovery : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIP;
+	int32_t m_discoveryPort;
+
+public:
+	ResultDoClientDiscovery( GenericRequest *request, int32_t reply, std::string ip = "", int32_t port = 0);
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestDoClientDiscovery_RTA.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestDoClientDiscovery_RTA : public GenericRequest {
+private:
+	std::wstring m_sessionId;
+	std::wstring m_localAddr;
+	int32_t m_localPort;
+
+	uint32_t m_gameId;
+
+	enum REPLY {
+		SUCCESS = 0,
+		TIMEOUT,
+		NOT_FOUND
+	};
+
+public:
+	static std::unique_ptr< RequestDoClientDiscovery_RTA > Create()
+	{
+		return std::make_unique< RequestDoClientDiscovery_RTA >();
+	}
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultDoClientDiscovery_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::string m_discoveryIp;
+	int32_t m_discoveryPort;
+
+public:
+	ResultDoClientDiscovery_RTA( GenericRequest *request, int32_t reply, std::string discoveryIp = "", int32_t discoveryPort = 0);
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestEnterRoom.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+#include "Game/ChatRoomSession.hpp"
+
+class RequestEnterRoom : public GenericRequest
+{
+private:
+	std::wstring m_roomName;
+
+	enum REPLY {
+		SUCCESS = 0,
+		GENERAL_ERROR
+	};
+
+public:
+	static std::unique_ptr< RequestEnterRoom > Create()
+	{
+		return std::make_unique< RequestEnterRoom >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultEnterRoom : public GenericResponse {
+private:
+	int32_t m_reply;
+	sptr_chat_room_session m_room;
+
+public:
+	ResultEnterRoom( GenericRequest *request, int32_t reply, sptr_chat_room_session room );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetCharacterData_RTA.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+#include "Game/RealmCharacter.hpp"
+
+class RequestGetNetCharacterData_RTA : public GenericRequest
+{
+private:
+	int32_t m_characterId;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+
+public:
+	static std::unique_ptr< RequestGetNetCharacterData_RTA > Create()
+	{
+		return std::make_unique< RequestGetNetCharacterData_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+
+	sptr_generic_response SendCharacterData(sptr_socket socket, sptr_realm_character data);
+};
+
+class ResultGetNetCharacterData_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+	int32_t m_endOfData;
+	std::vector< uint8_t > m_chunk;
+
+public:
+	ResultGetNetCharacterData_RTA( GenericRequest *request, int32_t reply,
+		std::optional< std::vector< uint8_t > > data = std::nullopt,
+		std::optional < int32_t > endOfData = std::nullopt );
+
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetEncryptionKey.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestGetEncryptionKey : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetEncryptionKey > Create()
+	{
+		return std::make_unique< RequestGetEncryptionKey >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetEncryptionKey : public GenericResponse {
+public:
+	std::vector< uint8_t > m_symKey;
+
+	ResultGetEncryptionKey( GenericRequest *request );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetFriendList.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
+class RequestGetFriendList : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetFriendList > Create()
+	{
+		return std::make_unique< RequestGetFriendList >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetFriendList : public GenericResponse {
+public:
+	ResultGetFriendList( GenericRequest *request );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetGame.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestGetGame : public GenericRequest {
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameName;
+
+	enum REPLY {
+		SUCCESS = 0,
+		TIMEOUT,
+		NOT_FOUND
+	};
+
+public:
+	static std::unique_ptr< RequestGetGame > Create()
+	{
+		return std::make_unique< RequestGetGame >();
+	}
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetGame : public GenericResponse {
+private:
+	int32_t m_reply;
+	int32_t m_gameId;
+
+public:
+	ResultGetGame( GenericRequest *request, int32_t reply, int32_t gameId = 0 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetGame_RTA.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestGetGame_RTA : public GenericRequest {
+private:
+	std::wstring m_sessionId;
+	std::wstring m_gameName;
+
+	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_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetGame_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+	int32_t m_gameId;
+
+	std::wstring m_discoveryAddr;
+	std::wstring m_localAddr;
+	int32_t m_port;
+
+public:
+	ResultGetGame_RTA( GenericRequest *request, int32_t reply, int32_t gameId = -1, std::string discoveryAddr = "", std::string localAddr = "", int32_t discoveryPort = 0 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetNetCharacterList_RTA.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <map>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+#include "Game/RealmCharacterMetaKV.hpp"
+
+class RequestGetNetCharacterList_RTA : public GenericRequest
+{
+private:
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+
+public:
+	static std::unique_ptr< RequestGetNetCharacterList_RTA > Create()
+	{
+		return std::make_unique< RequestGetNetCharacterList_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetNetCharacterList_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+	std::map< uint32_t, CharacterSlotData > m_characterList;
+
+public:
+	ResultGetNetCharacterList_RTA( GenericRequest *request, int32_t reply, std::optional< std::map< uint32_t, CharacterSlotData > > list );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetPublicRooms.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+#include "Game/ChatRoomSession.hpp"
+
+class RequestGetPublicRooms : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetPublicRooms > Create()
+	{
+		return std::make_unique< RequestGetPublicRooms >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetPublicRooms : public GenericResponse {
+private:
+	std::vector< sptr_chat_room_session > m_rooms;
+
+public:
+	ResultGetPublicRooms( GenericRequest *request, std::vector< sptr_chat_room_session > rooms );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetRealmStats.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestGetRealmStats : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetRealmStats > Create()
+	{
+		return std::make_unique< RequestGetRealmStats >();
+	}
+	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 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetRoom.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+#include "Game/ChatRoomSession.hpp"
+
+class RequestGetRoom : public GenericRequest {
+private:
+	std::wstring m_sessionId;
+	std::wstring m_roomName;
+
+	enum CREATE_ACCOUNT_REPLY {
+		SUCCESS = 0,
+		GENERAL_ERROR = 1,
+	};
+
+public:
+	static std::unique_ptr< RequestGetRoom > Create()
+	{
+		return std::make_unique< RequestGetRoom >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetRoom : public GenericResponse {
+private:
+	int32_t m_reply;
+	sptr_chat_room_session m_room;
+
+public:
+	ResultGetRoom( GenericRequest *request, int32_t reply, sptr_chat_room_session room = nullptr );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetRules.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestGetRules : public GenericRequest
+{
+private:
+	std::string m_language;
+
+public:
+	static std::unique_ptr< RequestGetRules > Create()
+	{
+		return std::make_unique< RequestGetRules >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetRules : public GenericResponse {
+private:
+	std::wstring m_rules;
+
+public:
+	ResultGetRules( GenericRequest *request, std::wstring rules );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetServerAddress.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+#include "Common/Constant.hpp"
+
+class RequestGetServerAddress : public GenericRequest {
+public:
+	static std::unique_ptr< RequestGetServerAddress > Create()
+	{
+		return std::make_unique< RequestGetServerAddress >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetServerAddress : public GenericResponse {
+public:
+	std::string m_ip;
+	int32_t		m_port;
+	RealmGameType m_gameType;
+
+	ResultGetServerAddress( GenericRequest *request, std::string ip, int32_t port, RealmGameType clientType );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetSocialListInitial.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+#include "Common/ForwardDecl.hpp"
+
+class RequestGetSocialListInitial : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetSocialListInitial > Create()
+	{
+		return std::make_unique< RequestGetSocialListInitial >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetSocialListInitial : public GenericResponse {
+private:
+	int32_t m_reply;
+	sptr_user m_user;
+
+public:
+	ResultGetSocialListInitial( GenericRequest *request, sptr_user user = nullptr );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestGetSocialListUpdate.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+#include "Common/ForwardDecl.hpp"
+
+class RequestGetSocialListUpdate : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestGetSocialListUpdate > Create()
+	{
+		return std::make_unique< RequestGetSocialListUpdate >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultGetSocialListUpdate : public GenericResponse {
+private:
+	int32_t m_reply;
+	sptr_user m_user;
+
+public:
+	ResultGetSocialListUpdate( GenericRequest *request, sptr_user user = nullptr );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestLeaveRoom.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestLeaveRoom : public GenericRequest
+{
+private:
+	std::wstring m_roomName;
+
+	enum REPLY {
+		SUCCESS = 0,
+		GENERAL_ERROR
+	};
+
+public:
+	static std::unique_ptr< RequestLeaveRoom > Create()
+	{
+		return std::make_unique< RequestLeaveRoom >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultLeaveRoom : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultLeaveRoom( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestLogin.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestLogin : public GenericRequest
+{
+private:
+	enum LOGIN_REPLY {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		ACCOUNT_INVALID = 4,
+	};
+
+	std::wstring m_username;
+	std::wstring m_password;
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestLogin > Create()
+	{
+		return std::make_unique< RequestLogin >();
+	}
+
+	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 {
+private:
+	std::wstring m_sessionId;
+	int32_t m_reply;
+
+public:
+	ResultLogin( GenericRequest *request, int32_t reply, std::wstring sessionId );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestLogout.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestLogout : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestLogout > Create()
+	{
+		return std::make_unique< RequestLogout >();
+	}
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultLogout : public GenericResponse {
+private:
+	int32_t m_reply;
+public:
+	ResultLogout( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestMatchGame.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestMatchGame : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestMatchGame > Create()
+	{
+		return std::make_unique< RequestMatchGame >();
+	}
+
+	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, std::string userIp );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestMatchGame_RTA.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestMatchGame_RTA : public GenericRequest
+{
+public:
+	static std::unique_ptr< RequestMatchGame_RTA > Create()
+	{
+		return std::make_unique< RequestMatchGame_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultMatchGame_RTA : public GenericResponse {
+private:
+	std::string m_userIp;
+
+public:
+	ResultMatchGame_RTA( GenericRequest *request, std::string userIp );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestRemoveFriend.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestRemoveFriend : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_chatHandle;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		DATABASE_ERROR = 2,
+		FRIEND_IGNORING = 19,
+		FRIEND_INVALID = 20,
+		FRIEND_DUPLICATE = 21,
+	};
+public:
+	static std::unique_ptr< RequestRemoveFriend > Create()
+	{
+		return std::make_unique< RequestRemoveFriend >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultRemoveFriend : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultRemoveFriend( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestRemoveIgnore.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestRemoveIgnore : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_chatHandle;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		DATABASE_ERROR = 2,
+		IGNORE_INVALID = 20,
+		IGNORE_FRIEND = 24,
+		IGNORE_DUPLICATE = 25,
+	};
+
+public:
+	static std::unique_ptr< RequestRemoveIgnore > Create()
+	{
+		return std::make_unique< RequestRemoveIgnore >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultRemoveIgnore : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultRemoveIgnore( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestSaveCharacter_RTA.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+#include "Game/RealmCharacter.hpp"
+
+class RequestSaveCharacter_RTA : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_memberSessionId;
+	uint32_t m_targetCharacterId;
+	
+	CharacterSlotData m_metaData;
+	std::vector< uint8_t > m_characterData;
+	
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+
+public:
+	static std::unique_ptr< RequestSaveCharacter_RTA > Create()
+	{
+		return std::make_unique< RequestSaveCharacter_RTA >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultSaveCharacter_RTA : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultSaveCharacter_RTA( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestSendInstantMessage.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestSendInstantMessage : public GenericRequest
+{
+private:
+	std::wstring m_chatHandle;
+	std::wstring m_message;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		GENERAL_ERROR,
+		USER_IGNORED = 19,
+	};
+
+public:
+	static std::unique_ptr< RequestSendInstantMessage > Create()
+	{
+		return std::make_unique< RequestSendInstantMessage >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultSendInstantMessage : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultSendInstantMessage( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestSendRoomMessage.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestSendRoomMessage : public GenericRequest
+{
+private:
+	std::wstring m_roomName;
+	std::wstring m_message;
+
+	enum REPLY {
+		SUCCESS = 0,
+		GENERAL_ERROR
+	};
+
+public:
+	static std::unique_ptr< RequestSendRoomMessage > Create()
+	{
+		return std::make_unique< RequestSendRoomMessage >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultSendRoomMessage : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultSendRoomMessage( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestStartGame.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestStartGame : public GenericRequest
+{
+private:
+	std::vector< uint8_t > m_data;
+
+	enum ERROR_CODE {
+		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 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestTouchSession.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestTouchSession : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+
+public:
+	static std::unique_ptr< RequestTouchSession > Create()
+	{
+		return std::make_unique< RequestTouchSession >();
+	}
+	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 );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestUpdateGameData.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+#include "Game/GameSession.hpp"
+
+class RequestUpdateGameData : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::string m_gameData;
+
+public:
+	static std::unique_ptr< RequestUpdateGameData > Create()
+	{
+		return std::make_unique< RequestUpdateGameData >();
+	}
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+	bool ParseGameData( sptr_game_session session );
+};
+
+class ResultUpdateGameData : public GenericResponse {
+public:
+	ResultUpdateGameData( GenericRequest *request );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/RequestUserJoinSuccess.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.hpp"
+#include "../GenericNetResponse.hpp"
+
+class RequestUserJoinSuccess : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_ownerSessionId;
+
+	enum ERROR_CODE {
+		SUCCESS = 0,
+		FATAL_ERROR,
+		GENERAL_ERROR,
+	};
+public:
+	static std::unique_ptr< RequestUserJoinSuccess > Create()
+	{
+		return std::make_unique< RequestUserJoinSuccess >();
+	}
+
+	sptr_generic_response ProcessRequest( sptr_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_byte_stream stream ) override;
+};
+
+class ResultUserJoinSuccess : public GenericResponse {
+private:
+	int32_t m_reply;
+
+public:
+	ResultUserJoinSuccess( GenericRequest *request, int32_t reply );
+	void Serialize( ByteBuffer &out ) const;
+};

Include/Network/Event/Request_5F.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
+class Request_5F : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::wstring m_memberSessionId;
+
+	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();
+};

Include/Network/Event/Request_61.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include "../GenericNetRequest.h"
+#include "../GenericNetResponse.h"
+
+class Request_61 : public GenericRequest
+{
+public:
+	static std::unique_ptr< Request_61 > Create()
+	{
+		return std::make_unique< Request_61 >();
+	}
+
+	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 );
+	ByteBuffer &Serialize();
+};

Include/Network/Events.hpp

@@ -0,0 +1,269 @@
+#pragma once
+
+#include <map>
+#include <functional>
+
+/* 0001 */	#include "Event/RequestAddFriend.hpp"
+/* 0002 */	#include "Event/RequestAddIgnore.hpp"
+
+/* 0005 */	#include "Event/RequestCancelGame.hpp"
+/* 0006 */	#include "Event/RequestCreateAccount.hpp"
+
+/* 0008 */	#include "Event/RequestCreatePrivateGame.hpp"
+/* 0009 */	#include "Event/RequestCreatePrivateRoom.hpp"
+
+/* 000A */	#include "Event/RequestCreatePublicGame.hpp"
+
+/* 000C */	#include "Event/RequestEnterRoom.hpp"
+/* 000D */	#include "Event/RequestGetGame.hpp"
+/* 000E */	#include "Event/RequestGetPublicRooms.hpp"
+/* 000F */	#include "Event/RequestGetRealmStats.hpp"
+
+/* 0011 */	#include "Event/RequestGetRoom.hpp"
+/* 0015 */	#include "Event/RequestLeaveRoom.hpp"
+/* 0016 */	#include "Event/RequestLogin.hpp"
+/* 0017 */	#include "Event/RequestLogout.hpp"
+/* 0018 */	#include "Event/RequestMatchGame.hpp"
+
+/* 001C */	#include "Event/RequestRemoveFriend.hpp"
+/* 001D */	#include "Event/RequestRemoveIgnore.hpp"
+
+/* 0021 */	#include "Event/RequestSendInstantMessage.hpp"
+/* 0022 */	#include "Event/RequestSendRoomMessage.hpp"
+/* 0023 */	#include "Event/RequestStartGame.hpp"
+/* 0024 */	#include "Event/RequestTouchSession.hpp"
+/* 0025 */	#include "Event/RequestDoClientDiscovery.hpp"
+
+/* 0027 */	#include "Event/RequestGetEncryptionKey.hpp"
+
+/* 0041 */	#include "Event/NotifyForcedLogout.hpp"
+/* 0042 */	#include "Event/RequestGetRules.hpp"
+/* 0043 */	#include "Event/RequestGetServerAddress.hpp"
+/* 0044 */	#include "Event/RequestUpdateGameData.hpp"
+
+/* 0054 */	#include "Event/RequestCreatePublicGame_RTA.hpp"
+/* 0055 */	#include "Event/RequestMatchGame_RTA.hpp"
+/* 0056 */	#include "Event/RequestCreatePrivateGame_RTA.hpp"
+/* 0057 */	#include "Event/RequestGetGame_RTA.hpp"
+
+/* 0058 */	#include "Event/RequestCreateNewCharacter_RTA.hpp"
+/* 005B */	#include "Event/RequestGetNetCharacterList_RTA.hpp"
+/* 005C */	#include "Event/RequestGetCharacterData_RTA.hpp"
+/* 005D */	#include "Event/RequestAppendCharacterData.hpp"
+/* 005E */	#include "Event/RequestSaveCharacter_RTA.hpp"
+/* 005F */	#include "Event/RequestUserJoinSuccess.hpp"
+/* 0060 */	#include "Event/RequestCancelGame_RTA.hpp"
+/* 0061 */	#include "Event/RequestGetSocialListInitial.hpp"
+/* 0062 */	#include "Event/RequestGetSocialListUpdate.hpp"
+
+/* 0066 */	#include "Event/RequestDoClientDiscovery_RTA.hpp"
+
+
+const std::map< int16_t, std::function< std::unique_ptr< GenericRequest >() > > REQUEST_EVENT =
+{
+	{ 0x0001, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestAddFriend >();
+		}
+	},
+	{ 0x0002, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestAddIgnore >();
+		}
+	},
+	{ 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 >();
+		}
+	},
+	{ 0x0015, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestLeaveRoom >();
+		}
+	},
+	{ 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 >();
+		}
+	},
+	{ 0x001C, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestRemoveFriend >();
+		}
+	},
+	{ 0x001D, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestRemoveIgnore >();
+		}
+	},
+	{ 0x0021, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestSendInstantMessage >();
+		}
+	},
+	{ 0x0022, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestSendRoomMessage >();
+		}
+	},
+	{ 0x0023, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestStartGame >();
+		}
+	},
+	{ 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 >();
+		}
+	},
+	{ 0x0057, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetGame_RTA >();
+		}
+	},
+	{ 0x0058, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestCreateNewCharacter_RTA >();
+		}
+	},
+	{ 0x005B, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetNetCharacterList_RTA >();
+		}
+	},
+	{ 0x005C, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetNetCharacterData_RTA >();
+		}
+	},
+	{ 0x005D, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestAppendCharacterData >();
+		}
+	},
+	{ 0x005E, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestSaveCharacter_RTA >();
+		}
+	},
+	{ 0x005F, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestUserJoinSuccess >();
+		}
+	},
+	{ 0x0060, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestCancelGame_RTA >();
+		}
+	},
+	{ 0x0061, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetSocialListInitial >();
+		}
+	},
+	{ 0x0062, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetSocialListUpdate >();
+		}
+	},
+	{ 0x0066, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestDoClientDiscovery_RTA >();
+		}
+	},
+};

Include/Network/GenericNetMessage.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Common/ByteStream.hpp"
+
+class GenericMessage
+{
+public:
+	uint16_t m_packetId;
+	ByteBuffer m_stream;
+
+	GenericMessage( uint16_t packetId ) : m_packetId( packetId )
+	{
+	}
+
+	virtual ~GenericMessage() = default;
+	virtual void Serialize( ByteBuffer &out ) const = 0;
+};
+
+typedef std::shared_ptr< GenericMessage > sptr_generic_message;

Include/Network/GenericNetRequest.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <memory>
+
+#include "Common/ByteStream.hpp"
+
+class GenericResponse;
+using sptr_generic_response = std::shared_ptr< GenericResponse >;
+
+class RealmUser;
+using sptr_user = std::shared_ptr< RealmUser >;
+
+class RealmSocket;
+using sptr_socket = std::shared_ptr< RealmSocket >;
+
+class GenericRequest {
+public:
+	int16_t m_packetId;
+	uint32_t m_trackId;
+
+	virtual ~GenericRequest() = default;
+
+	virtual sptr_generic_response ProcessRequest( sptr_socket user, sptr_byte_stream stream )
+	{
+		throw std::runtime_error( "ProcessRequest not implemented for GenericRequest" );
+	}
+
+	virtual sptr_generic_response ProcessRequest( sptr_byte_stream stream )
+	{
+		throw std::runtime_error( "ProcessRequest not implemented for GenericRequest" );
+	}
+
+	void DeserializeHeader( sptr_byte_stream stream )
+	{
+		m_packetId = stream->read_u16();
+		m_trackId = stream->read_u32();
+		auto version = stream->read_u32();	// 2 for CON and 6 for RTA
+	};
+
+	virtual void Deserialize( sptr_byte_stream stream ) = 0;
+};
+
+using sptr_generic_request = std::shared_ptr< GenericRequest >;
+

Include/Network/GenericNetResponse.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "GenericNetRequest.hpp"
+#include "Common/ByteStream.hpp"
+
+class GenericResponse
+{
+public:
+	uint16_t m_packetId;
+	uint32_t m_trackId;
+	ByteBuffer m_stream;
+
+	GenericResponse( const GenericRequest &request )
+	{
+		m_packetId = request.m_packetId;
+		m_trackId = request.m_trackId;
+	}
+
+	virtual ~GenericResponse() = default;
+	virtual void Serialize( ByteBuffer& out ) const = 0;
+};
+
+using sptr_generic_response = std::shared_ptr< GenericResponse >;

Include/Network/RealmSocket.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <memory>
+#include <vector>
+#include <mutex>
+#include <winsock2.h>
+
+#include "GenericNetRequest.hpp"
+#include "GenericNetResponse.hpp"
+#include "GenericNetMessage.hpp"
+#include "Common/Constant.hpp"
+
+class RealmSocket
+{
+private:
+	const size_t WRITE_BUFFER_SIZE = 65535;
+
+public:
+	RealmSocket();
+	~RealmSocket();
+
+	void send( const sptr_generic_response response );
+	void send( const GenericMessage &message );
+
+	// Comparison operator for sorting
+	bool operator<( const RealmSocket &rhs ) const
+	{
+		return fd < rhs.fd;
+	}
+
+	// Comparison operator for comparing
+	bool operator==( const RealmSocket &rhs ) const
+	{
+		return fd == rhs.fd;
+	}
+
+	SOCKET fd;
+
+	struct s_flag {
+		bool disconnected_wait;
+		bool disconnected_forced;
+		bool is_listener;
+		bool is_gateway;
+		bool want_more_read_data;
+		bool want_more_write_data;
+	} flag;
+
+	sockaddr_in local_addr;
+	sockaddr_in remote_addr;
+
+	RealmGameType gameType;
+	std::string remote_ip;
+	uint32_t remote_port;
+	uint32_t last_write_position;
+	uint64_t latency;
+
+	std::chrono::steady_clock::time_point last_recv_time;
+	std::chrono::steady_clock::time_point last_send_time;
+
+	std::mutex write_mutex;
+	std::mutex read_mutex;
+
+	std::vector< uint8_t >		read_buffer;
+
+	std::vector< uint8_t > m_pendingWriteBuffer;
+	std::vector< uint8_t > m_pendingReadBuffer;
+};
+
+using sptr_socket = std::shared_ptr< RealmSocket >;