Cleanup, remove unnecessary changes

client/CServerHandler.cpp

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

client/ClientNetPackVisitors.h

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

client/NetPacksClient.cpp

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

lib/StartInfo.cpp

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

lib/network/NetworkConnection.cpp

@@ -208,15 +208,15 @@ void NetworkConnection::close()
 	//NOTE: ignoring error code, intended
 }
 
-InternalConnection::InternalConnection(INetworkConnectionListener & listener, NetworkStrand & strand)
-	: strand(strand)
+InternalConnection::InternalConnection(INetworkConnectionListener & listener, NetworkContext & context)
+	: context(context)
 	, listener(listener)
 {
 }
 
 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)
 			self->listener.onPacketReceived(self, message);
 	});
@@ -224,7 +224,7 @@ void InternalConnection::receivePacket(const std::vector<std::byte> & message)
 
 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->otherSideWeak.reset();
 		self->connectionActive = false;

lib/network/NetworkConnection.h

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

lib/network/NetworkDefines.h

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

lib/network/NetworkHandler.cpp

@@ -21,26 +21,25 @@ std::unique_ptr<INetworkHandler> INetworkHandler::createHandler()
 }
 
 NetworkHandler::NetworkHandler()
-	: io(std::make_unique<NetworkContext>())
-	, strand(std::make_unique<NetworkStrand>(*io))
+	: context(std::make_unique<NetworkContext>())
 {}
 
 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)
 {
-	auto loopbackConnection = std::make_shared<InternalConnection>(listener, *strand);
+	auto loopbackConnection = std::make_shared<InternalConnection>(listener, *context);
 	loopbackConnection->connectTo(loopbackConnection);
 	return loopbackConnection;
 }
 
 void NetworkHandler::connectToRemote(INetworkClientListener & listener, const std::string & host, uint16_t port)
 {
-	auto socket = std::make_shared<NetworkSocket>(*io);
-	auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(*io);
+	auto socket = std::make_shared<NetworkSocket>(*context);
+	auto resolver = std::make_shared<boost::asio::ip::tcp::resolver>(*context);
 
 	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)
@@ -58,7 +57,7 @@ void NetworkHandler::connectToRemote(INetworkClientListener & listener, const st
 				listener.onConnectionFailed(error.message());
 				return;
 			}
-			auto connection = std::make_shared<NetworkConnection>(listener, socket, *io);
+			auto connection = std::make_shared<NetworkConnection>(listener, socket, *context);
 			connection->start();
 
 			listener.onConnectionEstablished(connection);
@@ -68,13 +67,13 @@ void NetworkHandler::connectToRemote(INetworkClientListener & listener, const st
 
 void NetworkHandler::run()
 {
-	boost::asio::executor_work_guard<decltype(io->get_executor())> work{io->get_executor()};
-	io->run();
+	boost::asio::executor_work_guard<decltype(context->get_executor())> work{context->get_executor()};
+	context->run();
 }
 
 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){
 		if (!error)
 			listener.onTimer();
@@ -83,18 +82,18 @@ void NetworkHandler::createTimer(INetworkTimerListener & listener, std::chrono::
 
 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);
 
-	boost::asio::post(*io, [&listener, localConnection](){
+	boost::asio::post(*context, [&listener, localConnection](){
 		listener.onConnectionEstablished(localConnection);
 	});
 }
 
 void NetworkHandler::stop()
 {
-	io->stop();
+	context->stop();
 }
 
 VCMI_LIB_NAMESPACE_END

lib/network/NetworkHandler.h

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

lib/network/NetworkServer.cpp

@@ -13,22 +13,21 @@
 
 VCMI_LIB_NAMESPACE_BEGIN
 
-NetworkServer::NetworkServer(INetworkServerListener & listener, NetworkContext & context, NetworkStrand & strand)
-	: io(context)
-	, strand(strand)
+NetworkServer::NetworkServer(INetworkServerListener & listener, NetworkContext & context)
+	: context(context)
 	, listener(listener)
 {
 }
 
 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();
 }
 
 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); });
 	return acceptor->local_endpoint().port();
 }
@@ -41,7 +40,7 @@ void NetworkServer::connectionAccepted(std::shared_ptr<NetworkSocket> upcomingCo
 	}
 
 	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);
 	connection->start();
 	listener.onNewConnection(connection);
@@ -60,7 +59,7 @@ void NetworkServer::onDisconnected(const std::shared_ptr<INetworkConnection> & c
 
 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);
 

lib/network/NetworkServer.h

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