games/vcmi
1
0
Fork 0
mirror of https://github.com/vcmi/vcmi.git synced 2025-11-23 22:37:55 +02:00
Code Issues Releases Activity

Cleanup, remove unnecessary changes

Browse Source
This commit is contained in:
Ivan Savenko
2025-06-29 16:26:23 +03:00
parent 52da332640
commit 3ea2c8bff0
11 changed files with 30 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
client/CServerHandler.cpp
View File

@@ -617,7 +617,7 @@ void CServerHandler::startGameplay(std::shared_ptr<CGameState> gameState)
if(GAME->mainmenu()) if(GAME->mainmenu())
GAME->mainmenu()->disable(); GAME->mainmenu()->disable();
// if (isGuest()) if (isGuest())
antilagServer = std::make_unique<AntilagServer>(getNetworkHandler(), gameState); antilagServer = std::make_unique<AntilagServer>(getNetworkHandler(), gameState);
switch(si->mode) switch(si->mode)

1
client/ClientNetPackVisitors.h
View File

@@ -91,7 +91,6 @@ public:
void visitCatapultAttack(CatapultAttack & pack) override; void visitCatapultAttack(CatapultAttack & pack) override;
void visitEndAction(EndAction & pack) override; void visitEndAction(EndAction & pack) override;
void visitPackageApplied(PackageApplied & pack) override; void visitPackageApplied(PackageApplied & pack) override;
void visitPackageReceived(PackageReceived & pack) override;
void visitSystemMessage(SystemMessage & pack) override; void visitSystemMessage(SystemMessage & pack) override;
void visitPlayerBlocked(PlayerBlocked & pack) override; void visitPlayerBlocked(PlayerBlocked & pack) override;
void visitPlayerStartsTurn(PlayerStartsTurn & pack) override; void visitPlayerStartsTurn(PlayerStartsTurn & pack) override;

5
client/NetPacksClient.cpp
View File

@@ -891,11 +891,6 @@ void ApplyClientNetPackVisitor::visitPackageApplied(PackageApplied & pack)
logNetwork->warn("Surprising server message! PackageApplied for unknown requestID!"); logNetwork->warn("Surprising server message! PackageApplied for unknown requestID!");
} }
void ApplyClientNetPackVisitor::visitPackageReceived(PackageReceived & pack)
{
// No-op for now
}
void ApplyClientNetPackVisitor::visitSystemMessage(SystemMessage & pack) void ApplyClientNetPackVisitor::visitSystemMessage(SystemMessage & pack)
{ {
// usually used to receive error messages from server // usually used to receive error messages from server

2
lib/StartInfo.cpp
View File

@@ -225,7 +225,7 @@ PlayerConnectionID LobbyInfo::clientFirstId(GameConnectionID clientId) const
return pair.first; return pair.first;
} }
return PlayerConnectionID::PLAYER_AI; throw std::runtime_error("LobbyInfo::clientFirstId: invalid GameConnectionID!");
} }
PlayerInfo & LobbyInfo::getPlayerInfo(PlayerColor color) PlayerInfo & LobbyInfo::getPlayerInfo(PlayerColor color)

8
lib/network/NetworkConnection.cpp
View File

@@ -208,15 +208,15 @@ void NetworkConnection::close()
//NOTE: ignoring error code, intended //NOTE: ignoring error code, intended
} }
InternalConnection::InternalConnection(INetworkConnectionListener & listener, NetworkStrand & strand) InternalConnection::InternalConnection(INetworkConnectionListener & listener, NetworkContext & context)
: strand(strand) : context(context)
, listener(listener) , listener(listener)
{ {
} }
void InternalConnection::receivePacket(const std::vector<std::byte> & message) void InternalConnection::receivePacket(const std::vector<std::byte> & message)
{ {
strand.post([self = std::static_pointer_cast<InternalConnection>(shared_from_this()), message](){ boost::asio::post(context, [self = std::static_pointer_cast<InternalConnection>(shared_from_this()), message](){
if (self->connectionActive) if (self->connectionActive)
self->listener.onPacketReceived(self, message); self->listener.onPacketReceived(self, message);
}); });
@@ -224,7 +224,7 @@ void InternalConnection::receivePacket(const std::vector<std::byte> & message)
void InternalConnection::disconnect() void InternalConnection::disconnect()
{ {
strand.post([self = std::static_pointer_cast<InternalConnection>(shared_from_this())](){ boost::asio::post(context, [self = std::static_pointer_cast<InternalConnection>(shared_from_this())](){
self->listener.onDisconnected(self, "Internal connection has been terminated"); self->listener.onDisconnected(self, "Internal connection has been terminated");
self->otherSideWeak.reset(); self->otherSideWeak.reset();
self->connectionActive = false; self->connectionActive = false;

4
lib/network/NetworkConnection.h
View File

@@ -49,11 +49,11 @@ public:
class InternalConnection final : public IInternalConnection, public std::enable_shared_from_this<InternalConnection> class InternalConnection final : public IInternalConnection, public std::enable_shared_from_this<InternalConnection>
{ {
std::weak_ptr<IInternalConnection> otherSideWeak; std::weak_ptr<IInternalConnection> otherSideWeak;
NetworkStrand & strand; NetworkContext & context;
INetworkConnectionListener & listener; INetworkConnectionListener & listener;
bool connectionActive = false; bool connectionActive = false;
public: public:
InternalConnection(INetworkConnectionListener & listener, NetworkStrand & strand); InternalConnection(INetworkConnectionListener & listener, NetworkContext & context);
void receivePacket(const std::vector<std::byte> & message) override; void receivePacket(const std::vector<std::byte> & message) override;
void disconnect() override; void disconnect() override;

1
lib/network/NetworkDefines.h
View File

@@ -20,7 +20,6 @@ using NetworkContext = boost::asio::io_context;
#else #else
using NetworkContext = boost::asio::io_service; using NetworkContext = boost::asio::io_service;
#endif #endif
using NetworkStrand = NetworkContext::strand;
using NetworkSocket = boost::asio::ip::tcp::socket; using NetworkSocket = boost::asio::ip::tcp::socket;
using NetworkAcceptor = boost::asio::ip::tcp::acceptor; using NetworkAcceptor = boost::asio::ip::tcp::acceptor;
using NetworkBuffer = boost::asio::streambuf; using NetworkBuffer = boost::asio::streambuf;

25
lib/network/NetworkHandler.cpp
View File

@@ -21,26 +21,25 @@ std::unique_ptr<INetworkHandler> INetworkHandler::createHandler()
} }
NetworkHandler::NetworkHandler() NetworkHandler::NetworkHandler()
: io(std::make_unique<NetworkContext>()) : context(std::make_unique<NetworkContext>())
, strand(std::make_unique<NetworkStrand>(*io))
{} {}
std::unique_ptr<INetworkServer> NetworkHandler::createServerTCP(INetworkServerListener & listener) std::unique_ptr<INetworkServer> NetworkHandler::createServerTCP(INetworkServerListener & listener)
{ {
return std::make_unique<NetworkServer>(listener, *io, *strand); return std::make_unique<NetworkServer>(listener, *context);
} }
std::shared_ptr<INetworkConnection> NetworkHandler::createAsyncConnection(INetworkConnectionListener & listener) std::shared_ptr<INetworkConnection> NetworkHandler::createAsyncConnection(INetworkConnectionListener & listener)
{ {
auto loopbackConnection = std::make_shared<InternalConnection>(listener, *strand); auto loopbackConnection = std::make_shared<InternalConnection>(listener, *context);
loopbackConnection->connectTo(loopbackConnection); loopbackConnection->connectTo(loopbackConnection);
return loopbackConnection; return loopbackConnection;
} }
void NetworkHandler::connectToRemote(INetworkClientListener & listener, const std::string & host, uint16_t port) void NetworkHandler::connectToRemote(INetworkClientListener & listener, const std::string & host, uint16_t port)
{ {
auto socket = std::make_shared<NetworkSocket>(*io); auto socket = std::make_shared<NetworkSocket>(*context);
auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(*io); auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(*context);
resolver->async_resolve(host, std::to_string(port), resolver->async_resolve(host, std::to_string(port),
[this, &listener, resolver, socket](const boost::system::error_code& error, const boost::asio::ip::tcp::resolver::results_type & endpoints) [this, &listener, resolver, socket](const boost::system::error_code& error, const boost::asio::ip::tcp::resolver::results_type & endpoints)
@@ -58,7 +57,7 @@ void NetworkHandler::connectToRemote(INetworkClientListener & listener, const st
listener.onConnectionFailed(error.message()); listener.onConnectionFailed(error.message());
return; return;
} }
auto connection = std::make_shared<NetworkConnection>(listener, socket, *io); auto connection = std::make_shared<NetworkConnection>(listener, socket, *context);
connection->start(); connection->start();
listener.onConnectionEstablished(connection); listener.onConnectionEstablished(connection);
@@ -68,13 +67,13 @@ void NetworkHandler::connectToRemote(INetworkClientListener & listener, const st
void NetworkHandler::run() void NetworkHandler::run()
{ {
boost::asio::executor_work_guard<decltype(io->get_executor())> work{io->get_executor()}; boost::asio::executor_work_guard<decltype(context->get_executor())> work{context->get_executor()};
io->run(); context->run();
} }
void NetworkHandler::createTimer(INetworkTimerListener & listener, std::chrono::milliseconds duration) void NetworkHandler::createTimer(INetworkTimerListener & listener, std::chrono::milliseconds duration)
{ {
auto timer = std::make_shared<NetworkTimer>(*io, duration); auto timer = std::make_shared<NetworkTimer>(*context, duration);
timer->async_wait([&listener, timer](const boost::system::error_code& error){ timer->async_wait([&listener, timer](const boost::system::error_code& error){
if (!error) if (!error)
listener.onTimer(); listener.onTimer();
@@ -83,18 +82,18 @@ void NetworkHandler::createTimer(INetworkTimerListener & listener, std::chrono::
void NetworkHandler::createInternalConnection(INetworkClientListener & listener, INetworkServer & server) void NetworkHandler::createInternalConnection(INetworkClientListener & listener, INetworkServer & server)
{ {
auto localConnection = std::make_shared<InternalConnection>(listener, *strand); auto localConnection = std::make_shared<InternalConnection>(listener, *context);
server.receiveInternalConnection(localConnection); server.receiveInternalConnection(localConnection);
boost::asio::post(*io, [&listener, localConnection](){ boost::asio::post(*context, [&listener, localConnection](){
listener.onConnectionEstablished(localConnection); listener.onConnectionEstablished(localConnection);
}); });
} }
void NetworkHandler::stop() void NetworkHandler::stop()
{ {
io->stop(); context->stop();
} }
VCMI_LIB_NAMESPACE_END VCMI_LIB_NAMESPACE_END

3
lib/network/NetworkHandler.h
View File

@@ -15,8 +15,7 @@ VCMI_LIB_NAMESPACE_BEGIN
class NetworkHandler final : public INetworkHandler class NetworkHandler final : public INetworkHandler
{ {
std::unique_ptr<NetworkContext> io; std::unique_ptr<NetworkContext> context;
std::unique_ptr<NetworkStrand> strand;
public: public:
NetworkHandler(); NetworkHandler();

13
lib/network/NetworkServer.cpp
View File

@@ -13,22 +13,21 @@
VCMI_LIB_NAMESPACE_BEGIN VCMI_LIB_NAMESPACE_BEGIN
NetworkServer::NetworkServer(INetworkServerListener & listener, NetworkContext & context, NetworkStrand & strand) NetworkServer::NetworkServer(INetworkServerListener & listener, NetworkContext & context)
: io(context) : context(context)
, strand(strand)
, listener(listener) , listener(listener)
{ {
} }
uint16_t NetworkServer::start(uint16_t port) uint16_t NetworkServer::start(uint16_t port)
{ {
acceptor = std::make_shared<NetworkAcceptor>(io, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port)); acceptor = std::make_shared<NetworkAcceptor>(context, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), port));
return startAsyncAccept(); return startAsyncAccept();
} }
uint16_t NetworkServer::startAsyncAccept() uint16_t NetworkServer::startAsyncAccept()
{ {
auto upcomingConnection = std::make_shared<NetworkSocket>(io); auto upcomingConnection = std::make_shared<NetworkSocket>(context);
acceptor->async_accept(*upcomingConnection, [this, upcomingConnection](const auto & ec) { connectionAccepted(upcomingConnection, ec); }); acceptor->async_accept(*upcomingConnection, [this, upcomingConnection](const auto & ec) { connectionAccepted(upcomingConnection, ec); });
return acceptor->local_endpoint().port(); return acceptor->local_endpoint().port();
} }
@@ -41,7 +40,7 @@ void NetworkServer::connectionAccepted(std::shared_ptr<NetworkSocket> upcomingCo
} }
logNetwork->info("We got a new connection! :)"); logNetwork->info("We got a new connection! :)");
auto connection = std::make_shared<NetworkConnection>(*this, upcomingConnection, io); auto connection = std::make_shared<NetworkConnection>(*this, upcomingConnection, context);
connections.insert(connection); connections.insert(connection);
connection->start(); connection->start();
listener.onNewConnection(connection); listener.onNewConnection(connection);
@@ -60,7 +59,7 @@ void NetworkServer::onDisconnected(const std::shared_ptr<INetworkConnection> & c
void NetworkServer::receiveInternalConnection(std::shared_ptr<IInternalConnection> remoteConnection) void NetworkServer::receiveInternalConnection(std::shared_ptr<IInternalConnection> remoteConnection)
{ {
auto localConnection = std::make_shared<InternalConnection>(*this, strand); auto localConnection = std::make_shared<InternalConnection>(*this, context);
connections.insert(localConnection); connections.insert(localConnection);

5
lib/network/NetworkServer.h
View File

@@ -15,8 +15,7 @@ VCMI_LIB_NAMESPACE_BEGIN
class NetworkServer : public INetworkConnectionListener, public INetworkServer class NetworkServer : public INetworkConnectionListener, public INetworkServer
{ {
NetworkContext & io; NetworkContext & context;
NetworkStrand & strand;
std::shared_ptr<NetworkAcceptor> acceptor; std::shared_ptr<NetworkAcceptor> acceptor;
std::set<std::shared_ptr<INetworkConnection>> connections; std::set<std::shared_ptr<INetworkConnection>> connections;
@@ -28,7 +27,7 @@ class NetworkServer : public INetworkConnectionListener, public INetworkServer
void onDisconnected(const std::shared_ptr<INetworkConnection> & connection, const std::string & errorMessage) override; void onDisconnected(const std::shared_ptr<INetworkConnection> & connection, const std::string & errorMessage) override;
void onPacketReceived(const std::shared_ptr<INetworkConnection> & connection, const std::vector<std::byte> & message) override; void onPacketReceived(const std::shared_ptr<INetworkConnection> & connection, const std::vector<std::byte> & message) override;
public: public:
NetworkServer(INetworkServerListener & listener, NetworkContext & context, NetworkStrand & strand); NetworkServer(INetworkServerListener & listener, NetworkContext & context);
void receiveInternalConnection(std::shared_ptr<IInternalConnection> remoteConnection) override; void receiveInternalConnection(std::shared_ptr<IInternalConnection> remoteConnection) override;