fix some missed things

Split things out to their correct files as well

cmake/FindGoogleTest.cmake

@@ -7,7 +7,6 @@ FetchContent_Declare(
 	GIT_REPOSITORY https://github.com/google/googletest.git
 	GIT_TAG release-1.12.1
 	GIT_PROGRESS TRUE
-	GIT_SHALLOW 1
 )
 
 # For Windows: Prevent overriding the parent project's compiler/linker settings

dAuthServer/AuthServer.cpp

@@ -20,6 +20,7 @@
 
 //Auth includes:
 #include "AuthPackets.h"
+#include "CommonPackets.h"
 #include "ServiceType.h"
 #include "MessageType/Server.h"
 #include "MessageType/Auth.h"
@@ -52,7 +53,6 @@ int main(int argc, char** argv) {
 	//Create all the objects we need to run our service:
 	Server::SetupLogger("AuthServer");
 	if (!Game::logger) return EXIT_FAILURE;
-	Game::config->LogSettings();
 
 	LOG("Starting Auth server...");
 	LOG("Version: %s", PROJECT_VERSION);
@@ -165,17 +165,12 @@ int main(int argc, char** argv) {
 }
 
 void HandlePacket(Packet* packet) {
-	if (packet->length < 4) return;
-
-	if (packet->data[0] == ID_USER_PACKET_ENUM) {
-		if (static_cast<ServiceType>(packet->data[1]) == ServiceType::COMMON) {
-			if (static_cast<MessageType::Server>(packet->data[3]) == MessageType::Server::VERSION_CONFIRM) {
-				AuthPackets::HandleHandshake(Game::server, packet);
-			}
-		} else if (static_cast<ServiceType>(packet->data[1]) == ServiceType::AUTH) {
-			if (static_cast<MessageType::Auth>(packet->data[3]) == MessageType::Auth::LOGIN_REQUEST) {
-				AuthPackets::HandleLoginRequest(Game::server, packet);
-			}
-		}
+	CINSTREAM;
+	LUBitStream luBitStream;
+	if (!luBitStream.ReadHeader(inStream) && luBitStream.rakNetID != ID_USER_PACKET_ENUM) return;
+	else if (luBitStream.serviceType == ServiceType::COMMON) {
+		CommonPackets::Handle(inStream, packet->systemAddress);
+	} else if (luBitStream.serviceType == ServiceType::AUTH) {
+		AuthPackets::Handle(inStream, packet->systemAddress);
 	}
 }

dChatServer/ChatIgnoreList.cpp

@@ -34,7 +34,7 @@ void ChatIgnoreList::GetIgnoreList(Packet* packet) {
 	if (!receiver.ignoredPlayers.empty()) {
 		LOG_DEBUG("Player %llu already has an ignore list, but is requesting it again.", playerId);
 	} else {
-		auto ignoreList = Database::Get()->GetIgnoreList(playerId);
+		auto ignoreList = Database::Get()->GetIgnoreList(static_cast<uint32_t>(playerId));
 		if (ignoreList.empty()) {
 			LOG_DEBUG("Player %llu has no ignores", playerId);
 			return;
@@ -43,6 +43,7 @@ void ChatIgnoreList::GetIgnoreList(Packet* packet) {
 		for (auto& ignoredPlayer : ignoreList) {
 			receiver.ignoredPlayers.emplace_back(ignoredPlayer.name, ignoredPlayer.id);
 			GeneralUtils::SetBit(receiver.ignoredPlayers.back().playerId, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(receiver.ignoredPlayers.back().playerId, eObjectBits::PERSISTENT);
 		}
 	}
 
@@ -113,8 +114,9 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 		}
 
 		if (ignoredPlayerId != LWOOBJID_EMPTY) {
-			Database::Get()->AddIgnore(playerId, ignoredPlayerId);
+			Database::Get()->AddIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(ignoredPlayerId));
 			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::PERSISTENT);
 
 			receiver.ignoredPlayers.emplace_back(toIgnoreStr, ignoredPlayerId);
 			LOG_DEBUG("Player %llu is ignoring %s", playerId, toIgnoreStr.c_str());
@@ -155,7 +157,7 @@ void ChatIgnoreList::RemoveIgnore(Packet* packet) {
 		return;
 	}
 
-	Database::Get()->RemoveIgnore(playerId, toRemove->playerId);
+	Database::Get()->RemoveIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(toRemove->playerId));
 	receiver.ignoredPlayers.erase(toRemove, receiver.ignoredPlayers.end());
 
 	CBITSTREAM;

dChatServer/ChatPacketHandler.cpp

@@ -35,6 +35,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		FriendData fd;
 		fd.isFTP = false; // not a thing in DLU
 		fd.friendID = friendData.friendID;
+		GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
 		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
 
 		fd.isBestFriend = friendData.isBestFriend; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
@@ -160,7 +161,9 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 			// Set the bits
 			GeneralUtils::SetBit(queryPlayerID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(queryPlayerID, eObjectBits::PERSISTENT);
 			GeneralUtils::SetBit(queryFriendID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(queryFriendID, eObjectBits::PERSISTENT);
 
 			// Since this player can either be the friend of someone else or be friends with someone else
 			// their column in the database determines what bit gets set.  When the value hits 3, they
@@ -315,6 +318,7 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 	}
 
 	// Convert friendID to LWOOBJID
+	GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
 	GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);
 
 	Database::Get()->RemoveFriend(playerID, friendID);

dChatServer/ChatServer.cpp

@@ -59,7 +59,6 @@ int main(int argc, char** argv) {
 	//Create all the objects we need to run our service:
 	Server::SetupLogger("ChatServer");
 	if (!Game::logger) return EXIT_FAILURE;
-	Game::config->LogSettings();
 
 	//Read our config:
 

dCommon/CMakeLists.txt

@@ -55,7 +55,6 @@ elseif (WIN32)
 		URL https://github.com/madler/zlib/archive/refs/tags/v1.2.11.zip
 		URL_HASH MD5=9d6a627693163bbbf3f26403a3a0b0b1
 		GIT_PROGRESS TRUE
-		GIT_SHALLOW 1
 	)
 
 	# Disable warning about no project version.

dCommon/dConfig.cpp

@@ -47,8 +47,6 @@ void dConfig::LoadConfig() {
 void dConfig::ReloadConfig() {
 	this->m_ConfigValues.clear();
 	LoadConfig();
-	for (const auto& handler : m_ConfigHandlers) handler();
-	LogSettings();
 }
 
 const std::string& dConfig::GetValue(std::string key) {
@@ -60,18 +58,6 @@ const std::string& dConfig::GetValue(std::string key) {
 	return this->m_ConfigValues[key];
 }
 
-void dConfig::AddConfigHandler(std::function<void()> handler) {
-	m_ConfigHandlers.push_back(handler);
-}
-
-void dConfig::LogSettings() const {
-	LOG("Configuration settings:");
-	for (const auto& [key, value] : m_ConfigValues) {
-		const auto& valueLog = key.find("password") != std::string::npos ? "<HIDDEN>" : value;
-		LOG("  %s = %s", key.c_str(), valueLog.c_str());
-	}
-}
-
 void dConfig::ProcessLine(const std::string& line) {
 	auto splitLoc = line.find('=');
 	auto key = line.substr(0, splitLoc);

dCommon/dConfig.h

@@ -1,7 +1,5 @@
 #pragma once
-
 #include <fstream>
-#include <functional>
 #include <map>
 #include <string>
 
@@ -31,15 +29,10 @@ public:
 	 * Reloads the config file to reset values
 	 */
 	void ReloadConfig();
-
-	// Adds a function to be called when the config is (re)loaded
-	void AddConfigHandler(std::function<void()> handler);
-	void LogSettings() const;
-
 private:
 	void ProcessLine(const std::string& line);
 
+private:
 	std::map<std::string, std::string> m_ConfigValues;
-	std::vector<std::function<void()>> m_ConfigHandlers;
 	std::string m_ConfigFilePath;
 };

dCommon/dEnums/MessageType/Master.h

@@ -3,7 +3,9 @@
 
 namespace MessageType {
 	enum class Master : uint32_t {
-		REQUEST_ZONE_TRANSFER = 1,
+		REQUEST_PERSISTENT_ID = 1,
+		REQUEST_PERSISTENT_ID_RESPONSE,
+		REQUEST_ZONE_TRANSFER,
 		REQUEST_ZONE_TRANSFER_RESPONSE,
 		SERVER_INFO,
 		REQUEST_SESSION_KEY,

dCommon/dEnums/eCharacterVersion.h

@@ -18,9 +18,7 @@ enum class eCharacterVersion : uint32_t {
 	SPEED_BASE,
 	// Fixes nexus force explorer missions
 	NJ_JAYMISSIONS,
-	NEXUS_FORCE_EXPLORER, // Fixes pet ids in player inventories
-	PET_IDS, // Fixes pet ids in player inventories
-	UP_TO_DATE, // will become INVENTORY_PERSISTENT_IDS
+	UP_TO_DATE, // will become NEXUS_FORCE_EXPLORER
 };
 
 #endif  //!__ECHARACTERVERSION__H__

dCommon/dEnums/eLoginResponse.h

@@ -1,24 +0,0 @@
-#ifndef __ELOGINRESPONSE__H__
-#define __ELOGINRESPONSE__H__
-
-#include <cstdint>
-
-enum class eLoginResponse : uint8_t {
-	GENERAL_FAILED = 0,
-	SUCCESS,
-	BANNED,
-	// Unused 3
-	// Unused 4
-	PERMISSIONS_NOT_HIGH_ENOUGH = 5,
-	INVALID_USER,
-	ACCOUNT_LOCKED,
-	WRONG_PASS,
-	ACCOUNT_ACTIVATION_PENDING,
-	ACCOUNT_DISABLED,
-	GAME_TIME_EXPIRED,
-	FREE_TRIAL_ENDED,
-	PLAY_SCHEDULE_TIME_UP,
-	ACCOUNT_NOT_ACTIVATED
-};
-
-#endif  //!__ELOGINRESPONSE__H__

dCommon/dEnums/eObjectBits.h

@@ -1,12 +1,13 @@
-#ifndef EOBJECTBITS_H
-#define EOBJECTBITS_H
+#ifndef __EOBJECTBITS__H__
+#define __EOBJECTBITS__H__
 
 #include <cstdint>
 
 enum class eObjectBits : size_t {
+	PERSISTENT = 32,
 	CLIENT = 46,
 	SPAWNED = 58,
 	CHARACTER = 60
 };
 
-#endif  //!EOBJECTBITS_H
+#endif  //!__EOBJECTBITS__H__

dCommon/dEnums/eServerDisconnectIdentifiers.h

@@ -1,24 +0,0 @@
-#ifndef __ESERVERDISCONNECTIDENTIFIERS__H__
-#define __ESERVERDISCONNECTIDENTIFIERS__H__
-
-#include <cstdint>
-
-enum class eServerDisconnectIdentifiers : uint32_t {
-	UNKNOWN_SERVER_ERROR = 0,
-	WRONG_GAME_VERSION,
-	WRONG_SERVER_VERSION,
-	CONNECTION_ON_INVALID_PORT,
-	DUPLICATE_LOGIN,
-	SERVER_SHUTDOWN,
-	SERVER_MAP_LOAD_FAILURE,
-	INVALID_SESSION_KEY,
-	ACCOUNT_NOT_IN_PENDING_LIST,
-	CHARACTER_NOT_FOUND,
-	CHARACTER_CORRUPTED,
-	KICK,
-	SAVE_FAILURE,
-	FREE_TRIAL_EXPIRED,
-	PLAY_SCHEDULE_TIME_DONE
-};
-
-#endif  //!__ESERVERDISCONNECTIDENTIFIERS__H__

dDatabase/GameDatabase/GameDatabase.h

@@ -48,7 +48,7 @@ public:
 	virtual void Commit() = 0;
 	virtual bool GetAutoCommit() = 0;
 	virtual void SetAutoCommit(bool value) = 0;
-	virtual void DeleteCharacter(const LWOOBJID characterId) = 0;
+	virtual void DeleteCharacter(const uint32_t characterId) = 0;
 };
 
 #endif  //!__GAMEDATABASE__H__

dDatabase/GameDatabase/ITables/IActivityLog.h

@@ -14,7 +14,7 @@ enum class eActivityType : uint32_t {
 class IActivityLog {
 public:
 	// Update the activity log for the given account.
-	virtual void UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) = 0;
+	virtual void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) = 0;
 };
 
 #endif  //!__IACTIVITYLOG__H__

dDatabase/GameDatabase/ITables/IBehaviors.h

@@ -9,7 +9,7 @@ class IBehaviors {
 public:
 	struct Info {
 		LWOOBJID behaviorId{};
-		LWOOBJID characterId{};
+		uint32_t characterId{};
 		std::string behaviorInfo;
 	};
 

dDatabase/GameDatabase/ITables/IBugReports.h

@@ -11,7 +11,7 @@ public:
 		std::string clientVersion;
 		std::string otherPlayer;
 		std::string selection;
-		LWOOBJID characterId{};
+		uint32_t characterId{};
 	};
 
 	// Add a new bug report to the database.

dDatabase/GameDatabase/ITables/ICharInfo.h

@@ -14,7 +14,7 @@ public:
 	struct Info {
 		std::string name;
 		std::string pendingName;
-		LWOOBJID id{};
+		uint32_t id{};
 		uint32_t accountId{};
 		bool needsRename{};
 		LWOCLONEID cloneId{};
@@ -25,25 +25,25 @@ public:
 	virtual std::vector<std::string> GetApprovedCharacterNames() = 0;
 
 	// Get the character info for the given character id.
-	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) = 0;
+	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) = 0;
 
 	// Get the character info for the given character name.
 	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view name) = 0;
 	
 	// Get the character ids for the given account.
-	virtual std::vector<LWOOBJID> GetAccountCharacterIds(const LWOOBJID accountId) = 0;
+	virtual std::vector<uint32_t> GetAccountCharacterIds(const uint32_t accountId) = 0;
 
 	// Insert a new character into the database.
 	virtual void InsertNewCharacter(const ICharInfo::Info info) = 0;
 
 	// Set the name of the given character.
-	virtual void SetCharacterName(const LWOOBJID characterId, const std::string_view name) = 0;
+	virtual void SetCharacterName(const uint32_t characterId, const std::string_view name) = 0;
 
 	// Set the pending name of the given character.
-	virtual void SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) = 0;
+	virtual void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) = 0;
 
 	// Updates the given character ids last login to be right now.
-	virtual void UpdateLastLoggedInCharacter(const LWOOBJID characterId) = 0;
+	virtual void UpdateLastLoggedInCharacter(const uint32_t characterId) = 0;
 
 	virtual bool IsNameInUse(const std::string_view name) = 0;
 };

dDatabase/GameDatabase/ITables/ICharXml.h

@@ -8,13 +8,13 @@
 class ICharXml {
 public:
 	// Get the character xml for the given character id.
-	virtual std::string GetCharacterXml(const LWOOBJID charId) = 0;
+	virtual std::string GetCharacterXml(const uint32_t charId) = 0;
 
 	// Update the character xml for the given character id.
-	virtual void UpdateCharacterXml(const LWOOBJID charId, const std::string_view lxfml) = 0;
+	virtual void UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) = 0;
 
 	// Insert the character xml for the given character id.
-	virtual void InsertCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) = 0;
+	virtual void InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) = 0;
 };
 
 #endif  //!__ICHARXML__H__

dDatabase/GameDatabase/ITables/ICommandLog.h

@@ -8,7 +8,7 @@ class ICommandLog {
 public:	
 
 	// Insert a new slash command log entry.
-	virtual void InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) = 0;
+	virtual void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) = 0;
 };
 
 #endif  //!__ICOMMANDLOG__H__

dDatabase/GameDatabase/ITables/IFriends.h

@@ -8,25 +8,25 @@
 class IFriends {
 public:
 	struct BestFriendStatus {
-		LWOOBJID playerCharacterId{};
-		LWOOBJID friendCharacterId{};
+		uint32_t playerCharacterId{};
+		uint32_t friendCharacterId{};
 		uint32_t bestFriendStatus{};
 	};
 
 	// Get the friends list for the given character id.
-	virtual std::vector<FriendData> GetFriendsList(const LWOOBJID charId) = 0;
+	virtual std::vector<FriendData> GetFriendsList(const uint32_t charId) = 0;
 
 	// Get the best friend status for the given player and friend character ids.
-	virtual std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) = 0;
+	virtual std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
 
 	// Set the best friend status for the given player and friend character ids.
-	virtual void SetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId, const uint32_t bestFriendStatus) = 0;
+	virtual void SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) = 0;
 
 	// Add a friend to the given character id.
-	virtual void AddFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) = 0;
+	virtual void AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
 
 	// Remove a friend from the given character id.
-	virtual void RemoveFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) = 0;
+	virtual void RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
 };
 
 #endif  //!__IFRIENDS__H__

dDatabase/GameDatabase/ITables/IIgnoreList.h

@@ -9,12 +9,12 @@ class IIgnoreList {
 public:
 	struct Info {
 		std::string name;
-		LWOOBJID id;
+		uint32_t id;
 	};
 
-	virtual std::vector<Info> GetIgnoreList(const LWOOBJID playerId) = 0;
-	virtual void AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) = 0;
-	virtual void RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) = 0;
+	virtual std::vector<Info> GetIgnoreList(const uint32_t playerId) = 0;
+	virtual void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) = 0;
+	virtual void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) = 0;
 };
 
 #endif  //!__IIGNORELIST__H__

dDatabase/GameDatabase/ITables/ILeaderboard.h

@@ -5,13 +5,12 @@
 #include <optional>
 #include <string>
 #include <vector>
-#include "dCommonVars.h"
 
 class ILeaderboard {
 public:
 
 	struct Entry {
-		LWOOBJID charId{};
+		uint32_t charId{};
 		uint32_t lastPlayedTimestamp{};
 		float primaryScore{};
 		float secondaryScore{};
@@ -37,12 +36,12 @@ public:
 	virtual std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) = 0;
 	virtual std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) = 0;
 	virtual std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) = 0;
-	virtual std::optional<Score> GetPlayerScore(const LWOOBJID playerId, const uint32_t gameId) = 0;
+	virtual std::optional<Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) = 0;
 
-	virtual void SaveScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) = 0;
-	virtual void UpdateScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) = 0;
-	virtual void IncrementNumWins(const LWOOBJID playerId, const uint32_t gameId) = 0;
-	virtual void IncrementTimesPlayed(const LWOOBJID playerId, const uint32_t gameId) = 0;
+	virtual void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) = 0;
+	virtual void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) = 0;
+	virtual void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) = 0;
+	virtual void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) = 0;
 };
 
 #endif  //!__ILEADERBOARD__H__

dDatabase/GameDatabase/ITables/IMail.h

@@ -16,13 +16,13 @@ public:
 	virtual void InsertNewMail(const MailInfo& mail) = 0;
 
 	// Get the mail for the given character id.
-	virtual std::vector<MailInfo> GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) = 0;
+	virtual std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) = 0;
 
 	// Get the mail for the given mail id.
 	virtual std::optional<MailInfo> GetMail(const uint64_t mailId) = 0;
 
 	// Get the number of unread mail for the given character id.
-	virtual uint32_t GetUnreadMailCount(const LWOOBJID characterId) = 0;
+	virtual uint32_t GetUnreadMailCount(const uint32_t characterId) = 0;
 
 	// Mark the given mail as read.
 	virtual void MarkMailRead(const uint64_t mailId) = 0;

dDatabase/GameDatabase/ITables/IObjectIdTracker.h

@@ -6,19 +6,14 @@
 
 class IObjectIdTracker {
 public:
-	// Only the first 48 bits of the ids are the id, the last 16 bits are reserved for flags.
-	struct Range {
-		uint64_t minID{}; // Only the first 48 bits are the id, the last 16 bits are reserved for flags.
-		uint64_t maxID{}; // Only the first 48 bits are the id, the last 16 bits are reserved for flags.
-	};
-
 	// Get the current persistent id.
-	virtual std::optional<uint64_t> GetCurrentPersistentId() = 0;
+	virtual std::optional<uint32_t> GetCurrentPersistentId() = 0;
 
 	// Insert the default persistent id.
 	virtual void InsertDefaultPersistentId() = 0;
 
-	virtual Range GetPersistentIdRange() = 0;
+	// Update the persistent id.
+	virtual void UpdatePersistentId(const uint32_t newId) = 0;
 };
 
 #endif  //!__IOBJECTIDTRACKER__H__

dDatabase/GameDatabase/ITables/IProperty.h

@@ -13,7 +13,7 @@ public:
 		std::string description;
 		std::string rejectionReason;
 		LWOOBJID id{};
-		LWOOBJID ownerId{};
+		uint32_t ownerId{};
 		LWOCLONEID cloneId{};
 		int32_t privacyOption{};
 		uint32_t modApproved{};
@@ -27,7 +27,7 @@ public:
 		uint32_t mapId{};
 		std::string searchString;
 		ePropertySortType sortChoice{};
-		LWOOBJID playerId{};
+		uint32_t playerId{};
 		uint32_t numResults{};
 		uint32_t startIndex{};
 		uint32_t playerSort{};
@@ -39,9 +39,6 @@ public:
 		std::vector<IProperty::Info> entries;
 	};
 
-	// Get the property info for the given property id.
-	virtual std::optional<IProperty::Info> GetPropertyInfo(const LWOOBJID id) = 0;
-
 	// Get the property info for the given property id.
 	virtual std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) = 0;
 

dDatabase/GameDatabase/ITables/IPropertyContents.h

@@ -16,16 +16,16 @@ public:
 		NiQuaternion rotation = QuatUtils::IDENTITY;
 		LWOOBJID id{};
 		LOT lot{};
-		LWOOBJID ugcId{};
+		uint32_t ugcId{};
 		std::array<LWOOBJID, 5> behaviors{};
 	};
 
 	// Inserts a new UGC model into the database.
 	virtual void InsertNewUgcModel(
 		std::stringstream& sd0Data,
-		const uint64_t blueprintId,
+		const uint32_t blueprintId,
 		const uint32_t accountId,
-		const LWOOBJID characterId) = 0;
+		const uint32_t characterId) = 0;
 
 	// Get the property models for the given property id.
 	virtual std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) = 0;
@@ -45,6 +45,6 @@ public:
 	virtual void RemoveModel(const LWOOBJID& modelId) = 0;
 
 	// Gets a model by ID
-	virtual std::optional<Model> GetModel(const LWOOBJID modelID) = 0;
+	virtual Model GetModel(const LWOOBJID modelID) = 0;
 };
 #endif  //!__IPROPERTIESCONTENTS__H__

dDatabase/GameDatabase/ITables/IUgc.h

@@ -29,7 +29,5 @@ public:
 
 	// Inserts a new UGC model into the database.
 	virtual void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) = 0;
-
-	virtual std::optional<IUgc::Model> GetUgcModel(const LWOOBJID ugcId) = 0;
 };
 #endif  //!__IUGC__H__

dDatabase/GameDatabase/ITables/IUgcModularBuild.h

@@ -7,7 +7,7 @@
 
 class IUgcModularBuild {
 public:
-	virtual void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) = 0;
+	virtual void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) = 0;
 	virtual void DeleteUgcBuild(const LWOOBJID bigId) = 0;
 };
 

dDatabase/GameDatabase/MySQL/MySQLDatabase.cpp

@@ -100,7 +100,7 @@ void MySQLDatabase::SetAutoCommit(bool value) {
 	con->setAutoCommit(value);
 }
 
-void MySQLDatabase::DeleteCharacter(const LWOOBJID characterId) {
+void MySQLDatabase::DeleteCharacter(const uint32_t characterId) {
 	ExecuteDelete("DELETE FROM charxml WHERE id=? LIMIT 1;", characterId);
 	ExecuteDelete("DELETE FROM command_log WHERE character_id=?;", characterId);
 	ExecuteDelete("DELETE FROM friends WHERE player_id=? OR friend_id=?;", characterId, characterId);

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -40,31 +40,31 @@ public:
 
 	std::vector<std::string> GetApprovedCharacterNames() override;
 
-	std::vector<FriendData> GetFriendsList(LWOOBJID charID) override;
+	std::vector<FriendData> GetFriendsList(uint32_t charID) override;
 
-	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) override;
-	void SetBestFriendStatus(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId, const uint32_t bestFriendStatus) override;
-	void AddFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) override;
-	void RemoveFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) override;
-	void UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) override;
+	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) override;
+	void SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) override;
+	void AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
 	void DeleteUgcModelData(const LWOOBJID& modelId) override;
 	void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) override;
 	std::vector<IUgc::Model> GetAllUgcModels() override;
 	void CreateMigrationHistoryTable() override;
 	bool IsMigrationRun(const std::string_view str) override;
 	void InsertMigration(const std::string_view str) override;
-	std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) override;
 	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
-	std::string GetCharacterXml(const LWOOBJID accountId) override;
-	void UpdateCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) override;
+	std::string GetCharacterXml(const uint32_t accountId) override;
+	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
 	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
 	void InsertNewCharacter(const ICharInfo::Info info) override;
-	void InsertCharacterXml(const LWOOBJID accountId, const std::string_view lxfml) override;
-	std::vector<LWOOBJID> GetAccountCharacterIds(LWOOBJID accountId) override;
-	void DeleteCharacter(const LWOOBJID characterId) override;
-	void SetCharacterName(const LWOOBJID characterId, const std::string_view name) override;
-	void SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) override;
-	void UpdateLastLoggedInCharacter(const LWOOBJID characterId) override;
+	void InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) override;
+	std::vector<uint32_t> GetAccountCharacterIds(uint32_t accountId) override;
+	void DeleteCharacter(const uint32_t characterId) override;
+	void SetCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void UpdateLastLoggedInCharacter(const uint32_t characterId) override;
 	void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) override;
 	std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) override;
 	std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) override;
@@ -83,30 +83,30 @@ public:
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
 		std::stringstream& sd0Data,
-		const uint64_t blueprintId,
+		const uint32_t blueprintId,
 		const uint32_t accountId,
-		const LWOOBJID characterId) override;
-	std::vector<MailInfo> GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) override;
+		const uint32_t characterId) override;
+	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
 	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
-	uint32_t GetUnreadMailCount(const LWOOBJID characterId) override;
+	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
 	void MarkMailRead(const uint64_t mailId) override;
 	void DeleteMail(const uint64_t mailId) override;
 	void ClaimMailItem(const uint64_t mailId) override;
-	void InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) override;
+	void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) override;
 	void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) override;
 	void UpdateAccountBan(const uint32_t accountId, const bool banned) override;
 	void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) override;
 	void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) override;
 	void SetMasterInfo(const IServers::MasterInfo& info) override;
-	std::optional<uint64_t> GetCurrentPersistentId() override;
-	IObjectIdTracker::Range GetPersistentIdRange() override;
+	std::optional<uint32_t> GetCurrentPersistentId() override;
 	void InsertDefaultPersistentId() override;
+	void UpdatePersistentId(const uint32_t id) override;
 	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
 	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
 	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
-	void AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
-	void RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
-	std::vector<IIgnoreList::Info> GetIgnoreList(const LWOOBJID playerId) override;
+	void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
 	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
 	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
 	void AddBehavior(const IBehaviors::Info& info) override;
@@ -118,18 +118,16 @@ public:
 	std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) override;
 	std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) override;
 	std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) override;
-	void SaveScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) override;
-	void UpdateScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) override;
-	std::optional<ILeaderboard::Score> GetPlayerScore(const LWOOBJID playerId, const uint32_t gameId) override;
-	void IncrementNumWins(const LWOOBJID playerId, const uint32_t gameId) override;
-	void IncrementTimesPlayed(const LWOOBJID playerId, const uint32_t gameId) override;
-	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) override;
+	void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
+	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
 	bool IsNameInUse(const std::string_view name) override;
-	std::optional<IPropertyContents::Model> GetModel(const LWOOBJID modelID) override;
-	std::optional<IUgc::Model> GetUgcModel(const LWOOBJID ugcId) override;
-	std::optional<IProperty::Info> GetPropertyInfo(const LWOOBJID id) override;
+	IPropertyContents::Model GetModel(const LWOOBJID modelID) override;
 	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
 private:
 
@@ -170,91 +168,91 @@ private:
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string_view param) {
-	LOG_DEBUG("%s", param.data());
+	// LOG("%s", param.data());
 	stmt->setString(index, param.data());
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const char* param) {
-	LOG_DEBUG("%s", param);
+	// LOG("%s", param);
 	stmt->setString(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string param) {
-	LOG_DEBUG("%s", param.c_str());
+	// LOG("%s", param.c_str());
 	stmt->setString(index, param.c_str());
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int8_t param) {
-	LOG_DEBUG("%u", param);
+	// LOG("%u", param);
 	stmt->setByte(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint8_t param) {
-	LOG_DEBUG("%d", param);
+	// LOG("%d", param);
 	stmt->setByte(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int16_t param) {
-	LOG_DEBUG("%u", param);
+	// LOG("%u", param);
 	stmt->setShort(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint16_t param) {
-	LOG_DEBUG("%d", param);
+	// LOG("%d", param);
 	stmt->setShort(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint32_t param) {
-	LOG_DEBUG("%u", param);
+	// LOG("%u", param);
 	stmt->setUInt(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int32_t param) {
-	LOG_DEBUG("%d", param);
+	// LOG("%d", param);
 	stmt->setInt(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int64_t param) {
-	LOG_DEBUG("%llu", param);
+	// LOG("%llu", param);
 	stmt->setInt64(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint64_t param) {
-	LOG_DEBUG("%llu", param);
+	// LOG("%llu", param);
 	stmt->setUInt64(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const float param) {
-	LOG_DEBUG("%f", param);
+	// LOG("%f", param);
 	stmt->setFloat(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const double param) {
-	LOG_DEBUG("%f", param);
+	// LOG("%f", param);
 	stmt->setDouble(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const bool param) {
-	LOG_DEBUG("%s", param ? "true" : "false");
+	// LOG("%d", param);
 	stmt->setBoolean(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::istream* param) {
-	LOG_DEBUG("Blob");
+	// LOG("Blob");
 	// This is the one time you will ever see me use const_cast.
 	stmt->setBlob(index, const_cast<std::istream*>(param));
 }
@@ -262,21 +260,10 @@ inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::istr
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::optional<uint32_t> param) {
 	if (param) {
-		LOG_DEBUG("%d", param.value());
+		// LOG("%d", param.value());
 		stmt->setInt(index, param.value());
 	} else {
-		LOG_DEBUG("Null");
-		stmt->setNull(index, sql::DataType::SQLNULL);
-	}
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::optional<LWOOBJID> param) {
-	if (param) {
-		LOG_DEBUG("%d", param.value());
-		stmt->setInt64(index, param.value());
-	} else {
-		LOG_DEBUG("Null");
+		// LOG("Null");
 		stmt->setNull(index, sql::DataType::SQLNULL);
 	}
 }

dDatabase/GameDatabase/MySQL/Tables/ActivityLog.cpp

@@ -1,6 +1,6 @@
 #include "MySQLDatabase.h"
 
-void MySQLDatabase::UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) {
+void MySQLDatabase::UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
 	ExecuteInsert("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);",
 		characterId, static_cast<uint32_t>(activityType), static_cast<uint32_t>(time(NULL)), mapId);
 }

dDatabase/GameDatabase/MySQL/Tables/CharInfo.cpp

@@ -19,7 +19,7 @@ std::optional<ICharInfo::Info> CharInfoFromQueryResult(std::unique_ptr<sql::Resu
 
 	ICharInfo::Info toReturn;
 
-	toReturn.id = stmt->getInt64("id");
+	toReturn.id = stmt->getUInt("id");
 	toReturn.name = stmt->getString("name").c_str();
 	toReturn.pendingName = stmt->getString("pending_name").c_str();
 	toReturn.needsRename = stmt->getBoolean("needs_rename");
@@ -30,7 +30,7 @@ std::optional<ICharInfo::Info> CharInfoFromQueryResult(std::unique_ptr<sql::Resu
 	return toReturn;
 }
 
-std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const LWOOBJID charId) {
+std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const uint32_t charId) {
 	return CharInfoFromQueryResult(
 		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE id = ? LIMIT 1;", charId)
 	);
@@ -42,13 +42,13 @@ std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const std::string
 	);
 }
 
-std::vector<LWOOBJID> MySQLDatabase::GetAccountCharacterIds(const LWOOBJID accountId) {
+std::vector<uint32_t> MySQLDatabase::GetAccountCharacterIds(const uint32_t accountId) {
 	auto result = ExecuteSelect("SELECT id FROM charinfo WHERE account_id = ? ORDER BY last_login DESC LIMIT 4;", accountId);
 
-	std::vector<LWOOBJID> toReturn;
+	std::vector<uint32_t> toReturn;
 	toReturn.reserve(result->rowsCount());
 	while (result->next()) {
-		toReturn.push_back(result->getInt64("id"));
+		toReturn.push_back(result->getUInt("id"));
 	}
 
 	return toReturn;
@@ -65,15 +65,15 @@ void MySQLDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 		static_cast<uint32_t>(time(NULL)));
 }
 
-void MySQLDatabase::SetCharacterName(const LWOOBJID characterId, const std::string_view name) {
+void MySQLDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
 	ExecuteUpdate("UPDATE charinfo SET name = ?, pending_name = '', needs_rename = 0, last_login = ? WHERE id = ? LIMIT 1;", name, static_cast<uint32_t>(time(NULL)), characterId);
 }
 
-void MySQLDatabase::SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) {
+void MySQLDatabase::SetPendingCharacterName(const uint32_t characterId, const std::string_view name) {
 	ExecuteUpdate("UPDATE charinfo SET pending_name = ?, needs_rename = 0, last_login = ? WHERE id = ? LIMIT 1", name, static_cast<uint32_t>(time(NULL)), characterId);
 }
 
-void MySQLDatabase::UpdateLastLoggedInCharacter(const LWOOBJID characterId) {
+void MySQLDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
 	ExecuteUpdate("UPDATE charinfo SET last_login = ? WHERE id = ? LIMIT 1", static_cast<uint32_t>(time(NULL)), characterId);
 }
 

dDatabase/GameDatabase/MySQL/Tables/CharXml.cpp

@@ -1,6 +1,6 @@
 #include "MySQLDatabase.h"
 
-std::string MySQLDatabase::GetCharacterXml(const LWOOBJID charId) {
+std::string MySQLDatabase::GetCharacterXml(const uint32_t charId) {
 	auto result = ExecuteSelect("SELECT xml_data FROM charxml WHERE id = ? LIMIT 1;", charId);
 
 	if (!result->next()) {
@@ -10,10 +10,10 @@ std::string MySQLDatabase::GetCharacterXml(const LWOOBJID charId) {
 	return result->getString("xml_data").c_str();
 }
 
-void MySQLDatabase::UpdateCharacterXml(const LWOOBJID charId, const std::string_view lxfml) {
+void MySQLDatabase::UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) {
 	ExecuteUpdate("UPDATE charxml SET xml_data = ? WHERE id = ?;", lxfml, charId);
 }
 
-void MySQLDatabase::InsertCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) {
+void MySQLDatabase::InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
 	ExecuteInsert("INSERT INTO `charxml` (`id`, `xml_data`) VALUES (?,?)", characterId, lxfml);
 }

dDatabase/GameDatabase/MySQL/Tables/CommandLog.cpp

@@ -1,5 +1,5 @@
 #include "MySQLDatabase.h"
 
-void MySQLDatabase::InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) {
+void MySQLDatabase::InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) {
 	ExecuteInsert("INSERT INTO command_log (character_id, command) VALUES (?, ?);", characterId, command);
 }

dDatabase/GameDatabase/MySQL/Tables/Friends.cpp

@@ -1,6 +1,6 @@
 #include "MySQLDatabase.h"
 
-std::vector<FriendData> MySQLDatabase::GetFriendsList(const LWOOBJID charId) {
+std::vector<FriendData> MySQLDatabase::GetFriendsList(const uint32_t charId) {
 	auto friendsList = ExecuteSelect(
 		R"QUERY(
 			SELECT fr.requested_player AS player, best_friend AS bff, ci.name AS name FROM 
@@ -19,7 +19,7 @@ std::vector<FriendData> MySQLDatabase::GetFriendsList(const LWOOBJID charId) {
 
 	while (friendsList->next()) {
 		FriendData fd;
-		fd.friendID = friendsList->getUInt64("player");
+		fd.friendID = friendsList->getUInt("player");
 		fd.isBestFriend = friendsList->getInt("bff") == 3; // 0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
 		fd.friendName = friendsList->getString("name").c_str();
 
@@ -29,7 +29,7 @@ std::vector<FriendData> MySQLDatabase::GetFriendsList(const LWOOBJID charId) {
 	return toReturn;
 }
 
-std::optional<IFriends::BestFriendStatus> MySQLDatabase::GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
+std::optional<IFriends::BestFriendStatus> MySQLDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
 	auto result = ExecuteSelect("SELECT * FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
 		playerCharacterId,
 		friendCharacterId,
@@ -42,14 +42,14 @@ std::optional<IFriends::BestFriendStatus> MySQLDatabase::GetBestFriendStatus(con
 	}
 
 	IFriends::BestFriendStatus toReturn;
-	toReturn.playerCharacterId = result->getUInt64("player_id");
-	toReturn.friendCharacterId = result->getUInt64("friend_id");
+	toReturn.playerCharacterId = result->getUInt("player_id");
+	toReturn.friendCharacterId = result->getUInt("friend_id");
 	toReturn.bestFriendStatus = result->getUInt("best_friend");
 
 	return toReturn;
 }
 
-void MySQLDatabase::SetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId, const uint32_t bestFriendStatus) {
+void MySQLDatabase::SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) {
 	ExecuteUpdate("UPDATE friends SET best_friend = ? WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
 		bestFriendStatus,
 		playerCharacterId,
@@ -59,11 +59,11 @@ void MySQLDatabase::SetBestFriendStatus(const LWOOBJID playerCharacterId, const
 	);
 }
 
-void MySQLDatabase::AddFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
+void MySQLDatabase::AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
 	ExecuteInsert("INSERT IGNORE INTO friends (player_id, friend_id, best_friend) VALUES (?, ?, 0);", playerCharacterId, friendCharacterId);
 }
 
-void MySQLDatabase::RemoveFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
+void MySQLDatabase::RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
 	ExecuteDelete("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
 		playerCharacterId,
 		friendCharacterId,

dDatabase/GameDatabase/MySQL/Tables/IgnoreList.cpp

@@ -1,22 +1,22 @@
 #include "MySQLDatabase.h"
 
-std::vector<IIgnoreList::Info> MySQLDatabase::GetIgnoreList(const LWOOBJID playerId) {
+std::vector<IIgnoreList::Info> MySQLDatabase::GetIgnoreList(const uint32_t playerId) {
 	auto result = ExecuteSelect("SELECT ci.name AS name, il.ignored_player_id AS ignore_id FROM ignore_list AS il JOIN charinfo AS ci ON il.ignored_player_id = ci.id WHERE il.player_id = ?", playerId);
 
 	std::vector<IIgnoreList::Info> ignoreList;
 
 	ignoreList.reserve(result->rowsCount());
 	while (result->next()) {
-		ignoreList.push_back(IIgnoreList::Info{ result->getString("name").c_str(), result->getInt64("ignore_id") });
+		ignoreList.push_back(IIgnoreList::Info{ result->getString("name").c_str(), result->getUInt("ignore_id") });
 	}
 
 	return ignoreList;
 }
 
-void MySQLDatabase::AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
+void MySQLDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
 	ExecuteInsert("INSERT IGNORE INTO ignore_list (player_id, ignored_player_id) VALUES (?, ?)", playerId, ignoredPlayerId);
 }
 
-void MySQLDatabase::RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
+void MySQLDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
 	ExecuteDelete("DELETE FROM ignore_list WHERE player_id = ? AND ignored_player_id = ?", playerId, ignoredPlayerId);
 }

dDatabase/GameDatabase/MySQL/Tables/Leaderboard.cpp

@@ -21,7 +21,7 @@ std::vector<ILeaderboard::Entry> ProcessQuery(UniqueResultSet& rows) {
 	while (rows->next()) {
 		auto& entry = entries.emplace_back();
 
-		entry.charId = rows->getUInt64("character_id");
+		entry.charId = rows->getUInt("character_id");
 		entry.lastPlayedTimestamp = rows->getUInt("lp_unix");
 		entry.primaryScore = rows->getFloat("primaryScore");
 		entry.secondaryScore = rows->getFloat("secondaryScore");
@@ -58,21 +58,21 @@ std::vector<ILeaderboard::Entry> MySQLDatabase::GetNsLeaderboard(const uint32_t
 	return ProcessQuery(leaderboard);
 }
 
-void MySQLDatabase::SaveScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) {
+void MySQLDatabase::SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
 	ExecuteInsert("INSERT leaderboard SET primaryScore = ?, secondaryScore = ?, tertiaryScore = ?, character_id = ?, game_id = ?;",
 		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
 }
 
-void MySQLDatabase::UpdateScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) {
+void MySQLDatabase::UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
 	ExecuteInsert("UPDATE leaderboard SET primaryScore = ?, secondaryScore = ?, tertiaryScore = ?, timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;",
 		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
 }
 
-void MySQLDatabase::IncrementTimesPlayed(const LWOOBJID playerId, const uint32_t gameId) {
+void MySQLDatabase::IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) {
 	ExecuteUpdate("UPDATE leaderboard SET timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;", playerId, gameId);
 }
 
-std::optional<ILeaderboard::Score> MySQLDatabase::GetPlayerScore(const LWOOBJID playerId, const uint32_t gameId) {
+std::optional<ILeaderboard::Score> MySQLDatabase::GetPlayerScore(const uint32_t playerId, const uint32_t gameId) {
 	std::optional<ILeaderboard::Score> toReturn = std::nullopt;
 	auto res = ExecuteSelect("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;", playerId, gameId);
 	if (res->next()) {
@@ -86,6 +86,6 @@ std::optional<ILeaderboard::Score> MySQLDatabase::GetPlayerScore(const LWOOBJID
 	return toReturn;
 }
 
-void MySQLDatabase::IncrementNumWins(const LWOOBJID playerId, const uint32_t gameId) {
+void MySQLDatabase::IncrementNumWins(const uint32_t playerId, const uint32_t gameId) {
 	ExecuteUpdate("UPDATE leaderboard SET numWins = numWins + 1 WHERE character_id = ? AND game_id = ?;", playerId, gameId);
 }

dDatabase/GameDatabase/MySQL/Tables/Mail.cpp

@@ -19,7 +19,7 @@ void MySQLDatabase::InsertNewMail(const MailInfo& mail) {
 		mail.itemCount);
 }
 
-std::vector<MailInfo> MySQLDatabase::GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> MySQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
 	auto res = ExecuteSelect(
 		"SELECT id, subject, body, sender_name, attachment_id, attachment_lot, attachment_subkey, attachment_count, was_read, time_sent"
 		" FROM mail WHERE receiver_id=? limit ?;",
@@ -61,7 +61,7 @@ std::optional<MailInfo> MySQLDatabase::GetMail(const uint64_t mailId) {
 	return toReturn;
 }
 
-uint32_t MySQLDatabase::GetUnreadMailCount(const LWOOBJID characterId) {
+uint32_t MySQLDatabase::GetUnreadMailCount(const uint32_t characterId) {
 	auto res = ExecuteSelect("SELECT COUNT(*) AS number_unread FROM mail WHERE receiver_id=? AND was_read=0;", characterId);
 
 	if (!res->next()) {

dDatabase/GameDatabase/MySQL/Tables/ObjectIdTracker.cpp

@@ -1,42 +1,17 @@
 #include "MySQLDatabase.h"
 
-std::optional<uint64_t> MySQLDatabase::GetCurrentPersistentId() {
+std::optional<uint32_t> MySQLDatabase::GetCurrentPersistentId() {
 	auto result = ExecuteSelect("SELECT last_object_id FROM object_id_tracker");
 	if (!result->next()) {
 		return std::nullopt;
 	}
-	return result->getUInt64("last_object_id");
+	return result->getUInt("last_object_id");
 }
 
 void MySQLDatabase::InsertDefaultPersistentId() {
 	ExecuteInsert("INSERT INTO object_id_tracker VALUES (1);");
 }
 
-IObjectIdTracker::Range MySQLDatabase::GetPersistentIdRange() {
-	IObjectIdTracker::Range range;
-	auto prevCommit = GetAutoCommit();
-	SetAutoCommit(false);
-
-	// THIS MUST ABSOLUTELY NOT FAIL. These IDs are expected to be unique. As such a transactional select is used to safely get a range
-	// of IDs that will never be used again. A separate feature could track unused IDs and recycle them, but that is not implemented.
-	ExecuteCustomQuery("START TRANSACTION;");
-	// 200 seems like a good range to reserve at once. Only way this would be noticable is if a player
-	// added hundreds of items at once.
-	// Doing the update first ensures that all other connections are blocked from accessing this table until we commit.
-	auto result = ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = last_object_id + 200;");
-	// If no rows were updated, it means the table is empty, so we need to insert the default row first.
-	if (result == 0) {
-		InsertDefaultPersistentId();
-		result = ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = last_object_id + 200;");
-	}
-
-	// At this point all connections are waiting on us to finish the transaction, so we can safely select the ID we just set.
-	auto selectRes = ExecuteSelect("SELECT last_object_id FROM object_id_tracker;");
-	selectRes->next();
-	range.maxID = selectRes->getUInt64("last_object_id");
-	range.minID = range.maxID - 199;
-
-	ExecuteCustomQuery("COMMIT;");
-	SetAutoCommit(prevCommit);
-	return range;
+void MySQLDatabase::UpdatePersistentId(const uint32_t newId) {
+	ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = ?;", newId);
 }

dDatabase/GameDatabase/MySQL/Tables/Property.cpp

@@ -1,23 +1,6 @@
 #include "MySQLDatabase.h"
 #include "ePropertySortType.h"
 
-IProperty::Info ReadPropertyInfo(UniqueResultSet& result) {
-	IProperty::Info info;
-	info.id = result->getUInt64("id");
-	info.ownerId = result->getInt64("owner_id");
-	info.cloneId = result->getUInt64("clone_id");
-	info.name = result->getString("name").c_str();
-	info.description = result->getString("description").c_str();
-	info.privacyOption = result->getInt("privacy_option");
-	info.rejectionReason = result->getString("rejection_reason").c_str();
-	info.lastUpdatedTime = result->getUInt("last_updated");
-	info.claimedTime = result->getUInt("time_claimed");
-	info.reputation = result->getUInt("reputation");
-	info.modApproved = result->getUInt("mod_approved");
-	info.performanceCost = result->getFloat("performance_cost");
-	return info;
-}
-
 std::optional<IProperty::PropertyEntranceResult> MySQLDatabase::GetProperties(const IProperty::PropertyLookup& params) {
 	std::optional<IProperty::PropertyEntranceResult> result;
 	std::string query;
@@ -134,7 +117,19 @@ std::optional<IProperty::PropertyEntranceResult> MySQLDatabase::GetProperties(co
 
 	while (properties->next()) {
 		if (!result) result = IProperty::PropertyEntranceResult();
-		result->entries.push_back(ReadPropertyInfo(properties));
+		auto& entry = result->entries.emplace_back();
+		entry.id = properties->getUInt64("id");
+		entry.ownerId = properties->getUInt64("owner_id");
+		entry.cloneId = properties->getUInt64("clone_id");
+		entry.name = properties->getString("name").c_str();
+		entry.description = properties->getString("description").c_str();
+		entry.privacyOption = properties->getInt("privacy_option");
+		entry.rejectionReason = properties->getString("rejection_reason").c_str();
+		entry.lastUpdatedTime = properties->getUInt("last_updated");
+		entry.claimedTime = properties->getUInt("time_claimed");
+		entry.reputation = properties->getUInt("reputation");
+		entry.modApproved = properties->getUInt("mod_approved");
+		entry.performanceCost = properties->getFloat("performance_cost");
 	}
 
 	return result;
@@ -149,7 +144,21 @@ std::optional<IProperty::Info> MySQLDatabase::GetPropertyInfo(const LWOMAPID map
 		return std::nullopt;
 	}
 
-	return ReadPropertyInfo(propertyEntry);
+	IProperty::Info toReturn;
+	toReturn.id = propertyEntry->getUInt64("id");
+	toReturn.ownerId = propertyEntry->getUInt64("owner_id");
+	toReturn.cloneId = propertyEntry->getUInt64("clone_id");
+	toReturn.name = propertyEntry->getString("name").c_str();
+	toReturn.description = propertyEntry->getString("description").c_str();
+	toReturn.privacyOption = propertyEntry->getInt("privacy_option");
+	toReturn.rejectionReason = propertyEntry->getString("rejection_reason").c_str();
+	toReturn.lastUpdatedTime = propertyEntry->getUInt("last_updated");
+	toReturn.claimedTime = propertyEntry->getUInt("time_claimed");
+	toReturn.reputation = propertyEntry->getUInt("reputation");
+	toReturn.modApproved = propertyEntry->getUInt("mod_approved");
+	toReturn.performanceCost = propertyEntry->getFloat("performance_cost");
+
+	return toReturn;
 }
 
 void MySQLDatabase::UpdatePropertyModerationInfo(const IProperty::Info& info) {
@@ -186,15 +195,3 @@ void MySQLDatabase::InsertNewProperty(const IProperty::Info& info, const uint32_
 		zoneId.GetMapID()
 	);
 }
-
-std::optional<IProperty::Info> MySQLDatabase::GetPropertyInfo(const LWOOBJID id) {
-	auto propertyEntry = ExecuteSelect(
-		"SELECT id, owner_id, clone_id, name, description, privacy_option, rejection_reason, last_updated, time_claimed, reputation, mod_approved, performance_cost "
-		"FROM properties WHERE id = ?;", id);
-
-	if (!propertyEntry->next()) {
-		return std::nullopt;
-	}
-
-	return ReadPropertyInfo(propertyEntry);
-}

dDatabase/GameDatabase/MySQL/Tables/PropertyContents.cpp

@@ -64,27 +64,26 @@ void MySQLDatabase::RemoveModel(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
 }
 
-std::optional<IPropertyContents::Model> MySQLDatabase::GetModel(const LWOOBJID modelID) {
+IPropertyContents::Model MySQLDatabase::GetModel(const LWOOBJID modelID) {
 	auto result = ExecuteSelect("SELECT * FROM properties_contents WHERE id = ?", modelID);
 
-	std::optional<IPropertyContents::Model> model = std::nullopt;
+	IPropertyContents::Model model{};
 	while (result->next()) {
-		model = IPropertyContents::Model{};
-		model->id = result->getUInt64("id");
-		model->lot = static_cast<LOT>(result->getUInt("lot"));
-		model->position.x = result->getFloat("x");
-		model->position.y = result->getFloat("y");
-		model->position.z = result->getFloat("z");
-		model->rotation.w = result->getFloat("rw");
-		model->rotation.x = result->getFloat("rx");
-		model->rotation.y = result->getFloat("ry");
-		model->rotation.z = result->getFloat("rz");
-		model->ugcId = result->getUInt64("ugc_id");
-		model->behaviors[0] = result->getUInt64("behavior_1");
-		model->behaviors[1] = result->getUInt64("behavior_2");
-		model->behaviors[2] = result->getUInt64("behavior_3");
-		model->behaviors[3] = result->getUInt64("behavior_4");
-		model->behaviors[4] = result->getUInt64("behavior_5");
+		model.id = result->getUInt64("id");
+		model.lot = static_cast<LOT>(result->getUInt("lot"));
+		model.position.x = result->getFloat("x");
+		model.position.y = result->getFloat("y");
+		model.position.z = result->getFloat("z");
+		model.rotation.w = result->getFloat("rw");
+		model.rotation.x = result->getFloat("rx");
+		model.rotation.y = result->getFloat("ry");
+		model.rotation.z = result->getFloat("rz");
+		model.ugcId = result->getUInt64("ugc_id");
+		model.behaviors[0] = result->getUInt64("behavior_1");
+		model.behaviors[1] = result->getUInt64("behavior_2");
+		model.behaviors[2] = result->getUInt64("behavior_3");
+		model.behaviors[3] = result->getUInt64("behavior_4");
+		model.behaviors[4] = result->getUInt64("behavior_5");
 	}
 
 	return model;

dDatabase/GameDatabase/MySQL/Tables/Ugc.cpp

@@ -1,17 +1,5 @@
 #include "MySQLDatabase.h"
 
-IUgc::Model ReadModel(UniqueResultSet& result) {
-	IUgc::Model model;
-
-	// blob is owned by the query, so we need to do a deep copy :/
-	std::unique_ptr<std::istream> blob(result->getBlob("lxfml"));
-	model.lxfmlData << blob->rdbuf();
-	model.id = result->getUInt64("ugcID");
-	model.modelID = result->getUInt64("modelID");
-
-	return model;
-}
-
 std::vector<IUgc::Model> MySQLDatabase::GetUgcModels(const LWOOBJID& propertyId) {
 	auto result = ExecuteSelect(
 		"SELECT lxfml, u.id as ugcID, pc.id as modelID FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
@@ -20,7 +8,14 @@ std::vector<IUgc::Model> MySQLDatabase::GetUgcModels(const LWOOBJID& propertyId)
 	std::vector<IUgc::Model> toReturn;
 
 	while (result->next()) {
-		toReturn.push_back(ReadModel(result));
+		IUgc::Model model;
+
+		// blob is owned by the query, so we need to do a deep copy :/
+		std::unique_ptr<std::istream> blob(result->getBlob("lxfml"));
+		model.lxfmlData << blob->rdbuf();
+		model.id = result->getUInt64("ugcID");
+		model.modelID = result->getUInt64("modelID");
+		toReturn.push_back(std::move(model));
 	}
 
 	return toReturn;
@@ -32,7 +27,14 @@ std::vector<IUgc::Model> MySQLDatabase::GetAllUgcModels() {
 	std::vector<IUgc::Model> models;
 	models.reserve(result->rowsCount());
 	while (result->next()) {
-		models.push_back(ReadModel(result));
+		IUgc::Model model;
+		model.id = result->getInt64("ugcID");
+		model.modelID = result->getUInt64("modelID");
+
+		// blob is owned by the query, so we need to do a deep copy :/
+		std::unique_ptr<std::istream> blob(result->getBlob("lxfml"));
+		model.lxfmlData << blob->rdbuf();
+		models.push_back(std::move(model));
 	}
 
 	return models;
@@ -43,10 +45,10 @@ void MySQLDatabase::RemoveUnreferencedUgcModels() {
 }
 
 void MySQLDatabase::InsertNewUgcModel(
-	std::stringstream& sd0Data, // cant be const sad
-	const uint64_t blueprintId,
+	std:: stringstream& sd0Data, // cant be const sad
+	const uint32_t blueprintId,
 	const uint32_t accountId,
-	const LWOOBJID characterId) {
+	const uint32_t characterId) {
 	const std::istream stream(sd0Data.rdbuf());
 	ExecuteInsert(
 		"INSERT INTO `ugc`(`id`, `account_id`, `character_id`, `is_optimized`, `lxfml`, `bake_ao`, `filename`) VALUES (?,?,?,?,?,?,?)",
@@ -69,14 +71,3 @@ void MySQLDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::stringstrea
 	const std::istream stream(lxfml.rdbuf());
 	ExecuteUpdate("UPDATE ugc SET lxfml = ? WHERE id = ?;", &stream, modelId);
 }
-
-std::optional<IUgc::Model> MySQLDatabase::GetUgcModel(const LWOOBJID ugcId) {
-	auto result = ExecuteSelect("SELECT u.id AS ugcID, lxfml, pc.id AS modelID FROM ugc AS u JOIN properties_contents AS pc ON pc.ugc_id = u.id WHERE u.id = ?", ugcId);
-
-	std::optional<IUgc::Model> toReturn = std::nullopt;
-	if (result->next()) {
-		toReturn = ReadModel(result);
-	}
-
-	return toReturn;
-}

dDatabase/GameDatabase/MySQL/Tables/UgcModularBuild.cpp

@@ -1,6 +1,6 @@
 #include "MySQLDatabase.h"
 
-void MySQLDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) {
+void MySQLDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) {
 	ExecuteInsert("INSERT INTO ugc_modular_build (ugc_id, ldf_config, character_id) VALUES (?,?,?)", bigId, modules, characterId);
 }
 

dDatabase/GameDatabase/SQLite/SQLiteDatabase.cpp

@@ -61,13 +61,13 @@ bool SQLiteDatabase::GetAutoCommit() {
 
 void SQLiteDatabase::SetAutoCommit(bool value) {
 	if (value) {
-		if (!GetAutoCommit()) con->compileStatement("COMMIT;").execDML();
-	} else {
 		if (GetAutoCommit()) con->compileStatement("BEGIN;").execDML();
+	} else {
+		if (!GetAutoCommit()) con->compileStatement("COMMIT;").execDML();
 	}
 }
 
-void SQLiteDatabase::DeleteCharacter(const LWOOBJID characterId) {
+void SQLiteDatabase::DeleteCharacter(const uint32_t characterId) {
 	ExecuteDelete("DELETE FROM charxml WHERE id=?;", characterId);
 	ExecuteDelete("DELETE FROM command_log WHERE character_id=?;", characterId);
 	ExecuteDelete("DELETE FROM friends WHERE player_id=? OR friend_id=?;", characterId, characterId);

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -38,31 +38,31 @@ public:
 
 	std::vector<std::string> GetApprovedCharacterNames() override;
 
-	std::vector<FriendData> GetFriendsList(LWOOBJID charID) override;
+	std::vector<FriendData> GetFriendsList(uint32_t charID) override;
 
-	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) override;
-	void SetBestFriendStatus(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId, const uint32_t bestFriendStatus) override;
-	void AddFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) override;
-	void RemoveFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) override;
-	void UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) override;
+	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) override;
+	void SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) override;
+	void AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
 	void DeleteUgcModelData(const LWOOBJID& modelId) override;
 	void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) override;
 	std::vector<IUgc::Model> GetAllUgcModels() override;
 	void CreateMigrationHistoryTable() override;
 	bool IsMigrationRun(const std::string_view str) override;
 	void InsertMigration(const std::string_view str) override;
-	std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) override;
 	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
-	std::string GetCharacterXml(const LWOOBJID accountId) override;
-	void UpdateCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) override;
+	std::string GetCharacterXml(const uint32_t accountId) override;
+	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
 	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
 	void InsertNewCharacter(const ICharInfo::Info info) override;
-	void InsertCharacterXml(const LWOOBJID accountId, const std::string_view lxfml) override;
-	std::vector<LWOOBJID> GetAccountCharacterIds(LWOOBJID accountId) override;
-	void DeleteCharacter(const LWOOBJID characterId) override;
-	void SetCharacterName(const LWOOBJID characterId, const std::string_view name) override;
-	void SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) override;
-	void UpdateLastLoggedInCharacter(const LWOOBJID characterId) override;
+	void InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) override;
+	std::vector<uint32_t> GetAccountCharacterIds(uint32_t accountId) override;
+	void DeleteCharacter(const uint32_t characterId) override;
+	void SetCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void UpdateLastLoggedInCharacter(const uint32_t characterId) override;
 	void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) override;
 	std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) override;
 	std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) override;
@@ -81,30 +81,30 @@ public:
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
 		std::stringstream& sd0Data,
-		const uint64_t blueprintId,
+		const uint32_t blueprintId,
 		const uint32_t accountId,
-		const LWOOBJID characterId) override;
-	std::vector<MailInfo> GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) override;
+		const uint32_t characterId) override;
+	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
 	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
-	uint32_t GetUnreadMailCount(const LWOOBJID characterId) override;
+	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
 	void MarkMailRead(const uint64_t mailId) override;
 	void DeleteMail(const uint64_t mailId) override;
 	void ClaimMailItem(const uint64_t mailId) override;
-	void InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) override;
+	void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) override;
 	void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) override;
 	void UpdateAccountBan(const uint32_t accountId, const bool banned) override;
 	void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) override;
 	void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) override;
 	void SetMasterInfo(const IServers::MasterInfo& info) override;
-	std::optional<uint64_t> GetCurrentPersistentId() override;
-	IObjectIdTracker::Range GetPersistentIdRange() override;
+	std::optional<uint32_t> GetCurrentPersistentId() override;
 	void InsertDefaultPersistentId() override;
+	void UpdatePersistentId(const uint32_t id) override;
 	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
 	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
 	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
-	void AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
-	void RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
-	std::vector<IIgnoreList::Info> GetIgnoreList(const LWOOBJID playerId) override;
+	void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
 	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
 	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
 	void AddBehavior(const IBehaviors::Info& info) override;
@@ -116,18 +116,16 @@ public:
 	std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) override;
 	std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) override;
 	std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) override;
-	void SaveScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) override;
-	void UpdateScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) override;
-	std::optional<ILeaderboard::Score> GetPlayerScore(const LWOOBJID playerId, const uint32_t gameId) override;
-	void IncrementNumWins(const LWOOBJID playerId, const uint32_t gameId) override;
-	void IncrementTimesPlayed(const LWOOBJID playerId, const uint32_t gameId) override;
-	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) override;
+	void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override;
+	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override;
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
+	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
 	bool IsNameInUse(const std::string_view name) override;
-	std::optional<IPropertyContents::Model> GetModel(const LWOOBJID modelID) override;
-	std::optional<IUgc::Model> GetUgcModel(const LWOOBJID ugcId) override;
-	std::optional<IProperty::Info> GetPropertyInfo(const LWOOBJID id) override;
+	IPropertyContents::Model GetModel(const LWOOBJID modelID) override;
 private:
 	CppSQLite3Statement CreatePreppedStmt(const std::string& query);
 
@@ -272,15 +270,4 @@ inline void SetParam(PreppedStmtRef stmt, const int index, const std::optional<u
 	}
 }
 
-template<>
-inline void SetParam(PreppedStmtRef stmt, const int index, const std::optional<LWOOBJID> param) {
-	if (param) {
-		LOG("%d", param.value());
-		stmt.bind(index, static_cast<sqlite_int64>(param.value()));
-	} else {
-		LOG("Null");
-		stmt.bindNull(index);
-	}
-}
-
 #endif  //!SQLITEDATABASE_H

dDatabase/GameDatabase/SQLite/Tables/ActivityLog.cpp

@@ -1,6 +1,6 @@
 #include "SQLiteDatabase.h"
 
-void SQLiteDatabase::UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) {
+void SQLiteDatabase::UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
 	ExecuteInsert("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);",
 		characterId, static_cast<uint32_t>(activityType), static_cast<uint32_t>(time(NULL)), mapId);
 }

dDatabase/GameDatabase/SQLite/Tables/CharInfo.cpp

@@ -20,7 +20,7 @@ std::optional<ICharInfo::Info> CharInfoFromQueryResult(CppSQLite3Query stmt) {
 
 	ICharInfo::Info toReturn;
 
-	toReturn.id = stmt.getInt64Field("id");
+	toReturn.id = stmt.getIntField("id");
 	toReturn.name = stmt.getStringField("name");
 	toReturn.pendingName = stmt.getStringField("pending_name");
 	toReturn.needsRename = stmt.getIntField("needs_rename");
@@ -31,7 +31,7 @@ std::optional<ICharInfo::Info> CharInfoFromQueryResult(CppSQLite3Query stmt) {
 	return toReturn;
 }
 
-std::optional<ICharInfo::Info> SQLiteDatabase::GetCharacterInfo(const LWOOBJID charId) {
+std::optional<ICharInfo::Info> SQLiteDatabase::GetCharacterInfo(const uint32_t charId) {
 	return CharInfoFromQueryResult(
 		ExecuteSelect("SELECT name, pending_name, needs_rename, prop_clone_id, permission_map, id, account_id FROM charinfo WHERE id = ? LIMIT 1;", charId).second
 	);
@@ -43,12 +43,12 @@ std::optional<ICharInfo::Info> SQLiteDatabase::GetCharacterInfo(const std::strin
 	);
 }
 
-std::vector<LWOOBJID> SQLiteDatabase::GetAccountCharacterIds(const LWOOBJID accountId) {
+std::vector<uint32_t> SQLiteDatabase::GetAccountCharacterIds(const uint32_t accountId) {
 	auto [_, result] = ExecuteSelect("SELECT id FROM charinfo WHERE account_id = ? ORDER BY last_login DESC LIMIT 4;", accountId);
 
-	std::vector<LWOOBJID> toReturn;
+	std::vector<uint32_t> toReturn;
 	while (!result.eof()) {
-		toReturn.push_back(result.getInt64Field("id"));
+		toReturn.push_back(result.getIntField("id"));
 		result.nextRow();
 	}
 
@@ -66,15 +66,15 @@ void SQLiteDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 		static_cast<uint32_t>(time(NULL)));
 }
 
-void SQLiteDatabase::SetCharacterName(const LWOOBJID characterId, const std::string_view name) {
+void SQLiteDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
 	ExecuteUpdate("UPDATE charinfo SET name = ?, pending_name = '', needs_rename = 0, last_login = ? WHERE id = ?;", name, static_cast<uint32_t>(time(NULL)), characterId);
 }
 
-void SQLiteDatabase::SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) {
+void SQLiteDatabase::SetPendingCharacterName(const uint32_t characterId, const std::string_view name) {
 	ExecuteUpdate("UPDATE charinfo SET pending_name = ?, needs_rename = 0, last_login = ? WHERE id = ?;", name, static_cast<uint32_t>(time(NULL)), characterId);
 }
 
-void SQLiteDatabase::UpdateLastLoggedInCharacter(const LWOOBJID characterId) {
+void SQLiteDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
 	ExecuteUpdate("UPDATE charinfo SET last_login = ? WHERE id = ?;", static_cast<uint32_t>(time(NULL)), characterId);
 }
 

dDatabase/GameDatabase/SQLite/Tables/CharXml.cpp

@@ -1,6 +1,6 @@
 #include "SQLiteDatabase.h"
 
-std::string SQLiteDatabase::GetCharacterXml(const LWOOBJID charId) {
+std::string SQLiteDatabase::GetCharacterXml(const uint32_t charId) {
 	auto [_, result] = ExecuteSelect("SELECT xml_data FROM charxml WHERE id = ? LIMIT 1;", charId);
 
 	if (result.eof()) {
@@ -10,10 +10,10 @@ std::string SQLiteDatabase::GetCharacterXml(const LWOOBJID charId) {
 	return result.getStringField("xml_data");
 }
 
-void SQLiteDatabase::UpdateCharacterXml(const LWOOBJID charId, const std::string_view lxfml) {
+void SQLiteDatabase::UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) {
 	ExecuteUpdate("UPDATE charxml SET xml_data = ? WHERE id = ?;", lxfml, charId);
 }
 
-void SQLiteDatabase::InsertCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) {
+void SQLiteDatabase::InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
 	ExecuteInsert("INSERT INTO `charxml` (`id`, `xml_data`) VALUES (?,?)", characterId, lxfml);
 }

dDatabase/GameDatabase/SQLite/Tables/CommandLog.cpp

@@ -1,5 +1,5 @@
 #include "SQLiteDatabase.h"
 
-void SQLiteDatabase::InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) {
+void SQLiteDatabase::InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) {
 	ExecuteInsert("INSERT INTO command_log (character_id, command) VALUES (?, ?);", characterId, command);
 }

dDatabase/GameDatabase/SQLite/Tables/Friends.cpp

@@ -1,6 +1,6 @@
 #include "SQLiteDatabase.h"
 
-std::vector<FriendData> SQLiteDatabase::GetFriendsList(const LWOOBJID charId) {
+std::vector<FriendData> SQLiteDatabase::GetFriendsList(const uint32_t charId) {
 	auto [_, friendsList] = ExecuteSelect(
 		R"QUERY(
 			SELECT fr.requested_player AS player, best_friend AS bff, ci.name AS name FROM 
@@ -18,7 +18,7 @@ std::vector<FriendData> SQLiteDatabase::GetFriendsList(const LWOOBJID charId) {
 
 	while (!friendsList.eof()) {
 		FriendData fd;
-		fd.friendID = friendsList.getInt64Field("player");
+		fd.friendID = friendsList.getIntField("player");
 		fd.isBestFriend = friendsList.getIntField("bff") == 3; // 0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
 		fd.friendName = friendsList.getStringField("name");
 
@@ -29,7 +29,7 @@ std::vector<FriendData> SQLiteDatabase::GetFriendsList(const LWOOBJID charId) {
 	return toReturn;
 }
 
-std::optional<IFriends::BestFriendStatus> SQLiteDatabase::GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
+std::optional<IFriends::BestFriendStatus> SQLiteDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
 	auto [_, result] = ExecuteSelect("SELECT * FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;",
 		playerCharacterId,
 		friendCharacterId,
@@ -42,14 +42,14 @@ std::optional<IFriends::BestFriendStatus> SQLiteDatabase::GetBestFriendStatus(co
 	}
 
 	IFriends::BestFriendStatus toReturn;
-	toReturn.playerCharacterId = result.getInt64Field("player_id");
-	toReturn.friendCharacterId = result.getInt64Field("friend_id");
+	toReturn.playerCharacterId = result.getIntField("player_id");
+	toReturn.friendCharacterId = result.getIntField("friend_id");
 	toReturn.bestFriendStatus = result.getIntField("best_friend");
 
 	return toReturn;
 }
 
-void SQLiteDatabase::SetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId, const uint32_t bestFriendStatus) {
+void SQLiteDatabase::SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) {
 	ExecuteUpdate("UPDATE friends SET best_friend = ? WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?);",
 		bestFriendStatus,
 		playerCharacterId,
@@ -59,11 +59,11 @@ void SQLiteDatabase::SetBestFriendStatus(const LWOOBJID playerCharacterId, const
 	);
 }
 
-void SQLiteDatabase::AddFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
+void SQLiteDatabase::AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
 	ExecuteInsert("INSERT OR IGNORE INTO friends (player_id, friend_id, best_friend) VALUES (?, ?, 0);", playerCharacterId, friendCharacterId);
 }
 
-void SQLiteDatabase::RemoveFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
+void SQLiteDatabase::RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
 	ExecuteDelete("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?);",
 		playerCharacterId,
 		friendCharacterId,

dDatabase/GameDatabase/SQLite/Tables/IgnoreList.cpp

@@ -1,22 +1,22 @@
 #include "SQLiteDatabase.h"
 
-std::vector<IIgnoreList::Info> SQLiteDatabase::GetIgnoreList(const LWOOBJID playerId) {
+std::vector<IIgnoreList::Info> SQLiteDatabase::GetIgnoreList(const uint32_t playerId) {
 	auto [_, result] = ExecuteSelect("SELECT ci.name AS name, il.ignored_player_id AS ignore_id FROM ignore_list AS il JOIN charinfo AS ci ON il.ignored_player_id = ci.id WHERE il.player_id = ?", playerId);
 
 	std::vector<IIgnoreList::Info> ignoreList;
 
 	while (!result.eof()) {
-		ignoreList.push_back(IIgnoreList::Info{ result.getStringField("name"), result.getInt64Field("ignore_id") });
+		ignoreList.push_back(IIgnoreList::Info{ result.getStringField("name"), static_cast<uint32_t>(result.getIntField("ignore_id")) });
 		result.nextRow();
 	}
 
 	return ignoreList;
 }
 
-void SQLiteDatabase::AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
+void SQLiteDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
 	ExecuteInsert("INSERT OR IGNORE INTO ignore_list (player_id, ignored_player_id) VALUES (?, ?)", playerId, ignoredPlayerId);
 }
 
-void SQLiteDatabase::RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
+void SQLiteDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
 	ExecuteDelete("DELETE FROM ignore_list WHERE player_id = ? AND ignored_player_id = ?", playerId, ignoredPlayerId);
 }

dDatabase/GameDatabase/SQLite/Tables/Leaderboard.cpp

@@ -20,7 +20,7 @@ std::vector<ILeaderboard::Entry> ProcessQuery(CppSQLite3Query& rows) {
 	while (!rows.eof()) {
 		auto& entry = entries.emplace_back();
 
-		entry.charId = rows.getInt64Field("character_id");
+		entry.charId = rows.getIntField("character_id");
 		entry.lastPlayedTimestamp = rows.getIntField("lp_unix");
 		entry.primaryScore = rows.getFloatField("primaryScore");
 		entry.secondaryScore = rows.getFloatField("secondaryScore");
@@ -58,17 +58,17 @@ std::vector<ILeaderboard::Entry> SQLiteDatabase::GetNsLeaderboard(const uint32_t
 	return ProcessQuery(result);
 }
 
-void SQLiteDatabase::SaveScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) {
+void SQLiteDatabase::SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
 	ExecuteInsert("INSERT INTO leaderboard (primaryScore, secondaryScore, tertiaryScore, character_id, game_id, last_played) VALUES (?,?,?,?,?,CURRENT_TIMESTAMP) ;",
 		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
 }
 
-void SQLiteDatabase::UpdateScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) {
+void SQLiteDatabase::UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) {
 	ExecuteInsert("UPDATE leaderboard SET primaryScore = ?, secondaryScore = ?, tertiaryScore = ?, timesPlayed = timesPlayed + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;",
 		score.primaryScore, score.secondaryScore, score.tertiaryScore, playerId, gameId);
 }
 
-std::optional<ILeaderboard::Score> SQLiteDatabase::GetPlayerScore(const LWOOBJID playerId, const uint32_t gameId) {
+std::optional<ILeaderboard::Score> SQLiteDatabase::GetPlayerScore(const uint32_t playerId, const uint32_t gameId) {
 	std::optional<ILeaderboard::Score> toReturn = std::nullopt;
 	auto [_, res] = ExecuteSelect("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;", playerId, gameId);
 	if (!res.eof()) {
@@ -82,10 +82,10 @@ std::optional<ILeaderboard::Score> SQLiteDatabase::GetPlayerScore(const LWOOBJID
 	return toReturn;
 }
 
-void SQLiteDatabase::IncrementNumWins(const LWOOBJID playerId, const uint32_t gameId) {
+void SQLiteDatabase::IncrementNumWins(const uint32_t playerId, const uint32_t gameId) {
 	ExecuteUpdate("UPDATE leaderboard SET numWins = numWins + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;", playerId, gameId);
 }
 
-void SQLiteDatabase::IncrementTimesPlayed(const LWOOBJID playerId, const uint32_t gameId) {
+void SQLiteDatabase::IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) {
 	ExecuteUpdate("UPDATE leaderboard SET timesPlayed = timesPlayed + 1, last_played = CURRENT_TIMESTAMP WHERE character_id = ? AND game_id = ?;", playerId, gameId);
 }

dDatabase/GameDatabase/SQLite/Tables/Mail.cpp

@@ -18,7 +18,7 @@ void SQLiteDatabase::InsertNewMail(const MailInfo& mail) {
 		mail.itemCount);
 }
 
-std::vector<MailInfo> SQLiteDatabase::GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> SQLiteDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
 	auto [_, res] = ExecuteSelect(
 		"SELECT id, subject, body, sender_name, attachment_id, attachment_lot, attachment_subkey, attachment_count, was_read, time_sent"
 		" FROM mail WHERE receiver_id=? limit ?;",
@@ -60,7 +60,7 @@ std::optional<MailInfo> SQLiteDatabase::GetMail(const uint64_t mailId) {
 	return toReturn;
 }
 
-uint32_t SQLiteDatabase::GetUnreadMailCount(const LWOOBJID characterId) {
+uint32_t SQLiteDatabase::GetUnreadMailCount(const uint32_t characterId) {
 	auto [_, res] = ExecuteSelect("SELECT COUNT(*) AS number_unread FROM mail WHERE receiver_id=? AND was_read=0;", characterId);
 
 	if (res.eof()) {

dDatabase/GameDatabase/SQLite/Tables/ObjectIdTracker.cpp

@@ -1,40 +1,17 @@
 #include "SQLiteDatabase.h"
 
-std::optional<uint64_t> SQLiteDatabase::GetCurrentPersistentId() {
+std::optional<uint32_t> SQLiteDatabase::GetCurrentPersistentId() {
 	auto [_, result] = ExecuteSelect("SELECT last_object_id FROM object_id_tracker");
 	if (result.eof()) {
 		return std::nullopt;
 	}
-	return result.getInt64Field("last_object_id");
+	return result.getIntField("last_object_id");
 }
 
 void SQLiteDatabase::InsertDefaultPersistentId() {
 	ExecuteInsert("INSERT INTO object_id_tracker VALUES (1);");
 }
 
-IObjectIdTracker::Range SQLiteDatabase::GetPersistentIdRange() {
-	IObjectIdTracker::Range range;
-	auto prevCommit = GetAutoCommit();
-	SetAutoCommit(false); // This begins the transaction for us if one is not already in progress
-
-	// THIS MUST ABSOLUTELY NOT FAIL. These IDs are expected to be unique. As such a transactional select is used to safely get a range
-	// of IDs that will never be used again. A separate feature could track unused IDs and recycle them, but that is not implemented.
-	// 200 seems like a good range to reserve at once. Only way this would be noticable is if a player
-	// added hundreds of items at once.
-	// Doing the update first ensures that all other connections are blocked from accessing this table until we commit.
-	auto result = ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = last_object_id + 200;");
-	if (result == 0) {
-		InsertDefaultPersistentId();
-		result = ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = last_object_id + 200;");
-	}
-
-	// At this point all connections are waiting on us to finish the transaction, so we can safely select the ID we just set.
-	auto [_, selectResult] = ExecuteSelect("SELECT last_object_id FROM object_id_tracker;");
-	range.maxID = selectResult.getInt64Field("last_object_id");
-	range.minID = range.maxID - 199;
-
-	// We must commit here manually, this will unlock the database for all other servers
-	ExecuteCustomQuery("COMMIT;");
-	SetAutoCommit(prevCommit);
-	return range;
+void SQLiteDatabase::UpdatePersistentId(const uint32_t newId) {
+	ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = ?;", newId);
 }

dDatabase/GameDatabase/SQLite/Tables/Property.cpp

@@ -1,23 +1,6 @@
 #include "SQLiteDatabase.h"
 #include "ePropertySortType.h"
 
-IProperty::Info ReadPropertyInfo(CppSQLite3Query& propertyEntry) {
-	IProperty::Info toReturn;
-	toReturn.id = propertyEntry.getInt64Field("id");
-	toReturn.ownerId = propertyEntry.getInt64Field("owner_id");
-	toReturn.cloneId = propertyEntry.getInt64Field("clone_id");
-	toReturn.name = propertyEntry.getStringField("name");
-	toReturn.description = propertyEntry.getStringField("description");
-	toReturn.privacyOption = propertyEntry.getIntField("privacy_option");
-	toReturn.rejectionReason = propertyEntry.getStringField("rejection_reason");
-	toReturn.lastUpdatedTime = propertyEntry.getIntField("last_updated");
-	toReturn.claimedTime = propertyEntry.getIntField("time_claimed");
-	toReturn.reputation = propertyEntry.getIntField("reputation");
-	toReturn.modApproved = propertyEntry.getIntField("mod_approved");
-	toReturn.performanceCost = propertyEntry.getFloatField("performance_cost");
-	return toReturn;
-}
-
 std::optional<IProperty::PropertyEntranceResult> SQLiteDatabase::GetProperties(const IProperty::PropertyLookup& params) {
 	std::optional<IProperty::PropertyEntranceResult> result;
 	std::string query;
@@ -135,7 +118,19 @@ std::optional<IProperty::PropertyEntranceResult> SQLiteDatabase::GetProperties(c
 	auto& [_, properties] = propertiesRes;
 	if (!properties.eof() && !result.has_value()) result = IProperty::PropertyEntranceResult();
 	while (!properties.eof()) {
-		result->entries.push_back(ReadPropertyInfo(properties));
+		auto& entry = result->entries.emplace_back();
+		entry.id = properties.getInt64Field("id");
+		entry.ownerId = properties.getInt64Field("owner_id");
+		entry.cloneId = properties.getInt64Field("clone_id");
+		entry.name = properties.getStringField("name");
+		entry.description = properties.getStringField("description");
+		entry.privacyOption = properties.getIntField("privacy_option");
+		entry.rejectionReason = properties.getStringField("rejection_reason");
+		entry.lastUpdatedTime = properties.getIntField("last_updated");
+		entry.claimedTime = properties.getIntField("time_claimed");
+		entry.reputation = properties.getIntField("reputation");
+		entry.modApproved = properties.getIntField("mod_approved");
+		entry.performanceCost = properties.getFloatField("performance_cost");
 		properties.nextRow();
 	}
 
@@ -151,7 +146,21 @@ std::optional<IProperty::Info> SQLiteDatabase::GetPropertyInfo(const LWOMAPID ma
 		return std::nullopt;
 	}
 
-	return ReadPropertyInfo(propertyEntry);
+	IProperty::Info toReturn;
+	toReturn.id = propertyEntry.getInt64Field("id");
+	toReturn.ownerId = propertyEntry.getInt64Field("owner_id");
+	toReturn.cloneId = propertyEntry.getInt64Field("clone_id");
+	toReturn.name = propertyEntry.getStringField("name");
+	toReturn.description = propertyEntry.getStringField("description");
+	toReturn.privacyOption = propertyEntry.getIntField("privacy_option");
+	toReturn.rejectionReason = propertyEntry.getStringField("rejection_reason");
+	toReturn.lastUpdatedTime = propertyEntry.getIntField("last_updated");
+	toReturn.claimedTime = propertyEntry.getIntField("time_claimed");
+	toReturn.reputation = propertyEntry.getIntField("reputation");
+	toReturn.modApproved = propertyEntry.getIntField("mod_approved");
+	toReturn.performanceCost = propertyEntry.getFloatField("performance_cost");
+
+	return toReturn;
 }
 
 void SQLiteDatabase::UpdatePropertyModerationInfo(const IProperty::Info& info) {
@@ -188,15 +197,3 @@ void SQLiteDatabase::InsertNewProperty(const IProperty::Info& info, const uint32
 		zoneId.GetMapID()
 	);
 }
-
-std::optional<IProperty::Info> SQLiteDatabase::GetPropertyInfo(const LWOOBJID id) {
-	auto [_, propertyEntry] = ExecuteSelect(
-		"SELECT id, owner_id, clone_id, name, description, privacy_option, rejection_reason, last_updated, time_claimed, reputation, mod_approved, performance_cost "
-		"FROM properties WHERE id = ?;", id);
-	
-	if (propertyEntry.eof()) {
-		return std::nullopt;
-	}
-
-	return ReadPropertyInfo(propertyEntry);
-}

dDatabase/GameDatabase/SQLite/Tables/PropertyContents.cpp

@@ -64,28 +64,27 @@ void SQLiteDatabase::RemoveModel(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
 }
 
-std::optional<IPropertyContents::Model> SQLiteDatabase::GetModel(const LWOOBJID modelID) {
+IPropertyContents::Model SQLiteDatabase::GetModel(const LWOOBJID modelID) {
 	auto [_, result] = ExecuteSelect("SELECT * FROM properties_contents WHERE id = ?", modelID);
 
-	std::optional<IPropertyContents::Model> model = std::nullopt;
+	IPropertyContents::Model model{};
 	if (!result.eof()) {
 		do {
-			model = IPropertyContents::Model{};
-			model->id = result.getInt64Field("id");
-			model->lot = static_cast<LOT>(result.getIntField("lot"));
-			model->position.x = result.getFloatField("x");
-			model->position.y = result.getFloatField("y");
-			model->position.z = result.getFloatField("z");
-			model->rotation.w = result.getFloatField("rw");
-			model->rotation.x = result.getFloatField("rx");
-			model->rotation.y = result.getFloatField("ry");
-			model->rotation.z = result.getFloatField("rz");
-			model->ugcId = result.getInt64Field("ugc_id");
-			model->behaviors[0] = result.getInt64Field("behavior_1");
-			model->behaviors[1] = result.getInt64Field("behavior_2");
-			model->behaviors[2] = result.getInt64Field("behavior_3");
-			model->behaviors[3] = result.getInt64Field("behavior_4");
-			model->behaviors[4] = result.getInt64Field("behavior_5");
+			model.id = result.getInt64Field("id");
+			model.lot = static_cast<LOT>(result.getIntField("lot"));
+			model.position.x = result.getFloatField("x");
+			model.position.y = result.getFloatField("y");
+			model.position.z = result.getFloatField("z");
+			model.rotation.w = result.getFloatField("rw");
+			model.rotation.x = result.getFloatField("rx");
+			model.rotation.y = result.getFloatField("ry");
+			model.rotation.z = result.getFloatField("rz");
+			model.ugcId = result.getInt64Field("ugc_id");
+			model.behaviors[0] = result.getInt64Field("behavior_1");
+			model.behaviors[1] = result.getInt64Field("behavior_2");
+			model.behaviors[2] = result.getInt64Field("behavior_3");
+			model.behaviors[3] = result.getInt64Field("behavior_4");
+			model.behaviors[4] = result.getInt64Field("behavior_5");
 		} while (result.nextRow());
 	}
 

dDatabase/GameDatabase/SQLite/Tables/Ugc.cpp

@@ -1,17 +1,5 @@
 #include "SQLiteDatabase.h"
 
-IUgc::Model ReadModel(CppSQLite3Query& result) {
-	IUgc::Model model;
-
-	int blobSize{};
-	const auto* blob = result.getBlobField("lxfml", blobSize);
-	model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
-	model.id = result.getInt64Field("ugcID");
-	model.modelID = result.getInt64Field("modelID");
-
-	return model;
-}
-
 std::vector<IUgc::Model> SQLiteDatabase::GetUgcModels(const LWOOBJID& propertyId) {
 	auto [_, result] = ExecuteSelect(
 		"SELECT lxfml, u.id AS ugcID, pc.id AS modelID FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
@@ -20,7 +8,14 @@ std::vector<IUgc::Model> SQLiteDatabase::GetUgcModels(const LWOOBJID& propertyId
 	std::vector<IUgc::Model> toReturn;
 
 	while (!result.eof()) {
-		toReturn.push_back(ReadModel(result));
+		IUgc::Model model;
+
+		int blobSize{};
+		const auto* blob = result.getBlobField("lxfml", blobSize);
+		model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
+		model.id = result.getInt64Field("ugcID");
+		model.modelID = result.getInt64Field("modelID");
+		toReturn.push_back(std::move(model));
 		result.nextRow();
 	}
 
@@ -32,7 +27,14 @@ std::vector<IUgc::Model> SQLiteDatabase::GetAllUgcModels() {
 
 	std::vector<IUgc::Model> models;
 	while (!result.eof()) {
-		models.push_back(ReadModel(result));
+		IUgc::Model model;
+		model.id = result.getInt64Field("ugcID");
+		model.modelID = result.getInt64Field("modelID");
+
+		int blobSize{};
+		const auto* blob = result.getBlobField("lxfml", blobSize);
+		model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
+		models.push_back(std::move(model));
 		result.nextRow();
 	}
 
@@ -45,9 +47,9 @@ void SQLiteDatabase::RemoveUnreferencedUgcModels() {
 
 void SQLiteDatabase::InsertNewUgcModel(
 	std::stringstream& sd0Data, // cant be const sad
-	const uint64_t blueprintId,
+	const uint32_t blueprintId,
 	const uint32_t accountId,
-	const LWOOBJID characterId) {
+	const uint32_t characterId) {
 	const std::istream stream(sd0Data.rdbuf());
 	ExecuteInsert(
 		"INSERT INTO `ugc`(`id`, `account_id`, `character_id`, `is_optimized`, `lxfml`, `bake_ao`, `filename`) VALUES (?,?,?,?,?,?,?)",
@@ -70,14 +72,3 @@ void SQLiteDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::stringstre
 	const std::istream stream(lxfml.rdbuf());
 	ExecuteUpdate("UPDATE ugc SET lxfml = ? WHERE id = ?;", &stream, modelId);
 }
-
-std::optional<IUgc::Model> SQLiteDatabase::GetUgcModel(const LWOOBJID ugcId) {
-	auto [_, result] = ExecuteSelect("SELECT u.id AS ugcID, pc.id AS modelID, lxfml FROM ugc AS u JOIN properties_contents AS pc ON pc.id = u.id WHERE u.id = ?;", ugcId);
-
-	std::optional<IUgc::Model> toReturn = std::nullopt;
-	if (!result.eof()) {
-		toReturn = ReadModel(result);
-	}
-
-	return toReturn;
-}

dDatabase/GameDatabase/SQLite/Tables/UgcModularBuild.cpp

@@ -1,6 +1,6 @@
 #include "SQLiteDatabase.h"
 
-void SQLiteDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) {
+void SQLiteDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) {
 	ExecuteInsert("INSERT INTO ugc_modular_build (ugc_id, ldf_config, character_id) VALUES (?,?,?)", bigId, modules, characterId);
 }
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.cpp

@@ -32,27 +32,27 @@ std::vector<std::string> TestSQLDatabase::GetApprovedCharacterNames() {
 	return {};
 }
 
-std::vector<FriendData> TestSQLDatabase::GetFriendsList(LWOOBJID charID) {
+std::vector<FriendData> TestSQLDatabase::GetFriendsList(uint32_t charID) {
 	return {};
 }
 
-std::optional<IFriends::BestFriendStatus> TestSQLDatabase::GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
+std::optional<IFriends::BestFriendStatus> TestSQLDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
 	return {};
 }
 
-void TestSQLDatabase::SetBestFriendStatus(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId, const uint32_t bestFriendStatus) {
+void TestSQLDatabase::SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) {
 
 }
 
-void TestSQLDatabase::AddFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) {
+void TestSQLDatabase::AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) {
 
 }
 
-void TestSQLDatabase::RemoveFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) {
+void TestSQLDatabase::RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) {
 
 }
 
-void TestSQLDatabase::UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) {
+void TestSQLDatabase::UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
 
 }
 
@@ -80,7 +80,7 @@ void TestSQLDatabase::InsertMigration(const std::string_view str) {
 
 }
 
-std::optional<ICharInfo::Info> TestSQLDatabase::GetCharacterInfo(const LWOOBJID charId) {
+std::optional<ICharInfo::Info> TestSQLDatabase::GetCharacterInfo(const uint32_t charId) {
 	return {};
 }
 
@@ -88,11 +88,11 @@ std::optional<ICharInfo::Info> TestSQLDatabase::GetCharacterInfo(const std::stri
 	return {};
 }
 
-std::string TestSQLDatabase::GetCharacterXml(const LWOOBJID accountId) {
+std::string TestSQLDatabase::GetCharacterXml(const uint32_t accountId) {
 	return {};
 }
 
-void TestSQLDatabase::UpdateCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) {
+void TestSQLDatabase::UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
 
 }
 
@@ -104,27 +104,27 @@ void TestSQLDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 
 }
 
-void TestSQLDatabase::InsertCharacterXml(const LWOOBJID accountId, const std::string_view lxfml) {
+void TestSQLDatabase::InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) {
 
 }
 
-std::vector<LWOOBJID> TestSQLDatabase::GetAccountCharacterIds(LWOOBJID accountId) {
+std::vector<uint32_t> TestSQLDatabase::GetAccountCharacterIds(uint32_t accountId) {
 	return {};
 }
 
-void TestSQLDatabase::DeleteCharacter(const LWOOBJID characterId) {
+void TestSQLDatabase::DeleteCharacter(const uint32_t characterId) {
 
 }
 
-void TestSQLDatabase::SetCharacterName(const LWOOBJID characterId, const std::string_view name) {
+void TestSQLDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
 
 }
 
-void TestSQLDatabase::SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) {
+void TestSQLDatabase::SetPendingCharacterName(const uint32_t characterId, const std::string_view name) {
 
 }
 
-void TestSQLDatabase::UpdateLastLoggedInCharacter(const LWOOBJID characterId) {
+void TestSQLDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
 
 }
 
@@ -192,11 +192,11 @@ void TestSQLDatabase::InsertNewMail(const MailInfo& mail) {
 
 }
 
-void TestSQLDatabase::InsertNewUgcModel(std::stringstream& sd0Data, const uint64_t blueprintId, const uint32_t accountId, const LWOOBJID characterId) {
+void TestSQLDatabase::InsertNewUgcModel(std::stringstream& sd0Data, const uint32_t blueprintId, const uint32_t accountId, const uint32_t characterId) {
 
 }
 
-std::vector<MailInfo> TestSQLDatabase::GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> TestSQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
 	return {};
 }
 
@@ -204,7 +204,7 @@ std::optional<MailInfo> TestSQLDatabase::GetMail(const uint64_t mailId) {
 	return {};
 }
 
-uint32_t TestSQLDatabase::GetUnreadMailCount(const LWOOBJID characterId) {
+uint32_t TestSQLDatabase::GetUnreadMailCount(const uint32_t characterId) {
 	return {};
 }
 
@@ -220,7 +220,7 @@ void TestSQLDatabase::ClaimMailItem(const uint64_t mailId) {
 
 }
 
-void TestSQLDatabase::InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) {
+void TestSQLDatabase::InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) {
 
 }
 
@@ -244,7 +244,7 @@ void TestSQLDatabase::SetMasterInfo(const IServers::MasterInfo& info) {
 
 }
 
-std::optional<uint64_t> TestSQLDatabase::GetCurrentPersistentId() {
+std::optional<uint32_t> TestSQLDatabase::GetCurrentPersistentId() {
 	return {};
 }
 
@@ -252,6 +252,10 @@ void TestSQLDatabase::InsertDefaultPersistentId() {
 
 }
 
+void TestSQLDatabase::UpdatePersistentId(const uint32_t id) {
+
+}
+
 std::optional<uint32_t> TestSQLDatabase::GetDonationTotal(const uint32_t activityId) {
 	return {};
 }
@@ -264,15 +268,15 @@ std::vector<IUgc::Model> TestSQLDatabase::GetUgcModels(const LWOOBJID& propertyI
 	return {};
 }
 
-void TestSQLDatabase::AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
+void TestSQLDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
 
 }
 
-void TestSQLDatabase::RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
+void TestSQLDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
 
 }
 
-std::vector<IIgnoreList::Info> TestSQLDatabase::GetIgnoreList(const LWOOBJID playerId) {
+std::vector<IIgnoreList::Info> TestSQLDatabase::GetIgnoreList(const uint32_t playerId) {
 	return {};
 }
 
@@ -300,6 +304,3 @@ void TestSQLDatabase::UpdateAccountGmLevel(const uint32_t accountId, const eGame
 
 }
 
-IObjectIdTracker::Range TestSQLDatabase::GetPersistentIdRange() {
-	return {};
-}

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -17,31 +17,31 @@ class TestSQLDatabase : public GameDatabase {
 
 	std::vector<std::string> GetApprovedCharacterNames() override;
 
-	std::vector<FriendData> GetFriendsList(LWOOBJID charID) override;
+	std::vector<FriendData> GetFriendsList(uint32_t charID) override;
 
-	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) override;
-	void SetBestFriendStatus(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId, const uint32_t bestFriendStatus) override;
-	void AddFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) override;
-	void RemoveFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) override;
-	void UpdateActivityLog(const LWOOBJID characterId, const eActivityType activityType, const LWOMAPID mapId) override;
+	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) override;
+	void SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) override;
+	void AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
+	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
 	void DeleteUgcModelData(const LWOOBJID& modelId) override;
 	void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) override;
 	std::vector<IUgc::Model> GetAllUgcModels() override;
 	void CreateMigrationHistoryTable() override;
 	bool IsMigrationRun(const std::string_view str) override;
 	void InsertMigration(const std::string_view str) override;
-	std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) override;
 	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
-	std::string GetCharacterXml(const LWOOBJID accountId) override;
-	void UpdateCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) override;
+	std::string GetCharacterXml(const uint32_t accountId) override;
+	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
 	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
 	void InsertNewCharacter(const ICharInfo::Info info) override;
-	void InsertCharacterXml(const LWOOBJID accountId, const std::string_view lxfml) override;
-	std::vector<LWOOBJID> GetAccountCharacterIds(LWOOBJID accountId) override;
-	void DeleteCharacter(const LWOOBJID characterId) override;
-	void SetCharacterName(const LWOOBJID characterId, const std::string_view name) override;
-	void SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) override;
-	void UpdateLastLoggedInCharacter(const LWOOBJID characterId) override;
+	void InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) override;
+	std::vector<uint32_t> GetAccountCharacterIds(uint32_t accountId) override;
+	void DeleteCharacter(const uint32_t characterId) override;
+	void SetCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) override;
+	void UpdateLastLoggedInCharacter(const uint32_t characterId) override;
 	void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) override;
 	std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) override;
 	std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) override;
@@ -60,30 +60,30 @@ class TestSQLDatabase : public GameDatabase {
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
 		std::stringstream& sd0Data,
-		const uint64_t blueprintId,
+		const uint32_t blueprintId,
 		const uint32_t accountId,
-		const LWOOBJID characterId) override;
-	std::vector<MailInfo> GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) override;
+		const uint32_t characterId) override;
+	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
 	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
-	uint32_t GetUnreadMailCount(const LWOOBJID characterId) override;
+	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
 	void MarkMailRead(const uint64_t mailId) override;
 	void DeleteMail(const uint64_t mailId) override;
 	void ClaimMailItem(const uint64_t mailId) override;
-	void InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) override;
+	void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) override;
 	void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) override;
 	void UpdateAccountBan(const uint32_t accountId, const bool banned) override;
 	void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) override;
 	void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) override;
 	void SetMasterInfo(const IServers::MasterInfo& info) override;
-	std::optional<uint64_t> GetCurrentPersistentId() override;
-	IObjectIdTracker::Range GetPersistentIdRange() override;
+	std::optional<uint32_t> GetCurrentPersistentId() override;
 	void InsertDefaultPersistentId() override;
+	void UpdatePersistentId(const uint32_t id) override;
 	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
 	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
 	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
-	void AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
-	void RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
-	std::vector<IIgnoreList::Info> GetIgnoreList(const LWOOBJID playerId) override;
+	void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
 	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
 	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
 	void AddBehavior(const IBehaviors::Info& info) override;
@@ -95,19 +95,17 @@ class TestSQLDatabase : public GameDatabase {
 	std::vector<ILeaderboard::Entry> GetAscendingLeaderboard(const uint32_t activityId) override { return {}; };
 	std::vector<ILeaderboard::Entry> GetNsLeaderboard(const uint32_t activityId) override { return {}; };
 	std::vector<ILeaderboard::Entry> GetAgsLeaderboard(const uint32_t activityId) override { return {}; };
-	void SaveScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) override {};
-	void UpdateScore(const LWOOBJID playerId, const uint32_t gameId, const Score& score) override {};
-	std::optional<ILeaderboard::Score> GetPlayerScore(const LWOOBJID playerId, const uint32_t gameId) override { return {}; };
-	void IncrementNumWins(const LWOOBJID playerId, const uint32_t gameId) override {};
-	void IncrementTimesPlayed(const LWOOBJID playerId, const uint32_t gameId) override {};
-	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) override {};
+	void SaveScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override {};
+	void UpdateScore(const uint32_t playerId, const uint32_t gameId, const Score& score) override {};
+	std::optional<ILeaderboard::Score> GetPlayerScore(const uint32_t playerId, const uint32_t gameId) override { return {}; };
+	void IncrementNumWins(const uint32_t playerId, const uint32_t gameId) override {};
+	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override {};
+	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override {};
 	void DeleteUgcBuild(const LWOOBJID bigId) override {};
 	uint32_t GetAccountCount() override { return 0; };
 
 	bool IsNameInUse(const std::string_view name) override { return false; };
-	std::optional<IPropertyContents::Model> GetModel(const LWOOBJID modelID) override { return {}; }
-	std::optional<IProperty::Info> GetPropertyInfo(const LWOOBJID id) override { return {}; }
-	std::optional<IUgc::Model> GetUgcModel(const LWOOBJID ugcId) override { return {}; }
+	IPropertyContents::Model GetModel(const LWOOBJID modelID) override { return {}; }
 };
 
 #endif  //!TESTSQLDATABASE_H

dDatabase/ModelNormalizeMigration.cpp

@@ -10,7 +10,7 @@ void ModelNormalizeMigration::Run() {
 	for (auto& [lxfmlData, id, modelID] : Database::Get()->GetAllUgcModels()) {
 		const auto model = Database::Get()->GetModel(modelID);
 		// only BBB models (lot 14) and models with a position of NiPoint3::ZERO need to have their position fixed.
-		if (!model || model->position != NiPoint3Constant::ZERO || model->lot != 14) continue;
+		if (model.position != NiPoint3Constant::ZERO || model.lot != 14) continue;
 	
 		Sd0 sd0(lxfmlData);
 		const auto asStr = sd0.GetAsStringUncompressed();
@@ -23,7 +23,7 @@ void ModelNormalizeMigration::Run() {
 		LOG("Updated model %llu to have a center of %f %f %f", modelID, newCenter.x, newCenter.y, newCenter.z);
 		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
 		auto asStream = sd0.GetAsStream();
-		Database::Get()->UpdateModel(model->id, newCenter, model->rotation, model->behaviors);
+		Database::Get()->UpdateModel(model.id, newCenter, model.rotation, model.behaviors);
 		Database::Get()->UpdateUgcModelData(id, asStream);
 	}
 	Database::Get()->SetAutoCommit(oldCommit);
@@ -35,15 +35,15 @@ void ModelNormalizeMigration::RunAfterFirstPart() {
 	for (auto& [lxfmlData, id, modelID] : Database::Get()->GetAllUgcModels()) {
 		const auto model = Database::Get()->GetModel(modelID);
 		// only BBB models (lot 14) need to have their position fixed from the above blunder
-		if (!model || model->lot != 14) continue;
+		if (model.lot != 14) continue;
 	
 		Sd0 sd0(lxfmlData);
 		const auto asStr = sd0.GetAsStringUncompressed();
-		const auto [newLxfml, newCenter] = Lxfml::NormalizePositionAfterFirstPart(asStr, model->position);
+		const auto [newLxfml, newCenter] = Lxfml::NormalizePositionAfterFirstPart(asStr, model.position);
 
 		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
 		auto asStream = sd0.GetAsStream();
-		Database::Get()->UpdateModel(model->id, newCenter, model->rotation, model->behaviors);
+		Database::Get()->UpdateModel(model.id, newCenter, model.rotation, model.behaviors);
 		Database::Get()->UpdateUgcModelData(id, asStream);
 	}
 	Database::Get()->SetAutoCommit(oldCommit);
@@ -55,16 +55,16 @@ void ModelNormalizeMigration::RunBrickBuildGrid() {
 	for (auto& [lxfmlData, id, modelID] : Database::Get()->GetAllUgcModels()) {
 		const auto model = Database::Get()->GetModel(modelID);
 		// only BBB models (lot 14) need to have their position fixed from the above blunder
-		if (!model || model->lot != 14) continue;
+		if (model.lot != 14) continue;
 	
 		Sd0 sd0(lxfmlData);
 		const auto asStr = sd0.GetAsStringUncompressed();
-		const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr, model->position);
+		const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr, model.position);
 
 		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
 		LOG("Updated model %llu to have a center of %f %f %f", modelID, newCenter.x, newCenter.y, newCenter.z);
 		auto asStream = sd0.GetAsStream();
-		Database::Get()->UpdateModel(model->id, newCenter, model->rotation, model->behaviors);
+		Database::Get()->UpdateModel(model.id, newCenter, model.rotation, model.behaviors);
 		Database::Get()->UpdateUgcModelData(id, asStream);
 	}
 	Database::Get()->SetAutoCommit(oldCommit);

dGame/Character.cpp

@@ -23,7 +23,7 @@
 #include "ePlayerFlag.h"
 #include "CDPlayerFlagsTable.h"
 
-Character::Character(LWOOBJID id, User* parentUser) {
+Character::Character(uint32_t id, User* parentUser) {
 	//First load the name, etc:
 	m_ID = id;
 	m_ParentUser = parentUser;
@@ -50,10 +50,6 @@ void Character::UpdateInfoFromDatabase() {
 
 	//Load the xmlData now:
 	m_XMLData = Database::Get()->GetCharacterXml(m_ID);
-	if (m_XMLData.empty()) {
-		LOG("Character %s (%llu) has no xml data!", m_Name.c_str(), m_ID);
-		return;
-	}
 
 	m_ZoneID = 0; //TEMP! Set back to 0 when done. This is so we can see loading screen progress for testing.
 	m_ZoneInstanceID = 0; //These values don't really matter, these are only used on the char select screen and seem unused.
@@ -65,6 +61,7 @@ void Character::UpdateInfoFromDatabase() {
 	//Set our objectID:
 	m_ObjectID = m_ID;
 	GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);
 
 	m_OurEntity = nullptr;
 	m_BuildMode = false;
@@ -78,7 +75,7 @@ void Character::DoQuickXMLDataParse() {
 	if (m_XMLData.size() == 0) return;
 
 	if (m_Doc.Parse(m_XMLData.c_str(), m_XMLData.size()) == 0) {
-		LOG("Loaded xmlData for character %s (%llu)!", m_Name.c_str(), m_ID);
+		LOG("Loaded xmlData for character %s (%i)!", m_Name.c_str(), m_ID);
 	} else {
 		LOG("Failed to load xmlData (%i) (%s) (%s)!", m_Doc.ErrorID(), m_Doc.ErrorIDToName(m_Doc.ErrorID()), m_Doc.ErrorStr());
 		//Server::rakServer->CloseConnection(m_ParentUser->GetSystemAddress(), true);
@@ -241,7 +238,7 @@ void Character::SetBuildMode(bool buildMode) {
 void Character::SaveXMLToDatabase() {
 	// Check that we can actually _save_ before saving
 	if (!m_OurEntity) {
-		LOG("%llu:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
+		LOG("%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
 		return;
 	}
 
@@ -311,7 +308,7 @@ void Character::SaveXMLToDatabase() {
 	//For metrics, log the time it took to save:
 	auto end = std::chrono::system_clock::now();
 	std::chrono::duration<double> elapsed = end - start;
-	LOG("%llu:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
+	LOG("%i:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
 }
 
 void Character::SetIsNewLogin() {
@@ -323,7 +320,7 @@ void Character::SetIsNewLogin() {
 	while (currentChild) {
 		auto* nextChild = currentChild->NextSiblingElement();
 		if (currentChild->Attribute("si")) {
-			LOG("Removed session flag (%s) from character %llu:%s, saving character to database", currentChild->Attribute("si"), GetID(), GetName().c_str());
+			LOG("Removed session flag (%s) from character %i:%s, saving character to database", currentChild->Attribute("si"), GetID(), GetName().c_str());
 			flags->DeleteChild(currentChild);
 			WriteToDatabase();
 		}
@@ -336,11 +333,8 @@ void Character::WriteToDatabase() {
 	tinyxml2::XMLPrinter printer(0, true, 0);
 	m_Doc.Print(&printer);
 
-	// Update the xml on the character for future use if needed
-	m_XMLData = printer.CStr();
-
 	//Finally, save to db:
-	Database::Get()->UpdateCharacterXml(m_ID, m_XMLData);
+	Database::Get()->UpdateCharacterXml(m_ID, printer.CStr());
 }
 
 void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {

dGame/Character.h

@@ -23,7 +23,7 @@ enum class eLootSourceType : uint32_t;
  */
 class Character {
 public:
-	Character(LWOOBJID id, User* parentUser);
+	Character(uint32_t id, User* parentUser);
 	~Character();
 
 	/**
@@ -53,7 +53,7 @@ public:
 	 * Gets the database ID of the character
 	 * @return the database ID of the character
 	 */
-	LWOOBJID GetID() const { return m_ID; }
+	uint32_t GetID() const { return m_ID; }
 
 	/**
 	 * Gets the (custom) name of the character
@@ -467,9 +467,9 @@ public:
 private:
 	void UpdateInfoFromDatabase();
 	/**
-	 * The ID of this character.
+	 * The ID of this character. First 32 bits of the ObjectID.
 	 */
-	LWOOBJID m_ID{};
+	uint32_t m_ID{};
 
 	/**
 	 * The 64-bit unique ID used in the game.

dGame/EntityManager.cpp

@@ -52,43 +52,6 @@ std::vector<LOT> EntityManager::m_GhostingExcludedLOTs = {
 	4967
 };
 
-template<typename T>
-void ParseDelimSetting(std::set<T>& setting, const std::string_view settingName, const char delim = ',') {
-	const auto str = Game::config->GetValue(settingName.data());
-	setting.clear();
-	for (const auto& strVal : GeneralUtils::SplitString(str, delim)) {
-		const auto val = GeneralUtils::TryParse<T>(strVal);
-		if (val) {
-			setting.insert(val.value());
-		}
-	}
-}
-
-void EntityManager::ReloadConfig() {
-	auto hcmode = Game::config->GetValue("hardcore_mode");
-	m_HardcoreMode = hcmode.empty() ? false : (hcmode == "1");
-	auto hcUscorePercent = Game::config->GetValue("hardcore_lose_uscore_on_death_percent");
-	m_HardcoreLoseUscoreOnDeathPercent = hcUscorePercent.empty() ? 10 : GeneralUtils::TryParse<uint32_t>(hcUscorePercent).value_or(10);
-	auto hcUscoreMult = Game::config->GetValue("hardcore_uscore_enemies_multiplier");
-	m_HardcoreUscoreEnemiesMultiplier = hcUscoreMult.empty() ? 2 : GeneralUtils::TryParse<uint32_t>(hcUscoreMult).value_or(2);
-	auto hcDropInv = Game::config->GetValue("hardcore_dropinventory_on_death");
-	m_HardcoreDropinventoryOnDeath = hcDropInv.empty() ? false : (hcDropInv == "1");
-	ParseDelimSetting<LOT>(m_HardcoreExcludedItemDrops, "hardcore_excluded_item_drops");
-
-	// We don't need to save the worlds, just need to check if this one is in the list
-	std::set<LWOMAPID> worlds;
-	ParseDelimSetting<LWOMAPID>(worlds, "hardcore_uscore_reduced_worlds");
-	m_HardcoreUscoreReduced = worlds.contains(Game::zoneManager->GetZoneID().GetMapID());
-
-	ParseDelimSetting<LOT>(m_HardcoreUscoreReducedLots, "hardcore_uscore_reduced_lots");
-	ParseDelimSetting<LOT>(m_HardcoreUscoreExcludedEnemies, "hardcore_uscore_excluded_enemies");
-	ParseDelimSetting<LWOMAPID>(m_HardcoreDisabledWorlds, "hardcore_disabled_worlds");
-
-	auto hcXpReduction = Game::config->GetValue("hardcore_uscore_reduction");
-	m_HardcoreUscoreReduction = hcXpReduction.empty() ? 1.0f : GeneralUtils::TryParse<float>(hcXpReduction).value_or(1.0f);
-	m_HardcoreMode = GetHardcoreDisabledWorlds().contains(Game::zoneManager->GetZoneID().GetMapID()) ? false : m_HardcoreMode;
-}
-
 void EntityManager::Initialize() {
 	// Check if this zone has ghosting enabled
 	m_GhostingEnabled = std::find(
@@ -98,8 +61,15 @@ void EntityManager::Initialize() {
 	) == m_GhostingExcludedZones.end();
 
 	// grab hardcore mode settings and load them with sane defaults
-	Game::config->AddConfigHandler([]() {Game::entityManager->ReloadConfig();});
-	Game::entityManager->ReloadConfig();
+	auto hcmode = Game::config->GetValue("hardcore_mode");
+	m_HardcoreMode = hcmode.empty() ? false : (hcmode == "1");
+	auto hcUscorePercent = Game::config->GetValue("hardcore_lose_uscore_on_death_percent");
+	m_HardcoreLoseUscoreOnDeathPercent = hcUscorePercent.empty() ? 10 : std::stoi(hcUscorePercent);
+	auto hcUscoreMult = Game::config->GetValue("hardcore_uscore_enemies_multiplier");
+	m_HardcoreUscoreEnemiesMultiplier = hcUscoreMult.empty() ? 2 : std::stoi(hcUscoreMult);
+	auto hcDropInv = Game::config->GetValue("hardcore_dropinventory_on_death");
+	m_HardcoreDropinventoryOnDeath = hcDropInv.empty() ? false : (hcDropInv == "1");
+
 	// If cloneID is not zero, then hardcore mode is disabled
 	// aka minigames and props
 	if (Game::zoneManager->GetZoneID().GetCloneID() != 0) m_HardcoreMode = false;

dGame/EntityManager.h

@@ -75,18 +75,11 @@ public:
 	const uint32_t GetHardcoreLoseUscoreOnDeathPercent() { return m_HardcoreLoseUscoreOnDeathPercent; };
 	const bool GetHardcoreDropinventoryOnDeath() { return m_HardcoreDropinventoryOnDeath; };
 	const uint32_t GetHardcoreUscoreEnemiesMultiplier() { return m_HardcoreUscoreEnemiesMultiplier; };
-	const std::set<LOT>& GetHardcoreExcludedItemDrops() { return m_HardcoreExcludedItemDrops; };
-	const float& GetHardcoreUscoreReduction() const { return m_HardcoreUscoreReduction; };
-	bool GetHardcoreUscoreReduced() const { return m_HardcoreUscoreReduced; };
-	const std::set<LOT>& GetHardcoreUscoreReducedLots() const { return m_HardcoreUscoreReducedLots; };
-	const std::set<LOT>& GetHardcoreUscoreExcludedEnemies() const { return m_HardcoreUscoreExcludedEnemies; };
-	const std::set<LWOMAPID>& GetHardcoreDisabledWorlds() const { return m_HardcoreDisabledWorlds; };
 
 	// Messaging
 	bool SendMessage(GameMessages::GameMsg& msg) const;
 
 private:
-	void ReloadConfig();
 	void SerializeEntities();
 	void KillEntities();
 	void DeleteEntities();
@@ -119,12 +112,6 @@ private:
 	uint32_t m_HardcoreLoseUscoreOnDeathPercent;
 	bool m_HardcoreDropinventoryOnDeath;
 	uint32_t m_HardcoreUscoreEnemiesMultiplier;
-	std::set<LOT> m_HardcoreExcludedItemDrops;
-	float m_HardcoreUscoreReduction{};
-	bool m_HardcoreUscoreReduced{};
-	std::set<LOT> m_HardcoreUscoreReducedLots{};
-	std::set<LOT> m_HardcoreUscoreExcludedEnemies{};
-	std::set<LWOMAPID> m_HardcoreDisabledWorlds{};
 };
 
 #endif // ENTITYMANAGER_H

dGame/LeaderboardManager.cpp

@@ -145,7 +145,7 @@ void QueryToLdf(Leaderboard& leaderboard, const std::vector<ILeaderboard::Entry>
 	}
 }
 
-std::vector<ILeaderboard::Entry> FilterToNumResults(const std::vector<ILeaderboard::Entry>& leaderboard, const LWOOBJID relatedPlayer, const Leaderboard::InfoType infoType, const uint32_t numResults) {
+std::vector<ILeaderboard::Entry> FilterToNumResults(const std::vector<ILeaderboard::Entry>& leaderboard, const uint32_t relatedPlayer, const Leaderboard::InfoType infoType, const uint32_t numResults) {
 	std::vector<ILeaderboard::Entry> toReturn;
 
 	int32_t index = 0;
@@ -197,7 +197,7 @@ std::vector<ILeaderboard::Entry> FilterWeeklies(const std::vector<ILeaderboard::
 	return weeklyLeaderboard;
 }
 
-std::vector<ILeaderboard::Entry> FilterFriends(const std::vector<ILeaderboard::Entry>& leaderboard, const LWOOBJID relatedPlayer) {
+std::vector<ILeaderboard::Entry> FilterFriends(const std::vector<ILeaderboard::Entry>& leaderboard, const uint32_t relatedPlayer) {
 	// Filter the leaderboard to only include friends of the player
 	auto friendOfPlayer = Database::Get()->GetFriendsList(relatedPlayer);
 	std::vector<ILeaderboard::Entry> friendsLeaderboard;
@@ -217,7 +217,7 @@ std::vector<ILeaderboard::Entry> ProcessLeaderboard(
 	const std::vector<ILeaderboard::Entry>& leaderboard,
 	const bool weekly,
 	const Leaderboard::InfoType infoType,
-	const LWOOBJID relatedPlayer,
+	const uint32_t relatedPlayer,
 	const uint32_t numResults) {
 	std::vector<ILeaderboard::Entry> toReturn;
 

dGame/User.cpp

@@ -5,12 +5,12 @@
 #include "Logger.h"
 #include "Game.h"
 #include "dZoneManager.h"
-#include "eServerDisconnectIdentifiers.h"
 #include "eGameMasterLevel.h"
 #include "BitStreamUtils.h"
 #include "MessageType/Chat.h"
 #include <chrono>
 #include <ctime>
+#include "CommonPackets.h"
 
 User::User(const SystemAddress& sysAddr, const std::string& username, const std::string& sessionKey) {
 	m_AccountID = 0;
@@ -39,11 +39,11 @@ User::User(const SystemAddress& sysAddr, const std::string& username, const std:
 	if (Game::server->GetZoneID() != 0) {
 		auto characterList = Database::Get()->GetAccountCharacterIds(m_AccountID);
 		if (!characterList.empty()) {
-			const auto lastUsedCharacterId = characterList.front();
+			const uint32_t lastUsedCharacterId = characterList.front();
 			Character* character = new Character(lastUsedCharacterId, this);
 			character->UpdateFromDatabase();
 			m_Characters.push_back(character);
-			LOG("Loaded %llu as it is the last used char", lastUsedCharacterId);
+			LOG("Loaded %i as it is the last used char", lastUsedCharacterId);
 		}
 	}
 }
@@ -132,7 +132,10 @@ void User::UserOutOfSync() {
 	if (m_AmountOfTimesOutOfSync > m_MaxDesyncAllowed) {
 		//YEET
 		LOG("User %s was out of sync %i times out of %i, disconnecting for suspected speedhacking.", m_Username.c_str(), m_AmountOfTimesOutOfSync, m_MaxDesyncAllowed);
-		Game::server->Disconnect(this->m_SystemAddress, eServerDisconnectIdentifiers::PLAY_SCHEDULE_TIME_DONE);
+		CommonPackets::DisconnectNotify notification;
+		notification.disconnectID = eServerDisconnectIdentifiers::PLAY_SCHEDULE_TIME_DONE;
+		notification.Send(this->m_SystemAddress);
+		Game::server->Disconnect(this->m_SystemAddress);
 	}
 }
 

dGame/UserManager.cpp

@@ -30,7 +30,6 @@
 #include "BitStreamUtils.h"
 #include "CheatDetection.h"
 #include "CharacterComponent.h"
-#include "eCharacterVersion.h"
 
 UserManager* UserManager::m_Address = nullptr;
 
@@ -325,77 +324,79 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 		LOG("AccountID: %i is creating a character with name: %s (temporary: %s)", u->GetAccountID(), name.c_str(), predefinedName.c_str());
 	}
 
-	//Now that the name is ok, we can get a persistent ObjectID:
-	LWOOBJID objectID = ObjectIDManager::GetPersistentID();
-	const uint32_t maxRetries = 100;
-	uint32_t tries = 0;
-	while (Database::Get()->GetCharacterInfo(objectID) && tries < maxRetries) {
-		tries++;
-		LOG("Found a duplicate character %llu, getting a new objectID", objectID);
-		objectID = ObjectIDManager::GetPersistentID();
-	}
+	//Now that the name is ok, we can get an objectID from Master:
+	ObjectIDManager::RequestPersistentID([=, this](uint32_t objectID) {
+		if (Database::Get()->GetCharacterInfo(objectID)) {
+			LOG("Character object id unavailable, check object_id_tracker!");
+			WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
+			return;
+		}
 
-	if (tries >= maxRetries) {
-		LOG("Failed to get a unique objectID for new character after %i tries, aborting char creation for account %i", maxRetries, u->GetAccountID());
-		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
-		return;
-	}
+		std::stringstream xml;
+		xml << "<obj v=\"1\">";
 
-	std::stringstream xml;
-	xml << "<obj v=\"1\">";
+		xml << "<mf hc=\"" << hairColor << "\" hs=\"" << hairStyle << "\" hd=\"0\" t=\"" << shirtColor << "\" l=\"" << pantsColor;
+		xml << "\" hdc=\"0\" cd=\"" << shirtStyle << "\" lh=\"" << lh << "\" rh=\"" << rh << "\" es=\"" << eyebrows << "\" ";
+		xml << "ess=\"" << eyes << "\" ms=\"" << mouth << "\"/>";
 
-	xml << "<mf hc=\"" << hairColor << "\" hs=\"" << hairStyle << "\" hd=\"0\" t=\"" << shirtColor << "\" l=\"" << pantsColor;
-	xml << "\" hdc=\"0\" cd=\"" << shirtStyle << "\" lh=\"" << lh << "\" rh=\"" << rh << "\" es=\"" << eyebrows << "\" ";
-	xml << "ess=\"" << eyes << "\" ms=\"" << mouth << "\"/>";
+		xml << "<char acct=\"" << u->GetAccountID() << "\" cc=\"0\" gm=\"0\" ft=\"0\" llog=\"" << time(NULL) << "\" ";
+		xml << "ls=\"0\" lzx=\"-626.5847\" lzy=\"613.3515\" lzz=\"-28.6374\" lzrx=\"0.0\" lzry=\"0.7015\" lzrz=\"0.0\" lzrw=\"0.7126\" ";
+		xml << "stt=\"0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;\">";
+		xml << "<vl><l id=\"1000\" cid=\"0\"/></vl>";
 
-	xml << "<char acct=\"" << u->GetAccountID() << "\" cc=\"0\" gm=\"0\" ft=\"0\" llog=\"" << time(NULL) << "\" ";
-	xml << "ls=\"0\" lzx=\"-626.5847\" lzy=\"613.3515\" lzz=\"-28.6374\" lzrx=\"0.0\" lzry=\"0.7015\" lzrz=\"0.0\" lzrw=\"0.7126\" ";
-	xml << "stt=\"0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;\">";
-	xml << "<vl><l id=\"1000\" cid=\"0\"/></vl>";
+		xml << "</char>";
 
-	xml << "</char>";
+		xml << "<dest hm=\"4\" hc=\"4\" im=\"0\" ic=\"0\" am=\"0\" ac=\"0\" d=\"0\"/>";
 
-	xml << "<dest hm=\"4\" hc=\"4\" im=\"0\" ic=\"0\" am=\"0\" ac=\"0\" d=\"0\"/>";
+		xml << "<inv><bag><b t=\"0\" m=\"20\"/><b t=\"1\" m=\"40\"/><b t=\"2\" m=\"240\"/><b t=\"3\" m=\"240\"/><b t=\"14\" m=\"40\"/></bag><items><in t=\"0\">";
 
-	xml << "<inv><bag><b t=\"0\" m=\"20\"/><b t=\"1\" m=\"40\"/><b t=\"2\" m=\"240\"/><b t=\"3\" m=\"240\"/><b t=\"14\" m=\"40\"/></bag><items><in t=\"0\">";
+		LWOOBJID lwoidforshirt = ObjectIDManager::GenerateRandomObjectID();
+		LWOOBJID lwoidforpants;
 
-	LWOOBJID lwoidforshirt = ObjectIDManager::GetPersistentID();
-	LWOOBJID lwoidforpants = ObjectIDManager::GetPersistentID();
+		do {
+			lwoidforpants = ObjectIDManager::GenerateRandomObjectID();
+		} while (lwoidforpants == lwoidforshirt); //Make sure we don't have the same ID for both shirt and pants
 
-	xml << "<i l=\"" << shirtLOT << "\" id=\"" << lwoidforshirt << "\" s=\"0\" c=\"1\" eq=\"1\" b=\"1\"/>";
-	xml << "<i l=\"" << pantsLOT << "\" id=\"" << lwoidforpants << "\" s=\"1\" c=\"1\" eq=\"1\" b=\"1\"/>";
+		GeneralUtils::SetBit(lwoidforshirt, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(lwoidforshirt, eObjectBits::PERSISTENT);
+		GeneralUtils::SetBit(lwoidforpants, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(lwoidforpants, eObjectBits::PERSISTENT);
 
-	xml << "</in></items></inv><lvl l=\"1\" cv=\"" << GeneralUtils::ToUnderlying(eCharacterVersion::UP_TO_DATE) << "\" sb=\"500\"/><flag></flag></obj>";
+		xml << "<i l=\"" << shirtLOT << "\" id=\"" << lwoidforshirt << "\" s=\"0\" c=\"1\" eq=\"1\" b=\"1\"/>";
+		xml << "<i l=\"" << pantsLOT << "\" id=\"" << lwoidforpants << "\" s=\"1\" c=\"1\" eq=\"1\" b=\"1\"/>";
 
-	//Check to see if our name was pre-approved:
-	bool nameOk = IsNamePreapproved(name);
-	if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
+		xml << "</in></items></inv><lvl l=\"1\" cv=\"1\" sb=\"500\"/><flag></flag></obj>";
 
-	// If predefined name is invalid, change it to be their object id
-	// that way more than one player can create characters if the predefined name files are not provided
-	auto assignedPredefinedName = predefinedName;
-	if (assignedPredefinedName == "INVALID") {
-		std::stringstream nameObjID;
-		nameObjID << "minifig" << objectID;
-		assignedPredefinedName = nameObjID.str();
-	}
+		//Check to see if our name was pre-approved:
+		bool nameOk = IsNamePreapproved(name);
+		if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
 
-	std::string_view nameToAssign = !name.empty() && nameOk ? name : assignedPredefinedName;
-	std::string pendingName = !name.empty() && !nameOk ? name : "";
+		// If predefined name is invalid, change it to be their object id
+		// that way more than one player can create characters if the predefined name files are not provided
+		auto assignedPredefinedName = predefinedName;
+		if (assignedPredefinedName == "INVALID") {
+			std::stringstream nameObjID;
+			nameObjID << "minifig" << objectID;
+			assignedPredefinedName = nameObjID.str();
+		}
 
-	ICharInfo::Info info;
-	info.name = nameToAssign;
-	info.pendingName = pendingName;
-	info.id = objectID;
-	info.accountId = u->GetAccountID();
+		std::string_view nameToAssign = !name.empty() && nameOk ? name : assignedPredefinedName;
+		std::string pendingName = !name.empty() && !nameOk ? name : "";
 
-	Database::Get()->InsertNewCharacter(info);
+		ICharInfo::Info info;
+		info.name = nameToAssign;
+		info.pendingName = pendingName;
+		info.id = objectID;
+		info.accountId = u->GetAccountID();
 
-	//Now finally insert our character xml:
-	Database::Get()->InsertCharacterXml(objectID, xml.str());
+		Database::Get()->InsertNewCharacter(info);
 
-	WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
-	UserManager::RequestCharacterList(sysAddr);
+		//Now finally insert our character xml:
+		Database::Get()->InsertCharacterXml(objectID, xml.str());
+
+		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
+		UserManager::RequestCharacterList(sysAddr);
+		});
 }
 
 void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet) {
@@ -408,8 +409,9 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 	CINSTREAM_SKIP_HEADER;
 	LWOOBJID objectID;
 	inStream.Read(objectID);
+	uint32_t charID = static_cast<uint32_t>(objectID);
 
-	LOG("Received char delete req for ID: %llu", objectID);
+	LOG("Received char delete req for ID: %llu (%u)", objectID, charID);
 
 	bool hasCharacter = CheatDetection::VerifyLwoobjidIsSender(
 		objectID,
@@ -421,8 +423,8 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 	if (!hasCharacter) {
 		WorldPackets::SendCharacterDeleteResponse(sysAddr, false);
 	} else {
-		LOG("Deleting character %llu", objectID);
-		Database::Get()->DeleteCharacter(objectID);
+		LOG("Deleting character %i", charID);
+		Database::Get()->DeleteCharacter(charID);
 
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::UNEXPECTED_DISCONNECT);
@@ -443,8 +445,11 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 	CINSTREAM_SKIP_HEADER;
 	LWOOBJID objectID;
 	inStream.Read(objectID);
+	GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
+	GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);
 
-	LOG("Received char rename request for ID: %llu", objectID);
+	uint32_t charID = static_cast<uint32_t>(objectID);
+	LOG("Received char rename request for ID: %llu (%u)", objectID, charID);
 
 	LUWString LUWStringName;
 	inStream.Read(LUWStringName);
@@ -461,7 +466,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 		u->GetAccountID());
 
 	auto unusedItr = std::find_if(u->GetCharacters().begin(), u->GetCharacters().end(), [&](Character* c) {
-		if (c->GetID() == objectID) {
+		if (c->GetID() == charID) {
 			character = c;
 			return true;
 		}
@@ -478,12 +483,12 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 		if (!Database::Get()->GetCharacterInfo(newName)) {
 			if (IsNamePreapproved(newName)) {
-				Database::Get()->SetCharacterName(objectID, newName);
+				Database::Get()->SetCharacterName(charID, newName);
 				LOG("Character %s now known as %s", character->GetName().c_str(), newName.c_str());
 				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 			} else {
-				Database::Get()->SetPendingCharacterName(objectID, newName);
+				Database::Get()->SetPendingCharacterName(charID, newName);
 				LOG("Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
 				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
@@ -497,7 +502,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 	}
 }
 
-void UserManager::LoginCharacter(const SystemAddress& sysAddr, LWOOBJID playerID) {
+void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID) {
 	User* u = GetUser(sysAddr);
 	if (!u) {
 		LOG("Couldn't get user to log in character");

dGame/UserManager.h

@@ -35,7 +35,7 @@ public:
 	void CreateCharacter(const SystemAddress& sysAddr, Packet* packet);
 	void DeleteCharacter(const SystemAddress& sysAddr, Packet* packet);
 	void RenameCharacter(const SystemAddress& sysAddr, Packet* packet);
-	void LoginCharacter(const SystemAddress& sysAddr, LWOOBJID playerID);
+	void LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID);
 
 	void SaveAllActiveCharacters();
 

dGame/dComponents/ActivityComponent.h

@@ -353,7 +353,7 @@ private:
 	/**
 	 * The database information for this activity
 	 */
-	CDActivities m_ActivityInfo{};
+	CDActivities m_ActivityInfo;
 
 	/**
 	 * All the active instances of this activity

dGame/dComponents/DestroyableComponent.cpp

@@ -37,7 +37,6 @@
 #include "eMissionTaskType.h"
 #include "eStateChangeType.h"
 #include "eGameActivity.h"
-#include <ranges>
 
 #include "CDComponentsRegistryTable.h"
 
@@ -667,6 +666,11 @@ void DestroyableComponent::Damage(uint32_t damage, const LWOOBJID source, uint32
 		return;
 	}
 
+	//check if hardcore mode is enabled
+	if (Game::entityManager->GetHardcoreMode()) {
+		DoHardcoreModeDrops(source);
+	}
+
 	Smash(source, eKillType::VIOLENT, u"", skillID);
 }
 
@@ -694,11 +698,6 @@ void DestroyableComponent::NotifySubscribers(Entity* attacker, uint32_t damage)
 }
 
 void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType, const std::u16string& deathType, uint32_t skillID) {
-	//check if hardcore mode is enabled
-	if (Game::entityManager->GetHardcoreMode()) {
-		DoHardcoreModeDrops(source);
-	}
-
 	if (m_iHealth > 0) {
 		SetArmor(0);
 		SetHealth(0);
@@ -982,8 +981,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 		auto* character = m_Parent->GetComponent<CharacterComponent>();
 		auto uscore = character->GetUScore();
 
-		auto uscoreToLose = static_cast<uint64_t>(uscore * (Game::entityManager->GetHardcoreLoseUscoreOnDeathPercent() / 100.0f));
-		LOG("Player %llu has lost %llu uscore!", m_Parent->GetObjectID(), uscoreToLose);
+		auto uscoreToLose = uscore * (Game::entityManager->GetHardcoreLoseUscoreOnDeathPercent() / 100);
 		character->SetUScore(uscore - uscoreToLose);
 
 		GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::MISSION);
@@ -997,11 +995,13 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 				if (items) {
 					auto itemMap = items->GetItems();
 					if (!itemMap.empty()) {
-						for (const auto item : itemMap | std::views::values) {
-							// Don't drop excluded items or null ones
-							if (!item || Game::entityManager->GetHardcoreExcludedItemDrops().contains(item->GetLot())) continue;
-							GameMessages::SendDropClientLoot(m_Parent, source, item->GetLot(), 0, m_Parent->GetPosition(), item->GetCount());
-							item->SetCount(0, false, false);
+						for (const auto& item : itemMap) {
+							//drop the item:
+							if (!item.second) continue;
+							// don't drop the thinkng cap
+							if (item.second->GetLot() == 6086) continue;
+							GameMessages::SendDropClientLoot(m_Parent, source, item.second->GetLot(), 0, m_Parent->GetPosition(), item.second->GetCount());
+							item.second->SetCount(0, false, false);
 						}
 						Game::entityManager->SerializeEntity(m_Parent);
 					}
@@ -1020,25 +1020,24 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 			//drop all coins:
 			GameMessages::SendDropClientLoot(m_Parent, source, LOT_NULL, coins, m_Parent->GetPosition());
 		}
+
+		// Reload the player since we can't normally reduce uscore from the server and we want the UI to update
+		// do this last so we don't get killed.... again
+		Game::entityManager->DestructEntity(m_Parent);
+		Game::entityManager->ConstructEntity(m_Parent);
 		return;
 	}
 
 	//award the player some u-score:
 	auto* player = Game::entityManager->GetEntity(source);
 	if (player && player->IsPlayer()) {
-		const auto lot = m_Parent->GetLOT();
 		auto* playerStats = player->GetComponent<CharacterComponent>();
-		if (playerStats && GetMaxHealth() > 0 && !Game::entityManager->GetHardcoreUscoreExcludedEnemies().contains(lot)) {
+		if (playerStats) {
 			//get the maximum health from this enemy:
 			auto maxHealth = GetMaxHealth();
-			const auto uscoreMultiplier = Game::entityManager->GetHardcoreUscoreEnemiesMultiplier();
-			const bool isUscoreReducedLot =
-			Game::entityManager->GetHardcoreUscoreReducedLots().contains(lot) ||
-			Game::entityManager->GetHardcoreUscoreReduced();
-			const auto uscoreReduction = isUscoreReducedLot ? Game::entityManager->GetHardcoreUscoreReduction() : 1.0f;
 
-			int uscore = maxHealth * Game::entityManager->GetHardcoreUscoreEnemiesMultiplier() * uscoreReduction;
-			LOG("Rewarding player %llu with %i uscore for killing enemy %i", player->GetObjectID(), uscore, lot);
+			int uscore = maxHealth * Game::entityManager->GetHardcoreUscoreEnemiesMultiplier();
+
 			playerStats->SetUScore(playerStats->GetUScore() + uscore);
 			GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::MISSION);
 

dGame/dComponents/InventoryComponent.cpp

@@ -626,8 +626,7 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument& document) {
 	for (const auto& pair : this->m_Inventories) {
 		auto* inventory = pair.second;
 
-		static const auto EXCLUDED_INVENTORIES = {VENDOR_BUYBACK, MODELS_IN_BBB, ITEM_SETS};
-		if (std::ranges::find(EXCLUDED_INVENTORIES, inventory->GetType()) != EXCLUDED_INVENTORIES.end()) {
+		if (inventory->GetType() == VENDOR_BUYBACK || inventory->GetType() == eInventoryType::MODELS_IN_BBB) {
 			continue;
 		}
 
@@ -1787,9 +1786,3 @@ void InventoryComponent::LoadGroupXml(const tinyxml2::XMLElement& groups) {
 		groupElement = groupElement->NextSiblingElement("grp");
 	}
 }
-
-void InventoryComponent::RegenerateItemIDs() {
-	for (auto* const inventory : m_Inventories | std::views::values) {
-		inventory->RegenerateItemIDs();
-	}
-}

dGame/dComponents/InventoryComponent.h

@@ -402,14 +402,10 @@ public:
 	bool SetSkill(BehaviorSlot slot, uint32_t skillId);
 
 	void UpdateGroup(const GroupUpdate& groupUpdate);
-
-	std::unordered_map<LWOOBJID, DatabasePet>& GetPetsMut() { return m_Pets; };
+	void RemoveGroup(const std::string& groupId);
 
 	void FixInvisibleItems();
 
-	// Used to migrate a character version, no need to call outside of that context
-	void RegenerateItemIDs();
-
 	~InventoryComponent() override;
 
 private:

dGame/dComponents/MissionComponent.cpp

@@ -19,7 +19,6 @@
 #include "MissionPrerequisites.h"
 #include "AchievementCacheKey.h"
 #include "eMissionState.h"
-#include "StringifiedEnum.h"
 
  // MARK: Mission Component
 
@@ -137,7 +136,6 @@ void MissionComponent::RemoveMission(uint32_t missionId) {
 }
 
 void MissionComponent::Progress(eMissionTaskType type, int32_t value, LWOOBJID associate, const std::string& targets, int32_t count, bool ignoreAchievements) {
-	LOG("Progressing missions %s %i %llu %s %s", StringifiedEnum::ToString(type).data(), value, associate, targets.c_str(), ignoreAchievements ? "(ignoring achievements)" : "");
 	std::vector<uint32_t> acceptedAchievements;
 	if (count > 0 && !ignoreAchievements) {
 		acceptedAchievements = LookForAchievements(type, value, true, associate, targets, count);

dGame/dComponents/PetComponent.cpp

@@ -479,19 +479,10 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
 		return;
 	}
 
-	LWOOBJID petSubKey = ObjectIDManager::GetPersistentID();
-	const uint32_t maxTries = 100;
-	uint32_t tries = 0;
-	while (Database::Get()->GetPetNameInfo(petSubKey) && tries < maxTries) {
-		tries++;
-		LOG("Found a duplicate pet %llu, getting a new subKey", petSubKey);
-		petSubKey = ObjectIDManager::GetPersistentID();
-	}
+	LWOOBJID petSubKey = ObjectIDManager::GenerateRandomObjectID();
 
-	if (tries >= maxTries) {
-		LOG("Failed to get a unique pet subKey after %i tries, aborting pet creation for player %i", maxTries, tamer->GetCharacter() ? tamer->GetCharacter()->GetID() : -1);
-		return;
-	}
+	GeneralUtils::SetBit(petSubKey, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(petSubKey, eObjectBits::PERSISTENT);
 
 	m_DatabaseId = petSubKey;
 

dGame/dComponents/PropertyEntranceComponent.cpp

@@ -135,7 +135,7 @@ void PropertyEntranceComponent::OnPropertyEntranceSync(Entity* entity, bool incl
 		const auto owner = propertyEntry.ownerId;
 		const auto otherCharacter = Database::Get()->GetCharacterInfo(owner);
 		if (!otherCharacter.has_value()) {
-			LOG("Failed to find property owner name for %llu!", owner);
+			LOG("Failed to find property owner name for %u!", owner);
 			continue;
 		}
 		auto& entry = entries.emplace_back();

dGame/dComponents/PropertyManagementComponent.cpp

@@ -64,6 +64,7 @@ PropertyManagementComponent::PropertyManagementComponent(Entity* parent) : Compo
 		this->propertyId = propertyInfo->id;
 		this->owner = propertyInfo->ownerId;
 		GeneralUtils::SetBit(this->owner, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(this->owner, eObjectBits::PERSISTENT);
 		this->clone_Id = propertyInfo->cloneId;
 		this->propertyName = propertyInfo->name;
 		this->propertyDescription = propertyInfo->description;
@@ -170,7 +171,7 @@ void PropertyManagementComponent::UpdatePropertyDetails(std::string name, std::s
 	info.name = propertyName;
 	info.description = propertyDescription;
 	info.lastUpdatedTime = std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
-
+	
 	Database::Get()->UpdateLastSave(info);
 	Database::Get()->UpdatePropertyDetails(info);
 
@@ -203,22 +204,14 @@ bool PropertyManagementComponent::Claim(const LWOOBJID playerId) {
 
 	auto prop_path = zone->GetPath(m_Parent->GetVarAsString(u"propertyName"));
 
-	if (prop_path) {
+	if (prop_path){
 		if (!prop_path->property.displayName.empty()) name = prop_path->property.displayName;
 		description = prop_path->property.displayDesc;
 	}
 
 	SetOwnerId(playerId);
 
-	// Due to legacy IDs being random
-	propertyId = ObjectIDManager::GetPersistentID();
-	const uint32_t maxTries = 100;
-	uint32_t tries = 0;
-	while (Database::Get()->GetPropertyInfo(propertyId) && tries < maxTries) {
-		tries++;
-		LOG("Found a duplicate property %llu, getting a new propertyId", propertyId);
-		propertyId = ObjectIDManager::GetPersistentID();
-	}
+	propertyId = ObjectIDManager::GenerateRandomObjectID();
 
 	IProperty::Info info;
 	info.id = propertyId;
@@ -382,45 +375,46 @@ void PropertyManagementComponent::UpdateModelPosition(const LWOOBJID id, const N
 	node->position = position;
 	node->rotation = rotation;
 
-	SpawnerInfo info{};
+	ObjectIDManager::RequestPersistentID([this, node, modelLOT, entity, position, rotation, originalRotation](uint32_t persistentId) {
+		SpawnerInfo info{};
 
-	info.templateID = modelLOT;
-	info.nodes = { node };
-	info.templateScale = 1.0f;
-	info.activeOnLoad = true;
-	info.amountMaintained = 1;
-	info.respawnTime = 10;
+		info.templateID = modelLOT;
+		info.nodes = { node };
+		info.templateScale = 1.0f;
+		info.activeOnLoad = true;
+		info.amountMaintained = 1;
+		info.respawnTime = 10;
 
-	info.emulated = true;
-	info.emulator = Game::entityManager->GetZoneControlEntity()->GetObjectID();
+		info.emulated = true;
+		info.emulator = Game::entityManager->GetZoneControlEntity()->GetObjectID();
 
-	info.spawnerID = ObjectIDManager::GetPersistentID();
-	GeneralUtils::SetBit(info.spawnerID, eObjectBits::CLIENT);
+		info.spawnerID = persistentId;
+		GeneralUtils::SetBit(info.spawnerID, eObjectBits::CLIENT);
 
-	const auto spawnerId = Game::zoneManager->MakeSpawner(info);
+		const auto spawnerId = Game::zoneManager->MakeSpawner(info);
 
-	auto* spawner = Game::zoneManager->GetSpawner(spawnerId);
+		auto* spawner = Game::zoneManager->GetSpawner(spawnerId);
 
-	info.nodes[0]->config.push_back(new LDFData<LWOOBJID>(u"modelBehaviors", 0));
-	info.nodes[0]->config.push_back(new LDFData<LWOOBJID>(u"userModelID", info.spawnerID));
-	info.nodes[0]->config.push_back(new LDFData<int>(u"modelType", 2));
-	info.nodes[0]->config.push_back(new LDFData<bool>(u"propertyObjectID", true));
-	info.nodes[0]->config.push_back(new LDFData<int>(u"componentWhitelist", 1));
+		info.nodes[0]->config.push_back(new LDFData<LWOOBJID>(u"modelBehaviors", 0));
+		info.nodes[0]->config.push_back(new LDFData<LWOOBJID>(u"userModelID", info.spawnerID));
+		info.nodes[0]->config.push_back(new LDFData<int>(u"modelType", 2));
+		info.nodes[0]->config.push_back(new LDFData<bool>(u"propertyObjectID", true));
+		info.nodes[0]->config.push_back(new LDFData<int>(u"componentWhitelist", 1));
 
-	auto* model = spawner->Spawn();
-	auto* modelComponent = model->GetComponent<ModelComponent>();
-	if (modelComponent) modelComponent->Pause();
+		auto* model = spawner->Spawn();
+		auto* modelComponent = model->GetComponent<ModelComponent>();
+		if (modelComponent) modelComponent->Pause();
 
-	models.insert_or_assign(model->GetObjectID(), spawnerId);
+		models.insert_or_assign(model->GetObjectID(), spawnerId);
 
-	GameMessages::SendPlaceModelResponse(entity->GetObjectID(), entity->GetSystemAddress(), position, m_Parent->GetObjectID(), 14, originalRotation);
+		GameMessages::SendPlaceModelResponse(entity->GetObjectID(), entity->GetSystemAddress(), position, m_Parent->GetObjectID(), 14, originalRotation);
 
-	GameMessages::SendUGCEquipPreCreateBasedOnEditMode(entity->GetObjectID(), entity->GetSystemAddress(), 0, spawnerId);
+		GameMessages::SendUGCEquipPreCreateBasedOnEditMode(entity->GetObjectID(), entity->GetSystemAddress(), 0, spawnerId);
 
-	GameMessages::SendGetModelsOnProperty(entity->GetObjectID(), GetModels(), UNASSIGNED_SYSTEM_ADDRESS);
-
-	Game::entityManager->GetZoneControlEntity()->OnZonePropertyModelPlaced(entity);
+		GameMessages::SendGetModelsOnProperty(entity->GetObjectID(), GetModels(), UNASSIGNED_SYSTEM_ADDRESS);
 
+		Game::entityManager->GetZoneControlEntity()->OnZonePropertyModelPlaced(entity);
+		});
 	// Progress place model missions
 	auto missionComponent = entity->GetComponent<MissionComponent>();
 	if (missionComponent != nullptr) missionComponent->Progress(eMissionTaskType::PLACE_MODEL, 0);
@@ -628,6 +622,8 @@ void PropertyManagementComponent::Load() {
 		//BBB property models need to have extra stuff set for them:
 		if (databaseModel.lot == 14) {
 			LWOOBJID blueprintID = databaseModel.ugcId;
+			GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
 
 			settings.push_back(new LDFData<LWOOBJID>(u"blueprintid", blueprintID));
 			settings.push_back(new LDFData<int>(u"componentWhitelist", 1));
@@ -700,7 +696,7 @@ void PropertyManagementComponent::Save() {
 		// save the behaviors of the model
 		for (const auto& [behaviorId, behaviorStr] : modelBehaviors) {
 			if (behaviorStr.empty() || behaviorId == -1 || behaviorId == 0) continue;
-			IBehaviors::Info info{
+			IBehaviors::Info info {
 				.behaviorId = behaviorId,
 				.characterId = character->GetID(),
 				.behaviorInfo = behaviorStr
@@ -828,7 +824,7 @@ void PropertyManagementComponent::OnChatMessageReceived(const std::string& sMess
 		if (!model) continue;
 		auto* const modelComponent = model->GetComponent<ModelComponent>();
 		if (!modelComponent) continue;
-
+		
 		modelComponent->OnChatMessageReceived(sMessage);
 	}
 }

dGame/dComponents/ScriptComponent.cpp

@@ -5,18 +5,16 @@
 
 #include "Entity.h"
 #include "ScriptComponent.h"
-#include "GameMessages.h"
-#include "Amf3.h"
-
-ScriptComponent::ScriptComponent(Entity* parent, const std::string& scriptName, bool serialized, bool client) : Component(parent) {
-	using namespace GameMessages;
 
+ScriptComponent::ScriptComponent(Entity* parent, std::string scriptName, bool serialized, bool client) : Component(parent) {
 	m_Serialized = serialized;
 	m_Client = client;
-	m_ScriptName = scriptName;
 
 	SetScript(scriptName);
-	RegisterMsg<GetObjectReportInfo>(this, &ScriptComponent::OnGetObjectReportInfo);
+}
+
+ScriptComponent::~ScriptComponent() {
+
 }
 
 void ScriptComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
@@ -52,16 +50,3 @@ void ScriptComponent::SetScript(const std::string& scriptName) {
 	// and they may also be used by other script components so DON'T delete them.
 	m_Script = CppScripts::GetScript(m_Parent, scriptName);
 }
-
-bool ScriptComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
-	auto& infoMsg = static_cast<GameMessages::GetObjectReportInfo&>(msg);
-
-	auto& scriptInfo = infoMsg.info->PushDebug("Script");
-	scriptInfo.PushDebug<AMFStringValue>("Script Name") = m_ScriptName.empty() ? "None" : m_ScriptName;
-	auto& networkSettings = scriptInfo.PushDebug("Network Settings");
-	for (const auto* const setting : m_Parent->GetNetworkSettings()) {
-		networkSettings.PushDebug<AMFStringValue>(GeneralUtils::UTF16ToWTF8(setting->GetKey())) = setting->GetValueAsString();
-	}
-
-	return true;
-}

dGame/dComponents/ScriptComponent.h

@@ -21,7 +21,8 @@ class ScriptComponent final : public Component {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::SCRIPT;
 
-	ScriptComponent(Entity* parent, const std::string& scriptName, bool serialized, bool client = false);
+	ScriptComponent(Entity* parent, std::string scriptName, bool serialized, bool client = false);
+	~ScriptComponent() override;
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
@@ -42,8 +43,6 @@ public:
 	 * @param scriptName the name of the script to find
 	 */
 	void SetScript(const std::string& scriptName);
-	
-	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
 
 private:
 
@@ -61,8 +60,6 @@ private:
 	 * Whether or not this script is a client script
 	 */
 	bool m_Client;
-
-	std::string m_ScriptName;
 };
 
 #endif // SCRIPTCOMPONENT_H

dGame/dGameMessages/GameMessages.cpp

@@ -2555,7 +2555,7 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 
 	uint32_t sd0Size;
 	inStream.Read(sd0Size);
-	std::unique_ptr<char[]> sd0Data(new char[sd0Size]);
+	std::shared_ptr<char[]> sd0Data(new char[sd0Size]);
 
 	if (sd0Data == nullptr) return;
 
@@ -2579,121 +2579,118 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 
 	//Now, the cave of dragons:
 
+	//We runs this in async because the http library here is blocking, meaning it'll halt the thread.
+	//But we don't want the server to go unresponsive, because then the client would disconnect.
+
 	//We need to get a new ID for our model first:
-	if (!entity || !entity->GetCharacter() || !entity->GetCharacter()->GetParentUser()) return;
-	const uint32_t maxRetries = 100;
-	uint32_t retries = 0;
-	bool blueprintIDExists = true;
-	bool modelExists = true;
+	ObjectIDManager::RequestPersistentID([=](uint32_t newID) {
+		if (!entity || !entity->GetCharacter() || !entity->GetCharacter()->GetParentUser()) return;
+		LWOOBJID newIDL = newID;
+		GeneralUtils::SetBit(newIDL, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(newIDL, eObjectBits::PERSISTENT);
 
-	// Legacy logic to check for old random IDs (regenerating these is not really feasible)
-	// Probably good to have this anyway in case someone messes with the last_object_id or it gets reset somehow
-	LWOOBJID newIDL = LWOOBJID_EMPTY;
-	LWOOBJID blueprintID = LWOOBJID_EMPTY;
-	do {
-		if (newIDL != LWOOBJID_EMPTY) LOG("Generating blueprintID for UGC model, collision with existing model ID: %llu", blueprintID);
-		newIDL = ObjectIDManager::GetPersistentID();
-		blueprintID = ObjectIDManager::GetPersistentID();
-		++retries;
-		blueprintIDExists = Database::Get()->GetUgcModel(blueprintID).has_value();
-		modelExists = Database::Get()->GetModel(newIDL).has_value();
-	} while ((blueprintIDExists || modelExists) && retries < maxRetries);
+		uint32_t blueprintIDSmall = ObjectIDManager::GenerateRandomObjectID();
+		LWOOBJID blueprintID = blueprintIDSmall;
+		GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
 
-	//We need to get the propertyID: (stolen from Wincent's propertyManagementComp)
-	const auto& worldId = Game::zoneManager->GetZone()->GetZoneID();
+		//We need to get the propertyID: (stolen from Wincent's propertyManagementComp)
+		const auto& worldId = Game::zoneManager->GetZone()->GetZoneID();
 
-	const auto zoneId = worldId.GetMapID();
-	const auto cloneId = worldId.GetCloneID();
+		const auto zoneId = worldId.GetMapID();
+		const auto cloneId = worldId.GetCloneID();
 
-	auto propertyInfo = Database::Get()->GetPropertyInfo(zoneId, cloneId);
-	LWOOBJID propertyId = LWOOBJID_EMPTY;
-	if (propertyInfo) propertyId = propertyInfo->id;
+		auto propertyInfo = Database::Get()->GetPropertyInfo(zoneId, cloneId);
+		LWOOBJID propertyId = LWOOBJID_EMPTY;
+		if (propertyInfo) propertyId = propertyInfo->id;
 
-	// Save the binary data to the Sd0 buffer
-	std::string str(sd0Data.get(), sd0Size);
-	std::istringstream sd0DataStream(str);
-	Sd0 sd0(sd0DataStream);
+		// Save the binary data to the Sd0 buffer
+		std::string str(sd0Data.get(), sd0Size);
+		std::istringstream sd0DataStream(str);
+		Sd0 sd0(sd0DataStream);
 
-	// Uncompress the data and normalize the position
-	const auto asStr = sd0.GetAsStringUncompressed();
-	const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr);
+		// Uncompress the data and normalize the position
+		const auto asStr = sd0.GetAsStringUncompressed();
+		const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr);
 
-	// Recompress the data and save to the database
-	sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
-	auto sd0AsStream = sd0.GetAsStream();
-	Database::Get()->InsertNewUgcModel(sd0AsStream, blueprintID, entity->GetCharacter()->GetParentUser()->GetAccountID(), entity->GetCharacter()->GetID());
+		// Recompress the data and save to the database
+		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
+		auto sd0AsStream = sd0.GetAsStream();
+		Database::Get()->InsertNewUgcModel(sd0AsStream, blueprintIDSmall, entity->GetCharacter()->GetParentUser()->GetAccountID(), entity->GetCharacter()->GetID());
 
-	//Insert into the db as a BBB model:
-	IPropertyContents::Model model;
-	model.id = newIDL;
-	model.ugcId = blueprintID;
-	model.position = newCenter;
-	model.rotation = NiQuaternion(0.0f, 0.0f, 0.0f, 0.0f);
-	model.lot = 14;
-	Database::Get()->InsertNewPropertyModel(propertyId, model, "Objects_14_name");
+		//Insert into the db as a BBB model:
+		IPropertyContents::Model model;
+		model.id = newIDL;
+		model.ugcId = blueprintIDSmall;
+		model.position = newCenter;
+		model.rotation = NiQuaternion(0.0f, 0.0f, 0.0f, 0.0f);
+		model.lot = 14;
+		Database::Get()->InsertNewPropertyModel(propertyId, model, "Objects_14_name");
 
-	/*
-		Commented out until UGC server would be updated to use a sd0 file instead of lxfml stream.
-		(or you uncomment the lxfml decomp stuff above)
-	*/
+		/*
+			Commented out until UGC server would be updated to use a sd0 file instead of lxfml stream.
+			(or you uncomment the lxfml decomp stuff above)
+		*/
 
-	// //Send off to UGC for processing, if enabled:
-	// if (Game::config->GetValue("ugc_remote") == "1") {
-	// 	std::string ugcIP = Game::config->GetValue("ugc_ip");
-	// 	int ugcPort = std::stoi(Game::config->GetValue("ugc_port"));
+		////Send off to UGC for processing, if enabled:
+		//if (Game::config->GetValue("ugc_remote") == "1") {
+		//	std::string ugcIP = Game::config->GetValue("ugc_ip");
+		//	int ugcPort = std::stoi(Game::config->GetValue("ugc_port"));
 
-	// 	httplib::Client cli(ugcIP, ugcPort); //connect to UGC HTTP server using our config above ^
+		//	httplib::Client cli(ugcIP, ugcPort); //connect to UGC HTTP server using our config above ^
 
-	// 	//Send out a request:
-	// 	std::string request = "/3dservices/UGCC150/150" + std::to_string(blueprintID) + ".lxfml";
-	// 	cli.Put(request.c_str(), lxfml.c_str(), "text/lxfml");
+		//	//Send out a request:
+		//	std::string request = "/3dservices/UGCC150/150" + std::to_string(blueprintID) + ".lxfml";
+		//	cli.Put(request.c_str(), lxfml.c_str(), "text/lxfml");
 
-	// 	//When the "put" above returns, it means that the UGC HTTP server is done processing our model &
-	// 	//the nif, hkx and checksum files are ready to be downloaded from cache.
-	// }
+		//	//When the "put" above returns, it means that the UGC HTTP server is done processing our model &
+		//	//the nif, hkx and checksum files are ready to be downloaded from cache.
+		//}
 
-	//Tell the client their model is saved: (this causes us to actually pop out of our current state):
-	const auto& newSd0 = sd0.GetAsVector();
-	uint32_t newSd0Size{};
-	for (const auto& chunk : newSd0) newSd0Size += chunk.size();
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::BLUEPRINT_SAVE_RESPONSE);
-	bitStream.Write(localId);
-	bitStream.Write(eBlueprintSaveResponseType::EverythingWorked);
-	bitStream.Write<uint32_t>(1);
-	bitStream.Write(blueprintID);
+		//Tell the client their model is saved: (this causes us to actually pop out of our current state):
+		const auto& newSd0 = sd0.GetAsVector();
+		uint32_t sd0Size{};
+		for (const auto& chunk : newSd0) sd0Size += chunk.size();
+		CBITSTREAM;
+		BitStreamUtils::WriteHeader(bitStream, ServiceType::CLIENT, MessageType::Client::BLUEPRINT_SAVE_RESPONSE);
+		bitStream.Write(localId);
+		bitStream.Write(eBlueprintSaveResponseType::EverythingWorked);
+		bitStream.Write<uint32_t>(1);
+		bitStream.Write(blueprintID);
 
-	bitStream.Write(newSd0Size);
+		bitStream.Write(sd0Size);
 
-	for (const auto& chunk : newSd0) bitStream.WriteAlignedBytes(reinterpret_cast<const unsigned char*>(chunk.data()), chunk.size());
+		for (const auto& chunk : newSd0) bitStream.WriteAlignedBytes(reinterpret_cast<const unsigned char*>(chunk.data()), chunk.size());
 
-	SEND_PACKET;
+		SEND_PACKET;
 
-	//Now we have to construct this object:
+		//Now we have to construct this object:
 
-	EntityInfo info;
-	info.lot = 14;
-	info.pos = newCenter;
-	info.rot = {};
-	info.spawner = nullptr;
-	info.spawnerID = entity->GetObjectID();
-	info.spawnerNodeID = 0;
+		EntityInfo info;
+		info.lot = 14;
+		info.pos = newCenter;
+		info.rot = {};
+		info.spawner = nullptr;
+		info.spawnerID = entity->GetObjectID();
+		info.spawnerNodeID = 0;
 
-	info.settings.push_back(new LDFData<LWOOBJID>(u"blueprintid", blueprintID));
-	info.settings.push_back(new LDFData<int>(u"componentWhitelist", 1));
-	info.settings.push_back(new LDFData<int>(u"modelType", 2));
-	info.settings.push_back(new LDFData<bool>(u"propertyObjectID", true));
-	info.settings.push_back(new LDFData<LWOOBJID>(u"userModelID", newIDL));
+		info.settings.push_back(new LDFData<LWOOBJID>(u"blueprintid", blueprintID));
+		info.settings.push_back(new LDFData<int>(u"componentWhitelist", 1));
+		info.settings.push_back(new LDFData<int>(u"modelType", 2));
+		info.settings.push_back(new LDFData<bool>(u"propertyObjectID", true));
+		info.settings.push_back(new LDFData<LWOOBJID>(u"userModelID", newIDL));
 
-	Entity* newEntity = Game::entityManager->CreateEntity(info, nullptr);
-	if (newEntity) {
-		Game::entityManager->ConstructEntity(newEntity);
+		Entity* newEntity = Game::entityManager->CreateEntity(info, nullptr);
+		if (newEntity) {
+			Game::entityManager->ConstructEntity(newEntity);
 
-		//Make sure the propMgmt doesn't delete our model after the server dies
-		//Trying to do this after the entity is constructed. Shouldn't really change anything but
-		//there was an issue with builds not appearing since it was placed above ConstructEntity.
-		PropertyManagementComponent::Instance()->AddModel(newEntity->GetObjectID(), newIDL);
-	}
+			//Make sure the propMgmt doesn't delete our model after the server dies
+			//Trying to do this after the entity is constructed. Shouldn't really change anything but
+			//there was an issue with builds not appearing since it was placed above ConstructEntity.
+			PropertyManagementComponent::Instance()->AddModel(newEntity->GetObjectID(), newIDL);
+		}
+
+		});
 }
 
 void GameMessages::HandlePropertyEntranceSync(RakNet::BitStream& inStream, Entity* entity, const SystemAddress& sysAddr) {
@@ -5532,52 +5529,55 @@ void GameMessages::HandleModularBuildFinish(RakNet::BitStream& inStream, Entity*
 			}
 		}
 
-		LOG("Build finished");
-		GameMessages::SendFinishArrangingWithItem(character, entity->GetObjectID()); // kick them from modular build
-		GameMessages::SendModularBuildEnd(character); // i dont know if this does anything but DLUv2 did it
+		ObjectIDManager::RequestPersistentID([=](uint32_t newId) {
+			LOG("Build finished");
+			GameMessages::SendFinishArrangingWithItem(character, entity->GetObjectID()); // kick them from modular build
+			GameMessages::SendModularBuildEnd(character); // i dont know if this does anything but DLUv2 did it
 
-		//inv->UnequipItem(inv->GetItemStackByLOT(6086, eInventoryType::ITEMS)); // take off the thinking cap
-		//Game::entityManager->SerializeEntity(entity);
+			//inv->UnequipItem(inv->GetItemStackByLOT(6086, eInventoryType::ITEMS)); // take off the thinking cap
+			//Game::entityManager->SerializeEntity(entity);
 
-		const auto moduleAssembly = new LDFData<std::u16string>(u"assemblyPartLOTs", modules);
+			const auto moduleAssembly = new LDFData<std::u16string>(u"assemblyPartLOTs", modules);
 
-		std::vector<LDFBaseData*> config;
-		config.push_back(moduleAssembly);
+			std::vector<LDFBaseData*> config;
+			config.push_back(moduleAssembly);
 
-		LWOOBJID newID = ObjectIDManager::GetPersistentID();
+			LWOOBJID newIdBig = newId;
+			GeneralUtils::SetBit(newIdBig, eObjectBits::CHARACTER);
 
-		if (count == 3) {
-			inv->AddItem(6416, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config, LWOOBJID_EMPTY, true, false, newID);
-		} else if (count == 7) {
-			inv->AddItem(8092, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config, LWOOBJID_EMPTY, true, false, newID);
-		}
-
-		auto* pCharacter = character->GetCharacter();
-		Database::Get()->InsertUgcBuild(GeneralUtils::UTF16ToWTF8(modules), newID, pCharacter ? std::optional(character->GetCharacter()->GetID()) : std::nullopt);
-
-		auto* missionComponent = character->GetComponent<MissionComponent>();
-
-		if (entity->GetLOT() != 9980 || Game::server->GetZoneID() != 1200) {
-			if (missionComponent != nullptr) {
-				missionComponent->Progress(eMissionTaskType::SCRIPT, entity->GetLOT(), entity->GetObjectID());
-				if (count >= 7 && everyPieceSwapped) missionComponent->Progress(eMissionTaskType::RACING, LWOOBJID_EMPTY, static_cast<LWOOBJID>(eRacingTaskParam::MODULAR_BUILDING));
+			if (count == 3) {
+				inv->AddItem(6416, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config, LWOOBJID_EMPTY, true, false, newIdBig);
+			} else if (count == 7) {
+				inv->AddItem(8092, 1, eLootSourceType::QUICKBUILD, eInventoryType::MODELS, config, LWOOBJID_EMPTY, true, false, newIdBig);
 			}
-		}
 
-		ScriptComponent* script = static_cast<ScriptComponent*>(entity->GetComponent(eReplicaComponentType::SCRIPT));
+			auto* pCharacter = character->GetCharacter();
+			Database::Get()->InsertUgcBuild(GeneralUtils::UTF16ToWTF8(modules), newIdBig, pCharacter ? std::optional(character->GetCharacter()->GetID()) : std::nullopt);
 
-		entity->GetScript()->OnModularBuildExit(entity, character, count >= 3, modList);
+			auto* missionComponent = character->GetComponent<MissionComponent>();
 
-		// Move remaining temp models back to models
-		std::vector<Item*> items;
+			if (entity->GetLOT() != 9980 || Game::server->GetZoneID() != 1200) {
+				if (missionComponent != nullptr) {
+					missionComponent->Progress(eMissionTaskType::SCRIPT, entity->GetLOT(), entity->GetObjectID());
+					if (count >= 7 && everyPieceSwapped) missionComponent->Progress(eMissionTaskType::RACING, LWOOBJID_EMPTY, static_cast<LWOOBJID>(eRacingTaskParam::MODULAR_BUILDING));
+				}
+			}
 
-		for (const auto& pair : temp->GetItems()) {
-			items.push_back(pair.second);
-		}
+			ScriptComponent* script = static_cast<ScriptComponent*>(entity->GetComponent(eReplicaComponentType::SCRIPT));
 
-		for (auto* item : items) {
-			inv->MoveItemToInventory(item, eInventoryType::MODELS, item->GetCount(), false);
-		}
+			entity->GetScript()->OnModularBuildExit(entity, character, count >= 3, modList);
+
+			// Move remaining temp models back to models
+			std::vector<Item*> items;
+
+			for (const auto& pair : temp->GetItems()) {
+				items.push_back(pair.second);
+			}
+
+			for (auto* item : items) {
+				inv->MoveItemToInventory(item, eInventoryType::MODELS, item->GetCount(), false);
+			}
+			});
 	}
 }
 

dGame/dInventory/Inventory.cpp

@@ -5,11 +5,8 @@
 #include "InventoryComponent.h"
 #include "eItemType.h"
 #include "eReplicaComponentType.h"
-#include "ObjectIDManager.h"
-#include "eObjectBits.h"
 
 #include "CDComponentsRegistryTable.h"
-#include <ranges>
 
 std::vector<LOT> Inventory::m_GameMasterRestrictedItems = {
 		1727, // GM Only - JetPack
@@ -320,16 +317,3 @@ Inventory::~Inventory() {
 
 	items.clear();
 }
-
-void Inventory::RegenerateItemIDs() {
-	std::map<LWOOBJID, Item*> newItems{};
-	for (auto* const item : items | std::views::values) {
-		const auto oldID = item->GetId();
-		const auto newID = item->GenerateID();
-		LOG("Updating item ID from %llu to %llu", oldID, newID);
-		newItems.insert_or_assign(newID, item);
-	}
-
-	// We don't want to delete the item pointers, we're just moving from map to map
-	items = newItems;
-}

dGame/dInventory/Inventory.h

@@ -158,8 +158,6 @@ public:
 	 */
 	void DeleteAllItems();
 
-	void RegenerateItemIDs();
-
 	~Inventory();
 
 private:

dGame/dInventory/Item.cpp

@@ -98,12 +98,22 @@ Item::Item(
 	this->preconditions = new PreconditionExpression(this->info->reqPrecondition);
 	this->subKey = subKey;
 
-	auto* const inventoryComponent = inventory->GetComponent();
-	GenerateID();
+	LWOOBJID id = ObjectIDManager::GenerateRandomObjectID();
+
+	GeneralUtils::SetBit(id, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(id, eObjectBits::PERSISTENT);
+
+	const auto type = static_cast<eItemType>(info->itemType);
+
+	if (type == eItemType::MOUNT) {
+		GeneralUtils::SetBit(id, eObjectBits::CLIENT);
+	}
+
+	this->id = id;
 
 	inventory->AddManagedItem(this);
 
-	auto* entity = inventoryComponent->GetParent();
+	auto* entity = inventory->GetComponent()->GetParent();
 	GameMessages::SendAddItemToInventoryClientSync(entity, entity->GetSystemAddress(), this, id, showFlyingLoot, static_cast<int>(this->count), subKey, lootSourceType);
 
 	if (isModMoveAndEquip) {
@@ -111,7 +121,7 @@ Item::Item(
 
 		LOG("Move and equipped (%i) from (%i)", this->lot, this->inventory->GetType());
 
-		Game::entityManager->SerializeEntity(inventoryComponent->GetParent());
+		Game::entityManager->SerializeEntity(inventory->GetComponent()->GetParent());
 	}
 }
 
@@ -564,28 +574,3 @@ void Item::LoadConfigXml(const tinyxml2::XMLElement& i) {
 		config.push_back(LDFBaseData::DataFromString(value));
 	}
 }
-
-LWOOBJID Item::GenerateID() {
-	auto* const inventoryComponent = inventory->GetComponent();
-	const bool isPlayer = inventoryComponent->GetParent()->IsPlayer();
-	LWOOBJID id{};
-
-	// Only players and non-proxy items get persistent IDs (since they are the only ones that will persist between worlds)
-	if (isPlayer && parent == LWOOBJID_EMPTY) {
-		id = ObjectIDManager::GetPersistentID();
-	} else {
-		id = ObjectIDManager::GenerateObjectID();
-		GeneralUtils::SetBit(id, eObjectBits::SPAWNED);
-		GeneralUtils::SetBit(id, eObjectBits::CLIENT);
-	}
-
-	LOG("Parent %llu lot %u Generated id %u:%llu", parent, GetLot(), static_cast<uint32_t>(id), id);
-	const auto type = static_cast<eItemType>(info->itemType);
-
-	if (type == eItemType::MOUNT) {
-		GeneralUtils::SetBit(id, eObjectBits::CLIENT);
-	}
-
-	this->id = id;
-	return id;
-}

dGame/dInventory/Item.h

@@ -228,8 +228,6 @@ public:
 
 	void LoadConfigXml(const tinyxml2::XMLElement& i);
 
-	LWOOBJID GenerateID();
-
 private:
 	/**
 	 * The object ID of this item

dGame/dMission/Mission.cpp

@@ -29,11 +29,6 @@
 #include "CDMissionEmailTable.h"
 #include "ChatPackets.h"
 #include "PlayerManager.h"
-#include "StringifiedEnum.h"
-
-namespace {
-	std::set<uint32_t> g_TestedMissions = {773, 774, 775, 776, 777}; // TODO Figure out why these missions are broken sometimes
-}
 
 Mission::Mission(MissionComponent* missionComponent, const uint32_t missionId) {
 	m_MissionComponent = missionComponent;
@@ -568,14 +563,12 @@ void Mission::YieldRewards() {
 
 void Mission::Progress(eMissionTaskType type, int32_t value, LWOOBJID associate, const std::string& targets, int32_t count) {
 	const auto isRemoval = count < 0;
-	const bool testedMission = GetTestedMissions().contains(GetMissionId());
-	if (testedMission) LOG("%i Removal: %s complete: %s achievement: %s", GetMissionId(), isRemoval ? "true" : "false", IsComplete() ? "true" : "false", IsAchievement() ? "true" : "false");
+
 	if (isRemoval && (IsComplete() || IsAchievement())) {
 		return;
 	}
 
 	for (auto* task : m_Tasks) {
-		if (testedMission) LOG("Complete: %s Type: %s TaskType: %s", task->IsComplete() ? "true" : "false", StringifiedEnum::ToString(type).data(), StringifiedEnum::ToString(task->GetType()).data());
 		if (task->IsComplete() && !isRemoval) {
 			continue;
 		}
@@ -625,7 +618,3 @@ Mission::~Mission() {
 
 	m_Tasks.clear();
 }
-
-const std::set<uint32_t>& Mission::GetTestedMissions() const {
-	return g_TestedMissions;
-}

dGame/dMission/Mission.h

@@ -241,9 +241,6 @@ public:
 	 * Sets the unique mission order ID of this mission
 	 */
 	void SetUniqueMissionOrderID(uint32_t value) { m_UniqueMissionID = value; };
-
-	const std::set<uint32_t>& GetTestedMissions() const;
-
 private:
 	/**
 	 * Progresses all the newly accepted tasks for this mission after it has been accepted to reflect the state of the

dGame/dMission/MissionTask.cpp

@@ -15,7 +15,6 @@
 #include "MissionComponent.h"
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
-#include "StringifiedEnum.h"
 
 MissionTask::MissionTask(Mission* mission, CDMissionTasks* info, uint32_t mask) {
 	this->info = info;
@@ -100,7 +99,6 @@ Mission* MissionTask::GetMission() const {
 
 
 uint32_t MissionTask::GetTarget() const {
-	if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("Target: %i", info->targetValue);
 	return info->target;
 }
 
@@ -160,7 +158,6 @@ bool MissionTask::InParameters(const uint32_t value) const {
 
 
 bool MissionTask::IsComplete() const {
-	if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("uid: %i target: %i", info->uid, info->targetValue);
 	// Mission 668 has task uid 984 which is a bit mask.  Its completion value is 3.
 	if (info->uid == 984) {
 		return progress >= 3;
@@ -171,7 +168,6 @@ bool MissionTask::IsComplete() const {
 
 
 void MissionTask::Complete() {
-	if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("target: %i", info->targetValue);
 	SetProgress(info->targetValue);
 }
 
@@ -184,7 +180,6 @@ void MissionTask::CheckCompletion() const {
 
 
 void MissionTask::Progress(int32_t value, LWOOBJID associate, const std::string& targets, int32_t count) {
-	if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("Progressing mission %s %i", StringifiedEnum::ToString(GetType()).data(), value);
 	if (IsComplete() && count > 0) return;
 
 	const auto type = GetType();
@@ -234,7 +229,7 @@ void MissionTask::Progress(int32_t value, LWOOBJID associate, const std::string&
 		entity = Game::entityManager->GetEntity(associate);
 		if (entity == nullptr) {
 			if (associate != LWOOBJID_EMPTY) {
-				if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("Failed to find associated entity (%llu)!", associate);
+				LOG("Failed to find associated entity (%llu)!", associate);
 			}
 			break;
 		}

dGame/dPropertyBehaviors/ControlBehaviors.cpp

@@ -35,21 +35,25 @@
 void ControlBehaviors::RequestUpdatedID(ControlBehaviorContext& context) {
 	BehaviorMessageBase msgBase{ context.arguments };
 	const auto oldBehaviorID = msgBase.GetBehaviorId();
-	if (!context) {
-		LOG("Model to update behavior ID for is null. Cannot update ID.");
-		return;
-	}
-	LWOOBJID persistentIdBig = ObjectIDManager::GetPersistentID();
-	// This updates the behavior ID of the behavior should this be a new behavior
-	AMFArrayValue args;
+	ObjectIDManager::RequestPersistentID(
+		[context, oldBehaviorID](uint32_t persistentId) {
+			if (!context) {
+				LOG("Model to update behavior ID for is null. Cannot update ID.");
+				return;
+			}
+			LWOOBJID persistentIdBig = persistentId;
+			GeneralUtils::SetBit(persistentIdBig, eObjectBits::CHARACTER);
+			// This updates the behavior ID of the behavior should this be a new behavior
+			AMFArrayValue args;
 
-	args.Insert("behaviorID", std::to_string(persistentIdBig));
-	args.Insert("objectID", std::to_string(context.modelComponent->GetParent()->GetObjectID()));
+			args.Insert("behaviorID", std::to_string(persistentIdBig));
+			args.Insert("objectID", std::to_string(context.modelComponent->GetParent()->GetObjectID()));
 
-	GameMessages::SendUIMessageServerToSingleClient(context.modelOwner, context.modelOwner->GetSystemAddress(), "UpdateBehaviorID", args);
-	context.modelComponent->UpdatePendingBehaviorId(persistentIdBig, oldBehaviorID);
+			GameMessages::SendUIMessageServerToSingleClient(context.modelOwner, context.modelOwner->GetSystemAddress(), "UpdateBehaviorID", args);
+			context.modelComponent->UpdatePendingBehaviorId(persistentIdBig, oldBehaviorID);
 
-	ControlBehaviors::Instance().SendBehaviorListToClient(context);
+			ControlBehaviors::Instance().SendBehaviorListToClient(context);
+		});
 }
 
 void ControlBehaviors::SendBehaviorListToClient(const ControlBehaviorContext& context) {

dGame/dUtilities/CheatDetection.cpp

@@ -76,8 +76,8 @@ void LogAndSaveFailedAntiCheatCheck(const LWOOBJID& id, const SystemAddress& sys
 		auto* user = UserManager::Instance()->GetUser(sysAddr);
 		
 		if (user) {
-			LOG("User at system address (%s) (%s) (%llu) sent a packet as (%llu) which is not an id they own.",
-				sysAddr.ToString(), user->GetLastUsedChar()->GetName().c_str(), user->GetLastUsedChar()->GetObjectID(), id);
+			LOG("User at system address (%s) (%s) (%llu) sent a packet as (%i) which is not an id they own.",
+				sysAddr.ToString(), user->GetLastUsedChar()->GetName().c_str(), user->GetLastUsedChar()->GetObjectID(), static_cast<int32_t>(id));
 		// Can't know sending player. Just log system address for IP banning.
 		} else {
 			LOG("No user found for system address (%s).", sysAddr.ToString());
@@ -117,7 +117,7 @@ bool CheatDetection::VerifyLwoobjidIsSender(const LWOOBJID& id, const SystemAddr
 			return false;
 		}
 		invalidPacket = true;
-		const auto characterId = id;
+		const uint32_t characterId = static_cast<uint32_t>(id);
 		// Check to make sure the ID provided is one of the user's characters.
 		for (const auto& character : sendingUser->GetCharacters()) {
 			if (character && character->GetID() == characterId) {

dGame/dUtilities/Mail.cpp

@@ -34,7 +34,7 @@ namespace {
 }
 
 namespace Mail {
-	std::map<eMessageID, std::function<std::unique_ptr<MailLUBitStream>()>> g_Handlers = {
+	std::map<eMessageID, std::function<std::unique_ptr<MailClientLUBitStream>()>> g_Handlers = {
 		{eMessageID::SendRequest, []() {
 			return std::make_unique<SendRequest>();
 		}},
@@ -55,11 +55,11 @@ namespace Mail {
 		}},
 	};
 
-	void MailLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+	void MailClientLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
 		bitStream.Write(messageID);
 	}
 
-	bool MailLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
+	bool MailClientLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
 		VALIDATE_READ(bitstream.Read(messageID));
 		return true;
 	}
@@ -133,16 +133,16 @@ namespace Mail {
 			response.status = eSendResponse::SenderAccountIsMuted;
 		}
 		LOG("Finished send with status %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}
 
 	void SendResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 	}
 
 	void NotificationResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write<uint64_t>(0); // unused
 		bitStream.Write<uint64_t>(0); // unused
@@ -158,12 +158,12 @@ namespace Mail {
 		auto playerMail = Database::Get()->GetMailForPlayer(character->GetID(), 20);
 		DataResponse response;
 		response.playerMail = playerMail;
-		response.Send(sysAddr);
+		response.Send();
 		LOG("DataRequest");
 	}
 
 	void DataResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(this->throttled);
 	
 		bitStream.Write<uint16_t>(this->playerMail.size());
@@ -199,11 +199,11 @@ namespace Mail {
 			}
 		}
 		LOG("AttachmentCollectResponse %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}
 
 	void AttachmentCollectResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -230,11 +230,11 @@ namespace Mail {
 			response.status = eDeleteResponse::NotFound;
 		}
 		LOG("DeleteRequest status %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}
 
 	void DeleteResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -256,11 +256,11 @@ namespace Mail {
 		}
 
 		LOG("ReadRequest %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}
 
 	void ReadResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailLUBitStream::Serialize(bitStream);
+		MailClientLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -275,13 +275,13 @@ namespace Mail {
 		}
 
 		LOG("NotificationRequest %s", StringifiedEnum::ToString(response.status).data());
-		response.Send(sysAddr);
+		response.Send();
 	}
 }
 
 // Non Stuct Functions
-void Mail::HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
-	MailLUBitStream data;
+void Mail::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
+	MailClientLUBitStream data;
 	if (!data.Deserialize(inStream)) {
 		LOG_DEBUG("Error Reading Mail header");
 		return;
@@ -368,5 +368,5 @@ void Mail::SendMail(const LWOOBJID sender, const std::string& senderName, LWOOBJ
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) return; // TODO: Echo to chat server
 	NotificationResponse response;
 	response.status = eNotificationResponse::NewMail;
-	response.Send(sysAddr);
+	response.Send();
 }

dGame/dUtilities/Mail.h

@@ -7,6 +7,8 @@
 #include "dCommonVars.h"
 #include "BitStreamUtils.h"
 #include "MailInfo.h"
+#include "MessageType/Client.h"
+#include "ClientPackets.h"
 
 class Entity;
 
@@ -103,112 +105,111 @@ namespace Mail {
 		UnknownError
 	};
 
-	struct MailLUBitStream : public LUBitStream {
+	struct MailClientLUBitStream : public ClientPackets::ClientLUBitStream {
 		eMessageID messageID = eMessageID::UnknownError;
-		SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
 		Entity* player = nullptr;
 
-		MailLUBitStream() = default;
-		MailLUBitStream(eMessageID _messageID) : LUBitStream(ServiceType::CLIENT, MessageType::Client::MAIL), messageID{_messageID} {};
+		MailClientLUBitStream() = default;
+		MailClientLUBitStream(eMessageID _messageID) : ClientPackets::ClientLUBitStream(MessageType::Client::MAIL), messageID{_messageID} {};
 
 		virtual void Serialize(RakNet::BitStream& bitStream) const override;
 		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
 		virtual void Handle() override {};
 	};
 
-	struct SendRequest : public MailLUBitStream {
+	struct SendRequest : public MailClientLUBitStream {
 		MailInfo mailInfo;
 
-		SendRequest() : MailLUBitStream(eMessageID::SendRequest) {}
+		SendRequest() : MailClientLUBitStream(eMessageID::SendRequest) {}
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};
 
-	struct SendResponse :public MailLUBitStream {
+	struct SendResponse :public MailClientLUBitStream {
 		eSendResponse status = eSendResponse::UnknownError;
 
-		SendResponse() : MailLUBitStream(eMessageID::SendResponse) {}
+		SendResponse() : MailClientLUBitStream(eMessageID::SendResponse) {}
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};
 
-	struct NotificationResponse : public MailLUBitStream {
+	struct NotificationResponse : public MailClientLUBitStream {
 		eNotificationResponse status = eNotificationResponse::UnknownError;
 		LWOOBJID auctionID = LWOOBJID_EMPTY;
 		uint32_t mailCount = 1;
-		NotificationResponse() : MailLUBitStream(eMessageID::NotificationResponse) {};
+		NotificationResponse() : MailClientLUBitStream(eMessageID::NotificationResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};
 
-	struct DataRequest : public MailLUBitStream {
-		DataRequest() : MailLUBitStream(eMessageID::DataRequest) {}
+	struct DataRequest : public MailClientLUBitStream {
+		DataRequest() : MailClientLUBitStream(eMessageID::DataRequest) {}
 		bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
 		void Handle() override;
 	};
 
-	struct DataResponse : public MailLUBitStream {
+	struct DataResponse : public MailClientLUBitStream {
 		uint32_t throttled = 0;
 		std::vector<MailInfo> playerMail;
 
-		DataResponse() : MailLUBitStream(eMessageID::DataResponse) {};
+		DataResponse() : MailClientLUBitStream(eMessageID::DataResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 
 	};
 
-	struct AttachmentCollectRequest : public MailLUBitStream {
+	struct AttachmentCollectRequest : public MailClientLUBitStream {
 		uint64_t mailID = 0;
 		LWOOBJID playerID = LWOOBJID_EMPTY;
 
-		AttachmentCollectRequest() : MailLUBitStream(eMessageID::AttachmentCollectRequest) {};
+		AttachmentCollectRequest() : MailClientLUBitStream(eMessageID::AttachmentCollectRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};
 
-	struct AttachmentCollectResponse : public MailLUBitStream {
+	struct AttachmentCollectResponse : public MailClientLUBitStream {
 		eAttachmentCollectResponse status = eAttachmentCollectResponse::UnknownError;
 		uint64_t mailID = 0;
-		AttachmentCollectResponse() : MailLUBitStream(eMessageID::AttachmentCollectResponse) {};
+		AttachmentCollectResponse() : MailClientLUBitStream(eMessageID::AttachmentCollectResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};
 
-	struct DeleteRequest : public MailLUBitStream {
+	struct DeleteRequest : public MailClientLUBitStream {
 		uint64_t mailID = 0;
 		LWOOBJID playerID = LWOOBJID_EMPTY;
 
-		DeleteRequest() : MailLUBitStream(eMessageID::DeleteRequest) {};
+		DeleteRequest() : MailClientLUBitStream(eMessageID::DeleteRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};
 
-	struct DeleteResponse : public MailLUBitStream {
+	struct DeleteResponse : public MailClientLUBitStream {
 		eDeleteResponse status = eDeleteResponse::UnknownError;
 		uint64_t mailID = 0;
-		DeleteResponse() : MailLUBitStream(eMessageID::DeleteResponse) {};
+		DeleteResponse() : MailClientLUBitStream(eMessageID::DeleteResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};
 
-	struct ReadRequest : public MailLUBitStream {
+	struct ReadRequest : public MailClientLUBitStream {
 		uint64_t mailID = 0;
 
-		ReadRequest() : MailLUBitStream(eMessageID::ReadRequest) {};
+		ReadRequest() : MailClientLUBitStream(eMessageID::ReadRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override;
 		void Handle() override;
 	};
 
-	struct ReadResponse : public MailLUBitStream {
+	struct ReadResponse : public MailClientLUBitStream {
 		uint64_t mailID = 0;
 		eReadResponse status = eReadResponse::UnknownError;
 
-		ReadResponse() : MailLUBitStream(eMessageID::ReadResponse) {};
+		ReadResponse() : MailClientLUBitStream(eMessageID::ReadResponse) {};
 		void Serialize(RakNet::BitStream& bitStream) const override;
 	};
 
-	struct NotificationRequest : public MailLUBitStream {
-		NotificationRequest() : MailLUBitStream(eMessageID::NotificationRequest) {};
+	struct NotificationRequest : public MailClientLUBitStream {
+		NotificationRequest() : MailClientLUBitStream(eMessageID::NotificationRequest) {};
 		bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
 		void Handle() override;
 	};
 
-	void HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player);
+	void Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player);
 
 	void SendMail(
 		const Entity* recipient,

dGame/dUtilities/ObjectIDManager.cpp

@@ -5,37 +5,47 @@
 #include "Database.h"
 #include "Logger.h"
 #include "Game.h"
-#include "eObjectBits.h"
 
-// should the spawners from vanity also have the CLIENT flag?
+ //! The persistent ID request
+struct PersistentIDRequest {
+	PersistentIDRequest(const uint64_t& requestID, const std::function<void(uint32_t)>& callback) : requestID(requestID), callback(callback) {}
+	uint64_t requestID;
 
-namespace {
-	// Start the range in a way that it when first called it will fetch some new persistent IDs
-	std::optional<IObjectIdTracker::Range> CurrentRange = std::nullopt;
-	uint32_t CurrentObjectID = uint32_t(1152921508165007067); // The current object ID (this should really start at the highest current ID in the world, then increment from there)
+	std::function<void(uint32_t)> callback;
 };
 
-uint64_t ObjectIDManager::GetPersistentID() {
-	if (!CurrentRange.has_value() || CurrentRange->minID > CurrentRange->maxID) {
-		CurrentRange = Database::Get()->GetPersistentIdRange();
-		// We're getting close to being out of IDs in this range, log a warning
-		const auto WARNING_RANGE = 70368744100000ULL;
-		if (CurrentRange->minID >= 70368744100000ULL) {
-			LOG("WARNING: Your server is running low on persistent IDs, please consider an ID squash in the near future.");
-		}
+namespace {
+	std::vector<PersistentIDRequest> Requests; //!< All outstanding persistent ID requests
+	uint64_t CurrentRequestID = 0;                  //!< The current request ID
+	uint32_t CurrentObjectID = uint32_t(1152921508165007067);                   //!< The current object ID
+	std::uniform_int_distribution<int> Uni(10000000, INT32_MAX);
+};
 
-		LOG("Reserved object ID range: %llu - %llu", CurrentRange->minID, CurrentRange->maxID);
-	}
+//! Requests a persistent ID
+void ObjectIDManager::RequestPersistentID(const std::function<void(uint32_t)> callback) {
+	const auto& request = Requests.emplace_back(++CurrentRequestID, callback);
 
-	const auto usedID = CurrentRange->minID++;
-	auto toReturn = usedID;
-	// Any IDs gotten from persistent IDs use the CHARACTER bit
-	GeneralUtils::SetBit(toReturn, eObjectBits::CHARACTER);
-	LOG("Using ID: %llu:%llu", toReturn, usedID);
-	return toReturn;
+	MasterPackets::SendPersistentIDRequest(Game::server, request.requestID);
 }
 
-// Generates an object ID server-sided (used for regular entities like smashables)
+//! Handles a persistent ID response
+void ObjectIDManager::HandleRequestPersistentIDResponse(const uint64_t requestID, const uint32_t persistentID) {
+	auto it = std::find_if(Requests.begin(), Requests.end(), [requestID](const PersistentIDRequest& request) {
+		return request.requestID == requestID;
+	});
+
+	if (it == Requests.end()) return;
+
+	it->callback(persistentID);
+	Requests.erase(it);
+}
+
+//! Handles cases where we have to get a unique object ID synchronously
+uint32_t ObjectIDManager::GenerateRandomObjectID() {
+	return Uni(Game::randomEngine);
+}
+
+//! Generates an object ID server-sided (used for regular entities like smashables)
 uint32_t ObjectIDManager::GenerateObjectID() {
 	return ++CurrentObjectID;
 }

dGame/dUtilities/ObjectIDManager.h

@@ -5,25 +5,36 @@
 #include <vector>
 #include <stdint.h>
 
-/**
- *  There are 2 types of IDs:
- *  Persistent IDs - These are used for anything that needs to be persist between worlds.
- *  Ephemeral IDs - These are used for any objects that only need to be unique for this world session.
+/*!
+  \file ObjectIDManager.h
+  \brief A manager for handling object ID generation
  */
 
+//! The Object ID Manager
 namespace ObjectIDManager {
-
-	/**
-	 * @brief Returns a Persistent ID with the CHARACTER bit set.
-	 * 
-	 * @return uint64_t A unique persistent ID with the CHARACTER bit set.
+	//! Requests a persistent ID
+	/*!
+	  \param callback The callback function
 	 */
-	uint64_t GetPersistentID();
+	void RequestPersistentID(const std::function<void(uint32_t)> callback);
 
-	/**
-	 * @brief Generates an ephemeral object ID for non-persistent objects.
-	 * 
-	 * @return uint32_t 
+
+	//! Handles a persistent ID response
+	/*!
+	  \param requestID The request ID
+	  \param persistentID The persistent ID
+	 */
+	void HandleRequestPersistentIDResponse(const uint64_t requestID, const uint32_t persistentID);
+
+	//! Generates an object ID server-sided
+	/*!
+	  \return A generated object ID
 	 */
 	uint32_t GenerateObjectID();
+
+	//! Generates a random object ID server-sided
+	/*!
+	 \return A generated object ID
+	 */
+	uint32_t GenerateRandomObjectID();
 };

dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp

@@ -3,6 +3,7 @@
 // Classes
 #include "Character.h"
 #include "ChatPackets.h"
+#include "CommonPackets.h"
 #include "dServer.h"
 #include "PlayerManager.h"
 #include "User.h"
@@ -16,7 +17,6 @@
 
 // Enums
 #include "MessageType/Chat.h"
-#include "eServerDisconnectIdentifiers.h"
 #include "eObjectBits.h"
 
 namespace GMGreaterThanZeroCommands {
@@ -31,8 +31,10 @@ namespace GMGreaterThanZeroCommands {
 				ChatPackets::SendSystemMessage(sysAddr, u"Count not find player of name: " + username);
 				return;
 			}
-
-			Game::server->Disconnect(player->GetSystemAddress(), eServerDisconnectIdentifiers::KICK);
+			CommonPackets::DisconnectNotify notification;
+			notification.disconnectID = eServerDisconnectIdentifiers::KICK;
+			notification.Send(player->GetSystemAddress());
+			Game::server->Disconnect(player->GetSystemAddress());
 
 			ChatPackets::SendSystemMessage(sysAddr, u"Kicked: " + username);
 		} else {
@@ -69,7 +71,10 @@ namespace GMGreaterThanZeroCommands {
 			if (accountId != 0) Database::Get()->UpdateAccountBan(accountId, true);
 
 			if (player != nullptr) {
-				Game::server->Disconnect(player->GetSystemAddress(), eServerDisconnectIdentifiers::FREE_TRIAL_EXPIRED);
+				CommonPackets::DisconnectNotify notification;
+				notification.disconnectID = eServerDisconnectIdentifiers::FREE_TRIAL_EXPIRED;
+				notification.Send(player->GetSystemAddress());
+				Game::server->Disconnect(player->GetSystemAddress());
 			}
 
 			ChatPackets::SendSystemMessage(sysAddr, u"Banned: " + GeneralUtils::ASCIIToUTF16(splitArgs[0]));
@@ -141,6 +146,7 @@ namespace GMGreaterThanZeroCommands {
 					characterId = characterInfo->id;
 
 					GeneralUtils::SetBit(characterId, eObjectBits::CHARACTER);
+					GeneralUtils::SetBit(characterId, eObjectBits::PERSISTENT);
 				}
 
 				if (accountId == 0) {

dMasterServer/CMakeLists.txt

@@ -1,5 +1,6 @@
 set(DMASTERSERVER_SOURCES
 	"InstanceManager.cpp"
+	"PersistentIDManager.cpp"
 	"Start.cpp"
 )
 

dMasterServer/MasterServer.cpp

@@ -35,6 +35,7 @@
 #include "Game.h"
 #include "InstanceManager.h"
 #include "MasterPackets.h"
+#include "PersistentIDManager.h"
 #include "FdbToSqlite.h"
 #include "BitStreamUtils.h"
 #include "Start.h"
@@ -98,7 +99,6 @@ int main(int argc, char** argv) {
 	//Create all the objects we need to run our service:
 	Server::SetupLogger("MasterServer");
 	if (!Game::logger) return EXIT_FAILURE;
-	Game::config->LogSettings();
 
 	auto folders = { "navmeshes", "migrations", "vanity" };
 
@@ -359,6 +359,7 @@ int main(int argc, char** argv) {
 	Database::Get()->SetMasterInfo(info);
 
 	//Create additional objects here:
+	PersistentIDManager::Initialize();
 	Game::im = new InstanceManager(Game::server->GetIP());
 
 	//Get CDClient initial information
@@ -532,6 +533,17 @@ void HandlePacket(Packet* packet) {
 
 	if (static_cast<ServiceType>(packet->data[1]) == ServiceType::MASTER) {
 		switch (static_cast<MessageType::Master>(packet->data[3])) {
+		case MessageType::Master::REQUEST_PERSISTENT_ID: {
+			LOG("A persistent ID req");
+			RakNet::BitStream inStream(packet->data, packet->length, false);
+			uint64_t header = inStream.Read(header);
+			uint64_t requestID = 0;
+			inStream.Read(requestID);
+
+			uint32_t objID = PersistentIDManager::GeneratePersistentID();
+			MasterPackets::SendPersistentIDResponse(Game::server, packet->systemAddress, requestID, objID);
+			break;
+		}
 
 		case MessageType::Master::REQUEST_ZONE_TRANSFER: {
 			LOG("Received zone transfer req");
@@ -869,6 +881,9 @@ int ShutdownSequence(int32_t signal) {
 		LOG("Triggered master shutdown");
 	}
 
+	PersistentIDManager::SaveToDatabase();
+	LOG("Saved ObjectIDTracker to DB");
+
 	// A server might not be finished spinning up yet, remove all of those here.
 	for (const auto& instance : Game::im->GetInstances()) {
 		if (!instance) continue;

dMasterServer/PersistentIDManager.cpp

@@ -0,0 +1,45 @@
+#include "PersistentIDManager.h"
+
+// Custom Classes
+#include "Database.h"
+#include "Logger.h"
+#include "Game.h"
+
+namespace {	
+	uint32_t CurrentPersistentID = 1;               //!< The highest current persistent ID in use
+};
+
+//! Initializes the manager
+void PersistentIDManager::Initialize() {
+	try {
+		auto lastObjectId = Database::Get()->GetCurrentPersistentId();
+
+		if (!lastObjectId) {
+			Database::Get()->InsertDefaultPersistentId();
+		} else {
+			CurrentPersistentID = lastObjectId.value();
+		}
+
+		if (CurrentPersistentID <= 0) {
+			LOG("Invalid persistent object ID in database. Aborting to prevent bad id generation.");
+			throw std::runtime_error("Invalid persistent object ID in database. Aborting to prevent bad id generation.");
+		}
+	} catch (std::exception& e) {
+		LOG("Unable to fetch max persistent object ID in use. This will cause issues. Aborting to prevent collisions.");
+		LOG("Error: %s", e.what());
+		throw e;
+	}
+}
+
+//! Generates a new persistent ID
+uint32_t PersistentIDManager::GeneratePersistentID() {
+	uint32_t toReturn = ++CurrentPersistentID;
+
+	SaveToDatabase();
+
+	return toReturn;
+}
+
+void PersistentIDManager::SaveToDatabase() {
+	Database::Get()->UpdatePersistentId(CurrentPersistentID);
+}

dMasterServer/PersistentIDManager.h

@@ -0,0 +1,23 @@
+#pragma once
+
+// C++
+#include <cstdint>
+
+/*!
+  \file PersistentIDManager.h
+  \brief A manager that handles requests for object IDs
+ */
+
+ //! The Object ID Manager
+namespace PersistentIDManager {
+	//! Initializes the manager
+	void Initialize();
+
+	//! Generates a new persistent ID
+	/*!
+	  \return The new persistent ID
+	 */
+	uint32_t GeneratePersistentID();
+
+	void SaveToDatabase();
+};

dNet/AuthPackets.cpp

@@ -17,296 +17,244 @@
 
 #include "Game.h"
 #include "dConfig.h"
-#include "eServerDisconnectIdentifiers.h"
-#include "eLoginResponse.h"
 #include "ServiceType.h"
 #include "MessageType/Server.h"
 #include "MessageType/Master.h"
 #include "eGameMasterLevel.h"
 #include "StringifiedEnum.h"
+#include "CommonPackets.h"
+#include "ClientPackets.h"
+
 namespace {
 	std::vector<uint32_t> claimCodes;
 }
 
-void Stamp::Serialize(RakNet::BitStream& outBitStream){
-	outBitStream.Write(type);
-	outBitStream.Write(value);
-	outBitStream.Write(timestamp);
-};
+namespace AuthPackets {
+	std::map<MessageType::Auth, std::function<std::unique_ptr<LUBitStream>()>> g_Handlers = {
+		{MessageType::Auth::LOGIN_REQUEST, []() {
+			return std::make_unique<LoginRequest>();
+		}}
+	};
 
+	// Struct Functions
+	void AuthLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->messageType);
+		bitStream.Write<uint8_t>(0); // padding
+	}
+	bool AuthLUBitStream::Deserialize(RakNet::BitStream& bitStream) {
+		VALIDATE_READ(bitStream.Read(this->messageType));
+		uint8_t padding = 0;
+		VALIDATE_READ(bitStream.Read(padding));
+		return true;
+	}
+
+	bool LoginRequest::Deserialize(RakNet::BitStream& bitStream) {
+		LUWString usernameLUString;
+		VALIDATE_READ(bitStream.Read(usernameLUString));
+		username = usernameLUString.GetAsString();
+
+		LUWString passwordLUString(41);
+		VALIDATE_READ(bitStream.Read(passwordLUString));
+		password = passwordLUString.GetAsString();
+		VALIDATE_READ(bitStream.Read(locale_id));
+		VALIDATE_READ(bitStream.Read(clientOS));
+
+		LUWString memoryStatsLU(256);
+		VALIDATE_READ(bitStream.Read(memoryStatsLU));
+		computerInfo.memoryStats = memoryStatsLU.GetAsString();
+
+		LUWString videoCardLU(128);
+		VALIDATE_READ(bitStream.Read(videoCardLU));
+		computerInfo.videoCard = videoCardLU.GetAsString();
+
+		// Processor/CPU info
+		VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.count));
+		VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.type));
+		VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.level));
+		VALIDATE_READ(bitStream.Read(computerInfo.processorInfo.revision));
+
+		// OS Info
+		VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.infoSize));
+		VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.majorVersion));
+		VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.minorVersion));
+		VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.buildNumber));
+		VALIDATE_READ(bitStream.Read(computerInfo.osVersionInfo.platformID));
+
+		return true;
+	}
+
+	void LoginRequest::Handle() {
+		LOG_DEBUG("Login Request from %s", username.c_str());
+		LOG_DEBUG("Password: %s", password.c_str());
+		
+		LOG_DEBUG("Locale ID: %s", StringifiedEnum::ToString(locale_id).data());
+
+		LOG_DEBUG("Operating System: %s", StringifiedEnum::ToString(clientOS).data());
+
+		LOG_DEBUG("Memory Stats [%s]", computerInfo.memoryStats.c_str());
+
+		LOG_DEBUG("VideoCard Info: [%s]", computerInfo.videoCard.c_str());
+
+		LOG_DEBUG("CPU Info: [#Processors: %i, Processor Type: %i, Processor Level: %i, Processor Revision: %i]",
+			computerInfo.processorInfo.count,
+			computerInfo.processorInfo.type,
+			computerInfo.processorInfo.level,
+			computerInfo.processorInfo.revision
+		);
+
+		LOG_DEBUG("OS Info: [Size: %i, Version: %i.%i, Buid#: %i, platformID: %i]",
+			computerInfo.osVersionInfo.infoSize,
+			computerInfo.osVersionInfo.majorVersion,
+			computerInfo.osVersionInfo.minorVersion,
+			computerInfo.osVersionInfo.buildNumber,
+			computerInfo.osVersionInfo.platformID
+		);
+
+		ClientPackets::LoginResponse response;
+		response.sysAddr = this->sysAddr;
+		response.stamps.emplace_back(eStamps::PASSPORT_AUTH_START, 0);
+		response.stamps.emplace_back(eStamps::PASSPORT_AUTH_CLIENT_OS, 0);
+		response.events.push_back(LUString(Game::config->GetValue("event_1")));
+		response.events.push_back(LUString(Game::config->GetValue("event_2")));
+		response.events.push_back(LUString(Game::config->GetValue("event_3")));
+		response.events.push_back(LUString(Game::config->GetValue("event_4")));
+		response.events.push_back(LUString(Game::config->GetValue("event_5")));
+		response.events.push_back(LUString(Game::config->GetValue("event_6")));
+		response.events.push_back(LUString(Game::config->GetValue("event_7")));
+		response.events.push_back(LUString(Game::config->GetValue("event_8")));
+		response.version_major = GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_major")).value_or(ClientVersion::major);
+		response.version_current = GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_current")).value_or(ClientVersion::current);
+		response.version_minor = GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_minor")).value_or(ClientVersion::minor);
+
+		uint32_t sessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>();
+		std::string userHash = std::to_string(sessionKey);
+		response.userKey = md5(userHash);
+
+		// Fetch account details
+		auto accountInfo = Database::Get()->GetAccountInfo(username);
+
+		if (!accountInfo) {
+			LOG("No user by name %s found!", username.c_str());
+			response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
+			response.Send(sysAddr);
+			return;
+		}
+
+		//If we aren't running in live mode, then only GMs are allowed to enter:
+		const auto& closedToNonDevs = Game::config->GetValue("closed_to_non_devs");
+		if (closedToNonDevs.size() > 0 && bool(std::stoi(closedToNonDevs)) && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) {
+			response.stamps.emplace_back(eStamps::GM_REQUIRED, 1);
+			response.Send(sysAddr);
+			return;
+		}
+
+		if (Game::config->GetValue("dont_use_keys") != "1" && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) {
+			//Check to see if we have a play key:
+			if (accountInfo->playKeyId == 0) {
+				response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
+				response.responseCode = eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH;
+				response.errorMessage = "Your account doesn't have a play key associated with it!";
+				response.Send(sysAddr);
+				LOG("User %s tried to log in, but they don't have a play key.", username.c_str());
+				return;
+			}
+
+			//Check if the play key is _valid_:
+			auto playKeyStatus = Database::Get()->IsPlaykeyActive(accountInfo->playKeyId);
+
+			if (!playKeyStatus) {
+				response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
+				response.responseCode = eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH;
+				response.errorMessage = "Your account doesn't have a valid play key associated with it!";
+				response.Send(sysAddr);
+				return;
+			}
+
+			if (!playKeyStatus.value()) {
+				response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
+				response.responseCode = eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH;
+				response.errorMessage = "Your play key has been disabled.";
+				response.Send(sysAddr);
+				LOG("User %s tried to log in, but their play key was disabled", username.c_str());
+				return;
+			}
+		} else if (Game::config->GetValue("dont_use_keys") == "1" || accountInfo->maxGmLevel > eGameMasterLevel::CIVILIAN) {
+			response.stamps.emplace_back(eStamps::PASSPORT_AUTH_BYPASS, 1);
+		}
+
+		if (accountInfo->banned) {
+			response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
+			response.responseCode = eLoginResponse::BANNED;
+			response.errorMessage = "Your account has been banned.";
+			response.Send(sysAddr);
+			return;
+		}
+
+		if (accountInfo->locked) {
+			response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
+			response.responseCode = eLoginResponse::ACCOUNT_LOCKED;
+			response.errorMessage = "Your account is locked.";
+			response.Send(sysAddr);
+			return;
+		}
+
+		bool loginSuccess = ::bcrypt_checkpw(password.c_str(), accountInfo->bcryptPassword.c_str()) == 0;
+
+		if (!loginSuccess) {
+			response.stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
+			response.responseCode = eLoginResponse::WRONG_PASS;
+			response.Send(sysAddr);
+		} else {
+			ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, 0, 0, false, [this, response, sessionKey](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) mutable {
+				response.responseCode = eLoginResponse::SUCCESS;
+				response.worldServerIP = LUString(zoneIP);
+				response.worldServerPort = zonePort;
+				response.Send();
+
+				CBITSTREAM;
+				BitStreamUtils::WriteHeader(bitStream, ServiceType::MASTER, MessageType::Master::SET_SESSION_KEY);
+				bitStream.Write(sessionKey);
+				LOG_DEBUG("Sending session key for %s to master server", this->username.c_str());
+				bitStream.Write(LUString(this->username));
+				Game::server->SendToMaster(bitStream);
+			});
+
+			for (auto const code : claimCodes) {
+				Database::Get()->InsertRewardCode(accountInfo->id, code);
+			}
+		}
+	}
+}
+
+// Non Stuct Functions
 void AuthPackets::LoadClaimCodes() {
-	if(!claimCodes.empty()) return;
+	if (!claimCodes.empty()) return;
 	auto rcstring = Game::config->GetValue("rewardcodes");
 	auto codestrings = GeneralUtils::SplitString(rcstring, ',');
-	for(auto const &codestring: codestrings){
+	for (auto const& codestring : codestrings) {
 		const auto code = GeneralUtils::TryParse<uint32_t>(codestring);
 
 		if (code && code.value() != -1) claimCodes.push_back(code.value());
 	}
 }
 
-void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
-	CINSTREAM_SKIP_HEADER
-	uint32_t clientVersion = 0;
-	inStream.Read(clientVersion);
-	inStream.IgnoreBytes(4);
+// Non Stuct Functions
+void AuthPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
+	AuthLUBitStream authLUBitStream;
+	if (!authLUBitStream.Deserialize(inStream)) return;
 
-	ServiceType serviceType;
-	inStream.Read(serviceType);
-	if (serviceType != ServiceType::CLIENT) LOG("WARNING: Service is not a Client!");
-    inStream.IgnoreBytes(2);
-
-	uint32_t processID;
-	inStream.Read(processID);
-
-	uint16_t port;
-	inStream.Read(port);
-	if (port != packet->systemAddress.port) LOG("WARNING: Port written in packet does not match the port the client is connecting over!");
-
-	inStream.IgnoreBytes(33);
-
-	LOG_DEBUG("Client Data [Version: %i, Service: %s, Process: %u, Port: %u, Sysaddr Port: %u]", clientVersion, StringifiedEnum::ToString(serviceType).data(), processID, port, packet->systemAddress.port);
-
-	SendHandshake(server, packet->systemAddress, server->GetIP(), server->GetPort(), server->GetServerType());
-}
-
-void AuthPackets::SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServiceType serverType) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, ServiceType::COMMON, MessageType::Server::VERSION_CONFIRM);
-
-	const auto& clientNetVersionString = Game::config->GetValue("client_net_version");
-	const uint32_t clientNetVersion = GeneralUtils::TryParse<uint32_t>(clientNetVersionString).value_or(171022);
-
-	bitStream.Write<uint32_t>(clientNetVersion);
-	bitStream.Write<uint32_t>(861228100);
-	bitStream.Write(static_cast<uint32_t>(serverType));
-	bitStream.Write<uint64_t>(219818307120);
-
-	server->Send(bitStream, sysAddr, false);
-}
-
-std::string CleanReceivedString(const std::string& str) {
-	std::string toReturn = str;
-	const auto removed = std::ranges::find_if(toReturn, [](unsigned char c) { return isprint(c) == 0 && isblank(c) == 0; });
-	toReturn.erase(removed, toReturn.end());
-	return toReturn;
-}
-
-void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-
-	std::vector<Stamp> stamps;
-	stamps.emplace_back(eStamps::PASSPORT_AUTH_START, 0);
-
-	LUWString usernameLUString;
-	inStream.Read(usernameLUString);
-	const auto username = usernameLUString.GetAsString();
-
-	LUWString password(41);
-	inStream.Read(password);
-
-	LanguageCodeID locale_id;
-	inStream.Read(locale_id);
-	LOG_DEBUG("Locale ID: %s", StringifiedEnum::ToString(locale_id).data());
-
-	ClientOS clientOS;
-	inStream.Read(clientOS);
-	LOG_DEBUG("Operating System: %s", StringifiedEnum::ToString(clientOS).data());
-	stamps.emplace_back(eStamps::PASSPORT_AUTH_CLIENT_OS, 0);
-
-	LUWString memoryStats(256);
-	inStream.Read(memoryStats);
-	LOG_DEBUG("Memory Stats [%s]", CleanReceivedString(memoryStats.GetAsString()).c_str());
-
-	LUWString videoCard(128);
-	inStream.Read(videoCard);
-	LOG_DEBUG("VideoCard Info: [%s]", CleanReceivedString(videoCard.GetAsString()).c_str());
-
-	// Processor/CPU info
-	uint32_t numOfProcessors;
-	inStream.Read(numOfProcessors);
-	uint32_t processorType;
-	inStream.Read(processorType);
-	uint16_t processorLevel;
-	inStream.Read(processorLevel);
-	uint16_t processorRevision;
-	inStream.Read(processorRevision);
-	LOG_DEBUG("CPU Info: [#Processors: %i, Processor Type: %i, Processor Level: %i, Processor Revision: %i]", numOfProcessors, processorType, processorLevel, processorRevision);
-
-	// OS Info
-	uint32_t osVersionInfoSize;
-	inStream.Read(osVersionInfoSize);
-	uint32_t majorVersion;
-	inStream.Read(majorVersion);
-	uint32_t minorVersion;
-	inStream.Read(minorVersion);
-	uint32_t buildNumber;
-	inStream.Read(buildNumber);
-	uint32_t platformID;
-	inStream.Read(platformID);
-	LOG_DEBUG("OS Info: [Size: %i, Major: %i, Minor %i, Buid#: %i, platformID: %i]", osVersionInfoSize, majorVersion, minorVersion, buildNumber, platformID);
-
-	// Fetch account details
-	auto accountInfo = Database::Get()->GetAccountInfo(username);
-
-	if (!accountInfo) {
-		LOG("No user by name %s found!", username.c_str());
-		stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::INVALID_USER, "", "", 2001, username, stamps);
-		return;
-	}
-
-	//If we aren't running in live mode, then only GMs are allowed to enter:
-	const auto& closedToNonDevs = Game::config->GetValue("closed_to_non_devs");
-	if (closedToNonDevs.size() > 0 && bool(std::stoi(closedToNonDevs)) && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) {
-		stamps.emplace_back(eStamps::GM_REQUIRED, 1);
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "The server is currently only open to developers.", "", 2001, username, stamps);
-		return;
-	}
-
-	if (Game::config->GetValue("dont_use_keys") != "1" && accountInfo->maxGmLevel == eGameMasterLevel::CIVILIAN) {
-		//Check to see if we have a play key:
-		if (accountInfo->playKeyId == 0) {
-			stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
-			AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a play key associated with it!", "", 2001, username, stamps);
-			LOG("User %s tried to log in, but they don't have a play key.", username.c_str());
+	auto it = g_Handlers.find(authLUBitStream.messageType);
+	if (it != g_Handlers.end()) {
+		auto request = it->second();
+		request->sysAddr = sysAddr;
+		if (!request->Deserialize(inStream)) {
+			LOG_DEBUG("Error Reading Auth Packet: %s", StringifiedEnum::ToString(authLUBitStream.messageType).data());
 			return;
 		}
-
-		//Check if the play key is _valid_:
-		auto playKeyStatus = Database::Get()->IsPlaykeyActive(accountInfo->playKeyId);
-
-		if (!playKeyStatus) {
-			stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
-			AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your account doesn't have a valid play key associated with it!", "", 2001, username, stamps);
-			return;
-		}
-
-		if (!playKeyStatus.value()) {
-			stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
-			AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::PERMISSIONS_NOT_HIGH_ENOUGH, "Your play key has been disabled.", "", 2001, username, stamps);
-			LOG("User %s tried to log in, but their play key was disabled", username.c_str());
-			return;
-		}
-	} else if (Game::config->GetValue("dont_use_keys") == "1" || accountInfo->maxGmLevel > eGameMasterLevel::CIVILIAN){
-		stamps.emplace_back(eStamps::PASSPORT_AUTH_BYPASS, 1);
-	}
-
-	if (accountInfo->banned) {
-		stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::BANNED, "", "", 2001, username, stamps);
-		return;
-	}
-
-	if (accountInfo->locked) {
-		stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::ACCOUNT_LOCKED, "", "", 2001, username, stamps);
-		return;
-	}
-
-	bool loginSuccess = ::bcrypt_checkpw(password.GetAsString().c_str(), accountInfo->bcryptPassword.c_str()) == 0;
-
-	if (!loginSuccess) {
-		stamps.emplace_back(eStamps::PASSPORT_AUTH_ERROR, 1);
-		AuthPackets::SendLoginResponse(server, packet->systemAddress, eLoginResponse::WRONG_PASS, "", "", 2001, username, stamps);
-		LOG("Wrong password used");
+		LOG_DEBUG("Received Auth Packet: %s", StringifiedEnum::ToString(authLUBitStream.messageType).data());
+		request->Handle();
 	} else {
-		SystemAddress system = packet->systemAddress; //Copy the sysAddr before the Packet gets destroyed from main
-
-		if (!server->GetIsConnectedToMaster()) {
-			stamps.emplace_back(eStamps::PASSPORT_AUTH_WORLD_DISCONNECT, 1);
-			AuthPackets::SendLoginResponse(server, system, eLoginResponse::GENERAL_FAILED, "", "", 0, username, stamps);
-			return;
-		}
-		stamps.emplace_back(eStamps::PASSPORT_AUTH_WORLD_SESSION_CONFIRM_TO_AUTH, 1);
-		ZoneInstanceManager::Instance()->RequestZoneTransfer(server, 0, 0, false, [system, server, username, stamps](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string zoneIP, uint16_t zonePort) mutable {
-			AuthPackets::SendLoginResponse(server, system, eLoginResponse::SUCCESS, "", zoneIP, zonePort, username, stamps);
-			});
-	}
-
-	for(auto const code: claimCodes){
-		Database::Get()->InsertRewardCode(accountInfo->id, code);
+		LOG_DEBUG("Unhandled Auth Packet with ID: %i", authLUBitStream.messageType);
 	}
 }
 
-void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username, std::vector<Stamp>& stamps) {
-	stamps.emplace_back(eStamps::PASSPORT_AUTH_IM_LOGIN_START, 1);
-	RakNet::BitStream loginResponse;
-	BitStreamUtils::WriteHeader(loginResponse, ServiceType::CLIENT, MessageType::Client::LOGIN_RESPONSE);
-
-	loginResponse.Write(responseCode);
-
-	// Event Gating
-	loginResponse.Write(LUString(Game::config->GetValue("event_1")));
-	loginResponse.Write(LUString(Game::config->GetValue("event_2")));
-	loginResponse.Write(LUString(Game::config->GetValue("event_3")));
-	loginResponse.Write(LUString(Game::config->GetValue("event_4")));
-	loginResponse.Write(LUString(Game::config->GetValue("event_5")));
-	loginResponse.Write(LUString(Game::config->GetValue("event_6")));
-	loginResponse.Write(LUString(Game::config->GetValue("event_7")));
-	loginResponse.Write(LUString(Game::config->GetValue("event_8")));
-
-	const uint16_t version_major =
-		GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_major")).value_or(ClientVersion::major);
-	const uint16_t version_current =
-		GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_current")).value_or(ClientVersion::current);
-	const uint16_t version_minor =
-		GeneralUtils::TryParse<uint16_t>(Game::config->GetValue("version_minor")).value_or(ClientVersion::minor);
-
-	loginResponse.Write(version_major);
-	loginResponse.Write(version_current);
-	loginResponse.Write(version_minor);
-
-	// Writes the user key
-	uint32_t sessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>();
-	std::string userHash = std::to_string(sessionKey);
-	userHash = md5(userHash);
-	loginResponse.Write(LUWString(userHash));
-
-	// World Server IP
-	loginResponse.Write(LUString(wServerIP));
-	// Chat Server IP (unused)
-	loginResponse.Write(LUString(""));
-
-	// World Server Redirect port
-	loginResponse.Write(wServerPort);
-	// Char Server Redirect port (unused)
-	loginResponse.Write(static_cast<uint16_t>(0));
-
-	// CDN Key
-	loginResponse.Write(LUString(""));
-
-	// CDN Ticket
-	loginResponse.Write(LUString("00000000-0000-0000-0000-000000000000", 37));
-
-	// Language
-	loginResponse.Write(Language::en_US);
-
-	// Write the localization
-	loginResponse.Write(LUString("US", 3));
-
-	loginResponse.Write<uint8_t>(false); // Just upgraded from F2P
-	loginResponse.Write<uint8_t>(false); // User is F2P
-	loginResponse.Write<uint64_t>(0); // Time Remaining in F2P
-
-	// Write custom error message
-	loginResponse.Write<uint16_t>(errorMsg.length());
-	loginResponse.Write(LUWString(errorMsg, static_cast<uint32_t>(errorMsg.length())));
-
-	stamps.emplace_back(eStamps::PASSPORT_AUTH_WORLD_COMMUNICATION_FINISH, 1);
-
-	loginResponse.Write<uint32_t>((sizeof(Stamp) * stamps.size()) + sizeof(uint32_t));
-	for (auto& stamp : stamps) stamp.Serialize(loginResponse);
-
-	server->Send(loginResponse, sysAddr, false);
-	//Inform the master server that we've created a session for this user:
-	if (responseCode == eLoginResponse::SUCCESS) {
-		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, ServiceType::MASTER, MessageType::Master::SET_SESSION_KEY);
-		bitStream.Write(sessionKey);
-		bitStream.Write(LUString(username));
-		server->SendToMaster(bitStream);
-
-		LOG("Set sessionKey: %i for user %s", sessionKey, username.c_str());
-	}
-}