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

Lobby Server and all of its events

Browse Source
This commit is contained in:
HikikoMarmy
2025-04-14 03:54:56 +01:00
parent 2525d7be5a
commit afc48ae9ff
19 changed files with 287 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Lobby Server/Event/RequestCancelGame.cpp
View File

@@ -18,10 +18,7 @@ sptr_generic_response RequestCancelGame::ProcessRequest( sptr_user user, sptr_by
return std::make_shared< ResultCancelGame >( this );
}
GameSessionManager::Get().CancelGameSession( user );
// TODO:
// Notify the players via the Discovery Server
GameSessionManager::Get().RequestCancel( user );
return std::make_shared< ResultCancelGame >( this );
}

2
Lobby Server/Event/RequestCreateAccount.cpp
View File

@@ -23,7 +23,7 @@ sptr_generic_response RequestCreateAccount::ProcessRequest( sptr_user user, sptr
return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::ERROR_FATAL, L"" );
}
return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::SUCCESS, user->session_id );
return std::make_shared< ResultCreateAccount >( this, CREATE_ACCOUNT_REPLY::SUCCESS, user->m_sessionId );
}
ResultCreateAccount::ResultCreateAccount( GenericRequest *request, int32_t reply, std::wstring sessionId ) : GenericResponse( *request )

2
Lobby Server/Event/RequestCreatePrivateGame.cpp
View File

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

4
Lobby Server/Event/RequestCreatePublicGame.cpp
View File

@@ -24,7 +24,7 @@ sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_user user, s
{
Deserialize( stream );
auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameName, 0, 9999 );
auto result = GameSessionManager::Get().CreatePublicGameSession( user, m_gameName );
if( !result )
{
@@ -34,8 +34,6 @@ sptr_generic_response RequestCreatePublicGame::ProcessRequest( sptr_user user, s
Log::Info( "[%S] Create Public Game: %S", m_sessionId.c_str(), m_gameName.c_str() );
user->player_level = 999;
return std::make_shared< ResultCreatePublicGame >(this, CREATE_REPLY::SUCCESS, Config::service_ip, Config::discovery_port);
}

25
Lobby Server/Event/RequestDoClientDiscovery.cpp
View File

@@ -1,8 +1,5 @@
#include "../../global_define.h"
#include "RequestDoClientDiscovery.h"
#include "NotifyClientDiscovered.h"
#include "NotifyGameDiscovered.h"
#include "NotifyClientReqConnect.h"
void RequestDoClientDiscovery::Deserialize( sptr_byte_stream stream )
{
@@ -19,32 +16,18 @@ sptr_generic_response RequestDoClientDiscovery::ProcessRequest( sptr_user user,
auto session = GameSessionManager::Get().FindGame( m_gameId );
if( session == nullptr )
{
Log::Error( "Game session not found! [%d]", m_gameId );
return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
}
// TODO: Get max size from game data blob
if( session->m_userList.size() >= 4 )
if( session->m_currentPlayers >= session->m_maximumPlayers )
{
Log::Error( "Game session is full! [%d]", m_gameId );
return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::GAME_FULL, "", 0 );
}
auto host = session->GetHost();
user->m_gameId = m_gameId;
user->m_isHost = false;
if( host == nullptr )
{
Log::Error( "Game session owner not found! [%d]", m_gameId );
return std::make_shared< ResultDoClientDiscovery >( this, DISCOVERY_REPLY::FATAL_ERROR, "", 0 );
}
Log::Debug( "[%s] DoClientDiscovery : %d", m_sessionId.c_str(), m_gameId );
user->game_id = m_gameId;
user->discovery_state = DiscoveryState::Initial_Connect;
// Send the discovery server information to the client
return std::make_shared< ResultDoClientDiscovery >(this, DISCOVERY_REPLY::SUCCESS, Config::service_ip, Config::discovery_port );
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 )

38
Lobby Server/Event/RequestGetGame.cpp
View File

@@ -13,36 +13,46 @@ sptr_generic_response RequestGetGame::ProcessRequest( sptr_user user, sptr_byte_
{
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 );
return std::make_shared< ResultGetGame >( this, TIMEOUT );
}
user->is_host = false;
user->is_ready = false;
user->game_id = -1;
auto session = GameSessionManager::Get().FindGame( m_gameName );
return std::make_shared< ResultGetGame >( this );
if( session == nullptr )
{
Log::Error( "Game session not found! [%S]", m_gameName.c_str() );
return std::make_shared< ResultGetGame >( this, NOT_FOUND );
}
if( session->m_currentPlayers >= session->m_maximumPlayers )
{
Log::Error( "Game session is full! [%S]", m_gameName.c_str() );
return std::make_shared< ResultGetGame >( this, TIMEOUT );
}
user->m_isHost = false;
user->m_gameId = session->m_gameIndex;
return std::make_shared< ResultGetGame >( this, SUCCESS );
}
ResultGetGame::ResultGetGame( GenericRequest *request ) : GenericResponse( *request )
ResultGetGame::ResultGetGame( GenericRequest *request, int32_t reply ) : GenericResponse( *request )
{
m_reply = reply;
}
ByteStream & ResultGetGame::Serialize()
ByteStream &ResultGetGame::Serialize()
{
m_stream.write_u16( m_packetId );
m_stream.write_u32( m_requestId );
m_stream.write_u32( 0 );
m_stream.write_u32( m_reply );
m_stream.write_utf16( L"Kelethin" );
m_stream.write_utf16(L"OwnerName");
m_stream.write_u32(0);
m_stream.write_utf16( L"OwnerName" );
m_stream.write_u32( 0 );
return m_stream;
}

11
Lobby Server/Event/RequestGetGame.h
View File

@@ -6,6 +6,12 @@ private:
std::wstring m_sessionId;
std::wstring m_gameName;
enum REPLY {
SUCCESS = 0,
TIMEOUT,
NOT_FOUND
};
public:
static std::unique_ptr< RequestGetGame > Create()
{
@@ -16,7 +22,10 @@ public:
};
class ResultGetGame : public GenericResponse {
private:
int32_t m_reply;
public:
ResultGetGame( GenericRequest *request );
ResultGetGame( GenericRequest *request, int32_t reply );
ByteStream &Serialize();
};

19
Lobby Server/Event/RequestGetRealmStats.cpp
View File

@@ -24,13 +24,16 @@ ByteStream &ResultGetRealmStats::Serialize()
m_stream.write_u32( m_requestId );
m_stream.write_u32( 0 );
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
// Player count on the game page.
m_stream.write_u32( RealmUserManager::Get().GetUserCount() ); // Users Logged In Game
// I'm not sure this appears anywhere in the game.
m_stream.write_u32( 0 ); // Users Logged In Realm
m_stream.write_u32( 0 ); // Users Running Game
m_stream.write_u32( 0 ); // Users Running Realm
m_stream.write_u32( 0 ); // Users Playing Game
m_stream.write_u32( 0 ); // Users Playing Realm
m_stream.write_u32( 0 ); // unmatchedGamesGame
m_stream.write_u32( 0 ); // unmatchedGamesRealm
return m_stream;
}

2
Lobby Server/Event/RequestGetRealmStats.h
View File

@@ -2,8 +2,6 @@
class RequestGetRealmStats : public GenericRequest
{
private:
public:
static std::unique_ptr< RequestGetRealmStats > Create()
{

5
Lobby Server/Event/RequestGetRules.cpp
View File

@@ -13,7 +13,10 @@ sptr_generic_response RequestGetRules::ProcessRequest( sptr_user user, sptr_byte
Deserialize( stream );
// TODO: Get rules/eula based on language
std::wstring rules = L"Welcome to the Norrath Emulated Server!\n\n";
std::wstring rules =
L"Welcome to the Norrath Emulated Server!\n\n"
L"This server is currently in development\n"
L"and may not be fully functional.\n\n";
return std::make_shared< ResultGetRules >( this, rules );
}

3
Lobby Server/Event/RequestLogin.cpp
View File

@@ -1,5 +1,4 @@
#include "../../global_define.h"
#include "RequestLogin.h"
void RequestLogin::Deserialize( sptr_byte_stream stream )
@@ -31,7 +30,7 @@ sptr_generic_response RequestLogin::ProcessRequest( sptr_user user, sptr_byte_st
Log::Debug( "RequestLogin : Champions of Norrath v1.0" );
}
return std::make_shared< ResultLogin >( this, LOGIN_REPLY::SUCCESS, user->session_id );
return std::make_shared< ResultLogin >( this, LOGIN_REPLY::SUCCESS, user->m_sessionId );
}
ResultLogin::ResultLogin( GenericRequest *request, int32_t reply, std::wstring sessionId ) : GenericResponse( *request )

1
Lobby Server/Event/RequestLogout.cpp
View File

@@ -11,7 +11,6 @@ sptr_generic_response RequestLogout::ProcessRequest( sptr_user user, sptr_byte_s
{
Deserialize( stream );
// TODO: Any other cleanup here?
Log::Debug( "[%S] Logout", m_sessionId.c_str() );
return std::make_shared< ResultLogout >( this, 0 );

36
Lobby Server/Event/RequestMatchGame.cpp
View File

@@ -15,7 +15,7 @@ void RequestMatchGame::Deserialize( sptr_byte_stream stream )
auto unknown_e = stream->read_u32();
// Match Game Node Count
for( int i = 0; i < unknown_e; i++ )
for( uint32_t i = 0; i < unknown_e; i++ )
{
auto node_a = stream->read_u16();
auto node_b = stream->read_u32();
@@ -40,13 +40,14 @@ sptr_generic_response RequestMatchGame::ProcessRequest( sptr_user user, sptr_byt
Deserialize( stream );
Log::Debug( "RequestMatchGame : %S", m_sessionId.c_str() );
Log::Packet( stream->data, stream->data.size(), false );
return std::make_shared< ResultMatchGame >( this );
}
ResultMatchGame::ResultMatchGame( GenericRequest *request ) : GenericResponse( *request )
{
}
ByteStream &ResultMatchGame::Serialize()
@@ -56,35 +57,36 @@ ByteStream &ResultMatchGame::Serialize()
m_stream.write_u32( 0 );
auto publicGameList = GameSessionManager::Get().GetAvailableGameSessionList();
auto publicGameCount = static_cast< uint32_t >( publicGameList.size() );
m_stream.write_u32(publicGameList.size());
m_stream.write_u32( publicGameCount );
{
for (auto& game : publicGameList)
m_stream.write_utf16(game->m_gameLocation);
for( auto &game : publicGameList )
m_stream.write_utf16( game->m_gameLocation );
}
m_stream.write_u32(publicGameList.size());
m_stream.write_u32( publicGameCount );
{
for (auto& game : publicGameList)
m_stream.write_utf16(game->m_gameName);
for( auto &game : publicGameList )
m_stream.write_utf16( game->m_gameName );
}
m_stream.write_u32(publicGameList.size());
m_stream.write_u32( publicGameCount );
{
for (auto& game : publicGameList)
m_stream.write_utf16(game->m_ownerName);
for( auto &game : publicGameList )
m_stream.write_utf16( game->m_ownerName );
}
m_stream.write_u32(publicGameList.size());
m_stream.write_u32( publicGameCount );
{
for (auto& game : publicGameList)
m_stream.write_u32(game->m_gameIndex);
for( auto &game : publicGameList )
m_stream.write_u32( game->m_gameIndex );
}
m_stream.write_u32(publicGameList.size());
m_stream.write_u32( publicGameCount );
{
for (auto& game : publicGameList)
m_stream.write_utf8(game->m_gameData);
for( auto &game : publicGameList )
m_stream.write_utf8( game->m_gameData );
}
return m_stream;

2
Lobby Server/Event/RequestTouchSession.cpp
View File

@@ -12,8 +12,6 @@ sptr_generic_response RequestTouchSession::ProcessRequest( sptr_user user, sptr_
{
Deserialize( stream );
Log::Debug( "RequestTouchSession : %S", m_sessionId.c_str() );
return std::make_shared< ResultTouchSession >( this );
}

35
Lobby Server/Event/RequestUpdateGameData.cpp
View File

@@ -11,11 +11,9 @@ void RequestUpdateGameData::Deserialize( sptr_byte_stream stream )
sptr_generic_response RequestUpdateGameData::ProcessRequest( sptr_user user, sptr_byte_stream stream )
{
Deserialize( stream);
Deserialize( stream );
Log::Packet( stream->data, stream->data.size(), false );
auto gameSession = GameSessionManager::Get().FindGame( user->game_id );
auto gameSession = GameSessionManager::Get().FindGame( user->m_gameId );
if( gameSession == nullptr )
{
@@ -23,14 +21,41 @@ sptr_generic_response RequestUpdateGameData::ProcessRequest( sptr_user user, spt
return std::make_shared< ResultUpdateGameData >( this );
}
if( m_gameData.size() != 256 )
{
Log::Error( "Game data size is not 256 bytes! [%S]", m_sessionId.c_str() );
return std::make_shared< ResultUpdateGameData >( this );
}
gameSession->m_gameData = m_gameData;
// Parse Game Data. Not the most ideal way to do this, but it works.
char currentPlayers = 0;
char maxPlayers = 0;
char description[ 200 ] = { 0 };
int result = sscanf( m_gameData.c_str(), " %hhd / %hhd :%199[^\r\n]", &currentPlayers, &maxPlayers, description );
if( result >= 2 )
{
gameSession->m_currentPlayers = currentPlayers;
gameSession->m_maximumPlayers = maxPlayers;
gameSession->m_description = ( result == 3 ) ? description : ""; // Empty if not parsed
}
else
{
Log::Debug( "Failed to parse game info from: %s", m_gameData.c_str() );
}
std::string ip = std::string( m_gameData.c_str() + 220, 24 );
user->m_localAddr = ip;
return std::make_shared< ResultUpdateGameData >( this );
}
ResultUpdateGameData::ResultUpdateGameData( GenericRequest *request ) : GenericResponse( *request )
{
}
ByteStream &ResultUpdateGameData::Serialize()

1
Lobby Server/Event/RequestUpdateGameData.h
View File

@@ -5,7 +5,6 @@ class RequestUpdateGameData : public GenericRequest
private:
std::wstring m_sessionId;
std::string m_gameData;
std::string m_hardwareIp;
public:
static std::unique_ptr< RequestUpdateGameData > Create()

95
Lobby Server/LobbyEvents.h Normal file
View File

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

139
Lobby Server/LobbyServer.cpp
View File

@@ -7,7 +7,7 @@
#include "../global_define.h"
#include "EventLookup.h"
#include "LobbyEvents.h"
#include "LobbyServer.h"
LobbyServer::LobbyServer()
@@ -37,13 +37,13 @@ void LobbyServer::Start( std::string ip, int32_t port )
service.sin_family = AF_INET;
service.sin_port = htons( port );
if (ip == "0.0.0.0")
if( ip == "0.0.0.0" )
{
service.sin_addr.s_addr = ADDR_ANY;
}
else
{
service.sin_addr.s_addr = inet_addr(ip.c_str());
service.sin_addr.s_addr = inet_addr( ip.c_str() );
}
if( bind( m_listenSocket, ( SOCKADDR * )&service, sizeof( service ) ) == SOCKET_ERROR )
@@ -89,6 +89,8 @@ void LobbyServer::Run()
FD_SET( m_listenSocket, &readSet );
CheckSocketProblem();
// Process clients
for( auto &client : m_clientSockets )
{
@@ -126,12 +128,21 @@ void LobbyServer::Run()
void LobbyServer::CheckSocketProblem()
{
auto now = std::chrono::steady_clock::now();
for( auto it = m_clientSockets.begin(); it != m_clientSockets.end(); )
{
auto duration = std::chrono::duration_cast< std::chrono::seconds >( now - ( *it )->last_recv_time );
if( duration.count() > 30 )
{
( *it )->flag.disconnected = true;
Log::Info( "[LOBBY] Client Timeout : (%s)", ( *it )->remote_ip.c_str() );
}
if( ( *it )->flag.disconnected )
{
RealmUserManager::Get().RemoveUser( ( *it ) );
Log::Info( "[LOBBY] Client disconnected : (%s)", ( *it )->remote_ip.c_str() );
Log::Info( "[LOBBY] Client Disconnected : (%s)", ( *it )->remote_ip.c_str() );
it = m_clientSockets.erase( it );
}
else
@@ -153,7 +164,7 @@ void LobbyServer::AcceptNewClient()
return;
}
auto new_socket = std::make_shared< RealmTCPSocket >();
auto new_socket = std::make_shared< RealmSocket >();
new_socket->fd = clientSocket;
new_socket->remote_addr = clientInfo;
new_socket->remote_ip = inet_ntoa( clientInfo.sin_addr );
@@ -163,82 +174,106 @@ void LobbyServer::AcceptNewClient()
RealmUserManager::Get().CreateUser( new_socket );
Log::Info( "[LOBBY] New client connected : (%s)", new_socket->remote_ip.c_str() );
Log::Info( "[LOBBY] New Client Connected : (%s)", new_socket->remote_ip.c_str() );
}
void LobbyServer::ReadSocket( sptr_tcp_socket socket )
void LobbyServer::ReadSocket( sptr_socket socket )
{
if( socket->flag.disconnected )
{
return;
}
auto bytesReceived = recv( socket->fd, ( char * )m_recvBuffer.data(), m_recvBuffer.size(), 0 );
const auto bytesReceived = recv( socket->fd, reinterpret_cast< char * >( m_recvBuffer.data() ), static_cast< int >( m_recvBuffer.size() ), 0 );
if( bytesReceived == SOCKET_ERROR )
{
auto error = WSAGetLastError();
Log::Info( "Socket Error [%d].", error );
Log::Info( "Socket Error [%d].", WSAGetLastError() );
socket->flag.disconnected = true;
return;
}
if( bytesReceived == 0 )
{
Log::Info( "Socket Disconnected." );
socket->flag.disconnected = true;
return;
}
// Append the received data to the sockets processing buffer.
// There's definitely a more elegant way of handling data here,
// but this is just easier for now.
socket->m_pendingReadBuffer.insert( socket->m_pendingReadBuffer.end(), m_recvBuffer.begin(), m_recvBuffer.begin() + bytesReceived );
socket->last_recv_time = std::chrono::steady_clock::now();
// Handle valid packets in the buffer.
while( socket->m_pendingReadBuffer.size() > 0 )
// Append received data to socket's pending buffer
socket->m_pendingReadBuffer.insert(
socket->m_pendingReadBuffer.end(),
m_recvBuffer.begin(),
m_recvBuffer.begin() + bytesReceived
);
// Process packets in the buffer
while( socket->m_pendingReadBuffer.size() >= 4 )
{
auto packetSize = htonl( *( int32_t * )&socket->m_pendingReadBuffer[ 0 ] );
int32_t packetSize = ntohl( *reinterpret_cast< const int32_t * >( &socket->m_pendingReadBuffer[ 0 ] ) );
if( packetSize > socket->m_pendingReadBuffer.size() )
if( packetSize <= 0 || packetSize > 1024 )
{
Log::Error( "Invalid packet size: %d. Disconnecting client.", packetSize );
socket->flag.disconnected = true;
break;
}
if( socket->m_pendingReadBuffer.size() < static_cast< size_t >( packetSize ) )
{
break;
}
//Log::Packet( socket->m_pendingReadBuffer, packetSize, false );
auto stream = std::make_shared< ByteStream >( socket->m_pendingReadBuffer.data() + 4, packetSize - 4 );
// Erase the packet from the buffer
socket->m_pendingReadBuffer.erase( socket->m_pendingReadBuffer.begin(), socket->m_pendingReadBuffer.begin() + packetSize );
socket->m_pendingReadBuffer.erase(
socket->m_pendingReadBuffer.begin(),
socket->m_pendingReadBuffer.begin() + packetSize
);
if (stream->data.size() == 0) break;
// Process the packet
HandleRequest( socket, stream );
}
}
void LobbyServer::WriteSocket( sptr_tcp_socket socket )
void LobbyServer::WriteSocket( sptr_socket socket )
{
if( socket->flag.disconnected )
{
if( socket->flag.disconnected || socket->m_pendingWriteBuffer.empty() )
return;
}
if( socket->m_pendingWriteBuffer.empty() )
{
return;
}
socket->last_send_time = std::chrono::steady_clock::now();
size_t totalBytesSent = 0;
const size_t bufferSize = socket->m_pendingWriteBuffer.size();
//Log::Packet( socket->m_pendingWriteBuffer, socket->m_pendingWriteBuffer.size(), false );
while( true )
while( totalBytesSent < bufferSize )
{
auto chunkSize = std::min< int >( socket->m_pendingWriteBuffer.size(), 1024 );
auto bytesSent = send( socket->fd, ( char * )socket->m_pendingWriteBuffer.data(), chunkSize, 0 );
const size_t remaining = bufferSize - totalBytesSent;
const int chunkSize = static_cast< int >( std::min<size_t>( remaining, 1024 ) );
int bytesSent = send(
socket->fd,
reinterpret_cast< const char * >( socket->m_pendingWriteBuffer.data() + totalBytesSent ),
chunkSize,
0
);
if( bytesSent == SOCKET_ERROR )
{
const int err = WSAGetLastError();
if( err == WSAEWOULDBLOCK )
break;
Log::Error( "Send failed: %d", err );
socket->flag.disconnected = true;
return;
}
if( bytesSent == 0 )
{
socket->flag.disconnected = true;
return;
@@ -250,23 +285,21 @@ void LobbyServer::WriteSocket( sptr_tcp_socket socket )
{
break;
}
if( totalBytesSent == socket->m_pendingWriteBuffer.size() )
{
break;
}
}
socket->m_pendingWriteBuffer.erase( socket->m_pendingWriteBuffer.begin(), socket->m_pendingWriteBuffer.begin() + totalBytesSent );
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 )
void LobbyServer::HandleRequest( sptr_socket socket, sptr_byte_stream stream )
{
//Log::Packet( stream->data, stream->data.size(), false );
auto packetId = stream->read< uint16_t >();
stream->set_position( 0 );
auto it = LOBBY_REQUEST_EVENT.find( packetId );
if( it == LOBBY_REQUEST_EVENT.end() )
{
@@ -274,9 +307,7 @@ void LobbyServer::HandleRequest( sptr_tcp_socket socket, sptr_byte_stream stream
Log::Packet( stream->data, stream->data.size(), false );
return;
}
Log::Debug( "[LOBBY] Request processed : 0x%04X", packetId );
auto request = it->second();
auto user = RealmUserManager::Get().GetUser( socket );
@@ -286,17 +317,9 @@ void LobbyServer::HandleRequest( sptr_tcp_socket socket, sptr_byte_stream stream
socket->flag.disconnected = true;
return;
}
if( auto res = request->ProcessRequest( user, 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);
}
}
}

9
Lobby Server/LobbyServer.h
View File

@@ -40,7 +40,6 @@ private:
static inline std::unique_ptr< LobbyServer > m_instance;
static inline std::mutex m_mutex;
Timer m_timer;
std::atomic< bool > m_running;
std::thread m_thread;
@@ -70,13 +69,13 @@ public:
private:
SOCKET m_listenSocket;
std::vector< sptr_tcp_socket > m_clientSockets;
std::vector< sptr_socket > m_clientSockets;
std::vector< uint8_t > m_recvBuffer;
void Run();
void CheckSocketProblem();
void AcceptNewClient();
void ReadSocket( sptr_tcp_socket socket );
void WriteSocket( sptr_tcp_socket socket );
void HandleRequest( sptr_tcp_socket socket, sptr_byte_stream stream );
void ReadSocket( sptr_socket socket );
void WriteSocket( sptr_socket socket );
void HandleRequest( sptr_socket socket, sptr_byte_stream stream );
};