mosskoi/Champions-Reborn-Server-Mirror
1
0
Fork 0
mirror of https://github.com/HikikoMarmy/Champions-Reborn-Server.git synced 2026-04-05 08:59:54 -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 {

6
Lobby Server/EventLookup.h
View File

@@ -7,6 +7,7 @@
#include "Event/RequestCreateAccount.h"
#include "Event/RequestCreatePrivateGame.h"
#include "Event/RequestCreatePublicGame.h"
#include "Event/RequestGetGame.h"
#include "Event/RequestGetRealmStats.h"
#include "Event/RequestLogin.h"
#include "Event/RequestLogout.h"
@@ -39,6 +40,11 @@ const std::map< int16_t, std::function< std::unique_ptr< GenericRequest >() > >
return std::make_unique< RequestCreatePublicGame >();
}
},
{ 0x000D, []() -> std::unique_ptr< GenericRequest >
{
return std::make_unique< RequestGetGame >();
}
},
{ 0x000F, []() -> std::unique_ptr< GenericRequest >
{
return std::make_unique< RequestGetRealmStats >();

56
Lobby Server/LobbyServer.cpp
View File

@@ -36,7 +36,15 @@ 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 = ADDR_ANY;
if (ip == "0.0.0.0")
{
service.sin_addr.s_addr = ADDR_ANY;
}
else
{
service.sin_addr.s_addr = inet_addr(ip.c_str());
}
if( bind( m_listenSocket, ( SOCKADDR * )&service, sizeof( service ) ) == SOCKET_ERROR )
{
@@ -116,6 +124,23 @@ void LobbyServer::Run()
}
}
void LobbyServer::CheckSocketProblem()
{
for( auto it = m_clientSockets.begin(); it != m_clientSockets.end(); )
{
if( ( *it )->flag.disconnected )
{
RealmUserManager::Get().RemoveUser( ( *it ) );
Log::Info( "[LOBBY] Client disconnected : (%s)", ( *it )->remote_ip.c_str() );
it = m_clientSockets.erase( it );
}
else
{
++it;
}
}
}
void LobbyServer::AcceptNewClient()
{
sockaddr_in clientInfo{};
@@ -130,12 +155,15 @@ void LobbyServer::AcceptNewClient()
auto new_socket = std::make_shared< RealmTCPSocket >();
new_socket->fd = clientSocket;
new_socket->remote_address = clientInfo;
new_socket->peer_ip_address = inet_ntoa( clientInfo.sin_addr );
new_socket->remote_addr = clientInfo;
new_socket->remote_ip = inet_ntoa( clientInfo.sin_addr );
new_socket->remote_port = ntohs( clientInfo.sin_port );
m_clientSockets.push_back( new_socket );
Log::Info( "[LOBBY] New client connected : (%s)", new_socket->peer_ip_address.c_str() );
RealmUserManager::Get().CreateUser( new_socket );
Log::Info( "[LOBBY] New client connected : (%s)", new_socket->remote_ip.c_str() );
}
void LobbyServer::ReadSocket( sptr_tcp_socket socket )
@@ -232,6 +260,8 @@ void LobbyServer::WriteSocket( sptr_tcp_socket socket )
socket->m_pendingWriteBuffer.erase( socket->m_pendingWriteBuffer.begin(), socket->m_pendingWriteBuffer.begin() + totalBytesSent );
}
#include "Event/NotifyGameDiscovered.h"
#include "Event/NotifyClientDiscovered.h"
void LobbyServer::HandleRequest( sptr_tcp_socket socket, sptr_byte_stream stream )
{
auto packetId = stream->read< uint16_t >();
@@ -248,9 +278,25 @@ void LobbyServer::HandleRequest( sptr_tcp_socket socket, sptr_byte_stream stream
Log::Debug( "[LOBBY] Request processed : 0x%04X", packetId );
auto request = it->second();
auto user = RealmUserManager::Get().GetUser( socket );
if( user == nullptr )
{
Log::Error( "User not found!" );
socket->flag.disconnected = true;
return;
}
if( auto res = request->ProcessRequest( socket, stream ) )
if( auto res = request->ProcessRequest( user, stream) )
{
socket->send( res );
if( user->player_level == 999 )
{
user->player_level = 1;
//NotifyGameDiscovered msg(Config::service_ip, Config::discovery_port);
//socket->send(msg);
}
}
}

1
Lobby Server/LobbyServer.h
View File

@@ -74,6 +74,7 @@ private:
std::vector< uint8_t > m_recvBuffer;
void Run();
void CheckSocketProblem();
void AcceptNewClient();
void ReadSocket( sptr_tcp_socket socket );
void WriteSocket( sptr_tcp_socket socket );