1
0
mirror of https://github.com/vcmi/vcmi.git synced 2024-12-22 22:13:35 +02:00
vcmi/server/GlobalLobbyProcessor.cpp
2024-05-16 08:03:06 +00:00

213 lines
5.9 KiB
C++

/*
* GlobalLobbyProcessor.cpp, part of VCMI engine
*
* Authors: listed in file AUTHORS in main folder
*
* License: GNU General Public License v2.0 or later
* Full text of license available in license.txt file, in main folder
*
*/
#include "StdInc.h"
#include "GlobalLobbyProcessor.h"
#include "CVCMIServer.h"
#include "../lib/CConfigHandler.h"
#include "../lib/json/JsonUtils.h"
#include "../lib/VCMI_Lib.h"
#include "../lib/modding/CModHandler.h"
#include "../lib/modding/CModInfo.h"
GlobalLobbyProcessor::GlobalLobbyProcessor(CVCMIServer & owner)
: owner(owner)
{
logGlobal->info("Connecting to lobby server");
establishNewConnection();
}
void GlobalLobbyProcessor::establishNewConnection()
{
std::string hostname = settings["lobby"]["hostname"].String();
uint16_t port = settings["lobby"]["port"].Integer();
owner.getNetworkHandler().connectToRemote(*this, hostname, port);
}
void GlobalLobbyProcessor::onDisconnected(const std::shared_ptr<INetworkConnection> & connection, const std::string & errorMessage)
{
if (connection == controlConnection)
{
owner.setState(EServerState::SHUTDOWN);
return;
}
else
{
for (auto const & proxy : proxyConnections)
{
if (proxy.second != connection)
continue;
if (owner.getState() == EServerState::LOBBY)
{
JsonNode message;
message["type"].String() = "leaveGameRoom";
message["accountID"].String() = proxy.first;
sendMessage(controlConnection, message);
}
proxyConnections.erase(proxy.first);
// player disconnected
owner.onDisconnected(connection, errorMessage);
return;
}
}
}
void GlobalLobbyProcessor::onPacketReceived(const std::shared_ptr<INetworkConnection> & connection, const std::vector<std::byte> & message)
{
if (connection == controlConnection)
{
JsonNode json(message.data(), message.size());
if(json["type"].String() == "operationFailed")
return receiveOperationFailed(json);
if(json["type"].String() == "serverLoginSuccess")
return receiveServerLoginSuccess(json);
if(json["type"].String() == "accountJoinsRoom")
return receiveAccountJoinsRoom(json);
logGlobal->error("Received unexpected message from lobby server of type '%s' ", json["type"].String());
}
else
{
// received game message via proxy connection
owner.onPacketReceived(connection, message);
}
}
void GlobalLobbyProcessor::receiveOperationFailed(const JsonNode & json)
{
logGlobal->info("Lobby: Failed to login into a lobby server!");
owner.setState(EServerState::SHUTDOWN);
}
void GlobalLobbyProcessor::receiveServerLoginSuccess(const JsonNode & json)
{
// no-op, wait just for any new commands from lobby
logGlobal->info("Lobby: Succesfully connected to lobby server");
owner.startAcceptingIncomingConnections();
}
void GlobalLobbyProcessor::receiveAccountJoinsRoom(const JsonNode & json)
{
std::string accountID = json["accountID"].String();
logGlobal->info("Lobby: Account %s will join our room!", accountID);
assert(proxyConnections.count(accountID) == 0);
proxyConnections[accountID] = nullptr;
establishNewConnection();
}
void GlobalLobbyProcessor::onConnectionFailed(const std::string & errorMessage)
{
owner.setState(EServerState::SHUTDOWN);
}
void GlobalLobbyProcessor::onConnectionEstablished(const std::shared_ptr<INetworkConnection> & connection)
{
if (controlConnection == nullptr)
{
controlConnection = connection;
logGlobal->info("Connection to lobby server established");
JsonNode toSend;
toSend["type"].String() = "serverLogin";
toSend["gameRoomID"].String() = owner.uuid;
toSend["accountID"].String() = getHostAccountID();
toSend["accountCookie"].String() = getHostAccountCookie();
toSend["version"].String() = VCMI_VERSION_STRING;
toSend["mods"] = getHostModList();
sendMessage(connection, toSend);
}
else
{
// Proxy connection for a player
std::string guestAccountID;
for (auto const & proxies : proxyConnections)
if (proxies.second == nullptr)
guestAccountID = proxies.first;
JsonNode toSend;
toSend["type"].String() = "serverProxyLogin";
toSend["gameRoomID"].String() = owner.uuid;
toSend["guestAccountID"].String() = guestAccountID;
toSend["accountCookie"].String() = getHostAccountCookie();
sendMessage(connection, toSend);
proxyConnections[guestAccountID] = connection;
owner.onNewConnection(connection);
}
}
JsonNode GlobalLobbyProcessor::getHostModList() const
{
ModCompatibilityInfo info;
for (auto const & modName : VLC->modh->getActiveMods())
{
if(VLC->modh->getModInfo(modName).checkModGameplayAffecting())
info[modName] = VLC->modh->getModInfo(modName).getVerificationInfo();
}
return ModVerificationInfo::jsonSerializeList(info);
}
void GlobalLobbyProcessor::sendGameStarted()
{
JsonNode toSend;
toSend["type"].String() = "gameStarted";
sendMessage(controlConnection, toSend);
}
void GlobalLobbyProcessor::sendChangeRoomDescription(const std::string & description)
{
JsonNode toSend;
toSend["type"].String() = "changeRoomDescription";
toSend["description"].String() = description;
sendMessage(controlConnection, toSend);
}
void GlobalLobbyProcessor::sendMessage(const NetworkConnectionPtr & targetConnection, const JsonNode & toSend)
{
assert(JsonUtils::validate(toSend, "vcmi:lobbyProtocol/" + toSend["type"].String(), toSend["type"].String() + " pack"));
targetConnection->sendPacket(toSend.toBytes());
}
//FIXME: consider whether these methods should be replaced with some other way to define our account ID / account cookie
static const std::string & getServerHost()
{
return settings["lobby"]["hostname"].String();
}
const std::string & GlobalLobbyProcessor::getHostAccountID() const
{
return persistentStorage["lobby"][getServerHost()]["accountID"].String();
}
const std::string & GlobalLobbyProcessor::getHostAccountCookie() const
{
return persistentStorage["lobby"][getServerHost()]["accountCookie"].String();
}
const std::string & GlobalLobbyProcessor::getHostAccountDisplayName() const
{
return persistentStorage["lobby"][getServerHost()]["displayName"].String();
}