feat: pathfinder multithreading

src/creatures/combat/combat.cpp

@@ -898,7 +898,7 @@ void Combat::addDistanceEffect(std::shared_ptr<Creature> caster, const Position
 
 void Combat::doChainEffect(const Position &origin, const Position &dest, uint8_t effect) {
 	if (effect > 0) {
-		std::forward_list<Direction> dirList;
+		stdext::arraylist<Direction> dirList(128);
 		FindPathParams fpp;
 		fpp.minTargetDist = 0;
 		fpp.maxTargetDist = 1;

src/creatures/combat/condition.cpp

@@ -1929,7 +1929,7 @@ bool ConditionFeared::getFleeDirection(std::shared_ptr<Creature> creature) {
 	return false;
 }
 
-bool ConditionFeared::getFleePath(std::shared_ptr<Creature> creature, const Position &pos, std::forward_list<Direction> &dirList) {
+bool ConditionFeared::getFleePath(std::shared_ptr<Creature> creature, const Position &pos, stdext::arraylist<Direction> &dirList) {
 	const std::vector<uint8_t> walkSize { 15, 9, 3, 1 };
 	bool found = false;
 	std::ptrdiff_t found_size = 0;
@@ -2030,7 +2030,7 @@ bool ConditionFeared::startCondition(std::shared_ptr<Creature> creature) {
 
 bool ConditionFeared::executeCondition(std::shared_ptr<Creature> creature, int32_t interval) {
 	Position currentPos = creature->getPosition();
-	std::forward_list<Direction> listDir;
+	stdext::arraylist<Direction> listDir(128);
 
 	g_logger().debug("[ConditionFeared::executeCondition] Executing condition, current position is {}", currentPos.toString());
 
@@ -2040,7 +2040,7 @@ bool ConditionFeared::executeCondition(std::shared_ptr<Creature> creature, int32
 		}
 
 		if (getFleePath(creature, currentPos, listDir)) {
-			g_dispatcher().addEvent(std::bind(&Game::forcePlayerAutoWalk, &g_game(), creature->getID(), listDir), "ConditionFeared::executeCondition");
+			g_dispatcher().addEvent(std::bind(&Game::forcePlayerAutoWalk, &g_game(), creature->getID(), listDir.data()), "ConditionFeared::executeCondition");
 			g_logger().debug("[ConditionFeared::executeCondition] Walking Scheduled");
 		}
 	}

src/creatures/combat/condition.hpp

@@ -333,7 +333,7 @@ class ConditionFeared final : public Condition {
 private:
 	bool canWalkTo(std::shared_ptr<Creature> creature, Position pos, Direction moveDirection) const;
 	bool getFleeDirection(std::shared_ptr<Creature> creature);
-	bool getFleePath(std::shared_ptr<Creature> creature, const Position &pos, std::forward_list<Direction> &dirList);
+	bool getFleePath(std::shared_ptr<Creature> creature, const Position &pos, stdext::arraylist<Direction> &dirList);
 	bool getRandomDirection(std::shared_ptr<Creature> creature, Position pos);
 	bool isStuck(std::shared_ptr<Creature> creature, Position pos) const;
 

src/creatures/creature.cpp

@@ -133,16 +133,23 @@ void Creature::onThink(uint32_t interval) {
 		}
 	}
 
+	auto onThink = [self = getCreature(), interval] {
+		// scripting event - onThink
+		const auto &thinkEvents = self->getCreatureEvents(CREATURE_EVENT_THINK);
+		for (const auto creatureEventPtr : thinkEvents) {
+			creatureEventPtr->executeOnThink(self->static_self_cast<Creature>(), interval);
+		}
+	};
+
 	if (isUpdatingPath) {
-		isUpdatingPath = false;
-		goToFollowCreature();
+		g_dispatcher().asyncEvent([self = getCreature(), onThink = std::move(onThink)] {
+			self->isUpdatingPath = false;
+			self->goToFollowCreature_async(onThink);
+		});
+		return;
 	}
 
-	// scripting event - onThink
-	const CreatureEventList &thinkEvents = getCreatureEvents(CREATURE_EVENT_THINK);
-	for (const auto creatureEventPtr : thinkEvents) {
-		creatureEventPtr->executeOnThink(static_self_cast<Creature>(), interval);
-	}
+	onThink();
 }
 
 void Creature::onAttacking(uint32_t interval) {
@@ -224,18 +231,20 @@ bool Creature::getNextStep(Direction &dir, uint32_t &) {
 	return true;
 }
 
-void Creature::startAutoWalk(const std::forward_list<Direction> &listDir, bool ignoreConditions /* = false*/) {
+void Creature::startAutoWalk(const std::vector<Direction> &listDir, bool ignoreConditions /* = false*/) {
+	listWalkDir.clear();
+
 	if (!ignoreConditions && (hasCondition(CONDITION_ROOTED) || hasCondition(CONDITION_FEARED))) {
 		return;
 	}
 
-	listWalkDir = listDir;
+	listWalkDir = { listDir.begin(), listDir.end() };
 
-	size_t size = 0;
-	for (auto it = listDir.begin(); it != listDir.end() && size <= 1; ++it) {
-		size++;
+	if (listWalkDir.empty()) {
+		return;
 	}
-	addEventWalk(size == 1);
+
+	addEventWalk(listWalkDir.size() == 1);
 }
 
 void Creature::addEventWalk(bool firstStep) {
@@ -249,20 +258,22 @@ void Creature::addEventWalk(bool firstStep) {
 		return;
 	}
 
-	int64_t ticks = getEventStepTicks(firstStep);
+	const int64_t ticks = getEventStepTicks(firstStep);
 	if (ticks <= 0) {
 		return;
 	}
 
-	// Take first step right away, but still queue the next
-	if (ticks == 1) {
-		g_game().checkCreatureWalk(getID());
-	}
+	g_dispatcher().context().tryAddEvent([ticks, self = getCreature()]() {
+		// Take first step right away, but still queue the next
+		if (ticks == 1) {
+			g_game().checkCreatureWalk(self->getID());
+		}
 
-	eventWalk = g_dispatcher().scheduleEvent(
-		static_cast<uint32_t>(ticks), std::bind(&Game::checkCreatureWalk, &g_game(), getID()),
-		"Creature::checkCreatureWalk"
-	);
+		self->eventWalk = g_dispatcher().scheduleEvent(
+			static_cast<uint32_t>(ticks), std::bind(&Game::checkCreatureWalk, &g_game(), self->getID()),
+			"Creature::checkCreatureWalk"
+		);
+	});
 }
 
 void Creature::stopEventWalk() {
@@ -320,11 +331,7 @@ int32_t Creature::getWalkCache(const Position &pos) {
 	if (std::abs(dx) <= maxWalkCacheWidth) {
 		int32_t dy = Position::getOffsetY(pos, myPos);
 		if (std::abs(dy) <= maxWalkCacheHeight) {
-			if (localMapCache[maxWalkCacheHeight + dy][maxWalkCacheWidth + dx]) {
-				return 1;
-			} else {
-				return 0;
-			}
+			return localMapCache[maxWalkCacheHeight + dy][maxWalkCacheWidth + dx];
 		}
 	}
 
@@ -464,7 +471,7 @@ void Creature::checkSummonMove(const Position &newPos, bool teleportSummon) {
 	}
 }
 
-void Creature::onCreatureMove(std::shared_ptr<Creature> creature, std::shared_ptr<Tile> newTile, const Position &newPos, std::shared_ptr<Tile> oldTile, const Position &oldPos, bool teleport) {
+void Creature::onCreatureMove(const std::shared_ptr<Creature> &creature, const std::shared_ptr<Tile> &newTile, const Position &newPos, const std::shared_ptr<Tile> &oldTile, const Position &oldPos, bool teleport) {
 	if (creature == getCreature()) {
 		lastStep = OTSYS_TIME();
 		lastStepCost = 1;
@@ -512,7 +519,7 @@ void Creature::onCreatureMove(std::shared_ptr<Creature> creature, std::shared_pt
 
 					// update 0
 					for (int32_t x = -maxWalkCacheWidth; x <= maxWalkCacheWidth; ++x) {
-						std::shared_ptr<Tile> cacheTile = g_game().map.getTile(static_cast<uint16_t>(myPos.getX() + x), static_cast<uint16_t>(myPos.getY() - maxWalkCacheHeight), myPos.z);
+						const auto &cacheTile = g_game().map.getTile(static_cast<uint16_t>(myPos.getX() + x), static_cast<uint16_t>(myPos.getY() - maxWalkCacheHeight), myPos.z);
 						updateTileCache(cacheTile, x, -maxWalkCacheHeight);
 					}
 				} else if (oldPos.y < newPos.y) { // south
@@ -523,7 +530,7 @@ void Creature::onCreatureMove(std::shared_ptr<Creature> creature, std::shared_pt
 
 					// update mapWalkHeight - 1
 					for (int32_t x = -maxWalkCacheWidth; x <= maxWalkCacheWidth; ++x) {
-						std::shared_ptr<Tile> cacheTile = g_game().map.getTile(static_cast<uint16_t>(myPos.getX() + x), static_cast<uint16_t>(myPos.getY() + maxWalkCacheHeight), myPos.z);
+						const auto &cacheTile = g_game().map.getTile(static_cast<uint16_t>(myPos.getX() + x), static_cast<uint16_t>(myPos.getY() + maxWalkCacheHeight), myPos.z);
 						updateTileCache(cacheTile, x, maxWalkCacheHeight);
 					}
 				}
@@ -548,7 +555,7 @@ void Creature::onCreatureMove(std::shared_ptr<Creature> creature, std::shared_pt
 
 					// update mapWalkWidth - 1
 					for (int32_t y = -maxWalkCacheHeight; y <= maxWalkCacheHeight; ++y) {
-						std::shared_ptr<Tile> cacheTile = g_game().map.getTile(myPos.x + maxWalkCacheWidth, static_cast<uint16_t>(myPos.y + y), myPos.z);
+						const auto &cacheTile = g_game().map.getTile(myPos.x + maxWalkCacheWidth, static_cast<uint16_t>(myPos.y + y), myPos.z);
 						updateTileCache(cacheTile, maxWalkCacheWidth, y);
 					}
 				} else if (oldPos.x > newPos.x) { // west
@@ -593,7 +600,7 @@ void Creature::onCreatureMove(std::shared_ptr<Creature> creature, std::shared_pt
 		}
 	}
 
-	auto followCreature = getFollowCreature();
+	const auto &followCreature = getFollowCreature();
 	if (followCreature && (creature == getCreature() || creature == followCreature)) {
 		if (hasFollowPath) {
 			isUpdatingPath = true;
@@ -605,7 +612,7 @@ void Creature::onCreatureMove(std::shared_ptr<Creature> creature, std::shared_pt
 		}
 	}
 
-	auto attackedCreature = getAttackedCreature();
+	const auto &attackedCreature = getAttackedCreature();
 	if (attackedCreature && (creature == attackedCreature || creature == getCreature())) {
 		if (newPos.z != oldPos.z || !canSee(attackedCreature->getPosition())) {
 			onCreatureDisappear(attackedCreature, false);
@@ -948,63 +955,72 @@ bool Creature::setAttackedCreature(std::shared_ptr<Creature> creature) {
 	return true;
 }
 
-void Creature::getPathSearchParams(std::shared_ptr<Creature>, FindPathParams &fpp) {
+void Creature::getPathSearchParams(const std::shared_ptr<Creature> &, FindPathParams &fpp) {
 	fpp.fullPathSearch = !hasFollowPath;
 	fpp.clearSight = true;
 	fpp.maxSearchDist = 12;
 	fpp.minTargetDist = 1;
 	fpp.maxTargetDist = 1;
 }
 
+void Creature::goToFollowCreature_async(std::function<void()> &&onComplete) {
+	if (pathfinderRunning.load()) {
+		return;
+	}
+
+	pathfinderRunning.store(true);
+	g_dispatcher().asyncEvent([self = getCreature()] {
+		self->goToFollowCreature();
+		self->pathfinderRunning.store(false);
+	});
+
+	if (onComplete) {
+		g_dispatcher().context().addEvent(std::move(onComplete));
+	}
+}
+
 void Creature::goToFollowCreature() {
-	auto followCreature = getFollowCreature();
-	if (followCreature) {
-		if (isSummon() && !getMonster()->isFamiliar() && !canFollowMaster()) {
-			hasFollowPath = false;
-			return;
-		}
+	const auto &followCreature = getFollowCreature();
+	if (!followCreature) {
+		return;
+	}
 
-		FindPathParams fpp;
-		getPathSearchParams(followCreature, fpp);
-		std::shared_ptr<Monster> monster = getMonster();
-		if (monster && !monster->getMaster() && (monster->isFleeing() || fpp.maxTargetDist > 1)) {
-			Direction dir = DIRECTION_NONE;
-
-			if (monster->isFleeing()) {
-				monster->getDistanceStep(followCreature->getPosition(), dir, true);
-			} else { // maxTargetDist > 1
-				if (!monster->getDistanceStep(followCreature->getPosition(), dir)) {
-					// if we can't get anything then let the A* calculate
-					listWalkDir.clear();
-					if (getPathTo(followCreature->getPosition(), listWalkDir, fpp)) {
-						hasFollowPath = true;
-						startAutoWalk(listWalkDir);
-					} else {
-						hasFollowPath = false;
-					}
-					return;
-				}
-			}
+	const auto &monster = getMonster();
 
-			if (dir != DIRECTION_NONE) {
-				listWalkDir.clear();
-				listWalkDir.push_front(dir);
+	if (isSummon() && !monster->isFamiliar() && !canFollowMaster()) {
+		listWalkDir.clear();
+		return;
+	}
 
-				hasFollowPath = true;
-				startAutoWalk(listWalkDir);
-			}
-		} else {
-			listWalkDir.clear();
-			if (getPathTo(followCreature->getPosition(), listWalkDir, fpp)) {
-				hasFollowPath = true;
-				startAutoWalk(listWalkDir);
-			} else {
-				hasFollowPath = false;
-			}
+	bool executeOnFollow = true;
+	stdext::arraylist<Direction> listDir(128);
+
+	FindPathParams fpp;
+	getPathSearchParams(followCreature, fpp);
+
+	if (monster && !monster->getMaster() && (monster->isFleeing() || fpp.maxTargetDist > 1)) {
+		Direction dir = DIRECTION_NONE;
+
+		if (monster->isFleeing()) {
+			monster->getDistanceStep(followCreature->getPosition(), dir, true);
+		} else if (!monster->getDistanceStep(followCreature->getPosition(), dir)) { // maxTargetDist > 1
+			// if we can't get anything then let the A* calculate
+			executeOnFollow = false;
+		} else if (dir != DIRECTION_NONE) {
+			listDir.push_back(dir);
+			hasFollowPath = true;
 		}
 	}
 
-	onFollowCreatureComplete(followCreature);
+	if (listDir.empty()) {
+		hasFollowPath = getPathTo(getFollowCreature()->getPosition(), listDir, fpp);
+	}
+
+	startAutoWalk(listDir.data());
+
+	if (executeOnFollow) {
+		onFollowCreatureComplete(getFollowCreature());
+	}
 }
 
 bool Creature::canFollowMaster() {
@@ -1248,7 +1264,6 @@ bool Creature::addCondition(std::shared_ptr<Condition> condition) {
 	std::shared_ptr<Condition> prevCond = getCondition(condition->getType(), condition->getId(), condition->getSubId());
 	if (prevCond) {
 		prevCond->addCondition(getCreature(), condition);
-
 		return true;
 	}
 
@@ -1638,11 +1653,11 @@ bool Creature::isInvisible() const {
 		!= conditions.end();
 }
 
-bool Creature::getPathTo(const Position &targetPos, std::forward_list<Direction> &dirList, const FindPathParams &fpp) {
+bool Creature::getPathTo(const Position &targetPos, stdext::arraylist<Direction> &dirList, const FindPathParams &fpp) {
 	return g_game().map.getPathMatching(getCreature(), dirList, FrozenPathingConditionCall(targetPos), fpp);
 }
 
-bool Creature::getPathTo(const Position &targetPos, std::forward_list<Direction> &dirList, int32_t minTargetDist, int32_t maxTargetDist, bool fullPathSearch /*= true*/, bool clearSight /*= true*/, int32_t maxSearchDist /*= 7*/) {
+bool Creature::getPathTo(const Position &targetPos, stdext::arraylist<Direction> &dirList, int32_t minTargetDist, int32_t maxTargetDist, bool fullPathSearch /*= true*/, bool clearSight /*= true*/, int32_t maxSearchDist /*= 7*/) {
 	FindPathParams fpp;
 	fpp.fullPathSearch = fullPathSearch;
 	fpp.maxSearchDist = maxSearchDist;