vcmi/client/AntilagServer.cpp

/*
 * AntilagServer.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 "AntilagServer.h"

#include "CServerHandler.h"
#include "Client.h"
#include "GameEngine.h"

#include "../server/CGameHandler.h"
#include "../lib/gameState/CGameState.h"
#include "../lib/mapObjects/CGHeroInstance.h"
#include "../lib/serializer/GameConnection.h"
#include "GameInstance.h"

class AntilagRollbackNotSupportedException : public std::runtime_error
{
public:
	using std::runtime_error::runtime_error;
};


int ConnectionPackWriter::write(const std::byte * data, unsigned size)
{
	buffer.insert(buffer.end(), data, data + size);
	return size;
}

void AntilagRollbackGeneratorVisitor::visitPackageReceived(PackageReceived & pack)
{
	success = true;
	// no-op rollback?
}

void AntilagRollbackGeneratorVisitor::visitPackageApplied(PackageApplied & pack)
{
	success = true;
	// no-op rollback?
}

void AntilagRollbackGeneratorVisitor::visitPlayerBlocked(PlayerBlocked & pack)
{
	success = true;
	// no-op rollback?
}

void AntilagRollbackGeneratorVisitor::visitSwapStacks(SwapStacks & pack)
{
	auto rollbackSwap = std::make_unique<SwapStacks>();

	rollbackSwap->srcArmy = pack.dstArmy;
	rollbackSwap->dstArmy = pack.srcArmy;
	rollbackSwap->srcSlot = pack.dstSlot;
	rollbackSwap->dstSlot = pack.srcSlot;

	rollbackPacks.push_back(std::move(rollbackSwap));
	success = true;
}

void AntilagRollbackGeneratorVisitor::visitRebalanceStacks(RebalanceStacks & pack)
{
	const auto * srcObject = gs.getObjInstance(pack.srcArmy);
	const auto * dstObject = gs.getObjInstance(pack.dstArmy);

	const auto * srcArmy = dynamic_cast<const CArmedInstance*>(srcObject);
	const auto * dstArmy = dynamic_cast<const CArmedInstance*>(dstObject);

	if (srcArmy->getStack(pack.srcSlot).getTotalExperience() != 0 ||
	   dstArmy->getStack(pack.srcSlot).getTotalExperience() != 0 ||
	   srcArmy->getStack(pack.srcSlot).getSlot(ArtifactPosition::CREATURE_SLOT)->artifactID.hasValue())
	{
		// TODO: rollback creature artifacts & stack experience
		return;
	}

	auto rollbackRebalance = std::make_unique<RebalanceStacks>();
	rollbackRebalance->srcArmy = pack.dstArmy;
	rollbackRebalance->dstArmy = pack.srcArmy;
	rollbackRebalance->srcSlot = pack.dstSlot;
	rollbackRebalance->dstSlot = pack.srcSlot;
	rollbackRebalance->count = pack.count;
	rollbackPacks.push_back(std::move(rollbackRebalance));
	success = true;
}

void AntilagRollbackGeneratorVisitor::visitBulkRebalanceStacks(BulkRebalanceStacks & pack)
{
	for (auto & subpack : pack.moves)
		visitRebalanceStacks(subpack);

	success = true;
}

void AntilagRollbackGeneratorVisitor::visitHeroVisitCastle(HeroVisitCastle & pack)
{
	auto rollbackVisit = std::make_unique<HeroVisitCastle>();
	rollbackVisit->startVisit = !pack.startVisit;
	rollbackVisit->tid = pack.tid;
	rollbackVisit->hid = pack.hid;

	rollbackPacks.push_back(std::move(rollbackVisit));

	success = true;
}

void AntilagRollbackGeneratorVisitor::visitTryMoveHero(TryMoveHero & pack)
{
	auto rollbackMove = std::make_unique<TryMoveHero>();
	auto rollbackFow = std::make_unique<FoWChange>();
	const auto * movedHero = gs.getHero(pack.id);

	rollbackMove->id = pack.id;
	rollbackMove->movePoints = movedHero->movementPointsRemaining();
	rollbackMove->result = pack.result;
	if (pack.result == TryMoveHero::EMBARK)
		rollbackMove->result = TryMoveHero::DISEMBARK;
	if (pack.result == TryMoveHero::DISEMBARK)
		rollbackMove->result = TryMoveHero::EMBARK;
	rollbackMove->start = pack.end;
	rollbackMove->end = pack.start;

	rollbackFow->mode = ETileVisibility::HIDDEN;
	rollbackFow->player = movedHero->getOwner();
	rollbackFow->tiles = pack.fowRevealed;

	rollbackPacks.push_back(std::move(rollbackMove));
	rollbackPacks.push_back(std::move(rollbackFow));
	success = true;
}

bool AntilagRollbackGeneratorVisitor::canBeRolledBack() const
{
	return success;
}

std::vector<std::unique_ptr<CPackForClient>> AntilagRollbackGeneratorVisitor::getRollbackPacks()
{
	return std::move(rollbackPacks);
}

AntilagReplyPredictionVisitor::AntilagReplyPredictionVisitor() = default;

void AntilagReplyPredictionVisitor::visitMoveHero(MoveHero & pack)
{
	canBeAppliedValue = true;
}

void AntilagReplyPredictionVisitor::visitArrangeStacks(ArrangeStacks & pack)
{
	canBeAppliedValue = true;
}

bool AntilagReplyPredictionVisitor::canBeApplied() const
{
	return canBeAppliedValue;
}

AntilagServer::AntilagServer(INetworkHandler & network, const std::shared_ptr<CGameState> & gs)
	: gameState(gs)
{
	antilagNetConnection = network.createAsyncConnection(*this);
	antilagGameConnection = std::make_shared<GameConnection>(antilagNetConnection);
}

AntilagServer::~AntilagServer() = default;

void AntilagServer::onDisconnected(const std::shared_ptr<INetworkConnection> & connection, const std::string & errorMessage)
{
	// should never be called
	throw std::runtime_error("AntilagServer::onDisconnected called!");
}

void AntilagServer::onPacketReceived(const std::shared_ptr<INetworkConnection> & connection, const std::vector<std::byte> & message)
{
	std::scoped_lock interfaceLock(ENGINE->interfaceMutex);

	auto basePack = antilagGameConnection->retrievePack(message);
	auto * serverPack = dynamic_cast<CPackForServer*>(basePack.get());

	AntilagReplyPredictionVisitor packVisitor;
	serverPack->visit(packVisitor);
	if (!packVisitor.canBeApplied())
		return;

	logGlobal->info("Predicting effects of pack '%s'", typeid(*serverPack).name());

	AntilagReplyPrediction newPrediction;
	newPrediction.requestID = serverPack->requestID;
	newPrediction.senderID = serverPack->player;
	predictedReplies.push_back(std::move(newPrediction));

	try
	{
		CGameHandler gameHandler(*this, gameState);
		gameHandler.handleReceivedPack(GameConnectionID::FIRST_CONNECTION, *serverPack);
	}
	catch (const AntilagRollbackNotSupportedException & )
	{
		return;
	}
}

void AntilagServer::tryPredictReply(const CPackForServer & request)
{
	antilagGameConnection->sendPack(request);
	logGlobal->info("Scheduled prediction of effects of pack '%s'", typeid(request).name());
}

bool AntilagServer::verifyReply(const CPackForClient & pack)
{
	logGlobal->info("Verifying reply: received pack '%s'", typeid(pack).name());

	const auto * packageReceived = dynamic_cast<const PackageReceived*>(&pack);
	const auto * packageApplied = dynamic_cast<const PackageApplied*>(&pack);

	if (packageReceived)
	{
		assert(currentPackageID == invalidPackageID);

		if (!predictedReplies.empty() && predictedReplies.front().requestID == packageReceived->requestID)
		{
			[[maybe_unused]] const auto & nextPrediction = predictedReplies.front();
			assert(nextPrediction.senderID == packageReceived->player);
			assert(nextPrediction.requestID == packageReceived->requestID);
			currentPackageID = packageReceived->requestID;
		}
	}

	if (currentPackageID == invalidPackageID)
	{
		// this is system package or reply to actions of another player
		// TODO: consider reapplying all our predictions, in case if this event invalidated our prediction
		return false;
	}

	ConnectionPackWriter packWriter;
	BinarySerializer serializer(&packWriter);
	serializer & &pack;

	if (packWriter.buffer == predictedReplies.front().writtenPacks.front().buffer)
	{
		// Our prediction was sucessful - drop rollback information for this pack
		predictedReplies.front().writtenPacks.erase(predictedReplies.front().writtenPacks.begin());

		if (predictedReplies.front().writtenPacks.empty())
		{
			predictedReplies.erase(predictedReplies.begin());
			currentPackageID = invalidPackageID;
			return true;
		}
	}
	else
	{
		// Prediction was incorrect - rollback everything that is left in this prediction and use real server packs
		for (auto & prediction : boost::adaptors::reverse(predictedReplies.front().writtenPacks))
		{
			for (auto & pack : prediction.rollbackPacks)
				GAME->server().client->handlePack(*pack);
		}
		predictedReplies.erase(predictedReplies.begin());
		currentPackageID = invalidPackageID;
		return false;
	}

	if (packageApplied)
	{
		assert(currentPackageID == packageApplied->requestID);
		assert(!predictedReplies.empty());
		assert(currentPackageID == predictedReplies.front().requestID);
		assert(predictedReplies.front().writtenPacks.empty());
		predictedReplies.erase(predictedReplies.begin());
		currentPackageID = invalidPackageID;
	}

	return true;
}

void AntilagServer::setState(EServerState value)
{
	// no-op
}

EServerState AntilagServer::getState() const
{
	return EServerState::GAMEPLAY;
}

bool AntilagServer::isPlayerHost(const PlayerColor & color) const
{
	return false; // TODO?
}

bool AntilagServer::hasPlayerAt(PlayerColor player, GameConnectionID c) const
{
	return true; // TODO?
}

bool AntilagServer::hasBothPlayersAtSameConnection(PlayerColor left, PlayerColor right) const
{
	return false; // TODO?
}

void AntilagServer::applyPack(CPackForClient & pack)
{
	AntilagRollbackGeneratorVisitor visitor(*gameState);
	pack.visit(visitor);
	if (!visitor.canBeRolledBack())
	{
		logGlobal->info("Prediction not possible: pack '%s'", typeid(pack).name());
		throw AntilagRollbackNotSupportedException(std::string("Prediction not possible ") + typeid(pack).name());
	}

	logGlobal->info("Prediction: pack '%s'", typeid(pack).name());

	ConnectionPackWriter packWriter;
	BinarySerializer serializer(&packWriter);
	serializer & &pack;
	packWriter.rollbackPacks = visitor.getRollbackPacks();
	predictedReplies.back().writtenPacks.push_back(std::move(packWriter));

	GAME->server().client->handlePack(pack);
}

void AntilagServer::sendPack(CPackForClient & pack, GameConnectionID connectionID)
{
	applyPack(pack);
}