Some fixes to LUA so that it complies

This LUA scripting implementation uses the sol header only C++ wrapper for the native LUA libraries.

The API does not follow the original LU scripting. Each instance of a script is in its own LUA-State, and has 'self' as a global. There are hooks to all the implemented CppScript methods, as well as a subset of the entity functionallity. Has to be expanded upon.

This is local work which has been sitting for awhile; thought someone might like to take a look at it.

.env.example

@@ -14,4 +14,4 @@ EXTERNAL_IP=localhost
 MARIADB_USER=darkflame
 MARIADB_PASSWORD=SECRET_VALUE_CHANGE_ME
 MARIADB_ROOT_PASSWORD=SECRET_VALUE_CHANGE_ME
-MARIADB_DATABASE=darkflame
+MARIADB_DATABASE=darkflame

.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,70 +97,26 @@ 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")
-
-# if navmeshes directory does not exist, create it
-if (NOT EXISTS ${PROJECT_BINARY_DIR}/navmeshes)
-	file(MAKE_DIRECTORY ${PROJECT_BINARY_DIR}/navmeshes)
-endif()
 
 # Copy navmesh data on first build and extract it
-configure_file(
-	${CMAKE_SOURCE_DIR}/resources/navmeshes.zip ${PROJECT_BINARY_DIR}/navmeshes.zip
-	COPYONLY
-)
+if (NOT EXISTS ${PROJECT_BINARY_DIR}/navmeshes/)
+	configure_file(
+		${CMAKE_SOURCE_DIR}/resources/navmeshes.zip ${PROJECT_BINARY_DIR}/navmeshes.zip
+		COPYONLY
+	)
 
-file(ARCHIVE_EXTRACT INPUT ${PROJECT_BINARY_DIR}/navmeshes.zip DESTINATION ${PROJECT_BINARY_DIR}/navmeshes)
-file(REMOVE ${PROJECT_BINARY_DIR}/navmeshes.zip)
+	file(ARCHIVE_EXTRACT INPUT ${PROJECT_BINARY_DIR}/navmeshes.zip)
+	file(REMOVE ${PROJECT_BINARY_DIR}/navmeshes.zip)
+endif()
 
 # Copy vanity files on first build
 set(VANITY_FILES "CREDITS.md" "INFO.md" "TESTAMENT.md" "NPC.xml")
@@ -214,12 +170,7 @@ set(INCLUDED_DIRECTORIES
 	"dNavigation/dTerrain"
 	"dZoneManager"
 	"dDatabase"
-	"dDatabase/CDClientDatabase"
-	"dDatabase/CDClientDatabase/CDClientTables"
-	"dDatabase/GameDatabase"
-	"dDatabase/GameDatabase/ITables"
-	"dDatabase/GameDatabase/MySQL"
-	"dDatabase/GameDatabase/MySQL/Tables"
+	"dDatabase/Tables"
 	"dNet"
 	"dScripts"
 	"dScripts/02_server"
@@ -304,6 +255,11 @@ set(INCLUDED_DIRECTORIES
 	"tests/dGameTests/dComponentsTests"
 	)
 
+if(__include_lua__)
+	set(INCLUDED_DIRECTORIES ${INCLUDED_DIRECTORIES} "dLua")
+	set(INCLUDED_DIRECTORIES ${INCLUDED_DIRECTORIES} "dLua/sol")
+endif()
+
 # Add system specfic includes for Apple, Windows and Other Unix OS' (including Linux)
 if (APPLE)
 	include_directories("/usr/local/include/")
@@ -334,9 +290,8 @@ add_subdirectory(thirdparty)
 file(
 	GLOB HEADERS_DDATABASE
 	LIST_DIRECTORIES false
-	${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/*.h
-	${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables/*.h
-	${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables/*.h
+	${PROJECT_SOURCE_DIR}/dDatabase/*.h
+	${PROJECT_SOURCE_DIR}/dDatabase/Tables/*.h
 	${PROJECT_SOURCE_DIR}/thirdparty/SQLite/*.h
 )
 
@@ -367,6 +322,7 @@ add_subdirectory(dDatabase)
 add_subdirectory(dChatFilter)
 add_subdirectory(dNet)
 add_subdirectory(dScripts) # Add for dGame to use
+add_subdirectory(dLua)
 add_subdirectory(dGame)
 add_subdirectory(dZoneManager)
 add_subdirectory(dNavigation)

CMakeVariables.txt

@@ -1,8 +1,12 @@
 PROJECT_VERSION_MAJOR=1
-PROJECT_VERSION_MINOR=1
-PROJECT_VERSION_PATCH=1
+PROJECT_VERSION_MINOR=0
+PROJECT_VERSION_PATCH=4
 # LICENSE
 LICENSE=AGPL-3.0
+# The network version.
+# 171023 - Darkflame Universe client
+# 171022 - Unmodded client
+NET_VERSION=171022
 # Debugging
 # Set __dynamic to 1 to enable the -rdynamic flag for the linker, yielding some symbols in crashlogs.
 __dynamic=1
@@ -18,5 +22,3 @@ __maria_db_connector_compile_jobs__=1
 __enable_testing__=1
 # The path to OpenSSL.  Change this if your OpenSSL install path is different than the default.
 OPENSSL_ROOT_DIR=/usr/local/opt/openssl@3/
-# Uncomment the below line to cache the entire CDClient into memory
-# CDCLIENT_CACHE_ALL=1

README.md

@@ -23,9 +23,6 @@ We do not recommend hosting public servers. Darkflame Universe is intended for s
 ### Supply of resource files
 Darkflame Universe is a server emulator and does not distribute any LEGO® Universe files. A separate game client is required to setup this server emulator and play the game, which we cannot supply. Users are strongly suggested to refer to the safe checksums listed [here](#verifying-your-client-files) to see if a client will work.
 
-## Step by step walkthrough for a single-player server
-If you would like a setup for a single player server only on a Windows machine, use the [Native Windows Setup Guide by HailStorm](https://gist.github.com/HailStorm32/169df65a47a104199b5cc57d10fa57de) and skip this README.
-
 ## Steps to setup server
 * [Clone this repository](#clone-the-repository)
 * [Install dependencies](#install-dependencies)
@@ -182,7 +179,7 @@ If you would like to build the server faster, append `-j<number>` where number i
 ### Notes
 Depending on your operating system, you may need to adjust some pre-processor defines in [CMakeVariables.txt](./CMakeVariables.txt) before building:
 * If you are on MacOS, ensure OPENSSL_ROOT_DIR is pointing to the openssl root directory.
-* If you are using a Darkflame Universe client, ensure `client_net_version` in `build/sharedconfig.ini` is changed to 171023.
+* If you are using a Darkflame Universe client, ensure NET_VERSION is changed to 171023.
 
 ## Configuring your server
 This server has a few steps that need to be taken to configure the server for your use case.
@@ -227,44 +224,6 @@ sudo setcap 'cap_net_bind_service=+ep' AuthServer
 ```
 and then go to `build/masterconfig.ini` and change `use_sudo_auth` to 0.
 
-### Linux Service
-If you are running this on a linux based system, it will use your terminal to run the program interactively, preventing you using it for other tasks and requiring it to be open to run the server.  
-_Note: You could use screen or tmux instead for virtual terminals_  
-To run the server non-interactively, we can use a systemctl service by copying the following file:  
-```shell
-cp ./systemd.example /etc/systemd/system/darkflame.service
-```  
-
-Make sure to edit the file in `/etc/systemd/system/darkflame.service` and change the:  
-- `User` and `Group` to the user that runs the darkflame server.  
-- `ExecPath` to the full file path of the server executable.  
-
-To register, enable and start the service use the following commands:
-
-- Reload the systemd manager configuration to make it aware of the new service file:
-```shell
-systemctl daemon-reload
-```
-- Start the service:
-```shell
-systemctl start darkflame.service
-```
-- Enable OR disable the service to start on boot using:
-```shell
-systemctl enable darkflame.service
-systemctl disable darkflame.service
-```
-- Verify that the service is running without errors:
-```shell
-systemctl status darkflame.service
-```
-- You can also restart, stop, or check the logs of the service using journalctl
-```shell
-systemctl restart darkflame.service
-systemctl stop darkflame.service
-journalctl -xeu darkflame.service
-```
-
 ### First admin user
 Run `MasterServer -a` to get prompted to create an admin account. This method is only intended for the system administrator as a means to get started, do NOT use this method to create accounts for other users!
 
@@ -326,7 +285,6 @@ Below are known good SHA256 checksums of the client:
 * `0d862f71eedcadc4494c4358261669721b40b2131101cbd6ef476c5a6ec6775b` (unpacked client, includes extra locales, rar compressed)
 
 If the returned hash matches one of the lines above then you can continue with setting up the server. If you are using a fully downloaded and complete client from live, then it will work, but the hash above may not match. Otherwise you must obtain a full install of LEGO® Universe 1.10.64.
-You must also make absolutely sure your LEGO Universe client is not in a Windows OneDrive. DLU is not and will not support a client being stored in a OneDrive, so ensure you have moved the client outside of that location.
 
 ### Darkflame Universe Client
 Darkflame Universe clients identify themselves using a higher version number than the regular live clients out there.
@@ -380,7 +338,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

@@ -7,7 +7,7 @@
 //DLU Includes:
 #include "dCommonVars.h"
 #include "dServer.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "Database.h"
 #include "dConfig.h"
 #include "Diagnostics.h"
@@ -25,14 +25,13 @@
 
 #include "Game.h"
 namespace Game {
-	Logger* logger = nullptr;
+	dLogger* logger = nullptr;
 	dServer* server = nullptr;
 	dConfig* config = nullptr;
 	bool shouldShutdown = false;
-	std::mt19937 randomEngine;
 }
 
-Logger* SetupLogger();
+dLogger* SetupLogger();
 void HandlePacket(Packet* packet);
 
 int main(int argc, char** argv) {
@@ -51,14 +50,20 @@ int main(int argc, char** argv) {
 	Game::logger->SetLogToConsole(Game::config->GetValue("log_to_console") != "0");
 	Game::logger->SetLogDebugStatements(Game::config->GetValue("log_debug_statements") == "1");
 
-	LOG("Starting Auth server...");
-	LOG("Version: %i.%i", PROJECT_VERSION_MAJOR, PROJECT_VERSION_MINOR);
-	LOG("Compiled on: %s", __TIMESTAMP__);
+	Game::logger->Log("AuthServer", "Starting Auth server...");
+	Game::logger->Log("AuthServer", "Version: %i.%i", PROJECT_VERSION_MAJOR, PROJECT_VERSION_MINOR);
+	Game::logger->Log("AuthServer", "Compiled on: %s", __TIMESTAMP__);
+
+	//Connect to the MySQL Database
+	std::string mysql_host = Game::config->GetValue("mysql_host");
+	std::string mysql_database = Game::config->GetValue("mysql_database");
+	std::string mysql_username = Game::config->GetValue("mysql_username");
+	std::string mysql_password = Game::config->GetValue("mysql_password");
 
 	try {
-		Database::Connect();
+		Database::Connect(mysql_host, mysql_database, mysql_username, mysql_password);
 	} catch (sql::SQLException& ex) {
-		LOG("Got an error while connecting to the database: %s", ex.what());
+		Game::logger->Log("AuthServer", "Got an error while connecting to the database: %s", ex.what());
 		Database::Destroy("AuthServer");
 		delete Game::server;
 		delete Game::logger;
@@ -68,14 +73,15 @@ int main(int argc, char** argv) {
 	//Find out the master's IP:
 	std::string masterIP;
 	uint32_t masterPort = 1500;
-
-	auto masterInfo = Database::Get()->GetMasterInfo();
-	if (masterInfo) {
-		masterIP = masterInfo->ip;
-		masterPort = masterInfo->port;
+	sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		masterIP = res->getString(1).c_str();
+		masterPort = res->getInt(2);
 	}
 
-	Game::randomEngine = std::mt19937(time(0));
+	delete res;
+	delete stmt;
 
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
 	uint32_t maxClients = 50;
@@ -94,8 +100,6 @@ int main(int argc, char** argv) {
 	uint32_t framesSinceMasterDisconnect = 0;
 	uint32_t framesSinceLastSQLPing = 0;
 
-	AuthPackets::LoadClaimCodes();
-	
 	while (!Game::shouldShutdown) {
 		//Check if we're still connected to master:
 		if (!Game::server->GetIsConnectedToMaster()) {
@@ -127,12 +131,16 @@ int main(int argc, char** argv) {
 			//Find out the master's IP for absolutely no reason:
 			std::string masterIP;
 			uint32_t masterPort;
-			auto masterInfo = Database::Get()->GetMasterInfo();
-			if (masterInfo) {
-				masterIP = masterInfo->ip;
-				masterPort = masterInfo->port;
+			sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+			auto res = stmt->executeQuery();
+			while (res->next()) {
+				masterIP = res->getString(1).c_str();
+				masterPort = res->getInt(2);
 			}
 
+			delete res;
+			delete stmt;
+
 			framesSinceLastSQLPing = 0;
 		} else framesSinceLastSQLPing++;
 
@@ -150,7 +158,7 @@ int main(int argc, char** argv) {
 	return EXIT_SUCCESS;
 }
 
-Logger* SetupLogger() {
+dLogger* SetupLogger() {
 	std::string logPath = (BinaryPathFinder::GetBinaryDir() / ("logs/AuthServer_" + std::to_string(time(nullptr)) + ".log")).string();
 	bool logToConsole = false;
 	bool logDebugStatements = false;
@@ -159,7 +167,7 @@ Logger* SetupLogger() {
 	logDebugStatements = true;
 #endif
 
-	return new Logger(logPath, logToConsole, logDebugStatements);
+	return new dLogger(logPath, logToConsole, logDebugStatements);
 }
 
 void HandlePacket(Packet* packet) {

dChatFilter/dChatFilter.cpp

@@ -8,7 +8,7 @@
 #include <regex>
 
 #include "dCommonVars.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "dConfig.h"
 #include "Database.h"
 #include "Game.h"
@@ -32,11 +32,15 @@ dChatFilter::dChatFilter(const std::string& filepath, bool dontGenerateDCF) {
 	}
 
 	//Read player names that are ok as well:
-	auto approvedNames = Database::Get()->GetApprovedCharacterNames();
-	for (auto& name : approvedNames) {
-		std::transform(name.begin(), name.end(), name.begin(), ::tolower); //Transform to lowercase
-		m_ApprovedWords.push_back(CalculateHash(name));
+	auto stmt = Database::CreatePreppedStmt("select name from charinfo;");
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		std::string line = res->getString(1).c_str();
+		std::transform(line.begin(), line.end(), line.begin(), ::tolower); //Transform to lowercase
+		m_ApprovedWords.push_back(CalculateHash(line));
 	}
+	delete res;
+	delete stmt;
 }
 
 dChatFilter::~dChatFilter() {
@@ -140,7 +144,7 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::
 			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
-		position += originalSegment.length() + 1;
+		position += segment.length() + 1;
 	}
 
 	return listOfBadSegments;

dChatServer/CMakeLists.txt

@@ -1,5 +1,4 @@
 set(DCHATSERVER_SOURCES
-	"ChatIgnoreList.cpp"
 	"ChatPacketHandler.cpp"
 	"PlayerContainer.cpp"
 )

dChatServer/ChatIgnoreList.cpp

@@ -1,173 +0,0 @@
-#include "ChatIgnoreList.h"
-#include "PlayerContainer.h"
-#include "eChatInternalMessageType.h"
-#include "BitStreamUtils.h"
-#include "PacketUtils.h"
-#include "Game.h"
-#include "Logger.h"
-#include "eObjectBits.h"
-
-#include "Database.h"
-
-// A note to future readers, The client handles all the actual ignoring logic:
-// not allowing teams, rejecting DMs, friends requets etc.
-// The only thing not auto-handled is instance activities force joining the team on the server.
-
-void WriteOutgoingReplyHeader(RakNet::BitStream& bitStream, const LWOOBJID& receivingPlayer, const ChatIgnoreList::Response type) {
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(receivingPlayer);
-
-	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, type);
-}
-
-void ChatIgnoreList::GetIgnoreList(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerId;
-	inStream.Read(playerId);
-
-	auto* receiver = Game::playerContainer.GetPlayerData(playerId);
-	if (!receiver) {
-		LOG("Tried to get ignore list, but player %llu not found in container", playerId);
-		return;
-	}
-
-	if (!receiver->ignoredPlayers.empty()) {
-		LOG_DEBUG("Player %llu already has an ignore list", playerId);
-		return;
-	}
-
-	auto ignoreList = Database::Get()->GetIgnoreList(static_cast<uint32_t>(playerId));
-	if (ignoreList.empty()) {
-		LOG_DEBUG("Player %llu has no ignores", playerId);
-		return;
-	}
-
-	for (auto& ignoredPlayer : ignoreList) {
-		receiver->ignoredPlayers.push_back(IgnoreData{ ignoredPlayer.id, ignoredPlayer.name });
-		GeneralUtils::SetBit(receiver->ignoredPlayers.back().playerId, eObjectBits::CHARACTER);
-		GeneralUtils::SetBit(receiver->ignoredPlayers.back().playerId, eObjectBits::PERSISTENT);
-	}
-
-	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver->playerID, ChatIgnoreList::Response::GET_IGNORE);
-
-	bitStream.Write<uint8_t>(false); // Probably is Is Free Trial, but we don't care about that
-	bitStream.Write<uint16_t>(0); // literally spacing due to struct alignment
-
-	bitStream.Write<uint16_t>(receiver->ignoredPlayers.size());
-	for (const auto& ignoredPlayer : receiver->ignoredPlayers) {
-		bitStream.Write(ignoredPlayer.playerId);
-		bitStream.Write(LUWString(ignoredPlayer.playerName, 36));
-	}
-
-	Game::server->Send(&bitStream, packet->systemAddress, false);
-}
-
-void ChatIgnoreList::AddIgnore(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerId;
-	inStream.Read(playerId);
-
-	auto* receiver = Game::playerContainer.GetPlayerData(playerId);
-	if (!receiver) {
-		LOG("Tried to get ignore list, but player %llu not found in container", playerId);
-		return;
-	}
-
-	constexpr int32_t MAX_IGNORES = 32;
-	if (receiver->ignoredPlayers.size() > MAX_IGNORES) {
-		LOG_DEBUG("Player %llu has too many ignores", playerId);
-		return;
-	}
-
-	inStream.IgnoreBytes(4); // ignore some garbage zeros idk
-
-	LUWString toIgnoreName(33);
-	inStream.Read(toIgnoreName);
-	std::string toIgnoreStr = toIgnoreName.GetAsString();
-
-	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver->playerID, ChatIgnoreList::Response::ADD_IGNORE);
-
-	// Check if the player exists
-	LWOOBJID ignoredPlayerId = LWOOBJID_EMPTY;
-	if (toIgnoreStr == receiver->playerName || toIgnoreStr.find("[GM]") == 0) {
-		LOG_DEBUG("Player %llu tried to ignore themselves", playerId);
-
-		bitStream.Write(ChatIgnoreList::AddResponse::GENERAL_ERROR);
-	} else if (std::count(receiver->ignoredPlayers.begin(), receiver->ignoredPlayers.end(), toIgnoreStr) > 0) {
-		LOG_DEBUG("Player %llu is already ignoring %s", playerId, toIgnoreStr.c_str());
-
-		bitStream.Write(ChatIgnoreList::AddResponse::ALREADY_IGNORED);
-	} else {
-		// Get the playerId falling back to query if not online
-		auto* playerData = Game::playerContainer.GetPlayerData(toIgnoreStr);
-		if (!playerData) {
-			// Fall back to query
-			auto player = Database::Get()->GetCharacterInfo(toIgnoreStr);
-			if (!player || player->name != toIgnoreStr) {
-				LOG_DEBUG("Player %s not found", toIgnoreStr.c_str());
-			} else {
-				ignoredPlayerId = player->id;
-			}
-		} else {
-			ignoredPlayerId = playerData->playerID;
-		}
-
-		if (ignoredPlayerId != LWOOBJID_EMPTY) {
-			Database::Get()->AddIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(ignoredPlayerId));
-			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::PERSISTENT);
-
-			receiver->ignoredPlayers.push_back(IgnoreData{ ignoredPlayerId, toIgnoreStr });
-			LOG_DEBUG("Player %llu is ignoring %s", playerId, toIgnoreStr.c_str());
-
-			bitStream.Write(ChatIgnoreList::AddResponse::SUCCESS);
-		} else {
-			bitStream.Write(ChatIgnoreList::AddResponse::PLAYER_NOT_FOUND);
-		}
-	}
-
-	LUWString playerNameSend(toIgnoreStr, 33);
-	bitStream.Write(playerNameSend);
-	bitStream.Write(ignoredPlayerId);
-
-	Game::server->Send(&bitStream, packet->systemAddress, false);
-}
-
-void ChatIgnoreList::RemoveIgnore(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerId;
-	inStream.Read(playerId);
-
-	auto* receiver = Game::playerContainer.GetPlayerData(playerId);
-	if (!receiver) {
-		LOG("Tried to get ignore list, but player %llu not found in container", playerId);
-		return;
-	}
-
-	inStream.IgnoreBytes(4); // ignore some garbage zeros idk
-
-	LUWString removedIgnoreName(33);
-	inStream.Read(removedIgnoreName);
-	std::string removedIgnoreStr = removedIgnoreName.GetAsString();
-
-	auto toRemove = std::remove(receiver->ignoredPlayers.begin(), receiver->ignoredPlayers.end(), removedIgnoreStr);
-	if (toRemove == receiver->ignoredPlayers.end()) {
-		LOG_DEBUG("Player %llu is not ignoring %s", playerId, removedIgnoreStr.c_str());
-		return;
-	}
-
-	Database::Get()->RemoveIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(toRemove->playerId));
-	receiver->ignoredPlayers.erase(toRemove, receiver->ignoredPlayers.end());
-
-	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver->playerID, ChatIgnoreList::Response::REMOVE_IGNORE);
-
-	bitStream.Write<int8_t>(0);
-	LUWString playerNameSend(removedIgnoreStr, 33);
-	bitStream.Write(playerNameSend);
-
-	Game::server->Send(&bitStream, packet->systemAddress, false);
-}

dChatServer/ChatIgnoreList.h

@@ -1,27 +0,0 @@
-#ifndef __CHATIGNORELIST__H__
-#define __CHATIGNORELIST__H__
-
-struct Packet;
-
-#include <cstdint>
-
-namespace ChatIgnoreList {
-	void GetIgnoreList(Packet* packet);
-	void AddIgnore(Packet* packet);
-	void RemoveIgnore(Packet* packet);
-
-	enum class Response : uint8_t {
-		ADD_IGNORE = 32,
-		REMOVE_IGNORE = 33,
-		GET_IGNORE = 34,
-	};
-
-	enum class AddResponse : uint8_t {
-		SUCCESS,
-		ALREADY_IGNORED,
-		PLAYER_NOT_FOUND,
-		GENERAL_ERROR,
-	};
-};
-
-#endif  //!__CHATIGNORELIST__H__

dChatServer/ChatPacketHandler.cpp

@@ -3,11 +3,10 @@
 #include "Database.h"
 #include <vector>
 #include "PacketUtils.h"
-#include "BitStreamUtils.h"
 #include "Game.h"
 #include "dServer.h"
 #include "GeneralUtils.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "eAddFriendResponseCode.h"
 #include "eAddFriendResponseType.h"
 #include "RakString.h"
@@ -19,29 +18,47 @@
 #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 = Game::playerContainer.GetPlayerData(playerID);
+	auto player = playerContainer.GetPlayerData(playerID);
 	if (!player) return;
 
-	auto friendsList = Database::Get()->GetFriendsList(playerID);
-	for (const auto& friendData : friendsList) {
+	//Get our friends list from the Db.  Using a derived table since the friend of a player can be in either column.
+	std::unique_ptr<sql::PreparedStatement> stmt(Database::CreatePreppedStmt(
+		"SELECT fr.requested_player, best_friend, ci.name FROM "
+		"(SELECT CASE "
+		"WHEN player_id = ? THEN friend_id "
+		"WHEN friend_id = ? THEN player_id "
+		"END AS requested_player, best_friend FROM friends) AS fr "
+		"JOIN charinfo AS ci ON ci.id = fr.requested_player "
+		"WHERE fr.requested_player IS NOT NULL AND fr.requested_player != ?;"));
+	stmt->setUInt(1, static_cast<uint32_t>(playerID));
+	stmt->setUInt(2, static_cast<uint32_t>(playerID));
+	stmt->setUInt(3, static_cast<uint32_t>(playerID));
+
+	std::vector<FriendData> friends;
+
+	std::unique_ptr<sql::ResultSet> res(stmt->executeQuery());
+	while (res->next()) {
 		FriendData fd;
 		fd.isFTP = false; // not a thing in DLU
-		fd.friendID = friendData.friendID;
+		fd.friendID = res->getUInt(1);
 		GeneralUtils::SetBit(fd.friendID, eObjectBits::PERSISTENT);
 		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
 
-		fd.isBestFriend = friendData.isBestFriend; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
+		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;
-		fd.friendName = friendData.friendName;
+		fd.friendName = res->getString(3);
 
 		//Now check if they're online:
-		auto fr = Game::playerContainer.GetPlayerData(fd.friendID);
+		auto fr = playerContainer.GetPlayerData(fd.friendID);
 
 		if (fr) {
 			fd.isOnline = true;
@@ -54,32 +71,38 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 			fd.zoneID = LWOZONEID();
 		}
 
-		player->friends.push_back(fd);
+		friends.push_back(fd);
 	}
 
 	//Now, we need to send the friendlist to the server they came from:
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
 	bitStream.Write<uint8_t>(0);
 	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
-	bitStream.Write((uint16_t)player->friends.size());
+	bitStream.Write((uint16_t)friends.size());
 
-	for (auto& data : player->friends) {
+	for (auto& data : friends) {
 		data.Serialize(bitStream);
 	}
 
+	player->friends = friends;
+
 	SystemAddress sysAddr = player->sysAddr;
 	SEND_PACKET;
 }
 
 void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	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;
 	LWOOBJID requestorPlayerID;
 	inStream.Read(requestorPlayerID);
+	inStream.Read(requestorPlayerID);
 	uint32_t spacing{};
 	inStream.Read(spacing);
 	std::string playerName = "";
@@ -95,17 +118,12 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 	char isBestFriendRequest{};
 	inStream.Read(isBestFriendRequest);
 
-	auto requestor = Game::playerContainer.GetPlayerData(requestorPlayerID);
-	if (!requestor) {
-		LOG("No requestor player %llu sent to %s found.", requestorPlayerID, playerName.c_str());
-		return;
-	}
-
+	auto requestor = playerContainer.GetPlayerData(requestorPlayerID);
 	if (requestor->playerName == playerName) {
 		SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN);
 		return;
 	};
-	std::unique_ptr<PlayerData> requestee(Game::playerContainer.GetPlayerData(playerName));
+	std::unique_ptr<PlayerData> requestee(playerContainer.GetPlayerData(playerName));
 
 	// Check if player is online first
 	if (isBestFriendRequest && !requestee) {
@@ -133,26 +151,35 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 	// If at this point we dont have a target, then they arent online and we cant send the request.
 	// Send the response code that corresponds to what the error is.
 	if (!requestee) {
+		std::unique_ptr<sql::PreparedStatement> nameQuery(Database::CreatePreppedStmt("SELECT name from charinfo where name = ?;"));
+		nameQuery->setString(1, playerName);
+		std::unique_ptr<sql::ResultSet> result(nameQuery->executeQuery());
+
 		requestee.reset(new PlayerData());
 		requestee->playerName = playerName;
-		auto responseType = Database::Get()->GetCharacterInfo(playerName)
-			? eAddFriendResponseType::NOTONLINE
-			: eAddFriendResponseType::INVALIDCHARACTER;
 
-		SendFriendResponse(requestor, requestee.get(), responseType);
+		SendFriendResponse(requestor, requestee.get(), result->next() ? eAddFriendResponseType::NOTONLINE : eAddFriendResponseType::INVALIDCHARACTER);
 		return;
 	}
 
 	if (isBestFriendRequest) {
+		std::unique_ptr<sql::PreparedStatement> friendUpdate(Database::CreatePreppedStmt("SELECT * FROM friends WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;"));
+		friendUpdate->setUInt(1, static_cast<uint32_t>(requestorPlayerID));
+		friendUpdate->setUInt(2, static_cast<uint32_t>(requestee->playerID));
+		friendUpdate->setUInt(3, static_cast<uint32_t>(requestee->playerID));
+		friendUpdate->setUInt(4, static_cast<uint32_t>(requestorPlayerID));
+		std::unique_ptr<sql::ResultSet> result(friendUpdate->executeQuery());
 
+		LWOOBJID queryPlayerID = LWOOBJID_EMPTY;
+		LWOOBJID queryFriendID = LWOOBJID_EMPTY;
 		uint8_t oldBestFriendStatus{};
 		uint8_t bestFriendStatus{};
-		auto bestFriendInfo = Database::Get()->GetBestFriendStatus(requestorPlayerID, requestee->playerID);
-		if (bestFriendInfo) {
+
+		if (result->next()) {
 			// Get the IDs
-			LWOOBJID queryPlayerID = bestFriendInfo->playerCharacterId;
-			LWOOBJID queryFriendID = bestFriendInfo->friendCharacterId;
-			oldBestFriendStatus = bestFriendInfo->bestFriendStatus;
+			queryPlayerID = result->getInt(1);
+			queryFriendID = result->getInt(2);
+			oldBestFriendStatus = result->getInt(3);
 			bestFriendStatus = oldBestFriendStatus;
 
 			// Set the bits
@@ -173,17 +200,22 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 		// Only do updates if there was a change in the bff status.
 		if (oldBestFriendStatus != bestFriendStatus) {
-			auto maxBestFriends = Game::playerContainer.GetMaxNumberOfBestFriends();
-			if (requestee->countOfBestFriends >= maxBestFriends || requestor->countOfBestFriends >= maxBestFriends) {
-				if (requestee->countOfBestFriends >= maxBestFriends) {
+			if (requestee->countOfBestFriends >= maxNumberOfBestFriends || requestor->countOfBestFriends >= maxNumberOfBestFriends) {
+				if (requestee->countOfBestFriends >= maxNumberOfBestFriends) {
 					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
 				}
-				if (requestor->countOfBestFriends >= maxBestFriends) {
+				if (requestor->countOfBestFriends >= maxNumberOfBestFriends) {
 					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
 				}
 			} else {
 				// Then update the database with this new info.
-				Database::Get()->SetBestFriendStatus(requestorPlayerID, requestee->playerID, bestFriendStatus);
+				std::unique_ptr<sql::PreparedStatement> updateQuery(Database::CreatePreppedStmt("UPDATE friends SET best_friend = ? WHERE (player_id = ? AND friend_id = ?) OR (player_id = ? AND friend_id = ?) LIMIT 1;"));
+				updateQuery->setUInt(1, bestFriendStatus);
+				updateQuery->setUInt(2, static_cast<uint32_t>(requestorPlayerID));
+				updateQuery->setUInt(3, static_cast<uint32_t>(requestee->playerID));
+				updateQuery->setUInt(4, static_cast<uint32_t>(requestee->playerID));
+				updateQuery->setUInt(5, static_cast<uint32_t>(requestorPlayerID));
+				updateQuery->executeUpdate();
 				// Sent the best friend update here if the value is 3
 				if (bestFriendStatus == 3U) {
 					requestee->countOfBestFriends += 1;
@@ -206,15 +238,8 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 			if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::WAITINGAPPROVAL, true, true);
 		}
 	} else {
-		auto maxFriends = Game::playerContainer.GetMaxNumberOfFriends();
-		if (requestee->friends.size() >= maxFriends) {
-			SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
-		} else if (requestor->friends.size() >= maxFriends) {
-			SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
-		} else {
-			// Do not send this if we are requesting to be a best friend.
-			SendFriendRequest(requestee.get(), requestor);
-		}
+		// Do not send this if we are requesting to be a best friend.
+		SendFriendRequest(requestee.get(), requestor);
 	}
 
 	// If the player is actually a player and not a ghost one defined above, release it from being deleted.
@@ -222,16 +247,17 @@ 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);
 
 	//Now to try and find both of these:
-	auto requestor = Game::playerContainer.GetPlayerData(playerID);
-	auto requestee = Game::playerContainer.GetPlayerData(friendName);
+	auto requestor = playerContainer.GetPlayerData(playerID);
+	auto requestee = playerContainer.GetPlayerData(friendName);
 	if (!requestor || !requestee) return;
 
 	eAddFriendResponseType serverResponseCode{};
@@ -285,7 +311,11 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 		requesteeData.isOnline = true;
 		requestor->friends.push_back(requesteeData);
 
-		Database::Get()->AddFriend(requestor->playerID, requestee->playerID);
+		std::unique_ptr<sql::PreparedStatement> statement(Database::CreatePreppedStmt("INSERT IGNORE INTO `friends` (`player_id`, `friend_id`, `best_friend`) VALUES (?,?,?);"));
+		statement->setUInt(1, static_cast<uint32_t>(requestor->playerID));
+		statement->setUInt(2, static_cast<uint32_t>(requestee->playerID));
+		statement->setInt(3, 0);
+		statement->execute();
 	}
 
 	if (serverResponseCode != eAddFriendResponseType::DECLINED) SendFriendResponse(requestor, requestee, serverResponseCode, isAlreadyBestFriends);
@@ -293,27 +323,36 @@ 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.
 	//First, we need to find their ID:
+	std::unique_ptr<sql::PreparedStatement> stmt(Database::CreatePreppedStmt("SELECT id FROM charinfo WHERE name=? LIMIT 1;"));
+	stmt->setString(1, friendName.c_str());
+
 	LWOOBJID friendID = 0;
-	auto friendIdResult = Database::Get()->GetCharacterInfo(friendName);
-	if (friendIdResult) {
-		friendID = friendIdResult->id;
+	std::unique_ptr<sql::ResultSet> res(stmt->executeQuery());
+	while (res->next()) {
+		friendID = res->getUInt(1);
 	}
 
 	// Convert friendID to LWOOBJID
 	GeneralUtils::SetBit(friendID, eObjectBits::PERSISTENT);
 	GeneralUtils::SetBit(friendID, eObjectBits::CHARACTER);
 
-	Database::Get()->RemoveFriend(playerID, friendID);
+	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));
+	deletestmt->setUInt(2, static_cast<uint32_t>(friendID));
+	deletestmt->setUInt(3, static_cast<uint32_t>(friendID));
+	deletestmt->setUInt(4, static_cast<uint32_t>(playerID));
+	deletestmt->execute();
 
 	//Now, we need to send an update to notify the sender (and possibly, receiver) that their friendship has been ended:
-	auto goonA = Game::playerContainer.GetPlayerData(playerID);
+	auto goonA = playerContainer.GetPlayerData(playerID);
 	if (goonA) {
 		// Remove the friend from our list of friends
 		for (auto friendData = goonA->friends.begin(); friendData != goonA->friends.end(); friendData++) {
@@ -326,7 +365,7 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 		SendRemoveFriend(goonA, friendName, true);
 	}
 
-	auto goonB = Game::playerContainer.GetPlayerData(friendID);
+	auto goonB = playerContainer.GetPlayerData(friendID);
 	if (!goonB) return;
 	// Do it again for other person
 	for (auto friendData = goonB->friends.begin(); friendData != goonB->friends.end(); friendData++) {
@@ -337,20 +376,21 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 		}
 	}
 
-	std::string goonAName = GeneralUtils::UTF16ToWTF8(Game::playerContainer.GetName(playerID));
+	std::string goonAName = GeneralUtils::UTF16ToWTF8(playerContainer.GetName(playerID));
 	SendRemoveFriend(goonB, goonAName, true);
 }
 
 void ChatPacketHandler::HandleChatMessage(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
-	auto* sender = Game::playerContainer.GetPlayerData(playerID);
+	auto* sender = playerContainer.GetPlayerData(playerID);
 
 	if (sender == nullptr) return;
 
-	if (Game::playerContainer.GetIsMuted(sender)) return;
+	if (playerContainer.GetIsMuted(sender)) return;
 
 	const auto senderName = std::string(sender->playerName.c_str());
 
@@ -361,37 +401,37 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 
 	std::string message = PacketUtils::ReadString(0x66, packet, true, 512);
 
-	LOG("Got a message from (%s) [%d]: %s", senderName.c_str(), channel, message.c_str());
+	Game::logger->Log("ChatPacketHandler", "Got a message from (%s) [%d]: %s", senderName.c_str(), channel, message.c_str());
 
 	if (channel != 8) return;
 
-	auto* team = Game::playerContainer.GetTeam(playerID);
+	auto* team = playerContainer.GetTeam(playerID);
 
 	if (team == nullptr) return;
 
 	for (const auto memberId : team->memberIDs) {
-		auto* otherMember = Game::playerContainer.GetPlayerData(memberId);
+		auto* otherMember = playerContainer.GetPlayerData(memberId);
 
 		if (otherMember == nullptr) return;
 
 		const auto otherName = std::string(otherMember->playerName.c_str());
 
 		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(otherMember->playerID);
 
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(otherMember->playerID);
 		bitStream.Write<uint8_t>(8);
 		bitStream.Write<unsigned int>(69);
-		bitStream.Write(LUWString(senderName));
+		PacketUtils::WritePacketWString(senderName, 33, &bitStream);
 		bitStream.Write(sender->playerID);
 		bitStream.Write<uint16_t>(0);
 		bitStream.Write<uint8_t>(0); //not mythran nametag
-		bitStream.Write(LUWString(otherName));
+		PacketUtils::WritePacketWString(otherName, 33, &bitStream);
 		bitStream.Write<uint8_t>(0); //not mythran for receiver
 		bitStream.Write<uint8_t>(0); //teams?
-		bitStream.Write(LUWString(message, 512));
+		PacketUtils::WritePacketWString(message, 512, &bitStream);
 
 		SystemAddress sysAddr = otherMember->sysAddr;
 		SEND_PACKET;
@@ -399,16 +439,16 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 }
 
 void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
-	LWOOBJID senderID = PacketUtils::ReadS64(0x08, packet);
+	LWOOBJID senderID = PacketUtils::ReadPacketS64(0x08, packet);
 	std::string receiverName = PacketUtils::ReadString(0x66, packet, true);
 	std::string message = PacketUtils::ReadString(0xAA, packet, true, 512);
 
 	//Get the bois:
-	auto goonA = Game::playerContainer.GetPlayerData(senderID);
-	auto goonB = Game::playerContainer.GetPlayerData(receiverName);
+	auto goonA = playerContainer.GetPlayerData(senderID);
+	auto goonB = playerContainer.GetPlayerData(receiverName);
 	if (!goonA || !goonB) return;
 
-	if (Game::playerContainer.GetIsMuted(goonA)) return;
+	if (playerContainer.GetIsMuted(goonA)) return;
 
 	std::string goonAName = goonA->playerName.c_str();
 	std::string goonBName = goonB->playerName.c_str();
@@ -416,21 +456,21 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the sender:
 	{
 		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(goonA->playerID);
 
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
-		bitStream.Write(LUWString(goonAName));
+		PacketUtils::WritePacketWString(goonAName, 33, &bitStream);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint16_t>(0);
 		bitStream.Write<uint8_t>(0); //not mythran nametag
-		bitStream.Write(LUWString(goonBName));
+		PacketUtils::WritePacketWString(goonBName, 33, &bitStream);
 		bitStream.Write<uint8_t>(0); //not mythran for receiver
 		bitStream.Write<uint8_t>(0); //success
-		bitStream.Write(LUWString(message, 512));
+		PacketUtils::WritePacketWString(message, 512, &bitStream);
 
 		SystemAddress sysAddr = goonA->sysAddr;
 		SEND_PACKET;
@@ -439,21 +479,21 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	//To the receiver:
 	{
 		CBITSTREAM;
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 		bitStream.Write(goonB->playerID);
 
-		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
+		PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
-		bitStream.Write(LUWString(goonAName));
+		PacketUtils::WritePacketWString(goonAName, 33, &bitStream);
 		bitStream.Write(goonA->playerID);
 		bitStream.Write<uint16_t>(0);
 		bitStream.Write<uint8_t>(0); //not mythran nametag
-		bitStream.Write(LUWString(goonBName));
+		PacketUtils::WritePacketWString(goonBName, 33, &bitStream);
 		bitStream.Write<uint8_t>(0); //not mythran for receiver
 		bitStream.Write<uint8_t>(3); //new whisper
-		bitStream.Write(LUWString(message, 512));
+		PacketUtils::WritePacketWString(message, 512, &bitStream);
 
 		SystemAddress sysAddr = goonB->sysAddr;
 		SEND_PACKET;
@@ -461,49 +501,51 @@ 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 = Game::playerContainer.GetPlayerData(playerID);
+	auto* player = playerContainer.GetPlayerData(playerID);
 
 	if (player == nullptr) {
 		return;
 	}
 
-	auto* team = Game::playerContainer.GetTeam(playerID);
+	auto* team = playerContainer.GetTeam(playerID);
 
 	if (team == nullptr) {
-		team = Game::playerContainer.CreateTeam(playerID);
+		team = playerContainer.CreateTeam(playerID);
 	}
 
-	auto* other = Game::playerContainer.GetPlayerData(invitedPlayer);
+	auto* other = playerContainer.GetPlayerData(invitedPlayer);
 
 	if (other == nullptr) {
 		return;
 	}
 
-	if (Game::playerContainer.GetTeam(other->playerID) != nullptr) {
+	if (playerContainer.GetTeam(other->playerID) != nullptr) {
 		return;
 	}
 
 	if (team->memberIDs.size() > 3) {
 		// no more teams greater than 4
 
-		LOG("Someone tried to invite a 5th player to a team");
+		Game::logger->Log("ChatPacketHandler", "Someone tried to invite a 5th player to a team");
 		return;
 	}
 
 	SendTeamInvite(other, player);
 
-	LOG("Got team invite: %llu -> %s", playerID, invitedPlayer.c_str());
+	Game::logger->Log("ChatPacketHandler", "Got team invite: %llu -> %s", playerID, invitedPlayer.c_str());
 }
 
 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;
@@ -511,136 +553,141 @@ void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
 	LWOOBJID leaderID = LWOOBJID_EMPTY;
 	inStream.Read(leaderID);
 
-	LOG("Accepted invite: %llu -> %llu (%d)", playerID, leaderID, declined);
+	Game::logger->Log("ChatPacketHandler", "Accepted invite: %llu -> %llu (%d)", playerID, leaderID, declined);
 
 	if (declined) {
 		return;
 	}
 
-	auto* team = Game::playerContainer.GetTeam(leaderID);
+	auto* team = playerContainer.GetTeam(leaderID);
 
 	if (team == nullptr) {
-		LOG("Failed to find team for leader (%llu)", leaderID);
+		Game::logger->Log("ChatPacketHandler", "Failed to find team for leader (%llu)", leaderID);
 
-		team = Game::playerContainer.GetTeam(playerID);
+		team = playerContainer.GetTeam(playerID);
 	}
 
 	if (team == nullptr) {
-		LOG("Failed to find team for player (%llu)", playerID);
+		Game::logger->Log("ChatPacketHandler", "Failed to find team for player (%llu)", playerID);
 		return;
 	}
 
-	Game::playerContainer.AddMember(team, playerID);
+	playerContainer.AddMember(team, playerID);
 }
 
 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);
 
-	auto* team = Game::playerContainer.GetTeam(playerID);
+	auto* team = playerContainer.GetTeam(playerID);
 
-	LOG("(%llu) leaving team", playerID);
+	Game::logger->Log("ChatPacketHandler", "(%llu) leaving team", playerID);
 
 	if (team != nullptr) {
-		Game::playerContainer.RemoveMember(team, playerID, false, false, true);
+		playerContainer.RemoveMember(team, playerID, false, false, true);
 	}
 }
 
 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);
 
-	LOG("(%llu) kicking (%s) from team", playerID, kickedPlayer.c_str());
+	Game::logger->Log("ChatPacketHandler", "(%llu) kicking (%s) from team", playerID, kickedPlayer.c_str());
 
-	auto* kicked = Game::playerContainer.GetPlayerData(kickedPlayer);
+	auto* kicked = playerContainer.GetPlayerData(kickedPlayer);
 
 	LWOOBJID kickedId = LWOOBJID_EMPTY;
 
 	if (kicked != nullptr) {
 		kickedId = kicked->playerID;
 	} else {
-		kickedId = Game::playerContainer.GetId(GeneralUtils::UTF8ToUTF16(kickedPlayer));
+		kickedId = playerContainer.GetId(GeneralUtils::UTF8ToUTF16(kickedPlayer));
 	}
 
 	if (kickedId == LWOOBJID_EMPTY) return;
 
-	auto* team = Game::playerContainer.GetTeam(playerID);
+	auto* team = playerContainer.GetTeam(playerID);
 
 	if (team != nullptr) {
 		if (team->leaderID != playerID || team->leaderID == kickedId) return;
 
-		Game::playerContainer.RemoveMember(team, kickedId, false, true, false);
+		playerContainer.RemoveMember(team, kickedId, false, true, false);
 	}
 }
 
 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);
 
-	LOG("(%llu) promoting (%s) to team leader", playerID, promotedPlayer.c_str());
+	Game::logger->Log("ChatPacketHandler", "(%llu) promoting (%s) to team leader", playerID, promotedPlayer.c_str());
 
-	auto* promoted = Game::playerContainer.GetPlayerData(promotedPlayer);
+	auto* promoted = playerContainer.GetPlayerData(promotedPlayer);
 
 	if (promoted == nullptr) return;
 
-	auto* team = Game::playerContainer.GetTeam(playerID);
+	auto* team = playerContainer.GetTeam(playerID);
 
 	if (team != nullptr) {
 		if (team->leaderID != playerID) return;
 
-		Game::playerContainer.PromoteMember(team, promoted->playerID);
+		playerContainer.PromoteMember(team, promoted->playerID);
 	}
 }
 
 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);
 
 	char option;
 	inStream.Read(option);
 
-	auto* team = Game::playerContainer.GetTeam(playerID);
+	auto* team = playerContainer.GetTeam(playerID);
 
 	if (team != nullptr) {
 		if (team->leaderID != playerID) return;
 
 		team->lootFlag = option;
 
-		Game::playerContainer.TeamStatusUpdate(team);
+		playerContainer.TeamStatusUpdate(team);
 
-		Game::playerContainer.UpdateTeamsOnWorld(team, false);
+		playerContainer.UpdateTeamsOnWorld(team, false);
 	}
 }
 
 void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
+	CINSTREAM;
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
+	inStream.Read(playerID);
 
-	auto* team = Game::playerContainer.GetTeam(playerID);
-	auto* data = Game::playerContainer.GetPlayerData(playerID);
+	auto* team = playerContainer.GetTeam(playerID);
+	auto* data = playerContainer.GetPlayerData(playerID);
 
 	if (team != nullptr && data != nullptr) {
 		if (team->local && data->zoneID.GetMapID() != team->zoneId.GetMapID() && data->zoneID.GetCloneID() != team->zoneId.GetCloneID()) {
-			Game::playerContainer.RemoveMember(team, playerID, false, false, true, true);
+			playerContainer.RemoveMember(team, playerID, false, false, true, true);
 
 			return;
 		}
 
 		if (team->memberIDs.size() <= 1 && !team->local) {
-			Game::playerContainer.DisbandTeam(team);
+			playerContainer.DisbandTeam(team);
 
 			return;
 		}
@@ -651,16 +698,16 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 			ChatPacketHandler::SendTeamSetLeader(data, LWOOBJID_EMPTY);
 		}
 
-		Game::playerContainer.TeamStatusUpdate(team);
+		playerContainer.TeamStatusUpdate(team);
 
 		const auto leaderName = GeneralUtils::UTF8ToUTF16(data->playerName);
 
 		for (const auto memberId : team->memberIDs) {
-			auto* otherMember = Game::playerContainer.GetPlayerData(memberId);
+			auto* otherMember = playerContainer.GetPlayerData(memberId);
 
 			if (memberId == playerID) continue;
 
-			const auto memberName = Game::playerContainer.GetName(memberId);
+			const auto memberName = playerContainer.GetName(memberId);
 
 			if (otherMember != nullptr) {
 				ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, data->playerID, data->zoneID);
@@ -668,19 +715,19 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 			ChatPacketHandler::SendTeamAddPlayer(data, false, team->local, false, memberId, memberName, otherMember != nullptr ? otherMember->zoneID : LWOZONEID(0, 0, 0));
 		}
 
-		Game::playerContainer.UpdateTeamsOnWorld(team, false);
+		playerContainer.UpdateTeamsOnWorld(team, false);
 	}
 }
 
 void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
 
-	bitStream.Write(LUWString(sender->playerName.c_str()));
+	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write(sender->playerID);
 
 	SystemAddress sysAddr = receiver->sysAddr;
@@ -689,7 +736,7 @@ 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;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
@@ -716,7 +763,7 @@ 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;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
@@ -741,7 +788,7 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI
 
 void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
@@ -758,7 +805,7 @@ 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;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
@@ -787,7 +834,7 @@ 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;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
@@ -813,7 +860,7 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband
 
 void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
@@ -847,16 +894,16 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla
 		[bool] - is FTP*/
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(friendData->playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
 	std::string playerName = playerData->playerName.c_str();
 
-	bitStream.Write(LUWString(playerName));
+	PacketUtils::WritePacketWString(playerName, 33, &bitStream);
 
 	bitStream.Write(playerData->zoneID.GetMapID());
 	bitStream.Write(playerData->zoneID.GetInstanceID());
@@ -886,12 +933,12 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 	}
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
-	bitStream.Write(LUWString(sender->playerName.c_str()));
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_REQUEST);
+	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	bitStream.Write<uint8_t>(0); // This is a BFF flag however this is unused in live and does not have an implementation client side.
 
 	SystemAddress sysAddr = receiver->sysAddr;
@@ -902,16 +949,16 @@ void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sen
 	if (!receiver || !sender) return;
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	// Portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::ADD_FRIEND_RESPONSE);
 	bitStream.Write(responseCode);
 	// For all requests besides accepted, write a flag that says whether or not we are already best friends with the receiver.
 	bitStream.Write<uint8_t>(responseCode != eAddFriendResponseType::ACCEPTED ? isBestFriendsAlready : sender->sysAddr != UNASSIGNED_SYSTEM_ADDRESS);
 	// Then write the player name
-	bitStream.Write(LUWString(sender->playerName.c_str()));
+	PacketUtils::WritePacketWString(sender->playerName.c_str(), 33, &bitStream);
 	// Then if this is an acceptance code, write the following extra info.
 	if (responseCode == eAddFriendResponseType::ACCEPTED) {
 		bitStream.Write(sender->playerID);
@@ -927,13 +974,13 @@ void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& pers
 	if (!receiver) return;
 
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
 	bitStream.Write(receiver->playerID);
 
 	//portion that will get routed:
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
-	bitStream.Write(LUWString(personToRemove));
+	PacketUtils::WritePacketWString(personToRemove, 33, &bitStream);
 
 	SystemAddress sysAddr = receiver->sysAddr;
 	SEND_PACKET;

dChatServer/ChatServer.cpp

@@ -6,7 +6,7 @@
 //DLU Includes:
 #include "dCommonVars.h"
 #include "dServer.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "Database.h"
 #include "dConfig.h"
 #include "dChatFilter.h"
@@ -19,7 +19,6 @@
 #include "eChatMessageType.h"
 #include "eChatInternalMessageType.h"
 #include "eWorldMessageType.h"
-#include "ChatIgnoreList.h"
 
 #include "Game.h"
 
@@ -28,19 +27,20 @@
 #include <MessageIdentifiers.h>
 
 namespace Game {
-	Logger* logger = nullptr;
+	dLogger* logger = nullptr;
 	dServer* server = nullptr;
 	dConfig* config = nullptr;
 	dChatFilter* chatFilter = nullptr;
 	AssetManager* assetManager = nullptr;
 	bool shouldShutdown = false;
-	std::mt19937 randomEngine;
-	PlayerContainer playerContainer;
 }
 
-Logger* SetupLogger();
+
+dLogger* SetupLogger();
 void HandlePacket(Packet* packet);
 
+PlayerContainer playerContainer;
+
 int main(int argc, char** argv) {
 	constexpr uint32_t chatFramerate = mediumFramerate;
 	constexpr uint32_t chatFrameDelta = mediumFrameDelta;
@@ -57,9 +57,9 @@ int main(int argc, char** argv) {
 	Game::logger->SetLogToConsole(Game::config->GetValue("log_to_console") != "0");
 	Game::logger->SetLogDebugStatements(Game::config->GetValue("log_debug_statements") == "1");
 
-	LOG("Starting Chat server...");
-	LOG("Version: %i.%i", PROJECT_VERSION_MAJOR, PROJECT_VERSION_MINOR);
-	LOG("Compiled on: %s", __TIMESTAMP__);
+	Game::logger->Log("ChatServer", "Starting Chat server...");
+	Game::logger->Log("ChatServer", "Version: %i.%i", PROJECT_VERSION_MAJOR, PROJECT_VERSION_MINOR);
+	Game::logger->Log("ChatServer", "Compiled on: %s", __TIMESTAMP__);
 
 	try {
 		std::string clientPathStr = Game::config->GetValue("client_location");
@@ -71,16 +71,21 @@ int main(int argc, char** argv) {
 
 		Game::assetManager = new AssetManager(clientPath);
 	} catch (std::runtime_error& ex) {
-		LOG("Got an error while setting up assets: %s", ex.what());
+		Game::logger->Log("ChatServer", "Got an error while setting up assets: %s", ex.what());
 
 		return EXIT_FAILURE;
 	}
 
 	//Connect to the MySQL Database
+	std::string mysql_host = Game::config->GetValue("mysql_host");
+	std::string mysql_database = Game::config->GetValue("mysql_database");
+	std::string mysql_username = Game::config->GetValue("mysql_username");
+	std::string mysql_password = Game::config->GetValue("mysql_password");
+
 	try {
-		Database::Connect();
+		Database::Connect(mysql_host, mysql_database, mysql_username, mysql_password);
 	} catch (sql::SQLException& ex) {
-		LOG("Got an error while connecting to the database: %s", ex.what());
+		Game::logger->Log("ChatServer", "Got an error while connecting to the database: %s", ex.what());
 		Database::Destroy("ChatServer");
 		delete Game::server;
 		delete Game::logger;
@@ -90,11 +95,16 @@ int main(int argc, char** argv) {
 	//Find out the master's IP:
 	std::string masterIP;
 	uint32_t masterPort = 1000;
-	auto masterInfo = Database::Get()->GetMasterInfo();
-	if (masterInfo) {
-		masterIP = masterInfo->ip;
-		masterPort = masterInfo->port;
+	sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+	auto res = stmt->executeQuery();
+	while (res->next()) {
+		masterIP = res->getString(1).c_str();
+		masterPort = res->getInt(2);
 	}
+
+	delete res;
+	delete stmt;
+
 	//It's safe to pass 'localhost' here, as the IP is only used as the external IP.
 	uint32_t maxClients = 50;
 	uint32_t ourPort = 1501;
@@ -104,10 +114,6 @@ int main(int argc, char** argv) {
 	Game::server = new dServer(Game::config->GetValue("external_ip"), ourPort, 0, maxClients, false, true, Game::logger, masterIP, masterPort, ServerType::Chat, Game::config, &Game::shouldShutdown);
 
 	Game::chatFilter = new dChatFilter(Game::assetManager->GetResPath().string() + "/chatplus_en_us", bool(std::stoi(Game::config->GetValue("dont_generate_dcf"))));
-	
-	Game::randomEngine = std::mt19937(time(0));
-
-	Game::playerContainer.Initialize();
 
 	//Run it until server gets a kill message from Master:
 	auto t = std::chrono::high_resolution_clock::now();
@@ -149,13 +155,16 @@ int main(int argc, char** argv) {
 			//Find out the master's IP for absolutely no reason:
 			std::string masterIP;
 			uint32_t masterPort;
-
-			auto masterInfo = Database::Get()->GetMasterInfo();
-			if (masterInfo) {
-				masterIP = masterInfo->ip;
-				masterPort = masterInfo->port;
+			sql::PreparedStatement* stmt = Database::CreatePreppedStmt("SELECT ip, port FROM servers WHERE name='master';");
+			auto res = stmt->executeQuery();
+			while (res->next()) {
+				masterIP = res->getString(1).c_str();
+				masterPort = res->getInt(2);
 			}
 
+			delete res;
+			delete stmt;
+
 			framesSinceLastSQLPing = 0;
 		} else framesSinceLastSQLPing++;
 
@@ -173,7 +182,7 @@ int main(int argc, char** argv) {
 	return EXIT_SUCCESS;
 }
 
-Logger* SetupLogger() {
+dLogger* SetupLogger() {
 	std::string logPath = (BinaryPathFinder::GetBinaryDir() / ("logs/ChatServer_" + std::to_string(time(nullptr)) + ".log")).string();
 	bool logToConsole = false;
 	bool logDebugStatements = false;
@@ -182,16 +191,16 @@ Logger* SetupLogger() {
 	logDebugStatements = true;
 #endif
 
-	return new Logger(logPath, logToConsole, logDebugStatements);
+	return new dLogger(logPath, logToConsole, logDebugStatements);
 }
 
 void HandlePacket(Packet* packet) {
 	if (packet->data[0] == ID_DISCONNECTION_NOTIFICATION || packet->data[0] == ID_CONNECTION_LOST) {
-		LOG("A server has disconnected, erasing their connected players from the list.");
+		Game::logger->Log("ChatServer", "A server has disconnected, erasing their connected players from the list.");
 	}
 
 	if (packet->data[0] == ID_NEW_INCOMING_CONNECTION) {
-		LOG("A server is connecting, awaiting user list.");
+		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.
@@ -199,19 +208,19 @@ void HandlePacket(Packet* packet) {
 	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
 		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
 		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
-			Game::playerContainer.InsertPlayer(packet);
+			playerContainer.InsertPlayer(packet);
 			break;
 
 		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
-			Game::playerContainer.RemovePlayer(packet);
+			playerContainer.RemovePlayer(packet);
 			break;
 
 		case eChatInternalMessageType::MUTE_UPDATE:
-			Game::playerContainer.MuteUpdate(packet);
+			playerContainer.MuteUpdate(packet);
 			break;
 
 		case eChatInternalMessageType::CREATE_TEAM:
-			Game::playerContainer.CreateTeamServer(packet);
+			playerContainer.CreateTeamServer(packet);
 			break;
 
 		case eChatInternalMessageType::ANNOUNCEMENT: {
@@ -222,7 +231,7 @@ void HandlePacket(Packet* packet) {
 		}
 
 		default:
-			LOG("Unknown CHAT_INTERNAL id: %i", int(packet->data[3]));
+			Game::logger->Log("ChatServer", "Unknown CHAT_INTERNAL id: %i", int(packet->data[3]));
 		}
 	}
 
@@ -233,15 +242,7 @@ void HandlePacket(Packet* packet) {
 			break;
 
 		case eChatMessageType::GET_IGNORE_LIST:
-			ChatIgnoreList::GetIgnoreList(packet);
-			break;
-
-		case eChatMessageType::ADD_IGNORE:
-			ChatIgnoreList::AddIgnore(packet);
-			break;
-
-		case eChatMessageType::REMOVE_IGNORE:
-			ChatIgnoreList::RemoveIgnore(packet);
+			Game::logger->Log("ChatServer", "Asked for ignore list, but is unimplemented right now.");
 			break;
 
 		case eChatMessageType::TEAM_GET_STATUS:
@@ -299,19 +300,19 @@ void HandlePacket(Packet* packet) {
 			break;
 
 		default:
-			LOG("Unknown CHAT id: %i", int(packet->data[3]));
+			Game::logger->Log("ChatServer", "Unknown CHAT id: %i", int(packet->data[3]));
 		}
 	}
 
 	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::WORLD) {
 		switch (static_cast<eWorldMessageType>(packet->data[3])) {
 		case eWorldMessageType::ROUTE_PACKET: {
-			LOG("Routing packet from world");
+			Game::logger->Log("ChatServer", "Routing packet from world");
 			break;
 		}
 
 		default:
-			LOG("Unknown World id: %i", int(packet->data[3]));
+			Game::logger->Log("ChatServer", "Unknown World id: %i", int(packet->data[3]));
 		}
 	}
 }

dChatServer/PlayerContainer.cpp

@@ -3,32 +3,25 @@
 #include <iostream>
 #include <algorithm>
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "ChatPacketHandler.h"
 #include "GeneralUtils.h"
-#include "BitStreamUtils.h"
+#include "PacketUtils.h"
 #include "Database.h"
 #include "eConnectionType.h"
 #include "eChatInternalMessageType.h"
-#include "ChatPackets.h"
-#include "dConfig.h"
 
-void PlayerContainer::Initialize() {
-	GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_number_of_best_friends"), m_MaxNumberOfBestFriends);
-	GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("max_number_of_friends"), m_MaxNumberOfFriends);
+PlayerContainer::PlayerContainer() {
 }
 
 PlayerContainer::~PlayerContainer() {
-	m_Players.clear();
-}
-
-TeamData::TeamData() {
-	lootFlag = Game::config->GetValue("default_team_loot") == "0" ? 0 : 1;
+	mPlayers.clear();
 }
 
 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;
@@ -43,17 +36,25 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	inStream.Read(data->muteExpire);
 	data->sysAddr = packet->systemAddress;
 
-	m_Names[data->playerID] = GeneralUtils::UTF8ToUTF16(data->playerName);
+	mNames[data->playerID] = GeneralUtils::UTF8ToUTF16(data->playerName);
 
-	m_Players.insert(std::make_pair(data->playerID, data));
-	LOG("Added user: %s (%llu), zone: %i", data->playerName.c_str(), data->playerID, data->zoneID.GetMapID());
+	mPlayers.insert(std::make_pair(data->playerID, data));
+	Game::logger->Log("PlayerContainer", "Added user: %s (%llu), zone: %i", data->playerName.c_str(), data->playerID, data->zoneID.GetMapID());
 
-	Database::Get()->UpdateActivityLog(data->playerID, eActivityType::PlayerLoggedIn, data->zoneID.GetMapID());
+	auto* insertLog = Database::CreatePreppedStmt("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);");
+
+	insertLog->setInt(1, data->playerID);
+	insertLog->setInt(2, 0);
+	insertLog->setUInt64(3, time(nullptr));
+	insertLog->setInt(4, data->zoneID.GetMapID());
+
+	insertLog->executeUpdate();
 }
 
 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.
@@ -82,15 +83,23 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 		}
 	}
 
-	LOG("Removed user: %llu", playerID);
-	m_Players.erase(playerID);
+	Game::logger->Log("PlayerContainer", "Removed user: %llu", playerID);
+	mPlayers.erase(playerID);
 
-	Database::Get()->UpdateActivityLog(playerID, eActivityType::PlayerLoggedOut, player->zoneID.GetMapID());
+	auto* insertLog = Database::CreatePreppedStmt("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);");
+
+	insertLog->setInt(1, playerID);
+	insertLog->setInt(2, 1);
+	insertLog->setUInt64(3, time(nullptr));
+	insertLog->setInt(4, player->zoneID.GetMapID());
+
+	insertLog->executeUpdate();
 }
 
 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);
@@ -98,7 +107,7 @@ void PlayerContainer::MuteUpdate(Packet* packet) {
 	auto* player = this->GetPlayerData(playerID);
 
 	if (player == nullptr) {
-		LOG("Failed to find user: %llu", playerID);
+		Game::logger->Log("PlayerContainer", "Failed to find user: %llu", playerID);
 
 		return;
 	}
@@ -109,8 +118,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);
@@ -140,7 +150,7 @@ void PlayerContainer::CreateTeamServer(Packet* packet) {
 
 void PlayerContainer::BroadcastMuteUpdate(LWOOBJID player, time_t time) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::MUTE_UPDATE);
 
 	bitStream.Write(player);
 	bitStream.Write(time);
@@ -179,7 +189,7 @@ TeamData* PlayerContainer::CreateLocalTeam(std::vector<LWOOBJID> members) {
 TeamData* PlayerContainer::CreateTeam(LWOOBJID leader, bool local) {
 	auto* team = new TeamData();
 
-	team->teamID = ++m_TeamIDCounter;
+	team->teamID = ++mTeamIDCounter;
 	team->leaderID = leader;
 	team->local = local;
 
@@ -201,14 +211,6 @@ TeamData* PlayerContainer::GetTeam(LWOOBJID playerID) {
 }
 
 void PlayerContainer::AddMember(TeamData* team, LWOOBJID playerID) {
-	if (team->memberIDs.size() >= 4){
-		LOG("Tried to add player to team that already had 4 players");
-		auto* player = GetPlayerData(playerID);
-		if (!player) return;
-		ChatPackets::SendSystemMessage(player->sysAddr, u"The teams is full! You have not been added to a team!");
-		return;
-	}
-
 	const auto index = std::find(team->memberIDs.begin(), team->memberIDs.end(), playerID);
 
 	if (index != team->memberIDs.end()) return;
@@ -347,7 +349,7 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
+	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::TEAM_UPDATE);
 
 	bitStream.Write(team->teamID);
 	bitStream.Write(deleteTeam);
@@ -364,15 +366,15 @@ void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 }
 
 std::u16string PlayerContainer::GetName(LWOOBJID playerID) {
-	const auto& pair = m_Names.find(playerID);
+	const auto& pair = mNames.find(playerID);
 
-	if (pair == m_Names.end()) return u"";
+	if (pair == mNames.end()) return u"";
 
 	return pair->second;
 }
 
 LWOOBJID PlayerContainer::GetId(const std::u16string& playerName) {
-	for (const auto& pair : m_Names) {
+	for (const auto& pair : mNames) {
 		if (pair.second == playerName) {
 			return pair.first;
 		}

dChatServer/PlayerContainer.h

@@ -7,32 +7,17 @@
 #include "dServer.h"
 #include <unordered_map>
 
-struct IgnoreData {
-	inline bool operator==(const std::string& other) const noexcept {
-		return playerName == other;
-	}
-
-	inline bool operator==(const LWOOBJID& other) const noexcept {
-		return playerId == other;
-	}
-
-	LWOOBJID playerId;
-	std::string playerName;
-};
-
 struct PlayerData {
 	LWOOBJID playerID;
 	std::string playerName;
 	SystemAddress sysAddr;
 	LWOZONEID zoneID;
 	std::vector<FriendData> friends;
-	std::vector<IgnoreData> ignoredPlayers;
 	time_t muteExpire;
 	uint8_t countOfBestFriends = 0;
 };
 
 struct TeamData {
-	TeamData();
 	LWOOBJID teamID = LWOOBJID_EMPTY; // Internal use
 	LWOOBJID leaderID = LWOOBJID_EMPTY;
 	std::vector<LWOOBJID> memberIDs{};
@@ -43,9 +28,9 @@ struct TeamData {
 
 class PlayerContainer {
 public:
+	PlayerContainer();
 	~PlayerContainer();
 
-	void Initialize();
 	void InsertPlayer(Packet* packet);
 	void RemovePlayer(Packet* packet);
 	void MuteUpdate(Packet* packet);
@@ -53,13 +38,13 @@ public:
 	void BroadcastMuteUpdate(LWOOBJID player, time_t time);
 
 	PlayerData* GetPlayerData(const LWOOBJID& playerID) {
-		auto it = m_Players.find(playerID);
-		if (it != m_Players.end()) return it->second;
+		auto it = mPlayers.find(playerID);
+		if (it != mPlayers.end()) return it->second;
 		return nullptr;
 	}
 
 	PlayerData* GetPlayerData(const std::string& playerName) {
-		for (auto player : m_Players) {
+		for (auto player : mPlayers) {
 			if (player.second) {
 				std::string pn = player.second->playerName.c_str();
 				if (pn == playerName) return player.second;
@@ -81,17 +66,13 @@ public:
 	std::u16string GetName(LWOOBJID playerID);
 	LWOOBJID GetId(const std::u16string& playerName);
 	bool GetIsMuted(PlayerData* data);
-	uint32_t GetMaxNumberOfBestFriends() { return m_MaxNumberOfBestFriends; }
-	uint32_t GetMaxNumberOfFriends() { return m_MaxNumberOfFriends; }
 
-	std::map<LWOOBJID, PlayerData*>& GetAllPlayerData() { return m_Players; }
+	std::map<LWOOBJID, PlayerData*>& GetAllPlayerData() { return mPlayers; }
 
 private:
-	LWOOBJID m_TeamIDCounter = 0;
-	std::map<LWOOBJID, PlayerData*> m_Players;
+	LWOOBJID mTeamIDCounter = 0;
+	std::map<LWOOBJID, PlayerData*> mPlayers;
 	std::vector<TeamData*> mTeams;
-	std::unordered_map<LWOOBJID, std::u16string> m_Names;
-	uint32_t m_MaxNumberOfBestFriends = 5;
-	uint32_t m_MaxNumberOfFriends = 50;
+	std::unordered_map<LWOOBJID, std::u16string> mNames;
 };
 

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,259 @@
+#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;
+		}
+		case AMFObject:
+		case AMFXML:
+		case AMFByteArray:
+		case AMFVectorInt:
+		case AMFVectorUInt:
+		case AMFVectorDouble:
+		case AMFVectorObject:
+		case AMFDictionary:
+			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 "Logger.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 "Logger.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: {
-		LOG("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/BrickByBrickFix.cpp

@@ -9,12 +9,13 @@
 #include "Database.h"
 #include "Game.h"
 #include "ZCompression.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 //! Forward declarations
 
+std::unique_ptr<sql::ResultSet> GetModelsFromDatabase();
 void WriteSd0Magic(char* input, uint32_t chunkSize);
-bool CheckSd0Magic(std::istream& streamToCheck);
+bool CheckSd0Magic(sql::Blob* streamToCheck);
 
 /**
  * @brief Truncates all models with broken data from the database.
@@ -23,24 +24,28 @@ bool CheckSd0Magic(std::istream& streamToCheck);
  */
 uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 	uint32_t modelsTruncated{};
-	auto modelsToTruncate = Database::Get()->GetAllUgcModels();
-	bool previousCommitValue = Database::Get()->GetAutoCommit();
-	Database::Get()->SetAutoCommit(false);
-	for (auto& model : modelsToTruncate) {
+	auto modelsToTruncate = GetModelsFromDatabase();
+	bool previousCommitValue = Database::GetAutoCommit();
+	Database::SetAutoCommit(false);
+	while (modelsToTruncate->next()) {
+		std::unique_ptr<sql::PreparedStatement> ugcModelToDelete(Database::CreatePreppedStmt("DELETE FROM ugc WHERE ugc.id = ?;"));
+		std::unique_ptr<sql::PreparedStatement> pcModelToDelete(Database::CreatePreppedStmt("DELETE FROM properties_contents WHERE ugc_id = ?;"));
 		std::string completeUncompressedModel{};
 		uint32_t chunkCount{};
+		uint64_t modelId = modelsToTruncate->getInt(1);
+		std::unique_ptr<sql::Blob> modelAsSd0(modelsToTruncate->getBlob(2));
 		// Check that header is sd0 by checking for the sd0 magic.
-		if (CheckSd0Magic(model.lxfmlData)) {
+		if (CheckSd0Magic(modelAsSd0.get())) {
 			while (true) {
 				uint32_t chunkSize{};
-				model.lxfmlData.read(reinterpret_cast<char*>(&chunkSize), sizeof(uint32_t)); // Extract chunk size from istream
+				modelAsSd0->read(reinterpret_cast<char*>(&chunkSize), sizeof(uint32_t)); // Extract chunk size from istream
 
 				// Check if good here since if at the end of an sd0 file, this will have eof flagged.
-				if (!model.lxfmlData.good()) break;
+				if (!modelAsSd0->good()) break;
 
 				std::unique_ptr<uint8_t[]> compressedChunk(new uint8_t[chunkSize]);
 				for (uint32_t i = 0; i < chunkSize; i++) {
-					compressedChunk[i] = model.lxfmlData.get();
+					compressedChunk[i] = modelAsSd0->get();
 				}
 
 				// Ignore the valgrind warning about uninitialized values.  These are discarded later when we know the actual uncompressed size.
@@ -54,14 +59,14 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 					completeUncompressedModel.append((char*)uncompressedChunk.get());
 					completeUncompressedModel.resize(previousSize + actualUncompressedSize);
 				} else {
-					LOG("Failed to inflate chunk %i for model %llu.  Error: %i", chunkCount, model.id, err);
+					Game::logger->Log("BrickByBrickFix", "Failed to inflate chunk %i for model %llu.  Error: %i", chunkCount, modelId, err);
 					break;
 				}
 				chunkCount++;
 			}
 			std::unique_ptr<tinyxml2::XMLDocument> document = std::make_unique<tinyxml2::XMLDocument>();
 			if (!document) {
-				LOG("Failed to initialize tinyxml document.  Aborting.");
+				Game::logger->Log("BrickByBrickFix", "Failed to initialize tinyxml document.  Aborting.");
 				return 0;
 			}
 
@@ -70,20 +75,28 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 					"</LXFML>",
 					completeUncompressedModel.length() >= 15 ? completeUncompressedModel.length() - 15 : 0) == std::string::npos
 					) {
-					LOG("Brick-by-brick model %llu will be deleted!", model.id);
-					Database::Get()->DeleteUgcModelData(model.id);
+					Game::logger->Log("BrickByBrickFix",
+						"Brick-by-brick model %llu will be deleted!", modelId);
+					ugcModelToDelete->setInt64(1, modelsToTruncate->getInt64(1));
+					pcModelToDelete->setInt64(1, modelsToTruncate->getInt64(1));
+					ugcModelToDelete->execute();
+					pcModelToDelete->execute();
 					modelsTruncated++;
 				}
 			}
 		} else {
-			LOG("Brick-by-brick model %llu will be deleted!", model.id);
-			Database::Get()->DeleteUgcModelData(model.id);
+			Game::logger->Log("BrickByBrickFix",
+				"Brick-by-brick model %llu will be deleted!", modelId);
+			ugcModelToDelete->setInt64(1, modelsToTruncate->getInt64(1));
+			pcModelToDelete->setInt64(1, modelsToTruncate->getInt64(1));
+			ugcModelToDelete->execute();
+			pcModelToDelete->execute();
 			modelsTruncated++;
 		}
 	}
 
-	Database::Get()->Commit();
-	Database::Get()->SetAutoCommit(previousCommitValue);
+	Database::Commit();
+	Database::SetAutoCommit(previousCommitValue);
 	return modelsTruncated;
 }
 
@@ -95,17 +108,21 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
  */
 uint32_t BrickByBrickFix::UpdateBrickByBrickModelsToSd0() {
 	uint32_t updatedModels = 0;
-	auto modelsToUpdate = Database::Get()->GetAllUgcModels();
-	auto previousAutoCommitState = Database::Get()->GetAutoCommit();
-	Database::Get()->SetAutoCommit(false);
-	for (auto& model : modelsToUpdate) {
+	auto modelsToUpdate = GetModelsFromDatabase();
+	auto previousAutoCommitState = Database::GetAutoCommit();
+	Database::SetAutoCommit(false);
+	std::unique_ptr<sql::PreparedStatement> insertionStatement(Database::CreatePreppedStmt("UPDATE ugc SET lxfml = ? WHERE id = ?;"));
+	while (modelsToUpdate->next()) {
+		int64_t modelId = modelsToUpdate->getInt64(1);
+		std::unique_ptr<sql::Blob> oldLxfml(modelsToUpdate->getBlob(2));
 		// Check if the stored blob starts with zlib magic (0x78 0xDA - best compression of zlib)
 		// If it does, convert it to sd0.
-		if (model.lxfmlData.get() == 0x78 && model.lxfmlData.get() == 0xDA) {
+		if (oldLxfml->get() == 0x78 && oldLxfml->get() == 0xDA) {
+
 			// Get and save size of zlib compressed chunk.
-			model.lxfmlData.seekg(0, std::ios::end);
-			uint32_t oldLxfmlSize = static_cast<uint32_t>(model.lxfmlData.tellg());
-			model.lxfmlData.seekg(0);
+			oldLxfml->seekg(0, std::ios::end);
+			uint32_t oldLxfmlSize = static_cast<uint32_t>(oldLxfml->tellg());
+			oldLxfml->seekg(0);
 
 			// Allocate 9 extra bytes.  5 for sd0 magic, 4 for the only zlib compressed size.
 			uint32_t oldLxfmlSizeWithHeader = oldLxfmlSize + 9;
@@ -113,27 +130,36 @@ uint32_t BrickByBrickFix::UpdateBrickByBrickModelsToSd0() {
 
 			WriteSd0Magic(sd0ConvertedModel.get(), oldLxfmlSize);
 			for (uint32_t i = 9; i < oldLxfmlSizeWithHeader; i++) {
-				sd0ConvertedModel.get()[i] = model.lxfmlData.get();
+				sd0ConvertedModel.get()[i] = oldLxfml->get();
 			}
 
 			std::string outputString(sd0ConvertedModel.get(), oldLxfmlSizeWithHeader);
 			std::istringstream outputStringStream(outputString);
 
+			insertionStatement->setBlob(1, static_cast<std::istream*>(&outputStringStream));
+			insertionStatement->setInt64(2, modelId);
 			try {
-				Database::Get()->UpdateUgcModelData(model.id, outputStringStream);
-				LOG("Updated model %i to sd0", model.id);
+				insertionStatement->executeUpdate();
+				Game::logger->Log("BrickByBrickFix", "Updated model %i to sd0", modelId);
 				updatedModels++;
 			} catch (sql::SQLException exception) {
-				LOG("Failed to update model %i.  This model should be inspected manually to see why."
-					"The database error is %s", model.id, exception.what());
+				Game::logger->Log(
+					"BrickByBrickFix",
+					"Failed to update model %i.  This model should be inspected manually to see why."
+					"The database error is %s", modelId, exception.what());
 			}
 		}
 	}
-	Database::Get()->Commit();
-	Database::Get()->SetAutoCommit(previousAutoCommitState);
+	Database::Commit();
+	Database::SetAutoCommit(previousAutoCommitState);
 	return updatedModels;
 }
 
+std::unique_ptr<sql::ResultSet> GetModelsFromDatabase() {
+	std::unique_ptr<sql::PreparedStatement> modelsRawDataQuery(Database::CreatePreppedStmt("SELECT id, lxfml FROM ugc;"));
+	return std::unique_ptr<sql::ResultSet>(modelsRawDataQuery->executeQuery());
+}
+
 /**
  * @brief Writes sd0 magic at the front of a char*
  *
@@ -149,6 +175,6 @@ void WriteSd0Magic(char* input, uint32_t chunkSize) {
 	*reinterpret_cast<uint32_t*>(input + 5) = chunkSize; // Write the integer to the character array
 }
 
-bool CheckSd0Magic(std::istream& streamToCheck) {
-	return streamToCheck.get() == 's' && streamToCheck.get() == 'd' && streamToCheck.get() == '0' && streamToCheck.get() == 0x01 && streamToCheck.get() == 0xFF;
+bool CheckSd0Magic(sql::Blob* streamToCheck) {
+	return streamToCheck->get() == 's' && streamToCheck->get() == 'd' && streamToCheck->get() == '0' && streamToCheck->get() == 0x01 && streamToCheck->get() == 0xFF;
 }

dCommon/CMakeLists.txt

@@ -1,10 +1,10 @@
-set(DCOMMON_SOURCES
+set(DCOMMON_SOURCES "AMFFormat.cpp"
 		"AMFDeserialize.cpp"
-		"AmfSerialize.cpp"
+		"AMFFormat_BitStream.cpp"
 		"BinaryIO.cpp"
 		"dConfig.cpp"
 		"Diagnostics.cpp"
-		"Logger.cpp"
+		"dLogger.cpp"
 		"GeneralUtils.cpp"
 		"LDFFormat.cpp"
 		"MD5.cpp"
@@ -12,7 +12,7 @@ set(DCOMMON_SOURCES
 		"NiPoint3.cpp"
 		"NiQuaternion.cpp"
 		"SHA512.cpp"
-		"Demangler.cpp"
+		"Type.cpp"
 		"ZCompression.cpp"
 		"BrickByBrickFix.cpp"
 		"BinaryPathFinder.cpp"

dCommon/Demangler.cpp

@@ -1,29 +0,0 @@
-#include "Demangler.h"
-#ifdef __GNUG__
-#include <cstdlib>
-#include <cxxabi.h>
-#include <memory>
-#include <typeinfo>
-
-std::string Demangler::Demangle(const char* name) {
-	// some arbitrary value to eliminate the compiler warning
-	// -4 is not a valid return value for __cxa_demangle so we'll use that.
-	int status = -4;
-
-	// __cxa_demangle requires that we free the returned char*
-	std::unique_ptr<char, void (*)(void*)> res{
-		abi::__cxa_demangle(name, NULL, NULL, &status),
-		std::free
-	};
-
-	return (status == 0) ? res.get() : "";
-}
-
-#else // __GNUG__
-
-// does nothing if not g++
-std::string Demangler::Demangle(const char* name) {
-	return name;
-}
-
-#endif // __GNUG__

dCommon/Demangler.h

@@ -1,9 +0,0 @@
-#pragma once
-
-#include <string>
-
-namespace Demangler {
-	// Given a char* containing a mangled name, return a std::string containing the demangled name.
-	// If the function fails for any reason, it returns an empty string.
-	std::string Demangle(const char* name);
-}

dCommon/Diagnostics.cpp

@@ -1,6 +1,6 @@
 #include "Diagnostics.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 // If we're on Win32, we'll include our minidump writer
 #ifdef _WIN32
@@ -9,7 +9,7 @@
 #include <Dbghelp.h>
 
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void make_minidump(EXCEPTION_POINTERS* e) {
 	auto hDbgHelp = LoadLibraryA("dbghelp");
@@ -28,7 +28,7 @@ void make_minidump(EXCEPTION_POINTERS* e) {
 			"_%4d%02d%02d_%02d%02d%02d.dmp",
 			t.wYear, t.wMonth, t.wDay, t.wHour, t.wMinute, t.wSecond);
 	}
-	LOG("Creating crash dump %s", name);
+	Game::logger->Log("Diagnostics", "Creating crash dump %s", name);
 	auto hFile = CreateFileA(name, GENERIC_WRITE, FILE_SHARE_READ, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 	if (hFile == INVALID_HANDLE_VALUE)
 		return;
@@ -83,7 +83,7 @@ struct bt_ctx {
 
 static inline void Bt(struct backtrace_state* state) {
 	std::string fileName = Diagnostics::GetOutDirectory() + "crash_" + Diagnostics::GetProcessName() + "_" + std::to_string(getpid()) + ".log";
-	LOG("backtrace is enabled, crash dump located at %s", fileName.c_str());
+	Game::logger->Log("Diagnostics", "backtrace is enabled, crash dump located at %s", fileName.c_str());
 	FILE* file = fopen(fileName.c_str(), "w+");
 	if (file != nullptr) {
 		backtrace_print(state, 2, file);
@@ -107,7 +107,7 @@ static void ErrorCallback(void* data, const char* msg, int errnum) {
 }
 #endif
 
-#include "Demangler.h"
+#include "Type.h"
 
 void GenerateDump() {
 	std::string cmd = "sudo gcore " + std::to_string(getpid());
@@ -118,56 +118,55 @@ void CatchUnhandled(int sig) {
 #ifndef __include_backtrace__
 
 	std::string fileName = Diagnostics::GetOutDirectory() + "crash_" + Diagnostics::GetProcessName() + "_" + std::to_string(getpid()) + ".log";
-	LOG("Encountered signal %i, creating crash dump %s", sig, fileName.c_str());
+	Game::logger->Log("Diagnostics", "Encountered signal %i, creating crash dump %s", sig, fileName.c_str());
 	if (Diagnostics::GetProduceMemoryDump()) {
 		GenerateDump();
 	}
-	constexpr uint8_t MaxStackTrace = 32;
-	void* array[MaxStackTrace];
+
+	void* array[10];
 	size_t size;
 
 	// get void*'s for all entries on the stack
-	size = backtrace(array, MaxStackTrace);
+	size = backtrace(array, 10);
 
-#  if defined(__GNUG__)
+#if defined(__GNUG__) and defined(__dynamic)
 
 	// Loop through the returned addresses, and get the symbols to be demangled
 	char** strings = backtrace_symbols(array, size);
 
-	FILE* file = fopen(fileName.c_str(), "w+");
-	if (file != NULL) {
-		fprintf(file, "Error: signal %d:\n", sig);
-	}
 	// Print the stack trace
 	for (size_t i = 0; i < size; i++) {
-		// Take a string like './WorldServer(_ZN19SlashCommandHandler17HandleChatCommandERKSbIDsSt11char_traitsIDsESaIDsEEP6EntityRK13SystemAddress+0x6187) [0x55869c44ecf7]'
-		// and extract '_ZN19SlashCommandHandler17HandleChatCommandERKSbIDsSt11char_traitsIDsESaIDsEEP6EntityRK13SystemAddress' from it to be demangled into a proper name
+		// Take a string like './WorldServer(_ZN19SlashCommandHandler17HandleChatCommandERKSbIDsSt11char_traitsIDsESaIDsEEP6EntityRK13SystemAddress+0x6187) [0x55869c44ecf7]' and extract the function name
 		std::string functionName = strings[i];
 		std::string::size_type start = functionName.find('(');
 		std::string::size_type end = functionName.find('+');
 		if (start != std::string::npos && end != std::string::npos) {
 			std::string demangled = functionName.substr(start + 1, end - start - 1);
 
-			demangled = Demangler::Demangle(demangled.c_str());
+			demangled = demangle(functionName.c_str());
 
-			// If the demangled string is not empty, then we can replace the mangled string with the demangled one
-			if (!demangled.empty()) {
-				demangled.push_back('(');
-				demangled += functionName.substr(end);
-				functionName = demangled;
+			if (demangled.empty()) {
+				Game::logger->Log("Diagnostics", "[%02zu] %s", i, demangled.c_str());
+			} else {
+				Game::logger->Log("Diagnostics", "[%02zu] %s", i, functionName.c_str());
 			}
-		}
-
-		LOG("[%02zu] %s", i, functionName.c_str());
-		if (file != NULL) {
-			fprintf(file, "[%02zu] %s\n", i, functionName.c_str());
+		} else {
+			Game::logger->Log("Diagnostics", "[%02zu] %s", i, functionName.c_str());
 		}
 	}
-#  else // defined(__GNUG__)
+#else
 	backtrace_symbols_fd(array, size, STDOUT_FILENO);
-#  endif // defined(__GNUG__)
+#endif
 
-#else // __include_backtrace__
+	FILE* file = fopen(fileName.c_str(), "w+");
+	if (file != NULL) {
+		// print out all the frames to stderr
+		fprintf(file, "Error: signal %d:\n", sig);
+		backtrace_symbols_fd(array, size, fileno(file));
+		fclose(file);
+	}
+
+#else
 
 	struct backtrace_state* state = backtrace_create_state(
 		Diagnostics::GetProcessFileName().c_str(),
@@ -178,7 +177,7 @@ void CatchUnhandled(int sig) {
 	struct bt_ctx ctx = { state, 0 };
 	Bt(state);
 
-#endif // __include_backtrace__
+#endif
 
 	exit(EXIT_FAILURE);
 }

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

@@ -9,7 +9,7 @@
 #include "CDClientDatabase.h"
 #include "GeneralUtils.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "AssetManager.h"
 
 #include "eSqliteDataType.h"
@@ -44,7 +44,7 @@ bool FdbToSqlite::Convert::ConvertDatabase(AssetMemoryBuffer& buffer) {
 
 		CDClientDatabase::ExecuteQuery("COMMIT;");
 	} catch (CppSQLite3Exception& e) {
-		LOG("Encountered error %s converting FDB to SQLite", e.errorMessage());
+		Game::logger->Log("FdbToSqlite", "Encountered error %s converting FDB to SQLite", e.errorMessage());
 		return false;
 	}
 

dCommon/Game.h

@@ -3,19 +3,16 @@
 #include <random>
 
 class dServer;
-class Logger;
+class dLogger;
 class InstanceManager;
 class dChatFilter;
 class dConfig;
 class RakPeerInterface;
 class AssetManager;
 struct SystemAddress;
-class EntityManager;
-class dZoneManager;
-class PlayerContainer;
 
 namespace Game {
-	extern Logger* logger;
+	extern dLogger* logger;
 	extern dServer* server;
 	extern InstanceManager* im;
 	extern dChatFilter* chatFilter;
@@ -25,7 +22,4 @@ namespace Game {
 	extern AssetManager* assetManager;
 	extern SystemAddress chatSysAddr;
 	extern bool shouldShutdown;
-	extern EntityManager* entityManager;
-	extern dZoneManager* zoneManager;
-	extern PlayerContainer playerContainer;
 }

dCommon/GeneralUtils.h

@@ -13,7 +13,7 @@
 #include "NiPoint3.h"
 
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 enum eInventoryType : uint32_t;
 enum class eObjectBits : size_t;
@@ -111,6 +111,29 @@ 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);
@@ -126,11 +149,6 @@ namespace GeneralUtils {
 	template <typename T>
 	T Parse(const char* value);
 
-	template <>
-	inline bool Parse(const char* value) {
-		return std::stoi(value);
-	}
-
 	template <>
 	inline int32_t Parse(const char* value) {
 		return std::stoi(value);
@@ -151,11 +169,6 @@ namespace GeneralUtils {
 		return std::stod(value);
 	}
 
-	template <>
-	inline uint16_t Parse(const char* value) {
-		return std::stoul(value);
-	}
-
 	template <>
 	inline uint32_t Parse(const char* value) {
 		return std::stoul(value);
@@ -210,42 +223,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

@@ -4,7 +4,7 @@
 #include "GeneralUtils.h"
 
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 // C++
 #include <string_view>
@@ -48,7 +48,7 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	try {
 		type = static_cast<eLDFType>(strtol(ldfTypeAndValue.first.data(), &storage, 10));
 	} catch (std::exception) {
-		LOG("Attempted to process invalid ldf type (%s) from string (%s)", ldfTypeAndValue.first.data(), format.data());
+		Game::logger->Log("LDFFormat", "Attempted to process invalid ldf type (%s) from string (%s)", ldfTypeAndValue.first.data(), format.data());
 		return nullptr;
 	}
 
@@ -61,33 +61,35 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	}
 
 	case LDF_TYPE_S32: {
-		int32_t data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
-			LOG("Warning: Attempted to process invalid int32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		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;
 		}
-		returnValue = new LDFData<int32_t>(key, data);
-
 		break;
 	}
 
 	case LDF_TYPE_FLOAT: {
-		float data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
-			LOG("Warning: Attempted to process invalid float value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		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;
 		}
-		returnValue = new LDFData<float>(key, data);
 		break;
 	}
 
 	case LDF_TYPE_DOUBLE: {
-		double data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
-			LOG("Warning: Attempted to process invalid double value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		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;
 		}
-		returnValue = new LDFData<double>(key, data);
 		break;
 	}
 
@@ -100,8 +102,10 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 		} else if (ldfTypeAndValue.second == "false") {
 			data = 0;
 		} else {
-			if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
-				LOG("Warning: Attempted to process invalid uint32 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			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());
 				return nullptr;
 			}
 		}
@@ -118,8 +122,10 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 		} else if (ldfTypeAndValue.second == "false") {
 			data = false;
 		} else {
-			if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
-				LOG("Warning: Attempted to process invalid bool value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+			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;
 			}
 		}
@@ -129,22 +135,24 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	}
 
 	case LDF_TYPE_U64: {
-		uint64_t data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
-			LOG("Warning: Attempted to process invalid uint64 value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		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;
 		}
-		returnValue = new LDFData<uint64_t>(key, data);
 		break;
 	}
 
 	case LDF_TYPE_OBJID: {
-		LWOOBJID data;
-		if (!GeneralUtils::TryParse(ldfTypeAndValue.second.data(), data)) {
-			LOG("Warning: Attempted to process invalid LWOOBJID value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		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;
 		}
-		returnValue = new LDFData<LWOOBJID>(key, data);
 		break;
 	}
 
@@ -155,12 +163,12 @@ LDFBaseData* LDFBaseData::DataFromString(const std::string_view& format) {
 	}
 
 	case LDF_TYPE_UNKNOWN: {
-		LOG("Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
+		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid unknown value (%s) from string (%s)", ldfTypeAndValue.second.data(), format.data());
 		break;
 	}
 
 	default: {
-		LOG("Warning: Attempted to process invalid LDF type (%d) from string (%s)", type, format.data());
+		Game::logger->Log("LDFFormat", "Warning: Attempted to process invalid LDF type (%d) from string (%s)", type, format.data());
 		break;
 	}
 	}

dCommon/Logger.cpp

@@ -1,96 +0,0 @@
-#include "Logger.h"
-
-#include <algorithm>
-#include <ctime>
-#include <filesystem>
-#include <stdarg.h>
-
-Writer::~Writer() {
-	// Dont try to close stdcout...
-	if (!m_Outfile || m_IsConsoleWriter) return;
-
-	fclose(m_Outfile);
-	m_Outfile = NULL;
-}
-
-void Writer::Log(const char* time, const char* message) {
-	if (!m_Outfile) return;
-
-	fputs(time, m_Outfile);
-	fputs(message, m_Outfile);
-}
-
-void Writer::Flush() {
-	if (!m_Outfile) return;
-	fflush(m_Outfile);
-}
-
-FileWriter::FileWriter(const char* outpath) {
-	m_Outfile = fopen(outpath, "wt");
-	if (!m_Outfile) printf("Couldn't open %s for writing!\n", outpath);
-	m_Outpath = outpath;
-	m_IsConsoleWriter = false;
-}
-
-ConsoleWriter::ConsoleWriter(bool enabled) {
-	m_Enabled = enabled;
-	m_Outfile = stdout;
-	m_IsConsoleWriter = true;
-}
-
-Logger::Logger(const std::string& outpath, bool logToConsole, bool logDebugStatements) {
-	m_logDebugStatements = logDebugStatements;
-	std::filesystem::path outpathPath(outpath);
-	if (!std::filesystem::exists(outpathPath.parent_path())) std::filesystem::create_directories(outpathPath.parent_path());
-	m_Writers.push_back(std::make_unique<FileWriter>(outpath));
-	m_Writers.push_back(std::make_unique<ConsoleWriter>(logToConsole));
-}
-
-void Logger::vLog(const char* format, va_list args) {
-	time_t t = time(NULL);
-	struct tm* time = localtime(&t);
-	char timeStr[70];
-	strftime(timeStr, sizeof(timeStr), "[%d-%m-%y %H:%M:%S ", time);
-	char message[2048];
-	vsnprintf(message, 2048, format, args);
-	for (const auto& writer : m_Writers) {
-		writer->Log(timeStr, message);
-	}
-}
-
-void Logger::Log(const char* className, const char* format, ...) {
-	va_list args;
-	std::string log = std::string(className) + "] " + std::string(format) + "\n";
-	va_start(args, format);
-	vLog(log.c_str(), args);
-	va_end(args);
-}
-
-void Logger::LogDebug(const char* className, const char* format, ...) {
-	if (!m_logDebugStatements) return;
-	va_list args;
-	std::string log = std::string(className) + "] " + std::string(format) + "\n";
-	va_start(args, format);
-	vLog(log.c_str(), args);
-	va_end(args);
-}
-
-void Logger::Flush() {
-	for (const auto& writer : m_Writers) {
-		writer->Flush();
-	}
-}
-
-void Logger::SetLogToConsole(bool logToConsole) {
-	for (const auto& writer : m_Writers) {
-		if (writer->IsConsoleWriter()) writer->SetEnabled(logToConsole);
-	}
-}
-
-bool Logger::GetLogToConsole() const {
-	bool toReturn = false;
-	for (const auto& writer : m_Writers) {
-		if (writer->IsConsoleWriter()) toReturn |= writer->GetEnabled();
-	}
-	return toReturn;
-}

dCommon/Logger.h

@@ -1,89 +0,0 @@
-#pragma once
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#define STRINGIFY_IMPL(x) #x
-
-#define STRINGIFY(x) STRINGIFY_IMPL(x)
-
-#define GET_FILE_NAME(x, y) GetFileNameFromAbsolutePath(__FILE__ x y)
-
-#define FILENAME_AND_LINE GET_FILE_NAME(":", STRINGIFY(__LINE__))
-
-// Calculate the filename at compile time from the path.
-// We just do this by scanning the path for the last '/' or '\' character and returning the string after it.
-constexpr const char* GetFileNameFromAbsolutePath(const char* path) {
-    const char* file = path;
-    while (*path) {
-		char nextChar = *path++;
-        if (nextChar == '/' || nextChar == '\\') {
-            file = path;
-        }
-    }
-    return file;
-}
-
-// These have to have a constexpr variable to store the filename_and_line result in a local variable otherwise
-// they will not be valid constexpr and will be evaluated at runtime instead of compile time!
-// The full string is still stored in the binary, however the offset of the filename in the absolute paths
-// is used in the instruction instead of the start of the absolute path.
-#define LOG(message, ...) do { auto str = FILENAME_AND_LINE; Game::logger->Log(str, message, ##__VA_ARGS__); } while(0)
-#define LOG_DEBUG(message, ...) do { auto str = FILENAME_AND_LINE; Game::logger->LogDebug(str, message, ##__VA_ARGS__); } while(0)
-
-// Writer class for writing data to files.
-class Writer {
-public:
-	Writer(bool enabled = true) : m_Enabled(enabled) {};
-	virtual ~Writer();
-
-	virtual void Log(const char* time, const char* message);
-	virtual void Flush();
-
-	void SetEnabled(bool disabled) { m_Enabled = disabled; }
-	bool GetEnabled() const { return m_Enabled; }
-
-	bool IsConsoleWriter() { return m_IsConsoleWriter; }
-public:
-	bool m_Enabled = true;
-	bool m_IsConsoleWriter = false;
-	FILE* m_Outfile;
-};
-
-// FileWriter class for writing data to a file on a disk.
-class FileWriter : public Writer {
-public:
-	FileWriter(const char* outpath);
-	FileWriter(const std::string& outpath) : FileWriter(outpath.c_str()) {};
-private:
-	std::string m_Outpath;
-};
-
-// ConsoleWriter class for writing data to the console.
-class ConsoleWriter : public Writer {
-public:
-	ConsoleWriter(bool enabled);
-};
-
-class Logger {
-public:
-	Logger() = delete;
-	Logger(const std::string& outpath, bool logToConsole, bool logDebugStatements);
-
-	void Log(const char* filenameAndLine, const char* format, ...);
-	void LogDebug(const char* filenameAndLine, const char* format, ...);
-
-	void Flush();
-
-	bool GetLogToConsole() const;
-	void SetLogToConsole(bool logToConsole);
-
-	void SetLogDebugStatements(bool logDebugStatements) { m_logDebugStatements = logDebugStatements; }
-
-private:
-	void vLog(const char* format, va_list args);
-
-	bool m_logDebugStatements;
-	std::vector<std::unique_ptr<Writer>> m_Writers;
-};

dCommon/NiPoint3.cpp

@@ -129,19 +129,10 @@ NiPoint3 NiPoint3::operator+(const NiPoint3& point) const {
 }
 
 //! Operator for addition of vectors
-NiPoint3& NiPoint3::operator+=(const NiPoint3& point) {
-	this->x += point.x;
-	this->y += point.y;
-	this->z += point.z;
-	return *this;
+NiPoint3 NiPoint3::operator+=(const NiPoint3& point) const {
+	return NiPoint3(this->x + point.x, this->y + point.y, this->z + point.z);
 }
 
-NiPoint3& NiPoint3::operator*=(const float scalar) {
-	this->x *= scalar;
-	this->y *= scalar;
-	this->z *= scalar;
-	return *this;
-}
 
 //! Operator for subtraction of vectors
 NiPoint3 NiPoint3::operator-(const NiPoint3& point) const {

dCommon/NiPoint3.h

@@ -136,9 +136,7 @@ public:
 	NiPoint3 operator+(const NiPoint3& point) const;
 
 	//! Operator for addition of vectors
-	NiPoint3& operator+=(const NiPoint3& point);
-
-	NiPoint3& operator*=(const float scalar);
+	NiPoint3 operator+=(const NiPoint3& point) const;
 
 	//! Operator for subtraction of vectors
 	NiPoint3 operator-(const NiPoint3& point) const;

dCommon/Type.cpp

@@ -0,0 +1,27 @@
+#include "Type.h"
+#ifdef __GNUG__
+#include <cstdlib>
+#include <memory>
+#include <cxxabi.h>
+
+std::string demangle(const char* name) {
+
+	int status = -4; // some arbitrary value to eliminate the compiler warning
+
+	// enable c++11 by passing the flag -std=c++11 to g++
+	std::unique_ptr<char, void(*)(void*)> res{
+		abi::__cxa_demangle(name, NULL, NULL, &status),
+		std::free
+	};
+
+	return (status == 0) ? res.get() : name;
+}
+
+#else
+
+// does nothing if not g++
+std::string demangle(const char* name) {
+	return name;
+}
+
+#endif

dCommon/Type.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <string>
+#include <typeinfo>
+
+std::string demangle(const char* name);
+
+template <class T>
+std::string type(const T& t) {
+
+	return demangle(typeid(t).name());
+}

dCommon/dClient/AssetManager.cpp

@@ -2,7 +2,7 @@
 
 #include "AssetManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 #include <zlib.h>
 

dCommon/dClient/AssetManager.h

@@ -42,7 +42,7 @@ struct AssetMemoryBuffer : std::streambuf {
 	}
 
 	void close() {
-		free(m_Base);
+		delete m_Base;
 	}
 };
 

dCommon/dClient/Pack.h

@@ -3,7 +3,6 @@
 #include <vector>
 #include <string>
 #include <filesystem>
-#include <fstream>
 
 #pragma pack(push, 1)
 struct PackRecord {

dCommon/dClient/PackIndex.cpp

@@ -1,7 +1,7 @@
 #include "PackIndex.h"
 #include "BinaryIO.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 PackIndex::PackIndex(const std::filesystem::path& filePath) {
 	m_FileStream = std::ifstream(filePath / "versions" / "primary.pki", std::ios::in | std::ios::binary);
@@ -34,7 +34,7 @@ PackIndex::PackIndex(const std::filesystem::path& filePath) {
 		m_PackFileIndices.push_back(packFileIndex);
 	}
 
-	LOG("Loaded pack catalog with %i pack files and %i files", m_PackPaths.size(), m_PackFileIndices.size());
+	Game::logger->Log("PackIndex", "Loaded pack catalog with %i pack files and %i files", m_PackPaths.size(), m_PackFileIndices.size());
 
 	for (auto& item : m_PackPaths) {
 		std::replace(item.begin(), item.end(), '\\', '/');

dCommon/dConfig.cpp

@@ -38,11 +38,13 @@ const std::string& dConfig::GetValue(std::string key) {
 }
 
 void dConfig::ProcessLine(const std::string& line) {
-	auto splitLoc = line.find('=');
-	auto key = line.substr(0, splitLoc);
-	auto value = line.substr(splitLoc + 1);
+	auto splitLine = GeneralUtils::SplitString(line, '=');
+
+	if (splitLine.size() != 2) return;
 
 	//Make sure that on Linux, we remove special characters:
+	auto& key = splitLine.at(0);
+	auto& value = splitLine.at(1);
 	if (!value.empty() && value.at(value.size() - 1) == '\r') value.erase(value.size() - 1);
 
 	if (this->m_ConfigValues.find(key) != this->m_ConfigValues.end()) return;

dCommon/dEnums/dCommonVars.h

@@ -9,7 +9,6 @@
 #include "BitStream.h"
 #include "eConnectionType.h"
 #include "eClientMessageType.h"
-#include "BitStreamUtils.h"
 
 #pragma warning (disable:4251) //Disables SQL warnings
 
@@ -29,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 BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+#define CMSGHEADER PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 #define SEND_PACKET Game::server->Send(&bitStream, sysAddr, false);
 #define SEND_PACKET_BROADCAST Game::server->Send(&bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
 

dCommon/dEnums/ePermissionMap.h

@@ -27,6 +27,20 @@ enum class ePermissionMap : uint64_t {
 	 * The character has restricted chat access, bit 6.
 	 */
 	RestrictedChatAccess = 0x1 << 6,
+
+	//
+	// Combined permissions
+	//
+
+	/**
+	 * The character is marked as 'old', restricted from trade and mail.
+	 */
+	Old = RestrictedTradeAccess | RestrictedMailAccess,
+
+	/**
+	* The character is soft banned, restricted from trade, mail, and chat.
+	*/
+	SoftBanned = RestrictedTradeAccess | RestrictedMailAccess | RestrictedChatAccess,
 };
 
 #endif  //!__EPERMISSIONMAP__H__

dCommon/dEnums/ePlayerFlag.h

@@ -166,8 +166,7 @@ enum ePlayerFlag : int32_t {
 	NJ_LIGHTNING_SPINJITZU = 2031,
 	NJ_ICE_SPINJITZU = 2032,
 	NJ_FIRE_SPINJITZU = 2033,
-	NJ_WU_SHOW_DAILY_CHEST = 2099,
-	DLU_SKIP_CINEMATICS = 1'000'000,
+	NJ_WU_SHOW_DAILY_CHEST = 2099
 };
 
 #endif  //!__EPLAYERFLAG__H__

dCommon/dEnums/eReplicaComponentType.h

@@ -34,7 +34,7 @@ enum class eReplicaComponentType : uint32_t {
 	PLATFORM_BOUNDARY,
 	MODULE,
 	ARCADE,
-	HAVOK_VEHICLE_PHYSICS,
+	VEHICLE_PHYSICS, // Havok demo based
 	MOVEMENT_AI,
 	EXHIBIT,
 	OVERHEAD_ICON,
@@ -50,11 +50,11 @@ enum class eReplicaComponentType : uint32_t {
 	PROPERTY_ENTRANCE,
 	FX,
 	PROPERTY_MANAGEMENT,
-	VEHICLE_PHYSICS,
+	VEHICLE_PHYSICS_NEW, // internal physics based on havok
 	PHYSICS_SYSTEM,
 	QUICK_BUILD,
 	SWITCH,
-	MINI_GAME_CONTROL,
+	ZONE_CONTROL, // Minigame
 	CHANGLING,
 	CHOICE_BUILD,
 	PACKAGE,
@@ -101,13 +101,13 @@ enum class eReplicaComponentType : uint32_t {
 	TRADE,
 	USER_CONTROL,
 	IGNORE_LIST,
-	MULTI_ZONE_ENTRANCE,
+	ROCKET_LAUNCH_LUP,
 	BUFF_REAL, // the real buff component, should just be name BUFF
 	INTERACTION_MANAGER,
 	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/eWorldMessageType.h

@@ -36,8 +36,7 @@ enum class eWorldMessageType : uint32_t {
 	HANDLE_FUNNESS,
 	FAKE_PRG_CSR_MESSAGE,
 	REQUEST_FREE_TRIAL_REFRESH,
-	GM_SET_FREE_TRIAL_STATUS,
-	UI_HELP_TOP_5 = 91
+	GM_SET_FREE_TRIAL_STATUS
 };
 
 #endif  //!__EWORLDMESSAGETYPE__H__

dCommon/dLogger.cpp

@@ -0,0 +1,110 @@
+#include "dLogger.h"
+
+dLogger::dLogger(const std::string& outpath, bool logToConsole, bool logDebugStatements) {
+	m_logToConsole = logToConsole;
+	m_logDebugStatements = logDebugStatements;
+	m_outpath = outpath;
+
+#ifdef _WIN32
+	mFile = std::ofstream(m_outpath);
+	if (!mFile) { printf("Couldn't open %s for writing!\n", outpath.c_str()); }
+#else
+	fp = fopen(outpath.c_str(), "wt");
+	if (fp == NULL) { printf("Couldn't open %s for writing!\n", outpath.c_str()); }
+#endif
+}
+
+dLogger::~dLogger() {
+#ifdef _WIN32
+	mFile.close();
+#else
+	if (fp != nullptr) {
+		fclose(fp);
+		fp = nullptr;
+	}
+#endif
+}
+
+void dLogger::vLog(const char* format, va_list args) {
+#ifdef _WIN32
+	time_t t = time(NULL);
+	struct tm time;
+	localtime_s(&time, &t);
+	char timeStr[70];
+	strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", &time);
+	char message[2048];
+	vsnprintf(message, 2048, format, args);
+
+	if (m_logToConsole) std::cout << "[" << timeStr << "] " << message;
+	mFile << "[" << timeStr << "] " << message;
+#else
+	time_t t = time(NULL);
+	struct tm* time = localtime(&t);
+	char timeStr[70];
+	strftime(timeStr, sizeof(timeStr), "%d-%m-%y %H:%M:%S", time);
+	char message[2048];
+	vsnprintf(message, 2048, format, args);
+
+	if (m_logToConsole) {
+		fputs("[", stdout);
+		fputs(timeStr, stdout);
+		fputs("] ", stdout);
+		fputs(message, stdout);
+	}
+
+	if (fp != nullptr) {
+		fputs("[", fp);
+		fputs(timeStr, fp);
+		fputs("] ", fp);
+		fputs(message, fp);
+	} else {
+		printf("Logger not initialized!\n");
+	}
+#endif
+}
+
+void dLogger::LogBasic(const char* format, ...) {
+	va_list args;
+	va_start(args, format);
+	vLog(format, args);
+	va_end(args);
+}
+
+void dLogger::LogBasic(const std::string& message) {
+	LogBasic(message.c_str());
+}
+
+void dLogger::Log(const char* className, const char* format, ...) {
+	va_list args;
+	std::string log = "[" + std::string(className) + "] " + std::string(format) + "\n";
+	va_start(args, format);
+	vLog(log.c_str(), args);
+	va_end(args);
+}
+
+void dLogger::Log(const std::string& className, const std::string& message) {
+	Log(className.c_str(), message.c_str());
+}
+
+void dLogger::LogDebug(const char* className, const char* format, ...) {
+	if (!m_logDebugStatements) return;
+	va_list args;
+	std::string log = "[" + std::string(className) + "] " + std::string(format) + "\n";
+	va_start(args, format);
+	vLog(log.c_str(), args);
+	va_end(args);
+}
+
+void dLogger::LogDebug(const std::string& className, const std::string& message) {
+	LogDebug(className.c_str(), message.c_str());
+}
+
+void dLogger::Flush() {
+#ifdef _WIN32
+	mFile.flush();
+#else
+	if (fp != nullptr) {
+		std::fflush(fp);
+	}
+#endif
+}

dCommon/dLogger.h

@@ -0,0 +1,38 @@
+#pragma once
+#include <ctime>
+#include <cstdarg>
+#include <string>
+#include <fstream>
+#include <iostream>
+
+class dLogger {
+public:
+	dLogger(const std::string& outpath, bool logToConsole, bool logDebugStatements);
+	~dLogger();
+
+	void SetLogToConsole(bool logToConsole) { m_logToConsole = logToConsole; }
+	void SetLogDebugStatements(bool logDebugStatements) { m_logDebugStatements = logDebugStatements; }
+	void vLog(const char* format, va_list args);
+
+	void LogBasic(const std::string& message);
+	void LogBasic(const char* format, ...);
+	void Log(const char* className, const char* format, ...);
+	void Log(const std::string& className, const std::string& message);
+	void LogDebug(const std::string& className, const std::string& message);
+	void LogDebug(const char* className, const char* format, ...);
+
+	void Flush();
+
+	const bool GetIsLoggingToConsole() const { return m_logToConsole; }
+
+private:
+	bool m_logDebugStatements;
+	bool m_logToConsole;
+	std::string m_outpath;
+	std::ofstream mFile;
+
+#ifndef _WIN32
+	//Glorious linux can run with SPEED:
+	FILE* fp = nullptr;
+#endif
+};

dDatabase/CDClientDatabase.h

@@ -13,7 +13,18 @@
 #include <sstream>
 #include <iostream>
 
-//! The CDClient Database namespace
+ // 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
+ */
+
+ //! The CDClient Database namespace
 namespace CDClientDatabase {
 
 	//! Opens a connection with the CDClient

dDatabase/CDClientDatabase/CDClientManager.cpp

@@ -1,92 +0,0 @@
-#include "CDClientManager.h"
-#include "CDActivityRewardsTable.h"
-#include "CDAnimationsTable.h"
-#include "CDBehaviorParameterTable.h"
-#include "CDBehaviorTemplateTable.h"
-#include "CDComponentsRegistryTable.h"
-#include "CDCurrencyTableTable.h"
-#include "CDDestructibleComponentTable.h"
-#include "CDEmoteTable.h"
-#include "CDInventoryComponentTable.h"
-#include "CDItemComponentTable.h"
-#include "CDItemSetsTable.h"
-#include "CDItemSetSkillsTable.h"
-#include "CDLevelProgressionLookupTable.h"
-#include "CDLootMatrixTable.h"
-#include "CDLootTableTable.h"
-#include "CDMissionNPCComponentTable.h"
-#include "CDMissionTasksTable.h"
-#include "CDMissionsTable.h"
-#include "CDObjectSkillsTable.h"
-#include "CDObjectsTable.h"
-#include "CDPhysicsComponentTable.h"
-#include "CDRebuildComponentTable.h"
-#include "CDScriptComponentTable.h"
-#include "CDSkillBehaviorTable.h"
-#include "CDZoneTableTable.h"
-#include "CDVendorComponentTable.h"
-#include "CDActivitiesTable.h"
-#include "CDPackageComponentTable.h"
-#include "CDProximityMonitorComponentTable.h"
-#include "CDMovementAIComponentTable.h"
-#include "CDBrickIDTableTable.h"
-#include "CDRarityTableTable.h"
-#include "CDMissionEmailTable.h"
-#include "CDRewardsTable.h"
-#include "CDPropertyEntranceComponentTable.h"
-#include "CDPropertyTemplateTable.h"
-#include "CDFeatureGatingTable.h"
-#include "CDRailActivatorComponent.h"
-#include "CDRewardCodesTable.h"
-
-// Uncomment this to cache the full cdclient database into memory. This will make the server load faster, but will use more memory.
-// A vanilla CDClient takes about 46MB of memory + the regular world data.
-// #define CDCLIENT_CACHE_ALL
-
-#ifdef CDCLIENT_CACHE_ALL
-	#define CDCLIENT_DONT_CACHE_TABLE(x) x
-#else
-	#define CDCLIENT_DONT_CACHE_TABLE(x)
-#endif
-
-CDClientManager::CDClientManager() {
-	CDActivityRewardsTable::Instance().LoadValuesFromDatabase();
-	CDActivitiesTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDAnimationsTable::Instance().LoadValuesFromDatabase());
-	CDBehaviorParameterTable::Instance().LoadValuesFromDatabase();
-	CDBehaviorTemplateTable::Instance().LoadValuesFromDatabase();
-	CDBrickIDTableTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDComponentsRegistryTable::Instance().LoadValuesFromDatabase());
-	CDCurrencyTableTable::Instance().LoadValuesFromDatabase();
-	CDDestructibleComponentTable::Instance().LoadValuesFromDatabase();
-	CDEmoteTableTable::Instance().LoadValuesFromDatabase();
-	CDFeatureGatingTable::Instance().LoadValuesFromDatabase();
-	CDInventoryComponentTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDItemComponentTable::Instance().LoadValuesFromDatabase());
-	CDItemSetSkillsTable::Instance().LoadValuesFromDatabase();
-	CDItemSetsTable::Instance().LoadValuesFromDatabase();
-	CDLevelProgressionLookupTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDLootMatrixTable::Instance().LoadValuesFromDatabase());
-	CDCLIENT_DONT_CACHE_TABLE(CDLootTableTable::Instance().LoadValuesFromDatabase());
-	CDMissionEmailTable::Instance().LoadValuesFromDatabase();
-	CDMissionNPCComponentTable::Instance().LoadValuesFromDatabase();
-	CDMissionTasksTable::Instance().LoadValuesFromDatabase();
-	CDMissionsTable::Instance().LoadValuesFromDatabase();
-	CDMovementAIComponentTable::Instance().LoadValuesFromDatabase();
-	CDObjectSkillsTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDObjectsTable::Instance().LoadValuesFromDatabase());
-	CDPhysicsComponentTable::Instance().LoadValuesFromDatabase();
-	CDPackageComponentTable::Instance().LoadValuesFromDatabase();
-	CDProximityMonitorComponentTable::Instance().LoadValuesFromDatabase();
-	CDPropertyEntranceComponentTable::Instance().LoadValuesFromDatabase();
-	CDPropertyTemplateTable::Instance().LoadValuesFromDatabase();
-	CDRailActivatorComponentTable::Instance().LoadValuesFromDatabase();
-	CDRarityTableTable::Instance().LoadValuesFromDatabase();
-	CDRebuildComponentTable::Instance().LoadValuesFromDatabase();
-	CDRewardCodesTable::Instance().LoadValuesFromDatabase();
-	CDRewardsTable::Instance().LoadValuesFromDatabase();
-	CDScriptComponentTable::Instance().LoadValuesFromDatabase();
-	CDSkillBehaviorTable::Instance().LoadValuesFromDatabase();
-	CDVendorComponentTable::Instance().LoadValuesFromDatabase();
-	CDZoneTableTable::Instance().LoadValuesFromDatabase();
-}

dDatabase/CDClientDatabase/CDClientTables/CDAnimationsTable.cpp

@@ -1,112 +0,0 @@
-#include "CDAnimationsTable.h"
-#include "GeneralUtils.h"
-#include "Game.h"
-
-
-void CDAnimationsTable::LoadValuesFromDatabase() {
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Animations");
-	while (!tableData.eof()) {
-		std::string animation_type = tableData.getStringField("animation_type", "");
-		DluAssert(!animation_type.empty());
-		AnimationGroupID animationGroupID = tableData.getIntField("animationGroupID", -1);
-		DluAssert(animationGroupID != -1);
-
-		CDAnimation entry;
-		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);)
-
-		this->animations[CDAnimationKey(animation_type, animationGroupID)].push_back(entry);
-		tableData.nextRow();
-	}
-
-	tableData.finalize();
-}
-
-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;
-
-	do {
-		std::string animation_type = tableData.getStringField("animation_type", "");
-		DluAssert(!animation_type.empty());
-		AnimationGroupID animationGroupID = tableData.getIntField("animationGroupID", -1);
-		DluAssert(animationGroupID != -1);
-
-		CDAnimation entry;
-		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);)
-
-		this->animations[CDAnimationKey(animation_type, animationGroupID)].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];
-	}
-}
-
-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)];
-}
-
-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/CDClientDatabase/CDClientTables/CDAnimationsTable.h

@@ -1,67 +0,0 @@
-#pragma once
-
-#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.
-	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
-	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
-};
-
-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:
-	void LoadValuesFromDatabase();
-	/**
-	 * 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:
-
-	/**
-	 * Cache all animations given a premade key
-	 */
-	void CacheAnimations(const CDAnimationKey animationKey);
-
-	/**
-	 * 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;
-};

dDatabase/CDClientDatabase/CDClientTables/CDComponentsRegistryTable.cpp

@@ -1,52 +0,0 @@
-#include "CDComponentsRegistryTable.h"
-#include "eReplicaComponentType.h"
-
-void CDComponentsRegistryTable::LoadValuesFromDatabase() {
-	// Now get the data
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ComponentsRegistry");
-	while (!tableData.eof()) {
-		CDComponentsRegistry entry;
-		entry.id = tableData.getIntField("id", -1);
-		entry.component_type = static_cast<eReplicaComponentType>(tableData.getIntField("component_type", 0));
-		entry.component_id = tableData.getIntField("component_id", -1);
-
-		this->mappedEntries.insert_or_assign(((uint64_t)entry.component_type) << 32 | ((uint64_t)entry.id), entry.component_id);
-		this->mappedEntries.insert_or_assign(entry.id, 0);
-
-		tableData.nextRow();
-	}
-
-	tableData.finalize();
-}
-
-int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponentType componentType, int32_t defaultValue) {
-	auto exists = mappedEntries.find(id);
-	if (exists != mappedEntries.end()) {
-		auto iter = mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
-		return iter == mappedEntries.end() ? defaultValue : iter->second;
-	}
-
-	// Now get the data. Get all components of this entity so we dont do a query for each component
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM ComponentsRegistry WHERE id = ?;");
-	query.bind(1, static_cast<int32_t>(id));
-
-	auto tableData = query.execQuery();
-
-	while (!tableData.eof()) {
-		CDComponentsRegistry entry;
-		entry.id = tableData.getIntField("id", -1);
-		entry.component_type = static_cast<eReplicaComponentType>(tableData.getIntField("component_type", 0));
-		entry.component_id = tableData.getIntField("component_id", -1);
-
-		this->mappedEntries.insert_or_assign(((uint64_t)entry.component_type) << 32 | ((uint64_t)entry.id), entry.component_id);
-
-		tableData.nextRow();
-	}
-
-	mappedEntries.insert_or_assign(id, 0);
-
-	auto iter = this->mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
-
-	return iter == this->mappedEntries.end() ? defaultValue : iter->second;
-}
-

dDatabase/CDClientDatabase/CDClientTables/CDEmoteTable.cpp

@@ -1,26 +0,0 @@
-#include "CDEmoteTable.h"
-
-void CDEmoteTableTable::LoadValuesFromDatabase() {
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Emotes");
-	while (!tableData.eof()) {
-		CDEmoteTable entry;
-		entry.ID = tableData.getIntField("id", -1);
-		entry.animationName = tableData.getStringField("animationName", "");
-		entry.iconFilename = tableData.getStringField("iconFilename", "");
-		entry.channel = tableData.getIntField("channel", -1);
-		entry.locked = tableData.getIntField("locked", -1) != 0;
-		entry.localize = tableData.getIntField("localize", -1) != 0;
-		entry.locState = tableData.getIntField("locStatus", -1);
-		entry.gateVersion = tableData.getStringField("gate_version", "");
-
-		entries.insert(std::make_pair(entry.ID, entry));
-		tableData.nextRow();
-	}
-
-	tableData.finalize();
-}
-
-CDEmoteTable* CDEmoteTableTable::GetEmote(int id) {
-	auto itr = entries.find(id);
-	return itr != entries.end() ? &itr->second : nullptr;
-}

dDatabase/CDClientDatabase/CDClientTables/CDLootMatrixTable.cpp

@@ -1,58 +0,0 @@
-#include "CDLootMatrixTable.h"
-
-CDLootMatrix CDLootMatrixTable::ReadRow(CppSQLite3Query& tableData) const {
-	CDLootMatrix entry{};
-	if (tableData.eof()) return entry;
-	entry.LootTableIndex = tableData.getIntField("LootTableIndex", -1);
-	entry.RarityTableIndex = tableData.getIntField("RarityTableIndex", -1);
-	entry.percent = tableData.getFloatField("percent", -1.0f);
-	entry.minToDrop = tableData.getIntField("minToDrop", -1);
-	entry.maxToDrop = tableData.getIntField("maxToDrop", -1);
-	entry.flagID = tableData.getIntField("flagID", -1);
-	UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
-	return entry;
-}
-
-void CDLootMatrixTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LootMatrix");
-	while (!tableSize.eof()) {
-		size = tableSize.getIntField(0, 0);
-
-		tableSize.nextRow();
-	}
-
-	// Reserve the size
-	this->entries.reserve(size);
-
-	// Now get the data
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM LootMatrix");
-	while (!tableData.eof()) {
-		CDLootMatrix entry;
-		uint32_t lootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
-
-		this->entries[lootMatrixIndex].push_back(ReadRow(tableData));
-		tableData.nextRow();
-	}
-}
-
-const LootMatrixEntries& CDLootMatrixTable::GetMatrix(uint32_t matrixId) {
-	auto itr = this->entries.find(matrixId);
-	if (itr != this->entries.end()) {
-		return itr->second;
-	}
-
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM LootMatrix where LootMatrixIndex = ?;");
-	query.bind(1, static_cast<int32_t>(matrixId));
-
-	auto tableData = query.execQuery();
-	while (!tableData.eof()) {
-		this->entries[matrixId].push_back(ReadRow(tableData));
-		tableData.nextRow();
-	}
-
-	return this->entries[matrixId];
-}
-

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.cpp

@@ -1,86 +0,0 @@
-#include "CDLootTableTable.h"
-#include "CDClientManager.h"
-#include "CDComponentsRegistryTable.h"
-#include "CDItemComponentTable.h"
-#include "eReplicaComponentType.h"
-
-// Sort the tables by their rarity so the highest rarity items are first.
-void SortTable(LootTableEntries& table) {
-	auto* componentsRegistryTable = CDClientManager::Instance().GetTable<CDComponentsRegistryTable>();
-	auto* itemComponentTable = CDClientManager::Instance().GetTable<CDItemComponentTable>();
-	// We modify the table in place so the outer loop keeps track of what is sorted
-	// and the inner loop finds the highest rarity item and swaps it with the current position
-	// of the outer loop.
-	for (auto oldItrOuter = table.begin(); oldItrOuter != table.end(); oldItrOuter++) {
-		auto lootToInsert = oldItrOuter;
-		// Its fine if this starts at 0, even if this doesnt match lootToInsert as the actual highest will
-		// either be found and overwrite these values, or the original is somehow zero and is still the highest rarity.
-		uint32_t highestLootRarity = 0;
-		for (auto oldItrInner = oldItrOuter; oldItrInner != table.end(); oldItrInner++) {
-			uint32_t itemComponentId = componentsRegistryTable->GetByIDAndType(oldItrInner->itemid, eReplicaComponentType::ITEM);
-			uint32_t rarity = itemComponentTable->GetItemComponentByID(itemComponentId).rarity;
-			if (rarity > highestLootRarity) {
-				highestLootRarity = rarity;
-				lootToInsert = oldItrInner;
-			}
-		}
-		std::swap(*oldItrOuter, *lootToInsert);
-	}
-}
-
-CDLootTable CDLootTableTable::ReadRow(CppSQLite3Query& tableData) const {
-	CDLootTable entry{};
-	if (tableData.eof()) return entry;
-	entry.itemid = tableData.getIntField("itemid", -1);
-	entry.MissionDrop = tableData.getIntField("MissionDrop", -1) == 1 ? true : false;
-	entry.sortPriority = tableData.getIntField("sortPriority", -1);
-	return entry;
-}
-
-void CDLootTableTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LootTable");
-	while (!tableSize.eof()) {
-		size = tableSize.getIntField(0, 0);
-
-		tableSize.nextRow();
-	}
-
-	// Reserve the size
-	this->entries.reserve(size);
-
-	// Now get the data
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM LootTable");
-	while (!tableData.eof()) {
-		CDLootTable entry;
-		uint32_t lootTableIndex = tableData.getIntField("LootTableIndex", -1);
-
-		this->entries[lootTableIndex].push_back(ReadRow(tableData));
-		tableData.nextRow();
-	}
-	for (auto& [id, table] : this->entries) {
-		SortTable(table);
-	}
-}
-
-const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
-	auto itr = this->entries.find(tableId);
-	if (itr != this->entries.end()) {
-		return itr->second;
-	}
-
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM LootTable WHERE LootTableIndex = ?;");
-	query.bind(1, static_cast<int32_t>(tableId));
-	auto tableData = query.execQuery();
-
-	while (!tableData.eof()) {
-		CDLootTable entry;
-		this->entries[tableId].push_back(ReadRow(tableData));
-		tableData.nextRow();
-	}
-	SortTable(this->entries[tableId]);
-
-	return this->entries[tableId];
-}

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.cpp

@@ -1,35 +0,0 @@
-#include "CDPhysicsComponentTable.h"
-
-void CDPhysicsComponentTable::LoadValuesFromDatabase() {
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PhysicsComponent");
-	while (!tableData.eof()) {
-		CDPhysicsComponent entry;
-		entry.id = tableData.getIntField("id", -1);
-		entry.bStatic = tableData.getIntField("static", -1) != 0;
-		entry.physicsAsset = tableData.getStringField("physics_asset", "");
-		UNUSED(entry->jump = tableData.getIntField("jump", -1) != 0);
-		UNUSED(entry->doublejump = tableData.getIntField("doublejump", -1) != 0);
-		entry.speed = tableData.getFloatField("speed", -1);
-		UNUSED(entry->rotSpeed = tableData.getFloatField("rotSpeed", -1));
-		entry.playerHeight = tableData.getFloatField("playerHeight");
-		entry.playerRadius = tableData.getFloatField("playerRadius");
-		entry.pcShapeType = tableData.getIntField("pcShapeType");
-		entry.collisionGroup = tableData.getIntField("collisionGroup");
-		UNUSED(entry->airSpeed = tableData.getFloatField("airSpeed"));
-		UNUSED(entry->boundaryAsset = tableData.getStringField("boundaryAsset"));
-		UNUSED(entry->jumpAirSpeed = tableData.getFloatField("jumpAirSpeed"));
-		UNUSED(entry->friction = tableData.getFloatField("friction"));
-		UNUSED(entry->gravityVolumeAsset = tableData.getStringField("gravityVolumeAsset"));
-
-		m_entries.insert(std::make_pair(entry.id, entry));
-		tableData.nextRow();
-	}
-
-	tableData.finalize();
-}
-
-CDPhysicsComponent* CDPhysicsComponentTable::GetByID(unsigned int componentID) {
-	auto itr = m_entries.find(componentID);
-	return itr != m_entries.end() ? &itr->second : nullptr;
-}
-

dDatabase/CDClientDatabase/CDClientTables/CDRarityTableTable.cpp

@@ -1,34 +0,0 @@
-#include "CDRarityTableTable.h"
-
-void CDRarityTableTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RarityTable");
-	while (!tableSize.eof()) {
-		size = tableSize.getIntField(0, 0);
-
-		tableSize.nextRow();
-	}
-
-	tableSize.finalize();
-
-	// Reserve the size
-	this->entries.reserve(size);
-
-	// Now get the data
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM RarityTable order by randmax desc;");
-	while (!tableData.eof()) {
-		uint32_t rarityTableIndex = tableData.getIntField("RarityTableIndex", -1);
-
-		CDRarityTable entry;
-		entry.randmax = tableData.getFloatField("randmax", -1);
-		entry.rarity = tableData.getIntField("rarity", -1);
-		entries[rarityTableIndex].push_back(entry);
-		tableData.nextRow();
-	}
-}
-
-const std::vector<CDRarityTable>& CDRarityTableTable::GetRarityTable(uint32_t id) {
-	return entries[id];
-}

dDatabase/CDClientDatabase/CDClientTables/CDRarityTableTable.h

@@ -1,23 +0,0 @@
-#pragma once
-
-// Custom Classes
-#include "CDTable.h"
-
-struct CDRarityTable {
-	float randmax;
-	unsigned int rarity;
-};
-
-typedef std::vector<CDRarityTable> RarityTable;
-
-class CDRarityTableTable : public CDTable<CDRarityTableTable> {
-private:
-	typedef uint32_t RarityTableIndex;
-	std::unordered_map<RarityTableIndex, std::vector<CDRarityTable>> entries;
-
-public:
-	void LoadValuesFromDatabase();
-
-	const std::vector<CDRarityTable>& GetRarityTable(uint32_t predicate);
-};
-

dDatabase/CDClientDatabase/CDClientTables/CDRewardCodesTable.cpp

@@ -1,47 +0,0 @@
-#include "CDRewardCodesTable.h"
-
-void CDRewardCodesTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RewardCodes");
-	while (!tableSize.eof()) {
-		size = tableSize.getIntField(0, 0);
-
-		tableSize.nextRow();
-	}
-
-	tableSize.finalize();
-
-	// Reserve the size
-	this->entries.reserve(size);
-
-	// Now get the data
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM RewardCodes");
-	while (!tableData.eof()) {
-		CDRewardCode entry;
-		entry.id = tableData.getIntField("id", -1);
-		entry.code = tableData.getStringField("code", "");
-		entry.attachmentLOT = tableData.getIntField("attachmentLOT", -1);
-		UNUSED_COLUMN(entry.locStatus = tableData.getIntField("locStatus", -1));
-		UNUSED_COLUMN(entry.gate_version = tableData.getStringField("gate_version", ""));
-
-		this->entries.push_back(entry);
-		tableData.nextRow();
-	}
-}
-
-LOT CDRewardCodesTable::GetAttachmentLOT(uint32_t rewardCodeId) const {
-	for (auto const &entry : this->entries){
-		if (rewardCodeId == entry.id) return entry.attachmentLOT;
-	}
-	return LOT_NULL;
-}
-
-uint32_t CDRewardCodesTable::GetCodeID(std::string code) const {
-	for (auto const &entry : this->entries){
-		if (code == entry.code) return entry.id;
-	}
-	return -1;
-}
-

dDatabase/CDClientDatabase/CDClientTables/CDRewardCodesTable.h

@@ -1,25 +0,0 @@
-#pragma once
-
-// Custom Classes
-#include "CDTable.h"
-
-
-struct CDRewardCode {
-	uint32_t id;
-	std::string code;
-	LOT attachmentLOT;
-	UNUSED(uint32_t locStatus);
-	UNUSED(std::string gate_version);
-};
-
-
-class CDRewardCodesTable : public CDTable<CDRewardCodesTable> {
-private:
-	std::vector<CDRewardCode> entries;
-
-public:
-	void LoadValuesFromDatabase();
-	const std::vector<CDRewardCode>& GetEntries() const;
-	LOT GetAttachmentLOT(uint32_t rewardCodeId) const;
-	uint32_t GetCodeID(std::string code) const;
-};

dDatabase/CDClientDatabase/CDClientTables/CDRewardsTable.cpp

@@ -1,29 +0,0 @@
-#include "CDRewardsTable.h"
-
-void CDRewardsTable::LoadValuesFromDatabase() {
-	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Rewards");
-	while (!tableData.eof()) {
-		CDRewards entry;
-		entry.id = tableData.getIntField("id", -1);
-		entry.levelID = tableData.getIntField("LevelID", -1);
-		entry.missionID = tableData.getIntField("MissionID", -1);
-		entry.rewardType = tableData.getIntField("RewardType", -1);
-		entry.value = tableData.getIntField("value", -1);
-		entry.count = tableData.getIntField("count", -1);
-
-		m_entries.insert(std::make_pair(entry.id, entry));
-		tableData.nextRow();
-	}
-
-	tableData.finalize();
-}
-
-std::vector<CDRewards> CDRewardsTable::GetByLevelID(uint32_t levelID) {
-	std::vector<CDRewards> result{};
-	for (const auto& e : m_entries) {
-		if (e.second.levelID == levelID) result.push_back(e.second);
-	}
-
-	return result;
-}
-

dDatabase/CDClientDatabase/CMakeLists.txt

@@ -1,12 +0,0 @@
-set(DDATABASE_CDCLIENTDATABASE_SOURCES
-	"CDClientDatabase.cpp"
-	"CDClientManager.cpp"
-)
-
-add_subdirectory(CDClientTables)
-
-foreach(file ${DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES})
-	set(DDATABASE_CDCLIENTDATABASE_SOURCES ${DDATABASE_CDCLIENTDATABASE_SOURCES} "CDClientTables/${file}")
-endforeach()
-
-set(DDATABASE_CDCLIENTDATABASE_SOURCES ${DDATABASE_CDCLIENTDATABASE_SOURCES} PARENT_SCOPE)

dDatabase/CDClientManager.cpp

@@ -0,0 +1,80 @@
+#include "CDClientManager.h"
+#include "CDActivityRewardsTable.h"
+#include "CDAnimationsTable.h"
+#include "CDBehaviorParameterTable.h"
+#include "CDBehaviorTemplateTable.h"
+#include "CDComponentsRegistryTable.h"
+#include "CDCurrencyTableTable.h"
+#include "CDDestructibleComponentTable.h"
+#include "CDEmoteTable.h"
+#include "CDInventoryComponentTable.h"
+#include "CDItemComponentTable.h"
+#include "CDItemSetsTable.h"
+#include "CDItemSetSkillsTable.h"
+#include "CDLevelProgressionLookupTable.h"
+#include "CDLootMatrixTable.h"
+#include "CDLootTableTable.h"
+#include "CDMissionNPCComponentTable.h"
+#include "CDMissionTasksTable.h"
+#include "CDMissionsTable.h"
+#include "CDObjectSkillsTable.h"
+#include "CDObjectsTable.h"
+#include "CDPhysicsComponentTable.h"
+#include "CDRebuildComponentTable.h"
+#include "CDScriptComponentTable.h"
+#include "CDSkillBehaviorTable.h"
+#include "CDZoneTableTable.h"
+#include "CDVendorComponentTable.h"
+#include "CDActivitiesTable.h"
+#include "CDPackageComponentTable.h"
+#include "CDProximityMonitorComponentTable.h"
+#include "CDMovementAIComponentTable.h"
+#include "CDBrickIDTableTable.h"
+#include "CDRarityTableTable.h"
+#include "CDMissionEmailTable.h"
+#include "CDRewardsTable.h"
+#include "CDPropertyEntranceComponentTable.h"
+#include "CDPropertyTemplateTable.h"
+#include "CDFeatureGatingTable.h"
+#include "CDRailActivatorComponent.h"
+
+CDClientManager::CDClientManager() {
+	CDActivityRewardsTable::Instance();
+	UNUSED(CDAnimationsTable::Instance());
+	CDBehaviorParameterTable::Instance();
+	CDBehaviorTemplateTable::Instance();
+	CDComponentsRegistryTable::Instance();
+	CDCurrencyTableTable::Instance();
+	CDDestructibleComponentTable::Instance();
+	CDEmoteTableTable::Instance();
+	CDInventoryComponentTable::Instance();
+	CDItemComponentTable::Instance();
+	CDItemSetsTable::Instance();
+	CDItemSetSkillsTable::Instance();
+	CDLevelProgressionLookupTable::Instance();
+	CDLootMatrixTable::Instance();
+	CDLootTableTable::Instance();
+	CDMissionNPCComponentTable::Instance();
+	CDMissionTasksTable::Instance();
+	CDMissionsTable::Instance();
+	CDObjectSkillsTable::Instance();
+	CDObjectsTable::Instance();
+	CDPhysicsComponentTable::Instance();
+	CDRebuildComponentTable::Instance();
+	CDScriptComponentTable::Instance();
+	CDSkillBehaviorTable::Instance();
+	CDZoneTableTable::Instance();
+	CDVendorComponentTable::Instance();
+	CDActivitiesTable::Instance();
+	CDPackageComponentTable::Instance();
+	CDProximityMonitorComponentTable::Instance();
+	CDMovementAIComponentTable::Instance();
+	CDBrickIDTableTable::Instance();
+	CDRarityTableTable::Instance();
+	CDMissionEmailTable::Instance();
+	CDRewardsTable::Instance();
+	CDPropertyEntranceComponentTable::Instance();
+	CDPropertyTemplateTable::Instance();
+	CDFeatureGatingTable::Instance();
+	CDRailActivatorComponentTable::Instance();
+}

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/CMakeLists.txt

@@ -1,15 +1,12 @@
-set(DDATABASE_SOURCES)
+set(DDATABASE_SOURCES "CDClientDatabase.cpp"
+		"CDClientManager.cpp"
+		"Database.cpp"
+		"MigrationRunner.cpp")
 
-add_subdirectory(CDClientDatabase)
+add_subdirectory(Tables)
 
-foreach(file ${DDATABASE_CDCLIENTDATABASE_SOURCES})
-	set(DDATABASE_SOURCES ${DDATABASE_SOURCES} "CDClientDatabase/${file}")
-endforeach()
-
-add_subdirectory(GameDatabase)
-
-foreach(file ${DDATABASE_GAMEDATABASE_SOURCES})
-	set(DDATABASE_SOURCES ${DDATABASE_SOURCES} "GameDatabase/${file}")
+foreach(file ${DDATABASE_TABLES_SOURCES})
+	set(DDATABASE_SOURCES ${DDATABASE_SOURCES} "Tables/${file}")
 endforeach()
 
 add_library(dDatabase STATIC ${DDATABASE_SOURCES})

dDatabase/Database.cpp

@@ -0,0 +1,118 @@
+#include "Database.h"
+#include "Game.h"
+#include "dConfig.h"
+#include "dLogger.h"
+using namespace std;
+
+#pragma warning (disable:4251) //Disables SQL warnings
+
+sql::Driver* Database::driver;
+sql::Connection* Database::con;
+sql::Properties Database::props;
+std::string Database::database;
+
+void Database::Connect(const string& host, const string& database, const string& username, const string& password) {
+
+	//To bypass debug issues:
+	const char* szDatabase = database.c_str();
+	const char* szUsername = username.c_str();
+	const char* szPassword = password.c_str();
+
+	driver = sql::mariadb::get_driver_instance();
+
+	sql::Properties properties;
+	// The mariadb connector is *supposed* to handle unix:// and pipe:// prefixes to hostName, but there are bugs where
+	// 1) it tries to parse a database from the connection string (like in tcp://localhost:3001/darkflame) based on the
+	//    presence of a /
+	// 2) even avoiding that, the connector still assumes you're connecting with a tcp socket
+	// So, what we do in the presence of a unix socket or pipe is to set the hostname to the protocol and localhost,
+	// which avoids parsing errors while still ensuring the correct connection type is used, and then setting the appropriate
+	// property manually (which the URL parsing fails to do)
+	const std::string UNIX_PROTO = "unix://";
+	const std::string PIPE_PROTO = "pipe://";
+    if (host.find(UNIX_PROTO) == 0) {
+		properties["hostName"] = "unix://localhost";
+		properties["localSocket"] = host.substr(UNIX_PROTO.length()).c_str();
+    } else if (host.find(PIPE_PROTO) == 0) {
+		properties["hostName"] = "pipe://localhost";
+		properties["pipe"] = host.substr(PIPE_PROTO.length()).c_str();
+    } else {
+		properties["hostName"] = host.c_str();
+    }
+	properties["user"] = szUsername;
+	properties["password"] = szPassword;
+	properties["autoReconnect"] = "true";
+
+	Database::props = properties;
+	Database::database = database;
+
+	Database::Connect();
+}
+
+void Database::Connect() {
+	// `connect(const Properties& props)` segfaults in windows debug, but
+	// `connect(const SQLString& host, const SQLString& user, const SQLString& pwd)` doesn't handle pipes/unix sockets correctly
+	if (Database::props.find("localSocket") != Database::props.end() || Database::props.find("pipe") != Database::props.end()) {
+		con = driver->connect(Database::props);
+	} else {
+		con = driver->connect(Database::props["hostName"].c_str(), Database::props["user"].c_str(), Database::props["password"].c_str());
+	}
+	con->setSchema(Database::database.c_str());
+}
+
+void Database::Destroy(std::string source, bool log) {
+	if (!con) return;
+
+	if (log) {
+		if (source != "") Game::logger->Log("Database", "Destroying MySQL connection from %s!", source.c_str());
+		else Game::logger->Log("Database", "Destroying MySQL connection!");
+	}
+
+	con->close();
+	delete con;
+} //Destroy
+
+sql::Statement* Database::CreateStmt() {
+	sql::Statement* toReturn = con->createStatement();
+	return toReturn;
+} //CreateStmt
+
+sql::PreparedStatement* Database::CreatePreppedStmt(const std::string& query) {
+	const char* test = query.c_str();
+	size_t size = query.length();
+	sql::SQLString str(test, size);
+
+	if (!con) {
+		Connect();
+		Game::logger->Log("Database", "Trying to reconnect to MySQL");
+	}
+
+	if (!con->isValid() || con->isClosed()) {
+		delete con;
+
+		con = nullptr;
+
+		Connect();
+		Game::logger->Log("Database", "Trying to reconnect to MySQL from invalid or closed connection");
+	}
+
+	auto* stmt = con->prepareStatement(str);
+
+	return stmt;
+} //CreatePreppedStmt
+
+void Database::Commit() {
+	Database::con->commit();
+}
+
+bool Database::GetAutoCommit() {
+	// TODO This should not just access a pointer.  A future PR should update this
+	// to check for null and throw an error if the connection is not valid.
+	return con->getAutoCommit();
+}
+
+void Database::SetAutoCommit(bool value) {
+	// TODO This should not just access a pointer.  A future PR should update this
+	// to check for null and throw an error if the connection is not valid.
+	Database::con->setAutoCommit(value);
+}

dDatabase/Database.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <string>
+#include <conncpp.hpp>
+
+class MySqlException : public std::runtime_error {
+public:
+	MySqlException() : std::runtime_error("MySQL error!") {}
+	MySqlException(const std::string& msg) : std::runtime_error(msg.c_str()) {}
+};
+
+class Database {
+private:
+	static sql::Driver* driver;
+	static sql::Connection* con;
+	static sql::Properties props;
+	static std::string database;
+public:
+	static void Connect(const std::string& host, const std::string& database, const std::string& username, const std::string& password);
+	static void Connect();
+	static void Destroy(std::string source = "", bool log = true);
+
+	static sql::Statement* CreateStmt();
+	static sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
+	static void Commit();
+	static bool GetAutoCommit();
+	static void SetAutoCommit(bool value);
+
+	static std::string GetDatabase() { return database; }
+	static sql::Properties GetProperties() { return props; }
+};

dDatabase/GameDatabase/CMakeLists.txt

@@ -1,12 +0,0 @@
-set(DDATABASE_GAMEDATABASE_SOURCES
-	"Database.cpp"
-	"MigrationRunner.cpp"
-)
-
-add_subdirectory(MySQL)
-
-foreach(file ${DDATABSE_DATABSES_MYSQL_SOURCES})
-	set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} "MySQL/${file}")
-endforeach()
-
-set(DDATABASE_GAMEDATABASE_SOURCES ${DDATABASE_GAMEDATABASE_SOURCES} PARENT_SCOPE)

dDatabase/GameDatabase/Database.cpp

@@ -1,40 +0,0 @@
-#include "Database.h"
-#include "Game.h"
-#include "dConfig.h"
-#include "Logger.h"
-#include "MySQLDatabase.h"
-#include "DluAssert.h"
-
-#pragma warning (disable:4251) //Disables SQL warnings
-
-namespace {
-	GameDatabase* database = nullptr;
-}
-
-void Database::Connect() {
-	if (database) {
-		LOG("Tried to connect to database when it's already connected!");
-		return;
-	}
-
-	database = new MySQLDatabase();
-	database->Connect();
-}
-
-GameDatabase* Database::Get() {
-	if (!database) {
-		LOG("Tried to get database when it's not connected!");
-		Connect();
-	}
-	return database;
-}
-
-void Database::Destroy(std::string source) {
-	if (database) {
-		database->Destroy(source);
-		delete database;
-		database = nullptr;
-	} else {
-		LOG("Trying to destroy database when it's not connected!");
-	}
-}

dDatabase/GameDatabase/Database.h

@@ -1,12 +0,0 @@
-#pragma once
-
-#include <string>
-#include <conncpp.hpp>
-
-#include "GameDatabase.h"
-
-namespace Database {
-	void Connect();
-	GameDatabase* Get();
-	void Destroy(std::string source = "");
-};

dDatabase/GameDatabase/GameDatabase.h

@@ -1,57 +0,0 @@
-#ifndef __GAMEDATABASE__H__
-#define __GAMEDATABASE__H__
-
-#include <optional>
-
-#include "ILeaderboard.h"
-#include "IPlayerCheatDetections.h"
-#include "ICommandLog.h"
-#include "IMail.h"
-#include "IObjectIdTracker.h"
-#include "IPlayKeys.h"
-#include "IServers.h"
-#include "IBugReports.h"
-#include "IPropertyContents.h"
-#include "IProperty.h"
-#include "IPetNames.h"
-#include "ICharXml.h"
-#include "IMigrationHistory.h"
-#include "IUgc.h"
-#include "IFriends.h"
-#include "ICharInfo.h"
-#include "IAccounts.h"
-#include "IActivityLog.h"
-#include "IIgnoreList.h"
-#include "IAccountsRewardCodes.h"
-
-namespace sql {
-	class Statement;
-	class PreparedStatement;
-};
-
-#ifdef _DEBUG
-#  define DLU_SQL_TRY_CATCH_RETHROW(x) do { try { x; } catch (sql::SQLException& ex) { LOG("SQL Error: %s", ex.what()); throw; } } while(0)
-#else
-#  define DLU_SQL_TRY_CATCH_RETHROW(x) x
-#endif // _DEBUG
-
-class GameDatabase :
-	public IPlayKeys, public ILeaderboard, public IObjectIdTracker, public IServers,
-	public IMail, public ICommandLog, public IPlayerCheatDetections, public IBugReports,
-	public IPropertyContents, public IProperty, public IPetNames, public ICharXml,
-	public IMigrationHistory, public IUgc, public IFriends, public ICharInfo,
-	public IAccounts, public IActivityLog, public IAccountsRewardCodes, public IIgnoreList {
-public:
-	virtual ~GameDatabase() = default;
-	// TODO: These should be made private.
-	virtual void Connect() = 0;
-	virtual void Destroy(std::string source = "") = 0;
-	virtual void ExecuteCustomQuery(const std::string_view query) = 0;
-	virtual sql::PreparedStatement* CreatePreppedStmt(const std::string& query) = 0;
-	virtual void Commit() = 0;
-	virtual bool GetAutoCommit() = 0;
-	virtual void SetAutoCommit(bool value) = 0;
-	virtual void DeleteCharacter(const uint32_t characterId) = 0;
-};
-
-#endif  //!__GAMEDATABASE__H__

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -1,37 +0,0 @@
-#ifndef __IACCOUNTS__H__
-#define __IACCOUNTS__H__
-
-#include <cstdint>
-#include <optional>
-#include <string_view>
-
-enum class eGameMasterLevel : uint8_t;
-
-class IAccounts {
-public:
-	struct Info {
-		std::string bcryptPassword;
-		uint32_t id{};
-		uint32_t playKeyId{};
-		bool banned{};
-		bool locked{};
-		eGameMasterLevel maxGmLevel{};
-	};
-
-	// Get the account info for the given username.
-	virtual std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) = 0;
-
-	// Update the account's unmute time.
-	virtual void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) = 0;
-
-	// Update the account's ban status.
-	virtual void UpdateAccountBan(const uint32_t accountId, const bool banned) = 0;
-
-	// Update the account's password.
-	virtual void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) = 0;
-
-	// Add a new account to the database.
-	virtual void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) = 0;
-};
-
-#endif  //!__IACCOUNTS__H__

dDatabase/GameDatabase/ITables/IAccountsRewardCodes.h

@@ -1,13 +0,0 @@
-#ifndef __IACCOUNTSREWARDCODES__H__
-#define __IACCOUNTSREWARDCODES__H__
-
-#include <cstdint>
-#include <vector>
-
-class IAccountsRewardCodes {
-public:
-	virtual void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) = 0;
-	virtual std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) = 0;
-};
-
-#endif  //!__IACCOUNTSREWARDCODES__H__

dDatabase/GameDatabase/ITables/IActivityLog.h

@@ -1,19 +0,0 @@
-#ifndef __IACTIVITYLOG__H__
-#define __IACTIVITYLOG__H__
-
-#include <cstdint>
-
-#include "dCommonVars.h"
-
-enum class eActivityType : uint32_t {
-	PlayerLoggedIn,
-	PlayerLoggedOut,
-};
-
-class IActivityLog {
-public:
-	// Update the activity log for the given account.
-	virtual void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) = 0;
-};
-
-#endif  //!__IACTIVITYLOG__H__

dDatabase/GameDatabase/ITables/IBugReports.h

@@ -1,20 +0,0 @@
-#ifndef __IBUGREPORTS__H__
-#define __IBUGREPORTS__H__
-
-#include <cstdint>
-#include <string_view>
-
-class IBugReports {
-public:
-	struct Info {
-		std::string body;
-		std::string clientVersion;
-		std::string otherPlayer;
-		std::string selection;
-		uint32_t characterId{};
-	};
-
-	// Add a new bug report to the database.
-	virtual void InsertNewBugReport(const Info& info) = 0;
-};
-#endif  //!__IBUGREPORTS__H__

dDatabase/GameDatabase/ITables/ICharInfo.h

@@ -1,49 +0,0 @@
-#ifndef __ICHARINFO__H__
-#define __ICHARINFO__H__
-
-#include <cstdint>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <vector>
-
-#include "ePermissionMap.h"
-
-class ICharInfo {
-public:
-	struct Info {
-		std::string name;
-		std::string pendingName;
-		uint32_t id{};
-		uint32_t accountId{};
-		bool needsRename{};
-		LWOCLONEID cloneId{};
-		ePermissionMap permissionMap{};
-	};
-
-	// Get the approved names of all characters.
-	virtual std::vector<std::string> GetApprovedCharacterNames() = 0;
-
-	// Get the character info for the given character id.
-	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) = 0;
-
-	// Get the character info for the given character name.
-	virtual std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view name) = 0;
-	
-	// Get the character ids for the given account.
-	virtual std::vector<uint32_t> GetAccountCharacterIds(const uint32_t accountId) = 0;
-
-	// Insert a new character into the database.
-	virtual void InsertNewCharacter(const ICharInfo::Info info) = 0;
-
-	// Set the name of the given character.
-	virtual void SetCharacterName(const uint32_t characterId, const std::string_view name) = 0;
-
-	// Set the pending name of the given character.
-	virtual void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) = 0;
-
-	// Updates the given character ids last login to be right now.
-	virtual void UpdateLastLoggedInCharacter(const uint32_t characterId) = 0;
-};
-
-#endif  //!__ICHARINFO__H__

dDatabase/GameDatabase/ITables/ICharXml.h

@@ -1,20 +0,0 @@
-#ifndef __ICHARXML__H__
-#define __ICHARXML__H__
-
-#include <cstdint>
-#include <string>
-#include <string_view>
-
-class ICharXml {
-public:
-	// Get the character xml for the given character id.
-	virtual std::string GetCharacterXml(const uint32_t charId) = 0;
-
-	// Update the character xml for the given character id.
-	virtual void UpdateCharacterXml(const uint32_t charId, const std::string_view lxfml) = 0;
-
-	// Insert the character xml for the given character id.
-	virtual void InsertCharacterXml(const uint32_t characterId, const std::string_view lxfml) = 0;
-};
-
-#endif  //!__ICHARXML__H__

dDatabase/GameDatabase/ITables/ICommandLog.h

@@ -1,14 +0,0 @@
-#ifndef __ICOMMANDLOG__H__
-#define __ICOMMANDLOG__H__
-
-#include <cstdint>
-#include <string_view>
-
-class ICommandLog {
-public:	
-
-	// Insert a new slash command log entry.
-	virtual void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) = 0;
-};
-
-#endif  //!__ICOMMANDLOG__H__

dDatabase/GameDatabase/ITables/IFriends.h

@@ -1,32 +0,0 @@
-#ifndef __IFRIENDS__H__
-#define __IFRIENDS__H__
-
-#include <cstdint>
-#include <optional>
-#include <vector>
-
-class IFriends {
-public:
-	struct BestFriendStatus {
-		uint32_t playerCharacterId{};
-		uint32_t friendCharacterId{};
-		uint32_t bestFriendStatus{};
-	};
-
-	// Get the friends list for the given character id.
-	virtual std::vector<FriendData> GetFriendsList(const uint32_t charId) = 0;
-
-	// Get the best friend status for the given player and friend character ids.
-	virtual std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
-
-	// Set the best friend status for the given player and friend character ids.
-	virtual void SetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId, const uint32_t bestFriendStatus) = 0;
-
-	// Add a friend to the given character id.
-	virtual void AddFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
-
-	// Remove a friend from the given character id.
-	virtual void RemoveFriend(const uint32_t playerCharacterId, const uint32_t friendCharacterId) = 0;
-};
-
-#endif  //!__IFRIENDS__H__

dDatabase/GameDatabase/ITables/IIgnoreList.h

@@ -1,20 +0,0 @@
-#ifndef __IIGNORELIST__H__
-#define __IIGNORELIST__H__
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-class IIgnoreList {
-public:
-	struct Info {
-		std::string name;
-		uint32_t id;
-	};
-
-	virtual std::vector<Info> GetIgnoreList(const uint32_t playerId) = 0;
-	virtual void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) = 0;
-	virtual void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) = 0;
-};
-
-#endif  //!__IIGNORELIST__H__

dDatabase/GameDatabase/ITables/ILeaderboard.h

@@ -1,14 +0,0 @@
-#ifndef __ILEADERBOARD__H__
-#define __ILEADERBOARD__H__
-
-#include <cstdint>
-#include <optional>
-
-class ILeaderboard {
-public:
-
-	// Get the donation total for the given activity id.
-	virtual std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) = 0;
-};
-
-#endif  //!__ILEADERBOARD__H__

dDatabase/GameDatabase/ITables/IMail.h

@@ -1,54 +0,0 @@
-#ifndef __IMAIL__H__
-#define __IMAIL__H__
-
-#include <cstdint>
-#include <optional>
-#include <string_view>
-
-#include "dCommonVars.h"
-#include "NiQuaternion.h"
-#include "NiPoint3.h"
-
-class IMail {
-public:
-	struct MailInfo {
-		std::string senderUsername;
-		std::string recipient;
-		std::string subject;
-		std::string body;
-		uint64_t id{};
-		uint32_t senderId{};
-		uint32_t receiverId{};
-		uint64_t timeSent{};
-		bool wasRead{};
-		struct {
-			LWOOBJID itemID{};
-			int32_t itemCount{};
-			LOT itemLOT{};
-			LWOOBJID itemSubkey{};
-		};
-	};
-
-	// Insert a new mail into the database.
-	virtual void InsertNewMail(const MailInfo& mail) = 0;
-
-	// Get the mail for the given character id.
-	virtual std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) = 0;
-
-	// Get the mail for the given mail id.
-	virtual std::optional<MailInfo> GetMail(const uint64_t mailId) = 0;
-
-	// Get the number of unread mail for the given character id.
-	virtual uint32_t GetUnreadMailCount(const uint32_t characterId) = 0;
-
-	// Mark the given mail as read.
-	virtual void MarkMailRead(const uint64_t mailId) = 0;
-
-	// Claim the item from the given mail.
-	virtual void ClaimMailItem(const uint64_t mailId) = 0;
-
-	// Delete the given mail.
-	virtual void DeleteMail(const uint64_t mailId) = 0;
-};
-
-#endif  //!__IMAIL__H__

dDatabase/GameDatabase/ITables/IMigrationHistory.h

@@ -1,17 +0,0 @@
-#ifndef __IMIGRATIONHISTORY__H__
-#define __IMIGRATIONHISTORY__H__
-
-#include <string_view>
-
-class IMigrationHistory {
-public:
-	// Create the migration history table.
-	virtual void CreateMigrationHistoryTable() = 0;
-
-	// Check if the given migration has been run.
-	virtual bool IsMigrationRun(const std::string_view str) = 0;
-
-	// Insert the given migration into the migration history table.
-	virtual void InsertMigration(const std::string_view str) = 0;
-};
-#endif  //!__IMIGRATIONHISTORY__H__

dDatabase/GameDatabase/ITables/IObjectIdTracker.h

@@ -1,19 +0,0 @@
-#ifndef __IOBJECTIDTRACKER__H__
-#define __IOBJECTIDTRACKER__H__
-
-#include <cstdint>
-#include <optional>
-
-class IObjectIdTracker {
-public:
-	// Get the current persistent id.
-	virtual std::optional<uint32_t> GetCurrentPersistentId() = 0;
-
-	// Insert the default persistent id.
-	virtual void InsertDefaultPersistentId() = 0;
-
-	// Update the persistent id.
-	virtual void UpdatePersistentId(const uint32_t newId) = 0;
-};
-
-#endif  //!__IOBJECTIDTRACKER__H__

dDatabase/GameDatabase/ITables/IPetNames.h

@@ -1,21 +0,0 @@
-#ifndef __IPETNAMES__H__
-#define __IPETNAMES__H__
-
-#include <cstdint>
-#include <optional>
-
-class IPetNames {
-public:
-	struct Info {
-		std::string petName;
-		int32_t approvalStatus{};
-	};
-
-	// Set the pet name moderation status for the given pet id.
-	virtual void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) = 0;
-
-	// Get pet info for the given pet id.
-	virtual std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) = 0;
-};
-
-#endif  //!__IPETNAMES__H__

dDatabase/GameDatabase/ITables/IPlayKeys.h

@@ -1,15 +0,0 @@
-#ifndef __IPLAYKEYS__H__
-#define __IPLAYKEYS__H__
-
-#include <cstdint>
-#include <optional>
-
-class IPlayKeys {
-public:
-	// Get the playkey id for the given playkey.
-	// Optional of bool may seem pointless, however the optional indicates if the playkey exists
-	// and the bool indicates if the playkey is active.
-	virtual std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) = 0;
-};
-
-#endif  //!__IPLAYKEYS__H__

dDatabase/GameDatabase/ITables/IPlayerCheatDetections.h

@@ -1,20 +0,0 @@
-#ifndef __IPLAYERCHEATDETECTIONS__H__
-#define __IPLAYERCHEATDETECTIONS__H__
-
-#include <cstdint>
-#include <optional>
-
-class IPlayerCheatDetections {
-public:
-	struct Info {
-		std::optional<uint32_t> userId = std::nullopt;
-		std::string username;
-		std::string systemAddress;
-		std::string extraMessage;
-	};
-
-	// Insert a new cheat detection.
-	virtual void InsertCheatDetection(const IPlayerCheatDetections::Info& info) = 0;
-};
-
-#endif  //!__IPLAYERCHEATDETECTIONS__H__

dDatabase/GameDatabase/ITables/IProperty.h

@@ -1,38 +0,0 @@
-#ifndef __IPROPERTY__H__
-#define __IPROPERTY__H__
-
-#include <cstdint>
-#include <optional>
-
-class IProperty {
-public:
-	struct Info {
-		std::string name;
-		std::string description;
-		std::string rejectionReason;
-		LWOOBJID id{};
-		uint32_t ownerId{};
-		LWOCLONEID cloneId{};
-		int32_t privacyOption{};
-		uint32_t modApproved{};
-		uint32_t lastUpdatedTime{};
-		uint32_t claimedTime{};
-		uint32_t reputation{};
-	};
-
-	// Get the property info for the given property id.
-	virtual std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) = 0;
-
-	// Update the property moderation info for the given property id.
-	virtual void UpdatePropertyModerationInfo(const IProperty::Info& info) = 0;
-	
-	// Update the property details for the given property id.
-	virtual void UpdatePropertyDetails(const IProperty::Info& info) = 0;
-
-	// Update the property performance cost for the given property id.
-	virtual void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) = 0;
-	
-	// Insert a new property into the database.
-	virtual void InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) = 0;
-};
-#endif  //!__IPROPERTY__H__

dDatabase/GameDatabase/ITables/IPropertyContents.h

@@ -1,40 +0,0 @@
-#ifndef __IPROPERTIESCONTENTS__H__
-#define __IPROPERTIESCONTENTS__H__
-
-#include <cstdint>
-#include <string_view>
-
-class IPropertyContents {
-public:	
-	struct Model {
-		inline bool operator==(const LWOOBJID& other) const noexcept {
-			return id == other;
-		}
-
-		NiPoint3 position;
-		NiQuaternion rotation;
-		LWOOBJID id{};
-		LOT lot{};
-		uint32_t ugcId{};
-	};
-
-	// Inserts a new UGC model into the database.
-	virtual void InsertNewUgcModel(
-		std::istringstream& sd0Data,
-		const uint32_t blueprintId,
-		const uint32_t accountId,
-		const uint32_t characterId) = 0;
-
-	// Get the property models for the given property id.
-	virtual std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) = 0;
-
-	// Insert a new property model into the database.
-	virtual void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) = 0;
-
-	// Update the model position and rotation for the given property id.
-	virtual void UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) = 0;
-
-	// Remove the model for the given property id.
-	virtual void RemoveModel(const LWOOBJID& modelId) = 0;
-};
-#endif  //!__IPROPERTIESCONTENTS__H__

dDatabase/GameDatabase/ITables/IServers.h

@@ -1,21 +0,0 @@
-#ifndef __ISERVERS__H__
-#define __ISERVERS__H__
-
-#include <cstdint>
-#include <optional>
-
-class IServers {
-public:
-	struct MasterInfo {
-		std::string ip;
-		uint32_t port{};
-	};
-
-	// Set the master server ip and port.
-	virtual void SetMasterIp(const std::string_view ip, const uint32_t port) = 0;
-
-	// Get the master server info.
-	virtual std::optional<MasterInfo> GetMasterInfo() = 0;
-};
-
-#endif  //!__ISERVERS__H__

dDatabase/GameDatabase/ITables/IUgc.h

@@ -1,32 +0,0 @@
-#ifndef __IUGC__H__
-#define __IUGC__H__
-
-#include <cstdint>
-#include <sstream>
-#include <optional>
-#include <string>
-#include <string_view>
-
-class IUgc {
-public:
-	struct Model {
-		std::stringstream lxfmlData;
-		LWOOBJID id{};
-	};
-
-	// Gets all UGC models for the given property id.
-	virtual std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) = 0;
-
-	// Gets all Ugcs models.
-	virtual std::vector<IUgc::Model> GetAllUgcModels() = 0;
-	
-	// Removes ugc models that are not referenced by any property.
-	virtual void RemoveUnreferencedUgcModels() = 0;
-
-	// Deletes the ugc model for the given model id.
-	virtual void DeleteUgcModelData(const LWOOBJID& modelId) = 0;
-
-	// Inserts a new UGC model into the database.
-	virtual void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) = 0;
-};
-#endif  //!__IUGC__H__

dDatabase/GameDatabase/MySQL/CMakeLists.txt

@@ -1,11 +0,0 @@
-SET(DDATABSE_DATABSES_MYSQL_SOURCES
-	"MySQLDatabase.cpp"
-)
-
-add_subdirectory(Tables)
-
-foreach(file ${DDATABASES_DATABASES_MYSQL_TABLES_SOURCES})
-	set(DDATABSE_DATABSES_MYSQL_SOURCES ${DDATABSE_DATABSES_MYSQL_SOURCES} "Tables/${file}")
-endforeach()
-
-set(DDATABSE_DATABSES_MYSQL_SOURCES ${DDATABSE_DATABSES_MYSQL_SOURCES} PARENT_SCOPE)

dDatabase/GameDatabase/MySQL/MySQLDatabase.cpp

@@ -1,113 +0,0 @@
-#include "MySQLDatabase.h"
-
-#include "Database.h"
-#include "Game.h"
-#include "dConfig.h"
-#include "Logger.h"
-
-namespace {
-	std::string databaseName;
-	sql::Properties properties;
-	sql::Driver* driver = nullptr;
-	sql::Connection* con = nullptr;
-};
-
-void MySQLDatabase::Connect() {
-	driver = sql::mariadb::get_driver_instance();
-
-	// The mariadb connector is *supposed* to handle unix:// and pipe:// prefixes to hostName, but there are bugs where
-	// 1) it tries to parse a database from the connection string (like in tcp://localhost:3001/darkflame) based on the
-	//    presence of a /
-	// 2) even avoiding that, the connector still assumes you're connecting with a tcp socket
-	// So, what we do in the presence of a unix socket or pipe is to set the hostname to the protocol and localhost,
-	// which avoids parsing errors while still ensuring the correct connection type is used, and then setting the appropriate
-	// property manually (which the URL parsing fails to do)
-	const std::string UNIX_PROTO = "unix://";
-	const std::string PIPE_PROTO = "pipe://";
-	std::string mysql_host = Game::config->GetValue("mysql_host");
-	if (mysql_host.find(UNIX_PROTO) == 0) {
-		properties["hostName"] = "unix://localhost";
-		properties["localSocket"] = mysql_host.substr(UNIX_PROTO.length()).c_str();
-	} else if (mysql_host.find(PIPE_PROTO) == 0) {
-		properties["hostName"] = "pipe://localhost";
-		properties["pipe"] = mysql_host.substr(PIPE_PROTO.length()).c_str();
-	} else {
-		properties["hostName"] = mysql_host.c_str();
-	}
-	properties["user"] = Game::config->GetValue("mysql_username").c_str();
-	properties["password"] = Game::config->GetValue("mysql_password").c_str();
-	properties["autoReconnect"] = "true";
-
-	databaseName = Game::config->GetValue("mysql_database").c_str();
-
-	// `connect(const Properties& props)` segfaults in windows debug, but
-	// `connect(const SQLString& host, const SQLString& user, const SQLString& pwd)` doesn't handle pipes/unix sockets correctly
-	if (properties.find("localSocket") != properties.end() || properties.find("pipe") != properties.end()) {
-		con = driver->connect(properties);
-	} else {
-		con = driver->connect(properties["hostName"].c_str(), properties["user"].c_str(), properties["password"].c_str());
-	}
-	con->setSchema(databaseName.c_str());
-}
-
-void MySQLDatabase::Destroy(std::string source) {
-	if (!con) return;
-
-	if (source.empty()) LOG("Destroying MySQL connection!");
-	else LOG("Destroying MySQL connection from %s!", source.c_str());
-
-	con->close();
-	delete con;
-	con = nullptr;
-}
-
-void MySQLDatabase::ExecuteCustomQuery(const std::string_view query) {
-	std::unique_ptr<sql::Statement>(con->createStatement())->execute(query.data());
-}
-
-sql::PreparedStatement* MySQLDatabase::CreatePreppedStmt(const std::string& query) {
-	if (!con) {
-		Connect();
-		LOG("Trying to reconnect to MySQL");
-	}
-
-	if (!con->isValid() || con->isClosed()) {
-		delete con;
-
-		con = nullptr;
-
-		Connect();
-		LOG("Trying to reconnect to MySQL from invalid or closed connection");
-	}
-
-	return con->prepareStatement(sql::SQLString(query.c_str(), query.length()));
-}
-
-void MySQLDatabase::Commit() {
-	con->commit();
-}
-
-bool MySQLDatabase::GetAutoCommit() {
-	// TODO This should not just access a pointer.  A future PR should update this
-	// to check for null and throw an error if the connection is not valid.
-	return con->getAutoCommit();
-}
-
-void MySQLDatabase::SetAutoCommit(bool value) {
-	// TODO This should not just access a pointer.  A future PR should update this
-	// to check for null and throw an error if the connection is not valid.
-	con->setAutoCommit(value);
-}
-
-void MySQLDatabase::DeleteCharacter(const uint32_t characterId) {
-	ExecuteDelete("DELETE FROM charxml WHERE id=? LIMIT 1;", characterId);
-	ExecuteDelete("DELETE FROM command_log WHERE character_id=?;", characterId);
-	ExecuteDelete("DELETE FROM friends WHERE player_id=? OR friend_id=?;", characterId, characterId);
-	ExecuteDelete("DELETE FROM leaderboard WHERE character_id=?;", characterId);
-	ExecuteDelete("DELETE FROM properties_contents WHERE property_id IN (SELECT id FROM properties WHERE owner_id=?);", characterId);
-	ExecuteDelete("DELETE FROM properties WHERE owner_id=?;", characterId);
-	ExecuteDelete("DELETE FROM ugc WHERE character_id=?;", characterId);
-	ExecuteDelete("DELETE FROM activity_log WHERE character_id=?;", characterId);
-	ExecuteDelete("DELETE FROM mail WHERE receiver_id=?;", characterId);
-	ExecuteDelete("DELETE FROM charinfo WHERE id=? LIMIT 1;", characterId);
-}

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -1,250 +0,0 @@
-#ifndef __MYSQLDATABASE__H__
-#define __MYSQLDATABASE__H__
-
-#include <conncpp.hpp>
-#include <memory>
-
-#include "GameDatabase.h"
-
-typedef std::unique_ptr<sql::PreparedStatement>& UniquePreppedStmtRef;
-
-// Purposefully no definition for this to provide linker errors in the case someone tries to
-// bind a parameter to a type that isn't defined.
-template<typename ParamType>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const ParamType param);
-
-// This is a function to set each parameter in a prepared statement.
-// This is accomplished with a combination of parameter packing and Fold Expressions.
-// The constexpr if statement is used to prevent the compiler from trying to call SetParam with 0 arguments.
-template<typename... Args>
-void SetParams(UniquePreppedStmtRef stmt, Args&&... args) {
-	if constexpr (sizeof...(args) != 0) {
-		int i = 1;
-		(SetParam(stmt, i++, args), ...);
-	}
-}
-
-class MySQLDatabase : public GameDatabase {
-public:
-	void Connect() override;
-	void Destroy(std::string source = "") override;
-
-	sql::PreparedStatement* CreatePreppedStmt(const std::string& query) override;
-	void Commit() override;
-	bool GetAutoCommit() override;
-	void SetAutoCommit(bool value) override;
-	void ExecuteCustomQuery(const std::string_view query) override;
-
-	// Overloaded queries
-	std::optional<IServers::MasterInfo> GetMasterInfo() override;
-
-	std::vector<std::string> GetApprovedCharacterNames() override;
-
-	std::vector<FriendData> GetFriendsList(uint32_t charID) override;
-
-	std::optional<IFriends::BestFriendStatus> GetBestFriendStatus(const uint32_t playerCharacterId, const uint32_t friendCharacterId) override;
-	void SetBestFriendStatus(const uint32_t playerAccountId, const uint32_t friendAccountId, const uint32_t bestFriendStatus) override;
-	void AddFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
-	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
-	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
-	void DeleteUgcModelData(const LWOOBJID& modelId) override;
-	void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) override;
-	std::vector<IUgc::Model> GetAllUgcModels() override;
-	void CreateMigrationHistoryTable() override;
-	bool IsMigrationRun(const std::string_view str) override;
-	void InsertMigration(const std::string_view str) override;
-	std::optional<ICharInfo::Info> GetCharacterInfo(const uint32_t charId) override;
-	std::optional<ICharInfo::Info> GetCharacterInfo(const std::string_view charId) override;
-	std::string GetCharacterXml(const uint32_t accountId) override;
-	void UpdateCharacterXml(const uint32_t characterId, const std::string_view lxfml) override;
-	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
-	void InsertNewCharacter(const ICharInfo::Info info) override;
-	void InsertCharacterXml(const uint32_t accountId, const std::string_view lxfml) override;
-	std::vector<uint32_t> GetAccountCharacterIds(uint32_t accountId) override;
-	void DeleteCharacter(const uint32_t characterId) override;
-	void SetCharacterName(const uint32_t characterId, const std::string_view name) override;
-	void SetPendingCharacterName(const uint32_t characterId, const std::string_view name) override;
-	void UpdateLastLoggedInCharacter(const uint32_t characterId) override;
-	void SetPetNameModerationStatus(const LWOOBJID& petId, const IPetNames::Info& info) override;
-	std::optional<IPetNames::Info> GetPetNameInfo(const LWOOBJID& petId) override;
-	std::optional<IProperty::Info> GetPropertyInfo(const LWOMAPID mapId, const LWOCLONEID cloneId) override;
-	void UpdatePropertyModerationInfo(const IProperty::Info& info) override;
-	void UpdatePropertyDetails(const IProperty::Info& info) override;
-	void InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) override;
-	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
-	void RemoveUnreferencedUgcModels() override;
-	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModelPositionRotation(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation) override;
-	void RemoveModel(const LWOOBJID& modelId) override;
-	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
-	void InsertNewBugReport(const IBugReports::Info& info) override;
-	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
-	void InsertNewMail(const IMail::MailInfo& mail) override;
-	void InsertNewUgcModel(
-		std::istringstream& sd0Data,
-		const uint32_t blueprintId,
-		const uint32_t accountId,
-		const uint32_t characterId) override;
-	std::vector<IMail::MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
-	std::optional<IMail::MailInfo> GetMail(const uint64_t mailId) override;
-	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
-	void MarkMailRead(const uint64_t mailId) override;
-	void DeleteMail(const uint64_t mailId) override;
-	void ClaimMailItem(const uint64_t mailId) override;
-	void InsertSlashCommandUsage(const uint32_t characterId, const std::string_view command) override;
-	void UpdateAccountUnmuteTime(const uint32_t accountId, const uint64_t timeToUnmute) override;
-	void UpdateAccountBan(const uint32_t accountId, const bool banned) override;
-	void UpdateAccountPassword(const uint32_t accountId, const std::string_view bcryptpassword) override;
-	void InsertNewAccount(const std::string_view username, const std::string_view bcryptpassword) override;
-	void SetMasterIp(const std::string_view ip, const uint32_t port) override;
-	std::optional<uint32_t> GetCurrentPersistentId() override;
-	void InsertDefaultPersistentId() override;
-	void UpdatePersistentId(const uint32_t id) override;
-	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
-	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
-	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
-	void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
-	void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
-	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
-	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
-	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
-private:
-
-	// Generic query functions that can be used for any query.
-	// Return type may be different depending on the query, so it is up to the caller to check the return type.
-	// The first argument is the query string, and the rest are the parameters to bind to the query.
-	// The return type is a unique_ptr to the result set, which is deleted automatically when it goes out of scope
-	template<typename... Args>
-	inline std::unique_ptr<sql::ResultSet> ExecuteSelect(const std::string& query, Args&&... args) {
-		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
-		SetParams(preppedStmt, std::forward<Args>(args)...);
-		DLU_SQL_TRY_CATCH_RETHROW(return std::unique_ptr<sql::ResultSet>(preppedStmt->executeQuery()));
-	}
-
-	template<typename... Args>
-	inline void ExecuteDelete(const std::string& query, Args&&... args) {
-		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
-		SetParams(preppedStmt, std::forward<Args>(args)...);
-		DLU_SQL_TRY_CATCH_RETHROW(preppedStmt->execute());
-	}
-
-	template<typename... Args>
-	inline int32_t ExecuteUpdate(const std::string& query, Args&&... args) {
-		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
-		SetParams(preppedStmt, std::forward<Args>(args)...);
-		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt->executeUpdate());
-	}
-
-	template<typename... Args>
-	inline bool ExecuteInsert(const std::string& query, Args&&... args) {
-		std::unique_ptr<sql::PreparedStatement> preppedStmt(CreatePreppedStmt(query));
-		SetParams(preppedStmt, std::forward<Args>(args)...);
-		DLU_SQL_TRY_CATCH_RETHROW(return preppedStmt->execute());
-	}
-};
-
-// Below are each of the definitions of SetParam for each supported type.
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string_view param) {
-	// LOG("%s", param.data());
-	stmt->setString(index, param.data());
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const char* param) {
-	// LOG("%s", param);
-	stmt->setString(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::string param) {
-	// LOG("%s", param.c_str());
-	stmt->setString(index, param.c_str());
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int8_t param) {
-	// LOG("%u", param);
-	stmt->setByte(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint8_t param) {
-	// LOG("%d", param);
-	stmt->setByte(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int16_t param) {
-	// LOG("%u", param);
-	stmt->setShort(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint16_t param) {
-	// LOG("%d", param);
-	stmt->setShort(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint32_t param) {
-	// LOG("%u", param);
-	stmt->setUInt(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int32_t param) {
-	// LOG("%d", param);
-	stmt->setInt(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const int64_t param) {
-	// LOG("%llu", param);
-	stmt->setInt64(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const uint64_t param) {
-	// LOG("%llu", param);
-	stmt->setUInt64(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const float param) {
-	// LOG("%f", param);
-	stmt->setFloat(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const double param) {
-	// LOG("%f", param);
-	stmt->setDouble(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const bool param) {
-	// LOG("%d", param);
-	stmt->setBoolean(index, param);
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::istream* param) {
-	// LOG("Blob");
-	// This is the one time you will ever see me use const_cast.
-	stmt->setBlob(index, const_cast<std::istream*>(param));
-}
-
-template<>
-inline void SetParam(UniquePreppedStmtRef stmt, const int index, const std::optional<uint32_t> param) {
-	if (param) {
-		// LOG("%d", param.value());
-		stmt->setInt(index, param.value());
-	} else {
-		// LOG("Null");
-		stmt->setNull(index, sql::DataType::SQLNULL);
-	}
-}
-
-#endif  //!__MYSQLDATABASE__H__