hey it compiles

into the model, item, and mutable model behaviors

README.md

@@ -245,11 +245,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

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,6 +3,7 @@
 #include "Database.h"
 #include <vector>
 #include "PacketUtils.h"
+#include "dMessageIdentifiers.h"
 #include "Game.h"
 #include "dServer.h"
 #include "GeneralUtils.h"
@@ -11,20 +12,15 @@
 #include "eAddFriendResponseType.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;
 
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = 0;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	auto player = playerContainer.GetPlayerData(playerID);
 	if (!player) return;
@@ -49,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;
@@ -75,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());
@@ -98,9 +94,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 	auto maxNumberOfBestFriendsAsString = Game::config->GetValue("max_number_of_best_friends");
 	// If this config option doesn't exist, default to 5 which is what live used.
 	auto maxNumberOfBestFriends = maxNumberOfBestFriendsAsString != "" ? std::stoi(maxNumberOfBestFriendsAsString) : 5U;
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID requestorPlayerID;
 	inStream.Read(requestorPlayerID);
+	inStream.Read(requestorPlayerID);
 	uint32_t spacing{};
 	inStream.Read(spacing);
 	std::string playerName = "";
@@ -181,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
@@ -245,9 +242,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	eAddFriendResponseCode clientResponseCode = static_cast<eAddFriendResponseCode>(packet->data[0x14]);
 	std::string friendName = PacketUtils::ReadString(0x15, packet, true);
@@ -320,9 +318,10 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	std::string friendName = PacketUtils::ReadString(0x14, packet, true);
 
 	//we'll have to query the db here to find the user, since you can delete them while they're offline.
@@ -337,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));
@@ -377,9 +376,10 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleChatMessage(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	auto* sender = playerContainer.GetPlayerData(playerID);
 
@@ -412,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);
@@ -451,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);
@@ -474,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);
@@ -496,9 +496,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	std::string invitedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
 	auto* player = playerContainer.GetPlayerData(playerID);
@@ -536,9 +537,10 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	uint32_t size = 0;
 	inStream.Read(size);
 	char declined = 0;
@@ -569,9 +571,10 @@ void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	uint32_t size = 0;
 	inStream.Read(size);
 
@@ -585,9 +588,10 @@ void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamKick(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	std::string kickedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
@@ -615,9 +619,10 @@ void ChatPacketHandler::HandleTeamKick(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	std::string promotedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
@@ -637,9 +642,10 @@ void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamLootOption(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	uint32_t size = 0;
 	inStream.Read(size);
 
@@ -660,9 +666,10 @@ void ChatPacketHandler::HandleTeamLootOption(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	auto* team = playerContainer.GetTeam(playerID);
 	auto* data = playerContainer.GetPlayerData(playerID);
@@ -709,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);
@@ -724,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);
@@ -751,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);
@@ -776,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);
 
@@ -793,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);
@@ -822,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);
@@ -848,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()) {
@@ -882,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();
@@ -921,11 +928,11 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	}
 
 	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.
 
@@ -937,11 +944,11 @@ void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sen
 	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);
@@ -962,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/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() {
 }
@@ -19,8 +18,9 @@ PlayerContainer::~PlayerContainer() {
 }
 
 void PlayerContainer::InsertPlayer(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	PlayerData* data = new PlayerData();
+	inStream.SetReadOffset(inStream.GetReadOffset() + 64);
 	inStream.Read(data->playerID);
 
 	uint32_t len;
@@ -51,8 +51,9 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 }
 
 void PlayerContainer::RemovePlayer(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
 	inStream.Read(playerID);
 
 	//Before they get kicked, we need to also send a message to their friends saying that they disconnected.
@@ -95,8 +96,9 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 }
 
 void PlayerContainer::MuteUpdate(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
 	inStream.Read(playerID);
 	time_t expire = 0;
 	inStream.Read(expire);
@@ -115,8 +117,9 @@ void PlayerContainer::MuteUpdate(Packet* packet) {
 }
 
 void PlayerContainer::CreateTeamServer(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
 	inStream.Read(playerID);
 	size_t membersSize = 0;
 	inStream.Read(membersSize);
@@ -146,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);
@@ -345,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_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,13 +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;
 
 /*!
@@ -67,9 +65,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 +77,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 +138,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);
 
@@ -210,8 +208,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/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
@@ -28,11 +28,9 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 
 //========== MACROS ===========
 
-#define HEADER_SIZE 8
 #define CBITSTREAM RakNet::BitStream bitStream;
 #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
-#define CINSTREAM_SKIP_HEADER CINSTREAM if (inStream.GetNumberOfUnreadBits() >= BYTES_TO_BITS(HEADER_SIZE)) inStream.IgnoreBytes(HEADER_SIZE); else inStream.IgnoreBits(inStream.GetNumberOfUnreadBits());
-#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);
 
@@ -47,16 +45,23 @@ typedef uint16_t LWOINSTANCEID;              //!< Used for Instance IDs
 typedef uint32_t PROPERTYCLONELIST;          //!< Used for Property Clone IDs
 typedef uint32_t StripId;
 
+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;
 
 //============ STRUCTS ==============
@@ -159,4 +164,416 @@ 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
+};
+
+//! 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 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,561 @@
+#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_SET_RESURRECT_RESTORE_VALUES = 1591,
+	GAME_MSG_VEHICLE_STOP_BOOST = 1617,
+	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/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 = 1562,
-	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/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/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/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/ePhysicsBehaviorType.h

@@ -0,0 +1,14 @@
+#ifndef __EPHYSICSBEHAVIORTYPE__H__
+#define __EPHYSICSBEHAVIORTYPE__H__
+
+#include <cstdint>
+
+enum class ePhysicsBehaviorType : int32_t {
+	INVALID = -1,
+	GROUND,
+	FLYING,
+	STANDARD,
+	DYNAMIC
+};
+
+#endif  //!__EPHYSICSBEHAVIORTYPE__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/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

@@ -107,7 +107,7 @@ enum class eReplicaComponentType : uint32_t {
 	DONATION_VENDOR,
 	COMBAT_MEDIATOR,
 	COMMENDATION_VENDOR,
-	GATE_RUSH_CONTROL,
+	UNKNOWN_103,
 	RAIL_ACTIVATOR,
 	ROLLER,
 	PLAYER_FORCED_MOVEMENT,
@@ -119,7 +119,7 @@ enum class eReplicaComponentType : uint32_t {
 	UNKNOWN_112,
 	PROPERTY_PLAQUE,
 	BUILD_BORDER,
-	UNKNOWN_115,
+	UNKOWN_115,
 	CULLING_PLANE,
 	DESTROYABLE = 1000 // Actually 7
 };

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/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/eTriggerEventType.h

@@ -35,7 +35,7 @@ public:
 			{"OnTimerDone", eTriggerEventType::TIMER_DONE},
 			{"OnRebuildComplete", eTriggerEventType::REBUILD_COMPLETE},
 			{"OnActivated", eTriggerEventType::ACTIVATED},
-			{"OnDectivated", eTriggerEventType::DEACTIVATED}, // Dectivated vs Deactivated
+			{"OnDeactivated", eTriggerEventType::DEACTIVATED},
 			{"OnArrived", eTriggerEventType::ARRIVED},
 			{"OnArrivedAtEndOfPath", eTriggerEventType::ARRIVED_AT_END_OF_PATH},
 			{"OnZoneSummaryDismissed", eTriggerEventType::ZONE_SUMMARY_DISMISSED},

dCommon/dEnums/eUgcModerationStatus.h

@@ -0,0 +1,13 @@
+
+#ifndef __EUGCMODERATIONSTATUS__H__
+#define __EUGCMODERATIONSTATUS__H__
+
+#include <cstdint>
+
+enum class eUgcModerationStatus : uint32_t {
+	NoStatus,
+	Approved,
+	Rejected,
+};
+
+#endif  //!__EUGCMODERATIONSTATUS__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__

dGame/Character.cpp

@@ -18,9 +18,6 @@
 #include "InventoryComponent.h"
 #include "eMissionTaskType.h"
 #include "eMissionState.h"
-#include "eObjectBits.h"
-#include "eGameMasterLevel.h"
-#include "ePlayerFlag.h"
 
 Character::Character(uint32_t id, User* parentUser) {
 	//First load the name, etc:
@@ -71,8 +68,8 @@ Character::Character(uint32_t id, User* parentUser) {
 
 	//Set our objectID:
 	m_ObjectID = m_ID;
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
 
 	m_ParentUser = parentUser;
 	m_OurEntity = nullptr;
@@ -130,8 +127,8 @@ void Character::UpdateFromDatabase() {
 
 	//Set our objectID:
 	m_ObjectID = m_ID;
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
 
 	m_OurEntity = nullptr;
 	m_BuildMode = false;
@@ -207,9 +204,7 @@ void Character::DoQuickXMLDataParse() {
 	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
 		character->QueryAttribute("cc", &m_Coins);
-		int32_t gm_level = 0;
-		character->QueryAttribute("gm", &gm_level);
-		m_GMLevel = static_cast<eGameMasterLevel>(gm_level);
+		character->QueryAttribute("gm", &m_GMLevel);
 
 		uint64_t lzidConcat = 0;
 		if (character->FindAttribute("lzid")) {
@@ -309,7 +304,7 @@ void Character::SaveXMLToDatabase() {
 
 	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
-		character->SetAttribute("gm", static_cast<uint32_t>(m_GMLevel));
+		character->SetAttribute("gm", m_GMLevel);
 		character->SetAttribute("cc", m_Coins);
 
 		auto zoneInfo = dZoneManager::Instance()->GetZone()->GetZoneID();
@@ -363,9 +358,9 @@ void Character::SaveXMLToDatabase() {
 	}
 
 	// Prevents the news feed from showing up on world transfers
-	if (GetPlayerFlag(ePlayerFlag::IS_NEWS_SCREEN_VISIBLE)) {
+	if (GetPlayerFlag(ePlayerFlags::IS_NEWS_SCREEN_VISIBLE)) {
 		auto* s = m_Doc->NewElement("s");
-		s->SetAttribute("si", ePlayerFlag::IS_NEWS_SCREEN_VISIBLE);
+		s->SetAttribute("si", ePlayerFlags::IS_NEWS_SCREEN_VISIBLE);
 		flags->LinkEndChild(s);
 	}
 
@@ -373,7 +368,7 @@ void Character::SaveXMLToDatabase() {
 
 	//Call upon the entity to update our xmlDoc:
 	if (!m_OurEntity) {
-		Game::logger->Log("Character", "%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
+		Game::logger->Log("Character", "We didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!");
 		return;
 	}
 
@@ -384,7 +379,7 @@ void Character::SaveXMLToDatabase() {
 	//For metrics, log the time it took to save:
 	auto end = std::chrono::system_clock::now();
 	std::chrono::duration<double> elapsed = end - start;
-	Game::logger->Log("Character", "%i:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
+	Game::logger->Log("Character", "Saved character to Database in: %fs", elapsed.count());
 }
 
 void Character::SetIsNewLogin() {
@@ -396,7 +391,7 @@ void Character::SetIsNewLogin() {
 	while (currentChild) {
 		if (currentChild->Attribute("si")) {
 			flags->DeleteChild(currentChild);
-			Game::logger->Log("Character", "Removed isLoggedIn flag from character %i:%s, saving character to database", GetID(), GetName().c_str());
+			Game::logger->Log("Character", "Removed isLoggedIn flag from character %i, saving character to database", GetID());
 			WriteToDatabase();
 		}
 		currentChild = currentChild->NextSiblingElement();
@@ -418,7 +413,7 @@ void Character::WriteToDatabase() {
 	delete printer;
 }
 
-void Character::SetPlayerFlag(const int32_t flagId, const bool value) {
+void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
 	// If the flag is already set, we don't have to recalculate it
 	if (GetPlayerFlag(flagId) == value) return;
 
@@ -465,7 +460,7 @@ void Character::SetPlayerFlag(const int32_t flagId, const bool value) {
 	GameMessages::SendNotifyClientFlagChange(m_ObjectID, flagId, value, m_ParentUser->GetSystemAddress());
 }
 
-bool Character::GetPlayerFlag(const int32_t flagId) const {
+bool Character::GetPlayerFlag(const uint32_t flagId) const {
 	// Calculate the index first
 	const auto flagIndex = uint32_t(std::floor(flagId / 64));
 
@@ -482,8 +477,8 @@ bool Character::GetPlayerFlag(const int32_t flagId) const {
 
 void Character::SetRetroactiveFlags() {
 	// Retroactive check for if player has joined a faction to set their 'joined a faction' flag to true.
-	if (GetPlayerFlag(ePlayerFlag::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlag::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlag::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlag::SENTINEL_FACTION)) {
-		SetPlayerFlag(ePlayerFlag::JOINED_A_FACTION, true);
+	if (GetPlayerFlag(ePlayerFlags::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlags::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlags::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlags::SENTINEL_FACTION)) {
+		SetPlayerFlag(ePlayerFlags::JOINED_A_FACTION, true);
 	}
 }
 
@@ -543,14 +538,14 @@ void Character::OnZoneLoad() {
 	if (missionComponent != nullptr) {
 		// Fix the monument race flag
 		if (missionComponent->GetMissionState(319) >= eMissionState::READY_TO_COMPLETE) {
-			SetPlayerFlag(ePlayerFlag::AG_FINISH_LINE_BUILT, true);
+			SetPlayerFlag(33, true);
 		}
 	}
 
 	const auto maxGMLevel = m_ParentUser->GetMaxGMLevel();
 
 	// This does not apply to the GMs
-	if (maxGMLevel > eGameMasterLevel::CIVILIAN) {
+	if (maxGMLevel > GAME_MASTER_LEVEL_CIVILIAN) {
 		return;
 	}
 
@@ -559,7 +554,7 @@ void Character::OnZoneLoad() {
 	 */
 	if (HasPermission(ePermissionMap::Old)) {
 		if (GetCoins() > 1000000) {
-			SetCoins(1000000, eLootSourceType::NONE);
+			SetCoins(1000000, eLootSourceType::LOOT_SOURCE_NONE);
 		}
 	}
 
@@ -626,21 +621,3 @@ void Character::SendMuteNotice() const {
 
 	ChatPackets::SendSystemMessage(GetEntity()->GetSystemAddress(), u"You are muted until " + timeStr);
 }
-
-void Character::SetBillboardVisible(bool visible) {
-	if (m_BillboardVisible == visible) return;
-	m_BillboardVisible = visible;
-
-	GameMessages::SendSetNamebillboardState(UNASSIGNED_SYSTEM_ADDRESS, m_OurEntity->GetObjectID());
-
-	if (!visible) return;
-
-	// The GameMessage we send for turning the nameplate off just deletes the BillboardSubcomponent from the parent component.
-	// Because that same message does not allow for custom parameters, we need to create the BillboardSubcomponent a different way
-	// This workaround involves sending an unrelated GameMessage that does not apply to player entites,
-	// but forces the client to create the necessary SubComponent that controls the billboard.
-	GameMessages::SendShowBillboardInteractIcon(UNASSIGNED_SYSTEM_ADDRESS, m_OurEntity->GetObjectID());
-
-	// Now turn off the billboard for the owner.
-	GameMessages::SendSetNamebillboardState(m_OurEntity->GetSystemAddress(), m_OurEntity->GetObjectID());
-}

dGame/Character.h

@@ -15,8 +15,6 @@ class User;
 struct Packet;
 class Entity;
 enum class ePermissionMap : uint64_t;
-enum class eGameMasterLevel : uint8_t;
-enum class eLootSourceType : uint32_t;
 
 /**
  * Meta information about a character, like their name and style
@@ -310,13 +308,13 @@ public:
 	 * Gets the GM level of the character
 	 * @return the GM level
 	 */
-	eGameMasterLevel GetGMLevel() const { return m_GMLevel; }
+	int32_t GetGMLevel() const { return m_GMLevel; }
 
 	/**
 	 * Sets the GM level of the character
 	 * @param value the GM level to set
 	 */
-	void SetGMLevel(eGameMasterLevel value) { m_GMLevel = value; }
+	void SetGMLevel(uint8_t value) { m_GMLevel = value; }
 
 	/**
 	 * Gets the current amount of coins of the character
@@ -415,14 +413,14 @@ public:
 	 * @param flagId the ID of the flag to set
 	 * @param value the value to set for the flag
 	 */
-	void SetPlayerFlag(int32_t flagId, bool value);
+	void SetPlayerFlag(uint32_t flagId, bool value);
 
 	/**
 	 * Gets the value for a certain character flag
 	 * @param flagId the ID of the flag to get a value for
 	 * @return the value of the flag given the ID (the default is false, obviously)
 	 */
-	bool GetPlayerFlag(int32_t flagId) const;
+	bool GetPlayerFlag(uint32_t flagId) const;
 
 	/**
 	 * Notifies the character that they're now muted
@@ -453,10 +451,6 @@ public:
 	*/
 	void SetIsFlying(bool isFlying) { m_IsFlying = isFlying; }
 
-	bool GetBillboardVisible() { return m_BillboardVisible; }
-
-	void SetBillboardVisible(bool visible);
-
 private:
 	/**
 	 * The ID of this character. First 32 bits of the ObjectID.
@@ -483,7 +477,7 @@ private:
 	 *
 	 * @see eGameMasterLevel
 	 */
-	eGameMasterLevel m_GMLevel;
+	int32_t m_GMLevel;
 
 	/**
 	 * Bitmap of permission attributes this character has.
@@ -658,11 +652,6 @@ private:
 	*/
 	bool m_IsFlying = false;
 
-	/**
-	 * True if billboard (referred to as nameplate for end users) is visible, false otherwise
-	 */
-	bool m_BillboardVisible = true;
-
 	/**
 	 * Queries the character XML and updates all the fields of this object
 	 * NOTE: quick as there's no DB lookups

dGame/Entity.cpp

@@ -24,7 +24,6 @@
 #include "Loot.h"
 #include "eMissionTaskType.h"
 #include "eTriggerEventType.h"
-#include "eObjectBits.h"
 
 //Component includes:
 #include "Component.h"
@@ -71,9 +70,9 @@
 #include "RailActivatorComponent.h"
 #include "LUPExhibitComponent.h"
 #include "TriggerComponent.h"
-#include "eGameMasterLevel.h"
+#include "ItemComponent.h"
+#include "MutableModelBehaviorComponent.h"
 #include "eReplicaComponentType.h"
-#include "eReplicaPacketType.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -92,7 +91,7 @@ Entity::Entity(const LWOOBJID& objectID, EntityInfo info, Entity* parentEntity)
 	m_TemplateID = info.lot;
 	m_ParentEntity = parentEntity;
 	m_Character = nullptr;
-	m_GMLevel = eGameMasterLevel::CIVILIAN;
+	m_GMLevel = 0;
 	m_CollectibleID = 0;
 	m_NetworkID = 0;
 	m_Groups = {};
@@ -614,7 +613,7 @@ void Entity::Initialize() {
 		m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPTED_ACTIVITY, new ScriptedActivityComponent(this, scriptedActivityID)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODEL, -1) != -1 && !GetComponent<PetComponent>()) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODEL, -1) != -1 && !(petComponentId > 0)) {
 		m_Components.insert(std::make_pair(eReplicaComponentType::MODEL, new ModelComponent(this)));
 		if (m_Components.find(eReplicaComponentType::DESTROYABLE) == m_Components.end()) {
 			auto destroyableComponent = new DestroyableComponent(this);
@@ -626,8 +625,7 @@ void Entity::Initialize() {
 		}
 	}
 
-	PetComponent* petComponent;
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ITEM) > 0 && !TryGetComponent(eReplicaComponentType::PET, petComponent) && !HasComponent(eReplicaComponentType::MODEL)) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ITEM) > 0  && !(petComponentId > 0)) {
 		m_Components.insert(std::make_pair(eReplicaComponentType::ITEM, nullptr));
 	}
 
@@ -729,7 +727,7 @@ void Entity::Initialize() {
 
 	if (!m_Character && EntityManager::Instance()->GetGhostingEnabled()) {
 		// Don't ghost what is likely large scene elements
-		if (HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER) && (m_Components.size() == 2 || (HasComponent(eReplicaComponentType::TRIGGER) && m_Components.size() == 3))) {
+		if (m_Components.size() == 2 && HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER)) {
 			goto no_ghosting;
 		}
 
@@ -765,7 +763,7 @@ void Entity::Initialize() {
 
 no_ghosting:
 
-	TriggerEvent(eTriggerEventType::CREATE, this);
+	TriggerEvent(eTriggerEventType::CREATE);
 
 	if (m_Character) {
 		auto* controllablePhysicsComponent = GetComponent<ControllablePhysicsComponent>();
@@ -860,7 +858,7 @@ void Entity::SetProximityRadius(dpEntity* entity, std::string name) {
 	proxMon->SetProximityRadius(entity, name);
 }
 
-void Entity::SetGMLevel(eGameMasterLevel value) {
+void Entity::SetGMLevel(uint8_t value) {
 	m_GMLevel = value;
 	if (GetParentUser()) {
 		Character* character = GetParentUser()->GetLastUsedChar();
@@ -877,7 +875,7 @@ void Entity::SetGMLevel(eGameMasterLevel value) {
 }
 
 void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType) {
-	if (packetType == eReplicaPacketType::CONSTRUCTION) {
+	if (packetType == PACKET_TYPE_CONSTRUCTION) {
 		outBitStream->Write(m_ObjectID);
 		outBitStream->Write(m_TemplateID);
 
@@ -954,9 +952,9 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 
 		if (m_ParentEntity != nullptr || m_SpawnerID != 0) {
 			outBitStream->Write1();
-			if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), static_cast<uint32_t>(eObjectBits::CLIENT)));
+			if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), OBJECT_BIT_CLIENT));
 			else if (m_Spawner != nullptr && m_Spawner->m_Info.isNetwork) outBitStream->Write(m_SpawnerID);
-			else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, static_cast<uint32_t>(eObjectBits::CLIENT)));
+			else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, OBJECT_BIT_CLIENT));
 		} else outBitStream->Write0();
 
 		outBitStream->Write(m_HasSpawnerNodeID);
@@ -972,15 +970,15 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 
 		outBitStream->Write0(); //ObjectWorldState
 
-		if (m_GMLevel != eGameMasterLevel::CIVILIAN) {
+		if (m_GMLevel != 0) {
 			outBitStream->Write1();
 			outBitStream->Write(m_GMLevel);
 		} else outBitStream->Write0(); //No GM Level
 	}
 
 	// Only serialize parent / child info should the info be dirty (changed) or if this is the construction of the entity.
-	outBitStream->Write(m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION);
-	if (m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION) {
+	outBitStream->Write(m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION);
+	if (m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION) {
 		m_IsParentChildDirty = false;
 		outBitStream->Write(m_ParentEntity != nullptr);
 		if (m_ParentEntity) {
@@ -1005,7 +1003,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 
 	bool destroyableSerialized = false;
 	bool bIsInitialUpdate = false;
-	if (packetType == eReplicaPacketType::CONSTRUCTION) bIsInitialUpdate = true;
+	if (packetType == PACKET_TYPE_CONSTRUCTION) bIsInitialUpdate = true;
 	unsigned int flags = 0;
 
 	PossessableComponent* possessableComponent;
@@ -1018,36 +1016,24 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		moduleAssemblyComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// basephys > controllable
 	ControllablePhysicsComponent* controllablePhysicsComponent;
 	if (TryGetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS, controllablePhysicsComponent)) {
 		controllablePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// ProjectilePhysics Deserilized
-
-	// basephys > physicssystem (base on but not for serialization)
-	// PhysicsSystem Deserialized
-
-	// basephys > vehicle
-	// VehiclePhysics Deserialized
-
-	// basephys > havokveh
-	// This is Havok Vehicle
-	VehiclePhysicsComponent* vehiclePhysicsComponent;
-	if (TryGetComponent(eReplicaComponentType::VEHICLE_PHYSICS, vehiclePhysicsComponent)) {
-		vehiclePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	SimplePhysicsComponent* simplePhysicsComponent;
+	if (TryGetComponent(eReplicaComponentType::SIMPLE_PHYSICS, simplePhysicsComponent)) {
+		simplePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// basephys > rigidbody (base on but not for serialization)
 	RigidbodyPhantomPhysicsComponent* rigidbodyPhantomPhysics;
 	if (TryGetComponent(eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS, rigidbodyPhantomPhysics)) {
 		rigidbodyPhantomPhysics->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
-	// basephys > simple (base on but not for serialization)
-	SimplePhysicsComponent* simplePhysicsComponent;
-	if (TryGetComponent(eReplicaComponentType::SIMPLE_PHYSICS, simplePhysicsComponent)) {
-		simplePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+
+	VehiclePhysicsComponent* vehiclePhysicsComponent;
+	if (TryGetComponent(eReplicaComponentType::VEHICLE_PHYSICS, vehiclePhysicsComponent)) {
+		vehiclePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	PhantomPhysicsComponent* phantomPhysicsComponent;
@@ -1055,7 +1041,11 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		phantomPhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// Destroyable
+	SoundTriggerComponent* soundTriggerComponent;
+	if (TryGetComponent(eReplicaComponentType::SOUND_TRIGGER, soundTriggerComponent)) {
+		soundTriggerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
 	BuffComponent* buffComponent;
 	if (TryGetComponent(eReplicaComponentType::BUFF, buffComponent)) {
 		buffComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
@@ -1067,24 +1057,13 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		destroyableSerialized = true;
 	}
 
-
-	CharacterComponent* characterComponent;
-	if (TryGetComponent(eReplicaComponentType::CHARACTER, characterComponent)) {
-		PossessorComponent* possessorComponent;
-		if (TryGetComponent(eReplicaComponentType::POSSESSOR, possessorComponent)) {
-			possessorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	if (HasComponent(eReplicaComponentType::COLLECTIBLE)) {
+		DestroyableComponent* destroyableComponent;
+		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
+			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		}
-
-		LevelProgressionComponent* levelProgressionComponent;
-		if (TryGetComponent(eReplicaComponentType::LEVEL_PROGRESSION, levelProgressionComponent)) {
-			levelProgressionComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-		}
-
-		PlayerForcedMovementComponent* playerForcedMovementComponent;
-		if (TryGetComponent(eReplicaComponentType::PLAYER_FORCED_MOVEMENT, playerForcedMovementComponent)) {
-			playerForcedMovementComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-		}
-		characterComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+		destroyableSerialized = true;
+		outBitStream->Write(m_CollectibleID); // Collectable component
 	}
 
 	PetComponent* petComponent;
@@ -1092,7 +1071,41 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		petComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// currently has Client and equiped item serialization in it
+	CharacterComponent* characterComponent;
+	if (TryGetComponent(eReplicaComponentType::CHARACTER, characterComponent)) {
+
+		PossessorComponent* possessorComponent;
+		if (TryGetComponent(eReplicaComponentType::POSSESSOR, possessorComponent)) {
+			possessorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+		} else {
+			// Should never happen, but just to be safe
+			outBitStream->Write0();
+		}
+
+		LevelProgressionComponent* levelProgressionComponent;
+		if (TryGetComponent(eReplicaComponentType::LEVEL_PROGRESSION, levelProgressionComponent)) {
+			levelProgressionComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+		} else {
+			// Should never happen, but just to be safe
+			outBitStream->Write0();
+		}
+
+		PlayerForcedMovementComponent* playerForcedMovementComponent;
+		if (TryGetComponent(eReplicaComponentType::PLAYER_FORCED_MOVEMENT, playerForcedMovementComponent)) {
+			playerForcedMovementComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+		} else {
+			// Should never happen, but just to be safe
+			outBitStream->Write0();
+		}
+
+		characterComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
+	ItemComponent* itemComponent;
+	if (TryGetComponent(eReplicaComponentType::ITEM, itemComponent)) {
+		itemComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
 	InventoryComponent* inventoryComponent;
 	if (TryGetComponent(eReplicaComponentType::INVENTORY, inventoryComponent)) {
 		inventoryComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
@@ -1113,12 +1126,6 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		baseCombatAiComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// kek
-	if (HasComponent(eReplicaComponentType::ITEM)) {
-		outBitStream->Write0();
-	}
-
-	// QUICKBUILD
 	RebuildComponent* rebuildComponent;
 	if (TryGetComponent(eReplicaComponentType::QUICK_BUILD, rebuildComponent)) {
 		DestroyableComponent* destroyableComponent;
@@ -1129,48 +1136,40 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		rebuildComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// base vendor
-	VendorComponent* vendorComponent;
-	if (TryGetComponent(eReplicaComponentType::VENDOR, vendorComponent)) {
-		vendorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-	// base vendor > Donation
-	// Donation Vendor Deserialized
-
-	// base vendor
-	// Achievement Vendor Deserialized
-
-	// activity > shooting gall
-	ShootingGalleryComponent* shootingGalleryComponent;
-	if (TryGetComponent(eReplicaComponentType::SHOOTING_GALLERY, shootingGalleryComponent)) {
-		shootingGalleryComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-
-	// Roller Deserialized
-
-	// activity
-	ScriptedActivityComponent* scriptedActivityComponent;
-	if (TryGetComponent(eReplicaComponentType::SCRIPTED_ACTIVITY, scriptedActivityComponent)) {
-		scriptedActivityComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-
-	// Collectible
-	if (HasComponent(eReplicaComponentType::COLLECTIBLE)) {
-		DestroyableComponent* destroyableComponent;
-		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
-			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-		}
-		destroyableSerialized = true;
-		outBitStream->Write(m_CollectibleID); // Collectable component
-	}
-
-
 	MovingPlatformComponent* movingPlatformComponent;
 	if (TryGetComponent(eReplicaComponentType::MOVING_PLATFORM, movingPlatformComponent)) {
 		movingPlatformComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	// ChoiceBuilds Deserialized
+	SwitchComponent* switchComponent;
+	if (TryGetComponent(eReplicaComponentType::SWITCH, switchComponent)) {
+		switchComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
+	VendorComponent* vendorComponent;
+	if (TryGetComponent(eReplicaComponentType::VENDOR, vendorComponent)) {
+		vendorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
+	BouncerComponent* bouncerComponent;
+	if (TryGetComponent(eReplicaComponentType::BOUNCER, bouncerComponent)) {
+		bouncerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
+	ScriptedActivityComponent* scriptedActivityComponent;
+	if (TryGetComponent(eReplicaComponentType::SCRIPTED_ACTIVITY, scriptedActivityComponent)) {
+		scriptedActivityComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
+	ShootingGalleryComponent* shootingGalleryComponent;
+	if (TryGetComponent(eReplicaComponentType::SHOOTING_GALLERY, shootingGalleryComponent)) {
+		shootingGalleryComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
+	RacingControlComponent* racingControlComponent;
+	if (TryGetComponent(eReplicaComponentType::RACING_CONTROL, racingControlComponent)) {
+		racingControlComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
 
 	LUPExhibitComponent* lupExhibitComponent;
 	if (TryGetComponent(eReplicaComponentType::LUP_EXHIBIT, lupExhibitComponent)) {
@@ -1182,6 +1181,11 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		modelComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
+	RenderComponent* renderComponent;
+	if (TryGetComponent(eReplicaComponentType::RENDER, renderComponent)) {
+		renderComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
+	}
+
 	if (modelComponent) {
 		DestroyableComponent* destroyableComponent;
 		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
@@ -1190,48 +1194,12 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		}
 	}
 
-	BouncerComponent* bouncerComponent;
-	if (TryGetComponent(eReplicaComponentType::BOUNCER, bouncerComponent)) {
-		bouncerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-
-	SwitchComponent* switchComponent;
-	if (TryGetComponent(eReplicaComponentType::SWITCH, switchComponent)) {
-		switchComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-
-	// activity
 	if (HasComponent(eReplicaComponentType::ZONE_CONTROL)) {
 		outBitStream->Write<uint32_t>(0x40000000);
 	}
 
-	// Sound Repeater Deserialized
-	// Chest Deserialized
-
-	// actually fx comp, that get's loaded via render comp
-	RenderComponent* renderComponent;
-	if (TryGetComponent(eReplicaComponentType::RENDER, renderComponent)) {
-		renderComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-
-	SoundTriggerComponent* soundTriggerComponent;
-	if (TryGetComponent(eReplicaComponentType::SOUND_TRIGGER, soundTriggerComponent)) {
-		soundTriggerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-
-	// just sound trigger again
-	// Racing Sound Trigger Deserialize (base is SoundTrigger)
-
-	// activity > scripted activity > base racing > racing
-	RacingControlComponent* racingControlComponent;
-	if (TryGetComponent(eReplicaComponentType::RACING_CONTROL, racingControlComponent)) {
-		racingControlComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
-	}
-
-	// activity > scripted activity > base racing > gaterush
-	// Gate Rush Deserialize
-
 	// BBB Component, unused currently
+	// Need to to write0 so that is serialized correctly
 	// TODO: Implement BBB Component
 	outBitStream->Write0();
 }
@@ -1265,7 +1233,6 @@ void Entity::Update(const float deltaTime) {
 			for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 				script->OnTimerDone(this, timerName);
 			}
-			TriggerEvent(eTriggerEventType::TIMER_DONE, this);
 		} else {
 			timerPosition++;
 		}
@@ -1376,10 +1343,6 @@ void Entity::OnCollisionLeavePhantom(const LWOOBJID otherEntity) {
 	auto* other = EntityManager::Instance()->GetEntity(otherEntity);
 	if (!other) return;
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnOffCollisionPhantom(this, other);
-	}
-
 	TriggerEvent(eTriggerEventType::EXIT, other);
 
 	SwitchComponent* switchComp = GetComponent<SwitchComponent>();
@@ -1428,7 +1391,7 @@ void Entity::OnEmoteReceived(const int32_t emote, Entity* target) {
 }
 
 void Entity::OnUse(Entity* originator) {
-	TriggerEvent(eTriggerEventType::INTERACT, originator);
+	TriggerEvent(eTriggerEventType::INTERACT);
 
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 		script->OnUse(this, originator);
@@ -1450,7 +1413,6 @@ void Entity::OnHitOrHealResult(Entity* attacker, int32_t damage) {
 }
 
 void Entity::OnHit(Entity* attacker) {
-	TriggerEvent(eTriggerEventType::HIT, attacker);
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 		script->OnHit(this, attacker);
 	}
@@ -1656,7 +1618,7 @@ void Entity::PickupItem(const LWOOBJID& objectID) {
 					}
 				}
 			} else {
-				inv->AddItem(p.second.lot, p.second.count, eLootSourceType::PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
+				inv->AddItem(p.second.lot, p.second.count, eLootSourceType::LOOT_SOURCE_PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
 			}
 		}
 	}

dGame/Entity.h

@@ -10,7 +10,6 @@
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include "LDFFormat.h"
-#include "eKillType.h"
 
 namespace Loot {
 	class Info;
@@ -32,10 +31,7 @@ class Item;
 class Character;
 class EntityCallbackTimer;
 enum class eTriggerEventType;
-enum class eGameMasterLevel : uint8_t;
 enum class eReplicaComponentType : uint32_t;
-enum class eReplicaPacketType : uint8_t;
-enum class eCinematicEvent : uint32_t;
 
 namespace CppScripts {
 	class Script;
@@ -64,7 +60,7 @@ public:
 
 	Character* GetCharacter() const { return m_Character; }
 
-	eGameMasterLevel GetGMLevel() const { return m_GMLevel; }
+	uint8_t GetGMLevel() const { return m_GMLevel; }
 
 	uint8_t GetCollectibleID() const { return uint8_t(m_CollectibleID); }
 
@@ -112,7 +108,7 @@ public:
 
 	void SetCharacter(Character* value) { m_Character = value; }
 
-	void SetGMLevel(eGameMasterLevel value);
+	void SetGMLevel(uint8_t value);
 
 	void SetOwnerOverride(LWOOBJID value);
 
@@ -312,7 +308,7 @@ protected:
 
 	Entity* m_ParentEntity; //For spawners and the like
 	std::vector<Entity*> m_ChildEntities;
-	eGameMasterLevel m_GMLevel;
+	uint8_t m_GMLevel;
 	uint16_t m_CollectibleID;
 	std::vector<std::string> m_Groups;
 	uint16_t m_NetworkID;

dGame/EntityManager.cpp

@@ -20,10 +20,7 @@
 #include "MessageIdentifiers.h"
 #include "dConfig.h"
 #include "eTriggerEventType.h"
-#include "eObjectBits.h"
-#include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
-#include "eReplicaPacketType.h"
 
 EntityManager* EntityManager::m_Address = nullptr;
 
@@ -110,11 +107,11 @@ Entity* EntityManager::CreateEntity(EntityInfo info, User* user, Entity* parentE
 		if (!controller && info.lot != 14) {
 
 			// The client flags means the client should render the entity
-			GeneralUtils::SetBit(id, eObjectBits::CLIENT);
+			id = GeneralUtils::SetBit(id, OBJECT_BIT_CLIENT);
 
 			// Spawned entities require the spawned flag to render
 			if (info.spawnerID != 0) {
-				GeneralUtils::SetBit(id, eObjectBits::SPAWNED);
+				id = GeneralUtils::SetBit(id, OBJECT_BIT_SPAWNED);
 			}
 		}
 	}
@@ -161,9 +158,9 @@ void EntityManager::DestroyEntity(const LWOOBJID& objectID) {
 }
 
 void EntityManager::DestroyEntity(Entity* entity) {
-	if (!entity) return;
-
-	entity->TriggerEvent(eTriggerEventType::DESTROY, entity);
+	if (entity == nullptr) {
+		return;
+	}
 
 	const auto id = entity->GetObjectID();
 
@@ -180,11 +177,15 @@ void EntityManager::DestroyEntity(Entity* entity) {
 	ScheduleForDeletion(id);
 }
 
-void EntityManager::SerializeEntities() {
+void EntityManager::UpdateEntities(const float deltaTime) {
+	for (const auto& e : m_Entities) {
+		e.second->Update(deltaTime);
+	}
+
 	for (auto entry = m_EntitiesToSerialize.begin(); entry != m_EntitiesToSerialize.end(); entry++) {
 		auto* entity = GetEntity(*entry);
 
-		if (!entity) continue;
+		if (entity == nullptr) continue;
 
 		m_SerializationCounter++;
 
@@ -192,8 +193,8 @@ void EntityManager::SerializeEntities() {
 		stream.Write(static_cast<char>(ID_REPLICA_MANAGER_SERIALIZE));
 		stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));
 
-		entity->WriteBaseReplicaData(&stream, eReplicaPacketType::SERIALIZATION);
-		entity->WriteComponents(&stream, eReplicaPacketType::SERIALIZATION);
+		entity->WriteBaseReplicaData(&stream, PACKET_TYPE_SERIALIZATION);
+		entity->WriteComponents(&stream, PACKET_TYPE_SERIALIZATION);
 
 		if (entity->GetIsGhostingCandidate()) {
 			for (auto* player : Player::GetAllPlayers()) {
@@ -206,59 +207,45 @@ void EntityManager::SerializeEntities() {
 		}
 	}
 	m_EntitiesToSerialize.clear();
-}
 
-void EntityManager::KillEntities() {
 	for (auto entry = m_EntitiesToKill.begin(); entry != m_EntitiesToKill.end(); entry++) {
 		auto* entity = GetEntity(*entry);
 
-		if (!entity) {
-			Game::logger->Log("EntityManager", "Attempting to kill null entity %llu", *entry);
-			continue;
-		}
+		if (!entity) continue;
 
 		if (entity->GetScheduledKiller()) {
-			entity->Smash(entity->GetScheduledKiller()->GetObjectID(), eKillType::SILENT);
+			entity->Smash(entity->GetScheduledKiller()->GetObjectID(), SILENT);
 		} else {
-			entity->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
+			entity->Smash(LWOOBJID_EMPTY, SILENT);
 		}
 	}
 	m_EntitiesToKill.clear();
-}
 
-void EntityManager::DeleteEntities() {
 	for (auto entry = m_EntitiesToDelete.begin(); entry != m_EntitiesToDelete.end(); entry++) {
+
+		// Get all this info first before we delete the player.
 		auto entityToDelete = GetEntity(*entry);
+		auto networkIdToErase = entityToDelete->GetNetworkId();
+		const auto& ghostingToDelete = std::find(m_EntitiesToGhost.begin(), m_EntitiesToGhost.end(), entityToDelete);
+
 		if (entityToDelete) {
-			// Get all this info first before we delete the player.
-			auto networkIdToErase = entityToDelete->GetNetworkId();
-			const auto& ghostingToDelete = std::find(m_EntitiesToGhost.begin(), m_EntitiesToGhost.end(), entityToDelete);
-
-			delete entityToDelete;
-
+			// If we are a player run through the player destructor.
+			if (entityToDelete->IsPlayer()) {
+				delete dynamic_cast<Player*>(entityToDelete);
+			} else {
+				delete entityToDelete;
+			}
 			entityToDelete = nullptr;
-
 			if (networkIdToErase != 0) m_LostNetworkIds.push(networkIdToErase);
-
-			if (ghostingToDelete != m_EntitiesToGhost.end()) m_EntitiesToGhost.erase(ghostingToDelete);
-		} else {
-			Game::logger->Log("EntityManager", "Attempted to delete non-existent entity %llu", *entry);
 		}
+
+		if (ghostingToDelete != m_EntitiesToGhost.end()) m_EntitiesToGhost.erase(ghostingToDelete);
+
 		m_Entities.erase(*entry);
 	}
 	m_EntitiesToDelete.clear();
 }
 
-void EntityManager::UpdateEntities(const float deltaTime) {
-	for (const auto& e : m_Entities) {
-		e.second->Update(deltaTime);
-	}
-
-	SerializeEntities();
-	KillEntities();
-	DeleteEntities();
-}
-
 Entity* EntityManager::GetEntity(const LWOOBJID& objectId) const {
 	const auto& index = m_Entities.find(objectId);
 
@@ -324,11 +311,6 @@ const std::unordered_map<std::string, LWOOBJID>& EntityManager::GetSpawnPointEnt
 }
 
 void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr, const bool skipChecks) {
-	if (!entity) {
-		Game::logger->Log("EntityManager", "Attempted to construct null entity");
-		return;
-	}
-
 	if (entity->GetNetworkId() == 0) {
 		uint16_t networkId;
 
@@ -366,8 +348,8 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 	stream.Write(true);
 	stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));
 
-	entity->WriteBaseReplicaData(&stream, eReplicaPacketType::CONSTRUCTION);
-	entity->WriteComponents(&stream, eReplicaPacketType::CONSTRUCTION);
+	entity->WriteBaseReplicaData(&stream, PACKET_TYPE_CONSTRUCTION);
+	entity->WriteComponents(&stream, PACKET_TYPE_CONSTRUCTION);
 
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
 		if (skipChecks) {
@@ -388,7 +370,7 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 	// PacketUtils::SavePacket("[24]_"+std::to_string(entity->GetObjectID()) + "_" + std::to_string(m_SerializationCounter) + ".bin", (char*)stream.GetData(), stream.GetNumberOfBytesUsed());
 
 	if (entity->IsPlayer()) {
-		if (entity->GetGMLevel() > eGameMasterLevel::CIVILIAN) {
+		if (entity->GetGMLevel() > GAME_MASTER_LEVEL_CIVILIAN) {
 			GameMessages::SendToggleGMInvis(entity->GetObjectID(), true, sysAddr);
 		}
 	}
@@ -408,7 +390,9 @@ void EntityManager::ConstructAllEntities(const SystemAddress& sysAddr) {
 }
 
 void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr) {
-	if (!entity || entity->GetNetworkId() == 0) return;
+	if (entity->GetNetworkId() == 0) {
+		return;
+	}
 
 	RakNet::BitStream stream;
 
@@ -425,7 +409,9 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 }
 
 void EntityManager::SerializeEntity(Entity* entity) {
-	if (!entity || entity->GetNetworkId() == 0) return;
+	if (entity->GetNetworkId() == 0) {
+		return;
+	}
 
 	if (std::find(m_EntitiesToSerialize.begin(), m_EntitiesToSerialize.end(), entity->GetObjectID()) == m_EntitiesToSerialize.end()) {
 		m_EntitiesToSerialize.push_back(entity->GetObjectID());
@@ -601,7 +587,7 @@ void EntityManager::ScheduleForKill(Entity* entity) {
 
 	SwitchComponent* switchComp = entity->GetComponent<SwitchComponent>();
 	if (switchComp) {
-		entity->TriggerEvent(eTriggerEventType::DEACTIVATED, entity);
+		entity->TriggerEvent(eTriggerEventType::DEACTIVATED);
 	}
 
 	const auto objectId = entity->GetObjectID();

dGame/EntityManager.h

@@ -85,10 +85,6 @@ public:
 	const uint32_t GetHardcoreUscoreEnemiesMultiplier() { return m_HardcoreUscoreEnemiesMultiplier; };
 
 private:
-	void SerializeEntities();
-	void KillEntities();
-	void DeleteEntities();
-
 	static EntityManager* m_Address; //For singleton method
 	static std::vector<LWOMAPID> m_GhostingExcludedZones;
 	static std::vector<LOT> m_GhostingExcludedLOTs;

dGame/TradingManager.cpp

@@ -156,21 +156,21 @@ void Trade::Complete() {
 	}
 
 	// Now actually do the trade.
-	characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::TRADE);
-	characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::TRADE);
+	characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::LOOT_SOURCE_TRADE);
+	characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::LOOT_SOURCE_TRADE);
 
 	for (const auto& tradeItem : m_ItemsA) {
 		auto* itemToRemove = inventoryA->FindItemById(tradeItem.itemId);
 		if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
 		missionsA->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
-		inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
+		inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
 	}
 
 	for (const auto& tradeItem : m_ItemsB) {
 		auto* itemToRemove = inventoryB->FindItemById(tradeItem.itemId);
 		if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
 		missionsB->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
-		inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
+		inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
 	}
 
 	characterA->SaveXMLToDatabase();

dGame/User.cpp

@@ -6,14 +6,13 @@
 #include "Game.h"
 #include "dZoneManager.h"
 #include "eServerDisconnectIdentifiers.h"
-#include "eGameMasterLevel.h"
 
 User::User(const SystemAddress& sysAddr, const std::string& username, const std::string& sessionKey) {
 	m_AccountID = 0;
 	m_Username = "";
 	m_SessionKey = "";
 
-	m_MaxGMLevel = eGameMasterLevel::CIVILIAN; //The max GM level this account can assign to it's characters
+	m_MaxGMLevel = 0; //The max GM level this account can assign to it's characters
 	m_LastCharID = 0;
 
 	m_SessionKey = sessionKey;
@@ -34,7 +33,7 @@ User::User(const SystemAddress& sysAddr, const std::string& username, const std:
 	sql::ResultSet* res = stmt->executeQuery();
 	while (res->next()) {
 		m_AccountID = res->getUInt(1);
-		m_MaxGMLevel = static_cast<eGameMasterLevel>(res->getInt(2));
+		m_MaxGMLevel = res->getInt(2);
 		m_MuteExpire = 0; //res->getUInt64(3);
 	}
 

dGame/User.h

@@ -9,7 +9,6 @@
 #include <unordered_map>
 
 class Character;
-enum class eGameMasterLevel : uint8_t;
 
 struct BehaviorParams {
 	uint32_t behavior;
@@ -30,7 +29,7 @@ public:
 	std::string& GetSessionKey() { return m_SessionKey; }
 	SystemAddress& GetSystemAddress() { return m_SystemAddress; }
 
-	eGameMasterLevel GetMaxGMLevel() { return m_MaxGMLevel; }
+	uint32_t GetMaxGMLevel() { return m_MaxGMLevel; }
 	uint32_t GetLastCharID() { return m_LastCharID; }
 	void SetLastCharID(uint32_t newCharID) { m_LastCharID = newCharID; }
 
@@ -62,7 +61,7 @@ private:
 	std::string m_SessionKey;
 	SystemAddress m_SystemAddress;
 
-	eGameMasterLevel m_MaxGMLevel; //The max GM level this account can assign to it's characters
+	uint32_t m_MaxGMLevel; //The max GM level this account can assign to it's characters
 	uint32_t m_LastCharID;
 	std::vector<Character*> m_Characters;
 	LWOOBJID m_LoggedInCharID;

dGame/UserManager.cpp

@@ -22,12 +22,7 @@
 #include "SkillComponent.h"
 #include "AssetManager.h"
 #include "CDClientDatabase.h"
-#include "eObjectBits.h"
-#include "eGameMasterLevel.h"
-#include "eCharacterCreationResponse.h"
-#include "eRenameResponse.h"
-#include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
+#include "dMessageIdentifiers.h"
 
 UserManager* UserManager::m_Address = nullptr;
 
@@ -272,13 +267,13 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 	if (name != "" && !UserManager::IsNameAvailable(name)) {
 		Game::logger->Log("UserManager", "AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str());
-		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE);
+		WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_CUSTOM_NAME_IN_USE);
 		return;
 	}
 
 	if (!IsNameAvailable(predefinedName)) {
 		Game::logger->Log("UserManager", "AccountID: %i chose unavailable predefined name: %s", u->GetAccountID(), predefinedName.c_str());
-		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::PREDEFINED_NAME_IN_USE);
+		WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_PREDEFINED_NAME_IN_USE);
 		return;
 	}
 
@@ -297,7 +292,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 		if (overlapResult->next()) {
 			Game::logger->Log("UserManager", "Character object id unavailable, check objectidtracker!");
-			WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
+			WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_OBJECT_ID_UNAVAILABLE);
 			return;
 		}
 
@@ -317,16 +312,16 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 			std::stringstream xml2;
 
 			LWOOBJID lwoidforshirt = idforshirt;
-			GeneralUtils::SetBit(lwoidforshirt, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(lwoidforshirt, eObjectBits::PERSISTENT);
+			lwoidforshirt = GeneralUtils::SetBit(lwoidforshirt, OBJECT_BIT_CHARACTER);
+			lwoidforshirt = GeneralUtils::SetBit(lwoidforshirt, OBJECT_BIT_PERSISTENT);
 			xml2 << xmlSave1 << "<i l=\"" << shirtLOT << "\" id=\"" << lwoidforshirt << "\" s=\"0\" c=\"1\" eq=\"1\" b=\"1\"/>";
 
 			std::string xmlSave2 = xml2.str();
 
 			ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t idforpants) {
 				LWOOBJID lwoidforpants = idforpants;
-				GeneralUtils::SetBit(lwoidforpants, eObjectBits::CHARACTER);
-				GeneralUtils::SetBit(lwoidforpants, eObjectBits::PERSISTENT);
+				lwoidforpants = GeneralUtils::SetBit(lwoidforpants, OBJECT_BIT_CHARACTER);
+				lwoidforpants = GeneralUtils::SetBit(lwoidforpants, OBJECT_BIT_PERSISTENT);
 
 				std::stringstream xml3;
 				xml3 << xmlSave2 << "<i l=\"" << pantsLOT << "\" id=\"" << lwoidforpants << "\" s=\"1\" c=\"1\" eq=\"1\" b=\"1\"/>";
@@ -335,7 +330,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 				//Check to see if our name was pre-approved:
 				bool nameOk = IsNamePreapproved(name);
-				if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
+				if (!nameOk && u->GetMaxGMLevel() > 1) nameOk = true;
 
 				if (name != "") {
 					sql::PreparedStatement* stmt = Database::CreatePreppedStmt("INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`) VALUES (?,?,?,?,?,?)");
@@ -373,7 +368,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 				stmt->execute();
 				delete stmt;
 
-				WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
+				WorldPackets::SendCharacterCreationResponse(sysAddr, CREATION_RESPONSE_SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 				});
 			});
@@ -423,7 +418,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 			stmt->execute();
 			delete stmt;
 			CBITSTREAM;
-			PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
+			PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION);
 			bitStream.Write(objectID);
 			Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 		}
@@ -484,8 +479,8 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 	}
 
 	LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet);
-	GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
-	GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);
+	objectID = GeneralUtils::ClearBit(objectID, OBJECT_BIT_CHARACTER);
+	objectID = GeneralUtils::ClearBit(objectID, OBJECT_BIT_PERSISTENT);
 
 	uint32_t charID = static_cast<uint32_t>(objectID);
 	Game::logger->Log("UserManager", "Received char rename request for ID: %llu (%u)", objectID, charID);
@@ -503,10 +498,10 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 	if (!hasCharacter || !character) {
 		Game::logger->Log("UserManager", "User %i tried to rename a character that it does not own!", u->GetAccountID());
-		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
+		WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_UNKNOWN_ERROR);
 	} else if (hasCharacter && character) {
 		if (newName == character->GetName()) {
-			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
+			WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_NAME_UNAVAILABLE);
 			return;
 		}
 
@@ -520,7 +515,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 				delete stmt;
 
 				Game::logger->Log("UserManager", "Character %s now known as %s", character->GetName().c_str(), newName.c_str());
-				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
+				WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 			} else {
 				sql::PreparedStatement* stmt = Database::CreatePreppedStmt("UPDATE charinfo SET pending_name=?, needs_rename=0, last_login=? WHERE id=? LIMIT 1");
@@ -531,15 +526,15 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 				delete stmt;
 
 				Game::logger->Log("UserManager", "Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
-				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
+				WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 			}
 		} else {
-			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_IN_USE);
+			WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_NAME_IN_USE);
 		}
 	} else {
 		Game::logger->Log("UserManager", "Unknown error occurred when renaming character, either hasCharacter or character variable != true.");
-		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
+		WorldPackets::SendCharacterRenameResponse(sysAddr, RENAME_RESPONSE_UNKNOWN_ERROR);
 	}
 }
 

dGame/dBehaviors/AirMovementBehavior.cpp

@@ -13,7 +13,7 @@ void AirMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bi
 		return;
 	}
 
-	context->RegisterSyncBehavior(handle, this, branch, this->m_Timeout);
+	context->RegisterSyncBehavior(handle, this, branch);
 }
 
 void AirMovementBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
@@ -47,5 +47,4 @@ void AirMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitS
 }
 
 void AirMovementBehavior::Load() {
-	this->m_Timeout = (GetFloat("timeout_ms") / 1000.0f);
 }

dGame/dBehaviors/AirMovementBehavior.h

@@ -4,7 +4,13 @@
 class AirMovementBehavior final : public Behavior
 {
 public:
-	explicit AirMovementBehavior(const uint32_t behavior_id) : Behavior(behavior_id) {}
+
+	/*
+	 * Inherited
+	 */
+
+	explicit AirMovementBehavior(const uint32_t behavior_id) : Behavior(behavior_id) {
+	}
 
 	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 
@@ -13,6 +19,4 @@ public:
 	void Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 
 	void Load() override;
-private:
-	float m_Timeout;
 };

dGame/dBehaviors/AttackDelayBehavior.cpp

@@ -13,7 +13,7 @@ void AttackDelayBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bi
 	};
 
 	for (auto i = 0u; i < this->m_numIntervals; ++i) {
-		context->RegisterSyncBehavior(handle, this, branch, this->m_delay * i, m_ignoreInterrupts);
+		context->RegisterSyncBehavior(handle, this, branch, m_ignoreInterrupts);
 	}
 }
 

dGame/dBehaviors/BasicAttackBehavior.cpp

@@ -147,7 +147,7 @@ void BasicAttackBehavior::Calculate(BehaviorContext* context, RakNet::BitStream*
 	DoBehaviorCalculation(context, bitStream, branch);
 
 	const auto endAddress = bitStream->GetWriteOffset();
-	const uint16_t allocate = endAddress - startAddress;
+	const uint16_t allocate = endAddress - startAddress + 1;
 
 	bitStream->SetWriteOffset(allocatedAddress);
 	bitStream->Write(allocate);

dGame/dBehaviors/BehaviorContext.cpp

@@ -10,12 +10,12 @@
 
 #include <sstream>
 
+#include "dMessageIdentifiers.h"
 #include "DestroyableComponent.h"
 #include "EchoSyncSkill.h"
 #include "PhantomPhysicsComponent.h"
 #include "RebuildComponent.h"
 #include "eReplicaComponentType.h"
-#include "eConnectionType.h"
 
 BehaviorSyncEntry::BehaviorSyncEntry() {
 }
@@ -47,7 +47,7 @@ uint32_t BehaviorContext::GetUniqueSkillId() const {
 }
 
 
-void BehaviorContext::RegisterSyncBehavior(const uint32_t syncId, Behavior* behavior, const BehaviorBranchContext& branchContext, const float duration, bool ignoreInterrupts) {
+void BehaviorContext::RegisterSyncBehavior(const uint32_t syncId, Behavior* behavior, const BehaviorBranchContext& branchContext, bool ignoreInterrupts) {
 	auto entry = BehaviorSyncEntry();
 
 	entry.handle = syncId;
@@ -55,9 +55,6 @@ void BehaviorContext::RegisterSyncBehavior(const uint32_t syncId, Behavior* beha
 	entry.branchContext = branchContext;
 	entry.branchContext.isSync = true;
 	entry.ignoreInterrupts = ignoreInterrupts;
-	// Add 10 seconds + duration time to account for lag and give clients time to send their syncs to the server.
-	constexpr float lagTime = 10.0f;
-	entry.time = lagTime + duration;
 
 	this->syncEntries.push_back(entry);
 }
@@ -186,21 +183,6 @@ void BehaviorContext::SyncCalculation(const uint32_t syncId, const float time, B
 	this->syncEntries.push_back(entry);
 }
 
-void BehaviorContext::UpdatePlayerSyncs(float deltaTime) {
-	uint32_t i = 0;
-	while (i < this->syncEntries.size()) {
-		auto& entry = this->syncEntries.at(i);
-
-		entry.time -= deltaTime;
-
-		if (entry.time >= 0.0f) {
-			i++;
-			continue;
-		}
-		this->syncEntries.erase(this->syncEntries.begin() + i);
-	}
-}
-
 void BehaviorContext::InvokeEnd(const uint32_t id) {
 	std::vector<BehaviorEndEntry> entries;
 
@@ -253,7 +235,7 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) {
 			// Write message
 			RakNet::BitStream message;
 
-			PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+			PacketUtils::WriteHeader(message, CLIENT, MSG_CLIENT_GAME_MSG);
 			message.Write(this->originator);
 			echo.Serialize(&message);
 

dGame/dBehaviors/BehaviorContext.h

@@ -80,9 +80,7 @@ struct BehaviorContext
 
 	uint32_t GetUniqueSkillId() const;
 
-	void UpdatePlayerSyncs(float deltaTime);
-
-	void RegisterSyncBehavior(uint32_t syncId, Behavior* behavior, const BehaviorBranchContext& branchContext, const float duration, bool ignoreInterrupts = false);
+	void RegisterSyncBehavior(uint32_t syncId, Behavior* behavior, const BehaviorBranchContext& branchContext, bool ignoreInterrupts = false);
 
 	void RegisterTimerBehavior(Behavior* behavior, const BehaviorBranchContext& branchContext, LWOOBJID second = LWOOBJID_EMPTY);
 

dGame/dBehaviors/ChangeOrientationBehavior.cpp

@@ -2,35 +2,43 @@
 #include "BehaviorBranchContext.h"
 #include "BehaviorContext.h"
 #include "EntityManager.h"
+#include "BaseCombatAIComponent.h"
+
+void ChangeOrientationBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
+}
 
 void ChangeOrientationBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
-	Entity* sourceEntity;
-	if (this->m_orientCaster) sourceEntity = EntityManager::Instance()->GetEntity(context->originator);
-	else sourceEntity = EntityManager::Instance()->GetEntity(branch.target);
-	if (!sourceEntity) return;
+	if (!m_ToTarget) return; // TODO: Add the other arguments to this behavior
 
-	if (this->m_toTarget) {
-		Entity* destinationEntity;
-		if (this->m_orientCaster) destinationEntity = EntityManager::Instance()->GetEntity(branch.target);
-		else destinationEntity = EntityManager::Instance()->GetEntity(context->originator);
-		if (!destinationEntity) return;
+	auto* self = EntityManager::Instance()->GetEntity(context->originator);
+	auto* other = EntityManager::Instance()->GetEntity(branch.target);
 
-		sourceEntity->SetRotation(
-			NiQuaternion::LookAt(sourceEntity->GetPosition(), destinationEntity->GetPosition())
-		);
-	} else if (this->m_toAngle){
-		auto baseAngle = NiPoint3(0, 0, this->m_angle);
-		if (this->m_relative) baseAngle += sourceEntity->GetRotation().GetForwardVector();
-		sourceEntity->SetRotation(NiQuaternion::FromEulerAngles(baseAngle));
-	} else return;
-	EntityManager::Instance()->SerializeEntity(sourceEntity);
-	return;
+	if (self == nullptr || other == nullptr) return;
+
+	const auto source = self->GetPosition();
+	const auto destination = self->GetPosition();
+
+	if (m_OrientCaster) {
+		auto* baseCombatAIComponent = self->GetComponent<BaseCombatAIComponent>();
+
+		/*if (baseCombatAIComponent != nullptr)
+		{
+			baseCombatAIComponent->LookAt(destination);
+		}
+		else*/
+		{
+			self->SetRotation(NiQuaternion::LookAt(source, destination));
+		}
+
+		EntityManager::Instance()->SerializeEntity(self);
+	} else {
+		other->SetRotation(NiQuaternion::LookAt(destination, source));
+
+		EntityManager::Instance()->SerializeEntity(other);
+	}
 }
 
 void ChangeOrientationBehavior::Load() {
-	this->m_orientCaster = GetBoolean("orient_caster", true);
-	this->m_toTarget = GetBoolean("to_target", false);
-	this->m_toAngle = GetBoolean("to_angle", false);
-	this->m_angle = GetFloat("angle", 0.0f);
-	this->m_relative = GetBoolean("relative", false);
+	m_OrientCaster = GetBoolean("orient_caster");
+	m_ToTarget = GetBoolean("to_target");
 }

dGame/dBehaviors/ChangeOrientationBehavior.h

@@ -2,15 +2,24 @@
 
 #include "Behavior.h"
 
-class ChangeOrientationBehavior final : public Behavior {
+#include <vector>
+
+class ChangeOrientationBehavior final : public Behavior
+{
 public:
-	explicit ChangeOrientationBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {}
+	bool m_OrientCaster;
+	bool m_ToTarget;
+
+	/*
+	 * Inherited
+	 */
+
+	explicit ChangeOrientationBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
+	}
+
+	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+
 	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+
 	void Load() override;
-private:
-	bool m_orientCaster;
-	bool m_toTarget;
-	bool m_toAngle;
-	float m_angle;
-	bool m_relative;
 };

dGame/dBehaviors/ChargeUpBehavior.cpp

@@ -12,7 +12,7 @@ void ChargeUpBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitSt
 		return;
 	};
 
-	context->RegisterSyncBehavior(handle, this, branch, this->m_MaxDuration);
+	context->RegisterSyncBehavior(handle, this, branch);
 }
 
 void ChargeUpBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
@@ -24,5 +24,4 @@ void ChargeUpBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitStre
 
 void ChargeUpBehavior::Load() {
 	this->m_action = GetAction("action");
-	this->m_MaxDuration = GetFloat("max_duration");
 }

dGame/dBehaviors/ChargeUpBehavior.h

@@ -4,7 +4,14 @@
 class ChargeUpBehavior final : public Behavior
 {
 public:
-	explicit ChargeUpBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {}
+	Behavior* m_action;
+
+	/*
+	 * Inherited
+	 */
+
+	explicit ChargeUpBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
+	}
 
 	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 
@@ -13,7 +20,4 @@ public:
 	void Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 
 	void Load() override;
-private:
-	Behavior* m_action;
-	float m_MaxDuration;
 };

dGame/dBehaviors/ForceMovementBehavior.cpp

@@ -16,7 +16,7 @@ void ForceMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream*
 		Game::logger->Log("ForceMovementBehavior", "Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
-	context->RegisterSyncBehavior(handle, this, branch, this->m_Duration);
+	context->RegisterSyncBehavior(handle, this, branch);
 }
 
 void ForceMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {

dGame/dBehaviors/ImmunityBehavior.cpp

@@ -7,7 +7,6 @@
 #include "dLogger.h"
 #include "DestroyableComponent.h"
 #include "ControllablePhysicsComponent.h"
-#include "eStateChangeType.h"
 
 void ImmunityBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	auto* target = EntityManager::Instance()->GetEntity(branch.target);

dGame/dBehaviors/ProjectileAttackBehavior.cpp

@@ -6,7 +6,6 @@
 #include "dLogger.h"
 #include "SkillComponent.h"
 #include "../dWorldServer/ObjectIDManager.h"
-#include "eObjectBits.h"
 
 void ProjectileAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	LWOOBJID target{};
@@ -108,7 +107,7 @@ void ProjectileAttackBehavior::Calculate(BehaviorContext* context, RakNet::BitSt
 	for (auto i = 0u; i < this->m_projectileCount; ++i) {
 		auto id = static_cast<LWOOBJID>(ObjectIDManager::Instance()->GenerateObjectID());
 
-		GeneralUtils::SetBit(id, eObjectBits::SPAWNED);
+		id = GeneralUtils::SetBit(id, OBJECT_BIT_SPAWNED);
 
 		bitStream->Write(id);
 

dGame/dBehaviors/SwitchBehavior.cpp

@@ -30,7 +30,7 @@ void SwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStre
 
 	Game::logger->LogDebug("SwitchBehavior", "[%i] State: (%d), imagination: (%i) / (%f)", entity->GetLOT(), state, destroyableComponent->GetImagination(), destroyableComponent->GetMaxImagination());
 
-	if (state) {
+	if (state || (entity->GetLOT() == 8092 && destroyableComponent->GetImagination() >= m_imagination)) {
 		this->m_actionTrue->Handle(context, bitStream, branch);
 	} else {
 		this->m_actionFalse->Handle(context, bitStream, branch);

dGame/dBehaviors/SwitchMultipleBehavior.cpp

@@ -22,9 +22,13 @@ void SwitchMultipleBehavior::Handle(BehaviorContext* context, RakNet::BitStream*
 	for (unsigned int i = 0; i < this->m_behaviors.size(); i++) {
 
 		const double data = this->m_behaviors.at(i).first;
-		trigger = i;
 
-		if (value <= data) break;
+		if (value <= data) {
+
+			trigger = i;
+
+			break;
+		}
 	}
 
 	auto* behavior = this->m_behaviors.at(trigger).second;

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -248,7 +248,7 @@ void BaseCombatAIComponent::CalculateCombat(const float deltaTime) {
 	if (rebuild != nullptr) {
 		const auto state = rebuild->GetState();
 
-		if (state != eRebuildState::COMPLETED) {
+		if (state != REBUILD_COMPLETED) {
 			return;
 		}
 	}
@@ -566,7 +566,7 @@ bool BaseCombatAIComponent::IsEnemy(LWOOBJID target) const {
 	if (quickbuild != nullptr) {
 		const auto state = quickbuild->GetState();
 
-		if (state != eRebuildState::COMPLETED) {
+		if (state != REBUILD_COMPLETED) {
 			return false;
 		}
 	}

dGame/dComponents/BouncerComponent.cpp

@@ -7,7 +7,6 @@
 #include "dLogger.h"
 #include "GameMessages.h"
 #include <BitStream.h>
-#include "eTriggerEventType.h"
 
 BouncerComponent::BouncerComponent(Entity* parent) : Component(parent) {
 	m_PetEnabled = false;
@@ -47,10 +46,8 @@ void BouncerComponent::SetPetBouncerEnabled(bool value) {
 	EntityManager::Instance()->SerializeEntity(m_Parent);
 
 	if (value) {
-		m_Parent->TriggerEvent(eTriggerEventType::PET_ON_SWITCH, m_Parent);
 		GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), 1513, u"create", "PetOnSwitch", LWOOBJID_EMPTY, 1, 1, true);
 	} else {
-		m_Parent->TriggerEvent(eTriggerEventType::PET_OFF_SWITCH, m_Parent);
 		GameMessages::SendStopFXEffect(m_Parent, true, "PetOnSwitch");
 	}
 

dGame/dComponents/CMakeLists.txt

@@ -7,6 +7,7 @@ set(DGAME_DCOMPONENTS_SOURCES "BaseCombatAIComponent.cpp"
 	"ControllablePhysicsComponent.cpp"
 	"DestroyableComponent.cpp"
 	"InventoryComponent.cpp"
+	"ItemComponent.cpp"
 	"LevelProgressionComponent.cpp"
 	"LUPExhibitComponent.cpp"
 	"MissionComponent.cpp"
@@ -15,6 +16,7 @@ set(DGAME_DCOMPONENTS_SOURCES "BaseCombatAIComponent.cpp"
 	"ModuleAssemblyComponent.cpp"
 	"MovementAIComponent.cpp"
 	"MovingPlatformComponent.cpp"
+	"MutableModelBehaviorComponent.cpp"
 	"PetComponent.cpp"
 	"PhantomPhysicsComponent.cpp"
 	"PlayerForcedMovementComponent.cpp"

dGame/dComponents/CharacterComponent.cpp

@@ -14,8 +14,6 @@
 #include "GameMessages.h"
 #include "Item.h"
 #include "AMFFormat.h"
-#include "eGameMasterLevel.h"
-#include "eGameActivity.h"
 
 CharacterComponent::CharacterComponent(Entity* parent, Character* character) : Component(parent) {
 	m_Character = character;
@@ -36,7 +34,7 @@ CharacterComponent::CharacterComponent(Entity* parent, Character* character) : C
 	m_EditorLevel = m_GMLevel;
 	m_Reputation = 0;
 
-	m_CurrentActivity = eGameActivity::NONE;
+	m_CurrentActivity = 0;
 	m_CountryCode = 0;
 	m_LastUpdateTimestamp = std::time(nullptr);
 }
@@ -167,9 +165,9 @@ void CharacterComponent::SetPvpEnabled(const bool value) {
 	m_PvpEnabled = value;
 }
 
-void CharacterComponent::SetGMLevel(eGameMasterLevel gmlevel) {
+void CharacterComponent::SetGMLevel(int gmlevel) {
 	m_DirtyGMInfo = true;
-	if (gmlevel > eGameMasterLevel::CIVILIAN) m_IsGM = true;
+	if (gmlevel > 0) m_IsGM = true;
 	else m_IsGM = false;
 	m_GMLevel = gmlevel;
 }
@@ -241,7 +239,7 @@ void CharacterComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 	// End custom attributes
 	//
 
-	if (m_GMLevel > eGameMasterLevel::CIVILIAN) {
+	if (m_GMLevel > 0) {
 		m_IsGM = true;
 		m_DirtyGMInfo = true;
 		m_EditorLevel = m_GMLevel;

dGame/dComponents/CharacterComponent.h

@@ -11,8 +11,6 @@
 #include "tinyxml2.h"
 #include "eReplicaComponentType.h"
 
-enum class eGameActivity : uint32_t;
-
 /**
  * The statistics that can be achieved per zone
  */
@@ -114,13 +112,13 @@ public:
 	 * Gets the current activity that the character is partaking in, see ScriptedActivityComponent for more details
 	 * @return the current activity that the character is partaking in
 	 */
-	const eGameActivity GetCurrentActivity() const { return m_CurrentActivity; }
+	const uint32_t GetCurrentActivity() const { return m_CurrentActivity; }
 
 	/**
 	 * Set the current activity of the character, see ScriptedActivityComponent for more details
 	 * @param currentActivity the activity to set
 	 */
-	void SetCurrentActivity(eGameActivity currentActivity) { m_CurrentActivity = currentActivity; m_DirtyCurrentActivity = true; }
+	void SetCurrentActivity(uint32_t currentActivity) { m_CurrentActivity = currentActivity; m_DirtyCurrentActivity = true; }
 
 	/**
 	 * Gets if the entity is currently racing
@@ -180,7 +178,7 @@ public:
 	 * Sets the GM level of the character, should be called in the entity. Here it's set for serialization
 	 * @param gmlevel the gm level to set
 	 */
-	void SetGMLevel(eGameMasterLevel gmlevel);
+	void SetGMLevel(int gmlevel);
 
 	/**
 	 * Initializes the player statistics from the string stored in the XML
@@ -335,7 +333,7 @@ private:
 	/**
 	 * The current GM level of this character (anything > 0 counts as a GM)
 	 */
-	eGameMasterLevel m_GMLevel;
+	unsigned char m_GMLevel;
 
 	/**
 	 * Whether the character has HF enabled
@@ -345,7 +343,7 @@ private:
 	/**
 	 * The level of the character in HF
 	 */
-	eGameMasterLevel m_EditorLevel;
+	unsigned char m_EditorLevel;
 
 	/**
 	 * Whether the currently active activity has been changed
@@ -355,7 +353,7 @@ private:
 	/**
 	 * The ID of the curently active activity
 	 */
-	eGameActivity m_CurrentActivity;
+	int m_CurrentActivity;
 
 	/**
 	 * Whether the social info has been changed

dGame/dComponents/ControllablePhysicsComponent.cpp

@@ -13,7 +13,6 @@
 #include "Character.h"
 #include "dZoneManager.h"
 #include "LevelProgressionComponent.h"
-#include "eStateChangeType.h"
 
 ControllablePhysicsComponent::ControllablePhysicsComponent(Entity* entity) : Component(entity) {
 	m_Position = {};

dGame/dComponents/ControllablePhysicsComponent.h

@@ -14,7 +14,6 @@
 
 class Entity;
 class dpEntity;
-enum class eStateChangeType : uint32_t;
 
 /**
  * Handles the movement of controllable Entities, e.g. enemies and players

dGame/dComponents/DestroyableComponent.cpp

@@ -33,8 +33,6 @@
 #include "dZoneManager.h"
 #include "WorldConfig.h"
 #include "eMissionTaskType.h"
-#include "eStateChangeType.h"
-#include "eGameActivity.h"
 
 #include "CDComponentsRegistryTable.h"
 
@@ -470,7 +468,7 @@ bool DestroyableComponent::IsKnockbackImmune() const {
 	auto* characterComponent = m_Parent->GetComponent<CharacterComponent>();
 	auto* inventoryComponent = m_Parent->GetComponent<InventoryComponent>();
 
-	if (characterComponent != nullptr && inventoryComponent != nullptr && characterComponent->GetCurrentActivity() == eGameActivity::QUICKBUILDING) {
+	if (characterComponent != nullptr && inventoryComponent != nullptr && characterComponent->GetCurrentActivity() == eGameActivities::ACTIVITY_QUICKBUILDING) {
 		const auto hasPassive = inventoryComponent->HasAnyPassive({
 			eItemSetPassiveAbilityID::EngineerRank2, eItemSetPassiveAbilityID::EngineerRank3,
 			eItemSetPassiveAbilityID::SummonerRank2, eItemSetPassiveAbilityID::SummonerRank3,
@@ -516,7 +514,7 @@ bool DestroyableComponent::CheckValidity(const LWOOBJID target, const bool ignor
 	if (targetQuickbuild != nullptr) {
 		const auto state = targetQuickbuild->GetState();
 
-		if (state != eRebuildState::COMPLETED) {
+		if (state != REBUILD_COMPLETED) {
 			return false;
 		}
 	}
@@ -805,7 +803,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 				coinsTotal -= coinsToLose;
 
 				LootGenerator::Instance().DropLoot(m_Parent, m_Parent, -1, coinsToLose, coinsToLose);
-				character->SetCoins(coinsTotal, eLootSourceType::PICKUP);
+				character->SetCoins(coinsTotal, eLootSourceType::LOOT_SOURCE_PICKUP);
 			}
 		}
 
@@ -994,7 +992,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
 		auto uscoreToLose = uscore * (EntityManager::Instance()->GetHardcoreLoseUscoreOnDeathPercent() / 100);
 		character->SetUScore(uscore - uscoreToLose);
 
-		GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::MISSION);
+		GameMessages::SendModifyLEGOScore(m_Parent, m_Parent->GetSystemAddress(), -uscoreToLose, eLootSourceType::LOOT_SOURCE_MISSION);
 
 		if (EntityManager::Instance()->GetHardcoreDropinventoryOnDeath()) {
 			//drop all items from inventory:
@@ -1025,7 +1023,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
 			auto coins = chars->GetCoins();
 
 			//lose all coins:
-			chars->SetCoins(0, eLootSourceType::NONE);
+			chars->SetCoins(0, eLootSourceType::LOOT_SOURCE_NONE);
 
 			//drop all coins:
 			GameMessages::SendDropClientLoot(m_Parent, source, LOT_NULL, coins, m_Parent->GetPosition());
@@ -1049,7 +1047,7 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source){
 			int uscore = maxHealth * EntityManager::Instance()->GetHardcoreUscoreEnemiesMultiplier();
 
 			playerStats->SetUScore(playerStats->GetUScore() + uscore);
-			GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::MISSION);
+			GameMessages::SendModifyLEGOScore(player, player->GetSystemAddress(), uscore, eLootSourceType::LOOT_SOURCE_MISSION);
 
 			EntityManager::Instance()->SerializeEntity(m_Parent);
 		}

dGame/dComponents/DestroyableComponent.h

@@ -11,7 +11,6 @@
 namespace CppScripts {
 	class Script;
 }; //! namespace CppScripts
-enum class eStateChangeType : uint32_t;
 
 /**
  * Represents the stats of an entity, for example its health, imagination and armor. Also handles factions, which

dGame/dComponents/InventoryComponent.cpp

@@ -29,8 +29,6 @@
 #include "eUnequippableActiveType.h"
 #include "CppScripts.h"
 #include "eMissionTaskType.h"
-#include "eStateChangeType.h"
-#include "eUseItemResponse.h"
 
 #include "CDComponentsRegistryTable.h"
 #include "CDInventoryComponentTable.h"
@@ -358,7 +356,7 @@ void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType in
 
 			left -= delta;
 
-			AddItem(lot, delta, eLootSourceType::NONE, inventory, {}, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, LWOOBJID_EMPTY, origin->GetType(), 0, false, preferredSlot);
+			AddItem(lot, delta, eLootSourceType::LOOT_SOURCE_NONE, inventory, {}, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, LWOOBJID_EMPTY, origin->GetType(), 0, false, preferredSlot);
 
 			item->SetCount(item->GetCount() - delta, false, false);
 
@@ -373,7 +371,7 @@ void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType in
 
 		const auto delta = std::min<uint32_t>(item->GetCount(), count);
 
-		AddItem(lot, delta, eLootSourceType::NONE, inventory, config, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, subkey, origin->GetType(), 0, item->GetBound(), preferredSlot);
+		AddItem(lot, delta, eLootSourceType::LOOT_SOURCE_NONE, inventory, config, LWOOBJID_EMPTY, showFlyingLot, isModMoveAndEquip, subkey, origin->GetType(), 0, item->GetBound(), preferredSlot);
 
 		item->SetCount(item->GetCount() - delta, false, false);
 	}
@@ -725,7 +723,6 @@ void InventoryComponent::Serialize(RakNet::BitStream* outBitStream, const bool b
 			outBitStream->Write(item.id);
 			outBitStream->Write(item.lot);
 
-			// subkey
 			outBitStream->Write0();
 
 			outBitStream->Write(item.count > 0);
@@ -733,7 +730,7 @@ void InventoryComponent::Serialize(RakNet::BitStream* outBitStream, const bool b
 
 			outBitStream->Write(item.slot != 0);
 			if (item.slot != 0) outBitStream->Write<uint16_t>(item.slot);
-			//invtype
+
 			outBitStream->Write0();
 
 			bool flag = !item.config.empty();
@@ -764,7 +761,7 @@ void InventoryComponent::Serialize(RakNet::BitStream* outBitStream, const bool b
 	} else {
 		outBitStream->Write(false);
 	}
-	//EquippedModelTransform
+
 	outBitStream->Write(false);
 }
 
@@ -1250,7 +1247,7 @@ void InventoryComponent::SpawnPet(Item* item) {
 	auto destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
 
 	if (Game::config->GetValue("pets_take_imagination") == "1" && destroyableComponent && destroyableComponent->GetImagination() <= 0) {
-		GameMessages::SendUseItemRequirementsResponse(m_Parent->GetObjectID(), m_Parent->GetSystemAddress(), eUseItemResponse::NoImaginationForPet);
+		GameMessages::SendUseItemRequirementsResponse(m_Parent->GetObjectID(), m_Parent->GetSystemAddress(), UseItemResponse::NoImaginationForPet);
 		return;
 	}
 

dGame/dComponents/InventoryComponent.h

@@ -21,7 +21,6 @@
 #include "PossessorComponent.h"
 #include "eInventoryType.h"
 #include "eReplicaComponentType.h"
-#include "eLootSourceType.h"
 
 class Entity;
 class ItemSet;
@@ -100,7 +99,7 @@ public:
 	void AddItem(
 		LOT lot,
 		uint32_t count,
-		eLootSourceType lootSourceType = eLootSourceType::NONE,
+		eLootSourceType lootSourceType = eLootSourceType::LOOT_SOURCE_NONE,
 		eInventoryType inventoryType = INVALID,
 		const std::vector<LDFBaseData*>& config = {},
 		LWOOBJID parent = LWOOBJID_EMPTY,

dGame/dComponents/ItemComponent.cpp

@@ -0,0 +1,33 @@
+#include "ItemComponent.h"
+#include "Entity.h"
+#include "eUgcModerationStatus.h"
+
+
+ItemComponent::ItemComponent(Entity* parent) : Component(parent) {
+	m_Parent = parent;
+
+	m_DirtyItemInfo = false;
+
+	m_UgId = m_Parent->GetVarAs<LWOOBJID>(u"userModelID");
+	if (m_UgId == LWOOBJID_EMPTY) m_UgId = m_Parent->GetObjectID();
+
+	m_UgModerationStatus = eUgcModerationStatus::NoStatus;
+
+	m_UgDescription = u"";
+}
+
+void ItemComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags) {
+
+	outBitStream->Write(m_DirtyItemInfo || bIsInitialUpdate);
+	if (m_DirtyItemInfo || bIsInitialUpdate){
+		outBitStream->Write(m_UgId);
+		outBitStream->Write(m_UgModerationStatus);
+		outBitStream->Write(m_UgDescription != u"");
+		if (m_UgDescription != u""){
+			outBitStream->Write<uint32_t>(m_UgDescription.length());
+			for (uint16_t character : m_UgDescription) outBitStream->Write(character);
+		}
+		m_DirtyItemInfo = false;
+	}
+
+}

dGame/dComponents/ItemComponent.h

@@ -0,0 +1,50 @@
+#pragma once
+#include "dCommonVars.h"
+#include "RakNetTypes.h"
+#include "NiPoint3.h"
+#include "NiQuaternion.h"
+#include "Component.h"
+#include "eReplicaComponentType.h"
+
+class Entity;
+enum class eUgcModerationStatus : uint32_t;
+
+class ItemComponent : public Component {
+public:
+	static const eReplicaComponentType ComponentType = eReplicaComponentType::ITEM;
+
+	ItemComponent(Entity* parent);
+
+	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags);
+
+	void SetUgId(LWOOBJID id) { m_UgId = id; m_DirtyItemInfo = true; };
+	LWOOBJID GetUgId() { return m_UgId; };
+
+	void SetUgModerationStatus(eUgcModerationStatus status) { m_UgModerationStatus = status; m_DirtyItemInfo = true; };
+	eUgcModerationStatus GetUgModerationStatus() { return m_UgModerationStatus; };
+
+	void SetUgDescription(std::u16string description) { m_UgDescription = description; m_DirtyItemInfo = true; };
+	std::u16string  GetUgDescription() { return m_UgDescription;};
+
+private:
+
+	/**
+	 * If we have change the item info
+	 */
+	bool m_DirtyItemInfo;
+
+	/**
+	 * The ID of the user that made the model
+	 */
+	LWOOBJID m_UgId;
+
+	/**
+	 *
+	 */
+	eUgcModerationStatus m_UgModerationStatus;
+
+	/**
+	 * The user generated description
+	 */
+	std::u16string m_UgDescription;
+};

dGame/dComponents/LevelProgressionComponent.cpp

@@ -59,7 +59,7 @@ void LevelProgressionComponent::HandleLevelUp() {
 	for (auto* reward : rewards) {
 		switch (reward->rewardType) {
 		case 0:
-			inventoryComponent->AddItem(reward->value, reward->count, eLootSourceType::LEVEL_REWARD);
+			inventoryComponent->AddItem(reward->value, reward->count, eLootSourceType::LOOT_SOURCE_LEVEL_REWARD);
 			break;
 		case 4:
 		{

dGame/dComponents/ModelComponent.cpp

@@ -1,31 +1,23 @@
 #include "ModelComponent.h"
 #include "Entity.h"
+#include "ePhysicsBehaviorType.h"
 
 ModelComponent::ModelComponent(Entity* parent) : Component(parent) {
+	m_DirtyModelInfo = false;
+	m_IsPickable = false;
+	m_PhysicsType = ePhysicsBehaviorType::STANDARD;
 	m_OriginalPosition = m_Parent->GetDefaultPosition();
 	m_OriginalRotation = m_Parent->GetDefaultRotation();
-
-	m_userModelID = m_Parent->GetVarAs<LWOOBJID>(u"userModelID");
 }
 
 void ModelComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags) {
-	// ItemComponent Serialization.  Pets do not get this serialization.
-	if (!m_Parent->HasComponent(eReplicaComponentType::PET)) {
-		outBitStream->Write1();
-		outBitStream->Write<LWOOBJID>(m_userModelID != LWOOBJID_EMPTY ? m_userModelID : m_Parent->GetObjectID());
-		outBitStream->Write<int>(0);
-		outBitStream->Write0();
+	outBitStream->Write(m_DirtyModelInfo || bIsInitialUpdate);
+	if (m_DirtyModelInfo || bIsInitialUpdate) {
+		outBitStream->Write(m_IsPickable);
+		outBitStream->Write(m_PhysicsType);
+		outBitStream->Write(m_OriginalPosition);
+		outBitStream->Write(m_OriginalRotation);
+		m_DirtyModelInfo = false;
 	}
-
-	//actual model component:
-	outBitStream->Write1(); // Yes we are writing model info
-	outBitStream->Write0(); // Is pickable
-	outBitStream->Write<uint32_t>(2); // Physics type
-	outBitStream->Write(m_OriginalPosition); // Original position
-	outBitStream->Write(m_OriginalRotation); // Original rotation
-
-	outBitStream->Write1(); // We are writing behavior info
-	outBitStream->Write<uint32_t>(0); // Number of behaviors
-	outBitStream->Write1(); // Is this model paused
-	if (bIsInitialUpdate) outBitStream->Write0(); // We are not writing model editing info
 }
+

dGame/dComponents/ModelComponent.h

@@ -7,6 +7,7 @@
 #include "eReplicaComponentType.h"
 
 class Entity;
+enum class ePhysicsBehaviorType : int32_t;
 
 /**
  * Component that represents entities that are a model, e.g. collectible models and BBB models.
@@ -29,7 +30,7 @@ public:
 	 * Sets the original position of the model
 	 * @param pos the original position to set
 	 */
-	void SetPosition(const NiPoint3& pos) { m_OriginalPosition = pos; }
+	void SetPosition(const NiPoint3& pos) { m_OriginalPosition = pos; m_DirtyModelInfo = true; }
 
 	/**
 	 * Returns the original rotation of the model
@@ -41,10 +42,25 @@ public:
 	 * Sets the original rotation of the model
 	 * @param rot the original rotation to set
 	 */
-	void SetRotation(const NiQuaternion& rot) { m_OriginalRotation = rot; }
+	void SetRotation(const NiQuaternion& rot) { m_OriginalRotation = rot; m_DirtyModelInfo = true; }
 
 private:
 
+	/**
+	 * if the model info has changed
+	 */
+	bool m_DirtyModelInfo;
+
+	/**
+	 * If the model is pickable
+	 */
+	bool m_IsPickable;
+
+	/**
+	 * the phsyics type of the model
+	 */
+	ePhysicsBehaviorType m_PhysicsType;
+
 	/**
 	 * The original position of the model
 	 */
@@ -55,8 +71,4 @@ private:
 	 */
 	NiQuaternion m_OriginalRotation;
 
-	/**
-	 * The ID of the user that made the model
-	 */
-	LWOOBJID m_userModelID;
 };

dGame/dComponents/ModuleAssemblyComponent.h

@@ -14,7 +14,7 @@ class ModuleAssemblyComponent : public Component {
 public:
 	static const eReplicaComponentType ComponentType = eReplicaComponentType::MODULE_ASSEMBLY;
 
-	ModuleAssemblyComponent(Entity* parent);
+	ModuleAssemblyComponent(Entity* MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION);
 	~ModuleAssemblyComponent() override;
 
 	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags);

dGame/dComponents/MutableModelBehaviorComponent.cpp

@@ -0,0 +1,30 @@
+#include "MutableModelBehaviorComponent.h"
+#include "Entity.h"
+
+MutableModelBehaviorComponent::MutableModelBehaviorComponent(Entity* parent) : Component(parent) {
+	m_DirtyModelBehaviorInfo = false;
+	m_BehaviorCount = 0;
+	m_IsPaused = true;
+
+	m_DirtyModelEditingInfo = false;
+	m_OldObjId = LWOOBJID_EMPTY;
+	m_Editor = LWOOBJID_EMPTY;
+
+}
+
+void MutableModelBehaviorComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate, unsigned int& flags) {
+	outBitStream->Write(m_DirtyModelBehaviorInfo || bIsInitialUpdate);
+	if (m_DirtyModelBehaviorInfo){
+		outBitStream->Write(m_BehaviorCount);
+		outBitStream->Write(m_IsPaused);
+		m_DirtyModelBehaviorInfo = false;
+	}
+
+	outBitStream->Write(m_DirtyModelEditingInfo && bIsInitialUpdate);
+	if (m_DirtyModelEditingInfo && bIsInitialUpdate) {
+		outBitStream->Write(m_OldObjId);
+		outBitStream->Write(m_Editor);
+		m_DirtyModelEditingInfo = false;
+	}
+}
+