Breakout message identifiers (#1065)

and make them scope enums

dAuthServer/AuthServer.cpp

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

dChatServer/ChatPacketHandler.cpp

@@ -3,7 +3,6 @@
 #include "Database.h"
 #include <vector>
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 #include "Game.h"
 #include "dServer.h"
 #include "GeneralUtils.h"
@@ -13,6 +12,11 @@
 #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;
 
@@ -72,11 +76,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::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());
@@ -413,10 +417,10 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 		const auto otherName = std::string(otherMember->playerName.c_str());
 
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(otherMember->playerID);
 
-		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(otherMember->playerID);
 		bitStream.Write<uint8_t>(8);
 		bitStream.Write<unsigned int>(69);
@@ -452,10 +456,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the sender:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(goonA->playerID);
 
-		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -475,10 +479,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the receiver:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(goonB->playerID);
 
-		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -717,11 +721,11 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TEAM_INVITE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
 
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write(sender->playerID);
@@ -732,14 +736,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, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_INVITE_CONFIRM);
+	bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM);
 
 	bitStream.Write(bLeaderIsFreeTrial);
 	bitStream.Write(i64LeaderID);
@@ -759,14 +763,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, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_GET_STATUS_RESPONSE);
+	bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE);
 
 	bitStream.Write(i64LeaderID);
 	bitStream.Write(i64LeaderZoneID);
@@ -784,14 +788,14 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI
 
 void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_LEADER);
+	bitStream.Write(eGameMessageType::TEAM_SET_LEADER);
 
 	bitStream.Write(i64PlayerID);
 
@@ -801,14 +805,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, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_ADD_PLAYER);
+	bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER);
 
 	bitStream.Write(bIsFreeTrial);
 	bitStream.Write(bLocal);
@@ -830,14 +834,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, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_REMOVE_PLAYER);
+	bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER);
 
 	bitStream.Write(bDisband);
 	bitStream.Write(bIsKicked);
@@ -856,14 +860,14 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband
 
 void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_OFF_WORLD_FLAG);
+	bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG);
 
 	bitStream.Write(i64PlayerID);
 	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID()) {
@@ -890,11 +894,11 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(friendData->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_UPDATE_FRIEND_NOTIFY);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
 	std::string playerName = playerData->playerName.c_str();
@@ -929,11 +933,11 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	}
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_REQUEST);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.
 
@@ -945,11 +949,11 @@ void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sen
 	if (!receiver || !sender) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	// Portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::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);
@@ -970,11 +974,11 @@ void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& pers
 	if (!receiver) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_REMOVE_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	PacketUtils::WritePacketWString(personToRemove, 33, &bitStream);
 

dChatServer/ChatServer.cpp

@@ -9,19 +9,23 @@
 #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;
@@ -68,7 +72,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;
 	}
 
@@ -199,25 +203,25 @@ void HandlePacket(Packet* packet) {
 		Game::logger->Log("ChatServer", "A server is connecting, awaiting user list.");
 	}
 
-	if (packet->data[1] == CHAT_INTERNAL) {
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
-		switch (packet->data[3]) {
+		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
-		case MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION:
+		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
 			playerContainer.InsertPlayer(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION:
+		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
 			playerContainer.RemovePlayer(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_MUTE_UPDATE:
+		case eChatInternalMessageType::MUTE_UPDATE:
 			playerContainer.MuteUpdate(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_CREATE_TEAM:
+		case eChatInternalMessageType::CREATE_TEAM:
 			playerContainer.CreateTeamServer(packet);
 			break;
 
-		case MSG_CHAT_INTERNAL_ANNOUNCEMENT: {
+		case eChatInternalMessageType::ANNOUNCEMENT: {
 			//we just forward this packet to every connected server
 			CINSTREAM;
 			Game::server->Send(&inStream, packet->systemAddress, true); //send to everyone except origin
@@ -229,67 +233,67 @@ void HandlePacket(Packet* packet) {
 		}
 	}
 
-	if (packet->data[1] == CHAT) {
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT) {
-		switch (packet->data[3]) {
+		switch (static_cast<eChatMessageType>(packet->data[3])) {
-		case MSG_CHAT_GET_FRIENDS_LIST:
+		case eChatMessageType::GET_FRIENDS_LIST:
 			ChatPacketHandler::HandleFriendlistRequest(packet);
 			break;
 
-		case MSG_CHAT_GET_IGNORE_LIST:
+		case eChatMessageType::GET_IGNORE_LIST:
 			Game::logger->Log("ChatServer", "Asked for ignore list, but is unimplemented right now.");
 			break;
 
-		case MSG_CHAT_TEAM_GET_STATUS:
+		case eChatMessageType::TEAM_GET_STATUS:
 			ChatPacketHandler::HandleTeamStatusRequest(packet);
 			break;
 
-		case MSG_CHAT_ADD_FRIEND_REQUEST:
+		case eChatMessageType::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 MSG_CHAT_ADD_FRIEND_RESPONSE:
+		case eChatMessageType::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 MSG_CHAT_REMOVE_FRIEND:
+		case eChatMessageType::REMOVE_FRIEND:
 			ChatPacketHandler::HandleRemoveFriend(packet);
 			break;
 
-		case MSG_CHAT_GENERAL_CHAT_MESSAGE:
+		case eChatMessageType::GENERAL_CHAT_MESSAGE:
 			ChatPacketHandler::HandleChatMessage(packet);
 			break;
 
-		case MSG_CHAT_PRIVATE_CHAT_MESSAGE:
+		case eChatMessageType::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 MSG_CHAT_TEAM_INVITE:
+		case eChatMessageType::TEAM_INVITE:
 			ChatPacketHandler::HandleTeamInvite(packet);
 			break;
 
-		case MSG_CHAT_TEAM_INVITE_RESPONSE:
+		case eChatMessageType::TEAM_INVITE_RESPONSE:
 			ChatPacketHandler::HandleTeamInviteResponse(packet);
 			break;
 
-		case MSG_CHAT_TEAM_LEAVE:
+		case eChatMessageType::TEAM_LEAVE:
 			ChatPacketHandler::HandleTeamLeave(packet);
 			break;
 
-		case MSG_CHAT_TEAM_SET_LEADER:
+		case eChatMessageType::TEAM_SET_LEADER:
 			ChatPacketHandler::HandleTeamPromote(packet);
 			break;
 
-		case MSG_CHAT_TEAM_KICK:
+		case eChatMessageType::TEAM_KICK:
 			ChatPacketHandler::HandleTeamKick(packet);
 			break;
 
-		case MSG_CHAT_TEAM_SET_LOOT:
+		case eChatMessageType::TEAM_SET_LOOT:
 			ChatPacketHandler::HandleTeamLootOption(packet);
 			break;
 
@@ -298,9 +302,9 @@ void HandlePacket(Packet* packet) {
 		}
 	}
 
-	if (packet->data[1] == WORLD) {
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
-		switch (packet->data[3]) {
+		switch (static_cast<eWorldMessageType>(packet->data[3])) {
-		case MSG_WORLD_CLIENT_ROUTE_PACKET: {
+		case eWorldMessageType::ROUTE_PACKET: {
 			Game::logger->Log("ChatServer", "Routing packet from world");
 			break;
 		}

dChatServer/PlayerContainer.cpp

@@ -6,9 +6,10 @@
 #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() {
 }
@@ -149,7 +150,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -348,7 +349,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_TEAM_UPDATE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);

dCommon/dEnums/dCommonVars.h

@@ -7,6 +7,8 @@
 #include <string>
 #include <set>
 #include "BitStream.h"
+#include "eConnectionType.h"
+#include "eClientMessageType.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
 
@@ -28,7 +30,7 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 
 #define CBITSTREAM RakNet::BitStream bitStream;
 #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
-#define CMSGHEADER PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GAME_MSG);
+#define CMSGHEADER PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 #define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
 #define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 

dCommon/dEnums/dMessageIdentifiers.h

@@ -1,564 +0,0 @@
-#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_ZONE_SUMMARY_DISMISSED = 1044,
-	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_SET_NAME_BILLBOARD_STATE = 1284,
-	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_SHOW_BILLBOARD_INTERACT_ICON = 1337,
-	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

@@ -0,0 +1,15 @@
+#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/eChatInternalMessageType.h

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

@@ -0,0 +1,78 @@
+#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/eClientMessageType.h

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

@@ -0,0 +1,14 @@
+#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/eGameMessageType.h

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

dCommon/dEnums/eMasterMessageType.h

@@ -0,0 +1,36 @@
+#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/eServerMessageType.h

@@ -0,0 +1,12 @@
+#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/eWorldMessageType.h

@@ -0,0 +1,42 @@
+#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/UserManager.cpp

@@ -22,11 +22,12 @@
 #include "SkillComponent.h"
 #include "AssetManager.h"
 #include "CDClientDatabase.h"
-#include "dMessageIdentifiers.h"
 #include "eObjectBits.h"
 #include "eGameMasterLevel.h"
 #include "eCharacterCreationResponse.h"
 #include "eRenameResponse.h"
+#include "eConnectionType.h"
+#include "eChatInternalMessageType.h"
 
 UserManager* UserManager::m_Address = nullptr;
 
@@ -422,7 +423,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 			stmt->execute();
 			delete stmt;
 			CBITSTREAM;
-			PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION);
+			PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
 			bitStream.Write(objectID);
 			Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 		}

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() {
 }
@@ -253,7 +253,7 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) {
 			// Write message
 			RakNet::BitStream message;
 
-			PacketUtils::WriteHeader(message, CLIENT, MSG_CLIENT_GAME_MSG);
+			PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 			message.Write(this->originator);
 			echo.Serialize(&message);
 

dGame/dComponents/ModuleAssemblyComponent.h

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

dGame/dComponents/RocketLaunchpadControlComponent.cpp

@@ -15,9 +15,10 @@
 #include "PropertyEntranceComponent.h"
 #include "RocketLaunchLupComponent.h"
 #include "dServer.h"
-#include "dMessageIdentifiers.h"
 #include "PacketUtils.h"
 #include "eObjectWorldState.h"
+#include "eConnectionType.h"
+#include "eMasterMessageType.h"
 
 RocketLaunchpadControlComponent::RocketLaunchpadControlComponent(Entity* parent, int rocketId) : Component(parent) {
 	auto query = CDClientDatabase::CreatePreppedStmt(
@@ -136,7 +137,7 @@ LWOCLONEID RocketLaunchpadControlComponent::GetSelectedCloneId(LWOOBJID player)
 
 void RocketLaunchpadControlComponent::TellMasterToPrepZone(int zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_PREP_ZONE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PREP_ZONE);
 	bitStream.Write(zoneID);
 	Game::server->SendToMaster(&bitStream);
 }

dGame/dComponents/ScriptedActivityComponent.cpp

@@ -18,10 +18,11 @@
 #include "dConfig.h"
 #include "InventoryComponent.h"
 #include "DestroyableComponent.h"
-#include "dMessageIdentifiers.h"
 #include "Loot.h"
 #include "eMissionTaskType.h"
 #include "eMatchUpdate.h"
+#include "eConnectionType.h"
+#include "eChatInternalMessageType.h"
 
 #include "CDCurrencyTableTable.h"
 #include "CDActivityRewardsTable.h"
@@ -517,7 +518,7 @@ void ActivityInstance::StartZone() {
 	// only make a team if we have more than one participant
 	if (participants.size() > 1) {
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_CREATE_TEAM);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::CREATE_TEAM);
 
 		bitStream.Write(leader->GetObjectID());
 		bitStream.Write(m_Participants.size());

dGame/dComponents/SkillComponent.cpp

@@ -20,11 +20,11 @@
 #include "ScriptComponent.h"
 #include "BuffComponent.h"
 #include "EchoStartSkill.h"
-#include "dMessageIdentifiers.h"
 #include "DoClientProjectileImpact.h"
 #include "CDClientManager.h"
-
 #include "CDSkillBehaviorTable.h"
+#include "eConnectionType.h"
+#include "eClientMessageType.h"
 
 ProjectileSyncEntry::ProjectileSyncEntry() {
 }
@@ -304,7 +304,7 @@ SkillExecutionResult SkillComponent::CalculateBehavior(const uint32_t skillId, c
 		// Write message
 		RakNet::BitStream message;
 
-		PacketUtils::WriteHeader(message, CLIENT, MSG_CLIENT_GAME_MSG);
+		PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 		message.Write(this->m_Parent->GetObjectID());
 		start.Serialize(&message);
 
@@ -437,7 +437,7 @@ void SkillComponent::SyncProjectileCalculation(const ProjectileSyncEntry& entry)
 
 	RakNet::BitStream message;
 
-	PacketUtils::WriteHeader(message, CLIENT, MSG_CLIENT_GAME_MSG);
+	PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 	message.Write(this->m_Parent->GetObjectID());
 	projectileImpact.Serialize(&message);
 

dGame/dGameMessages/DoClientProjectileImpact.h

@@ -1,13 +1,10 @@
 #ifndef __DOCLIENTPROJECTILEIMPACT__H__
 #define __DOCLIENTPROJECTILEIMPACT__H__
 
-#include "dMessageIdentifiers.h"
 #include "dCommonVars.h"
 
 /*  Tell a client local projectile to impact */
 class DoClientProjectileImpact {
-	static const GAME_MSG MsgID = GAME_MSG_DO_CLIENT_PROJECTILE_IMPACT;
-
 public:
 	DoClientProjectileImpact() {
 		i64OrgID = LWOOBJID_EMPTY;
@@ -30,7 +27,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::DO_CLIENT_PROJECTILE_IMPACT);
 
 		stream->Write(i64OrgID != LWOOBJID_EMPTY);
 		if (i64OrgID != LWOOBJID_EMPTY) stream->Write(i64OrgID);

dGame/dGameMessages/EchoStartSkill.h

@@ -2,14 +2,12 @@
 #define __ECHOSTARTSKILL__H__
 
 #include "dCommonVars.h"
-#include "dMessageIdentifiers.h"
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
+#include "eGameMessageType.h"
 
 /*  Same as start skill but with different network options. An echo down to other clients that need to play the skill. */
 class EchoStartSkill {
-	static const GAME_MSG MsgID = GAME_MSG_ECHO_START_SKILL;
-
 public:
 	EchoStartSkill() {
 		bUsedMouse = false;
@@ -42,7 +40,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::ECHO_START_SKILL);
 
 		stream->Write(bUsedMouse);
 

dGame/dGameMessages/EchoSyncSkill.h

@@ -4,13 +4,11 @@
 #include <string>
 
 #include "BitStream.h"
+#include "eGameMessageType.h"
 
-#include "dMessageIdentifiers.h"
 
 /*  Message to synchronize a skill cast */
 class EchoSyncSkill {
-	static const GAME_MSG MsgID = GAME_MSG_ECHO_SYNC_SKILL;
-
 public:
 	EchoSyncSkill() {
 		bDone = false;
@@ -31,7 +29,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::ECHO_SYNC_SKILL);
 
 		stream->Write(bDone);
 		uint32_t sBitStreamLength = sBitStream.length();

dGame/dGameMessages/GameMessageHandler.cpp

@@ -33,10 +33,11 @@
 #include "EchoSyncSkill.h"
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
+#include "eConnectionType.h"
 
 using namespace std;
 
-void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, GAME_MSG messageID) {
+void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, eGameMessageType messageID) {
 
 	CBITSTREAM;
 
@@ -53,54 +54,54 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 
 	switch (messageID) {
 
-	case GAME_MSG_UN_USE_BBB_MODEL: {
+	case eGameMessageType::UN_USE_BBB_MODEL: {
 		GameMessages::HandleUnUseModel(inStream, entity, sysAddr);
 		break;
 	}
-	case GAME_MSG_PLAY_EMOTE: {
+	case eGameMessageType::PLAY_EMOTE: {
 		GameMessages::HandlePlayEmote(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_MOVE_ITEM_IN_INVENTORY: {
+	case eGameMessageType::MOVE_ITEM_IN_INVENTORY: {
 		GameMessages::HandleMoveItemInInventory(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_REMOVE_ITEM_FROM_INVENTORY: {
+	case eGameMessageType::REMOVE_ITEM_FROM_INVENTORY: {
 		GameMessages::HandleRemoveItemFromInventory(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_EQUIP_ITEM:
+	case eGameMessageType::EQUIP_ITEM:
 		GameMessages::HandleEquipItem(inStream, entity);
 		break;
 
-	case GAME_MSG_UN_EQUIP_ITEM:
+	case eGameMessageType::UN_EQUIP_ITEM:
 		GameMessages::HandleUnequipItem(inStream, entity);
 		break;
 
-	case GAME_MSG_RESPOND_TO_MISSION: {
+	case eGameMessageType::RESPOND_TO_MISSION: {
 		GameMessages::HandleRespondToMission(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_REQUEST_USE: {
+	case eGameMessageType::REQUEST_USE: {
 		GameMessages::HandleRequestUse(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_SET_FLAG: {
+	case eGameMessageType::SET_FLAG: {
 		GameMessages::HandleSetFlag(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_HAS_BEEN_COLLECTED: {
+	case eGameMessageType::HAS_BEEN_COLLECTED: {
 		GameMessages::HandleHasBeenCollected(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PLAYER_LOADED: {
+	case eGameMessageType::PLAYER_LOADED: {
 		GameMessages::SendRestoreToPostLoadStats(entity, sysAddr);
 		entity->SetPlayerReadyForUpdates();
 
@@ -174,73 +175,73 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		break;
 	}
 
-	case GAME_MSG_REQUEST_LINKED_MISSION: {
+	case eGameMessageType::REQUEST_LINKED_MISSION: {
 		GameMessages::HandleRequestLinkedMission(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_MISSION_DIALOGUE_OK: {
+	case eGameMessageType::MISSION_DIALOGUE_OK: {
 		GameMessages::HandleMissionDialogOK(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_MISSION_DIALOGUE_CANCELLED: {
+	case eGameMessageType::MISSION_DIALOGUE_CANCELLED: {
 		//This message is pointless for our implementation, as the client just carries on after
 		//rejecting a mission offer. We dont need to do anything. This is just here to remove a warning in our logs :)
 		break;
 	}
 
-	case GAME_MSG_REQUEST_PLATFORM_RESYNC: {
+	case eGameMessageType::REQUEST_PLATFORM_RESYNC: {
 		GameMessages::HandleRequestPlatformResync(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_FIRE_EVENT_SERVER_SIDE: {
+	case eGameMessageType::FIRE_EVENT_SERVER_SIDE: {
 		GameMessages::HandleFireEventServerSide(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
+	case eGameMessageType::SEND_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
 		GameMessages::HandleActivitySummaryLeaderboardData(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
+	case eGameMessageType::REQUEST_ACTIVITY_SUMMARY_LEADERBOARD_DATA: {
 		GameMessages::HandleRequestActivitySummaryLeaderboardData(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_ACTIVITY_STATE_CHANGE_REQUEST: {
+	case eGameMessageType::ACTIVITY_STATE_CHANGE_REQUEST: {
 		GameMessages::HandleActivityStateChangeRequest(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PARSE_CHAT_MESSAGE: {
+	case eGameMessageType::PARSE_CHAT_MESSAGE: {
 		GameMessages::HandleParseChatMessage(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: {
+	case eGameMessageType::NOTIFY_SERVER_LEVEL_PROCESSING_COMPLETE: {
 		GameMessages::HandleNotifyServerLevelProcessingComplete(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PICKUP_CURRENCY: {
+	case eGameMessageType::PICKUP_CURRENCY: {
 		GameMessages::HandlePickupCurrency(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_PICKUP_ITEM: {
+	case eGameMessageType::PICKUP_ITEM: {
 		GameMessages::HandlePickupItem(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_RESURRECT: {
+	case eGameMessageType::RESURRECT: {
 		GameMessages::HandleResurrect(inStream, entity);
 		break;
 	}
 
-	case GAME_MSG_REQUEST_RESURRECT: {
+	case eGameMessageType::REQUEST_RESURRECT: {
 		GameMessages::SendResurrect(entity);
 		/*auto* dest = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 		if (dest) {
@@ -251,12 +252,12 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		}*/
 		break;
 	}
-	case GAME_MSG_HANDLE_HOT_PROPERTY_DATA: {
+	case eGameMessageType::HANDLE_HOT_PROPERTY_DATA: {
 		GameMessages::HandleGetHotPropertyData(inStream, entity, sysAddr);
 		break;
 	}
 
-	case GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT:
+	case eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT:
 	{
 		auto message = RequestServerProjectileImpact();
 
@@ -275,7 +276,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		break;
 	}
 
-	case GAME_MSG_START_SKILL: {
+	case eGameMessageType::START_SKILL: {
 		StartSkill startSkill = StartSkill();
 		startSkill.Deserialize(inStream); // inStream replaces &bitStream
 
@@ -313,7 +314,7 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		if (success) {
 			//Broadcast our startSkill:
 			RakNet::BitStream bitStreamLocal;
-			PacketUtils::WriteHeader(bitStreamLocal, CLIENT, MSG_CLIENT_GAME_MSG);
+			PacketUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 			bitStreamLocal.Write(entity->GetObjectID());
 
 			EchoStartSkill echoStartSkill;
@@ -333,11 +334,11 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		}
 	} break;
 
-	case GAME_MSG_SYNC_SKILL: {
+	case eGameMessageType::SYNC_SKILL: {
 		RakNet::BitStream bitStreamLocal;
-		PacketUtils::WriteHeader(bitStreamLocal, CLIENT, MSG_CLIENT_GAME_MSG);
+		PacketUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 		bitStreamLocal.Write(entity->GetObjectID());
-		//bitStreamLocal.Write((unsigned short)GAME_MSG_ECHO_SYNC_SKILL);
+		//bitStreamLocal.Write((unsigned short)eGameMessageType::ECHO_SYNC_SKILL);
 		//bitStreamLocal.Write(inStream);
 
 		SyncSkill sync = SyncSkill(inStream); // inStream replaced &bitStream
@@ -374,306 +375,306 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		Game::server->Send(&bitStreamLocal, sysAddr, true);
 	} break;
 
-	case GAME_MSG_REQUEST_SMASH_PLAYER:
+	case eGameMessageType::REQUEST_SMASH_PLAYER:
 		entity->Smash(entity->GetObjectID());
 		break;
 
-	case GAME_MSG_MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
+	case eGameMessageType::MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
 		GameMessages::HandleMoveItemBetweenInventoryTypes(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_MODULAR_BUILD_FINISH:
+	case eGameMessageType::MODULAR_BUILD_FINISH:
 		GameMessages::HandleModularBuildFinish(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_PUSH_EQUIPPED_ITEMS_STATE:
+	case eGameMessageType::PUSH_EQUIPPED_ITEMS_STATE:
 		GameMessages::HandlePushEquippedItemsState(inStream, entity);
 		break;
 
-	case GAME_MSG_POP_EQUIPPED_ITEMS_STATE:
+	case eGameMessageType::POP_EQUIPPED_ITEMS_STATE:
 		GameMessages::HandlePopEquippedItemsState(inStream, entity);
 		break;
 
-	case GAME_MSG_BUY_FROM_VENDOR:
+	case eGameMessageType::BUY_FROM_VENDOR:
 		GameMessages::HandleBuyFromVendor(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_SELL_TO_VENDOR:
+	case eGameMessageType::SELL_TO_VENDOR:
 		GameMessages::HandleSellToVendor(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_BUYBACK_FROM_VENDOR:
+	case eGameMessageType::BUYBACK_FROM_VENDOR:
 		GameMessages::HandleBuybackFromVendor(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_MODULAR_BUILD_MOVE_AND_EQUIP:
+	case eGameMessageType::MODULAR_BUILD_MOVE_AND_EQUIP:
 		GameMessages::HandleModularBuildMoveAndEquip(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_DONE_ARRANGING_WITH_ITEM:
+	case eGameMessageType::DONE_ARRANGING_WITH_ITEM:
 		GameMessages::HandleDoneArrangingWithItem(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_MODULAR_BUILD_CONVERT_MODEL:
+	case eGameMessageType::MODULAR_BUILD_CONVERT_MODEL:
 		GameMessages::HandleModularBuildConvertModel(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_BUILD_MODE_SET:
+	case eGameMessageType::BUILD_MODE_SET:
 		GameMessages::HandleBuildModeSet(inStream, entity);
 		break;
 
-	case GAME_MSG_REBUILD_CANCEL:
+	case eGameMessageType::REBUILD_CANCEL:
 		GameMessages::HandleRebuildCancel(inStream, entity);
 		break;
 
-	case GAME_MSG_MATCH_REQUEST:
+	case eGameMessageType::MATCH_REQUEST:
 		GameMessages::HandleMatchRequest(inStream, entity);
 		break;
 
-	case GAME_MSG_USE_NON_EQUIPMENT_ITEM:
+	case eGameMessageType::USE_NON_EQUIPMENT_ITEM:
 		GameMessages::HandleUseNonEquipmentItem(inStream, entity);
 		break;
 
-	case GAME_MSG_CLIENT_ITEM_CONSUMED:
+	case eGameMessageType::CLIENT_ITEM_CONSUMED:
 		GameMessages::HandleClientItemConsumed(inStream, entity);
 		break;
 
-	case GAME_MSG_SET_CONSUMABLE_ITEM:
+	case eGameMessageType::SET_CONSUMABLE_ITEM:
 		GameMessages::HandleSetConsumableItem(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_VERIFY_ACK:
+	case eGameMessageType::VERIFY_ACK:
 		GameMessages::HandleVerifyAck(inStream, entity, sysAddr);
 		break;
 
 		// Trading
-	case GAME_MSG_CLIENT_TRADE_REQUEST:
+	case eGameMessageType::CLIENT_TRADE_REQUEST:
 		GameMessages::HandleClientTradeRequest(inStream, entity, sysAddr);
 		break;
-	case GAME_MSG_CLIENT_TRADE_CANCEL:
+	case eGameMessageType::CLIENT_TRADE_CANCEL:
 		GameMessages::HandleClientTradeCancel(inStream, entity, sysAddr);
 		break;
-	case GAME_MSG_CLIENT_TRADE_ACCEPT:
+	case eGameMessageType::CLIENT_TRADE_ACCEPT:
 		GameMessages::HandleClientTradeAccept(inStream, entity, sysAddr);
 		break;
-	case GAME_MSG_CLIENT_TRADE_UPDATE:
+	case eGameMessageType::CLIENT_TRADE_UPDATE:
 		GameMessages::HandleClientTradeUpdate(inStream, entity, sysAddr);
 		break;
 
 		// Pets
-	case GAME_MSG_PET_TAMING_TRY_BUILD:
+	case eGameMessageType::PET_TAMING_TRY_BUILD:
 		GameMessages::HandlePetTamingTryBuild(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_NOTIFY_TAMING_BUILD_SUCCESS:
+	case eGameMessageType::NOTIFY_TAMING_BUILD_SUCCESS:
 		GameMessages::HandleNotifyTamingBuildSuccess(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_REQUEST_SET_PET_NAME:
+	case eGameMessageType::REQUEST_SET_PET_NAME:
 		GameMessages::HandleRequestSetPetName(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_START_SERVER_PET_MINIGAME_TIMER:
+	case eGameMessageType::START_SERVER_PET_MINIGAME_TIMER:
 		GameMessages::HandleStartServerPetMinigameTimer(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_CLIENT_EXIT_TAMING_MINIGAME:
+	case eGameMessageType::CLIENT_EXIT_TAMING_MINIGAME:
 		GameMessages::HandleClientExitTamingMinigame(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_COMMAND_PET:
+	case eGameMessageType::COMMAND_PET:
 		GameMessages::HandleCommandPet(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_DESPAWN_PET:
+	case eGameMessageType::DESPAWN_PET:
 		GameMessages::HandleDespawnPet(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_MESSAGE_BOX_RESPOND:
+	case eGameMessageType::MESSAGE_BOX_RESPOND:
 		GameMessages::HandleMessageBoxResponse(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_CHOICE_BOX_RESPOND:
+	case eGameMessageType::CHOICE_BOX_RESPOND:
 		GameMessages::HandleChoiceBoxRespond(inStream, entity, sysAddr);
 		break;
 
 		// Property
-	case GAME_MSG_QUERY_PROPERTY_DATA:
+	case eGameMessageType::QUERY_PROPERTY_DATA:
 		GameMessages::HandleQueryPropertyData(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_START_BUILDING_WITH_ITEM:
+	case eGameMessageType::START_BUILDING_WITH_ITEM:
 		GameMessages::HandleStartBuildingWithItem(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_SET_BUILD_MODE:
+	case eGameMessageType::SET_BUILD_MODE:
 		GameMessages::HandleSetBuildMode(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_PROPERTY_EDITOR_BEGIN:
+	case eGameMessageType::PROPERTY_EDITOR_BEGIN:
 		GameMessages::HandlePropertyEditorBegin(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_PROPERTY_EDITOR_END:
+	case eGameMessageType::PROPERTY_EDITOR_END:
 		GameMessages::HandlePropertyEditorEnd(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_PROPERTY_CONTENTS_FROM_CLIENT:
+	case eGameMessageType::PROPERTY_CONTENTS_FROM_CLIENT:
 		GameMessages::HandlePropertyContentsFromClient(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_ZONE_PROPERTY_MODEL_EQUIPPED:
+	case eGameMessageType::ZONE_PROPERTY_MODEL_EQUIPPED:
 		GameMessages::HandlePropertyModelEquipped(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_PLACE_PROPERTY_MODEL:
+	case eGameMessageType::PLACE_PROPERTY_MODEL:
 		GameMessages::HandlePlacePropertyModel(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_UPDATE_MODEL_FROM_CLIENT:
+	case eGameMessageType::UPDATE_MODEL_FROM_CLIENT:
 		GameMessages::HandleUpdatePropertyModel(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_DELETE_MODEL_FROM_CLIENT:
+	case eGameMessageType::DELETE_MODEL_FROM_CLIENT:
 		GameMessages::HandleDeletePropertyModel(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_BBB_LOAD_ITEM_REQUEST:
+	case eGameMessageType::BBB_LOAD_ITEM_REQUEST:
 		GameMessages::HandleBBBLoadItemRequest(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_BBB_SAVE_REQUEST:
+	case eGameMessageType::BBB_SAVE_REQUEST:
 		GameMessages::HandleBBBSaveRequest(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_CONTROL_BEHAVIOR:
+	case eGameMessageType::CONTROL_BEHAVIOR:
 		GameMessages::HandleControlBehaviors(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_PROPERTY_ENTRANCE_SYNC:
+	case eGameMessageType::PROPERTY_ENTRANCE_SYNC:
 		GameMessages::HandlePropertyEntranceSync(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_ENTER_PROPERTY1:
+	case eGameMessageType::ENTER_PROPERTY1:
 		GameMessages::HandleEnterProperty(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_ZONE_PROPERTY_MODEL_ROTATED:
+	case eGameMessageType::ZONE_PROPERTY_MODEL_ROTATED:
 		EntityManager::Instance()->GetZoneControlEntity()->OnZonePropertyModelRotated(usr->GetLastUsedChar()->GetEntity());
 		break;
 
-	case GAME_MSG_UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK:
+	case eGameMessageType::UPDATE_PROPERTY_OR_MODEL_FOR_FILTER_CHECK:
 		GameMessages::HandleUpdatePropertyOrModelForFilterCheck(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_SET_PROPERTY_ACCESS:
+	case eGameMessageType::SET_PROPERTY_ACCESS:
 		GameMessages::HandleSetPropertyAccess(inStream, entity, sysAddr);
 		break;
 
 		// Racing
-	case GAME_MSG_MODULE_ASSEMBLY_QUERY_DATA:
+	case eGameMessageType::MODULE_ASSEMBLY_QUERY_DATA:
 		GameMessages::HandleModuleAssemblyQueryData(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_ACKNOWLEDGE_POSSESSION:
+	case eGameMessageType::ACKNOWLEDGE_POSSESSION:
 		GameMessages::HandleAcknowledgePossession(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_VEHICLE_SET_WHEEL_LOCK_STATE:
+	case eGameMessageType::VEHICLE_SET_WHEEL_LOCK_STATE:
 		GameMessages::HandleVehicleSetWheelLockState(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_MODULAR_ASSEMBLY_NIF_COMPLETED:
+	case eGameMessageType::MODULAR_ASSEMBLY_NIF_COMPLETED:
 		GameMessages::HandleModularAssemblyNIFCompleted(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_RACING_CLIENT_READY:
+	case eGameMessageType::RACING_CLIENT_READY:
 		GameMessages::HandleRacingClientReady(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_REQUEST_DIE:
+	case eGameMessageType::REQUEST_DIE:
 		GameMessages::HandleRequestDie(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION:
+	case eGameMessageType::VEHICLE_NOTIFY_SERVER_ADD_PASSIVE_BOOST_ACTION:
 		GameMessages::HandleVehicleNotifyServerAddPassiveBoostAction(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION:
+	case eGameMessageType::VEHICLE_NOTIFY_SERVER_REMOVE_PASSIVE_BOOST_ACTION:
 		GameMessages::HandleVehicleNotifyServerRemovePassiveBoostAction(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_RACING_PLAYER_INFO_RESET_FINISHED:
+	case eGameMessageType::RACING_PLAYER_INFO_RESET_FINISHED:
 		GameMessages::HandleRacingPlayerInfoResetFinished(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER:
+	case eGameMessageType::VEHICLE_NOTIFY_HIT_IMAGINATION_SERVER:
 		GameMessages::HandleVehicleNotifyHitImaginationServer(inStream, entity, sysAddr);
 		break;
-	case GAME_MSG_UPDATE_PROPERTY_PERFORMANCE_COST:
+	case eGameMessageType::UPDATE_PROPERTY_PERFORMANCE_COST:
 		GameMessages::HandleUpdatePropertyPerformanceCost(inStream, entity, sysAddr);
 		break;
 		// SG
-	case GAME_MSG_UPDATE_SHOOTING_GALLERY_ROTATION:
+	case eGameMessageType::UPDATE_SHOOTING_GALLERY_ROTATION:
 		GameMessages::HandleUpdateShootingGalleryRotation(inStream, entity, sysAddr);
 		break;
 
 		// NT
-	case GAME_MSG_REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
+	case eGameMessageType::REQUEST_MOVE_ITEM_BETWEEN_INVENTORY_TYPES:
 		GameMessages::HandleRequestMoveItemBetweenInventoryTypes(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_TOGGLE_GHOST_REFERENCE_OVERRIDE:
+	case eGameMessageType::TOGGLE_GHOST_REFERENCE_OVERRIDE:
 		GameMessages::HandleToggleGhostReferenceOverride(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_SET_GHOST_REFERENCE_POSITION:
+	case eGameMessageType::SET_GHOST_REFERENCE_POSITION:
 		GameMessages::HandleSetGhostReferencePosition(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_READY_FOR_UPDATES:
+	case eGameMessageType::READY_FOR_UPDATES:
 		//We don't really care about this message, as it's simply here to inform us that the client is done loading an object.
 		//In the event we _do_ send an update to an object that hasn't finished loading, the client will handle it anyway.
 		break;
 
-	case GAME_MSG_REPORT_BUG:
+	case eGameMessageType::REPORT_BUG:
 		GameMessages::HandleReportBug(inStream, entity);
 		break;
 
-	case GAME_MSG_CLIENT_RAIL_MOVEMENT_READY:
+	case eGameMessageType::CLIENT_RAIL_MOVEMENT_READY:
 		GameMessages::HandleClientRailMovementReady(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_CANCEL_RAIL_MOVEMENT:
+	case eGameMessageType::CANCEL_RAIL_MOVEMENT:
 		GameMessages::HandleCancelRailMovement(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_PLAYER_RAIL_ARRIVED_NOTIFICATION:
+	case eGameMessageType::PLAYER_RAIL_ARRIVED_NOTIFICATION:
 		GameMessages::HandlePlayerRailArrivedNotification(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_CINEMATIC_UPDATE:
+	case eGameMessageType::CINEMATIC_UPDATE:
 		GameMessages::HandleCinematicUpdate(inStream, entity, sysAddr);
 		break;
 
-	case GAME_MSG_MODIFY_PLAYER_ZONE_STATISTIC:
+	case eGameMessageType::MODIFY_PLAYER_ZONE_STATISTIC:
 		GameMessages::HandleModifyPlayerZoneStatistic(inStream, entity);
 		break;
 
-	case GAME_MSG_UPDATE_PLAYER_STATISTIC:
+	case eGameMessageType::UPDATE_PLAYER_STATISTIC:
 		GameMessages::HandleUpdatePlayerStatistic(inStream, entity);
 		break;
 
-	case GAME_MSG_DISMOUNT_COMPLETE:
+	case eGameMessageType::DISMOUNT_COMPLETE:
 		GameMessages::HandleDismountComplete(inStream, entity, sysAddr);
 		break;
-	case GAME_MSG_DEACTIVATE_BUBBLE_BUFF:
+	case eGameMessageType::DEACTIVATE_BUBBLE_BUFF:
 		GameMessages::HandleDeactivateBubbleBuff(inStream, entity);
 		break;
-	case GAME_MSG_ACTIVATE_BUBBLE_BUFF:
+	case eGameMessageType::ACTIVATE_BUBBLE_BUFF:
 		GameMessages::HandleActivateBubbleBuff(inStream, entity);
 		break;
-	case GAME_MSG_ZONE_SUMMARY_DISMISSED:
+	case eGameMessageType::ZONE_SUMMARY_DISMISSED:
 		GameMessages::HandleZoneSummaryDismissed(inStream, entity);
 		break;
 	default:

dGame/dGameMessages/GameMessageHandler.h

@@ -7,7 +7,6 @@
 #define GAMEMESSAGEHANDLER_H
 
 #include "RakNetTypes.h"
-#include "dMessageIdentifiers.h"
 #include "dCommonVars.h"
 #include <iostream>
 #include <sstream>
@@ -21,8 +20,10 @@
 #include "GameMessages.h"
 #include "../dDatabase/CDClientDatabase.h"
 
+enum class eGameMessageType : uint16_t;
+
 namespace GameMessageHandler {
-	void HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, GAME_MSG messageID);
+	void HandleMessage(RakNet::BitStream* inStream, const SystemAddress& sysAddr, LWOOBJID objectID, eGameMessageType messageID);
 };
 
 #endif // GAMEMESSAGEHANDLER_H

dGame/dGameMessages/RequestServerProjectileImpact.h

@@ -2,13 +2,11 @@
 #define __REQUESTSERVERPROJECTILEIMPACT__H__
 
 #include "dCommonVars.h"
-#include "dMessageIdentifiers.h"
+#include "eGameMessageType.h"
 
 /*  Notifying the server that a locally owned projectile impacted. Sent to the caster of the projectile
 		should always be the local char. */
 class RequestServerProjectileImpact {
-	static const GAME_MSG MsgID = GAME_MSG_REQUEST_SERVER_PROJECTILE_IMPACT;
-
 public:
 	RequestServerProjectileImpact() {
 		i64LocalID = LWOOBJID_EMPTY;
@@ -29,7 +27,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::REQUEST_SERVER_PROJECTILE_IMPACT);
 
 		stream->Write(i64LocalID != LWOOBJID_EMPTY);
 		if (i64LocalID != LWOOBJID_EMPTY) stream->Write(i64LocalID);

dGame/dGameMessages/StartSkill.h

@@ -2,16 +2,14 @@
 #define __STARTSKILL__H__
 
 #include "dCommonVars.h"
-#include "dMessageIdentifiers.h"
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
+#include "eGameMessageType.h"
 
 /**
  * Same as sync skill but with different network options. An echo down to other clients that need to play the skill.
  */
 class StartSkill {
-	static const GAME_MSG MsgID = GAME_MSG_START_SKILL;
-
 public:
 	StartSkill() {
 		bUsedMouse = false;
@@ -46,7 +44,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::START_SKILL);
 
 		stream->Write(bUsedMouse);
 

dGame/dGameMessages/SyncSkill.h

@@ -5,11 +5,10 @@
 #include <string>
 
 #include "BitStream.h"
+#include "eGameMessageType.h"
 
 /*  Message to synchronize a skill cast */
 class SyncSkill {
-	static const GAME_MSG MsgID = GAME_MSG_SYNC_SKILL;
-
 public:
 	SyncSkill() {
 		bDone = false;
@@ -30,7 +29,7 @@ public:
 	}
 
 	void Serialize(RakNet::BitStream* stream) {
-		stream->Write(MsgID);
+		stream->Write(eGameMessageType::SYNC_SKILL);
 
 		stream->Write(bDone);
 		uint32_t sBitStreamLength = sBitStream.length();

dGame/dUtilities/Mail.cpp

@@ -13,7 +13,6 @@
 #include "Entity.h"
 #include "Character.h"
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 #include "dLogger.h"
 #include "EntityManager.h"
 #include "InventoryComponent.h"
@@ -26,6 +25,7 @@
 #include "WorldConfig.h"
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
+#include "eConnectionType.h"
 
 void Mail::SendMail(const Entity* recipient, const std::string& subject, const std::string& body, const LOT attachment,
 	const uint16_t attachmentCount) {
@@ -283,7 +283,7 @@ void Mail::HandleDataRequest(RakNet::BitStream* packet, const SystemAddress& sys
 	sql::ResultSet* res = stmt->executeQuery();
 
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
 	bitStream.Write(int(MailMessageID::MailData));
 	bitStream.Write(int(0));
 
@@ -406,7 +406,7 @@ void Mail::HandleNotificationRequest(const SystemAddress& sysAddr, uint32_t obje
 
 void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse response) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
 	bitStream.Write(int(MailMessageID::SendResponse));
 	bitStream.Write(int(response));
 	Game::server->Send(&bitStream, sysAddr, false);
@@ -414,7 +414,7 @@ void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse respo
 
 void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
 	uint64_t messageType = 2;
 	uint64_t s1 = 0;
 	uint64_t s2 = 0;
@@ -433,7 +433,7 @@ void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) {
 
 void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
 	bitStream.Write(int(MailMessageID::AttachmentCollectConfirm));
 	bitStream.Write(int(0)); //unknown
 	bitStream.Write(mailID);
@@ -442,7 +442,7 @@ void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t ma
 
 void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOOBJID playerID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
 	bitStream.Write(int(MailMessageID::MailDeleteConfirm));
 	bitStream.Write(int(0)); //unknown
 	bitStream.Write(mailID);
@@ -456,7 +456,7 @@ void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOO
 
 void Mail::SendReadConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAIL);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
 	bitStream.Write(int(MailMessageID::MailReadConfirm));
 	bitStream.Write(int(0)); //unknown
 	bitStream.Write(mailID);

dGame/dUtilities/SlashCommandHandler.cpp

@@ -71,7 +71,6 @@
 #include "eBubbleType.h"
 #include "AMFFormat.h"
 #include "MovingPlatformComponent.h"
-#include "dMessageIdentifiers.h"
 #include "eMissionState.h"
 #include "TriggerComponent.h"
 #include "eServerDisconnectIdentifiers.h"
@@ -79,6 +78,9 @@
 #include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
 #include "eControlScheme.h"
+#include "eConnectionType.h"
+#include "eChatInternalMessageType.h"
+#include "eMasterMessageType.h"
 
 #include "CDObjectsTable.h"
 #include "CDZoneTableTable.h"
@@ -765,7 +767,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 	if (chatCommand == "shutdownuniverse" && entity->GetGMLevel() == eGameMasterLevel::OPERATOR) {
 		//Tell the master server that we're going to be shutting down whole "universe":
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN_UNIVERSE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_UNIVERSE);
 		Game::server->SendToMaster(&bitStream);
 		ChatPackets::SendSystemMessage(sysAddr, u"Sent universe shutdown notification to master.");
 
@@ -1096,7 +1098,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 			//Notify chat about it
 			CBITSTREAM;
-			PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE);
+			PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
 
 			bitStream.Write(characterId);
 			bitStream.Write(expire);
@@ -2044,7 +2046,7 @@ void SlashCommandHandler::SendAnnouncement(const std::string& title, const std::
 
 	//Notify chat about it
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ANNOUNCEMENT);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ANNOUNCEMENT);
 
 	bitStream.Write<uint32_t>(title.size());
 	for (auto character : title) {

dMasterServer/InstanceManager.cpp

@@ -7,10 +7,11 @@
 #include "CDClientDatabase.h"
 #include "CDClientManager.h"
 #include "CDZoneTableTable.h"
-#include "dMessageIdentifiers.h"
 #include "MasterPackets.h"
 #include "PacketUtils.h"
 #include "BinaryPathFinder.h"
+#include "eConnectionType.h"
+#include "eMasterMessageType.h"
 
 InstanceManager::InstanceManager(dLogger* logger, const std::string& externalIP) {
 	mLogger = logger;
@@ -201,7 +202,7 @@ void InstanceManager::RequestAffirmation(Instance* instance, const PendingInstan
 
 	CBITSTREAM;
 
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_AFFIRM_TRANSFER_REQUEST);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_REQUEST);
 
 	bitStream.Write(request.id);
 
@@ -405,7 +406,7 @@ bool Instance::GetShutdownComplete() const {
 void Instance::Shutdown() {
 	CBITSTREAM;
 
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN);
 
 	Game::server->Send(&bitStream, this->m_SysAddr, false);
 

dMasterServer/MasterServer.cpp

@@ -27,6 +27,8 @@
 #include "dServer.h"
 #include "AssetManager.h"
 #include "BinaryPathFinder.h"
+#include "eConnectionType.h"
+#include "eMasterMessageType.h"
 
 //RakNet includes:
 #include "RakNetDefines.h"
@@ -39,7 +41,6 @@
 #include "MasterPackets.h"
 #include "ObjectIDManager.h"
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 #include "FdbToSqlite.h"
 
 namespace Game {
@@ -494,9 +495,9 @@ void HandlePacket(Packet* packet) {
 		}
 	}
 
-	if (packet->data[1] == MASTER) {
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
-		switch (packet->data[3]) {
+		switch (static_cast<eMasterMessageType>(packet->data[3])) {
-		case MSG_MASTER_REQUEST_PERSISTENT_ID: {
+		case eMasterMessageType::REQUEST_PERSISTENT_ID: {
 			Game::logger->Log("MasterServer", "A persistent ID req");
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
@@ -508,7 +509,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_REQUEST_ZONE_TRANSFER: {
+		case eMasterMessageType::REQUEST_ZONE_TRANSFER: {
 			Game::logger->Log("MasterServer", "Received zone transfer req");
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
@@ -544,7 +545,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_SERVER_INFO: {
+		case eMasterMessageType::SERVER_INFO: {
 			//MasterPackets::HandleServerInfo(packet);
 
 			//This is here because otherwise we'd have to include IM in
@@ -603,7 +604,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_SET_SESSION_KEY: {
+		case eMasterMessageType::SET_SESSION_KEY: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 			uint32_t sessionKey = 0;
@@ -617,7 +618,7 @@ void HandlePacket(Packet* packet) {
 					activeSessions.erase(it.first);
 
 					CBITSTREAM;
-					PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_NEW_SESSION_ALERT);
+					PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::NEW_SESSION_ALERT);
 					bitStream.Write(sessionKey);
 					bitStream.Write<uint32_t>(username.size());
 					for (auto character : username) {
@@ -634,7 +635,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_REQUEST_SESSION_KEY: {
+		case eMasterMessageType::REQUEST_SESSION_KEY: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 			std::string username = PacketUtils::ReadString(8, packet, false);
@@ -642,7 +643,7 @@ void HandlePacket(Packet* packet) {
 			for (auto key : activeSessions) {
 				if (key.second == username) {
 					CBITSTREAM;
-					PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SESSION_KEY_RESPONSE);
+					PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SESSION_KEY_RESPONSE);
 					bitStream.Write(key.first);
 					PacketUtils::WriteString(bitStream, key.second, 64);
 					Game::server->Send(&bitStream, packet->systemAddress, false);
@@ -652,7 +653,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_PLAYER_ADDED: {
+		case eMasterMessageType::PLAYER_ADDED: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -672,7 +673,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_PLAYER_REMOVED: {
+		case eMasterMessageType::PLAYER_REMOVED: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -690,7 +691,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_CREATE_PRIVATE_ZONE: {
+		case eMasterMessageType::CREATE_PRIVATE_ZONE: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -714,7 +715,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_REQUEST_PRIVATE_ZONE: {
+		case eMasterMessageType::REQUEST_PRIVATE_ZONE: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -749,7 +750,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_WORLD_READY: {
+		case eMasterMessageType::WORLD_READY: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -773,7 +774,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_PREP_ZONE: {
+		case eMasterMessageType::PREP_ZONE: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -789,7 +790,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_AFFIRM_TRANSFER_RESPONSE: {
+		case eMasterMessageType::AFFIRM_TRANSFER_RESPONSE: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -809,7 +810,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_SHUTDOWN_RESPONSE: {
+		case eMasterMessageType::SHUTDOWN_RESPONSE: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 
@@ -824,7 +825,7 @@ void HandlePacket(Packet* packet) {
 			break;
 		}
 
-		case MSG_MASTER_SHUTDOWN_UNIVERSE: {
+		case eMasterMessageType::SHUTDOWN_UNIVERSE: {
 			Game::logger->Log("MasterServer", "Received shutdown universe command, shutting down in 10 minutes.");
 			Game::shouldShutdown = true;
 			break;
@@ -888,7 +889,7 @@ void ShutdownSequence(int32_t signal) {
 
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN);
 		Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 		Game::logger->Log("MasterServer", "Triggered master shutdown");
 	}

dNet/AuthPackets.cpp

@@ -1,6 +1,5 @@
 #include "AuthPackets.h"
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 
 #include "dNetCommon.h"
 #include "dServer.h"
@@ -23,6 +22,9 @@
 #include "dConfig.h"
 #include "eServerDisconnectIdentifiers.h"
 #include "eLoginResponse.h"
+#include "eConnectionType.h"
+#include "eServerMessageType.h"
+#include "eMasterMessageType.h"
 
 void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
 	RakNet::BitStream inStream(packet->data, packet->length, false);
@@ -36,7 +38,7 @@ void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
 
 void AuthPackets::SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServerType serverType) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, SERVER, MSG_SERVER_VERSION_CONFIRM);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM);
 	bitStream.Write<unsigned int>(NET_VERSION);
 	bitStream.Write(uint32_t(0x93));
 
@@ -189,7 +191,7 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
 
 void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username) {
 	RakNet::BitStream packet;
-	PacketUtils::WriteHeader(packet, CLIENT, MSG_CLIENT_LOGIN_RESPONSE);
+	PacketUtils::WriteHeader(packet, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE);
 
 	packet.Write(static_cast<uint8_t>(responseCode));
 
@@ -255,7 +257,7 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd
 	//Inform the master server that we've created a session for this user:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SET_SESSION_KEY);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SET_SESSION_KEY);
 		bitStream.Write(sessionKey);
 		PacketUtils::WriteString(bitStream, username, 66);
 		server->SendToMaster(&bitStream);

dNet/ChatPackets.cpp

@@ -8,12 +8,13 @@
 #include "BitStream.h"
 #include "Game.h"
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 #include "dServer.h"
+#include "eConnectionType.h"
+#include "eChatMessageType.h"
 
 void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel, const std::string& senderName, LWOOBJID playerObjectID, bool senderMythran, const std::u16string& message) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_GENERAL_CHAT_MESSAGE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);
 
 	bitStream.Write(static_cast<uint64_t>(0));
 	bitStream.Write(chatChannel);
@@ -35,7 +36,7 @@ void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel
 
 void ChatPackets::SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_GENERAL_CHAT_MESSAGE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);
 
 	bitStream.Write(static_cast<uint64_t>(0));
 	bitStream.Write(static_cast<char>(4));
@@ -67,7 +68,7 @@ void ChatPackets::SendMessageFail(const SystemAddress& sysAddr) {
 	//0x01 - "Upgrade to a full LEGO Universe Membership to chat with other players."
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_SEND_CANNED_TEXT);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SEND_CANNED_TEXT);
 	bitStream.Write<uint8_t>(0); //response type, options above ^
 	//docs say there's a wstring here-- no idea what it's for, or if it's even needed so leaving it as is for now.
 	SEND_PACKET;

dNet/ClientPackets.cpp

@@ -31,7 +31,6 @@
 #include "dConfig.h"
 #include "CharacterComponent.h"
 #include "Database.h"
-#include "dMessageIdentifiers.h"
 #include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
 

dNet/MasterPackets.cpp

@@ -1,22 +1,23 @@
 #include "MasterPackets.h"
 #include "BitStream.h"
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 #include "dCommonVars.h"
 #include "dServer.h"
+#include "eConnectionType.h"
+#include "eMasterMessageType.h"
 
 #include <string>
 
 void MasterPackets::SendPersistentIDRequest(dServer* server, uint64_t requestID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_PERSISTENT_ID);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID);
 	bitStream.Write(requestID);
 	server->SendToMaster(&bitStream);
 }
 
 void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, uint32_t objID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_PERSISTENT_ID_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE);
 
 	bitStream.Write(requestID);
 	bitStream.Write(objID);
@@ -26,7 +27,7 @@ void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddres
 
 void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t cloneID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_ZONE_TRANSFER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER);
 
 	bitStream.Write(requestID);
 	bitStream.Write(static_cast<uint8_t>(mythranShift));
@@ -38,7 +39,7 @@ void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID,
 
 void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint32_t cloneID, const std::string& password) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_CREATE_PRIVATE_ZONE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::CREATE_PRIVATE_ZONE);
 
 	bitStream.Write(zoneID);
 	bitStream.Write(cloneID);
@@ -53,7 +54,7 @@ void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint
 
 void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID, bool mythranShift, const std::string& password) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_PRIVATE_ZONE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PRIVATE_ZONE);
 
 	bitStream.Write(requestID);
 	bitStream.Write(static_cast<uint8_t>(mythranShift));
@@ -68,7 +69,7 @@ void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID,
 
 void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCEID instanceId) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_WORLD_READY);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::WORLD_READY);
 
 	bitStream.Write(zoneId);
 	bitStream.Write(instanceId);
@@ -78,7 +79,7 @@ void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCE
 
 void MasterPackets::SendZoneTransferResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, const std::string& serverIP, uint32_t serverPort) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE);
 
 	bitStream.Write(requestID);
 	bitStream.Write(static_cast<uint8_t>(mythranShift));
@@ -110,7 +111,7 @@ void MasterPackets::HandleServerInfo(Packet* packet) {
 
 void MasterPackets::SendServerInfo(dServer* server, Packet* packet) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SERVER_INFO);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SERVER_INFO);
 
 	bitStream.Write(server->GetPort());
 	bitStream.Write(server->GetZoneID());

dNet/PacketUtils.cpp

@@ -1,17 +1,9 @@
 #include "PacketUtils.h"
-#include <MessageIdentifiers.h>
 #include <vector>
 #include <fstream>
 #include "dLogger.h"
 #include "Game.h"
 
-void PacketUtils::WriteHeader(RakNet::BitStream& bitStream, uint16_t connectionType, uint32_t internalPacketID) {
-	bitStream.Write(MessageID(ID_USER_PACKET_ENUM));
-	bitStream.Write(connectionType);
-	bitStream.Write(internalPacketID);
-	bitStream.Write(uint8_t(0));
-}
-
 uint16_t PacketUtils::ReadPacketU16(uint32_t startLoc, Packet* packet) {
 	if (startLoc + 2 > packet->length) return 0;
 

dNet/PacketUtils.h

@@ -1,11 +1,20 @@
 #ifndef PACKETUTILS_H
 #define PACKETUTILS_H
 
+#include <MessageIdentifiers.h>
 #include <BitStream.h>
 #include <string>
 
+enum class eConnectionType : uint16_t;
+
 namespace PacketUtils {
-	void WriteHeader(RakNet::BitStream& bitStream, uint16_t connectionType, uint32_t internalPacketID);
+	template<typename T>
+	void WriteHeader(RakNet::BitStream& bitStream, eConnectionType connectionType, T internalPacketID) {
+		bitStream.Write(MessageID(ID_USER_PACKET_ENUM));
+		bitStream.Write(connectionType);
+		bitStream.Write(internalPacketID);
+		bitStream.Write(uint8_t(0));
+	}
 
 	uint16_t ReadPacketU16(uint32_t startLoc, Packet* packet);
 	uint32_t ReadPacketU32(uint32_t startLoc, Packet* packet);

dNet/WorldPackets.cpp

@@ -1,7 +1,6 @@
 #include "dCommonVars.h"
 #include "WorldPackets.h"
 #include "BitStream.h"
-#include "dMessageIdentifiers.h"
 #include "PacketUtils.h"
 #include "GeneralUtils.h"
 #include "User.h"
@@ -14,10 +13,11 @@
 #include "dZoneManager.h"
 #include "CharacterComponent.h"
 #include "ZCompression.h"
+#include "eConnectionType.h"
 
 void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_LOAD_STATIC_ZONE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::LOAD_STATIC_ZONE);
 
 	auto zone = dZoneManager::Instance()->GetZone()->GetZoneID();
 	bitStream.Write(static_cast<uint16_t>(zone.GetMapID()));
@@ -41,7 +41,7 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
 	if (!user) return;
 
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_LIST_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE);
 
 	std::vector<Character*> characters = user->GetCharacters();
 	bitStream.Write(static_cast<uint8_t>(characters.size()));
@@ -90,28 +90,28 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
 
 void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_CREATE_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_CREATE_RESPONSE);
 	bitStream.Write(response);
 	SEND_PACKET;
 }
 
 void WorldPackets::SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHARACTER_RENAME_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_RENAME_RESPONSE);
 	bitStream.Write(response);
 	SEND_PACKET;
 }
 
 void WorldPackets::SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_DELETE_CHARACTER_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::DELETE_CHARACTER_RESPONSE);
 	bitStream.Write(static_cast<uint8_t>(response));
 	SEND_PACKET;
 }
 
 void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TRANSFER_TO_WORLD);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TRANSFER_TO_WORLD);
 
 	PacketUtils::WriteString(bitStream, serverIP, 33);
 	bitStream.Write(static_cast<uint16_t>(serverPort));
@@ -122,14 +122,14 @@ void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::
 
 void WorldPackets::SendServerState(const SystemAddress& sysAddr) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_SERVER_STATES);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SERVER_STATES);
 	bitStream.Write(static_cast<uint8_t>(1)); //If the server is receiving this request, it probably is ready anyway.
 	SEND_PACKET;
 }
 
 void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* entity, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CREATE_CHARACTER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CREATE_CHARACTER);
 
 	RakNet::BitStream data;
 	data.Write<uint32_t>(7); //LDF key count
@@ -198,7 +198,7 @@ void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* ent
 
 void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<std::pair<uint8_t, uint8_t>> unacceptedItems) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_CHAT_MODERATION_STRING);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHAT_MODERATION_STRING);
 
 	bitStream.Write<uint8_t>(unacceptedItems.empty()); // Is sentence ok?
 	bitStream.Write<uint16_t>(0x16); // Source ID, unknown
@@ -222,7 +222,7 @@ void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool
 
 void WorldPackets::SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_MAKE_GM_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAKE_GM_RESPONSE);
 
 	bitStream.Write<uint8_t>(success);
 	bitStream.Write(static_cast<uint16_t>(highestLevel));

dNet/dServer.cpp

@@ -6,9 +6,11 @@
 
 #include "RakNetworkFactory.h"
 #include "MessageIdentifiers.h"
+#include "eConnectionType.h"
+#include "eServerMessageType.h"
+#include "eMasterMessageType.h"
 
 #include "PacketUtils.h"
-#include "dMessageIdentifiers.h"
 #include "MasterPackets.h"
 #include "ZoneInstanceManager.h"
 
@@ -118,14 +120,14 @@ Packet* dServer::ReceiveFromMaster() {
 		}
 
 		if (packet->data[0] == ID_USER_PACKET_ENUM) {
-			if (packet->data[1] == MASTER) {
+			if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
-				switch (packet->data[3]) {
+				switch (static_cast<eMasterMessageType>(packet->data[3])) {
-				case MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE: {
+				case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: {
 					uint64_t requestID = PacketUtils::ReadPacketU64(8, packet);
 					ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet);
 					break;
 				}
-				case MSG_MASTER_SHUTDOWN:
+				case eMasterMessageType::SHUTDOWN:
 					*mShouldShutdown = true;
 					break;
 
@@ -166,7 +168,7 @@ void dServer::SendToMaster(RakNet::BitStream* bitStream) {
 
 void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, SERVER, MSG_SERVER_DISCONNECT_NOTIFY);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::DISCONNECT_NOTIFY);
 	bitStream.Write(disconNotifyID);
 	mPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, sysAddr, false);
 

dWorldServer/WorldServer.cpp

@@ -31,7 +31,6 @@
 #include "PacketUtils.h"
 #include "WorldPackets.h"
 #include "UserManager.h"
-#include "dMessageIdentifiers.h"
 #include "CDClientManager.h"
 #include "CDClientDatabase.h"
 #include "GeneralUtils.h"
@@ -65,7 +64,12 @@
 #include "NiPoint3.h"
 #include "eServerDisconnectIdentifiers.h"
 #include "eObjectBits.h"
-
+#include "eConnectionType.h"
+#include "eServerMessageType.h"
+#include "eChatInternalMessageType.h"
+#include "eWorldMessageType.h"
+#include "eMasterMessageType.h"
+#include "eGameMessageType.h"
 #include "ZCompression.h"
 
 namespace Game {
@@ -547,9 +551,9 @@ void HandlePacketChat(Packet* packet) {
 	}
 
 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
-		if (packet->data[1] == CHAT_INTERNAL) {
+		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
-			switch (packet->data[3]) {
+			switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
-			case MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER: {
+			case eChatInternalMessageType::ROUTE_TO_PLAYER: {
 				CINSTREAM;
 				LWOOBJID playerID;
 				inStream.Read(playerID);
@@ -571,7 +575,7 @@ void HandlePacketChat(Packet* packet) {
 				break;
 			}
 
-			case MSG_CHAT_INTERNAL_ANNOUNCEMENT: {
+			case eChatInternalMessageType::ANNOUNCEMENT: {
 				CINSTREAM;
 				LWOOBJID header;
 				inStream.Read(header);
@@ -610,7 +614,7 @@ void HandlePacketChat(Packet* packet) {
 				break;
 			}
 
-			case MSG_CHAT_INTERNAL_MUTE_UPDATE: {
+			case eChatInternalMessageType::MUTE_UPDATE: {
 				CINSTREAM;
 				LWOOBJID playerId;
 				time_t expire = 0;
@@ -629,7 +633,7 @@ void HandlePacketChat(Packet* packet) {
 				break;
 			}
 
-			case MSG_CHAT_INTERNAL_TEAM_UPDATE: {
+			case eChatInternalMessageType::TEAM_UPDATE: {
 				CINSTREAM;
 				LWOOBJID header;
 				inStream.Read(header);
@@ -706,7 +710,7 @@ void HandlePacket(Packet* packet) {
 
 		{
 			CBITSTREAM;
-			PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION);
+			PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
 			bitStream.Write(user->GetLoggedInChar());
 			Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 		}
@@ -718,35 +722,35 @@ void HandlePacket(Packet* packet) {
 		}
 
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_PLAYER_REMOVED);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_REMOVED);
 		bitStream.Write((LWOMAPID)Game::server->GetZoneID());
 		bitStream.Write((LWOINSTANCEID)instanceID);
 		Game::server->SendToMaster(&bitStream);
 	}
 
 	if (packet->data[0] != ID_USER_PACKET_ENUM) return;
-	if (packet->data[1] == SERVER) {
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
-		if (packet->data[3] == MSG_SERVER_VERSION_CONFIRM) {
+		if (static_cast<eServerMessageType>(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) {
 			AuthPackets::HandleHandshake(Game::server, packet);
 		}
 	}
 
-	if (packet->data[1] == MASTER) {
+	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
-		switch (packet->data[3]) {
+		switch (static_cast<eMasterMessageType>(packet->data[3])) {
-		case MSG_MASTER_REQUEST_PERSISTENT_ID_RESPONSE: {
+		case eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE: {
 			uint64_t requestID = PacketUtils::ReadPacketU64(8, packet);
 			uint32_t objectID = PacketUtils::ReadPacketU32(16, packet);
 			ObjectIDManager::Instance()->HandleRequestPersistentIDResponse(requestID, objectID);
 			break;
 		}
 
-		case MSG_MASTER_REQUEST_ZONE_TRANSFER_RESPONSE: {
+		case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: {
 			uint64_t requestID = PacketUtils::ReadPacketU64(8, packet);
 			ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet);
 			break;
 		}
 
-		case MSG_MASTER_SESSION_KEY_RESPONSE: {
+		case eMasterMessageType::SESSION_KEY_RESPONSE: {
 			//Read our session key and to which user it belongs:
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
@@ -803,7 +807,7 @@ void HandlePacket(Packet* packet) {
 				//Notify master:
 				{
 					CBITSTREAM;
-					PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_PLAYER_ADDED);
+					PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::PLAYER_ADDED);
 					bitStream.Write((LWOMAPID)Game::server->GetZoneID());
 					bitStream.Write((LWOINSTANCEID)instanceID);
 					Game::server->SendToMaster(&bitStream);
@@ -812,27 +816,27 @@ void HandlePacket(Packet* packet) {
 
 			break;
 		}
-		case MSG_MASTER_AFFIRM_TRANSFER_REQUEST: {
+		case eMasterMessageType::AFFIRM_TRANSFER_REQUEST: {
 			const uint64_t requestID = PacketUtils::ReadPacketU64(8, packet);
 
 			Game::logger->Log("MasterServer", "Got affirmation request of transfer %llu", requestID);
 
 			CBITSTREAM;
 
-			PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_AFFIRM_TRANSFER_RESPONSE);
+			PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::AFFIRM_TRANSFER_RESPONSE);
 			bitStream.Write(requestID);
 			Game::server->SendToMaster(&bitStream);
 
 			break;
 		}
 
-		case MSG_MASTER_SHUTDOWN: {
+		case eMasterMessageType::SHUTDOWN: {
 			Game::shouldShutdown = true;
 			Game::logger->Log("WorldServer", "Got shutdown request from master, zone (%i), instance (%i)", Game::server->GetZoneID(), Game::server->GetInstanceID());
 			break;
 		}
 
-		case MSG_MASTER_NEW_SESSION_ALERT: {
+		case eMasterMessageType::NEW_SESSION_ALERT: {
 			RakNet::BitStream inStream(packet->data, packet->length, false);
 			uint64_t header = inStream.Read(header);
 			uint32_t sessionKey = inStream.Read(sessionKey);
@@ -870,10 +874,10 @@ void HandlePacket(Packet* packet) {
 		return;
 	}
 
-	if (packet->data[1] != WORLD) return;
+	if (static_cast<eConnectionType>(packet->data[1]) != eConnectionType::WORLD) return;
 
-	switch (packet->data[3]) {
+	switch (static_cast<eWorldMessageType>(packet->data[3])) {
-	case MSG_WORLD_CLIENT_VALIDATION: {
+	case eWorldMessageType::VALIDATION: {
 		std::string username = PacketUtils::ReadString(0x08, packet, true);
 		std::string sessionKey = PacketUtils::ReadString(74, packet, true);
 		std::string clientDatabaseChecksum = PacketUtils::ReadString(packet->length - 33, packet, false);
@@ -905,7 +909,7 @@ void HandlePacket(Packet* packet) {
 
 		//Request the session info from Master:
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_REQUEST_SESSION_KEY);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_SESSION_KEY);
 		PacketUtils::WriteString(bitStream, username, 64);
 		Game::server->SendToMaster(&bitStream);
 
@@ -918,7 +922,7 @@ void HandlePacket(Packet* packet) {
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_CHARACTER_LIST_REQUEST: {
+	case eWorldMessageType::CHARACTER_LIST_REQUEST: {
 		//We need to delete the entity first, otherwise the char list could delete it while it exists in the world!
 		if (Game::server->GetZoneID() != 0) {
 			auto user = UserManager::Instance()->GetUser(packet->systemAddress);
@@ -940,12 +944,12 @@ void HandlePacket(Packet* packet) {
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_GAME_MSG: {
+	case eWorldMessageType::GAME_MSG: {
 		RakNet::BitStream bitStream(packet->data, packet->length, false);
 
 		uint64_t header;
 		LWOOBJID objectID;
-		uint16_t messageID;
+		eGameMessageType messageID;
 
 		bitStream.Read(header);
 		bitStream.Read(objectID);
@@ -954,16 +958,16 @@ void HandlePacket(Packet* packet) {
 		RakNet::BitStream dataStream;
 		bitStream.Read(dataStream, bitStream.GetNumberOfUnreadBits());
 
-		GameMessageHandler::HandleMessage(&dataStream, packet->systemAddress, objectID, GAME_MSG(messageID));
+		GameMessageHandler::HandleMessage(&dataStream, packet->systemAddress, objectID, messageID);
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_CHARACTER_CREATE_REQUEST: {
+	case eWorldMessageType::CHARACTER_CREATE_REQUEST: {
 		UserManager::Instance()->CreateCharacter(packet->systemAddress, packet);
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_LOGIN_REQUEST: {
+	case eWorldMessageType::LOGIN_REQUEST: {
 		RakNet::BitStream inStream(packet->data, packet->length, false);
 		uint64_t header = inStream.Read(header);
 
@@ -979,7 +983,7 @@ void HandlePacket(Packet* packet) {
 			// This means we swapped characters and we need to remove the previous player from the container.
 			if (static_cast<uint32_t>(lastCharacter) != playerID) {
 				CBITSTREAM;
-				PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_REMOVED_NOTIFICATION);
+				PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
 				bitStream.Write(lastCharacter);
 				Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 			}
@@ -989,18 +993,18 @@ void HandlePacket(Packet* packet) {
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_CHARACTER_DELETE_REQUEST: {
+	case eWorldMessageType::CHARACTER_DELETE_REQUEST: {
 		UserManager::Instance()->DeleteCharacter(packet->systemAddress, packet);
 		UserManager::Instance()->RequestCharacterList(packet->systemAddress);
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_CHARACTER_RENAME_REQUEST: {
+	case eWorldMessageType::CHARACTER_RENAME_REQUEST: {
 		UserManager::Instance()->RenameCharacter(packet->systemAddress, packet);
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_LEVEL_LOAD_COMPLETE: {
+	case eWorldMessageType::LEVEL_LOAD_COMPLETE: {
 		Game::logger->Log("WorldServer", "Received level load complete from user.");
 		User* user = UserManager::Instance()->GetUser(packet->systemAddress);
 		if (user) {
@@ -1128,7 +1132,7 @@ void HandlePacket(Packet* packet) {
 								GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
 
 								CBITSTREAM;
-								PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_BLUEPRINT_SAVE_RESPONSE);
+								PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::BLUEPRINT_SAVE_RESPONSE);
 								bitStream.Write<LWOOBJID>(LWOOBJID_EMPTY); //always zero so that a check on the client passes
 								bitStream.Write(eBlueprintSaveResponseType::EverythingWorked);
 								bitStream.Write<uint32_t>(1);
@@ -1169,7 +1173,7 @@ void HandlePacket(Packet* packet) {
 					//RakNet::RakString playerName(player->GetCharacter()->GetName().c_str());
 
 					CBITSTREAM;
-					PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_PLAYER_ADDED_NOTIFICATION);
+					PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION);
 					bitStream.Write(player->GetObjectID());
 					bitStream.Write<uint32_t>(playerName.size());
 					for (size_t i = 0; i < playerName.size(); i++) {
@@ -1194,12 +1198,12 @@ void HandlePacket(Packet* packet) {
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_POSITION_UPDATE: {
+	case eWorldMessageType::POSITION_UPDATE: {
 		ClientPackets::HandleClientPositionUpdate(packet->systemAddress, packet);
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_MAIL: {
+	case eWorldMessageType::MAIL: {
 		RakNet::BitStream bitStream(packet->data, packet->length, false);
 		LWOOBJID space;
 		bitStream.Read(space);
@@ -1207,7 +1211,7 @@ void HandlePacket(Packet* packet) {
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_ROUTE_PACKET: {
+	case eWorldMessageType::ROUTE_PACKET: {
 		//Yeet to chat
 		CINSTREAM;
 		uint64_t header = 0;
@@ -1222,7 +1226,7 @@ void HandlePacket(Packet* packet) {
 
 		CBITSTREAM;
 
-		PacketUtils::WriteHeader(bitStream, CHAT, packet->data[14]);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, packet->data[14]);
 
 		//We need to insert the player's objectID so the chat server can find who originated this request:
 		LWOOBJID objectID = 0;
@@ -1243,12 +1247,12 @@ void HandlePacket(Packet* packet) {
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_STRING_CHECK: {
+	case eWorldMessageType::STRING_CHECK: {
 		ClientPackets::HandleChatModerationRequest(packet->systemAddress, packet);
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_GENERAL_CHAT_MESSAGE: {
+	case eWorldMessageType::GENERAL_CHAT_MESSAGE: {
 		if (chatDisabled) {
 			ChatPackets::SendMessageFail(packet->systemAddress);
 		} else {
@@ -1258,7 +1262,7 @@ void HandlePacket(Packet* packet) {
 		break;
 	}
 
-	case MSG_WORLD_CLIENT_HANDLE_FUNNESS: {
+	case eWorldMessageType::HANDLE_FUNNESS: {
 		//This means the client is running slower or faster than it should.
 		//Could be insane lag, but I'mma just YEET them as it's usually speedhacking.
 		//This is updated to now count the amount of times we've been caught "speedhacking" to kick with a delay
@@ -1346,6 +1350,6 @@ void FinalizeShutdown() {
 
 void SendShutdownMessageToMaster() {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, MASTER, MSG_MASTER_SHUTDOWN_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SHUTDOWN_RESPONSE);
 	Game::server->SendToMaster(&bitStream);
 }