Merge remote-tracking branch 'origin/main' into dCinema

CMakeLists.txt

@@ -1,5 +1,11 @@
 cmake_minimum_required(VERSION 3.25)
 project(Darkflame)
+
+# check if the path to the source directory contains a space
+if("${CMAKE_SOURCE_DIR}" MATCHES " ")
+	message(FATAL_ERROR "The server cannot build in the path (" ${CMAKE_SOURCE_DIR} ") because it contains a space. Please move the server to a path without spaces.")
+endif()
+
 include(CTest)
 
 set(CMAKE_CXX_STANDARD 20)
@@ -73,7 +79,8 @@ if(UNIX)
 	set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -O2 -fPIC")
 elseif(MSVC)
 	# Skip warning for invalid conversion from size_t to uint32_t for all targets below for now
-	add_compile_options("/wd4267" "/utf-8")
+	# Also disable non-portable MSVC volatile behavior
+	add_compile_options("/wd4267" "/utf-8" "/volatile:iso")
 elseif(WIN32)
 	add_compile_definitions(_CRT_SECURE_NO_WARNINGS)
 endif()
@@ -103,7 +110,7 @@ make_directory(${CMAKE_BINARY_DIR}/resServer)
 make_directory(${CMAKE_BINARY_DIR}/logs)
 
 # Copy resource files on first build
-set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blacklist.dcf")
+set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blocklist.dcf")
 message(STATUS "Checking resource file integrity")
 
 include(Utils)

CMakeVariables.txt

@@ -1,6 +1,6 @@
-PROJECT_VERSION_MAJOR=1
-PROJECT_VERSION_MINOR=1
-PROJECT_VERSION_PATCH=1
+PROJECT_VERSION_MAJOR=2
+PROJECT_VERSION_MINOR=3
+PROJECT_VERSION_PATCH=0
 
 # Debugging
 # Set DYNAMIC to 1 to enable the -rdynamic flag for the linker, yielding some symbols in crashlogs.

Dockerfile

@@ -31,7 +31,7 @@ COPY --from=build /app/build/*Server /app/
 
 # Necessary suplimentary files
 COPY --from=build /app/build/*.ini /app/configs/
-COPY --from=build /app/build/vanity/*.* /app/vanity/*
+COPY --from=build /app/build/vanity/*.* /app/vanity/
 COPY --from=build /app/build/navmeshes /app/navmeshes
 COPY --from=build /app/build/migrations /app/migrations
 COPY --from=build /app/build/*.dcf /app/
@@ -39,7 +39,7 @@ COPY --from=build /app/build/*.dcf /app/
 # backup of config and vanity files to copy to the host incase 
 # of a mount clobbering the copy from above
 COPY --from=build /app/build/*.ini /app/default-configs/ 
-COPY --from=build /app/build/vanity/*.* /app/default-vanity/*
+COPY --from=build /app/build/vanity/*.* /app/default-vanity/
 
 # needed as the container runs with the root user
 # and therefore sudo doesn't exist

dChatFilter/dChatFilter.cpp

@@ -27,8 +27,8 @@ dChatFilter::dChatFilter(const std::string& filepath, bool dontGenerateDCF) {
 		ExportWordlistToDCF(filepath + ".dcf", true);
 	}
 
-	if (BinaryIO::DoesFileExist("blacklist.dcf")) {
-		ReadWordlistDCF("blacklist.dcf", false);
+	if (BinaryIO::DoesFileExist("blocklist.dcf")) {
+		ReadWordlistDCF("blocklist.dcf", false);
 	}
 
 	//Read player names that are ok as well:
@@ -44,20 +44,20 @@ dChatFilter::~dChatFilter() {
 	m_DeniedWords.clear();
 }
 
-void dChatFilter::ReadWordlistPlaintext(const std::string& filepath, bool whiteList) {
+void dChatFilter::ReadWordlistPlaintext(const std::string& filepath, bool allowList) {
 	std::ifstream file(filepath);
 	if (file) {
 		std::string line;
 		while (std::getline(file, line)) {
 			line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
 			std::transform(line.begin(), line.end(), line.begin(), ::tolower); //Transform to lowercase
-			if (whiteList) m_ApprovedWords.push_back(CalculateHash(line));
+			if (allowList) m_ApprovedWords.push_back(CalculateHash(line));
 			else m_DeniedWords.push_back(CalculateHash(line));
 		}
 	}
 }
 
-bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool whiteList) {
+bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool allowList) {
 	std::ifstream file(filepath, std::ios::binary);
 	if (file) {
 		fileHeader hdr;
@@ -70,13 +70,13 @@ bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool whiteList) {
 		if (hdr.formatVersion == formatVersion) {
 			size_t wordsToRead = 0;
 			BinaryIO::BinaryRead(file, wordsToRead);
-			if (whiteList) m_ApprovedWords.reserve(wordsToRead);
+			if (allowList) m_ApprovedWords.reserve(wordsToRead);
 			else m_DeniedWords.reserve(wordsToRead);
 
 			size_t word = 0;
 			for (size_t i = 0; i < wordsToRead; ++i) {
 				BinaryIO::BinaryRead(file, word);
-				if (whiteList) m_ApprovedWords.push_back(word);
+				if (allowList) m_ApprovedWords.push_back(word);
 				else m_DeniedWords.push_back(word);
 			}
 
@@ -90,14 +90,14 @@ bool dChatFilter::ReadWordlistDCF(const std::string& filepath, bool whiteList) {
 	return false;
 }
 
-void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool whiteList) {
+void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowList) {
 	std::ofstream file(filepath, std::ios::binary | std::ios_base::out);
 	if (file) {
 		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::header));
 		BinaryIO::BinaryWrite(file, uint32_t(dChatFilterDCF::formatVersion));
-		BinaryIO::BinaryWrite(file, size_t(whiteList ? m_ApprovedWords.size() : m_DeniedWords.size()));
+		BinaryIO::BinaryWrite(file, size_t(allowList ? m_ApprovedWords.size() : m_DeniedWords.size()));
 
-		for (size_t word : whiteList ? m_ApprovedWords : m_DeniedWords) {
+		for (size_t word : allowList ? m_ApprovedWords : m_DeniedWords) {
 			BinaryIO::BinaryWrite(file, word);
 		}
 
@@ -105,10 +105,10 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool whiteLis
 	}
 }
 
-std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList) {
+std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
 	if (gmLevel > eGameMasterLevel::FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
 	if (message.empty()) return { };
-	if (!whiteList && m_DeniedWords.empty()) return { { 0, message.length() } };
+	if (!allowList && m_DeniedWords.empty()) return { { 0, message.length() } };
 
 	std::stringstream sMessage(message);
 	std::string segment;
@@ -126,16 +126,16 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::
 
 		size_t hash = CalculateHash(segment);
 
-		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && whiteList) {
+		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && allowList) {
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
-		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && whiteList) {
+		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
-		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !whiteList) {
+		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}

dChatFilter/dChatFilter.h

@@ -21,10 +21,10 @@ public:
 	dChatFilter(const std::string& filepath, bool dontGenerateDCF);
 	~dChatFilter();
 
-	void ReadWordlistPlaintext(const std::string& filepath, bool whiteList);
-	bool ReadWordlistDCF(const std::string& filepath, bool whiteList);
-	void ExportWordlistToDCF(const std::string& filepath, bool whiteList);
-	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool whiteList = true);
+	void ReadWordlistPlaintext(const std::string& filepath, bool allowList);
+	bool ReadWordlistDCF(const std::string& filepath, bool allowList);
+	void ExportWordlistToDCF(const std::string& filepath, bool allowList);
+	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
 
 private:
 	bool m_DontGenerateDCF;

dChatServer/ChatPacketHandler.cpp

@@ -18,6 +18,7 @@
 #include "eGameMessageType.h"
 #include "StringifiedEnum.h"
 #include "eGameMasterLevel.h"
+#include "ChatPackets.h"
 
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
@@ -354,6 +355,67 @@ void ChatPacketHandler::HandleGMLevelUpdate(Packet* packet) {
 	inStream.Read(player.gmLevel);
 }
 
+
+void ChatPacketHandler::HandleWho(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	FindPlayerRequest request;
+	request.Deserialize(inStream);
+
+	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
+	if (!sender) return;
+
+	const auto& player = Game::playerContainer.GetPlayerData(request.playerName.GetAsString());
+	bool online = player;
+
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	bitStream.Write(request.requestor);
+
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::WHO_RESPONSE);
+	bitStream.Write<uint8_t>(online);
+	bitStream.Write(player.zoneID.GetMapID());
+	bitStream.Write(player.zoneID.GetInstanceID());
+	bitStream.Write(player.zoneID.GetCloneID());
+	bitStream.Write(request.playerName);
+
+	SystemAddress sysAddr = sender.sysAddr;
+	SEND_PACKET;
+}
+
+void ChatPacketHandler::HandleShowAll(Packet* packet) {
+	CINSTREAM_SKIP_HEADER;
+	ShowAllRequest request;
+	request.Deserialize(inStream);
+
+	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
+	if (!sender) return;
+
+	CBITSTREAM;
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
+	bitStream.Write(request.requestor);
+
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SHOW_ALL_RESPONSE);
+	bitStream.Write<uint8_t>(!request.displayZoneData && !request.displayIndividualPlayers);
+	bitStream.Write(Game::playerContainer.GetPlayerCount());
+	bitStream.Write(Game::playerContainer.GetSimCount());
+	bitStream.Write<uint8_t>(request.displayIndividualPlayers);
+	bitStream.Write<uint8_t>(request.displayZoneData);
+	if (request.displayZoneData || request.displayIndividualPlayers){
+		for (auto& [playerID, playerData ]: Game::playerContainer.GetAllPlayers()){
+			if (!playerData) continue;
+			bitStream.Write<uint8_t>(0); // structure packing
+			if (request.displayIndividualPlayers) bitStream.Write(LUWString(playerData.playerName));
+			if (request.displayZoneData) {
+				bitStream.Write(playerData.zoneID.GetMapID());
+				bitStream.Write(playerData.zoneID.GetInstanceID());
+				bitStream.Write(playerData.zoneID.GetCloneID());
+			}
+		}
+	}
+	SystemAddress sysAddr = sender.sysAddr;
+	SEND_PACKET;
+}
+
 // the structure the client uses to send this packet is shared in many chat messages 
 // that are sent to the server. Because of this, there are large gaps of unused data in chat messages
 void ChatPacketHandler::HandleChatMessage(Packet* packet) {

dChatServer/ChatPacketHandler.h

@@ -50,6 +50,8 @@ namespace ChatPacketHandler {
 	void HandleFriendResponse(Packet* packet);
 	void HandleRemoveFriend(Packet* packet);
 	void HandleGMLevelUpdate(Packet* packet);
+	void HandleWho(Packet* packet);
+	void HandleShowAll(Packet* packet);
 
 	void HandleChatMessage(Packet* packet);
 	void HandlePrivateChatMessage(Packet* packet);

dChatServer/ChatServer.cpp

@@ -179,6 +179,7 @@ int main(int argc, char** argv) {
 }
 
 void HandlePacket(Packet* packet) {
+	if (packet->length < 1) return;
 	if (packet->data[0] == ID_DISCONNECTION_NOTIFICATION || packet->data[0] == ID_CONNECTION_LOST) {
 		LOG("A server has disconnected, erasing their connected players from the list.");
 	} else if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
@@ -289,7 +290,11 @@ void HandlePacket(Packet* packet) {
 			Game::playerContainer.RemovePlayer(packet);
 			break;
 		case eChatMessageType::WHO:
+			ChatPacketHandler::HandleWho(packet);
+			break;
 		case eChatMessageType::SHOW_ALL:
+			ChatPacketHandler::HandleShowAll(packet);
+			break;
 		case eChatMessageType::USER_CHANNEL_CHAT_MESSAGE:
 		case eChatMessageType::WORLD_DISCONNECT_REQUEST:
 		case eChatMessageType::WORLD_PROXIMITY_RESPONSE:

dChatServer/PlayerContainer.cpp

@@ -49,6 +49,7 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	data.sysAddr = packet->systemAddress;
 
 	m_Names[data.playerID] = GeneralUtils::UTF8ToUTF16(data.playerName);
+	m_PlayerCount++;
 
 	LOG("Added user: %s (%llu), zone: %i", data.playerName.c_str(), data.playerID, data.zoneID.GetMapID());
 
@@ -87,6 +88,7 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 		}
 	}
 
+	m_PlayerCount--;
 	LOG("Removed user: %llu", playerID);
 	m_Players.erase(playerID);
 

dChatServer/PlayerContainer.h

@@ -71,6 +71,9 @@ public:
 	const PlayerData& GetPlayerData(const std::string& playerName);
 	PlayerData& GetPlayerDataMutable(const LWOOBJID& playerID);
 	PlayerData& GetPlayerDataMutable(const std::string& playerName);
+	uint32_t GetPlayerCount() { return m_PlayerCount; };
+	uint32_t GetSimCount() { return m_SimCount; };
+	const std::map<LWOOBJID, PlayerData>& GetAllPlayers() { return m_Players; };
 
 	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
 	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
@@ -93,5 +96,7 @@ private:
 	std::unordered_map<LWOOBJID, std::u16string> m_Names;
 	uint32_t m_MaxNumberOfBestFriends = 5;
 	uint32_t m_MaxNumberOfFriends = 50;
+	uint32_t m_PlayerCount = 0;
+	uint32_t m_SimCount = 0;
 };
 

dCommon/Diagnostics.cpp

@@ -120,6 +120,8 @@ void CatchUnhandled(int sig) {
 		if (eptr) std::rethrow_exception(eptr);
 	} catch(const std::exception& e) {
 		LOG("Caught exception: '%s'", e.what());
+	} catch (...) {
+		LOG("Caught unknown exception.");
 	}
 
 #ifndef INCLUDE_BACKTRACE
@@ -199,7 +201,7 @@ void OnTerminate() {
 }
 
 void MakeBacktrace() {
-	struct sigaction sigact;
+	struct sigaction sigact{};
 
 	sigact.sa_sigaction = CritErrHdlr;
 	sigact.sa_flags = SA_RESTART | SA_SIGINFO;

dCommon/GeneralUtils.cpp

@@ -8,23 +8,23 @@
 #include <map>
 
 template <typename T>
-inline size_t MinSize(size_t size, const std::basic_string_view<T>& string) {
-	if (size == size_t(-1) || size > string.size()) {
+static inline size_t MinSize(const size_t size, const std::basic_string_view<T> string) {
+	if (size == SIZE_MAX || size > string.size()) {
 		return string.size();
 	} else {
 		return size;
 	}
 }
 
-inline bool IsLeadSurrogate(char16_t c) {
+inline bool IsLeadSurrogate(const char16_t c) {
 	return (0xD800 <= c) && (c <= 0xDBFF);
 }
 
-inline bool IsTrailSurrogate(char16_t c) {
+inline bool IsTrailSurrogate(const char16_t c) {
 	return (0xDC00 <= c) && (c <= 0xDFFF);
 }
 
-inline void PushUTF8CodePoint(std::string& ret, char32_t cp) {
+inline void PushUTF8CodePoint(std::string& ret, const char32_t cp) {
 	if (cp <= 0x007F) {
 		ret.push_back(static_cast<uint8_t>(cp));
 	} else if (cp <= 0x07FF) {
@@ -46,16 +46,16 @@ inline void PushUTF8CodePoint(std::string& ret, char32_t cp) {
 
 constexpr const char16_t REPLACEMENT_CHARACTER = 0xFFFD;
 
-bool _IsSuffixChar(uint8_t c) {
+bool static _IsSuffixChar(const uint8_t c) {
 	return (c & 0xC0) == 0x80;
 }
 
-bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
-	size_t rem = slice.length();
+bool GeneralUtils::details::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
+	const size_t rem = slice.length();
 	if (slice.empty()) return false;
 	const uint8_t* bytes = reinterpret_cast<const uint8_t*>(&slice.front());
 	if (rem > 0) {
-		uint8_t first = bytes[0];
+		const uint8_t first = bytes[0];
 		if (first < 0x80) { // 1 byte character
 			out = static_cast<uint32_t>(first & 0x7F);
 			slice.remove_prefix(1);
@@ -64,7 +64,7 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 			// middle byte, not valid at start, fall through
 		} else if (first < 0xE0) { // two byte character
 			if (rem > 1) {
-				uint8_t second = bytes[1];
+				const uint8_t second = bytes[1];
 				if (_IsSuffixChar(second)) {
 					out = (static_cast<uint32_t>(first & 0x1F) << 6)
 						+ static_cast<uint32_t>(second & 0x3F);
@@ -74,8 +74,8 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 			}
 		} else if (first < 0xF0) { // three byte character
 			if (rem > 2) {
-				uint8_t second = bytes[1];
-				uint8_t third = bytes[2];
+				const uint8_t second = bytes[1];
+				const uint8_t third = bytes[2];
 				if (_IsSuffixChar(second) && _IsSuffixChar(third)) {
 					out = (static_cast<uint32_t>(first & 0x0F) << 12)
 						+ (static_cast<uint32_t>(second & 0x3F) << 6)
@@ -86,9 +86,9 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 			}
 		} else if (first < 0xF8) { // four byte character
 			if (rem > 3) {
-				uint8_t second = bytes[1];
-				uint8_t third = bytes[2];
-				uint8_t fourth = bytes[3];
+				const uint8_t second = bytes[1];
+				const uint8_t third = bytes[2];
+				const uint8_t fourth = bytes[3];
 				if (_IsSuffixChar(second) && _IsSuffixChar(third) && _IsSuffixChar(fourth)) {
 					out = (static_cast<uint32_t>(first & 0x07) << 18)
 						+ (static_cast<uint32_t>(second & 0x3F) << 12)
@@ -107,7 +107,7 @@ bool GeneralUtils::_NextUTF8Char(std::string_view& slice, uint32_t& out) {
 }
 
 /// See <https://www.ietf.org/rfc/rfc2781.html#section-2.1>
-bool PushUTF16CodePoint(std::u16string& output, uint32_t U, size_t size) {
+bool PushUTF16CodePoint(std::u16string& output, const uint32_t U, const size_t size) {
 	if (output.length() >= size) return false;
 	if (U < 0x10000) {
 		// If U < 0x10000, encode U as a 16-bit unsigned integer and terminate.
@@ -120,7 +120,7 @@ bool PushUTF16CodePoint(std::u16string& output, uint32_t U, size_t size) {
 		// Let U' = U - 0x10000. Because U is less than or equal to 0x10FFFF,
 		// U' must be less than or equal to 0xFFFFF. That is, U' can be
 		// represented in 20 bits.
-		uint32_t Ut = U - 0x10000;
+		const uint32_t Ut = U - 0x10000;
 
 		// Initialize two 16-bit unsigned integers, W1 and W2, to 0xD800 and
 		// 0xDC00, respectively. These integers each have 10 bits free to
@@ -141,25 +141,25 @@ bool PushUTF16CodePoint(std::u16string& output, uint32_t U, size_t size) {
 	} else return false;
 }
 
-std::u16string GeneralUtils::UTF8ToUTF16(const std::string_view& string, size_t size) {
-	size_t newSize = MinSize(size, string);
+std::u16string GeneralUtils::UTF8ToUTF16(const std::string_view string, const size_t size) {
+	const size_t newSize = MinSize(size, string);
 	std::u16string output;
 	output.reserve(newSize);
 	std::string_view iterator = string;
 
 	uint32_t c;
-	while (_NextUTF8Char(iterator, c) && PushUTF16CodePoint(output, c, size)) {}
+	while (details::_NextUTF8Char(iterator, c) && PushUTF16CodePoint(output, c, size)) {}
 	return output;
 }
 
 //! Converts an std::string (ASCII) to UCS-2 / UTF-16
-std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view& string, size_t size) {
-	size_t newSize = MinSize(size, string);
+std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view string, const size_t size) {
+	const size_t newSize = MinSize(size, string);
 	std::u16string ret;
 	ret.reserve(newSize);
 
-	for (size_t i = 0; i < newSize; i++) {
-		char c = string[i];
+	for (size_t i = 0; i < newSize; ++i) {
+		const char c = string[i];
 		// Note: both 7-bit ascii characters and REPLACEMENT_CHARACTER fit in one char16_t
 		ret.push_back((c > 0 && c <= 127) ? static_cast<char16_t>(c) : REPLACEMENT_CHARACTER);
 	}
@@ -169,18 +169,18 @@ std::u16string GeneralUtils::ASCIIToUTF16(const std::string_view& string, size_t
 
 //! Converts a (potentially-ill-formed) UTF-16 string to UTF-8
 //! See: <http://simonsapin.github.io/wtf-8/#decoding-ill-formed-utf-16>
-std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view& string, size_t size) {
-	size_t newSize = MinSize(size, string);
+std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view string, const size_t size) {
+	const size_t newSize = MinSize(size, string);
 	std::string ret;
 	ret.reserve(newSize);
 
-	for (size_t i = 0; i < newSize; i++) {
-		char16_t u = string[i];
+	for (size_t i = 0; i < newSize; ++i) {
+		const char16_t u = string[i];
 		if (IsLeadSurrogate(u) && (i + 1) < newSize) {
-			char16_t next = string[i + 1];
+			const char16_t next = string[i + 1];
 			if (IsTrailSurrogate(next)) {
 				i += 1;
-				char32_t cp = 0x10000
+				const char32_t cp = 0x10000
 					+ ((static_cast<char32_t>(u) - 0xD800) << 10)
 					+ (static_cast<char32_t>(next) - 0xDC00);
 				PushUTF8CodePoint(ret, cp);
@@ -195,40 +195,40 @@ std::string GeneralUtils::UTF16ToWTF8(const std::u16string_view& string, size_t
 	return ret;
 }
 
-bool GeneralUtils::CaseInsensitiveStringCompare(const std::string& a, const std::string& b) {
+bool GeneralUtils::CaseInsensitiveStringCompare(const std::string_view a, const std::string_view b) {
 	return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](char a, char b) { return tolower(a) == tolower(b); });
 }
 
 // MARK: Bits
 
 //! Sets a specific bit in a signed 64-bit integer
-int64_t GeneralUtils::SetBit(int64_t value, uint32_t index) {
+int64_t GeneralUtils::SetBit(int64_t value, const uint32_t index) {
 	return value |= 1ULL << index;
 }
 
 //! Clears a specific bit in a signed 64-bit integer
-int64_t GeneralUtils::ClearBit(int64_t value, uint32_t index) {
+int64_t GeneralUtils::ClearBit(int64_t value, const uint32_t index) {
 	return value &= ~(1ULL << index);
 }
 
 //! Checks a specific bit in a signed 64-bit integer
-bool GeneralUtils::CheckBit(int64_t value, uint32_t index) {
+bool GeneralUtils::CheckBit(int64_t value, const uint32_t index) {
 	return value & (1ULL << index);
 }
 
-bool GeneralUtils::ReplaceInString(std::string& str, const std::string& from, const std::string& to) {
-	size_t start_pos = str.find(from);
+bool GeneralUtils::ReplaceInString(std::string& str, const std::string_view from, const std::string_view to) {
+	const size_t start_pos = str.find(from);
 	if (start_pos == std::string::npos)
 		return false;
 	str.replace(start_pos, from.length(), to);
 	return true;
 }
 
-std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t delimiter) {
+std::vector<std::wstring> GeneralUtils::SplitString(const std::wstring_view str, const wchar_t delimiter) {
 	std::vector<std::wstring> vector = std::vector<std::wstring>();
 	std::wstring current;
 
-	for (const auto& c : str) {
+	for (const wchar_t c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = L"";
@@ -237,15 +237,15 @@ std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t d
 		}
 	}
 
-	vector.push_back(current);
+	vector.push_back(std::move(current));
 	return vector;
 }
 
-std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string& str, char16_t delimiter) {
+std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string_view str, const char16_t delimiter) {
 	std::vector<std::u16string> vector = std::vector<std::u16string>();
 	std::u16string current;
 
-	for (const auto& c : str) {
+	for (const char16_t c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = u"";
@@ -254,17 +254,15 @@ std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string& str,
 		}
 	}
 
-	vector.push_back(current);
+	vector.push_back(std::move(current));
 	return vector;
 }
 
-std::vector<std::string> GeneralUtils::SplitString(const std::string& str, char delimiter) {
+std::vector<std::string> GeneralUtils::SplitString(const std::string_view str, const char delimiter) {
 	std::vector<std::string> vector = std::vector<std::string>();
 	std::string current = "";
 
-	for (size_t i = 0; i < str.length(); i++) {
-		char c = str[i];
-
+	for (const char c : str) {
 		if (c == delimiter) {
 			vector.push_back(current);
 			current = "";
@@ -273,8 +271,7 @@ std::vector<std::string> GeneralUtils::SplitString(const std::string& str, char
 		}
 	}
 
-	vector.push_back(current);
-
+	vector.push_back(std::move(current));
 	return vector;
 }
 
@@ -283,7 +280,7 @@ std::u16string GeneralUtils::ReadWString(RakNet::BitStream& inStream) {
 	inStream.Read<uint32_t>(length);
 
 	std::u16string string;
-	for (auto i = 0; i < length; i++) {
+	for (uint32_t i = 0; i < length; ++i) {
 		uint16_t c;
 		inStream.Read(c);
 		string.push_back(c);
@@ -292,35 +289,35 @@ std::u16string GeneralUtils::ReadWString(RakNet::BitStream& inStream) {
 	return string;
 }
 
-std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::string& folder) {
+std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::string_view folder) {
 	// Because we dont know how large the initial number before the first _ is we need to make it a map like so.
-	std::map<uint32_t, std::string> filenames{};
-	for (auto& t : std::filesystem::directory_iterator(folder)) {
-		auto filename = t.path().filename().string();
-		auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
-		filenames.insert(std::make_pair(index, filename));
+    std::map<uint32_t, std::string> filenames{};
+	for (const auto& t : std::filesystem::directory_iterator(folder)) {
+        auto filename = t.path().filename().string();
+        const auto index = std::stoi(GeneralUtils::SplitString(filename, '_').at(0));
+        filenames.emplace(index, std::move(filename));
 	}
 
 	// Now sort the map by the oldest migration.
 	std::vector<std::string> sortedFiles{};
-	auto fileIterator = filenames.begin();
-	std::map<uint32_t, std::string>::iterator oldest = filenames.begin();
+	auto fileIterator = filenames.cbegin();
+	auto oldest = filenames.cbegin();
 	while (!filenames.empty()) {
-		if (fileIterator == filenames.end()) {
+		if (fileIterator == filenames.cend()) {
 			sortedFiles.push_back(oldest->second);
 			filenames.erase(oldest);
-			fileIterator = filenames.begin();
-			oldest = filenames.begin();
+			fileIterator = filenames.cbegin();
+			oldest = filenames.cbegin();
 			continue;
 		}
 		if (oldest->first > fileIterator->first) oldest = fileIterator;
-		fileIterator++;
+		++fileIterator;
 	}
 
 	return sortedFiles;
 }
 
-#ifdef DARKFLAME_PLATFORM_MACOS
+#if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
 
 // MacOS floating-point parse function specializations
 namespace GeneralUtils::details {

dCommon/GeneralUtils.h

@@ -3,17 +3,18 @@
 // C++
 #include <charconv>
 #include <cstdint>
-#include <random>
 #include <ctime>
+#include <functional>
+#include <optional>
+#include <random>
+#include <span>
+#include <stdexcept>
 #include <string>
 #include <string_view>
-#include <optional>
-#include <functional>
 #include <type_traits>
-#include <stdexcept>
+
 #include "BitStream.h"
 #include "NiPoint3.h"
-
 #include "dPlatforms.h"
 #include "Game.h"
 #include "Logger.h"
@@ -32,29 +33,31 @@ namespace GeneralUtils {
 	//! Converts a plain ASCII string to a UTF-16 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is -1 (No trimming)
+	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
 	  \return An UTF-16 representation of the string
 	 */
-	std::u16string ASCIIToUTF16(const std::string_view& string, size_t size = -1);
+	std::u16string ASCIIToUTF16(const std::string_view string, const size_t size = SIZE_MAX);
 
 	//! Converts a UTF-8 String to a UTF-16 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is -1 (No trimming)
+	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
 	  \return An UTF-16 representation of the string
 	 */
-	std::u16string UTF8ToUTF16(const std::string_view& string, size_t size = -1);
+	std::u16string UTF8ToUTF16(const std::string_view string, const size_t size = SIZE_MAX);
 
-	//! Internal, do not use
-	bool _NextUTF8Char(std::string_view& slice, uint32_t& out);
+	namespace details {
+		//! Internal, do not use
+		bool _NextUTF8Char(std::string_view& slice, uint32_t& out);
+	}
 
 	//! Converts a UTF-16 string to a UTF-8 string
 	/*!
 	  \param string The string to convert
-	  \param size A size to trim the string to. Default is -1 (No trimming)
+	  \param size A size to trim the string to. Default is SIZE_MAX (No trimming)
 	  \return An UTF-8 representation of the string
 	 */
-	std::string UTF16ToWTF8(const std::u16string_view& string, size_t size = -1);
+	std::string UTF16ToWTF8(const std::u16string_view string, const size_t size = SIZE_MAX);
 
 	/**
 	 * Compares two basic strings but does so ignoring case sensitivity
@@ -62,7 +65,7 @@ namespace GeneralUtils {
 	 * \param b the second string to compare against the first string
 	 * @return if the two strings are equal
 	 */
-	bool CaseInsensitiveStringCompare(const std::string& a, const std::string& b);
+	bool CaseInsensitiveStringCompare(const std::string_view a, const std::string_view b);
 
 	// MARK: Bits
 
@@ -70,9 +73,9 @@ namespace GeneralUtils {
 
 	//! Sets a bit on a numerical value
 	template <typename T>
-	inline void SetBit(T& value, eObjectBits bits) {
+	inline void SetBit(T& value, const eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+		const auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8) - 1) {
 			return;
 		}
@@ -82,9 +85,9 @@ namespace GeneralUtils {
 
 	//! Clears a bit on a numerical value
 	template <typename T>
-	inline void ClearBit(T& value, eObjectBits bits) {
+	inline void ClearBit(T& value, const eObjectBits bits) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+		const auto index = static_cast<size_t>(bits);
 		if (index > (sizeof(T) * 8 - 1)) {
 			return;
 		}
@@ -97,14 +100,14 @@ namespace GeneralUtils {
 	  \param value The value to set the bit for
 	  \param index The index of the bit
 	 */
-	int64_t SetBit(int64_t value, uint32_t index);
+	int64_t SetBit(int64_t value, const uint32_t index);
 
 	//! Clears a specific bit in a signed 64-bit integer
 	/*!
 	  \param value The value to clear the bit from
 	  \param index The index of the bit
 	 */
-	int64_t ClearBit(int64_t value, uint32_t index);
+	int64_t ClearBit(int64_t value, const uint32_t index);
 
 	//! Checks a specific bit in a signed 64-bit integer
 	/*!
@@ -112,19 +115,19 @@ namespace GeneralUtils {
 	  \param index The index of the bit
 	  \return Whether or not the bit is set
 	 */
-	bool CheckBit(int64_t value, uint32_t index);
+	bool CheckBit(int64_t value, const uint32_t index);
 
-	bool ReplaceInString(std::string& str, const std::string& from, const std::string& to);
+	bool ReplaceInString(std::string& str, const std::string_view from, const std::string_view to);
 
 	std::u16string ReadWString(RakNet::BitStream& inStream);
 
-	std::vector<std::wstring> SplitString(std::wstring& str, wchar_t delimiter);
+	std::vector<std::wstring> SplitString(const std::wstring_view str, const wchar_t delimiter);
 
-	std::vector<std::u16string> SplitString(const std::u16string& str, char16_t delimiter);
+	std::vector<std::u16string> SplitString(const std::u16string_view str, const char16_t delimiter);
 
-	std::vector<std::string> SplitString(const std::string& str, char delimiter);
+	std::vector<std::string> SplitString(const std::string_view str, const char delimiter);
 
-	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string& folder);
+	std::vector<std::string> GetSqlFileNamesFromFolder(const std::string_view folder);
 
 	// Concept constraining to enum types
 	template <typename T>
@@ -144,7 +147,7 @@ namespace GeneralUtils {
 
 	// If a boolean, present an alias to an intermediate integral type for parsing
 	template <Numeric T> requires std::same_as<T, bool>
-	struct numeric_parse<T> { using type = uint32_t; };
+	struct numeric_parse<T> { using type = uint8_t; };
 
 	// Shorthand type alias
 	template <Numeric T>
@@ -156,8 +159,9 @@ namespace GeneralUtils {
 	 * @returns An std::optional containing the desired value if it is equivalent to the string
 	*/
 	template <Numeric T>
-	[[nodiscard]] std::optional<T> TryParse(const std::string_view str) {
+	[[nodiscard]] std::optional<T> TryParse(std::string_view str) {
 		numeric_parse_t<T> result;
+		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
 
 		const char* const strEnd = str.data() + str.size();
 		const auto [parseEnd, ec] = std::from_chars(str.data(), strEnd, result);
@@ -181,8 +185,10 @@ namespace GeneralUtils {
 	 * @returns An std::optional containing the desired value if it is equivalent to the string
 	*/
 	template <std::floating_point T>
-	[[nodiscard]] std::optional<T> TryParse(const std::string_view str) noexcept
+	[[nodiscard]] std::optional<T> TryParse(std::string_view str) noexcept
 	try {
+		while (!str.empty() && std::isspace(str.front())) str.remove_prefix(1);
+
 		size_t parseNum;
 		const T result = details::_parse<T>(str, parseNum);
 		const bool isParsed = str.length() == parseNum;
@@ -202,7 +208,7 @@ namespace GeneralUtils {
 	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
 	*/
 	template <typename T>
-	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::string& strX, const std::string& strY, const std::string& strZ) {
+	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::string_view strX, const std::string_view strY, const std::string_view strZ) {
 		const auto x = TryParse<float>(strX);
 		if (!x) return std::nullopt;
 
@@ -214,17 +220,17 @@ namespace GeneralUtils {
 	}
 
 	/**
-	 * The TryParse overload for handling NiPoint3 by passingn a reference to a vector of three strings
-	 * @param str The string vector representing the X, Y, and Xcoordinates
+	 * The TryParse overload for handling NiPoint3 by passing a span of three strings
+	 * @param str The string vector representing the X, Y, and Z coordinates
 	 * @returns An std::optional containing the desired NiPoint3 if it can be constructed from the string parameters
 	*/
 	template <typename T>
-	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::vector<std::string>& str) {
+	[[nodiscard]] std::optional<NiPoint3> TryParse(const std::span<const std::string> str) {
 		return (str.size() == 3) ? TryParse<NiPoint3>(str[0], str[1], str[2]) : std::nullopt;
 	}
 
 	template <typename T>
-	std::u16string to_u16string(T value) {
+	std::u16string to_u16string(const T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));
 	}
 
@@ -243,7 +249,7 @@ namespace GeneralUtils {
 	  \param max The maximum to generate to
 	 */
 	template <typename T>
-	inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
+	inline T GenerateRandomNumber(const std::size_t min, const std::size_t max) {
 		// Make sure it is a numeric type
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
 
@@ -270,10 +276,10 @@ namespace GeneralUtils {
 
 	// on Windows we need to undef these or else they conflict with our numeric limits calls
 	// DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS
-	#ifdef _WIN32
-	#undef min
-	#undef max
-	#endif
+#ifdef _WIN32
+#undef min
+#undef max
+#endif
 
 	template <typename T>
 	inline T GenerateRandomNumber() {

dCommon/LDFFormat.h

@@ -31,22 +31,22 @@ public:
 
 	virtual ~LDFBaseData() {}
 
-	virtual void WriteToPacket(RakNet::BitStream& packet) = 0;
+	virtual void WriteToPacket(RakNet::BitStream& packet) const = 0;
 
-	virtual const std::u16string& GetKey() = 0;
+	virtual const std::u16string& GetKey() const = 0;
 
-	virtual eLDFType GetValueType() = 0;
+	virtual eLDFType GetValueType() const = 0;
 
 	/** Gets a string from the key/value pair
 	 * @param includeKey Whether or not to include the key in the data
 	 * @param includeTypeId Whether or not to include the type id in the data
 	 * @return The string representation of the data
 	 */
-	virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) = 0;
+	virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) const = 0;
 
-	virtual std::string GetValueAsString() = 0;
+	virtual std::string GetValueAsString() const = 0;
 
-	virtual LDFBaseData* Copy() = 0;
+	virtual LDFBaseData* Copy() const = 0;
 
 	/**
 	 * Given an input string, return the data as a LDF key.
@@ -62,7 +62,7 @@ private:
 	T value;
 
 	//! Writes the key to the packet
-	void WriteKey(RakNet::BitStream& packet) {
+	void WriteKey(RakNet::BitStream& packet) const {
 		packet.Write<uint8_t>(this->key.length() * sizeof(uint16_t));
 		for (uint32_t i = 0; i < this->key.length(); ++i) {
 			packet.Write<uint16_t>(this->key[i]);
@@ -70,7 +70,7 @@ private:
 	}
 
 	//! Writes the value to the packet
-	void WriteValue(RakNet::BitStream& packet) {
+	void WriteValue(RakNet::BitStream& packet) const {
 		packet.Write<uint8_t>(this->GetValueType());
 		packet.Write(this->value);
 	}
@@ -90,7 +90,7 @@ public:
 	/*!
 	  \return The value
 	 */
-	const T& GetValue(void) { return this->value; }
+	const T& GetValue(void) const { return this->value; }
 
 	//! Sets the value
 	/*!
@@ -102,13 +102,13 @@ public:
 	/*!
 	  \return The value string
 	 */
-	std::string GetValueString(void) { return ""; }
+	std::string GetValueString(void) const { return ""; }
 
 	//! Writes the data to a packet
 	/*!
 	  \param packet The packet
 	 */
-	void WriteToPacket(RakNet::BitStream& packet) override {
+	void WriteToPacket(RakNet::BitStream& packet) const override {
 		this->WriteKey(packet);
 		this->WriteValue(packet);
 	}
@@ -117,13 +117,13 @@ public:
 	/*!
 	 \return The key
 	 */
-	const std::u16string& GetKey(void) override { return this->key; }
+	const std::u16string& GetKey(void) const override { return this->key; }
 
 	//! Gets the LDF Type
 	/*!
 	 \return The LDF value type
 	 */
-	eLDFType GetValueType(void) override { return LDF_TYPE_UNKNOWN; }
+	eLDFType GetValueType(void) const override { return LDF_TYPE_UNKNOWN; }
 
 	//! Gets the string data
 	/*!
@@ -131,7 +131,7 @@ public:
 	  \param includeTypeId Whether or not to include the type id in the data
 	  \return The string representation of the data
 	 */
-	std::string GetString(const bool includeKey = true, const bool includeTypeId = true) override {
+	std::string GetString(const bool includeKey = true, const bool includeTypeId = true) const override {
 		if (GetValueType() == -1) {
 			return GeneralUtils::UTF16ToWTF8(this->key) + "=-1:<server variable>";
 		}
@@ -154,11 +154,11 @@ public:
 		return stream.str();
 	}
 
-	std::string GetValueAsString() override {
+	std::string GetValueAsString() const override {
 		return this->GetValueString();
 	}
 
-	LDFBaseData* Copy() override {
+	LDFBaseData* Copy() const override {
 		return new LDFData<T>(key, value);
 	}
 
@@ -166,19 +166,19 @@ public:
 };
 
 // LDF Types
-template<> inline eLDFType LDFData<std::u16string>::GetValueType(void) { return LDF_TYPE_UTF_16; };
-template<> inline eLDFType LDFData<int32_t>::GetValueType(void) { return LDF_TYPE_S32; };
-template<> inline eLDFType LDFData<float>::GetValueType(void) { return LDF_TYPE_FLOAT; };
-template<> inline eLDFType LDFData<double>::GetValueType(void) { return LDF_TYPE_DOUBLE; };
-template<> inline eLDFType LDFData<uint32_t>::GetValueType(void) { return LDF_TYPE_U32; };
-template<> inline eLDFType LDFData<bool>::GetValueType(void) { return LDF_TYPE_BOOLEAN; };
-template<> inline eLDFType LDFData<uint64_t>::GetValueType(void) { return LDF_TYPE_U64; };
-template<> inline eLDFType LDFData<LWOOBJID>::GetValueType(void) { return LDF_TYPE_OBJID; };
-template<> inline eLDFType LDFData<std::string>::GetValueType(void) { return LDF_TYPE_UTF_8; };
+template<> inline eLDFType LDFData<std::u16string>::GetValueType(void) const { return LDF_TYPE_UTF_16; };
+template<> inline eLDFType LDFData<int32_t>::GetValueType(void) const { return LDF_TYPE_S32; };
+template<> inline eLDFType LDFData<float>::GetValueType(void) const { return LDF_TYPE_FLOAT; };
+template<> inline eLDFType LDFData<double>::GetValueType(void) const { return LDF_TYPE_DOUBLE; };
+template<> inline eLDFType LDFData<uint32_t>::GetValueType(void) const { return LDF_TYPE_U32; };
+template<> inline eLDFType LDFData<bool>::GetValueType(void) const { return LDF_TYPE_BOOLEAN; };
+template<> inline eLDFType LDFData<uint64_t>::GetValueType(void) const { return LDF_TYPE_U64; };
+template<> inline eLDFType LDFData<LWOOBJID>::GetValueType(void) const { return LDF_TYPE_OBJID; };
+template<> inline eLDFType LDFData<std::string>::GetValueType(void) const { return LDF_TYPE_UTF_8; };
 
 // The specialized version for std::u16string (UTF-16)
 template<>
-inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream& packet) {
+inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream& packet) const {
 	packet.Write<uint8_t>(this->GetValueType());
 
 	packet.Write<uint32_t>(this->value.length());
@@ -189,7 +189,7 @@ inline void LDFData<std::u16string>::WriteValue(RakNet::BitStream& packet) {
 
 // The specialized version for bool
 template<>
-inline void LDFData<bool>::WriteValue(RakNet::BitStream& packet) {
+inline void LDFData<bool>::WriteValue(RakNet::BitStream& packet) const {
 	packet.Write<uint8_t>(this->GetValueType());
 
 	packet.Write<uint8_t>(this->value);
@@ -197,7 +197,7 @@ inline void LDFData<bool>::WriteValue(RakNet::BitStream& packet) {
 
 // The specialized version for std::string (UTF-8)
 template<>
-inline void LDFData<std::string>::WriteValue(RakNet::BitStream& packet) {
+inline void LDFData<std::string>::WriteValue(RakNet::BitStream& packet) const {
 	packet.Write<uint8_t>(this->GetValueType());
 
 	packet.Write<uint32_t>(this->value.length());
@@ -206,18 +206,18 @@ inline void LDFData<std::string>::WriteValue(RakNet::BitStream& packet) {
 	}
 }
 
-template<> inline std::string LDFData<std::u16string>::GetValueString() {
+template<> inline std::string LDFData<std::u16string>::GetValueString() const {
 	return GeneralUtils::UTF16ToWTF8(this->value, this->value.size());
 }
 
-template<> inline std::string LDFData<int32_t>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<float>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<double>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint32_t>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<bool>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint64_t>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<LWOOBJID>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<int32_t>::GetValueString() const { return std::to_string(this->value); }
+template<> inline std::string LDFData<float>::GetValueString() const { return std::to_string(this->value); }
+template<> inline std::string LDFData<double>::GetValueString() const { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint32_t>::GetValueString() const { return std::to_string(this->value); }
+template<> inline std::string LDFData<bool>::GetValueString() const { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint64_t>::GetValueString() const { return std::to_string(this->value); }
+template<> inline std::string LDFData<LWOOBJID>::GetValueString() const { return std::to_string(this->value); }
 
-template<> inline std::string LDFData<std::string>::GetValueString() { return this->value; }
+template<> inline std::string LDFData<std::string>::GetValueString() const { return this->value; }
 
 #endif  //!__LDFFORMAT__H__

dCommon/dConfig.cpp

@@ -1,6 +1,7 @@
 #include "dConfig.h"
 
 #include <sstream>
+#include <algorithm>
 
 #include "BinaryPathFinder.h"
 #include "GeneralUtils.h"

dCommon/dEnums/eGameMessageType.h

@@ -790,9 +790,10 @@ enum class eGameMessageType : uint16_t {
 	GET_MISSION_TYPE_STATES = 853,
 	GET_TIME_PLAYED = 854,
 	SET_MISSION_VIEWED = 855,
-	SLASH_COMMAND_TEXT_FEEDBACK = 856,
-	HANDLE_SLASH_COMMAND_KORE_DEBUGGER = 857,
+	HKX_VEHICLE_LOADED = 856,
+	SLASH_COMMAND_TEXT_FEEDBACK = 857,
 	BROADCAST_TEXT_TO_CHATBOX = 858,
+	HANDLE_SLASH_COMMAND_KORE_DEBUGGER = 859,
 	OPEN_PROPERTY_MANAGEMENT = 860,
 	OPEN_PROPERTY_VENDOR = 861,
 	VOTE_ON_PROPERTY = 862,

dCommon/dEnums/eInventoryType.h

@@ -4,6 +4,9 @@
 #define __EINVENTORYTYPE__H__
 
 #include <cstdint>
+
+#include "magic_enum.hpp"
+
 static const uint8_t NUMBER_OF_INVENTORIES = 17;
 /**
  * Represents the different types of inventories an entity may have
@@ -56,4 +59,10 @@ public:
 	};
 };
 
+template <>
+struct magic_enum::customize::enum_range<eInventoryType> {
+	static constexpr int min = 0;
+	static constexpr int max = 16;
+};
+
 #endif  //!__EINVENTORYTYPE__H__

dCommon/dEnums/eReponseMoveItemBetweenInventoryTypeCode.h

@@ -0,0 +1,21 @@
+#ifndef __EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__
+#define __EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__
+
+#include <cstdint>
+
+enum class eReponseMoveItemBetweenInventoryTypeCode : int32_t {
+	SUCCESS,
+	FAIL_GENERIC,
+	FAIL_INV_FULL,
+	FAIL_ITEM_NOT_FOUND,
+	FAIL_CANT_MOVE_TO_THAT_INV_TYPE,
+	FAIL_NOT_NEAR_BANK,
+	FAIL_CANT_SWAP_ITEMS,
+	FAIL_SOURCE_TYPE,
+	FAIL_WRONG_DEST_TYPE,
+	FAIL_SWAP_DEST_TYPE,
+	FAIL_CANT_MOVE_THINKING_HAT,
+	FAIL_DISMOUNT_BEFORE_MOVING
+};
+
+#endif  //!__EREPONSEMOVEITEMBETWEENINVENTORYTYPECODE__H__

dCommon/dEnums/eWorldMessageType.h

@@ -29,8 +29,8 @@ enum class eWorldMessageType : uint32_t {
 	ROUTE_PACKET,  // 				Social?
 	POSITION_UPDATE,
 	MAIL,
-	WORD_CHECK, // 				Whitelist word check
-	STRING_CHECK,  // 				Whitelist string check
+	WORD_CHECK, // 				AllowList word check
+	STRING_CHECK,  // 				AllowList string check
 	GET_PLAYERS_IN_ZONE,
 	REQUEST_UGC_MANIFEST_INFO,
 	BLUEPRINT_GET_ALL_DATA_REQUEST,

dDatabase/CDClientDatabase/CDClientManager.cpp

@@ -25,6 +25,7 @@
 #include "CDScriptComponentTable.h"
 #include "CDSkillBehaviorTable.h"
 #include "CDZoneTableTable.h"
+#include "CDTamingBuildPuzzleTable.h"
 #include "CDVendorComponentTable.h"
 #include "CDActivitiesTable.h"
 #include "CDPackageComponentTable.h"
@@ -41,8 +42,6 @@
 #include "CDRewardCodesTable.h"
 #include "CDPetComponentTable.h"
 
-#include <exception>
-
 #ifndef CDCLIENT_CACHE_ALL
 // Uncomment this to cache the full cdclient database into memory. This will make the server load faster, but will use more memory.
 // A vanilla CDClient takes about 46MB of memory + the regular world data.
@@ -55,13 +54,6 @@
 	#define CDCLIENT_DONT_CACHE_TABLE(x)
 #endif
 
-class CDClientConnectionException : public std::exception {
-public:
-	virtual const char* what() const throw() {
-		return "CDClientDatabase is not connected!";
-	}
-};
-
 // Using a macro to reduce repetitive code and issues from copy and paste.
 // As a note, ## in a macro is used to concatenate two tokens together.
 
@@ -108,11 +100,14 @@ DEFINE_TABLE_STORAGE(CDRewardCodesTable);
 DEFINE_TABLE_STORAGE(CDRewardsTable);
 DEFINE_TABLE_STORAGE(CDScriptComponentTable);
 DEFINE_TABLE_STORAGE(CDSkillBehaviorTable);
+DEFINE_TABLE_STORAGE(CDTamingBuildPuzzleTable);
 DEFINE_TABLE_STORAGE(CDVendorComponentTable);
 DEFINE_TABLE_STORAGE(CDZoneTableTable);
 
 void CDClientManager::LoadValuesFromDatabase() {
-	if (!CDClientDatabase::isConnected) throw CDClientConnectionException();
+	if (!CDClientDatabase::isConnected) {
+		throw std::runtime_error{ "CDClientDatabase is not connected!" };
+	}
 
 	CDActivityRewardsTable::Instance().LoadValuesFromDatabase();
 	CDActivitiesTable::Instance().LoadValuesFromDatabase();
@@ -152,6 +147,7 @@ void CDClientManager::LoadValuesFromDatabase() {
 	CDRewardsTable::Instance().LoadValuesFromDatabase();
 	CDScriptComponentTable::Instance().LoadValuesFromDatabase();
 	CDSkillBehaviorTable::Instance().LoadValuesFromDatabase();
+	CDTamingBuildPuzzleTable::Instance().LoadValuesFromDatabase();
 	CDVendorComponentTable::Instance().LoadValuesFromDatabase();
 	CDZoneTableTable::Instance().LoadValuesFromDatabase();
 }

dDatabase/CDClientDatabase/CDClientTables/CDPetComponentTable.cpp

@@ -50,7 +50,7 @@ void CDPetComponentTable::LoadValuesFromDatabase() {
 }
 
 void CDPetComponentTable::LoadValuesFromDefaults() {
-	GetEntriesMutable().insert(std::make_pair(defaultEntry.id, defaultEntry));
+	GetEntriesMutable().emplace(defaultEntry.id, defaultEntry);
 }
 
 CDPetComponent& CDPetComponentTable::GetByID(const uint32_t componentID) {

dDatabase/CDClientDatabase/CDClientTables/CDTamingBuildPuzzleTable.cpp

@@ -0,0 +1,35 @@
+#include "CDTamingBuildPuzzleTable.h"
+
+void CDTamingBuildPuzzleTable::LoadValuesFromDatabase() {
+	// First, get the size of the table
+	uint32_t size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM TamingBuildPuzzles");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
+		tableSize.nextRow();
+	}
+
+	// Reserve the size
+	auto& entries = GetEntriesMutable();
+	entries.reserve(size);
+
+	// Now get the data
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM TamingBuildPuzzles");
+	while (!tableData.eof()) {
+		const auto lot = static_cast<LOT>(tableData.getIntField("NPCLot", LOT_NULL));
+		entries.emplace(lot, CDTamingBuildPuzzle{
+			.puzzleModelLot = lot,
+			.validPieces{ tableData.getStringField("ValidPiecesLXF") },
+			.timeLimit = static_cast<float>(tableData.getFloatField("Timelimit", 30.0f)),
+			.numValidPieces = tableData.getIntField("NumValidPieces", 6),
+			.imaginationCost = tableData.getIntField("imagCostPerBuild", 10)
+		});
+		tableData.nextRow();
+	}
+}
+
+const CDTamingBuildPuzzle* CDTamingBuildPuzzleTable::GetByLOT(const LOT lot) const {
+	const auto& entries = GetEntries();
+	const auto itr = entries.find(lot);
+	return itr != entries.cend() ? &itr->second : nullptr;
+}

dDatabase/CDClientDatabase/CDClientTables/CDTamingBuildPuzzleTable.h

@@ -0,0 +1,60 @@
+#pragma once
+#include "CDTable.h"
+
+/**
+ * Information for the minigame to be completed
+ */
+struct CDTamingBuildPuzzle {
+	UNUSED_COLUMN(uint32_t id = 0;)
+
+	// The LOT of the object that is to be created
+	LOT puzzleModelLot = LOT_NULL;
+
+	// The LOT of the NPC
+	UNUSED_COLUMN(LOT npcLot = LOT_NULL;)
+
+	// The .lxfml file that contains the bricks required to build the model
+	std::string validPieces{};
+
+	// The .lxfml file that contains the bricks NOT required to build the model
+	UNUSED_COLUMN(std::string invalidPieces{};)
+
+	// Difficulty value
+	UNUSED_COLUMN(int32_t difficulty = 1;)
+
+	// The time limit to complete the build
+	float timeLimit = 30.0f;
+
+	// The number of pieces required to complete the minigame
+	int32_t numValidPieces = 6;
+
+	// Number of valid pieces
+	UNUSED_COLUMN(int32_t totalNumPieces = 16;)
+
+	// Model name
+	UNUSED_COLUMN(std::string modelName{};)
+
+	// The .lxfml file that contains the full model
+	UNUSED_COLUMN(std::string fullModel{};)
+
+	// The duration of the pet taming minigame
+	UNUSED_COLUMN(float duration = 45.0f;)
+
+	// The imagination cost for the tamer to start the minigame
+	int32_t imaginationCost = 10;
+};
+
+class CDTamingBuildPuzzleTable : public CDTable<CDTamingBuildPuzzleTable, std::unordered_map<LOT, CDTamingBuildPuzzle>> {
+public:
+	/**
+	 * Load values from the CD client database
+	*/
+	void LoadValuesFromDatabase();
+
+	/**
+	 * Gets the pet ability table corresponding to the pet LOT
+	 * @returns A pointer to the corresponding table, or nullptr if one cannot be found
+	*/
+	[[nodiscard]]
+	const CDTamingBuildPuzzle* GetByLOT(const LOT lot) const;
+};

dDatabase/CDClientDatabase/CDClientTables/CMakeLists.txt

@@ -36,5 +36,6 @@ set(DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES "CDActivitiesTable.cpp"
 	"CDRewardsTable.cpp"
 	"CDScriptComponentTable.cpp"
 	"CDSkillBehaviorTable.cpp"
+	"CDTamingBuildPuzzleTable.cpp"
 	"CDVendorComponentTable.cpp"
 	"CDZoneTableTable.cpp" PARENT_SCOPE)

dDatabase/GameDatabase/GameDatabase.h

@@ -23,6 +23,7 @@
 #include "IActivityLog.h"
 #include "IIgnoreList.h"
 #include "IAccountsRewardCodes.h"
+#include "IBehaviors.h"
 
 namespace sql {
 	class Statement;
@@ -40,7 +41,8 @@ class GameDatabase :
 	public IMail, public ICommandLog, public IPlayerCheatDetections, public IBugReports,
 	public IPropertyContents, public IProperty, public IPetNames, public ICharXml,
 	public IMigrationHistory, public IUgc, public IFriends, public ICharInfo,
-	public IAccounts, public IActivityLog, public IAccountsRewardCodes, public IIgnoreList {
+	public IAccounts, public IActivityLog, public IAccountsRewardCodes, public IIgnoreList,
+	public IBehaviors {
 public:
 	virtual ~GameDatabase() = default;
 	// TODO: These should be made private.

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -33,6 +33,9 @@ public:
 
 	// Add a new account to the database.
 	virtual void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) = 0;
+
+	// Update the GameMaster level of an account.
+	virtual void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) = 0;
 };
 
 #endif  //!__IACCOUNTS__H__

dDatabase/GameDatabase/ITables/IBehaviors.h

@@ -0,0 +1,22 @@
+#ifndef IBEHAVIORS_H
+#define IBEHAVIORS_H
+
+#include <cstdint>
+
+#include "dCommonVars.h"
+
+class IBehaviors {
+public:
+	struct Info {
+		int32_t behaviorId{};
+		uint32_t characterId{};
+		std::string behaviorInfo;
+	};
+
+	// This Add also takes care of updating if it exists.
+	virtual void AddBehavior(const Info& info) = 0;
+	virtual std::string GetBehavior(const int32_t behaviorId) = 0;
+	virtual void RemoveBehavior(const int32_t behaviorId) = 0;
+};
+
+#endif  //!IBEHAVIORS_H

dDatabase/GameDatabase/ITables/IPropertyContents.h

@@ -1,6 +1,7 @@
 #ifndef __IPROPERTIESCONTENTS__H__
 #define __IPROPERTIESCONTENTS__H__
 
+#include <array>
 #include <cstdint>
 #include <string_view>
 
@@ -16,6 +17,7 @@ public:
 		LWOOBJID id{};
 		LOT lot{};
 		uint32_t ugcId{};
+		std::array<int32_t, 5> behaviors{};
 	};
 
 	// Inserts a new UGC model into the database.
@@ -32,7 +34,7 @@ public:
 	virtual void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) = 0;
 
 	// Update the model position and rotation for the given property id.
-	virtual void UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) = 0;
+	virtual void UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) = 0;
 
 	// Remove the model for the given property id.
 	virtual void RemoveModel(const LWOOBJID& modelId) = 0;

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -74,7 +74,7 @@ public:
 	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
 	void RemoveUnreferencedUgcModels() override;
 	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) override;
+	void UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
@@ -108,6 +108,10 @@ public:
 	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
 	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
 	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
+	void AddBehavior(const IBehaviors::Info& info) override;
+	std::string GetBehavior(const int32_t behaviorId) override;
+	void RemoveBehavior(const int32_t characterId) override;
+	void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) override;
 private:
 
 	// Generic query functions that can be used for any query.

dDatabase/GameDatabase/MySQL/Tables/Accounts.cpp

@@ -35,3 +35,7 @@ void MySQLDatabase::UpdateAccountPassword(const uint32_t accountId, const std::s
 void MySQLDatabase::InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) {
 	ExecuteInsert("INSERT INTO accounts (name, password, gm_level) VALUES (?, ?, ?);", username, bcryptpassword, static_cast<int32_t>(eGameMasterLevel::OPERATOR));
 }
+
+void MySQLDatabase::UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) {
+	ExecuteUpdate("UPDATE accounts SET gm_level = ? WHERE id = ?;", static_cast<int32_t>(gmLevel), accountId);
+}

dDatabase/GameDatabase/MySQL/Tables/Behaviors.cpp

@@ -0,0 +1,19 @@
+#include "IBehaviors.h"
+
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::AddBehavior(const IBehaviors::Info& info) {
+	ExecuteInsert(
+		"INSERT INTO behaviors (behavior_info, character_id, behavior_id) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE behavior_info = ?",
+		info.behaviorInfo, info.characterId, info.behaviorId, info.behaviorInfo
+	);
+}
+
+void MySQLDatabase::RemoveBehavior(const int32_t behaviorId) {
+	ExecuteDelete("DELETE FROM behaviors WHERE behavior_id = ?", behaviorId);
+}
+
+std::string MySQLDatabase::GetBehavior(const int32_t behaviorId) {
+	auto result = ExecuteSelect("SELECT behavior_info FROM behaviors WHERE behavior_id = ?", behaviorId);
+	return result->next() ? result->getString("behavior_info").c_str() : "";
+}

dDatabase/GameDatabase/MySQL/Tables/CMakeLists.txt

@@ -2,6 +2,7 @@ set(DDATABASES_DATABASES_MYSQL_TABLES_SOURCES
 	"Accounts.cpp"
 	"AccountsRewardCodes.cpp"
 	"ActivityLog.cpp"
+	"Behaviors.cpp"
 	"BugReports.cpp"
 	"CharInfo.cpp"
 	"CharXml.cpp"

dDatabase/GameDatabase/MySQL/Tables/PropertyContents.cpp

@@ -1,7 +1,10 @@
 #include "MySQLDatabase.h"
 
 std::vector<IPropertyContents::Model> MySQLDatabase::GetPropertyModels(const LWOOBJID& propertyId) {
-	auto result = ExecuteSelect("SELECT id, lot, x, y, z, rx, ry, rz, rw, ugc_id FROM properties_contents WHERE property_id = ?;", propertyId);
+	auto result = ExecuteSelect(
+		"SELECT id, lot, x, y, z, rx, ry, rz, rw, ugc_id, "
+		"behavior_1, behavior_2, behavior_3, behavior_4, behavior_5 "
+		"FROM properties_contents WHERE property_id = ?;", propertyId);
 
 	std::vector<IPropertyContents::Model> toReturn;
 	toReturn.reserve(result->rowsCount());
@@ -17,6 +20,12 @@ std::vector<IPropertyContents::Model> MySQLDatabase::GetPropertyModels(const LWO
 		model.rotation.y = result->getFloat("ry");
 		model.rotation.z = result->getFloat("rz");
 		model.ugcId = result->getUInt64("ugc_id");
+		model.behaviors[0] = result->getInt("behavior_1");
+		model.behaviors[1] = result->getInt("behavior_2");
+		model.behaviors[2] = result->getInt("behavior_3");
+		model.behaviors[3] = result->getInt("behavior_4");
+		model.behaviors[4] = result->getInt("behavior_5");
+
 		toReturn.push_back(std::move(model));
 	}
 	return toReturn;
@@ -32,21 +41,23 @@ void MySQLDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const IPr
 			model.id, propertyId, model.ugcId == 0 ? std::nullopt : std::optional(model.ugcId), static_cast<uint32_t>(model.lot),
 			model.position.x, model.position.y, model.position.z, model.rotation.x, model.rotation.y, model.rotation.z, model.rotation.w,
 			name, "", // Model description.  TODO implement this.
-			0, // behavior 1.  TODO implement this.
-			0, // behavior 2.  TODO implement this.
-			0, // behavior 3.  TODO implement this.
-			0, // behavior 4.  TODO implement this.
-			0 // behavior 5.  TODO implement this.
+			model.behaviors[0], // behavior 1
+			model.behaviors[1], // behavior 2
+			model.behaviors[2], // behavior 3
+			model.behaviors[3], // behavior 4
+			model.behaviors[4] // behavior 5
 		);
 	} catch (sql::SQLException& e) {
 		LOG("Error inserting new property model: %s", e.what());
 	}
 }
 
-void MySQLDatabase::UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) {
+void MySQLDatabase::UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
 	ExecuteUpdate(
-		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ? WHERE id = ?;",
-		position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w, propertyId);
+		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ?, "
+		"behavior_1 = ?, behavior_2 = ?, behavior_3 = ?, behavior_4 = ?, behavior_5 = ? WHERE id = ?;",
+		position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w,
+		behaviors[0].first, behaviors[1].first, behaviors[2].first, behaviors[3].first, behaviors[4].first, propertyId);
 }
 
 void MySQLDatabase::RemoveModel(const LWOOBJID& modelId) {

dGame/Character.cpp

@@ -27,12 +27,11 @@ Character::Character(uint32_t id, User* parentUser) {
 	m_ID = id;
 	m_ParentUser = parentUser;
 	m_OurEntity = nullptr;
-	m_Doc = nullptr;
+	m_GMLevel = eGameMasterLevel::CIVILIAN;
+	m_PermissionMap = static_cast<ePermissionMap>(0);
 }
 
 Character::~Character() {
-	if (m_Doc) delete m_Doc;
-	m_Doc = nullptr;
 	m_OurEntity = nullptr;
 	m_ParentUser = nullptr;
 }
@@ -55,8 +54,6 @@ void Character::UpdateInfoFromDatabase() {
 	m_ZoneInstanceID = 0; //These values don't really matter, these are only used on the char select screen and seem unused.
 	m_ZoneCloneID = 0;
 
-	m_Doc = nullptr;
-
 	//Quickly and dirtly parse the xmlData to get the info we need:
 	DoQuickXMLDataParse();
 
@@ -70,18 +67,13 @@ void Character::UpdateInfoFromDatabase() {
 }
 
 void Character::UpdateFromDatabase() {
-	if (m_Doc) delete m_Doc;
 	UpdateInfoFromDatabase();
 }
 
 void Character::DoQuickXMLDataParse() {
 	if (m_XMLData.size() == 0) return;
 
-	delete m_Doc;
-	m_Doc = new tinyxml2::XMLDocument();
-	if (!m_Doc) return;
-
-	if (m_Doc->Parse(m_XMLData.c_str(), m_XMLData.size()) == 0) {
+	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);
 	} else {
 		LOG("Failed to load xmlData!");
@@ -89,7 +81,7 @@ void Character::DoQuickXMLDataParse() {
 		return;
 	}
 
-	tinyxml2::XMLElement* mf = m_Doc->FirstChildElement("obj")->FirstChildElement("mf");
+	tinyxml2::XMLElement* mf = m_Doc.FirstChildElement("obj")->FirstChildElement("mf");
 	if (!mf) {
 		LOG("Failed to find mf tag!");
 		return;
@@ -108,7 +100,7 @@ void Character::DoQuickXMLDataParse() {
 	mf->QueryAttribute("ess", &m_Eyes);
 	mf->QueryAttribute("ms", &m_Mouth);
 
-	tinyxml2::XMLElement* inv = m_Doc->FirstChildElement("obj")->FirstChildElement("inv");
+	tinyxml2::XMLElement* inv = m_Doc.FirstChildElement("obj")->FirstChildElement("inv");
 	if (!inv) {
 		LOG("Char has no inv!");
 		return;
@@ -141,7 +133,7 @@ void Character::DoQuickXMLDataParse() {
 	}
 
 
-	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
+	tinyxml2::XMLElement* character = m_Doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
 		character->QueryAttribute("cc", &m_Coins);
 		int32_t gm_level = 0;
@@ -205,7 +197,7 @@ void Character::DoQuickXMLDataParse() {
 		character->QueryAttribute("lzrw", &m_OriginalRotation.w);
 	}
 
-	auto* flags = m_Doc->FirstChildElement("obj")->FirstChildElement("flag");
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
 	if (flags) {
 		auto* currentChild = flags->FirstChildElement();
 		while (currentChild) {
@@ -239,12 +231,10 @@ void Character::SetBuildMode(bool buildMode) {
 }
 
 void Character::SaveXMLToDatabase() {
-	if (!m_Doc) return;
-
 	//For metrics, we'll record the time it took to save:
 	auto start = std::chrono::system_clock::now();
 
-	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
+	tinyxml2::XMLElement* character = m_Doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
 		character->SetAttribute("gm", static_cast<uint32_t>(m_GMLevel));
 		character->SetAttribute("cc", m_Coins);
@@ -266,11 +256,11 @@ void Character::SaveXMLToDatabase() {
 		}
 
 		auto emotes = character->FirstChildElement("ue");
-		if (!emotes) emotes = m_Doc->NewElement("ue");
+		if (!emotes) emotes = m_Doc.NewElement("ue");
 
 		emotes->DeleteChildren();
 		for (int emoteID : m_UnlockedEmotes) {
-			auto emote = m_Doc->NewElement("e");
+			auto emote = m_Doc.NewElement("e");
 			emote->SetAttribute("id", emoteID);
 
 			emotes->LinkEndChild(emote);
@@ -280,15 +270,15 @@ void Character::SaveXMLToDatabase() {
 	}
 
 	//Export our flags:
-	auto* flags = m_Doc->FirstChildElement("obj")->FirstChildElement("flag");
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
 	if (!flags) {
-		flags = m_Doc->NewElement("flag"); //Create a flags tag if we don't have one
-		m_Doc->FirstChildElement("obj")->LinkEndChild(flags); //Link it to the obj tag so we can find next time
+		flags = m_Doc.NewElement("flag"); //Create a flags tag if we don't have one
+		m_Doc.FirstChildElement("obj")->LinkEndChild(flags); //Link it to the obj tag so we can find next time
 	}
 
 	flags->DeleteChildren(); //Clear it if we have anything, so that we can fill it up again without dupes
 	for (std::pair<uint32_t, uint64_t> flag : m_PlayerFlags) {
-		auto* f = m_Doc->NewElement("f");
+		auto* f = m_Doc.NewElement("f");
 		f->SetAttribute("id", flag.first);
 
 		//Because of the joy that is tinyxml2, it doesn't offer a function to set a uint64 as an attribute.
@@ -301,7 +291,7 @@ void Character::SaveXMLToDatabase() {
 
 	// Prevents the news feed from showing up on world transfers
 	if (GetPlayerFlag(ePlayerFlag::IS_NEWS_SCREEN_VISIBLE)) {
-		auto* s = m_Doc->NewElement("s");
+		auto* s = m_Doc.NewElement("s");
 		s->SetAttribute("si", ePlayerFlag::IS_NEWS_SCREEN_VISIBLE);
 		flags->LinkEndChild(s);
 	}
@@ -326,7 +316,7 @@ void Character::SaveXMLToDatabase() {
 
 void Character::SetIsNewLogin() {
 	// If we dont have a flag element, then we cannot have a s element as a child of flag.
-	auto* flags = m_Doc->FirstChildElement("obj")->FirstChildElement("flag");
+	auto* flags = m_Doc.FirstChildElement("obj")->FirstChildElement("flag");
 	if (!flags) return;
 
 	auto* currentChild = flags->FirstChildElement();
@@ -344,7 +334,7 @@ void Character::SetIsNewLogin() {
 void Character::WriteToDatabase() {
 	//Dump our xml into m_XMLData:
 	tinyxml2::XMLPrinter printer(0, true, 0);
-	m_Doc->Print(&printer);
+	m_Doc.Print(&printer);
 
 	//Finally, save to db:
 	Database::Get()->UpdateCharacterXml(m_ID, printer.CStr());
@@ -421,15 +411,15 @@ void Character::SetRetroactiveFlags() {
 
 void Character::SaveXmlRespawnCheckpoints() {
 	//Export our respawn points:
-	auto* points = m_Doc->FirstChildElement("obj")->FirstChildElement("res");
+	auto* points = m_Doc.FirstChildElement("obj")->FirstChildElement("res");
 	if (!points) {
-		points = m_Doc->NewElement("res");
-		m_Doc->FirstChildElement("obj")->LinkEndChild(points);
+		points = m_Doc.NewElement("res");
+		m_Doc.FirstChildElement("obj")->LinkEndChild(points);
 	}
 
 	points->DeleteChildren();
 	for (const auto& point : m_WorldRespawnCheckpoints) {
-		auto* r = m_Doc->NewElement("r");
+		auto* r = m_Doc.NewElement("r");
 		r->SetAttribute("w", point.first);
 
 		r->SetAttribute("x", point.second.x);
@@ -443,7 +433,7 @@ void Character::SaveXmlRespawnCheckpoints() {
 void Character::LoadXmlRespawnCheckpoints() {
 	m_WorldRespawnCheckpoints.clear();
 
-	auto* points = m_Doc->FirstChildElement("obj")->FirstChildElement("res");
+	auto* points = m_Doc.FirstChildElement("obj")->FirstChildElement("res");
 	if (!points) {
 		return;
 	}

dGame/Character.h

@@ -37,7 +37,7 @@ public:
 	void LoadXmlRespawnCheckpoints();
 
 	const std::string& GetXMLData() const { return m_XMLData; }
-	tinyxml2::XMLDocument* GetXMLDoc() const { return m_Doc; }
+	const tinyxml2::XMLDocument& GetXMLDoc() const { return m_Doc; }
 
 	/**
 	 * Out of abundance of safety and clarity of what this saves, this is its own function.
@@ -464,22 +464,22 @@ private:
 	/**
 	 * The ID of this character. First 32 bits of the ObjectID.
 	 */
-	uint32_t m_ID;
+	uint32_t m_ID{};
 
 	/**
 	 * The 64-bit unique ID used in the game.
 	 */
-	LWOOBJID m_ObjectID;
+	LWOOBJID m_ObjectID{ LWOOBJID_EMPTY };
 
 	/**
 	 * The user that owns this character.
 	 */
-	User* m_ParentUser;
+	User* m_ParentUser{};
 
 	/**
 	 * If the character is in game, this is the entity that it represents, else nullptr.
 	 */
-	Entity* m_OurEntity;
+	Entity* m_OurEntity{};
 
 	/**
 	 * 0-9, the Game Master level of this character.
@@ -506,17 +506,17 @@ private:
 	/**
 	 * Whether the custom name of this character is rejected
 	 */
-	bool m_NameRejected;
+	bool m_NameRejected{};
 
 	/**
 	 * The current amount of coins of this character
 	 */
-	int64_t m_Coins;
+	int64_t m_Coins{};
 
 	/**
 	 * Whether the character is building
 	 */
-	bool m_BuildMode;
+	bool m_BuildMode{};
 
 	/**
 	 * The items equipped by the character on world load
@@ -583,7 +583,7 @@ private:
 	/**
 	 * The ID of the properties of this character
 	 */
-	uint32_t m_PropertyCloneID;
+	uint32_t m_PropertyCloneID{};
 
 	/**
 	 * The XML data for this character, stored as string
@@ -613,7 +613,7 @@ private:
 	/**
 	 * The last time this character logged in
 	 */
-	uint64_t m_LastLogin;
+	uint64_t m_LastLogin{};
 
 	/**
 	 * The gameplay flags this character has (not just true values)
@@ -623,7 +623,7 @@ private:
 	/**
 	 * The character XML belonging to this character
 	 */
-	tinyxml2::XMLDocument* m_Doc;
+	tinyxml2::XMLDocument m_Doc;
 
 	/**
 	 * Title of an announcement this character made (reserved for GMs)

dGame/Entity.cpp

@@ -226,7 +226,7 @@ void Entity::Initialize() {
 
 		AddComponent<SimplePhysicsComponent>(simplePhysicsComponentID);
 
-		AddComponent<ModelComponent>();
+		AddComponent<ModelComponent>()->LoadBehaviors();
 
 		AddComponent<RenderComponent>();
 
@@ -477,8 +477,7 @@ void Entity::Initialize() {
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::INVENTORY) > 0 || m_Character) {
-		auto* xmlDoc = m_Character ? m_Character->GetXMLDoc() : nullptr;
-		AddComponent<InventoryComponent>(xmlDoc);
+		AddComponent<InventoryComponent>();
 	}
 	// if this component exists, then we initialize it. it's value is always 0
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MULTI_ZONE_ENTRANCE, -1) != -1) {
@@ -651,7 +650,7 @@ void Entity::Initialize() {
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODEL, -1) != -1 && !GetComponent<PetComponent>()) {
-		AddComponent<ModelComponent>();
+		AddComponent<ModelComponent>()->LoadBehaviors();
 		if (!HasComponent(eReplicaComponentType::DESTROYABLE)) {
 			auto* destroyableComponent = AddComponent<DestroyableComponent>();
 			destroyableComponent->SetHealth(1);
@@ -1245,7 +1244,7 @@ void Entity::WriteComponents(RakNet::BitStream& outBitStream, eReplicaPacketType
 	outBitStream.Write0();
 }
 
-void Entity::UpdateXMLDoc(tinyxml2::XMLDocument* doc) {
+void Entity::UpdateXMLDoc(tinyxml2::XMLDocument& doc) {
 	//This function should only ever be called from within Character, meaning doc should always exist when this is called.
 	//Naturally, we don't include any non-player components in this update function.
 
@@ -1536,7 +1535,7 @@ void Entity::Kill(Entity* murderer, const eKillType killType) {
 		bool waitForDeathAnimation = false;
 
 		if (destroyableComponent) {
-			waitForDeathAnimation = destroyableComponent->GetDeathBehavior() == 0 && killType != eKillType::SILENT;
+			waitForDeathAnimation = !destroyableComponent->GetIsSmashable() && destroyableComponent->GetDeathBehavior() == 0 && killType != eKillType::SILENT;
 		}
 
 		// Live waited a hard coded 12 seconds for death animations of type 0 before networking destruction!
@@ -1636,10 +1635,8 @@ void Entity::PickupItem(const LWOOBJID& objectID) {
 				CDObjectSkillsTable* skillsTable = CDClientManager::GetTable<CDObjectSkillsTable>();
 				std::vector<CDObjectSkills> skills = skillsTable->Query([=](CDObjectSkills entry) {return (entry.objectTemplate == p.second.lot); });
 				for (CDObjectSkills skill : skills) {
-					CDSkillBehaviorTable* skillBehTable = CDClientManager::GetTable<CDSkillBehaviorTable>();
-
 					auto* skillComponent = GetComponent<SkillComponent>();
-					if (skillComponent) skillComponent->CastSkill(skill.skillID, GetObjectID(), GetObjectID());
+					if (skillComponent) skillComponent->CastSkill(skill.skillID, GetObjectID(), GetObjectID(), skill.castOnType, NiQuaternion(0, 0, 0, 0));
 
 					auto* missionComponent = GetComponent<MissionComponent>();
 
@@ -1844,6 +1841,12 @@ const NiPoint3& Entity::GetPosition() const {
 		return vehicel->GetPosition();
 	}
 
+	auto* rigidBodyPhantomPhysicsComponent = GetComponent<RigidbodyPhantomPhysicsComponent>();
+
+	if (rigidBodyPhantomPhysicsComponent != nullptr) {
+		return rigidBodyPhantomPhysicsComponent->GetPosition();
+	}
+
 	return NiPoint3Constant::ZERO;
 }
 
@@ -1872,6 +1875,12 @@ const NiQuaternion& Entity::GetRotation() const {
 		return vehicel->GetRotation();
 	}
 
+	auto* rigidBodyPhantomPhysicsComponent = GetComponent<RigidbodyPhantomPhysicsComponent>();
+
+	if (rigidBodyPhantomPhysicsComponent != nullptr) {
+		return rigidBodyPhantomPhysicsComponent->GetRotation();
+	}
+
 	return NiQuaternionConstant::IDENTITY;
 }
 
@@ -1900,6 +1909,12 @@ void Entity::SetPosition(const NiPoint3& position) {
 		vehicel->SetPosition(position);
 	}
 
+	auto* rigidBodyPhantomPhysicsComponent = GetComponent<RigidbodyPhantomPhysicsComponent>();
+
+	if (rigidBodyPhantomPhysicsComponent != nullptr) {
+		rigidBodyPhantomPhysicsComponent->SetPosition(position);
+	}
+
 	Game::entityManager->SerializeEntity(this);
 }
 
@@ -1928,6 +1943,12 @@ void Entity::SetRotation(const NiQuaternion& rotation) {
 		vehicel->SetRotation(rotation);
 	}
 
+	auto* rigidBodyPhantomPhysicsComponent = GetComponent<RigidbodyPhantomPhysicsComponent>();
+
+	if (rigidBodyPhantomPhysicsComponent != nullptr) {
+		rigidBodyPhantomPhysicsComponent->SetRotation(rotation);
+	}
+
 	Game::entityManager->SerializeEntity(this);
 }
 

dGame/Entity.h

@@ -174,7 +174,7 @@ public:
 
 	void WriteBaseReplicaData(RakNet::BitStream& outBitStream, eReplicaPacketType packetType);
 	void WriteComponents(RakNet::BitStream& outBitStream, eReplicaPacketType packetType);
-	void UpdateXMLDoc(tinyxml2::XMLDocument* doc);
+	void UpdateXMLDoc(tinyxml2::XMLDocument& doc);
 	void Update(float deltaTime);
 
 	// Events

dGame/User.cpp

@@ -12,6 +12,7 @@ User::User(const SystemAddress& sysAddr, const std::string& username, const std:
 	m_AccountID = 0;
 	m_Username = "";
 	m_SessionKey = "";
+	m_MuteExpire = 0;
 
 	m_MaxGMLevel = eGameMasterLevel::CIVILIAN; //The max GM level this account can assign to it's characters
 	m_LastCharID = 0;

dGame/UserManager.cpp

@@ -83,7 +83,7 @@ void UserManager::Initialize() {
 	auto chatListStream = Game::assetManager->GetFile("chatplus_en_us.txt");
 	if (!chatListStream) {
 		LOG("Failed to load %s", (Game::assetManager->GetResPath() / "chatplus_en_us.txt").string().c_str());
-		throw std::runtime_error("Aborting initialization due to missing chat whitelist file.");
+		throw std::runtime_error("Aborting initialization due to missing chat allowlist file.");
 	}
 
 	while (std::getline(chatListStream, line, '\n')) {
@@ -536,13 +536,13 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
 uint32_t FindCharShirtID(uint32_t shirtColor, uint32_t shirtStyle) {
 	try {
 		auto stmt = CDClientDatabase::CreatePreppedStmt(
-			"select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ? AND icc.decal == ?"
+			"select obj.id as objectId from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ? AND icc.decal == ?"
 		);
 		stmt.bind(1, "character create shirt");
 		stmt.bind(2, static_cast<int>(shirtColor));
 		stmt.bind(3, static_cast<int>(shirtStyle));
 		auto tableData = stmt.execQuery();
-		auto shirtLOT = tableData.getIntField(0, 4069);
+		auto shirtLOT = tableData.getIntField("objectId", 4069);
 		tableData.finalize();
 		return shirtLOT;
 	} catch (const std::exception& ex) {
@@ -555,12 +555,12 @@ uint32_t FindCharShirtID(uint32_t shirtColor, uint32_t shirtStyle) {
 uint32_t FindCharPantsID(uint32_t pantsColor) {
 	try {
 		auto stmt = CDClientDatabase::CreatePreppedStmt(
-			"select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ?"
+			"select obj.id as objectId from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ?"
 		);
 		stmt.bind(1, "cc pants");
 		stmt.bind(2, static_cast<int>(pantsColor));
 		auto tableData = stmt.execQuery();
-		auto pantsLOT = tableData.getIntField(0, 2508);
+		auto pantsLOT = tableData.getIntField("objectId", 2508);
 		tableData.finalize();
 		return pantsLOT;
 	} catch (const std::exception& ex) {

dGame/dBehaviors/Behavior.cpp

@@ -377,10 +377,10 @@ void Behavior::PlayFx(std::u16string type, const LWOOBJID target, const LWOOBJID
 		return;
 	}
 
-	const auto name = std::string(result.getStringField(0));
+	const auto name = std::string(result.getStringField("effectName"));
 
 	if (type.empty()) {
-		const auto typeResult = result.getStringField(1);
+		const auto typeResult = result.getStringField("effectType");
 
 		type = GeneralUtils::ASCIIToUTF16(typeResult);
 

dGame/dBehaviors/BehaviorContext.cpp

@@ -105,7 +105,7 @@ void BehaviorContext::ExecuteUpdates() {
 	this->scheduledUpdates.clear();
 }
 
-void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream& bitStream) {
+bool BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream& bitStream) {
 	BehaviorSyncEntry entry;
 	auto found = false;
 
@@ -128,7 +128,7 @@ void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream& bit
 	if (!found) {
 		LOG("Failed to find behavior sync entry with sync id (%i)!", syncId);
 
-		return;
+		return false;
 	}
 
 	auto* behavior = entry.behavior;
@@ -137,10 +137,11 @@ void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream& bit
 	if (behavior == nullptr) {
 		LOG("Invalid behavior for sync id (%i)!", syncId);
 
-		return;
+		return false;
 	}
 
 	behavior->Sync(this, bitStream, branch);
+	return true;
 }
 
 
@@ -198,6 +199,26 @@ void BehaviorContext::UpdatePlayerSyncs(float deltaTime) {
 			i++;
 			continue;
 		}
+
+		if (this->skillUId != 0 && !clientInitalized) {
+			EchoSyncSkill echo;
+			echo.bDone = true;
+			echo.uiSkillHandle = this->skillUId;
+			echo.uiBehaviorHandle = entry.handle;
+
+			RakNet::BitStream bitStream{};
+			entry.behavior->SyncCalculation(this, bitStream, entry.branchContext);
+
+			echo.sBitStream.assign(reinterpret_cast<char*>(bitStream.GetData()), bitStream.GetNumberOfBytesUsed());
+
+			RakNet::BitStream message;
+			BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+			message.Write(this->originator);
+			echo.Serialize(message);
+
+			Game::server->Send(message, UNASSIGNED_SYSTEM_ADDRESS, true);
+		}
+
 		this->syncEntries.erase(this->syncEntries.begin() + i);
 	}
 }
@@ -224,6 +245,16 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) {
 	for (auto i = 0u; i < this->syncEntries.size(); ++i) {
 		auto entry = this->syncEntries.at(i);
 
+		if (entry.behavior->m_templateId == BehaviorTemplate::ATTACK_DELAY) {
+			auto* self = Game::entityManager->GetEntity(originator);
+			if (self) {
+				auto* destroyableComponent = self->GetComponent<DestroyableComponent>();
+				if (destroyableComponent && destroyableComponent->GetHealth() <= 0) {
+					continue;
+				}
+			}
+		}
+
 		if (entry.time > 0) {
 			entry.time -= deltaTime;
 
@@ -333,7 +364,7 @@ void BehaviorContext::FilterTargets(std::vector<Entity*>& targets, std::forward_
 		}
 
 		// handle targeting the caster
-		if (candidate == caster){
+		if (candidate == caster) {
 			// if we aren't targeting self, erase, otherise increment and continue
 			if (!targetSelf) index = targets.erase(index);
 			else index++;
@@ -356,24 +387,24 @@ void BehaviorContext::FilterTargets(std::vector<Entity*>& targets, std::forward_
 		}
 
 		// if they are dead, then earse and continue
-		if (candidateDestroyableComponent->GetIsDead()){
+		if (candidateDestroyableComponent->GetIsDead()) {
 			index = targets.erase(index);
 			continue;
 		}
 
 		// if their faction is explicitly included, increment and continue
 		auto candidateFactions = candidateDestroyableComponent->GetFactionIDs();
-		if (CheckFactionList(includeFactionList, candidateFactions)){
+		if (CheckFactionList(includeFactionList, candidateFactions)) {
 			index++;
 			continue;
 		}
 
 		// check if they are a team member
-		if (targetTeam){
+		if (targetTeam) {
 			auto* team = TeamManager::Instance()->GetTeam(this->caster);
-			if (team){
+			if (team) {
 				// if we find a team member keep it and continue to skip enemy checks
-				if(std::find(team->members.begin(), team->members.end(), candidate->GetObjectID()) != team->members.end()){
+				if (std::find(team->members.begin(), team->members.end(), candidate->GetObjectID()) != team->members.end()) {
 					index++;
 					continue;
 				}
@@ -419,8 +450,8 @@ bool BehaviorContext::CheckTargetingRequirements(const Entity* target) const {
 // returns true if any of the object factions are in the faction list
 bool BehaviorContext::CheckFactionList(std::forward_list<int32_t>& factionList, std::vector<int32_t>& objectsFactions) const {
 	if (factionList.empty() || objectsFactions.empty()) return false;
-	for (auto faction : factionList){
-		if(std::find(objectsFactions.begin(), objectsFactions.end(), faction) != objectsFactions.end()) return true;
+	for (auto faction : factionList) {
+		if (std::find(objectsFactions.begin(), objectsFactions.end(), faction) != objectsFactions.end()) return true;
 	}
 	return false;
 }

dGame/dBehaviors/BehaviorContext.h

@@ -93,7 +93,7 @@ struct BehaviorContext
 
 	void ExecuteUpdates();
 
-	void SyncBehavior(uint32_t syncId, RakNet::BitStream& bitStream);
+	bool SyncBehavior(uint32_t syncId, RakNet::BitStream& bitStream);
 
 	void Update(float deltaTime);
 

dGame/dBehaviors/DamageAbsorptionBehavior.cpp

@@ -27,6 +27,8 @@ void DamageAbsorptionBehavior::Handle(BehaviorContext* context, RakNet::BitStrea
 	destroyable->SetIsShielded(true);
 
 	context->RegisterTimerBehavior(this, branch, target->GetObjectID());
+
+	Game::entityManager->SerializeEntity(target);
 }
 
 void DamageAbsorptionBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
@@ -52,7 +54,13 @@ void DamageAbsorptionBehavior::Timer(BehaviorContext* context, BehaviorBranchCon
 
 	const auto toRemove = std::min(present, this->m_absorbAmount);
 
-	destroyable->SetDamageToAbsorb(present - toRemove);
+	const auto remaining = present - toRemove;
+
+	destroyable->SetDamageToAbsorb(remaining);
+
+	destroyable->SetIsShielded(remaining > 0);
+
+	Game::entityManager->SerializeEntity(target);
 }
 
 void DamageAbsorptionBehavior::Load() {

dGame/dBehaviors/SwitchMultipleBehavior.cpp

@@ -47,11 +47,11 @@ void SwitchMultipleBehavior::Load() {
 	auto result = query.execQuery();
 
 	while (!result.eof()) {
-		const auto behavior_id = static_cast<uint32_t>(result.getFloatField(1));
+		const auto behavior_id = static_cast<uint32_t>(result.getFloatField("behavior"));
 
 		auto* behavior = CreateBehavior(behavior_id);
 
-		auto value = result.getFloatField(2);
+		auto value = result.getFloatField("value");
 
 		this->m_behaviors.emplace_back(value, behavior);
 

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -29,7 +29,8 @@
 
 BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id): Component(parent) {
 	m_Target = LWOOBJID_EMPTY;
-	SetAiState(AiState::spawn);
+	m_DirtyStateOrTarget = true;
+	m_State = AiState::spawn;
 	m_Timer = 1.0f;
 	m_StartPosition = parent->GetPosition();
 	m_MovementAI = nullptr;
@@ -45,20 +46,20 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id):
 	auto componentResult = componentQuery.execQuery();
 
 	if (!componentResult.eof()) {
-		if (!componentResult.fieldIsNull(0))
-			m_AggroRadius = componentResult.getFloatField(0);
+		if (!componentResult.fieldIsNull("aggroRadius"))
+			m_AggroRadius = componentResult.getFloatField("aggroRadius");
 
-		if (!componentResult.fieldIsNull(1))
-			m_TetherSpeed = componentResult.getFloatField(1);
+		if (!componentResult.fieldIsNull("tetherSpeed"))
+			m_TetherSpeed = componentResult.getFloatField("tetherSpeed");
 
-		if (!componentResult.fieldIsNull(2))
-			m_PursuitSpeed = componentResult.getFloatField(2);
+		if (!componentResult.fieldIsNull("pursuitSpeed"))
+			m_PursuitSpeed = componentResult.getFloatField("pursuitSpeed");
 
-		if (!componentResult.fieldIsNull(3))
-			m_SoftTetherRadius = componentResult.getFloatField(3);
+		if (!componentResult.fieldIsNull("softTetherRadius"))
+			m_SoftTetherRadius = componentResult.getFloatField("softTetherRadius");
 
-		if (!componentResult.fieldIsNull(4))
-			m_HardTetherRadius = componentResult.getFloatField(4);
+		if (!componentResult.fieldIsNull("hardTetherRadius"))
+			m_HardTetherRadius = componentResult.getFloatField("hardTetherRadius");
 	}
 
 	componentResult.finalize();
@@ -82,11 +83,11 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id):
 	auto result = skillQuery.execQuery();
 
 	while (!result.eof()) {
-		const auto skillId = static_cast<uint32_t>(result.getIntField(0));
+		const auto skillId = static_cast<uint32_t>(result.getIntField("skillID"));
 
-		const auto abilityCooldown = static_cast<float>(result.getFloatField(1));
+		const auto abilityCooldown = static_cast<float>(result.getFloatField("cooldown"));
 
-		const auto behaviorId = static_cast<uint32_t>(result.getIntField(2));
+		const auto behaviorId = static_cast<uint32_t>(result.getIntField("behaviorID"));
 
 		auto* behavior = Behavior::CreateBehavior(behaviorId);
 
@@ -150,13 +151,13 @@ void BaseCombatAIComponent::Update(const float deltaTime) {
 	m_dpEntityEnemy->SetPosition(m_Parent->GetPosition());
 
 	//Process enter events
-	for (auto en : m_dpEntity->GetNewObjects()) {
-		m_Parent->OnCollisionPhantom(en->GetObjectID());
+	for (const auto id : m_dpEntity->GetNewObjects()) {
+		m_Parent->OnCollisionPhantom(id);
 	}
 
 	//Process exit events
-	for (auto en : m_dpEntity->GetRemovedObjects()) {
-		m_Parent->OnCollisionLeavePhantom(en->GetObjectID());
+	for (const auto id : m_dpEntity->GetRemovedObjects()) {
+		m_Parent->OnCollisionLeavePhantom(id);
 	}
 
 	// Check if we should stop the tether effect

dGame/dComponents/BuffComponent.cpp

@@ -326,9 +326,9 @@ Entity* BuffComponent::GetParent() const {
 	return m_Parent;
 }
 
-void BuffComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
+void BuffComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 	// Load buffs
-	auto* dest = doc->FirstChildElement("obj")->FirstChildElement("dest");
+	auto* dest = doc.FirstChildElement("obj")->FirstChildElement("dest");
 
 	// Make sure we have a clean buff element.
 	auto* buffElement = dest->FirstChildElement("buff");
@@ -386,15 +386,15 @@ void BuffComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 	}
 }
 
-void BuffComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
+void BuffComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
 	// Save buffs
-	auto* dest = doc->FirstChildElement("obj")->FirstChildElement("dest");
+	auto* dest = doc.FirstChildElement("obj")->FirstChildElement("dest");
 
 	// Make sure we have a clean buff element.
 	auto* buffElement = dest->FirstChildElement("buff");
 
 	if (buffElement == nullptr) {
-		buffElement = doc->NewElement("buff");
+		buffElement = doc.NewElement("buff");
 
 		dest->LinkEndChild(buffElement);
 	} else {
@@ -402,7 +402,7 @@ void BuffComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 	}
 
 	for (const auto& [id, buff] : m_Buffs) {
-		auto* buffEntry = doc->NewElement("b");
+		auto* buffEntry = doc.NewElement("b");
 		// TODO: change this if to if (buff.cancelOnZone || buff.cancelOnLogout) handling at some point.  No current way to differentiate between zone transfer and logout.
 		if (buff.cancelOnZone) continue;
 
@@ -450,7 +450,7 @@ const std::vector<BuffParameter>& BuffComponent::GetBuffParameters(int32_t buffI
 		param.value = result.getFloatField("NumberValue");
 		param.effectId = result.getIntField("EffectID");
 
-		if (!result.fieldIsNull(3)) {
+		if (!result.fieldIsNull("StringValue")) {
 			std::istringstream stream(result.getStringField("StringValue"));
 			std::string token;
 

dGame/dComponents/BuffComponent.h

@@ -57,9 +57,9 @@ public:
 
 	Entity* GetParent() const;
 
-	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
+	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
 
-	void UpdateXml(tinyxml2::XMLDocument* doc) override;
+	void UpdateXml(tinyxml2::XMLDocument& doc) override;
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 

dGame/dComponents/CharacterComponent.cpp

@@ -186,9 +186,9 @@ void CharacterComponent::SetGMLevel(eGameMasterLevel gmlevel) {
 	m_GMLevel = gmlevel;
 }
 
-void CharacterComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
+void CharacterComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 
-	tinyxml2::XMLElement* character = doc->FirstChildElement("obj")->FirstChildElement("char");
+	auto* character = doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (!character) {
 		LOG("Failed to find char tag while loading XML!");
 		return;
@@ -299,8 +299,8 @@ void CharacterComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 	}
 }
 
-void CharacterComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
-	tinyxml2::XMLElement* minifig = doc->FirstChildElement("obj")->FirstChildElement("mf");
+void CharacterComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
+	tinyxml2::XMLElement* minifig = doc.FirstChildElement("obj")->FirstChildElement("mf");
 	if (!minifig) {
 		LOG("Failed to find mf tag while updating XML!");
 		return;
@@ -320,7 +320,7 @@ void CharacterComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 
 	// done with minifig
 
-	tinyxml2::XMLElement* character = doc->FirstChildElement("obj")->FirstChildElement("char");
+	tinyxml2::XMLElement* character = doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (!character) {
 		LOG("Failed to find char tag while updating XML!");
 		return;
@@ -338,11 +338,11 @@ void CharacterComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 
 	// Set the zone statistics of the form <zs><s/> ... <s/></zs>
 	auto zoneStatistics = character->FirstChildElement("zs");
-	if (!zoneStatistics) zoneStatistics = doc->NewElement("zs");
+	if (!zoneStatistics) zoneStatistics = doc.NewElement("zs");
 	zoneStatistics->DeleteChildren();
 
 	for (auto pair : m_ZoneStatistics) {
-		auto zoneStatistic = doc->NewElement("s");
+		auto zoneStatistic = doc.NewElement("s");
 
 		zoneStatistic->SetAttribute("map", pair.first);
 		zoneStatistic->SetAttribute("ac", pair.second.m_AchievementsCollected);

dGame/dComponents/CharacterComponent.h

@@ -70,8 +70,8 @@ public:
 	CharacterComponent(Entity* parent, Character* character, const SystemAddress& systemAddress);
 	~CharacterComponent() override;
 
-	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
-	void UpdateXml(tinyxml2::XMLDocument* doc) override;
+	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
+	void UpdateXml(tinyxml2::XMLDocument& doc) override;
 
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 

dGame/dComponents/Component.cpp

@@ -21,11 +21,11 @@ void Component::OnUse(Entity* originator) {
 
 }
 
-void Component::UpdateXml(tinyxml2::XMLDocument* doc) {
+void Component::UpdateXml(tinyxml2::XMLDocument& doc) {
 
 }
 
-void Component::LoadFromXml(tinyxml2::XMLDocument* doc) {
+void Component::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 
 }
 

dGame/dComponents/Component.h

@@ -34,13 +34,13 @@ public:
 	 * Save data from this componennt to character XML
 	 * @param doc the document to write data to
 	 */
-	virtual void UpdateXml(tinyxml2::XMLDocument* doc);
+	virtual void UpdateXml(tinyxml2::XMLDocument& doc);
 
 	/**
 	 * Load base data for this component from character XML
 	 * @param doc the document to read data from
 	 */
-	virtual void LoadFromXml(tinyxml2::XMLDocument* doc);
+	virtual void LoadFromXml(const tinyxml2::XMLDocument& doc);
 
 	virtual void Serialize(RakNet::BitStream& outBitStream, bool isConstruction);
 

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -158,8 +158,8 @@ void ControllablePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bo
 	}
 }
 
-void ControllablePhysicsComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
-	tinyxml2::XMLElement* character = doc->FirstChildElement("obj")->FirstChildElement("char");
+void ControllablePhysicsComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
+	auto* character = doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (!character) {
 		LOG("Failed to find char tag!");
 		return;
@@ -178,8 +178,8 @@ void ControllablePhysicsComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 	m_DirtyPosition = true;
 }
 
-void ControllablePhysicsComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
-	tinyxml2::XMLElement* character = doc->FirstChildElement("obj")->FirstChildElement("char");
+void ControllablePhysicsComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
+	tinyxml2::XMLElement* character = doc.FirstChildElement("obj")->FirstChildElement("char");
 	if (!character) {
 		LOG("Failed to find char tag while updating XML!");
 		return;

dGame/dComponents/ControllablePhysicsComponent.h

@@ -28,8 +28,8 @@ public:
 
 	void Update(float deltaTime) override;
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
-	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
-	void UpdateXml(tinyxml2::XMLDocument* doc) override;
+	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
+	void UpdateXml(tinyxml2::XMLDocument& doc) override;
 
 	/**
 	 * Sets the position of this entity, also ensures this update is serialized next tick.

dGame/dComponents/DestroyableComponent.cpp

@@ -185,8 +185,8 @@ void DestroyableComponent::Update(float deltaTime) {
 	m_DamageCooldownTimer -= deltaTime;
 }
 
-void DestroyableComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
-	tinyxml2::XMLElement* dest = doc->FirstChildElement("obj")->FirstChildElement("dest");
+void DestroyableComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
+	auto* dest = doc.FirstChildElement("obj")->FirstChildElement("dest");
 	if (!dest) {
 		LOG("Failed to find dest tag!");
 		return;
@@ -207,8 +207,8 @@ void DestroyableComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 	m_DirtyHealth = true;
 }
 
-void DestroyableComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
-	tinyxml2::XMLElement* dest = doc->FirstChildElement("obj")->FirstChildElement("dest");
+void DestroyableComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
+	tinyxml2::XMLElement* dest = doc.FirstChildElement("obj")->FirstChildElement("dest");
 	if (!dest) {
 		LOG("Failed to find dest tag!");
 		return;
@@ -389,9 +389,9 @@ void DestroyableComponent::AddFaction(const int32_t factionID, const bool ignore
 
 	if (result.eof()) return;
 
-	if (result.fieldIsNull(0)) return;
+	if (result.fieldIsNull("enemyList")) return;
 
-	const auto* list_string = result.getStringField(0);
+	const auto* list_string = result.getStringField("enemyList");
 
 	std::stringstream ss(list_string);
 	std::string token;

dGame/dComponents/DestroyableComponent.h

@@ -26,8 +26,8 @@ public:
 
 	void Update(float deltaTime) override;
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
-	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
-	void UpdateXml(tinyxml2::XMLDocument* doc) override;
+	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
+	void UpdateXml(tinyxml2::XMLDocument& doc) override;
 
 	/**
 	 * Initializes the component using a different LOT

dGame/dComponents/InventoryComponent.cpp

@@ -37,8 +37,11 @@
 #include "CDScriptComponentTable.h"
 #include "CDObjectSkillsTable.h"
 #include "CDSkillBehaviorTable.h"
+#include "StringifiedEnum.h"
 
-InventoryComponent::InventoryComponent(Entity* parent, tinyxml2::XMLDocument* document) : Component(parent) {
+#include <ranges>
+
+InventoryComponent::InventoryComponent(Entity* parent) : Component(parent) {
 	this->m_Dirty = true;
 	this->m_Equipped = {};
 	this->m_Pushed = {};
@@ -48,7 +51,8 @@ InventoryComponent::InventoryComponent(Entity* parent, tinyxml2::XMLDocument* do
 	const auto lot = parent->GetLOT();
 
 	if (lot == 1) {
-		LoadXml(document);
+		auto* character = m_Parent->GetCharacter();
+		if (character) LoadXml(character->GetXMLDoc());
 
 		CheckProxyIntegrity();
 
@@ -472,10 +476,10 @@ bool InventoryComponent::HasSpaceForLoot(const std::unordered_map<LOT, int32_t>&
 	return true;
 }
 
-void InventoryComponent::LoadXml(tinyxml2::XMLDocument* document) {
+void InventoryComponent::LoadXml(const tinyxml2::XMLDocument& document) {
 	LoadPetXml(document);
 
-	auto* inventoryElement = document->FirstChildElement("obj")->FirstChildElement("inv");
+	auto* inventoryElement = document.FirstChildElement("obj")->FirstChildElement("inv");
 
 	if (inventoryElement == nullptr) {
 		LOG("Failed to find 'inv' xml element!");
@@ -491,6 +495,11 @@ void InventoryComponent::LoadXml(tinyxml2::XMLDocument* document) {
 		return;
 	}
 
+	auto* const groups = inventoryElement->FirstChildElement("grps");
+	if (groups) {
+		LoadGroupXml(*groups);
+	}
+
 	m_Consumable = inventoryElement->IntAttribute("csl", LOT_NULL);
 
 	auto* bag = bags->FirstChildElement();
@@ -557,19 +566,9 @@ void InventoryComponent::LoadXml(tinyxml2::XMLDocument* document) {
 			itemElement->QueryAttribute("parent", &parent);
 			// End custom xml
 
-			std::vector<LDFBaseData*> config;
+			auto* item = new Item(id, lot, inventory, slot, count, bound, {}, parent, subKey);
 
-			auto* extraInfo = itemElement->FirstChildElement("x");
-
-			if (extraInfo) {
-				std::string modInfo = extraInfo->Attribute("ma");
-
-				LDFBaseData* moduleAssembly = new LDFData<std::u16string>(u"assemblyPartLOTs", GeneralUtils::ASCIIToUTF16(modInfo.substr(2, modInfo.size() - 1)));
-
-				config.push_back(moduleAssembly);
-			}
-
-			const auto* item = new Item(id, lot, inventory, slot, count, bound, config, parent, subKey);
+			item->LoadConfigXml(*itemElement);
 
 			if (equipped) {
 				const auto info = Inventory::FindItemComponent(lot);
@@ -594,10 +593,10 @@ void InventoryComponent::LoadXml(tinyxml2::XMLDocument* document) {
 	}
 }
 
-void InventoryComponent::UpdateXml(tinyxml2::XMLDocument* document) {
+void InventoryComponent::UpdateXml(tinyxml2::XMLDocument& document) {
 	UpdatePetXml(document);
 
-	auto* inventoryElement = document->FirstChildElement("obj")->FirstChildElement("inv");
+	auto* inventoryElement = document.FirstChildElement("obj")->FirstChildElement("inv");
 
 	if (inventoryElement == nullptr) {
 		LOG("Failed to find 'inv' xml element!");
@@ -631,7 +630,7 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument* document) {
 	bags->DeleteChildren();
 
 	for (const auto* inventory : inventoriesToSave) {
-		auto* bag = document->NewElement("b");
+		auto* bag = document.NewElement("b");
 
 		bag->SetAttribute("t", inventory->GetType());
 		bag->SetAttribute("m", static_cast<unsigned int>(inventory->GetSize()));
@@ -639,6 +638,15 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument* document) {
 		bags->LinkEndChild(bag);
 	}
 
+	auto* groups = inventoryElement->FirstChildElement("grps");
+	if (groups) {
+		groups->DeleteChildren();
+	} else {
+		groups = inventoryElement->InsertNewChildElement("grps");
+	}
+
+	UpdateGroupXml(*groups);
+
 	auto* items = inventoryElement->FirstChildElement("items");
 
 	if (items == nullptr) {
@@ -654,14 +662,14 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument* document) {
 			continue;
 		}
 
-		auto* bagElement = document->NewElement("in");
+		auto* bagElement = document.NewElement("in");
 
 		bagElement->SetAttribute("t", inventory->GetType());
 
 		for (const auto& pair : inventory->GetItems()) {
 			auto* item = pair.second;
 
-			auto* itemElement = document->NewElement("i");
+			auto* itemElement = document.NewElement("i");
 
 			itemElement->SetAttribute("l", item->GetLot());
 			itemElement->SetAttribute("id", item->GetId());
@@ -675,17 +683,7 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument* document) {
 			itemElement->SetAttribute("parent", item->GetParent());
 			// End custom xml
 
-			for (auto* data : item->GetConfig()) {
-				if (data->GetKey() != u"assemblyPartLOTs") {
-					continue;
-				}
-
-				auto* extraInfo = document->NewElement("x");
-
-				extraInfo->SetAttribute("ma", data->GetString(false).c_str());
-
-				itemElement->LinkEndChild(extraInfo);
-			}
+			item->SaveConfigXml(*itemElement);
 
 			bagElement->LinkEndChild(itemElement);
 		}
@@ -894,8 +892,6 @@ void InventoryComponent::UnEquipItem(Item* item) {
 
 	RemoveSlot(item->GetInfo().equipLocation);
 
-	PurgeProxies(item);
-
 	UnequipScripts(item);
 
 	Game::entityManager->SerializeEntity(m_Parent);
@@ -905,6 +901,8 @@ void InventoryComponent::UnEquipItem(Item* item) {
 		PropertyManagementComponent::Instance()->GetParent()->OnZonePropertyModelRemovedWhileEquipped(m_Parent);
 		Game::zoneManager->GetZoneControlObject()->OnZonePropertyModelRemovedWhileEquipped(m_Parent);
 	}
+
+	PurgeProxies(item);
 }
 
 
@@ -1093,7 +1091,7 @@ void InventoryComponent::CheckItemSet(const LOT lot) {
 	auto result = query.execQuery();
 
 	while (!result.eof()) {
-		const auto id = result.getIntField(0);
+		const auto id = result.getIntField("setID");
 
 		bool found = false;
 
@@ -1524,10 +1522,10 @@ void InventoryComponent::PurgeProxies(Item* item) {
 	const auto root = item->GetParent();
 
 	if (root != LWOOBJID_EMPTY) {
-		item = FindItemById(root);
+		Item* itemRoot = FindItemById(root);
 
-		if (item != nullptr) {
-			UnEquipItem(item);
+		if (itemRoot != nullptr) {
+			UnEquipItem(itemRoot);
 		}
 
 		return;
@@ -1542,8 +1540,8 @@ void InventoryComponent::PurgeProxies(Item* item) {
 	}
 }
 
-void InventoryComponent::LoadPetXml(tinyxml2::XMLDocument* document) {
-	auto* petInventoryElement = document->FirstChildElement("obj")->FirstChildElement("pet");
+void InventoryComponent::LoadPetXml(const tinyxml2::XMLDocument& document) {
+	auto* petInventoryElement = document.FirstChildElement("obj")->FirstChildElement("pet");
 
 	if (petInventoryElement == nullptr) {
 		m_Pets.clear();
@@ -1574,19 +1572,19 @@ void InventoryComponent::LoadPetXml(tinyxml2::XMLDocument* document) {
 	}
 }
 
-void InventoryComponent::UpdatePetXml(tinyxml2::XMLDocument* document) {
-	auto* petInventoryElement = document->FirstChildElement("obj")->FirstChildElement("pet");
+void InventoryComponent::UpdatePetXml(tinyxml2::XMLDocument& document) {
+	auto* petInventoryElement = document.FirstChildElement("obj")->FirstChildElement("pet");
 
 	if (petInventoryElement == nullptr) {
-		petInventoryElement = document->NewElement("pet");
+		petInventoryElement = document.NewElement("pet");
 
-		document->FirstChildElement("obj")->LinkEndChild(petInventoryElement);
+		document.FirstChildElement("obj")->LinkEndChild(petInventoryElement);
 	}
 
 	petInventoryElement->DeleteChildren();
 
 	for (const auto& pet : m_Pets) {
-		auto* petElement = document->NewElement("p");
+		auto* petElement = document.NewElement("p");
 
 		petElement->SetAttribute("id", pet.first);
 		petElement->SetAttribute("l", pet.second.lot);
@@ -1599,18 +1597,18 @@ void InventoryComponent::UpdatePetXml(tinyxml2::XMLDocument* document) {
 }
 
 
-bool InventoryComponent::SetSkill(int32_t slot, uint32_t skillId){
+bool InventoryComponent::SetSkill(int32_t slot, uint32_t skillId) {
 	BehaviorSlot behaviorSlot = BehaviorSlot::Invalid;
-	if (slot == 1 ) behaviorSlot = BehaviorSlot::Primary;
-	else if (slot == 2 ) behaviorSlot = BehaviorSlot::Offhand;
-	else if (slot == 3 ) behaviorSlot = BehaviorSlot::Neck;
-	else if (slot == 4 ) behaviorSlot = BehaviorSlot::Head;
-	else if (slot == 5 ) behaviorSlot = BehaviorSlot::Consumable;
+	if (slot == 1) behaviorSlot = BehaviorSlot::Primary;
+	else if (slot == 2) behaviorSlot = BehaviorSlot::Offhand;
+	else if (slot == 3) behaviorSlot = BehaviorSlot::Neck;
+	else if (slot == 4) behaviorSlot = BehaviorSlot::Head;
+	else if (slot == 5) behaviorSlot = BehaviorSlot::Consumable;
 	else return false;
 	return SetSkill(behaviorSlot, skillId);
 }
 
-bool InventoryComponent::SetSkill(BehaviorSlot slot, uint32_t skillId){
+bool InventoryComponent::SetSkill(BehaviorSlot slot, uint32_t skillId) {
 	if (skillId == 0) return false;
 	const auto index = m_Skills.find(slot);
 	if (index != m_Skills.end()) {
@@ -1623,3 +1621,109 @@ bool InventoryComponent::SetSkill(BehaviorSlot slot, uint32_t skillId){
 	return true;
 }
 
+void InventoryComponent::UpdateGroup(const GroupUpdate& groupUpdate) {
+	if (groupUpdate.groupId.empty()) return;
+
+	if (groupUpdate.inventory != eInventoryType::BRICKS && groupUpdate.inventory != eInventoryType::MODELS) {
+		LOG("Invalid inventory type for grouping %s", StringifiedEnum::ToString(groupUpdate.inventory).data());
+		return;
+	}
+
+	auto& groups = m_Groups[groupUpdate.inventory];
+	auto groupItr = std::ranges::find_if(groups, [&groupUpdate](const Group& group) {
+		return group.groupId == groupUpdate.groupId;
+		});
+
+	if (groupUpdate.command != GroupUpdateCommand::ADD && groupItr == groups.end()) {
+		LOG("Group %s not found in inventory %s. Cannot process command.", groupUpdate.groupId.c_str(), StringifiedEnum::ToString(groupUpdate.inventory).data());
+		return;
+	}
+
+	if (groupUpdate.command == GroupUpdateCommand::ADD && groups.size() >= MaximumGroupCount) {
+		LOG("Cannot add group to inventory %s. Maximum group count reached.", StringifiedEnum::ToString(groupUpdate.inventory).data());
+		return;
+	}
+
+	switch (groupUpdate.command) {
+	case GroupUpdateCommand::ADD: {
+		auto& group = groups.emplace_back();
+		group.groupId = groupUpdate.groupId;
+		group.groupName = groupUpdate.groupName;
+		break;
+	}
+	case GroupUpdateCommand::ADD_LOT: {
+		groupItr->lots.insert(groupUpdate.lot);
+		break;
+	}
+	case GroupUpdateCommand::REMOVE: {
+		groups.erase(groupItr);
+		break;
+	}
+	case GroupUpdateCommand::REMOVE_LOT: {
+		groupItr->lots.erase(groupUpdate.lot);
+		break;
+	}
+	case GroupUpdateCommand::MODIFY: {
+		groupItr->groupName = groupUpdate.groupName;
+		break;
+	}
+	default: {
+		LOG("Invalid group update command %i", groupUpdate.command);
+		break;
+	}
+	}
+}
+
+void InventoryComponent::UpdateGroupXml(tinyxml2::XMLElement& groups) const {
+	for (const auto& [inventory, groupsData] : m_Groups) {
+		for (const auto& group : groupsData) {
+			auto* const groupElement = groups.InsertNewChildElement("grp");
+
+			groupElement->SetAttribute("id", group.groupId.c_str());
+			groupElement->SetAttribute("n", group.groupName.c_str());
+			groupElement->SetAttribute("t", static_cast<uint32_t>(inventory));
+			groupElement->SetAttribute("u", 0);
+			std::ostringstream lots;
+			bool first = true;
+			for (const auto lot : group.lots) {
+				if (!first) lots << ' ';
+				first = false;
+
+				lots << lot;
+			}
+			groupElement->SetAttribute("l", lots.str().c_str());
+		}
+	}
+}
+
+void InventoryComponent::LoadGroupXml(const tinyxml2::XMLElement& groups) {
+	auto* groupElement = groups.FirstChildElement("grp");
+
+	while (groupElement) {
+		const char* groupId = nullptr;
+		const char* groupName = nullptr;
+		const char* lots = nullptr;
+		uint32_t inventory = eInventoryType::INVALID;
+
+		groupElement->QueryStringAttribute("id", &groupId);
+		groupElement->QueryStringAttribute("n", &groupName);
+		groupElement->QueryStringAttribute("l", &lots);
+		groupElement->QueryAttribute("t", &inventory);
+
+		if (!groupId || !groupName || !lots) {
+			LOG("Failed to load group from xml id %i name %i lots %i",
+				groupId == nullptr, groupName == nullptr, lots == nullptr);
+		} else {
+			auto& group = m_Groups[static_cast<eInventoryType>(inventory)].emplace_back();
+			group.groupId = groupId;
+			group.groupName = groupName;
+
+			for (const auto& lotStr : GeneralUtils::SplitString(lots, ' ')) {
+				auto lot = GeneralUtils::TryParse<LOT>(lotStr);
+				if (lot) group.lots.insert(*lot);
+			}
+		}
+
+		groupElement = groupElement->NextSiblingElement("grp");
+	}
+}

dGame/dComponents/InventoryComponent.h

@@ -37,13 +37,42 @@ enum class eItemType : int32_t;
  */
 class InventoryComponent final : public Component {
 public:
+	struct Group {
+		// Generated ID for the group. The ID is sent by the client and has the format user_group + Math.random() * UINT_MAX.
+		std::string groupId;
+		// Custom name assigned by the user.
+		std::string groupName;
+		// All the lots the user has in the group.
+		std::set<LOT> lots;
+	};
+
+	enum class GroupUpdateCommand {
+		ADD,
+		ADD_LOT,
+		MODIFY,
+		REMOVE,
+		REMOVE_LOT,
+	};
+
+	// Based on the command, certain fields will be used or not used.
+	// for example, ADD_LOT wont use groupName, MODIFY wont use lots, etc.
+	struct GroupUpdate {
+		std::string groupId;
+		std::string groupName;
+		LOT lot;
+		eInventoryType inventory;
+		GroupUpdateCommand command;
+	};
+
+	static constexpr uint32_t MaximumGroupCount = 50;
+
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::INVENTORY;
-	explicit InventoryComponent(Entity* parent, tinyxml2::XMLDocument* document = nullptr);
+	InventoryComponent(Entity* parent);
 
 	void Update(float deltaTime) override;
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
-	void LoadXml(tinyxml2::XMLDocument* document);
-	void UpdateXml(tinyxml2::XMLDocument* document) override;
+	void LoadXml(const tinyxml2::XMLDocument& document);
+	void UpdateXml(tinyxml2::XMLDocument& document) override;
 
 	/**
 	 * Returns an inventory of the specified type, if it exists
@@ -367,14 +396,23 @@ public:
 	 */
 	void UnequipScripts(Item* unequippedItem);
 
-	std::map<BehaviorSlot, uint32_t> GetSkills(){ return m_Skills; };
+	std::map<BehaviorSlot, uint32_t> GetSkills() { return m_Skills; };
 
 	bool SetSkill(int slot, uint32_t skillId);
 	bool SetSkill(BehaviorSlot slot, uint32_t skillId);
 
+	void UpdateGroup(const GroupUpdate& groupUpdate);
+	void RemoveGroup(const std::string& groupId);
+
 	~InventoryComponent() override;
 
 private:
+	/**
+	 * The key is the inventory the group belongs to, the value maps' key is the id for the group.
+	 * This is only used for bricks and model inventories.
+	 */
+	std::map<eInventoryType, std::vector<Group>> m_Groups{ { eInventoryType::BRICKS, {} }, { eInventoryType::MODELS, {} } };
+
 	/**
 	 * All the inventory this entity possesses
 	 */
@@ -470,13 +508,16 @@ private:
 	 * Saves all the pet information stored in inventory items to the database
 	 * @param document the xml doc to save to
 	 */
-	void LoadPetXml(tinyxml2::XMLDocument* document);
+	void LoadPetXml(const tinyxml2::XMLDocument& document);
 
 	/**
 	 * Loads all the pet information from an xml doc into items
 	 * @param document the xml doc to load from
 	 */
-	void UpdatePetXml(tinyxml2::XMLDocument* document);
+	void UpdatePetXml(tinyxml2::XMLDocument& document);
+
+	void LoadGroupXml(const tinyxml2::XMLElement& groups);
+	void UpdateGroupXml(tinyxml2::XMLElement& groups) const;
 };
 
 #endif

dGame/dComponents/LevelProgressionComponent.cpp

@@ -13,8 +13,8 @@ LevelProgressionComponent::LevelProgressionComponent(Entity* parent) : Component
 	m_CharacterVersion = eCharacterVersion::LIVE;
 }
 
-void LevelProgressionComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
-	tinyxml2::XMLElement* level = doc->FirstChildElement("obj")->FirstChildElement("lvl");
+void LevelProgressionComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
+	tinyxml2::XMLElement* level = doc.FirstChildElement("obj")->FirstChildElement("lvl");
 	if (!level) {
 		LOG("Failed to find lvl tag while updating XML!");
 		return;
@@ -24,8 +24,8 @@ void LevelProgressionComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 	level->SetAttribute("cv", static_cast<uint32_t>(m_CharacterVersion));
 }
 
-void LevelProgressionComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
-	tinyxml2::XMLElement* level = doc->FirstChildElement("obj")->FirstChildElement("lvl");
+void LevelProgressionComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
+	auto* level = doc.FirstChildElement("obj")->FirstChildElement("lvl");
 	if (!level) {
 		LOG("Failed to find lvl tag while loading XML!");
 		return;

dGame/dComponents/LevelProgressionComponent.h

@@ -27,13 +27,13 @@ public:
 	 * Save data from this componennt to character XML
 	 * @param doc the document to write data to
 	 */
-	void UpdateXml(tinyxml2::XMLDocument* doc) override;
+	void UpdateXml(tinyxml2::XMLDocument& doc) override;
 
 	/**
 	 * Load base data for this component from character XML
 	 * @param doc the document to read data from
 	 */
-	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
+	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
 
 	/**
 	 * Gets the current level of the entity

dGame/dComponents/MissionComponent.cpp

@@ -466,8 +466,8 @@ bool MissionComponent::RequiresItem(const LOT lot) {
 		return false;
 	}
 
-	if (!result.fieldIsNull(0)) {
-		const auto type = std::string(result.getStringField(0));
+	if (!result.fieldIsNull("type")) {
+		const auto type = std::string(result.getStringField("type"));
 
 		result.finalize();
 
@@ -504,10 +504,8 @@ bool MissionComponent::RequiresItem(const LOT lot) {
 }
 
 
-void MissionComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
-	if (doc == nullptr) return;
-
-	auto* mis = doc->FirstChildElement("obj")->FirstChildElement("mis");
+void MissionComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
+	auto* mis = doc.FirstChildElement("obj")->FirstChildElement("mis");
 
 	if (mis == nullptr) return;
 
@@ -523,7 +521,7 @@ void MissionComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 
 		auto* mission = new Mission(this, missionId);
 
-		mission->LoadFromXml(doneM);
+		mission->LoadFromXml(*doneM);
 
 		doneM = doneM->NextSiblingElement();
 
@@ -540,7 +538,7 @@ void MissionComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 
 		auto* mission = new Mission(this, missionId);
 
-		mission->LoadFromXml(currentM);
+		mission->LoadFromXml(*currentM);
 
 		if (currentM->QueryAttribute("o", &missionOrder) == tinyxml2::XML_SUCCESS && mission->IsMission()) {
 			mission->SetUniqueMissionOrderID(missionOrder);
@@ -554,25 +552,23 @@ void MissionComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 }
 
 
-void MissionComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
-	if (doc == nullptr) return;
-
+void MissionComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
 	auto shouldInsertMis = false;
 
-	auto* obj = doc->FirstChildElement("obj");
+	auto* obj = doc.FirstChildElement("obj");
 
 	auto* mis = obj->FirstChildElement("mis");
 
 	if (mis == nullptr) {
-		mis = doc->NewElement("mis");
+		mis = doc.NewElement("mis");
 
 		shouldInsertMis = true;
 	}
 
 	mis->DeleteChildren();
 
-	auto* done = doc->NewElement("done");
-	auto* cur = doc->NewElement("cur");
+	auto* done = doc.NewElement("done");
+	auto* cur = doc.NewElement("cur");
 
 	for (const auto& pair : m_Missions) {
 		auto* mission = pair.second;
@@ -580,10 +576,10 @@ void MissionComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 		if (mission) {
 			const auto complete = mission->IsComplete();
 
-			auto* m = doc->NewElement("m");
+			auto* m = doc.NewElement("m");
 
 			if (complete) {
-				mission->UpdateXml(m);
+				mission->UpdateXml(*m);
 
 				done->LinkEndChild(m);
 
@@ -591,7 +587,7 @@ void MissionComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 			}
 			if (mission->IsMission()) m->SetAttribute("o", mission->GetUniqueMissionOrderID());
 
-			mission->UpdateXml(m);
+			mission->UpdateXml(*m);
 
 			cur->LinkEndChild(m);
 		}

dGame/dComponents/MissionComponent.h

@@ -31,8 +31,8 @@ public:
 	explicit MissionComponent(Entity* parent);
 	~MissionComponent() override;
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate, unsigned int& flags);
-	void LoadFromXml(tinyxml2::XMLDocument* doc) override;
-	void UpdateXml(tinyxml2::XMLDocument* doc) override;
+	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
+	void UpdateXml(tinyxml2::XMLDocument& doc) override;
 
 	/**
 	 * Returns all the missions for this entity, mapped by mission ID

dGame/dComponents/ModelComponent.cpp

@@ -6,6 +6,9 @@
 
 #include "BehaviorStates.h"
 #include "ControlBehaviorMsgs.h"
+#include "tinyxml2.h"
+
+#include "Database.h"
 
 ModelComponent::ModelComponent(Entity* parent) : Component(parent) {
 	m_OriginalPosition = m_Parent->GetDefaultPosition();
@@ -14,6 +17,33 @@ ModelComponent::ModelComponent(Entity* parent) : Component(parent) {
 	m_userModelID = m_Parent->GetVarAs<LWOOBJID>(u"userModelID");
 }
 
+void ModelComponent::LoadBehaviors() {
+	auto behaviors = GeneralUtils::SplitString(m_Parent->GetVar<std::string>(u"userModelBehaviors"), ',');
+	for (const auto& behavior : behaviors) {
+		if (behavior.empty()) continue;
+
+		const auto behaviorId = GeneralUtils::TryParse<int32_t>(behavior);
+		if (!behaviorId.has_value() || behaviorId.value() == 0) continue;
+
+		LOG_DEBUG("Loading behavior %d", behaviorId.value());
+		auto& inserted = m_Behaviors.emplace_back();
+		inserted.SetBehaviorId(*behaviorId);
+		
+		const auto behaviorStr = Database::Get()->GetBehavior(behaviorId.value());
+		
+		tinyxml2::XMLDocument behaviorXml;
+		auto res = behaviorXml.Parse(behaviorStr.c_str(), behaviorStr.size());
+		LOG_DEBUG("Behavior %i %d: %s", res, behaviorId.value(), behaviorStr.c_str());
+
+		const auto* const behaviorRoot = behaviorXml.FirstChildElement("Behavior");
+		if (!behaviorRoot) {
+			LOG("Failed to load behavior %d due to missing behavior root", behaviorId.value());
+			continue;
+		}
+		inserted.Deserialize(*behaviorRoot);
+	}
+}
+
 void ModelComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	// ItemComponent Serialization.  Pets do not get this serialization.
 	if (!m_Parent->HasComponent(eReplicaComponentType::PET)) {
@@ -72,3 +102,23 @@ void ModelComponent::MoveToInventory(MoveToInventoryMessage& msg) {
 	m_Behaviors.erase(m_Behaviors.begin() + msg.GetBehaviorIndex());
 	// TODO move to the inventory
 }
+
+std::array<std::pair<int32_t, std::string>, 5> ModelComponent::GetBehaviorsForSave() const {
+	std::array<std::pair<int32_t, std::string>, 5> toReturn{};
+	for (auto i = 0; i < m_Behaviors.size(); i++) {
+		const auto& behavior = m_Behaviors.at(i);
+		if (behavior.GetBehaviorId() == -1) continue;
+		auto& [id, behaviorData] = toReturn[i];
+		id = behavior.GetBehaviorId();
+
+		tinyxml2::XMLDocument doc;
+		auto* root = doc.NewElement("Behavior");
+		behavior.Serialize(*root);
+		doc.InsertFirstChild(root);
+
+		tinyxml2::XMLPrinter printer(0, true, 0);
+		doc.Print(&printer);
+		behaviorData = printer.CStr();
+	}
+	return toReturn;
+}

dGame/dComponents/ModelComponent.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <map>
 
 #include "dCommonVars.h"
@@ -28,6 +29,8 @@ public:
 
 	ModelComponent(Entity* parent);
 
+	void LoadBehaviors();
+
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**
@@ -109,6 +112,8 @@ public:
 	
 	void VerifyBehaviors();
 
+	std::array<std::pair<int32_t, std::string>, 5> GetBehaviorsForSave() const;
+
 private:
 	/**
 	 * The behaviors of the model

dGame/dComponents/PetComponent.cpp

@@ -2,6 +2,7 @@
 #include "GameMessages.h"
 #include "BrickDatabase.h"
 #include "CDClientDatabase.h"
+#include "CDTamingBuildPuzzleTable.h"
 #include "ChatPackets.h"
 #include "EntityManager.h"
 #include "Character.h"
@@ -31,8 +32,9 @@
 #include "eGameMasterLevel.h"
 #include "eMissionState.h"
 #include "dNavMesh.h"
+#include "eGameActivity.h"
+#include "eStateChangeType.h"
 
-std::unordered_map<LOT, PetComponent::PetPuzzleData> PetComponent::buildCache{};
 std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::currentActivities{};
 std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::activePets{};
 
@@ -40,7 +42,7 @@ std::unordered_map<LWOOBJID, LWOOBJID> PetComponent::activePets{};
  * Maps all the pet lots to a flag indicating that the player has caught it. All basic pets have been guessed by ObjID
  * while the faction ones could be checked using their respective missions.
  */
-std::map<LOT, int32_t> PetComponent::petFlags = {
+const std::map<LOT, int32_t> PetComponent::petFlags{
 		{ 3050, 801 },  // Elephant
 		{ 3054, 803 },  // Cat
 		{ 3195, 806 },  // Triceratops
@@ -87,7 +89,6 @@ PetComponent::PetComponent(Entity* parentEntity, uint32_t componentId) : Compone
 	m_StartPosition = NiPoint3Constant::ZERO;
 	m_MovementAI = nullptr;
 	m_TresureTime = 0;
-	m_Preconditions = nullptr;
 
 	std::string checkPreconditions = GeneralUtils::UTF16ToWTF8(parentEntity->GetVar<std::u16string>(u"CheckPrecondition"));
 
@@ -152,96 +153,53 @@ void PetComponent::OnUse(Entity* originator) {
 		m_Tamer = LWOOBJID_EMPTY;
 	}
 
-	auto* inventoryComponent = originator->GetComponent<InventoryComponent>();
-
+	auto* const inventoryComponent = originator->GetComponent<InventoryComponent>();
 	if (inventoryComponent == nullptr) {
 		return;
 	}
 
-	if (m_Preconditions != nullptr && !m_Preconditions->Check(originator, true)) {
+	if (m_Preconditions.has_value() && !m_Preconditions->Check(originator, true)) {
 		return;
 	}
 
-	auto* movementAIComponent = m_Parent->GetComponent<MovementAIComponent>();
-
+	auto* const movementAIComponent = m_Parent->GetComponent<MovementAIComponent>();
 	if (movementAIComponent != nullptr) {
 		movementAIComponent->Stop();
 	}
 
 	inventoryComponent->DespawnPet();
 
-	const auto& cached = buildCache.find(m_Parent->GetLOT());
-	int32_t imaginationCost = 0;
-
-	std::string buildFile;
-
-	if (cached == buildCache.end()) {
-		auto query = CDClientDatabase::CreatePreppedStmt(
-			"SELECT ValidPiecesLXF, PuzzleModelLot, Timelimit, NumValidPieces, imagCostPerBuild FROM TamingBuildPuzzles WHERE NPCLot = ?;");
-		query.bind(1, static_cast<int>(m_Parent->GetLOT()));
-
-		auto result = query.execQuery();
-
-		if (result.eof()) {
-			ChatPackets::SendSystemMessage(originator->GetSystemAddress(), u"Failed to find the puzzle minigame for this pet.");
-
-			return;
-		}
-
-		if (result.fieldIsNull(0)) {
-			result.finalize();
-
-			return;
-		}
-
-		buildFile = std::string(result.getStringField(0));
-
-		PetPuzzleData data;
-		data.buildFile = buildFile;
-		data.puzzleModelLot = result.getIntField(1);
-		data.timeLimit = result.getFloatField(2);
-		data.numValidPieces = result.getIntField(3);
-		data.imaginationCost = result.getIntField(4);
-		if (data.timeLimit <= 0) data.timeLimit = 60;
-		imaginationCost = data.imaginationCost;
-
-		buildCache[m_Parent->GetLOT()] = data;
-
-		result.finalize();
-	} else {
-		buildFile = cached->second.buildFile;
-		imaginationCost = cached->second.imaginationCost;
+	const auto* const entry = CDClientManager::GetTable<CDTamingBuildPuzzleTable>()->GetByLOT(m_Parent->GetLOT());
+	if (!entry) {
+		ChatPackets::SendSystemMessage(originator->GetSystemAddress(), u"Failed to find the puzzle minigame for this pet.");
+		return;
 	}
 
-	auto* destroyableComponent = originator->GetComponent<DestroyableComponent>();
-
+	const auto* const destroyableComponent = originator->GetComponent<DestroyableComponent>();
 	if (destroyableComponent == nullptr) {
 		return;
 	}
 
-	auto imagination = destroyableComponent->GetImagination();
-
-	if (imagination < imaginationCost) {
+	const auto imagination = destroyableComponent->GetImagination();
+	if (imagination < entry->imaginationCost) {
 		return;
 	}
 
-	const auto& bricks = BrickDatabase::GetBricks(buildFile);
-
+	const auto& bricks = BrickDatabase::GetBricks(entry->validPieces);
 	if (bricks.empty()) {
 		ChatPackets::SendSystemMessage(originator->GetSystemAddress(), u"Failed to load the puzzle minigame for this pet.");
-		LOG("Couldn't find %s for minigame!", buildFile.c_str());
+		LOG("Couldn't find %s for minigame!", entry->validPieces.c_str());
 
 		return;
 	}
 
-	auto petPosition = m_Parent->GetPosition();
+	const auto petPosition = m_Parent->GetPosition();
 
-	auto originatorPosition = originator->GetPosition();
+	const auto originatorPosition = originator->GetPosition();
 
 	m_Parent->SetRotation(NiQuaternion::LookAt(petPosition, originatorPosition));
 
 	float interactionDistance = m_Parent->GetVar<float>(u"interaction_distance");
-
 	if (interactionDistance <= 0) {
 		interactionDistance = 15;
 	}
@@ -254,24 +212,23 @@ void PetComponent::OnUse(Entity* originator) {
 	if (dpWorld::IsLoaded()) {
 		NiPoint3 attempt = petPosition + forward * interactionDistance;
 
-		float y = dpWorld::GetNavMesh()->GetHeightAtPoint(attempt);
+		NiPoint3 nearestPoint = dpWorld::GetNavMesh()->NearestPoint(attempt);
 
-		while (std::abs(y - petPosition.y) > 4 && interactionDistance > 10) {
+		while (std::abs(nearestPoint.y - petPosition.y) > 4 && interactionDistance > 10) {
 			const NiPoint3 forward = m_Parent->GetRotation().GetForwardVector();
 
 			attempt = originatorPosition + forward * interactionDistance;
 
-			y = dpWorld::GetNavMesh()->GetHeightAtPoint(attempt);
+			nearestPoint = dpWorld::GetNavMesh()->NearestPoint(attempt);
 
 			interactionDistance -= 0.5f;
 		}
 
-		position = attempt;
+		position = nearestPoint;
 	} else {
 		position = petPosition + forward * interactionDistance;
 	}
 
-
 	auto rotation = NiQuaternion::LookAt(position, petPosition);
 
 	GameMessages::SendNotifyPetTamingMinigame(
@@ -290,11 +247,11 @@ void PetComponent::OnUse(Entity* originator) {
 		m_Parent->GetObjectID(),
 		LWOOBJID_EMPTY,
 		originator->GetObjectID(),
-		true,
+		false,
 		ePetTamingNotifyType::BEGIN,
-		petPosition,
-		position,
-		rotation,
+		NiPoint3Constant::ZERO,
+		NiPoint3Constant::ZERO,
+		NiQuaternion(0.0f, 0.0f, 0.0f, 0.0f),
 		UNASSIGNED_SYSTEM_ADDRESS
 	);
 
@@ -302,11 +259,18 @@ void PetComponent::OnUse(Entity* originator) {
 
 	m_Tamer = originator->GetObjectID();
 	SetStatus(5);
+	Game::entityManager->SerializeEntity(m_Parent);
 
 	currentActivities.insert_or_assign(m_Tamer, m_Parent->GetObjectID());
 
 	// Notify the start of a pet taming minigame
 	m_Parent->GetScript()->OnNotifyPetTamingMinigame(m_Parent, originator, ePetTamingNotifyType::BEGIN);
+
+	auto* characterComponent = originator->GetComponent<CharacterComponent>();
+	if (characterComponent != nullptr) {
+		characterComponent->SetCurrentActivity(eGameActivity::PET_TAMING);
+		Game::entityManager->SerializeEntity(originator);
+	}
 }
 
 void PetComponent::Update(float deltaTime) {
@@ -477,9 +441,8 @@ void PetComponent::TryBuild(uint32_t numBricks, bool clientFailed) {
 		return;
 	}
 
-	const auto& cached = buildCache.find(m_Parent->GetLOT());
-
-	if (cached == buildCache.end()) return;
+	const auto* const entry = CDClientManager::GetTable<CDTamingBuildPuzzleTable>()->GetByLOT(m_Parent->GetLOT());
+	if (!entry) return;
 
 	auto* destroyableComponent = tamer->GetComponent<DestroyableComponent>();
 
@@ -487,14 +450,14 @@ void PetComponent::TryBuild(uint32_t numBricks, bool clientFailed) {
 
 	auto imagination = destroyableComponent->GetImagination();
 
-	imagination -= cached->second.imaginationCost;
+	imagination -= entry->imaginationCost;
 
 	destroyableComponent->SetImagination(imagination);
 
 	Game::entityManager->SerializeEntity(tamer);
 
 	if (clientFailed) {
-		if (imagination < cached->second.imaginationCost) {
+		if (imagination < entry->imaginationCost) {
 			ClientFailTamingMinigame();
 		}
 	} else {
@@ -517,17 +480,14 @@ void PetComponent::NotifyTamingBuildSuccess(NiPoint3 position) {
 		return;
 	}
 
-	const auto& cached = buildCache.find(m_Parent->GetLOT());
-
-	if (cached == buildCache.end()) {
-		return;
-	}
+	const auto* const entry = CDClientManager::GetTable<CDTamingBuildPuzzleTable>()->GetByLOT(m_Parent->GetLOT());
+	if (!entry) return;
 
 	GameMessages::SendPlayFXEffect(tamer, -1, u"petceleb", "", LWOOBJID_EMPTY, 1, 1, true);
 	RenderComponent::PlayAnimation(tamer, u"rebuild-celebrate");
 
 	EntityInfo info{};
-	info.lot = cached->second.puzzleModelLot;
+	info.lot = entry->puzzleModelLot;
 	info.pos = position;
 	info.rot = NiQuaternionConstant::IDENTITY;
 	info.spawnerID = tamer->GetObjectID();
@@ -675,6 +635,11 @@ void PetComponent::RequestSetPetName(std::u16string name) {
 		UNASSIGNED_SYSTEM_ADDRESS
 	);
 
+	auto* characterComponent = tamer->GetComponent<CharacterComponent>();
+	if (characterComponent != nullptr) {
+		characterComponent->SetCurrentActivity(eGameActivity::NONE);
+		Game::entityManager->SerializeEntity(tamer);
+	}
 	GameMessages::SendTerminateInteraction(m_Tamer, eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
 
 	auto* modelEntity = Game::entityManager->GetEntity(m_ModelId);
@@ -714,6 +679,11 @@ void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {
 		UNASSIGNED_SYSTEM_ADDRESS
 	);
 
+	auto* characterComponent = tamer->GetComponent<CharacterComponent>();
+	if (characterComponent != nullptr) {
+		characterComponent->SetCurrentActivity(eGameActivity::NONE);
+		Game::entityManager->SerializeEntity(tamer);
+	}
 	GameMessages::SendNotifyTamingModelLoadedOnServer(m_Tamer, tamer->GetSystemAddress());
 
 	GameMessages::SendTerminateInteraction(m_Tamer, eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
@@ -731,13 +701,10 @@ void PetComponent::ClientExitTamingMinigame(bool voluntaryExit) {
 }
 
 void PetComponent::StartTimer() {
-	const auto& cached = buildCache.find(m_Parent->GetLOT());
+	const auto* const entry = CDClientManager::GetTable<CDTamingBuildPuzzleTable>()->GetByLOT(m_Parent->GetLOT());
+	if (!entry) return;
 
-	if (cached == buildCache.end()) {
-		return;
-	}
-
-	m_Timer = cached->second.timeLimit;
+	m_Timer = entry->timeLimit;
 }
 
 void PetComponent::ClientFailTamingMinigame() {
@@ -763,6 +730,11 @@ void PetComponent::ClientFailTamingMinigame() {
 		UNASSIGNED_SYSTEM_ADDRESS
 	);
 
+	auto* characterComponent = tamer->GetComponent<CharacterComponent>();
+	if (characterComponent != nullptr) {
+		characterComponent->SetCurrentActivity(eGameActivity::NONE);
+		Game::entityManager->SerializeEntity(tamer);
+	}
 	GameMessages::SendNotifyTamingModelLoadedOnServer(m_Tamer, tamer->GetSystemAddress());
 
 	GameMessages::SendTerminateInteraction(m_Tamer, eTerminateType::FROM_INTERACTION, m_Parent->GetObjectID());
@@ -1086,6 +1058,6 @@ void PetComponent::LoadPetNameFromModeration() {
 	}
 }
 
-void PetComponent::SetPreconditions(std::string& preconditions) {
-	m_Preconditions = new PreconditionExpression(preconditions);
+void PetComponent::SetPreconditions(const std::string& preconditions) {
+	m_Preconditions = std::make_optional<PreconditionExpression>(preconditions);
 }

dGame/dComponents/PetComponent.h

@@ -165,7 +165,7 @@ public:
 	 * Sets preconditions for the pet that need  to be met before it can be tamed
 	 * @param conditions the preconditions to set
 	 */
-	void SetPreconditions(std::string& conditions);
+	void SetPreconditions(const std::string& conditions);
 
 	/**
 	 * Returns the entity that this component belongs to
@@ -250,15 +250,10 @@ private:
 	 */
 	static std::unordered_map<LWOOBJID, LWOOBJID> currentActivities;
 
-	/**
-	 * Cache of all the minigames and their information from the database
-	 */
-	static std::unordered_map<LOT, PetComponent::PetPuzzleData> buildCache;
-
 	/**
 	 * Flags that indicate that a player has tamed a pet, indexed by the LOT of the pet
 	 */
-	static std::map<LOT, int32_t> petFlags;
+	static const std::map<LOT, int32_t> petFlags;
 
 	/**
 	 * The ID of the component in the pet component table
@@ -349,7 +344,7 @@ private:
 	/**
 	 * Preconditions that need to be met before an entity can tame this pet
 	 */
-	PreconditionExpression* m_Preconditions;
+	std::optional<PreconditionExpression> m_Preconditions{};
 
 	/**
 	 * Pet information loaded from the CDClientDatabase

dGame/dComponents/PhantomPhysicsComponent.cpp

@@ -47,7 +47,7 @@ PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent) : PhysicsCompon
 	m_Direction = NiPoint3(); // * m_DirectionalMultiplier
 
 	if (m_Parent->GetVar<bool>(u"create_physics")) {
-		CreatePhysics();
+		m_dpEntity = CreatePhysicsLnv(m_Scale, ComponentType);
 	}
 
 	if (m_Parent->GetVar<bool>(u"respawnVol")) {
@@ -89,105 +89,9 @@ PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent) : PhysicsCompon
 		m_RespawnRot = m_Rotation;
 	}
 
-	/*
-	for (LDFBaseData* data : settings) {
-		if (data) {
-			if (data->GetKey() == u"create_physics") {
-				if (bool(std::stoi(data->GetValueAsString()))) {
-					CreatePhysics(settings);
-				}
-			}
-
-			if (data->GetKey() == u"respawnVol") {
-				if (bool(std::stoi(data->GetValueAsString()))) {
-					m_IsRespawnVolume = true;
-				}
-			}
-
-			if (m_IsRespawnVolume) {
-				if (data->GetKey() == u"rspPos") {
-					//Joy, we get to split strings!
-					std::stringstream test(data->GetValueAsString());
-					std::string segment;
-					std::vector<std::string> seglist;
-
-					while (std::getline(test, segment, '\x1f')) {
-						seglist.push_back(segment);
-					}
-
-					m_RespawnPos = NiPoint3(std::stof(seglist[0]), std::stof(seglist[1]), std::stof(seglist[2]));
-				}
-
-				if (data->GetKey() == u"rspRot") {
-					//Joy, we get to split strings!
-					std::stringstream test(data->GetValueAsString());
-					std::string segment;
-					std::vector<std::string> seglist;
-
-					while (std::getline(test, segment, '\x1f')) {
-						seglist.push_back(segment);
-					}
-
-					m_RespawnRot = NiQuaternion(std::stof(seglist[0]), std::stof(seglist[1]), std::stof(seglist[2]), std::stof(seglist[3]));
-				}
-			}
-
-			if (m_Parent->GetLOT() == 4945) // HF - RespawnPoints
-			{
-				m_IsRespawnVolume = true;
-				m_RespawnPos = m_Position;
-				m_RespawnRot = m_Rotation;
-			}
-		}
-	}
-	*/
-
-	if (!m_HasCreatedPhysics) {
-		CDComponentsRegistryTable* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
-		auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), eReplicaComponentType::PHANTOM_PHYSICS);
-
-		CDPhysicsComponentTable* physComp = CDClientManager::GetTable<CDPhysicsComponentTable>();
-
-		if (physComp == nullptr) return;
-
-		auto* info = physComp->GetByID(componentID);
-		if (info == nullptr || info->physicsAsset == "" || info->physicsAsset == "NO_PHYSICS") return;
-
-		//temp test
-		if (info->physicsAsset == "miscellaneous\\misc_phys_10x1x5.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 10.0f, 5.0f, 1.0f);
-		} else if (info->physicsAsset == "miscellaneous\\misc_phys_640x640.hkx") {
-			// TODO Fix physics simulation to do simulation at high velocities due to bullet through paper problem...
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 1638.4f, 13.521004f * 2.0f, 1638.4f);
-
-			// Move this down by 13.521004 units so it is still effectively at the same height as before
-			m_Position = m_Position - NiPoint3Constant::UNIT_Y * 13.521004f;
-		} else if (info->physicsAsset == "env\\trigger_wall_tall.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 10.0f, 25.0f, 1.0f);
-		} else if (info->physicsAsset == "env\\env_gen_placeholderphysics.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 20.0f, 20.0f, 20.0f);
-		} else if (info->physicsAsset == "env\\POI_trigger_wall.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 1.0f, 12.5f, 20.0f); // Not sure what the real size is
-		} else if (info->physicsAsset == "env\\NG_NinjaGo\\env_ng_gen_gate_chamber_puzzle_ceiling_tile_falling_phantom.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 18.0f, 5.0f, 15.0f);
-			m_Position += m_Rotation.GetForwardVector() * 7.5f;
-		} else if (info->physicsAsset == "env\\NG_NinjaGo\\ng_flamejet_brick_phantom.HKX") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 1.0f, 1.0f, 12.0f);
-			m_Position += m_Rotation.GetForwardVector() * 6.0f;
-		} else if (info->physicsAsset == "env\\Ring_Trigger.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 6.0f, 6.0f, 6.0f);
-		} else if (info->physicsAsset == "env\\vfx_propertyImaginationBall.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 4.5f);
-		} else if (info->physicsAsset == "env\\env_won_fv_gas-blocking-volume.hkx") {
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 390.496826f, 111.467964f, 600.821534f, true);
-			m_Position.y -= (111.467964f * m_Scale) / 2;
-		} else {
-			// LOG_DEBUG("This one is supposed to have %s", info->physicsAsset.c_str());
-
-			//add fallback cube:
-			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 2.0f, 2.0f, 2.0f);
-		}
-	
+	if (!m_dpEntity) {
+		m_dpEntity = CreatePhysicsEntity(ComponentType);
+		if (!m_dpEntity) return;
 		m_dpEntity->SetScale(m_Scale);
 		m_dpEntity->SetRotation(m_Rotation);
 		m_dpEntity->SetPosition(m_Position);
@@ -201,69 +105,6 @@ PhantomPhysicsComponent::~PhantomPhysicsComponent() {
 	}
 }
 
-void PhantomPhysicsComponent::CreatePhysics() {
-	unsigned char alpha;
-	unsigned char red;
-	unsigned char green;
-	unsigned char blue;
-	int type = -1;
-	float x = 0.0f;
-	float y = 0.0f;
-	float z = 0.0f;
-	float width = 0.0f; //aka "radius"
-	float height = 0.0f;
-
-	if (m_Parent->HasVar(u"primitiveModelType")) {
-		type = m_Parent->GetVar<int32_t>(u"primitiveModelType");
-		x = m_Parent->GetVar<float>(u"primitiveModelValueX");
-		y = m_Parent->GetVar<float>(u"primitiveModelValueY");
-		z = m_Parent->GetVar<float>(u"primitiveModelValueZ");
-	} else {
-		CDComponentsRegistryTable* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
-		auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), eReplicaComponentType::PHANTOM_PHYSICS);
-
-		CDPhysicsComponentTable* physComp = CDClientManager::GetTable<CDPhysicsComponentTable>();
-
-		if (physComp == nullptr) return;
-
-		auto info = physComp->GetByID(componentID);
-
-		if (info == nullptr) return;
-
-		type = info->pcShapeType;
-		width = info->playerRadius;
-		height = info->playerHeight;
-	}
-
-	switch (type) {
-	case 1: { //Make a new box shape
-		NiPoint3 boxSize(x, y, z);
-		if (x == 0.0f) {
-			//LU has some weird values, so I think it's best to scale them down a bit
-			if (height < 0.5f) height = 2.0f;
-			if (width < 0.5f) width = 2.0f;
-
-			//Scale them:
-			width = width * m_Scale;
-			height = height * m_Scale;
-
-			boxSize = NiPoint3(width, height, width);
-		}
-
-		m_dpEntity = new dpEntity(m_Parent->GetObjectID(), boxSize);
-		break;
-	}
-	}
-
-	if (!m_dpEntity) return;
-
-	m_dpEntity->SetPosition({ m_Position.x, m_Position.y - (height / 2), m_Position.z });
-
-	dpWorld::AddEntity(m_dpEntity);
-
-	m_HasCreatedPhysics = true;
-}
-
 void PhantomPhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	PhysicsComponent::Serialize(outBitStream, bIsInitialUpdate);
 
@@ -308,8 +149,9 @@ void ApplyCollisionEffect(const LWOOBJID& target, const ePhysicsEffectType effec
 			controllablePhysicsComponent->SetGravityScale(effectScale);
 			GameMessages::SendSetGravityScale(target, effectScale, targetEntity->GetSystemAddress());
 		}
+		break;
 	}
-	// The other types are not handled by the server
+
 	case ePhysicsEffectType::ATTRACT:
 	case ePhysicsEffectType::FRICTION:
 	case ePhysicsEffectType::PUSH:
@@ -317,20 +159,20 @@ void ApplyCollisionEffect(const LWOOBJID& target, const ePhysicsEffectType effec
 	default:
 		break;
 	}
+	// The other types are not handled by the server and are here to handle all cases of the enum.
 }
 
 void PhantomPhysicsComponent::Update(float deltaTime) {
 	if (!m_dpEntity) return;
 
 	//Process enter events
-	for (auto en : m_dpEntity->GetNewObjects()) {
-		if (!en) continue;
-		ApplyCollisionEffect(en->GetObjectID(), m_EffectType, m_DirectionalMultiplier);
-		m_Parent->OnCollisionPhantom(en->GetObjectID());
+	for (const auto id : m_dpEntity->GetNewObjects()) {
+		ApplyCollisionEffect(id, m_EffectType, m_DirectionalMultiplier);
+		m_Parent->OnCollisionPhantom(id);
 
 		//If we are a respawn volume, inform the client:
 		if (m_IsRespawnVolume) {
-			auto entity = Game::entityManager->GetEntity(en->GetObjectID());
+			auto* const entity = Game::entityManager->GetEntity(id);
 
 			if (entity) {
 				GameMessages::SendPlayerReachedRespawnCheckpoint(entity, m_RespawnPos, m_RespawnRot);
@@ -341,10 +183,9 @@ void PhantomPhysicsComponent::Update(float deltaTime) {
 	}
 
 	//Process exit events
-	for (auto en : m_dpEntity->GetRemovedObjects()) {
-		if (!en) continue;
-		ApplyCollisionEffect(en->GetObjectID(), m_EffectType, 1.0f);
-		m_Parent->OnCollisionLeavePhantom(en->GetObjectID());
+	for (const auto id : m_dpEntity->GetRemovedObjects()) {
+		ApplyCollisionEffect(id, m_EffectType, 1.0f);
+		m_Parent->OnCollisionLeavePhantom(id);
 	}
 }
 
@@ -358,24 +199,12 @@ void PhantomPhysicsComponent::SetDirection(const NiPoint3& pos) {
 	m_IsDirectional = true;
 }
 
-void PhantomPhysicsComponent::SpawnVertices() {
-	if (!m_dpEntity) return;
-
-	LOG("%llu", m_Parent->GetObjectID());
-	auto box = static_cast<dpShapeBox*>(m_dpEntity->GetShape());
-	for (auto vert : box->GetVertices()) {
-		LOG("%f, %f, %f", vert.x, vert.y, vert.z);
-
-		EntityInfo info;
-		info.lot = 33;
-		info.pos = vert;
-		info.spawner = nullptr;
-		info.spawnerID = m_Parent->GetObjectID();
-		info.spawnerNodeID = 0;
-
-		Entity* newEntity = Game::entityManager->CreateEntity(info, nullptr);
-		Game::entityManager->ConstructEntity(newEntity);
+void PhantomPhysicsComponent::SpawnVertices() const {
+	if (!m_dpEntity) {
+		LOG("No dpEntity to spawn vertices for %llu:%i", m_Parent->GetObjectID(), m_Parent->GetLOT());
+		return;
 	}
+	PhysicsComponent::SpawnVertices(m_dpEntity);
 }
 
 void PhantomPhysicsComponent::SetDirectionalMultiplier(float mul) {

dGame/dComponents/PhantomPhysicsComponent.h

@@ -18,6 +18,7 @@ class LDFBaseData;
 class Entity;
 class dpEntity;
 enum class ePhysicsEffectType : uint32_t ;
+enum class eReplicaComponentType : uint32_t;
 
 /**
  * Allows the creation of phantom physics for an entity: a physics object that is generally invisible but can be
@@ -34,11 +35,6 @@ public:
 	void Update(float deltaTime) override;
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
-	/**
-	 * Creates the physics shape for this entity based on LDF data
-	 */
-	void CreatePhysics();
-
 	/**
 	 * Sets the direction this physics object is pointed at
 	 * @param pos the direction to set
@@ -109,7 +105,7 @@ public:
 	/**
 	 * Spawns an object at each of the vertices for debugging purposes
 	 */
-	void SpawnVertices();
+	void SpawnVertices() const;
 
 	/**
 	 * Legacy stuff no clue what this does
@@ -166,11 +162,6 @@ private:
 	 */
 	dpEntity* m_dpEntity;
 
-	/**
-	 * Whether or not the physics object has been created yet
-	 */
-	bool m_HasCreatedPhysics = false;
-
 	/**
 	 * Whether or not this physics object represents an object that updates the respawn pos of an entity that crosses it
 	 */

dGame/dComponents/PhysicsComponent.cpp

@@ -1,5 +1,19 @@
 #include "PhysicsComponent.h"
 
+#include "eReplicaComponentType.h"
+#include "NiPoint3.h"
+#include "NiQuaternion.h"
+
+#include "CDComponentsRegistryTable.h"
+#include "CDPhysicsComponentTable.h"
+
+#include "dpEntity.h"
+#include "dpWorld.h"
+#include "dpShapeBox.h"
+#include "dpShapeSphere.h"
+
+#include "EntityInfo.h"
+
 PhysicsComponent::PhysicsComponent(Entity* parent) : Component(parent) {
 	m_Position = NiPoint3Constant::ZERO;
 	m_Rotation = NiQuaternionConstant::IDENTITY;
@@ -19,3 +33,190 @@ void PhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitia
 		if (!bIsInitialUpdate) m_DirtyPosition = false;
 	}
 }
+
+dpEntity* PhysicsComponent::CreatePhysicsEntity(eReplicaComponentType type) {
+	CDComponentsRegistryTable* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
+	auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), type);
+
+	CDPhysicsComponentTable* physComp = CDClientManager::GetTable<CDPhysicsComponentTable>();
+
+	if (physComp == nullptr) return nullptr;
+
+	auto* info = physComp->GetByID(componentID);
+	if (info == nullptr || info->physicsAsset == "" || info->physicsAsset == "NO_PHYSICS") return nullptr;
+
+	dpEntity* toReturn;
+	if (info->physicsAsset == "miscellaneous\\misc_phys_10x1x5.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 10.0f, 5.0f, 1.0f);
+	} else if (info->physicsAsset == "miscellaneous\\misc_phys_640x640.hkx") {
+		// TODO Fix physics simulation to do simulation at high velocities due to bullet through paper problem...
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 1638.4f, 13.521004f * 2.0f, 1638.4f);
+
+		// Move this down by 13.521004 units so it is still effectively at the same height as before
+		m_Position = m_Position - NiPoint3Constant::UNIT_Y * 13.521004f;
+	} else if (info->physicsAsset == "env\\trigger_wall_tall.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 10.0f, 25.0f, 1.0f);
+	} else if (info->physicsAsset == "env\\env_gen_placeholderphysics.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 20.0f, 20.0f, 20.0f);
+	} else if (info->physicsAsset == "env\\POI_trigger_wall.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 1.0f, 12.5f, 20.0f); // Not sure what the real size is
+	} else if (info->physicsAsset == "env\\NG_NinjaGo\\env_ng_gen_gate_chamber_puzzle_ceiling_tile_falling_phantom.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 18.0f, 5.0f, 15.0f);
+		m_Position += m_Rotation.GetForwardVector() * 7.5f;
+	} else if (info->physicsAsset == "env\\NG_NinjaGo\\ng_flamejet_brick_phantom.HKX") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 1.0f, 1.0f, 12.0f);
+		m_Position += m_Rotation.GetForwardVector() * 6.0f;
+	} else if (info->physicsAsset == "env\\Ring_Trigger.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 6.0f, 6.0f, 6.0f);
+	} else if (info->physicsAsset == "env\\vfx_propertyImaginationBall.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 4.5f);
+	} else if (info->physicsAsset == "env\\env_won_fv_gas-blocking-volume.hkx") {
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 390.496826f, 111.467964f, 600.821534f, true);
+		m_Position.y -= (111.467964f * m_Parent->GetDefaultScale()) / 2;
+	} else {
+		// LOG_DEBUG("This one is supposed to have %s", info->physicsAsset.c_str());
+
+		//add fallback cube:
+		toReturn = new dpEntity(m_Parent->GetObjectID(), 2.0f, 2.0f, 2.0f);
+	}
+	return toReturn;
+}
+
+dpEntity* PhysicsComponent::CreatePhysicsLnv(const float scale, const eReplicaComponentType type) const {
+	int pcShapeType = -1;
+	float x = 0.0f;
+	float y = 0.0f;
+	float z = 0.0f;
+	float width = 0.0f; //aka "radius"
+	float height = 0.0f;
+	dpEntity* toReturn = nullptr;
+
+	if (m_Parent->HasVar(u"primitiveModelType")) {
+		pcShapeType = m_Parent->GetVar<int32_t>(u"primitiveModelType");
+		x = m_Parent->GetVar<float>(u"primitiveModelValueX");
+		y = m_Parent->GetVar<float>(u"primitiveModelValueY");
+		z = m_Parent->GetVar<float>(u"primitiveModelValueZ");
+	} else {
+		CDComponentsRegistryTable* compRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
+		auto componentID = compRegistryTable->GetByIDAndType(m_Parent->GetLOT(), type);
+
+		CDPhysicsComponentTable* physComp = CDClientManager::GetTable<CDPhysicsComponentTable>();
+
+		if (physComp == nullptr) return nullptr;
+
+		auto info = physComp->GetByID(componentID);
+
+		if (info == nullptr) return nullptr;
+
+		pcShapeType = info->pcShapeType;
+		width = info->playerRadius;
+		height = info->playerHeight;
+	}
+
+	switch (pcShapeType) {
+	case 0: { // HKX type
+		break;
+	}
+	case 1: { //Make a new box shape
+		NiPoint3 boxSize(x, y, z);
+		if (x == 0.0f) {
+			//LU has some weird values, so I think it's best to scale them down a bit
+			if (height < 0.5f) height = 2.0f;
+			if (width < 0.5f) width = 2.0f;
+
+			//Scale them:
+			width = width * scale;
+			height = height * scale;
+
+			boxSize = NiPoint3(width, height, width);
+		}
+
+		toReturn = new dpEntity(m_Parent->GetObjectID(), boxSize);
+
+		toReturn->SetPosition({ m_Position.x, m_Position.y - (height / 2), m_Position.z });
+		break;
+	}
+	case 2: { //Make a new cylinder shape
+		break;
+	}
+	case 3: { //Make a new sphere shape
+		auto [x, y, z] = m_Position;
+		toReturn = new dpEntity(m_Parent->GetObjectID(), width);
+		toReturn->SetPosition({ x, y, z });
+		break;
+	}
+	case 4: { //Make a new capsule shape
+		break;
+	}
+	}
+
+	if (toReturn) dpWorld::AddEntity(toReturn);
+
+	return toReturn;
+}
+
+void PhysicsComponent::SpawnVertices(dpEntity* entity) const {
+	if (!entity) return;
+
+	LOG("Spawning vertices for %llu", m_Parent->GetObjectID());
+	EntityInfo info;
+	info.lot = 33;
+	info.spawner = nullptr;
+	info.spawnerID = m_Parent->GetObjectID();
+	info.spawnerNodeID = 0;
+
+	// These don't use overloaded methods as dPhysics does not link with dGame at the moment.
+	auto box = dynamic_cast<dpShapeBox*>(entity->GetShape());
+	if (box) {
+		for (auto vert : box->GetVertices()) {
+			LOG("Vertex at %f, %f, %f", vert.x, vert.y, vert.z);
+
+			info.pos = vert;
+			Entity* newEntity = Game::entityManager->CreateEntity(info);
+			Game::entityManager->ConstructEntity(newEntity);
+		}
+	}
+	auto sphere = dynamic_cast<dpShapeSphere*>(entity->GetShape());
+	if (sphere) {
+		auto [x, y, z] = entity->GetPosition(); // Use shapes position instead of the parent's position in case it's different
+		float plusX = x + sphere->GetRadius();
+		float minusX = x - sphere->GetRadius();
+		float plusY = y + sphere->GetRadius();
+		float minusY = y - sphere->GetRadius();
+		float plusZ = z + sphere->GetRadius();
+		float minusZ = z - sphere->GetRadius();
+
+		auto radius = sphere->GetRadius();
+		LOG("Radius: %f", radius);
+		LOG("Plus Vertices %f %f %f", plusX, plusY, plusZ);
+		LOG("Minus Vertices %f %f %f", minusX, minusY, minusZ);
+
+		info.pos = NiPoint3{ x, plusY, z };
+		Entity* newEntity = Game::entityManager->CreateEntity(info);
+		Game::entityManager->ConstructEntity(newEntity);
+
+		info.pos = NiPoint3{ x, minusY, z };
+		newEntity = Game::entityManager->CreateEntity(info);
+		Game::entityManager->ConstructEntity(newEntity);
+
+		info.pos = NiPoint3{ plusX, y, z };
+		newEntity = Game::entityManager->CreateEntity(info);
+		Game::entityManager->ConstructEntity(newEntity);
+
+		info.pos = NiPoint3{ minusX, y, z };
+		newEntity = Game::entityManager->CreateEntity(info);
+		Game::entityManager->ConstructEntity(newEntity);
+
+		info.pos = NiPoint3{ x, y, plusZ };
+		newEntity = Game::entityManager->CreateEntity(info);
+		Game::entityManager->ConstructEntity(newEntity);
+
+		info.pos = NiPoint3{ x, y, minusZ };
+		newEntity = Game::entityManager->CreateEntity(info);
+		Game::entityManager->ConstructEntity(newEntity);
+
+		info.pos = NiPoint3{ x, y, z };
+		newEntity = Game::entityManager->CreateEntity(info);
+		Game::entityManager->ConstructEntity(newEntity);
+	}
+}

dGame/dComponents/PhysicsComponent.h

@@ -9,6 +9,10 @@ namespace Raknet {
 	class BitStream;
 };
 
+enum class eReplicaComponentType : uint32_t;
+
+class dpEntity;
+
 class PhysicsComponent : public Component {
 public:
 	PhysicsComponent(Entity* parent);
@@ -22,6 +26,12 @@ public:
 	const NiQuaternion& GetRotation() const { return m_Rotation; }
 	virtual void SetRotation(const NiQuaternion& rot) { if (m_Rotation == rot) return; m_Rotation = rot; m_DirtyPosition = true; }
 protected:
+	dpEntity* CreatePhysicsEntity(eReplicaComponentType type);
+
+	dpEntity* CreatePhysicsLnv(const float scale, const eReplicaComponentType type) const;
+
+	void SpawnVertices(dpEntity* entity) const;
+
 	NiPoint3 m_Position;
 
 	NiQuaternion m_Rotation;

dGame/dComponents/PossessableComponent.cpp

@@ -18,8 +18,8 @@ PossessableComponent::PossessableComponent(Entity* parent, uint32_t componentId)
 
 	// Should a result not exist for this default to attached visible
 	if (!result.eof()) {
-		m_PossessionType = static_cast<ePossessionType>(result.getIntField(0, 1)); // Default to Attached Visible
-		m_DepossessOnHit = static_cast<bool>(result.getIntField(1, 0));
+		m_PossessionType = static_cast<ePossessionType>(result.getIntField("possessionType", 1)); // Default to Attached Visible
+		m_DepossessOnHit = static_cast<bool>(result.getIntField("depossessOnHit", 0));
 	} else {
 		m_PossessionType = ePossessionType::ATTACHED_VISIBLE;
 		m_DepossessOnHit = false;

dGame/dComponents/PropertyManagementComponent.cpp

@@ -21,9 +21,11 @@
 #include "eObjectBits.h"
 #include "CharacterComponent.h"
 #include "PlayerManager.h"
+#include "ModelComponent.h"
 
 #include <vector>
 #include "CppScripts.h"
+#include <ranges>
 
 PropertyManagementComponent* PropertyManagementComponent::instance = nullptr;
 
@@ -49,11 +51,11 @@ PropertyManagementComponent::PropertyManagementComponent(Entity* parent) : Compo
 
 	auto result = query.execQuery();
 
-	if (result.eof() || result.fieldIsNull(0)) {
+	if (result.eof() || result.fieldIsNull("id")) {
 		return;
 	}
 
-	templateId = result.getIntField(0);
+	templateId = result.getIntField("id");
 
 	auto propertyInfo = Database::Get()->GetPropertyInfo(zoneId, cloneId);
 
@@ -105,7 +107,7 @@ std::vector<NiPoint3> PropertyManagementComponent::GetPaths() const {
 
 	std::vector<float> points;
 
-	std::istringstream stream(result.getStringField(0));
+	std::istringstream stream(result.getStringField("path"));
 	std::string token;
 
 	while (std::getline(stream, token, ' ')) {
@@ -352,16 +354,11 @@ void PropertyManagementComponent::UpdateModelPosition(const LWOOBJID id, const N
 
 		auto* spawner = Game::zoneManager->GetSpawner(spawnerId);
 
-		auto ldfModelBehavior = new LDFData<LWOOBJID>(u"modelBehaviors", 0);
-		auto userModelID = new LDFData<LWOOBJID>(u"userModelID", info.spawnerID);
-		auto modelType = new LDFData<int>(u"modelType", 2);
-		auto propertyObjectID = new LDFData<bool>(u"propertyObjectID", true);
-		auto componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);
-		info.nodes[0]->config.push_back(componentWhitelist);
-		info.nodes[0]->config.push_back(ldfModelBehavior);
-		info.nodes[0]->config.push_back(modelType);
-		info.nodes[0]->config.push_back(propertyObjectID);
-		info.nodes[0]->config.push_back(userModelID);
+		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();
 
@@ -585,31 +582,33 @@ void PropertyManagementComponent::Load() {
 			GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
 			GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
 
-			LDFBaseData* ldfBlueprintID = new LDFData<LWOOBJID>(u"blueprintid", blueprintID);
-			LDFBaseData* componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);
-			LDFBaseData* modelType = new LDFData<int>(u"modelType", 2);
-			LDFBaseData* propertyObjectID = new LDFData<bool>(u"propertyObjectID", true);
-			LDFBaseData* userModelID = new LDFData<LWOOBJID>(u"userModelID", databaseModel.id);
-
-			settings.push_back(ldfBlueprintID);
-			settings.push_back(componentWhitelist);
-			settings.push_back(modelType);
-			settings.push_back(propertyObjectID);
-			settings.push_back(userModelID);
+			settings.push_back(new LDFData<LWOOBJID>(u"blueprintid", blueprintID));
+			settings.push_back(new LDFData<int>(u"componentWhitelist", 1));
+			settings.push_back(new LDFData<int>(u"modelType", 2));
+			settings.push_back(new LDFData<bool>(u"propertyObjectID", true));
+			settings.push_back(new LDFData<LWOOBJID>(u"userModelID", databaseModel.id));
 		} else {
-			auto modelType = new LDFData<int>(u"modelType", 2);
-			auto userModelID = new LDFData<LWOOBJID>(u"userModelID", databaseModel.id);
-			auto ldfModelBehavior = new LDFData<LWOOBJID>(u"modelBehaviors", 0);
-			auto propertyObjectID = new LDFData<bool>(u"propertyObjectID", true);
-			auto componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);
-
-			settings.push_back(componentWhitelist);
-			settings.push_back(ldfModelBehavior);
-			settings.push_back(modelType);
-			settings.push_back(propertyObjectID);
-			settings.push_back(userModelID);
+			settings.push_back(new LDFData<int>(u"modelType", 2));
+			settings.push_back(new LDFData<LWOOBJID>(u"userModelID", databaseModel.id));
+			settings.push_back(new LDFData<LWOOBJID>(u"modelBehaviors", 0));
+			settings.push_back(new LDFData<bool>(u"propertyObjectID", true));
+			settings.push_back(new LDFData<int>(u"componentWhitelist", 1));
 		}
 
+		std::ostringstream userModelBehavior;
+		bool firstAdded = false;
+		for (auto behavior : databaseModel.behaviors) {
+			if (behavior < 0) {
+				LOG("Invalid behavior ID: %d, removing behavior reference from model", behavior);
+				behavior = 0;
+			}
+			if (firstAdded) userModelBehavior << ",";
+			userModelBehavior << behavior;
+			firstAdded = true;
+		}
+
+		settings.push_back(new LDFData<std::string>(u"userModelBehaviors", userModelBehavior.str()));
+
 		node->config = settings;
 
 		const auto spawnerId = Game::zoneManager->MakeSpawner(info);
@@ -627,6 +626,12 @@ void PropertyManagementComponent::Save() {
 		return;
 	}
 
+	const auto* const owner = GetOwner();
+	if (!owner) return;
+
+	const auto* const character = owner->GetCharacter();
+	if (!character) return;
+
 	auto present = Database::Get()->GetPropertyModels(propertyId);
 
 	std::vector<LWOOBJID> modelIds;
@@ -641,6 +646,20 @@ void PropertyManagementComponent::Save() {
 		if (entity == nullptr) {
 			continue;
 		}
+		auto* modelComponent = entity->GetComponent<ModelComponent>();
+		if (!modelComponent) continue;
+		const auto modelBehaviors = modelComponent->GetBehaviorsForSave();
+
+		// save the behaviors of the model
+		for (const auto& [behaviorId, behaviorStr] : modelBehaviors) {
+			if (behaviorStr.empty() || behaviorId == -1 || behaviorId == 0) continue;
+			IBehaviors::Info info {
+				.behaviorId = behaviorId,
+				.characterId = character->GetID(),
+				.behaviorInfo = behaviorStr
+			};
+			Database::Get()->AddBehavior(info);
+		}
 
 		const auto position = entity->GetPosition();
 		const auto rotation = entity->GetRotation();
@@ -652,10 +671,13 @@ void PropertyManagementComponent::Save() {
 			model.position = position;
 			model.rotation = rotation;
 			model.ugcId = 0;
+			for (auto i = 0; i < model.behaviors.size(); i++) {
+				model.behaviors[i] = modelBehaviors[i].first;
+			}
 
 			Database::Get()->InsertNewPropertyModel(propertyId, model, "Objects_" + std::to_string(model.lot) + "_name");
 		} else {
-			Database::Get()->UpdateModelPositionRotation(id, position, rotation);
+			Database::Get()->UpdateModel(id, position, rotation, modelBehaviors);
 		}
 	}
 

dGame/dComponents/ProximityMonitorComponent.cpp

@@ -5,7 +5,7 @@
 #include "EntityManager.h"
 #include "SimplePhysicsComponent.h"
 
-const std::map<LWOOBJID, dpEntity*> ProximityMonitorComponent::m_EmptyObjectMap = {};
+const std::unordered_set<LWOOBJID> ProximityMonitorComponent::m_EmptyObjectSet = {};
 
 ProximityMonitorComponent::ProximityMonitorComponent(Entity* parent, int radiusSmall, int radiusLarge) : Component(parent) {
 	if (radiusSmall != -1 && radiusLarge != -1) {
@@ -38,26 +38,26 @@ void ProximityMonitorComponent::SetProximityRadius(dpEntity* entity, const std::
 	m_ProximitiesData.insert(std::make_pair(name, entity));
 }
 
-const std::map<LWOOBJID, dpEntity*>& ProximityMonitorComponent::GetProximityObjects(const std::string& name) {
-	const auto& iter = m_ProximitiesData.find(name);
+const std::unordered_set<LWOOBJID>& ProximityMonitorComponent::GetProximityObjects(const std::string& name) {
+	const auto iter = m_ProximitiesData.find(name);
 
-	if (iter == m_ProximitiesData.end()) {
-		return m_EmptyObjectMap;
+	if (iter == m_ProximitiesData.cend()) {
+		return m_EmptyObjectSet;
 	}
 
 	return iter->second->GetCurrentlyCollidingObjects();
 }
 
 bool ProximityMonitorComponent::IsInProximity(const std::string& name, LWOOBJID objectID) {
-	const auto& iter = m_ProximitiesData.find(name);
+	const auto iter = m_ProximitiesData.find(name);
 
-	if (iter == m_ProximitiesData.end()) {
+	if (iter == m_ProximitiesData.cend()) {
 		return false;
 	}
 
-	const auto& collitions = iter->second->GetCurrentlyCollidingObjects();
+	const auto& collisions = iter->second->GetCurrentlyCollidingObjects();
 
-	return collitions.find(objectID) != collitions.end();
+	return collisions.contains(objectID);
 }
 
 void ProximityMonitorComponent::Update(float deltaTime) {
@@ -66,13 +66,13 @@ void ProximityMonitorComponent::Update(float deltaTime) {
 
 		prox.second->SetPosition(m_Parent->GetPosition());
 		//Process enter events
-		for (auto* en : prox.second->GetNewObjects()) {
-			m_Parent->OnCollisionProximity(en->GetObjectID(), prox.first, "ENTER");
+		for (const auto id : prox.second->GetNewObjects()) {
+			m_Parent->OnCollisionProximity(id, prox.first, "ENTER");
 		}
 
 		//Process exit events
-		for (auto* en : prox.second->GetRemovedObjects()) {
-			m_Parent->OnCollisionProximity(en->GetObjectID(), prox.first, "LEAVE");
+		for (const auto id : prox.second->GetRemovedObjects()) {
+			m_Parent->OnCollisionProximity(id, prox.first, "LEAVE");
 		}
 	}
 }

dGame/dComponents/ProximityMonitorComponent.h

@@ -6,6 +6,8 @@
 #ifndef PROXIMITYMONITORCOMPONENT_H
 #define PROXIMITYMONITORCOMPONENT_H
 
+#include <unordered_set>
+
 #include "BitStream.h"
 #include "Entity.h"
 #include "dpWorld.h"
@@ -42,9 +44,9 @@ public:
 	/**
 	 * Returns the last of entities that are used to check proximity, given a name
 	 * @param name the proximity name to retrieve physics objects for
-	 * @return a map of physics entities for this name, indexed by object ID
+	 * @return a set of physics entity object IDs for this name
 	 */
-	const std::map<LWOOBJID, dpEntity*>& GetProximityObjects(const std::string& name);
+	const std::unordered_set<LWOOBJID>& GetProximityObjects(const std::string& name);
 
 	/**
 	 * Checks if the passed object is in proximity of the named proximity sensor
@@ -70,7 +72,7 @@ private:
 	/**
 	 * Default value for the proximity data
 	 */
-	static const std::map<LWOOBJID, dpEntity*> m_EmptyObjectMap;
+	static const std::unordered_set<LWOOBJID> m_EmptyObjectSet;
 };
 
 #endif // PROXIMITYMONITORCOMPONENT_H

dGame/dComponents/RacingControlComponent.cpp

@@ -25,6 +25,7 @@
 #include "LeaderboardManager.h"
 #include "dZoneManager.h"
 #include "CDActivitiesTable.h"
+#include "eStateChangeType.h"
 #include <ctime>
 
 #ifndef M_PI
@@ -77,6 +78,9 @@ void RacingControlComponent::OnPlayerLoaded(Entity* player) {
 
 	m_LoadedPlayers++;
 
+	// not live accurate to stun the player but prevents them from using skills during the race that are not meant to be used.
+	GameMessages::SendSetStunned(player->GetObjectID(), eStateChangeType::PUSH, player->GetSystemAddress(), LWOOBJID_EMPTY, true, true, true, true, true, true, true, true, true);
+
 	LOG("Loading player %i",
 		m_LoadedPlayers);
 	m_LobbyPlayers.push_back(player->GetObjectID());
@@ -394,25 +398,6 @@ void RacingControlComponent::HandleMessageBoxResponse(Entity* player, int32_t bu
 		GameMessages::SendNotifyRacingClient(
 			m_Parent->GetObjectID(), 2, 0, LWOOBJID_EMPTY, u"",
 			player->GetObjectID(), UNASSIGNED_SYSTEM_ADDRESS);
-
-		auto* missionComponent = player->GetComponent<MissionComponent>();
-
-		if (missionComponent == nullptr) return;
-
-		missionComponent->Progress(eMissionTaskType::RACING, 0, static_cast<LWOOBJID>(eRacingTaskParam::COMPETED_IN_RACE)); // Progress task for competing in a race
-		missionComponent->Progress(eMissionTaskType::RACING, data->smashedTimes, static_cast<LWOOBJID>(eRacingTaskParam::SAFE_DRIVER)); // Finish a race without being smashed.
-
-		// If solo racing is enabled OR if there are 3 players in the race, progress placement tasks.
-		if (m_SoloRacing || m_LoadedPlayers > 2) {
-			missionComponent->Progress(eMissionTaskType::RACING, data->finished, static_cast<LWOOBJID>(eRacingTaskParam::FINISH_WITH_PLACEMENT)); // Finish in 1st place on a race
-			if (data->finished == 1) {
-				missionComponent->Progress(eMissionTaskType::RACING, Game::zoneManager->GetZone()->GetWorldID(), static_cast<LWOOBJID>(eRacingTaskParam::FIRST_PLACE_MULTIPLE_TRACKS)); // Finish in 1st place on multiple tracks.
-				missionComponent->Progress(eMissionTaskType::RACING, Game::zoneManager->GetZone()->GetWorldID(), static_cast<LWOOBJID>(eRacingTaskParam::WIN_RACE_IN_WORLD)); // Finished first place in specific world.
-			}
-			if (data->finished == m_LoadedPlayers) {
-				missionComponent->Progress(eMissionTaskType::RACING, Game::zoneManager->GetZone()->GetWorldID(), static_cast<LWOOBJID>(eRacingTaskParam::LAST_PLACE_FINISH)); // Finished first place in specific world.
-			}
-		}
 	} else if ((id == "ACT_RACE_EXIT_THE_RACE?" || id == "Exit") && button == m_ActivityExitConfirm) {
 		auto* vehicle = Game::entityManager->GetEntity(data->vehicleID);
 
@@ -817,8 +802,10 @@ void RacingControlComponent::Update(float deltaTime) {
 
 			// Some offset up to make they don't fall through the terrain on a
 			// respawn, seems to fix itself to the track anyhow
-			player.respawnPosition = position + NiPoint3Constant::UNIT_Y * 5;
-			player.respawnRotation = vehicle->GetRotation();
+			if (waypoint.racing.isResetNode) {
+				player.respawnPosition = position + NiPoint3Constant::UNIT_Y * 5;
+				player.respawnRotation = vehicle->GetRotation();
+			}
 			player.respawnIndex = respawnIndex;
 
 			// Reached the start point, lapped
@@ -864,6 +851,21 @@ void RacingControlComponent::Update(float deltaTime) {
 						// Entire race time
 						missionComponent->Progress(eMissionTaskType::RACING, (raceTime) * 1000, static_cast<LWOOBJID>(eRacingTaskParam::TOTAL_TRACK_TIME));
 
+						missionComponent->Progress(eMissionTaskType::RACING, 0, static_cast<LWOOBJID>(eRacingTaskParam::COMPETED_IN_RACE)); // Progress task for competing in a race
+						missionComponent->Progress(eMissionTaskType::RACING, player.smashedTimes, static_cast<LWOOBJID>(eRacingTaskParam::SAFE_DRIVER)); // Finish a race without being smashed.
+
+						// If solo racing is enabled OR if there are 3 players in the race, progress placement tasks.
+						if (m_SoloRacing || m_RacingPlayers.size() > 2) {
+							missionComponent->Progress(eMissionTaskType::RACING, player.finished, static_cast<LWOOBJID>(eRacingTaskParam::FINISH_WITH_PLACEMENT)); // Finish in 1st place on a race
+							if (player.finished == 1) {
+								missionComponent->Progress(eMissionTaskType::RACING, Game::zoneManager->GetZone()->GetWorldID(), static_cast<LWOOBJID>(eRacingTaskParam::FIRST_PLACE_MULTIPLE_TRACKS)); // Finish in 1st place on multiple tracks.
+								missionComponent->Progress(eMissionTaskType::RACING, Game::zoneManager->GetZone()->GetWorldID(), static_cast<LWOOBJID>(eRacingTaskParam::WIN_RACE_IN_WORLD)); // Finished first place in specific world.
+							}
+							if (player.finished == m_RacingPlayers.size()) {
+								missionComponent->Progress(eMissionTaskType::RACING, Game::zoneManager->GetZone()->GetWorldID(), static_cast<LWOOBJID>(eRacingTaskParam::LAST_PLACE_FINISH)); // Finished first place in specific world.
+							}
+						}
+
 						auto* characterComponent = playerEntity->GetComponent<CharacterComponent>();
 						if (characterComponent != nullptr) {
 							characterComponent->TrackRaceCompleted(m_Finished == 1);

dGame/dComponents/RenderComponent.cpp

@@ -129,7 +129,7 @@ void RenderComponent::PlayEffect(const int32_t effectId, const std::u16string& e
 
 	auto result = query.execQuery();
 
-	if (result.eof() || result.fieldIsNull(0)) {
+	if (result.eof() || result.fieldIsNull("animation_length")) {
 		result.finalize();
 
 		m_DurationCache[effectId] = 0;
@@ -139,7 +139,7 @@ void RenderComponent::PlayEffect(const int32_t effectId, const std::u16string& e
 		return;
 	}
 
-	effect.time = static_cast<float>(result.getFloatField(0));
+	effect.time = static_cast<float>(result.getFloatField("animation_length"));
 
 	result.finalize();
 

dGame/dComponents/RigidbodyPhantomPhysicsComponent.cpp

@@ -1,16 +1,57 @@
-/*
- * Darkflame Universe
- * Copyright 2023
- */
+// Darkflame Universe
+// Copyright 2024
 
 #include "RigidbodyPhantomPhysicsComponent.h"
 #include "Entity.h"
 
+#include "dpEntity.h"
+#include "CDComponentsRegistryTable.h"
+#include "CDPhysicsComponentTable.h"
+#include "dpWorld.h"
+#include "dpShapeBox.h"
+#include "dpShapeSphere.h"
+#include"EntityInfo.h"
+
 RigidbodyPhantomPhysicsComponent::RigidbodyPhantomPhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
 	m_Position = m_Parent->GetDefaultPosition();
 	m_Rotation = m_Parent->GetDefaultRotation();
+	m_Scale = m_Parent->GetDefaultScale();
+
+	if (m_Parent->GetVar<bool>(u"create_physics")) {
+		m_dpEntity = CreatePhysicsLnv(m_Scale, ComponentType);
+		if (!m_dpEntity) {
+			m_dpEntity = CreatePhysicsEntity(ComponentType);
+			if (!m_dpEntity) return;
+			m_dpEntity->SetScale(m_Scale);
+			m_dpEntity->SetRotation(m_Rotation);
+			m_dpEntity->SetPosition(m_Position);
+			dpWorld::AddEntity(m_dpEntity);
+		}
+	}
 }
 
 void RigidbodyPhantomPhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	PhysicsComponent::Serialize(outBitStream, bIsInitialUpdate);
 }
+
+void RigidbodyPhantomPhysicsComponent::Update(const float deltaTime) {
+	if (!m_dpEntity) return;
+
+	//Process enter events
+	for (const auto id : m_dpEntity->GetNewObjects()) {
+		m_Parent->OnCollisionPhantom(id);
+	}
+
+	//Process exit events
+	for (const auto id : m_dpEntity->GetRemovedObjects()) {
+		m_Parent->OnCollisionLeavePhantom(id);
+	}
+}
+
+void RigidbodyPhantomPhysicsComponent::SpawnVertices() const {
+	if (!m_dpEntity) {
+		LOG("No dpEntity to spawn vertices for %llu:%i", m_Parent->GetObjectID(), m_Parent->GetLOT());
+		return;
+	}
+	PhysicsComponent::SpawnVertices(m_dpEntity);
+}

dGame/dComponents/RigidbodyPhantomPhysicsComponent.h

@@ -1,10 +1,8 @@
-/*
- * Darkflame Universe
- * Copyright 2023
- */
+// Darkflame Universe
+// Copyright 2024
 
-#ifndef __RIGIDBODYPHANTOMPHYSICS_H__
-#define __RIGIDBODYPHANTOMPHYSICS_H__
+#ifndef RIGIDBODYPHANTOMPHYSICS_H
+#define RIGIDBODYPHANTOMPHYSICS_H
 
 #include "BitStream.h"
 #include "dCommonVars.h"
@@ -13,6 +11,8 @@
 #include "PhysicsComponent.h"
 #include "eReplicaComponentType.h"
 
+class dpEntity;
+
  /**
   * Component that handles rigid bodies that can be interacted with, mostly client-side rendered. An example is the
   * bananas that fall from trees in GF.
@@ -23,7 +23,15 @@ public:
 
 	RigidbodyPhantomPhysicsComponent(Entity* parent);
 
+	void Update(const float deltaTime) override;
+
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
+
+	void SpawnVertices() const;
+private:
+	float m_Scale{};
+
+	dpEntity* m_dpEntity{};
 };
 
-#endif // __RIGIDBODYPHANTOMPHYSICS_H__
+#endif // RIGIDBODYPHANTOMPHYSICS_H

dGame/dComponents/RocketLaunchpadControlComponent.cpp

@@ -27,12 +27,12 @@ RocketLaunchpadControlComponent::RocketLaunchpadControlComponent(Entity* parent,
 
 	auto result = query.execQuery();
 
-	if (!result.eof() && !result.fieldIsNull(0)) {
-		m_TargetZone = result.getIntField(0);
-		m_DefaultZone = result.getIntField(1);
-		m_TargetScene = result.getStringField(2);
-		m_AltPrecondition = new PreconditionExpression(result.getStringField(3));
-		m_AltLandingScene = result.getStringField(4);
+	if (!result.eof() && !result.fieldIsNull("targetZone")) {
+		m_TargetZone = result.getIntField("targetZone");
+		m_DefaultZone = result.getIntField("defaultZoneID");
+		m_TargetScene = result.getStringField("targetScene");
+		m_AltPrecondition = new PreconditionExpression(result.getStringField("altLandingPrecondition"));
+		m_AltLandingScene = result.getStringField("altLandingSpawnPointName");
 	}
 
 	result.finalize();

dGame/dComponents/SkillComponent.cpp

@@ -38,7 +38,7 @@ bool SkillComponent::CastPlayerSkill(const uint32_t behaviorId, const uint32_t s
 
 	context->skillID = skillID;
 
-	this->m_managedBehaviors.insert_or_assign(skillUid, context);
+	this->m_managedBehaviors.insert({ skillUid, context });
 
 	auto* behavior = Behavior::CreateBehavior(behaviorId);
 
@@ -52,17 +52,24 @@ bool SkillComponent::CastPlayerSkill(const uint32_t behaviorId, const uint32_t s
 }
 
 void SkillComponent::SyncPlayerSkill(const uint32_t skillUid, const uint32_t syncId, RakNet::BitStream& bitStream) {
-	const auto index = this->m_managedBehaviors.find(skillUid);
+	const auto index = this->m_managedBehaviors.equal_range(skillUid);
 
-	if (index == this->m_managedBehaviors.end()) {
+	if (index.first == this->m_managedBehaviors.end()) {
 		LOG("Failed to find skill with uid (%i)!", skillUid, syncId);
 
 		return;
 	}
 
-	auto* context = index->second;
+	bool foundSyncId = false;
+	for (auto it = index.first; it != index.second && !foundSyncId; ++it) {
+		const auto& context = it->second;
 
-	context->SyncBehavior(syncId, bitStream);
+		foundSyncId = context->SyncBehavior(syncId, bitStream);
+	}
+
+	if (!foundSyncId) {
+		LOG("Failed to find sync id (%i) for skill with uid (%i)!", syncId, skillUid);
+	}
 }
 
 
@@ -99,7 +106,7 @@ void SkillComponent::SyncPlayerProjectile(const LWOOBJID projectileId, RakNet::B
 		return;
 	}
 
-	const auto behavior_id = static_cast<uint32_t>(result.getIntField(0));
+	const auto behavior_id = static_cast<uint32_t>(result.getIntField("behaviorID"));
 
 	result.finalize();
 
@@ -138,7 +145,7 @@ void SkillComponent::Update(const float deltaTime) {
 		for (const auto& pair : this->m_managedBehaviors) pair.second->UpdatePlayerSyncs(deltaTime);
 	}
 
-	std::map<uint32_t, BehaviorContext*> keep{};
+	std::multimap<uint32_t, BehaviorContext*> keep{};
 
 	for (const auto& pair : this->m_managedBehaviors) {
 		auto* context = pair.second;
@@ -176,7 +183,7 @@ void SkillComponent::Update(const float deltaTime) {
 			}
 		}
 
-		keep.insert_or_assign(pair.first, context);
+		keep.insert({ pair.first, context });
 	}
 
 	this->m_managedBehaviors = keep;
@@ -227,7 +234,7 @@ void SkillComponent::RegisterCalculatedProjectile(const LWOOBJID projectileId, B
 	this->m_managedProjectiles.push_back(entry);
 }
 
-bool SkillComponent::CastSkill(const uint32_t skillId, LWOOBJID target, const LWOOBJID optionalOriginatorID) {
+bool SkillComponent::CastSkill(const uint32_t skillId, LWOOBJID target, const LWOOBJID optionalOriginatorID, const int32_t castType, const NiQuaternion rotationOverride) {
 	uint32_t behaviorId = -1;
 	// try to find it via the cache
 	const auto& pair = m_skillBehaviorCache.find(skillId);
@@ -247,11 +254,19 @@ bool SkillComponent::CastSkill(const uint32_t skillId, LWOOBJID target, const LW
 		return false;
 	}
 
-	return CalculateBehavior(skillId, behaviorId, target, false, false, optionalOriginatorID).success;
+	return CalculateBehavior(skillId, behaviorId, target, false, false, optionalOriginatorID, castType, rotationOverride).success;
 }
 
 
-SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, const uint32_t behaviorId, const LWOOBJID target, const bool ignoreTarget, const bool clientInitalized, const LWOOBJID originatorOverride) {
+SkillExecutionResult SkillComponent::CalculateBehavior(
+	const uint32_t skillId,
+	const uint32_t behaviorId,
+	const LWOOBJID target,
+	const bool ignoreTarget,
+	const bool clientInitalized,
+	const LWOOBJID originatorOverride,
+	const int32_t castType,
+	const NiQuaternion rotationOverride) {
 	RakNet::BitStream bitStream{};
 
 	auto* behavior = Behavior::CreateBehavior(behaviorId);
@@ -277,13 +292,13 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c
 		return { false, 0 };
 	}
 
-	this->m_managedBehaviors.insert_or_assign(context->skillUId, context);
+	this->m_managedBehaviors.insert({ context->skillUId, context });
 
 	if (!clientInitalized) {
 		// Echo start skill
 		EchoStartSkill start;
 
-		start.iCastType = 0;
+		start.iCastType = castType;
 		start.skillID = skillId;
 		start.uiSkillHandle = context->skillUId;
 		start.optionalOriginatorID = context->originator;
@@ -294,6 +309,10 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c
 		if (originator != nullptr) {
 			start.originatorRot = originator->GetRotation();
 		}
+
+		if (rotationOverride != NiQuaternionConstant::IDENTITY) {
+			start.originatorRot = rotationOverride;
+		}
 		//start.optionalTargetID = target;
 
 		start.sBitStream.assign(reinterpret_cast<char*>(bitStream.GetData()), bitStream.GetNumberOfBytesUsed());
@@ -413,7 +432,7 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry)
 		return;
 	}
 
-	const auto behaviorId = static_cast<uint32_t>(result.getIntField(0));
+	const auto behaviorId = static_cast<uint32_t>(result.getIntField("behaviorID"));
 
 	result.finalize();
 
@@ -464,7 +483,7 @@ void SkillComponent::HandleUnCast(const uint32_t behaviorId, const LWOOBJID targ
 	behavior->UnCast(&context, { target });
 }
 
-SkillComponent::SkillComponent(Entity* parent): Component(parent) {
+SkillComponent::SkillComponent(Entity* parent) : Component(parent) {
 	this->m_skillUid = 0;
 }
 

dGame/dComponents/SkillComponent.h

@@ -127,7 +127,7 @@ public:
 	 * @param optionalOriginatorID change the originator of the skill
 	 * @return if the case succeeded
 	 */
-	bool CastSkill(const uint32_t skillId, LWOOBJID target = LWOOBJID_EMPTY, const LWOOBJID optionalOriginatorID = LWOOBJID_EMPTY);
+	bool CastSkill(const uint32_t skillId, LWOOBJID target = LWOOBJID_EMPTY, const LWOOBJID optionalOriginatorID = LWOOBJID_EMPTY, const int32_t castType = 0, const NiQuaternion rotationOverride = NiQuaternionConstant::IDENTITY);
 
 	/**
 	 * Initializes a server-side skill calculation.
@@ -139,7 +139,7 @@ public:
 	 * @param originatorOverride an override for the originator of the skill calculation
 	 * @return the result of the skill calculation
 	 */
-	SkillExecutionResult CalculateBehavior(uint32_t skillId, uint32_t behaviorId, LWOOBJID target, bool ignoreTarget = false, bool clientInitalized = false, LWOOBJID originatorOverride = LWOOBJID_EMPTY);
+	SkillExecutionResult CalculateBehavior(uint32_t skillId, uint32_t behaviorId, LWOOBJID target, bool ignoreTarget = false, bool clientInitalized = false, LWOOBJID originatorOverride = LWOOBJID_EMPTY, const int32_t castType = 0, const NiQuaternion rotationOverride = NiQuaternionConstant::IDENTITY);
 
 	/**
 	 * Register a server-side projectile.
@@ -188,7 +188,7 @@ private:
 	/**
 	 * All of the active skills mapped by their unique ID.
 	 */
-	std::map<uint32_t, BehaviorContext*> m_managedBehaviors;
+	std::multimap<uint32_t, BehaviorContext*> m_managedBehaviors;
 
 	/**
 	 * All active projectiles.

dGame/dComponents/VendorComponent.cpp

@@ -76,8 +76,8 @@ void VendorComponent::RefreshInventory(bool isCreation) {
 				if (vendorItems.empty()) break;
 				auto randomItemIndex = GeneralUtils::GenerateRandomNumber<int32_t>(0, vendorItems.size() - 1);
 				const auto& randomItem = vendorItems.at(randomItemIndex);
-				vendorItems.erase(vendorItems.begin() + randomItemIndex);
 				if (SetupItem(randomItem.itemid)) m_Inventory.push_back(SoldItem(randomItem.itemid, randomItem.sortPriority));
+				vendorItems.erase(vendorItems.begin() + randomItemIndex);
 			}
 		}
 	}

dGame/dGameMessages/GameMessageHandler.cpp

@@ -685,6 +685,13 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream& inStream, const System
 	case eGameMessageType::REQUEST_VENDOR_STATUS_UPDATE:
 		GameMessages::SendVendorStatusUpdate(entity, sysAddr, true);
 		break;
+	case eGameMessageType::UPDATE_INVENTORY_GROUP:
+		GameMessages::HandleUpdateInventoryGroup(inStream, entity, sysAddr);
+		break;
+	case eGameMessageType::UPDATE_INVENTORY_GROUP_CONTENTS:
+		GameMessages::HandleUpdateInventoryGroupContents(inStream, entity, sysAddr);
+		break;
+
 	default:
 		LOG_DEBUG("Received Unknown GM with ID: %4i, %s", messageID, StringifiedEnum::ToString(messageID).data());
 		break;

dGame/dGameMessages/GameMessages.cpp

@@ -99,9 +99,11 @@
 #include "ActivityManager.h"
 #include "PlayerManager.h"
 #include "eVendorTransactionResult.h"
+#include "eReponseMoveItemBetweenInventoryTypeCode.h"
 
 #include "CDComponentsRegistryTable.h"
 #include "CDObjectsTable.h"
+#include "eItemType.h"
 
 #include "Recorder.h"
 
@@ -377,8 +379,8 @@ void GameMessages::SendPlatformResync(Entity* entity, const SystemAddress& sysAd
 
 	const auto lot = entity->GetLOT();
 
-	if (lot == 12341 || lot == 5027 || lot == 5028 || lot == 14335 || lot == 14447 || lot == 14449) {
-		iDesiredWaypointIndex = 0;
+	if (lot == 12341 || lot == 5027 || lot == 5028 || lot == 14335 || lot == 14447 || lot == 14449 || lot == 11306 || lot == 11308) {
+		iDesiredWaypointIndex = (lot == 11306 || lot == 11308) ? 1 : 0;
 		iIndex = 0;
 		nextIndex = 0;
 		bStopAtDesiredWaypoint = true;
@@ -420,7 +422,8 @@ void GameMessages::SendPlatformResync(Entity* entity, const SystemAddress& sysAd
 		bitStream.Write(qUnexpectedRotation.w);
 	}
 
-	SEND_PACKET_BROADCAST;
+	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST;
+	SEND_PACKET;
 }
 
 void GameMessages::SendRestoreToPostLoadStats(Entity* entity, const SystemAddress& sysAddr) {
@@ -2671,17 +2674,11 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 		info.spawnerID = entity->GetObjectID();
 		info.spawnerNodeID = 0;
 
-		LDFBaseData* ldfBlueprintID = new LDFData<LWOOBJID>(u"blueprintid", blueprintID);
-		LDFBaseData* componentWhitelist = new LDFData<int>(u"componentWhitelist", 1);
-		LDFBaseData* modelType = new LDFData<int>(u"modelType", 2);
-		LDFBaseData* propertyObjectID = new LDFData<bool>(u"propertyObjectID", true);
-		LDFBaseData* userModelID = new LDFData<LWOOBJID>(u"userModelID", newIDL);
-
-		info.settings.push_back(ldfBlueprintID);
-		info.settings.push_back(componentWhitelist);
-		info.settings.push_back(modelType);
-		info.settings.push_back(propertyObjectID);
-		info.settings.push_back(userModelID);
+		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) {
@@ -4577,16 +4574,31 @@ void GameMessages::HandleRequestMoveItemBetweenInventoryTypes(RakNet::BitStream&
 	if (inStream.ReadBit()) inStream.Read(itemLOT);
 
 	if (invTypeDst == invTypeSrc) {
+		SendResponseMoveItemBetweenInventoryTypes(entity->GetObjectID(), sysAddr, invTypeDst, invTypeSrc, eReponseMoveItemBetweenInventoryTypeCode::FAIL_GENERIC);
 		return;
 	}
 
 	auto* inventoryComponent = entity->GetComponent<InventoryComponent>();
 
-	if (inventoryComponent != nullptr) {
+	if (inventoryComponent) {
 		if (itemID != LWOOBJID_EMPTY) {
 			auto* item = inventoryComponent->FindItemById(itemID);
 
-			if (!item) return;
+			if (!item) {
+				SendResponseMoveItemBetweenInventoryTypes(entity->GetObjectID(), sysAddr, invTypeDst, invTypeSrc, eReponseMoveItemBetweenInventoryTypeCode::FAIL_ITEM_NOT_FOUND);
+				return;
+			} 
+
+			if (item->GetLot() == 6086) { // Thinking hat
+				SendResponseMoveItemBetweenInventoryTypes(entity->GetObjectID(), sysAddr, invTypeDst, invTypeSrc, eReponseMoveItemBetweenInventoryTypeCode::FAIL_CANT_MOVE_THINKING_HAT);
+				return;
+			}
+			
+			auto* destInv = inventoryComponent->GetInventory(invTypeDst);
+			if (destInv && destInv->GetEmptySlots() == 0) {
+				SendResponseMoveItemBetweenInventoryTypes(entity->GetObjectID(), sysAddr, invTypeDst, invTypeSrc, eReponseMoveItemBetweenInventoryTypeCode::FAIL_INV_FULL);
+				return;
+			}
 
 			// Despawn the pet if we are moving that pet to the vault.
 			auto* petComponent = PetComponent::GetActivePet(entity->GetObjectID());
@@ -4595,10 +4607,32 @@ void GameMessages::HandleRequestMoveItemBetweenInventoryTypes(RakNet::BitStream&
 			}
 
 			inventoryComponent->MoveItemToInventory(item, invTypeDst, iStackCount, showFlyingLoot, false, false, destSlot);
+			SendResponseMoveItemBetweenInventoryTypes(entity->GetObjectID(), sysAddr, invTypeDst, invTypeSrc, eReponseMoveItemBetweenInventoryTypeCode::SUCCESS);
 		}
+	} else {
+		SendResponseMoveItemBetweenInventoryTypes(entity->GetObjectID(), sysAddr, invTypeDst, invTypeSrc, eReponseMoveItemBetweenInventoryTypeCode::FAIL_GENERIC);
 	}
 }
 
+void GameMessages::SendResponseMoveItemBetweenInventoryTypes(LWOOBJID objectId, const SystemAddress& sysAddr, eInventoryType inventoryTypeDestination, eInventoryType inventoryTypeSource, eReponseMoveItemBetweenInventoryTypeCode response) {
+	CBITSTREAM;
+	CMSGHEADER;
+
+	bitStream.Write(objectId);
+	bitStream.Write(eGameMessageType::RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES);
+
+	bitStream.Write(inventoryTypeDestination != eInventoryType::ITEMS);
+	if (inventoryTypeDestination != eInventoryType::ITEMS) bitStream.Write(inventoryTypeDestination);
+
+	bitStream.Write(inventoryTypeSource != eInventoryType::ITEMS);
+	if (inventoryTypeSource != eInventoryType::ITEMS) bitStream.Write(inventoryTypeSource);
+
+	bitStream.Write(response != eReponseMoveItemBetweenInventoryTypeCode::FAIL_GENERIC);
+	if (response != eReponseMoveItemBetweenInventoryTypeCode::FAIL_GENERIC) bitStream.Write(response);
+
+	SEND_PACKET;
+}
+
 
 void GameMessages::SendShowActivityCountdown(LWOOBJID objectId, bool bPlayAdditionalSound, bool bPlayCountdownSound, std::u16string sndName, int32_t stateToPlaySoundOn, const SystemAddress& sysAddr) {
 	CBITSTREAM;
@@ -4674,7 +4708,7 @@ void GameMessages::HandleBuyFromVendor(RakNet::BitStream& inStream, Entity* enti
 	if (!user) return;
 	Entity* player = Game::entityManager->GetEntity(user->GetLoggedInChar());
 	if (!player) return;
-	
+
 	// handle buying normal items
 	auto* vendorComponent = entity->GetComponent<VendorComponent>();
 	if (vendorComponent) {
@@ -5316,7 +5350,7 @@ void GameMessages::HandleRemoveItemFromInventory(RakNet::BitStream& inStream, En
 	bool iLootTypeSourceIsDefault = false;
 	LWOOBJID iLootTypeSource = LWOOBJID_EMPTY;
 	bool iObjIDIsDefault = false;
-	LWOOBJID iObjID;
+	LWOOBJID iObjID = LWOOBJID_EMPTY;
 	bool iObjTemplateIsDefault = false;
 	LOT iObjTemplate = LOT_NULL;
 	bool iRequestingObjIDIsDefault = false;
@@ -5377,17 +5411,18 @@ void GameMessages::HandleRemoveItemFromInventory(RakNet::BitStream& inStream, En
 	iStackCount = std::min<uint32_t>(item->GetCount(), iStackCount);
 
 	if (bConfirmed) {
-		if (eInvType == eInventoryType::MODELS) {
+		const auto itemType = static_cast<eItemType>(item->GetInfo().itemType);
+		if (itemType == eItemType::MODEL || itemType == eItemType::LOOT_MODEL) {
 			item->DisassembleModel(iStackCount);
 		}
-
+		auto lot = item->GetLot();
 		item->SetCount(item->GetCount() - iStackCount, true);
 		Game::entityManager->SerializeEntity(entity);
 
 		auto* missionComponent = entity->GetComponent<MissionComponent>();
 
 		if (missionComponent != nullptr) {
-			missionComponent->Progress(eMissionTaskType::GATHER, item->GetLot(), LWOOBJID_EMPTY, "", -iStackCount);
+			missionComponent->Progress(eMissionTaskType::GATHER, lot, LWOOBJID_EMPTY, "", -iStackCount);
 		}
 	}
 }
@@ -6223,3 +6258,93 @@ void GameMessages::HandleCancelDonationOnPlayer(RakNet::BitStream& inStream, Ent
 	if (!characterComponent) return;
 	characterComponent->SetCurrentInteracting(LWOOBJID_EMPTY);
 }
+
+void GameMessages::SendSlashCommandFeedbackText(Entity* entity, std::u16string text) {
+	CBITSTREAM;
+	CMSGHEADER;
+
+	bitStream.Write(entity->GetObjectID());
+	bitStream.Write(eGameMessageType::SLASH_COMMAND_TEXT_FEEDBACK);
+	bitStream.Write<uint32_t>(text.size());
+	bitStream.Write(text);
+	auto sysAddr = entity->GetSystemAddress();
+	SEND_PACKET;
+}
+
+void GameMessages::HandleUpdateInventoryGroup(RakNet::BitStream& inStream, Entity* entity, const SystemAddress& sysAddr) {
+	std::string action;
+	std::u16string groupName;
+	InventoryComponent::GroupUpdate groupUpdate;
+	bool locked{}; // All groups are locked by default
+
+	uint32_t size{};
+	if (!inStream.Read(size)) return;
+	action.resize(size);
+	if (!inStream.Read(action.data(), size)) return;
+
+	if (!inStream.Read(size)) return;
+	groupUpdate.groupId.resize(size);
+	if (!inStream.Read(groupUpdate.groupId.data(), size)) return;
+
+	if (!inStream.Read(size)) return;
+	groupName.resize(size);
+	if (!inStream.Read(reinterpret_cast<char*>(groupName.data()), size * 2)) return;
+
+	if (!inStream.Read(groupUpdate.inventory)) return;
+	if (!inStream.Read(locked)) return;
+
+	groupUpdate.groupName = GeneralUtils::UTF16ToWTF8(groupName);
+
+	if (action == "ADD") groupUpdate.command = InventoryComponent::GroupUpdateCommand::ADD;
+	else if (action == "MODIFY") groupUpdate.command = InventoryComponent::GroupUpdateCommand::MODIFY;
+	else if (action == "REMOVE") groupUpdate.command = InventoryComponent::GroupUpdateCommand::REMOVE;
+	else {
+		LOG("Invalid action %s", action.c_str());
+		return;
+	}
+
+	auto* inventoryComponent = entity->GetComponent<InventoryComponent>();
+	if (inventoryComponent) inventoryComponent->UpdateGroup(groupUpdate);
+}
+
+void GameMessages::HandleUpdateInventoryGroupContents(RakNet::BitStream& inStream, Entity* entity, const SystemAddress& sysAddr) {
+	std::string action;
+	InventoryComponent::GroupUpdate groupUpdate;
+
+	uint32_t size{};
+	if (!inStream.Read(size)) return;
+	action.resize(size);
+	if (!inStream.Read(action.data(), size)) return;
+
+	if (action == "ADD") groupUpdate.command = InventoryComponent::GroupUpdateCommand::ADD_LOT;
+	else if (action == "REMOVE") groupUpdate.command = InventoryComponent::GroupUpdateCommand::REMOVE_LOT;
+	else {
+		LOG("Invalid action %s", action.c_str());
+		return;
+	}
+
+	if (!inStream.Read(size)) return;
+	groupUpdate.groupId.resize(size);
+	if (!inStream.Read(groupUpdate.groupId.data(), size)) return;
+
+	if (!inStream.Read(groupUpdate.inventory)) return;
+	if (!inStream.Read(groupUpdate.lot)) return;
+
+	auto* inventoryComponent = entity->GetComponent<InventoryComponent>();
+	if (inventoryComponent) inventoryComponent->UpdateGroup(groupUpdate);
+}
+
+void GameMessages::SendForceCameraTargetCycle(Entity* entity, bool bForceCycling, eCameraTargetCyclingMode cyclingMode, LWOOBJID optionalTargetID) {
+	CBITSTREAM;
+	CMSGHEADER;
+
+	bitStream.Write(entity->GetObjectID());
+	bitStream.Write(eGameMessageType::FORCE_CAMERA_TARGET_CYCLE);
+	bitStream.Write(bForceCycling);
+	bitStream.Write(cyclingMode != eCameraTargetCyclingMode::ALLOW_CYCLE_TEAMMATES);
+	if (cyclingMode != eCameraTargetCyclingMode::ALLOW_CYCLE_TEAMMATES) bitStream.Write(cyclingMode);
+	bitStream.Write(optionalTargetID);
+
+	auto sysAddr = entity->GetSystemAddress();
+	SEND_PACKET;
+}

dGame/dGameMessages/GameMessages.h

@@ -39,6 +39,12 @@ enum class eQuickBuildFailReason : uint32_t;
 enum class eQuickBuildState : uint32_t;
 enum class BehaviorSlot : int32_t;
 enum class eVendorTransactionResult : uint32_t;
+enum class eReponseMoveItemBetweenInventoryTypeCode : int32_t;
+
+enum class eCameraTargetCyclingMode : int32_t {
+	ALLOW_CYCLE_TEAMMATES,
+	DISALLOW_CYCLING
+};
 
 namespace GameMessages {
 	class PropertyDataMessage;
@@ -589,6 +595,7 @@ namespace GameMessages {
 	//NT:
 
 	void HandleRequestMoveItemBetweenInventoryTypes(RakNet::BitStream& inStream, Entity* entity, const SystemAddress& sysAddr);
+	void SendResponseMoveItemBetweenInventoryTypes(LWOOBJID objectId, const SystemAddress& sysAddr, eInventoryType inventoryTypeDestination, eInventoryType inventoryTypeSource, eReponseMoveItemBetweenInventoryTypeCode response);
 
 	void SendShowActivityCountdown(LWOOBJID objectId, bool bPlayAdditionalSound, bool bPlayCountdownSound, std::u16string sndName, int32_t stateToPlaySoundOn, const SystemAddress& sysAddr);
 
@@ -664,6 +671,12 @@ namespace GameMessages {
 	void HandleRemoveDonationItem(RakNet::BitStream& inStream, Entity* entity, const SystemAddress& sysAddr);
 	void HandleConfirmDonationOnPlayer(RakNet::BitStream& inStream, Entity* entity);
 	void HandleCancelDonationOnPlayer(RakNet::BitStream& inStream, Entity* entity);
+
+	void SendSlashCommandFeedbackText(Entity* entity, std::u16string text);
+
+	void HandleUpdateInventoryGroup(RakNet::BitStream& inStream, Entity* entity, const SystemAddress& sysAddr);
+	void HandleUpdateInventoryGroupContents(RakNet::BitStream& inStream, Entity* entity, const SystemAddress& sysAddr);
+	void SendForceCameraTargetCycle(Entity* entity, bool bForceCycling, eCameraTargetCyclingMode cyclingMode, LWOOBJID optionalTargetID);
 };
 
 #endif // GAMEMESSAGES_H

dGame/dInventory/Item.cpp

@@ -27,6 +27,23 @@
 #include "CDComponentsRegistryTable.h"
 #include "CDPackageComponentTable.h"
 
+namespace {
+	const std::map<std::string, std::string> ExtraSettingAbbreviations = {
+		{ "assemblyPartLOTs", "ma" },
+		{ "blueprintID", "b" },
+		{ "userModelID", "ui" },
+		{ "userModelName", "un" },
+		{ "userModelDesc", "ud" },
+		{ "userModelHasBhvr", "ub" },
+		{ "userModelBehaviors", "ubh" },
+		{ "userModelBehaviorSourceID", "ubs" },
+		{ "userModelPhysicsType", "up" },
+		{ "userModelMod", "um" },
+		{ "userModelOpt", "uo" },
+		{ "reforgedLOT", "rl" },
+	};
+}
+
 Item::Item(const LWOOBJID id, const LOT lot, Inventory* inventory, const uint32_t slot, const uint32_t count, const bool bound, const std::vector<LDFBaseData*>& config, const LWOOBJID parent, LWOOBJID subKey, eLootSourceType lootSourceType) {
 	if (!Inventory::IsValidItem(lot)) {
 		return;
@@ -122,6 +139,10 @@ uint32_t Item::GetSlot() const {
 	return slot;
 }
 
+std::vector<LDFBaseData*> Item::GetConfig() const {
+	return config;
+}
+
 std::vector<LDFBaseData*>& Item::GetConfig() {
 	return config;
 }
@@ -251,7 +272,7 @@ bool Item::Consume() {
 
 	auto skills = skillsTable->Query([this](const CDObjectSkills entry) {
 		return entry.objectTemplate == static_cast<uint32_t>(lot);
-	});
+		});
 
 	auto success = false;
 
@@ -405,18 +426,18 @@ void Item::DisassembleModel(uint32_t numToDismantle) {
 
 	auto result = query.execQuery();
 
-	if (result.eof() || result.fieldIsNull(0)) {
+	if (result.eof() || result.fieldIsNull("render_asset")) {
 		return;
 	}
 
-	std::string renderAsset = std::string(result.getStringField(0));
+	std::string renderAsset = std::string(result.getStringField("render_asset"));
 
 	// normalize path slashes
 	for (auto& c : renderAsset) {
 		if (c == '\\') c = '/';
 	}
 
-	std::string lxfmlFolderName = std::string(result.getStringField(1));
+	std::string lxfmlFolderName = std::string(result.getStringField("LXFMLFolder"));
 	if (!lxfmlFolderName.empty()) lxfmlFolderName.insert(0, "/");
 
 	std::vector<std::string> renderAssetSplit = GeneralUtils::SplitString(renderAsset, '/');
@@ -515,3 +536,35 @@ Item::~Item() {
 
 	config.clear();
 }
+
+void Item::SaveConfigXml(tinyxml2::XMLElement& i) const {
+	tinyxml2::XMLElement* x = nullptr;
+
+	for (const auto* config : this->config) {
+		const auto& key = GeneralUtils::UTF16ToWTF8(config->GetKey());
+		const auto saveKey = ExtraSettingAbbreviations.find(key);
+		if (saveKey == ExtraSettingAbbreviations.end()) {
+			continue;
+		}
+
+		if (!x) {
+			x = i.InsertNewChildElement("x");
+		}
+
+		const auto dataToSave = config->GetString(false);
+		x->SetAttribute(saveKey->second.c_str(), dataToSave.c_str());
+	}
+}
+
+void Item::LoadConfigXml(const tinyxml2::XMLElement& i) {
+	const auto* x = i.FirstChildElement("x");
+	if (!x) return;
+
+	for (const auto& pair : ExtraSettingAbbreviations) {
+		const auto* data = x->Attribute(pair.second.c_str());
+		if (!data) continue;
+
+		const auto value = pair.first + "=" + data;
+		config.push_back(LDFBaseData::DataFromString(value));
+	}
+}

dGame/dInventory/Item.h

@@ -9,6 +9,10 @@
 #include "eInventoryType.h"
 #include "eLootSourceType.h"
 
+namespace tinyxml2 {
+	class XMLElement;
+};
+
 /**
  * An item that can be stored in an inventory and optionally consumed or equipped
  * TODO: ideally this should be a component
@@ -116,6 +120,12 @@ public:
 	 */
 	std::vector<LDFBaseData*>& GetConfig();
 
+	/**
+	 * Returns current config info for this item, e.g. for rockets
+	 * @return current config info for this item
+	 */
+	std::vector<LDFBaseData*> GetConfig() const;
+
 	/**
 	 * Returns the database info for this item
 	 * @return the database info for this item
@@ -214,6 +224,10 @@ public:
 	 */
 	void RemoveFromInventory();
 
+	void SaveConfigXml(tinyxml2::XMLElement& i) const;
+
+	void LoadConfigXml(const tinyxml2::XMLElement& i);
+
 private:
 	/**
 	 * The object ID of this item

dGame/dInventory/ItemSet.cpp

@@ -8,10 +8,13 @@
 #include "MissionComponent.h"
 #include "eMissionTaskType.h"
 #include <algorithm>
+#include <array>
 
 #include "CDSkillBehaviorTable.h"
 
 ItemSet::ItemSet(const uint32_t id, InventoryComponent* inventoryComponent) {
+	using namespace std::string_view_literals;
+
 	this->m_ID = id;
 	this->m_InventoryComponent = inventoryComponent;
 
@@ -27,14 +30,16 @@ ItemSet::ItemSet(const uint32_t id, InventoryComponent* inventoryComponent) {
 		return;
 	}
 
-	for (auto i = 0; i < 5; ++i) {
-		if (result.fieldIsNull(i)) {
+	constexpr std::array rowNames = { "skillSetWith2"sv, "skillSetWith3"sv, "skillSetWith4"sv, "skillSetWith5"sv, "skillSetWith6"sv };
+	for (auto i = 0; i < rowNames.size(); ++i) {
+		const auto rowName = rowNames[i];
+		if (result.fieldIsNull(rowName.data())) {
 			continue;
 		}
 
 		auto skillQuery = CDClientDatabase::CreatePreppedStmt(
 			"SELECT SkillID FROM ItemSetSkills WHERE SkillSetID = ?;");
-		skillQuery.bind(1, result.getIntField(i));
+		skillQuery.bind(1, result.getIntField(rowName.data()));
 
 		auto skillResult = skillQuery.execQuery();
 
@@ -43,13 +48,13 @@ ItemSet::ItemSet(const uint32_t id, InventoryComponent* inventoryComponent) {
 		}
 
 		while (!skillResult.eof()) {
-			if (skillResult.fieldIsNull(0)) {
+			if (skillResult.fieldIsNull("SkillID")) {
 				skillResult.nextRow();
 
 				continue;
 			}
 
-			const auto skillId = skillResult.getIntField(0);
+			const auto skillId = skillResult.getIntField("SkillID");
 
 			switch (i) {
 			case 0:
@@ -75,7 +80,7 @@ ItemSet::ItemSet(const uint32_t id, InventoryComponent* inventoryComponent) {
 		}
 	}
 
-	std::string ids = result.getStringField(5);
+	std::string ids = result.getStringField("itemIDs");
 
 	ids.erase(std::remove_if(ids.begin(), ids.end(), ::isspace), ids.end());
 

dGame/dMission/Mission.cpp

@@ -65,24 +65,24 @@ Mission::Mission(MissionComponent* missionComponent, const uint32_t missionId) {
 	}
 }
 
-void Mission::LoadFromXml(tinyxml2::XMLElement* element) {
+void Mission::LoadFromXml(const tinyxml2::XMLElement& element) {
 	// Start custom XML
-	if (element->Attribute("state") != nullptr) {
-		m_State = static_cast<eMissionState>(std::stoul(element->Attribute("state")));
+	if (element.Attribute("state") != nullptr) {
+		m_State = static_cast<eMissionState>(std::stoul(element.Attribute("state")));
 	}
 	// End custom XML
 
-	if (element->Attribute("cct") != nullptr) {
-		m_Completions = std::stoul(element->Attribute("cct"));
+	if (element.Attribute("cct") != nullptr) {
+		m_Completions = std::stoul(element.Attribute("cct"));
 
-		m_Timestamp = std::stoul(element->Attribute("cts"));
+		m_Timestamp = std::stoul(element.Attribute("cts"));
 
 		if (IsComplete()) {
 			return;
 		}
 	}
 
-	auto* task = element->FirstChildElement();
+	auto* task = element.FirstChildElement();
 
 	auto index = 0U;
 
@@ -132,19 +132,19 @@ void Mission::LoadFromXml(tinyxml2::XMLElement* element) {
 	}
 }
 
-void Mission::UpdateXml(tinyxml2::XMLElement* element) {
+void Mission::UpdateXml(tinyxml2::XMLElement& element) {
 	// Start custom XML
-	element->SetAttribute("state", static_cast<unsigned int>(m_State));
+	element.SetAttribute("state", static_cast<unsigned int>(m_State));
 	// End custom XML
 
-	element->DeleteChildren();
+	element.DeleteChildren();
 
-	element->SetAttribute("id", static_cast<unsigned int>(info.id));
+	element.SetAttribute("id", static_cast<unsigned int>(info.id));
 
 	if (m_Completions > 0) {
-		element->SetAttribute("cct", static_cast<unsigned int>(m_Completions));
+		element.SetAttribute("cct", static_cast<unsigned int>(m_Completions));
 
-		element->SetAttribute("cts", static_cast<unsigned int>(m_Timestamp));
+		element.SetAttribute("cts", static_cast<unsigned int>(m_Timestamp));
 
 		if (IsComplete()) {
 			return;
@@ -155,27 +155,27 @@ void Mission::UpdateXml(tinyxml2::XMLElement* element) {
 		if (task->GetType() == eMissionTaskType::COLLECTION ||
 			task->GetType() == eMissionTaskType::VISIT_PROPERTY) {
 
-			auto* child = element->GetDocument()->NewElement("sv");
+			auto* child = element.GetDocument()->NewElement("sv");
 
 			child->SetAttribute("v", static_cast<unsigned int>(task->GetProgress()));
 
-			element->LinkEndChild(child);
+			element.LinkEndChild(child);
 
 			for (auto unique : task->GetUnique()) {
-				auto* uniqueElement = element->GetDocument()->NewElement("sv");
+				auto* uniqueElement = element.GetDocument()->NewElement("sv");
 
 				uniqueElement->SetAttribute("v", static_cast<unsigned int>(unique));
 
-				element->LinkEndChild(uniqueElement);
+				element.LinkEndChild(uniqueElement);
 			}
 
 			break;
 		}
-		auto* child = element->GetDocument()->NewElement("sv");
+		auto* child = element.GetDocument()->NewElement("sv");
 
 		child->SetAttribute("v", static_cast<unsigned int>(task->GetProgress()));
 
-		element->LinkEndChild(child);
+		element.LinkEndChild(child);
 	}
 }
 
@@ -454,6 +454,16 @@ void Mission::YieldRewards() {
 		}
 	}
 
+	// Even with no repeatable column, reputation is repeatable
+	if (info.reward_reputation > 0) {
+		missionComponent->Progress(eMissionTaskType::EARN_REPUTATION, 0, LWOOBJID_EMPTY, "", info.reward_reputation);
+		auto* const character = entity->GetComponent<CharacterComponent>();
+		if (character) {
+			character->SetReputation(character->GetReputation() + info.reward_reputation);
+			GameMessages::SendUpdateReputation(entity->GetObjectID(), character->GetReputation(), entity->GetSystemAddress());
+		}
+	}
+
 	if (m_Completions > 0) {
 		std::vector<std::pair<LOT, uint32_t>> items;
 
@@ -532,15 +542,6 @@ void Mission::YieldRewards() {
 		modelInventory->SetSize(modelInventory->GetSize() + info.reward_bankinventory);
 	}
 
-	if (info.reward_reputation > 0) {
-		missionComponent->Progress(eMissionTaskType::EARN_REPUTATION, 0, 0L, "", info.reward_reputation);
-		auto character = entity->GetComponent<CharacterComponent>();
-		if (character) {
-			character->SetReputation(character->GetReputation() + info.reward_reputation);
-			GameMessages::SendUpdateReputation(entity->GetObjectID(), character->GetReputation(), entity->GetSystemAddress());
-		}
-	}
-
 	if (info.reward_maxhealth > 0) {
 		destroyableComponent->SetMaxHealth(destroyableComponent->GetMaxHealth() + static_cast<float>(info.reward_maxhealth), true);
 	}

dGame/dMission/Mission.h

@@ -28,8 +28,8 @@ public:
 	Mission(MissionComponent* missionComponent, uint32_t missionId);
 	~Mission();
 
-	void LoadFromXml(tinyxml2::XMLElement* element);
-	void UpdateXml(tinyxml2::XMLElement* element);
+	void LoadFromXml(const tinyxml2::XMLElement& element);
+	void UpdateXml(tinyxml2::XMLElement& element);
 
 	/**
 	 * Returns the ID of this mission

dGame/dMission/MissionTask.cpp

@@ -186,7 +186,7 @@ void MissionTask::Progress(int32_t value, LWOOBJID associate, const std::string&
 
 	if (count < 0) {
 		if (mission->IsMission() && type == eMissionTaskType::GATHER && InAllTargets(value)) {
-			if (parameters.size() > 0 && (parameters[0] & 1) != 0) {
+			if (parameters.size() > 0 && (parameters[0] & 4) != 0) {
 				return;
 			}
 

dGame/dPropertyBehaviors/ControlBehaviorMessages/Action.cpp

@@ -1,6 +1,8 @@
 #include "Action.h"
 #include "Amf3.h"
 
+#include "tinyxml2.h"
+
 Action::Action(const AMFArrayValue& arguments) {
 	for (const auto& [paramName, paramValue] : arguments.GetAssociative()) {
 		if (paramName == "Type") {
@@ -32,3 +34,46 @@ void Action::SendBehaviorBlocksToClient(AMFArrayValue& args) const {
 		actionArgs->Insert(m_ValueParameterName, m_ValueParameterDouble);
 	}
 }
+
+void Action::Serialize(tinyxml2::XMLElement& action) const {
+	action.SetAttribute("Type", m_Type.c_str());
+
+	if (m_ValueParameterName.empty()) return;
+
+	action.SetAttribute("ValueParameterName", m_ValueParameterName.c_str());
+
+	if (m_ValueParameterName == "Message") {
+		action.SetAttribute("Value", m_ValueParameterString.c_str());
+	} else {
+		action.SetAttribute("Value", m_ValueParameterDouble);
+	}
+}
+
+void Action::Deserialize(const tinyxml2::XMLElement& action) {
+	const char* type = nullptr;
+	action.QueryAttribute("Type", &type);
+	if (!type) {
+		LOG("No type found for an action?");
+		return;
+	}
+
+	m_Type = type;
+
+	const char* valueParameterName = nullptr;
+	action.QueryAttribute("ValueParameterName", &valueParameterName);
+	if (valueParameterName) {
+		m_ValueParameterName = valueParameterName;
+
+		if (m_ValueParameterName == "Message") {
+			const char* value = nullptr;
+			action.QueryAttribute("Value", &value);
+			if (value) {
+				m_ValueParameterString = value;
+			} else {
+				LOG("No value found for an action message?");
+			}
+		} else {
+			action.QueryDoubleAttribute("Value", &m_ValueParameterDouble);
+		}
+	}
+}

dGame/dPropertyBehaviors/ControlBehaviorMessages/Action.h

@@ -3,6 +3,10 @@
 
 #include <string>
 
+namespace tinyxml2 {
+	class XMLElement;
+};
+
 class AMFArrayValue;
 
 /**
@@ -20,6 +24,8 @@ public:
 
 	void SendBehaviorBlocksToClient(AMFArrayValue& args) const;
 
+	void Serialize(tinyxml2::XMLElement& action) const;
+	void Deserialize(const tinyxml2::XMLElement& action);
 private:
 	double m_ValueParameterDouble{ 0.0 };
 	std::string m_Type{ "" };

dGame/dPropertyBehaviors/ControlBehaviorMessages/StripUiPosition.cpp

@@ -1,6 +1,7 @@
 #include "StripUiPosition.h"
 
 #include "Amf3.h"
+#include "tinyxml2.h"
 
 StripUiPosition::StripUiPosition(const AMFArrayValue& arguments, const std::string& uiKeyName) {
 	const auto* const uiArray = arguments.GetArray(uiKeyName);
@@ -21,3 +22,13 @@ void StripUiPosition::SendBehaviorBlocksToClient(AMFArrayValue& args) const {
 	uiArgs->Insert("x", m_XPosition);
 	uiArgs->Insert("y", m_YPosition);
 }
+
+void StripUiPosition::Serialize(tinyxml2::XMLElement& position) const {
+	position.SetAttribute("x", m_XPosition);
+	position.SetAttribute("y", m_YPosition);
+}
+
+void StripUiPosition::Deserialize(const tinyxml2::XMLElement& position) {
+	position.QueryDoubleAttribute("x", &m_XPosition);
+	position.QueryDoubleAttribute("y", &m_YPosition);
+}

dGame/dPropertyBehaviors/ControlBehaviorMessages/StripUiPosition.h

@@ -3,6 +3,10 @@
 
 class AMFArrayValue;
 
+namespace tinyxml2 {
+	class XMLElement;
+}
+
 /**
  * @brief The position of the first Action in a Strip
  * 
@@ -15,6 +19,8 @@ public:
 	[[nodiscard]] double GetX() const noexcept { return m_XPosition; }
 	[[nodiscard]] double GetY() const noexcept { return m_YPosition; }
 
+	void Serialize(tinyxml2::XMLElement& position) const;
+	void Deserialize(const tinyxml2::XMLElement& position);
 private:
 	double m_XPosition{ 0.0 };
 	double m_YPosition{ 0.0 };

dGame/dPropertyBehaviors/PropertyBehavior.cpp

@@ -3,6 +3,7 @@
 #include "Amf3.h"
 #include "BehaviorStates.h"
 #include "ControlBehaviorMsgs.h"
+#include "tinyxml2.h"
 
 PropertyBehavior::PropertyBehavior() {
 	m_LastEditedState = BehaviorState::HOME_STATE;
@@ -124,3 +125,31 @@ void PropertyBehavior::SendBehaviorBlocksToClient(AMFArrayValue& args) const {
 
 	// TODO Serialize the execution state of the behavior
 }
+
+void PropertyBehavior::Serialize(tinyxml2::XMLElement& behavior) const {
+	behavior.SetAttribute("id", m_BehaviorId);
+	behavior.SetAttribute("name", m_Name.c_str());
+	behavior.SetAttribute("isLocked", isLocked);
+	behavior.SetAttribute("isLoot", isLoot);
+
+	for (const auto& [stateId, state] : m_States) {
+		if (state.IsEmpty()) continue;
+		auto* const stateElement = behavior.InsertNewChildElement("State");
+		stateElement->SetAttribute("id", static_cast<uint32_t>(stateId));
+		state.Serialize(*stateElement);
+	}
+}
+
+
+void PropertyBehavior::Deserialize(const tinyxml2::XMLElement& behavior) {
+	m_Name = behavior.Attribute("name");
+	behavior.QueryBoolAttribute("isLocked", &isLocked);
+	behavior.QueryBoolAttribute("isLoot", &isLoot);
+
+	for (const auto* stateElement = behavior.FirstChildElement("State"); stateElement; stateElement = stateElement->NextSiblingElement("State")) {
+		int32_t stateId = -1;
+		stateElement->QueryIntAttribute("id", &stateId);
+		if (stateId < 0 || stateId > 5) continue;
+		m_States[static_cast<BehaviorState>(stateId)].Deserialize(*stateElement);
+	}
+}

dGame/dPropertyBehaviors/PropertyBehavior.h

@@ -3,6 +3,10 @@
 
 #include "State.h"
 
+namespace tinyxml2 {
+	class XMLElement;
+}
+
 enum class BehaviorState : uint32_t;
 
 class AMFArrayValue;
@@ -25,6 +29,8 @@ public:
 	[[nodiscard]] int32_t GetBehaviorId() const noexcept { return m_BehaviorId; }
 	void SetBehaviorId(int32_t id) noexcept { m_BehaviorId = id; }
 
+	void Serialize(tinyxml2::XMLElement& behavior) const;
+	void Deserialize(const tinyxml2::XMLElement& behavior);
 private:
 
 	// The states this behavior has.

dGame/dPropertyBehaviors/State.cpp

@@ -2,6 +2,7 @@
 
 #include "Amf3.h"
 #include "ControlBehaviorMsgs.h"
+#include "tinyxml2.h"
 
 template <>
 void State::HandleMsg(AddStripMessage& msg) {
@@ -134,4 +135,20 @@ void State::SendBehaviorBlocksToClient(AMFArrayValue& args) const {
 
 		strip.SendBehaviorBlocksToClient(*stripArgs);
 	}
-};
+}
+
+void State::Serialize(tinyxml2::XMLElement& state) const {
+	for (const auto& strip : m_Strips) {
+		if (strip.IsEmpty()) continue;
+
+		auto* const stripElement = state.InsertNewChildElement("Strip");
+		strip.Serialize(*stripElement);
+	}
+}
+
+void State::Deserialize(const tinyxml2::XMLElement& state) {
+	for (const auto* stripElement = state.FirstChildElement("Strip"); stripElement; stripElement = stripElement->NextSiblingElement("Strip")) {
+		auto& strip = m_Strips.emplace_back();
+		strip.Deserialize(*stripElement);
+	}
+}

dGame/dPropertyBehaviors/State.h

@@ -3,6 +3,10 @@
 
 #include "Strip.h"
 
+namespace tinyxml2 {
+	class XMLElement;
+}
+
 class AMFArrayValue;
 
 class State {
@@ -13,6 +17,8 @@ public:
 	void SendBehaviorBlocksToClient(AMFArrayValue& args) const;
 	bool IsEmpty() const;
 
+	void Serialize(tinyxml2::XMLElement& state) const;
+	void Deserialize(const tinyxml2::XMLElement& state);
 private:
 	std::vector<Strip> m_Strips;
 };

dGame/dPropertyBehaviors/Strip.cpp

@@ -2,6 +2,7 @@
 
 #include "Amf3.h"
 #include "ControlBehaviorMsgs.h"
+#include "tinyxml2.h"
 
 template <>
 void Strip::HandleMsg(AddStripMessage& msg) {
@@ -83,4 +84,25 @@ void Strip::SendBehaviorBlocksToClient(AMFArrayValue& args) const {
 	for (const auto& action : m_Actions) {
 		action.SendBehaviorBlocksToClient(*actions);
 	}
-};
+}
+
+void Strip::Serialize(tinyxml2::XMLElement& strip) const {
+	auto* const positionElement = strip.InsertNewChildElement("Position");
+	m_Position.Serialize(*positionElement);
+	for (const auto& action : m_Actions) {
+		auto* const actionElement = strip.InsertNewChildElement("Action");
+		action.Serialize(*actionElement);
+	}
+}
+
+void Strip::Deserialize(const tinyxml2::XMLElement& strip) {
+	const auto* positionElement = strip.FirstChildElement("Position");
+	if (positionElement) {
+		m_Position.Deserialize(*positionElement);
+	}
+
+	for (const auto* actionElement = strip.FirstChildElement("Action"); actionElement; actionElement = actionElement->NextSiblingElement("Action")) {
+		auto& action = m_Actions.emplace_back();
+		action.Deserialize(*actionElement);
+	}
+}

dGame/dPropertyBehaviors/Strip.h

@@ -6,6 +6,10 @@
 
 #include <vector>
 
+namespace tinyxml2 {
+	class XMLElement;
+}
+
 class AMFArrayValue;
 
 class Strip {
@@ -16,6 +20,8 @@ public:
 	void SendBehaviorBlocksToClient(AMFArrayValue& args) const;
 	bool IsEmpty() const noexcept { return m_Actions.empty(); }
 
+	void Serialize(tinyxml2::XMLElement& strip) const;
+	void Deserialize(const tinyxml2::XMLElement& strip);
 private:
 	std::vector<Action> m_Actions;
 	StripUiPosition m_Position;