hey it compiles

into the model, item, and mutable model behaviors

.github/workflows/build-and-test.yml

@@ -36,16 +36,22 @@ jobs:
         testPreset: "ci-${{matrix.os}}"
     - name: artifacts
       uses: actions/upload-artifact@v3
+      if: ${{ github.ref == 'ref/head/main' }}
       with:
         name: build-${{matrix.os}}
         path: |
-          build/*Server*
-          build/*.ini
-          build/*.so
-          build/*.dll
-          build/vanity/
-          build/navmeshes/
-          build/migrations/
-          build/*.dcf
-          !build/*.pdb
-          !build/d*/
+          build
+          !build/tests
+          !build/Testing
+          !build/CMakeFiles
+          !build/DartConfiguration.tcl
+          !build/CTestTestfile.cmake
+          !build/CMakeCache.txt
+          !build/build.ninja
+          !build/_deps
+          !build/cmake_install.cmake
+          !build/*.a
+          !build/*.lib
+          !build/*.dir
+          !build/*.vcxproj
+          !build/*.vcxproj.filters

CMakeLists.txt

@@ -97,56 +97,15 @@ make_directory(${CMAKE_BINARY_DIR}/logs)
 
 # Copy resource files on first build
 set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blacklist.dcf")
-message(STATUS "Checking resource file integrity")
-foreach (resource_file ${RESOURCE_FILES})
-	set(file_size 0)
-	if (EXISTS ${PROJECT_BINARY_DIR}/${resource_file})
-		file(SIZE ${PROJECT_BINARY_DIR}/${resource_file} file_size)
-	endif()
-	if (${file_size} EQUAL 0)
+foreach(resource_file ${RESOURCE_FILES})
+	if (NOT EXISTS ${PROJECT_BINARY_DIR}/${resource_file})
 		configure_file(
 			${CMAKE_SOURCE_DIR}/resources/${resource_file} ${PROJECT_BINARY_DIR}/${resource_file}
 			COPYONLY
 		)
-		message(STATUS "Moved " ${resource_file} " to project binary directory")
-	elseif (resource_file MATCHES ".ini")
-		message(STATUS "Checking " ${resource_file} " for missing config options")
-		file(READ ${PROJECT_BINARY_DIR}/${resource_file} current_file_contents)
-		string(REPLACE "\\\n" "" current_file_contents ${current_file_contents})
-		string(REPLACE "\n" ";" current_file_contents ${current_file_contents})
-		set(parsed_current_file_contents "")
-		# Remove comment lines so they do not interfere with the variable parsing
-		foreach (line ${current_file_contents})
-			string(FIND ${line} "#" is_comment)
-			if (NOT ${is_comment} EQUAL 0)
-				string(APPEND parsed_current_file_contents ${line})
-			endif()
-		endforeach()
-		file(READ ${CMAKE_SOURCE_DIR}/resources/${resource_file} depot_file_contents)
-		string(REPLACE "\\\n" "" depot_file_contents ${depot_file_contents})
-		string(REPLACE "\n" ";" depot_file_contents ${depot_file_contents})
-		set(line_to_add "")
-		foreach (line ${depot_file_contents})
-			string(FIND ${line} "#" is_comment)
-			if (NOT ${is_comment} EQUAL 0)
-				string(REPLACE "=" ";" line_split ${line})
-				list(GET line_split 0 variable_name)
-				if (NOT ${parsed_current_file_contents} MATCHES ${variable_name})
-					message(STATUS "Adding missing config option " ${variable_name} " to " ${resource_file})
-					set(line_to_add ${line_to_add} ${line})
-					foreach (line_to_append ${line_to_add})
-						file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n" ${line_to_append})
-					endforeach()
-					file(APPEND ${PROJECT_BINARY_DIR}/${resource_file} "\n")
-				endif()
-				set(line_to_add "")
-			else()
-				set(line_to_add ${line_to_add} ${line})
-			endif()
-		endforeach()
+		message("Moved ${resource_file} to project binary directory")
 	endif()
 endforeach()
-message(STATUS "Resource file integrity check complete")
 
 # Copy navmesh data on first build and extract it
 if (NOT EXISTS ${PROJECT_BINARY_DIR}/navmeshes/)
@@ -322,15 +281,6 @@ link_directories(${PROJECT_BINARY_DIR})
 # Load all of our third party directories
 add_subdirectory(thirdparty)
 
-# Include Boost
-find_package(Boost COMPONENTS interprocess)
-
-if(Boost_FOUND)
-    include_directories(${Boost_INCLUDE_DIRS}) 
-
-    target_link_libraries(dGame ${Boost_LIBRARIES})
-endif()
-
 # Glob together all headers that need to be precompiled
 file(
 	GLOB HEADERS_DDATABASE

CMakeVariables.txt

@@ -1,6 +1,6 @@
 PROJECT_VERSION_MAJOR=1
-PROJECT_VERSION_MINOR=1
-PROJECT_VERSION_PATCH=0
+PROJECT_VERSION_MINOR=0
+PROJECT_VERSION_PATCH=4
 # LICENSE
 LICENSE=AGPL-3.0
 # The network version.

README.md

@@ -245,11 +245,30 @@ To connect to a server follow these steps:
 * In the client directory, locate `boot.cfg`
 * Open it in a text editor and locate where it says `AUTHSERVERIP=0:`
 * Replace the contents after to `:` and the following `,` with what you configured as the server's public facing IP. For example `AUTHSERVERIP=0:localhost` for locally hosted servers
-* Next locate the line `UGCUSE3DSERVICES=7:`
-* Ensure the number after the 7 is a `0`
 * Launch `legouniverse.exe`, through `wine` if on a Unix-like operating system
 * Note that if you are on WSL2, you will need to configure the public IP in the server and client to be the IP of the WSL2 instance and not localhost, which can be found by running `ifconfig` in the terminal. Windows defaults to WSL1, so this will not apply to most users.
 
+## Brick-By-Brick building
+Should you choose to do any brick building, you will want to have some form of a http server that returns a 404 error since we are unable to emulate live User Generated Content at the moment. If you attempt to do any brick building without a 404 server running properly, you will be unable to load into your game. Python is the easiest way to do this, but any thing that returns a 404 should work fine.
+* Note: the client hard codes this request on port 80.
+
+<font size="4">**If you do not plan on doing any Brick Building, then you can skip this step.**</font>
+
+The easiest way to do this is to install [python](https://www.python.org/downloads/).
+
+### Allowing a user to build in Brick-by-Brick mode
+Brick-By-Brick building requires `PATCHSERVERIP=0:` and `UGCSERVERIP=0:` in the `boot.cfg` to point to a HTTP server which always returns `HTTP 404 - Not Found` for all requests. This can be most easily achieved by pointing both of those variables to `localhost` while having running in the background.
+Each client must have their own 404 server running if they are using a locally hosted 404 server.
+```bash
+# If on linux run this command. Because this is run on a port below 1024, binary network permissions are needed.
+sudo python3 -m http.server 80
+
+# If on windows one of the following will work when run through Powershell or Command Prompt assuming python is installed
+python3 -m http.server 80
+python http.server 80
+py -m http.server 80
+```
+
 ## Updating your server
 To update your server to the latest version navigate to your cloned directory
 ```bash
@@ -338,7 +357,7 @@ This is a Work in Progress, but below are some quick links to documentaion for s
 ## Former Contributors
 * TheMachine
 * Matthew
-* [Raine](https://github.com/uwainium)
+* [Raine](https://github.com/Rainebannister)
 * Bricknave
 
 ## Special Thanks

dAuthServer/AuthServer.cpp

@@ -15,13 +15,10 @@
 
 //RakNet includes:
 #include "RakNetDefines.h"
-#include <MessageIdentifiers.h>
 
 //Auth includes:
 #include "AuthPackets.h"
-#include "eConnectionType.h"
-#include "eServerMessageType.h"
-#include "eAuthMessageType.h"
+#include "dMessageIdentifiers.h"
 
 #include "Game.h"
 namespace Game {
@@ -29,7 +26,6 @@ namespace Game {
 	dServer* server = nullptr;
 	dConfig* config = nullptr;
 	bool shouldShutdown = false;
-	std::mt19937 randomEngine;
 }
 
 dLogger* SetupLogger();
@@ -84,8 +80,6 @@ int main(int argc, char** argv) {
 	delete res;
 	delete stmt;
 
-	Game::randomEngine = std::mt19937(time(0));
-
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
 	uint32_t maxClients = 50;
 	uint32_t ourPort = 1001; //LU client is hardcoded to use this for auth port, so I'm making it the default.
@@ -174,15 +168,13 @@ dLogger* SetupLogger() {
 }
 
 void HandlePacket(Packet* packet) {
-	if (packet->length < 4) return;
-
 	if (packet->data[0] == ID_USER_PACKET_ENUM) {
-		if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
-			if (static_cast<eServerMessageType>(packet->data[3]) == eServerMessageType::VERSION_CONFIRM) {
+		if (packet->data[1] == SERVER) {
+			if (packet->data[3] == MSG_SERVER_VERSION_CONFIRM) {
 				AuthPackets::HandleHandshake(Game::server, packet);
 			}
-		} else if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::AUTH) {
-			if (static_cast<eAuthMessageType>(packet->data[3]) == eAuthMessageType::LOGIN_REQUEST) {
+		} else if (packet->data[1] == AUTH) {
+			if (packet->data[3] == MSG_AUTH_LOGIN_REQUEST) {
 				AuthPackets::HandleLoginRequest(Game::server, packet);
 			}
 		}

dChatFilter/dChatFilter.cpp

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

dChatFilter/dChatFilter.h

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

dChatServer/ChatPacketHandler.cpp

@@ -3,6 +3,7 @@
 #include "Database.h"
 #include <vector>
 #include "PacketUtils.h"
+#include "dMessageIdentifiers.h"
 #include "Game.h"
 #include "dServer.h"
 #include "GeneralUtils.h"
@@ -11,20 +12,15 @@
 #include "eAddFriendResponseType.h"
 #include "RakString.h"
 #include "dConfig.h"
-#include "eObjectBits.h"
-#include "eConnectionType.h"
-#include "eChatMessageType.h"
-#include "eChatInternalMessageType.h"
-#include "eClientMessageType.h"
-#include "eGameMessageType.h"
 
 extern PlayerContainer playerContainer;
 
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = 0;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	auto player = playerContainer.GetPlayerData(playerID);
 	if (!player) return;
@@ -49,8 +45,8 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		FriendData fd;
 		fd.isFTP = false; // not a thing in DLU
 		fd.friendID = res->getUInt(1);
-		GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
-		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+		GeneralUtils::SetBit(fd.friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
 
 		fd.isBestFriend = res->getInt(2) == 3; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
 		if (fd.isBestFriend) player->countOfBestFriends += 1;
@@ -75,11 +71,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_GET_FRIENDS_LIST_RESPONSE);
 	bitStream.Write<uint8_t>(0);
 	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
 	bitStream.Write((uint16_t)friends.size());
@@ -98,9 +94,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 	auto maxNumberOfBestFriendsAsString = Game::config->GetValue("max_number_of_best_friends");
 	// If this config option doesn't exist, default to 5 which is what live used.
 	auto maxNumberOfBestFriends = maxNumberOfBestFriendsAsString != "" ? std::stoi(maxNumberOfBestFriendsAsString) : 5U;
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID requestorPlayerID;
 	inStream.Read(requestorPlayerID);
+	inStream.Read(requestorPlayerID);
 	uint32_t spacing{};
 	inStream.Read(spacing);
 	std::string playerName = "";
@@ -181,10 +178,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 			bestFriendStatus = oldBestFriendStatus;
 
 			// Set the bits
-			GeneralUtils::SetBit(queryPlayerID, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(queryPlayerID, eObjectBits::PERSISTENT);
-			GeneralUtils::SetBit(queryFriendID, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(queryFriendID, eObjectBits::PERSISTENT);
+			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+			GeneralUtils::SetBit(queryPlayerID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
+			GeneralUtils::SetBit(queryFriendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
 
 			// Since this player can either be the friend of someone else or be friends with someone else
 			// their column in the database determines what bit gets set.  When the value hits 3, they
@@ -245,9 +242,10 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	eAddFriendResponseCode clientResponseCode = static_cast<eAddFriendResponseCode>(packet->data[0x14]);
 	std::string friendName = PacketUtils::ReadString(0x15, packet, true);
@@ -320,9 +318,10 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	std::string friendName = PacketUtils::ReadString(0x14, packet, true);
 
 	//we'll have to query the db here to find the user, since you can delete them while they're offline.
@@ -337,8 +336,8 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 	}
 
 	// Convert friendID to LWOOBJID
-	GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
-	GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);
+	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_PERSISTENT));
+	GeneralUtils::SetBit(friendID, static_cast<size_t>(eObjectBits::OBJECT_BIT_CHARACTER));
 
 	std::unique_ptr<sql::PreparedStatement> deletestmt(Database::CreatePreppedStmt("DELETE FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;"));
 	deletestmt->setUInt(1, static_cast<uint32_t>(playerID));
@@ -377,9 +376,10 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleChatMessage(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	auto* sender = playerContainer.GetPlayerData(playerID);
 
@@ -412,10 +412,10 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 		const auto otherName = std::string(otherMember->playerName.c_str());
 
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 		bitStream.Write(otherMember->playerID);
 
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(otherMember->playerID);
 		bitStream.Write<uint8_t>(8);
 		bitStream.Write<unsigned int>(69);
@@ -451,10 +451,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the sender:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 		bitStream.Write(goonA->playerID);
 
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -474,10 +474,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the receiver:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 		bitStream.Write(goonB->playerID);
 
-		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, CHAT, MSG_CHAT_PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
@@ -496,9 +496,10 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	std::string invitedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
 	auto* player = playerContainer.GetPlayerData(playerID);
@@ -536,9 +537,10 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	uint32_t size = 0;
 	inStream.Read(size);
 	char declined = 0;
@@ -569,9 +571,10 @@ void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	uint32_t size = 0;
 	inStream.Read(size);
 
@@ -585,9 +588,10 @@ void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamKick(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	std::string kickedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
@@ -615,9 +619,10 @@ void ChatPacketHandler::HandleTeamKick(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	std::string promotedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
@@ -637,9 +642,10 @@ void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamLootOption(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 	uint32_t size = 0;
 	inStream.Read(size);
 
@@ -660,9 +666,10 @@ void ChatPacketHandler::HandleTeamLootOption(Packet* packet) {
 }
 
 void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
 	auto* team = playerContainer.GetTeam(playerID);
 	auto* data = playerContainer.GetPlayerData(playerID);
@@ -709,11 +716,11 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_TEAM_INVITE);
 
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write(sender->playerID);
@@ -724,14 +731,14 @@ void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender)
 
 void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_INVITE_CONFIRM);
 
 	bitStream.Write(bLeaderIsFreeTrial);
 	bitStream.Write(i64LeaderID);
@@ -751,14 +758,14 @@ void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeader
 
 void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_GET_STATUS_RESPONSE);
 
 	bitStream.Write(i64LeaderID);
 	bitStream.Write(i64LeaderZoneID);
@@ -776,14 +783,14 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI
 
 void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_SET_LEADER);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_LEADER);
 
 	bitStream.Write(i64PlayerID);
 
@@ -793,14 +800,14 @@ void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64Play
 
 void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_ADD_PLAYER);
 
 	bitStream.Write(bIsFreeTrial);
 	bitStream.Write(bLocal);
@@ -822,14 +829,14 @@ void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTria
 
 void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_REMOVE_PLAYER);
 
 	bitStream.Write(bDisband);
 	bitStream.Write(bIsKicked);
@@ -848,14 +855,14 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband
 
 void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
 	bitStream.Write(receiver->playerID);
-	bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG);
+	bitStream.Write(GAME_MSG::GAME_MSG_TEAM_SET_OFF_WORLD_FLAG);
 
 	bitStream.Write(i64PlayerID);
 	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID()) {
@@ -882,11 +889,11 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(friendData->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
 	std::string playerName = playerData->playerName.c_str();
@@ -921,11 +928,11 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	}
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_REQUEST);
 	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.
 
@@ -937,11 +944,11 @@ void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sen
 	if (!receiver || !sender) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	// Portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_ADD_FRIEND_RESPONSE);
 	bitStream.Write(responseCode);
 	// For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver.
 	bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
@@ -962,11 +969,11 @@ void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& pers
 	if (!receiver) return;
 
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, CLIENT, MSG_CLIENT_REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	PacketUtils::WritePacketWString(personToRemove, 33, &bitStream);
 

dChatServer/ChatServer.cpp

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

dChatServer/PlayerContainer.cpp

@@ -6,10 +6,9 @@
 #include "dLogger.h"
 #include "ChatPacketHandler.h"
 #include "GeneralUtils.h"
+#include "dMessageIdentifiers.h"
 #include "PacketUtils.h"
 #include "Database.h"
-#include "eConnectionType.h"
-#include "eChatInternalMessageType.h"
 
 PlayerContainer::PlayerContainer() {
 }
@@ -19,8 +18,9 @@ PlayerContainer::~PlayerContainer() {
 }
 
 void PlayerContainer::InsertPlayer(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	PlayerData* data = new PlayerData();
+	inStream.SetReadOffset(inStream.GetReadOffset() + 64);
 	inStream.Read(data->playerID);
 
 	uint32_t len;
@@ -51,8 +51,9 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 }
 
 void PlayerContainer::RemovePlayer(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
 	inStream.Read(playerID);
 
 	//Before they get kicked, we need to also send a message to their friends saying that they disconnected.
@@ -95,8 +96,9 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 }
 
 void PlayerContainer::MuteUpdate(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
 	inStream.Read(playerID);
 	time_t expire = 0;
 	inStream.Read(expire);
@@ -115,8 +117,9 @@ void PlayerContainer::MuteUpdate(Packet* packet) {
 }
 
 void PlayerContainer::CreateTeamServer(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID;
+	inStream.Read(playerID); //skip header
 	inStream.Read(playerID);
 	size_t membersSize = 0;
 	inStream.Read(membersSize);
@@ -146,7 +149,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_MUTE_UPDATE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -345,7 +348,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
+	PacketUtils::WriteHeader(bitStream, CHAT_INTERNAL, MSG_CHAT_INTERNAL_TEAM_UPDATE);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);

dCommon/AMFDeserialize.cpp

@@ -1,79 +1,77 @@
 #include "AMFDeserialize.h"
 
-#include <stdexcept>
-
-#include "Amf3.h"
+#include "AMFFormat.h"
 
 /**
  * AMF3 Reference document https://rtmp.veriskope.com/pdf/amf3-file-format-spec.pdf
  * AMF3 Deserializer written by EmosewaMC
  */
 
-AMFBaseValue* AMFDeserialize::Read(RakNet::BitStream* inStream) {
+AMFValue* AMFDeserialize::Read(RakNet::BitStream* inStream) {
 	if (!inStream) return nullptr;
-	AMFBaseValue* returnValue = nullptr;
+	AMFValue* returnValue = nullptr;
 	// Read in the value type from the bitStream
-	eAmf marker;
+	int8_t marker;
 	inStream->Read(marker);
 	// Based on the typing, create the value associated with that and return the base value class
 	switch (marker) {
-	case eAmf::Undefined: {
-		returnValue = new AMFBaseValue();
+	case AMFValueType::AMFUndefined: {
+		returnValue = new AMFUndefinedValue();
 		break;
 	}
 
-	case eAmf::Null: {
+	case AMFValueType::AMFNull: {
 		returnValue = new AMFNullValue();
 		break;
 	}
 
-	case eAmf::False: {
-		returnValue = new AMFBoolValue(false);
+	case AMFValueType::AMFFalse: {
+		returnValue = new AMFFalseValue();
 		break;
 	}
 
-	case eAmf::True: {
-		returnValue = new AMFBoolValue(true);
+	case AMFValueType::AMFTrue: {
+		returnValue = new AMFTrueValue();
 		break;
 	}
 
-	case eAmf::Integer: {
+	case AMFValueType::AMFInteger: {
 		returnValue = ReadAmfInteger(inStream);
 		break;
 	}
 
-	case eAmf::Double: {
+	case AMFValueType::AMFDouble: {
 		returnValue = ReadAmfDouble(inStream);
 		break;
 	}
 
-	case eAmf::String: {
+	case AMFValueType::AMFString: {
 		returnValue = ReadAmfString(inStream);
 		break;
 	}
 
-	case eAmf::Array: {
+	case AMFValueType::AMFArray: {
 		returnValue = ReadAmfArray(inStream);
 		break;
 	}
 
-	// These values are unimplemented in the live client and will remain unimplemented
-	// unless someone modifies the client to allow serializing of these values.
-	case eAmf::XMLDoc:
-	case eAmf::Date:
-	case eAmf::Object:
-	case eAmf::XML:
-	case eAmf::ByteArray:
-	case eAmf::VectorInt:
-	case eAmf::VectorUInt:
-	case eAmf::VectorDouble:
-	case eAmf::VectorObject:
-	case eAmf::Dictionary: {
-		throw marker;
+							   // TODO We do not need these values, but if someone wants to implement them
+							   // then please do so and add the corresponding unit tests.
+	case AMFValueType::AMFXMLDoc:
+	case AMFValueType::AMFDate:
+	case AMFValueType::AMFObject:
+	case AMFValueType::AMFXML:
+	case AMFValueType::AMFByteArray:
+	case AMFValueType::AMFVectorInt:
+	case AMFValueType::AMFVectorUInt:
+	case AMFValueType::AMFVectorDouble:
+	case AMFValueType::AMFVectorObject:
+	case AMFValueType::AMFDictionary: {
+		throw static_cast<AMFValueType>(marker);
 		break;
 	}
 	default:
-		throw std::invalid_argument("Invalid AMF3 marker" + std::to_string(static_cast<int32_t>(marker)));
+		throw static_cast<AMFValueType>(marker);
 		break;
 	}
 	return returnValue;
@@ -101,7 +99,7 @@ uint32_t AMFDeserialize::ReadU29(RakNet::BitStream* inStream) {
 	return actualNumber;
 }
 
-const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
+std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
 	auto length = ReadU29(inStream);
 	// Check if this is a reference
 	bool isReference = length % 2 == 1;
@@ -115,39 +113,48 @@ const std::string AMFDeserialize::ReadString(RakNet::BitStream* inStream) {
 		return value;
 	} else {
 		// Length is a reference to a previous index - use that as the read in value
-		return accessedElements.at(length);
+		return accessedElements[length];
 	}
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream* inStream) {
+AMFValue* AMFDeserialize::ReadAmfDouble(RakNet::BitStream* inStream) {
+	auto doubleValue = new AMFDoubleValue();
 	double value;
 	inStream->Read<double>(value);
-	return new AMFDoubleValue(value);
+	doubleValue->SetDoubleValue(value);
+	return doubleValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream* inStream) {
+AMFValue* AMFDeserialize::ReadAmfArray(RakNet::BitStream* inStream) {
 	auto arrayValue = new AMFArrayValue();
 
 	// Read size of dense array
 	auto sizeOfDenseArray = (ReadU29(inStream) >> 1);
-	// Then read associative portion
+
+	// Then read Key'd portion
 	while (true) {
 		auto key = ReadString(inStream);
-		// No more associative values when we encounter an empty string key
+		// No more values when we encounter an empty string
 		if (key.size() == 0) break;
-		arrayValue->Insert(key, Read(inStream));
+		arrayValue->InsertValue(key, Read(inStream));
 	}
+
 	// Finally read dense portion
 	for (uint32_t i = 0; i < sizeOfDenseArray; i++) {
-		arrayValue->Insert(i, Read(inStream));
+		arrayValue->PushBackValue(Read(inStream));
 	}
+
 	return arrayValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfString(RakNet::BitStream* inStream) {
-	return new AMFStringValue(ReadString(inStream));
+AMFValue* AMFDeserialize::ReadAmfString(RakNet::BitStream* inStream) {
+	auto stringValue = new AMFStringValue();
+	stringValue->SetStringValue(ReadString(inStream));
+	return stringValue;
 }
 
-AMFBaseValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream* inStream) {
-	return new AMFIntValue(ReadU29(inStream));
+AMFValue* AMFDeserialize::ReadAmfInteger(RakNet::BitStream* inStream) {
+	auto integerValue = new AMFIntegerValue();
+	integerValue->SetIntegerValue(ReadU29(inStream));
+	return integerValue;
 }

dCommon/AMFDeserialize.h

@@ -5,8 +5,7 @@
 #include <vector>
 #include <string>
 
-class AMFBaseValue;
-
+class AMFValue;
 class AMFDeserialize {
 public:
 	/**
@@ -15,7 +14,7 @@ public:
 	 * @param inStream inStream to read value from.
 	 * @return Returns an AMFValue with all the information from the bitStream in it.
 	 */
-	AMFBaseValue* Read(RakNet::BitStream* inStream);
+	AMFValue* Read(RakNet::BitStream* inStream);
 private:
 	/**
 	 * @brief Private method to read a U29 integer from a bitstream
@@ -31,7 +30,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return The read string
 	 */
-	const std::string ReadString(RakNet::BitStream* inStream);
+	std::string ReadString(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFDouble value from a bitStream
@@ -39,7 +38,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Double value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfDouble(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfDouble(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFArray from a bitStream
@@ -47,7 +46,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Array value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfArray(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfArray(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFString from a bitStream
@@ -55,7 +54,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return String value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfString(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfString(RakNet::BitStream* inStream);
 
 	/**
 	 * @brief Read an AMFInteger from a bitStream
@@ -63,7 +62,7 @@ private:
 	 * @param inStream bitStream to read data from
 	 * @return Integer value represented as an AMFValue
 	 */
-	AMFBaseValue* ReadAmfInteger(RakNet::BitStream* inStream);
+	AMFValue* ReadAmfInteger(RakNet::BitStream* inStream);
 
 	/**
 	 * List of strings read so far saved to be read by reference.

dCommon/AMFFormat.cpp

@@ -0,0 +1,156 @@
+#include "AMFFormat.h"
+
+// AMFInteger
+void AMFIntegerValue::SetIntegerValue(uint32_t value) {
+	this->value = value;
+}
+
+uint32_t AMFIntegerValue::GetIntegerValue() {
+	return this->value;
+}
+
+// AMFDouble
+void AMFDoubleValue::SetDoubleValue(double value) {
+	this->value = value;
+}
+
+double AMFDoubleValue::GetDoubleValue() {
+	return this->value;
+}
+
+// AMFString
+void AMFStringValue::SetStringValue(const std::string& value) {
+	this->value = value;
+}
+
+std::string AMFStringValue::GetStringValue() {
+	return this->value;
+}
+
+// AMFXMLDoc
+void AMFXMLDocValue::SetXMLDocValue(const std::string& value) {
+	this->xmlData = value;
+}
+
+std::string AMFXMLDocValue::GetXMLDocValue() {
+	return this->xmlData;
+}
+
+// AMFDate
+void AMFDateValue::SetDateValue(uint64_t value) {
+	this->millisecondTimestamp = value;
+}
+
+uint64_t AMFDateValue::GetDateValue() {
+	return this->millisecondTimestamp;
+}
+
+// AMFArray Insert Value
+void AMFArrayValue::InsertValue(const std::string& key, AMFValue* value) {
+	this->associative.insert(std::make_pair(key, value));
+}
+
+// AMFArray Remove Value
+void AMFArrayValue::RemoveValue(const std::string& key) {
+	_AMFArrayMap_::iterator it = this->associative.find(key);
+	if (it != this->associative.end()) {
+		this->associative.erase(it);
+	}
+}
+
+// AMFArray Get Associative Iterator Begin
+_AMFArrayMap_::iterator AMFArrayValue::GetAssociativeIteratorValueBegin() {
+	return this->associative.begin();
+}
+
+// AMFArray Get Associative Iterator End
+_AMFArrayMap_::iterator AMFArrayValue::GetAssociativeIteratorValueEnd() {
+	return this->associative.end();
+}
+
+// AMFArray Push Back Value
+void AMFArrayValue::PushBackValue(AMFValue* value) {
+	this->dense.push_back(value);
+}
+
+// AMFArray Pop Back Value
+void AMFArrayValue::PopBackValue() {
+	this->dense.pop_back();
+}
+
+// AMFArray Get Dense List Size
+uint32_t AMFArrayValue::GetDenseValueSize() {
+	return (uint32_t)this->dense.size();
+}
+
+// AMFArray Get Dense Iterator Begin
+_AMFArrayList_::iterator AMFArrayValue::GetDenseIteratorBegin() {
+	return this->dense.begin();
+}
+
+// AMFArray Get Dense Iterator End
+_AMFArrayList_::iterator AMFArrayValue::GetDenseIteratorEnd() {
+	return this->dense.end();
+}
+
+AMFArrayValue::~AMFArrayValue() {
+	for (auto valueToDelete : GetDenseArray()) {
+		if (valueToDelete) delete valueToDelete;
+	}
+	for (auto valueToDelete : GetAssociativeMap()) {
+		if (valueToDelete.second) delete valueToDelete.second;
+	}
+}
+
+// AMFObject Constructor
+AMFObjectValue::AMFObjectValue(std::vector<std::pair<std::string, AMFValueType>> traits) {
+	this->traits.reserve(traits.size());
+	std::vector<std::pair<std::string, AMFValueType>>::iterator it = traits.begin();
+	while (it != traits.end()) {
+		this->traits.insert(std::make_pair(it->first, std::make_pair(it->second, new AMFNullValue())));
+		it++;
+	}
+}
+
+// AMFObject Set Value
+void AMFObjectValue::SetTraitValue(const std::string& trait, AMFValue* value) {
+	if (value) {
+		_AMFObjectTraits_::iterator it = this->traits.find(trait);
+		if (it != this->traits.end()) {
+			if (it->second.first == value->GetValueType()) {
+				it->second.second = value;
+			}
+		}
+	}
+}
+
+// AMFObject Get Value
+AMFValue* AMFObjectValue::GetTraitValue(const std::string& trait) {
+	_AMFObjectTraits_::iterator it = this->traits.find(trait);
+	if (it != this->traits.end()) {
+		return it->second.second;
+	}
+
+	return nullptr;
+}
+
+// AMFObject Get Trait Iterator Begin
+_AMFObjectTraits_::iterator AMFObjectValue::GetTraitsIteratorBegin() {
+	return this->traits.begin();
+}
+
+// AMFObject Get Trait Iterator End
+_AMFObjectTraits_::iterator AMFObjectValue::GetTraitsIteratorEnd() {
+	return this->traits.end();
+}
+
+// AMFObject Get Trait Size
+uint32_t AMFObjectValue::GetTraitArrayCount() {
+	return (uint32_t)this->traits.size();
+}
+
+AMFObjectValue::~AMFObjectValue() {
+	for (auto valueToDelete = GetTraitsIteratorBegin(); valueToDelete != GetTraitsIteratorEnd(); valueToDelete++) {
+		if (valueToDelete->second.second) delete valueToDelete->second.second;
+	}
+}

dCommon/AMFFormat.h

@@ -0,0 +1,413 @@
+#pragma once
+
+// Custom Classes
+#include "dCommonVars.h"
+
+// C++
+#include <unordered_map>
+#include <vector>
+
+/*!
+  \file AMFFormat.hpp
+  \brief A class for managing AMF values
+ */
+
+class AMFValue;     // Forward declaration
+
+// Definitions
+#define _AMFArrayMap_               std::unordered_map<std::string, AMFValue*>
+#define _AMFArrayList_              std::vector<AMFValue*>
+
+#define _AMFObjectTraits_           std::unordered_map<std::string, std::pair<AMFValueType, AMFValue*>>
+#define _AMFObjectDynamicTraits_    std::unordered_map<std::string, AMFValue*>
+
+//! An enum for each AMF value type
+enum AMFValueType : unsigned char {
+	AMFUndefined = 0x00,            //!< An undefined AMF Value
+	AMFNull = 0x01,                 //!< A null AMF value
+	AMFFalse = 0x02,                //!< A false AMF value
+	AMFTrue = 0x03,                 //!< A true AMF value
+	AMFInteger = 0x04,              //!< An integer AMF value
+	AMFDouble = 0x05,               //!< A double AMF value
+	AMFString = 0x06,               //!< A string AMF value
+	AMFXMLDoc = 0x07,               //!< An XML Doc AMF value
+	AMFDate = 0x08,                 //!< A date AMF value
+	AMFArray = 0x09,                //!< An array AMF value
+	AMFObject = 0x0A,               //!< An object AMF value
+	AMFXML = 0x0B,                  //!< An XML AMF value
+	AMFByteArray = 0x0C,            //!< A byte array AMF value
+	AMFVectorInt = 0x0D,            //!< An integer vector AMF value
+	AMFVectorUInt = 0x0E,           //!< An unsigned integer AMF value
+	AMFVectorDouble = 0x0F,         //!< A double vector AMF value
+	AMFVectorObject = 0x10,         //!< An object vector AMF value
+	AMFDictionary = 0x11            //!< A dictionary AMF value
+};
+
+//! An enum for the object value types
+enum AMFObjectValueType : unsigned char {
+	AMFObjectAnonymous = 0x01,
+	AMFObjectTyped = 0x02,
+	AMFObjectDynamic = 0x03,
+	AMFObjectExternalizable = 0x04
+};
+
+//! The base AMF value class
+class AMFValue {
+public:
+	//! Returns the AMF value type
+	/*!
+	  \return The AMF value type
+	 */
+	virtual AMFValueType GetValueType() = 0;
+	virtual ~AMFValue() {};
+};
+
+//! A typedef for a pointer to an AMF value
+typedef AMFValue* NDGFxValue;
+
+
+// The various AMF value types
+
+//! The undefined value AMF type
+class AMFUndefinedValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	  \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFUndefined;
+};
+
+//! The null value AMF type
+class AMFNullValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFNull;
+};
+
+//! The false value AMF type
+class AMFFalseValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFFalse;
+};
+
+//! The true value AMF type
+class AMFTrueValue : public AMFValue {
+private:
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+public:
+	static const AMFValueType ValueType = AMFTrue;
+};
+
+//! The integer value AMF type
+class AMFIntegerValue : public AMFValue {
+private:
+	uint32_t value;         //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFInteger;
+	//! Sets the integer value
+	/*!
+	  \param value The value to set
+	 */
+	void SetIntegerValue(uint32_t value);
+
+	//! Gets the integer value
+	/*!
+	  \return The integer value
+	 */
+	uint32_t GetIntegerValue();
+};
+
+//! The double value AMF type
+class AMFDoubleValue : public AMFValue {
+private:
+	double value;           //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFDouble;
+	//! Sets the double value
+	/*!
+	  \param value The value to set to
+	 */
+	void SetDoubleValue(double value);
+
+	//! Gets the double value
+	/*!
+	  \return The double value
+	 */
+	double GetDoubleValue();
+};
+
+//! The string value AMF type
+class AMFStringValue : public AMFValue {
+private:
+	std::string value;          //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFString;
+	//! Sets the string value
+	/*!
+	  \param value The string value to set to
+	 */
+	void SetStringValue(const std::string& value);
+
+	//! Gets the string value
+	/*!
+	  \return The string value
+	 */
+	std::string GetStringValue();
+};
+
+//! The XML doc value AMF type
+class AMFXMLDocValue : public AMFValue {
+private:
+	std::string xmlData;            //!< The value of the AMF type
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFXMLDoc;
+	//! Sets the XML Doc value
+	/*!
+	  \param value The value to set to
+	 */
+	void SetXMLDocValue(const std::string& value);
+
+	//! Gets the XML Doc value
+	/*!
+	  \return The XML Doc value
+	 */
+	std::string GetXMLDocValue();
+};
+
+//! The date value AMF type
+class AMFDateValue : public AMFValue {
+private:
+	uint64_t millisecondTimestamp;      //!< The time in milliseconds since the ephoch
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFDate;
+	//! Sets the date time
+	/*!
+	  \param value The value to set to
+	 */
+	void SetDateValue(uint64_t value);
+
+	//! Gets the date value
+	/*!
+	  \return The date value in milliseconds since the epoch
+	 */
+	uint64_t GetDateValue();
+};
+
+//! The array value AMF type
+// This object will manage it's own memory map and list.  Do not delete its values.
+class AMFArrayValue : public AMFValue {
+private:
+	_AMFArrayMap_ associative;      //!< The array map (associative part)
+	_AMFArrayList_ dense;           //!< The array list (dense part)
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() override { return ValueType; }
+
+public:
+	static const AMFValueType ValueType = AMFArray;
+
+	~AMFArrayValue() override;
+	//! Inserts an item into the array map for a specific key
+	/*!
+	  \param key The key to set
+	  \param value The value to add
+	 */
+	void InsertValue(const std::string& key, AMFValue* value);
+
+	//! Removes an item for a specific key
+	/*!
+	  \param key The key to remove
+	 */
+	void RemoveValue(const std::string& key);
+
+	//! Finds an AMF value
+	/*!
+	  \return The AMF value if found, nullptr otherwise
+	 */
+	template <typename T>
+	T* FindValue(const std::string& key) const {
+		_AMFArrayMap_::const_iterator it = this->associative.find(key);
+		if (it != this->associative.end() && T::ValueType == it->second->GetValueType()) {
+			return dynamic_cast<T*>(it->second);
+		}
+
+		return nullptr;
+	};
+
+	//! Returns where the associative iterator begins
+	/*!
+	  \return Where the array map iterator begins
+	 */
+	_AMFArrayMap_::iterator GetAssociativeIteratorValueBegin();
+
+	//! Returns where the associative iterator ends
+	/*!
+	  \return Where the array map iterator ends
+	 */
+	_AMFArrayMap_::iterator GetAssociativeIteratorValueEnd();
+
+	//! Pushes back a value into the array list
+	/*!
+	  \param value The value to push back
+	 */
+	void PushBackValue(AMFValue* value);
+
+	//! Pops back the last value in the array list
+	void PopBackValue();
+
+	//! Gets the count of the dense list
+	/*!
+	  \return The dense list size
+	 */
+	uint32_t GetDenseValueSize();
+
+	//! Gets a specific value from the list for the specified index
+	/*!
+	  \param index The index to get
+	 */
+	template <typename T>
+	T* GetValueAt(uint32_t index) {
+		if (index >= this->dense.size()) return nullptr;
+		AMFValue* foundValue = this->dense.at(index);
+		return T::ValueType == foundValue->GetValueType() ? dynamic_cast<T*>(foundValue) : nullptr;
+	};
+
+	//! Returns where the dense iterator begins
+	/*!
+	  \return Where the iterator begins
+	 */
+	_AMFArrayList_::iterator GetDenseIteratorBegin();
+
+	//! Returns where the dense iterator ends
+	/*!
+	  \return Where the iterator ends
+	 */
+	_AMFArrayList_::iterator GetDenseIteratorEnd();
+
+	//! Returns the associative map
+	/*!
+	  \return The associative map
+	 */
+	_AMFArrayMap_ GetAssociativeMap() { return this->associative; };
+
+	//! Returns the dense array
+	/*!
+	  \return The dense array
+	 */
+	_AMFArrayList_ GetDenseArray() { return this->dense; };
+};
+
+//! The anonymous object value AMF type
+class AMFObjectValue : public AMFValue {
+private:
+	_AMFObjectTraits_ traits;           //!< The object traits
+
+	//! Returns the AMF value type
+	/*!
+	 \return The AMF value type
+	 */
+	AMFValueType GetValueType() override { return ValueType; }
+	~AMFObjectValue() override;
+
+public:
+	static const AMFValueType ValueType = AMFObject;
+	//! Constructor
+	/*!
+	  \param traits The traits to set
+	 */
+	AMFObjectValue(std::vector<std::pair<std::string, AMFValueType>> traits);
+
+	//! Gets the object value type
+	/*!
+	  \return The object value type
+	 */
+	virtual AMFObjectValueType GetObjectValueType() { return AMFObjectAnonymous; }
+
+	//! Sets the value of a trait
+	/*!
+	  \param trait The trait to set the value for
+	  \param value The AMF value to set
+	 */
+	void SetTraitValue(const std::string& trait, AMFValue* value);
+
+	//! Gets a trait value
+	/*!
+	  \param trait The trait to get the value for
+	  \return The trait value
+	 */
+	AMFValue* GetTraitValue(const std::string& trait);
+
+	//! Gets the beginning of the object traits iterator
+	/*!
+	  \return The AMF trait array iterator begin
+	 */
+	_AMFObjectTraits_::iterator GetTraitsIteratorBegin();
+
+	//! Gets the end of the object traits iterator
+	/*!
+	  \return The AMF trait array iterator begin
+	 */
+	_AMFObjectTraits_::iterator GetTraitsIteratorEnd();
+
+	//! Gets the amount of traits
+	/*!
+	  \return The amount of traits
+	 */
+	uint32_t GetTraitArrayCount();
+};

dCommon/AMFFormat_BitStream.cpp

@@ -0,0 +1,250 @@
+#include "AMFFormat_BitStream.h"
+
+// Writes an AMFValue pointer to a RakNet::BitStream
+template<>
+void RakNet::BitStream::Write<AMFValue*>(AMFValue* value) {
+	if (value != nullptr) {
+		AMFValueType type = value->GetValueType();
+
+		switch (type) {
+		case AMFUndefined: {
+			AMFUndefinedValue* v = (AMFUndefinedValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFNull: {
+			AMFNullValue* v = (AMFNullValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFFalse: {
+			AMFFalseValue* v = (AMFFalseValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFTrue: {
+			AMFTrueValue* v = (AMFTrueValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFInteger: {
+			AMFIntegerValue* v = (AMFIntegerValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFDouble: {
+			AMFDoubleValue* v = (AMFDoubleValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFString: {
+			AMFStringValue* v = (AMFStringValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFXMLDoc: {
+			AMFXMLDocValue* v = (AMFXMLDocValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFDate: {
+			AMFDateValue* v = (AMFDateValue*)value;
+			this->Write(*v);
+			break;
+		}
+
+		case AMFArray: {
+			this->Write((AMFArrayValue*)value);
+			break;
+		}
+		}
+	}
+}
+
+/**
+ * A private function to write an value to a RakNet::BitStream
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
+	unsigned char b4 = (unsigned char)v;
+	if (v < 0x00200000) {
+		b4 = b4 & 0x7F;
+		if (v > 0x7F) {
+			unsigned char b3;
+			v = v >> 7;
+			b3 = ((unsigned char)(v)) | 0x80;
+			if (v > 0x7F) {
+				unsigned char b2;
+				v = v >> 7;
+				b2 = ((unsigned char)(v)) | 0x80;
+				bs->Write(b2);
+			}
+
+			bs->Write(b3);
+		}
+	} else {
+		unsigned char b1;
+		unsigned char b2;
+		unsigned char b3;
+
+		v = v >> 8;
+		b3 = ((unsigned char)(v)) | 0x80;
+		v = v >> 7;
+		b2 = ((unsigned char)(v)) | 0x80;
+		v = v >> 7;
+		b1 = ((unsigned char)(v)) | 0x80;
+
+		bs->Write(b1);
+		bs->Write(b2);
+		bs->Write(b3);
+	}
+
+	bs->Write(b4);
+}
+
+/**
+ * Writes a flag number to a RakNet::BitStream
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
+	v = (v << 1) | 0x01;
+	WriteUInt29(bs, v);
+}
+
+/**
+ * Writes an AMFString to a RakNet::BitStream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
+	WriteFlagNumber(bs, (uint32_t)str.size());
+	bs->Write(str.c_str(), (uint32_t)str.size());
+}
+
+/**
+ * Writes an U16 to a bitstream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
+	bs->Write(value);
+}
+
+/**
+ * Writes an U32 to a bitstream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
+	bs->Write(value);
+}
+
+/**
+ * Writes an U64 to a bitstream
+ *
+ * RakNet writes in the correct byte order - do not reverse this.
+ */
+void WriteAMFU64(RakNet::BitStream* bs, uint64_t value) {
+	bs->Write(value);
+}
+
+
+// Writes an AMFUndefinedValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFUndefinedValue>(AMFUndefinedValue value) {
+	this->Write(AMFUndefined);
+}
+
+// Writes an AMFNullValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFNullValue>(AMFNullValue value) {
+	this->Write(AMFNull);
+}
+
+// Writes an AMFFalseValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFFalseValue>(AMFFalseValue value) {
+	this->Write(AMFFalse);
+}
+
+// Writes an AMFTrueValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFTrueValue>(AMFTrueValue value) {
+	this->Write(AMFTrue);
+}
+
+// Writes an AMFIntegerValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFIntegerValue>(AMFIntegerValue value) {
+	this->Write(AMFInteger);
+	WriteUInt29(this, value.GetIntegerValue());
+}
+
+// Writes an AMFDoubleValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFDoubleValue>(AMFDoubleValue value) {
+	this->Write(AMFDouble);
+	double d = value.GetDoubleValue();
+	WriteAMFU64(this, *((unsigned long long*) & d));
+}
+
+// Writes an AMFStringValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFStringValue>(AMFStringValue value) {
+	this->Write(AMFString);
+	std::string v = value.GetStringValue();
+	WriteAMFString(this, v);
+}
+
+// Writes an AMFXMLDocValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFXMLDocValue>(AMFXMLDocValue value) {
+	this->Write(AMFXMLDoc);
+	std::string v = value.GetXMLDocValue();
+	WriteAMFString(this, v);
+}
+
+// Writes an AMFDateValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFDateValue>(AMFDateValue value) {
+	this->Write(AMFDate);
+	uint64_t date = value.GetDateValue();
+	WriteAMFU64(this, date);
+}
+
+// Writes an AMFArrayValue to BitStream
+template<>
+void RakNet::BitStream::Write<AMFArrayValue*>(AMFArrayValue* value) {
+	this->Write(AMFArray);
+	uint32_t denseSize = value->GetDenseValueSize();
+	WriteFlagNumber(this, denseSize);
+
+	_AMFArrayMap_::iterator it = value->GetAssociativeIteratorValueBegin();
+	_AMFArrayMap_::iterator end = value->GetAssociativeIteratorValueEnd();
+
+	while (it != end) {
+		WriteAMFString(this, it->first);
+		this->Write(it->second);
+		it++;
+	}
+
+	this->Write(AMFNull);
+
+	if (denseSize > 0) {
+		_AMFArrayList_::iterator it2 = value->GetDenseIteratorBegin();
+		_AMFArrayList_::iterator end2 = value->GetDenseIteratorEnd();
+
+		while (it2 != end2) {
+			this->Write(*it2);
+			it2++;
+		}
+	}
+}

dCommon/AMFFormat_BitStream.h

@@ -0,0 +1,92 @@
+#pragma once
+
+// Custom Classes
+#include "AMFFormat.h"
+
+// RakNet
+#include <BitStream.h>
+
+/*!
+ \file AMFFormat_BitStream.h
+ \brief A class that implements native writing of AMF values to RakNet::BitStream
+ */
+
+ // We are using the RakNet namespace
+namespace RakNet {
+	//! Writes an AMFValue pointer to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFValue*>(AMFValue* value);
+
+	//! Writes an AMFUndefinedValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFUndefinedValue>(AMFUndefinedValue value);
+
+	//! Writes an AMFNullValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFNullValue>(AMFNullValue value);
+
+	//! Writes an AMFFalseValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFFalseValue>(AMFFalseValue value);
+
+	//! Writes an AMFTrueValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFTrueValue>(AMFTrueValue value);
+
+	//! Writes an AMFIntegerValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFIntegerValue>(AMFIntegerValue value);
+
+	//! Writes an AMFDoubleValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFDoubleValue>(AMFDoubleValue value);
+
+	//! Writes an AMFStringValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFStringValue>(AMFStringValue value);
+
+	//! Writes an AMFXMLDocValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFXMLDocValue>(AMFXMLDocValue value);
+
+	//! Writes an AMFDateValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFDateValue>(AMFDateValue value);
+
+	//! Writes an AMFArrayValue to a RakNet::BitStream
+	/*!
+	 \param value The value to write
+	 */
+	template <>
+	void RakNet::BitStream::Write<AMFArrayValue*>(AMFArrayValue* value);
+} // namespace RakNet

dCommon/Amf3.h

@@ -1,367 +0,0 @@
-#ifndef __AMF3__H__
-#define __AMF3__H__
-
-#include "dCommonVars.h"
-#include "dLogger.h"
-#include "Game.h"
-
-#include <unordered_map>
-#include <vector>
-
-enum class eAmf : uint8_t {
-	Undefined = 0x00,            // An undefined AMF Value
-	Null = 0x01,                 // A null AMF value
-	False = 0x02,                // A false AMF value
-	True = 0x03,                 // A true AMF value
-	Integer = 0x04,              // An integer AMF value
-	Double = 0x05,               // A double AMF value
-	String = 0x06,               // A string AMF value
-	XMLDoc = 0x07,               // Unused in the live client and cannot be serialized without modification.  An XML Doc AMF value
-	Date = 0x08,                 // Unused in the live client and cannot be serialized without modification.  A date AMF value
-	Array = 0x09,                // An array AMF value
-	Object = 0x0A,               // Unused in the live client and cannot be serialized without modification.  An object AMF value
-	XML = 0x0B,                  // Unused in the live client and cannot be serialized without modification.  An XML AMF value
-	ByteArray = 0x0C,            // Unused in the live client and cannot be serialized without modification.  A byte array AMF value
-	VectorInt = 0x0D,            // Unused in the live client and cannot be serialized without modification.  An integer vector AMF value
-	VectorUInt = 0x0E,           // Unused in the live client and cannot be serialized without modification.  An unsigned integer AMF value
-	VectorDouble = 0x0F,         // Unused in the live client and cannot be serialized without modification.  A double vector AMF value
-	VectorObject = 0x10,         // Unused in the live client and cannot be serialized without modification.  An object vector AMF value
-	Dictionary = 0x11            // Unused in the live client and cannot be serialized without modification.  A dictionary AMF value
-};
-
-class AMFBaseValue {
-public:
-	virtual eAmf GetValueType() { return eAmf::Undefined; };
-	AMFBaseValue() {};
-	virtual ~AMFBaseValue() {};
-};
-
-template<typename ValueType>
-class AMFValue : public AMFBaseValue {
-public:
-	AMFValue() {};
-	AMFValue(ValueType value) { SetValue(value); };
-	virtual ~AMFValue() override {};
-
-	eAmf GetValueType() override { return eAmf::Undefined; };
-
-	const ValueType& GetValue() { return data; };
-	void SetValue(ValueType value) { data = value; };
-protected:
-	ValueType data;
-};
-
-// As a string this is much easier to write and read from a BitStream.
-template<>
-class AMFValue<const char*> : public AMFBaseValue {
-public:
-	AMFValue() {};
-	AMFValue(const char* value) { SetValue(std::string(value)); };
-	virtual ~AMFValue() override {};
-
-	eAmf GetValueType() override { return eAmf::String; };
-
-	const std::string& GetValue() { return data; };
-	void SetValue(std::string value) { data = value; };
-protected:
-	std::string data;
-};
-
-typedef AMFValue<std::nullptr_t> AMFNullValue;
-typedef AMFValue<bool> AMFBoolValue;
-typedef AMFValue<int32_t> AMFIntValue;
-typedef AMFValue<std::string> AMFStringValue;
-typedef AMFValue<double> AMFDoubleValue;
-
-template<> inline eAmf AMFValue<std::nullptr_t>::GetValueType() { return eAmf::Null; };
-template<> inline eAmf AMFValue<bool>::GetValueType() { return this->data ? eAmf::True : eAmf::False; };
-template<> inline eAmf AMFValue<int32_t>::GetValueType() { return eAmf::Integer; };
-template<> inline eAmf AMFValue<uint32_t>::GetValueType() { return eAmf::Integer; };
-template<> inline eAmf AMFValue<std::string>::GetValueType() { return eAmf::String; };
-template<> inline eAmf AMFValue<double>::GetValueType() { return eAmf::Double; };
-
-/**
- * The AMFArrayValue object holds 2 types of lists:
- * An associative list where a key maps to a value
- * A Dense list where elements are stored back to back
- *
- * Objects that are Registered are owned by this object
- * and are not to be deleted by a caller.
- */
-class AMFArrayValue : public AMFBaseValue {
-
-	typedef std::unordered_map<std::string, AMFBaseValue*> AMFAssociative;
-	typedef std::vector<AMFBaseValue*> AMFDense;
-
-public:
-	eAmf GetValueType() override { return eAmf::Array; };
-
-	~AMFArrayValue() override {
-		for (auto valueToDelete : GetDense()) {
-			if (valueToDelete) {
-				delete valueToDelete;
-				valueToDelete = nullptr;
-			}
-		}
-		for (auto valueToDelete : GetAssociative()) {
-			if (valueToDelete.second) {
-				delete valueToDelete.second;
-				valueToDelete.second = nullptr;
-			}
-		}
-	};
-
-	/**
-	 * Returns the Associative portion of the object
-	 */
-	inline AMFAssociative& GetAssociative() { return this->associative; };
-
-	/**
-	 * Returns the dense portion of the object
-	 */
-	inline AMFDense& GetDense() { return this->dense; };
-
-	/**
-	 * Inserts an AMFValue into the associative portion with the given key.
-	 * If a duplicate is attempted to be inserted, it is ignored and the
-	 * first value with that key is kept in the map.
-	 *
-	 * These objects are not to be deleted by the caller as they are owned by
-	 * the AMFArray object which manages its own memory.
-	 *
-	 * @param key The key to associate with the value
-	 * @param value The value to insert
-	 *
-	 * @return The inserted element if the type matched,
-	 * or nullptr if a key existed and was not the same type
-	 */
-	template<typename ValueType>
-	std::pair<AMFValue<ValueType>*, bool> Insert(const std::string& key, ValueType value) {
-		auto element = associative.find(key);
-		AMFValue<ValueType>* val = nullptr;
-		bool found = true;
-		if (element == associative.end()) {
-			val = new AMFValue<ValueType>(value);
-			associative.insert(std::make_pair(key, val));
-		} else {
-			val = dynamic_cast<AMFValue<ValueType>*>(element->second);
-			found = false;
-		}
-		return std::make_pair(val, found);
-	};
-
-	// Associates an array with a string key
-	std::pair<AMFBaseValue*, bool> Insert(const std::string& key) {
-		auto element = associative.find(key);
-		AMFArrayValue* val = nullptr;
-		bool found = true;
-		if (element == associative.end()) {
-			val = new AMFArrayValue();
-			associative.insert(std::make_pair(key, val));
-		} else {
-			val = dynamic_cast<AMFArrayValue*>(element->second);
-			found = false;
-		}
-		return std::make_pair(val, found);
-	};
-
-	// Associates an array with an integer key
-	std::pair<AMFBaseValue*, bool> Insert(const uint32_t& index) {
-		AMFArrayValue* val = nullptr;
-		bool inserted = false;
-		if (index >= dense.size()) {
-			dense.resize(index + 1);
-			val = new AMFArrayValue();
-			dense.at(index) = val;
-			inserted = true;
-		}
-		return std::make_pair(dynamic_cast<AMFArrayValue*>(dense.at(index)), inserted);
-	};
-
-	/**
-	 * @brief Inserts an AMFValue into the AMFArray key'd by index.
-	 * Attempting to insert the same key to the same value twice overwrites
-	 * the previous value with the new one.
-	 *
-	 * @param index The index to associate with the value
-	 * @param value The value to insert
-	 * @return The inserted element, or nullptr if the type did not match
-	 * what was at the index.
-	 */
-	template<typename ValueType>
-	std::pair<AMFValue<ValueType>*, bool> Insert(const uint32_t& index, ValueType value) {
-		AMFValue<ValueType>* val = nullptr;
-		bool inserted = false;
-		if (index >= this->dense.size()) {
-			this->dense.resize(index + 1);
-			val = new AMFValue<ValueType>(value);
-			this->dense.at(index) = val;
-			inserted = true;
-		}
-		return std::make_pair(dynamic_cast<AMFValue<ValueType>*>(this->dense.at(index)), inserted);
-	};
-
-	/**
-	 * Inserts an AMFValue into the associative portion with the given key.
-	 * If a duplicate is attempted to be inserted, it replaces the original
-	 *
-	 * The inserted element is now owned by this object and is not to be deleted
-	 *
-	 * @param key The key to associate with the value
-	 * @param value The value to insert
-	 */
-	void Insert(const std::string& key, AMFBaseValue* value) {
-		auto element = associative.find(key);
-		if (element != associative.end() && element->second) {
-			delete element->second;
-			element->second = value;
-		} else {
-			associative.insert(std::make_pair(key, value));
-		}
-	};
-
-	/**
-	 * Inserts an AMFValue into the associative portion with the given index.
-	 * If a duplicate is attempted to be inserted, it replaces the original
-	 *
-	 * The inserted element is now owned by this object and is not to be deleted
-	 *
-	 * @param key The key to associate with the value
-	 * @param value The value to insert
-	 */
-	void Insert(const uint32_t index, AMFBaseValue* value) {
-		if (index < dense.size()) {
-			AMFDense::iterator itr = dense.begin() + index;
-			if (*itr) delete dense.at(index);
-		} else {
-			dense.resize(index + 1);
-		}
-		dense.at(index) = value;
-	};
-
-	/**
-	 * Pushes an AMFValue into the back of the dense portion.
-	 *
-	 * These objects are not to be deleted by the caller as they are owned by
-	 * the AMFArray object which manages its own memory.
-	 *
-	 * @param value The value to insert
-	 *
-	 * @return The inserted pointer, or nullptr should the key already be in use.
-	 */
-	template<typename ValueType>
-	inline AMFValue<ValueType>* Push(ValueType value) {
-		return Insert(this->dense.size(), value).first;
-	};
-
-	/**
-	 * Removes the key from the associative portion
-	 *
-	 * The pointer removed is now no longer managed by this container
-	 *
-	 * @param key The key to remove from the associative portion
-	 */
-	void Remove(const std::string& key, bool deleteValue = true) {
-		AMFAssociative::iterator it = this->associative.find(key);
-		if (it != this->associative.end()) {
-			if (deleteValue) delete it->second;
-			this->associative.erase(it);
-		}
-	}
-
-	/**
-	 * Pops the last element in the dense portion, deleting it in the process.
-	 */
-	void Remove(const uint32_t index) {
-		if (!this->dense.empty() && index < this->dense.size()) {
-			auto itr = this->dense.begin() + index;
-			if (*itr) delete (*itr);
-			this->dense.erase(itr);
-		}
-	}
-
-	void Pop() {
-		if (!this->dense.empty()) Remove(this->dense.size() - 1);
-	}
-
-	AMFArrayValue* GetArray(const std::string& key) {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		if (it != this->associative.end()) {
-			return dynamic_cast<AMFArrayValue*>(it->second);
-		}
-		return nullptr;
-	};
-
-	AMFArrayValue* GetArray(const uint32_t index) {
-		return index >= this->dense.size() ? nullptr : dynamic_cast<AMFArrayValue*>(this->dense.at(index));
-	};
-
-	inline AMFArrayValue* InsertArray(const std::string& key) {
-		return static_cast<AMFArrayValue*>(Insert(key).first);
-	};
-
-	inline AMFArrayValue* InsertArray(const uint32_t index) {
-		return static_cast<AMFArrayValue*>(Insert(index).first);
-	};
-
-	inline AMFArrayValue* PushArray() {
-		return static_cast<AMFArrayValue*>(Insert(this->dense.size()).first);
-	};
-
-	/**
-	 * Gets an AMFValue by the key from the associative portion and converts it
-	 * to the AmfValue template type.  If the key did not exist, it is inserted.
-	 *
-	 * @tparam The target object type
-	 * @param key The key to lookup
-	 *
-	 * @return The AMFValue
-	 */
-	template <typename AmfType>
-	AMFValue<AmfType>* Get(const std::string& key) const {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		return it != this->associative.end() ?
-			dynamic_cast<AMFValue<AmfType>*>(it->second) :
-			nullptr;
-	};
-
-	// Get from the array but dont cast it
-	AMFBaseValue* Get(const std::string& key) const {
-		AMFAssociative::const_iterator it = this->associative.find(key);
-		return it != this->associative.end() ? it->second : nullptr;
-	};
-
-	/**
-	 * @brief Get an AMFValue object at a position in the dense portion.
-	 * Gets an AMFValue by the index from the dense portion and converts it
-	 * to the AmfValue template type.  If the index did not exist, it is inserted.
-	 *
-	 * @tparam The target object type
-	 * @param index The index to get
-	 * @return The casted object, or nullptr.
-	 */
-	template <typename AmfType>
-	AMFValue<AmfType>* Get(uint32_t index) const {
-		return index < this->dense.size() ?
-			dynamic_cast<AMFValue<AmfType>*>(this->dense.at(index)) :
-			nullptr;
-	};
-
-	// Get from the dense but dont cast it
-	AMFBaseValue* Get(const uint32_t index) const {
-		return index < this->dense.size() ? this->dense.at(index) : nullptr;
-	};
-private:
-	/**
-	 * The associative portion.  These values are key'd with strings to an AMFValue.
-	 */
-	AMFAssociative associative;
-
-	/**
-	 * The dense portion.  These AMFValue's are stored one after
-	 * another with the most recent addition being at the back.
-	 */
-	AMFDense dense;
-};
-
-#endif  //!__AMF3__H__

dCommon/AmfSerialize.cpp

@@ -1,184 +0,0 @@
-#include "AmfSerialize.h"
-
-#include "Game.h"
-#include "dLogger.h"
-
-// Writes an AMFValue pointer to a RakNet::BitStream
-template<>
-void RakNet::BitStream::Write<AMFBaseValue&>(AMFBaseValue& value) {
-	eAmf type = value.GetValueType();
-	this->Write(type);
-	switch (type) {
-	case eAmf::Integer: {
-		this->Write<AMFIntValue&>(*static_cast<AMFIntValue*>(&value));
-		break;
-	}
-
-	case eAmf::Double: {
-		this->Write<AMFDoubleValue&>(*static_cast<AMFDoubleValue*>(&value));
-		break;
-	}
-
-	case eAmf::String: {
-		this->Write<AMFStringValue&>(*static_cast<AMFStringValue*>(&value));
-		break;
-	}
-
-	case eAmf::Array: {
-		this->Write<AMFArrayValue&>(*static_cast<AMFArrayValue*>(&value));
-		break;
-	}
-	default: {
-		Game::logger->Log("AmfSerialize", "Encountered unwritable AMFType %i!", type);
-	}
-	case eAmf::Undefined:
-	case eAmf::Null:
-	case eAmf::False:
-	case eAmf::True:
-	case eAmf::Date:
-	case eAmf::Object:
-	case eAmf::XML:
-	case eAmf::XMLDoc:
-	case eAmf::ByteArray:
-	case eAmf::VectorInt:
-	case eAmf::VectorUInt:
-	case eAmf::VectorDouble:
-	case eAmf::VectorObject:
-	case eAmf::Dictionary:
-		break;
-	}
-}
-
-/**
- * A private function to write an value to a RakNet::BitStream
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteUInt29(RakNet::BitStream* bs, uint32_t v) {
-	unsigned char b4 = (unsigned char)v;
-	if (v < 0x00200000) {
-		b4 = b4 & 0x7F;
-		if (v > 0x7F) {
-			unsigned char b3;
-			v = v >> 7;
-			b3 = ((unsigned char)(v)) | 0x80;
-			if (v > 0x7F) {
-				unsigned char b2;
-				v = v >> 7;
-				b2 = ((unsigned char)(v)) | 0x80;
-				bs->Write(b2);
-			}
-
-			bs->Write(b3);
-		}
-	} else {
-		unsigned char b1;
-		unsigned char b2;
-		unsigned char b3;
-
-		v = v >> 8;
-		b3 = ((unsigned char)(v)) | 0x80;
-		v = v >> 7;
-		b2 = ((unsigned char)(v)) | 0x80;
-		v = v >> 7;
-		b1 = ((unsigned char)(v)) | 0x80;
-
-		bs->Write(b1);
-		bs->Write(b2);
-		bs->Write(b3);
-	}
-
-	bs->Write(b4);
-}
-
-/**
- * Writes a flag number to a RakNet::BitStream
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteFlagNumber(RakNet::BitStream* bs, uint32_t v) {
-	v = (v << 1) | 0x01;
-	WriteUInt29(bs, v);
-}
-
-/**
- * Writes an AMFString to a RakNet::BitStream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFString(RakNet::BitStream* bs, const std::string& str) {
-	WriteFlagNumber(bs, (uint32_t)str.size());
-	bs->Write(str.c_str(), (uint32_t)str.size());
-}
-
-/**
- * Writes an U16 to a bitstream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFU16(RakNet::BitStream* bs, uint16_t value) {
-	bs->Write(value);
-}
-
-/**
- * Writes an U32 to a bitstream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFU32(RakNet::BitStream* bs, uint32_t value) {
-	bs->Write(value);
-}
-
-/**
- * Writes an U64 to a bitstream
- *
- * RakNet writes in the correct byte order - do not reverse this.
- */
-void WriteAMFU64(RakNet::BitStream* bs, uint64_t value) {
-	bs->Write(value);
-}
-
-// Writes an AMFIntegerValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFIntValue&>(AMFIntValue& value) {
-	WriteUInt29(this, value.GetValue());
-}
-
-// Writes an AMFDoubleValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFDoubleValue&>(AMFDoubleValue& value) {
-	double d = value.GetValue();
-	WriteAMFU64(this, *reinterpret_cast<uint64_t*>(&d));
-}
-
-// Writes an AMFStringValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFStringValue&>(AMFStringValue& value) {
-	WriteAMFString(this, value.GetValue());
-}
-
-// Writes an AMFArrayValue to BitStream
-template<>
-void RakNet::BitStream::Write<AMFArrayValue&>(AMFArrayValue& value) {
-	uint32_t denseSize = value.GetDense().size();
-	WriteFlagNumber(this, denseSize);
-
-	auto it = value.GetAssociative().begin();
-	auto end = value.GetAssociative().end();
-
-	while (it != end) {
-		WriteAMFString(this, it->first);
-		this->Write<AMFBaseValue&>(*it->second);
-		it++;
-	}
-
-	this->Write(eAmf::Null);
-
-	if (denseSize > 0) {
-		auto it2 = value.GetDense().begin();
-		auto end2 = value.GetDense().end();
-
-		while (it2 != end2) {
-			this->Write<AMFBaseValue&>(**it2);
-			it2++;
-		}
-	}
-}

dCommon/AmfSerialize.h

@@ -1,50 +0,0 @@
-#pragma once
-
-// Custom Classes
-#include "Amf3.h"
-
-// RakNet
-#include <BitStream.h>
-
-/*!
- \file AmfSerialize.h
- \brief A class that implements native writing of AMF values to RakNet::BitStream
- */
-
- // We are using the RakNet namespace
-namespace RakNet {
-	//! Writes an AMFValue pointer to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFBaseValue&>(AMFBaseValue& value);
-
-	//! Writes an AMFIntegerValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFIntValue&>(AMFIntValue& value);
-
-	//! Writes an AMFDoubleValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFDoubleValue&>(AMFDoubleValue& value);
-
-	//! Writes an AMFStringValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFStringValue&>(AMFStringValue& value);
-
-	//! Writes an AMFArrayValue to a RakNet::BitStream
-	/*!
-	 \param value The value to write
-	 */
-	template <>
-	void RakNet::BitStream::Write<AMFArrayValue&>(AMFArrayValue& value);
-} // namespace RakNet

dCommon/Brick.h

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

dCommon/CMakeLists.txt

@@ -1,6 +1,6 @@
-set(DCOMMON_SOURCES
+set(DCOMMON_SOURCES "AMFFormat.cpp"
 		"AMFDeserialize.cpp"
-		"AmfSerialize.cpp"
+		"AMFFormat_BitStream.cpp"
 		"BinaryIO.cpp"
 		"dConfig.cpp"
 		"Diagnostics.cpp"

dCommon/Diagnostics.cpp

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

dCommon/DluAssert.h

@@ -1,12 +0,0 @@
-#ifndef __DLUASSERT__H__
-#define __DLUASSERT__H__
-
-#include <assert.h>
-
-#ifdef _DEBUG
-#	define DluAssert(expression) assert(expression)
-#else
-#	define DluAssert(expression)
-#endif
-
-#endif  //!__DLUASSERT__H__

dCommon/Game.h

@@ -10,8 +10,6 @@ class dConfig;
 class RakPeerInterface;
 class AssetManager;
 struct SystemAddress;
-class EntityManager;
-class dZoneManager;
 
 namespace Game {
 	extern dLogger* logger;
@@ -24,6 +22,4 @@ namespace Game {
 	extern AssetManager* assetManager;
 	extern SystemAddress chatSysAddr;
 	extern bool shouldShutdown;
-	extern EntityManager* entityManager;
-	extern dZoneManager* zoneManager;
 }

dCommon/GeneralUtils.cpp

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

dCommon/GeneralUtils.h

@@ -10,13 +10,11 @@
 #include <type_traits>
 #include <stdexcept>
 #include <BitStream.h>
-#include "NiPoint3.h"
 
 #include "Game.h"
 #include "dLogger.h"
 
 enum eInventoryType : uint32_t;
-enum class eObjectBits : size_t;
 enum class eReplicaComponentType : uint32_t;
 
 /*!
@@ -67,9 +65,9 @@ namespace GeneralUtils {
 
 	//! Sets a bit on a numerical value
 	template <typename T>
-	inline void SetBit(T& value, eObjectBits bits) {
+	void SetBit(T& value, size_t index) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+
 		if (index > (sizeof(T) * 8) - 1) {
 			return;
 		}
@@ -79,9 +77,9 @@ namespace GeneralUtils {
 
 	//! Clears a bit on a numerical value
 	template <typename T>
-	inline void ClearBit(T& value, eObjectBits bits) {
+	void ClearBit(T& value, size_t index) {
 		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		auto index = static_cast<size_t>(bits);
+
 		if (index > (sizeof(T) * 8 - 1)) {
 			return;
 		}
@@ -111,13 +109,36 @@ namespace GeneralUtils {
 	 */
 	bool CheckBit(int64_t value, uint32_t index);
 
+	// MARK: Random Number Generation
+
+	//! Generates a random number
+	/*!
+	  \param min The minimum the generate from
+	  \param max The maximum to generate to
+	 */
+	template <typename T>
+	inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
+		// Make sure it is a numeric type
+		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
+
+		if constexpr (std::is_integral_v<T>) {  // constexpr only necessary on first statement
+			std::uniform_int_distribution<T> distribution(min, max);
+			return distribution(Game::randomEngine);
+		} else if (std::is_floating_point_v<T>) {
+			std::uniform_real_distribution<T> distribution(min, max);
+			return distribution(Game::randomEngine);
+		}
+
+		return T();
+	}
+
 	bool ReplaceInString(std::string& str, const std::string& from, const std::string& to);
 
 	std::u16string ReadWString(RakNet::BitStream* inStream);
 
 	std::vector<std::wstring> SplitString(std::wstring& str, wchar_t delimiter);
 
-	std::vector<std::u16string> SplitString(const std::u16string& str, char16_t delimiter);
+	std::vector<std::u16string> SplitString(std::u16string& str, char16_t delimiter);
 
 	std::vector<std::string> SplitString(const std::string& str, char delimiter);
 
@@ -187,8 +208,6 @@ namespace GeneralUtils {
 		return TryParse<T>(value.c_str(), dst);
 	}
 
-	bool TryParse(const std::string& x, const std::string& y, const std::string& z, NiPoint3& dst);
-
 	template<typename T>
 	std::u16string to_u16string(T value) {
 		return GeneralUtils::ASCIIToUTF16(std::to_string(value));
@@ -200,42 +219,4 @@ namespace GeneralUtils {
 		std::hash<T> h;
 		s ^= h(v) + 0x9e3779b9 + (s << 6) + (s >> 2);
 	}
-
-	// MARK: Random Number Generation
-
-	//! Generates a random number
-	/*!
-	  \param min The minimum the generate from
-	  \param max The maximum to generate to
-	 */
-	template <typename T>
-	inline T GenerateRandomNumber(std::size_t min, std::size_t max) {
-		// Make sure it is a numeric type
-		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-
-		if constexpr (std::is_integral_v<T>) {  // constexpr only necessary on first statement
-			std::uniform_int_distribution<T> distribution(min, max);
-			return distribution(Game::randomEngine);
-		} else if (std::is_floating_point_v<T>) {
-			std::uniform_real_distribution<T> distribution(min, max);
-			return distribution(Game::randomEngine);
-		}
-
-		return T();
-	}
-
-// on Windows we need to undef these or else they conflict with our numeric limits calls
-// DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS DEVELOPERS
-#ifdef _WIN32
-#undef min
-#undef max
-#endif
-
-	template <typename T>
-	inline T GenerateRandomNumber() {
-		// Make sure it is a numeric type
-		static_assert(std::is_arithmetic<T>::value, "Not an arithmetic type");
-		
-		return GenerateRandomNumber<T>(std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
-	}
 }

dCommon/LDFFormat.cpp

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

dCommon/LDFFormat.h

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

dCommon/NiPoint3.cpp

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

dCommon/NiPoint3.h

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

dCommon/dClient/AssetManager.cpp

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

dCommon/dClient/Pack.cpp

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

dCommon/dEnums/dCommonVars.h

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

dCommon/dEnums/dMessageIdentifiers.h

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

dCommon/dEnums/eAuthMessageType.h

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

dCommon/dEnums/eBuildType.h

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

dCommon/dEnums/eCharacterCreationResponse.h

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

dCommon/dEnums/eChatInternalMessageType.h

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

dCommon/dEnums/eChatMessageType.h

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

dCommon/dEnums/eCinematicEvent.h

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

dCommon/dEnums/eClientMessageType.h

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

dCommon/dEnums/eConnectionType.h

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

dCommon/dEnums/eControlScheme.h

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

dCommon/dEnums/eCyclingMode.h

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

dCommon/dEnums/eEndBehavior.h

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

dCommon/dEnums/eGameActivity.h

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

dCommon/dEnums/eGameMasterLevel.h

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

dCommon/dEnums/eGameMessageType.h

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

dCommon/dEnums/eKillType.h

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

dCommon/dEnums/eLoginResponse.h

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

dCommon/dEnums/eLootSourceType.h

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

dCommon/dEnums/eMasterMessageType.h

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

dCommon/dEnums/eMatchUpdate.h

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

dCommon/dEnums/eObjectBits.h

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

dCommon/dEnums/eObjectWorldState.h

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

dCommon/dEnums/ePetTamingNotifyType.h

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

dCommon/dEnums/ePhysicsBehaviorType.h

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

dCommon/dEnums/ePhysicsEffectType.h

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

dCommon/dEnums/ePlayerFlag.h

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

dCommon/dEnums/eQuickBuildFailReason.h

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

dCommon/dEnums/eRebuildState.h

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

dCommon/dEnums/eRenameResponse.h

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

dCommon/dEnums/eReplicaComponentType.h

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

dCommon/dEnums/eReplicaPacketType.h

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

dCommon/dEnums/eServerMessageType.h

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

dCommon/dEnums/eStateChangeType.h

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

dCommon/dEnums/eTerminateType.h

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

dCommon/dEnums/eTriggerEventType.h

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

dCommon/dEnums/eUgcModerationStatus.h

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

dCommon/dEnums/eUseItemResponse.h

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

dCommon/dEnums/eWorldMessageType.h

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

dDatabase/CDAbstractProvider.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include "GeneralUtils.h"
-
-#include "Game.h"
-#include "dLogger.h"
-#include "dServer.h"
-
-#include "CDTable.h"
-
-template <
-    typename KeyType,
-    typename MappedType
->
-class CDAbstractProvider
-{
-public:
-    virtual void LoadClient() = 0;
-    virtual void LoadHost() = 0;
-
-    virtual const MappedType& GetEntry(const KeyType& key, const MappedType& defaultValue) = 0;
-};

dDatabase/CDAbstractSharedMemoryMap.h

@@ -1,124 +0,0 @@
-#pragma once
-
-#include "GeneralUtils.h"
-
-#include "Game.h"
-#include "dLogger.h"
-#include "dServer.h"
-
-#include "CDTable.h"
-
-#include "CDAbstractProvider.h"
-
-#include <boost/interprocess/managed_shared_memory.hpp>
-#include <boost/interprocess/containers/map.hpp>
-#include <boost/interprocess/allocators/allocator.hpp>
-#include <boost/interprocess/containers/string.hpp>
-#include <functional>
-#include <utility>
-#include <chrono>
-
-template <
-    typename KeyType,
-    typename MappedType
->
-class CDAbstractSharedMemoryMap : public CDAbstractProvider<KeyType, MappedType>
-{
-    typedef std::pair<const KeyType, MappedType> ValueType;
-
-    typedef boost::interprocess::allocator<ValueType, boost::interprocess::managed_shared_memory::segment_manager> ShmemAllocator;
-
-    typedef boost::interprocess::map<KeyType, MappedType, std::less<KeyType>, ShmemAllocator> Map;
-
-public:
-    std::map<KeyType, MappedType> m_CacheMap;
-
-    std::string m_Name;
-
-    size_t m_Size;
-
-    bool m_Host;
-    Map* m_HostEntries;
-
-    boost::interprocess::managed_shared_memory m_ClientSegment;
-    ShmemAllocator* m_ClientAllocInst;
-    boost::interprocess::offset_ptr<Map> m_ClientEntires;
-
-    CDAbstractSharedMemoryMap(std::string name, size_t size)
-    {
-        m_Name = name;
-        m_Size = size;
-        m_Host = false;
-        m_HostEntries = nullptr;
-        m_ClientAllocInst = nullptr;
-        m_ClientEntires = nullptr;
-
-        LoadClient();
-    }
-    
-    const MappedType& GetEntry(const KeyType& key, const MappedType& defaultValue) override {
-        const auto& cacheIt = m_CacheMap.find(key);
-        if (cacheIt != m_CacheMap.end()) {
-            return cacheIt->second;
-        }
-
-        const auto& it = m_ClientEntires->find(key);
-        if (it == m_ClientEntires->end()) {
-            return defaultValue;
-        }
-
-        return it->second;
-    }
-
-    const void SetEntry(const KeyType& key, const MappedType& value) {
-        if (m_Host) {
-            // If we are already hosting, we cannot add to the map, throw an error
-            throw std::runtime_error("Can not add to a map that is already being hosted");
-        }
-
-        m_CacheMap.emplace(key, value);
-    }
-
-    void LoadClient() override {
-        try {
-            m_ClientSegment = boost::interprocess::managed_shared_memory(boost::interprocess::open_read_only, m_Name.c_str());
-
-            m_ClientAllocInst = new ShmemAllocator(m_ClientSegment.get_segment_manager());
-
-            m_ClientEntires = m_ClientSegment.find<Map>(m_Name.c_str()).first;
-
-            if (m_ClientEntires == nullptr) {
-                throw std::runtime_error("Could not find shared memory segment " + m_Name);
-            }
-
-        } catch (std::exception &e) {
-            // Not open
-        }
-    }
-
-    void LoadHost() override {
-        try {
-            boost::interprocess::shared_memory_object::remove(m_Name.c_str());
-
-            boost::interprocess::managed_shared_memory segment(boost::interprocess::create_only, m_Name.c_str(), m_Size);
-
-            ShmemAllocator alloc(segment.get_segment_manager());
-
-            m_HostEntries = segment.construct<Map>(m_Name.c_str()) (std::less<KeyType>(), alloc);
-
-            // Copy cache
-            for (const auto& pair : m_CacheMap) {
-                m_HostEntries->insert(std::make_pair(pair.first, pair.second));
-            }
-
-            m_Host = true;
-
-            LoadClient();
-        } catch (std::exception &e) {
-            // Make sure the smemory is removed
-            boost::interprocess::shared_memory_object::remove(m_Name.c_str());
-
-            throw e;
-        }
-    }
-};

dDatabase/CDAbstractSharedMemoryProvider.h

@@ -1,150 +0,0 @@
-#pragma once
-
-#include "CDAbstractProvider.h"
-
-#include <boost/interprocess/managed_shared_memory.hpp>
-#include <boost/interprocess/containers/map.hpp>
-#include <boost/interprocess/allocators/allocator.hpp>
-#include <boost/interprocess/containers/string.hpp>
-#include <functional>
-#include <utility>
-#include <chrono>
-#include <mutex>
-
-template <
-    typename KeyType,
-    typename MappedType
->
-class CDAbstractSharedMemoryProvider : public CDAbstractProvider<KeyType, MappedType>
-{
-    typedef std::pair<const KeyType, MappedType> ValueType;
-
-    typedef boost::interprocess::allocator<ValueType, boost::interprocess::managed_shared_memory::segment_manager> ShmemAllocator;
-
-    typedef boost::interprocess::map<KeyType, MappedType, std::less<KeyType>, ShmemAllocator> Map;
-
-public:
-    std::string m_Name;
-    std::string m_MapName;
-    std::function <ValueType(CppSQLite3Query&)> m_ParseEntry;
-    std::function <int32_t(int32_t)> m_CalculateSize;
-
-    bool m_Cache;
-
-    std::unordered_map<KeyType, MappedType> m_CacheMap;
-    
-    bool m_Host;
-    Map* m_HostEntries;
-
-    boost::interprocess::managed_shared_memory m_ClientSegment;
-    ShmemAllocator* m_ClientAllocInst;
-    boost::interprocess::offset_ptr<Map> m_ClientEntires;
-
-    CDAbstractSharedMemoryProvider(std::string name, std::function <ValueType(CppSQLite3Query&)> parseEntry, std::function <int32_t(int32_t)> calculateSize, bool cache)
-    {
-        m_Name = name;
-        m_MapName = name + "Map";
-        m_ParseEntry = parseEntry;
-        m_CalculateSize = calculateSize;
-        m_Cache = cache;
-        m_Host = false;
-        m_HostEntries = nullptr;
-
-        LoadClient();
-    }
-
-    const MappedType& GetEntry(const KeyType& key, const MappedType& defaultValue) override {
-        if (m_Host) {
-            auto it = m_HostEntries->find(key);
-            if (it == m_HostEntries->end())
-            {
-                return defaultValue;
-            }
-            return it->second;
-        }
-
-        if (m_Cache) {
-            auto it = m_CacheMap.find(key);
-            if (it != m_CacheMap.end()) {
-                return it->second;
-            }
-        }
-
-        const auto& it = m_ClientEntires->find(key);
-        if (it == m_ClientEntires->end())
-        {
-            if (m_Cache) {
-                m_CacheMap.emplace(key, defaultValue);
-            }
-
-            return defaultValue;
-        }
-
-        if (m_Cache) {
-            m_CacheMap.emplace(key, it->second);
-        }
-
-        return it->second;
-    }
-
-    void LoadClient() override {
-        try {
-            m_ClientSegment = boost::interprocess::managed_shared_memory(boost::interprocess::open_read_only, m_MapName.c_str());
-
-            m_ClientAllocInst = new ShmemAllocator(m_ClientSegment.get_segment_manager());
-
-            m_ClientEntires = m_ClientSegment.find<Map>(m_Name.c_str()).first;
-
-            if (m_ClientEntires == nullptr) {
-                throw std::runtime_error("Could not find shared memory segment " + m_Name);
-            }
-
-        } catch (boost::interprocess::interprocess_exception& e) {
-            // Not open
-        }
-    }
-
-    void LoadHost() override {
-        try {
-            boost::interprocess::shared_memory_object::remove(m_MapName.c_str());
-
-            auto sizeQuery = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM " + m_Name);
-
-            if (sizeQuery.eof()) {
-                throw std::runtime_error("Could not get size of table " + m_Name);
-                return;
-            }
-
-            int32_t size = sizeQuery.getIntField(0);
-
-            size = m_CalculateSize(size);
-
-            boost::interprocess::managed_shared_memory segment(boost::interprocess::create_only, m_MapName.c_str(), size);
-
-            ShmemAllocator alloc_inst (segment.get_segment_manager());
-
-            m_HostEntries = segment.construct<Map>(m_Name.c_str()) (std::less<KeyType>(), alloc_inst);
-
-            auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM " + m_Name);
-
-            while (!tableData.eof()) {
-                ValueType entry = m_ParseEntry(tableData);
-
-                m_HostEntries->insert(entry);
-
-                tableData.nextRow();
-            }
-
-            tableData.finalize();
-
-            m_Host = true;
-
-            LoadClient();
-        } catch (std::exception &e) {
-            // Make sure the smemory is removed
-            boost::interprocess::shared_memory_object::remove(m_MapName.c_str());
-
-            throw e;
-        }
-    }
-};

dDatabase/CDAbstractSqliteProvider.h

@@ -1,74 +0,0 @@
-#pragma once
-
-#include "GeneralUtils.h"
-
-#include "Game.h"
-#include "dLogger.h"
-#include "dServer.h"
-
-#include "CDTable.h"
-
-#include "CDAbstractProvider.h"
-
-template <
-    typename KeyType,
-    typename MappedType
->
-class CDAbstractSqliteProvider : public CDAbstractProvider<KeyType, MappedType>
-{
-    typedef std::pair<const KeyType, MappedType> ValueType;
-
-public:
-    std::string m_Name;
-    std::function <ValueType(CppSQLite3Query&)> m_ParseEntry;
-
-    std::unordered_map<KeyType, MappedType> m_Entries;
-
-    CDAbstractSqliteProvider(std::string name, std::function <ValueType(CppSQLite3Query&)> parseEntry, bool cache)
-    {
-        m_Name = name;
-        m_ParseEntry = parseEntry;
-
-        LoadClient();
-    }
-
-    void LoadClient() override {
-        // First, get the size of the table
-        uint32_t size = 0;
-        auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM " + m_Name);
-        while (!tableSize.eof()) {
-            size = tableSize.getIntField(0, 0);
-
-            tableSize.nextRow();
-        }
-
-        tableSize.finalize();
-
-        // Reserve the size
-        m_Entries.reserve(size);
-
-        // Now get the data
-        auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM " + m_Name);
-        while (!tableData.eof()) {
-            auto entry = m_ParseEntry(tableData);
-
-            m_Entries.insert(entry);
-
-            tableData.nextRow();
-        }
-
-        tableData.finalize();
-    }
-
-    void LoadHost() override {
-        return;
-    }
-
-    const MappedType& GetEntry(const KeyType& key, const MappedType& defaultValue) override {
-        auto it = m_Entries.find(key);
-        if (it != m_Entries.end()) {
-            return it->second;
-        }
-        return defaultValue;
-    }
-};

dDatabase/CDClientDatabase.h

@@ -16,6 +16,9 @@
  // Enable this to cache all entries in each table for fast access, comes with more memory cost
  //#define CDCLIENT_CACHE_ALL
 
+ // Enable this to skip some unused columns in some tables
+#define UNUSED(v)
+
 /*!
   \file CDClientDatabase.hpp
   \brief An interface between the CDClient.sqlite file and the server

dDatabase/CDClientManager.cpp

@@ -40,7 +40,7 @@
 
 CDClientManager::CDClientManager() {
 	CDActivityRewardsTable::Instance();
-	CDAnimationsTable::Instance();
+	UNUSED(CDAnimationsTable::Instance());
 	CDBehaviorParameterTable::Instance();
 	CDBehaviorTemplateTable::Instance();
 	CDComponentsRegistryTable::Instance();
@@ -78,11 +78,3 @@ CDClientManager::CDClientManager() {
 	CDFeatureGatingTable::Instance();
 	CDRailActivatorComponentTable::Instance();
 }
-
-void CDClientManager::LoadHost() {
-	for (auto itr = this->tables.begin(); itr != this->tables.end(); ++itr) {
-		itr->second->LoadHost();
-	}
-
-	CDTable::InitalizeHost();
-}

dDatabase/CDClientManager.h

@@ -4,8 +4,6 @@
 
 #include "Singleton.h"
 
-#define UNUSED_TABLE(v)
-
 /**
  * Initialize the CDClient tables so they are all loaded into memory.
  */

dDatabase/CDProvider.h

@@ -1,41 +0,0 @@
-#pragma once
-
-#include "CDAbstractProvider.h"
-
-/**
- * Shared memory provider with CDAbstractSharedMemoryProvider<key, value>
- * 
- * Depends on the boost::interprocess library — header only
- * 
- * Requires that CD_PROVIDER_MEMORY is defined and CD_PROVIDER_SQLITE is not defined
- */
-#if defined(CD_PROVIDER_MEMORY) && !defined(CD_PROVIDER_SQLITE)
-
-#include "CDAbstractSharedMemoryProvider.h"
-
-#define CD_PROVIDER(provider, key, value) CDAbstractSharedMemoryProvider<key, value>* provider; typedef key CD_KEY; typedef value CD_VALUE
-#define NEW_CD_PROVIDER(provider, name, parser, size_calculator, cache) provider = new CDAbstractSharedMemoryProvider<CD_KEY, CD_VALUE>(name, parser, size_calculator, cache)
-
-template<typename KeyType, typename MappedType>
-using CDProvider = CDAbstractSharedMemoryProvider<KeyType, MappedType>;
-
-#endif
-
-/**
- * SQLite provider with CDAbstractSqliteProvider<key, value>
- * 
- * No extra dependencies
- * 
- * Requires that CD_PROVIDER_SQLITE or CD_PROVIDER_MEMORY is not defined — the default option
- */
-#if defined(CD_PROVIDER_SQLITE) || !defined(CD_PROVIDER_MEMORY)
-
-#include "CDAbstractSqliteProvider.h"
-
-#define CD_PROVIDER(provider, key, value) CDAbstractSqliteProvider<key, value>* provider; typedef key CD_KEY; typedef value CD_VALUE
-#define NEW_CD_PROVIDER(provider, name, parser, size_calculator, cache) provider = new CDAbstractSqliteProvider<CD_KEY, CD_VALUE>(name, parser, cache)
-
-template<typename KeyType, typename MappedType>
-using CDProvider = CDAbstractSqliteProvider<KeyType, MappedType>;
-
-#endif

dDatabase/Tables/CDAnimationsTable.cpp

@@ -1,83 +1,56 @@
 #include "CDAnimationsTable.h"
-#include "GeneralUtils.h"
-#include "Game.h"
 
-bool CDAnimationsTable::CacheData(CppSQLite3Statement& queryToCache) {
-	auto tableData = queryToCache.execQuery();
-	// If we received a bad lookup, cache it anyways so we do not run the query again.
-	if (tableData.eof()) return false;
+CDAnimationsTable::CDAnimationsTable(void) {
 
-	do {
-		std::string animation_type = tableData.getStringField("animation_type", "");
-		DluAssert(!animation_type.empty());
-		AnimationGroupID animationGroupID = tableData.getIntField("animationGroupID", -1);
-		DluAssert(animationGroupID != -1);
+	// First, get the size of the table
+	unsigned int size = 0;
+	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Animations");
+	while (!tableSize.eof()) {
+		size = tableSize.getIntField(0, 0);
 
-		CDAnimation entry;
+		tableSize.nextRow();
+	}
+
+	tableSize.finalize();
+
+	// Reserve the size
+	this->entries.reserve(size);
+
+	// Now get the data
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Animations");
+	while (!tableData.eof()) {
+		CDAnimations entry;
+		entry.animationGroupID = tableData.getIntField("animationGroupID", -1);
+		entry.animation_type = tableData.getStringField("animation_type", "");
 		entry.animation_name = tableData.getStringField("animation_name", "");
-		entry.chance_to_play = tableData.getFloatField("chance_to_play", 1.0f);
-		UNUSED_COLUMN(entry.min_loops = tableData.getIntField("min_loops", 0);)
-		UNUSED_COLUMN(entry.max_loops = tableData.getIntField("max_loops", 0);)
-		entry.animation_length = tableData.getFloatField("animation_length", 0.0f);
-		UNUSED_COLUMN(entry.hideEquip = tableData.getIntField("hideEquip", 0) == 1;)
-		UNUSED_COLUMN(entry.ignoreUpperBody = tableData.getIntField("ignoreUpperBody", 0) == 1;)
-		UNUSED_COLUMN(entry.restartable = tableData.getIntField("restartable", 0) == 1;)
-		UNUSED_COLUMN(entry.face_animation_name = tableData.getStringField("face_animation_name", "");)
-		UNUSED_COLUMN(entry.priority = tableData.getFloatField("priority", 0.0f);)
-		UNUSED_COLUMN(entry.blendTime = tableData.getFloatField("blendTime", 0.0f);)
+		entry.chance_to_play = tableData.getFloatField("chance_to_play", -1.0f);
+		entry.min_loops = tableData.getIntField("min_loops", -1);
+		entry.max_loops = tableData.getIntField("max_loops", -1);
+		entry.animation_length = tableData.getFloatField("animation_length", -1.0f);
+		entry.hideEquip = tableData.getIntField("hideEquip", -1) == 1 ? true : false;
+		entry.ignoreUpperBody = tableData.getIntField("ignoreUpperBody", -1) == 1 ? true : false;
+		entry.restartable = tableData.getIntField("restartable", -1) == 1 ? true : false;
+		entry.face_animation_name = tableData.getStringField("face_animation_name", "");
+		entry.priority = tableData.getFloatField("priority", -1.0f);
+		entry.blendTime = tableData.getFloatField("blendTime", -1.0f);
 
-		this->animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
+		this->entries.push_back(entry);
 		tableData.nextRow();
-	} while (!tableData.eof());
+	}
 
 	tableData.finalize();
-
-	return true;
 }
 
-void CDAnimationsTable::CacheAnimations(const CDAnimationKey animationKey) {
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Animations WHERE animationGroupID = ? and animation_type = ?");
-	query.bind(1, static_cast<int32_t>(animationKey.second));
-	query.bind(2, animationKey.first.c_str());
-	// If we received a bad lookup, cache it anyways so we do not run the query again.
-	if (!CacheData(query)) {
-		this->animations[animationKey];
-	}
+std::vector<CDAnimations> CDAnimationsTable::Query(std::function<bool(CDAnimations)> predicate) {
+
+	std::vector<CDAnimations> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
 }
 
-void CDAnimationsTable::CacheAnimationGroup(AnimationGroupID animationGroupID) {
-	auto animationEntryCached = this->animations.find(CDAnimationKey("", animationGroupID));
-	if (animationEntryCached != this->animations.end()) {
-		return;
-	}
-
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM Animations WHERE animationGroupID = ?");
-	query.bind(1, static_cast<int32_t>(animationGroupID));
-
-	// Cache the query so we don't run the query again.
-	CacheData(query);
-	this->animations[CDAnimationKey("", animationGroupID)];
+std::vector<CDAnimations> CDAnimationsTable::GetEntries(void) const {
+	return this->entries;
 }
 
-CDAnimationLookupResult CDAnimationsTable::GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID) {
-	CDAnimationKey animationKey(animationType, animationGroupID);
-	auto animationEntryCached = this->animations.find(animationKey);
-	if (animationEntryCached == this->animations.end()) {
-		this->CacheAnimations(animationKey);
-	}
-
-	auto animationEntry = this->animations.find(animationKey);
-	// If we have only one animation, return it regardless of the chance to play.
-	if (animationEntry->second.size() == 1) {
-		return CDAnimationLookupResult(animationEntry->second.front());
-	}
-	auto randomAnimation = GeneralUtils::GenerateRandomNumber<float>(0, 1);
-
-	for (auto& animationEntry : animationEntry->second) {
-		randomAnimation -= animationEntry.chance_to_play;
-		// This is how the client gets the random animation.
-		if (animationEntry.animation_name != previousAnimationName && randomAnimation <= 0.0f) return CDAnimationLookupResult(animationEntry);
-	}
-
-	return CDAnimationLookupResult();
-}

dDatabase/Tables/CDAnimationsTable.h

@@ -1,66 +1,33 @@
 #pragma once
 
+// Custom Classes
 #include "CDTable.h"
-#include <list>
 
-struct CDAnimation {
-	// unsigned int animationGroupID;
-	// std::string animation_type;
-	// The above two are a pair to represent a primary key in the map.
+struct CDAnimations {
+	unsigned int animationGroupID;          //!< The animation group ID
+	std::string animation_type;        //!< The animation type
 	std::string animation_name;        //!< The animation name
 	float chance_to_play;           //!< The chance to play the animation
-	UNUSED_COLUMN(unsigned int min_loops;)                 //!< The minimum number of loops
-	UNUSED_COLUMN(unsigned int max_loops;)                 //!< The maximum number of loops
+	unsigned int min_loops;                 //!< The minimum number of loops
+	unsigned int max_loops;                 //!< The maximum number of loops
 	float animation_length;         //!< The animation length
-	UNUSED_COLUMN(bool hideEquip;)                 //!< Whether or not to hide the equip
-	UNUSED_COLUMN(bool ignoreUpperBody;)           //!< Whether or not to ignore the upper body
-	UNUSED_COLUMN(bool restartable;)               //!< Whether or not the animation is restartable
-	UNUSED_COLUMN(std::string face_animation_name;)   //!< The face animation name
-	UNUSED_COLUMN(float priority;)                 //!< The priority
-	UNUSED_COLUMN(float blendTime;)                //!< The blend time
+	bool hideEquip;                 //!< Whether or not to hide the equip
+	bool ignoreUpperBody;           //!< Whether or not to ignore the upper body
+	bool restartable;               //!< Whether or not the animation is restartable
+	std::string face_animation_name;   //!< The face animation name
+	float priority;                 //!< The priority
+	float blendTime;                //!< The blend time
 };
 
-typedef LookupResult<CDAnimation> CDAnimationLookupResult;
 
 class CDAnimationsTable : public CDTable<CDAnimationsTable> {
-	typedef int32_t AnimationGroupID;
-	typedef std::string AnimationID;
-	typedef std::pair<std::string, AnimationGroupID> CDAnimationKey;
-public:
-	/**
-	 * Given an animationType and the previousAnimationName played, return the next animationType to play.
-	 * If there are more than 1 animationTypes that can be played, one is selected at random but also does not allow
-	 * the previousAnimationName to be played twice.
-	 * 
-	 * @param animationType The animationID to lookup
-	 * @param previousAnimationName The previously played animation
-	 * @param animationGroupID The animationGroupID to lookup
-	 * @return CDAnimationLookupResult 
-	 */
-	[[nodiscard]] CDAnimationLookupResult GetAnimation(const AnimationID& animationType, const std::string& previousAnimationName, const AnimationGroupID animationGroupID);
-
-	/**
-	 * Cache a full AnimationGroup by its ID.
-	 */
-	void CacheAnimationGroup(AnimationGroupID animationGroupID);
 private:
+	std::vector<CDAnimations> entries;
 
-	/**
-	 * Cache all animations given a premade key
-	 */
-	void CacheAnimations(const CDAnimationKey animationKey);
+public:
+	CDAnimationsTable();
+	// Queries the table with a custom "where" clause
+	std::vector<CDAnimations> Query(std::function<bool(CDAnimations)> predicate);
 
-	/**
-	 * Run the query responsible for caching the data.
-	 * @param queryToCache 
-	 * @return true 
-	 * @return false 
-	 */
-	bool CacheData(CppSQLite3Statement& queryToCache);
-
-	/**
-	 * Each animation is key'd by its animationName and its animationGroupID.  Each
-	 * animation has a possible list of animations.  This is because there can be animations have a percent chance to play so one is selected at random.
-	 */
-	std::map<CDAnimationKey, std::list<CDAnimation>> animations;
+	std::vector<CDAnimations> GetEntries(void) const;
 };

dDatabase/Tables/CDBehaviorParameterTable.cpp

@@ -21,7 +21,10 @@ CDBehaviorParameterTable::CDBehaviorParameterTable(void) {
 		entry.value = tableData.getFloatField("value", -1.0f);
 
 		m_Entries.insert(std::make_pair(hash, entry));
+
+		tableData.nextRow();
 	}
+	tableData.finalize();
 }
 
 float CDBehaviorParameterTable::GetValue(const uint32_t behaviorID, const std::string& name, const float defaultValue) {

dDatabase/Tables/CDBehaviorTemplateTable.h

@@ -6,10 +6,10 @@
 #include <unordered_set>
 
 struct CDBehaviorTemplate {
-    unsigned int behaviorID;                                         //!< The Behavior ID
-    unsigned int templateID;                                         //!< The Template ID (LOT)
-    unsigned int effectID;                                           //!< The Effect ID attached
-    size_t effectHandle;                                             //!< The effect handle
+	unsigned int behaviorID;                                         //!< The Behavior ID
+	unsigned int templateID;                                         //!< The Template ID (LOT)
+	unsigned int effectID;                                           //!< The Effect ID attached
+	std::unordered_set<std::string>::iterator effectHandle;          //!< The effect handle
 };
 
 

dDatabase/Tables/CDComponentsRegistryTable.cpp

@@ -1,4 +1,3 @@
-
 #include "CDComponentsRegistryTable.h"
 #include "eReplicaComponentType.h"
 

dDatabase/Tables/CDTable.cpp

@@ -1,68 +0,0 @@
-#include "CDTable.h"
-
-#if defined(CD_PROVIDER_MEMORY)
-
-#include "CDAbstractSharedMemoryMap.h"
-
-typedef boost::interprocess::allocator<char, boost::interprocess::managed_shared_memory::segment_manager> CharAllocator; 
-typedef boost::interprocess::basic_string<char, std::char_traits<char>, CharAllocator> my_string;
-
-CDAbstractSharedMemoryMap<size_t, boost::interprocess::string>* CDStringMap;
-
-void CDTable::InitalizeHost()
-{
-    CDStringMap->LoadHost();
-}
-
-void CDTable::Initalize()
-{
-    CDStringMap = new CDAbstractSharedMemoryMap<size_t, boost::interprocess::string>("CDStringMap", 10 * 1000 * 1000);
-}
-
-std::string CDTable::GetString(size_t handle)
-{
-    std::string str = std::string(CDStringMap->GetEntry(handle, "").c_str());
-
-    return str;
-}
-
-size_t CDTable::SetString(std::string value)
-{
-    size_t hash = 0;
-
-    GeneralUtils::hash_combine(hash, value);
-
-    CDStringMap->SetEntry(hash, boost::interprocess::string(value.c_str()));
-
-    return hash;
-}
-
-#else
-
-std::unordered_map<size_t, std::string> CDStringMap;
-
-void CDTable::InitalizeHost()
-{
-}
-
-void CDTable::Initalize()
-{
-}
-
-std::string CDTable::GetString(size_t handle)
-{
-    return CDStringMap[handle];
-}
-
-size_t CDTable::SetString(std::string value)
-{
-    size_t hash = 0;
-
-    GeneralUtils::hash_combine(hash, value);
-
-    CDStringMap[hash] = value;
-
-    return hash;
-}
-
-#endif

dDatabase/Tables/CDTable.h

@@ -2,7 +2,6 @@
 
 #include "CDClientDatabase.h"
 #include "Singleton.h"
-#include "DluAssert.h"
 
 #include <functional>
 #include <string>
@@ -16,71 +15,11 @@
 #endif
 #include "cpplinq.hpp"
 
-// Used for legacy
-#define UNUSED(x)
-
-// Enable this to skip some unused columns in some tables
-#define UNUSED_COLUMN(v)
-
 #pragma warning (disable : 4244) //Disable double to float conversion warnings
 #pragma warning (disable : 4715) //Disable "not all control paths return a value"
 
-#if defined(__unix) || defined(__APPLE__)
-//For Linux:
-typedef __int64_t __int64;
-#endif
-
-/*!
-  \file CDTable.hpp
-  \brief A virtual class for CDClient Tables
- */
-
- //! The base class for all CD tables
 template<class Table>
 class CDTable : public Singleton<Table> {
-public:
-    
-    //! Returns the table's name
-    /*!
-      \return The table name
-     */
-    virtual std::string GetName() const = 0;
-
-    //! Loads the table into shared memory
-    virtual void LoadHost() {};
-
-    //! Initalizes the table services
-    static void Initalize();
-
-    //! Initalizes the table services as host
-    static void InitalizeHost();
-
-    //! Get a string from a handle
-    /*!
-      \param handle The handle to get the string from
-      \return The string
-     */
-    static std::string GetString(size_t handle);
-
-    //! Set a string
-    /*!
-      \param value The string to set
-      \return The handle to the string
-     */
-    static size_t SetString(std::string value);
-
 protected:
 	virtual ~CDTable() = default;
 };
-
-template<class T>
-class LookupResult {
-	typedef std::pair<T, bool> DataType;
-public:
-	LookupResult() { m_data.first = T(); m_data.second = false; };
-	LookupResult(T& data) { m_data.first = data; m_data.second = true; };
-	inline const T& Data() { return m_data.first; };
-	inline const bool& FoundData() { return m_data.second; };
-private:
-	DataType m_data;
-};

dDatabase/Tables/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(DDATABASE_TABLES_SOURCES "CDTable.cpp" "CDActivitiesTable.cpp"
+set(DDATABASE_TABLES_SOURCES "CDActivitiesTable.cpp"
 	"CDActivityRewardsTable.cpp"
 	"CDAnimationsTable.cpp"
 	"CDBehaviorParameterTable.cpp"

dGame/Character.cpp

@@ -18,9 +18,6 @@
 #include "InventoryComponent.h"
 #include "eMissionTaskType.h"
 #include "eMissionState.h"
-#include "eObjectBits.h"
-#include "eGameMasterLevel.h"
-#include "ePlayerFlag.h"
 
 Character::Character(uint32_t id, User* parentUser) {
 	//First load the name, etc:
@@ -71,8 +68,8 @@ Character::Character(uint32_t id, User* parentUser) {
 
 	//Set our objectID:
 	m_ObjectID = m_ID;
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
 
 	m_ParentUser = parentUser;
 	m_OurEntity = nullptr;
@@ -130,8 +127,8 @@ void Character::UpdateFromDatabase() {
 
 	//Set our objectID:
 	m_ObjectID = m_ID;
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::CHARACTER);
-	GeneralUtils::SetBit(m_ObjectID, eObjectBits::PERSISTENT);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_CHARACTER);
+	m_ObjectID = GeneralUtils::SetBit(m_ObjectID, OBJECT_BIT_PERSISTENT);
 
 	m_OurEntity = nullptr;
 	m_BuildMode = false;
@@ -207,9 +204,7 @@ void Character::DoQuickXMLDataParse() {
 	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
 		character->QueryAttribute("cc", &m_Coins);
-		int32_t gm_level = 0;
-		character->QueryAttribute("gm", &gm_level);
-		m_GMLevel = static_cast<eGameMasterLevel>(gm_level);
+		character->QueryAttribute("gm", &m_GMLevel);
 
 		uint64_t lzidConcat = 0;
 		if (character->FindAttribute("lzid")) {
@@ -241,7 +236,7 @@ void Character::DoQuickXMLDataParse() {
 		//To try and fix the AG landing into:
 		if (m_ZoneID == 1000 && Game::server->GetZoneID() == 1100) {
 			//sneakily insert our position:
-			auto pos = Game::zoneManager->GetZone()->GetSpawnPos();
+			auto pos = dZoneManager::Instance()->GetZone()->GetSpawnPos();
 			character->SetAttribute("lzx", pos.x);
 			character->SetAttribute("lzy", pos.y);
 			character->SetAttribute("lzz", pos.z);
@@ -290,13 +285,13 @@ void Character::DoQuickXMLDataParse() {
 
 void Character::UnlockEmote(int emoteID) {
 	m_UnlockedEmotes.push_back(emoteID);
-	GameMessages::SendSetEmoteLockState(Game::entityManager->GetEntity(m_ObjectID), false, emoteID);
+	GameMessages::SendSetEmoteLockState(EntityManager::Instance()->GetEntity(m_ObjectID), false, emoteID);
 }
 
 void Character::SetBuildMode(bool buildMode) {
 	m_BuildMode = buildMode;
 
-	auto* controller = Game::zoneManager->GetZoneControlObject();
+	auto* controller = dZoneManager::Instance()->GetZoneControlObject();
 
 	controller->OnFireEventServerSide(m_OurEntity, buildMode ? "OnBuildModeEnter" : "OnBuildModeLeave");
 }
@@ -309,10 +304,10 @@ void Character::SaveXMLToDatabase() {
 
 	tinyxml2::XMLElement* character = m_Doc->FirstChildElement("obj")->FirstChildElement("char");
 	if (character) {
-		character->SetAttribute("gm", static_cast<uint32_t>(m_GMLevel));
+		character->SetAttribute("gm", m_GMLevel);
 		character->SetAttribute("cc", m_Coins);
 
-		auto zoneInfo = Game::zoneManager->GetZone()->GetZoneID();
+		auto zoneInfo = dZoneManager::Instance()->GetZone()->GetZoneID();
 		// lzid garbage, binary concat of zoneID, zoneInstance and zoneClone
 		if (zoneInfo.GetMapID() != 0 && zoneInfo.GetCloneID() == 0) {
 			uint64_t lzidConcat = zoneInfo.GetCloneID();
@@ -363,9 +358,9 @@ void Character::SaveXMLToDatabase() {
 	}
 
 	// Prevents the news feed from showing up on world transfers
-	if (GetPlayerFlag(ePlayerFlag::IS_NEWS_SCREEN_VISIBLE)) {
+	if (GetPlayerFlag(ePlayerFlags::IS_NEWS_SCREEN_VISIBLE)) {
 		auto* s = m_Doc->NewElement("s");
-		s->SetAttribute("si", ePlayerFlag::IS_NEWS_SCREEN_VISIBLE);
+		s->SetAttribute("si", ePlayerFlags::IS_NEWS_SCREEN_VISIBLE);
 		flags->LinkEndChild(s);
 	}
 
@@ -373,7 +368,7 @@ void Character::SaveXMLToDatabase() {
 
 	//Call upon the entity to update our xmlDoc:
 	if (!m_OurEntity) {
-		Game::logger->Log("Character", "%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
+		Game::logger->Log("Character", "We didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!");
 		return;
 	}
 
@@ -384,7 +379,7 @@ void Character::SaveXMLToDatabase() {
 	//For metrics, log the time it took to save:
 	auto end = std::chrono::system_clock::now();
 	std::chrono::duration<double> elapsed = end - start;
-	Game::logger->Log("Character", "%i:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
+	Game::logger->Log("Character", "Saved character to Database in: %fs", elapsed.count());
 }
 
 void Character::SetIsNewLogin() {
@@ -396,7 +391,7 @@ void Character::SetIsNewLogin() {
 	while (currentChild) {
 		if (currentChild->Attribute("si")) {
 			flags->DeleteChild(currentChild);
-			Game::logger->Log("Character", "Removed isLoggedIn flag from character %i:%s, saving character to database", GetID(), GetName().c_str());
+			Game::logger->Log("Character", "Removed isLoggedIn flag from character %i, saving character to database", GetID());
 			WriteToDatabase();
 		}
 		currentChild = currentChild->NextSiblingElement();
@@ -424,7 +419,7 @@ void Character::SetPlayerFlag(const uint32_t flagId, const bool value) {
 
 	if (value) {
 		// Update the mission component:
-		auto* player = Game::entityManager->GetEntity(m_ObjectID);
+		auto* player = EntityManager::Instance()->GetEntity(m_ObjectID);
 
 		if (player != nullptr) {
 			auto* missionComponent = player->GetComponent<MissionComponent>();
@@ -482,8 +477,8 @@ bool Character::GetPlayerFlag(const uint32_t flagId) const {
 
 void Character::SetRetroactiveFlags() {
 	// Retroactive check for if player has joined a faction to set their 'joined a faction' flag to true.
-	if (GetPlayerFlag(ePlayerFlag::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlag::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlag::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlag::SENTINEL_FACTION)) {
-		SetPlayerFlag(ePlayerFlag::JOINED_A_FACTION, true);
+	if (GetPlayerFlag(ePlayerFlags::VENTURE_FACTION) || GetPlayerFlag(ePlayerFlags::ASSEMBLY_FACTION) || GetPlayerFlag(ePlayerFlags::PARADOX_FACTION) || GetPlayerFlag(ePlayerFlags::SENTINEL_FACTION)) {
+		SetPlayerFlag(ePlayerFlags::JOINED_A_FACTION, true);
 	}
 }
 
@@ -543,14 +538,14 @@ void Character::OnZoneLoad() {
 	if (missionComponent != nullptr) {
 		// Fix the monument race flag
 		if (missionComponent->GetMissionState(319) >= eMissionState::READY_TO_COMPLETE) {
-			SetPlayerFlag(ePlayerFlag::AG_FINISH_LINE_BUILT, true);
+			SetPlayerFlag(33, true);
 		}
 	}
 
 	const auto maxGMLevel = m_ParentUser->GetMaxGMLevel();
 
 	// This does not apply to the GMs
-	if (maxGMLevel > eGameMasterLevel::CIVILIAN) {
+	if (maxGMLevel > GAME_MASTER_LEVEL_CIVILIAN) {
 		return;
 	}
 
@@ -559,7 +554,7 @@ void Character::OnZoneLoad() {
 	 */
 	if (HasPermission(ePermissionMap::Old)) {
 		if (GetCoins() > 1000000) {
-			SetCoins(1000000, eLootSourceType::NONE);
+			SetCoins(1000000, eLootSourceType::LOOT_SOURCE_NONE);
 		}
 	}
 
@@ -602,7 +597,7 @@ void Character::SetCoins(int64_t newCoins, eLootSourceType lootSource) {
 
 	m_Coins = newCoins;
 
-	GameMessages::SendSetCurrency(Game::entityManager->GetEntity(m_ObjectID), m_Coins, 0, 0, 0, 0, true, lootSource);
+	GameMessages::SendSetCurrency(EntityManager::Instance()->GetEntity(m_ObjectID), m_Coins, 0, 0, 0, 0, true, lootSource);
 }
 
 bool Character::HasBeenToWorld(LWOMAPID mapID) const {
@@ -626,21 +621,3 @@ void Character::SendMuteNotice() const {
 
 	ChatPackets::SendSystemMessage(GetEntity()->GetSystemAddress(), u"You are muted until " + timeStr);
 }
-
-void Character::SetBillboardVisible(bool visible) {
-	if (m_BillboardVisible == visible) return;
-	m_BillboardVisible = visible;
-
-	GameMessages::SendSetNamebillboardState(UNASSIGNED_SYSTEM_ADDRESS, m_OurEntity->GetObjectID());
-
-	if (!visible) return;
-
-	// The GameMessage we send for turning the nameplate off just deletes the BillboardSubcomponent from the parent component.
-	// Because that same message does not allow for custom parameters, we need to create the BillboardSubcomponent a different way
-	// This workaround involves sending an unrelated GameMessage that does not apply to player entites,
-	// but forces the client to create the necessary SubComponent that controls the billboard.
-	GameMessages::SendShowBillboardInteractIcon(UNASSIGNED_SYSTEM_ADDRESS, m_OurEntity->GetObjectID());
-
-	// Now turn off the billboard for the owner.
-	GameMessages::SendSetNamebillboardState(m_OurEntity->GetSystemAddress(), m_OurEntity->GetObjectID());
-}

dGame/Character.h

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

dGame/Entity.cpp

@@ -24,7 +24,6 @@
 #include "Loot.h"
 #include "eMissionTaskType.h"
 #include "eTriggerEventType.h"
-#include "eObjectBits.h"
 
 //Component includes:
 #include "Component.h"
@@ -71,9 +70,9 @@
 #include "RailActivatorComponent.h"
 #include "LUPExhibitComponent.h"
 #include "TriggerComponent.h"
-#include "eGameMasterLevel.h"
+#include "ItemComponent.h"
+#include "MutableModelBehaviorComponent.h"
 #include "eReplicaComponentType.h"
-#include "eReplicaPacketType.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -92,7 +91,7 @@ Entity::Entity(const LWOOBJID& objectID, EntityInfo info, Entity* parentEntity)
 	m_TemplateID = info.lot;
 	m_ParentEntity = parentEntity;
 	m_Character = nullptr;
-	m_GMLevel = eGameMasterLevel::CIVILIAN;
+	m_GMLevel = 0;
 	m_CollectibleID = 0;
 	m_NetworkID = 0;
 	m_Groups = {};
@@ -263,17 +262,17 @@ void Entity::Initialize() {
 				NiQuaternion rot;
 
 				const auto& targetSceneName = m_Character->GetTargetScene();
-				auto* targetScene = Game::entityManager->GetSpawnPointEntity(targetSceneName);
+				auto* targetScene = EntityManager::Instance()->GetSpawnPointEntity(targetSceneName);
 
 				if (m_Character->HasBeenToWorld(mapID) && targetSceneName.empty()) {
 					pos = m_Character->GetRespawnPoint(mapID);
-					rot = Game::zoneManager->GetZone()->GetSpawnRot();
+					rot = dZoneManager::Instance()->GetZone()->GetSpawnRot();
 				} else if (targetScene != nullptr) {
 					pos = targetScene->GetPosition();
 					rot = targetScene->GetRotation();
 				} else {
-					pos = Game::zoneManager->GetZone()->GetSpawnPos();
-					rot = Game::zoneManager->GetZone()->GetSpawnRot();
+					pos = dZoneManager::Instance()->GetZone()->GetSpawnPos();
+					rot = dZoneManager::Instance()->GetZone()->GetSpawnRot();
 				}
 
 				controllablePhysics->SetPosition(pos);
@@ -386,8 +385,8 @@ void Entity::Initialize() {
 						comp->SetMaxCoins(currencyValues[0].maxvalue);
 					}
 
-					// extraInfo overrides. Client ORs the database smashable and the luz smashable.
-					comp->SetIsSmashable(comp->GetIsSmashable() | (GetVarAs<int32_t>(u"is_smashable") != 0));
+					// extraInfo overrides
+					comp->SetIsSmashable(GetVarAs<int32_t>(u"is_smashable") != 0);
 				}
 			} else {
 				comp->SetHealth(1);
@@ -505,7 +504,7 @@ void Entity::Initialize() {
 	// ZoneControl script
 	if (m_TemplateID == 2365) {
 		CDZoneTableTable* zoneTable = CDClientManager::Instance().GetTable<CDZoneTableTable>();
-		const auto zoneID = Game::zoneManager->GetZoneID();
+		const auto zoneID = dZoneManager::Instance()->GetZoneID();
 		const CDZoneTable* zoneData = zoneTable->Query(zoneID.GetMapID());
 
 		if (zoneData != nullptr) {
@@ -595,9 +594,8 @@ void Entity::Initialize() {
 		m_Components.insert(std::make_pair(eReplicaComponentType::BOUNCER, comp));
 	}
 
-	int32_t renderComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RENDER);
-	if ((renderComponentId > 0 && m_TemplateID != 2365) || m_Character) {
-		RenderComponent* render = new RenderComponent(this, renderComponentId);
+	if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RENDER) > 0 && m_TemplateID != 2365) || m_Character) {
+		RenderComponent* render = new RenderComponent(this);
 		m_Components.insert(std::make_pair(eReplicaComponentType::RENDER, render));
 	}
 
@@ -615,7 +613,7 @@ void Entity::Initialize() {
 		m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPTED_ACTIVITY, new ScriptedActivityComponent(this, scriptedActivityID)));
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODEL, -1) != -1 && !GetComponent<PetComponent>()) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODEL, -1) != -1 && !(petComponentId > 0)) {
 		m_Components.insert(std::make_pair(eReplicaComponentType::MODEL, new ModelComponent(this)));
 		if (m_Components.find(eReplicaComponentType::DESTROYABLE) == m_Components.end()) {
 			auto destroyableComponent = new DestroyableComponent(this);
@@ -627,8 +625,7 @@ void Entity::Initialize() {
 		}
 	}
 
-	PetComponent* petComponent;
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ITEM) > 0 && !TryGetComponent(eReplicaComponentType::PET, petComponent) && !HasComponent(eReplicaComponentType::MODEL)) {
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ITEM) > 0  && !(petComponentId > 0)) {
 		m_Components.insert(std::make_pair(eReplicaComponentType::ITEM, nullptr));
 	}
 
@@ -691,7 +688,7 @@ void Entity::Initialize() {
 	}
 
 	std::string pathName = GetVarAsString(u"attached_path");
-	const Path* path = Game::zoneManager->GetZone()->GetPath(pathName);
+	const Path* path = dZoneManager::Instance()->GetZone()->GetPath(pathName);
 
 	//Check to see if we have an attached path and add the appropiate component to handle it:
 	if (path){
@@ -708,13 +705,6 @@ void Entity::Initialize() {
 				// TODO: create movementAIcomp and set path
 			}
 		}*/
-	} else {
-		// else we still need to setup moving platform if it has a moving platform comp but no path
-		int32_t movingPlatformComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MOVING_PLATFORM, -1);
-		if (movingPlatformComponentId >= 0) {
-			MovingPlatformComponent* plat = new MovingPlatformComponent(this, pathName);
-			m_Components.insert(std::make_pair(eReplicaComponentType::MOVING_PLATFORM, plat));
-		}
 	}
 
 	int proximityMonitorID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROXIMITY_MONITOR);
@@ -735,9 +725,9 @@ void Entity::Initialize() {
 		}
 		});
 
-	if (!m_Character && Game::entityManager->GetGhostingEnabled()) {
+	if (!m_Character && EntityManager::Instance()->GetGhostingEnabled()) {
 		// Don't ghost what is likely large scene elements
-		if (HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER) && (m_Components.size() == 2 || (HasComponent(eReplicaComponentType::TRIGGER) && m_Components.size() == 3))) {
+		if (m_Components.size() == 2 && HasComponent(eReplicaComponentType::SIMPLE_PHYSICS) && HasComponent(eReplicaComponentType::RENDER)) {
 			goto no_ghosting;
 		}
 
@@ -773,7 +763,7 @@ void Entity::Initialize() {
 
 no_ghosting:
 
-	TriggerEvent(eTriggerEventType::CREATE, this);
+	TriggerEvent(eTriggerEventType::CREATE);
 
 	if (m_Character) {
 		auto* controllablePhysicsComponent = GetComponent<ControllablePhysicsComponent>();
@@ -868,7 +858,7 @@ void Entity::SetProximityRadius(dpEntity* entity, std::string name) {
 	proxMon->SetProximityRadius(entity, name);
 }
 
-void Entity::SetGMLevel(eGameMasterLevel value) {
+void Entity::SetGMLevel(uint8_t value) {
 	m_GMLevel = value;
 	if (GetParentUser()) {
 		Character* character = GetParentUser()->GetLastUsedChar();
@@ -885,7 +875,7 @@ void Entity::SetGMLevel(eGameMasterLevel value) {
 }
 
 void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType) {
-	if (packetType == eReplicaPacketType::CONSTRUCTION) {
+	if (packetType == PACKET_TYPE_CONSTRUCTION) {
 		outBitStream->Write(m_ObjectID);
 		outBitStream->Write(m_TemplateID);
 
@@ -962,9 +952,9 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 
 		if (m_ParentEntity != nullptr || m_SpawnerID != 0) {
 			outBitStream->Write1();
-			if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), static_cast<uint32_t>(eObjectBits::CLIENT)));
+			if (m_ParentEntity != nullptr) outBitStream->Write(GeneralUtils::SetBit(m_ParentEntity->GetObjectID(), OBJECT_BIT_CLIENT));
 			else if (m_Spawner != nullptr && m_Spawner->m_Info.isNetwork) outBitStream->Write(m_SpawnerID);
-			else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, static_cast<uint32_t>(eObjectBits::CLIENT)));
+			else outBitStream->Write(GeneralUtils::SetBit(m_SpawnerID, OBJECT_BIT_CLIENT));
 		} else outBitStream->Write0();
 
 		outBitStream->Write(m_HasSpawnerNodeID);
@@ -980,15 +970,15 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 
 		outBitStream->Write0(); //ObjectWorldState
 
-		if (m_GMLevel != eGameMasterLevel::CIVILIAN) {
+		if (m_GMLevel != 0) {
 			outBitStream->Write1();
 			outBitStream->Write(m_GMLevel);
 		} else outBitStream->Write0(); //No GM Level
 	}
 
 	// Only serialize parent / child info should the info be dirty (changed) or if this is the construction of the entity.
-	outBitStream->Write(m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION);
-	if (m_IsParentChildDirty || packetType == eReplicaPacketType::CONSTRUCTION) {
+	outBitStream->Write(m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION);
+	if (m_IsParentChildDirty || packetType == PACKET_TYPE_CONSTRUCTION) {
 		m_IsParentChildDirty = false;
 		outBitStream->Write(m_ParentEntity != nullptr);
 		if (m_ParentEntity) {
@@ -1013,7 +1003,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 
 	bool destroyableSerialized = false;
 	bool bIsInitialUpdate = false;
-	if (packetType == eReplicaPacketType::CONSTRUCTION) bIsInitialUpdate = true;
+	if (packetType == PACKET_TYPE_CONSTRUCTION) bIsInitialUpdate = true;
 	unsigned int flags = 0;
 
 	PossessableComponent* possessableComponent;
@@ -1111,8 +1101,9 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		characterComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	if (HasComponent(eReplicaComponentType::ITEM)) {
-		outBitStream->Write0();
+	ItemComponent* itemComponent;
+	if (TryGetComponent(eReplicaComponentType::ITEM, itemComponent)) {
+		itemComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	InventoryComponent* inventoryComponent;
@@ -1242,7 +1233,6 @@ void Entity::Update(const float deltaTime) {
 			for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 				script->OnTimerDone(this, timerName);
 			}
-			TriggerEvent(eTriggerEventType::TIMER_DONE, this);
 		} else {
 			timerPosition++;
 		}
@@ -1284,12 +1274,12 @@ void Entity::Update(const float deltaTime) {
 	}
 
 	if (m_ShouldDestroyAfterUpdate) {
-		Game::entityManager->DestroyEntity(this->GetObjectID());
+		EntityManager::Instance()->DestroyEntity(this->GetObjectID());
 	}
 }
 
 void Entity::OnCollisionProximity(LWOOBJID otherEntity, const std::string& proxName, const std::string& status) {
-	Entity* other = Game::entityManager->GetEntity(otherEntity);
+	Entity* other = EntityManager::Instance()->GetEntity(otherEntity);
 	if (!other) return;
 
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
@@ -1303,7 +1293,7 @@ void Entity::OnCollisionProximity(LWOOBJID otherEntity, const std::string& proxN
 }
 
 void Entity::OnCollisionPhantom(const LWOOBJID otherEntity) {
-	auto* other = Game::entityManager->GetEntity(otherEntity);
+	auto* other = EntityManager::Instance()->GetEntity(otherEntity);
 	if (!other) return;
 
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
@@ -1350,13 +1340,9 @@ void Entity::OnCollisionPhantom(const LWOOBJID otherEntity) {
 }
 
 void Entity::OnCollisionLeavePhantom(const LWOOBJID otherEntity) {
-	auto* other = Game::entityManager->GetEntity(otherEntity);
+	auto* other = EntityManager::Instance()->GetEntity(otherEntity);
 	if (!other) return;
 
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnOffCollisionPhantom(this, other);
-	}
-
 	TriggerEvent(eTriggerEventType::EXIT, other);
 
 	SwitchComponent* switchComp = GetComponent<SwitchComponent>();
@@ -1405,7 +1391,7 @@ void Entity::OnEmoteReceived(const int32_t emote, Entity* target) {
 }
 
 void Entity::OnUse(Entity* originator) {
-	TriggerEvent(eTriggerEventType::INTERACT, originator);
+	TriggerEvent(eTriggerEventType::INTERACT);
 
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 		script->OnUse(this, originator);
@@ -1427,7 +1413,6 @@ void Entity::OnHitOrHealResult(Entity* attacker, int32_t damage) {
 }
 
 void Entity::OnHit(Entity* attacker) {
-	TriggerEvent(eTriggerEventType::HIT, attacker);
 	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 		script->OnHit(this, attacker);
 	}
@@ -1493,24 +1478,18 @@ void Entity::OnChoiceBoxResponse(Entity* sender, int32_t button, const std::u16s
 	}
 }
 
-void Entity::RequestActivityExit(Entity* sender, LWOOBJID player, bool canceled) {
-	for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
-		script->OnRequestActivityExit(sender, player, canceled);
-	}
-}
-
 void Entity::Smash(const LWOOBJID source, const eKillType killType, const std::u16string& deathType) {
 	if (!m_PlayerIsReadyForUpdates) return;
 
 	auto* destroyableComponent = GetComponent<DestroyableComponent>();
 	if (destroyableComponent == nullptr) {
-		Kill(Game::entityManager->GetEntity(source));
+		Kill(EntityManager::Instance()->GetEntity(source));
 		return;
 	}
 	auto* possessorComponent = GetComponent<PossessorComponent>();
 	if (possessorComponent) {
 		if (possessorComponent->GetPossessable() != LWOOBJID_EMPTY) {
-			auto* mount = Game::entityManager->GetEntity(possessorComponent->GetPossessable());
+			auto* mount = EntityManager::Instance()->GetEntity(possessorComponent->GetPossessable());
 			if (mount) possessorComponent->Dismount(mount, true);
 		}
 	}
@@ -1538,20 +1517,20 @@ void Entity::Kill(Entity* murderer) {
 	}
 
 	if (!IsPlayer()) {
-		Game::entityManager->DestroyEntity(this);
+		EntityManager::Instance()->DestroyEntity(this);
 	}
 
 	const auto& grpNameQBShowBricks = GetVar<std::string>(u"grpNameQBShowBricks");
 
 	if (!grpNameQBShowBricks.empty()) {
-		auto spawners = Game::zoneManager->GetSpawnersByName(grpNameQBShowBricks);
+		auto spawners = dZoneManager::Instance()->GetSpawnersByName(grpNameQBShowBricks);
 
 		Spawner* spawner = nullptr;
 
 		if (!spawners.empty()) {
 			spawner = spawners[0];
 		} else {
-			spawners = Game::zoneManager->GetSpawnersInGroup(grpNameQBShowBricks);
+			spawners = dZoneManager::Instance()->GetSpawnersInGroup(grpNameQBShowBricks);
 
 			if (!spawners.empty()) {
 				spawner = spawners[0];
@@ -1639,7 +1618,7 @@ void Entity::PickupItem(const LWOOBJID& objectID) {
 					}
 				}
 			} else {
-				inv->AddItem(p.second.lot, p.second.count, eLootSourceType::PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
+				inv->AddItem(p.second.lot, p.second.count, eLootSourceType::LOOT_SOURCE_PICKUP, eInventoryType::INVALID, {}, LWOOBJID_EMPTY, true, false, LWOOBJID_EMPTY, eInventoryType::INVALID, 1);
 			}
 		}
 	}
@@ -1719,7 +1698,7 @@ void Entity::CancelCallbackTimers() {
 
 void Entity::ScheduleKillAfterUpdate(Entity* murderer) {
 	//if (m_Info.spawner) m_Info.spawner->ScheduleKill(this);
-	Game::entityManager->ScheduleForKill(this);
+	EntityManager::Instance()->ScheduleForKill(this);
 
 	if (murderer) m_ScheduleKiller = murderer;
 }
@@ -1763,7 +1742,7 @@ void Entity::TriggerEvent(eTriggerEventType event, Entity* optionalTarget) {
 
 Entity* Entity::GetOwner() const {
 	if (m_OwnerOverride != LWOOBJID_EMPTY) {
-		auto* other = Game::entityManager->GetEntity(m_OwnerOverride);
+		auto* other = EntityManager::Instance()->GetEntity(m_OwnerOverride);
 
 		if (other != nullptr) {
 			return other->GetOwner();
@@ -1827,6 +1806,8 @@ bool Entity::IsSleeping() const {
 
 
 const NiPoint3& Entity::GetPosition() const {
+	if (!this) return NiPoint3::ZERO;
+
 	auto* controllable = GetComponent<ControllablePhysicsComponent>();
 
 	if (controllable != nullptr) {
@@ -1907,7 +1888,7 @@ void Entity::SetPosition(NiPoint3 position) {
 		vehicel->SetPosition(position);
 	}
 
-	Game::entityManager->SerializeEntity(this);
+	EntityManager::Instance()->SerializeEntity(this);
 }
 
 void Entity::SetRotation(NiQuaternion rotation) {
@@ -1935,7 +1916,7 @@ void Entity::SetRotation(NiQuaternion rotation) {
 		vehicel->SetRotation(rotation);
 	}
 
-	Game::entityManager->SerializeEntity(this);
+	EntityManager::Instance()->SerializeEntity(this);
 }
 
 bool Entity::GetBoolean(const std::u16string& name) const {
@@ -1987,7 +1968,7 @@ std::vector<LWOOBJID>& Entity::GetTargetsInPhantom() {
 	for (auto i = 0u; i < m_TargetsInPhantom.size(); ++i) {
 		const auto id = m_TargetsInPhantom.at(i);
 
-		auto* entity = Game::entityManager->GetEntity(id);
+		auto* entity = EntityManager::Instance()->GetEntity(id);
 
 		if (entity == nullptr) {
 			continue;

dGame/Entity.h

@@ -10,7 +10,6 @@
 #include "NiPoint3.h"
 #include "NiQuaternion.h"
 #include "LDFFormat.h"
-#include "eKillType.h"
 
 namespace Loot {
 	class Info;
@@ -32,10 +31,7 @@ class Item;
 class Character;
 class EntityCallbackTimer;
 enum class eTriggerEventType;
-enum class eGameMasterLevel : uint8_t;
 enum class eReplicaComponentType : uint32_t;
-enum class eReplicaPacketType : uint8_t;
-enum class eCinematicEvent : uint32_t;
 
 namespace CppScripts {
 	class Script;
@@ -64,7 +60,7 @@ public:
 
 	Character* GetCharacter() const { return m_Character; }
 
-	eGameMasterLevel GetGMLevel() const { return m_GMLevel; }
+	uint8_t GetGMLevel() const { return m_GMLevel; }
 
 	uint8_t GetCollectibleID() const { return uint8_t(m_CollectibleID); }
 
@@ -112,7 +108,7 @@ public:
 
 	void SetCharacter(Character* value) { m_Character = value; }
 
-	void SetGMLevel(eGameMasterLevel value);
+	void SetGMLevel(uint8_t value);
 
 	void SetOwnerOverride(LWOOBJID value);
 
@@ -207,7 +203,6 @@ public:
 
 	void OnMessageBoxResponse(Entity* sender, int32_t button, const std::u16string& identifier, const std::u16string& userData);
 	void OnChoiceBoxResponse(Entity* sender, int32_t button, const std::u16string& buttonIdentifier, const std::u16string& identifier);
-	void RequestActivityExit(Entity* sender, LWOOBJID player, bool canceled);
 
 	void Smash(const LWOOBJID source = LWOOBJID_EMPTY, const eKillType killType = eKillType::VIOLENT, const std::u16string& deathType = u"");
 	void Kill(Entity* murderer = nullptr);
@@ -313,7 +308,7 @@ protected:
 
 	Entity* m_ParentEntity; //For spawners and the like
 	std::vector<Entity*> m_ChildEntities;
-	eGameMasterLevel m_GMLevel;
+	uint8_t m_GMLevel;
 	uint16_t m_CollectibleID;
 	std::vector<std::string> m_Groups;
 	uint16_t m_NetworkID;

dGame/EntityManager.cpp

@@ -20,10 +20,9 @@
 #include "MessageIdentifiers.h"
 #include "dConfig.h"
 #include "eTriggerEventType.h"
-#include "eObjectBits.h"
-#include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
-#include "eReplicaPacketType.h"
+
+EntityManager* EntityManager::m_Address = nullptr;
 
 // Configure which zones have ghosting disabled, mostly small worlds.
 std::vector<LWOMAPID> EntityManager::m_GhostingExcludedZones = {
@@ -60,7 +59,7 @@ void EntityManager::Initialize() {
 	m_GhostingEnabled = std::find(
 		m_GhostingExcludedZones.begin(),
 		m_GhostingExcludedZones.end(),
-		Game::zoneManager->GetZoneID().GetMapID()
+		dZoneManager::Instance()->GetZoneID().GetMapID()
 	) == m_GhostingExcludedZones.end();
 
 	// grab hardcore mode settings and load them with sane defaults
@@ -75,7 +74,10 @@ void EntityManager::Initialize() {
 
 	// If cloneID is not zero, then hardcore mode is disabled
 	// aka minigames and props
-	if (Game::zoneManager->GetZoneID().GetCloneID() != 0) m_HardcoreMode = false;
+	if (dZoneManager::Instance()->GetZoneID().GetCloneID() != 0) m_HardcoreMode = false;
+}
+
+EntityManager::~EntityManager() {
 }
 
 Entity* EntityManager::CreateEntity(EntityInfo info, User* user, Entity* parentEntity, const bool controller, const LWOOBJID explicitId) {
@@ -105,11 +107,11 @@ Entity* EntityManager::CreateEntity(EntityInfo info, User* user, Entity* parentE
 		if (!controller && info.lot != 14) {
 
 			// The client flags means the client should render the entity
-			GeneralUtils::SetBit(id, eObjectBits::CLIENT);
+			id = GeneralUtils::SetBit(id, OBJECT_BIT_CLIENT);
 
 			// Spawned entities require the spawned flag to render
 			if (info.spawnerID != 0) {
-				GeneralUtils::SetBit(id, eObjectBits::SPAWNED);
+				id = GeneralUtils::SetBit(id, OBJECT_BIT_SPAWNED);
 			}
 		}
 	}
@@ -156,9 +158,9 @@ void EntityManager::DestroyEntity(const LWOOBJID& objectID) {
 }
 
 void EntityManager::DestroyEntity(Entity* entity) {
-	if (!entity) return;
-
-	entity->TriggerEvent(eTriggerEventType::DESTROY, entity);
+	if (entity == nullptr) {
+		return;
+	}
 
 	const auto id = entity->GetObjectID();
 
@@ -175,11 +177,15 @@ void EntityManager::DestroyEntity(Entity* entity) {
 	ScheduleForDeletion(id);
 }
 
-void EntityManager::SerializeEntities() {
+void EntityManager::UpdateEntities(const float deltaTime) {
+	for (const auto& e : m_Entities) {
+		e.second->Update(deltaTime);
+	}
+
 	for (auto entry = m_EntitiesToSerialize.begin(); entry != m_EntitiesToSerialize.end(); entry++) {
 		auto* entity = GetEntity(*entry);
 
-		if (!entity) continue;
+		if (entity == nullptr) continue;
 
 		m_SerializationCounter++;
 
@@ -187,8 +193,8 @@ void EntityManager::SerializeEntities() {
 		stream.Write(static_cast<char>(ID_REPLICA_MANAGER_SERIALIZE));
 		stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));
 
-		entity->WriteBaseReplicaData(&stream, eReplicaPacketType::SERIALIZATION);
-		entity->WriteComponents(&stream, eReplicaPacketType::SERIALIZATION);
+		entity->WriteBaseReplicaData(&stream, PACKET_TYPE_SERIALIZATION);
+		entity->WriteComponents(&stream, PACKET_TYPE_SERIALIZATION);
 
 		if (entity->GetIsGhostingCandidate()) {
 			for (auto* player : Player::GetAllPlayers()) {
@@ -201,59 +207,45 @@ void EntityManager::SerializeEntities() {
 		}
 	}
 	m_EntitiesToSerialize.clear();
-}
 
-void EntityManager::KillEntities() {
 	for (auto entry = m_EntitiesToKill.begin(); entry != m_EntitiesToKill.end(); entry++) {
 		auto* entity = GetEntity(*entry);
 
-		if (!entity) {
-			Game::logger->Log("EntityManager", "Attempting to kill null entity %llu", *entry);
-			continue;
-		}
+		if (!entity) continue;
 
 		if (entity->GetScheduledKiller()) {
-			entity->Smash(entity->GetScheduledKiller()->GetObjectID(), eKillType::SILENT);
+			entity->Smash(entity->GetScheduledKiller()->GetObjectID(), SILENT);
 		} else {
-			entity->Smash(LWOOBJID_EMPTY, eKillType::SILENT);
+			entity->Smash(LWOOBJID_EMPTY, SILENT);
 		}
 	}
 	m_EntitiesToKill.clear();
-}
 
-void EntityManager::DeleteEntities() {
 	for (auto entry = m_EntitiesToDelete.begin(); entry != m_EntitiesToDelete.end(); entry++) {
+
+		// Get all this info first before we delete the player.
 		auto entityToDelete = GetEntity(*entry);
+		auto networkIdToErase = entityToDelete->GetNetworkId();
+		const auto& ghostingToDelete = std::find(m_EntitiesToGhost.begin(), m_EntitiesToGhost.end(), entityToDelete);
+
 		if (entityToDelete) {
-			// Get all this info first before we delete the player.
-			auto networkIdToErase = entityToDelete->GetNetworkId();
-			const auto& ghostingToDelete = std::find(m_EntitiesToGhost.begin(), m_EntitiesToGhost.end(), entityToDelete);
-
-			delete entityToDelete;
-
+			// If we are a player run through the player destructor.
+			if (entityToDelete->IsPlayer()) {
+				delete dynamic_cast<Player*>(entityToDelete);
+			} else {
+				delete entityToDelete;
+			}
 			entityToDelete = nullptr;
-
 			if (networkIdToErase != 0) m_LostNetworkIds.push(networkIdToErase);
-
-			if (ghostingToDelete != m_EntitiesToGhost.end()) m_EntitiesToGhost.erase(ghostingToDelete);
-		} else {
-			Game::logger->Log("EntityManager", "Attempted to delete non-existent entity %llu", *entry);
 		}
+
+		if (ghostingToDelete != m_EntitiesToGhost.end()) m_EntitiesToGhost.erase(ghostingToDelete);
+
 		m_Entities.erase(*entry);
 	}
 	m_EntitiesToDelete.clear();
 }
 
-void EntityManager::UpdateEntities(const float deltaTime) {
-	for (const auto& e : m_Entities) {
-		e.second->Update(deltaTime);
-	}
-
-	SerializeEntities();
-	KillEntities();
-	DeleteEntities();
-}
-
 Entity* EntityManager::GetEntity(const LWOOBJID& objectId) const {
 	const auto& index = m_Entities.find(objectId);
 
@@ -319,11 +311,6 @@ const std::unordered_map<std::string, LWOOBJID>& EntityManager::GetSpawnPointEnt
 }
 
 void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr, const bool skipChecks) {
-	if (!entity) {
-		Game::logger->Log("EntityManager", "Attempted to construct null entity");
-		return;
-	}
-
 	if (entity->GetNetworkId() == 0) {
 		uint16_t networkId;
 
@@ -361,8 +348,8 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 	stream.Write(true);
 	stream.Write(static_cast<unsigned short>(entity->GetNetworkId()));
 
-	entity->WriteBaseReplicaData(&stream, eReplicaPacketType::CONSTRUCTION);
-	entity->WriteComponents(&stream, eReplicaPacketType::CONSTRUCTION);
+	entity->WriteBaseReplicaData(&stream, PACKET_TYPE_CONSTRUCTION);
+	entity->WriteComponents(&stream, PACKET_TYPE_CONSTRUCTION);
 
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
 		if (skipChecks) {
@@ -383,7 +370,7 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 	// PacketUtils::SavePacket("[24]_"+std::to_string(entity->GetObjectID()) + "_" + std::to_string(m_SerializationCounter) + ".bin", (char*)stream.GetData(), stream.GetNumberOfBytesUsed());
 
 	if (entity->IsPlayer()) {
-		if (entity->GetGMLevel() > eGameMasterLevel::CIVILIAN) {
+		if (entity->GetGMLevel() > GAME_MASTER_LEVEL_CIVILIAN) {
 			GameMessages::SendToggleGMInvis(entity->GetObjectID(), true, sysAddr);
 		}
 	}
@@ -403,7 +390,9 @@ void EntityManager::ConstructAllEntities(const SystemAddress& sysAddr) {
 }
 
 void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr) {
-	if (!entity || entity->GetNetworkId() == 0) return;
+	if (entity->GetNetworkId() == 0) {
+		return;
+	}
 
 	RakNet::BitStream stream;
 
@@ -420,7 +409,9 @@ void EntityManager::DestructEntity(Entity* entity, const SystemAddress& sysAddr)
 }
 
 void EntityManager::SerializeEntity(Entity* entity) {
-	if (!entity || entity->GetNetworkId() == 0) return;
+	if (entity->GetNetworkId() == 0) {
+		return;
+	}
 
 	if (std::find(m_EntitiesToSerialize.begin(), m_EntitiesToSerialize.end(), entity->GetObjectID()) == m_EntitiesToSerialize.end()) {
 		m_EntitiesToSerialize.push_back(entity->GetObjectID());
@@ -596,7 +587,7 @@ void EntityManager::ScheduleForKill(Entity* entity) {
 
 	SwitchComponent* switchComp = entity->GetComponent<SwitchComponent>();
 	if (switchComp) {
-		entity->TriggerEvent(eTriggerEventType::DEACTIVATED, entity);
+		entity->TriggerEvent(eTriggerEventType::DEACTIVATED);
 	}
 
 	const auto objectId = entity->GetObjectID();

dGame/EntityManager.h

@@ -1,13 +1,12 @@
 #ifndef ENTITYMANAGER_H
 #define ENTITYMANAGER_H
 
+#include "dCommonVars.h"
 #include <map>
 #include <stack>
 #include <vector>
 #include <unordered_map>
 
-#include "dCommonVars.h"
-
 class Entity;
 class EntityInfo;
 class Player;
@@ -18,8 +17,19 @@ struct SystemAddress;
 
 class EntityManager {
 public:
+	static EntityManager* Instance() {
+		if (!m_Address) {
+			m_Address = new EntityManager();
+			m_Address->Initialize();
+		}
+
+		return m_Address;
+	}
+
 	void Initialize();
 
+	~EntityManager();
+
 	void UpdateEntities(float deltaTime);
 	Entity* CreateEntity(EntityInfo info, User* user = nullptr, Entity* parentEntity = nullptr, bool controller = false, LWOOBJID explicitId = LWOOBJID_EMPTY);
 	void DestroyEntity(const LWOOBJID& objectID);
@@ -75,10 +85,7 @@ public:
 	const uint32_t GetHardcoreUscoreEnemiesMultiplier() { return m_HardcoreUscoreEnemiesMultiplier; };
 
 private:
-	void SerializeEntities();
-	void KillEntities();
-	void DeleteEntities();
-
+	static EntityManager* m_Address; //For singleton method
 	static std::vector<LWOMAPID> m_GhostingExcludedZones;
 	static std::vector<LOT> m_GhostingExcludedLOTs;
 

dGame/LeaderboardManager.cpp

@@ -1,8 +1,5 @@
 #include "LeaderboardManager.h"
-
-#include <sstream>
 #include <utility>
-
 #include "Database.h"
 #include "EntityManager.h"
 #include "Character.h"
@@ -13,400 +10,461 @@
 #include "CDClientManager.h"
 #include "GeneralUtils.h"
 #include "Entity.h"
-#include "LDFFormat.h"
-#include "DluAssert.h"
 
 #include "CDActivitiesTable.h"
-#include "Metrics.hpp"
 
-namespace LeaderboardManager {
-	std::map<GameID, Leaderboard::Type> leaderboardCache;
-}
-
-Leaderboard::Leaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, LWOOBJID relatedPlayer, const Leaderboard::Type leaderboardType) {
+Leaderboard::Leaderboard(uint32_t gameID, uint32_t infoType, bool weekly, std::vector<LeaderboardEntry> entries,
+	LWOOBJID relatedPlayer, LeaderboardType leaderboardType) {
+	this->relatedPlayer = relatedPlayer;
 	this->gameID = gameID;
 	this->weekly = weekly;
 	this->infoType = infoType;
+	this->entries = std::move(entries);
 	this->leaderboardType = leaderboardType;
-	this->relatedPlayer = relatedPlayer;
 }
 
-Leaderboard::~Leaderboard() {
-	Clear();
-}
+std::u16string Leaderboard::ToString() const {
+	std::string leaderboard;
 
-void Leaderboard::Clear() {
-	for (auto& entry : entries) for (auto ldfData : entry) delete ldfData;
-}
+	leaderboard += "ADO.Result=7:1\n";
+	leaderboard += "Result.Count=1:1\n";
+	leaderboard += "Result[0].Index=0:RowNumber\n";
+	leaderboard += "Result[0].RowCount=1:" + std::to_string(entries.size()) + "\n";
 
-inline void WriteLeaderboardRow(std::ostringstream& leaderboard, const uint32_t& index, LDFBaseData* data) {
-	leaderboard << "\nResult[0].Row[" << index << "]." << data->GetString();
-}
+	auto index = 0;
+	for (const auto& entry : entries) {
+		leaderboard += "Result[0].Row[" + std::to_string(index) + "].LastPlayed=8:" + std::to_string(entry.lastPlayed) + "\n";
+		leaderboard += "Result[0].Row[" + std::to_string(index) + "].CharacterID=8:" + std::to_string(entry.playerID) + "\n";
+		leaderboard += "Result[0].Row[" + std::to_string(index) + "].NumPlayed=1:1\n";
+		leaderboard += "Result[0].Row[" + std::to_string(index) + "].RowNumber=8:" + std::to_string(entry.placement) + "\n";
+		leaderboard += "Result[0].Row[" + std::to_string(index) + "].Time=1:" + std::to_string(entry.time) + "\n";
 
-void Leaderboard::Serialize(RakNet::BitStream* bitStream) const {
-	bitStream->Write(gameID);
-	bitStream->Write(infoType);
-
-	std::ostringstream leaderboard;
-
-	leaderboard << "ADO.Result=7:1"; // Unused in 1.10.64, but is in captures
-	leaderboard << "\nResult.Count=1:1"; // number of results, always 1
-	if (!this->entries.empty()) leaderboard << "\nResult[0].Index=0:RowNumber"; // "Primary key".  Live doesn't include this if there are no entries.
-	leaderboard << "\nResult[0].RowCount=1:" << entries.size();
-
-	int32_t rowNumber = 0;
-	for (auto& entry : entries) {
-		for (auto* data : entry) {
-			WriteLeaderboardRow(leaderboard, rowNumber, data);
+		// Only these minigames have a points system
+		if (leaderboardType == Survival || leaderboardType == ShootingGallery) {
+			leaderboard += "Result[0].Row[" + std::to_string(index) + "].Points=1:" + std::to_string(entry.score) + "\n";
+		} else if (leaderboardType == SurvivalNS) {
+			leaderboard += "Result[0].Row[" + std::to_string(index) + "].Wave=1:" + std::to_string(entry.score) + "\n";
 		}
-		rowNumber++;
+
+		leaderboard += "Result[0].Row[" + std::to_string(index) + "].name=0:" + entry.playerName + "\n";
+		index++;
 	}
 
-	// Serialize the thing to a BitStream
-	uint32_t leaderboardSize = leaderboard.tellp();
-	bitStream->Write<uint32_t>(leaderboardSize);
-	// Doing this all in 1 call so there is no possbility of a dangling pointer.
-	bitStream->WriteAlignedBytes(reinterpret_cast<const unsigned char*>(GeneralUtils::ASCIIToUTF16(leaderboard.str()).c_str()), leaderboardSize * sizeof(char16_t));
-	if (leaderboardSize > 0) bitStream->Write<uint16_t>(0);
-	bitStream->Write0();
-	bitStream->Write0();
+	return GeneralUtils::UTF8ToUTF16(leaderboard);
 }
 
-void Leaderboard::QueryToLdf(std::unique_ptr<sql::ResultSet>& rows) {
-	Clear();
-	if (rows->rowsCount() == 0) return;
-
-	this->entries.reserve(rows->rowsCount());
-	while (rows->next()) {
-		constexpr int32_t MAX_NUM_DATA_PER_ROW = 9;
-		this->entries.push_back(std::vector<LDFBaseData*>());
-		auto& entry = this->entries.back();
-		entry.reserve(MAX_NUM_DATA_PER_ROW);
-		entry.push_back(new LDFData<uint64_t>(u"CharacterID", rows->getInt("character_id")));
-		entry.push_back(new LDFData<uint64_t>(u"LastPlayed", rows->getUInt64("lastPlayed")));
-		entry.push_back(new LDFData<int32_t>(u"NumPlayed", rows->getInt("timesPlayed")));
-		entry.push_back(new LDFData<std::u16string>(u"name", GeneralUtils::ASCIIToUTF16(rows->getString("name").c_str())));
-		entry.push_back(new LDFData<uint64_t>(u"RowNumber", rows->getInt("ranking")));
-		switch (leaderboardType) {
-		case Type::ShootingGallery:
-			entry.push_back(new LDFData<int32_t>(u"Score", rows->getInt("primaryScore")));
-			// Score:1
-			entry.push_back(new LDFData<int32_t>(u"Streak", rows->getInt("secondaryScore")));
-			// Streak:1
-			entry.push_back(new LDFData<float>(u"HitPercentage", (rows->getInt("tertiaryScore") / 100.0f)));
-			// HitPercentage:3 between 0 and 1
-			break;
-		case Type::Racing:
-			entry.push_back(new LDFData<float>(u"BestTime", rows->getDouble("primaryScore")));
-			// BestLapTime:3
-			entry.push_back(new LDFData<float>(u"BestLapTime", rows->getDouble("secondaryScore")));
-			// BestTime:3
-			entry.push_back(new LDFData<int32_t>(u"License", 1));
-			// License:1 - 1 if player has completed mission 637 and 0 otherwise
-			entry.push_back(new LDFData<int32_t>(u"NumWins", rows->getInt("numWins")));
-			// NumWins:1
-			break;
-		case Type::UnusedLeaderboard4:
-			entry.push_back(new LDFData<int32_t>(u"Points", rows->getInt("primaryScore")));
-			// Points:1
-			break;
-		case Type::MonumentRace:
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("primaryScore")));
-			// Time:1(?)
-			break;
-		case Type::FootRace:
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("primaryScore")));
-			// Time:1
-			break;
-		case Type::Survival:
-			entry.push_back(new LDFData<int32_t>(u"Points", rows->getInt("primaryScore")));
-			// Points:1
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("secondaryScore")));
-			// Time:1
-			break;
-		case Type::SurvivalNS:
-			entry.push_back(new LDFData<int32_t>(u"Wave", rows->getInt("primaryScore")));
-			// Wave:1
-			entry.push_back(new LDFData<int32_t>(u"Time", rows->getInt("secondaryScore")));
-			// Time:1
-			break;
-		case Type::Donations:
-			entry.push_back(new LDFData<int32_t>(u"Points", rows->getInt("primaryScore")));
-			// Score:1				
-			break;
-		case Type::None:
-			// This type is included here simply to resolve a compiler warning on mac about unused enum types
-			break;
-		default:
-			break;
-		}
-	}
+std::vector<LeaderboardEntry> Leaderboard::GetEntries() {
+	return entries;
 }
 
-const std::string_view Leaderboard::GetOrdering(Leaderboard::Type leaderboardType) {
-	// Use a switch case and return desc for all 3 columns if higher is better and asc if lower is better
-	switch (leaderboardType) {
-	case Type::Racing:
-	case Type::MonumentRace:
-		return "primaryScore ASC, secondaryScore ASC, tertiaryScore ASC";
-	case Type::Survival:
-		return Game::config->GetValue("classic_survival_scoring") == "1" ?
-			"secondaryScore DESC, primaryScore DESC, tertiaryScore DESC" :
-			"primaryScore DESC, secondaryScore DESC, tertiaryScore DESC";
-	case Type::SurvivalNS:
-		return "primaryScore DESC, secondaryScore ASC, tertiaryScore DESC";
-	case Type::ShootingGallery:
-	case Type::FootRace:
-	case Type::UnusedLeaderboard4:
-	case Type::Donations:
-	case Type::None:
-	default:
-		return "primaryScore DESC, secondaryScore DESC, tertiaryScore DESC";
-	}
+uint32_t Leaderboard::GetGameID() const {
+	return gameID;
 }
 
-void Leaderboard::SetupLeaderboard(bool weekly, uint32_t resultStart, uint32_t resultEnd) {
-	resultStart++;
-	resultEnd++;
-	// We need everything except 1 column so i'm selecting * from leaderboard
-	const std::string queryBase =
-		R"QUERY( 
-		WITH leaderboardsRanked AS ( 
-			SELECT leaderboard.*, charinfo.name, 
-				RANK() OVER 
-				( 
-				ORDER BY %s, UNIX_TIMESTAMP(last_played) ASC, id DESC
-			) AS ranking 
-				FROM leaderboard JOIN charinfo on charinfo.id = leaderboard.character_id 
-				WHERE game_id = ? %s 
-		), 
-		myStanding AS ( 
-			SELECT 
-				ranking as myRank 
-			FROM leaderboardsRanked 
-			WHERE id = ? 
-		), 
-		lowestRanking AS ( 
-			SELECT MAX(ranking) AS lowestRank 
-				FROM leaderboardsRanked 
-		) 
-		SELECT leaderboardsRanked.*, character_id, UNIX_TIMESTAMP(last_played) as lastPlayed, leaderboardsRanked.name, leaderboardsRanked.ranking FROM leaderboardsRanked, myStanding, lowestRanking 
-		WHERE leaderboardsRanked.ranking 
-		BETWEEN 
-		LEAST(GREATEST(CAST(myRank AS SIGNED) - 5, %i), lowestRanking.lowestRank - 9) 
-		AND 
-		LEAST(GREATEST(myRank + 5, %i), lowestRanking.lowestRank) 
-		ORDER BY ranking ASC;
-	)QUERY";
-
-	std::string friendsFilter =
-		R"QUERY(
-		AND (
-			character_id IN (
-				SELECT fr.requested_player FROM (
-					SELECT CASE
-					WHEN player_id = ? THEN friend_id
-					WHEN friend_id = ? THEN player_id
-					END AS requested_player
-					FROM friends
-				) AS fr
-				JOIN charinfo AS ci
-				ON ci.id = fr.requested_player
-				WHERE fr.requested_player IS NOT NULL
-			)
-		OR character_id = ?
-		)
-	)QUERY";
-
-	std::string weeklyFilter = " AND UNIX_TIMESTAMP(last_played) BETWEEN UNIX_TIMESTAMP(date_sub(now(),INTERVAL 1 WEEK)) AND UNIX_TIMESTAMP(now()) ";
-
-	std::string filter;
-	// Setup our filter based on the query type
-	if (this->infoType == InfoType::Friends) filter += friendsFilter;
-	if (this->weekly) filter += weeklyFilter;
-	const auto orderBase = GetOrdering(this->leaderboardType);
-
-	// For top query, we want to just rank all scores, but for all others we need the scores around a specific player
-	std::string baseLookup;
-	if (this->infoType == InfoType::Top) {
-		baseLookup = "SELECT id, last_played FROM leaderboard WHERE game_id = ? " + (this->weekly ? weeklyFilter : std::string("")) + " ORDER BY ";
-		baseLookup += orderBase.data();
-	} else {
-		baseLookup = "SELECT id, last_played FROM leaderboard WHERE game_id = ? " + (this->weekly ? weeklyFilter : std::string("")) + " AND character_id = ";
-		baseLookup += std::to_string(static_cast<uint32_t>(this->relatedPlayer));
-	}
-	baseLookup += " LIMIT 1";
-	Game::logger->LogDebug("LeaderboardManager", "query is %s", baseLookup.c_str());
-	std::unique_ptr<sql::PreparedStatement> baseQuery(Database::CreatePreppedStmt(baseLookup));
-	baseQuery->setInt(1, this->gameID);
-	std::unique_ptr<sql::ResultSet> baseResult(baseQuery->executeQuery());
-
-	if (!baseResult->next()) return; // In this case, there are no entries in the leaderboard for this game.
-
-	uint32_t relatedPlayerLeaderboardId = baseResult->getInt("id");
-
-	// Create and execute the actual save here. Using a heap allocated buffer to avoid stack overflow
-	constexpr uint16_t STRING_LENGTH = 4096;
-	std::unique_ptr<char[]> lookupBuffer = std::make_unique<char[]>(STRING_LENGTH);
-	int32_t res = snprintf(lookupBuffer.get(), STRING_LENGTH, queryBase.c_str(), orderBase.data(), filter.c_str(), resultStart, resultEnd);
-	DluAssert(res != -1);
-	std::unique_ptr<sql::PreparedStatement> query(Database::CreatePreppedStmt(lookupBuffer.get()));
-	Game::logger->LogDebug("LeaderboardManager", "Query is %s vars are %i %i %i", lookupBuffer.get(), this->gameID, this->relatedPlayer, relatedPlayerLeaderboardId);
-	query->setInt(1, this->gameID);
-	if (this->infoType == InfoType::Friends) {
-		query->setInt(2, this->relatedPlayer);
-		query->setInt(3, this->relatedPlayer);
-		query->setInt(4, this->relatedPlayer);
-		query->setInt(5, relatedPlayerLeaderboardId);
-	} else {
-		query->setInt(2, relatedPlayerLeaderboardId);
-	}
-	std::unique_ptr<sql::ResultSet> result(query->executeQuery());
-	QueryToLdf(result);
+uint32_t Leaderboard::GetInfoType() const {
+	return infoType;
 }
 
-void Leaderboard::Send(const LWOOBJID targetID) const {
-	auto* player = Game::entityManager->GetEntity(relatedPlayer);
+void Leaderboard::Send(LWOOBJID targetID) const {
+	auto* player = EntityManager::Instance()->GetEntity(relatedPlayer);
 	if (player != nullptr) {
 		GameMessages::SendActivitySummaryLeaderboardData(targetID, this, player->GetSystemAddress());
 	}
 }
 
-std::string FormatInsert(const Leaderboard::Type& type, const Score& score, const bool useUpdate) {
-	std::string insertStatement;
-	if (useUpdate) {
-		insertStatement =
-			R"QUERY(
-			UPDATE leaderboard 
-			SET primaryScore = %f, secondaryScore = %f, tertiaryScore = %f, 
-			timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;
-			)QUERY";
-	} else {
-		insertStatement =
-			R"QUERY(
-			INSERT leaderboard SET 
-			primaryScore = %f, secondaryScore = %f, tertiaryScore = %f, 
-			character_id = ?, game_id = ?;
-			)QUERY";
-	}
+void LeaderboardManager::SaveScore(LWOOBJID playerID, uint32_t gameID, uint32_t score, uint32_t time) {
+	const auto* player = EntityManager::Instance()->GetEntity(playerID);
+	if (player == nullptr)
+		return;
 
-	constexpr uint16_t STRING_LENGTH = 400;
-	// Then fill in our score
-	char finishedQuery[STRING_LENGTH];
-	int32_t res = snprintf(finishedQuery, STRING_LENGTH, insertStatement.c_str(), score.GetPrimaryScore(), score.GetSecondaryScore(), score.GetTertiaryScore());
-	DluAssert(res != -1);
-	return finishedQuery;
-}
+	auto* character = player->GetCharacter();
+	if (character == nullptr)
+		return;
 
-void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activityId, const float primaryScore, const float secondaryScore, const float tertiaryScore) {
-	const Leaderboard::Type leaderboardType = GetLeaderboardType(activityId);
-	auto* lookup = "SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;";
+	auto* select = Database::CreatePreppedStmt("SELECT time, score FROM leaderboard WHERE character_id = ? AND game_id = ?;");
 
-	std::unique_ptr<sql::PreparedStatement> query(Database::CreatePreppedStmt(lookup));
-	query->setInt(1, playerID);
-	query->setInt(2, activityId);
-	std::unique_ptr<sql::ResultSet> myScoreResult(query->executeQuery());
+	select->setUInt64(1, character->GetID());
+	select->setInt(2, gameID);
+
+	auto any = false;
+	auto* result = select->executeQuery();
+	auto leaderboardType = GetLeaderboardType(gameID);
+
+	// Check if the new score is a high score
+	while (result->next()) {
+		any = true;
+
+		const auto storedTime = result->getInt(1);
+		const auto storedScore = result->getInt(2);
+		auto highscore = true;
+		bool classicSurvivalScoring = Game::config->GetValue("classic_survival_scoring") == "1";
 
-	std::string saveQuery("UPDATE leaderboard SET timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;");
-	Score newScore(primaryScore, secondaryScore, tertiaryScore);
-	if (myScoreResult->next()) {
-		Score oldScore;
-		bool lowerScoreBetter = false;
 		switch (leaderboardType) {
-			// Higher score better
-		case Leaderboard::Type::ShootingGallery: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
-			oldScore.SetTertiaryScore(myScoreResult->getInt("tertiaryScore"));
+		case ShootingGallery:
+			if (score <= storedScore)
+				highscore = false;
 			break;
-		}
-		case Leaderboard::Type::FootRace: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
+		case Racing:
+			if (time >= storedTime)
+				highscore = false;
 			break;
-		}
-		case Leaderboard::Type::Survival: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
+		case MonumentRace:
+			if (time >= storedTime)
+				highscore = false;
 			break;
-		}
-		case Leaderboard::Type::SurvivalNS: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
+		case FootRace:
+			if (time <= storedTime)
+				highscore = false;
 			break;
-		}
-		case Leaderboard::Type::UnusedLeaderboard4:
-		case Leaderboard::Type::Donations: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
+		case Survival:
+			if (classicSurvivalScoring) {
+				if (time <= storedTime) { // Based on time (LU live)
+					highscore = false;
+				}
+			} else {
+				if (score <= storedScore) // Based on score (DLU)
+					highscore = false;
+			}
 			break;
-		}
-		case Leaderboard::Type::Racing: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			oldScore.SetSecondaryScore(myScoreResult->getInt("secondaryScore"));
-
-			// For wins we dont care about the score, just the time, so zero out the tertiary.
-			// Wins are updated later.
-			oldScore.SetTertiaryScore(0);
-			newScore.SetTertiaryScore(0);
-			lowerScoreBetter = true;
+		case SurvivalNS:
+			if (!(score > storedScore || (time < storedTime && score >= storedScore)))
+				highscore = false;
 			break;
-		}
-		case Leaderboard::Type::MonumentRace: {
-			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			lowerScoreBetter = true;
-			// Do score checking here
-			break;
-		}
-		case Leaderboard::Type::None:
 		default:
-			Game::logger->Log("LeaderboardManager", "Unknown leaderboard type %i for game %i. Cannot save score!", leaderboardType, activityId);
+			highscore = false;
+		}
+
+		if (!highscore) {
+			delete select;
+			delete result;
 			return;
 		}
-		bool newHighScore = lowerScoreBetter ? newScore < oldScore : newScore > oldScore;
-		// Nimbus station has a weird leaderboard where we need a custom scoring system
-		if (leaderboardType == Leaderboard::Type::SurvivalNS) {
-			newHighScore = newScore.GetPrimaryScore() > oldScore.GetPrimaryScore() ||
-				(newScore.GetPrimaryScore() == oldScore.GetPrimaryScore() && newScore.GetSecondaryScore() < oldScore.GetSecondaryScore());
-		} else if (leaderboardType == Leaderboard::Type::Survival && Game::config->GetValue("classic_survival_scoring") == "1") {
-			Score oldScoreFlipped(oldScore.GetSecondaryScore(), oldScore.GetPrimaryScore());
-			Score newScoreFlipped(newScore.GetSecondaryScore(), newScore.GetPrimaryScore());
-			newHighScore = newScoreFlipped > oldScoreFlipped;
-		}
-		if (newHighScore) {
-			saveQuery = FormatInsert(leaderboardType, newScore, true);
-		}
+	}
+
+	delete select;
+	delete result;
+
+	if (any) {
+		auto* statement = Database::CreatePreppedStmt("UPDATE leaderboard SET time = ?, score = ?, last_played=SYSDATE() WHERE character_id = ? AND game_id = ?;");
+		statement->setInt(1, time);
+		statement->setInt(2, score);
+		statement->setUInt64(3, character->GetID());
+		statement->setInt(4, gameID);
+		statement->execute();
+
+		delete statement;
 	} else {
-		saveQuery = FormatInsert(leaderboardType, newScore, false);
-	}
-	Game::logger->Log("LeaderboardManager", "save query %s %i %i", saveQuery.c_str(), playerID, activityId);
-	std::unique_ptr<sql::PreparedStatement> saveStatement(Database::CreatePreppedStmt(saveQuery));
-	saveStatement->setInt(1, playerID);
-	saveStatement->setInt(2, activityId);
-	saveStatement->execute();
-	
-	// track wins separately
-	if (leaderboardType == Leaderboard::Type::Racing && tertiaryScore != 0.0f) {
-		std::unique_ptr<sql::PreparedStatement> winUpdate(Database::CreatePreppedStmt("UPDATE leaderboard SET numWins = numWins + 1 WHERE character_id = ? AND game_id = ?;"));
-		winUpdate->setInt(1, playerID);
-		winUpdate->setInt(2, activityId);
-		winUpdate->execute();
+		// Note: last_played will be set to SYSDATE() by default when inserting into leaderboard
+		auto* statement = Database::CreatePreppedStmt("INSERT INTO leaderboard (character_id, game_id, time, score) VALUES (?, ?, ?, ?);");
+		statement->setUInt64(1, character->GetID());
+		statement->setInt(2, gameID);
+		statement->setInt(3, time);
+		statement->setInt(4, score);
+		statement->execute();
+
+		delete statement;
 	}
 }
 
-void LeaderboardManager::SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID, const uint32_t resultStart, const uint32_t resultEnd) {
-	Leaderboard leaderboard(gameID, infoType, weekly, playerID, GetLeaderboardType(gameID));
-	leaderboard.SetupLeaderboard(weekly, resultStart, resultEnd);
-	leaderboard.Send(targetID);
+Leaderboard* LeaderboardManager::GetLeaderboard(uint32_t gameID, InfoType infoType, bool weekly, LWOOBJID playerID) {
+	auto leaderboardType = GetLeaderboardType(gameID);
+
+	std::string query;
+	bool classicSurvivalScoring = Game::config->GetValue("classic_survival_scoring") == "1";
+	switch (infoType) {
+	case InfoType::Standings:
+		switch (leaderboardType) {
+		case ShootingGallery:
+			query = standingsScoreQuery; // Shooting gallery is based on the highest score.
+			break;
+		case FootRace:
+			query = standingsTimeQuery; // The higher your time, the better for FootRace.
+			break;
+		case Survival:
+			query = classicSurvivalScoring ? standingsTimeQuery : standingsScoreQuery;
+			break;
+		case SurvivalNS:
+			query = standingsScoreQueryAsc; // BoNS is scored by highest wave (score) first, then time.
+			break;
+		default:
+			query = standingsTimeQueryAsc; // MonumentRace and Racing are based on the shortest time.
+		}
+		break;
+	case InfoType::Friends:
+		switch (leaderboardType) {
+		case ShootingGallery:
+			query = friendsScoreQuery; // Shooting gallery is based on the highest score.
+			break;
+		case FootRace:
+			query = friendsTimeQuery; // The higher your time, the better for FootRace.
+			break;
+		case Survival:
+			query = classicSurvivalScoring ? friendsTimeQuery : friendsScoreQuery;
+			break;
+		case SurvivalNS:
+			query = friendsScoreQueryAsc; // BoNS is scored by highest wave (score) first, then time.
+			break;
+		default:
+			query = friendsTimeQueryAsc;  // MonumentRace and Racing are based on the shortest time.
+		}
+		break;
+
+	default:
+		switch (leaderboardType) {
+		case ShootingGallery:
+			query = topPlayersScoreQuery; // Shooting gallery is based on the highest score.
+			break;
+		case FootRace:
+			query = topPlayersTimeQuery; // The higher your time, the better for FootRace.
+			break;
+		case Survival:
+			query = classicSurvivalScoring ? topPlayersTimeQuery : topPlayersScoreQuery;
+			break;
+		case SurvivalNS:
+			query = topPlayersScoreQueryAsc; // BoNS is scored by highest wave (score) first, then time.
+			break;
+		default:
+			query = topPlayersTimeQueryAsc;  // MonumentRace and Racing are based on the shortest time.
+		}
+	}
+
+	auto* statement = Database::CreatePreppedStmt(query);
+	statement->setUInt(1, gameID);
+
+	// Only the standings and friends leaderboards require the character ID to be set
+	if (infoType == Standings || infoType == Friends) {
+		auto characterID = 0;
+
+		const auto* player = EntityManager::Instance()->GetEntity(playerID);
+		if (player != nullptr) {
+			auto* character = player->GetCharacter();
+			if (character != nullptr)
+				characterID = character->GetID();
+		}
+
+		statement->setUInt64(2, characterID);
+	}
+
+	auto* res = statement->executeQuery();
+
+	std::vector<LeaderboardEntry> entries{};
+
+	uint32_t index = 0;
+	while (res->next()) {
+		LeaderboardEntry entry;
+		entry.playerID = res->getUInt64(4);
+		entry.playerName = res->getString(5);
+		entry.time = res->getUInt(1);
+		entry.score = res->getUInt(2);
+		entry.placement = res->getUInt(3);
+		entry.lastPlayed = res->getUInt(6);
+
+		entries.push_back(entry);
+		index++;
+	}
+
+	delete res;
+	delete statement;
+
+	return new Leaderboard(gameID, infoType, weekly, entries, playerID, leaderboardType);
 }
 
-Leaderboard::Type LeaderboardManager::GetLeaderboardType(const GameID gameID) {
-	auto lookup = leaderboardCache.find(gameID);
-	if (lookup != leaderboardCache.end()) return lookup->second;
+void LeaderboardManager::SendLeaderboard(uint32_t gameID, InfoType infoType, bool weekly, LWOOBJID targetID,
+	LWOOBJID playerID) {
+	const auto* leaderboard = LeaderboardManager::GetLeaderboard(gameID, infoType, weekly, playerID);
+	leaderboard->Send(targetID);
+	delete leaderboard;
+}
 
+LeaderboardType LeaderboardManager::GetLeaderboardType(uint32_t gameID) {
 	auto* activitiesTable = CDClientManager::Instance().GetTable<CDActivitiesTable>();
-	std::vector<CDActivities> activities = activitiesTable->Query([gameID](const CDActivities& entry) {
-		return entry.ActivityID == gameID;
+	std::vector<CDActivities> activities = activitiesTable->Query([=](const CDActivities& entry) {
+		return (entry.ActivityID == gameID);
 		});
-	auto type = !activities.empty() ? static_cast<Leaderboard::Type>(activities.at(0).leaderboardType) : Leaderboard::Type::None;
-	leaderboardCache.insert_or_assign(gameID, type);
-	return type;
+
+	for (const auto& activity : activities) {
+		return static_cast<LeaderboardType>(activity.leaderboardType);
+	}
+
+	return LeaderboardType::None;
 }
+
+const std::string LeaderboardManager::topPlayersScoreQuery =
+"WITH leaderboard_vales AS ( "
+"        SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"RANK() OVER ( ORDER BY l.score DESC, l.time DESC, last_played ) leaderboard_rank "
+"        FROM leaderboard l "
+"INNER JOIN charinfo c ON l.character_id = c.id "
+"WHERE l.game_id = ? "
+"ORDER BY leaderboard_rank) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales LIMIT 11;";
+
+const std::string LeaderboardManager::friendsScoreQuery =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, f.friend_id, f.player_id, "
+"           RANK() OVER ( ORDER BY l.score DESC, l.time DESC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"        INNER JOIN friends f ON f.player_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"     personal_values AS ( "
+"         SELECT id as related_player_id, "
+"                GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"                GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"         FROM leaderboard_vales WHERE leaderboard_vales.id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank AND (player_id = related_player_id OR friend_id = related_player_id);";
+
+const std::string LeaderboardManager::standingsScoreQuery =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"           RANK() OVER ( ORDER BY l.score DESC, l.time DESC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"personal_values AS ( "
+"    SELECT GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"           GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"    FROM leaderboard_vales WHERE id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank;";
+
+const std::string LeaderboardManager::topPlayersScoreQueryAsc =
+"WITH leaderboard_vales AS ( "
+"        SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"RANK() OVER ( ORDER BY l.score DESC, l.time ASC, last_played ) leaderboard_rank "
+"        FROM leaderboard l "
+"INNER JOIN charinfo c ON l.character_id = c.id "
+"WHERE l.game_id = ? "
+"ORDER BY leaderboard_rank) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales LIMIT 11;";
+
+const std::string LeaderboardManager::friendsScoreQueryAsc =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, f.friend_id, f.player_id, "
+"           RANK() OVER ( ORDER BY l.score DESC, l.time ASC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"        INNER JOIN friends f ON f.player_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"     personal_values AS ( "
+"         SELECT id as related_player_id, "
+"                GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"                GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"         FROM leaderboard_vales WHERE leaderboard_vales.id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank AND (player_id = related_player_id OR friend_id = related_player_id);";
+
+const std::string LeaderboardManager::standingsScoreQueryAsc =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"           RANK() OVER ( ORDER BY l.score DESC, l.time ASC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"personal_values AS ( "
+"    SELECT GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"           GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"    FROM leaderboard_vales WHERE id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank;";
+
+const std::string LeaderboardManager::topPlayersTimeQuery =
+"WITH leaderboard_vales AS ( "
+"        SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"RANK() OVER ( ORDER BY l.time DESC, l.score DESC, last_played ) leaderboard_rank "
+"        FROM leaderboard l "
+"INNER JOIN charinfo c ON l.character_id = c.id "
+"WHERE l.game_id = ? "
+"ORDER BY leaderboard_rank) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales LIMIT 11;";
+
+const std::string LeaderboardManager::friendsTimeQuery =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, f.friend_id, f.player_id, "
+"           RANK() OVER ( ORDER BY l.time DESC, l.score DESC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"        INNER JOIN friends f ON f.player_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"     personal_values AS ( "
+"         SELECT id as related_player_id, "
+"                GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"                GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"         FROM leaderboard_vales WHERE leaderboard_vales.id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank AND (player_id = related_player_id OR friend_id = related_player_id);";
+
+const std::string LeaderboardManager::standingsTimeQuery =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"           RANK() OVER ( ORDER BY l.time DESC, l.score DESC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"personal_values AS ( "
+"    SELECT GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"           GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"    FROM leaderboard_vales WHERE id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank;";
+
+const std::string LeaderboardManager::topPlayersTimeQueryAsc =
+"WITH leaderboard_vales AS ( "
+"        SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"RANK() OVER ( ORDER BY l.time ASC, l.score DESC, last_played ) leaderboard_rank "
+"        FROM leaderboard l "
+"INNER JOIN charinfo c ON l.character_id = c.id "
+"WHERE l.game_id = ? "
+"ORDER BY leaderboard_rank) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales LIMIT 11;";
+
+const std::string LeaderboardManager::friendsTimeQueryAsc =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, f.friend_id, f.player_id, "
+"           RANK() OVER ( ORDER BY l.time ASC, l.score DESC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"        INNER JOIN friends f ON f.player_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"     personal_values AS ( "
+"         SELECT id as related_player_id, "
+"                GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"                GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"         FROM leaderboard_vales WHERE leaderboard_vales.id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank AND (player_id = related_player_id OR friend_id = related_player_id);";
+
+const std::string LeaderboardManager::standingsTimeQueryAsc =
+"WITH leaderboard_vales AS ( "
+"    SELECT l.time, l.score, UNIX_TIMESTAMP(l.last_played) last_played, c.name, c.id, "
+"           RANK() OVER ( ORDER BY l.time ASC, l.score DESC, last_played ) leaderboard_rank "
+"    FROM leaderboard l "
+"        INNER JOIN charinfo c ON l.character_id = c.id "
+"    WHERE l.game_id = ? "
+"    ORDER BY leaderboard_rank), "
+"personal_values AS ( "
+"    SELECT GREATEST(CAST(leaderboard_rank AS SIGNED) - 5, 1) AS min_rank, "
+"           GREATEST(leaderboard_rank + 5, 11) AS max_rank "
+"    FROM leaderboard_vales WHERE id = ? LIMIT 1) "
+"SELECT time, score, leaderboard_rank, id, name, last_played "
+"FROM leaderboard_vales, personal_values "
+"WHERE leaderboard_rank BETWEEN min_rank AND max_rank;";

dGame/LeaderboardManager.h

@@ -1,134 +1,80 @@
-#ifndef __LEADERBOARDMANAGER__H__
-#define __LEADERBOARDMANAGER__H__
-
-#include <map>
-#include <memory>
-#include <string_view>
+#pragma once
 #include <vector>
-
-#include "Singleton.h"
+#include <climits>
 #include "dCommonVars.h"
-#include "LDFFormat.h"
 
-namespace sql {
-	class ResultSet;
+struct LeaderboardEntry {
+	uint64_t playerID;
+	std::string playerName;
+	uint32_t time;
+	uint32_t score;
+	uint32_t placement;
+	time_t lastPlayed;
 };
 
-namespace RakNet {
-	class BitStream;
+enum InfoType : uint32_t {
+	Top,     // Top 11 all time players
+	Standings, // Ranking of the current player
+	Friends    // Ranking between friends
 };
 
-class Score {
-public:
-	Score() {
-		primaryScore = 0;
-		secondaryScore = 0;
-		tertiaryScore = 0;
-	}
-	Score(const float primaryScore, const float secondaryScore = 0, const float tertiaryScore = 0) {
-		this->primaryScore = primaryScore;
-		this->secondaryScore = secondaryScore;
-		this->tertiaryScore = tertiaryScore;
-	}
-	bool operator<(const Score& rhs) const {
-		return primaryScore < rhs.primaryScore || (primaryScore == rhs.primaryScore && secondaryScore < rhs.secondaryScore) || (primaryScore == rhs.primaryScore && secondaryScore == rhs.secondaryScore && tertiaryScore < rhs.tertiaryScore);
-	}
-	bool operator>(const Score& rhs) const {
-		return primaryScore > rhs.primaryScore || (primaryScore == rhs.primaryScore && secondaryScore > rhs.secondaryScore) || (primaryScore == rhs.primaryScore && secondaryScore == rhs.secondaryScore && tertiaryScore > rhs.tertiaryScore);
-	}
-	void SetPrimaryScore(const float score) { primaryScore = score; }
-	float GetPrimaryScore() const { return primaryScore; }
-
-	void SetSecondaryScore(const float score) { secondaryScore = score; }
-	float GetSecondaryScore() const { return secondaryScore; }
-
-	void SetTertiaryScore(const float score) { tertiaryScore = score; }
-	float GetTertiaryScore() const { return tertiaryScore; }
-private:
-	float primaryScore;
-	float secondaryScore;
-	float tertiaryScore;
+enum LeaderboardType : uint32_t {
+	ShootingGallery,
+	Racing,
+	MonumentRace,
+	FootRace,
+	Survival = 5,
+	SurvivalNS = 6,
+	None = UINT_MAX
 };
 
-using GameID = uint32_t;
-
 class Leaderboard {
 public:
-
-	// Enums for leaderboards
-	enum InfoType : uint32_t {
-		Top,     // Top 11 all time players
-		MyStanding, // Ranking of the current player
-		Friends    // Ranking between friends
-	};
-
-	enum Type : uint32_t {
-		ShootingGallery,
-		Racing,
-		MonumentRace,
-		FootRace,
-		UnusedLeaderboard4, // There is no 4 defined anywhere in the cdclient, but it takes a Score.
-		Survival,
-		SurvivalNS,
-		Donations,
-		None
-	};
-	Leaderboard() = delete;
-	Leaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, LWOOBJID relatedPlayer, const Leaderboard::Type = None);
-
-	~Leaderboard();
-
-	/**
-	 * @brief Resets the leaderboard state and frees its allocated memory
-	 * 
-	 */
-	void Clear();
-
-	/**
-	 * Serialize the Leaderboard to a BitStream
-	 *
-	 * Expensive!  Leaderboards are very string intensive so be wary of performatnce calling this method.
-	 */
-	void Serialize(RakNet::BitStream* bitStream) const;
-
-	/**
-	 * Builds the leaderboard from the database based on the associated gameID
-	 *
-	 * @param resultStart The index to start the leaderboard at. Zero indexed.
-	 * @param resultEnd The index to end the leaderboard at. Zero indexed.
-	 */
-	void SetupLeaderboard(bool weekly, uint32_t resultStart = 0, uint32_t resultEnd = 10);
-
-	/**
-	 * Sends the leaderboard to the client specified by targetID.
-	 */
-	void Send(const LWOOBJID targetID) const;
-
-	// Helper function to get the columns, ordering and insert format for a leaderboard
-	static const std::string_view GetOrdering(Type leaderboardType);
+	Leaderboard(uint32_t gameID, uint32_t infoType, bool weekly, std::vector<LeaderboardEntry> entries,
+		LWOOBJID relatedPlayer = LWOOBJID_EMPTY, LeaderboardType = None);
+	std::vector<LeaderboardEntry> GetEntries();
+	[[nodiscard]] std::u16string ToString() const;
+	[[nodiscard]] uint32_t GetGameID() const;
+	[[nodiscard]] uint32_t GetInfoType() const;
+	void Send(LWOOBJID targetID) const;
 private:
-	// Takes the resulting query from a leaderboard lookup and converts it to the LDF we need
-	// to send it to a client.
-	void QueryToLdf(std::unique_ptr<sql::ResultSet>& rows);
-
-	using LeaderboardEntry = std::vector<LDFBaseData*>;
-	using LeaderboardEntries = std::vector<LeaderboardEntry>;
-
-	LeaderboardEntries entries;
+	std::vector<LeaderboardEntry> entries{};
 	LWOOBJID relatedPlayer;
-	GameID gameID;
-	InfoType infoType;
-	Leaderboard::Type leaderboardType;
+	uint32_t gameID;
+	uint32_t infoType;
+	LeaderboardType leaderboardType;
 	bool weekly;
 };
 
-namespace LeaderboardManager {
-	void SendLeaderboard(const GameID gameID, const Leaderboard::InfoType infoType, const bool weekly, const LWOOBJID playerID, const LWOOBJID targetID, const uint32_t resultStart = 0, const uint32_t resultEnd = 10);
+class LeaderboardManager {
+public:
+	static LeaderboardManager* Instance() {
+		if (address == nullptr)
+			address = new LeaderboardManager;
+		return address;
+	}
+	static void SendLeaderboard(uint32_t gameID, InfoType infoType, bool weekly, LWOOBJID targetID,
+		LWOOBJID playerID = LWOOBJID_EMPTY);
+	static Leaderboard* GetLeaderboard(uint32_t gameID, InfoType infoType, bool weekly, LWOOBJID playerID = LWOOBJID_EMPTY);
+	static void SaveScore(LWOOBJID playerID, uint32_t gameID, uint32_t score, uint32_t time);
+	static LeaderboardType GetLeaderboardType(uint32_t gameID);
+private:
+	static LeaderboardManager* address;
 
-	void SaveScore(const LWOOBJID& playerID, const GameID activityId, const float primaryScore, const float secondaryScore = 0, const float tertiaryScore = 0);
+	// Modified 12/12/2021: Existing queries were renamed to be more descriptive.
+	static const std::string topPlayersScoreQuery;
+	static const std::string friendsScoreQuery;
+	static const std::string standingsScoreQuery;
+	static const std::string topPlayersScoreQueryAsc;
+	static const std::string friendsScoreQueryAsc;
+	static const std::string standingsScoreQueryAsc;
 
-	Leaderboard::Type GetLeaderboardType(const GameID gameID);
-	extern std::map<GameID, Leaderboard::Type> leaderboardCache;
+	// Added 12/12/2021: Queries dictated by time are needed for certain minigames.
+	static const std::string topPlayersTimeQuery;
+	static const std::string friendsTimeQuery;
+	static const std::string standingsTimeQuery;
+	static const std::string topPlayersTimeQueryAsc;
+	static const std::string friendsTimeQueryAsc;
+	static const std::string standingsTimeQueryAsc;
 };
 
-#endif  //!__LEADERBOARDMANAGER__H__

dGame/Player.cpp

@@ -62,7 +62,7 @@ void Player::SetSystemAddress(const SystemAddress& value) {
 void Player::SetRespawnPos(const NiPoint3 position) {
 	m_respawnPos = position;
 
-	m_Character->SetRespawnPoint(Game::zoneManager->GetZone()->GetWorldID(), position);
+	m_Character->SetRespawnPoint(dZoneManager::Instance()->GetZone()->GetWorldID(), position);
 }
 
 void Player::SetRespawnRot(const NiQuaternion rotation) {
@@ -85,7 +85,7 @@ void Player::SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId) {
 	const auto objid = GetObjectID();
 
 	ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, zoneId, cloneId, false, [objid](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string serverIP, uint16_t serverPort) {
-		auto* entity = Game::entityManager->GetEntity(objid);
+		auto* entity = EntityManager::Instance()->GetEntity(objid);
 
 		if (entity == nullptr) {
 			return;
@@ -108,7 +108,7 @@ void Player::SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId) {
 
 		WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
 
-		Game::entityManager->DestructEntity(entity);
+		EntityManager::Instance()->DestructEntity(entity);
 		return;
 		});
 }
@@ -135,13 +135,13 @@ void Player::RemoveLimboConstruction(LWOOBJID objectId) {
 
 void Player::ConstructLimboEntities() {
 	for (const auto objectId : m_LimboConstructions) {
-		auto* entity = Game::entityManager->GetEntity(objectId);
+		auto* entity = EntityManager::Instance()->GetEntity(objectId);
 
 		if (entity == nullptr) {
 			continue;
 		}
 
-		Game::entityManager->ConstructEntity(entity, m_SystemAddress);
+		EntityManager::Instance()->ConstructEntity(entity, m_SystemAddress);
 	}
 
 	m_LimboConstructions.clear();
@@ -224,7 +224,7 @@ Player* Player::GetPlayer(const SystemAddress& sysAddr) {
 }
 
 Player* Player::GetPlayer(const std::string& name) {
-	const auto characters = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::CHARACTER);
+	const auto characters = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::CHARACTER);
 
 	for (auto* character : characters) {
 		if (!character->IsPlayer()) continue;
@@ -269,7 +269,7 @@ Player::~Player() {
 			continue;
 		}
 
-		auto* entity = Game::entityManager->GetGhostCandidate(id);
+		auto* entity = EntityManager::Instance()->GetGhostCandidate(id);
 
 		if (entity != nullptr) {
 			entity->SetObservers(entity->GetObservers() - 1);
@@ -285,12 +285,12 @@ Player::~Player() {
 	}
 
 	if (IsPlayer()) {
-		Entity* zoneControl = Game::entityManager->GetZoneControlEntity();
+		Entity* zoneControl = EntityManager::Instance()->GetZoneControlEntity();
 		for (CppScripts::Script* script : CppScripts::GetEntityScripts(zoneControl)) {
 			script->OnPlayerExit(zoneControl, this);
 		}
 
-		std::vector<Entity*> scriptedActs = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
+		std::vector<Entity*> scriptedActs = EntityManager::Instance()->GetEntitiesByComponent(eReplicaComponentType::SCRIPTED_ACTIVITY);
 		for (Entity* scriptEntity : scriptedActs) {
 			if (scriptEntity->GetObjectID() != zoneControl->GetObjectID()) { // Don't want to trigger twice on instance worlds
 				for (CppScripts::Script* script : CppScripts::GetEntityScripts(scriptEntity)) {

dGame/TradingManager.cpp

@@ -40,11 +40,11 @@ LWOOBJID Trade::GetParticipantB() const {
 }
 
 Entity* Trade::GetParticipantAEntity() const {
-	return Game::entityManager->GetEntity(m_ParticipantA);
+	return EntityManager::Instance()->GetEntity(m_ParticipantA);
 }
 
 Entity* Trade::GetParticipantBEntity() const {
-	return Game::entityManager->GetEntity(m_ParticipantB);
+	return EntityManager::Instance()->GetEntity(m_ParticipantB);
 }
 
 void Trade::SetCoins(LWOOBJID participant, uint64_t coins) {
@@ -156,21 +156,21 @@ void Trade::Complete() {
 	}
 
 	// Now actually do the trade.
-	characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::TRADE);
-	characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::TRADE);
+	characterA->SetCoins(characterA->GetCoins() - m_CoinsA + m_CoinsB, eLootSourceType::LOOT_SOURCE_TRADE);
+	characterB->SetCoins(characterB->GetCoins() - m_CoinsB + m_CoinsA, eLootSourceType::LOOT_SOURCE_TRADE);
 
 	for (const auto& tradeItem : m_ItemsA) {
 		auto* itemToRemove = inventoryA->FindItemById(tradeItem.itemId);
 		if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
 		missionsA->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
-		inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
+		inventoryB->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
 	}
 
 	for (const auto& tradeItem : m_ItemsB) {
 		auto* itemToRemove = inventoryB->FindItemById(tradeItem.itemId);
 		if (itemToRemove) itemToRemove->SetCount(itemToRemove->GetCount() - tradeItem.itemCount);
 		missionsB->Progress(eMissionTaskType::GATHER, tradeItem.itemLot, LWOOBJID_EMPTY, "", -tradeItem.itemCount);
-		inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::TRADE);
+		inventoryA->AddItem(tradeItem.itemLot, tradeItem.itemCount, eLootSourceType::LOOT_SOURCE_TRADE);
 	}
 
 	characterA->SaveXMLToDatabase();

dGame/User.cpp

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

dGame/User.h

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

dGame/UserManager.cpp

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