Optimize pathfinding

CMakeLists.txt

@@ -7,7 +7,7 @@
 # driving the vcpkg triplet in the same way either when starting vcpkg directly,
 # or when letting CMake start vcpkg at configure/generate time.
 # Note: this logic must happen before PROJECT command.
 if (DEFINED ENV{VCPKG_DEFAULT_TRIPLET} AND NOT DEFINED VCPKG_TARGET_TRIPLET)
     set(VCPKG_TARGET_TRIPLET "$ENV{VCPKG_DEFAULT_TRIPLET}" CACHE STRING "The vcpkg triplet")
 endif()
 
@@ -130,4 +130,4 @@
 endif()
 ### END  Git Version ###
 
-target_precompile_headers(tfs PUBLIC src/otpch.h)
+target_precompile_headers(tfs PUBLIC src/otpch.h)

config.lua.dist

@@ -37,6 +37,13 @@ replaceKickOnLogin = true
 maxPacketsPerSecond = 25
 enableTwoFactorAuth = true
 
+-- Pathfinding
+-- pathfindingInterval handles how often paths are force drawn
+-- pathfindingDelay delays any recently drawn paths from drawing again
+-- pathfindingDelay does not delay pathfindingInterval
+pathfindingInterval = 200
+pathfindingDelay = 300
+
 -- Deaths
 -- NOTE: Leave deathLosePercent as -1 if you want to use the default
 -- death penalty formula. For the old formula, set it to 10. For

src/configmanager.cpp

@@ -292,6 +292,8 @@ bool ConfigManager::load()
 	integer[QUEST_TRACKER_PREMIUM_LIMIT] = getGlobalNumber(L, "questTrackerPremiumLimit", 15);
 	integer[STAMINA_REGEN_MINUTE] = getGlobalNumber(L, "timeToRegenMinuteStamina", 3 * 60);
 	integer[STAMINA_REGEN_PREMIUM] = getGlobalNumber(L, "timeToRegenMinutePremiumStamina", 6 * 60);
+	integer[PATHFINDING_INTERVAL] = getGlobalNumber(L, "pathfindingInterval", 200);
+	integer[PATHFINDING_DELAY] = getGlobalNumber(L, "pathfindingDelay", 300);
 
 	expStages = loadXMLStages();
 	if (expStages.empty()) {

src/configmanager.h

@@ -121,6 +121,8 @@ enum integer_config_t
 	QUEST_TRACKER_PREMIUM_LIMIT,
 	STAMINA_REGEN_MINUTE,
 	STAMINA_REGEN_PREMIUM,
+	PATHFINDING_INTERVAL,
+	PATHFINDING_DELAY,
 
 	LAST_INTEGER_CONFIG /* this must be the last one */
 };

src/creature.cpp

@@ -135,27 +135,23 @@ void Creature::onThink(uint32_t interval)
 		blockTicks = 0;
 	}
 
-	if (followCreature) {
-		walkUpdateTicks += interval;
-		if (forceUpdateFollowPath || walkUpdateTicks >= 2000) {
-			walkUpdateTicks = 0;
-			forceUpdateFollowPath = false;
-			isUpdatingPath = true;
-		}
-	}
-
-	if (isUpdatingPath) {
-		isUpdatingPath = false;
-		goToFollowCreature();
-	}
-
 	// scripting event - onThink
 	const CreatureEventList& thinkEvents = getCreatureEvents(CREATURE_EVENT_THINK);
 	for (CreatureEvent* thinkEvent : thinkEvents) {
 		thinkEvent->executeOnThink(this, interval);
 	}
 }
 
+void Creature::forceUpdatePath()
+{
+	if (!attackedCreature && !followCreature) {
+		return;
+	}
+
+	lastPathUpdate = OTSYS_TIME() + getNumber(ConfigManager::PATHFINDING_DELAY);
+	g_dispatcher.addTask(createTask([id = getID()]() { g_game.updateCreatureWalk(id); }));
+}
+
 void Creature::onAttacking(uint32_t interval)
 {
 	if (!attackedCreature) {
@@ -190,8 +186,6 @@ void Creature::onWalk()
 					player->sendCancelMessage(ret);
 					player->sendCancelWalk();
 				}
-
-				forceUpdateFollowPath = true;
 			}
 		} else {
 			stopEventWalk();
@@ -202,6 +196,9 @@ void Creature::onWalk()
 		}
 	}
 
+	removeFollowers();
+	updateFollowersPaths();
+
 	if (cancelNextWalk) {
 		listWalkDir.clear();
 		onWalkAborted();
@@ -212,6 +209,13 @@ void Creature::onWalk()
 		eventWalk = 0;
 		addEventWalk();
 	}
+
+	if (attackedCreature || followCreature) {
+		if (lastPathUpdate - OTSYS_TIME() > 0) {
+			g_dispatcher.addTask(createTask([id = getID()]() { g_game.updateCreatureWalk(id); }));
+			lastPathUpdate = OTSYS_TIME() + getNumber(ConfigManager::PATHFINDING_DELAY);
+		}
+	}
 }
 
 void Creature::onWalk(Direction& dir)
@@ -415,10 +419,6 @@ void Creature::onCreatureMove(Creature* creature, const Tile* newTile, const Pos
 	}
 
 	if (creature == followCreature || (creature == this && followCreature)) {
-		if (hasFollowPath) {
-			isUpdatingPath = true;
-		}
-
 		if (newPos.z != oldPos.z || !canSee(followCreature->getPosition())) {
 			onCreatureDisappear(followCreature, false);
 		}
@@ -733,6 +733,7 @@ void Creature::setAttackedCreature(Creature* creature)
 	}
 
 	attackedCreature = creature;
+	creature->addFollower(this);
 	onAttackedCreature(attackedCreature);
 	attackedCreature->onAttacked();
 
@@ -763,7 +764,7 @@ void Creature::getPathSearchParams(const Creature*, FindPathParams& fpp) const
 {
 	fpp.fullPathSearch = !hasFollowPath;
 	fpp.clearSight = true;
-	fpp.maxSearchDist = 12;
+	fpp.maxSearchDist = Map::maxViewportX + Map::maxViewportY;
 	fpp.minTargetDist = 1;
 	fpp.maxTargetDist = 1;
 }
@@ -780,6 +781,8 @@ void Creature::setFollowCreature(Creature* creature)
 	}
 
 	followCreature = creature;
+	creature->addFollower(this);
+	hasFollowPath = false;
 	onFollowCreature(creature);
 }
 
@@ -804,13 +807,64 @@ void Creature::onFollowCreature(const Creature*)
 		listWalkDir.clear();
 		onWalkAborted();
 	}
+}
 
-	hasFollowPath = false;
-	forceUpdateFollowPath = false;
-	isUpdatingPath = true;
+void Creature::onUnfollowCreature() { hasFollowPath = false; }
+
+// Pathfinding Events
+bool Creature::isFollower(Creature* creature)
+{
+	auto it = std::find(followers.begin(), followers.end(), creature);
+	return it != followers.end();
+}
+
+void Creature::addFollower(Creature* creature)
+{
+	if (!isFollower(creature)) {
+		followers.push_back(creature);
+	}
 }
 
-void Creature::onUnfollowCreature() { isUpdatingPath = false; }
+void Creature::removeFollowers()
+{
+	const Position& position = getPosition();
+
+	followers.erase(std::remove_if(followers.begin(), followers.end(),
+	                               [&position](Creature* creature) {
+		                               const Position& followerPosition = creature->getPosition();
+		                               uint16_t distance = position.getDistanceX(followerPosition) +
+		                                                   position.getDistanceY(followerPosition);
+		                               return distance >= Map::maxViewportX + Map::maxViewportY ||
+		                                      position.z != followerPosition.z;
+	                               }),
+	                followers.end());
+}
+
+void Creature::updateFollowersPaths()
+{
+	if (followers.empty()) {
+		return;
+	}
+
+	const Position& thisPosition = getPosition();
+	for (const auto& follower : followers) {
+		if (follower != nullptr) {
+			const Position& followerPosition = follower->getPosition();
+
+			if (follower->lastPathUpdate - OTSYS_TIME() > 0) {
+				continue;
+			}
+
+			if (thisPosition.getDistanceX(followerPosition) >= Map::maxViewportX ||
+			    thisPosition.getDistanceY(followerPosition) >= Map::maxViewportY) {
+				continue;
+			}
+
+			g_dispatcher.addTask(createTask([id = follower->getID()]() { g_game.updateCreatureWalk(id); }));
+			follower->lastPathUpdate = OTSYS_TIME() + getNumber(ConfigManager::PATHFINDING_DELAY);
+		}
+	}
+}
 
 double Creature::getDamageRatio(Creature* attacker) const
 {
@@ -1437,7 +1491,7 @@ bool Creature::isInvisible() const
 
 bool Creature::getPathTo(const Position& targetPos, std::vector<Direction>& dirList, const FindPathParams& fpp) const
 {
-	return g_game.map.getPathMatching(*this, dirList, FrozenPathingConditionCall(targetPos), fpp);
+	return g_game.map.getPathMatching(*this, targetPos, dirList, FrozenPathingConditionCall(targetPos), fpp);
 }
 
 bool Creature::getPathTo(const Position& targetPos, std::vector<Direction>& dirList, int32_t minTargetDist,

src/creature.h

@@ -55,6 +55,7 @@ struct FindPathParams
 static constexpr int32_t EVENT_CREATURECOUNT = 10;
 static constexpr int32_t EVENT_CREATURE_THINK_INTERVAL = 1000;
 static constexpr int32_t EVENT_CHECK_CREATURE_INTERVAL = (EVENT_CREATURE_THINK_INTERVAL / EVENT_CREATURECOUNT);
+
 static constexpr uint32_t CREATURE_ID_MIN = 0x10000000;
 static constexpr uint32_t CREATURE_ID_MAX = std::numeric_limits<uint32_t>::max();
 
@@ -199,6 +200,14 @@ class Creature : virtual public Thing
 	virtual void onFollowCreature(const Creature*);
 	virtual void onUnfollowCreature();
 
+	// Pathfinding functions
+	bool isFollower(Creature* creature);
+	void addFollower(Creature* creature);
+	void removeFollowers();
+
+	// Pathfinding events
+	void updateFollowersPaths();
+
 	// combat functions
 	Creature* getAttackedCreature() { return attackedCreature; }
 	virtual void setAttackedCreature(Creature* creature);
@@ -286,6 +295,7 @@ class Creature : virtual public Thing
 	void setCreatureLight(LightInfo lightInfo);
 
 	virtual void onThink(uint32_t interval);
+	virtual void forceUpdatePath();
 	void onAttacking(uint32_t interval);
 	virtual void onWalk();
 	virtual bool getNextStep(Direction& dir, uint32_t& flags);
@@ -385,8 +395,10 @@ class Creature : virtual public Thing
 	Creature* attackedCreature = nullptr;
 	Creature* master = nullptr;
 	Creature* followCreature = nullptr;
+	std::vector<Creature*> followers;
 
 	uint64_t lastStep = 0;
+	int64_t lastPathUpdate = 0;
 	uint32_t referenceCounter = 0;
 	uint32_t id = 0;
 	uint32_t scriptEventsBitField = 0;
@@ -413,14 +425,12 @@ class Creature : virtual public Thing
 	Skulls_t skull = SKULL_NONE;
 
 	bool isInternalRemoved = false;
-	bool isUpdatingPath = false;
 	bool creatureCheck = false;
 	bool inCheckCreaturesVector = false;
 	bool skillLoss = true;
 	bool lootDrop = true;
 	bool cancelNextWalk = false;
 	bool hasFollowPath = false;
-	bool forceUpdateFollowPath = false;
 	bool hiddenHealth = false;
 	bool canUseDefense = true;
 	bool movementBlocked = false;

src/game.cpp

@@ -66,6 +66,8 @@ void Game::start(ServiceManager* manager)
 	serviceManager = manager;
 
 	g_scheduler.addEvent(createSchedulerTask(EVENT_CREATURE_THINK_INTERVAL, [this]() { checkCreatures(0); }));
+	g_scheduler.addEvent(
+	    createSchedulerTask(getNumber(ConfigManager::PATHFINDING_INTERVAL), [this]() { updateCreaturesPath(0); }));
 	g_scheduler.addEvent(createSchedulerTask(EVENT_DECAYINTERVAL, [this]() { checkDecay(); }));
 }
 
@@ -3884,6 +3886,19 @@ void Game::checkCreatures(size_t index)
 	cleanup();
 }
 
+void Game::updateCreaturesPath(size_t index)
+{
+	g_scheduler.addEvent(createSchedulerTask(getNumber(ConfigManager::PATHFINDING_INTERVAL),
+	                                         [=, this]() { updateCreaturesPath((index + 1) % EVENT_CREATURECOUNT); }));
+
+	auto& checkCreatureList = checkCreatureLists[index];
+	for (Creature* creature : checkCreatureList) {
+		if (!creature->isDead()) {
+			creature->forceUpdatePath();
+		}
+	}
+}
+
 void Game::changeSpeed(Creature* creature, int32_t varSpeedDelta)
 {
 	int32_t varSpeed = creature->getSpeed() - creature->getBaseSpeed();

src/game.h

@@ -424,6 +424,7 @@ class Game
 	void updateCreatureWalk(uint32_t creatureId);
 	void checkCreatureAttack(uint32_t creatureId);
 	void checkCreatures(size_t index);
+	void updateCreaturesPath(size_t index);
 
 	bool combatBlockHit(CombatDamage& damage, Creature* attacker, Creature* target, bool checkDefense, bool checkArmor,
 	                    bool field, bool ignoreResistances = false);