feat: script debug info

* feat: re-write persistent object ID tracker

Features:
- Remove random objectIDs entirely
- Replace random objectIDs with persistentIDs
- Remove the need to contact the MASTER server for a persistent ID
- Add persistent ID logic to WorldServers that use transactions to guarantee unique IDs no matter when they are generated
- Default character xml version to be the most recent one

Fixes:
- Return optional from GetModel (and check for nullopt where it may exist)
- Regenerate inventory item ids on first login to be unique item IDs (fixes all those random IDs

Pet IDs and subkeys are left alone and are assumed to be reserved (checks are there to prevent this)
There is also duplicate check logic in place for properties and UGC/Models

* Update comment and log

* fix: sqlite transaction bug

* fix colliding temp item ids

temp items should not be saved. would cause issues between worlds as experienced before this commit

cmake/FindGoogleTest.cmake

@@ -7,6 +7,7 @@ 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,7 +20,6 @@
 
 //Auth includes:
 #include "AuthPackets.h"
-#include "CommonPackets.h"
 #include "ServiceType.h"
 #include "MessageType/Server.h"
 #include "MessageType/Auth.h"
@@ -53,6 +52,7 @@ 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,12 +165,17 @@ int main(int argc, char** argv) {
 }
 
 void HandlePacket(Packet* 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);
+	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);
+			}
+		}
 	}
 }

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(static_cast<uint32_t>(playerId));
+		auto ignoreList = Database::Get()->GetIgnoreList(playerId);
 		if (ignoreList.empty()) {
 			LOG_DEBUG("Player %llu has no ignores", playerId);
 			return;
@@ -43,7 +43,6 @@ 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);
 		}
 	}
 
@@ -114,9 +113,8 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 		}
 
 		if (ignoredPlayerId != LWOOBJID_EMPTY) {
-			Database::Get()->AddIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(ignoredPlayerId));
+			Database::Get()->AddIgnore(playerId, 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());
@@ -157,7 +155,7 @@ void ChatIgnoreList::RemoveIgnore(Packet* packet) {
 		return;
 	}
 
-	Database::Get()->RemoveIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(toRemove->playerId));
+	Database::Get()->RemoveIgnore(playerId, toRemove->playerId);
 	receiver.ignoredPlayers.erase(toRemove, receiver.ignoredPlayers.end());
 
 	CBITSTREAM;

dChatServer/ChatPacketHandler.cpp

@@ -35,7 +35,6 @@ 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
@@ -161,9 +160,7 @@ 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
@@ -318,7 +315,6 @@ 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,6 +59,7 @@ 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,6 +55,7 @@ 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,6 +47,8 @@ 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) {
@@ -58,6 +60,18 @@ 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,5 +1,7 @@
 #pragma once
+
 #include <fstream>
+#include <functional>
 #include <map>
 #include <string>
 
@@ -29,10 +31,15 @@ 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,9 +3,7 @@
 
 namespace MessageType {
 	enum class Master : uint32_t {
-		REQUEST_PERSISTENT_ID = 1,
-		REQUEST_PERSISTENT_ID_RESPONSE,
-		REQUEST_ZONE_TRANSFER,
+		REQUEST_ZONE_TRANSFER = 1,
 		REQUEST_ZONE_TRANSFER_RESPONSE,
 		SERVER_INFO,
 		REQUEST_SESSION_KEY,

dCommon/dEnums/eCharacterVersion.h

@@ -18,7 +18,9 @@ enum class eCharacterVersion : uint32_t {
 	SPEED_BASE,
 	// Fixes nexus force explorer missions
 	NJ_JAYMISSIONS,
-	UP_TO_DATE, // will become NEXUS_FORCE_EXPLORER
+	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
 };
 
 #endif  //!__ECHARACTERVERSION__H__

dCommon/dEnums/eLoginResponse.h

@@ -0,0 +1,24 @@
+#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,13 +1,12 @@
-#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

@@ -0,0 +1,24 @@
+#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 uint32_t characterId) = 0;
+	virtual void DeleteCharacter(const LWOOBJID 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 uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) = 0;
+	virtual void UpdateActivityLog(const LWOOBJID 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{};
-		uint32_t characterId{};
+		LWOOBJID characterId{};
 		std::string behaviorInfo;
 	};
 

dDatabase/GameDatabase/ITables/IBugReports.h

@@ -11,7 +11,7 @@ public:
 		std::string clientVersion;
 		std::string otherPlayer;
 		std::string selection;
-		uint32_t characterId{};
+		LWOOBJID 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;
-		uint32_t id{};
+		LWOOBJID 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 uint32_t charId) = 0;
+	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID 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<uint32_t> GetAccountCharacterIds(const uint32_t accountId) = 0;
+	virtual std::vector<LWOOBJID> GetAccountCharacterIds(const LWOOBJID 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 uint32_t characterId, const std::string_view name) = 0;
+	virtual void SetCharacterName(const LWOOBJID characterId, const std::string_view name) = 0;
 
 	// Set the pending name of the given character.
-	virtual void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) = 0;
+	virtual void SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) = 0;
 
 	// Updates the given character ids last login to be right now.
-	virtual void UpdateLastLoggedInCharacter(const uint32_t characterId) = 0;
+	virtual void UpdateLastLoggedInCharacter(const LWOOBJID 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 uint32_t charId) = 0;
+	virtual std::string GetCharacterXml(const LWOOBJID charId) = 0;
 
 	// Update the character xml for the given character id.
-	virtual void UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) = 0;
+	virtual void UpdateCharacterXml(const LWOOBJID charId, const std::string_view lxfml) = 0;
 
 	// Insert the character xml for the given character id.
-	virtual void InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) = 0;
+	virtual void InsertCharacterXml(const LWOOBJID 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 uint32_t characterId, const std::string_view command) = 0;
+	virtual void InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) = 0;
 };
 
 #endif  //!__ICOMMANDLOG__H__

dDatabase/GameDatabase/ITables/IFriends.h

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

dDatabase/GameDatabase/ITables/IIgnoreList.h

@@ -9,12 +9,12 @@ class IIgnoreList {
 public:
 	struct Info {
 		std::string name;
-		uint32_t id;
+		LWOOBJID id;
 	};
 
-	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;
+	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;
 };
 
 #endif  //!__IIGNORELIST__H__

dDatabase/GameDatabase/ITables/ILeaderboard.h

@@ -5,12 +5,13 @@
 #include <optional>
 #include <string>
 #include <vector>
+#include "dCommonVars.h"
 
 class ILeaderboard {
 public:
 
 	struct Entry {
-		uint32_t charId{};
+		LWOOBJID charId{};
 		uint32_t lastPlayedTimestamp{};
 		float primaryScore{};
 		float secondaryScore{};
@@ -36,12 +37,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 uint32_t playerId, const uint32_t gameId) = 0;
+	virtual std::optional<Score> GetPlayerScore(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;
+	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;
 };
 
 #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 uint32_t characterId, const uint32_t numberOfMail) = 0;
+	virtual std::vector<MailInfo> GetMailForPlayer(const LWOOBJID 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 uint32_t characterId) = 0;
+	virtual uint32_t GetUnreadMailCount(const LWOOBJID characterId) = 0;
 
 	// Mark the given mail as read.
 	virtual void MarkMailRead(const uint64_t mailId) = 0;

dDatabase/GameDatabase/ITables/IObjectIdTracker.h

@@ -6,14 +6,19 @@
 
 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<uint32_t> GetCurrentPersistentId() = 0;
+	virtual std::optional<uint64_t> GetCurrentPersistentId() = 0;
 
 	// Insert the default persistent id.
 	virtual void InsertDefaultPersistentId() = 0;
 
-	// Update the persistent id.
-	virtual void UpdatePersistentId(const uint32_t newId) = 0;
+	virtual Range GetPersistentIdRange() = 0;
 };
 
 #endif  //!__IOBJECTIDTRACKER__H__

dDatabase/GameDatabase/ITables/IProperty.h

@@ -13,7 +13,7 @@ public:
 		std::string description;
 		std::string rejectionReason;
 		LWOOBJID id{};
-		uint32_t ownerId{};
+		LWOOBJID ownerId{};
 		LWOCLONEID cloneId{};
 		int32_t privacyOption{};
 		uint32_t modApproved{};
@@ -27,7 +27,7 @@ public:
 		uint32_t mapId{};
 		std::string searchString;
 		ePropertySortType sortChoice{};
-		uint32_t playerId{};
+		LWOOBJID playerId{};
 		uint32_t numResults{};
 		uint32_t startIndex{};
 		uint32_t playerSort{};
@@ -39,6 +39,9 @@ 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{};
-		uint32_t ugcId{};
+		LWOOBJID ugcId{};
 		std::array<LWOOBJID, 5> behaviors{};
 	};
 
 	// Inserts a new UGC model into the database.
 	virtual void InsertNewUgcModel(
 		std::stringstream& sd0Data,
-		const uint32_t blueprintId,
+		const uint64_t blueprintId,
 		const uint32_t accountId,
-		const uint32_t characterId) = 0;
+		const LWOOBJID 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 Model GetModel(const LWOOBJID modelID) = 0;
+	virtual std::optional<Model> GetModel(const LWOOBJID modelID) = 0;
 };
 #endif  //!__IPROPERTIESCONTENTS__H__

dDatabase/GameDatabase/ITables/IUgc.h

@@ -29,5 +29,7 @@ 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<uint32_t> characterId) = 0;
+	virtual void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> 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 uint32_t characterId) {
+void MySQLDatabase::DeleteCharacter(const LWOOBJID 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(uint32_t charID) override;
+	std::vector<FriendData> GetFriendsList(LWOOBJID charID) 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;
+	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;
 	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 uint32_t charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) override;
 	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
-	std::string GetCharacterXml(const uint32_t accountId) override;
-	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
+	std::string GetCharacterXml(const LWOOBJID accountId) override;
+	void UpdateCharacterXml(const LWOOBJID 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 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 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 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 uint32_t blueprintId,
+		const uint64_t blueprintId,
 		const uint32_t accountId,
-		const uint32_t characterId) override;
-	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+		const LWOOBJID characterId) override;
+	std::vector<MailInfo> GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) override;
 	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
-	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
+	uint32_t GetUnreadMailCount(const LWOOBJID 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 uint32_t characterId, const std::string_view command) override;
+	void InsertSlashCommandUsage(const LWOOBJID 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<uint32_t> GetCurrentPersistentId() override;
+	std::optional<uint64_t> GetCurrentPersistentId() override;
+	IObjectIdTracker::Range GetPersistentIdRange() 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 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 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 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,16 +118,18 @@ 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 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 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 DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
 	bool IsNameInUse(const std::string_view name) override;
-	IPropertyContents::Model GetModel(const LWOOBJID modelID) 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;
 	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
 private:
 
@@ -168,91 +170,91 @@ private:
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string_view param) {
-	// LOG("%s", param.data());
+	LOG_DEBUG("%s", param.data());
 	stmt->setString(index, param.data());
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const char* param) {
-	// LOG("%s", param);
+	LOG_DEBUG("%s", param);
 	stmt->setString(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string param) {
-	// LOG("%s", param.c_str());
+	LOG_DEBUG("%s", param.c_str());
 	stmt->setString(index, param.c_str());
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int8_t param) {
-	// LOG("%u", param);
+	LOG_DEBUG("%u", param);
 	stmt->setByte(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint8_t param) {
-	// LOG("%d", param);
+	LOG_DEBUG("%d", param);
 	stmt->setByte(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int16_t param) {
-	// LOG("%u", param);
+	LOG_DEBUG("%u", param);
 	stmt->setShort(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint16_t param) {
-	// LOG("%d", param);
+	LOG_DEBUG("%d", param);
 	stmt->setShort(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint32_t param) {
-	// LOG("%u", param);
+	LOG_DEBUG("%u", param);
 	stmt->setUInt(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int32_t param) {
-	// LOG("%d", param);
+	LOG_DEBUG("%d", param);
 	stmt->setInt(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int64_t param) {
-	// LOG("%llu", param);
+	LOG_DEBUG("%llu", param);
 	stmt->setInt64(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint64_t param) {
-	// LOG("%llu", param);
+	LOG_DEBUG("%llu", param);
 	stmt->setUInt64(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const float param) {
-	// LOG("%f", param);
+	LOG_DEBUG("%f", param);
 	stmt->setFloat(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const double param) {
-	// LOG("%f", param);
+	LOG_DEBUG("%f", param);
 	stmt->setDouble(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const bool param) {
-	// LOG("%d", param);
+	LOG_DEBUG("%s", param ? "true" : "false");
 	stmt->setBoolean(index, param);
 }
 
 template<>
 inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::istream* param) {
-	// LOG("Blob");
+	LOG_DEBUG("Blob");
 	// This is the one time you will ever see me use const_cast.
 	stmt->setBlob(index, const_cast<std::istream*>(param));
 }
@@ -260,10 +262,21 @@ 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("%d", param.value());
+		LOG_DEBUG("%d", param.value());
 		stmt->setInt(index, param.value());
 	} else {
-		// LOG("Null");
+		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");
 		stmt->setNull(index, sql::DataType::SQLNULL);
 	}
 }

dDatabase/GameDatabase/MySQL/Tables/ActivityLog.cpp

@@ -1,6 +1,6 @@
 #include "MySQLDatabase.h"
 
-void MySQLDatabase::UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
+void MySQLDatabase::UpdateActivityLog(const LWOOBJID 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->getUInt("id");
+	toReturn.id = stmt->getInt64("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 uint32_t charId) {
+std::optional<ICharInfo::Info> MySQLDatabase::GetCharacterInfo(const LWOOBJID 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<uint32_t> MySQLDatabase::GetAccountCharacterIds(const uint32_t accountId) {
+std::vector<LWOOBJID> MySQLDatabase::GetAccountCharacterIds(const LWOOBJID accountId) {
 	auto result = ExecuteSelect("SELECT id FROM charinfo WHERE account_id = ? ORDER BY last_login DESC LIMIT 4;", accountId);
 
-	std::vector<uint32_t> toReturn;
+	std::vector<LWOOBJID> toReturn;
 	toReturn.reserve(result->rowsCount());
 	while (result->next()) {
-		toReturn.push_back(result->getUInt("id"));
+		toReturn.push_back(result->getInt64("id"));
 	}
 
 	return toReturn;
@@ -65,15 +65,15 @@ void MySQLDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 		static_cast<uint32_t>(time(NULL)));
 }
 
-void MySQLDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
+void MySQLDatabase::SetCharacterName(const LWOOBJID 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 uint32_t characterId, const std::string_view name) {
+void MySQLDatabase::SetPendingCharacterName(const LWOOBJID 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 uint32_t characterId) {
+void MySQLDatabase::UpdateLastLoggedInCharacter(const LWOOBJID 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 uint32_t charId) {
+std::string MySQLDatabase::GetCharacterXml(const LWOOBJID 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 uint32_t charId) {
 	return result->getString("xml_data").c_str();
 }
 
-void MySQLDatabase::UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) {
+void MySQLDatabase::UpdateCharacterXml(const LWOOBJID charId, const std::string_view lxfml) {
 	ExecuteUpdate("UPDATE charxml SET xml_data = ? WHERE id = ?;", lxfml, charId);
 }
 
-void MySQLDatabase::InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
+void MySQLDatabase::InsertCharacterXml(const LWOOBJID 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 uint32_t characterId, const std::string_view command) {
+void MySQLDatabase::InsertSlashCommandUsage(const LWOOBJID 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 uint32_t charId) {
+std::vector<FriendData> MySQLDatabase::GetFriendsList(const LWOOBJID 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 uint32_t charId) {
 
 	while (friendsList->next()) {
 		FriendData fd;
-		fd.friendID = friendsList->getUInt("player");
+		fd.friendID = friendsList->getUInt64("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 uint32_t charId) {
 	return toReturn;
 }
 
-std::optional<IFriends::BestFriendStatus> MySQLDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+std::optional<IFriends::BestFriendStatus> MySQLDatabase::GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID 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->getUInt("player_id");
-	toReturn.friendCharacterId = result->getUInt("friend_id");
+	toReturn.playerCharacterId = result->getUInt64("player_id");
+	toReturn.friendCharacterId = result->getUInt64("friend_id");
 	toReturn.bestFriendStatus = result->getUInt("best_friend");
 
 	return toReturn;
 }
 
-void MySQLDatabase::SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) {
+void MySQLDatabase::SetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID 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 uint32_t playerCharacterId, const
 	);
 }
 
-void MySQLDatabase::AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+void MySQLDatabase::AddFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
 	ExecuteInsert("INSERT IGNORE INTO friends (player_id, friend_id, best_friend) VALUES (?, ?, 0);", playerCharacterId, friendCharacterId);
 }
 
-void MySQLDatabase::RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+void MySQLDatabase::RemoveFriend(const LWOOBJID playerCharacterId, const LWOOBJID 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 uint32_t playerId) {
+std::vector<IIgnoreList::Info> MySQLDatabase::GetIgnoreList(const LWOOBJID 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->getUInt("ignore_id") });
+		ignoreList.push_back(IIgnoreList::Info{ result->getString("name").c_str(), result->getInt64("ignore_id") });
 	}
 
 	return ignoreList;
 }
 
-void MySQLDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+void MySQLDatabase::AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
 	ExecuteInsert("INSERT IGNORE INTO ignore_list (player_id, ignored_player_id) VALUES (?, ?)", playerId, ignoredPlayerId);
 }
 
-void MySQLDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+void MySQLDatabase::RemoveIgnore(const LWOOBJID playerId, const LWOOBJID 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->getUInt("character_id");
+		entry.charId = rows->getUInt64("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 uint32_t playerId, const uint32_t gameId, const Score& score) {
+void MySQLDatabase::SaveScore(const LWOOBJID 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 uint32_t playerId, const uint32_t gameId, const Score& score) {
+void MySQLDatabase::UpdateScore(const LWOOBJID 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 uint32_t playerId, const uint32_t gameId) {
+void MySQLDatabase::IncrementTimesPlayed(const LWOOBJID 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 uint32_t playerId, const uint32_t gameId) {
+std::optional<ILeaderboard::Score> MySQLDatabase::GetPlayerScore(const LWOOBJID 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 uint32_t
 	return toReturn;
 }
 
-void MySQLDatabase::IncrementNumWins(const uint32_t playerId, const uint32_t gameId) {
+void MySQLDatabase::IncrementNumWins(const LWOOBJID 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 uint32_t characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> MySQLDatabase::GetMailForPlayer(const LWOOBJID 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 uint32_t characterId) {
+uint32_t MySQLDatabase::GetUnreadMailCount(const LWOOBJID 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,17 +1,42 @@
 #include "MySQLDatabase.h"
 
-std::optional<uint32_t> MySQLDatabase::GetCurrentPersistentId() {
+std::optional<uint64_t> MySQLDatabase::GetCurrentPersistentId() {
 	auto result = ExecuteSelect("SELECT last_object_id FROM object_id_tracker");
 	if (!result->next()) {
 		return std::nullopt;
 	}
-	return result->getUInt("last_object_id");
+	return result->getUInt64("last_object_id");
 }
 
 void MySQLDatabase::InsertDefaultPersistentId() {
 	ExecuteInsert("INSERT INTO object_id_tracker VALUES (1);");
 }
 
-void MySQLDatabase::UpdatePersistentId(const uint32_t newId) {
-	ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = ?;", newId);
+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;
 }

dDatabase/GameDatabase/MySQL/Tables/Property.cpp

@@ -1,6 +1,23 @@
 #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;
@@ -117,19 +134,7 @@ std::optional<IProperty::PropertyEntranceResult> MySQLDatabase::GetProperties(co
 
 	while (properties->next()) {
 		if (!result) result = IProperty::PropertyEntranceResult();
-		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");
+		result->entries.push_back(ReadPropertyInfo(properties));
 	}
 
 	return result;
@@ -144,21 +149,7 @@ std::optional<IProperty::Info> MySQLDatabase::GetPropertyInfo(const LWOMAPID map
 		return std::nullopt;
 	}
 
-	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;
+	return ReadPropertyInfo(propertyEntry);
 }
 
 void MySQLDatabase::UpdatePropertyModerationInfo(const IProperty::Info& info) {
@@ -195,3 +186,15 @@ 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,26 +64,27 @@ void MySQLDatabase::RemoveModel(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
 }
 
-IPropertyContents::Model MySQLDatabase::GetModel(const LWOOBJID modelID) {
+std::optional<IPropertyContents::Model> MySQLDatabase::GetModel(const LWOOBJID modelID) {
 	auto result = ExecuteSelect("SELECT * FROM properties_contents WHERE id = ?", modelID);
 
-	IPropertyContents::Model model{};
+	std::optional<IPropertyContents::Model> model = std::nullopt;
 	while (result->next()) {
-		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 = 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");
 	}
 
 	return model;

dDatabase/GameDatabase/MySQL/Tables/Ugc.cpp

@@ -1,5 +1,17 @@
 #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;",
@@ -8,14 +20,7 @@ std::vector<IUgc::Model> MySQLDatabase::GetUgcModels(const LWOOBJID& propertyId)
 	std::vector<IUgc::Model> toReturn;
 
 	while (result->next()) {
-		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));
+		toReturn.push_back(ReadModel(result));
 	}
 
 	return toReturn;
@@ -27,14 +32,7 @@ std::vector<IUgc::Model> MySQLDatabase::GetAllUgcModels() {
 	std::vector<IUgc::Model> models;
 	models.reserve(result->rowsCount());
 	while (result->next()) {
-		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));
+		models.push_back(ReadModel(result));
 	}
 
 	return models;
@@ -45,10 +43,10 @@ void MySQLDatabase::RemoveUnreferencedUgcModels() {
 }
 
 void MySQLDatabase::InsertNewUgcModel(
-	std:: stringstream& sd0Data, // cant be const sad
-	const uint32_t blueprintId,
+	std::stringstream& sd0Data, // cant be const sad
+	const uint64_t blueprintId,
 	const uint32_t accountId,
-	const uint32_t characterId) {
+	const LWOOBJID characterId) {
 	const std::istream stream(sd0Data.rdbuf());
 	ExecuteInsert(
 		"INSERT INTO `ugc`(`id`, `account_id`, `character_id`, `is_optimized`, `lxfml`, `bake_ao`, `filename`) VALUES (?,?,?,?,?,?,?)",
@@ -71,3 +69,14 @@ 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<uint32_t> characterId) {
+void MySQLDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> 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("BEGIN;").execDML();
-	} else {
 		if (!GetAutoCommit()) con->compileStatement("COMMIT;").execDML();
+	} else {
+		if (GetAutoCommit()) con->compileStatement("BEGIN;").execDML();
 	}
 }
 
-void SQLiteDatabase::DeleteCharacter(const uint32_t characterId) {
+void SQLiteDatabase::DeleteCharacter(const LWOOBJID 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(uint32_t charID) override;
+	std::vector<FriendData> GetFriendsList(LWOOBJID charID) 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;
+	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;
 	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 uint32_t charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) override;
 	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
-	std::string GetCharacterXml(const uint32_t accountId) override;
-	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
+	std::string GetCharacterXml(const LWOOBJID accountId) override;
+	void UpdateCharacterXml(const LWOOBJID 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 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 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 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 uint32_t blueprintId,
+		const uint64_t blueprintId,
 		const uint32_t accountId,
-		const uint32_t characterId) override;
-	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+		const LWOOBJID characterId) override;
+	std::vector<MailInfo> GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) override;
 	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
-	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
+	uint32_t GetUnreadMailCount(const LWOOBJID 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 uint32_t characterId, const std::string_view command) override;
+	void InsertSlashCommandUsage(const LWOOBJID 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<uint32_t> GetCurrentPersistentId() override;
+	std::optional<uint64_t> GetCurrentPersistentId() override;
+	IObjectIdTracker::Range GetPersistentIdRange() 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 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 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 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,16 +116,18 @@ 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 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 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 DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
 	bool IsNameInUse(const std::string_view name) override;
-	IPropertyContents::Model GetModel(const LWOOBJID modelID) 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;
 private:
 	CppSQLite3Statement CreatePreppedStmt(const std::string& query);
 
@@ -270,4 +272,15 @@ 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 uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
+void SQLiteDatabase::UpdateActivityLog(const LWOOBJID 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.getIntField("id");
+	toReturn.id = stmt.getInt64Field("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 uint32_t charId) {
+std::optional<ICharInfo::Info> SQLiteDatabase::GetCharacterInfo(const LWOOBJID 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<uint32_t> SQLiteDatabase::GetAccountCharacterIds(const uint32_t accountId) {
+std::vector<LWOOBJID> SQLiteDatabase::GetAccountCharacterIds(const LWOOBJID accountId) {
 	auto [_, result] = ExecuteSelect("SELECT id FROM charinfo WHERE account_id = ? ORDER BY last_login DESC LIMIT 4;", accountId);
 
-	std::vector<uint32_t> toReturn;
+	std::vector<LWOOBJID> toReturn;
 	while (!result.eof()) {
-		toReturn.push_back(result.getIntField("id"));
+		toReturn.push_back(result.getInt64Field("id"));
 		result.nextRow();
 	}
 
@@ -66,15 +66,15 @@ void SQLiteDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 		static_cast<uint32_t>(time(NULL)));
 }
 
-void SQLiteDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
+void SQLiteDatabase::SetCharacterName(const LWOOBJID 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 uint32_t characterId, const std::string_view name) {
+void SQLiteDatabase::SetPendingCharacterName(const LWOOBJID 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 uint32_t characterId) {
+void SQLiteDatabase::UpdateLastLoggedInCharacter(const LWOOBJID 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 uint32_t charId) {
+std::string SQLiteDatabase::GetCharacterXml(const LWOOBJID 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 uint32_t charId) {
 	return result.getStringField("xml_data");
 }
 
-void SQLiteDatabase::UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) {
+void SQLiteDatabase::UpdateCharacterXml(const LWOOBJID charId, const std::string_view lxfml) {
 	ExecuteUpdate("UPDATE charxml SET xml_data = ? WHERE id = ?;", lxfml, charId);
 }
 
-void SQLiteDatabase::InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
+void SQLiteDatabase::InsertCharacterXml(const LWOOBJID 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 uint32_t characterId, const std::string_view command) {
+void SQLiteDatabase::InsertSlashCommandUsage(const LWOOBJID 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 uint32_t charId) {
+std::vector<FriendData> SQLiteDatabase::GetFriendsList(const LWOOBJID 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 uint32_t charId) {
 
 	while (!friendsList.eof()) {
 		FriendData fd;
-		fd.friendID = friendsList.getIntField("player");
+		fd.friendID = friendsList.getInt64Field("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 uint32_t charId) {
 	return toReturn;
 }
 
-std::optional<IFriends::BestFriendStatus> SQLiteDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+std::optional<IFriends::BestFriendStatus> SQLiteDatabase::GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID 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.getIntField("player_id");
-	toReturn.friendCharacterId = result.getIntField("friend_id");
+	toReturn.playerCharacterId = result.getInt64Field("player_id");
+	toReturn.friendCharacterId = result.getInt64Field("friend_id");
 	toReturn.bestFriendStatus = result.getIntField("best_friend");
 
 	return toReturn;
 }
 
-void SQLiteDatabase::SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) {
+void SQLiteDatabase::SetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID 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 uint32_t playerCharacterId, const
 	);
 }
 
-void SQLiteDatabase::AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+void SQLiteDatabase::AddFriend(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
 	ExecuteInsert("INSERT OR IGNORE INTO friends (player_id, friend_id, best_friend) VALUES (?, ?, 0);", playerCharacterId, friendCharacterId);
 }
 
-void SQLiteDatabase::RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+void SQLiteDatabase::RemoveFriend(const LWOOBJID playerCharacterId, const LWOOBJID 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 uint32_t playerId) {
+std::vector<IIgnoreList::Info> SQLiteDatabase::GetIgnoreList(const LWOOBJID 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"), static_cast<uint32_t>(result.getIntField("ignore_id")) });
+		ignoreList.push_back(IIgnoreList::Info{ result.getStringField("name"), result.getInt64Field("ignore_id") });
 		result.nextRow();
 	}
 
 	return ignoreList;
 }
 
-void SQLiteDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+void SQLiteDatabase::AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
 	ExecuteInsert("INSERT OR IGNORE INTO ignore_list (player_id, ignored_player_id) VALUES (?, ?)", playerId, ignoredPlayerId);
 }
 
-void SQLiteDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+void SQLiteDatabase::RemoveIgnore(const LWOOBJID playerId, const LWOOBJID 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.getIntField("character_id");
+		entry.charId = rows.getInt64Field("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 uint32_t playerId, const uint32_t gameId, const Score& score) {
+void SQLiteDatabase::SaveScore(const LWOOBJID 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 uint32_t playerId, const uint32_t gameId, const Score& score) {
+void SQLiteDatabase::UpdateScore(const LWOOBJID 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 uint32_t playerId, const uint32_t gameId) {
+std::optional<ILeaderboard::Score> SQLiteDatabase::GetPlayerScore(const LWOOBJID 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 uint32_t
 	return toReturn;
 }
 
-void SQLiteDatabase::IncrementNumWins(const uint32_t playerId, const uint32_t gameId) {
+void SQLiteDatabase::IncrementNumWins(const LWOOBJID 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 uint32_t playerId, const uint32_t gameId) {
+void SQLiteDatabase::IncrementTimesPlayed(const LWOOBJID 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 uint32_t characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> SQLiteDatabase::GetMailForPlayer(const LWOOBJID 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 uint32_t characterId) {
+uint32_t SQLiteDatabase::GetUnreadMailCount(const LWOOBJID 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,17 +1,40 @@
 #include "SQLiteDatabase.h"
 
-std::optional<uint32_t> SQLiteDatabase::GetCurrentPersistentId() {
+std::optional<uint64_t> SQLiteDatabase::GetCurrentPersistentId() {
 	auto [_, result] = ExecuteSelect("SELECT last_object_id FROM object_id_tracker");
 	if (result.eof()) {
 		return std::nullopt;
 	}
-	return result.getIntField("last_object_id");
+	return result.getInt64Field("last_object_id");
 }
 
 void SQLiteDatabase::InsertDefaultPersistentId() {
 	ExecuteInsert("INSERT INTO object_id_tracker VALUES (1);");
 }
 
-void SQLiteDatabase::UpdatePersistentId(const uint32_t newId) {
-	ExecuteUpdate("UPDATE object_id_tracker SET last_object_id = ?;", newId);
+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;
 }

dDatabase/GameDatabase/SQLite/Tables/Property.cpp

@@ -1,6 +1,23 @@
 #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;
@@ -118,19 +135,7 @@ std::optional<IProperty::PropertyEntranceResult> SQLiteDatabase::GetProperties(c
 	auto& [_, properties] = propertiesRes;
 	if (!properties.eof() && !result.has_value()) result = IProperty::PropertyEntranceResult();
 	while (!properties.eof()) {
-		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");
+		result->entries.push_back(ReadPropertyInfo(properties));
 		properties.nextRow();
 	}
 
@@ -146,21 +151,7 @@ std::optional<IProperty::Info> SQLiteDatabase::GetPropertyInfo(const LWOMAPID ma
 		return std::nullopt;
 	}
 
-	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;
+	return ReadPropertyInfo(propertyEntry);
 }
 
 void SQLiteDatabase::UpdatePropertyModerationInfo(const IProperty::Info& info) {
@@ -197,3 +188,15 @@ 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,27 +64,28 @@ void SQLiteDatabase::RemoveModel(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
 }
 
-IPropertyContents::Model SQLiteDatabase::GetModel(const LWOOBJID modelID) {
+std::optional<IPropertyContents::Model> SQLiteDatabase::GetModel(const LWOOBJID modelID) {
 	auto [_, result] = ExecuteSelect("SELECT * FROM properties_contents WHERE id = ?", modelID);
 
-	IPropertyContents::Model model{};
+	std::optional<IPropertyContents::Model> model = std::nullopt;
 	if (!result.eof()) {
 		do {
-			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 = 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");
 		} while (result.nextRow());
 	}
 

dDatabase/GameDatabase/SQLite/Tables/Ugc.cpp

@@ -1,5 +1,17 @@
 #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;",
@@ -8,14 +20,7 @@ std::vector<IUgc::Model> SQLiteDatabase::GetUgcModels(const LWOOBJID& propertyId
 	std::vector<IUgc::Model> toReturn;
 
 	while (!result.eof()) {
-		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));
+		toReturn.push_back(ReadModel(result));
 		result.nextRow();
 	}
 
@@ -27,14 +32,7 @@ std::vector<IUgc::Model> SQLiteDatabase::GetAllUgcModels() {
 
 	std::vector<IUgc::Model> models;
 	while (!result.eof()) {
-		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));
+		models.push_back(ReadModel(result));
 		result.nextRow();
 	}
 
@@ -47,9 +45,9 @@ void SQLiteDatabase::RemoveUnreferencedUgcModels() {
 
 void SQLiteDatabase::InsertNewUgcModel(
 	std::stringstream& sd0Data, // cant be const sad
-	const uint32_t blueprintId,
+	const uint64_t blueprintId,
 	const uint32_t accountId,
-	const uint32_t characterId) {
+	const LWOOBJID characterId) {
 	const std::istream stream(sd0Data.rdbuf());
 	ExecuteInsert(
 		"INSERT INTO `ugc`(`id`, `account_id`, `character_id`, `is_optimized`, `lxfml`, `bake_ao`, `filename`) VALUES (?,?,?,?,?,?,?)",
@@ -72,3 +70,14 @@ 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<uint32_t> characterId) {
+void SQLiteDatabase::InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> 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(uint32_t charID) {
+std::vector<FriendData> TestSQLDatabase::GetFriendsList(LWOOBJID charID) {
 	return {};
 }
 
-std::optional<IFriends::BestFriendStatus> TestSQLDatabase::GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) {
+std::optional<IFriends::BestFriendStatus> TestSQLDatabase::GetBestFriendStatus(const LWOOBJID playerCharacterId, const LWOOBJID friendCharacterId) {
 	return {};
 }
 
-void TestSQLDatabase::SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) {
+void TestSQLDatabase::SetBestFriendStatus(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId, const uint32_t bestFriendStatus) {
 
 }
 
-void TestSQLDatabase::AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) {
+void TestSQLDatabase::AddFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) {
 
 }
 
-void TestSQLDatabase::RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) {
+void TestSQLDatabase::RemoveFriend(const LWOOBJID playerAccountId, const LWOOBJID friendAccountId) {
 
 }
 
-void TestSQLDatabase::UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) {
+void TestSQLDatabase::UpdateActivityLog(const LWOOBJID 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 uint32_t charId) {
+std::optional<ICharInfo::Info> TestSQLDatabase::GetCharacterInfo(const LWOOBJID charId) {
 	return {};
 }
 
@@ -88,11 +88,11 @@ std::optional<ICharInfo::Info> TestSQLDatabase::GetCharacterInfo(const std::stri
 	return {};
 }
 
-std::string TestSQLDatabase::GetCharacterXml(const uint32_t accountId) {
+std::string TestSQLDatabase::GetCharacterXml(const LWOOBJID accountId) {
 	return {};
 }
 
-void TestSQLDatabase::UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) {
+void TestSQLDatabase::UpdateCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) {
 
 }
 
@@ -104,27 +104,27 @@ void TestSQLDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 
 }
 
-void TestSQLDatabase::InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) {
+void TestSQLDatabase::InsertCharacterXml(const LWOOBJID accountId, const std::string_view lxfml) {
 
 }
 
-std::vector<uint32_t> TestSQLDatabase::GetAccountCharacterIds(uint32_t accountId) {
+std::vector<LWOOBJID> TestSQLDatabase::GetAccountCharacterIds(LWOOBJID accountId) {
 	return {};
 }
 
-void TestSQLDatabase::DeleteCharacter(const uint32_t characterId) {
+void TestSQLDatabase::DeleteCharacter(const LWOOBJID characterId) {
 
 }
 
-void TestSQLDatabase::SetCharacterName(const uint32_t characterId, const std::string_view name) {
+void TestSQLDatabase::SetCharacterName(const LWOOBJID characterId, const std::string_view name) {
 
 }
 
-void TestSQLDatabase::SetPendingCharacterName(const uint32_t characterId, const std::string_view name) {
+void TestSQLDatabase::SetPendingCharacterName(const LWOOBJID characterId, const std::string_view name) {
 
 }
 
-void TestSQLDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
+void TestSQLDatabase::UpdateLastLoggedInCharacter(const LWOOBJID characterId) {
 
 }
 
@@ -192,11 +192,11 @@ void TestSQLDatabase::InsertNewMail(const MailInfo& mail) {
 
 }
 
-void TestSQLDatabase::InsertNewUgcModel(std::stringstream& sd0Data, const uint32_t blueprintId, const uint32_t accountId, const uint32_t characterId) {
+void TestSQLDatabase::InsertNewUgcModel(std::stringstream& sd0Data, const uint64_t blueprintId, const uint32_t accountId, const LWOOBJID characterId) {
 
 }
 
-std::vector<MailInfo> TestSQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> TestSQLDatabase::GetMailForPlayer(const LWOOBJID 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 uint32_t characterId) {
+uint32_t TestSQLDatabase::GetUnreadMailCount(const LWOOBJID characterId) {
 	return {};
 }
 
@@ -220,7 +220,7 @@ void TestSQLDatabase::ClaimMailItem(const uint64_t mailId) {
 
 }
 
-void TestSQLDatabase::InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) {
+void TestSQLDatabase::InsertSlashCommandUsage(const LWOOBJID characterId, const std::string_view command) {
 
 }
 
@@ -244,7 +244,7 @@ void TestSQLDatabase::SetMasterInfo(const IServers::MasterInfo& info) {
 
 }
 
-std::optional<uint32_t> TestSQLDatabase::GetCurrentPersistentId() {
+std::optional<uint64_t> TestSQLDatabase::GetCurrentPersistentId() {
 	return {};
 }
 
@@ -252,10 +252,6 @@ void TestSQLDatabase::InsertDefaultPersistentId() {
 
 }
 
-void TestSQLDatabase::UpdatePersistentId(const uint32_t id) {
-
-}
-
 std::optional<uint32_t> TestSQLDatabase::GetDonationTotal(const uint32_t activityId) {
 	return {};
 }
@@ -268,15 +264,15 @@ std::vector<IUgc::Model> TestSQLDatabase::GetUgcModels(const LWOOBJID& propertyI
 	return {};
 }
 
-void TestSQLDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+void TestSQLDatabase::AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
 
 }
 
-void TestSQLDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+void TestSQLDatabase::RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) {
 
 }
 
-std::vector<IIgnoreList::Info> TestSQLDatabase::GetIgnoreList(const uint32_t playerId) {
+std::vector<IIgnoreList::Info> TestSQLDatabase::GetIgnoreList(const LWOOBJID playerId) {
 	return {};
 }
 
@@ -304,3 +300,6 @@ 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(uint32_t charID) override;
+	std::vector<FriendData> GetFriendsList(LWOOBJID charID) 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;
+	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;
 	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 uint32_t charId) override;
+	std::optional<ICharInfo::Info> GetCharacterInfo(const LWOOBJID charId) override;
 	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
-	std::string GetCharacterXml(const uint32_t accountId) override;
-	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
+	std::string GetCharacterXml(const LWOOBJID accountId) override;
+	void UpdateCharacterXml(const LWOOBJID 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 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 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 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 uint32_t blueprintId,
+		const uint64_t blueprintId,
 		const uint32_t accountId,
-		const uint32_t characterId) override;
-	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+		const LWOOBJID characterId) override;
+	std::vector<MailInfo> GetMailForPlayer(const LWOOBJID characterId, const uint32_t numberOfMail) override;
 	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
-	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
+	uint32_t GetUnreadMailCount(const LWOOBJID 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 uint32_t characterId, const std::string_view command) override;
+	void InsertSlashCommandUsage(const LWOOBJID 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<uint32_t> GetCurrentPersistentId() override;
+	std::optional<uint64_t> GetCurrentPersistentId() override;
+	IObjectIdTracker::Range GetPersistentIdRange() 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 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 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 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,17 +95,19 @@ 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 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 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 DeleteUgcBuild(const LWOOBJID bigId) override {};
 	uint32_t GetAccountCount() override { return 0; };
 
 	bool IsNameInUse(const std::string_view name) override { return false; };
-	IPropertyContents::Model GetModel(const LWOOBJID modelID) override { return {}; }
+	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 {}; }
 };
 
 #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.position != NiPoint3Constant::ZERO || model.lot != 14) continue;
+		if (!model || 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.lot != 14) continue;
+		if (!model || 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.lot != 14) continue;
+		if (!model || 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(uint32_t id, User* parentUser) {
+Character::Character(LWOOBJID id, User* parentUser) {
 	//First load the name, etc:
 	m_ID = id;
 	m_ParentUser = parentUser;
@@ -50,6 +50,10 @@ 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.
@@ -61,7 +65,6 @@ 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;
@@ -75,7 +78,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 (%i)!", m_Name.c_str(), m_ID);
+		LOG("Loaded xmlData for character %s (%llu)!", 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);
@@ -238,7 +241,7 @@ void Character::SetBuildMode(bool buildMode) {
 void Character::SaveXMLToDatabase() {
 	// Check that we can actually _save_ before saving
 	if (!m_OurEntity) {
-		LOG("%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
+		LOG("%llu:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
 		return;
 	}
 
@@ -308,7 +311,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("%i:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
+	LOG("%llu:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
 }
 
 void Character::SetIsNewLogin() {
@@ -320,7 +323,7 @@ void Character::SetIsNewLogin() {
 	while (currentChild) {
 		auto* nextChild = currentChild->NextSiblingElement();
 		if (currentChild->Attribute("si")) {
-			LOG("Removed session flag (%s) from character %i:%s, saving character to database", currentChild->Attribute("si"), GetID(), GetName().c_str());
+			LOG("Removed session flag (%s) from character %llu:%s, saving character to database", currentChild->Attribute("si"), GetID(), GetName().c_str());
 			flags->DeleteChild(currentChild);
 			WriteToDatabase();
 		}
@@ -333,8 +336,11 @@ 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, printer.CStr());
+	Database::Get()->UpdateCharacterXml(m_ID, m_XMLData);
 }
 
 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(uint32_t id, User* parentUser);
+	Character(LWOOBJID id, User* parentUser);
 	~Character();
 
 	/**
@@ -53,7 +53,7 @@ public:
 	 * Gets the database ID of the character
 	 * @return the database ID of the character
 	 */
-	uint32_t GetID() const { return m_ID; }
+	LWOOBJID 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. First 32 bits of the ObjectID.
+	 * The ID of this character.
 	 */
-	uint32_t m_ID{};
+	LWOOBJID m_ID{};
 
 	/**
 	 * The 64-bit unique ID used in the game.

dGame/EntityManager.cpp

@@ -52,6 +52,43 @@ 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(
@@ -61,15 +98,8 @@ void EntityManager::Initialize() {
 	) == m_GhostingExcludedZones.end();
 
 	// grab hardcore mode settings and load them with sane defaults
-	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");
-
+	Game::config->AddConfigHandler([]() {Game::entityManager->ReloadConfig();});
+	Game::entityManager->ReloadConfig();
 	// 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,11 +75,18 @@ 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();
@@ -112,6 +119,12 @@ 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 uint32_t relatedPlayer, const Leaderboard::InfoType infoType, const uint32_t numResults) {
+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> 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 uint32_t relatedPlayer) {
+std::vector<ILeaderboard::Entry> FilterFriends(const std::vector<ILeaderboard::Entry>& leaderboard, const LWOOBJID 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 uint32_t relatedPlayer,
+	const LWOOBJID 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 uint32_t lastUsedCharacterId = characterList.front();
+			const auto lastUsedCharacterId = characterList.front();
 			Character* character = new Character(lastUsedCharacterId, this);
 			character->UpdateFromDatabase();
 			m_Characters.push_back(character);
-			LOG("Loaded %i as it is the last used char", lastUsedCharacterId);
+			LOG("Loaded %llu as it is the last used char", lastUsedCharacterId);
 		}
 	}
 }
@@ -132,10 +132,7 @@ 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);
-		CommonPackets::DisconnectNotify notification;
-		notification.disconnectID = eServerDisconnectIdentifiers::PLAY_SCHEDULE_TIME_DONE;
-		notification.Send(this->m_SystemAddress);
-		Game::server->Disconnect(this->m_SystemAddress);
+		Game::server->Disconnect(this->m_SystemAddress, eServerDisconnectIdentifiers::PLAY_SCHEDULE_TIME_DONE);
 	}
 }
 

dGame/UserManager.cpp

@@ -30,6 +30,7 @@
 #include "BitStreamUtils.h"
 #include "CheatDetection.h"
 #include "CharacterComponent.h"
+#include "eCharacterVersion.h"
 
 UserManager* UserManager::m_Address = nullptr;
 
@@ -324,79 +325,77 @@ 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 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;
-		}
+	//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();
+	}
 
-		std::stringstream xml;
-		xml << "<obj v=\"1\">";
+	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;
+	}
 
-		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 << "\"/>";
+	std::stringstream xml;
+	xml << "<obj v=\"1\">";
 
-		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 << "<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>";
+	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 << "<dest hm=\"4\" hc=\"4\" im=\"0\" ic=\"0\" am=\"0\" ac=\"0\" d=\"0\"/>";
+	xml << "</char>";
 
-		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 << "<dest hm=\"4\" hc=\"4\" im=\"0\" ic=\"0\" am=\"0\" ac=\"0\" d=\"0\"/>";
 
-		LWOOBJID lwoidforshirt = ObjectIDManager::GenerateRandomObjectID();
-		LWOOBJID lwoidforpants;
+	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\">";
 
-		do {
-			lwoidforpants = ObjectIDManager::GenerateRandomObjectID();
-		} while (lwoidforpants == lwoidforshirt); //Make sure we don't have the same ID for both shirt and pants
+	LWOOBJID lwoidforshirt = ObjectIDManager::GetPersistentID();
+	LWOOBJID lwoidforpants = ObjectIDManager::GetPersistentID();
 
-		GeneralUtils::SetBit(lwoidforshirt, eObjectBits::CHARACTER);
-		GeneralUtils::SetBit(lwoidforshirt, eObjectBits::PERSISTENT);
-		GeneralUtils::SetBit(lwoidforpants, eObjectBits::CHARACTER);
-		GeneralUtils::SetBit(lwoidforpants, eObjectBits::PERSISTENT);
+	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\"/>";
 
-		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\"/>";
+	xml << "</in></items></inv><lvl l=\"1\" cv=\"" << GeneralUtils::ToUnderlying(eCharacterVersion::UP_TO_DATE) << "\" sb=\"500\"/><flag></flag></obj>";
 
-		xml << "</in></items></inv><lvl l=\"1\" cv=\"1\" sb=\"500\"/><flag></flag></obj>";
+	//Check to see if our name was pre-approved:
+	bool nameOk = IsNamePreapproved(name);
+	if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
 
-		//Check to see if our name was pre-approved:
-		bool nameOk = IsNamePreapproved(name);
-		if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
+	// 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();
+	}
 
-		// 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();
-		}
+	std::string_view nameToAssign = !name.empty() && nameOk ? name : assignedPredefinedName;
+	std::string pendingName = !name.empty() && !nameOk ? name : "";
 
-		std::string_view nameToAssign = !name.empty() && nameOk ? name : assignedPredefinedName;
-		std::string pendingName = !name.empty() && !nameOk ? name : "";
+	ICharInfo::Info info;
+	info.name = nameToAssign;
+	info.pendingName = pendingName;
+	info.id = objectID;
+	info.accountId = u->GetAccountID();
 
-		ICharInfo::Info info;
-		info.name = nameToAssign;
-		info.pendingName = pendingName;
-		info.id = objectID;
-		info.accountId = u->GetAccountID();
+	Database::Get()->InsertNewCharacter(info);
 
-		Database::Get()->InsertNewCharacter(info);
+	//Now finally insert our character xml:
+	Database::Get()->InsertCharacterXml(objectID, xml.str());
 
-		//Now finally insert our character xml:
-		Database::Get()->InsertCharacterXml(objectID, xml.str());
-
-		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
-		UserManager::RequestCharacterList(sysAddr);
-		});
+	WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
+	UserManager::RequestCharacterList(sysAddr);
 }
 
 void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet) {
@@ -409,9 +408,8 @@ 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 (%u)", objectID, charID);
+	LOG("Received char delete req for ID: %llu", objectID);
 
 	bool hasCharacter = CheatDetection::VerifyLwoobjidIsSender(
 		objectID,
@@ -423,8 +421,8 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 	if (!hasCharacter) {
 		WorldPackets::SendCharacterDeleteResponse(sysAddr, false);
 	} else {
-		LOG("Deleting character %i", charID);
-		Database::Get()->DeleteCharacter(charID);
+		LOG("Deleting character %llu", objectID);
+		Database::Get()->DeleteCharacter(objectID);
 
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, ServiceType::CHAT, MessageType::Chat::UNEXPECTED_DISCONNECT);
@@ -445,11 +443,8 @@ 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);
 
-	uint32_t charID = static_cast<uint32_t>(objectID);
-	LOG("Received char rename request for ID: %llu (%u)", objectID, charID);
+	LOG("Received char rename request for ID: %llu", objectID);
 
 	LUWString LUWStringName;
 	inStream.Read(LUWStringName);
@@ -466,7 +461,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() == charID) {
+		if (c->GetID() == objectID) {
 			character = c;
 			return true;
 		}
@@ -483,12 +478,12 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 		if (!Database::Get()->GetCharacterInfo(newName)) {
 			if (IsNamePreapproved(newName)) {
-				Database::Get()->SetCharacterName(charID, newName);
+				Database::Get()->SetCharacterName(objectID, 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(charID, newName);
+				Database::Get()->SetPendingCharacterName(objectID, 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);
@@ -502,7 +497,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 	}
 }
 
-void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID) {
+void UserManager::LoginCharacter(const SystemAddress& sysAddr, LWOOBJID 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, uint32_t playerID);
+	void LoginCharacter(const SystemAddress& sysAddr, LWOOBJID 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,6 +37,7 @@
 #include "eMissionTaskType.h"
 #include "eStateChangeType.h"
 #include "eGameActivity.h"
+#include <ranges>
 
 #include "CDComponentsRegistryTable.h"
 
@@ -666,11 +667,6 @@ 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);
 }
 
@@ -698,6 +694,11 @@ 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);
@@ -981,7 +982,8 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 		auto* character = m_Parent->GetComponent<CharacterComponent>();
 		auto uscore = character->GetUScore();
 
-		auto uscoreToLose = uscore * (Game::entityManager->GetHardcoreLoseUscoreOnDeathPercent() / 100);
+		auto uscoreToLose = static_cast<uint64_t>(uscore * (Game::entityManager->GetHardcoreLoseUscoreOnDeathPercent() / 100.0f));
+		LOG("Player %llu has lost %llu uscore!", m_Parent->GetObjectID(), uscoreToLose);
 		character->SetUScore(uscore - uscoreToLose);
 
 		GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::MISSION);
@@ -995,13 +997,11 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 				if (items) {
 					auto itemMap = items->GetItems();
 					if (!itemMap.empty()) {
-						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);
+						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);
 						}
 						Game::entityManager->SerializeEntity(m_Parent);
 					}
@@ -1020,24 +1020,25 @@ 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) {
+		if (playerStats && GetMaxHealth() > 0 && !Game::entityManager->GetHardcoreUscoreExcludedEnemies().contains(lot)) {
 			//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();
-
+			int uscore = maxHealth * Game::entityManager->GetHardcoreUscoreEnemiesMultiplier() * uscoreReduction;
+			LOG("Rewarding player %llu with %i uscore for killing enemy %i", player->GetObjectID(), uscore, lot);
 			playerStats->SetUScore(playerStats->GetUScore() + uscore);
 			GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::MISSION);
 

dGame/dComponents/InventoryComponent.cpp

@@ -626,7 +626,8 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument& document) {
 	for (const auto& pair : this->m_Inventories) {
 		auto* inventory = pair.second;
 
-		if (inventory->GetType() == VENDOR_BUYBACK || inventory->GetType() == eInventoryType::MODELS_IN_BBB) {
+		static const auto EXCLUDED_INVENTORIES = {VENDOR_BUYBACK, MODELS_IN_BBB, ITEM_SETS};
+		if (std::ranges::find(EXCLUDED_INVENTORIES, inventory->GetType()) != EXCLUDED_INVENTORIES.end()) {
 			continue;
 		}
 
@@ -1786,3 +1787,9 @@ 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,10 +402,14 @@ public:
 	bool SetSkill(BehaviorSlot slot, uint32_t skillId);
 
 	void UpdateGroup(const GroupUpdate& groupUpdate);
-	void RemoveGroup(const std::string& groupId);
+
+	std::unordered_map<LWOOBJID, DatabasePet>& GetPetsMut() { return m_Pets; };
 
 	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,6 +19,7 @@
 #include "MissionPrerequisites.h"
 #include "AchievementCacheKey.h"
 #include "eMissionState.h"
+#include "StringifiedEnum.h"
 
  // MARK: Mission Component
 
@@ -136,6 +137,7 @@ 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,10 +479,19 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
 		return;
 	}
 
-	LWOOBJID petSubKey = ObjectIDManager::GenerateRandomObjectID();
+	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();
+	}
 
-	GeneralUtils::SetBit(petSubKey, eObjectBits::CHARACTER);
-	GeneralUtils::SetBit(petSubKey, eObjectBits::PERSISTENT);
+	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;
+	}
 
 	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 %u!", owner);
+			LOG("Failed to find property owner name for %llu!", owner);
 			continue;
 		}
 		auto& entry = entries.emplace_back();

dGame/dComponents/PropertyManagementComponent.cpp

@@ -64,7 +64,6 @@ 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;
@@ -171,7 +170,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);
 
@@ -204,14 +203,22 @@ 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);
 
-	propertyId = ObjectIDManager::GenerateRandomObjectID();
+	// 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();
+	}
 
 	IProperty::Info info;
 	info.id = propertyId;
@@ -375,46 +382,45 @@ void PropertyManagementComponent::UpdateModelPosition(const LWOOBJID id, const N
 	node->position = position;
 	node->rotation = rotation;
 
-	ObjectIDManager::RequestPersistentID([this, node, modelLOT, entity, position, rotation, originalRotation](uint32_t persistentId) {
-		SpawnerInfo info{};
+	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 = persistentId;
-		GeneralUtils::SetBit(info.spawnerID, eObjectBits::CLIENT);
+	info.spawnerID = ObjectIDManager::GetPersistentID();
+	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);
+	GameMessages::SendGetModelsOnProperty(entity->GetObjectID(), GetModels(), UNASSIGNED_SYSTEM_ADDRESS);
+
+	Game::entityManager->GetZoneControlEntity()->OnZonePropertyModelPlaced(entity);
 
-		Game::entityManager->GetZoneControlEntity()->OnZonePropertyModelPlaced(entity);
-		});
 	// Progress place model missions
 	auto missionComponent = entity->GetComponent<MissionComponent>();
 	if (missionComponent != nullptr) missionComponent->Progress(eMissionTaskType::PLACE_MODEL, 0);
@@ -622,8 +628,6 @@ 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));
@@ -696,7 +700,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
@@ -824,7 +828,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,16 +5,18 @@
 
 #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);
-}
-
-ScriptComponent::~ScriptComponent() {
-
+	RegisterMsg<GetObjectReportInfo>(this, &ScriptComponent::OnGetObjectReportInfo);
 }
 
 void ScriptComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
@@ -50,3 +52,16 @@ 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,8 +21,7 @@ class ScriptComponent final : public Component {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::SCRIPT;
 
-	ScriptComponent(Entity* parent, std::string scriptName, bool serialized, bool client = false);
-	~ScriptComponent() override;
+	ScriptComponent(Entity* parent, const std::string& scriptName, bool serialized, bool client = false);
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
@@ -43,6 +42,8 @@ public:
 	 * @param scriptName the name of the script to find
 	 */
 	void SetScript(const std::string& scriptName);
+	
+	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
 
 private:
 
@@ -60,6 +61,8 @@ 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::shared_ptr<char[]> sd0Data(new char[sd0Size]);
+	std::unique_ptr<char[]> sd0Data(new char[sd0Size]);
 
 	if (sd0Data == nullptr) return;
 
@@ -2579,118 +2579,121 @@ 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:
-	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);
+	if (!entity || !entity->GetCharacter() || !entity->GetCharacter()->GetParentUser()) return;
+	const uint32_t maxRetries = 100;
+	uint32_t retries = 0;
+	bool blueprintIDExists = true;
+	bool modelExists = true;
 
-		uint32_t blueprintIDSmall = ObjectIDManager::GenerateRandomObjectID();
-		LWOOBJID blueprintID = blueprintIDSmall;
-		GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
-		GeneralUtils::SetBit(blueprintID, 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);
 
-		//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, blueprintIDSmall, 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, blueprintID, entity->GetCharacter()->GetParentUser()->GetAccountID(), entity->GetCharacter()->GetID());
 
-		//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");
+	//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");
 
-		/*
-			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 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);
+	//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);
 
-		bitStream.Write(sd0Size);
+	bitStream.Write(newSd0Size);
 
-		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) {
@@ -5529,55 +5532,52 @@ void GameMessages::HandleModularBuildFinish(RakNet::BitStream& inStream, Entity*
 			}
 		}
 
-		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
+		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 newIdBig = newId;
-			GeneralUtils::SetBit(newIdBig, eObjectBits::CHARACTER);
+		LWOOBJID newID = ObjectIDManager::GetPersistentID();
 
-			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);
+		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));
 			}
+		}
 
-			auto* pCharacter = character->GetCharacter();
-			Database::Get()->InsertUgcBuild(GeneralUtils::UTF16ToWTF8(modules), newIdBig, pCharacter ? std::optional(character->GetCharacter()->GetID()) : std::nullopt);
+		ScriptComponent* script = static_cast<ScriptComponent*>(entity->GetComponent(eReplicaComponentType::SCRIPT));
 
-			auto* missionComponent = character->GetComponent<MissionComponent>();
+		entity->GetScript()->OnModularBuildExit(entity, character, count >= 3, modList);
 
-			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));
-				}
-			}
+		// Move remaining temp models back to models
+		std::vector<Item*> items;
 
-			ScriptComponent* script = static_cast<ScriptComponent*>(entity->GetComponent(eReplicaComponentType::SCRIPT));
+		for (const auto& pair : temp->GetItems()) {
+			items.push_back(pair.second);
+		}
 
-			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);
-			}
-			});
+		for (auto* item : items) {
+			inv->MoveItemToInventory(item, eInventoryType::MODELS, item->GetCount(), false);
+		}
 	}
 }
 

dGame/dInventory/Inventory.cpp

@@ -5,8 +5,11 @@
 #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
@@ -317,3 +320,16 @@ 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,6 +158,8 @@ public:
 	 */
 	void DeleteAllItems();
 
+	void RegenerateItemIDs();
+
 	~Inventory();
 
 private:

dGame/dInventory/Item.cpp

@@ -98,22 +98,12 @@ Item::Item(
 	this->preconditions = new PreconditionExpression(this->info->reqPrecondition);
 	this->subKey = subKey;
 
-	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;
+	auto* const inventoryComponent = inventory->GetComponent();
+	GenerateID();
 
 	inventory->AddManagedItem(this);
 
-	auto* entity = inventory->GetComponent()->GetParent();
+	auto* entity = inventoryComponent->GetParent();
 	GameMessages::SendAddItemToInventoryClientSync(entity, entity->GetSystemAddress(), this, id, showFlyingLoot, static_cast<int>(this->count), subKey, lootSourceType);
 
 	if (isModMoveAndEquip) {
@@ -121,7 +111,7 @@ Item::Item(
 
 		LOG("Move and equipped (%i) from (%i)", this->lot, this->inventory->GetType());
 
-		Game::entityManager->SerializeEntity(inventory->GetComponent()->GetParent());
+		Game::entityManager->SerializeEntity(inventoryComponent->GetParent());
 	}
 }
 
@@ -574,3 +564,28 @@ 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,6 +228,8 @@ public:
 
 	void LoadConfigXml(const tinyxml2::XMLElement& i);
 
+	LWOOBJID GenerateID();
+
 private:
 	/**
 	 * The object ID of this item

dGame/dMission/Mission.cpp

@@ -29,6 +29,11 @@
 #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;
@@ -563,12 +568,14 @@ 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;
 		}
@@ -618,3 +625,7 @@ Mission::~Mission() {
 
 	m_Tasks.clear();
 }
+
+const std::set<uint32_t>& Mission::GetTestedMissions() const {
+	return g_TestedMissions;
+}

dGame/dMission/Mission.h

@@ -241,6 +241,9 @@ 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,6 +15,7 @@
 #include "MissionComponent.h"
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
+#include "StringifiedEnum.h"
 
 MissionTask::MissionTask(Mission* mission, CDMissionTasks* info, uint32_t mask) {
 	this->info = info;
@@ -99,6 +100,7 @@ Mission* MissionTask::GetMission() const {
 
 
 uint32_t MissionTask::GetTarget() const {
+	if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("Target: %i", info->targetValue);
 	return info->target;
 }
 
@@ -158,6 +160,7 @@ 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;
@@ -168,6 +171,7 @@ bool MissionTask::IsComplete() const {
 
 
 void MissionTask::Complete() {
+	if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("target: %i", info->targetValue);
 	SetProgress(info->targetValue);
 }
 
@@ -180,6 +184,7 @@ 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();
@@ -229,7 +234,7 @@ void MissionTask::Progress(int32_t value, LWOOBJID associate, const std::string&
 		entity = Game::entityManager->GetEntity(associate);
 		if (entity == nullptr) {
 			if (associate != LWOOBJID_EMPTY) {
-				LOG("Failed to find associated entity (%llu)!", associate);
+				if (mission->GetTestedMissions().contains(mission->GetMissionId())) LOG("Failed to find associated entity (%llu)!", associate);
 			}
 			break;
 		}

dGame/dPropertyBehaviors/ControlBehaviors.cpp

@@ -35,25 +35,21 @@
 void ControlBehaviors::RequestUpdatedID(ControlBehaviorContext& context) {
 	BehaviorMessageBase msgBase{ context.arguments };
 	const auto oldBehaviorID = msgBase.GetBehaviorId();
-	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;
+	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;
 
-			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 (%i) which is not an id they own.",
-				sysAddr.ToString(), user->GetLastUsedChar()->GetName().c_str(), user->GetLastUsedChar()->GetObjectID(), static_cast<int32_t>(id));
+			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);
 		// 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 uint32_t characterId = static_cast<uint32_t>(id);
+		const auto characterId = 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<MailClientLUBitStream>()>> g_Handlers = {
+	std::map<eMessageID, std::function<std::unique_ptr<MailLUBitStream>()>> g_Handlers = {
 		{eMessageID::SendRequest, []() {
 			return std::make_unique<SendRequest>();
 		}},
@@ -55,11 +55,11 @@ namespace Mail {
 		}},
 	};
 
-	void MailClientLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+	void MailLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
 		bitStream.Write(messageID);
 	}
 
-	bool MailClientLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
+	bool MailLUBitStream::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();
+		response.Send(sysAddr);
 	}
 
 	void SendResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailClientLUBitStream::Serialize(bitStream);
+		MailLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 	}
 
 	void NotificationResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailClientLUBitStream::Serialize(bitStream);
+		MailLUBitStream::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();
+		response.Send(sysAddr);
 		LOG("DataRequest");
 	}
 
 	void DataResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailClientLUBitStream::Serialize(bitStream);
+		MailLUBitStream::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();
+		response.Send(sysAddr);
 	}
 
 	void AttachmentCollectResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailClientLUBitStream::Serialize(bitStream);
+		MailLUBitStream::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();
+		response.Send(sysAddr);
 	}
 
 	void DeleteResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailClientLUBitStream::Serialize(bitStream);
+		MailLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -256,11 +256,11 @@ namespace Mail {
 		}
 
 		LOG("ReadRequest %s", StringifiedEnum::ToString(response.status).data());
-		response.Send();
+		response.Send(sysAddr);
 	}
 
 	void ReadResponse::Serialize(RakNet::BitStream& bitStream) const {
-		MailClientLUBitStream::Serialize(bitStream);
+		MailLUBitStream::Serialize(bitStream);
 		bitStream.Write(status);
 		bitStream.Write(mailID);
 	}
@@ -275,13 +275,13 @@ namespace Mail {
 		}
 
 		LOG("NotificationRequest %s", StringifiedEnum::ToString(response.status).data());
-		response.Send();
+		response.Send(sysAddr);
 	}
 }
 
 // Non Stuct Functions
-void Mail::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
-	MailClientLUBitStream data;
+void Mail::HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
+	MailLUBitStream 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();
+	response.Send(sysAddr);
 }

dGame/dUtilities/Mail.h

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

dGame/dUtilities/ObjectIDManager.cpp

@@ -5,47 +5,37 @@
 #include "Database.h"
 #include "Logger.h"
 #include "Game.h"
+#include "eObjectBits.h"
 
- //! 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;
-
-	std::function<void(uint32_t)> callback;
-};
+// should the spawners from vanity also have the CLIENT flag?
 
 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);
+	// 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)
 };
 
-//! Requests a persistent ID
-void ObjectIDManager::RequestPersistentID(const std::function<void(uint32_t)> callback) {
-	const auto& request = Requests.emplace_back(++CurrentRequestID, 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.");
+		}
 
-	MasterPackets::SendPersistentIDRequest(Game::server, request.requestID);
+		LOG("Reserved object ID range: %llu - %llu", CurrentRange->minID, CurrentRange->maxID);
+	}
+
+	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;
 }
 
-//! 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)
+// Generates an object ID server-sided (used for regular entities like smashables)
 uint32_t ObjectIDManager::GenerateObjectID() {
 	return ++CurrentObjectID;
 }

dGame/dUtilities/ObjectIDManager.h

@@ -5,36 +5,25 @@
 #include <vector>
 #include <stdint.h>
 
-/*!
-  \file ObjectIDManager.h
-  \brief A manager for handling object ID generation
+/**
+ *  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.
  */
 
-//! The Object ID Manager
 namespace ObjectIDManager {
-	//! Requests a persistent ID
-	/*!
-	  \param callback The callback function
+
+	/**
+	 * @brief Returns a Persistent ID with the CHARACTER bit set.
+	 * 
+	 * @return uint64_t A unique persistent ID with the CHARACTER bit set.
 	 */
-	void RequestPersistentID(const std::function<void(uint32_t)> callback);
+	uint64_t GetPersistentID();
 
-
-	//! 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
+	/**
+	 * @brief Generates an ephemeral object ID for non-persistent objects.
+	 * 
+	 * @return uint32_t 
 	 */
 	uint32_t GenerateObjectID();
-
-	//! Generates a random object ID server-sided
-	/*!
-	 \return A generated object ID
-	 */
-	uint32_t GenerateRandomObjectID();
 };

dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp

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

dMasterServer/CMakeLists.txt

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

dMasterServer/MasterServer.cpp

@@ -35,7 +35,6 @@
 #include "Game.h"
 #include "InstanceManager.h"
 #include "MasterPackets.h"
-#include "PersistentIDManager.h"
 #include "FdbToSqlite.h"
 #include "BitStreamUtils.h"
 #include "Start.h"
@@ -99,6 +98,7 @@ 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,7 +359,6 @@ 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
@@ -533,17 +532,6 @@ 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");
@@ -881,9 +869,6 @@ 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

@@ -1,45 +0,0 @@
-#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

@@ -1,23 +0,0 @@
-#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,244 +17,296 @@
 
 #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;
 }
 
-namespace AuthPackets {
-	std::map<MessageType::Auth, std::function<std::unique_ptr<LUBitStream>()>> g_Handlers = {
-		{MessageType::Auth::LOGIN_REQUEST, []() {
-			return std::make_unique<LoginRequest>();
-		}}
-	};
+void Stamp::Serialize(RakNet::BitStream& outBitStream){
+	outBitStream.Write(type);
+	outBitStream.Write(value);
+	outBitStream.Write(timestamp);
+};
 
-	// 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());
 	}
 }
 
-// Non Stuct Functions
-void AuthPackets::Handle(RakNet::BitStream& inStream, const SystemAddress& sysAddr) {
-	AuthLUBitStream authLUBitStream;
-	if (!authLUBitStream.Deserialize(inStream)) return;
+void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
+	CINSTREAM_SKIP_HEADER
+	uint32_t clientVersion = 0;
+	inStream.Read(clientVersion);
+	inStream.IgnoreBytes(4);
 
-	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());
+	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());
 			return;
 		}
-		LOG_DEBUG("Received Auth Packet: %s", StringifiedEnum::ToString(authLUBitStream.messageType).data());
-		request->Handle();
+
+		//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");
 	} else {
-		LOG_DEBUG("Unhandled Auth Packet with ID: %i", authLUBitStream.messageType);
+		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);
 	}
 }
 
+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());
+	}
+}