perf: optimized moveCreature and spectators

src/creatures/monsters/monster.hpp

@@ -453,7 +453,11 @@ class Monster final : public Creature {
 	void dropLoot(std::shared_ptr<Container> corpse, std::shared_ptr<Creature> lastHitCreature) override;
 	void getPathSearchParams(const std::shared_ptr<Creature> &creature, FindPathParams &fpp) override;
 	bool useCacheMap() const override {
-		return !randomStepping;
+		// return !randomStepping;
+		//  As the map cache is done synchronously for each movement that a monster makes, it is better to disable it,
+		//  as the pathfinder, which is one of the resources that uses this cache the most,
+		//  is multithreding and thus the processing cost is divided between the threads.
+		return false;
 	}
 
 	friend class MonsterFunctions;

src/map/map.cpp

@@ -342,13 +342,35 @@ void Map::moveCreature(const std::shared_ptr<Creature> &creature, const std::sha
 
 	bool teleport = forceTeleport || !newTile->getGround() || !Position::areInRange<1, 1, 0>(oldPos, newPos);
 
-	auto spectators = Spectators()
-						  .find<Creature>(oldPos, true)
-						  .find<Creature>(newPos, true);
+	Spectators spectators;
+	if (!teleport && oldPos.z == newPos.z) {
+		int32_t minRangeX = MAP_MAX_VIEW_PORT_X;
+		int32_t maxRangeX = MAP_MAX_VIEW_PORT_X;
+		int32_t minRangeY = MAP_MAX_VIEW_PORT_Y;
+		int32_t maxRangeY = MAP_MAX_VIEW_PORT_Y;
+
+		if (oldPos.y > newPos.y) {
+			++minRangeY;
+		} else if (oldPos.y < newPos.y) {
+			++maxRangeY;
+		}
+
+		if (oldPos.x < newPos.x) {
+			++maxRangeX;
+		} else if (oldPos.x > newPos.x) {
+			++minRangeX;
+		}
+
+		spectators.find<Creature>(oldPos, true, minRangeX, maxRangeX, minRangeY, maxRangeY);
+	} else {
+		spectators.find<Creature>(oldPos, true);
+		spectators.find<Creature>(newPos, true);
+	}
 
 	auto playersSpectators = spectators.filter<Player>();
 
 	std::vector<int32_t> oldStackPosVector;
+	oldStackPosVector.reserve(playersSpectators.size());
 	for (const auto &spec : playersSpectators) {
 		if (spec->canSeeCreature(creature)) {
 			oldStackPosVector.push_back(oldTile->getClientIndexOfCreature(spec->getPlayer(), creature));

src/map/spectators.cpp

@@ -18,50 +18,27 @@ void Spectators::clearCache() {
 	spectatorsCache.clear();
 }
 
-bool Spectators::contains(const std::shared_ptr<Creature> &creature) {
-	return creatures.contains(creature);
-}
-
-bool Spectators::erase(const std::shared_ptr<Creature> &creature) {
-	return creatures.erase(creature);
-}
-
 Spectators Spectators::insert(const std::shared_ptr<Creature> &creature) {
 	if (creature) {
-		creatures.emplace(creature);
+		creatures.emplace_back(creature);
 	}
 	return *this;
 }
 
-Spectators Spectators::insertAll(const SpectatorList &list) {
+Spectators Spectators::insertAll(const CreatureVector &list) {
 	if (!list.empty()) {
-		creatures.insertAll(list);
-	}
-	return *this;
-}
+		const bool hasValue = !creatures.empty();
 
-Spectators Spectators::join(Spectators &anotherSpectators) {
-	return insertAll(anotherSpectators.creatures.data());
-}
-
-bool Spectators::empty() const noexcept {
-	return creatures.empty();
-}
+		creatures.insert(creatures.end(), list.begin(), list.end());
 
-size_t Spectators::size() noexcept {
-	return creatures.size();
-}
-
-CreatureVector::iterator Spectators::begin() noexcept {
-	return creatures.begin();
-}
-
-CreatureVector::iterator Spectators::end() noexcept {
-	return creatures.end();
-}
-
-const CreatureVector &Spectators::data() noexcept {
-	return creatures.data();
+		// Remove duplicate
+		if (hasValue) {
+			std::unordered_set uset(creatures.begin(), creatures.end());
+			creatures.clear();
+			creatures.insert(creatures.end(), uset.begin(), uset.end());
+		}
+	}
+	return *this;
 }
 
 bool Spectators::checkCache(const SpectatorsCache::FloorData &specData, bool onlyPlayers, const Position &centerPos, bool checkDistance, bool multifloor, int32_t minRangeX, int32_t maxRangeX, int32_t minRangeY, int32_t maxRangeY) {
@@ -77,7 +54,7 @@ bool Spectators::checkCache(const SpectatorsCache::FloorData &specData, bool onl
 	}
 
 	if (checkDistance) {
-		SpectatorList spectators;
+		CreatureVector spectators;
 		spectators.reserve(creatures.size());
 		for (const auto &creature : *list) {
 			const auto &specPos = creature->getPosition();
@@ -176,7 +153,7 @@ Spectators Spectators::find(const Position &centerPos, bool multifloor, bool onl
 	const int32_t endx2 = x2 - (x2 & SECTOR_MASK);
 	const int32_t endy2 = y2 - (y2 & SECTOR_MASK);
 
-	SpectatorList spectators;
+	CreatureVector spectators;
 	spectators.reserve(std::max<uint8_t>(MAP_MAX_VIEW_PORT_X, MAP_MAX_VIEW_PORT_Y) * 2);
 
 	const MapSector* startSector = g_game().map.getMapSector(startx1, starty1);

src/map/spectators.hpp

@@ -16,12 +16,10 @@ class Monster;
 class Npc;
 struct Position;
 
-using SpectatorList = std::vector<std::shared_ptr<Creature>>;
-
 struct SpectatorsCache {
 	struct FloorData {
-		std::optional<SpectatorList> floor;
-		std::optional<SpectatorList> multiFloor;
+		std::optional<CreatureVector> floor;
+		std::optional<CreatureVector> multiFloor;
 	};
 
 	int32_t minRangeX { 0 };
@@ -48,24 +46,47 @@ class Spectators {
 		requires std::is_base_of_v<Creature, T>
 	Spectators filter();
 
-	bool contains(const std::shared_ptr<Creature> &creature);
-	bool erase(const std::shared_ptr<Creature> &creature);
 	Spectators insert(const std::shared_ptr<Creature> &creature);
-	Spectators insertAll(const SpectatorList &list);
-	Spectators join(Spectators &anotherSpectators);
-	bool empty() const noexcept;
-	size_t size() noexcept;
-	CreatureVector::iterator begin() noexcept;
-	CreatureVector::iterator end() noexcept;
-	const CreatureVector &data() noexcept;
+	Spectators insertAll(const CreatureVector &list);
+	Spectators join(const Spectators &anotherSpectators) {
+		return insertAll(anotherSpectators.creatures);
+	}
+
+	bool contains(const std::shared_ptr<Creature> &creature) const {
+		return std::ranges::find(creatures, creature) != creatures.end();
+	}
+
+	bool erase(const std::shared_ptr<Creature> &creature) {
+		return std::erase(creatures, creature) > 0;
+	}
+
+	bool empty() const noexcept {
+		return creatures.empty();
+	}
+
+	size_t size() const noexcept {
+		return creatures.size();
+	}
+
+	auto begin() const noexcept {
+		return creatures.begin();
+	}
+
+	auto end() const noexcept {
+		return creatures.end();
+	}
+
+	const auto &data() const noexcept {
+		return creatures;
+	}
 
 private:
 	static phmap::flat_hash_map<Position, SpectatorsCache> spectatorsCache;
 
 	Spectators find(const Position &centerPos, bool multifloor = false, bool onlyPlayers = false, int32_t minRangeX = 0, int32_t maxRangeX = 0, int32_t minRangeY = 0, int32_t maxRangeY = 0);
 	bool checkCache(const SpectatorsCache::FloorData &specData, bool onlyPlayers, const Position &centerPos, bool checkDistance, bool multifloor, int32_t minRangeX, int32_t maxRangeX, int32_t minRangeY, int32_t maxRangeY);
 
-	stdext::vector_set<std::shared_ptr<Creature>> creatures;
+	CreatureVector creatures;
 };
 
 template <typename T>