Lobby Server events for game/room management

Lobby Server/Event/NotifyClientDiscovered.cpp

@@ -10,6 +10,8 @@ NotifyClientDiscovered::NotifyClientDiscovered( std::string clientIp, int32_t cl
 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 );
 

Lobby Server/Event/NotifyClientReqConnect.cpp

@@ -10,6 +10,8 @@ NotifyClientRequestConnect::NotifyClientRequestConnect( std::string clientIp, in
 ByteStream &NotifyClientRequestConnect::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 );
 

Lobby Server/Event/NotifyGameDiscovered.cpp

@@ -10,6 +10,8 @@ NotifyGameDiscovered::NotifyGameDiscovered( std::string clientIp, int32_t client
 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 );
 

Lobby Server/Event/RequestCancelGame.cpp

@@ -12,11 +12,18 @@ sptr_generic_response RequestCancelGame::ProcessRequest( sptr_tcp_socket socket,
 {
 	Deserialize( socket, stream );
 
-	// TODO:
+	auto user = RealmUserManager::Get().GetUser( socket );
-	// Cancel the game
-	// Notify the players via the Discovery Server
 
-	Log::Debug( "RequestCancelGame : %S", m_sessionId.c_str() );
+	if( user == nullptr )
+	{
+		Log::Error( "User not found! [%S]", m_sessionId.c_str() );
+		return std::make_shared< ResultCancelGame >( this );
+	}
+
+	GameSessionManager::Get().CancelGameSession( m_sessionId );
+
+	// TODO:
+	// Notify the players via the Discovery Server
 
 	return std::make_shared< ResultCancelGame >( this );
 }

Lobby Server/Event/RequestCreatePrivateGame.cpp

@@ -34,8 +34,10 @@ sptr_generic_response RequestCreatePrivateGame::ProcessRequest( sptr_tcp_socket
 
 	Log::Info( "[%S] Create Private Game: %S", m_sessionId.c_str(), m_gameName.c_str() );
 
+	user->m_state = RealmUser::UserState::InGameLobby;
+
 	// Send the discovery server information to the client
-	return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::SUCCESS, "192.168.1.248", 40820 );
+	return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::SUCCESS, "192.168.1.248", 3008 );
 }
 
 ResultCreatePrivateGame::ResultCreatePrivateGame( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )

Lobby Server/Event/RequestCreatePrivateGame.h

@@ -11,6 +11,7 @@ private:
 		FATAL_ERROR,
 		GENERAL_ERROR,
 	};
+
 public:
 	static std::unique_ptr< RequestCreatePrivateGame > Create()
 	{

Lobby Server/Event/RequestCreatePublicGame.cpp

@@ -41,8 +41,10 @@ sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_tcp_socket s
 
 	Log::Info( "[%S] Create Public Game: %S", m_sessionId.c_str(), m_gameName.c_str() );
 
+	user->m_state = RealmUser::UserState::InGameLobby;
+
 	// Send the discovery server information to the client
-	return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::SUCCESS, "192.168.1.248", 40820 );
+	return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::SUCCESS, "192.168.1.248", 3008 );
 }
 
 ResultCreatePublicGame::ResultCreatePublicGame( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )

Lobby Server/Event/RequestDoClientDiscovery.cpp

@@ -1,6 +1,7 @@
 #include "../../global_define.h"
 #include "RequestDoClientDiscovery.h"
-#include "NotifyClientReqConnect.h"
+#include "NotifyClientDiscovered.h"
+#include "NotifyGameDiscovered.h"
 
 void RequestDoClientDiscovery::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
 {
@@ -28,15 +29,22 @@ sptr_generic_response RequestDoClientDiscovery::ProcessRequest( sptr_tcp_socket
 		return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
 	}
 
-	auto result = GameSessionManager::Get().UserJoinGame( m_gameId, user );
+	auto result = GameSessionManager::Get().CreatePublicGameSession( user, L"test", 0, 9999 );
 
-	if( result == false )
+	//auto result = GameSessionManager::Get().UserJoinGame( m_gameId, user );
-	{
-		Log::Error( "Failed to join game! [%d]", m_gameId );
-		return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::GAME_FULL, "", 0 );
-	}
 
-	return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::SUCCESS, "192.168.1.248", 40820 );
+	//if( result == false )
+	//{
+	//	Log::Error( "Failed to join game! [%d]", m_gameId );
+	//	return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::GAME_FULL, "", 0 );
+	//}
+
+	//NotifyClientDiscovered notify1( "192.168.1.248", 47115 );
+	//NotifyGameDiscovered notify2( "192.168.1.248", 47115 );
+	//socket->send( notify1 );
+	//socket->send( notify2 );
+
+	return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::SUCCESS, "192.168.1.248", 3008 );
 }
 
 ResultDoClientDiscovery::ResultDoClientDiscovery( GenericRequest *request, int32_t reply, std::string ip, int32_t port ) : GenericResponse( *request )

Lobby Server/Event/RequestGetRealmStats.cpp

@@ -0,0 +1,36 @@
+#include "../../global_define.h"
+#include "RequestGetRealmStats.h"
+
+void RequestGetRealmStats::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+}
+
+sptr_generic_response RequestGetRealmStats::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	return std::make_shared< ResultGetRealmStats >( this );
+}
+
+ResultGetRealmStats::ResultGetRealmStats( GenericRequest *request ) : GenericResponse( *request )
+{
+	
+}
+
+ByteStream &ResultGetRealmStats::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	m_stream.write_u32( 1 );
+	m_stream.write_u32( 2 );
+	m_stream.write_u32( 3 );
+	m_stream.write_u32( 4 );
+	m_stream.write_u32( 5 );
+	m_stream.write_u32( 6 );
+	m_stream.write_u32( 7 );
+	m_stream.write_u32( 8 );
+	return m_stream;
+}

Lobby Server/Event/RequestGetRealmStats.h

@@ -0,0 +1,20 @@
+#pragma once
+
+class RequestGetRealmStats : public GenericRequest
+{
+private:
+
+public:
+	static std::unique_ptr< RequestGetRealmStats > Create()
+	{
+		return std::make_unique< RequestGetRealmStats >();
+	}
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultGetRealmStats : public GenericResponse {
+public:
+	ResultGetRealmStats( GenericRequest *request );
+	ByteStream &Serialize();
+};

Lobby Server/Event/RequestMatchGame.cpp

@@ -53,36 +53,43 @@ ByteStream &ResultMatchGame::Serialize()
 {
 	m_stream.write_u16( m_packetId );
 	m_stream.write_u32( m_requestId );
-	m_stream.write_u32( 0 );		// Connection State
+	m_stream.write_u32( 0 );
 
-	m_stream.write_u32( 5 );
+	m_stream.write_u32( 2 );
 
-	for( int i = 0; i < 5; i++ )
+	for( int i = 0; i < 2; i++ )
 	{
 		m_stream.write_utf16( L"Unknown_A " + std::to_wstring( i ) );
 	}
 
-	m_stream.write_u32( 5 );
+	m_stream.write_u32( 2 );
 
-	for( int i = 0; i < 5; i++ )
+	for( int i = 0; i < 2; i++ )
 	{
 		m_stream.write_utf16( L"Game Name " + std::to_wstring( i ) );
 	}
 
-	m_stream.write_u32( 5 );
+	m_stream.write_u32( 2 );
 
-	for( int i = 0; i < 5; i++ )
+	for( int i = 0; i < 2; i++ )
 	{
 		m_stream.write_utf16( L"Unknown_B " + std::to_wstring( i ) );
 	}
 
-
 	// Room Unique ID (Used when selecting)
-	m_stream.write_u32( 5 );
+	m_stream.write_u32( 2 );
-	for( int i = 0; i < 5; i++ )
+	for( int i = 0; i < 2; i++ )
 	{
 		m_stream.write_u32( i );
 	}
 
+	// "GameBlob"
+	m_stream.write_u32( 1 );
+	for( int i = 0; i < 1; i++ )
+	{
+		std::vector< uint8_t > bytes( 256, 0 );
+		m_stream.write_bytes( bytes );
+	}
+
 	return m_stream;
 }

Lobby Server/Event/RequestUpdateGameData.cpp

@@ -0,0 +1,36 @@
+#include "../../global_define.h"
+#include "RequestUpdateGameData.h"
+
+void RequestUpdateGameData::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	DeserializeHeader( stream );
+
+	m_sessionId = stream->read_encrypted_utf16();
+	m_gameData = stream->read_utf8();
+	//m_hardwareIp = stream->read_sz_utf8();
+}
+
+sptr_generic_response RequestUpdateGameData::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
+{
+	Deserialize( socket, stream );
+
+	Log::Debug( "RequestUpdateGameData : %S", m_sessionId.c_str() );
+
+	Log::Packet( stream->data, stream->data.size(), false );
+
+	return std::make_shared< ResultUpdateGameData >( this );
+}
+
+ResultUpdateGameData::ResultUpdateGameData( GenericRequest *request ) : GenericResponse( *request )
+{
+	
+}
+
+ByteStream &ResultUpdateGameData::Serialize()
+{
+	m_stream.write_u16( m_packetId );
+	m_stream.write_u32( m_requestId );
+	m_stream.write_u32( 0 );
+
+	return m_stream;
+}

Lobby Server/Event/RequestUpdateGameData.h

@@ -0,0 +1,23 @@
+#pragma once
+
+class RequestUpdateGameData : public GenericRequest
+{
+private:
+	std::wstring m_sessionId;
+	std::string m_gameData;
+	std::string m_hardwareIp;
+
+public:
+	static std::unique_ptr< RequestUpdateGameData > Create()
+	{
+		return std::make_unique< RequestUpdateGameData >();
+	}
+	sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+	void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
+};
+
+class ResultUpdateGameData : public GenericResponse {
+public:
+	ResultUpdateGameData( GenericRequest *request );
+	ByteStream &Serialize();
+};

Lobby Server/EventLookup.h

@@ -7,6 +7,7 @@
 #include "Event/RequestCreateAccount.h"
 #include "Event/RequestCreatePrivateGame.h"
 #include "Event/RequestCreatePublicGame.h"
+#include "Event/RequestGetRealmStats.h"
 #include "Event/RequestLogin.h"
 #include "Event/RequestLogout.h"
 #include "Event/RequestMatchGame.h"
@@ -14,6 +15,7 @@
 #include "Event/RequestDoClientDiscovery.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 =
 {
@@ -37,6 +39,11 @@ const std::map< int16_t, std::function< std::unique_ptr< GenericRequest >() > >
 			return std::make_unique< RequestCreatePublicGame >();
 		}
 	},
+	{ 0x000F, []() -> std::unique_ptr< GenericRequest >
+		{
+			return std::make_unique< RequestGetRealmStats >();
+		}
+	},
 	{ 0x0016, []() -> std::unique_ptr< GenericRequest >
 		{
 			return std::make_unique< RequestLogin >();
@@ -71,5 +78,12 @@ const std::map< int16_t, std::function< std::unique_ptr< GenericRequest >() > >
 		{
 		return std::make_unique< RequestGetRules >();
 		}
+	},
+	{
+	 0x0044, []() -> std::unique_ptr< GenericRequest >
+	  {
+	  return std::make_unique< RequestUpdateGameData >();
+	  }
 	}
+
 };

Lobby Server/LobbyServer.cpp

@@ -36,7 +36,7 @@ void LobbyServer::Start( std::string ip, int32_t port )
 	sockaddr_in service;
 	service.sin_family = AF_INET;
 	service.sin_port = htons( port );
-	service.sin_addr.s_addr = inet_addr( ip.c_str() );
+	service.sin_addr.s_addr = ADDR_ANY;
 
 	if( bind( m_listenSocket, ( SOCKADDR * )&service, sizeof( service ) ) == SOCKET_ERROR )
 	{
@@ -241,6 +241,7 @@ void LobbyServer::HandleRequest( sptr_tcp_socket socket, sptr_byte_stream stream
 	if( it == LOBBY_REQUEST_EVENT.end() )
 	{
 		Log::Error( "[LOBBY] Unknown packet id : 0x%04X", packetId );
+		Log::Packet( stream->data, stream->data.size(), false );
 		return;
 	}