Dont preemptively delete objects

Let finalizeShutdown take care of it

.clang-format

@@ -0,0 +1,37 @@
+---
+BraceWrapping: 
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterObjCDeclaration: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+  BeforeLambdaBody: false
+  BeforeWhile: false
+BreakBeforeBraces: Attach
+ColumnLimit: 0
+IndentWidth: 4
+IndentCaseLabels: true
+IncludeBlocks: Regroup
+IncludeCategories:
+  - Regex: '<[[:alnum:].]+\.h>'
+    Priority: 1
+  - Regex: '<[[:alnum:].]+>'
+    Priority: 2
+  - Regex: '.*/.*'
+    Priority: 3
+  - Regex: '.*'
+    Priority: 4
+DerivePointerAlignment: false
+PointerAlignment: Left
+...

.clang-tidy

@@ -0,0 +1,17 @@
+Checks: '-*,readability-*,performance-*,modernize-*,-modernize-use-trailing-return-type,bugprone-*'
+WarningsAsErrors: true
+HeaderFilterRegex: ''
+FormatStyle: none
+CheckOptions:
+  - key: readability-identifier-naming.ClassCase
+    value: CamelCase
+  - key: readability-identifier-naming.ClassMethodCase
+    value: CamelCase
+  - key: readability-identifier-naming.ClassMemberPrefix
+    value: m_
+  - key: readability-identifier-naming.ClassMemberCase
+    value: CamelCase
+  - key: readability-identifier-naming.ClassConstantCase
+    value: UPPER_CASE
+  - key: readability-identifier-naming.FunctionCase
+    value: CamelCase

.git-blame-ignore-revs

@@ -6,6 +6,3 @@
 
 # convert to unix line endings
 72477e01e2711e0f61cdb192ee266e5e21b8846f
-
-# enum cleanup
-faf42d2f8cf432df2993b031f079b0b8c6d7dbe7

CMakeLists.txt

@@ -163,7 +163,6 @@ set(INCLUDED_DIRECTORIES
 	"dGame/dMission"
 	"dGame/dEntity"
 	"dGame/dPropertyBehaviors"
-	"dGame/dPropertyBehaviors/ControlBehaviorMessages"
 	"dGame/dUtilities"
 	"dPhysics"
 	"dNavigation"
@@ -255,11 +254,6 @@ set(INCLUDED_DIRECTORIES
 	"tests/dGameTests/dComponentsTests"
 	)
 
-if(__include_lua__)
-	set(INCLUDED_DIRECTORIES ${INCLUDED_DIRECTORIES} "dLua")
-	set(INCLUDED_DIRECTORIES ${INCLUDED_DIRECTORIES} "dLua/sol")
-endif()
-
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
 if (APPLE)
 	include_directories("/usr/local/include/")
@@ -322,7 +316,6 @@ add_subdirectory(dDatabase)
 add_subdirectory(dChatFilter)
 add_subdirectory(dNet)
 add_subdirectory(dScripts) # Add for dGame to use
-add_subdirectory(dLua)
 add_subdirectory(dGame)
 add_subdirectory(dZoneManager)
 add_subdirectory(dNavigation)

README.md

@@ -172,10 +172,6 @@ You can either run `build.sh` when in the root folder of the repository:
 
 Or manually run the commands used in [build.sh](build.sh).
 
-If you would like to build the server faster, append `-j<number>` where number is the number of simultaneous compile jobs to run at once.  It is recommended that you have this number always be 1 less than your core count to prevent slowdowns.  The command would look like this if you would build with 4 jobs at once:
-```bash
-./build.sh -j4
-```
 ### Notes
 Depending on your operating system, you may need to adjust some pre-processor defines in [CMakeVariables.txt](./CMakeVariables.txt) before building:
 * If you are on MacOS, ensure OPENSSL_ROOT_DIR is pointing to the openssl root directory.
@@ -245,11 +241,30 @@ To connect to a server follow these steps:
 * In the client directory, locate `boot.cfg`
 * Open it in a text editor and locate where it says `AUTHSERVERIP=0:`
 * Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
-* Next locate the line `UGCUSE3DSERVICES=7:`
-* Ensure the number after the 7 is a `0`
 * Launch `legouniverse.exe`, through `wine` if on a Unix-like operating system
 * Note that if you are on WSL2, you will need to configure the public IP in the server and client to be the IP of the WSL2 instance and not localhost, which can be found by running `ifconfig` in the terminal. Windows defaults to WSL1, so this will not apply to most users.
 
+## Brick-By-Brick building
+Should you choose to do any brick building, you will want to have some form of a http server that returns a 404 error since we are unable to emulate live User Generated Content at the moment. If you attempt to do any brick building without a 404 server running properly, you will be unable to load into your game. Python is the easiest way to do this, but any thing that returns a 404 should work fine.
+* Note: the client hard codes this request on port 80.
+
+<font size="4">**If you do not plan on doing any Brick Building, then you can skip this step.**</font>
+
+The easiest way to do this is to install [python](https://www.python.org/downloads/).
+
+### Allowing a user to build in Brick-by-Brick mode
+Brick-By-Brick building requires `PATCHSERVERIP=0:` and `UGCSERVERIP=0:` in the `boot.cfg` to point to a HTTP server which always returns `HTTP 404 - Not Found` for all requests. This can be most easily achieved by pointing both of those variables to `localhost` while having running in the background.
+Each client must have their own 404 server running if they are using a locally hosted 404 server.
+```bash
+# If on linux run this command. Because this is run on a port below 1024, binary network permissions are needed.
+sudo python3 -m http.server 80
+
+# If on windows one of the following will work when run through Powershell or Command Prompt assuming python is installed
+python3 -m http.server 80
+python http.server 80
+py -m http.server 80
+```
+
 ## Updating your server
 To update your server to the latest version navigate to your cloned directory
 ```bash

build.sh

@@ -9,5 +9,5 @@ cd build
 cmake ..
 
 # To build utilizing multiple cores, append `-j` and the amount of cores to utilize, for example `cmake --build . --config Release -j8'
-cmake --build . --config Release $1
+cmake --build . --config Release -j4
 

dAuthServer/AuthServer.cpp

@@ -15,13 +15,10 @@
 
 //RakNet includes:
 #include "RakNetDefines.h"
-#include <MessageIdentifiers.h>
 
 //Auth includes:
 #include "AuthPackets.h"
-#include "eConnectionType.h"
-#include "eServerMessageType.h"
-#include "eAuthMessageType.h"
+#include "dMessageIdentifiers.h"
 
 #include "Game.h"
 namespace Game {
@@ -171,15 +168,13 @@ dLogger* SetupLogger() {
 }
 
 void HandlePacket(Packet* packet) {
-	if (packet->length < 4) return;
-
 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
-		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
-			if (static_cast<eServerMessageType>(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) {
+		if (packet->data[1] == SERVER) {
+			if (packet->data[3] == MSG_SERVER_VERSION_CONFIRM) {
 				AuthPackets::HandleHandshake(Game::server, packet);
 			}
-		} else if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::AUTH) {
-			if (static_cast<eAuthMessageType>(packet->data[3]) == eAuthMessageType::LOGIN_REQUEST) {
+		} else if (packet->data[1] == AUTH) {
+			if (packet->data[3] == MSG_AUTH_LOGIN_REQUEST) {
 				AuthPackets::HandleLoginRequest(Game::server, packet);
 			}
 		}

dChatFilter/dChatFilter.cpp

@@ -12,7 +12,6 @@
 #include "dConfig.h"
 #include "Database.h"
 #include "Game.h"
-#include "eGameMasterLevel.h"
 
 using namespace dChatFilterDCF;
 
@@ -109,8 +108,8 @@ 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) {
-	if (gmLevel > eGameMasterLevel::FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
+std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, int gmLevel, bool whiteList) {
+	if (gmLevel > GAME_MASTER_LEVEL_FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
 	if (message.empty()) return { };
 	if (!whiteList && m_DeniedWords.empty()) return { { 0, message.length() } };
 

dChatFilter/dChatFilter.h

@@ -4,7 +4,6 @@
 
 #include "dCommonVars.h"
 
-enum class eGameMasterLevel : uint8_t;
 namespace dChatFilterDCF {
 	static const uint32_t header = ('D' + ('C' << 8) + ('F' << 16) + ('B' << 24));
 	static const uint32_t formatVersion = 2;
@@ -24,7 +23,7 @@ public:
 	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);
+	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, int gmLevel, bool whiteList = true);
 
 private:
 	bool m_DontGenerateDCF;

dChatServer/ChatPacketHandler.cpp

@@ -3,20 +3,15 @@
 #include "Database.h"
 #include <vector>
 #include "PacketUtils.h"
+#include "dMessageIdentifiers.h"
 #include "Game.h"
 #include "dServer.h"
 #include "GeneralUtils.h"
 #include "dLogger.h"
-#include "eAddFriendResponseCode.h"
-#include "eAddFriendResponseType.h"
+#include "AddFriendResponseCode.h"
+#include "AddFriendResponseType.h"
 #include "RakString.h"
 #include "dConfig.h"
-#include "eObjectBits.h"
-#include "eConnectionType.h"
-#include "eChatMessageType.h"
-#include "eChatInternalMessageType.h"
-#include "eClientMessageType.h"
-#include "eGameMessageType.h"
 
 extern PlayerContainer playerContainer;
 
@@ -50,8 +45,8 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		FriendData fd;
 		fd.isFTP = false; // not a thing in DLU
 		fd.friendID = res->getUInt(1);
-		GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
-		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
 
 		fd.isBestFriend = res->getInt(2) == 3; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
 		if (fd.isBestFriend) player->countOfBestFriends += 1;
@@ -76,11 +71,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE);
 	bitStream.Write<uint8_t>(0);
 	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
 	bitStream.Write((uint16_t)friends.size());
@@ -120,7 +115,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 	auto requestor = playerContainer.GetPlayerData(requestorPlayerID);
 	if (requestor->playerName == playerName) {
-		SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN);
+		SendFriendResponse(requestor, requestor, AddFriendResponseType::MYTHRAN);
 		return;
 	};
 	std::unique_ptr<PlayerData> requestee(playerContainer.GetPlayerData(playerName));
@@ -158,7 +153,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		requestee.reset(new PlayerData());
 		requestee->playerName = playerName;
 
-		SendFriendResponse(requestor, requestee.get(), result->next() ? eAddFriendResponseType::NOTONLINE : eAddFriendResponseType::INVALIDCHARACTER);
+		SendFriendResponse(requestor, requestee.get(), result->next() ? AddFriendResponseType::NOTONLINE : AddFriendResponseType::INVALIDCHARACTER);
 		return;
 	}
 
@@ -183,10 +178,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 			bestFriendStatus = oldBestFriendStatus;
 
 			// Set the bits
-			GeneralUtils::SetBit(queryPlayerID, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(queryPlayerID, eObjectBits::PERSISTENT);
-			GeneralUtils::SetBit(queryFriendID, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(queryFriendID, eObjectBits::PERSISTENT);
+			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
 
 			// Since this player can either be the friend of someone else or be friends with someone else
 			// their column in the database determines what bit gets set.  When the value hits 3, they
@@ -202,10 +197,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		if (oldBestFriendStatus != bestFriendStatus) {
 			if (requestee->countOfBestFriends >= maxNumberOfBestFriends || requestor->countOfBestFriends >= maxNumberOfBestFriends) {
 				if (requestee->countOfBestFriends >= maxNumberOfBestFriends) {
-					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
+					SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::THEIRFRIENDLISTFULL, false);
 				}
 				if (requestor->countOfBestFriends >= maxNumberOfBestFriends) {
-					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
+					SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::YOURFRIENDSLISTFULL, false);
 				}
 			} else {
 				// Then update the database with this new info.
@@ -220,8 +215,8 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 				if (bestFriendStatus == 3U) {
 					requestee->countOfBestFriends += 1;
 					requestor->countOfBestFriends += 1;
-					if (requestee->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee.get(), requestor, eAddFriendResponseType::ACCEPTED, false, true);
-					if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::ACCEPTED, false, true);
+					if (requestee->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee.get(), requestor, AddFriendResponseType::ACCEPTED, false, true);
+					if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::ACCEPTED, false, true);
 					for (auto& friendData : requestor->friends) {
 						if (friendData.friendID == requestee->playerID) {
 							friendData.isBestFriend = true;
@@ -235,7 +230,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 				}
 			}
 		} else {
-			if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::WAITINGAPPROVAL, true, true);
+			if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), AddFriendResponseType::WAITINGAPPROVAL, true, true);
 		}
 	} else {
 		// Do not send this if we are requesting to be a best friend.
@@ -252,7 +247,7 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	inStream.Read(playerID);
 	inStream.Read(playerID);
 
-	eAddFriendResponseCode clientResponseCode = static_cast<eAddFriendResponseCode>(packet->data[0x14]);
+	AddFriendResponseCode clientResponseCode = static_cast<AddFriendResponseCode>(packet->data[0x14]);
 	std::string friendName = PacketUtils::ReadString(0x15, packet, true);
 
 	//Now to try and find both of these:
@@ -260,29 +255,29 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	auto requestee = playerContainer.GetPlayerData(friendName);
 	if (!requestor || !requestee) return;
 
-	eAddFriendResponseType serverResponseCode{};
+	AddFriendResponseType serverResponseCode{};
 	uint8_t isAlreadyBestFriends = 0U;
 	// We need to convert this response code to one we can actually send back to the client.
 	switch (clientResponseCode) {
-	case eAddFriendResponseCode::ACCEPTED:
-		serverResponseCode = eAddFriendResponseType::ACCEPTED;
+	case AddFriendResponseCode::ACCEPTED:
+		serverResponseCode = AddFriendResponseType::ACCEPTED;
 		break;
-	case eAddFriendResponseCode::BUSY:
-		serverResponseCode = eAddFriendResponseType::BUSY;
+	case AddFriendResponseCode::BUSY:
+		serverResponseCode = AddFriendResponseType::BUSY;
 		break;
-	case eAddFriendResponseCode::CANCELLED:
-		serverResponseCode = eAddFriendResponseType::CANCELLED;
+	case AddFriendResponseCode::CANCELLED:
+		serverResponseCode = AddFriendResponseType::CANCELLED;
 		break;
-	case eAddFriendResponseCode::REJECTED:
-		serverResponseCode = eAddFriendResponseType::DECLINED;
+	case AddFriendResponseCode::REJECTED:
+		serverResponseCode = AddFriendResponseType::DECLINED;
 		break;
 	}
 
 	// Now that we have handled the base cases, we need to check the other cases.
-	if (serverResponseCode == eAddFriendResponseType::ACCEPTED) {
+	if (serverResponseCode == AddFriendResponseType::ACCEPTED) {
 		for (auto friendData : requestor->friends) {
 			if (friendData.friendID == requestee->playerID) {
-				serverResponseCode = eAddFriendResponseType::ALREADYFRIEND;
+				serverResponseCode = AddFriendResponseType::ALREADYFRIEND;
 				if (friendData.isBestFriend) {
 					isAlreadyBestFriends = 1U;
 				}
@@ -291,7 +286,7 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	}
 
 	// This message is NOT sent for best friends and is handled differently for those requests.
-	if (serverResponseCode == eAddFriendResponseType::ACCEPTED) {
+	if (serverResponseCode == AddFriendResponseType::ACCEPTED) {
 		// Add the each player to the others friend list.
 		FriendData requestorData;
 		requestorData.zoneID = requestor->zoneID;
@@ -318,8 +313,8 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 		statement->execute();
 	}
 
-	if (serverResponseCode != eAddFriendResponseType::DECLINED) SendFriendResponse(requestor, requestee, serverResponseCode, isAlreadyBestFriends);
-	if (serverResponseCode != eAddFriendResponseType::ALREADYFRIEND) SendFriendResponse(requestee, requestor, serverResponseCode, isAlreadyBestFriends);
+	if (serverResponseCode != AddFriendResponseType::DECLINED) SendFriendResponse(requestor, requestee, serverResponseCode, isAlreadyBestFriends);
+	if (serverResponseCode != AddFriendResponseType::ALREADYFRIEND) SendFriendResponse(requestee, requestor, serverResponseCode, isAlreadyBestFriends);
 }
 
 void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
@@ -341,8 +336,8 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 	}
 
 	// Convert friendID to LWOOBJID
-	GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
-	GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
 
 	std::unique_ptr<sql::PreparedStatement> deletestmt(Database::CreatePreppedStmt("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;"));
 	deletestmt->setUInt(1, static_cast<uint32_t>(playerID));
@@ -417,10 +412,10 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 		const auto otherName = std::string(otherMember->playerName.c_str());
 
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 		bitStream.Write(otherMember->playerID);
 
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(otherMember->playerID);
 		bitStream.Write<uint8_t>(8);
 		bitStream.Write<unsigned int>(69);
@@ -456,10 +451,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the sender:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 		bitStream.Write(goonA->playerID);
 
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -479,10 +474,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the receiver:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 		bitStream.Write(goonB->playerID);
 
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -721,11 +716,11 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TEAM_INVITE);
 
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write(sender->playerID);
@@ -736,14 +731,14 @@ void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender)
 
 void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_INVITE_CONFIRM);
 
 	bitStream.Write(bLeaderIsFreeTrial);
 	bitStream.Write(i64LeaderID);
@@ -763,14 +758,14 @@ void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeader
 
 void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_GET_STATUS_RESPONSE);
 
 	bitStream.Write(i64LeaderID);
 	bitStream.Write(i64LeaderZoneID);
@@ -788,14 +783,14 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI
 
 void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_SET_LEADER);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_LEADER);
 
 	bitStream.Write(i64PlayerID);
 
@@ -805,14 +800,14 @@ void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64Play
 
 void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_ADD_PLAYER);
 
 	bitStream.Write(bIsFreeTrial);
 	bitStream.Write(bLocal);
@@ -834,14 +829,14 @@ void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTria
 
 void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_REMOVE_PLAYER);
 
 	bitStream.Write(bDisband);
 	bitStream.Write(bIsKicked);
@@ -860,14 +855,14 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband
 
 void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_OFF_WORLD_FLAG);
 
 	bitStream.Write(i64PlayerID);
 	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID()) {
@@ -894,11 +889,11 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(friendData->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
 	std::string playerName = playerData->playerName.c_str();
@@ -927,17 +922,17 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	//Make sure people aren't requesting people that they're already friends with:
 	for (auto fr : receiver->friends) {
 		if (fr.friendID == sender->playerID) {
-			SendFriendResponse(sender, receiver, eAddFriendResponseType::ALREADYFRIEND, fr.isBestFriend);
+			SendFriendResponse(sender, receiver, AddFriendResponseType::ALREADYFRIEND, fr.isBestFriend);
 			return; //we have this player as a friend, yeet this function so it doesn't send another request.
 		}
 	}
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_REQUEST);
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.
 
@@ -945,22 +940,22 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
+void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sender, AddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
 	if (!receiver || !sender) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	// Portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_RESPONSE);
 	bitStream.Write(responseCode);
 	// For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver.
-	bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
+	bitStream.Write<uint8_t>(responseCode != AddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
 	// Then write the player name
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	// Then if this is an acceptance code, write the following extra info.
-	if (responseCode == eAddFriendResponseType::ACCEPTED) {
+	if (responseCode == AddFriendResponseType::ACCEPTED) {
 		bitStream.Write(sender->playerID);
 		bitStream.Write(sender->zoneID);
 		bitStream.Write(isBestFriendRequest); //isBFF
@@ -974,11 +969,11 @@ void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& pers
 	if (!receiver) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	PacketUtils::WritePacketWString(personToRemove, 33, &bitStream);
 

dChatServer/ChatPacketHandler.h

@@ -4,7 +4,7 @@
 #include "BitStream.h"
 
 struct PlayerData;
-enum class eAddFriendResponseType : uint8_t;
+enum class AddFriendResponseType : uint8_t;
 
 namespace ChatPacketHandler {
 	void HandleFriendlistRequest(Packet* packet);
@@ -35,6 +35,6 @@ namespace ChatPacketHandler {
 	void SendFriendUpdate(PlayerData* friendData, PlayerData* playerData, uint8_t notifyType, uint8_t isBestFriend);
 
 	void SendFriendRequest(PlayerData* receiver, PlayerData* sender);
-	void SendFriendResponse(PlayerData* receiver, PlayerData* sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready = 0U, uint8_t isBestFriendRequest = 0U);
+	void SendFriendResponse(PlayerData* receiver, PlayerData* sender, AddFriendResponseType responseCode, uint8_t isBestFriendsAlready = 0U, uint8_t isBestFriendRequest = 0U);
 	void SendRemoveFriend(PlayerData* receiver, std::string& personToRemove, bool isSuccessful);
 };

dChatServer/ChatServer.cpp

@@ -9,23 +9,19 @@
 #include "dLogger.h"
 #include "Database.h"
 #include "dConfig.h"
+#include "dMessageIdentifiers.h"
 #include "dChatFilter.h"
 #include "Diagnostics.h"
 #include "AssetManager.h"
 #include "BinaryPathFinder.h"
-#include "eConnectionType.h"
+
 #include "PlayerContainer.h"
 #include "ChatPacketHandler.h"
-#include "eChatMessageType.h"
-#include "eChatInternalMessageType.h"
-#include "eWorldMessageType.h"
 
 #include "Game.h"
 
 //RakNet includes:
 #include "RakNetDefines.h"
-#include <MessageIdentifiers.h>
-
 namespace Game {
 	dLogger* logger = nullptr;
 	dServer* server = nullptr;
@@ -72,7 +68,7 @@ int main(int argc, char** argv) {
 		Game::assetManager = new AssetManager(clientPath);
 	} catch (std::runtime_error& ex) {
 		Game::logger->Log("ChatServer", "Got an error while setting up assets: %s", ex.what());
-
+		
 		return EXIT_FAILURE;
 	}
 
@@ -203,27 +199,25 @@ void HandlePacket(Packet* packet) {
 		Game::logger->Log("ChatServer", "A server is connecting, awaiting user list.");
 	}
 
-	if (packet->length < 4) return; // Nothing left to process.  Need 4 bytes to continue.
-
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
-		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
-		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
+	if (packet->data[1] == CHAT_INTERNAL) {
+		switch (packet->data[3]) {
+		case MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION:
 			playerContainer.InsertPlayer(packet);
 			break;
 
-		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
+		case MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION:
 			playerContainer.RemovePlayer(packet);
 			break;
 
-		case eChatInternalMessageType::MUTE_UPDATE:
+		case MSG_CHAT_INTERNAL_MUTE_UPDATE:
 			playerContainer.MuteUpdate(packet);
 			break;
 
-		case eChatInternalMessageType::CREATE_TEAM:
+		case MSG_CHAT_INTERNAL_CREATE_TEAM:
 			playerContainer.CreateTeamServer(packet);
 			break;
 
-		case eChatInternalMessageType::ANNOUNCEMENT: {
+		case MSG_CHAT_INTERNAL_ANNOUNCEMENT: {
 			//we just forward this packet to every connected server
 			CINSTREAM;
 			Game::server->Send(&inStream, packet->systemAddress, true); //send to everyone except origin
@@ -235,67 +229,67 @@ void HandlePacket(Packet* packet) {
 		}
 	}
 
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
-		switch (static_cast<eChatMessageType>(packet->data[3])) {
-		case eChatMessageType::GET_FRIENDS_LIST:
+	if (packet->data[1] == CHAT) {
+		switch (packet->data[3]) {
+		case MSG_CHAT_GET_FRIENDS_LIST:
 			ChatPacketHandler::HandleFriendlistRequest(packet);
 			break;
 
-		case eChatMessageType::GET_IGNORE_LIST:
+		case MSG_CHAT_GET_IGNORE_LIST:
 			Game::logger->Log("ChatServer", "Asked for ignore list, but is unimplemented right now.");
 			break;
 
-		case eChatMessageType::TEAM_GET_STATUS:
+		case MSG_CHAT_TEAM_GET_STATUS:
 			ChatPacketHandler::HandleTeamStatusRequest(packet);
 			break;
 
-		case eChatMessageType::ADD_FRIEND_REQUEST:
+		case MSG_CHAT_ADD_FRIEND_REQUEST:
 			//this involves someone sending the initial request, the response is below, response as in from the other player.
 			//We basically just check to see if this player is online or not and route the packet.
 			ChatPacketHandler::HandleFriendRequest(packet);
 			break;
 
-		case eChatMessageType::ADD_FRIEND_RESPONSE:
+		case MSG_CHAT_ADD_FRIEND_RESPONSE:
 			//This isn't the response a server sent, rather it is a player's response to a received request.
 			//Here, we'll actually have to add them to eachother's friend lists depending on the response code.
 			ChatPacketHandler::HandleFriendResponse(packet);
 			break;
 
-		case eChatMessageType::REMOVE_FRIEND:
+		case MSG_CHAT_REMOVE_FRIEND:
 			ChatPacketHandler::HandleRemoveFriend(packet);
 			break;
 
-		case eChatMessageType::GENERAL_CHAT_MESSAGE:
+		case MSG_CHAT_GENERAL_CHAT_MESSAGE:
 			ChatPacketHandler::HandleChatMessage(packet);
 			break;
 
-		case eChatMessageType::PRIVATE_CHAT_MESSAGE:
+		case MSG_CHAT_PRIVATE_CHAT_MESSAGE:
 			//This message is supposed to be echo'd to both the sender and the receiver
 			//BUT: they have to have different responseCodes, so we'll do some of the ol hacky wacky to fix that right up.
 			ChatPacketHandler::HandlePrivateChatMessage(packet);
 			break;
 
-		case eChatMessageType::TEAM_INVITE:
+		case MSG_CHAT_TEAM_INVITE:
 			ChatPacketHandler::HandleTeamInvite(packet);
 			break;
 
-		case eChatMessageType::TEAM_INVITE_RESPONSE:
+		case MSG_CHAT_TEAM_INVITE_RESPONSE:
 			ChatPacketHandler::HandleTeamInviteResponse(packet);
 			break;
 
-		case eChatMessageType::TEAM_LEAVE:
+		case MSG_CHAT_TEAM_LEAVE:
 			ChatPacketHandler::HandleTeamLeave(packet);
 			break;
 
-		case eChatMessageType::TEAM_SET_LEADER:
+		case MSG_CHAT_TEAM_SET_LEADER:
 			ChatPacketHandler::HandleTeamPromote(packet);
 			break;
 
-		case eChatMessageType::TEAM_KICK:
+		case MSG_CHAT_TEAM_KICK:
 			ChatPacketHandler::HandleTeamKick(packet);
 			break;
 
-		case eChatMessageType::TEAM_SET_LOOT:
+		case MSG_CHAT_TEAM_SET_LOOT:
 			ChatPacketHandler::HandleTeamLootOption(packet);
 			break;
 
@@ -304,9 +298,9 @@ void HandlePacket(Packet* packet) {
 		}
 	}
 
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
-		switch (static_cast<eWorldMessageType>(packet->data[3])) {
-		case eWorldMessageType::ROUTE_PACKET: {
+	if (packet->data[1] == WORLD) {
+		switch (packet->data[3]) {
+		case MSG_WORLD_CLIENT_ROUTE_PACKET: {
 			Game::logger->Log("ChatServer", "Routing packet from world");
 			break;
 		}

dChatServer/PlayerContainer.cpp

@@ -6,10 +6,9 @@
 #include "dLogger.h"
 #include "ChatPacketHandler.h"
 #include "GeneralUtils.h"
+#include "dMessageIdentifiers.h"
 #include "PacketUtils.h"
 #include "Database.h"
-#include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
 
 PlayerContainer::PlayerContainer() {
 }
@@ -150,7 +149,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -349,7 +348,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_TEAM_UPDATE);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);

dCommon/AMFFormat.h

@@ -257,7 +257,7 @@ private:
 	/*!
 	 \return The AMF value type
 	 */
-	AMFValueType GetValueType() override { return ValueType; }
+	AMFValueType GetValueType() { return ValueType; }
 
 public:
 	static const AMFValueType ValueType = AMFArray;
@@ -362,7 +362,7 @@ private:
 	/*!
 	 \return The AMF value type
 	 */
-	AMFValueType GetValueType() override { return ValueType; }
+	AMFValueType GetValueType() { return ValueType; }
 	~AMFObjectValue() override;
 
 public:

dCommon/AMFFormat_BitStream.cpp

@@ -65,15 +65,6 @@ void RakNet::BitStream::Write<AMFValue*>(AMFValue* value) {
 			this->Write((AMFArrayValue*)value);
 			break;
 		}
-		case AMFObject:
-		case AMFXML:
-		case AMFByteArray:
-		case AMFVectorInt:
-		case AMFVectorUInt:
-		case AMFVectorDouble:
-		case AMFVectorObject:
-		case AMFDictionary:
-			break;
 		}
 	}
 }

dCommon/Brick.h

@@ -1,11 +0,0 @@
-#ifndef __BRICK__H__
-#define __BRICK__H__
-
-#include <cstdint>
-
-struct Brick {
-	uint32_t designerID;
-	uint32_t materialID;
-};
-
-#endif  //!__BRICK__H__

dCommon/Diagnostics.cpp

@@ -111,7 +111,7 @@ static void ErrorCallback(void* data, const char* msg, int errnum) {
 
 void GenerateDump() {
 	std::string cmd = "sudo gcore " + std::to_string(getpid());
-	int ret = system(cmd.c_str()); // Saving a return just to prevent warning
+	system(cmd.c_str());
 }
 
 void CatchUnhandled(int sig) {

dCommon/GeneralUtils.cpp

@@ -241,7 +241,7 @@ std::vector<std::wstring> GeneralUtils::SplitString(std::wstring& str, wchar_t d
 	return vector;
 }
 
-std::vector<std::u16string> GeneralUtils::SplitString(const std::u16string& str, char16_t delimiter) {
+std::vector<std::u16string> GeneralUtils::SplitString(std::u16string& str, char16_t delimiter) {
 	std::vector<std::u16string> vector = std::vector<std::u16string>();
 	std::u16string current;
 
@@ -319,7 +319,3 @@ std::vector<std::string> GeneralUtils::GetSqlFileNamesFromFolder(const std::stri
 
 	return sortedFiles;
 }
-
-bool GeneralUtils::TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst) {
-	return TryParse<float>(x.c_str(), dst.x) && TryParse<float>(y.c_str(), dst.y) && TryParse<float>(z.c_str(), dst.z);
-}

dCommon/GeneralUtils.h

@@ -10,14 +10,11 @@
 #include <type_traits>
 #include <stdexcept>
 #include <BitStream.h>
-#include "NiPoint3.h"
 
 #include "Game.h"
 #include "dLogger.h"
 
 enum eInventoryType : uint32_t;
-enum class eObjectBits : size_t;
-enum class eReplicaComponentType : uint32_t;
 
 /*!
   \file GeneralUtils.hpp
@@ -67,9 +64,9 @@ namespace GeneralUtils {
 
 	//! Sets a bit on a numerical value
 	template <typename T>
-	inline void SetBit(T& value, eObjectBits bits) {
+	void SetBit(T& value, size_t index) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+
 		if (index > (sizeof(T) * 8) - 1) {
 			return;
 		}
@@ -79,9 +76,9 @@ namespace GeneralUtils {
 
 	//! Clears a bit on a numerical value
 	template <typename T>
-	inline void ClearBit(T& value, eObjectBits bits) {
+	void ClearBit(T& value, size_t index) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+
 		if (index > (sizeof(T) * 8 - 1)) {
 			return;
 		}
@@ -140,7 +137,7 @@ namespace GeneralUtils {
 
 	std::vector<std::wstring> SplitString(std::wstring& str, wchar_t delimiter);
 
-	std::vector<std::u16string> SplitString(const std::u16string& str, char16_t delimiter);
+	std::vector<std::u16string> SplitString(std::u16string& str, char16_t delimiter);
 
 	std::vector<std::string> SplitString(const std::string& str, char delimiter);
 
@@ -184,11 +181,6 @@ namespace GeneralUtils {
 		return static_cast<eInventoryType>(std::stoul(value));
 	}
 
-	template <>
-	inline eReplicaComponentType Parse(const char* value) {
-		return static_cast<eReplicaComponentType>(std::stoul(value));
-	}
-
 	template <typename T>
 	bool TryParse(const char* value, T& dst) {
 		try {
@@ -210,8 +202,6 @@ namespace GeneralUtils {
 		return TryParse<T>(value.c_str(), dst);
 	}
 
-	bool TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst);
-
 	template<typename T>
 	std::u16string to_u16string(T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));

dCommon/LDFFormat.cpp

@@ -3,174 +3,122 @@
 // Custom Classes
 #include "GeneralUtils.h"
 
-#include "Game.h"
-#include "dLogger.h"
-
 // C++
-#include <string_view>
+#include <sstream>
 #include <vector>
 
-using LDFKey = std::string_view;
-using LDFTypeAndValue = std::string_view;
-
-using LDFType = std::string_view;
-using LDFValue = std::string_view;
-
 //! Returns a pointer to a LDFData value based on string format
-LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
-	// A valid LDF must be at least 3 characters long (=0:) is the shortest valid LDF (empty UTF-16 key with no initial value)
-	if (format.empty() || format.length() <= 2) return nullptr;
-	auto equalsPosition = format.find('=');
-	// You can have an empty key, just make sure the type and value might exist
-	if (equalsPosition == std::string::npos || equalsPosition == (format.size() - 1)) return nullptr;
+LDFBaseData* LDFBaseData::DataFromString(const std::string& format) {
 
-	std::pair<LDFKey, LDFTypeAndValue> keyValue;
-	keyValue.first = format.substr(0, equalsPosition);
-	keyValue.second = format.substr(equalsPosition + 1, format.size());
+	// First, check the format
+	std::istringstream ssFormat(format);
+	std::string token;
 
-	std::u16string key = GeneralUtils::ASCIIToUTF16(keyValue.first);
-
-	auto colonPosition = keyValue.second.find(':');
-
-	// If : is the first thing after an =, then this is an invalid LDF since
-	// we dont have a type to use.
-	if (colonPosition == std::string::npos || colonPosition == 0) return nullptr;
-
-	std::pair<LDFType, LDFValue> ldfTypeAndValue;
-	ldfTypeAndValue.first = keyValue.second.substr(0, colonPosition);
-	ldfTypeAndValue.second = keyValue.second.substr(colonPosition + 1, keyValue.second.size());
-
-	// Only allow empty values for string values.
-	if (ldfTypeAndValue.second.size() == 0 && !(ldfTypeAndValue.first == "0" || ldfTypeAndValue.first == "13")) return nullptr;
-
-	eLDFType type;
-	char* storage;
-	try {
-		type = static_cast<eLDFType>(strtol(ldfTypeAndValue.first.data(), &storage, 10));
-	} catch (std::exception) {
-		Game::logger->Log("LDFFormat", "Attempted to process invalid ldf type (%s) from string (%s)", ldfTypeAndValue.first.data(), format.data());
-		return nullptr;
+	std::vector<std::string> keyValueArray;
+	while (std::getline(ssFormat, token, '=')) {
+		keyValueArray.push_back(token);
 	}
 
-	LDFBaseData* returnValue = nullptr;
-	switch (type) {
-	case LDF_TYPE_UTF_16: {
-		std::u16string data = GeneralUtils::UTF8ToUTF16(ldfTypeAndValue.second);
-		returnValue = new LDFData<std::u16string>(key, data);
-		break;
-	}
+	if (keyValueArray.size() == 2) {
+		std::u16string key = GeneralUtils::ASCIIToUTF16(keyValueArray[0]);
 
-	case LDF_TYPE_S32: {
-		try {
-			int32_t data = static_cast<int32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
-			returnValue = new LDFData<int32_t>(key, data);
-		} catch (std::exception) {
-			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
-			return nullptr;
+		std::vector<std::string> dataArray;
+		std::istringstream ssData(keyValueArray[1]);
+		while (std::getline(ssData, token, ':')) {
+			dataArray.push_back(token);
 		}
-		break;
-	}
 
-	case LDF_TYPE_FLOAT: {
-		try {
-			float data = strtof(ldfTypeAndValue.second.data(), &storage);
-			returnValue = new LDFData<float>(key, data);
-		} catch (std::exception) {
-			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
-			return nullptr;
+		if (dataArray.size() > 2) { // hacky fix for strings with colons in them
+			std::vector<std::string> newDataArray;
+			newDataArray.push_back(dataArray[0]);
+			std::string value = "";
+			for (size_t i = 1; i < dataArray.size(); ++i) {
+				value += dataArray[i] + ':';
+			}
+			value.pop_back(); // remove last colon
+			newDataArray.push_back(value);
+			dataArray = newDataArray;
 		}
-		break;
-	}
 
-	case LDF_TYPE_DOUBLE: {
-		try {
-			double data = strtod(ldfTypeAndValue.second.data(), &storage);
-			returnValue = new LDFData<double>(key, data);
-		} catch (std::exception) {
-			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
-			return nullptr;
+		if ((dataArray[0] == "0" || dataArray[0] == "13") && dataArray.size() == 1) {
+			dataArray.push_back("");
 		}
-		break;
-	}
 
-	case LDF_TYPE_U32:
-	{
-		uint32_t data;
+		if (dataArray.size() == 2) {
+			eLDFType type = static_cast<eLDFType>(stoi(dataArray[0]));
 
-		if (ldfTypeAndValue.second == "true") {
-			data = 1;
-		} else if (ldfTypeAndValue.second == "false") {
-			data = 0;
-		} else {
-			try {
-				data = static_cast<uint32_t>(strtoul(ldfTypeAndValue.second.data(), &storage, 10));
-			} catch (std::exception) {
-				Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			switch (type) {
+			case LDF_TYPE_UTF_16: {
+				std::u16string data = GeneralUtils::UTF8ToUTF16(dataArray[1]);
+				return new LDFData<std::u16string>(key, data);
+			}
+
+			case LDF_TYPE_S32: {
+				int32_t data = static_cast<int32_t>(stoull(dataArray[1]));
+				return new LDFData<int32_t>(key, data);
+			}
+
+			case LDF_TYPE_FLOAT: {
+				float data = static_cast<float>(stof(dataArray[1]));
+				return new LDFData<float>(key, data);
+			}
+
+			case LDF_TYPE_DOUBLE: {
+				double data = static_cast<float>(stod(dataArray[1]));
+				return new LDFData<double>(key, data);
+			}
+
+			case LDF_TYPE_U32:
+			{
+				uint32_t data;
+
+				if (dataArray[1] == "true") {
+					data = 1;
+				} else if (dataArray[1] == "false") {
+					data = 0;
+				} else {
+					data = static_cast<uint32_t>(stoul(dataArray[1]));
+				}
+
+				return new LDFData<uint32_t>(key, data);
+			}
+
+			case LDF_TYPE_BOOLEAN: {
+				bool data;
+
+				if (dataArray[1] == "true") {
+					data = true;
+				} else if (dataArray[1] == "false") {
+					data = false;
+				} else {
+					data = static_cast<bool>(stoi(dataArray[1]));
+				}
+
+				return new LDFData<bool>(key, data);
+			}
+
+			case LDF_TYPE_U64: {
+				uint64_t data = static_cast<uint64_t>(stoull(dataArray[1]));
+				return new LDFData<uint64_t>(key, data);
+			}
+
+			case LDF_TYPE_OBJID: {
+				LWOOBJID data = static_cast<LWOOBJID>(stoll(dataArray[1]));
+				return new LDFData<LWOOBJID>(key, data);
+			}
+
+			case LDF_TYPE_UTF_8: {
+				std::string data = dataArray[1];
+				return new LDFData<std::string>(key, data);
+			}
+
+			case LDF_TYPE_UNKNOWN: {
 				return nullptr;
 			}
-		}
-
-		returnValue = new LDFData<uint32_t>(key, data);
-		break;
-	}
-
-	case LDF_TYPE_BOOLEAN: {
-		bool data;
-
-		if (ldfTypeAndValue.second == "true") {
-			data = true;
-		} else if (ldfTypeAndValue.second == "false") {
-			data = false;
-		} else {
-			try {
-				data = static_cast<bool>(strtol(ldfTypeAndValue.second.data(), &storage, 10));
-			} catch (std::exception) {
-				Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
-				return nullptr;
 			}
 		}
-
-		returnValue = new LDFData<bool>(key, data);
-		break;
 	}
 
-	case LDF_TYPE_U64: {
-		try {
-			uint64_t data = static_cast<uint64_t>(strtoull(ldfTypeAndValue.second.data(), &storage, 10));
-			returnValue = new LDFData<uint64_t>(key, data);
-		} catch (std::exception) {
-			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
-			return nullptr;
-		}
-		break;
-	}
+	return nullptr;
 
-	case LDF_TYPE_OBJID: {
-		try {
-			LWOOBJID data = static_cast<LWOOBJID>(strtoll(ldfTypeAndValue.second.data(), &storage, 10));
-			returnValue = new LDFData<LWOOBJID>(key, data);
-		} catch (std::exception) {
-			Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
-			return nullptr;
-		}
-		break;
-	}
-
-	case LDF_TYPE_UTF_8: {
-		std::string data = ldfTypeAndValue.second.data();
-		returnValue = new LDFData<std::string>(key, data);
-		break;
-	}
-
-	case LDF_TYPE_UNKNOWN: {
-		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
-		break;
-	}
-
-	default: {
-		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LDF type (%d) from string (%s)", type, format.data());
-		break;
-	}
-	}
-	return returnValue;
 }

dCommon/LDFFormat.h

@@ -1,5 +1,4 @@
-#ifndef __LDFFORMAT__H__
-#define __LDFFORMAT__H__
+#pragma once
 
 // Custom Classes
 #include "dCommonVars.h"
@@ -7,12 +6,18 @@
 
 // C++
 #include <string>
-#include <string_view>
 #include <sstream>
 
 // RakNet
-#include "BitStream.h"
 
+#include "../thirdparty/raknet/Source/BitStream.h"
+
+/*!
+  \file LDFFormat.hpp
+  \brief A collection of LDF format classes
+ */
+
+ //! An enum for LDF Data Types
 enum eLDFType {
 	LDF_TYPE_UNKNOWN = -1,          //!< Unknown data type
 	LDF_TYPE_UTF_16 = 0,            //!< UTF-16 wstring data type
@@ -26,21 +31,36 @@ enum eLDFType {
 	LDF_TYPE_UTF_8 = 13,            //!< UTF-8 string data type
 };
 
+//! A base class for the LDF data
 class LDFBaseData {
 public:
 
-	virtual ~LDFBaseData() {}
+	//! Destructor
+	virtual ~LDFBaseData(void) {}
 
+	//! Writes the data to a packet
+	/*!
+	  \param packet The packet
+	 */
 	virtual void WriteToPacket(RakNet::BitStream* packet) = 0;
 
-	virtual const std::u16string& GetKey() = 0;
+	//! Gets the key
+	/*!
+	  \return The key
+	 */
+	virtual const std::u16string& GetKey(void) = 0;
 
-	virtual eLDFType GetValueType() = 0;
+	//! Gets the value type
+	/*!
+	  \return The value type
+	 */
+	virtual eLDFType GetValueType(void) = 0;
 
-	/** Gets a string from the key/value pair
-	 * @param includeKey Whether or not to include the key in the data
-	 * @param includeTypeId Whether or not to include the type id in the data
-	 * @return The string representation of the data
+	//! Gets a string from the key/value pair
+	/*!
+	  \param includeKey Whether or not to include the key in the data
+	  \param includeTypeId Whether or not to include the type id in the data
+	  \return The string representation of the data
 	 */
 	virtual std::string GetString(bool includeKey = true, bool includeTypeId = true) = 0;
 
@@ -48,15 +68,19 @@ public:
 
 	virtual LDFBaseData* Copy() = 0;
 
-	/**
-	 * Given an input string, return the data as a LDF key.
+	// MARK: Functions
+
+	//! Returns a pointer to a LDFData value based on string format
+	/*!
+	  \param format The format
 	 */
-	static LDFBaseData* DataFromString(const std::string_view& format);
+	static LDFBaseData* DataFromString(const std::string& format);
 
 };
 
+//! A structure for an LDF key-value pair
 template<typename T>
-class LDFData: public LDFBaseData {
+class LDFData : public LDFBaseData {
 private:
 	std::u16string key;
 	T value;
@@ -140,11 +164,15 @@ public:
 
 		if (includeKey) {
 			const std::string& sKey = GeneralUtils::UTF16ToWTF8(this->key, this->key.size());
-			stream << sKey << '=';
+
+			stream << sKey << "=";
 		}
 
 		if (includeTypeId) {
-			stream << this->GetValueType() << ':';
+			const std::string& sType = std::to_string(this->GetValueType());
+
+
+			stream << sType << ":";
 		}
 
 		const std::string& sData = this->GetValueString();
@@ -206,18 +234,20 @@ inline void LDFData<std::string>::WriteValue(RakNet::BitStream* packet) {
 	}
 }
 
-template<> inline std::string LDFData<std::u16string>::GetValueString() {
+// MARK: String Data
+template<> inline std::string LDFData<std::u16string>::GetValueString(void) {
+	//std::string toReturn(this->value.begin(), this->value.end());
+	//return toReturn;
+
 	return GeneralUtils::UTF16ToWTF8(this->value, this->value.size());
 }
 
-template<> inline std::string LDFData<int32_t>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<float>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<double>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint32_t>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<bool>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<uint64_t>::GetValueString() { return std::to_string(this->value); }
-template<> inline std::string LDFData<LWOOBJID>::GetValueString() { return std::to_string(this->value); }
+template<> inline std::string LDFData<int32_t>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<float>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<double>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint32_t>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<bool>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<uint64_t>::GetValueString(void) { return std::to_string(this->value); }
+template<> inline std::string LDFData<LWOOBJID>::GetValueString(void) { return std::to_string(this->value); }
 
-template<> inline std::string LDFData<std::string>::GetValueString() { return this->value; }
-
-#endif  //!__LDFFORMAT__H__
+template<> inline std::string LDFData<std::string>::GetValueString(void) { return this->value; }

dCommon/NiPoint3.cpp

@@ -128,12 +128,6 @@ NiPoint3 NiPoint3::operator+(const NiPoint3& point) const {
 	return NiPoint3(this->x + point.x, this->y + point.y, this->z + point.z);
 }
 
-//! Operator for addition of vectors
-NiPoint3 NiPoint3::operator+=(const NiPoint3& point) const {
-	return NiPoint3(this->x + point.x, this->y + point.y, this->z + point.z);
-}
-
-
 //! Operator for subtraction of vectors
 NiPoint3 NiPoint3::operator-(const NiPoint3& point) const {
 	return NiPoint3(this->x - point.x, this->y - point.y, this->z - point.z);

dCommon/NiPoint3.h

@@ -135,9 +135,6 @@ public:
 	//! Operator for addition of vectors
 	NiPoint3 operator+(const NiPoint3& point) const;
 
-	//! Operator for addition of vectors
-	NiPoint3 operator+=(const NiPoint3& point) const;
-
 	//! Operator for subtraction of vectors
 	NiPoint3 operator-(const NiPoint3& point) const;
 

dCommon/dClient/AssetManager.cpp

@@ -47,10 +47,6 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 			this->LoadPackIndex();
 			break;
 		}
-		case eAssetBundleType::None:
-		case eAssetBundleType::Unpacked: {
-			break;
-		}
 	}
 }
 
@@ -115,7 +111,7 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 		*len = ftell(file);
 		*data = (char*)malloc(*len);
 		fseek(file, 0, SEEK_SET);
-		int32_t readInData = fread(*data, sizeof(uint8_t), *len, file);
+		fread(*data, sizeof(uint8_t), *len, file);
 		fclose(file);
 
 		return true;

dCommon/dClient/Pack.cpp

@@ -77,7 +77,7 @@ bool Pack::ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) {
 
 	if (!isCompressed) {
 		char* tempData = (char*)malloc(pkRecord.m_UncompressedSize);
-		int32_t readInData = fread(tempData, sizeof(uint8_t), pkRecord.m_UncompressedSize, file);
+		fread(tempData, sizeof(uint8_t), pkRecord.m_UncompressedSize, file);
 
 		*data = tempData;
 		*len = pkRecord.m_UncompressedSize;
@@ -97,11 +97,11 @@ bool Pack::ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) {
 		if (currentReadPos >= pkRecord.m_UncompressedSize) break;
 
 		uint32_t size;
-		int32_t readInData = fread(&size, sizeof(uint32_t), 1, file);
+		fread(&size, sizeof(uint32_t), 1, file);
 		pos += 4; // Move pointer position 4 to the right
 
 		char* chunk = (char*)malloc(size);
-		int32_t readInData2 = fread(chunk, sizeof(int8_t), size, file);
+		fread(chunk, sizeof(int8_t), size, file);
 		pos += size; // Move pointer position the amount of bytes read to the right
 
 		int32_t err;

dCommon/dEnums/AddFriendResponseCode.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#ifndef __EADDFRIENDRESPONSECODE__H__
-#define __EADDFRIENDRESPONSECODE__H__
+#ifndef __ADDFRIENDRESPONSECODE__H__
+#define __ADDFRIENDRESPONSECODE__H__
 
 #include <cstdint>
 
-enum class eAddFriendResponseCode : uint8_t {
+enum class AddFriendResponseCode : uint8_t {
 	ACCEPTED = 0,
 	REJECTED,
 	BUSY,

dCommon/dEnums/AddFriendResponseType.h

@@ -1,11 +1,11 @@
 #pragma once
 
-#ifndef __EADDFRIENDRESPONSETYPE__H__
-#define __EADDFRIENDRESPONSETYPE__H__
+#ifndef __ADDFRIENDRESPONSETYPE__H__
+#define __ADDFRIENDRESPONSETYPE__H__
 
 #include <cstdint>
 
-enum class eAddFriendResponseType : uint8_t {
+enum class AddFriendResponseType : uint8_t {
 	ACCEPTED = 0,
 	ALREADYFRIEND,
 	INVALIDCHARACTER,
@@ -21,4 +21,4 @@ enum class eAddFriendResponseType : uint8_t {
 	FRIENDISFREETRIAL
 };
 
-#endif  //!__EADDFRIENDRESPONSETYPE__H__
+#endif  //!__ADDFRIENDRESPONSETYPE__H__

dCommon/dEnums/ItemSetPassiveAbilityID.h

@@ -0,0 +1,105 @@
+#pragma once
+
+/**
+2	Engineer (Rank 1) Item Set
+3	Engineer (Rank 2) Item Set
+4	Engineer (Rank 3) Item Set
+7	Knight (Rank 1) Item Set
+8	Knight (Rank 2) Item Set
+9	Knight (Rank 3) Item Set
+10	Space Ranger (Rank 1) Item Set
+11	Space Ranger (Rank 2) Item Set
+12	Space Ranger (Rank 3) Item Set
+13	Samurai (Rank 1) Item Set
+14	Samurai (Rank 2) Item Set
+15	Samurai (Rank 3) Item Set
+16	Sorcerer (Rank 1) Item Set
+17	Sorcerer (Rank 2) Item Set
+18	Sorcerer (Rank 3) Item Set
+19	Space Marauder (Rank 1) Item Set
+20	Space Marauder (Rank 2) Item Set
+21	Space Marauder (Rank 3) Item Set
+22	Shinobi (Rank 1) Item Set
+23	Shinobi (Rank 2) Item Set
+24	Shinobi (Rank 3) Item Set
+25	Inventor (Rank 1) Item Set
+26	Inventor (Rank 2) Item Set
+27	Inventor (Rank 3) Item Set
+28	Summoner (Rank 1) Item Set
+29	Summoner (Rank 2) Item Set
+30	Summoner (Rank 3) Item Set
+31	Adventurer (Rank 1) Item Set
+32	Adventurer (Rank 2) Item Set
+33	Adventurer (Rank 3) Item Set
+34	Daredevil (Rank 1) Item Set
+35	Daredevil (Rank 2) Item Set
+36	Daredevil (Rank 3) Item Set
+37	Buccaneer (Rank 1) Item Set
+38	Buccaneer (Rank 2) Item Set
+39	Buccaneer (Rank 3) Item Set
+40	Bone Suit Item Set
+41	Imagination Spinjitzu Item Set
+42	Bat Lord Item Set
+43	Mosaic Jester Item Set
+44	Explorien Bot Item Set
+45	[Unnamed] Item Set
+46	[Unnamed] Item Set
+47	[Unnamed] Item Set
+48	Earth Spinjitzu Item Set
+49	[Unnamed] Item Set
+50	Fire Spinjitzu Item Set
+51	Ice Spinjitzu Item Set
+52	Lightning Spinjitzu Item Set
+ */
+enum class ItemSetPassiveAbilityID
+{
+	EngineerRank1 = 2,
+	EngineerRank2 = 3,
+	EngineerRank3 = 4,
+	KnightRank1 = 7,
+	KnightRank2 = 8,
+	KnightRank3 = 9,
+	SpaceRangerRank1 = 10,
+	SpaceRangerRank2 = 11,
+	SpaceRangerRank3 = 12,
+	SamuraiRank1 = 13,
+	SamuraiRank2 = 14,
+	SamuraiRank3 = 15,
+	SorcererRank1 = 16,
+	SorcererRank2 = 17,
+	SorcererRank3 = 18,
+	SpaceMarauderRank1 = 19,
+	SpaceMarauderRank2 = 20,
+	SpaceMarauderRank3 = 21,
+	ShinobiRank1 = 22,
+	ShinobiRank2 = 23,
+	ShinobiRank3 = 24,
+	InventorRank1 = 25,
+	InventorRank2 = 26,
+	InventorRank3 = 27,
+	SummonerRank1 = 28,
+	SummonerRank2 = 29,
+	SummonerRank3 = 30,
+	AdventurerRank1 = 31,
+	AdventurerRank2 = 32,
+	AdventurerRank3 = 33,
+	DaredevilRank1 = 34,
+	DaredevilRank2 = 35,
+	DaredevilRank3 = 36,
+	BuccaneerRank1 = 37,
+	BuccaneerRank2 = 38,
+	BuccaneerRank3 = 39,
+	BoneSuit = 40,
+	ImaginationSpinjitzu = 41,
+	BatLord = 42,
+	MosaicJester = 43,
+	ExplorienBot = 44,
+	Unnamed1 = 45,
+	Unnamed2 = 46,
+	Unnamed3 = 47,
+	EarthSpinjitzu = 48,
+	Unnamed4 = 49,
+	FireSpinjitzu = 50,
+	IceSpinjitzu = 51,
+	LightningSpinjitzu = 52
+};

dCommon/dEnums/MissionLockState.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#ifndef MISSIONLOCKSTATE_H
+#define MISSIONLOCKSTATE_H
+
+enum class MissionLockState : int
+{
+	MISSION_LOCK_LOCKED,
+	MISSION_LOCK_NEW,
+	MISSION_LOCK_UNLOCKED,
+};
+
+#endif

dCommon/dEnums/MissionState.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#ifndef __MISSIONSTATE__H__
+#define __MISSIONSTATE__H__
+
+/**
+ * Represents the possible states a mission can be in
+ */
+enum class MissionState : int32_t {
+	/**
+	 * The mission state is unknown
+	 */
+	MISSION_STATE_UNKNOWN = -1,
+
+	/**
+	 * The mission is yielding rewards
+	 */
+	 MISSION_STATE_REWARDING = 0,
+
+	 /**
+	  * The mission can be accepted
+	  */
+	  MISSION_STATE_AVAILABLE = 1,
+
+	  /**
+	   * The mission has been accepted but not yet completed
+	   */
+	   MISSION_STATE_ACTIVE = 2,
+
+	   /**
+		* All the tasks for the mission have been completed and the entity can turn the mission in to complete it
+		*/
+		MISSION_STATE_READY_TO_COMPLETE = 4,            //!< The mission is ready to complete
+
+		/**
+		 * The mission has been completed
+		 */
+		 MISSION_STATE_COMPLETE = 8,
+
+		 /**
+		  * The mission is available again and has been completed before. Used for daily missions.
+		  */
+		  MISSION_STATE_COMPLETE_AVAILABLE = 9,
+
+		  /**
+		   * The mission is active and has been completed before. Used for daily missions.
+		   */
+		   MISSION_STATE_COMPLETE_ACTIVE = 10,
+
+		   /**
+			* The mission has been completed before and has now been completed again. Used for daily missions.
+			*/
+			MISSION_STATE_COMPLETE_READY_TO_COMPLETE = 12
+};
+
+#endif  //!__MISSIONSTATE__H__

dCommon/dEnums/MissionTaskType.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#ifndef MISSIONTASKTYPE_H
+#define MISSIONTASKTYPE_H
+
+//! An enum for mission task types
+enum class MissionTaskType : int {
+	MISSION_TASK_TYPE_UNKNOWN = -1,                     //!< The task type is unknown
+	MISSION_TASK_TYPE_SMASH = 0,                        //!< A task for smashing something
+	MISSION_TASK_TYPE_SCRIPT = 1,                       //!< A task handled by a server LUA script
+	MISSION_TASK_TYPE_ACTIVITY = 2,                     //!< A task for completing a quickbuild
+	MISSION_TASK_TYPE_ENVIRONMENT = 3,                  //!< A task for something in the environment
+	MISSION_TASK_TYPE_MISSION_INTERACTION = 4,          //!< A task for interacting with a mission
+	MISSION_TASK_TYPE_EMOTE = 5,                        //!< A task for playing an emote
+	MISSION_TASK_TYPE_FOOD = 9,                         //!< A task for eating food
+	MISSION_TASK_TYPE_SKILL = 10,                       //!< A task for performing a skill
+	MISSION_TASK_TYPE_ITEM_COLLECTION = 11,             //!< A task for collecting an item
+	MISSION_TASK_TYPE_LOCATION = 12,                    //!< A task for finding a location
+	MISSION_TASK_TYPE_MINIGAME = 14,                    //!< A task for doing something in a minigame
+	MISSION_TASK_TYPE_NON_MISSION_INTERACTION = 15,     //!< A task for interacting with a non-mission
+	MISSION_TASK_TYPE_MISSION_COMPLETE = 16,            //!< A task for completing a mission
+	MISSION_TASK_TYPE_EARN_REPUTATION = 17,             //!< A task for earning reputation
+	MISSION_TASK_TYPE_POWERUP = 21,                     //!< A task for collecting a powerup
+	MISSION_TASK_TYPE_PET_TAMING = 22,                  //!< A task for taming a pet
+	MISSION_TASK_TYPE_RACING = 23,                      //!< A task for racing
+	MISSION_TASK_TYPE_PLAYER_FLAG = 24,                 //!< A task for setting a player flag
+	MISSION_TASK_TYPE_PLACE_MODEL = 25,                //!< A task for picking up a model
+	MISSION_TASK_TYPE_VISIT_PROPERTY = 30               //!< A task for visiting a property
+};
+
+#endif

dCommon/dEnums/PermissionMap.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cstdint>
+
+/**
+ * Bitmap of permissions and restrictions for characters.
+ */
+enum class PermissionMap : uint64_t
+{
+	/**
+	 * Reserved for future use, bit 0-3.
+	 */
+
+	 /**
+	  * The character has restricted trade acccess, bit 4.
+	  */
+	RestrictedTradeAccess = 0x1 << 4,
+
+	/**
+	 * The character has restricted mail access, bit 5.
+	 */
+	 RestrictedMailAccess = 0x1 << 5,
+
+	 /**
+	  * The character has restricted chat access, bit 6.
+	  */
+	  RestrictedChatAccess = 0x1 << 6,
+
+	  //
+	  // Combined permissions
+	  //
+
+	  /**
+	   * The character is marked as 'old', restricted from trade and mail.
+	   */
+	   Old = RestrictedTradeAccess | RestrictedMailAccess,
+
+	   /**
+		* The character is soft banned, restricted from trade, mail, and chat.
+		*/
+		SoftBanned = RestrictedTradeAccess | RestrictedMailAccess | RestrictedChatAccess,
+};

dCommon/dEnums/RacingTaskParam.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <cstdint>
+
+enum class RacingTaskParam : int32_t {
+	RACING_TASK_PARAM_FINISH_WITH_PLACEMENT = 1,            //<! A task param for finishing with a specific placement.
+	RACING_TASK_PARAM_LAP_TIME = 2,                         //<! A task param for finishing with a specific lap time.
+	RACING_TASK_PARAM_TOTAL_TRACK_TIME = 3,                 //<! A task param for finishing with a specific track time.
+	RACING_TASK_PARAM_COMPLETE_ANY_RACING_TASK = 4,         //<! A task param for completing a racing task.
+	RACING_TASK_PARAM_COMPLETE_TRACK_TASKS = 5,             //<! A task param for completing a task for a specific track.
+	RACING_TASK_PARAM_MODULAR_BUILDING = 6,                 //<! A task param for modular building with racing builds.
+	RACING_TASK_PARAM_SAFE_DRIVER = 10,                     //<! A task param for completing a race without smashing.
+	RACING_TASK_PARAM_SMASHABLES = 11,                      //<! A task param for smashing entities during a race.
+	RACING_TASK_PARAM_COLLECT_IMAGINATION = 12,             //<! A task param for collecting imagination during a race.
+	RACING_TASK_PARAM_COMPETED_IN_RACE = 13,                //<! A task param for competing in a race.
+	RACING_TASK_PARAM_WIN_RACE_IN_WORLD = 14,               //<! A task param for winning a race in a specific world.
+	RACING_TASK_PARAM_FIRST_PLACE_MULTIPLE_TRACKS = 15,     //<! A task param for finishing in first place on multiple tracks.
+	RACING_TASK_PARAM_LAST_PLACE_FINISH = 16,               //<! A task param for finishing in last place.
+	RACING_TASK_PARAM_SMASH_SPECIFIC_SMASHABLE = 17         //<! A task param for smashing dragon eggs during a race.
+};

dCommon/dEnums/dCommonVars.h

@@ -7,11 +7,11 @@
 #include <string>
 #include <set>
 #include "BitStream.h"
-#include "eConnectionType.h"
-#include "eClientMessageType.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
 
+typedef int RESTICKET;
+
 // These are the same define, but they mean two different things in different contexts
 // so a different define to distinguish what calculation is happening will help clarity.
 #define FRAMES_TO_MS(x) 1000 / x
@@ -30,7 +30,7 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 
 #define CBITSTREAM RakNet::BitStream bitStream;
 #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
-#define CMSGHEADER PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+#define CMSGHEADER PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GAME_MSG);
 #define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
 #define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 
@@ -43,20 +43,33 @@ typedef uint32_t LWOCLONEID;                 //!< Used for Clone IDs
 typedef uint16_t LWOMAPID;                   //!< Used for Map IDs
 typedef uint16_t LWOINSTANCEID;              //!< Used for Instance IDs
 typedef uint32_t PROPERTYCLONELIST;          //!< Used for Property Clone IDs
-typedef uint32_t StripId;
+typedef uint32_t STRIPID;
+typedef uint32_t BEHAVIORSTATE;
+
+typedef int32_t PetTamingPiece;             //!< Pet Taming Pieces
 
 const LWOOBJID LWOOBJID_EMPTY = 0;          //!< An empty object ID
 const LOT LOT_NULL = -1;                    //!< A null LOT
 const int32_t LOOTTYPE_NONE = 0;            //!< No loot type available
 const float SECONDARY_PRIORITY = 1.0f;      //!< Secondary Priority
+const uint32_t INVENTORY_INVALID = -1;      //!< Invalid Inventory
+const uint32_t INVENTORY_DEFAULT = -1;      //!< Default Inventory
+const uint32_t StatusChangeInfo = 0;        //!< Status Change Info (???)
 const uint32_t INVENTORY_MAX = 9999999;     //!< The Maximum Inventory Size
 const uint32_t LWOCLONEID_INVALID = -1;     //!< Invalid LWOCLONEID
 const uint16_t LWOINSTANCEID_INVALID = -1;  //!< Invalid LWOINSTANCEID
 const uint16_t LWOMAPID_INVALID = -1;       //!< Invalid LWOMAPID
 const uint64_t LWOZONEID_INVALID = 0;       //!< Invalid LWOZONEID
 
+typedef std::set<LWOOBJID> TSetObjID;
+
 const float PI = 3.14159f;
 
+#if defined(__unix) || defined(__APPLE__)
+//For Linux:
+typedef __int64_t __int64;
+#endif
+
 //============ STRUCTS ==============
 
 struct LWOSCENEID {
@@ -157,4 +170,480 @@ public:
 	}
 };
 
+struct Brick {
+	uint32_t designerID;
+	uint32_t materialID;
+};
+
+//This union is used by the behavior system
+union suchar {
+	unsigned char usigned;
+	char svalue;
+};
+
+//=========== DLU ENUMS ============
+
+enum eGameMasterLevel : int32_t {
+	GAME_MASTER_LEVEL_CIVILIAN = 0,             // Normal player.
+	GAME_MASTER_LEVEL_FORUM_MODERATOR = 1,      // No permissions on live servers.
+	GAME_MASTER_LEVEL_JUNIOR_MODERATOR = 2,     // Can kick/mute and pull chat logs.
+	GAME_MASTER_LEVEL_MODERATOR = 3,            // Can return lost items.
+	GAME_MASTER_LEVEL_SENIOR_MODERATOR = 4,     // Can ban.
+	GAME_MASTER_LEVEL_LEAD_MODERATOR = 5,       // Can approve properties.
+	GAME_MASTER_LEVEL_JUNIOR_DEVELOPER = 6,     // Junior developer & future content team. Civilan on live.
+	GAME_MASTER_LEVEL_INACTIVE_DEVELOPER = 7,   // Inactive developer, limited permissions.
+	GAME_MASTER_LEVEL_DEVELOPER = 8,            // Active developer, full permissions on live.
+	GAME_MASTER_LEVEL_OPERATOR = 9              // Can shutdown server for restarts & updates.
+};
+
+//=========== LU ENUMS ============
+
+//! An enum for object ID bits
+enum eObjectBits : int32_t {
+	OBJECT_BIT_PERSISTENT = 32,     //!< The 32 bit index
+	OBJECT_BIT_CLIENT = 46,         //!< The 46 bit index
+	OBJECT_BIT_SPAWNED = 58,        //!< The 58 bit index
+	OBJECT_BIT_CHARACTER = 60       //!< The 60 bit index
+};
+
+//! An enum for MatchUpdate types
+enum eMatchUpdate : int {
+	MATCH_UPDATE_PLAYER_JOINED = 0,
+	MATCH_UPDATE_PLAYER_LEFT = 1,
+	MATCH_UPDATE_TIME = 3,
+	MATCH_UPDATE_TIME_START_DELAY = 4,
+	MATCH_UPDATE_PLAYER_READY = 5,
+	MATCH_UPDATE_PLAYER_UNREADY = 6
+};
+
+//! An enum for camera cycling modes
+enum eCyclingMode : uint32_t {
+	ALLOW_CYCLE_TEAMMATES,
+	DISALLOW_CYCLING
+};
+
+enum eCinematicEvent : uint32_t {
+	STARTED,
+	WAYPOINT,
+	ENDED,
+};
+
+//! An enum for character creation responses
+enum eCreationResponse : uint8_t {
+	CREATION_RESPONSE_SUCCESS = 0,                  //!< The creation was successful
+	CREATION_RESPONSE_OBJECT_ID_UNAVAILABLE,        //!< The Object ID can't be used
+	CREATION_RESPONSE_NAME_NOT_ALLOWED,             //!< The name is not allowed
+	CREATION_RESPONSE_PREDEFINED_NAME_IN_USE,       //!< The predefined name is already in use
+	CREATION_RESPONSE_CUSTOM_NAME_IN_USE            //!< The custom name is already in use
+};
+
+//! An enum for login responses
+enum eLoginResponse : uint8_t {
+	LOGIN_RESPONSE_GENERAL_FAILED = 0,
+	LOGIN_RESPONSE_SUCCESS = 1,
+	LOGIN_RESPONSE_BANNED = 2,
+	LOGIN_RESPONSE_PERMISSIONS_NOT_HIGH_ENOUGH = 5,
+	LOGIN_RESPONSE_WRONG_PASS_OR_USER = 6,
+	LOGIN_RESPONSE_ACCOUNT_LOCKED = 7
+};
+
+//! An enum for character rename responses
+enum eRenameResponse : uint8_t {
+	RENAME_RESPONSE_SUCCESS = 0,                    //!< The renaming was successful
+	RENAME_RESPONSE_UNKNOWN_ERROR,                  //!< There was an unknown error
+	RENAME_RESPONSE_NAME_UNAVAILABLE,               //!< The name is unavailable
+	RENAME_RESPONSE_NAME_IN_USE                     //!< The name is already in use
+};
+
+//! A replica packet type
+enum eReplicaPacketType {
+	PACKET_TYPE_CONSTRUCTION,                       //!< A construction packet
+	PACKET_TYPE_SERIALIZATION,                      //!< A serialization packet
+	PACKET_TYPE_DESTRUCTION                         //!< A destruction packet
+};
+
+enum ServerDisconnectIdentifiers {
+	SERVER_DISCON_UNKNOWN_SERVER_ERROR = 0,               //!< Unknown server error
+	SERVER_DISCON_DUPLICATE_LOGIN = 4,                    //!< Used when another user with the same username is logged in (duplicate login)
+	SERVER_DISCON_SERVER_SHUTDOWN = 5,                    //!< Used when the server is shutdown
+	SERVER_DISCON_SERVER_MAP_LOAD_FAILURE = 6,            //!< Used when the server cannot load a map
+	SERVER_DISCON_INVALID_SESSION_KEY = 7,                //!< Used if the session is invalid
+	SERVER_DISCON_ACCOUNT_NOT_IN_PENDING_LIST = 8,        //!< ???
+	SERVER_DISCON_CHARACTER_NOT_FOUND = 9,                //!< Used if a character that the server has is not found (i.e, corruption with user-player data)
+	SERVER_DISCON_CHARACTER_CORRUPTED = 10,               //!< Similar to abovce
+	SERVER_DISCON_KICK = 11,                              //!< Used if the user is kicked from the server
+	SERVER_DISCON_FREE_TRIAL_EXPIRED = 12,                //!< Used if the user's free trial expired
+	SERVER_DISCON_PLAY_SCHEDULE_TIME_DONE = 13            //!< Used if the user's play time is used up
+};
+
+//! The Behavior Types for use with the AI system
+enum eCombatBehaviorTypes : uint32_t {
+	PASSIVE = 0,                    //!< The object is passive
+	AGGRESSIVE = 1,                 //!< The object is aggressive
+	PASSIVE_TURRET = 2,             //!< The object is a passive turret
+	AGGRESSIVE_TURRET = 3           //!< The object is an aggressive turret
+};
+
+//! The Combat Role Type for use with the AI system
+enum eCombatRoleType : uint32_t {
+	MELEE = 0,                      //!< Used for melee attacks
+	RANGED = 1,                     //!< Used for range attacks
+	SUPPORT = 2                     //!< Used for support
+};
+
+//! The kill types for the Die packet
+enum eKillType : uint32_t {
+	VIOLENT,
+	SILENT
+};
+
+//! The various world states used throughout the server
+enum eObjectWorldState {
+	WORLDSTATE_INWORLD,             //!< Probably used when the object is in the world
+	WORLDSTATE_ATTACHED,            //!< Probably used when the object is attached to another object
+	WORLDSTATE_INVENTORY            //!< Probably used when the object is in an inventory
+};
+
+//! The trigger stats (???)
+enum eTriggerStat {
+	INVALID_STAT,                   //!< ???
+	HEALTH,                         //!< Probably used for health
+	ARMOR,                          //!< Probably used for armor
+	IMAGINATION                     //!< Probably used for imagination
+};
+
+//! The trigger operations (???)
+enum eTriggerOperator {
+	INVALID_OPER,                   //!< ???
+	EQUAL,                          //!< ???
+	NOT_EQUAL,                      //!< ???
+	GREATER,                        //!< ???
+	GREATER_EQUAL,                  //!< ???
+	LESS,                           //!< ???
+	LESS_EQUAL                      //!< ???
+};
+
+//! The various build types
+enum eBuildType {
+	BUILD_NOWHERE,                  //!< Used if something can't be built anywhere
+	BUILD_IN_WORLD,                 //!< Used if something can be built in the world
+	BUILD_ON_PROPERTY               //!< Used if something can be build on a property
+};
+
+//! Quickbuild fail reasons
+enum eFailReason : uint32_t {
+	REASON_NOT_GIVEN,
+	REASON_OUT_OF_IMAGINATION,
+	REASON_CANCELED_EARLY,
+	REASON_BUILD_ENDED
+};
+
+//! Terminate interaction type
+enum eTerminateType : uint32_t {
+	RANGE,
+	USER,
+	FROM_INTERACTION
+};
+
+//! The combat state
+enum eCombatState {
+	IDLE,                           //!< The AI is in an idle state
+	AGGRO,                          //!< The AI is in an aggressive state
+	TETHER,                         //!< The AI is being redrawn back to tether point
+	SPAWN,                          //!< The AI is spawning
+	DEAD                            //!< The AI is dead
+};
+
+enum eControlSceme {
+	SCHEME_A,
+	SCHEME_D,
+	SCHEME_GAMEPAD,
+	SCHEME_E,
+	SCHEME_FPS,
+	SCHEME_DRIVING,
+	SCHEME_TAMING,
+	SCHEME_MODULAR_BUILD,
+	SCHEME_WEAR_A_ROBOT //== freecam?
+};
+
+enum class eStateChangeType : uint32_t {
+	PUSH,
+	POP
+};
+
+enum eNotifyType {
+	NOTIFY_TYPE_SUCCESS,
+	NOTIFY_TYPE_QUIT,
+	NOTIFY_TYPE_FAILED,
+	NOTIFY_TYPE_BEGIN,
+	NOTIFY_TYPE_READY,
+	NOTIFY_TYPE_NAMINGPET
+};
+
+enum eReplicaComponentType : int32_t {
+	COMPONENT_TYPE_CONTROLLABLE_PHYSICS = 1,			//!< The ControllablePhysics Component
+	COMPONENT_TYPE_RENDER = 2,			//!< The Render Component
+	COMPONENT_TYPE_SIMPLE_PHYSICS = 3,			//!< The SimplePhysics Component
+	COMPONENT_TYPE_CHARACTER = 4,			//!< The Character Component
+	COMPONENT_TYPE_SCRIPT = 5,			//!< The Script Component
+	COMPONENT_TYPE_BOUNCER = 6,			//!< The Bouncer Component
+	COMPONENT_TYPE_BUFF = 7,			//!< The Buff Component
+	COMPONENT_TYPE_SKILL = 9,			//!< The Skill Component
+	COMPONENT_TYPE_ITEM = 11,			//!< The Item Component
+	COMPONENT_TYPE_VENDOR = 16,			//!< The Vendor Component
+	COMPONENT_TYPE_INVENTORY = 17,			//!< The Inventory Component
+	COMPONENT_TYPE_SHOOTING_GALLERY = 19,			//!< The Shooting Gallery Component
+	COMPONENT_TYPE_RIGID_BODY_PHANTOM_PHYSICS = 20,			//!< The RigidBodyPhantomPhysics Component
+	COMPONENT_TYPE_COLLECTIBLE = 23,			//!< The Collectible Component
+	COMPONENT_TYPE_MOVING_PLATFORM = 25,			//!< The MovingPlatform Component
+	COMPONENT_TYPE_PET = 26,			//!< The Pet Component
+	COMPONENT_TYPE_VEHICLE_PHYSICS = 30,			//!< The VehiclePhysics Component
+	COMPONENT_TYPE_MOVEMENT_AI = 31,			//!< The MovementAI Component
+	COMPONENT_TYPE_PROPERTY = 36,			//!< The Property Component
+	COMPONENT_TYPE_SCRIPTED_ACTIVITY = 39,			//!< The ScriptedActivity Component
+	COMPONENT_TYPE_PHANTOM_PHYSICS = 40,			//!< The PhantomPhysics Component
+	COMPONENT_TYPE_MODEL = 42,			//!< The Model Component
+	COMPONENT_TYPE_PROPERTY_ENTRANCE = 43,			//!< The PhantomPhysics Component
+	COMPONENT_TYPE_PROPERTY_MANAGEMENT = 45,			//!< The PropertyManagement Component
+	COMPONENT_TYPE_REBUILD = 48,			//!< The Rebuild Component
+	COMPONENT_TYPE_SWITCH = 49,			//!< The Switch Component
+	COMPONENT_TYPE_ZONE_CONTROL = 50,			//!< The ZoneControl Component
+	COMPONENT_TYPE_PACKAGE = 53,			//!< The Package Component
+	COMPONENT_TYPE_PLAYER_FLAG = 58,			//!< The PlayerFlag Component
+	COMPONENT_TYPE_BASE_COMBAT_AI = 60,			//!< The BaseCombatAI Component
+	COMPONENT_TYPE_MODULE_ASSEMBLY = 61,			//!< The ModuleAssembly Component
+	COMPONENT_TYPE_PROPERTY_VENDOR = 65,			//!< The PropertyVendor Component
+	COMPONENT_TYPE_ROCKET_LAUNCH = 67,			//!< The RocketLaunch Component
+	COMPONENT_TYPE_RACING_CONTROL = 71,			//!< The RacingControl Component
+	COMPONENT_TYPE_MISSION_OFFER = 73,			//!< The MissionOffer Component
+	COMPONENT_TYPE_EXHIBIT = 75,			//!< The Exhibit Component
+	COMPONENT_TYPE_RACING_STATS = 74,			//!< The Racing Stats Component
+	COMPONENT_TYPE_SOUND_TRIGGER = 77,			//!< The Sound Trigger Component
+	COMPONENT_TYPE_PROXIMITY_MONITOR = 78,			//!< The Proximity Monitor Component
+	COMPONENT_TYPE_MISSION = 84,			//!< The Mission Component
+	COMPONENT_TYPE_ROCKET_LAUNCH_LUP = 97,			//!< The LUP Launchpad Componen
+	COMPONENT_TYPE_RAIL_ACTIVATOR = 104,			//!< The Rail Activator Component
+	COMPONENT_TYPE_PLAYER_FORCED_MOVEMENT = 106,			//!< The Player Forced Movement Component
+	COMPONENT_TYPE_POSSESSABLE = 108,			//!< The Possessable Component
+	COMPONENT_TYPE_LEVEL_PROGRESSION = 109,			//!< The Level Progression Component
+	COMPONENT_TYPE_POSSESSOR = 110,			//!< The Possessor Component
+	COMPONENT_TYPE_BUILD_BORDER = 114,			//!< The Build Border Component
+	COMPONENT_TYPE_DESTROYABLE = 1000,			//!< The Destroyable Component
+};
+
+enum class UseItemResponse : uint32_t {
+	NoImaginationForPet = 1,
+	FailedPrecondition,
+	MountsNotAllowed
+};
+
+enum eRebuildState : uint32_t {
+	REBUILD_OPEN,
+	REBUILD_COMPLETED = 2,
+	REBUILD_RESETTING = 4,
+	REBUILD_BUILDING,
+	REBUILD_INCOMPLETE
+};
+
+/**
+ * The loot source's type.
+ */
+enum eLootSourceType : int32_t {
+	LOOT_SOURCE_NONE = 0,
+	LOOT_SOURCE_CHEST,
+	LOOT_SOURCE_MISSION,
+	LOOT_SOURCE_MAIL,
+	LOOT_SOURCE_CURRENCY,
+	LOOT_SOURCE_ACHIEVEMENT,
+	LOOT_SOURCE_TRADE,
+	LOOT_SOURCE_QUICKBUILD,
+	LOOT_SOURCE_DELETION,
+	LOOT_SOURCE_VENDOR,
+	LOOT_SOURCE_ACTIVITY,
+	LOOT_SOURCE_PICKUP,
+	LOOT_SOURCE_BRICK,
+	LOOT_SOURCE_PROPERTY,
+	LOOT_SOURCE_MODERATION,
+	LOOT_SOURCE_EXHIBIT,
+	LOOT_SOURCE_INVENTORY,
+	LOOT_SOURCE_CLAIMCODE,
+	LOOT_SOURCE_CONSUMPTION,
+	LOOT_SOURCE_CRAFTING,
+	LOOT_SOURCE_LEVEL_REWARD,
+	LOOT_SOURCE_RELOCATE
+};
+
+enum eGameActivities : uint32_t {
+	ACTIVITY_NONE,
+	ACTIVITY_QUICKBUILDING,
+	ACTIVITY_SHOOTING_GALLERY,
+	ACTIVITY_RACING,
+	ACTIVITY_PINBALL,
+	ACTIVITY_PET_TAMING
+};
+
+enum ePlayerFlags {
+	BTARR_TESTING = 0,
+	PLAYER_HAS_ENTERED_PET_RANCH = 1,
+	MINIMAP_UNLOCKED = 2,
+	ACTIVITY_REBUILDING_FAIL_TIME = 3,
+	ACTIVITY_REBUILDING_FAIL_RANGE = 4,
+	ACTIVITY_SHOOTING_GALLERY_HELP = 5,
+	HELP_WALKING_CONTROLS = 6,
+	FIRST_SMASHABLE = 7,
+	FIRST_IMAGINATION_PICKUP = 8,
+	FIRST_DAMAGE = 9,
+	FIRST_ITEM = 10,
+	FIRST_BRICK = 11,
+	FIRST_CONSUMABLE = 12,
+	FIRST_EQUIPPABLE = 13,
+	CHAT_HELP = 14,
+	FIRST_PET_TAMING_MINIGAME = 15,
+	FIRST_PET_ON_SWITCH = 16,
+	FIRST_PET_JUMPED_ON_SWITCH = 17,
+	FIRST_PET_FOUND_TREASURE = 18,
+	FIRST_PET_DUG_TREASURE = 19,
+	FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
+	FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
+	FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
+	FIRST_EMOTE_UNLOCKED = 23,
+	GF_PIRATE_REP = 24,
+	AG_BOB_CINEMATIC_EVENT = 25,
+	HELP_JUMPING_CONTROLS = 26,
+	HELP_DOUBLE_JUMP_CONTROLS = 27,
+	HELP_CAMERA_CONTROLS = 28,
+	HELP_ROTATE_CONTROLS = 29,
+	HELP_SMASH = 30,
+	MONUMENT_INTRO_MUSIC_PLAYED = 31,
+	BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
+	AG_FINISH_LINE_BUILT = 33,
+	AG_BOSS_AREA_FOUND = 34,
+	AG_LANDED_IN_BATTLEFIELD = 35,
+	GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
+	MODULAR_BUILD_STARTED = 37,
+	MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
+	THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
+	BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
+	HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
+	MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
+	FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
+	ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
+	JOINED_A_FACTION = 45,
+	VENTURE_FACTION = 46,
+	ASSEMBLY_FACTION = 47,
+	PARADOX_FACTION = 48,
+	SENTINEL_FACTION = 49,
+	LUP_WORLD_ACCESS = 50,
+	AG_FIRST_FLAG_COLLECTED = 51,
+	TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
+	MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
+	MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
+	AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
+	GF_PET_DIG_FLAG_1 = 56,
+	GF_PET_DIG_FLAG_2 = 57,
+	GF_PET_DIG_FLAG_3 = 58,
+	SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
+	GF_PLAYER_FALL_DEATH = 60,
+	GF_PLAYER_CAN_GET_FLAG_1 = 61,
+	GF_PLAYER_CAN_GET_FLAG_2 = 62,
+	GF_PLAYER_CAN_GET_FLAG_3 = 63,
+	ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
+	AG_FIRST_COMBAT_COMPLETE = 65,
+	AG_COMPLETE_BOB_MISSION = 66,
+	IS_NEWS_SCREEN_VISIBLE = 114,
+	NJ_GARMADON_CINEMATIC_SEEN = 125,
+	ELEPHANT_PET_3050 = 801,
+	CAT_PET_3054 = 802,
+	TRICERATOPS_PET_3195 = 803,
+	TERRIER_PET_3254 = 804,
+	SKUNK_PET_3261 = 805,
+	LION_PET_3520 = 806,
+	BUNNY_PET_3672 = 807,
+	CROCODILE_PET_3994 = 808,
+	DOBERMAN_PET_5635 = 809,
+	BUFFALO_PET_5636 = 810,
+	ROBOT_DOG_PET_5637 = 811,
+	EUROPEAN_DRAGON_PET_5639 = 812,
+	TORTOISE_PET_5640 = 813,
+	ASIAN_DRAGON_PET_5641 = 814,
+	MANTIS_PET_5642 = 815,
+	PANDA_PET_5643 = 816,
+	WARTHOG_PET_6720 = 817,
+	GOAT_PET_7638 = 818,
+	CRAB_PET_7694 = 819,
+	AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
+	AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
+	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
+	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
+	AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
+	AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
+	AG_BATTLE_BINOC_AT_PARADOX = 1102,
+	AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
+	AG_BATTLE_BINOC_AT_BECK = 1104,
+	AG_MONUMENT_BINOC_INTRO = 1105,
+	AG_MONUMENT_BINOC_OUTRO = 1106,
+	AG_LAUNCH_BINOC_INTRO = 1107,
+	AG_LAUNCH_BINOC_BISON = 1108,
+	AG_LAUNCH_BINOC_SHARK = 1109,
+	NS_BINOC_CONCERT_TRANSITION = 1201,
+	NS_BINOC_RACE_PLACE_TRANSITION = 1202,
+	NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
+	NS_BINOC_GF_LAUNCH = 1204,
+	NS_BINOC_FV_LAUNCH = 1205,
+	NS_BINOC_BRICK_ANNEX_WATER = 1206,
+	NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
+	NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
+	NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
+	NS_BINOC_TBA = 1210,
+	NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
+	NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
+	NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
+	NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
+	NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
+	NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
+	NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
+	NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
+	NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
+	NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
+	PR_BINOC_AT_LAUNCH_PAD = 1251,
+	PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
+	PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
+	PR_BINOC_ON_BY_CROWS_NEST = 1254,
+	PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
+	PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
+	PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
+	PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
+	PR_PET_DIG_BY_LAUNCH_PAD = 1265,
+	PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
+	GF_BINOC_ON_LANDING_PAD = 1301,
+	GF_BINOC_AT_RAVINE_START = 1302,
+	GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
+	GF_BINOC_AT_TURTLE_AREA = 1304,
+	GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
+	GF_BINOC_IN_ELEPHANTS_AREA = 1306,
+	GF_BINOC_IN_RACING_AREA = 1307,
+	GF_BINOC_IN_CROC_AREA = 1308,
+	GF_BINOC_IN_JAIL_AREA = 1309,
+	GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
+	NT_PLINTH_REBUILD = 1919,
+	NT_FACTION_SPY_DUKE = 1974,
+	NT_FACTION_SPY_OVERBUILD = 1976,
+	NT_FACTION_SPY_HAEL = 1977,
+	NJ_EARTH_SPINJITZU = 2030,
+	NJ_LIGHTNING_SPINJITZU = 2031,
+	NJ_ICE_SPINJITZU = 2032,
+	NJ_FIRE_SPINJITZU = 2033,
+	NJ_WU_SHOW_DAILY_CHEST = 2099
+};
+
+//======== FUNC ===========
+
+template<typename T>
+inline T const& clamp(const T& val, const T& low, const T& high) {
+	if (val < low) return low;
+	else if (val > high) return high;
+
+	return val;
+}
+
 #endif  //!__DCOMMONVARS__H__

dCommon/dEnums/dMessageIdentifiers.h

@@ -0,0 +1,559 @@
+#pragma once
+#include "MessageIdentifiers.h"
+
+enum CONNECTION_TYPE {
+	SERVER = 0,         //!< Means it is used throughout all servers
+	AUTH,               //!< Means it is sent from the client authentication
+	CHAT,               //!< Means it is sent from and to the chat server
+	CHAT_INTERNAL,      //!< Unused - We can potentially use this in the future for various things
+	WORLD,              //!< Means it is sent from the client world
+	CLIENT,             //!< Means it is sent to the client from the world server
+	MASTER              //!< Means it is sent to and from the master server
+};
+
+//! The Internal Server Packet Identifiers
+enum SERVER {
+	MSG_SERVER_VERSION_CONFIRM = 0,     /*!< Sent during a handshake to confirm the server/client version */
+	MSG_SERVER_DISCONNECT_NOTIFY,       /*!< Sent when a user disconnected */
+	MSG_SERVER_GENERAL_NOTIFY           /*!< A general notification */
+};
+
+//! The Internal Authentication Packet Identifiers
+enum AUTH {
+	MSG_AUTH_LOGIN_REQUEST = 0,             /*!< Sent from the client when a user logs in */
+	MSG_AUTH_LOGOUT_REQUEST,                /*!< Sent from the client when a user logs out */
+	MSG_AUTH_CREATE_NEW_ACCOUNT_REQUEST,    /*!< Sent from the client when a user creates a new account */
+	MSG_AUTH_LEGOINTERFACE_AUTH_RESPONSE,   /*!< Unknown */
+	MSG_AUTH_SESSIONKEY_RECEIVED_CONFIRM,   /*!< Sent when the server recieved the session key (?) */
+	MSG_AUTH_RUNTIME_CONFIG                 /*!< Unknown */
+};
+
+//! The Internal Chat Packet Identifiers
+enum CHAT {
+	MSG_CHAT_LOGIN_SESSION_NOTIFY = 0,      /*!< When a user logs in */
+	MSG_CHAT_GENERAL_CHAT_MESSAGE,          /*!< Used for global chat messages */
+	MSG_CHAT_PRIVATE_CHAT_MESSAGE,          /*!< Used for private chat messages */
+	MSG_CHAT_USER_CHANNEL_CHAT_MESSAGE,     /*!< Unknown */
+	MSG_CHAT_WORLD_DISCONNECT_REQUEST,      /*!< Unknown */
+	MSG_CHAT_WORLD_PROXIMITY_RESPONSE,      /*!< Unknown */
+	MSG_CHAT_WORLD_PARCEL_RESPONSE,         /*!< Unknown */
+	MSG_CHAT_ADD_FRIEND_REQUEST,            /*!< When the client requests to add a friend */
+	MSG_CHAT_ADD_FRIEND_RESPONSE,           /*!< Sent from the server when the client adds a friend */
+	MSG_CHAT_REMOVE_FRIEND,                 /*!< When the client removes a friend */
+	MSG_CHAT_GET_FRIENDS_LIST,              /*!< Sent when the client requests a user's friends list */
+	MSG_CHAT_ADD_IGNORE,                    /*!< Sent when the client adds a friend to the "ignore" list */
+	MSG_CHAT_REMOVE_IGNORE,                 /*!< Sent when the client removes a friend from the "ignore" list */
+	MSG_CHAT_GET_IGNORE_LIST,               /*!< Sent when the client requests a user's ignored list */
+	MSG_CHAT_TEAM_MISSED_INVITE_CHECK,      /*!< Unknown (Something with an unresponded-to friend request probably) */
+	MSG_CHAT_TEAM_INVITE,                   /*!< When the client invites a user to a team */
+	MSG_CHAT_TEAM_INVITE_RESPONSE,          /*!< Sent from the server when the client invites someone to the team */
+	MSG_CHAT_TEAM_KICK,                     /*!< Sent when the client kicks a member from a team */
+	MSG_CHAT_TEAM_LEAVE,                    /*!< Sent when the client leaves a team */
+	MSG_CHAT_TEAM_SET_LOOT,                 /*!< Unknown (Something to do with team loot) */
+	MSG_CHAT_TEAM_SET_LEADER,               /*!< Unknown (Probably sets the team leader or something) */
+	MSG_CHAT_TEAM_GET_STATUS,               /*!< Check to see if we are in a team or not, sent on world join */
+	MSG_CHAT_GUILD_CREATE,                  /*!< Guild Creation */
+	MSG_CHAT_GUILD_INVITE,                  /*!< Guild Invitation */
+	MSG_CHAT_GUILD_INVITE_RESPONSE,         /*!< Guild Invite Response */
+	MSG_CHAT_GUILD_LEAVE,                   /*!< Guild Leave */
+	MSG_CHAT_GUILD_KICK,                    /*!< Guild Kick */
+	MSG_CHAT_GUILD_GET_STATUS,              /*!< Guild Get Status */
+	MSG_CHAT_GUILD_GET_ALL,                 /*!< Guild Get All */
+	MSG_CHAT_SHOW_ALL,
+	MSG_CHAT_BLUEPRINT_MODERATED,
+	MSG_CHAT_BLUEPRINT_MODEL_READY,
+	MSG_CHAT_PROPERTY_READY_FOR_APPROVAL,
+	MSG_CHAT_PROPERTY_MODERATION_CHANGED,
+	MSG_CHAT_PROPERTY_BUILDMODE_CHANGED,
+	MSG_CHAT_PROPERTY_BUILDMODE_CHANGED_REPORT,
+	MSG_CHAT_MAIL,
+	MSG_CHAT_WORLD_INSTANCE_LOCATION_REQUEST,
+	MSG_CHAT_REPUTATION_UPDATE,
+	MSG_CHAT_SEND_CANNED_TEXT,
+	MSG_CHAT_GMLEVEL_UPDATE,
+	MSG_CHAT_CHARACTER_NAME_CHANGE_REQUEST,
+	MSG_CHAT_CSR_REQUEST,
+	MSG_CHAT_CSR_REPLY,
+	MSG_CHAT_GM_KICK,
+	MSG_CHAT_GM_ANNOUNCE,
+	MSG_CHAT_GM_MUTE,
+	MSG_CHAT_ACTIVITY_UPDATE,
+	MSG_CHAT_WORLD_ROUTE_PACKET,
+	MSG_CHAT_GET_ZONE_POPULATIONS,
+	MSG_CHAT_REQUEST_MINIMUM_CHAT_MODE,
+	MSG_CHAT_REQUEST_MINIMUM_CHAT_MODE_PRIVATE,
+	MSG_CHAT_MATCH_REQUEST,
+	MSG_CHAT_UGCMANIFEST_REPORT_MISSING_FILE,
+	MSG_CHAT_UGCMANIFEST_REPORT_DONE_FILE,
+	MSG_CHAT_UGCMANIFEST_REPORT_DONE_BLUEPRINT,
+	MSG_CHAT_UGCC_REQUEST,
+	MSG_CHAT_WHO,
+	MSG_CHAT_WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE,
+	MSG_CHAT_ACHIEVEMENT_NOTIFY,
+	MSG_CHAT_GM_CLOSE_PRIVATE_CHAT_WINDOW,
+	MSG_CHAT_UNEXPECTED_DISCONNECT,
+	MSG_CHAT_PLAYER_READY,
+	MSG_CHAT_GET_DONATION_TOTAL,
+	MSG_CHAT_UPDATE_DONATION,
+	MSG_CHAT_PRG_CSR_COMMAND,
+	MSG_CHAT_HEARTBEAT_REQUEST_FROM_WORLD,
+	MSG_CHAT_UPDATE_FREE_TRIAL_STATUS
+};
+
+//! Used for packets related to chatting
+enum CHAT_INTERNAL {
+	MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION = 0,
+	MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION,
+	MSG_CHAT_INTERNAL_ADD_FRIEND,
+	MSG_CHAT_INTERNAL_ADD_BEST_FRIEND,
+	MSG_CHAT_INTERNAL_ADD_TO_TEAM,
+	MSG_CHAT_INTERNAL_ADD_BLOCK,
+	MSG_CHAT_INTERNAL_REMOVE_FRIEND,
+	MSG_CHAT_INTERNAL_REMOVE_BLOCK,
+	MSG_CHAT_INTERNAL_REMOVE_FROM_TEAM,
+	MSG_CHAT_INTERNAL_DELETE_TEAM,
+	MSG_CHAT_INTERNAL_REPORT,
+	MSG_CHAT_INTERNAL_PRIVATE_CHAT,
+	MSG_CHAT_INTERNAL_PRIVATE_CHAT_RESPONSE,
+	MSG_CHAT_INTERNAL_ANNOUNCEMENT,
+	MSG_CHAT_INTERNAL_MAIL_COUNT_UPDATE,
+	MSG_CHAT_INTERNAL_MAIL_SEND_NOTIFY,
+	MSG_CHAT_INTERNAL_REQUEST_USER_LIST,
+	MSG_CHAT_INTERNAL_FRIEND_LIST,
+	MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER,
+	MSG_CHAT_INTERNAL_TEAM_UPDATE,
+	MSG_CHAT_INTERNAL_MUTE_UPDATE,
+	MSG_CHAT_INTERNAL_CREATE_TEAM,
+};
+
+//! Used for packets send to the world
+enum WORLD {
+	MSG_WORLD_CLIENT_VALIDATION = 1,  // 				Session info
+	MSG_WORLD_CLIENT_CHARACTER_LIST_REQUEST,
+	MSG_WORLD_CLIENT_CHARACTER_CREATE_REQUEST,
+	MSG_WORLD_CLIENT_LOGIN_REQUEST,  // 			Character selected
+	MSG_WORLD_CLIENT_GAME_MSG,
+	MSG_WORLD_CLIENT_CHARACTER_DELETE_REQUEST,
+	MSG_WORLD_CLIENT_CHARACTER_RENAME_REQUEST,
+	MSG_WORLD_CLIENT_HAPPY_FLOWER_MODE_NOTIFY,
+	MSG_WORLD_CLIENT_SLASH_RELOAD_MAP,  // 			Reload map cmp
+	MSG_WORLD_CLIENT_SLASH_PUSH_MAP_REQUEST,  // 	Push map req cmd
+	MSG_WORLD_CLIENT_SLASH_PUSH_MAP,  // 			Push map cmd
+	MSG_WORLD_CLIENT_SLASH_PULL_MAP,  // 			Pull map cmd
+	MSG_WORLD_CLIENT_LOCK_MAP_REQUEST,
+	MSG_WORLD_CLIENT_GENERAL_CHAT_MESSAGE,  // 		General chat message
+	MSG_WORLD_CLIENT_HTTP_MONITOR_INFO_REQUEST,
+	MSG_WORLD_CLIENT_SLASH_DEBUG_SCRIPTS,  // 		Debug scripts cmd
+	MSG_WORLD_CLIENT_MODELS_CLEAR,
+	MSG_WORLD_CLIENT_EXHIBIT_INSERT_MODEL,
+	MSG_WORLD_CLIENT_LEVEL_LOAD_COMPLETE,  // 		Character data request
+	MSG_WORLD_CLIENT_TMP_GUILD_CREATE,
+	MSG_WORLD_CLIENT_ROUTE_PACKET,  // 				Social?
+	MSG_WORLD_CLIENT_POSITION_UPDATE,
+	MSG_WORLD_CLIENT_MAIL,
+	MSG_WORLD_CLIENT_WORD_CHECK, // 				Whitelist word check
+	MSG_WORLD_CLIENT_STRING_CHECK,  // 				Whitelist string check
+	MSG_WORLD_CLIENT_GET_PLAYERS_IN_ZONE,
+	MSG_WORLD_CLIENT_REQUEST_UGC_MANIFEST_INFO,
+	MSG_WORLD_CLIENT_BLUEPRINT_GET_ALL_DATA_REQUEST,
+	MSG_WORLD_CLIENT_CANCEL_MAP_QUEUE,
+	MSG_WORLD_CLIENT_HANDLE_FUNNESS,
+	MSG_WORLD_CLIENT_FAKE_PRG_CSR_MESSAGE,
+	MSG_WORLD_CLIENT_REQUEST_FREE_TRIAL_REFRESH,
+	MSG_WORLD_CLIENT_GM_SET_FREE_TRIAL_STATUS
+};
+
+//! An enum for packets sent to the client
+enum CLIENT {
+	MSG_CLIENT_LOGIN_RESPONSE = 0,
+	MSG_CLIENT_LOGOUT_RESPONSE,
+	MSG_CLIENT_LOAD_STATIC_ZONE,
+	MSG_CLIENT_CREATE_OBJECT,
+	MSG_CLIENT_CREATE_CHARACTER,
+	MSG_CLIENT_CREATE_CHARACTER_EXTENDED,
+	MSG_CLIENT_CHARACTER_LIST_RESPONSE,
+	MSG_CLIENT_CHARACTER_CREATE_RESPONSE,
+	MSG_CLIENT_CHARACTER_RENAME_RESPONSE,
+	MSG_CLIENT_CHAT_CONNECT_RESPONSE,
+	MSG_CLIENT_AUTH_ACCOUNT_CREATE_RESPONSE,
+	MSG_CLIENT_DELETE_CHARACTER_RESPONSE,
+	MSG_CLIENT_GAME_MSG,
+	MSG_CLIENT_CONNECT_CHAT,
+	MSG_CLIENT_TRANSFER_TO_WORLD,
+	MSG_CLIENT_IMPENDING_RELOAD_NOTIFY,
+	MSG_CLIENT_MAKE_GM_RESPONSE,
+	MSG_CLIENT_HTTP_MONITOR_INFO_RESPONSE,
+	MSG_CLIENT_SLASH_PUSH_MAP_RESPONSE,
+	MSG_CLIENT_SLASH_PULL_MAP_RESPONSE,
+	MSG_CLIENT_SLASH_LOCK_MAP_RESPONSE,
+	MSG_CLIENT_BLUEPRINT_SAVE_RESPONSE,
+	MSG_CLIENT_BLUEPRINT_LUP_SAVE_RESPONSE,
+	MSG_CLIENT_BLUEPRINT_LOAD_RESPONSE_ITEMID,
+	MSG_CLIENT_BLUEPRINT_GET_ALL_DATA_RESPONSE,
+	MSG_CLIENT_MODEL_INSTANTIATE_RESPONSE,
+	MSG_CLIENT_DEBUG_OUTPUT,
+	MSG_CLIENT_ADD_FRIEND_REQUEST,
+	MSG_CLIENT_ADD_FRIEND_RESPONSE,
+	MSG_CLIENT_REMOVE_FRIEND_RESPONSE,
+	MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE,
+	MSG_CLIENT_UPDATE_FRIEND_NOTIFY,
+	MSG_CLIENT_ADD_IGNORE_RESPONSE,
+	MSG_CLIENT_REMOVE_IGNORE_RESPONSE,
+	MSG_CLIENT_GET_IGNORE_LIST_RESPONSE,
+	MSG_CLIENT_TEAM_INVITE,
+	MSG_CLIENT_TEAM_INVITE_INITIAL_RESPONSE,
+	MSG_CLIENT_GUILD_CREATE_RESPONSE,
+	MSG_CLIENT_GUILD_GET_STATUS_RESPONSE,
+	MSG_CLIENT_GUILD_INVITE,
+	MSG_CLIENT_GUILD_INVITE_INITIAL_RESPONSE,
+	MSG_CLIENT_GUILD_INVITE_FINAL_RESPONSE,
+	MSG_CLIENT_GUILD_INVITE_CONFIRM,
+	MSG_CLIENT_GUILD_ADD_PLAYER,
+	MSG_CLIENT_GUILD_REMOVE_PLAYER,
+	MSG_CLIENT_GUILD_LOGIN_LOGOUT,
+	MSG_CLIENT_GUILD_RANK_CHANGE,
+	MSG_CLIENT_GUILD_DATA,
+	MSG_CLIENT_GUILD_STATUS,
+	MSG_CLIENT_MAIL,
+	MSG_CLIENT_DB_PROXY_RESULT,
+	MSG_CLIENT_SHOW_ALL_RESPONSE,
+	MSG_CLIENT_WHO_RESPONSE,
+	MSG_CLIENT_SEND_CANNED_TEXT,
+	MSG_CLIENT_UPDATE_CHARACTER_NAME,
+	MSG_CLIENT_SET_NETWORK_SIMULATOR,
+	MSG_CLIENT_INVALID_CHAT_MESSAGE,
+	MSG_CLIENT_MINIMUM_CHAT_MODE_RESPONSE,
+	MSG_CLIENT_MINIMUM_CHAT_MODE_RESPONSE_PRIVATE,
+	MSG_CLIENT_CHAT_MODERATION_STRING,
+	MSG_CLIENT_UGC_MANIFEST_RESPONSE,
+	MSG_CLIENT_IN_LOGIN_QUEUE,
+	MSG_CLIENT_SERVER_STATES,
+	MSG_CLIENT_GM_CLOSE_TARGET_CHAT_WINDOW,
+	MSG_CLIENT_GENERAL_TEXT_FOR_LOCALIZATION,
+	MSG_CLIENT_UPDATE_FREE_TRIAL_STATUS,
+	MSG_CLIENT_UGC_DOWNLOAD_FAILED = 120
+};
+
+//! Used for packets sent to the master server
+enum MASTER {
+	MSG_MASTER_REQUEST_PERSISTENT_ID = 1,
+	MSG_MASTER_REQUEST_PERSISTENT_ID_RESPONSE,
+	MSG_MASTER_REQUEST_ZONE_TRANSFER,
+	MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE,
+	MSG_MASTER_SERVER_INFO,
+	MSG_MASTER_REQUEST_SESSION_KEY,
+	MSG_MASTER_SET_SESSION_KEY,
+	MSG_MASTER_SESSION_KEY_RESPONSE,
+	MSG_MASTER_PLAYER_ADDED,
+	MSG_MASTER_PLAYER_REMOVED,
+
+	MSG_MASTER_CREATE_PRIVATE_ZONE,
+	MSG_MASTER_REQUEST_PRIVATE_ZONE,
+
+	MSG_MASTER_WORLD_READY,
+	MSG_MASTER_PREP_ZONE,
+
+	MSG_MASTER_SHUTDOWN,
+	MSG_MASTER_SHUTDOWN_RESPONSE,
+	MSG_MASTER_SHUTDOWN_IMMEDIATE,
+
+	MSG_MASTER_SHUTDOWN_UNIVERSE,
+
+	MSG_MASTER_AFFIRM_TRANSFER_REQUEST,
+	MSG_MASTER_AFFIRM_TRANSFER_RESPONSE,
+
+	MSG_MASTER_NEW_SESSION_ALERT
+};
+
+//! The Game messages
+enum GAME_MSG : unsigned short {
+	GAME_MSG_TELEPORT = 19,
+	GAME_MSG_SET_PLAYER_CONTROL_SCHEME = 26,
+	GAME_MSG_DROP_CLIENT_LOOT = 30,
+	GAME_MSG_DIE = 37,
+	GAME_MSG_REQUEST_DIE = 38,
+	GAME_MSG_PLAY_EMOTE = 41,
+	GAME_MSG_PLAY_ANIMATION = 43,
+	GAME_MSG_CONTROL_BEHAVIOR = 48,
+	GAME_MSG_SET_NAME = 72,
+	GAME_MSG_ECHO_START_SKILL = 118,
+	GAME_MSG_START_SKILL = 119,
+	GAME_MSG_VERIFY_ACK = 121,
+	GAME_MSG_ADD_SKILL = 127,
+	GAME_MSG_REMOVE_SKILL = 128,
+	GAME_MSG_SET_CURRENCY = 133,
+	GAME_MSG_PICKUP_CURRENCY = 137,
+	GAME_MSG_PICKUP_ITEM = 139,
+	GAME_MSG_TEAM_PICKUP_ITEM = 140,
+	GAME_MSG_PLAY_FX_EFFECT = 154,
+	GAME_MSG_STOP_FX_EFFECT = 155,
+	GAME_MSG_REQUEST_RESURRECT = 159,
+	GAME_MSG_RESURRECT = 160,
+	GAME_MSG_PUSH_EQUIPPED_ITEMS_STATE = 191,
+	GAME_MSG_POP_EQUIPPED_ITEMS_STATE = 192,
+	GAME_MSG_SET_GM_LEVEL = 193,
+	GAME_MSG_SET_STUNNED = 198,
+	GAME_MSG_SET_STUN_IMMUNITY = 200,
+	GAME_MSG_KNOCKBACK = 202,
+	GAME_MSG_REBUILD_CANCEL = 209,
+	GAME_MSG_ENABLE_REBUILD = 213,
+	GAME_MSG_MOVE_ITEM_IN_INVENTORY = 224,
+	GAME_MSG_ADD_ITEM_TO_INVENTORY_CLIENT_SYNC = 227,
+	GAME_MSG_REMOVE_ITEM_FROM_INVENTORY = 230,
+	GAME_MSG_EQUIP_ITEM = 231,
+	GAME_MSG_UN_EQUIP_ITEM = 233,
+	GAME_MSG_OFFER_MISSION = 248,
+	GAME_MSG_RESPOND_TO_MISSION = 249,
+	GAME_MSG_NOTIFY_MISSION = 254,
+	GAME_MSG_NOTIFY_MISSION_TASK = 255,
+	GAME_MSG_REBUILD_NOTIFY_STATE = 336,
+	GAME_MSG_TERMINATE_INTERACTION = 357,
+	GAME_MSG_SERVER_TERMINATE_INTERACTION = 358,
+	GAME_MSG_REQUEST_USE = 364,
+	GAME_MSG_VENDOR_OPEN_WINDOW = 369,
+	GAME_MSG_BUY_FROM_VENDOR = 373,
+	GAME_MSG_SELL_TO_VENDOR = 374,
+	GAME_MSG_TEAM_SET_OFF_WORLD_FLAG = 383,
+	GAME_MSG_SET_INVENTORY_SIZE = 389,
+	GAME_MSG_ACKNOWLEDGE_POSSESSION = 391,
+	GAME_MSG_SET_SHOOTING_GALLERY_PARAMS = 400,
+	GAME_MSG_REQUEST_ACTIVITY_START_STOP = 402,
+	GAME_MSG_REQUEST_ACTIVITY_ENTER = 403,
+	GAME_MSG_REQUEST_ACTIVITY_EXIT = 404,
+	GAME_MSG_ACTIVITY_ENTER = 405,
+	GAME_MSG_ACTIVITY_EXIT = 406,
+	GAME_MSG_ACTIVITY_START = 407,
+	GAME_MSG_ACTIVITY_STOP = 408,
+	GAME_MSG_SHOOTING_GALLERY_CLIENT_AIM_UPDATE = 409,
+	GAME_MSG_SHOOTING_GALLERY_FIRE = 411,
+	GAME_MSG_REQUEST_VENDOR_STATUS_UPDATE = 416,
+	GAME_MSG_VENDOR_STATUS_UPDATE = 417,
+	GAME_MSG_NOTIFY_CLIENT_SHOOTING_GALLERY_SCORE = 425,
+	GAME_MSG_CONSUME_CLIENT_ITEM = 427,
+	GAME_MSG_CLIENT_ITEM_CONSUMED = 428,
+	GAME_MSG_UPDATE_SHOOTING_GALLERY_ROTATION = 448,
+	GAME_MSG_SET_FLAG = 471,
+	GAME_MSG_NOTIFY_CLIENT_FLAG_CHANGE = 472,
+	GAME_MSG_VENDOR_TRANSACTION_RESULT = 476,
+	GAME_MSG_HAS_BEEN_COLLECTED = 486,
+	GAME_MSG_DISPLAY_CHAT_BUBBLE = 495,
+	GAME_MSG_SPAWN_PET = 498,
+	GAME_MSG_DESPAWN_PET = 499,
+	GAME_MSG_PLAYER_LOADED = 505,
+	GAME_MSG_PLAYER_READY = 509,
+	GAME_MSG_REQUEST_LINKED_MISSION = 515,
+	GAME_MSG_INVALID_ZONE_TRANSFER_LIST = 519,
+	GAME_MSG_MISSION_DIALOGUE_OK = 520,
+	GAME_MSG_DISPLAY_MESSAGE_BOX = 529,
+	GAME_MSG_MESSAGE_BOX_RESPOND = 530,
+	GAME_MSG_CHOICE_BOX_RESPOND = 531,
+	GAME_MSG_SMASH = 537,
+	GAME_MSG_UNSMASH = 538,
+	GAME_MSG_SET_SHOOTING_GALLERY_RETICULE_EFFECT = 548,
+	GAME_MSG_PLACE_MODEL_RESPONSE = 0x223,
+	GAME_MSG_SET_JET_PACK_MODE = 561,
+	GAME_MSG_REGISTER_PET_ID = 565,
+	GAME_MSG_REGISTER_PET_DBID = 566,
+	GAME_MSG_SHOW_ACTIVITY_COUNTDOWN = 568,
+	GAME_MSG_START_ACTIVITY_TIME = 576,
+	GAME_MSG_ACTIVITY_PAUSE = 602,
+	GAME_MSG_USE_NON_EQUIPMENT_ITEM = 603,
+	GAME_MSG_USE_ITEM_RESULT = 607,
+	GAME_MSG_COMMAND_PET = 640,
+	GAME_MSG_PET_RESPONSE = 641,
+	GAME_MSG_REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 648,
+	GAME_MSG_SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA = 649,
+	GAME_MSG_NOTIFY_OBJECT = 656,
+	GAME_MSG_CLIENT_NOTIFY_PET = 659,
+	GAME_MSG_NOTIFY_PET = 660,
+	GAME_MSG_NOTIFY_PET_TAMING_MINIGAME = 661,
+	GAME_MSG_START_SERVER_PET_MINIGAME_TIMER = 662,
+	GAME_MSG_CLIENT_EXIT_TAMING_MINIGAME = 663,
+	GAME_MSG_PET_NAME_CHANGED = 686,
+	GAME_MSG_PET_TAMING_MINIGAME_RESULT = 667,
+	GAME_MSG_PET_TAMING_TRY_BUILD_RESULT = 668,
+	GAME_MSG_NOTIFY_TAMING_BUILD_SUCCESS = 673,
+	GAME_MSG_NOTIFY_TAMING_MODEL_LOADED_ON_SERVER = 674,
+	GAME_MSG_ACTIVATE_BUBBLE_BUFF = 678,
+	GAME_MSG_DEACTIVATE_BUBBLE_BUFF = 679,
+	GAME_MSG_ADD_PET_TO_PLAYER = 681,
+	GAME_MSG_REQUEST_SET_PET_NAME = 683,
+	GAME_MSG_SET_PET_NAME = 684,
+	GAME_MSG_NOTIFY_PET_TAMING_PUZZLE_SELECTED = 675,
+	GAME_MSG_SHOW_PET_ACTION_BUTTON = 692,
+	GAME_MSG_SET_EMOTE_LOCK_STATE = 693,
+	GAME_MSG_USE_ITEM_REQUIREMENTS_RESPONSE = 703,
+	GAME_MSG_PLAY_EMBEDDED_EFFECT_ON_ALL_CLIENTS_NEAR_OBJECT = 713,
+	GAME_MSG_DOWNLOAD_PROPERTY_DATA = 716,
+	GAME_MSG_QUERY_PROPERTY_DATA = 717,
+	GAME_MSG_PROPERTY_EDITOR_BEGIN = 724,
+	GAME_MSG_PROPERTY_EDITOR_END = 725,
+	GAME_MSG_IS_MINIFIG_IN_A_BUBBLE = 729,
+	GAME_MSG_START_PATHING = 733,
+	GAME_MSG_ACTIVATE_BUBBLE_BUFF_FROM_SERVER = 734,
+	GAME_MSG_DEACTIVATE_BUBBLE_BUFF_FROM_SERVER = 735,
+	GAME_MSG_NOTIFY_CLIENT_ZONE_OBJECT = 737,
+	GAME_MSG_UPDATE_REPUTATION = 746,
+	GAME_MSG_PROPERTY_RENTAL_RESPONSE = 750,
+	GAME_MSG_REQUEST_PLATFORM_RESYNC = 760,
+	GAME_MSG_PLATFORM_RESYNC = 761,
+	GAME_MSG_PLAY_CINEMATIC = 762,
+	GAME_MSG_END_CINEMATIC = 763,
+	GAME_MSG_CINEMATIC_UPDATE = 764,
+	GAME_MSG_TOGGLE_GHOST_REFERENCE_OVERRIDE = 767,
+	GAME_MSG_SET_GHOST_REFERENCE_POSITION = 768,
+	GAME_MSG_FIRE_EVENT_SERVER_SIDE = 770,
+	GAME_MSG_SET_NETWORK_SCRIPT_VAR = 781,
+	GAME_MSG_UPDATE_MODEL_FROM_CLIENT = 793,
+	GAME_MSG_DELETE_MODEL_FROM_CLIENT = 794,
+	GAME_MSG_PLAY_ND_AUDIO_EMITTER = 821,
+	GAME_MSG_PLAY2_DAMBIENT_SOUND = 831,
+	GAME_MSG_ENTER_PROPERTY1 = 840,
+	GAME_MSG_ENTER_PROPERTY2 = 841,
+	GAME_MSG_PROPERTY_ENTRANCE_SYNC = 842,
+	GAME_MSG_PROPERTY_SELECT_QUERY = 845,
+	GAME_MSG_PARSE_CHAT_MESSAGE = 850,
+	GAME_MSG_BROADCAST_TEXT_TO_CHATBOX = 858,
+	GAME_MSG_OPEN_PROPERTY_MANAGEMENT = 860,
+	GAME_MSG_OPEN_PROPERTY_VENDOR = 861,
+	GAME_MSG_UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK = 863,
+	GAME_MSG_CLIENT_TRADE_REQUEST = 868,
+	GAME_MSG_SERVER_TRADE_REQUEST = 869,
+	GAME_MSG_SERVER_TRADE_INVITE = 870,
+	GAME_MSG_CLIENT_TRADE_REPLY = 871,
+	GAME_MSG_SERVER_TRADE_REPLY = 872,
+	GAME_MSG_SERVER_TRADE_INITIAL_REPLY = 873,
+	GAME_MSG_SERVER_TRADE_FINAL_REPLY = 874,
+	GAME_MSG_CLIENT_TRADE_UPDATE = 875,
+	GAME_MSG_SERVER_SIDE_TRADE_UPDATE = 876,
+	GAME_MSG_SERVER_TRADE_UPDATE = 877,
+	GAME_MSG_CLIENT_TRADE_CANCEL = 878,
+	GAME_MSG_CLIENT_SIDE_TRADE_CANCEL = 879,
+	GAME_MSG_CLIENT_TRADE_ACCEPT = 880,
+	GAME_MSG_SERVER_SIDE_TRADE_ACCEPT = 881,
+	GAME_MSG_SERVER_SIDE_TRADE_CANCEL = 882,
+	GAME_MSG_SERVER_TRADE_CANCEL = 883,
+	GAME_MSG_SERVER_TRADE_ACCEPT = 884,
+	GAME_MSG_READY_FOR_UPDATES = 888,
+	GAME_MSG_ORIENT_TO_OBJECT = 905,
+	GAME_MSG_ORIENT_TO_POSITION = 906,
+	GAME_MSG_ORIENT_TO_ANGLE = 907,
+	GAME_MSG_BOUNCER_ACTIVE_STATUS = 942,
+	GAME_MSG_UN_USE_BBB_MODEL = 999,
+	GAME_MSG_BBB_LOAD_ITEM_REQUEST = 1000,
+	GAME_MSG_BBB_SAVE_REQUEST = 1001,
+	GAME_MSG_BBB_SAVE_RESPONSE = 1006,
+	GAME_MSG_NOTIFY_CLIENT_OBJECT = 1042,
+	GAME_MSG_DISPLAY_ZONE_SUMMARY = 1043,
+	GAME_MSG_ACTIVITY_STATE_CHANGE_REQUEST = 1053,
+	GAME_MSG_MODIFY_PLAYER_ZONE_STATISTIC = 1046,
+	GAME_MSG_START_BUILDING_WITH_ITEM = 1057,
+	GAME_MSG_START_ARRANGING_WITH_ITEM = 1061,
+	GAME_MSG_FINISH_ARRANGING_WITH_ITEM = 1062,
+	GAME_MSG_DONE_ARRANGING_WITH_ITEM = 1063,
+	GAME_MSG_SET_BUILD_MODE = 1068,
+	GAME_MSG_BUILD_MODE_SET = 1069,
+	GAME_MSG_SET_BUILD_MODE_CONFIRMED = 1073,
+	GAME_MSG_NOTIFY_CLIENT_FAILED_PRECONDITION = 1081,
+	GAME_MSG_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1093,
+	GAME_MSG_MODULAR_BUILD_BEGIN = 1094,
+	GAME_MSG_MODULAR_BUILD_END = 1095,
+	GAME_MSG_MODULAR_BUILD_MOVE_AND_EQUIP = 1096,
+	GAME_MSG_MODULAR_BUILD_FINISH = 1097,
+	GAME_MSG_REPORT_BUG = 1198,
+	GAME_MSG_MISSION_DIALOGUE_CANCELLED = 1129,
+	GAME_MSG_ECHO_SYNC_SKILL = 1144,
+	GAME_MSG_SYNC_SKILL = 1145,
+	GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT = 1148,
+	GAME_MSG_DO_CLIENT_PROJECTILE_IMPACT = 1151,
+	GAME_MSG_MODULAR_BUILD_CONVERT_MODEL = 1155,
+	GAME_MSG_SET_PLAYER_ALLOWED_RESPAWN = 1165,
+	GAME_MSG_UI_MESSAGE_SERVER_TO_SINGLE_CLIENT = 1184,
+	GAME_MSG_UI_MESSAGE_SERVER_TO_ALL_CLIENTS = 1185,
+	GAME_MSG_PET_TAMING_TRY_BUILD = 1197,
+	GAME_MSG_REQUEST_SMASH_PLAYER = 1202,
+	GAME_MSG_FIRE_EVENT_CLIENT_SIDE = 1213,
+	GAME_MSG_TOGGLE_GM_INVIS = 1218,
+	GAME_MSG_CHANGE_OBJECT_WORLD_STATE = 1223,
+	GAME_MSG_VEHICLE_LOCK_INPUT = 1230,
+	GAME_MSG_VEHICLE_UNLOCK_INPUT = 1231,
+	GAME_MSG_RACING_RESET_PLAYER_TO_LAST_RESET = 1252,
+	GAME_MSG_RACING_SERVER_SET_PLAYER_LAP_AND_PLANE = 1253,
+	GAME_MSG_RACING_SET_PLAYER_RESET_INFO = 1254,
+	GAME_MSG_RACING_PLAYER_INFO_RESET_FINISHED = 1255,
+	GAME_MSG_LOCK_NODE_ROTATION = 1260,
+	GAME_MSG_VEHICLE_SET_WHEEL_LOCK_STATE = 1273,
+	GAME_MSG_NOTIFY_VEHICLE_OF_RACING_OBJECT = 1276,
+	GAME_MSG_PLAYER_REACHED_RESPAWN_CHECKPOINT = 1296,
+	GAME_MSG_HANDLE_UGC_EQUIP_POST_DELETE_BASED_ON_EDIT_MODE = 1300,
+	GAME_MSG_HANDLE_UGC_EQUIP_PRE_CREATE_BASED_ON_EDIT_MODE = 1301,
+	GAME_MSG_PROPERTY_CONTENTS_FROM_CLIENT = 1305,
+	GAME_MSG_GET_MODELS_ON_PROPERTY = 1306,
+	GAME_MSG_MATCH_REQUEST = 1308,
+	GAME_MSG_MATCH_RESPONSE = 1309,
+	GAME_MSG_MATCH_UPDATE = 1310,
+	GAME_MSG_MODULE_ASSEMBLY_DB_DATA_FOR_CLIENT = 1131,
+	GAME_MSG_MODULE_ASSEMBLY_QUERY_DATA = 1132,
+	GAME_MSG_CHANGE_IDLE_FLAGS = 1338,
+	GAME_MSG_VEHICLE_ADD_PASSIVE_BOOST_ACTION = 1340,
+	GAME_MSG_VEHICLE_REMOVE_PASSIVE_BOOST_ACTION = 1341,
+	GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION = 1342,
+	GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION = 1343,
+	GAME_MSG_VEHICLE_ADD_SLOWDOWN_ACTION = 1344,
+	GAME_MSG_VEHICLE_REMOVE_SLOWDOWN_ACTION = 1345,
+	GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_SLOWDOWN_ACTION = 1346,
+	GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_SLOWDOWN_ACTION = 1347,
+	GAME_MSG_BUYBACK_FROM_VENDOR = 1350,
+	GAME_MSG_SET_PROPERTY_ACCESS = 1366,
+	GAME_MSG_ZONE_PROPERTY_MODEL_PLACED = 1369,
+	GAME_MSG_ZONE_PROPERTY_MODEL_ROTATED = 1370,
+	GAME_MSG_ZONE_PROPERTY_MODEL_REMOVED_WHILE_EQUIPPED = 1371,
+	GAME_MSG_ZONE_PROPERTY_MODEL_EQUIPPED = 1372,
+	GAME_MSG_ZONE_PROPERTY_MODEL_PICKED_UP = 1373,
+	GAME_MSG_ZONE_PROPERTY_MODEL_REMOVED = 1374,
+	GAME_MSG_NOTIFY_RACING_CLIENT = 1390,
+	GAME_MSG_RACING_PLAYER_HACK_CAR = 1391,
+	GAME_MSG_RACING_PLAYER_LOADED = 1392,
+	GAME_MSG_RACING_CLIENT_READY = 1393,
+	GAME_MSG_UPDATE_CHAT_MODE = 1395,
+	GAME_MSG_VEHICLE_NOTIFY_FINISHED_RACE = 1396,
+	GAME_MSG_SET_CONSUMABLE_ITEM = 1409,
+	GAME_MSG_SET_STATUS_IMMUNITY = 1435,
+	GAME_MSG_SET_PET_NAME_MODERATED = 1448,
+	GAME_MSG_MODIFY_LEGO_SCORE = 1459,
+	GAME_MSG_RESTORE_TO_POST_LOAD_STATS = 1468,
+	GAME_MSG_SET_RAIL_MOVEMENT = 1471,
+	GAME_MSG_START_RAIL_MOVEMENT = 1472,
+	GAME_MSG_CANCEL_RAIL_MOVEMENT = 1474,
+	GAME_MSG_CLIENT_RAIL_MOVEMENT_READY = 1476,
+	GAME_MSG_PLAYER_RAIL_ARRIVED_NOTIFICATION = 1477,
+	GAME_MSG_UPDATE_PLAYER_STATISTIC = 1481,
+	GAME_MSG_MODULAR_ASSEMBLY_NIF_COMPLETED = 1498,
+	GAME_MSG_NOTIFY_NOT_ENOUGH_INV_SPACE = 1516,
+	GAME_MSG_TEAM_SET_LEADER = 0x0615,
+	GAME_MSG_TEAM_INVITE_CONFIRM = 0x0616,
+	GAME_MSG_TEAM_GET_STATUS_RESPONSE = 0x0617,
+	GAME_MSG_TEAM_ADD_PLAYER = 0x061a,
+	GAME_MSG_TEAM_REMOVE_PLAYER = 0x061b,
+	GAME_MSG_START_CELEBRATION_EFFECT = 1618,
+	GAME_MSG_ADD_BUFF = 1647,
+	GAME_MSG_SERVER_DONE_LOADING_ALL_OBJECTS = 1642,
+	GAME_MSG_PLACE_PROPERTY_MODEL = 1170,
+	GAME_MSG_VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER = 1606,
+	GAME_MSG_ADD_RUN_SPEED_MODIFIER = 1505,
+	GAME_MSG_HANDLE_HOT_PROPERTY_DATA = 1511,
+	GAME_MSG_SEND_HOT_PROPERTY_DATA = 1510,
+	GAME_MSG_REMOVE_RUN_SPEED_MODIFIER = 1506,
+	GAME_MSG_UPDATE_PROPERTY_PERFORMANCE_COST = 1547,
+	GAME_MSG_PROPERTY_ENTRANCE_BEGIN = 1553,
+	GAME_MSG_REMOVE_BUFF = 1648,
+	GAME_MSG_REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1666,
+	GAME_MSG_RESPONSE_MOVE_ITEM_BETWEEN_INVENTORY_TYPES = 1667,
+	GAME_MSG_PLAYER_SET_CAMERA_CYCLING_MODE = 1676,
+	GAME_MSG_SET_MOUNT_INVENTORY_ID = 1726,
+	GAME_MSG_NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE = 1734,
+	GAME_MSG_NOTIFY_LEVEL_REWARDS = 1735,
+	GAME_MSG_DISMOUNT_COMPLETE = 1756,
+	GAME_MSG_MARK_INVENTORY_ITEM_AS_ACTIVE = 1767,
+	END
+};

dCommon/dEnums/eAuthMessageType.h

@@ -1,15 +0,0 @@
-#ifndef __EAUTHMESSAGETYPE__H__
-#define __EAUTHMESSAGETYPE__H__
-
-#include <cstdint>
-
-enum class eAuthMessageType : uint32_t {
-	LOGIN_REQUEST = 0,
-	LOGOUT_REQUEST,
-	CREATE_NEW_ACCOUNT_REQUEST,
-	LEGOINTERFACE_AUTH_RESPONSE,
-	SESSIONKEY_RECEIVED_CONFIRM,
-	RUNTIME_CONFIG
-};
-
-#endif  //!__EAUTHMESSAGETYPE__H__

dCommon/dEnums/eBubbleType.h

@@ -7,8 +7,8 @@
 
 enum class eBubbleType : uint32_t {
 	DEFAULT = 0,
-	ENERGY,
-	SKUNK
+	ENERGY = 1,
+	SKUNK = 2,
 };
 
 #endif  //!__EBUBBLETYPE__H__

dCommon/dEnums/eBuildType.h

@@ -1,12 +0,0 @@
-#ifndef __EBUILDTYPE__H__
-#define __EBUILDTYPE__H__
-
-#include <cstdint>
-
-enum class eBuildType :uint32_t {
-	NOWHERE,
-	IN_WORLD,
-	ON_PROPERTY
-};
-
-#endif  //!__EBUILDTYPE__H__

dCommon/dEnums/eCharacterCreationResponse.h

@@ -1,14 +0,0 @@
-#ifndef __ECHARACTERCREATIONRESPONSE__H__
-#define __ECHARACTERCREATIONRESPONSE__H__
-
-#include <cstdint>
-
-enum class eCharacterCreationResponse : uint8_t {
-	SUCCESS = 0,
-	OBJECT_ID_UNAVAILABLE,
-	NAME_NOT_ALLOWED,
-	PREDEFINED_NAME_IN_USE,
-	CUSTOM_NAME_IN_USE
-};
-
-#endif  //!__ECHARACTERCREATIONRESPONSE__H__

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

@@ -1,78 +0,0 @@
-#ifndef __ECHATMESSAGETYPE__H__
-#define __ECHATMESSAGETYPE__H__
-
-#include <cstdint>
-
-//! The Internal Chat Packet Identifiers
-enum class eChatMessageType :uint32_t {
-	LOGIN_SESSION_NOTIFY = 0,
-	GENERAL_CHAT_MESSAGE,
-	PRIVATE_CHAT_MESSAGE,
-	USER_CHANNEL_CHAT_MESSAGE,
-	WORLD_DISCONNECT_REQUEST,
-	WORLD_PROXIMITY_RESPONSE,
-	WORLD_PARCEL_RESPONSE,
-	ADD_FRIEND_REQUEST,
-	ADD_FRIEND_RESPONSE,
-	REMOVE_FRIEND,
-	GET_FRIENDS_LIST,
-	ADD_IGNORE,
-	REMOVE_IGNORE,
-	GET_IGNORE_LIST,
-	TEAM_MISSED_INVITE_CHECK,
-	TEAM_INVITE,
-	TEAM_INVITE_RESPONSE,
-	TEAM_KICK,
-	TEAM_LEAVE,
-	TEAM_SET_LOOT,
-	TEAM_SET_LEADER,
-	TEAM_GET_STATUS,
-	GUILD_CREATE,
-	GUILD_INVITE,
-	GUILD_INVITE_RESPONSE,
-	GUILD_LEAVE,
-	GUILD_KICK,
-	GUILD_GET_STATUS,
-	GUILD_GET_ALL,
-	SHOW_ALL,
-	BLUEPRINT_MODERATED,
-	BLUEPRINT_MODEL_READY,
-	PROPERTY_READY_FOR_APPROVAL,
-	PROPERTY_MODERATION_CHANGED,
-	PROPERTY_BUILDMODE_CHANGED,
-	PROPERTY_BUILDMODE_CHANGED_REPORT,
-	MAIL,
-	WORLD_INSTANCE_LOCATION_REQUEST,
-	REPUTATION_UPDATE,
-	SEND_CANNED_TEXT,
-	GMLEVEL_UPDATE,
-	CHARACTER_NAME_CHANGE_REQUEST,
-	CSR_REQUEST,
-	CSR_REPLY,
-	GM_KICK,
-	GM_ANNOUNCE,
-	GM_MUTE,
-	ACTIVITY_UPDATE,
-	WORLD_ROUTE_PACKET,
-	GET_ZONE_POPULATIONS,
-	REQUEST_MINIMUM_CHAT_MODE,
-	REQUEST_MINIMUM_CHAT_MODE_PRIVATE,
-	MATCH_REQUEST,
-	UGCMANIFEST_REPORT_MISSING_FILE,
-	UGCMANIFEST_REPORT_DONE_FILE,
-	UGCMANIFEST_REPORT_DONE_BLUEPRINT,
-	UGCC_REQUEST,
-	WHO,
-	WORLD_PLAYERS_PET_MODERATED_ACKNOWLEDGE,
-	ACHIEVEMENT_NOTIFY,
-	GM_CLOSE_PRIVATE_CHAT_WINDOW,
-	UNEXPECTED_DISCONNECT,
-	PLAYER_READY,
-	GET_DONATION_TOTAL,
-	UPDATE_DONATION,
-	PRG_CSR_COMMAND,
-	HEARTBEAT_REQUEST_FROM_WORLD,
-	UPDATE_FREE_TRIAL_STATUS
-};
-
-#endif  //!__ECHATMESSAGETYPE__H__

dCommon/dEnums/eCinematicEvent.h

@@ -1,12 +0,0 @@
-#ifndef __ECINEMATICEVENT__H__
-#define __ECINEMATICEVENT__H__
-
-#include <cstdint>
-
-enum class eCinematicEvent : uint32_t {
-	STARTED,
-	WAYPOINT,
-	ENDED,
-};
-
-#endif  //!__ECINEMATICEVENT__H__

dCommon/dEnums/eClientMessageType.h

@@ -1,76 +0,0 @@
-#ifndef __ECLIENTMESSAGETYPE__H__
-#define __ECLIENTMESSAGETYPE__H__
-
-#include <cstdint>
-
-enum class eClientMessageType : uint32_t {
-	LOGIN_RESPONSE = 0,
-	LOGOUT_RESPONSE,
-	LOAD_STATIC_ZONE,
-	CREATE_OBJECT,
-	CREATE_CHARACTER,
-	CREATE_CHARACTER_EXTENDED,
-	CHARACTER_LIST_RESPONSE,
-	CHARACTER_CREATE_RESPONSE,
-	CHARACTER_RENAME_RESPONSE,
-	CHAT_CONNECT_RESPONSE,
-	AUTH_ACCOUNT_CREATE_RESPONSE,
-	DELETE_CHARACTER_RESPONSE,
-	GAME_MSG,
-	CONNECT_CHAT,
-	TRANSFER_TO_WORLD,
-	IMPENDING_RELOAD_NOTIFY,
-	MAKE_GM_RESPONSE,
-	HTTP_MONITOR_INFO_RESPONSE,
-	SLASH_PUSH_MAP_RESPONSE,
-	SLASH_PULL_MAP_RESPONSE,
-	SLASH_LOCK_MAP_RESPONSE,
-	BLUEPRINT_SAVE_RESPONSE,
-	BLUEPRINT_LUP_SAVE_RESPONSE,
-	BLUEPRINT_LOAD_RESPONSE_ITEMID,
-	BLUEPRINT_GET_ALL_DATA_RESPONSE,
-	MODEL_INSTANTIATE_RESPONSE,
-	DEBUG_OUTPUT,
-	ADD_FRIEND_REQUEST,
-	ADD_FRIEND_RESPONSE,
-	REMOVE_FRIEND_RESPONSE,
-	GET_FRIENDS_LIST_RESPONSE,
-	UPDATE_FRIEND_NOTIFY,
-	ADD_IGNORE_RESPONSE,
-	REMOVE_IGNORE_RESPONSE,
-	GET_IGNORE_LIST_RESPONSE,
-	TEAM_INVITE,
-	TEAM_INVITE_INITIAL_RESPONSE,
-	GUILD_CREATE_RESPONSE,
-	GUILD_GET_STATUS_RESPONSE,
-	GUILD_INVITE,
-	GUILD_INVITE_INITIAL_RESPONSE,
-	GUILD_INVITE_FINAL_RESPONSE,
-	GUILD_INVITE_CONFIRM,
-	GUILD_ADD_PLAYER,
-	GUILD_REMOVE_PLAYER,
-	GUILD_LOGIN_LOGOUT,
-	GUILD_RANK_CHANGE,
-	GUILD_DATA,
-	GUILD_STATUS,
-	MAIL,
-	DB_PROXY_RESULT,
-	SHOW_ALL_RESPONSE,
-	WHO_RESPONSE,
-	SEND_CANNED_TEXT,
-	UPDATE_CHARACTER_NAME,
-	SET_NETWORK_SIMULATOR,
-	INVALID_CHAT_MESSAGE,
-	MINIMUM_CHAT_MODE_RESPONSE,
-	MINIMUM_CHAT_MODE_RESPONSE_PRIVATE,
-	CHAT_MODERATION_STRING,
-	UGC_MANIFEST_RESPONSE,
-	IN_LOGIN_QUEUE,
-	SERVER_STATES,
-	GM_CLOSE_TARGET_CHAT_WINDOW,
-	GENERAL_TEXT_FOR_LOCALIZATION,
-	UPDATE_FREE_TRIAL_STATUS,
-	UGC_DOWNLOAD_FAILED = 120
-};
-
-#endif  //!__ECLIENTMESSAGETYPE__H__

dCommon/dEnums/eConnectionType.h

@@ -1,14 +0,0 @@
-#ifndef __ECONNECTIONTYPE__H__
-#define __ECONNECTIONTYPE__H__
-
-enum class eConnectionType : uint16_t {
-	SERVER = 0,
-	AUTH,
-	CHAT,
-	CHAT_INTERNAL,
-	WORLD,
-	CLIENT,
-	MASTER
-};
-
-#endif  //!__ECONNECTIONTYPE__H__

dCommon/dEnums/eControlScheme.h

@@ -1,18 +0,0 @@
-#ifndef __ECONTROLSCHEME__H__
-#define __ECONTROLSCHEME__H__
-
-#include <cstdint>
-
-enum class eControlScheme : uint32_t {
-	SCHEME_A,
-	SCHEME_D,
-	SCHEME_GAMEPAD,
-	SCHEME_E,
-	SCHEME_FPS,
-	SCHEME_DRIVING,
-	SCHEME_TAMING,
-	SCHEME_MODULAR_BUILD,
-	SCHEME_WEAR_A_ROBOT //== freecam?
-};
-
-#endif  //!__ECONTROLSCHEME__H__

dCommon/dEnums/eCyclingMode.h

@@ -1,11 +0,0 @@
-#ifndef __ECYCLINGMODE__H__
-#define __ECYCLINGMODE__H__
-
-#include <cstdint>
-
-enum class eCyclingMode : uint32_t {
-	ALLOW_CYCLE_TEAMMATES,
-	DISALLOW_CYCLING
-};
-
-#endif  //!__ECYCLINGMODE__H__

dCommon/dEnums/eEndBehavior.h

@@ -1,11 +0,0 @@
-#ifndef __EENDBEHAVIOR__H__
-#define __EENDBEHAVIOR__H__
-
-#include <cstdint>
-
-enum class eEndBehavior : uint32_t {
-	RETURN,
-	WAIT
-};
-
-#endif  //!__EENDBEHAVIOR__H__

dCommon/dEnums/eGameActivity.h

@@ -1,15 +0,0 @@
-#ifndef __EGAMEACTIVITY__H__
-#define __EGAMEACTIVITY__H__
-
-#include <cstdint>
-
-enum class eGameActivity : uint32_t {
-	NONE,
-	QUICKBUILDING,
-	SHOOTING_GALLERY,
-	RACING,
-	PINBALL,
-	PET_TAMING
-};
-
-#endif  //!__EGAMEACTIVITY__H__

dCommon/dEnums/eGameMasterLevel.h

@@ -1,20 +0,0 @@
-#ifndef __EGAMEMASTERLEVEL__H__
-#define __EGAMEMASTERLEVEL__H__
-
-#include <cstdint>
-
-enum class eGameMasterLevel : uint8_t {
-	CIVILIAN = 0,             // Normal player.
-	FORUM_MODERATOR = 1,      // No permissions on live servers.
-	JUNIOR_MODERATOR = 2,     // Can kick/mute and pull chat logs.
-	MODERATOR = 3,            // Can return lost items.
-	SENIOR_MODERATOR = 4,     // Can ban.
-	LEAD_MODERATOR = 5,       // Can approve properties.
-	JUNIOR_DEVELOPER = 6,     // Junior developer & future content team. Civilan on live.
-	INACTIVE_DEVELOPER = 7,   // Inactive developer, limited permissions.
-	DEVELOPER = 8,            // Active developer, full permissions on live.
-	OPERATOR = 9              // Can shutdown server for restarts & updates.
-};
-
-
-#endif  //!__EGAMEMASTERLEVEL__H__

dCommon/dEnums/eGameMessageType.h

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

dCommon/dEnums/eHelpType.h

@@ -1,41 +0,0 @@
-
-#ifndef __EHELPTYPE__H__
-#define __EHELPTYPE__H__
-
-#include <cstdint>
-
-enum class eHelpType : int32_t {
-	NONE = 0,
-	UNLOCK_MINIMAP = 2,
-	TOGGLETOOLTIP_OUTOFTIME_REBUILD = 3,
-	TOGGLETOOLTIP_LEAVELOSE_REBUILD = 4,
-	TOGGLECONTROLSTUTORIAL_WALKING = 6,
-	DISPLAYTUTORIAL_PASSPORT_1ST_SMASH = 7,
-	TOOLTIP_1ST_IMAGINATION_PICKUP = 8,
-	UNKNOWN9 = 9,
-	PETTAMINGMINIGAME_TUTORIAL_01 = 15,
-	PR_BOUNCER_TUTORIAL_03 = 16,
-	PR_TOOLTIP_1ST_PET_JUMPED_ON_SWITCH = 17,
-	PR_DIG_TUTORIAL_01 = 18,
-	PR_DIG_TUTORIAL_03 = 19,
-	PR_BOUNCER_TUTORIAL_01 = 20,
-	PR_NO_IMAGINATION_HIBERNATE = 21,
-	UNKNOWN22 = 22,
-	TOGGLECONTROLSTUTORIAL_JUMPING = 26,
-	TOGGLECONTROLSTUTORIAL_DOUBLEJUMPING = 27,
-	TOGGLECONTROLSTUTORIAL_CAMERA = 28,
-	TOGGLECONTROLSTUTORIAL_SMASH = 30,
-	UNKNOWN38 = 38,
-	UI_MOD_BUILD_PUT_ON_HAT = 40,
-	UI_MOD_BUILD_EQUIP_FIRST_MODULE = 41,
-	UNKNOWN42 = 42,
-	UNKNOWN43 = 43,
-	UI_MOD_BUILD_GO_LAUNCH_ROCKET = 44,
-	UI_MOD_BUILD_TALK_TO_SKYLANE = 45,
-	UNKNOWN53 = 53,
-	PET_DESPAWN_BY_OWNER_HIBERNATE = 69,
-	PET_DESPAWN_TAMING_NEW_PET = 70,
-	UI_INVENTORY_FULL_CANNOT_PICKUP_ITEM = 86
-};
-
-#endif  //!__EHELPTYPE__H__

dCommon/dEnums/eItemSetPassiveAbilityID.h

@@ -1,58 +0,0 @@
-#pragma once
-
-#ifndef __EITEMSETPASSIVEABILITYID__H__
-#define __EITEMSETPASSIVEABILITYID__H__
-
-enum class eItemSetPassiveAbilityID {
-	EngineerRank1 = 2,
-	EngineerRank2 = 3,
-	EngineerRank3 = 4,
-	KnightRank1 = 7,
-	KnightRank2 = 8,
-	KnightRank3 = 9,
-	SpaceRangerRank1 = 10,
-	SpaceRangerRank2 = 11,
-	SpaceRangerRank3 = 12,
-	SamuraiRank1 = 13,
-	SamuraiRank2 = 14,
-	SamuraiRank3 = 15,
-	SorcererRank1 = 16,
-	SorcererRank2 = 17,
-	SorcererRank3 = 18,
-	SpaceMarauderRank1 = 19,
-	SpaceMarauderRank2 = 20,
-	SpaceMarauderRank3 = 21,
-	ShinobiRank1 = 22,
-	ShinobiRank2 = 23,
-	ShinobiRank3 = 24,
-	InventorRank1 = 25,
-	InventorRank2 = 26,
-	InventorRank3 = 27,
-	SummonerRank1 = 28,
-	SummonerRank2 = 29,
-	SummonerRank3 = 30,
-	AdventurerRank1 = 31,
-	AdventurerRank2 = 32,
-	AdventurerRank3 = 33,
-	DaredevilRank1 = 34,
-	DaredevilRank2 = 35,
-	DaredevilRank3 = 36,
-	BuccaneerRank1 = 37,
-	BuccaneerRank2 = 38,
-	BuccaneerRank3 = 39,
-	BoneSuit = 40,
-	ImaginationSpinjitzu = 41,
-	BatLord = 42,
-	MosaicJester = 43,
-	ExplorienBot = 44,
-	Unnamed1 = 45,
-	Unnamed2 = 46,
-	Unnamed3 = 47,
-	EarthSpinjitzu = 48,
-	Unnamed4 = 49,
-	FireSpinjitzu = 50,
-	IceSpinjitzu = 51,
-	LightningSpinjitzu = 52
-};
-
-#endif  //!__EITEMSETPASSIVEABILITYID__H__

dCommon/dEnums/eItemType.h

@@ -6,31 +6,31 @@
 #include <cstdint>
 
 enum class eItemType : int32_t {
-	UNKNOWN = -1,
-	BRICK = 1,
-	HAT,
-	HAIR,
-	NECK,
-	LEFT_HAND,
-	RIGHT_HAND,
-	LEGS,
-	LEFT_TRINKET,
-	RIGHT_TRINKET,
-	BEHAVIOR,
-	PROPERTY,
-	MODEL,
-	COLLECTIBLE,
-	CONSUMABLE,
-	CHEST,
-	EGG,
-	PET_FOOD,
-	QUEST_OBJECT,
-	PET_INVENTORY_ITEM,
-	PACKAGE,
-	LOOT_MODEL,
-	VEHICLE,
-	LUP_MODEL,
-	MOUNT
+	ITEM_TYPE_UNKNOWN = -1, 			//!< An unknown item type
+	ITEM_TYPE_BRICK = 1, 				//!< A brick
+	ITEM_TYPE_HAT = 2, 					//!< A hat / head item
+	ITEM_TYPE_HAIR = 3, 				//!< A hair item
+	ITEM_TYPE_NECK = 4, 				//!< A neck item
+	ITEM_TYPE_LEFT_HAND = 5, 			//!< A left handed item
+	ITEM_TYPE_RIGHT_HAND = 6, 			//!< A right handed item
+	ITEM_TYPE_LEGS = 7, 				//!< A pants item
+	ITEM_TYPE_LEFT_TRINKET = 8, 		//!< A left handled trinket item
+	ITEM_TYPE_RIGHT_TRINKET = 9, 		//!< A right handed trinket item
+	ITEM_TYPE_BEHAVIOR = 10,			//!< A behavior
+	ITEM_TYPE_PROPERTY = 11,			//!< A property
+	ITEM_TYPE_MODEL = 12,				//!< A model
+	ITEM_TYPE_COLLECTIBLE = 13,			//!< A collectible item
+	ITEM_TYPE_CONSUMABLE = 14,			//!< A consumable item
+	ITEM_TYPE_CHEST = 15,				//!< A chest item
+	ITEM_TYPE_EGG = 16,					//!< An egg
+	ITEM_TYPE_PET_FOOD = 17,			//!< A pet food item
+	ITEM_TYPE_QUEST_OBJECT = 18,		//!< A quest item
+	ITEM_TYPE_PET_INVENTORY_ITEM = 19,	//!< A pet inventory item
+	ITEM_TYPE_PACKAGE = 20,				//!< A package
+	ITEM_TYPE_LOOT_MODEL = 21,			//!< A loot model
+	ITEM_TYPE_VEHICLE = 22,				//!< A vehicle
+	ITEM_TYPE_CURRENCY = 23,			//!< Currency
+	ITEM_TYPE_MOUNT = 24				//!< A Mount
 };
 
 #endif  //!__EITEMTYPE__H__

dCommon/dEnums/eKillType.h

@@ -1,11 +0,0 @@
-#ifndef __EKILLTYPE__H__
-#define __EKILLTYPE__H__
-
-#include <cstdint>
-
-enum class eKillType : uint32_t {
-	VIOLENT,
-	SILENT
-};
-
-#endif  //!__EKILLTYPE__H__

dCommon/dEnums/eLoginResponse.h

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

dCommon/dEnums/eLootSourceType.h

@@ -1,31 +0,0 @@
-#ifndef __ELOOTSOURCETYPE__H__
-#define __ELOOTSOURCETYPE__H__
-
-#include <cstdint>
-
-enum class eLootSourceType : uint32_t {
-	NONE = 0,
-	CHEST,
-	MISSION,
-	MAIL,
-	CURRENCY,
-	ACHIEVEMENT,
-	TRADE,
-	QUICKBUILD,
-	DELETION,
-	VENDOR,
-	ACTIVITY,
-	PICKUP,
-	BRICK,
-	PROPERTY,
-	MODERATION,
-	EXHIBIT,
-	INVENTORY,
-	CLAIMCODE,
-	CONSUMPTION,
-	CRAFTING,
-	LEVEL_REWARD,
-	RELOCATE
-};
-
-#endif  //!__ELOOTSOURCETYPE__H__

dCommon/dEnums/eMasterMessageType.h

@@ -1,36 +0,0 @@
-#ifndef __EMASTERMESSAGETYPE__H__
-#define __EMASTERMESSAGETYPE__H__
-
-#include <cstdint>
-
-enum class eMasterMessageType : uint32_t {
-	REQUEST_PERSISTENT_ID = 1,
-	REQUEST_PERSISTENT_ID_RESPONSE,
-	REQUEST_ZONE_TRANSFER,
-	REQUEST_ZONE_TRANSFER_RESPONSE,
-	SERVER_INFO,
-	REQUEST_SESSION_KEY,
-	SET_SESSION_KEY,
-	SESSION_KEY_RESPONSE,
-	PLAYER_ADDED,
-	PLAYER_REMOVED,
-
-	CREATE_PRIVATE_ZONE,
-	REQUEST_PRIVATE_ZONE,
-
-	WORLD_READY,
-	PREP_ZONE,
-
-	SHUTDOWN,
-	SHUTDOWN_RESPONSE,
-	SHUTDOWN_IMMEDIATE,
-
-	SHUTDOWN_UNIVERSE,
-
-	AFFIRM_TRANSFER_REQUEST,
-	AFFIRM_TRANSFER_RESPONSE,
-
-	NEW_SESSION_ALERT
-};
-
-#endif  //!__EMASTERMESSAGETYPE__H__

dCommon/dEnums/eMatchUpdate.h

@@ -1,17 +0,0 @@
-#ifndef __EMATCHUPDATE__H__
-#define __EMATCHUPDATE__H__
-
-#include <cstdint>
-
-enum class eMatchUpdate : int32_t {
-	PLAYER_ADDED = 0,
-	PLAYER_REMOVED,
-	PHASE_CREATED,
-	PHASE_WAIT_READY,
-	PHASE_WAIT_START,
-	PLAYER_READY,
-	PLAYER_NOT_READY,
-	PLAYER_UPDATE
-};
-
-#endif  //!__EMATCHUPDATE__H__

dCommon/dEnums/eMissionLockState.h

@@ -1,12 +0,0 @@
-#pragma once
-
-#ifndef __EMISSIONLOCKSTATE__H__
-#define __EMISSIONLOCKSTATE__H__
-
-enum class eMissionLockState : int {
-	LOCKED,
-	NEW,
-	UNLOCKED,
-};
-
-#endif  //!__EMISSIONLOCKSTATE__H__

dCommon/dEnums/eMissionState.h

@@ -1,56 +0,0 @@
-#pragma once
-
-#ifndef __MISSIONSTATE__H__
-#define __MISSIONSTATE__H__
-
-/**
- * Represents the possible states a mission can be in
- */
-enum class eMissionState : int {
-	/**
-	 * The mission state is unknown
-	 */
-	UNKNOWN = -1,
-
-	/**
-	 * The mission is yielding rewards
-	 */
-	REWARDING = 0,
-
-	/**
-	 * The mission can be accepted
-	 */
-	AVAILABLE = 1,
-
-	/**
-	 * The mission has been accepted but not yet completed
-	 */
-	ACTIVE = 2,
-
-	/**
-	* All the tasks for the mission have been completed and the entity can turn the mission in to complete it
-	*/
-	READY_TO_COMPLETE = 4,            //!< The mission is ready to complete
-
-	/**
-	 * The mission has been completed
-	*/
-	COMPLETE = 8,
-
-	/**
-	 * The mission is available again and has been completed before. Used for daily missions.
-	 */
-	COMPLETE_AVAILABLE = 9,
-
-	/**
-	 * The mission is active and has been completed before. Used for daily missions.
-	 */
-	COMPLETE_ACTIVE = 10,
-
-	/**
-	* The mission has been completed before and has now been completed again. Used for daily missions.
-	*/
-	COMPLETE_READY_TO_COMPLETE = 12
-};
-
-#endif  //!__MISSIONSTATE__H__

dCommon/dEnums/eMissionTaskType.h

@@ -1,43 +0,0 @@
-#pragma once
-
-#ifndef __EMISSIONTASKTYPE__H__
-#define __EMISSIONTASKTYPE__H__
-
-enum class eMissionTaskType : int {
-	UNKNOWN = -1,
-	SMASH,
-	SCRIPT,
-	ACTIVITY,
-	COLLECTION,
-	TALK_TO_NPC,
-	EMOTE,
-	SHASH_CHAIN,
-	BUY,
-	SELL,
-	USE_ITEM,
-	USE_SKILL,
-	GATHER,
-	EXPLORE,
-	DELIVERY,
-	PERFORM_ACTIVITY,
-	INTERACT,
-	META,
-	EARN_REPUTATION,
-	VOTING,
-	SHOWCASE_DELIVERY,
-	REVIECE_CAST,
-	POWERUP,
-	PET_TAMING,
-	RACING,
-	PLAYER_FLAG,
-	PLACE_MODEL,
-	REMOVE_MODEL,
-	ADD_BEHAVIOR,
-	REMOVE_BEHAVIOR,
-	CLAIM_PROPERTY,
-	VISIT_PROPERTY,
-	TIME_PLAYED,
-	DONATION
-};
-
-#endif  //!__EMISSIONTASKTYPE__H__

dCommon/dEnums/eObjectBits.h

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

dCommon/dEnums/eObjectWorldState.h

@@ -1,12 +0,0 @@
-#ifndef __EOBJECTWORLDSTATE__H__
-#define __EOBJECTWORLDSTATE__H__
-
-#include <cstdint>
-
-enum class eObjectWorldState : uint32_t {
-	INWORLD,
-	ATTACHED,
-	INVENTORY
-};
-
-#endif  //!__EOBJECTWORLDSTATE__H__

dCommon/dEnums/ePackageType.h

@@ -1,13 +0,0 @@
-#ifndef __EPACKAGETYPE__H__
-#define __EPACKAGETYPE__H__
-
-enum class ePackageType {
-	INVALID = -1,
-	ITEM,
-	BRICKS,
-	MODELS,
-	CAR_MODELS
-};
-
-
-#endif  //!__EPACKAGETYPE__H__

dCommon/dEnums/ePermissionMap.h

@@ -1,46 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-#ifndef __EPERMISSIONMAP__H__
-#define __EPERMISSIONMAP__H__
-
-/**
- * Bitmap of permissions and restrictions for characters.
- */
-enum class ePermissionMap : uint64_t {
-	/**
-	 * Reserved for future use, bit 0-3.
-	 */
-
-	/**
-	 * The character has restricted trade acccess, bit 4.
-	 */
-	RestrictedTradeAccess = 0x1 << 4,
-
-	/**
-	 * The character has restricted mail access, bit 5.
-	 */
-	RestrictedMailAccess = 0x1 << 5,
-
-	/**
-	 * The character has restricted chat access, bit 6.
-	 */
-	RestrictedChatAccess = 0x1 << 6,
-
-	//
-	// Combined permissions
-	//
-
-	/**
-	 * The character is marked as 'old', restricted from trade and mail.
-	 */
-	Old = RestrictedTradeAccess | RestrictedMailAccess,
-
-	/**
-	* The character is soft banned, restricted from trade, mail, and chat.
-	*/
-	SoftBanned = RestrictedTradeAccess | RestrictedMailAccess | RestrictedChatAccess,
-};
-
-#endif  //!__EPERMISSIONMAP__H__

dCommon/dEnums/ePetTamingNotifyType.h

@@ -1,15 +0,0 @@
-#ifndef __EPETTAMINGNOTIFYTYPE__H__
-#define __EPETTAMINGNOTIFYTYPE__H__
-
-#include <cstdint>
-
-enum class ePetTamingNotifyType : uint32_t {
-	SUCCESS,
-	QUIT,
-	FAILED,
-	BEGIN,
-	READY,
-	NAMINGPET
-};
-
-#endif  //!__EPETTAMINGNOTIFYTYPE__H__

dCommon/dEnums/ePhysicsEffectType.h

@@ -1,15 +0,0 @@
-#ifndef __EPHYSICSEFFECTTYPE__H__
-#define __EPHYSICSEFFECTTYPE__H__
-
-
-#include <cstdint>
-
-enum class ePhysicsEffectType : uint32_t {
-	PUSH,
-	ATTRACT,
-	REPULSE,
-	GRAVITY_SCALE,
-	FRICTION
-};
-
-#endif  //!__EPHYSICSEFFECTTYPE__H__

dCommon/dEnums/ePlayerFlag.h

@@ -1,172 +0,0 @@
-#ifndef __EPLAYERFLAG__H__
-#define __EPLAYERFLAG__H__
-
-#include <cstdint>
-
-enum ePlayerFlag : int32_t {
-	BTARR_TESTING = 0,
-	PLAYER_HAS_ENTERED_PET_RANCH = 1,
-	MINIMAP_UNLOCKED = 2,
-	ACTIVITY_REBUILDING_FAIL_TIME = 3,
-	ACTIVITY_REBUILDING_FAIL_RANGE = 4,
-	ACTIVITY_SHOOTING_GALLERY_HELP = 5,
-	HELP_WALKING_CONTROLS = 6,
-	FIRST_SMASHABLE = 7,
-	FIRST_IMAGINATION_PICKUP = 8,
-	FIRST_DAMAGE = 9,
-	FIRST_ITEM = 10,
-	FIRST_BRICK = 11,
-	FIRST_CONSUMABLE = 12,
-	FIRST_EQUIPPABLE = 13,
-	CHAT_HELP = 14,
-	FIRST_PET_TAMING_MINIGAME = 15,
-	FIRST_PET_ON_SWITCH = 16,
-	FIRST_PET_JUMPED_ON_SWITCH = 17,
-	FIRST_PET_FOUND_TREASURE = 18,
-	FIRST_PET_DUG_TREASURE = 19,
-	FIRST_PET_OWNER_ON_PET_BOUNCER = 20,
-	FIRST_PET_DESPAWN_NO_IMAGINATION = 21,
-	FIRST_PET_SELECTED_ENOUGH_BRICKS = 22,
-	FIRST_EMOTE_UNLOCKED = 23,
-	GF_PIRATE_REP = 24,
-	AG_BOB_CINEMATIC_EVENT = 25,
-	HELP_JUMPING_CONTROLS = 26,
-	HELP_DOUBLE_JUMP_CONTROLS = 27,
-	HELP_CAMERA_CONTROLS = 28,
-	HELP_ROTATE_CONTROLS = 29,
-	HELP_SMASH = 30,
-	MONUMENT_INTRO_MUSIC_PLAYED = 31,
-	BEGINNING_ZONE_SUMMARY_DISPLAYED = 32,
-	AG_FINISH_LINE_BUILT = 33,
-	AG_BOSS_AREA_FOUND = 34,
-	AG_LANDED_IN_BATTLEFIELD = 35,
-	GF_PLAYER_HAS_BEEN_TO_THE_RAVINE = 36,
-	MODULAR_BUILD_STARTED = 37,
-	MODULAR_BUILD_FINISHED_CLICK_BUTTON = 38,
-	THINKING_HAT_RECEIVED_GO_TO_MODULAR_BUILD_AREA = 39,
-	BUILD_AREA_ENTERED_MOD_NOT_ACTIVATED_PUT_ON_HAT = 40,
-	HAT_ON_INSIDE_OF_MOD_BUILD_EQUIP_A_MODULE_FROM_LEG = 41,
-	MODULE_EQUIPPED_PLACE_ON_GLOWING_BLUE_SPOT = 42,
-	FIRST_MODULE_PLACED_CORRECTLY_NOW_DO_THE_REST = 43,
-	ROCKET_COMPLETE_NOW_LAUNCH_FROM_PAD = 44,
-	JOINED_A_FACTION = 45,
-	VENTURE_FACTION = 46,
-	ASSEMBLY_FACTION = 47,
-	PARADOX_FACTION = 48,
-	SENTINEL_FACTION = 49,
-	LUP_WORLD_ACCESS = 50,
-	AG_FIRST_FLAG_COLLECTED = 51,
-	TOOLTIP_TALK_TO_SKYLAND_TO_GET_HAT = 52,
-	MODULAR_BUILD_PLAYER_PLACES_FIRST_MODEL_IN_SCRATCH = 53,
-	MODULAR_BUILD_FIRST_ARROW_DISPLAY_FOR_MODULE = 54,
-	AG_BEACON_QB_SO_THE_PLAYER_CAN_ALWAYS_BUILD_THEM = 55,
-	GF_PET_DIG_FLAG_1 = 56,
-	GF_PET_DIG_FLAG_2 = 57,
-	GF_PET_DIG_FLAG_3 = 58,
-	SUPPRESS_SPACESHIP_CINEMATIC_FLYTHROUGH = 59,
-	GF_PLAYER_FALL_DEATH = 60,
-	GF_PLAYER_CAN_GET_FLAG_1 = 61,
-	GF_PLAYER_CAN_GET_FLAG_2 = 62,
-	GF_PLAYER_CAN_GET_FLAG_3 = 63,
-	ENTER_BBB_FROM_PROPERTY_EDIT_CONFIRMATION_DIALOG = 64,
-	AG_FIRST_COMBAT_COMPLETE = 65,
-	AG_COMPLETE_BOB_MISSION = 66,
-	FIRST_MANUAL_PET_HIBERNATE = 69,
-	CAGED_SPIDER = 74,
-	IS_NEWS_SCREEN_VISIBLE = 114,
-	NJ_GARMADON_CINEMATIC_SEEN = 125,
-	EQUPPED_TRIAL_FACTION_GEAR = 126,
-	ELEPHANT_PET_3050 = 801,
-	CAT_PET_3054 = 803,
-	TRICERATOPS_PET_3195 = 806,
-	TERRIER_PET_3254 = 807,
-	SKUNK_PET_3261 = 811,
-	BUNNY_PET_3672 = 813,
-	CROCODILE_PET_3994 = 814,
-	DOBERMAN_PET_5635 = 815,
-	BUFFALO_PET_5636 = 816,
-	ROBOT_DOG_PET_5637 = 818,
-	RED_DRAGON_PET_5639 = 819,
-	TORTOISE_PET_5640 = 820,
-	GREEN_DRAGON_PET_5641 = 821,
-	PANDA_PET_5643 = 822,
-	MANTIS_PET_5642 = 823,
-	WARTHOG_PET_6720 = 824,
-	LION_PET_3520 = 825,
-	GOAT_PET_7638 = 818,
-	CRAB_PET_7694 = 827,
-	REINDEER_PET_12294 = 829,
-	STEGOSAURUS_PET_12431 = 830,
-	SABER_CAT_PET_12432 = 831,
-	GRYPHON_PET_12433 = 832,
-	ALINE_PET_12334 = 833,
-	UNKNOWN_PET = 834,
-	EARTH_DRAGON_PET_16210 = 836,
-	SKELETON_DRAGON_PET_13067 = 838,
-	AG_SPACE_SHIP_BINOC_AT_LAUNCH = 1001,
-	AG_SPACE_SHIP_BINOC_AT_LAUNCH_PLATFORM = 1002,
-	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_LEFT_OF_START = 1003,
-	AG_SPACE_SHIP_BINOC_ON_PLATFORM_TO_RIGHT_OF_START = 1004,
-	AG_SPACE_SHIP_BINOC_AT_BOB = 1005,
-	AG_BATTLE_BINOC_FOR_TRICERETOPS = 1101,
-	AG_BATTLE_BINOC_AT_PARADOX = 1102,
-	AG_BATTLE_BINOC_AT_MISSION_GIVER = 1103,
-	AG_BATTLE_BINOC_AT_BECK = 1104,
-	AG_MONUMENT_BINOC_INTRO = 1105,
-	AG_MONUMENT_BINOC_OUTRO = 1106,
-	AG_LAUNCH_BINOC_INTRO = 1107,
-	AG_LAUNCH_BINOC_BISON = 1108,
-	AG_LAUNCH_BINOC_SHARK = 1109,
-	NS_BINOC_CONCERT_TRANSITION = 1201,
-	NS_BINOC_RACE_PLACE_TRANSITION = 1202,
-	NS_BINOC_BRICK_ANNEX_TRANSITION = 1203,
-	NS_BINOC_GF_LAUNCH = 1204,
-	NS_BINOC_FV_LAUNCH = 1205,
-	NS_BINOC_BRICK_ANNEX_WATER = 1206,
-	NS_BINOC_AG_LAUNCH_AT_RACE_PLACE = 1207,
-	NS_BINOC_AG_LAUNCH_AT_BRICK_ANNEX = 1208,
-	NS_BINOC_AG_LAUNCH_AT_PLAZA = 1209,
-	NS_BINOC_TBA = 1210,
-	NS_FLAG_COLLECTABLE_1_BY_JONNY_THUNDER = 1211,
-	NS_FLAG_COLLECTABLE_2_UNDER_CONCERT_BRIDGE = 1212,
-	NS_FLAG_COLLECTABLE_3_BY_FV_LAUNCH = 1213,
-	NS_FLAG_COLLECTABLE_4_IN_PLAZA_BEHIND_BUILDING = 1214,
-	NS_FLAG_COLLECTABLE_5_BY_GF_LAUNCH = 1215,
-	NS_FLAG_COLLECTABLE_6_BY_DUCK_SG = 1216,
-	NS_FLAG_COLLECTABLE_7_BY_LUP_LAUNCH = 1217,
-	NS_FLAG_COLLECTABLE_8_BY_NT_LUANCH = 1218,
-	NS_FLAG_COLLECTABLE_9_BY_RACE_BUILD = 1219,
-	NS_FLAG_COLLECTABLE_10_ON_AG_LAUNCH_PATH = 1220,
-	PR_BINOC_AT_LAUNCH_PAD = 1251,
-	PR_BINOC_AT_BEGINNING_OF_ISLAND_B = 1252,
-	PR_BINOC_AT_FIRST_PET_BOUNCER = 1253,
-	PR_BINOC_ON_BY_CROWS_NEST = 1254,
-	PR_PET_DIG_AT_BEGINNING_OF_ISLAND_B = 1261,
-	PR_PET_DIG_AT_THE_LOCATION_OF_OLD_BOUNCE_BACK = 1262,
-	PR_PET_DIG_UNDER_QB_BRIDGE = 1263,
-	PR_PET_DIG_BACK_SIDE_BY_PARTNER_BOUNCE = 1264,
-	PR_PET_DIG_BY_LAUNCH_PAD = 1265,
-	PR_PET_DIG_BY_FIRST_PET_BOUNCER = 1266,
-	GF_BINOC_ON_LANDING_PAD = 1301,
-	GF_BINOC_AT_RAVINE_START = 1302,
-	GF_BINOC_ON_TOP_OF_RAVINE_HEAD = 1303,
-	GF_BINOC_AT_TURTLE_AREA = 1304,
-	GF_BINOC_IN_TUNNEL_TO_ELEPHANTS = 1305,
-	GF_BINOC_IN_ELEPHANTS_AREA = 1306,
-	GF_BINOC_IN_RACING_AREA = 1307,
-	GF_BINOC_IN_CROC_AREA = 1308,
-	GF_BINOC_IN_JAIL_AREA = 1309,
-	GF_BINOC_TELESCOPE_NEXT_TO_CAPTAIN_JACK = 1310,
-	NT_HEART_OF_DARKNESS = 1911,
-	NT_PLINTH_REBUILD = 1919,
-	NT_FACTION_SPY_DUKE = 1974,
-	NT_FACTION_SPY_OVERBUILD = 1976,
-	NT_FACTION_SPY_HAEL = 1977,
-	NJ_EARTH_SPINJITZU = 2030,
-	NJ_LIGHTNING_SPINJITZU = 2031,
-	NJ_ICE_SPINJITZU = 2032,
-	NJ_FIRE_SPINJITZU = 2033,
-	NJ_WU_SHOW_DAILY_CHEST = 2099
-};
-
-#endif  //!__EPLAYERFLAG__H__

dCommon/dEnums/eQuickBuildFailReason.h

@@ -1,13 +0,0 @@
-#ifndef __EQUICKBUILDFAILREASON__H__
-#define __EQUICKBUILDFAILREASON__H__
-
-#include <cstdint>
-
-enum class eQuickBuildFailReason : uint32_t {
-	NOT_GIVEN,
-	OUT_OF_IMAGINATION,
-	CANCELED_EARLY,
-	BUILD_ENDED
-};
-
-#endif  //!__EQUICKBUILDFAILREASON__H__

dCommon/dEnums/eRacingTaskParam.h

@@ -1,25 +0,0 @@
-#pragma once
-
-#ifndef __ERACINGTASKPARAM__H__
-#define __ERACINGTASKPARAM__H__
-
-#include <cstdint>
-
-enum class eRacingTaskParam : int32_t {
-	FINISH_WITH_PLACEMENT = 1,
-	LAP_TIME,
-	TOTAL_TRACK_TIME,
-	COMPLETE_ANY_RACING_TASK,
-	COMPLETE_TRACK_TASKS,
-	MODULAR_BUILDING,
-	SAFE_DRIVER = 10,
-	SMASHABLES,
-	COLLECT_IMAGINATION,
-	COMPETED_IN_RACE,
-	WIN_RACE_IN_WORLD,
-	FIRST_PLACE_MULTIPLE_TRACKS,
-	LAST_PLACE_FINISH,
-	SMASH_SPECIFIC_SMASHABLE
-};
-
-#endif  //!__ERACINGTASKPARAM__H__

dCommon/dEnums/eRebuildState.h

@@ -1,15 +0,0 @@
-#ifndef __EREBUILDSTATE__H__
-#define __EREBUILDSTATE__H__
-
-#include <cstdint>
-
-enum class eRebuildState : uint32_t {
-	OPEN,
-	COMPLETED = 2,
-	RESETTING = 4,
-	BUILDING,
-	INCOMPLETE
-};
-
-
-#endif  //!__EREBUILDSTATE__H__

dCommon/dEnums/eRenameResponse.h

@@ -1,15 +0,0 @@
-#ifndef __ERENAMERESPONSE__H__
-#define __ERENAMERESPONSE__H__
-
-#include <cstdint>
-
-//! An enum for character rename responses
-enum class eRenameResponse : uint8_t {
-	SUCCESS = 0,
-	UNKNOWN_ERROR,
-	NAME_UNAVAILABLE,
-	NAME_IN_USE
-};
-
-
-#endif  //!__ERENAMERESPONSE__H__

dCommon/dEnums/eReplicaComponentType.h

@@ -1,127 +0,0 @@
-#ifndef __EREPLICACOMPONENTTYPE__H__
-#define __EREPLICACOMPONENTTYPE__H__
-
-#include <cstdint>
-
-enum class eReplicaComponentType : uint32_t {
-	INVALID = 0,
-	CONTROLLABLE_PHYSICS,
-	RENDER,
-	SIMPLE_PHYSICS,
-	CHARACTER,
-	SCRIPT,
-	BOUNCER,
-	BUFF, // buff is really 98, this is DESTROYABLE
-	GHOST,
-	SKILL,
-	SPAWNER,
-	ITEM,
-	REBUILD,
-	REBUILD_START,
-	REBUILD_ACTIVATOR,
-	ICON_ONLY,
-	VENDOR,
-	INVENTORY,
-	PROJECTILE_PHYSICS,
-	SHOOTING_GALLERY,
-	RIGID_BODY_PHANTOM_PHYSICS,
-	DROP_EFFECT,
-	CHEST,
-	COLLECTIBLE,
-	BLUEPRINT,
-	MOVING_PLATFORM,
-	PET,
-	PLATFORM_BOUNDARY,
-	MODULE,
-	ARCADE,
-	VEHICLE_PHYSICS, // Havok demo based
-	MOVEMENT_AI,
-	EXHIBIT,
-	OVERHEAD_ICON,
-	PET_CONTROL,
-	MINIFIG,
-	PROPERTY,
-	PET_CREATOR,
-	MODEL_BUILDER,
-	SCRIPTED_ACTIVITY,
-	PHANTOM_PHYSICS,
-	SPRINGPAD,
-	MODEL,
-	PROPERTY_ENTRANCE,
-	FX,
-	PROPERTY_MANAGEMENT,
-	VEHICLE_PHYSICS_NEW, // internal physics based on havok
-	PHYSICS_SYSTEM,
-	QUICK_BUILD,
-	SWITCH,
-	ZONE_CONTROL, // Minigame
-	CHANGLING,
-	CHOICE_BUILD,
-	PACKAGE,
-	SOUND_REPEATER,
-	SOUND_AMBIENT_2D,
-	SOUND_AMBIENT_3D,
-	PRECONDITION,
-	PLAYER_FLAG,
-	CUSTOM_BUILD_ASSEMBLY,
-	BASE_COMBAT_AI,
-	MODULE_ASSEMBLY,
-	SHOWCASE_MODEL_HANDLER,
-	RACING_MODULE,
-	GENERIC_ACTIVATOR,
-	PROPERTY_VENDOR,
-	HF_LIGHT_DIRECTION_GADGET,
-	ROCKET_LAUNCH,
-	ROCKET_LANDING,
-	TRIGGER,
-	DROPPED_LOOT,
-	RACING_CONTROL,
-	FACTION_TRIGGER,
-	MISSION_OFFER,
-	RACING_STATS,
-	LUP_EXHIBIT,
-	BBB,
-	SOUND_TRIGGER,
-	PROXIMITY_MONITOR,
-	RACING_SOUND_TRIGGER,
-	CHAT,
-	FRIENDS_LIST,
-	GUILD,
-	LOCAL_SYSTEM,
-	MISSION,
-	MUTABLE_MODEL_BEHAVIORS,
-	PATHFINDING,
-	PET_TAMING_CONTROL,
-	PROPERTY_EDITOR,
-	SKINNED_RENDER,
-	SLASH_COMMAND,
-	STATUS_EFFECT,
-	TEAMS,
-	TEXT_EFFECT,
-	TRADE,
-	USER_CONTROL,
-	IGNORE_LIST,
-	ROCKET_LAUNCH_LUP,
-	BUFF_REAL, // the real buff component, should just be name BUFF
-	INTERACTION_MANAGER,
-	DONATION_VENDOR,
-	COMBAT_MEDIATOR,
-	COMMENDATION_VENDOR,
-	UNKNOWN_103,
-	RAIL_ACTIVATOR,
-	ROLLER,
-	PLAYER_FORCED_MOVEMENT,
-	CRAFTING,
-	POSSESSABLE,
-	LEVEL_PROGRESSION,
-	POSSESSOR,
-	MOUNT_CONTROL,
-	UNKNOWN_112,
-	PROPERTY_PLAQUE,
-	BUILD_BORDER,
-	UNKOWN_115,
-	CULLING_PLANE,
-	DESTROYABLE = 1000 // Actually 7
-};
-
-#endif  //!__EREPLICACOMPONENTTYPE__H__

dCommon/dEnums/eReplicaPacketType.h

@@ -1,12 +0,0 @@
-#ifndef __EREPLICAPACKETTYPE__H__
-#define __EREPLICAPACKETTYPE__H__
-
-#include <cstdint>
-
-enum class eReplicaPacketType : uint8_t {
-	CONSTRUCTION,
-	SERIALIZATION,
-	DESTRUCTION
-};
-
-#endif  //!__EREPLICAPACKETTYPE__H__

dCommon/dEnums/eServerDisconnectIdentifiers.h

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

dCommon/dEnums/eServerMessageType.h

@@ -1,12 +0,0 @@
-#ifndef __ESERVERMESSAGETYPE__H__
-#define __ESERVERMESSAGETYPE__H__
-
-#include <cstdint>
-//! The Internal Server Packet Identifiers
-enum class eServerMessageType : uint32_t {
-	VERSION_CONFIRM = 0,
-	DISCONNECT_NOTIFY,
-	GENERAL_NOTIFY
-};
-
-#endif  //!__ESERVERMESSAGETYPE__H__

dCommon/dEnums/eStateChangeType.h

@@ -1,11 +0,0 @@
-#ifndef __ESTATECHANGETYPE__H__
-#define __ESTATECHANGETYPE__H__
-
-#include <cstdint>
-
-enum class eStateChangeType : uint32_t {
-	PUSH,
-	POP
-};
-
-#endif  //!__ESTATECHANGETYPE__H__

dCommon/dEnums/eTerminateType.h

@@ -1,12 +0,0 @@
-#ifndef __ETERMINATETYPE__H__
-#define __ETERMINATETYPE__H__
-
-#include <cstdint>
-
-enum class eTerminateType : uint32_t {
-	RANGE,
-	USER,
-	FROM_INTERACTION
-};
-
-#endif  //!__ETERMINATETYPE__H__

dCommon/dEnums/eTriggerCommandType.h

@@ -1,119 +0,0 @@
-#ifndef __ETRIGGERCOMMANDTYPE__H__
-#define __ETRIGGERCOMMANDTYPE__H__
-
-// For info about Trigger Command see:
-// https://docs.lu-dev.net/en/latest/file-structures/lutriggers.html?highlight=trigger#possible-values-commands
-
-enum class eTriggerCommandType {
-	INVALID,
-	ZONE_PLAYER,
-	FIRE_EVENT,
-	DESTROY_OBJ,
-	TOGGLE_TRIGGER,
-	RESET_REBUILD,
-	SET_PATH,
-	SET_PICK_TYPE,
-	MOVE_OBJECT,
-	ROTATE_OBJECT,
-	PUSH_OBJECT,
-	REPEL_OBJECT,
-	SET_TIMER,
-	CANCEL_TIMER,
-	PLAY_CINEMATIC,
-	TOGGLE_BBB,
-	UPDATE_MISSION,
-	SET_BOUNCER_STATE,
-	BOUNCE_ALL_ON_BOUNCER,
-	TURN_AROUND_ON_PATH,
-	GO_FORWARD_ON_PATH,
-	GO_BACKWARD_ON_PATH,
-	STOP_PATHING,
-	START_PATHING,
-	LOCK_OR_UNLOCK_CONTROLS,
-	PLAY_EFFECT,
-	STOP_EFFECT,
-	ACTIVATE_MUSIC_CUE,
-	DEACTIVATE_MUSIC_CUE,
-	FLASH_MUSIC_CUE,
-	SET_MUSIC_PARAMETER,
-	PLAY_2D_AMBIENT_SOUND,
-	STOP_2D_AMBIENT_SOUND,
-	PLAY_3D_AMBIENT_SOUND,
-	STOP_3D_AMBIENT_SOUND,
-	ACTIVATE_MIXER_PROGRAM,
-	DEACTIVATE_MIXER_PROGRAM,
-	CAST_SKILL,
-	DISPLAY_ZONE_SUMMARY,
-	SET_PHYSICS_VOLUME_EFFECT,
-	SET_PHYSICS_VOLUME_STATUS,
-	SET_MODEL_TO_BUILD,
-	SPAWN_MODEL_BRICKS,
-	ACTIVATE_SPAWNER_NETWORK,
-	DEACTIVATE_SPAWNER_NETWORK,
-	RESET_SPAWNER_NETWORK,
-	DESTROY_SPAWNER_NETWORK_OBJECTS,
-	GO_TO_WAYPOINT,
-	ACTIVATE_PHYSICS
-};
-
-
-class TriggerCommandType {
-public:
-	static eTriggerCommandType StringToTriggerCommandType(std::string commandString) {
-		const std::map<std::string, eTriggerCommandType> TriggerCommandMap = {
-			{ "zonePlayer", eTriggerCommandType::ZONE_PLAYER},
-			{ "fireEvent", eTriggerCommandType::FIRE_EVENT},
-			{ "destroyObj", eTriggerCommandType::DESTROY_OBJ},
-			{ "toggleTrigger", eTriggerCommandType::TOGGLE_TRIGGER},
-			{ "resetRebuild", eTriggerCommandType::RESET_REBUILD},
-			{ "setPath", eTriggerCommandType::SET_PATH},
-			{ "setPickType", eTriggerCommandType::SET_PICK_TYPE},
-			{ "moveObject", eTriggerCommandType::MOVE_OBJECT},
-			{ "rotateObject", eTriggerCommandType::ROTATE_OBJECT},
-			{ "pushObject", eTriggerCommandType::PUSH_OBJECT},
-			{ "repelObject", eTriggerCommandType::REPEL_OBJECT},
-			{ "setTimer", eTriggerCommandType::SET_TIMER},
-			{ "cancelTimer", eTriggerCommandType::CANCEL_TIMER},
-			{ "playCinematic", eTriggerCommandType::PLAY_CINEMATIC},
-			{ "toggleBBB", eTriggerCommandType::TOGGLE_BBB},
-			{ "updateMission", eTriggerCommandType::UPDATE_MISSION},
-			{ "setBouncerState", eTriggerCommandType::SET_BOUNCER_STATE},
-			{ "bounceAllOnBouncer", eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER},
-			{ "turnAroundOnPath", eTriggerCommandType::TURN_AROUND_ON_PATH},
-			{ "goForwardOnPath", eTriggerCommandType::GO_FORWARD_ON_PATH},
-			{ "goBackwardOnPath", eTriggerCommandType::GO_BACKWARD_ON_PATH},
-			{ "stopPathing", eTriggerCommandType::STOP_PATHING},
-			{ "startPathing", eTriggerCommandType::START_PATHING},
-			{ "LockOrUnlockControls", eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS},
-			{ "PlayEffect", eTriggerCommandType::PLAY_EFFECT},
-			{ "StopEffect", eTriggerCommandType::STOP_EFFECT},
-			{ "activateMusicCue", eTriggerCommandType::ACTIVATE_MUSIC_CUE},
-			{ "deactivateMusicCue", eTriggerCommandType::DEACTIVATE_MUSIC_CUE},
-			{ "flashMusicCue", eTriggerCommandType::FLASH_MUSIC_CUE},
-			{ "setMusicParameter", eTriggerCommandType::SET_MUSIC_PARAMETER},
-			{ "play2DAmbientSound", eTriggerCommandType::PLAY_2D_AMBIENT_SOUND},
-			{ "stop2DAmbientSound", eTriggerCommandType::STOP_2D_AMBIENT_SOUND},
-			{ "play3DAmbientSound", eTriggerCommandType::PLAY_3D_AMBIENT_SOUND},
-			{ "stop3DAmbientSound", eTriggerCommandType::STOP_3D_AMBIENT_SOUND},
-			{ "activateMixerProgram", eTriggerCommandType::ACTIVATE_MIXER_PROGRAM},
-			{ "deactivateMixerProgram", eTriggerCommandType::DEACTIVATE_MIXER_PROGRAM},
-			{ "CastSkill", eTriggerCommandType::CAST_SKILL},
-			{ "displayZoneSummary", eTriggerCommandType::DISPLAY_ZONE_SUMMARY},
-			{ "SetPhysicsVolumeEffect", eTriggerCommandType::SET_PHYSICS_VOLUME_EFFECT},
-			{ "SetPhysicsVolumeStatus", eTriggerCommandType::SET_PHYSICS_VOLUME_STATUS},
-			{ "setModelToBuild", eTriggerCommandType::SET_MODEL_TO_BUILD},
-			{ "spawnModelBricks", eTriggerCommandType::SPAWN_MODEL_BRICKS},
-			{ "ActivateSpawnerNetwork", eTriggerCommandType::ACTIVATE_SPAWNER_NETWORK},
-			{ "DeactivateSpawnerNetwork", eTriggerCommandType::DEACTIVATE_SPAWNER_NETWORK},
-			{ "ResetSpawnerNetwork", eTriggerCommandType::RESET_SPAWNER_NETWORK},
-			{ "DestroySpawnerNetworkObjects", eTriggerCommandType::DESTROY_SPAWNER_NETWORK_OBJECTS},
-			{ "Go_To_Waypoint", eTriggerCommandType::GO_TO_WAYPOINT},
-			{ "ActivatePhysics", eTriggerCommandType::ACTIVATE_PHYSICS}
-		};
-
-		auto intermed = TriggerCommandMap.find(commandString);
-		return (intermed != TriggerCommandMap.end()) ? intermed->second : eTriggerCommandType::INVALID;
-	};
-};
-
-#endif  //!__ETRIGGERCOMMANDTYPE__H__

dCommon/dEnums/eTriggerEventType.h

@@ -1,53 +0,0 @@
-#ifndef __ETRIGGEREVENTTYPE__H__
-#define __ETRIGGEREVENTTYPE__H__
-
-enum class eTriggerEventType {
-	INVALID,
-	DESTROY,
-	CUSTOM_EVENT,
-	ENTER,
-	EXIT,
-	CREATE,
-	HIT,
-	TIMER_DONE,
-	REBUILD_COMPLETE,
-	ACTIVATED,
-	DEACTIVATED,
-	ARRIVED,
-	ARRIVED_AT_END_OF_PATH,
-	ZONE_SUMMARY_DISMISSED,
-	ARRIVED_AT_DESIRED_WAYPOINT,
-	PET_ON_SWITCH,
-	PET_OFF_SWITCH,
-	INTERACT
-};
-
-class TriggerEventType {
-public:
-	static eTriggerEventType StringToTriggerEventType(std::string commandString) {
-		const std::map<std::string, eTriggerEventType> TriggerEventMap = {
-			{"OnDestroy", eTriggerEventType::DESTROY},
-			{"OnCustomEvent", eTriggerEventType::CUSTOM_EVENT},
-			{"OnEnter", eTriggerEventType::ENTER},
-			{"OnExit", eTriggerEventType::EXIT},
-			{"OnCreate", eTriggerEventType::CREATE},
-			{"OnHit", eTriggerEventType::HIT},
-			{"OnTimerDone", eTriggerEventType::TIMER_DONE},
-			{"OnRebuildComplete", eTriggerEventType::REBUILD_COMPLETE},
-			{"OnActivated", eTriggerEventType::ACTIVATED},
-			{"OnDectivated", eTriggerEventType::DEACTIVATED}, // Dectivated vs Deactivated
-			{"OnArrived", eTriggerEventType::ARRIVED},
-			{"OnArrivedAtEndOfPath", eTriggerEventType::ARRIVED_AT_END_OF_PATH},
-			{"OnZoneSummaryDismissed", eTriggerEventType::ZONE_SUMMARY_DISMISSED},
-			{"OnArrivedAtDesiredWaypoint", eTriggerEventType::ARRIVED_AT_DESIRED_WAYPOINT},
-			{"OnPetOnSwitch", eTriggerEventType::PET_ON_SWITCH},
-			{"OnPetOffSwitch", eTriggerEventType::PET_OFF_SWITCH},
-			{"OnInteract", eTriggerEventType::INTERACT},
-		};
-
-		auto intermed = TriggerEventMap.find(commandString);
-		return (intermed != TriggerEventMap.end()) ? intermed->second : eTriggerEventType::INVALID;
-	};
-};
-
-#endif  //!__ETRIGGEREVENTTYPE__H__

dCommon/dEnums/eUseItemResponse.h

@@ -1,12 +0,0 @@
-#ifndef __EUSEITEMRESPONSE__H__
-#define __EUSEITEMRESPONSE__H__
-
-#include <cstdint>
-
-enum class eUseItemResponse : uint32_t {
-	NoImaginationForPet = 1,
-	FailedPrecondition,
-	MountsNotAllowed
-};
-
-#endif  //!__EUSEITEMRESPONSE__H__

dCommon/dEnums/eWorldMessageType.h

@@ -1,42 +0,0 @@
-#ifndef __EWORLDMESSAGETYPE__H__
-#define __EWORLDMESSAGETYPE__H__
-
-#include <cstdint>
-
-enum class eWorldMessageType : uint32_t {
-	VALIDATION = 1,  // 				Session info
-	CHARACTER_LIST_REQUEST,
-	CHARACTER_CREATE_REQUEST,
-	LOGIN_REQUEST,  // 			Character selected
-	GAME_MSG,
-	CHARACTER_DELETE_REQUEST,
-	CHARACTER_RENAME_REQUEST,
-	HAPPY_FLOWER_MODE_NOTIFY,
-	SLASH_RELOAD_MAP,  // 			Reload map cmp
-	SLASH_PUSH_MAP_REQUEST,  // 	Push map req cmd
-	SLASH_PUSH_MAP,  // 			Push map cmd
-	SLASH_PULL_MAP,  // 			Pull map cmd
-	LOCK_MAP_REQUEST,
-	GENERAL_CHAT_MESSAGE,  // 		General chat message
-	HTTP_MONITOR_INFO_REQUEST,
-	SLASH_DEBUG_SCRIPTS,  // 		Debug scripts cmd
-	MODELS_CLEAR,
-	EXHIBIT_INSERT_MODEL,
-	LEVEL_LOAD_COMPLETE,  // 		Character data request
-	TMP_GUILD_CREATE,
-	ROUTE_PACKET,  // 				Social?
-	POSITION_UPDATE,
-	MAIL,
-	WORD_CHECK, // 				Whitelist word check
-	STRING_CHECK,  // 				Whitelist string check
-	GET_PLAYERS_IN_ZONE,
-	REQUEST_UGC_MANIFEST_INFO,
-	BLUEPRINT_GET_ALL_DATA_REQUEST,
-	CANCEL_MAP_QUEUE,
-	HANDLE_FUNNESS,
-	FAKE_PRG_CSR_MESSAGE,
-	REQUEST_FREE_TRIAL_REFRESH,
-	GM_SET_FREE_TRIAL_STATUS
-};
-
-#endif  //!__EWORLDMESSAGETYPE__H__

dDatabase/CDClientManager.cpp

@@ -1,80 +1,46 @@
 #include "CDClientManager.h"
-#include "CDActivityRewardsTable.h"
-#include "CDAnimationsTable.h"
-#include "CDBehaviorParameterTable.h"
-#include "CDBehaviorTemplateTable.h"
-#include "CDComponentsRegistryTable.h"
-#include "CDCurrencyTableTable.h"
-#include "CDDestructibleComponentTable.h"
-#include "CDEmoteTable.h"
-#include "CDInventoryComponentTable.h"
-#include "CDItemComponentTable.h"
-#include "CDItemSetsTable.h"
-#include "CDItemSetSkillsTable.h"
-#include "CDLevelProgressionLookupTable.h"
-#include "CDLootMatrixTable.h"
-#include "CDLootTableTable.h"
-#include "CDMissionNPCComponentTable.h"
-#include "CDMissionTasksTable.h"
-#include "CDMissionsTable.h"
-#include "CDObjectSkillsTable.h"
-#include "CDObjectsTable.h"
-#include "CDPhysicsComponentTable.h"
-#include "CDRebuildComponentTable.h"
-#include "CDScriptComponentTable.h"
-#include "CDSkillBehaviorTable.h"
-#include "CDZoneTableTable.h"
-#include "CDVendorComponentTable.h"
-#include "CDActivitiesTable.h"
-#include "CDPackageComponentTable.h"
-#include "CDProximityMonitorComponentTable.h"
-#include "CDMovementAIComponentTable.h"
-#include "CDBrickIDTableTable.h"
-#include "CDRarityTableTable.h"
-#include "CDMissionEmailTable.h"
-#include "CDRewardsTable.h"
-#include "CDPropertyEntranceComponentTable.h"
-#include "CDPropertyTemplateTable.h"
-#include "CDFeatureGatingTable.h"
-#include "CDRailActivatorComponent.h"
 
-CDClientManager::CDClientManager() {
-	CDActivityRewardsTable::Instance();
-	UNUSED(CDAnimationsTable::Instance());
-	CDBehaviorParameterTable::Instance();
-	CDBehaviorTemplateTable::Instance();
-	CDComponentsRegistryTable::Instance();
-	CDCurrencyTableTable::Instance();
-	CDDestructibleComponentTable::Instance();
-	CDEmoteTableTable::Instance();
-	CDInventoryComponentTable::Instance();
-	CDItemComponentTable::Instance();
-	CDItemSetsTable::Instance();
-	CDItemSetSkillsTable::Instance();
-	CDLevelProgressionLookupTable::Instance();
-	CDLootMatrixTable::Instance();
-	CDLootTableTable::Instance();
-	CDMissionNPCComponentTable::Instance();
-	CDMissionTasksTable::Instance();
-	CDMissionsTable::Instance();
-	CDObjectSkillsTable::Instance();
-	CDObjectsTable::Instance();
-	CDPhysicsComponentTable::Instance();
-	CDRebuildComponentTable::Instance();
-	CDScriptComponentTable::Instance();
-	CDSkillBehaviorTable::Instance();
-	CDZoneTableTable::Instance();
-	CDVendorComponentTable::Instance();
-	CDActivitiesTable::Instance();
-	CDPackageComponentTable::Instance();
-	CDProximityMonitorComponentTable::Instance();
-	CDMovementAIComponentTable::Instance();
-	CDBrickIDTableTable::Instance();
-	CDRarityTableTable::Instance();
-	CDMissionEmailTable::Instance();
-	CDRewardsTable::Instance();
-	CDPropertyEntranceComponentTable::Instance();
-	CDPropertyTemplateTable::Instance();
-	CDFeatureGatingTable::Instance();
-	CDRailActivatorComponentTable::Instance();
+// Static Variables
+CDClientManager* CDClientManager::m_Address = nullptr;
+
+//! Initializes the manager
+void CDClientManager::Initialize(void) {
+	tables.insert(std::make_pair("ActivityRewards", new CDActivityRewardsTable()));
+	UNUSED(tables.insert(std::make_pair("Animations", new CDAnimationsTable())));
+	tables.insert(std::make_pair("BehaviorParameter", new CDBehaviorParameterTable()));
+	tables.insert(std::make_pair("BehaviorTemplate", new CDBehaviorTemplateTable()));
+	tables.insert(std::make_pair("ComponentsRegistry", new CDComponentsRegistryTable()));
+	tables.insert(std::make_pair("CurrencyTable", new CDCurrencyTableTable()));
+	tables.insert(std::make_pair("DestructibleComponent", new CDDestructibleComponentTable()));
+	tables.insert(std::make_pair("EmoteTable", new CDEmoteTableTable()));
+	tables.insert(std::make_pair("InventoryComponent", new CDInventoryComponentTable()));
+	tables.insert(std::make_pair("ItemComponent", new CDItemComponentTable()));
+	tables.insert(std::make_pair("ItemSets", new CDItemSetsTable()));
+	tables.insert(std::make_pair("ItemSetSkills", new CDItemSetSkillsTable()));
+	tables.insert(std::make_pair("LevelProgressionLookup", new CDLevelProgressionLookupTable()));
+	tables.insert(std::make_pair("LootMatrix", new CDLootMatrixTable()));
+	tables.insert(std::make_pair("LootTable", new CDLootTableTable()));
+	tables.insert(std::make_pair("MissionNPCComponent", new CDMissionNPCComponentTable()));
+	tables.insert(std::make_pair("MissionTasks", new CDMissionTasksTable()));
+	tables.insert(std::make_pair("Missions", new CDMissionsTable()));
+	tables.insert(std::make_pair("ObjectSkills", new CDObjectSkillsTable()));
+	tables.insert(std::make_pair("Objects", new CDObjectsTable()));
+	tables.insert(std::make_pair("PhysicsComponent", new CDPhysicsComponentTable()));
+	tables.insert(std::make_pair("RebuildComponent", new CDRebuildComponentTable()));
+	tables.insert(std::make_pair("ScriptComponent", new CDScriptComponentTable()));
+	tables.insert(std::make_pair("SkillBehavior", new CDSkillBehaviorTable()));
+	tables.insert(std::make_pair("ZoneTable", new CDZoneTableTable()));
+	tables.insert(std::make_pair("VendorComponent", new CDVendorComponentTable()));
+	tables.insert(std::make_pair("Activities", new CDActivitiesTable()));
+	tables.insert(std::make_pair("PackageComponent", new CDPackageComponentTable()));
+	tables.insert(std::make_pair("ProximityMonitorComponent", new CDProximityMonitorComponentTable()));
+	tables.insert(std::make_pair("MovementAIComponent", new CDMovementAIComponentTable()));
+	tables.insert(std::make_pair("BrickIDTable", new CDBrickIDTableTable()));
+	tables.insert(std::make_pair("RarityTable", new CDRarityTableTable()));
+	tables.insert(std::make_pair("MissionEmail", new CDMissionEmailTable()));
+	tables.insert(std::make_pair("Rewards", new CDRewardsTable()));
+	tables.insert(std::make_pair("PropertyEntranceComponent", new CDPropertyEntranceComponentTable()));
+	tables.insert(std::make_pair("PropertyTemplate", new CDPropertyTemplateTable()));
+	tables.insert(std::make_pair("FeatureGating", new CDFeatureGatingTable()));
+	tables.insert(std::make_pair("RailActivatorComponent", new CDRailActivatorComponentTable()));
 }

dDatabase/CDClientManager.h

@@ -1,24 +1,96 @@
 #pragma once
 
+// Custom Classes
 #include "CDTable.h"
 
-#include "Singleton.h"
+// Tables
+#include "CDActivityRewardsTable.h"
+#include "CDAnimationsTable.h"
+#include "CDBehaviorParameterTable.h"
+#include "CDBehaviorTemplateTable.h"
+#include "CDComponentsRegistryTable.h"
+#include "CDCurrencyTableTable.h"
+#include "CDDestructibleComponentTable.h"
+#include "CDEmoteTable.h"
+#include "CDInventoryComponentTable.h"
+#include "CDItemComponentTable.h"
+#include "CDItemSetsTable.h"
+#include "CDItemSetSkillsTable.h"
+#include "CDLevelProgressionLookupTable.h"
+#include "CDLootMatrixTable.h"
+#include "CDLootTableTable.h"
+#include "CDMissionNPCComponentTable.h"
+#include "CDMissionTasksTable.h"
+#include "CDMissionsTable.h"
+#include "CDObjectSkillsTable.h"
+#include "CDObjectsTable.h"
+#include "CDPhysicsComponentTable.h"
+#include "CDRebuildComponentTable.h"
+#include "CDScriptComponentTable.h"
+#include "CDSkillBehaviorTable.h"
+#include "CDZoneTableTable.h"
+#include "CDVendorComponentTable.h"
+#include "CDActivitiesTable.h"
+#include "CDPackageComponentTable.h"
+#include "CDProximityMonitorComponentTable.h"
+#include "CDMovementAIComponentTable.h"
+#include "CDBrickIDTableTable.h"
+#include "CDRarityTableTable.h"
+#include "CDMissionEmailTable.h"
+#include "CDRewardsTable.h"
+#include "CDPropertyEntranceComponentTable.h"
+#include "CDPropertyTemplateTable.h"
+#include "CDFeatureGatingTable.h"
+#include "CDRailActivatorComponent.h"
 
-/**
- * Initialize the CDClient tables so they are all loaded into memory.
+// C++
+#include <type_traits>
+#include <unordered_map>
+
+/*!
+  \file CDClientManager.hpp
+  \brief A manager for the CDClient tables
  */
-class CDClientManager : public Singleton<CDClientManager> {
-public:
-	CDClientManager();
 
-	/**
-	 * Fetch a table from CDClient
-	 * 
-	 * @tparam Table type to fetch
-	 * @return A pointer to the requested table.
+ //! Manages all data from the CDClient
+class CDClientManager {
+private:
+	static CDClientManager* m_Address;                 //!< The singleton address
+
+	std::unordered_map<std::string, CDTable*> tables;   //!< The tables
+
+public:
+
+	//! The singleton method
+	static CDClientManager* Instance() {
+		if (m_Address == 0) {
+			m_Address = new CDClientManager;
+		}
+
+		return m_Address;
+	}
+
+	//! Initializes the manager
+	void Initialize(void);
+
+	//! Fetches a CDClient table
+	/*!
+	  This function uses typename T which must be a subclass of CDTable.
+	  It returns the class that conforms to the class name
+
+	  \param tableName The table name
+	  \return The class or nullptr
 	 */
 	template<typename T>
-	T* GetTable() {
-		return &T::Instance();
+	T* GetTable(const std::string& tableName) {
+		static_assert(std::is_base_of<CDTable, T>::value, "T should inherit from CDTable!");
+
+		for (auto itr = this->tables.begin(); itr != this->tables.end(); ++itr) {
+			if (itr->first == tableName) {
+				return dynamic_cast<T*>(itr->second);
+			}
+		}
+
+		return nullptr;
 	}
 };

dDatabase/Tables/CDActivitiesTable.cpp

@@ -1,5 +1,6 @@
 #include "CDActivitiesTable.h"
 
+//! Constructor
 CDActivitiesTable::CDActivitiesTable(void) {
 
 	// First, get the size of the table
@@ -47,6 +48,15 @@ CDActivitiesTable::CDActivitiesTable(void) {
 	tableData.finalize();
 }
 
+//! Destructor
+CDActivitiesTable::~CDActivitiesTable(void) {}
+
+//! Returns the table's name
+std::string CDActivitiesTable::GetName(void) const {
+	return "Activities";
+}
+
+//! Queries the table with a custom "where" clause
 std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActivities)> predicate) {
 
 	std::vector<CDActivities> data = cpplinq::from(this->entries)
@@ -56,6 +66,7 @@ std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActiviti
 	return data;
 }
 
+//! Gets all the entries in the table
 std::vector<CDActivities> CDActivitiesTable::GetEntries(void) const {
 	return this->entries;
 }

dDatabase/Tables/CDActivitiesTable.h

@@ -3,6 +3,12 @@
 // Custom Classes
 #include "CDTable.h"
 
+/*!
+ \file CDActivitiesTable.hpp
+ \brief Contains data for the Activities table
+ */
+
+ //! Activities Entry Struct
 struct CDActivities {
 	unsigned int ActivityID;
 	unsigned int locStatus;
@@ -25,14 +31,36 @@ struct CDActivities {
 	float optionalPercentage;
 };
 
-class CDActivitiesTable : public CDTable<CDActivitiesTable> {
+
+//! Activities table
+class CDActivitiesTable : public CDTable {
 private:
 	std::vector<CDActivities> entries;
 
 public:
-	CDActivitiesTable();
-	// Queries the table with a custom "where" clause
+
+	//! Constructor
+	CDActivitiesTable(void);
+
+	//! Destructor
+	~CDActivitiesTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	  \param predicate The predicate
+	 */
 	std::vector<CDActivities> Query(std::function<bool(CDActivities)> predicate);
 
+	//! Gets all the entries in the table
+	/*!
+	  \return The entries
+	 */
 	std::vector<CDActivities> GetEntries(void) const;
+
 };

dDatabase/Tables/CDActivityRewardsTable.cpp

@@ -1,5 +1,6 @@
 #include "CDActivityRewardsTable.h"
 
+//! Constructor
 CDActivityRewardsTable::CDActivityRewardsTable(void) {
 
 	// First, get the size of the table
@@ -35,6 +36,15 @@ CDActivityRewardsTable::CDActivityRewardsTable(void) {
 	tableData.finalize();
 }
 
+//! Destructor
+CDActivityRewardsTable::~CDActivityRewardsTable(void) {}
+
+//! Returns the table's name
+std::string CDActivityRewardsTable::GetName(void) const {
+	return "ActivityRewards";
+}
+
+//! Queries the table with a custom "where" clause
 std::vector<CDActivityRewards> CDActivityRewardsTable::Query(std::function<bool(CDActivityRewards)> predicate) {
 
 	std::vector<CDActivityRewards> data = cpplinq::from(this->entries)
@@ -44,6 +54,7 @@ std::vector<CDActivityRewards> CDActivityRewardsTable::Query(std::function<bool(
 	return data;
 }
 
+//! Gets all the entries in the table
 std::vector<CDActivityRewards> CDActivityRewardsTable::GetEntries(void) const {
 	return this->entries;
 }

dDatabase/Tables/CDActivityRewardsTable.h

@@ -3,6 +3,12 @@
 // Custom Classes
 #include "CDTable.h"
 
+/*!
+ \file CDActivityRewardsTable.hpp
+ \brief Contains data for the ActivityRewards table
+ */
+
+ //! ActivityRewards Entry Struct
 struct CDActivityRewards {
 	unsigned int objectTemplate;        //!< The object template (?)
 	unsigned int ActivityRewardIndex;   //!< The activity reward index
@@ -13,15 +19,36 @@ struct CDActivityRewards {
 	std::string description;            //!< The description
 };
 
-class CDActivityRewardsTable : public CDTable<CDActivityRewardsTable> {
+
+//! ActivityRewards table
+class CDActivityRewardsTable : public CDTable {
 private:
 	std::vector<CDActivityRewards> entries;
 
 public:
-	CDActivityRewardsTable();
-	// Queries the table with a custom "where" clause
+
+	//! Constructor
+	CDActivityRewardsTable(void);
+
+	//! Destructor
+	~CDActivityRewardsTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	  \param predicate The predicate
+	 */
 	std::vector<CDActivityRewards> Query(std::function<bool(CDActivityRewards)> predicate);
 
+	//! Gets all the entries in the table
+	/*!
+	  \return The entries
+	 */
 	std::vector<CDActivityRewards> GetEntries(void) const;
 
 };

dDatabase/Tables/CDAnimationsTable.cpp

@@ -1,5 +1,6 @@
 #include "CDAnimationsTable.h"
 
+//! Constructor
 CDAnimationsTable::CDAnimationsTable(void) {
 
 	// First, get the size of the table
@@ -41,6 +42,15 @@ CDAnimationsTable::CDAnimationsTable(void) {
 	tableData.finalize();
 }
 
+//! Destructor
+CDAnimationsTable::~CDAnimationsTable(void) {}
+
+//! Returns the table's name
+std::string CDAnimationsTable::GetName(void) const {
+	return "Animations";
+}
+
+//! Queries the table with a custom "where" clause
 std::vector<CDAnimations> CDAnimationsTable::Query(std::function<bool(CDAnimations)> predicate) {
 
 	std::vector<CDAnimations> data = cpplinq::from(this->entries)
@@ -50,6 +60,7 @@ std::vector<CDAnimations> CDAnimationsTable::Query(std::function<bool(CDAnimatio
 	return data;
 }
 
+//! Gets all the entries in the table
 std::vector<CDAnimations> CDAnimationsTable::GetEntries(void) const {
 	return this->entries;
 }

dDatabase/Tables/CDAnimationsTable.h

@@ -3,6 +3,12 @@
 // Custom Classes
 #include "CDTable.h"
 
+/*!
+ \file CDAnimationsTable.hpp
+ \brief Contains data for the Animations table
+ */
+
+ //! Animations Entry Struct
 struct CDAnimations {
 	unsigned int animationGroupID;          //!< The animation group ID
 	std::string animation_type;        //!< The animation type
@@ -20,14 +26,35 @@ struct CDAnimations {
 };
 
 
-class CDAnimationsTable : public CDTable<CDAnimationsTable> {
+//! Animations table
+class CDAnimationsTable : public CDTable {
 private:
 	std::vector<CDAnimations> entries;
 
 public:
-	CDAnimationsTable();
-	// Queries the table with a custom "where" clause
+
+	//! Constructor
+	CDAnimationsTable(void);
+
+	//! Destructor
+	~CDAnimationsTable(void);
+
+	//! Returns the table's name
+	/*!
+	 \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	 \param predicate The predicate
+	 */
 	std::vector<CDAnimations> Query(std::function<bool(CDAnimations)> predicate);
 
+	//! Gets all the entries in the table
+	/*!
+	  \return The entries
+	 */
 	std::vector<CDAnimations> GetEntries(void) const;
+
 };

dDatabase/Tables/CDBehaviorParameterTable.cpp

@@ -1,6 +1,7 @@
 #include "CDBehaviorParameterTable.h"
 #include "GeneralUtils.h"
 
+//! Constructor
 CDBehaviorParameterTable::CDBehaviorParameterTable(void) {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BehaviorParameter");
 	uint32_t uniqueParameterId = 0;
@@ -27,6 +28,14 @@ CDBehaviorParameterTable::CDBehaviorParameterTable(void) {
 	tableData.finalize();
 }
 
+//! Destructor
+CDBehaviorParameterTable::~CDBehaviorParameterTable(void) {}
+
+//! Returns the table's name
+std::string CDBehaviorParameterTable::GetName(void) const {
+	return "BehaviorParameter";
+}
+
 float CDBehaviorParameterTable::GetValue(const uint32_t behaviorID, const std::string& name, const float defaultValue) {
 	auto parameterID = this->m_ParametersList.find(name);
 	if (parameterID == this->m_ParametersList.end()) return defaultValue;

dDatabase/Tables/CDBehaviorParameterTable.h

@@ -5,18 +5,37 @@
 #include <unordered_map>
 #include <unordered_set>
 
+/*!
+ \file CDBehaviorParameterTable.hpp
+ \brief Contains data for the BehaviorParameter table
+ */
+
+ //! BehaviorParameter Entry Struct
 struct CDBehaviorParameter {
 	unsigned int behaviorID;											//!< The Behavior ID
 	std::unordered_map<std::string, uint32_t>::iterator parameterID;   	//!< The Parameter ID
 	float value;            											//!< The value of the behavior template
 };
 
-class CDBehaviorParameterTable : public CDTable<CDBehaviorParameterTable> {
+//! BehaviorParameter table
+class CDBehaviorParameterTable : public CDTable {
 private:
 	std::unordered_map<uint64_t, CDBehaviorParameter> m_Entries;
 	std::unordered_map<std::string, uint32_t> m_ParametersList;
 public:
-	CDBehaviorParameterTable();
+
+	//! Constructor
+	CDBehaviorParameterTable(void);
+
+	//! Destructor
+	~CDBehaviorParameterTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
 	float GetValue(const uint32_t behaviorID, const std::string& name, const float defaultValue = 0);
 
 	std::map<std::string, float> GetParametersByBehaviorID(uint32_t behaviorID);

dDatabase/Tables/CDBehaviorTemplateTable.cpp

@@ -1,5 +1,6 @@
 #include "CDBehaviorTemplateTable.h"
 
+//! Constructor
 CDBehaviorTemplateTable::CDBehaviorTemplateTable(void) {
 
 	// First, get the size of the table
@@ -39,6 +40,15 @@ CDBehaviorTemplateTable::CDBehaviorTemplateTable(void) {
 	tableData.finalize();
 }
 
+//! Destructor
+CDBehaviorTemplateTable::~CDBehaviorTemplateTable(void) {}
+
+//! Returns the table's name
+std::string CDBehaviorTemplateTable::GetName(void) const {
+	return "BehaviorTemplate";
+}
+
+//! Queries the table with a custom "where" clause
 std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::Query(std::function<bool(CDBehaviorTemplate)> predicate) {
 
 	std::vector<CDBehaviorTemplate> data = cpplinq::from(this->entries)
@@ -48,6 +58,7 @@ std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::Query(std::function<boo
 	return data;
 }
 
+//! Gets all the entries in the table
 std::vector<CDBehaviorTemplate> CDBehaviorTemplateTable::GetEntries(void) const {
 	return this->entries;
 }

dDatabase/Tables/CDBehaviorTemplateTable.h

@@ -5,6 +5,12 @@
 #include <unordered_map>
 #include <unordered_set>
 
+/*!
+ \file CDBehaviorTemplateTable.hpp
+ \brief Contains data for the BehaviorTemplate table
+ */
+
+ //! BehaviorTemplate Entry Struct
 struct CDBehaviorTemplate {
 	unsigned int behaviorID;                                         //!< The Behavior ID
 	unsigned int templateID;                                         //!< The Template ID (LOT)
@@ -13,16 +19,36 @@ struct CDBehaviorTemplate {
 };
 
 
-class CDBehaviorTemplateTable : public CDTable<CDBehaviorTemplateTable> {
+//! BehaviorTemplate table
+class CDBehaviorTemplateTable : public CDTable {
 private:
 	std::vector<CDBehaviorTemplate> entries;
 	std::unordered_map<uint32_t, CDBehaviorTemplate> entriesMappedByBehaviorID;
 	std::unordered_set<std::string> m_EffectHandles;
 public:
-	CDBehaviorTemplateTable();
-	// Queries the table with a custom "where" clause
+
+	//! Constructor
+	CDBehaviorTemplateTable(void);
+
+	//! Destructor
+	~CDBehaviorTemplateTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	  \param predicate The predicate
+	 */
 	std::vector<CDBehaviorTemplate> Query(std::function<bool(CDBehaviorTemplate)> predicate);
 
+	//! Gets all the entries in the table
+	/*!
+	   \return The entries
+	 */
 	std::vector<CDBehaviorTemplate> GetEntries(void) const;
 
 	const CDBehaviorTemplate GetByBehaviorID(uint32_t behaviorID);

dDatabase/Tables/CDBrickIDTableTable.cpp

@@ -1,5 +1,6 @@
 #include "CDBrickIDTableTable.h"
 
+//! Constructor
 CDBrickIDTableTable::CDBrickIDTableTable(void) {
 
 	// First, get the size of the table
@@ -30,6 +31,15 @@ CDBrickIDTableTable::CDBrickIDTableTable(void) {
 	tableData.finalize();
 }
 
+//! Destructor
+CDBrickIDTableTable::~CDBrickIDTableTable(void) {}
+
+//! Returns the table's name
+std::string CDBrickIDTableTable::GetName(void) const {
+	return "BrickIDTable";
+}
+
+//! Queries the table with a custom "where" clause
 std::vector<CDBrickIDTable> CDBrickIDTableTable::Query(std::function<bool(CDBrickIDTable)> predicate) {
 
 	std::vector<CDBrickIDTable> data = cpplinq::from(this->entries)
@@ -39,6 +49,7 @@ std::vector<CDBrickIDTable> CDBrickIDTableTable::Query(std::function<bool(CDBric
 	return data;
 }
 
+//! Gets all the entries in the table
 std::vector<CDBrickIDTable> CDBrickIDTableTable::GetEntries(void) const {
 	return this->entries;
 }

dDatabase/Tables/CDBrickIDTableTable.h

@@ -16,14 +16,34 @@ struct CDBrickIDTable {
 
 
 //! BrickIDTable table
-class CDBrickIDTableTable : public CDTable<CDBrickIDTableTable> {
+class CDBrickIDTableTable : public CDTable {
 private:
 	std::vector<CDBrickIDTable> entries;
 
 public:
-	CDBrickIDTableTable();
-	// Queries the table with a custom "where" clause
+
+	//! Constructor
+	CDBrickIDTableTable(void);
+
+	//! Destructor
+	~CDBrickIDTableTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	  \param predicate The predicate
+	 */
 	std::vector<CDBrickIDTable> Query(std::function<bool(CDBrickIDTable)> predicate);
 
+	//! Gets all the entries in the table
+	/*!
+	   \return The entries
+	 */
 	std::vector<CDBrickIDTable> GetEntries(void) const;
+
 };

dDatabase/Tables/CDComponentsRegistryTable.cpp

@@ -1,8 +1,8 @@
 #include "CDComponentsRegistryTable.h"
-#include "eReplicaComponentType.h"
 
 #define CDCLIENT_CACHE_ALL
 
+//! Constructor
 CDComponentsRegistryTable::CDComponentsRegistryTable(void) {
 
 #ifdef CDCLIENT_CACHE_ALL
@@ -25,11 +25,29 @@ CDComponentsRegistryTable::CDComponentsRegistryTable(void) {
 	while (!tableData.eof()) {
 		CDComponentsRegistry entry;
 		entry.id = tableData.getIntField("id", -1);
-		entry.component_type = static_cast<eReplicaComponentType>(tableData.getIntField("component_type", 0));
+		entry.component_type = tableData.getIntField("component_type", -1);
 		entry.component_id = tableData.getIntField("component_id", -1);
 
 		this->mappedEntries.insert_or_assign(((uint64_t)entry.component_type) << 32 | ((uint64_t)entry.id), entry.component_id);
 
+		//this->entries.push_back(entry);
+
+		/*
+		//Darwin's stuff:
+		const auto& it = this->mappedEntries.find(entry.id);
+		if (it != mappedEntries.end()) {
+			const auto& iter = it->second.find(entry.component_type);
+			if (iter == it->second.end()) {
+				it->second.insert(std::make_pair(entry.component_type, entry.component_id));
+			}
+		}
+		else {
+			std::map<unsigned int, unsigned int> map;
+			map.insert(std::make_pair(entry.component_type, entry.component_id));
+			this->mappedEntries.insert(std::make_pair(entry.id, map));
+		}
+		*/
+
 		tableData.nextRow();
 	}
 
@@ -37,7 +55,15 @@ CDComponentsRegistryTable::CDComponentsRegistryTable(void) {
 #endif
 }
 
-int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue) {
+//! Destructor
+CDComponentsRegistryTable::~CDComponentsRegistryTable(void) {}
+
+//! Returns the table's name
+std::string CDComponentsRegistryTable::GetName(void) const {
+	return "ComponentsRegistry";
+}
+
+int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, uint32_t componentType, int32_t defaultValue) {
 	const auto& iter = this->mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
 
 	if (iter == this->mappedEntries.end()) {
@@ -46,6 +72,16 @@ int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponent
 
 	return iter->second;
 
+	/*
+	const auto& it = this->mappedEntries.find(id);
+	if (it != mappedEntries.end()) {
+		const auto& iter = it->second.find(componentType);
+		if (iter != it->second.end()) {
+			return iter->second;
+		}
+	}
+	*/
+
 #ifndef CDCLIENT_CACHE_ALL
 	// Now get the data
 	std::stringstream query;

dDatabase/Tables/CDComponentsRegistryTable.h

@@ -3,19 +3,38 @@
 // Custom Classes
 #include "CDTable.h"
 
-enum class eReplicaComponentType : uint32_t;
+/*!
+  \file CDComponentsRegistryTable.hpp
+  \brief Contains data for the ComponentsRegistry table
+ */
+
+ //! ComponentsRegistry Entry Struct
 struct CDComponentsRegistry {
 	unsigned int id;                    //!< The LOT is used as the ID
-	eReplicaComponentType component_type;        //!< See ComponentTypes enum for values
+	unsigned int component_type;        //!< See ComponentTypes enum for values
 	unsigned int component_id;          //!< The ID used within the component's table (0 may either mean it's non-networked, or that the ID is actually 0
 };
 
 
-class CDComponentsRegistryTable : public CDTable<CDComponentsRegistryTable> {
+//! ComponentsRegistry table
+class CDComponentsRegistryTable : public CDTable {
 private:
+	//std::vector<CDComponentsRegistry> entries;
 	std::map<uint64_t, uint32_t> mappedEntries; //id, component_type, component_id
 
 public:
-	CDComponentsRegistryTable();
-	int32_t GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue = 0);
+
+	//! Constructor
+	CDComponentsRegistryTable(void);
+
+	//! Destructor
+	~CDComponentsRegistryTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	int32_t GetByIDAndType(uint32_t id, uint32_t componentType, int32_t defaultValue = 0);
 };

dDatabase/Tables/CDCurrencyTableTable.cpp

@@ -34,6 +34,15 @@ CDCurrencyTableTable::CDCurrencyTableTable(void) {
 	tableData.finalize();
 }
 
+//! Destructor
+CDCurrencyTableTable::~CDCurrencyTableTable(void) {}
+
+//! Returns the table's name
+std::string CDCurrencyTableTable::GetName(void) const {
+	return "CurrencyTable";
+}
+
+//! Queries the table with a custom "where" clause
 std::vector<CDCurrencyTable> CDCurrencyTableTable::Query(std::function<bool(CDCurrencyTable)> predicate) {
 
 	std::vector<CDCurrencyTable> data = cpplinq::from(this->entries)
@@ -43,6 +52,7 @@ std::vector<CDCurrencyTable> CDCurrencyTableTable::Query(std::function<bool(CDCu
 	return data;
 }
 
+//! Gets all the entries in the table
 std::vector<CDCurrencyTable> CDCurrencyTableTable::GetEntries(void) const {
 	return this->entries;
 }

dDatabase/Tables/CDCurrencyTableTable.h

@@ -18,14 +18,34 @@ struct CDCurrencyTable {
 };
 
 //! CurrencyTable table
-class CDCurrencyTableTable : public CDTable<CDCurrencyTableTable> {
+class CDCurrencyTableTable : public CDTable {
 private:
 	std::vector<CDCurrencyTable> entries;
 
 public:
-	CDCurrencyTableTable();
-	// Queries the table with a custom "where" clause
+
+	//! Constructor
+	CDCurrencyTableTable(void);
+
+	//! Destructor
+	~CDCurrencyTableTable(void);
+
+	//! Returns the table's name
+	/*!
+	  \return The table name
+	 */
+	std::string GetName(void) const override;
+
+	//! Queries the table with a custom "where" clause
+	/*!
+	  \param predicate The predicate
+	 */
 	std::vector<CDCurrencyTable> Query(std::function<bool(CDCurrencyTable)> predicate);
 
+	//! Gets all the entries in the table
+	/*!
+	  \return The entries
+	 */
 	std::vector<CDCurrencyTable> GetEntries(void) const;
+
 };