cleanup

src/game/scheduling/dispatcher.cpp

@@ -12,22 +12,23 @@
 #include "game/scheduling/dispatcher.hpp"
 #include "lib/thread/thread_pool.hpp"
 #include "lib/di/container.hpp"
+#include "utils/tools.hpp"
 
 constexpr static auto ASYNC_TIME_OUT = std::chrono::seconds(15);
+constexpr static auto SLEEP_TIME_MS = 15;
 
 Dispatcher &Dispatcher::getInstance() {
 	return inject<Dispatcher>();
 }
 
 void Dispatcher::init() {
-	Task::TIME_NOW = std::chrono::system_clock::now();
+	updateClock();
 
 	threadPool.addLoad([this] {
 		std::unique_lock asyncLock(mutex);
 
 		while (!threadPool.getIoContext().stopped()) {
-			// Current Time Cache
-			Task::TIME_NOW = std::chrono::system_clock::now();
+			updateClock();
 
 			// Execute all asynchronous events separately by context
 			for (uint_fast8_t i = 0; i < static_cast<uint8_t>(AsyncEventContext::Last); ++i) {
@@ -43,12 +44,12 @@ void Dispatcher::init() {
 			// Merge all events that were created by events and scheduled events
 			mergeEvents();
 
-			std::this_thread::sleep_for(std::chrono::milliseconds(15));
+			sleep_for(SLEEP_TIME_MS);
 		}
 	});
 }
 
-void Dispatcher::addEvent(std::function<void(void)> &&f, std::string &&context, uint32_t expiresAfterMs) {
+void Dispatcher::addEvent(std::function<void(void)> &&f, const std::string_view context, uint32_t expiresAfterMs) {
 	threads[getThreadId()].tasks.emplace_back(expiresAfterMs, f, context);
 }
 
@@ -61,8 +62,8 @@ uint64_t Dispatcher::scheduleEvent(const std::shared_ptr<Task> &task) {
 	return scheduledtasksRef.emplace(task->generateId(), task).first->first;
 }
 
-uint64_t Dispatcher::scheduleEvent(uint32_t delay, std::function<void(void)> &&f, std::string &&context, bool cycle) {
-	const auto &task = std::make_shared<Task>(std::move(f), std::move(context), delay, cycle);
+uint64_t Dispatcher::scheduleEvent(uint32_t delay, std::function<void(void)> &&f, const std::string_view context, bool cycle) {
+	const auto &task = std::make_shared<Task>(std::move(f), context, delay, cycle);
 	return scheduleEvent(task);
 }
 
@@ -91,16 +92,15 @@ void Dispatcher::executeAsyncEvents(const uint8_t contextId, std::unique_lock<st
 		return;
 	}
 
-	const size_t sizeEventAsync = asyncTasks.size();
 	std::atomic_uint_fast64_t executedTasks = 0;
 
 	// Execute Async Task
 	for (const auto &task : asyncTasks) {
-		threadPool.addLoad([&] {
+		threadPool.addLoad([this, &task, &executedTasks, totalTaskSize = asyncTasks.size()] {
 			task.execute();
 
 			executedTasks.fetch_add(1);
-			if (executedTasks.load() == sizeEventAsync) {
+			if (executedTasks.load() == totalTaskSize) {
 				asyncTasks_cv.notify_one();
 			}
 		});
@@ -122,9 +122,7 @@ void Dispatcher::executeScheduledEvents() {
 			break;
 		}
 
-		task->execute();
-
-		if (!task->isCanceled() && task->isCycle()) {
+		if (task->execute() && task->isCycle()) {
 			task->updateTime();
 			scheduledtasks.emplace(task);
 		} else {

src/game/scheduling/dispatcher.hpp

@@ -43,15 +43,15 @@ class Dispatcher {
 		asyncTasks_cv.notify_all();
 	}
 
-	void addEvent(std::function<void(void)> &&f, std::string &&context, uint32_t expiresAfterMs = 0);
+	void addEvent(std::function<void(void)> &&f, const std::string_view context, uint32_t expiresAfterMs = 0);
 	void addEvent_async(std::function<void(void)> &&f, AsyncEventContext context = AsyncEventContext::First);
 
 	uint64_t scheduleEvent(const std::shared_ptr<Task> &task);
-	uint64_t scheduleEvent(uint32_t delay, std::function<void(void)> &&f, std::string &&context) {
-		return scheduleEvent(delay, std::move(f), std::move(context), false);
+	uint64_t scheduleEvent(uint32_t delay, std::function<void(void)> &&f, const std::string_view context) {
+		return scheduleEvent(delay, std::move(f), context, false);
 	}
-	uint64_t cycleEvent(uint32_t delay, std::function<void(void)> &&f, std::string &&context) {
-		return scheduleEvent(delay, std::move(f), std::move(context), true);
+	uint64_t cycleEvent(uint32_t delay, std::function<void(void)> &&f, const std::string_view context) {
+		return scheduleEvent(delay, std::move(f), context, true);
 	}
 
 	[[nodiscard]] uint64_t getDispatcherCycle() const {
@@ -61,6 +61,11 @@ class Dispatcher {
 	void stopEvent(uint64_t eventId);
 
 private:
+	// Update Time Cache
+	static void updateClock() {
+		Task::TIME_NOW = std::chrono::system_clock::now();
+	}
+
 	static int16_t getThreadId() {
 		static std::atomic_int16_t lastId = -1;
 		thread_local static int16_t id = -1;
@@ -73,7 +78,7 @@ class Dispatcher {
 		return id;
 	};
 
-	uint64_t scheduleEvent(uint32_t delay, std::function<void(void)> &&f, std::string &&context, bool cycle);
+	uint64_t scheduleEvent(uint32_t delay, std::function<void(void)> &&f, const std::string_view context, bool cycle);
 
 	inline void mergeEvents();
 	inline void executeEvents();

src/game/scheduling/task.hpp

@@ -16,14 +16,14 @@ class Task {
 public:
 	static std::chrono::system_clock::time_point TIME_NOW;
 
-	Task(uint32_t expiresAfterMs, std::function<void(void)> &f, std::string context) :
+	Task(uint32_t expiresAfterMs, std::function<void(void)> &f, const std::string_view context) :
 		expiration(expiresAfterMs > 0 ? TIME_NOW + std::chrono::milliseconds(expiresAfterMs) : SYSTEM_TIME_ZERO),
-		context(std::move(context)), func(std::move(f)) {
+		context(std::string(context)), func(std::move(f)) {
 		assert(!this->context.empty() && "Context cannot be empty!");
 	}
 
-	Task(std::function<void(void)> &&f, std::string context, uint32_t delay, bool cycle = false) :
-		delay(delay), utime(TIME_NOW + std::chrono::milliseconds(delay)), cycle(cycle), context(std::move(context)), func(std::move(f)) {
+	Task(std::function<void(void)> &&f, const std::string_view context, uint32_t delay, bool cycle = false) :
+		cycle(cycle), delay(delay), utime(TIME_NOW + std::chrono::milliseconds(delay)), context(std::string(context)), func(std::move(f)) {
 		assert(!this->context.empty() && "Context cannot be empty!");
 	}
 

src/utils/tools.cpp

@@ -834,7 +834,6 @@ AmmoTypeNames ammoTypeNames = {
 	{ "throwingknife", AMMO_THROWINGKNIFE },
 	{ "diamondarrow", AMMO_ARROW },
 	{ "spectralbolt", AMMO_BOLT },
-
 };
 
 WeaponActionNames weaponActionNames = {
@@ -1795,3 +1794,7 @@ std::string formatNumber(uint64_t number) {
 	}
 	return formattedNumber;
 }
+
+void sleep_for(uint64_t ms) {
+	std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+}

src/utils/tools.hpp

@@ -123,6 +123,7 @@ ItemAttribute_t stringToItemAttribute(const std::string &str);
 
 const char* getReturnMessage(ReturnValue value);
 
+void sleep_for(uint64_t ms);
 void capitalizeWords(std::string &source);
 void consoleHandlerExit();
 std::string validateNameHouse(const std::string &name);