Fix database coalition error for debug builds

src/iologindata.cpp

@@ -85,39 +85,37 @@ bool IOLoginData::loginserverAuthentication(const std::string& name, const std::
 	return true;
 }
 
-std::pair<uint32_t, std::string_view> IOLoginData::gameworldAuthentication(std::string_view accountName, std::string_view password,	std::string_view characterName, std::string_view token, uint32_t tokenTime)
+std::pair<uint32_t, uint32_t> IOLoginData::gameworldAuthentication(std::string_view accountName, std::string_view password,	std::string_view characterName,	std::string_view token, uint32_t tokenTime)
 {
 	Database& db = Database::getInstance();
 
-	DBResult_ptr result = db.storeQuery(fmt::format("SELECT `id`, `password`, `secret` FROM `accounts` WHERE `name` = {:s}", db.escapeString(accountName)));
+	DBResult_ptr result = db.storeQuery(fmt::format(
+		"SELECT `a`.`id` AS `account_id`, `a`.`password`, `a`.`secret`, `p`.`id` AS `character_id` FROM `accounts` `a` JOIN `players` `p` ON `a`.`id` = `p`.`account_id` WHERE (`a`.`name` = {:s} OR `a`.`email` = {:s}) AND `p`.`name` = {:s} AND `p`.`deletion` = 0",
+		db.escapeString(accountName), db.escapeString(accountName), db.escapeString(characterName)));
 	if (!result) {
-		return std::make_pair(0, characterName);
+		return {};
 	}
 
 	std::string secret = decodeSecret(result->getString("secret"));
 	if (!secret.empty()) {
 		if (token.empty()) {
-			return std::make_pair(0, characterName);
+			return {};
 		}
 
 		bool tokenValid = token == generateToken(secret, tokenTime) || token == generateToken(secret, tokenTime - 1) || token == generateToken(secret, tokenTime + 1);
 		if (!tokenValid) {
-			return std::make_pair(0, characterName);
+			return {};
 		}
 	}
 
 	if (transformToSHA1(password) != result->getString("password")) {
-		return std::make_pair(0, characterName);
+		return {};
 	}
 
-	uint32_t accountId = result->getNumber<uint32_t>("id");
+	uint32_t accountId = result->getNumber<uint32_t>("account_id");
+	uint32_t characterId = result->getNumber<uint32_t>("character_id");
 
-	result = db.storeQuery(fmt::format("SELECT `name` FROM `players` WHERE `name` = {:s} AND `account_id` = {:d} AND `deletion` = 0", db.escapeString(characterName), accountId));
-	if (!result) {
-		return std::make_pair(0, characterName);
-	}
-
-	return std::make_pair(accountId, result->getString("name"));
+	return std::make_pair(accountId, characterId);
 }
 
 uint32_t IOLoginData::getAccountIdByPlayerName(const std::string& playerName)
@@ -169,16 +167,16 @@ void IOLoginData::updateOnlineStatus(uint32_t guid, bool login)
 	}
 }
 
-bool IOLoginData::preloadPlayer(Player* player, const std::string& name)
+bool IOLoginData::preloadPlayer(Player* player)
 {
 	Database& db = Database::getInstance();
 
-	DBResult_ptr result = db.storeQuery(fmt::format("SELECT `p`.`id`, `p`.`account_id`, `p`.`group_id`, `a`.`type`, `a`.`premium_ends_at` FROM `players` as `p` JOIN `accounts` as `a` ON `a`.`id` = `p`.`account_id` WHERE `p`.`name` = {:s} AND `p`.`deletion` = 0", db.escapeString(name)));
+	DBResult_ptr result = db.storeQuery(fmt::format("SELECT `p`.`name`, `p`.`account_id`, `p`.`group_id`, `a`.`type`, `a`.`premium_ends_at` FROM `players` AS `p` JOIN `accounts` AS `a` ON `a`.`id` = `p`.`account_id` WHERE `p`.`id` = {:d} AND `p`.`deletion` = 0", player->getGUID()));
 	if (!result) {
 		return false;
 	}
 
-	player->setGUID(result->getNumber<uint32_t>("id"));
+	player->setName(result->getString("name"));
 	Group* group = g_game.groups.getGroup(result->getNumber<uint16_t>("group_id"));
 	if (!group) {
 		std::cout << "[Error - IOLoginData::preloadPlayer] " << player->name << " has Group ID " << result->getNumber<uint16_t>("group_id") << " which doesn't exist." << std::endl;

src/iologindata.h

@@ -16,14 +16,14 @@ class IOLoginData
 		static Account loadAccount(uint32_t accno);
 
 		static bool loginserverAuthentication(const std::string& name, const std::string& password, Account& account);
-		static std::pair<uint32_t, std::string_view> gameworldAuthentication(std::string_view accountName, std::string_view password, std::string_view characterName, std::string_view token, uint32_t tokenTime);
+		static std::pair<uint32_t, uint32_t> gameworldAuthentication(std::string_view accountName, std::string_view password, std::string_view characterName, std::string_view token, uint32_t tokenTime);
 		static uint32_t getAccountIdByPlayerName(const std::string& playerName);
 		static uint32_t getAccountIdByPlayerId(uint32_t playerId);
 
 		static AccountType_t getAccountType(uint32_t accountId);
 		static void setAccountType(uint32_t accountId, AccountType_t accountType);
 		static void updateOnlineStatus(uint32_t guid, bool login);
-		static bool preloadPlayer(Player* player, const std::string& name);
+		static bool preloadPlayer(Player* player);
 
 		static bool loadPlayerById(Player* player, uint32_t id);
 		static bool loadPlayerByName(Player* player, const std::string& name);

src/player.h

@@ -124,8 +124,8 @@ class Player final : public Creature, public Cylinder
 		const std::string& getName() const override {
 			return name;
 		}
-		void setName(const std::string& name) {
-			this->name = name;
+		void setName(std::string_view name) {
+			this->name = name; 
 		}
 		const std::string& getNameDescription() const override {
 			return name;

src/protocolgame.cpp

@@ -124,18 +124,18 @@ void ProtocolGame::release()
 	Protocol::release();
 }
 
-void ProtocolGame::login(const std::string& name, uint32_t accountId, OperatingSystem_t operatingSystem)
+void ProtocolGame::login(uint32_t characterId, uint32_t accountId, OperatingSystem_t operatingSystem)
 {
 	//dispatcher thread
-	Player* foundPlayer = g_game.getPlayerByName(name);
+	Player* foundPlayer = g_game.getPlayerByGUID(characterId);
 	if (!foundPlayer || g_config.getBoolean(ConfigManager::ALLOW_CLONES)) {
 		player = new Player(getThis());
-		player->setName(name);
 
 		player->incrementReferenceCounter();
 		player->setID();
+		player->setGUID(characterId);
 
-		if (!IOLoginData::preloadPlayer(player, name)) {
+		if (!IOLoginData::preloadPlayer(player)) {
 			disconnectClient("Your character could not be loaded.");
 			return;
 		}
@@ -394,14 +394,13 @@ void ProtocolGame::onRecvFirstMessage(NetworkMessage& msg)
 		return;
 	}
 
-	uint32_t accountId;
-	std::tie(accountId, characterName) = IOLoginData::gameworldAuthentication(accountName, password, characterName, token, tokenTime);
+	auto [accountId, characterId] = IOLoginData::gameworldAuthentication(accountName, password, characterName, token, tokenTime);
 	if (accountId == 0) {
 		disconnectClient("Account name or password is not correct.");
 		return;
 	}
 
-	addGameTask([=, thisPtr = getThis(), characterName = std::string{ characterName }]() { thisPtr->login(characterName, accountId, operatingSystem); });
+	g_dispatcher.addTask([=, thisPtr = getThis()]() { thisPtr->login(characterId, accountId, operatingSystem); });
 }
 
 void ProtocolGame::onConnect()

src/protocolgame.h

@@ -50,7 +50,7 @@ class ProtocolGame final : public Protocol
 
 		explicit ProtocolGame(Connection_ptr connection) : Protocol(connection) {}
 
-		void login(const std::string& name, uint32_t accountId, OperatingSystem_t operatingSystem);
+		void login(uint32_t characterId, uint32_t accountId, OperatingSystem_t operatingSystem);
 		void logout(bool displayEffect, bool forced);
 
 		uint16_t getVersion() const {

src/tasks.h

@@ -53,6 +53,10 @@ class Dispatcher : public ThreadHolder<Dispatcher> {
 	public:
 		void addTask(Task* task);
 
+		void addTask(TaskFunc&& f) { addTask(new Task(std::move(f))); }
+
+		void addTask(uint32_t expiration, TaskFunc&& f) { addTask(new Task(expiration, std::move(f))); }
+
 		void shutdown();
 
 		uint64_t getDispatcherCycle() const {