mosskoi/Champions-Reborn-Server-Mirror
1
0
Fork 0
mirror of https://github.com/HikikoMarmy/Champions-Reborn-Server.git synced 2026-04-10 10:59:48 -03:00
Code Issues Packages Projects Releases Wiki Activity

Clean up and game creation

Browse Source
This commit is contained in:
HikikoMarmy
2025-02-20 02:39:41 +00:00
parent 5123cc95f8
commit 4469603710
31 changed files with 263 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
Lobby Server/Event/RequestCancelGame.cpp
View File

@@ -1,18 +1,16 @@
#include "../../global_define.h"
#include "RequestCancelGame.h"
void RequestCancelGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestCancelGame::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
m_sessionId = stream->read_encrypted_utf16();
}
sptr_generic_response RequestCancelGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestCancelGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
auto user = RealmUserManager::Get().GetUser( socket );
Deserialize( stream );
if( user == nullptr )
{
@@ -20,7 +18,7 @@ sptr_generic_response RequestCancelGame::ProcessRequest( sptr_tcp_socket socket,
return std::make_shared< ResultCancelGame >( this );
}
GameSessionManager::Get().CancelGameSession( m_sessionId );
GameSessionManager::Get().CancelGameSession( user );
// TODO:
// Notify the players via the Discovery Server

4
Lobby Server/Event/RequestCancelGame.h
View File

@@ -11,8 +11,8 @@ public:
return std::make_unique< RequestCancelGame >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultCancelGame : public GenericResponse {

11
Lobby Server/Event/RequestCreateAccount.cpp
View File

@@ -1,7 +1,7 @@
#include "../../global_define.h"
#include "RequestCreateAccount.h"
void RequestCreateAccount::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestCreateAccount::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
@@ -11,22 +11,19 @@ void RequestCreateAccount::Deserialize( sptr_tcp_socket socket, sptr_byte_stream
auto dateOfBirth = stream->read_encrypted_utf16();
}
sptr_generic_response RequestCreateAccount::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestCreateAccount::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
Log::Debug( "Account creation isn't supported. Random SessionID generated." );
auto &userMng = RealmUserManager::Get();
auto user = userMng.CreateUser( socket, L"foo", L"bar" );
if( nullptr == user )
{
Log::Error( "RequestCreateAccount::ProcessRequest() - User not found!" );
return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::ERROR_FATAL, L"" );
}
return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::SUCCESS, user->m_sessionId );
return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::SUCCESS, user->session_id );
}
ResultCreateAccount::ResultCreateAccount( GenericRequest *request, int32_t reply, std::wstring sessionId ) : GenericResponse( *request )

4
Lobby Server/Event/RequestCreateAccount.h
View File

@@ -19,8 +19,8 @@ public:
CREATE_ACCOUNT_REPLY m_reply;
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultCreateAccount : public GenericResponse {

23
Lobby Server/Event/RequestCreatePrivateGame.cpp
View File

@@ -2,7 +2,7 @@
#include "RequestCreatePrivateGame.h"
void RequestCreatePrivateGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestCreatePrivateGame::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
@@ -10,21 +10,11 @@ void RequestCreatePrivateGame::Deserialize( sptr_tcp_socket socket, sptr_byte_st
m_gameName = stream->read_utf16();
}
sptr_generic_response RequestCreatePrivateGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestCreatePrivateGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
auto user = RealmUserManager::Get().GetUser( socket );
if( user == nullptr )
{
Log::Error( "User not found! [%S]", m_sessionId.c_str() );
return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::FATAL_ERROR, "", 0 );
}
auto &game_manager = GameSessionManager::Get();
auto result = game_manager.CreatePrivateGameSession( user, m_gameName, 0, 9999 );
auto result = GameSessionManager::Get().CreatePrivateGameSession( user, m_gameName, 0, 9999 );
if( !result )
{
@@ -34,10 +24,7 @@ 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", 3008 );
return std::make_shared< ResultCreatePrivateGame >( this, CREATE_REPLY::SUCCESS, Config::service_ip, Config::discovery_port );
}
ResultCreatePrivateGame::ResultCreatePrivateGame( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )

6
Lobby Server/Event/RequestCreatePrivateGame.h
View File

@@ -10,6 +10,8 @@ private:
SUCCESS = 0,
FATAL_ERROR,
GENERAL_ERROR,
GAME_NAME_IN_USE = 38,
GAME_PENDING = 40,
};
public:
@@ -18,8 +20,8 @@ public:
return std::make_unique< RequestCreatePrivateGame >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultCreatePrivateGame : public GenericResponse {

27
Lobby Server/Event/RequestCreatePublicGame.cpp
View File

@@ -1,8 +1,11 @@
#include "../../global_define.h"
#include "RequestCreatePublicGame.h"
#include "NotifyGameDiscovered.h"
#include "NotifyClientDiscovered.h"
void RequestCreatePublicGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
// Request
void RequestCreatePublicGame::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
@@ -17,21 +20,11 @@ void RequestCreatePublicGame::Deserialize( sptr_tcp_socket socket, sptr_byte_str
m_gameName = stream->read_utf16();
}
sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
auto user = RealmUserManager::Get().GetUser( socket );
if( user == nullptr )
{
Log::Error( "User not found! [%S]", m_sessionId.c_str() );
return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::FATAL_ERROR, "", 0 );
}
auto &game_manager = GameSessionManager::Get();
auto result = game_manager.CreatePublicGameSession( user, m_gameName, 0, 9999 );
auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameName, 0, 9999 );
if( !result )
{
@@ -41,12 +34,12 @@ 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;
user->player_level = 999;
// Send the discovery server information to the client
return std::make_shared< ResultCreatePublicGame >( this, CREATE_REPLY::SUCCESS, "192.168.1.248", 3008 );
return std::make_shared< ResultCreatePublicGame >(this, CREATE_REPLY::SUCCESS, Config::service_ip, Config::discovery_port);
}
// Result
ResultCreatePublicGame::ResultCreatePublicGame( GenericRequest *request, int32_t reply, std::string discoveryIp, int32_t discoveryPort ) : GenericResponse( *request )
{
m_reply = reply;

6
Lobby Server/Event/RequestCreatePublicGame.h
View File

@@ -13,14 +13,16 @@ private:
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_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultCreatePublicGame : public GenericResponse {

46
Lobby Server/Event/RequestDoClientDiscovery.cpp
View File

@@ -2,8 +2,9 @@
#include "RequestDoClientDiscovery.h"
#include "NotifyClientDiscovered.h"
#include "NotifyGameDiscovered.h"
#include "NotifyClientReqConnect.h"
void RequestDoClientDiscovery::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestDoClientDiscovery::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
@@ -11,40 +12,39 @@ void RequestDoClientDiscovery::Deserialize( sptr_tcp_socket socket, sptr_byte_st
m_gameId = stream->read_u32();
}
sptr_generic_response RequestDoClientDiscovery::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestDoClientDiscovery::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
auto user = RealmUserManager::Get().GetUser( socket );
if( user == nullptr )
auto session = GameSessionManager::Get().FindGame( m_gameId );
if( session == nullptr )
{
Log::Error( "User not found! [%s]", m_sessionId.c_str() );
Log::Error( "Game session not found! [%d]", m_gameId );
return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
}
if( user->m_sessionId != m_sessionId )
// TODO: Get max size from game data blob
if( session->m_userList.size() >= 4 )
{
Log::Error( "Session ID mismatch! [%s]", m_sessionId.c_str() );
Log::Error( "Game session is full! [%d]", m_gameId );
return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::GAME_FULL, "", 0 );
}
auto host = session->GetHost();
if( host == nullptr )
{
Log::Error( "Game session owner not found! [%d]", m_gameId );
return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
}
auto result = GameSessionManager::Get().CreatePublicGameSession( user, L"test", 0, 9999 );
Log::Debug( "[%s] DoClientDiscovery : %d", m_sessionId.c_str(), m_gameId );
//auto result = GameSessionManager::Get().UserJoinGame( m_gameId, user );
user->game_id = m_gameId;
user->discovery_state = DiscoveryState::Initial_Connect;
//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 );
// Send the discovery server information to the client
return std::make_shared< ResultDoClientDiscovery >(this, DISCOVERY_REPLY::SUCCESS, Config::service_ip, Config::discovery_port );
}
ResultDoClientDiscovery::ResultDoClientDiscovery( GenericRequest *request, int32_t reply, std::string ip, int32_t port ) : GenericResponse( *request )

4
Lobby Server/Event/RequestDoClientDiscovery.h
View File

@@ -18,8 +18,8 @@ public:
return std::make_unique< RequestDoClientDiscovery >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultDoClientDiscovery : public GenericResponse {

6
Lobby Server/Event/RequestGetEncryptionKey.cpp
View File

@@ -1,14 +1,14 @@
#include "../../global_define.h"
#include "RequestGetEncryptionKey.h"
void RequestGetEncryptionKey::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestGetEncryptionKey::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
}
sptr_generic_response RequestGetEncryptionKey::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestGetEncryptionKey::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
auto publicKey = stream->read_utf8();
auto unknown = stream->read_u32();

4
Lobby Server/Event/RequestGetEncryptionKey.h
View File

@@ -8,8 +8,8 @@ public:
return std::make_unique< RequestGetEncryptionKey >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultGetEncryptionKey : public GenericResponse {

48
Lobby Server/Event/RequestGetGame.cpp Normal file
View File

@@ -0,0 +1,48 @@
#include "../../global_define.h"
#include "RequestGetGame.h"
void RequestGetGame::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
m_sessionId = stream->read_encrypted_utf16();
m_gameName = stream->read_utf16();
}
sptr_generic_response RequestGetGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( stream );
Log::Debug( "RequestGetGame : %S", m_sessionId.c_str() );
Log::Debug( "RequestGetGame : %S", m_gameName.c_str() );
if( user == nullptr )
{
Log::Error( "User not found! [%S]", m_sessionId.c_str() );
return std::make_shared< ResultGetGame >( this );
}
user->is_host = false;
user->is_ready = false;
user->game_id = -1;
return std::make_shared< ResultGetGame >( this );
}
ResultGetGame::ResultGetGame( GenericRequest *request ) : GenericResponse( *request )
{
}
ByteStream & ResultGetGame::Serialize()
{
m_stream.write_u16( m_packetId );
m_stream.write_u32( m_requestId );
m_stream.write_u32( 0 );
m_stream.write_utf16( L"Kelethin" );
m_stream.write_utf16(L"OwnerName");
m_stream.write_u32(0);
return m_stream;
}

22
Lobby Server/Event/RequestGetGame.h Normal file
View File

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

22
Lobby Server/Event/RequestGetRealmStats.cpp
View File

@@ -1,14 +1,14 @@
#include "../../global_define.h"
#include "RequestGetRealmStats.h"
void RequestGetRealmStats::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestGetRealmStats::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
}
sptr_generic_response RequestGetRealmStats::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestGetRealmStats::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
return std::make_shared< ResultGetRealmStats >( this );
}
@@ -24,13 +24,13 @@ ByteStream &ResultGetRealmStats::Serialize()
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 );
m_stream.write_u32( 1 ); // Users Logged In Game
m_stream.write_u32( 2 ); // Users Logged In Realm
m_stream.write_u32( 3 ); // Users Running Game
m_stream.write_u32( 4 ); // Users Running Realm
m_stream.write_u32( 5 ); // Users Playing Game
m_stream.write_u32( 6 ); // Users Playing Realm
m_stream.write_u32( 7 ); // unmatchedGamesGame
m_stream.write_u32( 8 ); // unmatchedGamesRealm
return m_stream;
}

4
Lobby Server/Event/RequestGetRealmStats.h
View File

@@ -9,8 +9,8 @@ public:
{
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;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultGetRealmStats : public GenericResponse {

6
Lobby Server/Event/RequestGetRules.cpp
View File

@@ -1,16 +1,16 @@
#include "../../global_define.h"
#include "RequestGetRules.h"
void RequestGetRules::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestGetRules::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
m_language = stream->read_sz_utf8();
}
sptr_generic_response RequestGetRules::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestGetRules::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
// TODO: Get rules/eula based on language
std::wstring rules = L"Welcome to the Norrath Emulated Server!\n\n";

4
Lobby Server/Event/RequestGetRules.h
View File

@@ -11,8 +11,8 @@ public:
return std::make_unique< RequestGetRules >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultGetRules : public GenericResponse {

12
Lobby Server/Event/RequestLogin.cpp
View File

@@ -2,7 +2,7 @@
#include "RequestLogin.h"
void RequestLogin::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestLogin::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
@@ -10,9 +10,9 @@ void RequestLogin::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream
m_password = stream->read_encrypted_utf16();
}
sptr_generic_response RequestLogin::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestLogin::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
if( m_username.empty() || m_password.empty() )
{
@@ -31,11 +31,7 @@ sptr_generic_response RequestLogin::ProcessRequest( sptr_tcp_socket socket, sptr
Log::Debug( "RequestLogin : Champions of Norrath v1.0" );
}
auto &userMng = RealmUserManager::Get();
auto user = userMng.CreateUser( socket, m_username, m_password );
return std::make_shared< ResultLogin >( this, LOGIN_REPLY::SUCCESS, user->m_sessionId );
return std::make_shared< ResultLogin >( this, LOGIN_REPLY::SUCCESS, user->session_id );
}
ResultLogin::ResultLogin( GenericRequest *request, int32_t reply, std::wstring sessionId ) : GenericResponse( *request )

4
Lobby Server/Event/RequestLogin.h
View File

@@ -25,8 +25,8 @@ public:
return std::make_unique< RequestLogin >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultLogin : public GenericResponse {

18
Lobby Server/Event/RequestLogout.cpp
View File

@@ -1,31 +1,19 @@
#include "../../global_define.h"
#include "RequestLogout.h"
void RequestLogout::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestLogout::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
m_sessionId = stream->read_encrypted_utf16();
}
sptr_generic_response RequestLogout::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestLogout::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
auto &userMng = RealmUserManager::Get();
auto user = userMng.GetUser( m_sessionId );
if( nullptr == user )
{
Log::Error( "RequestLogout::ProcessRequest() - User not found!" );
return std::make_shared< ResultLogout >( this, 1 );
}
Deserialize( stream );
// TODO: Any other cleanup here?
Log::Debug( "[%S] Logout", m_sessionId.c_str() );
userMng.RemoveUser( m_sessionId );
return std::make_shared< ResultLogout >( this, 0 );
}

4
Lobby Server/Event/RequestLogout.h
View File

@@ -10,8 +10,8 @@ public:
{
return std::make_unique< RequestLogout >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultLogout : public GenericResponse {

42
Lobby Server/Event/RequestMatchGame.cpp
View File

@@ -1,7 +1,7 @@
#include "../../global_define.h"
#include "RequestMatchGame.h"
void RequestMatchGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestMatchGame::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
@@ -35,9 +35,9 @@ void RequestMatchGame::Deserialize( sptr_tcp_socket socket, sptr_byte_stream str
int dbg = 0;
}
sptr_generic_response RequestMatchGame::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestMatchGame::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
Log::Debug( "RequestMatchGame : %S", m_sessionId.c_str() );
@@ -55,40 +55,36 @@ ByteStream &ResultMatchGame::Serialize()
m_stream.write_u32( m_requestId );
m_stream.write_u32( 0 );
m_stream.write_u32( 2 );
auto publicGameList = GameSessionManager::Get().GetAvailableGameSessionList();
for( int i = 0; i < 2; i++ )
m_stream.write_u32(publicGameList.size());
{
m_stream.write_utf16( L"Unknown_A " + std::to_wstring( i ) );
for (auto& game : publicGameList)
m_stream.write_utf16(game->m_gameLocation);
}
m_stream.write_u32( 2 );
for( int i = 0; i < 2; i++ )
m_stream.write_u32(publicGameList.size());
{
m_stream.write_utf16( L"Game Name " + std::to_wstring( i ) );
for (auto& game : publicGameList)
m_stream.write_utf16(game->m_gameName);
}
m_stream.write_u32( 2 );
for( int i = 0; i < 2; i++ )
m_stream.write_u32(publicGameList.size());
{
m_stream.write_utf16( L"Unknown_B " + std::to_wstring( i ) );
for (auto& game : publicGameList)
m_stream.write_utf16(game->m_ownerName);
}
// Room Unique ID (Used when selecting)
m_stream.write_u32( 2 );
for( int i = 0; i < 2; i++ )
m_stream.write_u32(publicGameList.size());
{
m_stream.write_u32( i );
for (auto& game : publicGameList)
m_stream.write_u32(game->m_gameIndex);
}
// "GameBlob"
m_stream.write_u32( 1 );
for( int i = 0; i < 1; i++ )
m_stream.write_u32(publicGameList.size());
{
std::vector< uint8_t > bytes( 256, 0 );
m_stream.write_bytes( bytes );
for (auto& game : publicGameList)
m_stream.write_utf8(game->m_gameData);
}
return m_stream;

4
Lobby Server/Event/RequestMatchGame.h
View File

@@ -10,8 +10,8 @@ public:
{
return std::make_unique< RequestMatchGame >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultMatchGame : public GenericResponse {

6
Lobby Server/Event/RequestTouchSession.cpp
View File

@@ -1,16 +1,16 @@
#include "../../global_define.h"
#include "RequestTouchSession.h"
void RequestTouchSession::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestTouchSession::Deserialize( sptr_byte_stream stream )
{
DeserializeHeader( stream );
m_sessionId = stream->read_encrypted_utf16();
}
sptr_generic_response RequestTouchSession::ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
sptr_generic_response RequestTouchSession::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Deserialize( stream );
Log::Debug( "RequestTouchSession : %S", m_sessionId.c_str() );

4
Lobby Server/Event/RequestTouchSession.h
View File

@@ -10,8 +10,8 @@ public:
{
return std::make_unique< RequestTouchSession >();
}
sptr_generic_response ProcessRequest( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
void Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream ) override;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultTouchSession : public GenericResponse {

19
Lobby Server/Event/RequestUpdateGameData.cpp
View File

@@ -1,23 +1,30 @@
#include "../../global_define.h"
#include "RequestUpdateGameData.h"
void RequestUpdateGameData::Deserialize( sptr_tcp_socket socket, sptr_byte_stream stream )
void RequestUpdateGameData::Deserialize( 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 )
sptr_generic_response RequestUpdateGameData::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( socket, stream );
Log::Debug( "RequestUpdateGameData : %S", m_sessionId.c_str() );
Deserialize( stream);
Log::Packet( stream->data, stream->data.size(), false );
auto gameSession = GameSessionManager::Get().FindGame( user->game_id );
if( gameSession == nullptr )
{
Log::Error( "Game not found! [%S]", m_sessionId.c_str() );
return std::make_shared< ResultUpdateGameData >( this );
}
gameSession->m_gameData = m_gameData;
return std::make_shared< ResultUpdateGameData >( this );
}

4
Lobby Server/Event/RequestUpdateGameData.h
View File

@@ -12,8 +12,8 @@ public:
{
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;
sptr_generic_response ProcessRequest( sptr_user user, sptr_byte_stream stream ) override;
void Deserialize( sptr_byte_stream stream ) override;
};
class ResultUpdateGameData : public GenericResponse {