Optimize pathfinding

config.lua.dist

@@ -37,6 +37,12 @@ replaceKickOnLogin = true
 maxPacketsPerSecond = 25
 enableTwoFactorAuth = true
 
+-- Pathfinding
+-- NOTE: pathfindingInterval how often paths are force drawn
+-- NOTE: pathfindingDelay delay recently force drawn paths from drawing again
+pathfindingInterval = 100
+pathfindingDelay = 200
+
 -- 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", 100);
+	integer[PATHFINDING_DELAY] = getGlobalNumber(L, "pathfindingDelay", 200);
 
 	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

@@ -141,27 +141,27 @@ 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;
+	}
+
+	if (lastPathUpdate > OTSYS_TIME()) {
+		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) {
@@ -196,8 +196,6 @@ void Creature::onWalk()
 					player->sendCancelMessage(ret);
 					player->sendCancelWalk();
 				}
-
-				forceUpdateFollowPath = true;
 			}
 		} else {
 			stopEventWalk();
@@ -208,6 +206,8 @@ void Creature::onWalk()
 		}
 	}
 
+	updateFollowersPaths();
+
 	if (cancelNextWalk) {
 		listWalkDir.clear();
 		onWalkAborted();
@@ -218,6 +218,10 @@ void Creature::onWalk()
 		eventWalk = 0;
 		addEventWalk();
 	}
+
+	if (attackedCreature || followCreature) {
+		g_dispatcher.addTask(createTask([id = getID()]() { g_game.updateCreatureWalk(id); }));
+	}
 }
 
 void Creature::onWalk(Direction& dir)
@@ -619,10 +623,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);
 		}
@@ -939,6 +939,7 @@ bool Creature::setAttackedCreature(Creature* creature)
 		}
 
 		attackedCreature = creature;
+		creature->addFollower(this);
 		onAttackedCreature(attackedCreature);
 		attackedCreature->onAttacked();
 	} else {
@@ -955,7 +956,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;
 }
@@ -1025,19 +1026,36 @@ bool Creature::setFollowCreature(Creature* creature)
 			onWalkAborted();
 		}
 
-		hasFollowPath = false;
-		forceUpdateFollowPath = false;
 		followCreature = creature;
-		isUpdatingPath = true;
+		creature->addFollower(this);
+		hasFollowPath = false;
 	} else {
-		isUpdatingPath = false;
 		followCreature = nullptr;
 	}
 
 	onFollowCreature(creature);
 	return true;
 }
 
+// Pathfinding Events
+void Creature::updateFollowersPaths()
+{
+	if (followers.empty()) {
+		return;
+	}
+
+	const Position& thisPosition = getPosition();
+	for (const auto follower : followers) {
+		const Position& followerPosition = follower->getPosition();
+		if (thisPosition.getDistanceX(followerPosition) >= Map::maxViewportX + 2 ||
+		    thisPosition.getDistanceY(followerPosition) >= Map::maxViewportY + 2) {
+			continue;
+		}
+
+		g_dispatcher.addTask(createTask([id = follower->getID()]() { g_game.updateCreatureWalk(id); }));
+	}
+}
+
 double Creature::getDamageRatio(Creature* attacker) const
 {
 	uint32_t totalDamage = 0;
@@ -1663,7 +1681,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();
 
@@ -195,6 +196,12 @@ class Creature : virtual public Thing
 	virtual void onFollowCreature(const Creature*) {}
 	virtual void onFollowCreatureComplete(const Creature*) {}
 
+	// Pathfinding functions
+	void addFollower(Creature* creature) { followers.emplace_back(creature); };
+
+	// Pathfinding events
+	void updateFollowersPaths();
+
 	// combat functions
 	Creature* getAttackedCreature() { return attackedCreature; }
 	virtual bool setAttackedCreature(Creature* creature);
@@ -278,6 +285,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);
@@ -384,8 +392,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;
@@ -414,14 +424,12 @@ class Creature : virtual public Thing
 	bool localMapCache[mapWalkHeight][mapWalkWidth] = {{false}};
 	bool isInternalRemoved = false;
 	bool isMapLoaded = 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

@@ -67,6 +67,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(); }));
 }
 
@@ -3873,6 +3875,21 @@ 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();
+		}
+	}
+
+	cleanup();
+}
+
 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);