LTO only on release

* chore: Remove dpEntity pointers from collision checking

* Update fn documentation in ProximityMonitorComponent.h

* use more idiomatic method to calculate vector index

* feedback

* missed a ranges::find replacement

* adjust for feedback. last changes tonight.

* okay, also remove unneeded include. then sleep.

* for real tho

* update to use unordered_set instead of set

CMakeLists.txt

@@ -1,11 +1,26 @@
-cmake_minimum_required(VERSION 3.18)
+cmake_minimum_required(VERSION 3.25)
 project(Darkflame)
 include(CTest)
 
 set(CMAKE_CXX_STANDARD 20)
 set(CXX_STANDARD_REQUIRED ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON) 	# Export the compile commands for debugging
+set(CMAKE_POLICY_DEFAULT_CMP0063 NEW) 	# Set CMAKE visibility policy to NEW on project and subprojects
+set(CMAKE_VISIBILITY_INLINES_HIDDEN ON) # Set C and C++ symbol visibility to hide inlined functions
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake")
 
+# Check if link-time-optimization is supported and apply it if possible in release builds
+include(CheckIPOSupported)
+check_ipo_supported(RESULT supported OUTPUT error)
+
+if(supported)
+	message(STATUS "IPO / LTO enabled")
+	set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
+	set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
+else()
+	message(STATUS "IPO / LTO not supported: <${error}>")
+endif()
+
 # Read variables from file
 FILE(READ "${CMAKE_SOURCE_DIR}/CMakeVariables.txt" variables)
 
@@ -100,7 +115,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)
@@ -211,29 +226,29 @@ if (APPLE)
 endif()
 
 # Load all of our third party directories
-add_subdirectory(thirdparty)
+add_subdirectory(thirdparty SYSTEM)
 
 # Create our list of include directories
-set(INCLUDED_DIRECTORIES
+include_directories(
 	"dPhysics"
 
 	"dNavigation"
 
 	"dNet"
 
-	"thirdparty/magic_enum/include/magic_enum"
-	"thirdparty/raknet/Source"
-	"thirdparty/tinyxml2"
-	"thirdparty/recastnavigation"
-	"thirdparty/SQLite"
-	"thirdparty/cpplinq"
-	"thirdparty/cpp-httplib"
-	"thirdparty/MD5"
-
 	"tests"
 	"tests/dCommonTests"
 	"tests/dGameTests"
 	"tests/dGameTests/dComponentsTests"
+
+	SYSTEM "thirdparty/magic_enum/include/magic_enum"
+	SYSTEM "thirdparty/raknet/Source"
+	SYSTEM "thirdparty/tinyxml2"
+	SYSTEM "thirdparty/recastnavigation"
+	SYSTEM "thirdparty/SQLite"
+	SYSTEM "thirdparty/cpplinq"
+	SYSTEM "thirdparty/cpp-httplib"
+	SYSTEM "thirdparty/MD5"
 )
 
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
@@ -242,14 +257,9 @@ if(APPLE)
 	include_directories("/usr/local/include/")
 endif()
 
-# Actually include the directories from our list
-foreach(dir ${INCLUDED_DIRECTORIES})
-	include_directories(${PROJECT_SOURCE_DIR}/${dir})
-endforeach()
-
 # Add linking directories:
 if (UNIX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wold-style-cast -Werror") # Warning flags
 endif()
 file(
 	GLOB HEADERS_DZONEMANAGER

README.md

@@ -51,7 +51,7 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
 
 ### Windows packages
 Ensure that you have either the [MSVC C++ compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/) (recommended) or the [Clang compiler](https://github.com/llvm/llvm-project/releases/) installed.
-You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.18**</font> or later!).
+You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.25**</font> or later!).
 
 ### MacOS packages
 Ensure you have [brew](https://brew.sh) installed.
@@ -73,7 +73,7 @@ sudo apt install build-essential gcc zlib1g-dev libssl-dev openssl mariadb-serve
 ```
 
 #### Required CMake version
-This project uses <font size="4">**CMake version 3.18**</font> or higher and as such you will need to ensure you have this version installed.
+This project uses <font size="4">**CMake version 3.25**</font> or higher and as such you will need to ensure you have this version installed.
 You can check your CMake version by using the following command in a terminal.
 ```bash
 cmake --version

cmake/FindMariaDB.cmake

@@ -141,6 +141,6 @@ elseif(APPLE)
 endif()
 
 # Add directories to include lists
-target_include_directories(MariaDB::ConnCpp INTERFACE ${MARIADB_INCLUDE_DIR})
+target_include_directories(MariaDB::ConnCpp SYSTEM INTERFACE ${MARIADB_INCLUDE_DIR})
 
 set(MariaDB_FOUND TRUE)

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/ChatIgnoreList.cpp

@@ -1,6 +1,6 @@
 #include "ChatIgnoreList.h"
 #include "PlayerContainer.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.h"
 #include "BitStreamUtils.h"
 #include "Game.h"
 #include "Logger.h"
@@ -13,7 +13,7 @@
 // The only thing not auto-handled is instance activities force joining the team on the server.
 
 void WriteOutgoingReplyHeader(RakNet::BitStream& bitStream, const LWOOBJID& receivingPlayer, const ChatIgnoreList::Response type) {
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT,  eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receivingPlayer);
 
 	//portion that will get routed:

dChatServer/ChatPacketHandler.cpp

@@ -14,7 +14,6 @@
 #include "eObjectBits.h"
 #include "eConnectionType.h"
 #include "eChatMessageType.h"
-#include "eChatInternalMessageType.h"
 #include "eClientMessageType.h"
 #include "eGameMessageType.h"
 #include "StringifiedEnum.h"
@@ -60,7 +59,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
@@ -454,7 +453,7 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 
 void ChatPacketHandler::SendPrivateChatMessage(const PlayerData& sender, const PlayerData& receiver, const PlayerData& routeTo, const LUWString& message, const eChatChannel channel, const eChatMessageResponseCode responseCode) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(routeTo.playerID);
 
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
@@ -696,7 +695,7 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerData& sender) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -711,7 +710,7 @@ void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerD
 
 void ChatPacketHandler::SendTeamInviteConfirm(const PlayerData& receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -738,7 +737,7 @@ void ChatPacketHandler::SendTeamInviteConfirm(const PlayerData& receiver, bool b
 
 void ChatPacketHandler::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -763,7 +762,7 @@ void ChatPacketHandler::SendTeamStatus(const PlayerData& receiver, LWOOBJID i64L
 
 void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -780,7 +779,7 @@ void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i
 
 void ChatPacketHandler::SendTeamAddPlayer(const PlayerData& receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -809,7 +808,7 @@ void ChatPacketHandler::SendTeamAddPlayer(const PlayerData& receiver, bool bIsFr
 
 void ChatPacketHandler::SendTeamRemovePlayer(const PlayerData& receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -835,7 +834,7 @@ void ChatPacketHandler::SendTeamRemovePlayer(const PlayerData& receiver, bool bD
 
 void ChatPacketHandler::SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -869,7 +868,7 @@ void ChatPacketHandler::SendFriendUpdate(const PlayerData& friendData, const Pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(friendData.playerID);
 
 	//portion that will get routed:
@@ -906,7 +905,7 @@ void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const Play
 	}
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
@@ -920,7 +919,7 @@ void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const Play
 
 void ChatPacketHandler::SendFriendResponse(const PlayerData& receiver, const PlayerData& sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	// Portion that will get routed:
@@ -943,7 +942,7 @@ void ChatPacketHandler::SendFriendResponse(const PlayerData& receiver, const Pla
 
 void ChatPacketHandler::SendRemoveFriend(const PlayerData& receiver, std::string& personToRemove, bool isSuccessful) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::WORLD_ROUTE_PACKET);
 	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:

dChatServer/ChatServer.cpp

@@ -17,7 +17,6 @@
 #include "PlayerContainer.h"
 #include "ChatPacketHandler.h"
 #include "eChatMessageType.h"
-#include "eChatInternalMessageType.h"
 #include "eWorldMessageType.h"
 #include "ChatIgnoreList.h"
 #include "StringifiedEnum.h"
@@ -182,47 +181,29 @@ int main(int argc, char** argv) {
 void HandlePacket(Packet* packet) {
 	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.");
-	}
-
-	if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
+	} else if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
 		LOG("A server is connecting, awaiting user list.");
-	}
+	} else if (packet->length < 4 || packet->data[0] != ID_USER_PACKET_ENUM) return; // Nothing left to process or not the right packet type
 
-	if (packet->length < 4) return; // Nothing left to process.  Need 4 bytes to continue.
+	CINSTREAM;
+	inStream.SetReadOffset(BYTES_TO_BITS(1));
 
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
-		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
-		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
-			Game::playerContainer.InsertPlayer(packet);
-			break;
+	eConnectionType connection;
+	eChatMessageType chatMessageID;
 
-		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
-			Game::playerContainer.RemovePlayer(packet);
-			break;
-
-		case eChatInternalMessageType::MUTE_UPDATE:
+	inStream.Read(connection);
+	if (connection != eConnectionType::CHAT) return;
+	inStream.Read(chatMessageID);
+	
+	switch (chatMessageID) {
+		case eChatMessageType::GM_MUTE:
 			Game::playerContainer.MuteUpdate(packet);
 			break;
 
-		case eChatInternalMessageType::CREATE_TEAM:
+		case eChatMessageType::CREATE_TEAM:
 			Game::playerContainer.CreateTeamServer(packet);
 			break;
 
-		case eChatInternalMessageType::ANNOUNCEMENT: {
-			//we just forward this packet to every connected server
-			CINSTREAM;
-			Game::server->Send(inStream, packet->systemAddress, true); //send to everyone except origin
-			break;
-		}
-
-		default:
-			LOG("Unknown CHAT_INTERNAL id: %i", int(packet->data[3]));
-		}
-	}
-
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
-		eChatMessageType chat_message_type = static_cast<eChatMessageType>(packet->data[3]);
-		switch (chat_message_type) {
 		case eChatMessageType::GET_FRIENDS_LIST:
 			ChatPacketHandler::HandleFriendlistRequest(packet);
 			break;
@@ -296,6 +277,19 @@ void HandlePacket(Packet* packet) {
 			ChatPacketHandler::HandleGMLevelUpdate(packet);
 			break;
 		case eChatMessageType::LOGIN_SESSION_NOTIFY:
+			Game::playerContainer.InsertPlayer(packet);
+			break;
+		case eChatMessageType::GM_ANNOUNCE:{
+			// we just forward this packet to every connected server
+			inStream.ResetReadPointer();
+			Game::server->Send(inStream, packet->systemAddress, true); // send to everyone except origin
+			}
+			break;
+		case eChatMessageType::UNEXPECTED_DISCONNECT:
+			Game::playerContainer.RemovePlayer(packet);
+			break;
+		case eChatMessageType::WHO:
+		case eChatMessageType::SHOW_ALL:
 		case eChatMessageType::USER_CHANNEL_CHAT_MESSAGE:
 		case eChatMessageType::WORLD_DISCONNECT_REQUEST:
 		case eChatMessageType::WORLD_PROXIMITY_RESPONSE:
@@ -308,7 +302,6 @@ void HandlePacket(Packet* packet) {
 		case eChatMessageType::GUILD_KICK:
 		case eChatMessageType::GUILD_GET_STATUS:
 		case eChatMessageType::GUILD_GET_ALL:
-		case eChatMessageType::SHOW_ALL:
 		case eChatMessageType::BLUEPRINT_MODERATED:
 		case eChatMessageType::BLUEPRINT_MODEL_READY:
 		case eChatMessageType::PROPERTY_READY_FOR_APPROVAL:
@@ -323,7 +316,6 @@ void HandlePacket(Packet* packet) {
 		case eChatMessageType::CSR_REQUEST:
 		case eChatMessageType::CSR_REPLY:
 		case eChatMessageType::GM_KICK:
-		case eChatMessageType::GM_ANNOUNCE:
 		case eChatMessageType::WORLD_ROUTE_PACKET:
 		case eChatMessageType::GET_ZONE_POPULATIONS:
 		case eChatMessageType::REQUEST_MINIMUM_CHAT_MODE:
@@ -332,33 +324,18 @@ void HandlePacket(Packet* packet) {
 		case eChatMessageType::UGCMANIFEST_REPORT_DONE_FILE:
 		case eChatMessageType::UGCMANIFEST_REPORT_DONE_BLUEPRINT:
 		case eChatMessageType::UGCC_REQUEST:
-		case eChatMessageType::WHO:
 		case eChatMessageType::WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE:
 		case eChatMessageType::ACHIEVEMENT_NOTIFY:
 		case eChatMessageType::GM_CLOSE_PRIVATE_CHAT_WINDOW:
-		case eChatMessageType::UNEXPECTED_DISCONNECT:
 		case eChatMessageType::PLAYER_READY:
 		case eChatMessageType::GET_DONATION_TOTAL:
 		case eChatMessageType::UPDATE_DONATION:
 		case eChatMessageType::PRG_CSR_COMMAND:
 		case eChatMessageType::HEARTBEAT_REQUEST_FROM_WORLD:
 		case eChatMessageType::UPDATE_FREE_TRIAL_STATUS:
-			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chat_message_type).data(), chat_message_type);
+			LOG("Unhandled CHAT Message id: %s (%i)", StringifiedEnum::ToString(chatMessageID).data(), chatMessageID);
 			break;
 		default:
-			LOG("Unknown CHAT Message id: %i", chat_message_type);
-		}
-	}
-
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
-		switch (static_cast<eWorldMessageType>(packet->data[3])) {
-		case eWorldMessageType::ROUTE_PACKET: {
-			LOG("Routing packet from world");
-			break;
-		}
-
-		default:
-			LOG("Unknown World id: %i", int(packet->data[3]));
-		}
+			LOG("Unknown CHAT Message id: %i", chatMessageID);
 	}
 }

dChatServer/PlayerContainer.cpp

@@ -9,9 +9,9 @@
 #include "BitStreamUtils.h"
 #include "Database.h"
 #include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
 #include "ChatPackets.h"
 #include "dConfig.h"
+#include "eChatMessageType.h"
 
 void PlayerContainer::Initialize() {
 	m_MaxNumberOfBestFriends =
@@ -145,7 +145,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_MUTE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -352,7 +352,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::TEAM_GET_STATUS);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);
@@ -390,7 +390,7 @@ LWOOBJID PlayerContainer::GetId(const std::u16string& playerName) {
 }
 
 PlayerData& PlayerContainer::GetPlayerDataMutable(const LWOOBJID& playerID) {
-	return m_Players[playerID];
+	return m_Players.contains(playerID) ? m_Players[playerID] : m_Players[LWOOBJID_EMPTY];
 }
 
 PlayerData& PlayerContainer::GetPlayerDataMutable(const std::string& playerName) {

dCommon/GeneralUtils.cpp

@@ -320,7 +320,7 @@ std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::stri
 	return sortedFiles;
 }
 
-#ifdef DARKFLAME_PLATFORM_MACOS
+#if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
 
 // MacOS floating-point parse function specializations
 namespace GeneralUtils::details {

dCommon/GeneralUtils.h

@@ -166,7 +166,7 @@ namespace GeneralUtils {
 		return isParsed ? static_cast<T>(result) : std::optional<T>{};
 	}
 
-#ifdef DARKFLAME_PLATFORM_MACOS
+#if !(__GNUC__ >= 11 || _MSC_VER >= 1924)
 
 	// MacOS floating-point parse helper function specializations
 	namespace details {
@@ -264,8 +264,8 @@ namespace GeneralUtils {
 	 * @returns The enum entry's value in its underlying type
 	*/
 	template <Enum eType>
-	constexpr typename std::underlying_type_t<eType> CastUnderlyingType(const eType entry) noexcept {
-		return static_cast<typename std::underlying_type_t<eType>>(entry);
+	constexpr std::underlying_type_t<eType> ToUnderlying(const eType entry) noexcept {
+		return static_cast<std::underlying_type_t<eType>>(entry);
 	}
 
 	// on Windows we need to undef these or else they conflict with our numeric limits calls

dCommon/dEnums/eChatInternalMessageType.h

@@ -1,31 +0,0 @@
-#ifndef __ECHATINTERNALMESSAGETYPE__H__
-#define __ECHATINTERNALMESSAGETYPE__H__
-
-#include <cstdint>
-
-enum eChatInternalMessageType : uint32_t {
-	PLAYER_ADDED_NOTIFICATION = 0,
-	PLAYER_REMOVED_NOTIFICATION,
-	ADD_FRIEND,
-	ADD_BEST_FRIEND,
-	ADD_TO_TEAM,
-	ADD_BLOCK,
-	REMOVE_FRIEND,
-	REMOVE_BLOCK,
-	REMOVE_FROM_TEAM,
-	DELETE_TEAM,
-	REPORT,
-	PRIVATE_CHAT,
-	PRIVATE_CHAT_RESPONSE,
-	ANNOUNCEMENT,
-	MAIL_COUNT_UPDATE,
-	MAIL_SEND_NOTIFY,
-	REQUEST_USER_LIST,
-	FRIEND_LIST,
-	ROUTE_TO_PLAYER,
-	TEAM_UPDATE,
-	MUTE_UPDATE,
-	CREATE_TEAM,
-};
-
-#endif  //!__ECHATINTERNALMESSAGETYPE__H__

dCommon/dEnums/eChatMessageType.h

@@ -72,7 +72,9 @@ enum class eChatMessageType :uint32_t {
 	UPDATE_DONATION,
 	PRG_CSR_COMMAND,
 	HEARTBEAT_REQUEST_FROM_WORLD,
-	UPDATE_FREE_TRIAL_STATUS
+	UPDATE_FREE_TRIAL_STATUS,
+	// CUSTOM DLU MESSAGE ID FOR INTERNAL USE
+	CREATE_TEAM,
 };
 
 #endif  //!__ECHATMESSAGETYPE__H__

dCommon/dEnums/eConnectionType.h

@@ -5,8 +5,7 @@ enum class eConnectionType : uint16_t {
 	SERVER = 0,
 	AUTH,
 	CHAT,
-	CHAT_INTERNAL,
-	WORLD,
+	WORLD = 4,
 	CLIENT,
 	MASTER
 };

dCommon/dEnums/eWaypointCommandType.h

@@ -0,0 +1,59 @@
+
+#ifndef __EWAYPOINTCOMMANDTYPES__H__
+#define __EWAYPOINTCOMMANDTYPES__H__
+
+#include <cstdint>
+
+enum class eWaypointCommandType : uint32_t {
+	INVALID,
+	BOUNCE,
+	STOP,
+	GROUP_EMOTE,
+	SET_VARIABLE,
+	CAST_SKILL,
+	EQUIP_INVENTORY,
+	UNEQUIP_INVENTORY,
+	DELAY,
+	EMOTE,
+	TELEPORT,
+	PATH_SPEED,
+	REMOVE_NPC,
+	CHANGE_WAYPOINT,
+	DELETE_SELF,
+	KILL_SELF,
+	SPAWN_OBJECT,
+	PLAY_SOUND,
+};
+
+class WaypointCommandType {
+public:
+	static eWaypointCommandType StringToWaypointCommandType(std::string commandString) {
+		const std::map<std::string, eWaypointCommandType> WaypointCommandTypeMap = {
+			{"bounce", eWaypointCommandType::BOUNCE},
+			{"stop", eWaypointCommandType::STOP},
+			{"groupemote", eWaypointCommandType::GROUP_EMOTE},
+			{"setvar", eWaypointCommandType::SET_VARIABLE},
+			{"castskill", eWaypointCommandType::CAST_SKILL},
+			{"eqInvent", eWaypointCommandType::EQUIP_INVENTORY},
+			{"unInvent", eWaypointCommandType::UNEQUIP_INVENTORY},
+			{"delay", eWaypointCommandType::DELAY},
+			{"femote", eWaypointCommandType::EMOTE},
+			{"emote", eWaypointCommandType::EMOTE},
+			{"teleport", eWaypointCommandType::TELEPORT},
+			{"pathspeed", eWaypointCommandType::PATH_SPEED},
+			{"removeNPC", eWaypointCommandType::REMOVE_NPC},
+			{"changeWP", eWaypointCommandType::CHANGE_WAYPOINT},
+			{"DeleteSelf", eWaypointCommandType::DELETE_SELF},
+			{"killself", eWaypointCommandType::KILL_SELF},
+			{"removeself", eWaypointCommandType::DELETE_SELF},
+			{"spawnOBJ", eWaypointCommandType::SPAWN_OBJECT},
+			{"playSound", eWaypointCommandType::PLAY_SOUND},
+		};
+
+		auto intermed = WaypointCommandTypeMap.find(commandString);
+		return (intermed != WaypointCommandTypeMap.end()) ? intermed->second : eWaypointCommandType::INVALID;
+	};
+};
+
+
+#endif  //!__EWAYPOINTCOMMANDTYPES__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/CDClientTables/CDLootTableTable.cpp

@@ -58,7 +58,7 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 		CDLootTable entry;
 		uint32_t lootTableIndex = tableData.getIntField("LootTableIndex", -1);
 
-		entries[lootTableIndex].push_back(ReadRow(tableData));
+		entries[lootTableIndex].emplace_back(ReadRow(tableData));
 		tableData.nextRow();
 	}
 	for (auto& [id, table] : entries) {
@@ -66,7 +66,7 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 	}
 }
 
-const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
+const LootTableEntries& CDLootTableTable::GetTable(const uint32_t tableId) {
 	auto& entries = GetEntriesMutable();
 	auto itr = entries.find(tableId);
 	if (itr != entries.end()) {
@@ -79,7 +79,7 @@ const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
 
 	while (!tableData.eof()) {
 		CDLootTable entry;
-		entries[tableId].push_back(ReadRow(tableData));
+		entries[tableId].emplace_back(ReadRow(tableData));
 		tableData.nextRow();
 	}
 	SortTable(entries[tableId]);

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDLootTable {
 	uint32_t itemid;                 //!< The LOT of the item
 	uint32_t LootTableIndex;         //!< The Loot Table Index
@@ -20,6 +22,5 @@ private:
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
-	const LootTableEntries& GetTable(uint32_t tableId);
+	const LootTableEntries& GetTable(const uint32_t tableId);
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.cpp

@@ -20,7 +20,7 @@ void CDMissionEmailTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionEmail");
 	while (!tableData.eof()) {
-		CDMissionEmail entry;
+		auto& entry = entries.emplace_back();
 		entry.ID = tableData.getIntField("ID", -1);
 		entry.messageType = tableData.getIntField("messageType", -1);
 		entry.notificationGroup = tableData.getIntField("notificationGroup", -1);
@@ -30,11 +30,8 @@ void CDMissionEmailTable::LoadValuesFromDatabase() {
 		entry.locStatus = tableData.getIntField("locStatus", -1);
 		entry.gate_version = tableData.getStringField("gate_version", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 //! Queries the table with a custom "where" clause

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionEmail {
 	uint32_t ID;
 	uint32_t messageType;

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.cpp

@@ -20,18 +20,15 @@ void CDMissionNPCComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionNPCComponent");
 	while (!tableData.eof()) {
-		CDMissionNPCComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.missionID = tableData.getIntField("missionID", -1);
 		entry.offersMission = tableData.getIntField("offersMission", -1) == 1 ? true : false;
 		entry.acceptsMission = tableData.getIntField("acceptsMission", -1) == 1 ? true : false;
 		entry.gate_version = tableData.getStringField("gate_version", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 //! Queries the table with a custom "where" clause

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionNPCComponent {
 	uint32_t id;                //!< The ID
 	uint32_t missionID;         //!< The Mission ID
@@ -17,4 +19,3 @@ public:
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionNPCComponent> Query(std::function<bool(CDMissionNPCComponent)> predicate);
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.cpp

@@ -20,7 +20,7 @@ void CDMissionTasksTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MissionTasks");
 	while (!tableData.eof()) {
-		CDMissionTasks entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.taskType = tableData.getIntField("taskType", -1);
@@ -35,11 +35,8 @@ void CDMissionTasksTable::LoadValuesFromDatabase() {
 		UNUSED(entry.localize = tableData.getIntField("localize", -1) == 1 ? true : false);
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDMissionTasks> CDMissionTasksTable::Query(std::function<bool(CDMissionTasks)> predicate) {
@@ -51,7 +48,7 @@ std::vector<CDMissionTasks> CDMissionTasksTable::Query(std::function<bool(CDMiss
 	return data;
 }
 
-std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(uint32_t missionID) {
+std::vector<CDMissionTasks*> CDMissionTasksTable::GetByMissionID(const uint32_t missionID) {
 	std::vector<CDMissionTasks*> tasks;
 
 	// TODO: this should not be linear(?) and also shouldnt need to be a pointer

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMissionTasks {
 	uint32_t id;                //!< The Mission ID that the task belongs to
 	UNUSED(uint32_t locStatus);         //!< ???
@@ -25,7 +27,7 @@ public:
 	// Queries the table with a custom "where" clause
 	std::vector<CDMissionTasks> Query(std::function<bool(CDMissionTasks)> predicate);
 
-	std::vector<CDMissionTasks*> GetByMissionID(uint32_t missionID);
+	std::vector<CDMissionTasks*> GetByMissionID(const uint32_t missionID);
 
 	// TODO: Remove this and replace it with a proper lookup function.
 	const CDTable::StorageType& GetEntries() const;

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.cpp

@@ -22,7 +22,7 @@ void CDMissionsTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Missions");
 	while (!tableData.eof()) {
-		CDMissions entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.defined_type = tableData.getStringField("defined_type", "");
 		entry.defined_subtype = tableData.getStringField("defined_subtype", "");
@@ -76,7 +76,6 @@ void CDMissionsTable::LoadValuesFromDatabase() {
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.reward_bankinventory = tableData.getIntField("reward_bankinventory", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
 	tableData.finalize();

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.h

@@ -75,4 +75,3 @@ public:
 
 	static CDMissions Default;
 };
-

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.cpp

@@ -20,7 +20,7 @@ void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM MovementAIComponent");
 	while (!tableData.eof()) {
-		CDMovementAIComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.MovementType = tableData.getStringField("MovementType", "");
 		entry.WanderChance = tableData.getFloatField("WanderChance", -1.0f);
@@ -30,11 +30,8 @@ void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 		entry.WanderRadius = tableData.getFloatField("WanderRadius", -1.0f);
 		entry.attachedPath = tableData.getStringField("attachedPath", "");
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDMovementAIComponent> CDMovementAIComponentTable::Query(std::function<bool(CDMovementAIComponent)> predicate) {

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDMovementAIComponent {
 	uint32_t id;
 	std::string MovementType;

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.cpp

@@ -20,17 +20,14 @@ void CDObjectSkillsTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ObjectSkills");
 	while (!tableData.eof()) {
-		CDObjectSkills entry;
+		auto &entry = entries.emplace_back();
 		entry.objectTemplate = tableData.getIntField("objectTemplate", -1);
 		entry.skillID = tableData.getIntField("skillID", -1);
 		entry.castOnType = tableData.getIntField("castOnType", -1);
 		entry.AICombatWeight = tableData.getIntField("AICombatWeight", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 std::vector<CDObjectSkills> CDObjectSkillsTable::Query(std::function<bool(CDObjectSkills)> predicate) {

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDObjectSkills {
 	uint32_t objectTemplate;        //!< The LOT of the item
 	uint32_t skillID;               //!< The Skill ID of the object

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.cpp

@@ -1,7 +1,7 @@
 #include "CDObjectsTable.h"
 
 namespace {
-	CDObjects m_default;
+	CDObjects ObjDefault;
 };
 
 void CDObjectsTable::LoadValuesFromDatabase() {
@@ -20,8 +20,10 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Objects");
 	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
-		CDObjects entry;
-		entry.id = tableData.getIntField("id", -1);
+		const uint32_t lot = tableData.getIntField("id", 0);
+
+		auto& entry = entries[lot];
+		entry.id = lot;
 		entry.name = tableData.getStringField("name", "");
 		UNUSED_COLUMN(entry.placeable = tableData.getIntField("placeable", -1);)
 		entry.type = tableData.getStringField("type", "");
@@ -36,35 +38,34 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 		UNUSED_COLUMN(entry.gate_version = tableData.getStringField("gate_version", "");)
 		UNUSED_COLUMN(entry.HQ_valid = tableData.getIntField("HQ_valid", -1);)
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
 
-	tableData.finalize();
-
-	m_default.id = 0;
+	ObjDefault.id = 0;
 }
 
-const CDObjects& CDObjectsTable::GetByID(uint32_t LOT) {
+const CDObjects& CDObjectsTable::GetByID(const uint32_t lot) {
 	auto& entries = GetEntriesMutable();
-	const auto& it = entries.find(LOT);
+	const auto& it = entries.find(lot);
 	if (it != entries.end()) {
 		return it->second;
 	}
 
 	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Objects WHERE id = ?;");
-	query.bind(1, static_cast<int32_t>(LOT));
+	query.bind(1, static_cast<int32_t>(lot));
 
 	auto tableData = query.execQuery();
 	if (tableData.eof()) {
-		entries.insert(std::make_pair(LOT, m_default));
-		return m_default;
+		entries.emplace(lot, ObjDefault);
+		return ObjDefault;
 	}
 
 	// Now get the data
 	while (!tableData.eof()) {
-		CDObjects entry;
-		entry.id = tableData.getIntField("id", -1);
+		const uint32_t lot = tableData.getIntField("id", 0);
+
+		auto& entry = entries[lot];
+		entry.id = lot;
 		entry.name = tableData.getStringField("name", "");
 		UNUSED(entry.placeable = tableData.getIntField("placeable", -1));
 		entry.type = tableData.getStringField("type", "");
@@ -79,17 +80,15 @@ const CDObjects& CDObjectsTable::GetByID(uint32_t LOT) {
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 		UNUSED(entry.HQ_valid = tableData.getIntField("HQ_valid", -1));
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
 
 	tableData.finalize();
 
-	const auto& it2 = entries.find(LOT);
+	const auto& it2 = entries.find(lot);
 	if (it2 != entries.end()) {
 		return it2->second;
 	}
 
-	return m_default;
+	return ObjDefault;
 }
-

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDObjects {
 	uint32_t id;                            //!< The LOT of the object
 	std::string name;                      //!< The internal name of the object
@@ -24,6 +26,6 @@ class CDObjectsTable : public CDTable<CDObjectsTable, std::map<uint32_t, CDObjec
 public:
 	void LoadValuesFromDatabase();
 	// Gets an entry by ID
-	const CDObjects& GetByID(uint32_t LOT);
+	const CDObjects& GetByID(const uint32_t lot);
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.cpp

@@ -19,12 +19,11 @@ void CDPackageComponentTable::LoadValuesFromDatabase() {
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PackageComponent");
 	while (!tableData.eof()) {
-		CDPackageComponent entry;
+		auto& entry = entries.emplace_back();
 		entry.id = tableData.getIntField("id", -1);
 		entry.LootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
 		entry.packageType = tableData.getIntField("packageType", -1);
 
-		entries.push_back(entry);
 		tableData.nextRow();
 	}
 

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.h

@@ -3,6 +3,8 @@
 // Custom Classes
 #include "CDTable.h"
 
+#include <cstdint>
+
 struct CDPackageComponent {
 	uint32_t id;
 	uint32_t LootMatrixIndex;

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.cpp

@@ -4,32 +4,31 @@ void CDPhysicsComponentTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PhysicsComponent");
 	auto& entries = GetEntriesMutable();
 	while (!tableData.eof()) {
-		CDPhysicsComponent entry;
-		entry.id = tableData.getIntField("id", -1);
+		const uint32_t componentID = tableData.getIntField("id", -1);
+
+		auto& entry = entries[componentID];
+		entry.id = componentID;
 		entry.bStatic = tableData.getIntField("static", -1) != 0;
 		entry.physicsAsset = tableData.getStringField("physics_asset", "");
-		UNUSED(entry->jump = tableData.getIntField("jump", -1) != 0);
-		UNUSED(entry->doublejump = tableData.getIntField("doublejump", -1) != 0);
-		entry.speed = tableData.getFloatField("speed", -1);
-		UNUSED(entry->rotSpeed = tableData.getFloatField("rotSpeed", -1));
-		entry.playerHeight = tableData.getFloatField("playerHeight");
-		entry.playerRadius = tableData.getFloatField("playerRadius");
+		UNUSED_COLUMN(entry.jump = tableData.getIntField("jump", -1) != 0;)
+		UNUSED_COLUMN(entry.doubleJump = tableData.getIntField("doublejump", -1) != 0;)
+		entry.speed = static_cast<float>(tableData.getFloatField("speed", -1));
+		UNUSED_COLUMN(entry.rotSpeed = tableData.getFloatField("rotSpeed", -1);)
+		entry.playerHeight = static_cast<float>(tableData.getFloatField("playerHeight"));
+		entry.playerRadius = static_cast<float>(tableData.getFloatField("playerRadius"));
 		entry.pcShapeType = tableData.getIntField("pcShapeType");
 		entry.collisionGroup = tableData.getIntField("collisionGroup");
-		UNUSED(entry->airSpeed = tableData.getFloatField("airSpeed"));
-		UNUSED(entry->boundaryAsset = tableData.getStringField("boundaryAsset"));
-		UNUSED(entry->jumpAirSpeed = tableData.getFloatField("jumpAirSpeed"));
-		UNUSED(entry->friction = tableData.getFloatField("friction"));
-		UNUSED(entry->gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset"));
+		UNUSED_COLUMN(entry.airSpeed = tableData.getFloatField("airSpeed");)
+		UNUSED_COLUMN(entry.boundaryAsset = tableData.getStringField("boundaryAsset");)
+		UNUSED_COLUMN(entry.jumpAirSpeed = tableData.getFloatField("jumpAirSpeed");)
+		UNUSED_COLUMN(entry.friction = tableData.getFloatField("friction");)
+		UNUSED_COLUMN(entry.gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset");)
 
-		entries.insert(std::make_pair(entry.id, entry));
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
-CDPhysicsComponent* CDPhysicsComponentTable::GetByID(uint32_t componentID) {
+CDPhysicsComponent* CDPhysicsComponentTable::GetByID(const uint32_t componentID) {
 	auto& entries = GetEntriesMutable();
 	auto itr = entries.find(componentID);
 	return itr != entries.end() ? &itr->second : nullptr;

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.h

@@ -1,5 +1,6 @@
 #pragma once
 #include "CDTable.h"
+#include <cstdint>
 #include <string>
 
 struct CDPhysicsComponent {
@@ -7,7 +8,7 @@ struct CDPhysicsComponent {
 	bool bStatic;
 	std::string physicsAsset;
 	UNUSED(bool jump);
-	UNUSED(bool doublejump);
+	UNUSED(bool doubleJump);
 	float speed;
 	UNUSED(float rotSpeed);
 	float playerHeight;
@@ -26,5 +27,5 @@ public:
 	void LoadValuesFromDatabase();
 
 	static const std::string GetTableName() { return "PhysicsComponent"; };
-	CDPhysicsComponent* GetByID(uint32_t componentID);
+	CDPhysicsComponent* GetByID(const uint32_t componentID);
 };

dGame/Entity.cpp

@@ -731,15 +731,21 @@ void Entity::Initialize() {
 		// if we have a moving platform path, then we need a moving platform component
 		if (path->pathType == PathType::MovingPlatform) {
 			AddComponent<MovingPlatformComponent>(pathName);
-			// else if we are a movement path
-		} /*else if (path->pathType == PathType::Movement) {
-			auto movementAIcomp = GetComponent<MovementAIComponent>();
-			if (movementAIcomp){
-				// TODO: set path in existing movementAIComp
+		} else if (path->pathType == PathType::Movement) {
+			auto movementAIcomponent = GetComponent<MovementAIComponent>();
+			if (movementAIcomponent && combatAiId == 0) {
+				movementAIcomponent->SetPath(pathName);
 			} else {
-				// TODO: create movementAIcomp and set path
+				MovementAIInfo moveInfo = MovementAIInfo();
+				moveInfo.movementType = "";
+				moveInfo.wanderChance = 0;
+				moveInfo.wanderRadius = 16;
+				moveInfo.wanderSpeed = 2.5f;
+				moveInfo.wanderDelayMax = 5;
+				moveInfo.wanderDelayMin = 2;
+				AddComponent<MovementAIComponent>(moveInfo);
 			}
-		}*/
+		}
 	} else {
 		// else we still need to setup moving platform if it has a moving platform comp but no path
 		int32_t movingPlatformComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MOVING_PLATFORM, -1);

dGame/EntityManager.cpp

@@ -418,10 +418,16 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 }
 
 void EntityManager::SerializeEntity(Entity* entity) {
-	if (!entity || entity->GetNetworkId() == 0) return;
+	if (!entity) return;
+	
+	EntityManager::SerializeEntity(*entity);
+}
 
-	if (std::find(m_EntitiesToSerialize.begin(), m_EntitiesToSerialize.end(), entity->GetObjectID()) == m_EntitiesToSerialize.end()) {
-		m_EntitiesToSerialize.push_back(entity->GetObjectID());
+void EntityManager::SerializeEntity(const Entity& entity) {
+	if (entity.GetNetworkId() == 0) return;
+
+	if (std::find(m_EntitiesToSerialize.cbegin(), m_EntitiesToSerialize.cend(), entity.GetObjectID()) == m_EntitiesToSerialize.cend()) {
+		m_EntitiesToSerialize.push_back(entity.GetObjectID());
 	}
 }
 

dGame/EntityManager.h

@@ -45,6 +45,7 @@ public:
 	void ConstructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS, bool skipChecks = false);
 	void DestructEntity(Entity* entity, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 	void SerializeEntity(Entity* entity);
+	void SerializeEntity(const Entity& entity);
 
 	void ConstructAllEntities(const SystemAddress& sysAddr);
 	void DestructAllEntities(const SystemAddress& sysAddr);

dGame/UserManager.cpp

@@ -26,7 +26,7 @@
 #include "eCharacterCreationResponse.h"
 #include "eRenameResponse.h"
 #include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.h"
 #include "BitStreamUtils.h"
 #include "CheatDetection.h"
 
@@ -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')) {
@@ -422,7 +422,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 		Database::Get()->DeleteCharacter(charID);
 
 		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::UNEXPECTED_DISCONNECT);
 		bitStream.Write(objectID);
 		Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 

dGame/dBehaviors/BasicAttackBehavior.cpp

@@ -222,7 +222,7 @@ void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet
 		if (healthDamageDealt >= 1) {
 			successState = eBasicAttackSuccessTypes::SUCCESS;
 		} else if (armorDamageDealt >= 1) {
-			successState = this->m_OnFailArmor->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY ? eBasicAttackSuccessTypes::FAILIMMUNE : eBasicAttackSuccessTypes::FAILARMOR;
+			successState = this->m_OnFailArmor->m_templateId == BehaviorTemplate::EMPTY ? eBasicAttackSuccessTypes::FAILIMMUNE : eBasicAttackSuccessTypes::FAILARMOR;
 		}
 
 		bitStream.Write(armorDamageDealt);

dGame/dBehaviors/Behavior.cpp

@@ -5,7 +5,7 @@
 #include "CDActivitiesTable.h"
 #include "Game.h"
 #include "Logger.h"
-#include "BehaviorTemplates.h"
+#include "BehaviorTemplate.h"
 #include "BehaviorBranchContext.h"
 #include <unordered_map>
 
@@ -110,176 +110,176 @@ Behavior* Behavior::CreateBehavior(const uint32_t behaviorId) {
 	Behavior* behavior = nullptr;
 
 	switch (templateId) {
-	case BehaviorTemplates::BEHAVIOR_EMPTY: break;
-	case BehaviorTemplates::BEHAVIOR_BASIC_ATTACK:
+	case BehaviorTemplate::EMPTY: break;
+	case BehaviorTemplate::BASIC_ATTACK:
 		behavior = new BasicAttackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TAC_ARC:
+	case BehaviorTemplate::TAC_ARC:
 		behavior = new TacArcBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_AND:
+	case BehaviorTemplate::AND:
 		behavior = new AndBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROJECTILE_ATTACK:
+	case BehaviorTemplate::PROJECTILE_ATTACK:
 		behavior = new ProjectileAttackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_HEAL:
+	case BehaviorTemplate::HEAL:
 		behavior = new HealBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_MOVEMENT_SWITCH:
+	case BehaviorTemplate::MOVEMENT_SWITCH:
 		behavior = new MovementSwitchBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_AREA_OF_EFFECT:
+	case BehaviorTemplate::AREA_OF_EFFECT:
 		behavior = new AreaOfEffectBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PLAY_EFFECT:
+	case BehaviorTemplate::PLAY_EFFECT:
 		behavior = new PlayEffectBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_IMMUNITY:
+	case BehaviorTemplate::IMMUNITY:
 		behavior = new ImmunityBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_DAMAGE_BUFF: break;
-	case BehaviorTemplates::BEHAVIOR_DAMAGE_ABSORBTION:
+	case BehaviorTemplate::DAMAGE_BUFF: break;
+	case BehaviorTemplate::DAMAGE_ABSORBTION:
 		behavior = new DamageAbsorptionBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_OVER_TIME:
+	case BehaviorTemplate::OVER_TIME:
 		behavior = new OverTimeBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_IMAGINATION:
+	case BehaviorTemplate::IMAGINATION:
 		behavior = new ImaginationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TARGET_CASTER:
+	case BehaviorTemplate::TARGET_CASTER:
 		behavior = new TargetCasterBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_STUN:
+	case BehaviorTemplate::STUN:
 		behavior = new StunBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_DURATION:
+	case BehaviorTemplate::DURATION:
 		behavior = new DurationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_KNOCKBACK:
+	case BehaviorTemplate::KNOCKBACK:
 		behavior = new KnockbackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_ATTACK_DELAY:
+	case BehaviorTemplate::ATTACK_DELAY:
 		behavior = new AttackDelayBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CAR_BOOST:
+	case BehaviorTemplate::CAR_BOOST:
 		behavior = new CarBoostBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_FALL_SPEED:
+	case BehaviorTemplate::FALL_SPEED:
 		behavior = new FallSpeedBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SHIELD: break;
-	case BehaviorTemplates::BEHAVIOR_REPAIR_ARMOR:
+	case BehaviorTemplate::SHIELD: break;
+	case BehaviorTemplate::REPAIR_ARMOR:
 		behavior = new RepairBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SPEED:
+	case BehaviorTemplate::SPEED:
 		behavior = new SpeedBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_DARK_INSPIRATION:
+	case BehaviorTemplate::DARK_INSPIRATION:
 		behavior = new DarkInspirationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_LOOT_BUFF:
+	case BehaviorTemplate::LOOT_BUFF:
 		behavior = new LootBuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_VENTURE_VISION:
+	case BehaviorTemplate::VENTURE_VISION:
 		behavior = new VentureVisionBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SPAWN_OBJECT:
+	case BehaviorTemplate::SPAWN_OBJECT:
 		behavior = new SpawnBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_LAY_BRICK: break;
-	case BehaviorTemplates::BEHAVIOR_SWITCH:
+	case BehaviorTemplate::LAY_BRICK: break;
+	case BehaviorTemplate::SWITCH:
 		behavior = new SwitchBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_BUFF:
+	case BehaviorTemplate::BUFF:
 		behavior = new BuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_JETPACK:
+	case BehaviorTemplate::JETPACK:
 		behavior = new JetPackBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SKILL_EVENT:
+	case BehaviorTemplate::SKILL_EVENT:
 		behavior = new SkillEventBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CONSUME_ITEM:
+	case BehaviorTemplate::CONSUME_ITEM:
 		behavior = new ConsumeItemBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SKILL_CAST_FAILED:
+	case BehaviorTemplate::SKILL_CAST_FAILED:
 		behavior = new SkillCastFailedBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_IMITATION_SKUNK_STINK: break;
-	case BehaviorTemplates::BEHAVIOR_CHANGE_IDLE_FLAGS:
+	case BehaviorTemplate::IMITATION_SKUNK_STINK: break;
+	case BehaviorTemplate::CHANGE_IDLE_FLAGS:
 		behavior = new ChangeIdleFlagsBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_APPLY_BUFF:
+	case BehaviorTemplate::APPLY_BUFF:
 		behavior = new ApplyBuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CHAIN:
+	case BehaviorTemplate::CHAIN:
 		behavior = new ChainBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_CHANGE_ORIENTATION:
+	case BehaviorTemplate::CHANGE_ORIENTATION:
 		behavior = new ChangeOrientationBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_FORCE_MOVEMENT:
+	case BehaviorTemplate::FORCE_MOVEMENT:
 		behavior = new ForceMovementBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_INTERRUPT:
+	case BehaviorTemplate::INTERRUPT:
 		behavior = new InterruptBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_ALTER_COOLDOWN: break;
-	case BehaviorTemplates::BEHAVIOR_CHARGE_UP:
+	case BehaviorTemplate::ALTER_COOLDOWN: break;
+	case BehaviorTemplate::CHARGE_UP:
 		behavior = new ChargeUpBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SWITCH_MULTIPLE:
+	case BehaviorTemplate::SWITCH_MULTIPLE:
 		behavior = new SwitchMultipleBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_START:
+	case BehaviorTemplate::START:
 		behavior = new StartBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_END:
+	case BehaviorTemplate::END:
 		behavior = new EndBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_ALTER_CHAIN_DELAY: break;
-	case BehaviorTemplates::BEHAVIOR_CAMERA: break;
-	case BehaviorTemplates::BEHAVIOR_REMOVE_BUFF:
+	case BehaviorTemplate::ALTER_CHAIN_DELAY: break;
+	case BehaviorTemplate::CAMERA: break;
+	case BehaviorTemplate::REMOVE_BUFF:
 		behavior = new RemoveBuffBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_GRAB: break;
-	case BehaviorTemplates::BEHAVIOR_MODULAR_BUILD: break;
-	case BehaviorTemplates::BEHAVIOR_NPC_COMBAT_SKILL:
+	case BehaviorTemplate::GRAB: break;
+	case BehaviorTemplate::MODULAR_BUILD: break;
+	case BehaviorTemplate::NPC_COMBAT_SKILL:
 		behavior = new NpcCombatSkillBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_BLOCK:
+	case BehaviorTemplate::BLOCK:
 		behavior = new BlockBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_VERIFY:
+	case BehaviorTemplate::VERIFY:
 		behavior = new VerifyBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TAUNT:
+	case BehaviorTemplate::TAUNT:
 		behavior = new TauntBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_AIR_MOVEMENT:
+	case BehaviorTemplate::AIR_MOVEMENT:
 		behavior = new AirMovementBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_SPAWN_QUICKBUILD:
+	case BehaviorTemplate::SPAWN_QUICKBUILD:
 		behavior = new SpawnBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PULL_TO_POINT:
+	case BehaviorTemplate::PULL_TO_POINT:
 		behavior = new PullToPointBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROPERTY_ROTATE: break;
-	case BehaviorTemplates::BEHAVIOR_DAMAGE_REDUCTION:
+	case BehaviorTemplate::PROPERTY_ROTATE: break;
+	case BehaviorTemplate::DAMAGE_REDUCTION:
 		behavior = new DamageReductionBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROPERTY_TELEPORT:
+	case BehaviorTemplate::PROPERTY_TELEPORT:
 		behavior = new PropertyTeleportBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_PROPERTY_CLEAR_TARGET:
+	case BehaviorTemplate::PROPERTY_CLEAR_TARGET:
 		behavior = new ClearTargetBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_TAKE_PICTURE: break;
-	case BehaviorTemplates::BEHAVIOR_MOUNT: break;
-	case BehaviorTemplates::BEHAVIOR_SKILL_SET: break;
+	case BehaviorTemplate::TAKE_PICTURE: break;
+	case BehaviorTemplate::MOUNT: break;
+	case BehaviorTemplate::SKILL_SET: break;
 	default:
 		//LOG("Failed to load behavior with invalid template id (%i)!", templateId);
 		break;
@@ -296,19 +296,19 @@ Behavior* Behavior::CreateBehavior(const uint32_t behaviorId) {
 	return behavior;
 }
 
-BehaviorTemplates Behavior::GetBehaviorTemplate(const uint32_t behaviorId) {
+BehaviorTemplate Behavior::GetBehaviorTemplate(const uint32_t behaviorId) {
 	auto behaviorTemplateTable = CDClientManager::GetTable<CDBehaviorTemplateTable>();
 
-	BehaviorTemplates templateID = BehaviorTemplates::BEHAVIOR_EMPTY;
+	BehaviorTemplate templateID = BehaviorTemplate::EMPTY;
 	// Find behavior template by its behavior id.  Default to 0.
 	if (behaviorTemplateTable) {
 		auto templateEntry = behaviorTemplateTable->GetByBehaviorID(behaviorId);
 		if (templateEntry.behaviorID == behaviorId) {
-			templateID = static_cast<BehaviorTemplates>(templateEntry.templateID);
+			templateID = static_cast<BehaviorTemplate>(templateEntry.templateID);
 		}
 	}
 
-	if (templateID == BehaviorTemplates::BEHAVIOR_EMPTY && behaviorId != 0) {
+	if (templateID == BehaviorTemplate::EMPTY && behaviorId != 0) {
 		LOG("Failed to load behavior template with id (%i)!", behaviorId);
 	}
 
@@ -335,26 +335,22 @@ void Behavior::PlayFx(std::u16string type, const LWOOBJID target, const LWOOBJID
 
 	const auto typeString = GeneralUtils::UTF16ToWTF8(type);
 
-	if (m_effectNames == nullptr) {
-		m_effectNames = new std::unordered_map<std::string, std::string>();
-	} else {
-		const auto pair = m_effectNames->find(typeString);
+	const auto itr = m_effectNames.find(typeString);
 
-		if (type.empty()) {
-			type = GeneralUtils::ASCIIToUTF16(*m_effectType);
-		}
+	if (type.empty()) {
+		type = GeneralUtils::ASCIIToUTF16(m_effectType);
+	}
 
-		if (pair != m_effectNames->end()) {
-			if (renderComponent == nullptr) {
-				GameMessages::SendPlayFXEffect(targetEntity, effectId, type, pair->second, secondary, 1, 1, true);
-
-				return;
-			}
-
-			renderComponent->PlayEffect(effectId, type, pair->second, secondary);
+	if (itr != m_effectNames.end()) {
+		if (renderComponent == nullptr) {
+			GameMessages::SendPlayFXEffect(targetEntity, effectId, type, itr->second, secondary, 1, 1, true);
 
 			return;
 		}
+
+		renderComponent->PlayEffect(effectId, type, itr->second, secondary);
+
+		return;
 	}
 
 	// The SQlite result object becomes invalid if the query object leaves scope.
@@ -388,12 +384,12 @@ void Behavior::PlayFx(std::u16string type, const LWOOBJID target, const LWOOBJID
 
 		type = GeneralUtils::ASCIIToUTF16(typeResult);
 
-		m_effectType = new std::string(typeResult);
+		m_effectType = typeResult;
 	}
 
 	result.finalize();
 
-	m_effectNames->insert_or_assign(typeString, name);
+	m_effectNames.insert_or_assign(typeString, name);
 
 	if (renderComponent == nullptr) {
 		GameMessages::SendPlayFXEffect(targetEntity, effectId, type, name, secondary, 1, 1, true);
@@ -423,8 +419,7 @@ Behavior::Behavior(const uint32_t behaviorId) {
 
 	if (behaviorId == 0) {
 		this->m_effectId = 0;
-		this->m_effectHandle = nullptr;
-		this->m_templateId = BehaviorTemplates::BEHAVIOR_EMPTY;
+		this->m_templateId = BehaviorTemplate::EMPTY;
 	}
 
 	// Make sure we do not proceed if we are trying to load an invalid behavior
@@ -432,17 +427,16 @@ Behavior::Behavior(const uint32_t behaviorId) {
 		LOG("Failed to load behavior with id (%i)!", behaviorId);
 
 		this->m_effectId = 0;
-		this->m_effectHandle = nullptr;
-		this->m_templateId = BehaviorTemplates::BEHAVIOR_EMPTY;
+		this->m_templateId = BehaviorTemplate::EMPTY;
 
 		return;
 	}
 
-	this->m_templateId = static_cast<BehaviorTemplates>(templateInDatabase.templateID);
+	this->m_templateId = static_cast<BehaviorTemplate>(templateInDatabase.templateID);
 
 	this->m_effectId = templateInDatabase.effectID;
 
-	this->m_effectHandle = *templateInDatabase.effectHandle != "" ? new std::string(*templateInDatabase.effectHandle) : nullptr;
+	this->m_effectHandle = *templateInDatabase.effectHandle;
 }
 
 
@@ -507,9 +501,3 @@ void Behavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream,
 
 void Behavior::SyncCalculation(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 }
-
-Behavior::~Behavior() {
-	delete m_effectNames;
-	delete m_effectType;
-	delete m_effectHandle;
-}

dGame/dBehaviors/Behavior.h

@@ -6,7 +6,7 @@
 #include <unordered_map>
 
 #include "BitStream.h"
-#include "BehaviorTemplates.h"
+#include "BehaviorTemplate.h"
 #include "dCommonVars.h"
 
 struct BehaviorContext;
@@ -26,7 +26,7 @@ public:
 
 	static Behavior* CreateBehavior(uint32_t behaviorId);
 
-	static BehaviorTemplates GetBehaviorTemplate(uint32_t behaviorId);
+	static BehaviorTemplate GetBehaviorTemplate(uint32_t behaviorId);
 
 	/*
 	 * Utilities
@@ -39,11 +39,11 @@ public:
 	 */
 
 	uint32_t m_behaviorId;
-	BehaviorTemplates m_templateId;
+	BehaviorTemplate m_templateId;
 	uint32_t m_effectId;
-	std::string* m_effectHandle = nullptr;
-	std::unordered_map<std::string, std::string>* m_effectNames = nullptr;
-	std::string* m_effectType = nullptr;
+	std::string m_effectHandle;
+	std::unordered_map<std::string, std::string> m_effectNames;
+	std::string m_effectType;
 
 	/*
 	 * Behavior parameters
@@ -88,5 +88,11 @@ public:
 	 */
 
 	explicit Behavior(uint32_t behaviorId);
-	virtual ~Behavior();
+	virtual ~Behavior() = default;
+
+	Behavior(const Behavior& other) = default;
+	Behavior(Behavior&& other) = default;
+
+	Behavior& operator=(const Behavior& other) = default;
+	Behavior& operator=(Behavior&& other) = default;
 };

dGame/dBehaviors/BehaviorTemplate.h

@@ -0,0 +1,70 @@
+#pragma once
+
+enum class BehaviorTemplate : unsigned int {
+	EMPTY, // Not a real behavior, indicates invalid behaviors
+	BASIC_ATTACK,
+	TAC_ARC,
+	AND,
+	PROJECTILE_ATTACK,
+	HEAL,
+	MOVEMENT_SWITCH,
+	AREA_OF_EFFECT,
+	PLAY_EFFECT,
+	IMMUNITY,
+	DAMAGE_BUFF,
+	DAMAGE_ABSORBTION,
+	OVER_TIME,
+	IMAGINATION,
+	TARGET_CASTER,
+	STUN,
+	DURATION,
+	KNOCKBACK,
+	ATTACK_DELAY,
+	CAR_BOOST,
+	FALL_SPEED,
+	SHIELD,
+	REPAIR_ARMOR,
+	SPEED,
+	DARK_INSPIRATION,
+	LOOT_BUFF,
+	VENTURE_VISION,
+	SPAWN_OBJECT,
+	LAY_BRICK,
+	SWITCH,
+	BUFF,
+	JETPACK,
+	SKILL_EVENT,
+	CONSUME_ITEM,
+	SKILL_CAST_FAILED,
+	IMITATION_SKUNK_STINK,
+	CHANGE_IDLE_FLAGS,
+	APPLY_BUFF,
+	CHAIN,
+	CHANGE_ORIENTATION,
+	FORCE_MOVEMENT,
+	INTERRUPT,
+	ALTER_COOLDOWN,
+	CHARGE_UP,
+	SWITCH_MULTIPLE,
+	START,
+	END,
+	ALTER_CHAIN_DELAY,
+	CAMERA,
+	REMOVE_BUFF,
+	GRAB,
+	MODULAR_BUILD,
+	NPC_COMBAT_SKILL,
+	BLOCK,
+	VERIFY,
+	TAUNT,
+	AIR_MOVEMENT,
+	SPAWN_QUICKBUILD,
+	PULL_TO_POINT,
+	PROPERTY_ROTATE,
+	DAMAGE_REDUCTION,
+	PROPERTY_TELEPORT,
+	PROPERTY_CLEAR_TARGET,
+	TAKE_PICTURE,
+	MOUNT,
+	SKILL_SET
+};

dGame/dBehaviors/BehaviorTemplates.cpp

@@ -1 +0,0 @@
-#include "BehaviorTemplates.h"

dGame/dBehaviors/BehaviorTemplates.h

@@ -1,70 +0,0 @@
-#pragma once
-
-enum class BehaviorTemplates : unsigned int {
-	BEHAVIOR_EMPTY, // Not a real behavior, indicates invalid behaviors
-	BEHAVIOR_BASIC_ATTACK,
-	BEHAVIOR_TAC_ARC,
-	BEHAVIOR_AND,
-	BEHAVIOR_PROJECTILE_ATTACK,
-	BEHAVIOR_HEAL,
-	BEHAVIOR_MOVEMENT_SWITCH,
-	BEHAVIOR_AREA_OF_EFFECT,
-	BEHAVIOR_PLAY_EFFECT,
-	BEHAVIOR_IMMUNITY,
-	BEHAVIOR_DAMAGE_BUFF,
-	BEHAVIOR_DAMAGE_ABSORBTION,
-	BEHAVIOR_OVER_TIME,
-	BEHAVIOR_IMAGINATION,
-	BEHAVIOR_TARGET_CASTER,
-	BEHAVIOR_STUN,
-	BEHAVIOR_DURATION,
-	BEHAVIOR_KNOCKBACK,
-	BEHAVIOR_ATTACK_DELAY,
-	BEHAVIOR_CAR_BOOST,
-	BEHAVIOR_FALL_SPEED,
-	BEHAVIOR_SHIELD,
-	BEHAVIOR_REPAIR_ARMOR,
-	BEHAVIOR_SPEED,
-	BEHAVIOR_DARK_INSPIRATION,
-	BEHAVIOR_LOOT_BUFF,
-	BEHAVIOR_VENTURE_VISION,
-	BEHAVIOR_SPAWN_OBJECT,
-	BEHAVIOR_LAY_BRICK,
-	BEHAVIOR_SWITCH,
-	BEHAVIOR_BUFF,
-	BEHAVIOR_JETPACK,
-	BEHAVIOR_SKILL_EVENT,
-	BEHAVIOR_CONSUME_ITEM,
-	BEHAVIOR_SKILL_CAST_FAILED,
-	BEHAVIOR_IMITATION_SKUNK_STINK,
-	BEHAVIOR_CHANGE_IDLE_FLAGS,
-	BEHAVIOR_APPLY_BUFF,
-	BEHAVIOR_CHAIN,
-	BEHAVIOR_CHANGE_ORIENTATION,
-	BEHAVIOR_FORCE_MOVEMENT,
-	BEHAVIOR_INTERRUPT,
-	BEHAVIOR_ALTER_COOLDOWN,
-	BEHAVIOR_CHARGE_UP,
-	BEHAVIOR_SWITCH_MULTIPLE,
-	BEHAVIOR_START,
-	BEHAVIOR_END,
-	BEHAVIOR_ALTER_CHAIN_DELAY,
-	BEHAVIOR_CAMERA,
-	BEHAVIOR_REMOVE_BUFF,
-	BEHAVIOR_GRAB,
-	BEHAVIOR_MODULAR_BUILD,
-	BEHAVIOR_NPC_COMBAT_SKILL,
-	BEHAVIOR_BLOCK,
-	BEHAVIOR_VERIFY,
-	BEHAVIOR_TAUNT,
-	BEHAVIOR_AIR_MOVEMENT,
-	BEHAVIOR_SPAWN_QUICKBUILD,
-	BEHAVIOR_PULL_TO_POINT,
-	BEHAVIOR_PROPERTY_ROTATE,
-	BEHAVIOR_DAMAGE_REDUCTION,
-	BEHAVIOR_PROPERTY_TELEPORT,
-	BEHAVIOR_PROPERTY_CLEAR_TARGET,
-	BEHAVIOR_TAKE_PICTURE,
-	BEHAVIOR_MOUNT,
-	BEHAVIOR_SKILL_SET
-};

dGame/dBehaviors/CMakeLists.txt

@@ -7,7 +7,6 @@ set(DGAME_DBEHAVIORS_SOURCES "AirMovementBehavior.cpp"
 	"Behavior.cpp"
 	"BehaviorBranchContext.cpp"
 	"BehaviorContext.cpp"
-	"BehaviorTemplates.cpp"
 	"BlockBehavior.cpp"
 	"BuffBehavior.cpp"
 	"CarBoostBehavior.cpp"

dGame/dBehaviors/ForceMovementBehavior.cpp

@@ -7,7 +7,7 @@
 #include "Logger.h"
 
 void ForceMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
-	if (this->m_hitAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
+	if (this->m_hitAction->m_templateId == BehaviorTemplate::EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplate::EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplate::EMPTY) {
 		return;
 	}
 
@@ -38,7 +38,7 @@ void ForceMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream& bi
 }
 
 void ForceMovementBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
-	if (this->m_hitAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
+	if (this->m_hitAction->m_templateId == BehaviorTemplate::EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplate::EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplate::EMPTY) {
 		return;
 	}
 

dGame/dBehaviors/InterruptBehavior.cpp

@@ -8,36 +8,50 @@
 
 
 void InterruptBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
-	if (branch.target != context->originator) {
-		bool unknown = false;
+	LWOOBJID usedTarget = m_target ? branch.target : context->originator;
 
-		if (!bitStream.Read(unknown)) {
-			LOG("Unable to read unknown1 from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
+	if (usedTarget != context->originator) {
+		bool isTargetImmuneStuns = false;
+		if (!bitStream.Read(isTargetImmuneStuns)) {
+			LOG("Unable to read isTargetImmune from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
 			return;
 		};
 
-		if (unknown) return;
+		if (isTargetImmuneStuns) return;
 	}
 
 	if (!this->m_interruptBlock) {
-		bool unknown = false;
-
-		if (!bitStream.Read(unknown)) {
-			LOG("Unable to read unknown2 from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
+		bool isBlockingInterrupts = false;
+		if (!bitStream.Read(isBlockingInterrupts)) {
+			LOG("Unable to read isBlockingInterrupts from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
 			return;
 		};
 
-		if (unknown) return;
+		if (isBlockingInterrupts) return;
 	}
 
-	if (this->m_target) // Guess...
-	{
-		bool unknown = false;
+	bool hasInterruptedStatusEffects = false;
+	if (!bitStream.Read(hasInterruptedStatusEffects)) {
+		LOG("Unable to read hasInterruptedStatusEffects from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
+		return;
+	};
 
-		if (!bitStream.Read(unknown)) {
-			LOG("Unable to read unknown3 from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
-			return;
-		};
+	if (hasInterruptedStatusEffects) {
+		bool hasMoreInterruptedStatusEffects = false;
+		int32_t loopLimit = 0;
+		while (bitStream.Read(hasMoreInterruptedStatusEffects) && hasMoreInterruptedStatusEffects) {
+			int32_t statusEffectID = 0;
+			bitStream.Read(statusEffectID);
+			// nothing happens with this data yes.  I have no idea why or what it was used for, but the client literally just reads it and does nothing with it.
+			// 0x004faca4 for a reference.  it also has a hard loop limit of 100 soo,
+			loopLimit++;
+			if (loopLimit > 100) {
+				// if this is hit you have a problem
+				LOG("Loop limit reached for interrupted status effects, aborting Handle due to bad bitstream! %i", bitStream.GetNumberOfUnreadBits());
+				break;
+			}
+			LOG_DEBUG("Interrupted status effect ID: %i", statusEffectID);
+		}
 	}
 
 	if (branch.target == context->originator) return;
@@ -55,7 +69,8 @@ void InterruptBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitS
 
 
 void InterruptBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
-	if (branch.target != context->originator) {
+	LWOOBJID usedTarget = m_target ? branch.target : context->originator;
+	if (usedTarget != context->originator) {
 		bitStream.Write(false);
 	}
 

dGame/dBehaviors/MovementSwitchBehavior.cpp

@@ -6,13 +6,13 @@
 void MovementSwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
 	uint32_t movementType{};
 	if (!bitStream.Read(movementType)) {
-		if (this->m_groundAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY &&
-			this->m_jumpAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY &&
-			this->m_fallingAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY &&
-			this->m_doubleJumpAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY &&
-			this->m_airAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY &&
-			this->m_jetpackAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY &&
-			this->m_movingAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
+		if (this->m_groundAction->m_templateId == BehaviorTemplate::EMPTY &&
+			this->m_jumpAction->m_templateId == BehaviorTemplate::EMPTY &&
+			this->m_fallingAction->m_templateId == BehaviorTemplate::EMPTY &&
+			this->m_doubleJumpAction->m_templateId == BehaviorTemplate::EMPTY &&
+			this->m_airAction->m_templateId == BehaviorTemplate::EMPTY &&
+			this->m_jetpackAction->m_templateId == BehaviorTemplate::EMPTY &&
+			this->m_movingAction->m_templateId == BehaviorTemplate::EMPTY) {
 			return;
 		}
 		LOG("Unable to read movementType from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
@@ -47,7 +47,7 @@ void MovementSwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream&
 Behavior* MovementSwitchBehavior::LoadMovementType(std::string movementType) {
 	float actionValue = GetFloat(movementType, -1.0f);
 	auto loadedBehavior = GetAction(actionValue != -1.0f ? actionValue : 0.0f);
-	if (actionValue == -1.0f && loadedBehavior->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
+	if (actionValue == -1.0f && loadedBehavior->m_templateId == BehaviorTemplate::EMPTY) {
 		loadedBehavior = this->m_groundAction;
 	}
 	return loadedBehavior;

dGame/dBehaviors/SkillEventBehavior.cpp

@@ -9,17 +9,16 @@ void SkillEventBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bit
 	auto* target = Game::entityManager->GetEntity(branch.target);
 	auto* caster = Game::entityManager->GetEntity(context->originator);
 
-	if (caster != nullptr && target != nullptr && this->m_effectHandle != nullptr && !this->m_effectHandle->empty()) {
-		target->GetScript()->OnSkillEventFired(target, caster, *this->m_effectHandle);
+	if (caster != nullptr && target != nullptr && !this->m_effectHandle.empty()) {
+		target->GetScript()->OnSkillEventFired(target, caster, this->m_effectHandle);
 	}
 }
 
-void
-SkillEventBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
+void SkillEventBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
 	auto* target = Game::entityManager->GetEntity(branch.target);
 	auto* caster = Game::entityManager->GetEntity(context->originator);
 
-	if (caster != nullptr && target != nullptr && this->m_effectHandle != nullptr && !this->m_effectHandle->empty()) {
-		target->GetScript()->OnSkillEventFired(target, caster, *this->m_effectHandle);
+	if (caster != nullptr && target != nullptr && !this->m_effectHandle.empty()) {
+		target->GetScript()->OnSkillEventFired(target, caster, this->m_effectHandle);
 	}
 }

dGame/dBehaviors/SwitchBehavior.cpp

@@ -7,9 +7,9 @@
 #include "BuffComponent.h"
 
 void SwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
-	auto state = true;
+	bool state = true;
 
-	if (this->m_imagination > 0 || !this->m_isEnemyFaction) {
+	if (m_imagination > 0 || m_targetHasBuff > 0 || m_Distance > -1.0f) {
 		if (!bitStream.Read(state)) {
 			LOG("Unable to read state from bitStream, aborting Handle! %i", bitStream.GetNumberOfUnreadBits());
 			return;
@@ -18,49 +18,59 @@ void SwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStre
 
 	auto* entity = Game::entityManager->GetEntity(context->originator);
 
-	if (entity == nullptr) {
-		return;
-	}
+	if (!entity) return;
 
 	auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
 
-	if (destroyableComponent == nullptr) {
-		return;
+	if (destroyableComponent) {
+		if (m_isEnemyFaction) {
+			auto* target = Game::entityManager->GetEntity(branch.target);
+			if (target) state = destroyableComponent->IsEnemy(target);
+		}
+
+		LOG_DEBUG("[%i] State: (%d), imagination: (%i) / (%f)", entity->GetLOT(), state, destroyableComponent->GetImagination(), destroyableComponent->GetMaxImagination());
 	}
 
-	LOG_DEBUG("[%i] State: (%d), imagination: (%i) / (%f)", entity->GetLOT(), state, destroyableComponent->GetImagination(), destroyableComponent->GetMaxImagination());
-
-	if (state) {
-		this->m_actionTrue->Handle(context, bitStream, branch);
-	} else {
-		this->m_actionFalse->Handle(context, bitStream, branch);
-	}
+	auto* behaviorToCall = state ? m_actionTrue : m_actionFalse;
+	behaviorToCall->Handle(context, bitStream, branch);
 }
 
 void SwitchBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, BehaviorBranchContext branch) {
-	auto state = true;
-
-	if (this->m_imagination > 0 || !this->m_isEnemyFaction) {
+	bool state = true;
+	if (m_imagination > 0 || m_targetHasBuff > 0 || m_Distance > -1.0f) {
 		auto* entity = Game::entityManager->GetEntity(branch.target);
 
 		state = entity != nullptr;
 
-		if (state && m_targetHasBuff != 0) {
-			auto* buffComponent = entity->GetComponent<BuffComponent>();
+		if (state) {
+			if (m_targetHasBuff != 0) {
+				auto* buffComponent = entity->GetComponent<BuffComponent>();
 
-			if (buffComponent != nullptr && !buffComponent->HasBuff(m_targetHasBuff)) {
-				state = false;
+				if (buffComponent != nullptr && !buffComponent->HasBuff(m_targetHasBuff)) {
+					state = false;
+				}
+			} else if (m_imagination > 0) {
+				auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
+
+				if (destroyableComponent && destroyableComponent->GetImagination() < m_imagination) {
+					state = false;
+				}
+			} else if (m_Distance > -1.0f) {
+				auto* originator = Game::entityManager->GetEntity(context->originator);
+
+				if (originator) {
+					const auto distance = (originator->GetPosition() - entity->GetPosition()).Length();
+
+					state = distance <= m_Distance;
+				}
 			}
 		}
 
 		bitStream.Write(state);
 	}
 
-	if (state) {
-		this->m_actionTrue->Calculate(context, bitStream, branch);
-	} else {
-		this->m_actionFalse->Calculate(context, bitStream, branch);
-	}
+	auto* behaviorToCall = state ? m_actionTrue : m_actionFalse;
+	behaviorToCall->Calculate(context, bitStream, branch);
 }
 
 void SwitchBehavior::Load() {
@@ -72,5 +82,7 @@ void SwitchBehavior::Load() {
 
 	this->m_isEnemyFaction = GetBoolean("isEnemyFaction");
 
-	this->m_targetHasBuff = GetInt("target_has_buff");
+	this->m_targetHasBuff = GetInt("target_has_buff", -1);
+
+	this->m_Distance = GetFloat("distance", -1.0f);
 }

dGame/dBehaviors/SwitchBehavior.h

@@ -14,6 +14,8 @@ public:
 
 	int32_t m_targetHasBuff;
 
+	float m_Distance;
+
 	/*
 	 * Inherited
 	 */

dGame/dComponents/AchievementVendorComponent.cpp

@@ -9,11 +9,15 @@
 #include "UserManager.h"
 #include "CDMissionsTable.h"
 
+AchievementVendorComponent::AchievementVendorComponent(Entity* parent) : VendorComponent(parent) {
+	RefreshInventory(true);
+};
+
 bool AchievementVendorComponent::SellsItem(Entity* buyer, const LOT lot) {
 	auto* missionComponent = buyer->GetComponent<MissionComponent>();
 	if (!missionComponent) return false;
 
-	if (m_PlayerPurchasableItems[buyer->GetObjectID()].contains(lot)){
+	if (m_PlayerPurchasableItems[buyer->GetObjectID()].contains(lot)) {
 		return true;
 	}
 
@@ -35,7 +39,7 @@ void AchievementVendorComponent::Buy(Entity* buyer, LOT lot, uint32_t count) {
 	int itemCompID = compRegistryTable->GetByIDAndType(lot, eReplicaComponentType::ITEM);
 	CDItemComponent itemComp = itemComponentTable->GetItemComponentByID(itemCompID);
 	uint32_t costLOT = itemComp.commendationLOT;
-	
+
 	if (costLOT == -1 || !SellsItem(buyer, lot)) {
 		auto* user = UserManager::Instance()->GetUser(buyer->GetSystemAddress());
 		CheatDetection::ReportCheat(user, buyer->GetSystemAddress(), "Attempted to buy item %i from achievement vendor %i that is not purchasable", lot, m_Parent->GetLOT());
@@ -44,7 +48,7 @@ void AchievementVendorComponent::Buy(Entity* buyer, LOT lot, uint32_t count) {
 	}
 
 	auto* inventoryComponent = buyer->GetComponent<InventoryComponent>();
-	if (!inventoryComponent)  {
+	if (!inventoryComponent) {
 		GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_FAIL);
 		return;
 	}
@@ -69,4 +73,9 @@ void AchievementVendorComponent::Buy(Entity* buyer, LOT lot, uint32_t count) {
 	inventoryComponent->AddItem(lot, count, eLootSourceType::VENDOR);
 	GameMessages::SendVendorTransactionResult(buyer, buyer->GetSystemAddress(), eVendorTransactionResult::PURCHASE_SUCCESS);
 
-}
+}
+
+void AchievementVendorComponent::RefreshInventory(bool isCreation) {
+	SetHasStandardCostItems(true);
+	Game::entityManager->SerializeEntity(m_Parent);
+}

dGame/dComponents/AchievementVendorComponent.h

@@ -11,7 +11,9 @@ class Entity;
 class AchievementVendorComponent final : public VendorComponent {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::ACHIEVEMENT_VENDOR;
-	AchievementVendorComponent(Entity* parent) : VendorComponent(parent) {};
+	AchievementVendorComponent(Entity* parent);
+	
+	void RefreshInventory(bool isCreation = false) override;
 	bool SellsItem(Entity* buyer, const LOT lot);
 	void Buy(Entity* buyer, LOT lot, uint32_t count);
 

dGame/dComponents/ActivityComponent.cpp

@@ -21,7 +21,7 @@
 #include "eMissionTaskType.h"
 #include "eMatchUpdate.h"
 #include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.h"
 
 #include "CDCurrencyTableTable.h"
 #include "CDActivityRewardsTable.h"
@@ -501,7 +501,7 @@ void ActivityInstance::StartZone() {
 	// only make a team if we have more than one participant
 	if (participants.size() > 1) {
 		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::CREATE_TEAM);
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::CREATE_TEAM);
 
 		bitStream.Write(leader->GetObjectID());
 		bitStream.Write(m_Participants.size());

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -150,19 +150,18 @@ 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
 	if (m_TetherEffectActive) {
 		m_TetherTime -= deltaTime;
-		const auto& info = m_MovementAI->GetInfo();
 		if (m_Target != LWOOBJID_EMPTY || (NiPoint3::DistanceSquared(
 			m_StartPosition,
 			m_Parent->GetPosition()) < 20 * 20 && m_TetherTime <= 0)

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -26,7 +26,6 @@ ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : Phy
 	m_SpeedMultiplier = 1;
 	m_GravityScale = 1;
 	m_DirtyCheats = false;
-	m_IgnoreMultipliers = false;
 
 	m_DirtyEquippedItemInfo = true;
 	m_PickupRadius = 0.0f;
@@ -92,31 +91,31 @@ void ControllablePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bo
 		outBitStream.Write(m_ImmuneToStunInteractCount);
 	}
 
-	if (m_IgnoreMultipliers) m_DirtyCheats = false;
-
-	outBitStream.Write(m_DirtyCheats);
-	if (m_DirtyCheats) {
+	outBitStream.Write(m_DirtyCheats || bIsInitialUpdate);
+	if (m_DirtyCheats || bIsInitialUpdate) {
 		outBitStream.Write(m_GravityScale);
 		outBitStream.Write(m_SpeedMultiplier);
 
-		m_DirtyCheats = false;
+		if (!bIsInitialUpdate) m_DirtyCheats = false;
 	}
 
-	outBitStream.Write(m_DirtyEquippedItemInfo);
-	if (m_DirtyEquippedItemInfo) {
+	outBitStream.Write(m_DirtyEquippedItemInfo || bIsInitialUpdate);
+	if (m_DirtyEquippedItemInfo || bIsInitialUpdate) {
 		outBitStream.Write(m_PickupRadius);
 		outBitStream.Write(m_InJetpackMode);
-		m_DirtyEquippedItemInfo = false;
+
+		if (!bIsInitialUpdate) m_DirtyEquippedItemInfo = false;
 	}
 
-	outBitStream.Write(m_DirtyBubble);
-	if (m_DirtyBubble) {
+	outBitStream.Write(m_DirtyBubble || bIsInitialUpdate);
+	if (m_DirtyBubble || bIsInitialUpdate) {
 		outBitStream.Write(m_IsInBubble);
 		if (m_IsInBubble) {
 			outBitStream.Write(m_BubbleType);
 			outBitStream.Write(m_SpecialAnims);
 		}
-		m_DirtyBubble = false;
+
+		if (!bIsInitialUpdate) m_DirtyBubble = false;
 	}
 
 	outBitStream.Write(m_DirtyPosition || bIsInitialUpdate);
@@ -149,7 +148,8 @@ void ControllablePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bo
 			outBitStream.Write(m_AngularVelocity.z);
 		}
 
-		outBitStream.Write0();
+		outBitStream.Write0(); // local_space_info, always zero for now.
+
 		if (!bIsInitialUpdate) {
 			m_DirtyPosition = false;
 			outBitStream.Write(m_IsTeleporting);

dGame/dComponents/ControllablePhysicsComponent.h

@@ -174,18 +174,6 @@ public:
 	 */
 	const float GetGravityScale() const { return m_GravityScale; }
 
-	/**
-	 * Sets the ignore multipliers value, allowing you to skip the serialization of speed and gravity multipliers
-	 * @param value whether or not to ignore multipliers
-	 */
-	void SetIgnoreMultipliers(bool value) { m_IgnoreMultipliers = value; }
-
-	/**
-	 * Returns the current ignore multipliers value
-	 * @return the current ignore multipliers value
-	 */
-	const bool GetIgnoreMultipliers() const { return m_IgnoreMultipliers; }
-
 	/**
 	 * Can make an entity static, making it unable to move around
 	 * @param value whether or not the entity is static
@@ -353,11 +341,6 @@ private:
 	 */
 	bool m_DirtyCheats;
 
-	/**
-	 * Makes it so that the speed multiplier and gravity scale are no longer serialized if false
-	 */
-	bool m_IgnoreMultipliers;
-
 	/**
 	 * Whether this entity is static, making it unable to move
 	 */

dGame/dComponents/MovementAIComponent.cpp

@@ -50,9 +50,44 @@ MovementAIComponent::MovementAIComponent(Entity* parent, MovementAIInfo info) :
 	m_CurrentSpeed = 0;
 	m_MaxSpeed = 0;
 	m_LockRotation = false;
+	m_Path = nullptr;
+	m_SourcePosition = m_Parent->GetPosition();
+	m_Paused = false;
+	m_SavedVelocity = NiPoint3Constant::ZERO;
+
+	if (!m_Parent->GetComponent<BaseCombatAIComponent>()) SetPath(m_Parent->GetVarAsString(u"attached_path"));
+}
+
+void MovementAIComponent::SetPath(const std::string pathName) {
+	m_Path = Game::zoneManager->GetZone()->GetPath(pathName);
+	if (!pathName.empty()) LOG("WARNING: %s path %s", m_Path ? "Found" : "Failed to find", pathName.c_str());
+	if (!m_Path) return;
+	SetMaxSpeed(1);
+	SetCurrentSpeed(m_BaseSpeed);
+	SetPath(m_Path->pathWaypoints);
+}
+
+void MovementAIComponent::Pause() {
+	if (m_Paused) return;
+	m_Paused = true;
+	SetPosition(ApproximateLocation());
+	m_SavedVelocity = GetVelocity();
+	SetVelocity(NiPoint3Constant::ZERO);
+	Game::entityManager->SerializeEntity(m_Parent);
+}
+
+void MovementAIComponent::Resume() {
+	if (!m_Paused) return;
+	m_Paused = false;
+	SetVelocity(m_SavedVelocity);
+	m_SavedVelocity = NiPoint3Constant::ZERO;
+	SetRotation(NiQuaternion::LookAt(m_Parent->GetPosition(), m_NextWaypoint));
+	Game::entityManager->SerializeEntity(m_Parent);
 }
 
 void MovementAIComponent::Update(const float deltaTime) {
+	if (m_Paused) return;
+
 	if (m_PullingToPoint) {
 		const auto source = GetCurrentWaypoint();
 
@@ -81,64 +116,65 @@ void MovementAIComponent::Update(const float deltaTime) {
 	}
 
 	m_TimeTravelled += deltaTime;
+
+	SetPosition(ApproximateLocation());
+
 	if (m_TimeTravelled < m_TimeToTravel) return;
 	m_TimeTravelled = 0.0f;
 
 	const auto source = GetCurrentWaypoint();
 
 	SetPosition(source);
-
-	NiPoint3 velocity = NiPoint3Constant::ZERO;
+	m_SourcePosition = source;
 
 	if (m_Acceleration > 0 && m_BaseSpeed > 0 && AdvanceWaypointIndex()) // Do we have another waypoint to seek?
 	{
 		m_NextWaypoint = GetCurrentWaypoint();
-
 		if (m_NextWaypoint == source) {
 			m_TimeToTravel = 0.0f;
+		} else {
+			m_CurrentSpeed = std::min(m_CurrentSpeed + m_Acceleration, m_MaxSpeed);
 
-			goto nextAction;
+			const auto speed = m_CurrentSpeed * m_BaseSpeed; // scale speed based on base speed
+
+			const auto delta = m_NextWaypoint - source;
+
+			// Normalize the vector
+			const auto length = delta.Length();
+			if (length > 0.0f) {
+				SetVelocity((delta / length) * speed);
+			}
+
+			// Calclute the time it will take to reach the next waypoint with the current speed
+			m_TimeTravelled = 0.0f;
+			m_TimeToTravel = length / speed;
+
+			SetRotation(NiQuaternion::LookAt(source, m_NextWaypoint));
 		}
-
-		if (m_CurrentSpeed < m_MaxSpeed) {
-			m_CurrentSpeed += m_Acceleration;
-		}
-
-		if (m_CurrentSpeed > m_MaxSpeed) {
-			m_CurrentSpeed = m_MaxSpeed;
-		}
-
-		const auto speed = m_CurrentSpeed * m_BaseSpeed; // scale speed based on base speed
-
-		const auto delta = m_NextWaypoint - source;
-
-		// Normalize the vector
-		const auto length = delta.Length();
-		if (length > 0) {
-			velocity = (delta / length) * speed;
-		}
-
-		// Calclute the time it will take to reach the next waypoint with the current speed
-		m_TimeTravelled = 0.0f;
-		m_TimeToTravel = length / speed;
-
-		SetRotation(NiQuaternion::LookAt(source, m_NextWaypoint));
 	} else {
 		// Check if there are more waypoints in the queue, if so set our next destination to the next waypoint
 		if (m_CurrentPath.empty()) {
-			Stop();
-
-			return;
+			if (m_Path) {
+				if (m_Path->pathBehavior == PathBehavior::Loop) {
+					SetPath(m_Path->pathWaypoints);
+				} else if (m_Path->pathBehavior == PathBehavior::Bounce) {
+					std::vector<PathWaypoint> waypoints = m_Path->pathWaypoints;
+					std::reverse(waypoints.begin(), waypoints.end());
+					SetPath(waypoints);
+				} else if (m_Path->pathBehavior == PathBehavior::Once) {
+					Stop();
+					return;
+				}
+			} else {
+				Stop();
+				return;
+			}
 		}
-		SetDestination(m_CurrentPath.top());
+		SetDestination(m_CurrentPath.top().position);
 
 		m_CurrentPath.pop();
 	}
 
-nextAction:
-
-	SetVelocity(velocity);
-
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
@@ -161,7 +197,7 @@ NiPoint3 MovementAIComponent::GetCurrentWaypoint() const {
 }
 
 NiPoint3 MovementAIComponent::ApproximateLocation() const {
-	auto source = m_Parent->GetPosition();
+	auto source = m_SourcePosition;
 
 	if (AtFinalWaypoint()) return source;
 
@@ -227,13 +263,13 @@ void MovementAIComponent::PullToPoint(const NiPoint3& point) {
 	m_PullPoint = point;
 }
 
-void MovementAIComponent::SetPath(std::vector<NiPoint3> path) {
+void MovementAIComponent::SetPath(std::vector<PathWaypoint> path) {
 	if (path.empty()) return;
-	std::for_each(path.rbegin(), path.rend() - 1, [this](const NiPoint3& point) {
+	std::for_each(path.rbegin(), path.rend() - 1, [this](const PathWaypoint& point) {
 		this->m_CurrentPath.push(point);
 		});
 
-	SetDestination(path.front());
+	SetDestination(path.front().position);
 }
 
 float MovementAIComponent::GetBaseSpeed(LOT lot) {
@@ -278,6 +314,23 @@ void MovementAIComponent::SetRotation(const NiQuaternion& value) {
 	if (!m_LockRotation) m_Parent->SetRotation(value);
 }
 
+NiPoint3 MovementAIComponent::GetVelocity() const {
+	auto* controllablePhysicsComponent = m_Parent->GetComponent<ControllablePhysicsComponent>();
+
+	if (controllablePhysicsComponent != nullptr) {
+		return controllablePhysicsComponent->GetVelocity();
+	}
+
+	auto* simplePhysicsComponent = m_Parent->GetComponent<SimplePhysicsComponent>();
+
+	if (simplePhysicsComponent != nullptr) {
+		return simplePhysicsComponent->GetVelocity();
+	}
+
+	return NiPoint3Constant::ZERO;
+
+}
+
 void MovementAIComponent::SetVelocity(const NiPoint3& value) {
 	auto* controllablePhysicsComponent = m_Parent->GetComponent<ControllablePhysicsComponent>();
 
@@ -294,7 +347,7 @@ void MovementAIComponent::SetVelocity(const NiPoint3& value) {
 	}
 }
 
-void MovementAIComponent::SetDestination(const NiPoint3& destination) {
+void MovementAIComponent::SetDestination(const NiPoint3 destination) {
 	if (m_PullingToPoint) return;
 
 	const auto location = ApproximateLocation();
@@ -303,6 +356,8 @@ void MovementAIComponent::SetDestination(const NiPoint3& destination) {
 		SetPosition(location);
 	}
 
+	m_SourcePosition = location;
+
 	std::vector<NiPoint3> computedPath;
 	if (dpWorld::IsLoaded()) {
 		computedPath = dpWorld::GetNavMesh()->GetPath(m_Parent->GetPosition(), destination, m_Info.wanderSpeed);
@@ -319,8 +374,7 @@ void MovementAIComponent::SetDestination(const NiPoint3& destination) {
 		auto step = delta / 10.0f;
 
 		for (int i = 0; i < 10; i++) {
-			// TODO: Replace this with += when the NiPoint3::operator+= is fixed
-			start = start + step;
+			start += step;
 
 			computedPath.push_back(start);
 		}

dGame/dComponents/MovementAIComponent.h

@@ -14,11 +14,14 @@
 #include "Logger.h"
 #include "Component.h"
 #include "eReplicaComponentType.h"
+#include "Zone.h"
 #include <vector>
 
 class ControllablePhysicsComponent;
 class BaseCombatAIComponent;
 
+struct Path;
+
 /**
  * Information that describes the different variables used to make an entity move around
  */
@@ -61,6 +64,8 @@ public:
 
 	MovementAIComponent(Entity* parentEntity, MovementAIInfo info);
 
+	void SetPath(const std::string pathName);
+
 	void Update(float deltaTime) override;
 
 	/**
@@ -73,7 +78,7 @@ public:
 	 * Set a destination point for the entity to move towards
 	 * @param value the destination point to move towards
 	 */
-	void SetDestination(const NiPoint3& value);
+	void SetDestination(const NiPoint3 value);
 
 	/**
 	 * Returns the current rotation this entity is moving towards
@@ -189,7 +194,13 @@ public:
 	 * Sets a path to follow for the AI
 	 * @param path the path to follow
 	 */
-	void SetPath(std::vector<NiPoint3> path);
+	void SetPath(std::vector<PathWaypoint> path);
+
+	void Pause();
+
+	void Resume();
+
+	NiPoint3 GetVelocity() const;
 
 	/**
 	 * Returns the base speed from the DB for a given LOT
@@ -301,7 +312,15 @@ private:
 	/**
 	 * The path from the current position to the destination.
 	 */
-	std::stack<NiPoint3> m_CurrentPath;
+	std::stack<PathWaypoint> m_CurrentPath;
+
+	const Path* m_Path = nullptr;
+
+	NiPoint3 m_SourcePosition;
+
+	bool m_Paused;
+
+	NiPoint3 m_SavedVelocity;
 };
 
 #endif // MOVEMENTAICOMPONENT_H

dGame/dComponents/PetComponent.h

@@ -353,7 +353,6 @@ private:
 
 	/**
 	 * Pet information loaded from the CDClientDatabase
-	 * TODO: Switch to a reference when safe to do so
 	 */
 	CDPetComponent m_PetInfo;
 };

dGame/dComponents/PhantomPhysicsComponent.cpp

@@ -187,7 +187,7 @@ PhantomPhysicsComponent::PhantomPhysicsComponent(Entity* parent) : PhysicsCompon
 			//add fallback cube:
 			m_dpEntity = new dpEntity(m_Parent->GetObjectID(), 2.0f, 2.0f, 2.0f);
 		}
-	
+
 		m_dpEntity->SetScale(m_Scale);
 		m_dpEntity->SetRotation(m_Rotation);
 		m_dpEntity->SetPosition(m_Position);
@@ -323,14 +323,13 @@ 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 +340,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);
 	}
 }
 

dGame/dComponents/PropertyManagementComponent.cpp

@@ -352,16 +352,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,29 +580,17 @@ 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));
 		}
 
 		node->config = settings;

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,40 +38,41 @@ 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) {
 	for (const auto& prox : m_ProximitiesData) {
 		if (!prox.second) continue;
 
+		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/TriggerComponent.cpp

@@ -15,8 +15,9 @@
 #include "PlayerManager.h"
 #include "Game.h"
 #include "EntityManager.h"
+#include "MovementAIComponent.h"
 
-TriggerComponent::TriggerComponent(Entity* parent, const std::string triggerInfo): Component(parent) {
+TriggerComponent::TriggerComponent(Entity* parent, const std::string triggerInfo) : Component(parent) {
 	m_Parent = parent;
 	m_Trigger = nullptr;
 
@@ -43,7 +44,7 @@ void TriggerComponent::TriggerEvent(eTriggerEventType event, Entity* optionalTar
 }
 
 void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity* optionalTarget) {
-	auto argArray =  GeneralUtils::SplitString(command->args, ',');
+	auto argArray = GeneralUtils::SplitString(command->args, ',');
 
 	// determine targets
 	std::vector<Entity*> targetEntities = GatherTargets(command, optionalTarget);
@@ -55,107 +56,119 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
 		if (!targetEntity) continue;
 
 		switch (command->id) {
-			case eTriggerCommandType::ZONE_PLAYER: break;
-			case eTriggerCommandType::FIRE_EVENT:
-				HandleFireEvent(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::DESTROY_OBJ:
-				HandleDestroyObject(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::TOGGLE_TRIGGER:
-				HandleToggleTrigger(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::RESET_REBUILD:
-				HandleResetRebuild(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::SET_PATH: break;
-			case eTriggerCommandType::SET_PICK_TYPE: break;
-			case eTriggerCommandType::MOVE_OBJECT:
-				HandleMoveObject(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::ROTATE_OBJECT:
-				HandleRotateObject(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::PUSH_OBJECT:
-				HandlePushObject(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::REPEL_OBJECT:
-				HandleRepelObject(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::SET_TIMER:
-				HandleSetTimer(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::CANCEL_TIMER:
-				HandleCancelTimer(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::PLAY_CINEMATIC:
-				HandlePlayCinematic(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::TOGGLE_BBB:
-				HandleToggleBBB(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::UPDATE_MISSION:
-				HandleUpdateMission(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::SET_BOUNCER_STATE: break;
-			case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
-			case eTriggerCommandType::TURN_AROUND_ON_PATH: break;
-			case eTriggerCommandType::GO_FORWARD_ON_PATH: break;
-			case eTriggerCommandType::GO_BACKWARD_ON_PATH: break;
-			case eTriggerCommandType::STOP_PATHING: break;
-			case eTriggerCommandType::START_PATHING: break;
-			case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
-			case eTriggerCommandType::PLAY_EFFECT:
-				HandlePlayEffect(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::STOP_EFFECT:
-				GameMessages::SendStopFXEffect(targetEntity, true, command->args);
-				break;
-			case eTriggerCommandType::CAST_SKILL:
-				HandleCastSkill(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::DISPLAY_ZONE_SUMMARY:
-				GameMessages::SendDisplayZoneSummary(targetEntity->GetObjectID(), targetEntity->GetSystemAddress(), false, command->args == "1", m_Parent->GetObjectID());
-				break;
-			case eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT:
-				HandleSetPhysicsVolumeEffect(targetEntity, argArray);
-				break;
-			case eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS:
-				HandleSetPhysicsVolumeStatus(targetEntity, command->args);
-				break;
-			case eTriggerCommandType::SET_MODEL_TO_BUILD: break;
-			case eTriggerCommandType::SPAWN_MODEL_BRICKS: break;
-			case eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK:
-				HandleActivateSpawnerNetwork(command->args);
-				break;
-			case eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK:
-				HandleDeactivateSpawnerNetwork(command->args);
-				break;
-			case eTriggerCommandType::RESET_SPAWNER_NETWORK:
-				HandleResetSpawnerNetwork(command->args);
-				break;
-			case eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS:
-				HandleDestroySpawnerNetworkObjects(command->args);
-				break;
-			case eTriggerCommandType::GO_TO_WAYPOINT: break;
-			case eTriggerCommandType::ACTIVATE_PHYSICS:
-				HandleActivatePhysics(targetEntity, command->args);
-				break;
+		case eTriggerCommandType::ZONE_PLAYER: break;
+		case eTriggerCommandType::FIRE_EVENT:
+			HandleFireEvent(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::DESTROY_OBJ:
+			HandleDestroyObject(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::TOGGLE_TRIGGER:
+			HandleToggleTrigger(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::RESET_REBUILD:
+			HandleResetRebuild(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::SET_PATH:
+			HandleSetPath(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::SET_PICK_TYPE: break;
+		case eTriggerCommandType::MOVE_OBJECT:
+			HandleMoveObject(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::ROTATE_OBJECT:
+			HandleRotateObject(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::PUSH_OBJECT:
+			HandlePushObject(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::REPEL_OBJECT:
+			HandleRepelObject(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::SET_TIMER:
+			HandleSetTimer(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::CANCEL_TIMER:
+			HandleCancelTimer(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::PLAY_CINEMATIC:
+			HandlePlayCinematic(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::TOGGLE_BBB:
+			HandleToggleBBB(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::UPDATE_MISSION:
+			HandleUpdateMission(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::SET_BOUNCER_STATE: break;
+		case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
+		case eTriggerCommandType::TURN_AROUND_ON_PATH:
+			HandleTurnAroundOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::GO_FORWARD_ON_PATH:
+			HandleGoForwardOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::GO_BACKWARD_ON_PATH:
+			HandleGoBackwardOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::STOP_PATHING:
+			HandleStopPathing(targetEntity);
+			break;
+		case eTriggerCommandType::START_PATHING:
+			HandleStartPathing(targetEntity);
+			break;
+		case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
+		case eTriggerCommandType::PLAY_EFFECT:
+			HandlePlayEffect(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::STOP_EFFECT:
+			GameMessages::SendStopFXEffect(targetEntity, true, command->args);
+			break;
+		case eTriggerCommandType::CAST_SKILL:
+			HandleCastSkill(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::DISPLAY_ZONE_SUMMARY:
+			GameMessages::SendDisplayZoneSummary(targetEntity->GetObjectID(), targetEntity->GetSystemAddress(), false, command->args == "1", m_Parent->GetObjectID());
+			break;
+		case eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT:
+			HandleSetPhysicsVolumeEffect(targetEntity, argArray);
+			break;
+		case eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS:
+			HandleSetPhysicsVolumeStatus(targetEntity, command->args);
+			break;
+		case eTriggerCommandType::SET_MODEL_TO_BUILD: break;
+		case eTriggerCommandType::SPAWN_MODEL_BRICKS: break;
+		case eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK:
+			HandleActivateSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK:
+			HandleDeactivateSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::RESET_SPAWNER_NETWORK:
+			HandleResetSpawnerNetwork(command->args);
+			break;
+		case eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS:
+			HandleDestroySpawnerNetworkObjects(command->args);
+			break;
+		case eTriggerCommandType::GO_TO_WAYPOINT: break;
+		case eTriggerCommandType::ACTIVATE_PHYSICS:
+			HandleActivatePhysics(targetEntity, command->args);
+			break;
 			// DEPRECATED BLOCK START
-			case eTriggerCommandType::ACTIVATE_MUSIC_CUE: break;
-			case eTriggerCommandType::DEACTIVATE_MUSIC_CUE: break;
-			case eTriggerCommandType::FLASH_MUSIC_CUE: break;
-			case eTriggerCommandType::SET_MUSIC_PARAMETER: break;
-			case eTriggerCommandType::PLAY_2D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::STOP_2D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::PLAY_3D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::STOP_3D_AMBIENT_SOUND: break;
-			case eTriggerCommandType::ACTIVATE_MIXER_PROGRAM: break;
-			case eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM: break;
+		case eTriggerCommandType::ACTIVATE_MUSIC_CUE: break;
+		case eTriggerCommandType::DEACTIVATE_MUSIC_CUE: break;
+		case eTriggerCommandType::FLASH_MUSIC_CUE: break;
+		case eTriggerCommandType::SET_MUSIC_PARAMETER: break;
+		case eTriggerCommandType::PLAY_2D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::STOP_2D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::PLAY_3D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::STOP_3D_AMBIENT_SOUND: break;
+		case eTriggerCommandType::ACTIVATE_MIXER_PROGRAM: break;
+		case eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM: break;
 			// DEPRECATED BLOCK END
-			default:
-				LOG_DEBUG("Event %i was not handled!", command->id);
-				break;
+		default:
+			LOG_DEBUG("Event %i was not handled!", command->id);
+			break;
 		}
 	}
 }
@@ -164,20 +177,25 @@ std::vector<Entity*> TriggerComponent::GatherTargets(LUTriggers::Command* comman
 	std::vector<Entity*> entities = {};
 
 	if (command->target == "self") entities.push_back(m_Parent);
-	else if (command->target == "zone") { /*TODO*/ }
-	else if (command->target == "target" && optionalTarget) entities.push_back(optionalTarget);
-	else if (command->target == "targetTeam" && optionalTarget) {
+	else if (command->target == "zone") {
+		/*TODO*/
+	} else if (command->target == "target" && optionalTarget) {
+		entities.push_back(optionalTarget);
+	} else if (command->target == "targetTeam" && optionalTarget) {
 		auto* team = TeamManager::Instance()->GetTeam(optionalTarget->GetObjectID());
 		for (const auto memberId : team->members) {
 			auto* member = Game::entityManager->GetEntity(memberId);
 			if (member) entities.push_back(member);
 		}
-	} else if (command->target == "objGroup") entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
-	else if (command->target == "allPlayers") {
+	} else if (command->target == "objGroup") {
+		entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
+	} else if (command->target == "allPlayers") {
 		for (auto* player : PlayerManager::GetAllPlayers()) {
 			entities.push_back(player);
 		}
-	} else if (command->target == "allNPCs") { /*UNUSED*/ }
+	} else if (command->target == "allNPCs") {
+		/*UNUSED*/
+	}
 
 	return entities;
 }
@@ -186,12 +204,12 @@ void TriggerComponent::HandleFireEvent(Entity* targetEntity, std::string args) {
 	targetEntity->GetScript()->OnFireEventServerSide(targetEntity, m_Parent, args, 0, 0, 0);
 }
 
-void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleDestroyObject(Entity* targetEntity, std::string args) {
 	const eKillType killType = GeneralUtils::TryParse<eKillType>(args).value_or(eKillType::VIOLENT);
 	targetEntity->Smash(m_Parent->GetObjectID(), killType);
 }
 
-void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string args) {
 	auto* triggerComponent = targetEntity->GetComponent<TriggerComponent>();
 	if (!triggerComponent) {
 		LOG_DEBUG("Trigger component not found!");
@@ -200,7 +218,7 @@ void TriggerComponent::HandleToggleTrigger(Entity* targetEntity, std::string arg
 	triggerComponent->SetTriggerEnabled(args == "1");
 }
 
-void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args) {
 	auto* quickBuildComponent = targetEntity->GetComponent<QuickBuildComponent>();
 	if (!quickBuildComponent) {
 		LOG_DEBUG("Rebuild component not found!");
@@ -209,7 +227,7 @@ void TriggerComponent::HandleResetRebuild(Entity* targetEntity, std::string args
 	quickBuildComponent->ResetQuickBuild(args == "1");
 }
 
-void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() <= 2) return;
 
 	NiPoint3 position = targetEntity->GetPosition();
@@ -219,7 +237,7 @@ void TriggerComponent::HandleMoveObject(Entity* targetEntity, std::vector<std::s
 	targetEntity->SetPosition(position);
 }
 
-void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() <= 2) return;
 
 	const NiPoint3 vector = GeneralUtils::TryParse<NiPoint3>(argArray).value_or(NiPoint3Constant::ZERO);
@@ -228,7 +246,7 @@ void TriggerComponent::HandleRotateObject(Entity* targetEntity, std::vector<std:
 	targetEntity->SetRotation(rotation);
 }
 
-void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() < 3) return;
 
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
@@ -246,7 +264,7 @@ void TriggerComponent::HandlePushObject(Entity* targetEntity, std::vector<std::s
 }
 
 
-void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args) {
 	auto* phantomPhysicsComponent = m_Parent->GetComponent<PhantomPhysicsComponent>();
 	if (!phantomPhysicsComponent) {
 		LOG_DEBUG("Phantom Physics component not found!");
@@ -270,7 +288,7 @@ void TriggerComponent::HandleRepelObject(Entity* targetEntity, std::string args)
 	Game::entityManager->SerializeEntity(m_Parent);
 }
 
-void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray){
+void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::string> argArray) {
 	if (argArray.size() != 2) {
 		LOG_DEBUG("Not enough variables!");
 		return;
@@ -279,7 +297,7 @@ void TriggerComponent::HandleSetTimer(Entity* targetEntity, std::vector<std::str
 	m_Parent->AddTimer(argArray.at(0), time);
 }
 
-void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleCancelTimer(Entity* targetEntity, std::string args) {
 	m_Parent->CancelTimer(args);
 }
 
@@ -327,7 +345,7 @@ void TriggerComponent::HandleUpdateMission(Entity* targetEntity, std::vector<std
 	// then we need a good way to convert this from a string to that enum
 	if (argArray.at(0) != "exploretask") return;
 	MissionComponent* missionComponent = targetEntity->GetComponent<MissionComponent>();
-	if (!missionComponent){
+	if (!missionComponent) {
 		LOG_DEBUG("Mission component not found!");
 		return;
 	}
@@ -339,7 +357,7 @@ void TriggerComponent::HandlePlayEffect(Entity* targetEntity, std::vector<std::s
 	const auto effectID = GeneralUtils::TryParse<int32_t>(argArray.at(1));
 	if (!effectID) return;
 	std::u16string effectType = GeneralUtils::UTF8ToUTF16(argArray.at(2));
-	
+
 	float priority = 1;
 	if (argArray.size() == 4) {
 		priority = GeneralUtils::TryParse<float>(argArray.at(3)).value_or(priority);
@@ -348,7 +366,7 @@ void TriggerComponent::HandlePlayEffect(Entity* targetEntity, std::vector<std::s
 	GameMessages::SendPlayFXEffect(targetEntity, effectID.value(), effectType, argArray.at(0), LWOOBJID_EMPTY, priority);
 }
 
-void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args){
+void TriggerComponent::HandleCastSkill(Entity* targetEntity, std::string args) {
 	auto* skillComponent = targetEntity->GetComponent<SkillComponent>();
 	if (!skillComponent) {
 		LOG_DEBUG("Skill component not found!");
@@ -376,7 +394,7 @@ void TriggerComponent::HandleSetPhysicsVolumeEffect(Entity* targetEntity, std::v
 	phantomPhysicsComponent->SetEffectType(effectType);
 	phantomPhysicsComponent->SetDirectionalMultiplier(std::stof(argArray.at(1)));
 	if (argArray.size() > 4) {
-		const NiPoint3 direction = 
+		const NiPoint3 direction =
 			GeneralUtils::TryParse<NiPoint3>(argArray.at(2), argArray.at(3), argArray.at(4)).value_or(NiPoint3Constant::ZERO);
 
 		phantomPhysicsComponent->SetDirection(direction);
@@ -402,25 +420,25 @@ void TriggerComponent::HandleSetPhysicsVolumeStatus(Entity* targetEntity, std::s
 	Game::entityManager->SerializeEntity(targetEntity);
 }
 
-void TriggerComponent::HandleActivateSpawnerNetwork(std::string args){
+void TriggerComponent::HandleActivateSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Activate();
 	}
 }
 
-void TriggerComponent::HandleDeactivateSpawnerNetwork(std::string args){
+void TriggerComponent::HandleDeactivateSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Deactivate();
 	}
 }
 
-void TriggerComponent::HandleResetSpawnerNetwork(std::string args){
+void TriggerComponent::HandleResetSpawnerNetwork(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->Reset();
 	}
 }
 
-void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args){
+void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args) {
 	for (auto* spawner : Game::zoneManager->GetSpawnersByName(args)) {
 		if (spawner) spawner->DestroyAllEntities();
 	}
@@ -429,9 +447,50 @@ void TriggerComponent::HandleDestroySpawnerNetworkObjects(std::string args){
 void TriggerComponent::HandleActivatePhysics(Entity* targetEntity, std::string args) {
 	if (args == "true") {
 		// TODO add physics entity if there isn't one
-	} else if (args == "false"){
+	} else if (args == "false") {
 		// TODO remove Phsyics entity if there is one
 	} else {
 		LOG_DEBUG("Invalid argument for ActivatePhysics Trigger: %s", args.c_str());
 	}
 }
+
+void TriggerComponent::HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// movementAIComponent->SetupPath(argArray.at(0));
+	if (argArray.size() >= 2) {
+		auto index = GeneralUtils::TryParse<int32_t>(argArray.at(1));
+		if (!index) return;
+		// movementAIComponent->SetPathStartingWaypointIndex(index.value());
+	}
+	if (argArray.size() >= 3 && argArray.at(2) == "1") {
+		// movementAIComponent->ReversePath();
+	}
+}
+
+void TriggerComponent::HandleTurnAroundOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoForwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoBackwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (!movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleStopPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Pause();
+}
+
+void TriggerComponent::HandleStartPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Resume();
+}

dGame/dComponents/TriggerComponent.h

@@ -44,6 +44,12 @@ private:
 	void HandleResetSpawnerNetwork(std::string args);
 	void HandleDestroySpawnerNetworkObjects(std::string args);
 	void HandleActivatePhysics(Entity* targetEntity, std::string args);
+	void HandleTurnAroundOnPath(Entity* targetEntity);
+	void HandleGoForwardOnPath(Entity* targetEntity);
+	void HandleGoBackwardOnPath(Entity* targetEntity);
+	void HandleStopPathing(Entity* targetEntity);
+	void HandleStartPathing(Entity* targetEntity);
+	void HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray);
 
 	LUTriggers::Trigger* m_Trigger;
 };

dGame/dComponents/VendorComponent.h

@@ -26,7 +26,7 @@ public:
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	void OnUse(Entity* originator) override;
-	void RefreshInventory(bool isCreation = false);
+	virtual void RefreshInventory(bool isCreation = false);
 	void SetupConstants();
 	bool SellsItem(const LOT item) const;
 	float GetBuyScalar() const { return m_BuyScalar; }

dGame/dGameMessages/GameMessages.cpp

@@ -2663,17 +2663,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) {

dGame/dUtilities/SlashCommandHandler.cpp

@@ -79,7 +79,7 @@
 #include "RenderComponent.h"
 #include "eControlScheme.h"
 #include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.h"
 #include "eMasterMessageType.h"
 #include "PlayerManager.h"
 
@@ -1063,7 +1063,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 			//Notify chat about it
 			CBITSTREAM;
-			BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
+			BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_MUTE);
 
 			bitStream.Write(characterId);
 			bitStream.Write(expire);
@@ -2078,7 +2078,7 @@ void SlashCommandHandler::SendAnnouncement(const std::string& title, const std::
 
 	//Notify chat about it
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ANNOUNCEMENT);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_ANNOUNCE);
 
 	bitStream.Write<uint32_t>(title.size());
 	for (auto character : title) {

dGame/dUtilities/VanityUtilities.cpp

@@ -285,7 +285,7 @@ void ParseXml(const std::string& file) {
 				}
 
 				if (zoneID.value() != currentZoneID) {
-					LOG_DEBUG("Skipping location because it is in %i and not the current zone (%i)", zoneID.value(), currentZoneID);
+					LOG_DEBUG("Skipping (%s) %i location because it is in %i and not the current zone (%i)", name, lot, zoneID.value(), currentZoneID);
 					continue;
 				}
 

dMasterServer/MasterServer.cpp

@@ -675,7 +675,7 @@ void HandlePacket(Packet* packet) {
 
 			const auto& zone = instance->GetZoneID();
 
-			MasterPackets::SendZoneTransferResponse(Game::server, packet->systemAddress, requestID, (bool)mythranShift, zone.GetMapID(), instance->GetInstanceID(), zone.GetCloneID(), instance->GetIP(), instance->GetPort());
+			MasterPackets::SendZoneTransferResponse(Game::server, packet->systemAddress, requestID, static_cast<bool>(mythranShift), zone.GetMapID(), instance->GetInstanceID(), zone.GetCloneID(), instance->GetIP(), instance->GetPort());
 
 			break;
 		}

dNet/AuthPackets.cpp

@@ -229,7 +229,7 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd
 	RakNet::BitStream loginResponse;
 	BitStreamUtils::WriteHeader(loginResponse, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE);
 
-	loginResponse.Write<uint8_t>(GeneralUtils::CastUnderlyingType(responseCode));
+	loginResponse.Write(responseCode);
 
 	// Event Gating
 	loginResponse.Write(LUString(Game::config->GetValue("event_1")));

dPhysics/dpEntity.cpp

@@ -3,8 +3,6 @@
 #include "dpShapeBox.h"
 #include "dpGrid.h"
 
-#include <iostream>
-
 dpEntity::dpEntity(const LWOOBJID& objectID, dpShapeType shapeType, bool isStatic) {
 	m_ObjectID = objectID;
 	m_IsStatic = isStatic;
@@ -76,16 +74,17 @@ void dpEntity::CheckCollision(dpEntity* other) {
 		return;
 	}
 
-	bool wasFound = m_CurrentlyCollidingObjects.contains(other->GetObjectID());
-
-	bool isColliding = m_CollisionShape->IsColliding(other->GetShape());
+	const auto objId = other->GetObjectID();
+	const auto objItr = m_CurrentlyCollidingObjects.find(objId);
+	const bool wasFound = objItr != m_CurrentlyCollidingObjects.cend();
+	const bool isColliding = m_CollisionShape->IsColliding(other->GetShape());
 
 	if (isColliding && !wasFound) {
-		m_CurrentlyCollidingObjects.emplace(other->GetObjectID(), other);
-		m_NewObjects.push_back(other);
+		m_CurrentlyCollidingObjects.emplace(objId);
+		m_NewObjects.push_back(objId);
 	} else if (!isColliding && wasFound) {
-		m_CurrentlyCollidingObjects.erase(other->GetObjectID());
-		m_RemovedObjects.push_back(other);
+		m_CurrentlyCollidingObjects.erase(objItr);
+		m_RemovedObjects.push_back(objId);
 	}
 }
 

dPhysics/dpEntity.h

@@ -2,7 +2,8 @@
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include <vector>
-#include <map>
+#include <unordered_set>
+#include <span>
 
 #include "dCommonVars.h"
 #include "dpCommon.h"
@@ -49,9 +50,9 @@ public:
 	bool GetSleeping() const { return m_Sleeping; }
 	void SetSleeping(bool value) { m_Sleeping = value; }
 
-	const std::vector<dpEntity*>& GetNewObjects() const { return m_NewObjects; }
-	const std::vector<dpEntity*>& GetRemovedObjects() const { return m_RemovedObjects; }
-	const std::map<LWOOBJID, dpEntity*>& GetCurrentlyCollidingObjects() const { return m_CurrentlyCollidingObjects; }
+	std::span<const LWOOBJID> GetNewObjects() const { return m_NewObjects; }
+	std::span<const LWOOBJID> GetRemovedObjects() const { return m_RemovedObjects; }
+	const std::unordered_set<LWOOBJID>& GetCurrentlyCollidingObjects() const { return m_CurrentlyCollidingObjects; }
 
 	void PreUpdate() { m_NewObjects.clear();  m_RemovedObjects.clear(); }
 
@@ -80,7 +81,7 @@ private:
 
 	bool m_IsGargantuan = false;
 
-	std::vector<dpEntity*> m_NewObjects;
-	std::vector<dpEntity*> m_RemovedObjects;
-	std::map<LWOOBJID, dpEntity*> m_CurrentlyCollidingObjects;
+	std::vector<LWOOBJID> m_NewObjects;
+	std::vector<LWOOBJID> m_RemovedObjects;
+	std::unordered_set<LWOOBJID> m_CurrentlyCollidingObjects;
 };

dPhysics/dpGrid.cpp

@@ -26,8 +26,8 @@ dpGrid::~dpGrid() {
 
 void dpGrid::Add(dpEntity* entity) {
 	//Determine which grid cell it's in.
-	int cellX = (int)std::round(entity->m_Position.x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int cellZ = (int)std::round(entity->m_Position.z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellX = static_cast<int>(std::round(entity->m_Position.x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellZ = static_cast<int>(std::round(entity->m_Position.z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
 	// Clamp values to the range [0, NUM_CELLS - 1]
 	cellX = std::clamp(cellX, 0, NUM_CELLS - 1);
@@ -42,11 +42,11 @@ void dpGrid::Add(dpEntity* entity) {
 }
 
 void dpGrid::Move(dpEntity* entity, float x, float z) {
-	int oldCellX = (int)std::round(entity->m_Position.x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int oldCellZ = (int)std::round(entity->m_Position.z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellX = static_cast<int>(std::round(entity->m_Position.x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellZ = static_cast<int>(std::round(entity->m_Position.z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
-	int cellX = (int)std::round(x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int cellZ = (int)std::round(z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellX = static_cast<int>(std::round(x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int cellZ = static_cast<int>(std::round(z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
 	// Clamp values to the range [0, NUM_CELLS - 1]
 	cellX = std::clamp(cellX, 0, NUM_CELLS - 1);
@@ -73,8 +73,8 @@ void dpGrid::Move(dpEntity* entity, float x, float z) {
 
 void dpGrid::Delete(dpEntity* entity) {
 	if (!entity) return;
-	int oldCellX = (int)std::round(entity->m_Position.x) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
-	int oldCellZ = (int)std::round(entity->m_Position.z) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellX = static_cast<int>(std::round(entity->m_Position.x)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
+	int oldCellZ = static_cast<int>(std::round(entity->m_Position.z)) / dpGrid::CELL_SIZE + NUM_CELLS / 2;
 
 	// Clamp values to the range [0, NUM_CELLS - 1]
 	oldCellX = std::clamp(oldCellX, 0, NUM_CELLS - 1);

dScripts/02_server/Map/AM/WanderingVendor.cpp

@@ -1,11 +1,11 @@
 #include "WanderingVendor.h"
 #include "MovementAIComponent.h"
 #include "ProximityMonitorComponent.h"
+#include <ranges>
 
 void WanderingVendor::OnStartup(Entity* self) {
 	auto movementAIComponent = self->GetComponent<MovementAIComponent>();
 	if (!movementAIComponent) return;
-	// movementAIComponent->Resume();
 	self->SetProximityRadius(10, "playermonitor");
 }
 
@@ -13,14 +13,23 @@ void WanderingVendor::OnProximityUpdate(Entity* self, Entity* entering, std::str
 	if (status == "ENTER" && entering->IsPlayer()) {
 		auto movementAIComponent = self->GetComponent<MovementAIComponent>();
 		if (!movementAIComponent) return;
-		// movementAIComponent->Pause();
+		movementAIComponent->Pause();
 		self->CancelTimer("startWalking");
 	} else if (status == "LEAVE") {
 		auto* proximityMonitorComponent = self->GetComponent<ProximityMonitorComponent>();
 		if (!proximityMonitorComponent) self->AddComponent<ProximityMonitorComponent>();
 
 		const auto proxObjs = proximityMonitorComponent->GetProximityObjects("playermonitor");
-		if (proxObjs.empty()) self->AddTimer("startWalking", 1.5);
+		bool foundPlayer = false;
+		for (const auto id : proxObjs) {
+			auto* entity = Game::entityManager->GetEntity(id);
+			if (entity && entity->IsPlayer()) {
+				foundPlayer = true;
+				break;
+			}
+		}
+
+		if (!foundPlayer) self->AddTimer("startWalking", 1.5);
 	}
 }
 
@@ -28,6 +37,6 @@ void WanderingVendor::OnTimerDone(Entity* self, std::string timerName) {
 	if (timerName == "startWalking") {
 		auto movementAIComponent = self->GetComponent<MovementAIComponent>();
 		if (!movementAIComponent) return;
-		// movementAIComponent->Resume();
+		movementAIComponent->Resume();
 	}
 }

dScripts/02_server/Map/General/StoryBoxInteractServer.cpp

@@ -29,7 +29,7 @@ void StoryBoxInteractServer::OnUse(Entity* self, Entity* user) {
 		return;
 	}
 
-	if (!self->HasVar(u"storyText") || !self->HasVar(u"altFlagID")) return;
+	if (!self->HasVar(u"storyText")) return;
 	const auto storyText = self->GetVarAsString(u"storyText");
 	if (storyText.length() > 2) {
 		auto storyValue = GeneralUtils::TryParse<uint32_t>(storyText.substr(storyText.length() - 2));

dScripts/ai/AG/AgBusDoor.cpp

@@ -23,13 +23,13 @@ void AgBusDoor::OnProximityUpdate(Entity* self, Entity* entering, std::string na
 	m_Counter = 0;
 	m_OuterCounter = 0;
 
-	for (const auto& pair : proximityMonitorComponent->GetProximityObjects("busDoor")) {
-		auto* entity = Game::entityManager->GetEntity(pair.first);
+	for (const auto id : proximityMonitorComponent->GetProximityObjects("busDoor")) {
+		const auto* const entity = Game::entityManager->GetEntity(id);
 		if (entity != nullptr && entity->IsPlayer()) m_Counter++;
 	}
 
-	for (const auto& pair : proximityMonitorComponent->GetProximityObjects("busDoorOuter")) {
-		auto* entity = Game::entityManager->GetEntity(pair.first);
+	for (const auto id : proximityMonitorComponent->GetProximityObjects("busDoorOuter")) {
+		const auto* const entity = Game::entityManager->GetEntity(id);
 		if (entity != nullptr && entity->IsPlayer()) m_OuterCounter++;
 	}
 

dScripts/ai/MINIGAME/SG_GF/SERVER/SGCannon.cpp

@@ -307,11 +307,7 @@ void SGCannon::DoSpawnTimerFunc(Entity* self, const std::string& name) {
 		movementAI->SetCurrentSpeed(toSpawn.initialSpeed);
 		movementAI->SetHaltDistance(0.0f);
 
-		std::vector<NiPoint3> pathWaypoints;
-
-		for (const auto& waypoint : path->pathWaypoints) {
-			pathWaypoints.push_back(waypoint.position);
-		}
+		std::vector<PathWaypoint> pathWaypoints = path->pathWaypoints;
 
 		if (GeneralUtils::GenerateRandomNumber<float_t>(0, 1) < 0.5f) {
 			std::reverse(pathWaypoints.begin(), pathWaypoints.end());

dScripts/zone/LUPs/RobotCity_Intro/WblRobotCitizen.cpp

@@ -5,20 +5,19 @@
 void WblRobotCitizen::OnStartup(Entity* self) {
 	auto movementAIComponent = self->GetComponent<MovementAIComponent>();
 	if (!movementAIComponent) return;
-	// movementAIComponent->Resume();
 }
 
 void WblRobotCitizen::OnUse(Entity* self, Entity* user) {
-	// auto movementAIComponent = self->GetComponent<MovementAIComponent>();
-	// if (!movementAIComponent) movementAIComponent->Pause();
+	auto movementAIComponent = self->GetComponent<MovementAIComponent>();
+	if (movementAIComponent) movementAIComponent->Pause();
 	auto face = NiQuaternion::LookAt(self->GetPosition(), user->GetPosition());
 	self->SetRotation(face);
-	auto timer = RenderComponent::PlayAnimation(self, "wave");
+	auto timer = RenderComponent::PlayAnimation(self, "wave", 0.4f);
 	self->AddTimer("animation time", timer);
 }
 
 void WblRobotCitizen::OnTimerDone(Entity* self, std::string timerName) {
 	auto movementAIComponent = self->GetComponent<MovementAIComponent>();
 	if (!movementAIComponent) return;
-	// movementAIComponent->Resume();
+	movementAIComponent->Resume();
 }

dWorldServer/WorldServer.cpp

@@ -66,7 +66,7 @@
 #include "eObjectBits.h"
 #include "eConnectionType.h"
 #include "eServerMessageType.h"
-#include "eChatInternalMessageType.h"
+#include "eChatMessageType.h"
 #include "eWorldMessageType.h"
 #include "eMasterMessageType.h"
 #include "eGameMessageType.h"
@@ -335,7 +335,7 @@ int main(int argc, char** argv) {
 
 		// Update to the new framerate and scale all timings to said new framerate
 		if (newFrameDelta != currentFrameDelta) {
-			float_t ratioBeforeToAfter = (float)currentFrameDelta / (float)newFrameDelta;
+			float_t ratioBeforeToAfter = static_cast<float>(currentFrameDelta) / static_cast<float>(newFrameDelta);
 			currentFrameDelta = newFrameDelta;
 			currentFramerate = MS_TO_FRAMES(newFrameDelta);
 			LOG_DEBUG("Framerate for zone/instance/clone %i/%i/%i is now %i", zoneID, instanceID, cloneID, currentFramerate);
@@ -541,118 +541,116 @@ void HandlePacketChat(Packet* packet) {
 	}
 
 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
-		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
-			switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
-			case eChatInternalMessageType::ROUTE_TO_PLAYER: {
-				CINSTREAM_SKIP_HEADER;
-				LWOOBJID playerID;
-				inStream.Read(playerID);
+		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
+			switch (static_cast<eChatMessageType>(packet->data[3])) {
+				case eChatMessageType::WORLD_ROUTE_PACKET: {
+					CINSTREAM_SKIP_HEADER;
+					LWOOBJID playerID;
+					inStream.Read(playerID);
 
-				auto player = Game::entityManager->GetEntity(playerID);
-				if (!player) return;
+					auto player = Game::entityManager->GetEntity(playerID);
+					if (!player) return;
 
-				auto sysAddr = player->GetSystemAddress();
+					auto sysAddr = player->GetSystemAddress();
 
-				//Write our stream outwards:
-				CBITSTREAM;
-				for (BitSize_t i = 0; i < inStream.GetNumberOfBytesUsed(); i++) {
-					bitStream.Write(packet->data[i + 16]); //16 bytes == header + playerID to skip
+					//Write our stream outwards:
+					CBITSTREAM;
+					for (BitSize_t i = 0; i < inStream.GetNumberOfBytesUsed(); i++) {
+						bitStream.Write(packet->data[i + 16]); //16 bytes == header + playerID to skip
+					}
+
+					SEND_PACKET; //send routed packet to player
+					break;
 				}
 
-				SEND_PACKET; //send routed packet to player
+				case eChatMessageType::GM_ANNOUNCE: {
+					CINSTREAM_SKIP_HEADER;
 
-				break;
-			}
+					std::string title;
+					std::string msg;
 
-			case eChatInternalMessageType::ANNOUNCEMENT: {
-				CINSTREAM_SKIP_HEADER;
+					uint32_t len;
+					inStream.Read<uint32_t>(len);
+					for (uint32_t i = 0; len > i; i++) {
+						char character;
+						inStream.Read<char>(character);
+						title += character;
+					}
 
-				std::string title;
-				std::string msg;
+					len = 0;
+					inStream.Read<uint32_t>(len);
+					for (uint32_t i = 0; len > i; i++) {
+						char character;
+						inStream.Read<char>(character);
+						msg += character;
+					}
 
-				uint32_t len;
-				inStream.Read<uint32_t>(len);
-				for (uint32_t i = 0; len > i; i++) {
-					char character;
-					inStream.Read<char>(character);
-					title += character;
-				}
+					//Send to our clients:
+					AMFArrayValue args;
 
-				len = 0;
-				inStream.Read<uint32_t>(len);
-				for (uint32_t i = 0; len > i; i++) {
-					char character;
-					inStream.Read<char>(character);
-					msg += character;
-				}
+					args.Insert("title", title);
+					args.Insert("message", msg);
 
-				//Send to our clients:
-				AMFArrayValue args;
-
-				args.Insert("title", title);
-				args.Insert("message", msg);
-
-				GameMessages::SendUIMessageServerToAllClients("ToggleAnnounce", args);
-
-				break;
-			}
-
-			case eChatInternalMessageType::MUTE_UPDATE: {
-				CINSTREAM_SKIP_HEADER;
-				LWOOBJID playerId;
-				time_t expire = 0;
-				inStream.Read(playerId);
-				inStream.Read(expire);
-
-				auto* entity = Game::entityManager->GetEntity(playerId);
-				auto* character = entity != nullptr ? entity->GetCharacter() : nullptr;
-				auto* user = character != nullptr ? character->GetParentUser() : nullptr;
-				if (user) {
-					user->SetMuteExpire(expire);
-
-					entity->GetCharacter()->SendMuteNotice();
-				}
-
-				break;
-			}
-
-			case eChatInternalMessageType::TEAM_UPDATE: {
-				CINSTREAM_SKIP_HEADER;
-
-				LWOOBJID teamID = 0;
-				char lootOption = 0;
-				char memberCount = 0;
-				std::vector<LWOOBJID> members;
-
-				inStream.Read(teamID);
-				bool deleteTeam = inStream.ReadBit();
-
-				if (deleteTeam) {
-					TeamManager::Instance()->DeleteTeam(teamID);
-
-					LOG("Deleting team (%llu)", teamID);
+					GameMessages::SendUIMessageServerToAllClients("ToggleAnnounce", args);
 
 					break;
 				}
 
-				inStream.Read(lootOption);
-				inStream.Read(memberCount);
-				LOG("Updating team (%llu), (%i), (%i)", teamID, lootOption, memberCount);
-				for (char i = 0; i < memberCount; i++) {
-					LWOOBJID member = LWOOBJID_EMPTY;
-					inStream.Read(member);
-					members.push_back(member);
+				case eChatMessageType::GM_MUTE: {
+					CINSTREAM_SKIP_HEADER;
+					LWOOBJID playerId;
+					time_t expire = 0;
+					inStream.Read(playerId);
+					inStream.Read(expire);
 
-					LOG("Updating team member (%llu)", member);
+					auto* entity = Game::entityManager->GetEntity(playerId);
+					auto* character = entity != nullptr ? entity->GetCharacter() : nullptr;
+					auto* user = character != nullptr ? character->GetParentUser() : nullptr;
+					if (user) {
+						user->SetMuteExpire(expire);
+
+						entity->GetCharacter()->SendMuteNotice();
+					}
+
+					break;
 				}
 
-				TeamManager::Instance()->UpdateTeam(teamID, lootOption, members);
+				case eChatMessageType::TEAM_GET_STATUS: {
+					CINSTREAM_SKIP_HEADER;
 
-				break;
-			}
+					LWOOBJID teamID = 0;
+					char lootOption = 0;
+					char memberCount = 0;
+					std::vector<LWOOBJID> members;
 
-			default:
-				LOG("Received an unknown chat internal: %i", int(packet->data[3]));
+					inStream.Read(teamID);
+					bool deleteTeam = inStream.ReadBit();
+
+					if (deleteTeam) {
+						TeamManager::Instance()->DeleteTeam(teamID);
+
+						LOG("Deleting team (%llu)", teamID);
+
+						break;
+					}
+
+					inStream.Read(lootOption);
+					inStream.Read(memberCount);
+					LOG("Updating team (%llu), (%i), (%i)", teamID, lootOption, memberCount);
+					for (char i = 0; i < memberCount; i++) {
+						LWOOBJID member = LWOOBJID_EMPTY;
+						inStream.Read(member);
+						members.push_back(member);
+
+						LOG("Updating team member (%llu)", member);
+					}
+
+					TeamManager::Instance()->UpdateTeam(teamID, lootOption, members);
+
+					break;
+				}
+				default:
+					LOG("Received an unknown chat: %i", int(packet->data[3]));
 			}
 		}
 	}
@@ -728,8 +726,8 @@ void HandleMasterPacket(Packet* packet) {
 			{
 				CBITSTREAM;
 				BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_ADDED);
-				bitStream.Write((LWOMAPID)Game::server->GetZoneID());
-				bitStream.Write((LWOINSTANCEID)instanceID);
+				bitStream.Write<LWOMAPID>(Game::server->GetZoneID());
+				bitStream.Write<LWOINSTANCEID>(instanceID);
 				Game::server->SendToMaster(bitStream);
 			}
 		}
@@ -817,7 +815,7 @@ void HandlePacket(Packet* packet) {
 
 		{
 			CBITSTREAM;
-			BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
+			BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::UNEXPECTED_DISCONNECT);
 			bitStream.Write(user->GetLoggedInChar());
 			Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 		}
@@ -830,8 +828,8 @@ void HandlePacket(Packet* packet) {
 
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_REMOVED);
-		bitStream.Write((LWOMAPID)Game::server->GetZoneID());
-		bitStream.Write((LWOINSTANCEID)instanceID);
+		bitStream.Write<LWOMAPID>(Game::server->GetZoneID());
+		bitStream.Write<LWOINSTANCEID>(instanceID);
 		Game::server->SendToMaster(bitStream);
 	}
 
@@ -986,7 +984,7 @@ void HandlePacket(Packet* packet) {
 			// This means we swapped characters and we need to remove the previous player from the container.
 			if (static_cast<uint32_t>(lastCharacter) != playerID) {
 				CBITSTREAM;
-				BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
+				BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::UNEXPECTED_DISCONNECT);
 				bitStream.Write(lastCharacter);
 				Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 			}
@@ -1132,7 +1130,7 @@ void HandlePacket(Packet* packet) {
 					const auto& playerName = character->GetName();
 
 					CBITSTREAM;
-					BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION);
+					BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::LOGIN_SESSION_NOTIFY);
 					bitStream.Write(player->GetObjectID());
 					bitStream.Write<uint32_t>(playerName.size());
 					for (size_t i = 0; i < playerName.size(); i++) {

dZoneManager/Zone.cpp

@@ -17,6 +17,7 @@
 
 #include "eTriggerCommandType.h"
 #include "eTriggerEventType.h"
+#include "eWaypointCommandType.h"
 #include "dNavMesh.h"
 
 Zone::Zone(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) :
@@ -452,15 +453,23 @@ void Zone::LoadPath(std::istream& file) {
 				std::string value;
 				BinaryIO::ReadString<uint8_t>(file, value, BinaryIO::ReadType::WideString);
 
-				LDFBaseData* ldfConfig = nullptr;
 				if (path.pathType == PathType::Movement || path.pathType == PathType::Rail) {
-					ldfConfig = LDFBaseData::DataFromString(parameter + "=0:" + value);
+					// cause NetDevil puts spaces in things that don't need spaces
+					parameter.erase(std::remove_if(parameter.begin(), parameter.end(), ::isspace), parameter.end());
+					auto waypointCommand = WaypointCommandType::StringToWaypointCommandType(parameter);
+					if (waypointCommand == eWaypointCommandType::DELAY) value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
+					if (waypointCommand != eWaypointCommandType::INVALID) {
+						auto& command = waypoint.commands.emplace_back();
+						command.command = waypointCommand;
+						command.data = value;
+					} else LOG("Tried to load invalid waypoint command '%s'", parameter.c_str());
 				} else {
-					ldfConfig = LDFBaseData::DataFromString(parameter + "=" + value);
+					waypoint.config.emplace_back(LDFBaseData::DataFromString(parameter + "=" + value));
 				}
-				if (ldfConfig) waypoint.config.push_back(ldfConfig);
+
 			}
 		}
+
 		// We verify the waypoint heights against the navmesh because in many movement paths,
 		// the waypoint is located near 0 height, 
 		if (path.pathType == PathType::Movement) {

dZoneManager/Zone.h

@@ -13,52 +13,60 @@ namespace LUTriggers {
 
 class Level;
 
+enum class eWaypointCommandType : uint32_t;
+
+struct WaypointCommand {
+	eWaypointCommandType command{};
+	std::string data;
+};
+
+
 struct SceneRef {
 	std::string filename;
-	uint32_t id;
-	uint32_t sceneType; //0 = general, 1 = audio?
+	uint32_t id{};
+	uint32_t sceneType{}; //0 = general, 1 = audio?
 	std::string name;
 	NiPoint3 unknown1;
-	float unknown2;
-	uint8_t color_r;
-	uint8_t color_g;
-	uint8_t color_b;
+	float unknown2{};
+	uint8_t color_r{};
+	uint8_t color_g{};
+	uint8_t color_b{};
 	Level* level;
 	std::map<uint32_t, LUTriggers::Trigger*> triggers;
 };
 
 struct SceneTransitionInfo {
-	uint64_t sceneID; //id of the scene being transitioned to.
+	uint64_t sceneID{}; //id of the scene being transitioned to.
 	NiPoint3 position;
 };
 
 struct SceneTransition {
 	std::string name;
 	std::vector<SceneTransitionInfo> points;
-	float width;
+	float width{};
 };
 
 struct MovingPlatformPathWaypoint {
-	uint8_t lockPlayer;
-	float wait;
+	uint8_t lockPlayer{};
+	float wait{};
 	std::string departSound;
 	std::string arriveSound;
 };
 
 struct CameraPathWaypoint {
-	float time;
-	float fov;
-	float tension;
-	float continuity;
-	float bias;
+	float time{};
+	float fov{};
+	float tension{};
+	float continuity{};
+	float bias{};
 };
 
 struct RacingPathWaypoint {
-	uint8_t isResetNode;
-	uint8_t isNonHorizontalCamera;
-	float planeWidth;
-	float planeHeight;
-	float shortestDistanceToEnd;
+	uint8_t isResetNode{};
+	uint8_t isNonHorizontalCamera{};
+	float planeWidth{};
+	float planeHeight{};
+	float shortestDistanceToEnd{};
 };
 
 struct PathWaypoint {
@@ -67,8 +75,9 @@ struct PathWaypoint {
 	MovingPlatformPathWaypoint movingPlatform;
 	CameraPathWaypoint camera;
 	RacingPathWaypoint racing;
-	float speed;
+	float speed{};
 	std::vector<LDFBaseData*> config;
+	std::vector<WaypointCommand> commands;
 };
 
 enum class PathType : uint32_t {
@@ -128,49 +137,49 @@ enum class PropertyAchievmentRequired : uint32_t {
 
 struct MovingPlatformPath {
 	std::string platformTravelSound;
-	uint8_t timeBasedMovement;
+	uint8_t timeBasedMovement{};
 };
 
 struct PropertyPath {
-	PropertyPathType pathType;
-	int32_t price;
-	uint32_t rentalTime;
-	uint64_t associatedZone;
+	PropertyPathType pathType{};
+	int32_t price{};
+	uint32_t rentalTime{};
+	uint64_t associatedZone{};
 	std::string displayName;
 	std::string displayDesc;
-	PropertyType type;
-	uint32_t cloneLimit;
-	float repMultiplier;
-	PropertyRentalPeriod rentalPeriod;
-	PropertyAchievmentRequired achievementRequired;
+	PropertyType type{};
+	uint32_t cloneLimit{};
+	float repMultiplier{};
+	PropertyRentalPeriod rentalPeriod{};
+	PropertyAchievmentRequired achievementRequired{};
 
 	// Player respawn coordinates in the main zone (not the property zone)
 	NiPoint3 playerZoneCoords;
-	float maxBuildHeight;
+	float maxBuildHeight{};
 };
 
 struct CameraPath {
 	std::string nextPath;
-	uint8_t rotatePlayer;
+	uint8_t rotatePlayer{};
 };
 
 struct SpawnerPath {
-	LOT spawnedLOT;
-	uint32_t respawnTime;
-	int32_t maxToSpawn;
-	uint32_t amountMaintained;
+	LOT spawnedLOT{};
+	uint32_t respawnTime{};
+	int32_t maxToSpawn{};
+	uint32_t amountMaintained{};
 	LWOOBJID spawnerObjID;
-	uint8_t spawnerNetActive;
+	uint8_t spawnerNetActive{};
 };
 
 
 struct Path {
-	uint32_t pathVersion;
+	uint32_t pathVersion{};
 	PathType pathType;
 	std::string pathName;
-	uint32_t flags;
+	uint32_t flags{};
 	PathBehavior pathBehavior;
-	uint32_t waypointCount;
+	uint32_t waypointCount{};
 	std::vector<PathWaypoint> pathWaypoints;
 	SpawnerPath spawner;
 	MovingPlatformPath movingPlatform;

migrations/dlu/9_Update_Leaderboard_Storage.sql

@@ -11,7 +11,7 @@ ALTER TABLE leaderboard CHANGE time secondaryScore FLOAT NOT NULL DEFAULT 0 AFTE
 /* A bit messy, but better than going through a bunch of code fixes all to be run once. */
 UPDATE leaderboard SET
 	primaryScore = secondaryScore,
-	secondaryScore = 0 WHERE game_id IN (1, 44, 46, 47, 48, 49, 53, 103, 104, 108, 1901);
+	secondaryScore = 0 WHERE game_id IN (1, 44, 46, 47, 48, 49, 53, 103, 104, 108, 1901) AND secondaryScore > 0;
 
 /* Do this last so we dont update entry times erroneously */
 ALTER TABLE leaderboard 

tests/dCommonTests/CMakeLists.txt

@@ -1,7 +1,7 @@
 set(DCOMMONTEST_SOURCES
 	"AMFDeserializeTests.cpp"
 	"Amf3Tests.cpp"
-	"CastUnderlyingTypeTests.cpp"
+	"ToUnderlyingTests.cpp"
 	"HeaderSkipTest.cpp"
 	"TestCDFeatureGatingTable.cpp"
 	"TestLDFFormat.cpp"

tests/dCommonTests/TestLDFFormat.cpp

@@ -27,7 +27,7 @@ TEST_F(LDFTests, LDFUTF16Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
+	ASSERT_EQ((static_cast<LDFData<std::u16string>*>(data.get()))->GetValue(), u"IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -37,7 +37,7 @@ TEST_F(LDFTests, LDFUTF16EmptyTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"");
+	ASSERT_EQ(static_cast<LDFData<std::u16string>*>(data.get())->GetValue(), u"");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -47,7 +47,7 @@ TEST_F(LDFTests, LDFUTF16ColonTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"::");
+	ASSERT_EQ(static_cast<LDFData<std::u16string>*>(data.get())->GetValue(), u"::");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -57,7 +57,7 @@ TEST_F(LDFTests, LDFUTF16EqualsTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_16);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::u16string>*)data.get())->GetValue(), u"==");
+	ASSERT_EQ(static_cast<LDFData<std::u16string>*>(data.get())->GetValue(), u"==");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -66,7 +66,7 @@ TEST_F(LDFTests, LDFS32Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_S32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<int32_t>*)data.get())->GetValue(), -15);
+	ASSERT_EQ(static_cast<LDFData<int32_t>*>(data.get())->GetValue(), -15);
 	ASSERT_EQ(data->GetString(), "KEY=1:-15");
 }
 TEST_F(LDFTests, LDFU32Test) {
@@ -74,7 +74,7 @@ TEST_F(LDFTests, LDFU32Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(static_cast<LDFData<uint32_t>*>(data.get())->GetValue(), 15);
 	ASSERT_EQ(data->GetString(), "KEY=5:15");
 }
 
@@ -83,7 +83,7 @@ TEST_F(LDFTests, LDFU32TrueTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 1);
+	ASSERT_EQ(static_cast<LDFData<uint32_t>*>(data.get())->GetValue(), 1);
 	ASSERT_EQ(data->GetString(), "KEY=5:1");
 }
 
@@ -92,7 +92,7 @@ TEST_F(LDFTests, LDFU32FalseTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U32);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint32_t>*)data.get())->GetValue(), 0);
+	ASSERT_EQ(static_cast<LDFData<uint32_t>*>(data.get())->GetValue(), 0);
 	ASSERT_EQ(data->GetString(), "KEY=5:0");
 }
 
@@ -103,7 +103,7 @@ TEST_F(LDFTests, LDFFloatTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_FLOAT);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<float>*)data.get())->GetValue(), 15.5f);
+	ASSERT_EQ(static_cast<LDFData<float>*>(data.get())->GetValue(), 15.5f);
 	ASSERT_EQ(data->GetString().find("KEY=3:15.5"), 0);
 }
 
@@ -112,7 +112,7 @@ TEST_F(LDFTests, LDFDoubleTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_DOUBLE);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<double>*)data.get())->GetValue(), 15.5);
+	ASSERT_EQ(static_cast<LDFData<double>*>(data.get())->GetValue(), 15.5);
 	ASSERT_EQ(data->GetString().find("KEY=4:15.5"), 0);
 }
 
@@ -122,7 +122,7 @@ TEST_F(LDFTests, LDFBoolTrueTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), true);
+	ASSERT_EQ(static_cast<LDFData<bool>*>(data.get())->GetValue(), true);
 	ASSERT_EQ(data->GetString(), "KEY=7:1");
 }
 
@@ -131,7 +131,7 @@ TEST_F(LDFTests, LDFBoolFalseTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), false);
+	ASSERT_EQ(static_cast<LDFData<bool>*>(data.get())->GetValue(), false);
 	ASSERT_EQ(data->GetString(), "KEY=7:0");
 }
 
@@ -140,7 +140,7 @@ TEST_F(LDFTests, LDFBoolIntTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_BOOLEAN);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<bool>*)data.get())->GetValue(), true);
+	ASSERT_EQ(static_cast<LDFData<bool>*>(data.get())->GetValue(), true);
 	ASSERT_EQ(data->GetString(), "KEY=7:1");
 }
 
@@ -149,7 +149,7 @@ TEST_F(LDFTests, LDFU64Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_U64);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint64_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(static_cast<LDFData<uint64_t>*>(data.get())->GetValue(), 15);
 	ASSERT_EQ(data->GetString(), "KEY=8:15");
 }
 
@@ -158,7 +158,7 @@ TEST_F(LDFTests, LDFLWOOBJIDTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_OBJID);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<uint64_t>*)data.get())->GetValue(), 15);
+	ASSERT_EQ(static_cast<LDFData<uint64_t>*>(data.get())->GetValue(), 15);
 	ASSERT_EQ(data->GetString(), "KEY=9:15");
 }
 
@@ -168,7 +168,7 @@ TEST_F(LDFTests, LDFUTF8Test) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "IAmA weird string with :::: and spac,./;'][\\es that I expect to be parsed correctly...; ");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -178,7 +178,7 @@ TEST_F(LDFTests, LDFUTF8EmptyTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 
@@ -188,7 +188,7 @@ TEST_F(LDFTests, LDFUTF8ColonsTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "::");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "::");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 TEST_F(LDFTests, LDFUTF8EqualsTest) {
@@ -197,7 +197,7 @@ TEST_F(LDFTests, LDFUTF8EqualsTest) {
 	ASSERT_NE(data, nullptr);
 	ASSERT_EQ(data->GetValueType(), eLDFType::LDF_TYPE_UTF_8);
 	ASSERT_EQ(data->GetKey(), u"KEY");
-	ASSERT_EQ(((LDFData<std::string>*)data.get())->GetValue(), "==");
+	ASSERT_EQ(static_cast<LDFData<std::string>*>(data.get())->GetValue(), "==");
 	ASSERT_EQ(data->GetString(), testWord);
 }
 

tests/dCommonTests/ToUnderlyingTests.cpp

@@ -7,13 +7,13 @@
 #include "eWorldMessageType.h"
 
 #define ASSERT_TYPE_EQ(TYPE, ENUM)\
-	ASSERT_TRUE(typeid(TYPE) == typeid(GeneralUtils::CastUnderlyingType(static_cast<ENUM>(0))));
+	ASSERT_TRUE(typeid(TYPE) == typeid(GeneralUtils::ToUnderlying(static_cast<ENUM>(0))));
 
 #define ASSERT_TYPE_NE(TYPE, ENUM)\
-	ASSERT_FALSE(typeid(TYPE) == typeid(GeneralUtils::CastUnderlyingType(static_cast<ENUM>(0))));
+	ASSERT_FALSE(typeid(TYPE) == typeid(GeneralUtils::ToUnderlying(static_cast<ENUM>(0))));
 	
 // Verify that the underlying enum types are being cast correctly
-TEST(CastUnderlyingTypeTests, VerifyCastUnderlyingType) {
+TEST(ToUnderlyingTests, VerifyToUnderlying) {
 	ASSERT_TYPE_EQ(uint8_t, eGameMasterLevel);
 	ASSERT_TYPE_EQ(uint16_t, eGameMessageType);
 	ASSERT_TYPE_EQ(uint32_t, eWorldMessageType)

tests/dGameTests/dGameMessagesTests/GameMessageTests.cpp

@@ -87,7 +87,7 @@ TEST_F(GameMessageTests, SendBlueprintLoadItemResponse) {
 
 TEST_F(GameMessageTests, ControlBehaviorAddStrip) {
 	auto data = ReadFromFile("addStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	AddStripMessage addStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_FLOAT_EQ(addStrip.GetPosition().GetX(), 50.65);
 	ASSERT_FLOAT_EQ(addStrip.GetPosition().GetY(), 178.05);
@@ -102,7 +102,7 @@ TEST_F(GameMessageTests, ControlBehaviorAddStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorRemoveStrip) {
 	auto data = ReadFromFile("removeStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RemoveStripMessage removeStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(static_cast<int32_t>(removeStrip.GetActionContext().GetStripId()), 1);
 	ASSERT_EQ(static_cast<int32_t>(removeStrip.GetActionContext().GetStateId()), 0);
@@ -111,7 +111,7 @@ TEST_F(GameMessageTests, ControlBehaviorRemoveStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorMergeStrips) {
 	auto data = ReadFromFile("mergeStrips");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	MergeStripsMessage mergeStrips(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(mergeStrips.GetSourceActionContext().GetStripId(), 2);
 	ASSERT_EQ(mergeStrips.GetDestinationActionContext().GetStripId(), 0);
@@ -123,7 +123,7 @@ TEST_F(GameMessageTests, ControlBehaviorMergeStrips) {
 
 TEST_F(GameMessageTests, ControlBehaviorSplitStrip) {
 	auto data = ReadFromFile("splitStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	SplitStripMessage splitStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(splitStrip.GetBehaviorId(), -1);
 
@@ -138,7 +138,7 @@ TEST_F(GameMessageTests, ControlBehaviorSplitStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorUpdateStripUI) {
 	auto data = ReadFromFile("updateStripUI");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	UpdateStripUiMessage updateStripUi(ReadArrayFromBitStream(inStream));
 	ASSERT_FLOAT_EQ(updateStripUi.GetPosition().GetX(), 116.65);
 	ASSERT_FLOAT_EQ(updateStripUi.GetPosition().GetY(), 35.35);
@@ -149,7 +149,7 @@ TEST_F(GameMessageTests, ControlBehaviorUpdateStripUI) {
 
 TEST_F(GameMessageTests, ControlBehaviorAddAction) {
 	auto data = ReadFromFile("addAction");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	AddActionMessage addAction(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(addAction.GetActionIndex(), 3);
 	ASSERT_EQ(addAction.GetActionContext().GetStripId(), 0);
@@ -163,7 +163,7 @@ TEST_F(GameMessageTests, ControlBehaviorAddAction) {
 
 TEST_F(GameMessageTests, ControlBehaviorMigrateActions) {
 	auto data = ReadFromFile("migrateActions");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	MigrateActionsMessage migrateActions(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(migrateActions.GetSrcActionIndex(), 1);
 	ASSERT_EQ(migrateActions.GetDstActionIndex(), 2);
@@ -176,7 +176,7 @@ TEST_F(GameMessageTests, ControlBehaviorMigrateActions) {
 
 TEST_F(GameMessageTests, ControlBehaviorRearrangeStrip) {
 	auto data = ReadFromFile("rearrangeStrip");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RearrangeStripMessage rearrangeStrip(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(rearrangeStrip.GetSrcActionIndex(), 2);
 	ASSERT_EQ(rearrangeStrip.GetDstActionIndex(), 1);
@@ -187,7 +187,7 @@ TEST_F(GameMessageTests, ControlBehaviorRearrangeStrip) {
 
 TEST_F(GameMessageTests, ControlBehaviorAdd) {
 	auto data = ReadFromFile("add");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	AddMessage add(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(add.GetBehaviorId(), 10446);
 	ASSERT_EQ(add.GetBehaviorIndex(), 0);
@@ -195,7 +195,7 @@ TEST_F(GameMessageTests, ControlBehaviorAdd) {
 
 TEST_F(GameMessageTests, ControlBehaviorRemoveActions) {
 	auto data = ReadFromFile("removeActions");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RemoveActionsMessage removeActions(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(removeActions.GetBehaviorId(), -1);
 	ASSERT_EQ(removeActions.GetActionIndex(), 1);
@@ -205,7 +205,7 @@ TEST_F(GameMessageTests, ControlBehaviorRemoveActions) {
 
 TEST_F(GameMessageTests, ControlBehaviorRename) {
 	auto data = ReadFromFile("rename");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	RenameMessage rename(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(rename.GetName(), "test");
 	ASSERT_EQ(rename.GetBehaviorId(), BehaviorMessageBase::DefaultBehaviorId);
@@ -213,7 +213,7 @@ TEST_F(GameMessageTests, ControlBehaviorRename) {
 
 TEST_F(GameMessageTests, ControlBehaviorUpdateAction) {
 	auto data = ReadFromFile("updateAction");
-	RakNet::BitStream inStream((unsigned char*)data.c_str(), data.length(), true);
+	RakNet::BitStream inStream(reinterpret_cast<unsigned char*>(&data[0]), data.length(), true);
 	UpdateActionMessage updateAction(ReadArrayFromBitStream(inStream));
 	ASSERT_EQ(updateAction.GetAction().GetType(), "FlyDown");
 	ASSERT_EQ(updateAction.GetAction().GetValueParameterName(), "Distance");

tests/dGameTests/dGameMessagesTests/LegacyGameMessageTests.cpp

@@ -2,297 +2,297 @@
 #include "eGameMessageType.h"
 
 TEST(LegacyGameMessageTests, AssertLegacyGmValues) {
-	EXPECT_EQ(eGameMessageType::TELEPORT, (eGameMessageType)19);
-	EXPECT_EQ(eGameMessageType::SET_PLAYER_CONTROL_SCHEME, (eGameMessageType)26);
-	EXPECT_EQ(eGameMessageType::DROP_CLIENT_LOOT, (eGameMessageType)30);
-	EXPECT_EQ(eGameMessageType::DIE, (eGameMessageType)37);
-	EXPECT_EQ(eGameMessageType::REQUEST_DIE, (eGameMessageType)38);
-	EXPECT_EQ(eGameMessageType::PLAY_EMOTE, (eGameMessageType)41);
-	EXPECT_EQ(eGameMessageType::PLAY_ANIMATION, (eGameMessageType)43);
-	EXPECT_EQ(eGameMessageType::CONTROL_BEHAVIORS, (eGameMessageType)48);
-	EXPECT_EQ(eGameMessageType::SET_NAME, (eGameMessageType)72);
-	EXPECT_EQ(eGameMessageType::ECHO_START_SKILL, (eGameMessageType)118);
-	EXPECT_EQ(eGameMessageType::START_SKILL, (eGameMessageType)119);
-	EXPECT_EQ(eGameMessageType::VERIFY_ACK, (eGameMessageType)121);
-	EXPECT_EQ(eGameMessageType::ADD_SKILL, (eGameMessageType)127);
-	EXPECT_EQ(eGameMessageType::REMOVE_SKILL, (eGameMessageType)128);
-	EXPECT_EQ(eGameMessageType::SET_CURRENCY, (eGameMessageType)133);
-	EXPECT_EQ(eGameMessageType::PICKUP_CURRENCY, (eGameMessageType)137);
-	EXPECT_EQ(eGameMessageType::PICKUP_ITEM, (eGameMessageType)139);
-	EXPECT_EQ(eGameMessageType::TEAM_PICKUP_ITEM, (eGameMessageType)140);
-	EXPECT_EQ(eGameMessageType::PLAY_FX_EFFECT, (eGameMessageType)154);
-	EXPECT_EQ(eGameMessageType::STOP_FX_EFFECT, (eGameMessageType)155);
-	EXPECT_EQ(eGameMessageType::REQUEST_RESURRECT, (eGameMessageType)159);
-	EXPECT_EQ(eGameMessageType::RESURRECT, (eGameMessageType)160);
-	EXPECT_EQ(eGameMessageType::PUSH_EQUIPPED_ITEMS_STATE, (eGameMessageType)191);
-	EXPECT_EQ(eGameMessageType::POP_EQUIPPED_ITEMS_STATE, (eGameMessageType)192);
-	EXPECT_EQ(eGameMessageType::SET_GM_LEVEL, (eGameMessageType)193);
-	EXPECT_EQ(eGameMessageType::SET_STUNNED, (eGameMessageType)198);
-	EXPECT_EQ(eGameMessageType::SET_STUN_IMMUNITY, (eGameMessageType)200);
-	EXPECT_EQ(eGameMessageType::KNOCKBACK, (eGameMessageType)202);
-	EXPECT_EQ(eGameMessageType::REBUILD_CANCEL, (eGameMessageType)209);
-	EXPECT_EQ(eGameMessageType::ENABLE_REBUILD, (eGameMessageType)213);
-	EXPECT_EQ(eGameMessageType::MOVE_ITEM_IN_INVENTORY, (eGameMessageType)224);
-	EXPECT_EQ(eGameMessageType::ADD_ITEM_TO_INVENTORY_CLIENT_SYNC, (eGameMessageType)227);
-	EXPECT_EQ(eGameMessageType::REMOVE_ITEM_FROM_INVENTORY, (eGameMessageType)230);
-	EXPECT_EQ(eGameMessageType::EQUIP_INVENTORY, (eGameMessageType)231);
-	EXPECT_EQ(eGameMessageType::UN_EQUIP_INVENTORY, (eGameMessageType)233);
-	EXPECT_EQ(eGameMessageType::OFFER_MISSION, (eGameMessageType)248);
-	EXPECT_EQ(eGameMessageType::RESPOND_TO_MISSION, (eGameMessageType)249);
-	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION, (eGameMessageType)254);
-	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION_TASK, (eGameMessageType)255);
-	EXPECT_EQ(eGameMessageType::REBUILD_NOTIFY_STATE, (eGameMessageType)336);
-	EXPECT_EQ(eGameMessageType::TERMINATE_INTERACTION, (eGameMessageType)357);
-	EXPECT_EQ(eGameMessageType::SERVER_TERMINATE_INTERACTION, (eGameMessageType)358);
-	EXPECT_EQ(eGameMessageType::REQUEST_USE, (eGameMessageType)364);
-	EXPECT_EQ(eGameMessageType::VENDOR_OPEN_WINDOW, (eGameMessageType)369);
-	EXPECT_EQ(eGameMessageType::BUY_FROM_VENDOR, (eGameMessageType)373);
-	EXPECT_EQ(eGameMessageType::SELL_TO_VENDOR, (eGameMessageType)374);
-	EXPECT_EQ(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG, (eGameMessageType)383);
-	EXPECT_EQ(eGameMessageType::SET_INVENTORY_SIZE, (eGameMessageType)389);
-	EXPECT_EQ(eGameMessageType::ACKNOWLEDGE_POSSESSION, (eGameMessageType)391);
-	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_PARAMS, (eGameMessageType)400);
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_START_STOP, (eGameMessageType)402);
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_ENTER, (eGameMessageType)403);
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_EXIT, (eGameMessageType)404);
-	EXPECT_EQ(eGameMessageType::ACTIVITY_ENTER, (eGameMessageType)405);
-	EXPECT_EQ(eGameMessageType::ACTIVITY_EXIT, (eGameMessageType)406);
-	EXPECT_EQ(eGameMessageType::ACTIVITY_START, (eGameMessageType)407);
-	EXPECT_EQ(eGameMessageType::ACTIVITY_STOP, (eGameMessageType)408);
-	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_CLIENT_AIM_UPDATE, (eGameMessageType)409);
-	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_FIRE, (eGameMessageType)411);
-	EXPECT_EQ(eGameMessageType::REQUEST_VENDOR_STATUS_UPDATE, (eGameMessageType)416);
-	EXPECT_EQ(eGameMessageType::VENDOR_STATUS_UPDATE, (eGameMessageType)417);
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE, (eGameMessageType)425);
-	EXPECT_EQ(eGameMessageType::CONSUME_CLIENT_ITEM, (eGameMessageType)427);
-	EXPECT_EQ(eGameMessageType::CLIENT_ITEM_CONSUMED, (eGameMessageType)428);
-	EXPECT_EQ(eGameMessageType::UPDATE_SHOOTING_GALLERY_ROTATION, (eGameMessageType)448);
-	EXPECT_EQ(eGameMessageType::SET_FLAG, (eGameMessageType)471);
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FLAG_CHANGE, (eGameMessageType)472);
-	EXPECT_EQ(eGameMessageType::VENDOR_TRANSACTION_RESULT, (eGameMessageType)476);
-	EXPECT_EQ(eGameMessageType::HAS_BEEN_COLLECTED, (eGameMessageType)486);
-	EXPECT_EQ(eGameMessageType::DISPLAY_CHAT_BUBBLE, (eGameMessageType)495);
-	EXPECT_EQ(eGameMessageType::SPAWN_PET, (eGameMessageType)498);
-	EXPECT_EQ(eGameMessageType::DESPAWN_PET, (eGameMessageType)499);
-	EXPECT_EQ(eGameMessageType::PLAYER_LOADED, (eGameMessageType)505);
-	EXPECT_EQ(eGameMessageType::PLAYER_READY, (eGameMessageType)509);
-	EXPECT_EQ(eGameMessageType::REQUEST_LINKED_MISSION, (eGameMessageType)515);
-	EXPECT_EQ(eGameMessageType::INVALID_ZONE_TRANSFER_LIST, (eGameMessageType)519);
-	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_OK, (eGameMessageType)520);
-	EXPECT_EQ(eGameMessageType::DISPLAY_MESSAGE_BOX, (eGameMessageType)529);
-	EXPECT_EQ(eGameMessageType::MESSAGE_BOX_RESPOND, (eGameMessageType)530);
-	EXPECT_EQ(eGameMessageType::CHOICE_BOX_RESPOND, (eGameMessageType)531);
-	EXPECT_EQ(eGameMessageType::SMASH, (eGameMessageType)537);
-	EXPECT_EQ(eGameMessageType::UN_SMASH, (eGameMessageType)538);
-	EXPECT_EQ(eGameMessageType::PLACE_MODEL_RESPONSE, (eGameMessageType)547);
-	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_RETICULE_EFFECT, (eGameMessageType)546);
-	EXPECT_EQ(eGameMessageType::SET_JET_PACK_MODE, (eGameMessageType)561);
-	EXPECT_EQ(eGameMessageType::REGISTER_PET_ID, (eGameMessageType)565);
-	EXPECT_EQ(eGameMessageType::REGISTER_PET_DBID, (eGameMessageType)566);
-	EXPECT_EQ(eGameMessageType::SHOW_ACTIVITY_COUNTDOWN, (eGameMessageType)568);
-	EXPECT_EQ(eGameMessageType::START_ACTIVITY_TIME, (eGameMessageType)576);
-	EXPECT_EQ(eGameMessageType::ACTIVITY_PAUSE, (eGameMessageType)602);
-	EXPECT_EQ(eGameMessageType::USE_NON_EQUIPMENT_ITEM, (eGameMessageType)603);
-	EXPECT_EQ(eGameMessageType::USE_ITEM_RESULT, (eGameMessageType)607);
-	EXPECT_EQ(eGameMessageType::COMMAND_PET, (eGameMessageType)640);
-	EXPECT_EQ(eGameMessageType::PET_RESPONSE, (eGameMessageType)641);
-	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA, (eGameMessageType)648);
-	EXPECT_EQ(eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA, (eGameMessageType)649);
-	EXPECT_EQ(eGameMessageType::NOTIFY_OBJECT, (eGameMessageType)656);
-	EXPECT_EQ(eGameMessageType::CLIENT_NOTIFY_PET, (eGameMessageType)659);
-	EXPECT_EQ(eGameMessageType::NOTIFY_PET, (eGameMessageType)660);
-	EXPECT_EQ(eGameMessageType::NOTIFY_PET_TAMING_MINIGAME, (eGameMessageType)661);
-	EXPECT_EQ(eGameMessageType::START_SERVER_PET_MINIGAME_TIMER, (eGameMessageType)662);
-	EXPECT_EQ(eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME, (eGameMessageType)663);
-	EXPECT_EQ(eGameMessageType::PET_NAME_CHANGED, (eGameMessageType)686);
-	EXPECT_EQ(eGameMessageType::PET_TAMING_MINIGAME_RESULT, (eGameMessageType)667);
-	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD_RESULT, (eGameMessageType)668);
-	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_BUILD_SUCCESS, (eGameMessageType)673);
-	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_MODEL_LOADED_ON_SERVER, (eGameMessageType)674);
-	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF, (eGameMessageType)678);
-	EXPECT_EQ(eGameMessageType::DECTIVATE_BUBBLE_BUFF, (eGameMessageType)679);
-	EXPECT_EQ(eGameMessageType::ADD_PET_TO_PLAYER, (eGameMessageType)681);
-	EXPECT_EQ(eGameMessageType::REQUEST_SET_PET_NAME, (eGameMessageType)683);
-	EXPECT_EQ(eGameMessageType::SET_PET_NAME, (eGameMessageType)684);
-	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_PUZZLE_SELECTED, (eGameMessageType)675);
-	EXPECT_EQ(eGameMessageType::SHOW_PET_ACTION_BUTTON, (eGameMessageType)692);
-	EXPECT_EQ(eGameMessageType::SET_EMOTE_LOCK_STATE, (eGameMessageType)693);
-	EXPECT_EQ(eGameMessageType::USE_ITEM_REQUIREMENTS_RESPONSE, (eGameMessageType)703);
-	EXPECT_EQ(eGameMessageType::PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT, (eGameMessageType)713);
-	EXPECT_EQ(eGameMessageType::DOWNLOAD_PROPERTY_DATA, (eGameMessageType)716);
-	EXPECT_EQ(eGameMessageType::QUERY_PROPERTY_DATA, (eGameMessageType)717);
-	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_BEGIN, (eGameMessageType)724);
-	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_END, (eGameMessageType)725);
-	EXPECT_EQ(eGameMessageType::IS_MINIFIG_IN_A_BUBBLE, (eGameMessageType)729);
-	EXPECT_EQ(eGameMessageType::START_PATHING, (eGameMessageType)733);
-	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF_FROM_SERVER, (eGameMessageType)734);
-	EXPECT_EQ(eGameMessageType::DEACTIVATE_BUBBLE_BUFF_FROM_SERVER, (eGameMessageType)735);
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_ZONE_OBJECT, (eGameMessageType)737);
-	EXPECT_EQ(eGameMessageType::UPDATE_REPUTATION, (eGameMessageType)746);
-	EXPECT_EQ(eGameMessageType::PROPERTY_RENTAL_RESPONSE, (eGameMessageType)750);
-	EXPECT_EQ(eGameMessageType::REQUEST_PLATFORM_RESYNC, (eGameMessageType)760);
-	EXPECT_EQ(eGameMessageType::PLATFORM_RESYNC, (eGameMessageType)761);
-	EXPECT_EQ(eGameMessageType::PLAY_CINEMATIC, (eGameMessageType)762);
-	EXPECT_EQ(eGameMessageType::END_CINEMATIC, (eGameMessageType)763);
-	EXPECT_EQ(eGameMessageType::CINEMATIC_UPDATE, (eGameMessageType)764);
-	EXPECT_EQ(eGameMessageType::TOGGLE_GHOST_REFERENCE_OVERRIDE, (eGameMessageType)767);
-	EXPECT_EQ(eGameMessageType::SET_GHOST_REFERENCE_POSITION, (eGameMessageType)768);
-	EXPECT_EQ(eGameMessageType::FIRE_EVENT_SERVER_SIDE, (eGameMessageType)770);
-	EXPECT_EQ(eGameMessageType::SCRIPT_NETWORK_VAR_UPDATE, (eGameMessageType)781);
-	EXPECT_EQ(eGameMessageType::UPDATE_MODEL_FROM_CLIENT, (eGameMessageType)793);
-	EXPECT_EQ(eGameMessageType::DELETE_MODEL_FROM_CLIENT, (eGameMessageType)794);
-	EXPECT_EQ(eGameMessageType::PLAY_ND_AUDIO_EMITTER, (eGameMessageType)821);
-	EXPECT_EQ(eGameMessageType::PLAY2_D_AMBIENT_SOUND, (eGameMessageType)831);
-	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY1, (eGameMessageType)840);
-	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY2, (eGameMessageType)841);
-	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_SYNC, (eGameMessageType)842);
-	EXPECT_EQ(eGameMessageType::PROPERTY_SELECT_QUERY, (eGameMessageType)845);
-	EXPECT_EQ(eGameMessageType::PARSE_CHAT_MESSAGE, (eGameMessageType)850);
-	EXPECT_EQ(eGameMessageType::BROADCAST_TEXT_TO_CHATBOX, (eGameMessageType)858);
-	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_MANAGEMENT, (eGameMessageType)860);
-	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_VENDOR, (eGameMessageType)861);
-	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK, (eGameMessageType)863);
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REQUEST, (eGameMessageType)868);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REQUEST, (eGameMessageType)869);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INVITE, (eGameMessageType)870);
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REPLY, (eGameMessageType)871);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REPLY, (eGameMessageType)872);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INITIAL_REPLY, (eGameMessageType)873);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_FINAL_REPLY, (eGameMessageType)874);
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_UPDATE, (eGameMessageType)875);
-	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_UPDATE, (eGameMessageType)876);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_UPDATE, (eGameMessageType)877);
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_CANCEL, (eGameMessageType)878);
-	EXPECT_EQ(eGameMessageType::CLIENT_SIDE_TRADE_CANCEL, (eGameMessageType)879);
-	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_ACCEPT, (eGameMessageType)880);
-	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_ACCEPT, (eGameMessageType)881);
-	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_CANCEL, (eGameMessageType)882);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_CANCEL, (eGameMessageType)883);
-	EXPECT_EQ(eGameMessageType::SERVER_TRADE_ACCEPT, (eGameMessageType)884);
-	EXPECT_EQ(eGameMessageType::READY_FOR_UPDATES, (eGameMessageType)888);
-	EXPECT_EQ(eGameMessageType::ORIENT_TO_OBJECT, (eGameMessageType)905);
-	EXPECT_EQ(eGameMessageType::ORIENT_TO_POSITION, (eGameMessageType)906);
-	EXPECT_EQ(eGameMessageType::ORIENT_TO_ANGLE, (eGameMessageType)907);
-	EXPECT_EQ(eGameMessageType::BOUNCER_ACTIVE_STATUS, (eGameMessageType)942);
-	EXPECT_EQ(eGameMessageType::UN_USE_BBB_MODEL, (eGameMessageType)999);
-	EXPECT_EQ(eGameMessageType::BBB_LOAD_ITEM_REQUEST, (eGameMessageType)1000);
-	EXPECT_EQ(eGameMessageType::BBB_SAVE_REQUEST, (eGameMessageType)1001);
-	EXPECT_EQ(eGameMessageType::BBB_SAVE_RESPONSE, (eGameMessageType)1005);
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_OBJECT, (eGameMessageType)1042);
-	EXPECT_EQ(eGameMessageType::DISPLAY_ZONE_SUMMARY, (eGameMessageType)1043);
-	EXPECT_EQ(eGameMessageType::ZONE_SUMMARY_DISMISSED, (eGameMessageType)1044);
-	EXPECT_EQ(eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST, (eGameMessageType)1053);
-	EXPECT_EQ(eGameMessageType::MODIFY_PLAYER_ZONE_STATISTIC, (eGameMessageType)1046);
-	EXPECT_EQ(eGameMessageType::START_BUILDING_WITH_ITEM, (eGameMessageType)1057);
-	EXPECT_EQ(eGameMessageType::START_ARRANGING_WITH_ITEM, (eGameMessageType)1061);
-	EXPECT_EQ(eGameMessageType::FINISH_ARRANGING_WITH_ITEM, (eGameMessageType)1062);
-	EXPECT_EQ(eGameMessageType::DONE_ARRANGING_WITH_ITEM, (eGameMessageType)1063);
-	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE, (eGameMessageType)1068);
-	EXPECT_EQ(eGameMessageType::BUILD_MODE_SET, (eGameMessageType)1069);
-	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE_CONFIRMED, (eGameMessageType)1073);
-	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FAILED_PRECONDITION, (eGameMessageType)1081);
-	EXPECT_EQ(eGameMessageType::MOVE_ITEM_BETWEEN_INVENTORY_TYPES, (eGameMessageType)1093);
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_BEGIN, (eGameMessageType)1094);
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_END, (eGameMessageType)1095);
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_MOVE_AND_EQUIP, (eGameMessageType)1096);
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_FINISH, (eGameMessageType)1097);
-	EXPECT_EQ(eGameMessageType::REPORT_BUG, (eGameMessageType)1198);
-	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_CANCELLED, (eGameMessageType)1129);
-	EXPECT_EQ(eGameMessageType::ECHO_SYNC_SKILL, (eGameMessageType)1144);
-	EXPECT_EQ(eGameMessageType::SYNC_SKILL, (eGameMessageType)1145);
-	EXPECT_EQ(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT, (eGameMessageType)1148);
-	EXPECT_EQ(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT, (eGameMessageType)1151);
-	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_CONVERT_MODEL, (eGameMessageType)1155);
-	EXPECT_EQ(eGameMessageType::SET_PLAYER_ALLOWED_RESPAWN, (eGameMessageType)1165);
-	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_SINGLE_CLIENT, (eGameMessageType)1184);
-	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_ALL_CLIENTS, (eGameMessageType)1185);
-	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD, (eGameMessageType)1197);
-	EXPECT_EQ(eGameMessageType::REQUEST_SMASH_PLAYER, (eGameMessageType)1202);
-	EXPECT_EQ(eGameMessageType::FIRE_EVENT_CLIENT_SIDE, (eGameMessageType)1213);
-	EXPECT_EQ(eGameMessageType::TOGGLE_GM_INVIS, (eGameMessageType)1218);
-	EXPECT_EQ(eGameMessageType::CHANGE_OBJECT_WORLD_STATE, (eGameMessageType)1223);
-	EXPECT_EQ(eGameMessageType::VEHICLE_LOCK_INPUT, (eGameMessageType)1230);
-	EXPECT_EQ(eGameMessageType::VEHICLE_UNLOCK_INPUT, (eGameMessageType)1231);
-	EXPECT_EQ(eGameMessageType::RACING_RESET_PLAYER_TO_LAST_RESET, (eGameMessageType)1252);
-	EXPECT_EQ(eGameMessageType::RACING_SERVER_SET_PLAYER_LAP_AND_PLANE, (eGameMessageType)1253);
-	EXPECT_EQ(eGameMessageType::RACING_SET_PLAYER_RESET_INFO, (eGameMessageType)1254);
-	EXPECT_EQ(eGameMessageType::RACING_PLAYER_INFO_RESET_FINISHED, (eGameMessageType)1255);
-	EXPECT_EQ(eGameMessageType::LOCK_NODE_ROTATION, (eGameMessageType)1260);
-	EXPECT_EQ(eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE, (eGameMessageType)1273);
-	EXPECT_EQ(eGameMessageType::NOTIFY_VEHICLE_OF_RACING_OBJECT, (eGameMessageType)1276);
-	EXPECT_EQ(eGameMessageType::SET_NAME_BILLBOARD_STATE, (eGameMessageType)1284);
-	EXPECT_EQ(eGameMessageType::PLAYER_REACHED_RESPAWN_CHECKPOINT, (eGameMessageType)1296);
-	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_DELETE_BASED_ON_EDIT_MODE, (eGameMessageType)1300);
-	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_CREATE_BASED_ON_EDIT_MODE, (eGameMessageType)1301);
-	EXPECT_EQ(eGameMessageType::PROPERTY_CONTENTS_FROM_CLIENT, (eGameMessageType)1305);
-	EXPECT_EQ(eGameMessageType::GET_MODELS_ON_PROPERTY, (eGameMessageType)1306);
-	EXPECT_EQ(eGameMessageType::MATCH_REQUEST, (eGameMessageType)1308);
-	EXPECT_EQ(eGameMessageType::MATCH_RESPONSE, (eGameMessageType)1309);
-	EXPECT_EQ(eGameMessageType::MATCH_UPDATE, (eGameMessageType)1310);
-	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT, (eGameMessageType)1131);
-	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_QUERY_DATA, (eGameMessageType)1132);
-	EXPECT_EQ(eGameMessageType::SHOW_BILLBOARD_INTERACT_ICON, (eGameMessageType)1337);
-	EXPECT_EQ(eGameMessageType::CHANGE_IDLE_FLAGS, (eGameMessageType)1338);
-	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_PASSIVE_BOOST_ACTION, (eGameMessageType)1340);
-	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, (eGameMessageType)1341);
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_PASSIVE_BOOST_ACTION, (eGameMessageType)1342);
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, (eGameMessageType)1343);
-	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_SLOWDOWN_ACTION, (eGameMessageType)1344);
-	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_SLOWDOWN_ACTION, (eGameMessageType)1345);
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_SLOWDOWN_ACTION, (eGameMessageType)1346);
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_SLOWDOWN_ACTION, (eGameMessageType)1347);
-	EXPECT_EQ(eGameMessageType::BUYBACK_FROM_VENDOR, (eGameMessageType)1350);
-	EXPECT_EQ(eGameMessageType::SET_PROPERTY_ACCESS, (eGameMessageType)1366);
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PLACED, (eGameMessageType)1369);
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_ROTATED, (eGameMessageType)1370);
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED, (eGameMessageType)1371);
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED, (eGameMessageType)1372);
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PICKED_UP, (eGameMessageType)1373);
-	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED, (eGameMessageType)1374);
-	EXPECT_EQ(eGameMessageType::NOTIFY_RACING_CLIENT, (eGameMessageType)1390);
-	EXPECT_EQ(eGameMessageType::RACING_PLAYER_HACK_CAR, (eGameMessageType)1391);
-	EXPECT_EQ(eGameMessageType::RACING_PLAYER_LOADED, (eGameMessageType)1392);
-	EXPECT_EQ(eGameMessageType::RACING_CLIENT_READY, (eGameMessageType)1393);
-	EXPECT_EQ(eGameMessageType::UPDATE_CHAT_MODE, (eGameMessageType)1395);
-	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_FINISHED_RACE, (eGameMessageType)1396);
-	EXPECT_EQ(eGameMessageType::SET_CONSUMABLE_ITEM, (eGameMessageType)1409);
-	EXPECT_EQ(eGameMessageType::SET_STATUS_IMMUNITY, (eGameMessageType)1435);
-	EXPECT_EQ(eGameMessageType::SET_PET_NAME_MODERATED, (eGameMessageType)1448);
-	EXPECT_EQ(eGameMessageType::MODIFY_LEGO_SCORE, (eGameMessageType)1459);
-	EXPECT_EQ(eGameMessageType::RESTORE_TO_POST_LOAD_STATS, (eGameMessageType)1468);
-	EXPECT_EQ(eGameMessageType::SET_RAIL_MOVEMENT, (eGameMessageType)1471);
-	EXPECT_EQ(eGameMessageType::START_RAIL_MOVEMENT, (eGameMessageType)1472);
-	EXPECT_EQ(eGameMessageType::CANCEL_RAIL_MOVEMENT, (eGameMessageType)1474);
-	EXPECT_EQ(eGameMessageType::CLIENT_RAIL_MOVEMENT_READY, (eGameMessageType)1476);
-	EXPECT_EQ(eGameMessageType::PLAYER_RAIL_ARRIVED_NOTIFICATION, (eGameMessageType)1477);
-	EXPECT_EQ(eGameMessageType::UPDATE_PLAYER_STATISTIC, (eGameMessageType)1481);
-	EXPECT_EQ(eGameMessageType::MODULAR_ASSEMBLY_NIF_COMPLETED, (eGameMessageType)1498);
-	EXPECT_EQ(eGameMessageType::NOTIFY_NOT_ENOUGH_INV_SPACE, (eGameMessageType)1516);
-	EXPECT_EQ(eGameMessageType::TEAM_SET_LEADER, (eGameMessageType)1557);
-	EXPECT_EQ(eGameMessageType::TEAM_INVITE_CONFIRM, (eGameMessageType)1558);
-	EXPECT_EQ(eGameMessageType::TEAM_GET_STATUS_RESPONSE, (eGameMessageType)1559);
-	EXPECT_EQ(eGameMessageType::TEAM_ADD_PLAYER, (eGameMessageType)1562);
-	EXPECT_EQ(eGameMessageType::TEAM_REMOVE_PLAYER, (eGameMessageType)1563);
-	EXPECT_EQ(eGameMessageType::START_CELEBRATION_EFFECT, (eGameMessageType)1618);
-	EXPECT_EQ(eGameMessageType::ADD_BUFF, (eGameMessageType)1647);
-	EXPECT_EQ(eGameMessageType::SERVER_DONE_LOADING_ALL_OBJECTS, (eGameMessageType)1642);
-	EXPECT_EQ(eGameMessageType::PLACE_PROPERTY_MODEL, (eGameMessageType)1170);
-	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER, (eGameMessageType)1606);
-	EXPECT_EQ(eGameMessageType::ADD_RUN_SPEED_MODIFIER, (eGameMessageType)1505);
-	EXPECT_EQ(eGameMessageType::GET_HOT_PROPERTY_DATA, (eGameMessageType)1511);
-	EXPECT_EQ(eGameMessageType::SEND_HOT_PROPERTY_DATA, (eGameMessageType)1510);
-	EXPECT_EQ(eGameMessageType::REMOVE_RUN_SPEED_MODIFIER, (eGameMessageType)1506);
-	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_PERFORMANCE_COST, (eGameMessageType)1547);
-	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_BEGIN, (eGameMessageType)1553);
-	EXPECT_EQ(eGameMessageType::SET_RESURRECT_RESTORE_VALUES, (eGameMessageType)1591);
-	EXPECT_EQ(eGameMessageType::VEHICLE_STOP_BOOST, (eGameMessageType)1617);
-	EXPECT_EQ(eGameMessageType::REMOVE_BUFF, (eGameMessageType)1648);
-	EXPECT_EQ(eGameMessageType::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, (eGameMessageType)1666);
-	EXPECT_EQ(eGameMessageType::RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, (eGameMessageType)1667);
-	EXPECT_EQ(eGameMessageType::PLAYER_SET_CAMERA_CYCLING_MODE, (eGameMessageType)1676);
-	EXPECT_EQ(eGameMessageType::SET_MOUNT_INVENTORY_ID, (eGameMessageType)1727);
-	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE, (eGameMessageType)1734);
-	EXPECT_EQ(eGameMessageType::NOTIFY_LEVEL_REWARDS, (eGameMessageType)1735);
-	EXPECT_EQ(eGameMessageType::DISMOUNT_COMPLETE, (eGameMessageType)1756);
-	EXPECT_EQ(eGameMessageType::MARK_INVENTORY_ITEM_AS_ACTIVE, (eGameMessageType)1767);
+	EXPECT_EQ(eGameMessageType::TELEPORT, static_cast<eGameMessageType>(19));
+	EXPECT_EQ(eGameMessageType::SET_PLAYER_CONTROL_SCHEME, static_cast<eGameMessageType>(26));
+	EXPECT_EQ(eGameMessageType::DROP_CLIENT_LOOT, static_cast<eGameMessageType>(30));
+	EXPECT_EQ(eGameMessageType::DIE, static_cast<eGameMessageType>(37));
+	EXPECT_EQ(eGameMessageType::REQUEST_DIE, static_cast<eGameMessageType>(38));
+	EXPECT_EQ(eGameMessageType::PLAY_EMOTE, static_cast<eGameMessageType>(41));
+	EXPECT_EQ(eGameMessageType::PLAY_ANIMATION, static_cast<eGameMessageType>(43));
+	EXPECT_EQ(eGameMessageType::CONTROL_BEHAVIORS, static_cast<eGameMessageType>(48));
+	EXPECT_EQ(eGameMessageType::SET_NAME, static_cast<eGameMessageType>(72));
+	EXPECT_EQ(eGameMessageType::ECHO_START_SKILL, static_cast<eGameMessageType>(118));
+	EXPECT_EQ(eGameMessageType::START_SKILL, static_cast<eGameMessageType>(119));
+	EXPECT_EQ(eGameMessageType::VERIFY_ACK, static_cast<eGameMessageType>(121));
+	EXPECT_EQ(eGameMessageType::ADD_SKILL, static_cast<eGameMessageType>(127));
+	EXPECT_EQ(eGameMessageType::REMOVE_SKILL, static_cast<eGameMessageType>(128));
+	EXPECT_EQ(eGameMessageType::SET_CURRENCY, static_cast<eGameMessageType>(133));
+	EXPECT_EQ(eGameMessageType::PICKUP_CURRENCY, static_cast<eGameMessageType>(137));
+	EXPECT_EQ(eGameMessageType::PICKUP_ITEM, static_cast<eGameMessageType>(139));
+	EXPECT_EQ(eGameMessageType::TEAM_PICKUP_ITEM, static_cast<eGameMessageType>(140));
+	EXPECT_EQ(eGameMessageType::PLAY_FX_EFFECT, static_cast<eGameMessageType>(154));
+	EXPECT_EQ(eGameMessageType::STOP_FX_EFFECT, static_cast<eGameMessageType>(155));
+	EXPECT_EQ(eGameMessageType::REQUEST_RESURRECT, static_cast<eGameMessageType>(159));
+	EXPECT_EQ(eGameMessageType::RESURRECT, static_cast<eGameMessageType>(160));
+	EXPECT_EQ(eGameMessageType::PUSH_EQUIPPED_ITEMS_STATE, static_cast<eGameMessageType>(191));
+	EXPECT_EQ(eGameMessageType::POP_EQUIPPED_ITEMS_STATE, static_cast<eGameMessageType>(192));
+	EXPECT_EQ(eGameMessageType::SET_GM_LEVEL, static_cast<eGameMessageType>(193));
+	EXPECT_EQ(eGameMessageType::SET_STUNNED, static_cast<eGameMessageType>(198));
+	EXPECT_EQ(eGameMessageType::SET_STUN_IMMUNITY, static_cast<eGameMessageType>(200));
+	EXPECT_EQ(eGameMessageType::KNOCKBACK, static_cast<eGameMessageType>(202));
+	EXPECT_EQ(eGameMessageType::REBUILD_CANCEL, static_cast<eGameMessageType>(209));
+	EXPECT_EQ(eGameMessageType::ENABLE_REBUILD, static_cast<eGameMessageType>(213));
+	EXPECT_EQ(eGameMessageType::MOVE_ITEM_IN_INVENTORY, static_cast<eGameMessageType>(224));
+	EXPECT_EQ(eGameMessageType::ADD_ITEM_TO_INVENTORY_CLIENT_SYNC, static_cast<eGameMessageType>(227));
+	EXPECT_EQ(eGameMessageType::REMOVE_ITEM_FROM_INVENTORY, static_cast<eGameMessageType>(230));
+	EXPECT_EQ(eGameMessageType::EQUIP_INVENTORY, static_cast<eGameMessageType>(231));
+	EXPECT_EQ(eGameMessageType::UN_EQUIP_INVENTORY, static_cast<eGameMessageType>(233));
+	EXPECT_EQ(eGameMessageType::OFFER_MISSION, static_cast<eGameMessageType>(248));
+	EXPECT_EQ(eGameMessageType::RESPOND_TO_MISSION, static_cast<eGameMessageType>(249));
+	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION, static_cast<eGameMessageType>(254));
+	EXPECT_EQ(eGameMessageType::NOTIFY_MISSION_TASK, static_cast<eGameMessageType>(255));
+	EXPECT_EQ(eGameMessageType::REBUILD_NOTIFY_STATE, static_cast<eGameMessageType>(336));
+	EXPECT_EQ(eGameMessageType::TERMINATE_INTERACTION, static_cast<eGameMessageType>(357));
+	EXPECT_EQ(eGameMessageType::SERVER_TERMINATE_INTERACTION, static_cast<eGameMessageType>(358));
+	EXPECT_EQ(eGameMessageType::REQUEST_USE, static_cast<eGameMessageType>(364));
+	EXPECT_EQ(eGameMessageType::VENDOR_OPEN_WINDOW, static_cast<eGameMessageType>(369));
+	EXPECT_EQ(eGameMessageType::BUY_FROM_VENDOR, static_cast<eGameMessageType>(373));
+	EXPECT_EQ(eGameMessageType::SELL_TO_VENDOR, static_cast<eGameMessageType>(374));
+	EXPECT_EQ(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG, static_cast<eGameMessageType>(383));
+	EXPECT_EQ(eGameMessageType::SET_INVENTORY_SIZE, static_cast<eGameMessageType>(389));
+	EXPECT_EQ(eGameMessageType::ACKNOWLEDGE_POSSESSION, static_cast<eGameMessageType>(391));
+	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_PARAMS, static_cast<eGameMessageType>(400));
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_START_STOP, static_cast<eGameMessageType>(402));
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_ENTER, static_cast<eGameMessageType>(403));
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_EXIT, static_cast<eGameMessageType>(404));
+	EXPECT_EQ(eGameMessageType::ACTIVITY_ENTER, static_cast<eGameMessageType>(405));
+	EXPECT_EQ(eGameMessageType::ACTIVITY_EXIT, static_cast<eGameMessageType>(406));
+	EXPECT_EQ(eGameMessageType::ACTIVITY_START, static_cast<eGameMessageType>(407));
+	EXPECT_EQ(eGameMessageType::ACTIVITY_STOP, static_cast<eGameMessageType>(408));
+	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_CLIENT_AIM_UPDATE, static_cast<eGameMessageType>(409));
+	EXPECT_EQ(eGameMessageType::SHOOTING_GALLERY_FIRE, static_cast<eGameMessageType>(411));
+	EXPECT_EQ(eGameMessageType::REQUEST_VENDOR_STATUS_UPDATE, static_cast<eGameMessageType>(416));
+	EXPECT_EQ(eGameMessageType::VENDOR_STATUS_UPDATE, static_cast<eGameMessageType>(417));
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE, static_cast<eGameMessageType>(425));
+	EXPECT_EQ(eGameMessageType::CONSUME_CLIENT_ITEM, static_cast<eGameMessageType>(427));
+	EXPECT_EQ(eGameMessageType::CLIENT_ITEM_CONSUMED, static_cast<eGameMessageType>(428));
+	EXPECT_EQ(eGameMessageType::UPDATE_SHOOTING_GALLERY_ROTATION, static_cast<eGameMessageType>(448));
+	EXPECT_EQ(eGameMessageType::SET_FLAG, static_cast<eGameMessageType>(471));
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FLAG_CHANGE, static_cast<eGameMessageType>(472));
+	EXPECT_EQ(eGameMessageType::VENDOR_TRANSACTION_RESULT, static_cast<eGameMessageType>(476));
+	EXPECT_EQ(eGameMessageType::HAS_BEEN_COLLECTED, static_cast<eGameMessageType>(486));
+	EXPECT_EQ(eGameMessageType::DISPLAY_CHAT_BUBBLE, static_cast<eGameMessageType>(495));
+	EXPECT_EQ(eGameMessageType::SPAWN_PET, static_cast<eGameMessageType>(498));
+	EXPECT_EQ(eGameMessageType::DESPAWN_PET, static_cast<eGameMessageType>(499));
+	EXPECT_EQ(eGameMessageType::PLAYER_LOADED, static_cast<eGameMessageType>(505));
+	EXPECT_EQ(eGameMessageType::PLAYER_READY, static_cast<eGameMessageType>(509));
+	EXPECT_EQ(eGameMessageType::REQUEST_LINKED_MISSION, static_cast<eGameMessageType>(515));
+	EXPECT_EQ(eGameMessageType::INVALID_ZONE_TRANSFER_LIST, static_cast<eGameMessageType>(519));
+	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_OK, static_cast<eGameMessageType>(520));
+	EXPECT_EQ(eGameMessageType::DISPLAY_MESSAGE_BOX, static_cast<eGameMessageType>(529));
+	EXPECT_EQ(eGameMessageType::MESSAGE_BOX_RESPOND, static_cast<eGameMessageType>(530));
+	EXPECT_EQ(eGameMessageType::CHOICE_BOX_RESPOND, static_cast<eGameMessageType>(531));
+	EXPECT_EQ(eGameMessageType::SMASH, static_cast<eGameMessageType>(537));
+	EXPECT_EQ(eGameMessageType::UN_SMASH, static_cast<eGameMessageType>(538));
+	EXPECT_EQ(eGameMessageType::PLACE_MODEL_RESPONSE, static_cast<eGameMessageType>(547));
+	EXPECT_EQ(eGameMessageType::SET_SHOOTING_GALLERY_RETICULE_EFFECT, static_cast<eGameMessageType>(546));
+	EXPECT_EQ(eGameMessageType::SET_JET_PACK_MODE, static_cast<eGameMessageType>(561));
+	EXPECT_EQ(eGameMessageType::REGISTER_PET_ID, static_cast<eGameMessageType>(565));
+	EXPECT_EQ(eGameMessageType::REGISTER_PET_DBID, static_cast<eGameMessageType>(566));
+	EXPECT_EQ(eGameMessageType::SHOW_ACTIVITY_COUNTDOWN, static_cast<eGameMessageType>(568));
+	EXPECT_EQ(eGameMessageType::START_ACTIVITY_TIME, static_cast<eGameMessageType>(576));
+	EXPECT_EQ(eGameMessageType::ACTIVITY_PAUSE, static_cast<eGameMessageType>(602));
+	EXPECT_EQ(eGameMessageType::USE_NON_EQUIPMENT_ITEM, static_cast<eGameMessageType>(603));
+	EXPECT_EQ(eGameMessageType::USE_ITEM_RESULT, static_cast<eGameMessageType>(607));
+	EXPECT_EQ(eGameMessageType::COMMAND_PET, static_cast<eGameMessageType>(640));
+	EXPECT_EQ(eGameMessageType::PET_RESPONSE, static_cast<eGameMessageType>(641));
+	EXPECT_EQ(eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA, static_cast<eGameMessageType>(648));
+	EXPECT_EQ(eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA, static_cast<eGameMessageType>(649));
+	EXPECT_EQ(eGameMessageType::NOTIFY_OBJECT, static_cast<eGameMessageType>(656));
+	EXPECT_EQ(eGameMessageType::CLIENT_NOTIFY_PET, static_cast<eGameMessageType>(659));
+	EXPECT_EQ(eGameMessageType::NOTIFY_PET, static_cast<eGameMessageType>(660));
+	EXPECT_EQ(eGameMessageType::NOTIFY_PET_TAMING_MINIGAME, static_cast<eGameMessageType>(661));
+	EXPECT_EQ(eGameMessageType::START_SERVER_PET_MINIGAME_TIMER, static_cast<eGameMessageType>(662));
+	EXPECT_EQ(eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME, static_cast<eGameMessageType>(663));
+	EXPECT_EQ(eGameMessageType::PET_NAME_CHANGED, static_cast<eGameMessageType>(686));
+	EXPECT_EQ(eGameMessageType::PET_TAMING_MINIGAME_RESULT, static_cast<eGameMessageType>(667));
+	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD_RESULT, static_cast<eGameMessageType>(668));
+	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_BUILD_SUCCESS, static_cast<eGameMessageType>(673));
+	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_MODEL_LOADED_ON_SERVER, static_cast<eGameMessageType>(674));
+	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF, static_cast<eGameMessageType>(678));
+	EXPECT_EQ(eGameMessageType::DECTIVATE_BUBBLE_BUFF, static_cast<eGameMessageType>(679));
+	EXPECT_EQ(eGameMessageType::ADD_PET_TO_PLAYER, static_cast<eGameMessageType>(681));
+	EXPECT_EQ(eGameMessageType::REQUEST_SET_PET_NAME, static_cast<eGameMessageType>(683));
+	EXPECT_EQ(eGameMessageType::SET_PET_NAME, static_cast<eGameMessageType>(684));
+	EXPECT_EQ(eGameMessageType::NOTIFY_TAMING_PUZZLE_SELECTED, static_cast<eGameMessageType>(675));
+	EXPECT_EQ(eGameMessageType::SHOW_PET_ACTION_BUTTON, static_cast<eGameMessageType>(692));
+	EXPECT_EQ(eGameMessageType::SET_EMOTE_LOCK_STATE, static_cast<eGameMessageType>(693));
+	EXPECT_EQ(eGameMessageType::USE_ITEM_REQUIREMENTS_RESPONSE, static_cast<eGameMessageType>(703));
+	EXPECT_EQ(eGameMessageType::PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT, static_cast<eGameMessageType>(713));
+	EXPECT_EQ(eGameMessageType::DOWNLOAD_PROPERTY_DATA, static_cast<eGameMessageType>(716));
+	EXPECT_EQ(eGameMessageType::QUERY_PROPERTY_DATA, static_cast<eGameMessageType>(717));
+	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_BEGIN, static_cast<eGameMessageType>(724));
+	EXPECT_EQ(eGameMessageType::PROPERTY_EDITOR_END, static_cast<eGameMessageType>(725));
+	EXPECT_EQ(eGameMessageType::IS_MINIFIG_IN_A_BUBBLE, static_cast<eGameMessageType>(729));
+	EXPECT_EQ(eGameMessageType::START_PATHING, static_cast<eGameMessageType>(733));
+	EXPECT_EQ(eGameMessageType::ACTIVATE_BUBBLE_BUFF_FROM_SERVER, static_cast<eGameMessageType>(734));
+	EXPECT_EQ(eGameMessageType::DEACTIVATE_BUBBLE_BUFF_FROM_SERVER, static_cast<eGameMessageType>(735));
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_ZONE_OBJECT, static_cast<eGameMessageType>(737));
+	EXPECT_EQ(eGameMessageType::UPDATE_REPUTATION, static_cast<eGameMessageType>(746));
+	EXPECT_EQ(eGameMessageType::PROPERTY_RENTAL_RESPONSE, static_cast<eGameMessageType>(750));
+	EXPECT_EQ(eGameMessageType::REQUEST_PLATFORM_RESYNC, static_cast<eGameMessageType>(760));
+	EXPECT_EQ(eGameMessageType::PLATFORM_RESYNC, static_cast<eGameMessageType>(761));
+	EXPECT_EQ(eGameMessageType::PLAY_CINEMATIC, static_cast<eGameMessageType>(762));
+	EXPECT_EQ(eGameMessageType::END_CINEMATIC, static_cast<eGameMessageType>(763));
+	EXPECT_EQ(eGameMessageType::CINEMATIC_UPDATE, static_cast<eGameMessageType>(764));
+	EXPECT_EQ(eGameMessageType::TOGGLE_GHOST_REFERENCE_OVERRIDE, static_cast<eGameMessageType>(767));
+	EXPECT_EQ(eGameMessageType::SET_GHOST_REFERENCE_POSITION, static_cast<eGameMessageType>(768));
+	EXPECT_EQ(eGameMessageType::FIRE_EVENT_SERVER_SIDE, static_cast<eGameMessageType>(770));
+	EXPECT_EQ(eGameMessageType::SCRIPT_NETWORK_VAR_UPDATE, static_cast<eGameMessageType>(781));
+	EXPECT_EQ(eGameMessageType::UPDATE_MODEL_FROM_CLIENT, static_cast<eGameMessageType>(793));
+	EXPECT_EQ(eGameMessageType::DELETE_MODEL_FROM_CLIENT, static_cast<eGameMessageType>(794));
+	EXPECT_EQ(eGameMessageType::PLAY_ND_AUDIO_EMITTER, static_cast<eGameMessageType>(821));
+	EXPECT_EQ(eGameMessageType::PLAY2_D_AMBIENT_SOUND, static_cast<eGameMessageType>(831));
+	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY1, static_cast<eGameMessageType>(840));
+	EXPECT_EQ(eGameMessageType::ENTER_PROPERTY2, static_cast<eGameMessageType>(841));
+	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_SYNC, static_cast<eGameMessageType>(842));
+	EXPECT_EQ(eGameMessageType::PROPERTY_SELECT_QUERY, static_cast<eGameMessageType>(845));
+	EXPECT_EQ(eGameMessageType::PARSE_CHAT_MESSAGE, static_cast<eGameMessageType>(850));
+	EXPECT_EQ(eGameMessageType::BROADCAST_TEXT_TO_CHATBOX, static_cast<eGameMessageType>(858));
+	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_MANAGEMENT, static_cast<eGameMessageType>(860));
+	EXPECT_EQ(eGameMessageType::OPEN_PROPERTY_VENDOR, static_cast<eGameMessageType>(861));
+	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK, static_cast<eGameMessageType>(863));
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REQUEST, static_cast<eGameMessageType>(868));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REQUEST, static_cast<eGameMessageType>(869));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INVITE, static_cast<eGameMessageType>(870));
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_REPLY, static_cast<eGameMessageType>(871));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_REPLY, static_cast<eGameMessageType>(872));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_INITIAL_REPLY, static_cast<eGameMessageType>(873));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_FINAL_REPLY, static_cast<eGameMessageType>(874));
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_UPDATE, static_cast<eGameMessageType>(875));
+	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_UPDATE, static_cast<eGameMessageType>(876));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_UPDATE, static_cast<eGameMessageType>(877));
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_CANCEL, static_cast<eGameMessageType>(878));
+	EXPECT_EQ(eGameMessageType::CLIENT_SIDE_TRADE_CANCEL, static_cast<eGameMessageType>(879));
+	EXPECT_EQ(eGameMessageType::CLIENT_TRADE_ACCEPT, static_cast<eGameMessageType>(880));
+	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_ACCEPT, static_cast<eGameMessageType>(881));
+	EXPECT_EQ(eGameMessageType::SERVER_SIDE_TRADE_CANCEL, static_cast<eGameMessageType>(882));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_CANCEL, static_cast<eGameMessageType>(883));
+	EXPECT_EQ(eGameMessageType::SERVER_TRADE_ACCEPT, static_cast<eGameMessageType>(884));
+	EXPECT_EQ(eGameMessageType::READY_FOR_UPDATES, static_cast<eGameMessageType>(888));
+	EXPECT_EQ(eGameMessageType::ORIENT_TO_OBJECT, static_cast<eGameMessageType>(905));
+	EXPECT_EQ(eGameMessageType::ORIENT_TO_POSITION, static_cast<eGameMessageType>(906));
+	EXPECT_EQ(eGameMessageType::ORIENT_TO_ANGLE, static_cast<eGameMessageType>(907));
+	EXPECT_EQ(eGameMessageType::BOUNCER_ACTIVE_STATUS, static_cast<eGameMessageType>(942));
+	EXPECT_EQ(eGameMessageType::UN_USE_BBB_MODEL, static_cast<eGameMessageType>(999));
+	EXPECT_EQ(eGameMessageType::BBB_LOAD_ITEM_REQUEST, static_cast<eGameMessageType>(1000));
+	EXPECT_EQ(eGameMessageType::BBB_SAVE_REQUEST, static_cast<eGameMessageType>(1001));
+	EXPECT_EQ(eGameMessageType::BBB_SAVE_RESPONSE, static_cast<eGameMessageType>(1005));
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_OBJECT, static_cast<eGameMessageType>(1042));
+	EXPECT_EQ(eGameMessageType::DISPLAY_ZONE_SUMMARY, static_cast<eGameMessageType>(1043));
+	EXPECT_EQ(eGameMessageType::ZONE_SUMMARY_DISMISSED, static_cast<eGameMessageType>(1044));
+	EXPECT_EQ(eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST, static_cast<eGameMessageType>(1053));
+	EXPECT_EQ(eGameMessageType::MODIFY_PLAYER_ZONE_STATISTIC, static_cast<eGameMessageType>(1046));
+	EXPECT_EQ(eGameMessageType::START_BUILDING_WITH_ITEM, static_cast<eGameMessageType>(1057));
+	EXPECT_EQ(eGameMessageType::START_ARRANGING_WITH_ITEM, static_cast<eGameMessageType>(1061));
+	EXPECT_EQ(eGameMessageType::FINISH_ARRANGING_WITH_ITEM, static_cast<eGameMessageType>(1062));
+	EXPECT_EQ(eGameMessageType::DONE_ARRANGING_WITH_ITEM, static_cast<eGameMessageType>(1063));
+	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE, static_cast<eGameMessageType>(1068));
+	EXPECT_EQ(eGameMessageType::BUILD_MODE_SET, static_cast<eGameMessageType>(1069));
+	EXPECT_EQ(eGameMessageType::SET_BUILD_MODE_CONFIRMED, static_cast<eGameMessageType>(1073));
+	EXPECT_EQ(eGameMessageType::NOTIFY_CLIENT_FAILED_PRECONDITION, static_cast<eGameMessageType>(1081));
+	EXPECT_EQ(eGameMessageType::MOVE_ITEM_BETWEEN_INVENTORY_TYPES, static_cast<eGameMessageType>(1093));
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_BEGIN, static_cast<eGameMessageType>(1094));
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_END, static_cast<eGameMessageType>(1095));
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_MOVE_AND_EQUIP, static_cast<eGameMessageType>(1096));
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_FINISH, static_cast<eGameMessageType>(1097));
+	EXPECT_EQ(eGameMessageType::REPORT_BUG, static_cast<eGameMessageType>(1198));
+	EXPECT_EQ(eGameMessageType::MISSION_DIALOGUE_CANCELLED, static_cast<eGameMessageType>(1129));
+	EXPECT_EQ(eGameMessageType::ECHO_SYNC_SKILL, static_cast<eGameMessageType>(1144));
+	EXPECT_EQ(eGameMessageType::SYNC_SKILL, static_cast<eGameMessageType>(1145));
+	EXPECT_EQ(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT, static_cast<eGameMessageType>(1148));
+	EXPECT_EQ(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT, static_cast<eGameMessageType>(1151));
+	EXPECT_EQ(eGameMessageType::MODULAR_BUILD_CONVERT_MODEL, static_cast<eGameMessageType>(1155));
+	EXPECT_EQ(eGameMessageType::SET_PLAYER_ALLOWED_RESPAWN, static_cast<eGameMessageType>(1165));
+	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_SINGLE_CLIENT, static_cast<eGameMessageType>(1184));
+	EXPECT_EQ(eGameMessageType::UI_MESSAGE_SERVER_TO_ALL_CLIENTS, static_cast<eGameMessageType>(1185));
+	EXPECT_EQ(eGameMessageType::PET_TAMING_TRY_BUILD, static_cast<eGameMessageType>(1197));
+	EXPECT_EQ(eGameMessageType::REQUEST_SMASH_PLAYER, static_cast<eGameMessageType>(1202));
+	EXPECT_EQ(eGameMessageType::FIRE_EVENT_CLIENT_SIDE, static_cast<eGameMessageType>(1213));
+	EXPECT_EQ(eGameMessageType::TOGGLE_GM_INVIS, static_cast<eGameMessageType>(1218));
+	EXPECT_EQ(eGameMessageType::CHANGE_OBJECT_WORLD_STATE, static_cast<eGameMessageType>(1223));
+	EXPECT_EQ(eGameMessageType::VEHICLE_LOCK_INPUT, static_cast<eGameMessageType>(1230));
+	EXPECT_EQ(eGameMessageType::VEHICLE_UNLOCK_INPUT, static_cast<eGameMessageType>(1231));
+	EXPECT_EQ(eGameMessageType::RACING_RESET_PLAYER_TO_LAST_RESET, static_cast<eGameMessageType>(1252));
+	EXPECT_EQ(eGameMessageType::RACING_SERVER_SET_PLAYER_LAP_AND_PLANE, static_cast<eGameMessageType>(1253));
+	EXPECT_EQ(eGameMessageType::RACING_SET_PLAYER_RESET_INFO, static_cast<eGameMessageType>(1254));
+	EXPECT_EQ(eGameMessageType::RACING_PLAYER_INFO_RESET_FINISHED, static_cast<eGameMessageType>(1255));
+	EXPECT_EQ(eGameMessageType::LOCK_NODE_ROTATION, static_cast<eGameMessageType>(1260));
+	EXPECT_EQ(eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE, static_cast<eGameMessageType>(1273));
+	EXPECT_EQ(eGameMessageType::NOTIFY_VEHICLE_OF_RACING_OBJECT, static_cast<eGameMessageType>(1276));
+	EXPECT_EQ(eGameMessageType::SET_NAME_BILLBOARD_STATE, static_cast<eGameMessageType>(1284));
+	EXPECT_EQ(eGameMessageType::PLAYER_REACHED_RESPAWN_CHECKPOINT, static_cast<eGameMessageType>(1296));
+	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_DELETE_BASED_ON_EDIT_MODE, static_cast<eGameMessageType>(1300));
+	EXPECT_EQ(eGameMessageType::HANDLE_UGC_POST_CREATE_BASED_ON_EDIT_MODE, static_cast<eGameMessageType>(1301));
+	EXPECT_EQ(eGameMessageType::PROPERTY_CONTENTS_FROM_CLIENT, static_cast<eGameMessageType>(1305));
+	EXPECT_EQ(eGameMessageType::GET_MODELS_ON_PROPERTY, static_cast<eGameMessageType>(1306));
+	EXPECT_EQ(eGameMessageType::MATCH_REQUEST, static_cast<eGameMessageType>(1308));
+	EXPECT_EQ(eGameMessageType::MATCH_RESPONSE, static_cast<eGameMessageType>(1309));
+	EXPECT_EQ(eGameMessageType::MATCH_UPDATE, static_cast<eGameMessageType>(1310));
+	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT, static_cast<eGameMessageType>(1131));
+	EXPECT_EQ(eGameMessageType::MODULE_ASSEMBLY_QUERY_DATA, static_cast<eGameMessageType>(1132));
+	EXPECT_EQ(eGameMessageType::SHOW_BILLBOARD_INTERACT_ICON, static_cast<eGameMessageType>(1337));
+	EXPECT_EQ(eGameMessageType::CHANGE_IDLE_FLAGS, static_cast<eGameMessageType>(1338));
+	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1340));
+	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1341));
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1342));
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION, static_cast<eGameMessageType>(1343));
+	EXPECT_EQ(eGameMessageType::VEHICLE_ADD_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1344));
+	EXPECT_EQ(eGameMessageType::VEHICLE_REMOVE_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1345));
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_ADD_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1346));
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_VEHICLE_REMOVE_SLOWDOWN_ACTION, static_cast<eGameMessageType>(1347));
+	EXPECT_EQ(eGameMessageType::BUYBACK_FROM_VENDOR, static_cast<eGameMessageType>(1350));
+	EXPECT_EQ(eGameMessageType::SET_PROPERTY_ACCESS, static_cast<eGameMessageType>(1366));
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PLACED, static_cast<eGameMessageType>(1369));
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_ROTATED, static_cast<eGameMessageType>(1370));
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED, static_cast<eGameMessageType>(1371));
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED, static_cast<eGameMessageType>(1372));
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_PICKED_UP, static_cast<eGameMessageType>(1373));
+	EXPECT_EQ(eGameMessageType::ZONE_PROPERTY_MODEL_REMOVED, static_cast<eGameMessageType>(1374));
+	EXPECT_EQ(eGameMessageType::NOTIFY_RACING_CLIENT, static_cast<eGameMessageType>(1390));
+	EXPECT_EQ(eGameMessageType::RACING_PLAYER_HACK_CAR, static_cast<eGameMessageType>(1391));
+	EXPECT_EQ(eGameMessageType::RACING_PLAYER_LOADED, static_cast<eGameMessageType>(1392));
+	EXPECT_EQ(eGameMessageType::RACING_CLIENT_READY, static_cast<eGameMessageType>(1393));
+	EXPECT_EQ(eGameMessageType::UPDATE_CHAT_MODE, static_cast<eGameMessageType>(1395));
+	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_FINISHED_RACE, static_cast<eGameMessageType>(1396));
+	EXPECT_EQ(eGameMessageType::SET_CONSUMABLE_ITEM, static_cast<eGameMessageType>(1409));
+	EXPECT_EQ(eGameMessageType::SET_STATUS_IMMUNITY, static_cast<eGameMessageType>(1435));
+	EXPECT_EQ(eGameMessageType::SET_PET_NAME_MODERATED, static_cast<eGameMessageType>(1448));
+	EXPECT_EQ(eGameMessageType::MODIFY_LEGO_SCORE, static_cast<eGameMessageType>(1459));
+	EXPECT_EQ(eGameMessageType::RESTORE_TO_POST_LOAD_STATS, static_cast<eGameMessageType>(1468));
+	EXPECT_EQ(eGameMessageType::SET_RAIL_MOVEMENT, static_cast<eGameMessageType>(1471));
+	EXPECT_EQ(eGameMessageType::START_RAIL_MOVEMENT, static_cast<eGameMessageType>(1472));
+	EXPECT_EQ(eGameMessageType::CANCEL_RAIL_MOVEMENT, static_cast<eGameMessageType>(1474));
+	EXPECT_EQ(eGameMessageType::CLIENT_RAIL_MOVEMENT_READY, static_cast<eGameMessageType>(1476));
+	EXPECT_EQ(eGameMessageType::PLAYER_RAIL_ARRIVED_NOTIFICATION, static_cast<eGameMessageType>(1477));
+	EXPECT_EQ(eGameMessageType::UPDATE_PLAYER_STATISTIC, static_cast<eGameMessageType>(1481));
+	EXPECT_EQ(eGameMessageType::MODULAR_ASSEMBLY_NIF_COMPLETED, static_cast<eGameMessageType>(1498));
+	EXPECT_EQ(eGameMessageType::NOTIFY_NOT_ENOUGH_INV_SPACE, static_cast<eGameMessageType>(1516));
+	EXPECT_EQ(eGameMessageType::TEAM_SET_LEADER, static_cast<eGameMessageType>(1557));
+	EXPECT_EQ(eGameMessageType::TEAM_INVITE_CONFIRM, static_cast<eGameMessageType>(1558));
+	EXPECT_EQ(eGameMessageType::TEAM_GET_STATUS_RESPONSE, static_cast<eGameMessageType>(1559));
+	EXPECT_EQ(eGameMessageType::TEAM_ADD_PLAYER, static_cast<eGameMessageType>(1562));
+	EXPECT_EQ(eGameMessageType::TEAM_REMOVE_PLAYER, static_cast<eGameMessageType>(1563));
+	EXPECT_EQ(eGameMessageType::START_CELEBRATION_EFFECT, static_cast<eGameMessageType>(1618));
+	EXPECT_EQ(eGameMessageType::ADD_BUFF, static_cast<eGameMessageType>(1647));
+	EXPECT_EQ(eGameMessageType::SERVER_DONE_LOADING_ALL_OBJECTS, static_cast<eGameMessageType>(1642));
+	EXPECT_EQ(eGameMessageType::PLACE_PROPERTY_MODEL, static_cast<eGameMessageType>(1170));
+	EXPECT_EQ(eGameMessageType::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER, static_cast<eGameMessageType>(1606));
+	EXPECT_EQ(eGameMessageType::ADD_RUN_SPEED_MODIFIER, static_cast<eGameMessageType>(1505));
+	EXPECT_EQ(eGameMessageType::GET_HOT_PROPERTY_DATA, static_cast<eGameMessageType>(1511));
+	EXPECT_EQ(eGameMessageType::SEND_HOT_PROPERTY_DATA, static_cast<eGameMessageType>(1510));
+	EXPECT_EQ(eGameMessageType::REMOVE_RUN_SPEED_MODIFIER, static_cast<eGameMessageType>(1506));
+	EXPECT_EQ(eGameMessageType::UPDATE_PROPERTY_PERFORMANCE_COST, static_cast<eGameMessageType>(1547));
+	EXPECT_EQ(eGameMessageType::PROPERTY_ENTRANCE_BEGIN, static_cast<eGameMessageType>(1553));
+	EXPECT_EQ(eGameMessageType::SET_RESURRECT_RESTORE_VALUES, static_cast<eGameMessageType>(1591));
+	EXPECT_EQ(eGameMessageType::VEHICLE_STOP_BOOST, static_cast<eGameMessageType>(1617));
+	EXPECT_EQ(eGameMessageType::REMOVE_BUFF, static_cast<eGameMessageType>(1648));
+	EXPECT_EQ(eGameMessageType::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, static_cast<eGameMessageType>(1666));
+	EXPECT_EQ(eGameMessageType::RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES, static_cast<eGameMessageType>(1667));
+	EXPECT_EQ(eGameMessageType::PLAYER_SET_CAMERA_CYCLING_MODE, static_cast<eGameMessageType>(1676));
+	EXPECT_EQ(eGameMessageType::SET_MOUNT_INVENTORY_ID, static_cast<eGameMessageType>(1727));
+	EXPECT_EQ(eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE, static_cast<eGameMessageType>(1734));
+	EXPECT_EQ(eGameMessageType::NOTIFY_LEVEL_REWARDS, static_cast<eGameMessageType>(1735));
+	EXPECT_EQ(eGameMessageType::DISMOUNT_COMPLETE, static_cast<eGameMessageType>(1756));
+	EXPECT_EQ(eGameMessageType::MARK_INVENTORY_ITEM_AS_ACTIVE, static_cast<eGameMessageType>(1767));
 }