rarityTable

Fix up other large tables to have proper backup lookups

Revert "idk im just dumb ig"

This reverts commit 5d5be5df53b8959b42b291613d7db749a65a3585.

idk im just dumb ig

.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

CMakeLists.txt

@@ -148,19 +148,16 @@ foreach (resource_file ${RESOURCE_FILES})
 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")

CMakeVariables.txt

@@ -1,8 +1,12 @@
 PROJECT_VERSION_MAJOR=1
 PROJECT_VERSION_MINOR=1
-PROJECT_VERSION_PATCH=1
+PROJECT_VERSION_PATCH=0
 # 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

@@ -179,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.

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,14 @@
 
 #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,9 +51,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 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");
@@ -64,7 +64,7 @@ int main(int argc, char** argv) {
 	try {
 		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;
@@ -161,7 +161,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;
@@ -170,7 +170,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"

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"
@@ -76,11 +75,11 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 
 	//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)friends.size());
@@ -118,11 +117,6 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 	inStream.Read(isBestFriendRequest);
 
 	auto requestor = playerContainer.GetPlayerData(requestorPlayerID);
-	if (!requestor) {
-		LOG("No requestor player %llu sent to %s found.", requestorPlayerID, playerName.c_str());
-		return;
-	}
-
 	if (requestor->playerName == playerName) {
 		SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN);
 		return;
@@ -402,7 +396,7 @@ 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;
 
@@ -418,21 +412,21 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 		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;
@@ -440,7 +434,7 @@ 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);
 
@@ -457,21 +451,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;
@@ -480,21 +474,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;
@@ -532,13 +526,13 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
 	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) {
@@ -552,7 +546,7 @@ 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;
@@ -561,13 +555,13 @@ void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
 	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 = 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;
 	}
 
@@ -583,7 +577,7 @@ void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
 
 	auto* team = playerContainer.GetTeam(playerID);
 
-	LOG("(%llu) leaving team", playerID);
+	Game::logger->Log("ChatPacketHandler", "(%llu) leaving team", playerID);
 
 	if (team != nullptr) {
 		playerContainer.RemoveMember(team, playerID, false, false, true);
@@ -597,7 +591,7 @@ void ChatPacketHandler::HandleTeamKick(Packet* packet) {
 
 	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 = playerContainer.GetPlayerData(kickedPlayer);
 
@@ -627,7 +621,7 @@ void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
 
 	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 = playerContainer.GetPlayerData(promotedPlayer);
 
@@ -715,13 +709,13 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 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;
@@ -730,7 +724,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:
@@ -757,7 +751,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:
@@ -782,7 +776,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:
@@ -799,7 +793,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:
@@ -828,7 +822,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:
@@ -854,7 +848,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:
@@ -888,16 +882,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());
@@ -927,12 +921,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;
@@ -943,16 +937,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);
@@ -968,13 +962,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"
@@ -27,17 +27,16 @@
 #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;
 }
 
 
-Logger* SetupLogger();
+dLogger* SetupLogger();
 void HandlePacket(Packet* packet);
 
 PlayerContainer playerContainer;
@@ -58,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");
@@ -72,7 +71,7 @@ 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;
 	}
@@ -86,7 +85,7 @@ int main(int argc, char** argv) {
 	try {
 		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;
@@ -115,8 +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));
 
 	//Run it until server gets a kill message from Master:
 	auto t = std::chrono::high_resolution_clock::now();
@@ -185,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;
@@ -194,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.
@@ -234,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]));
 		}
 	}
 
@@ -245,7 +242,7 @@ void HandlePacket(Packet* packet) {
 			break;
 
 		case eChatMessageType::GET_IGNORE_LIST:
-			LOG("Asked for ignore list, but is unimplemented right now.");
+			Game::logger->Log("ChatServer", "Asked for ignore list, but is unimplemented right now.");
 			break;
 
 		case eChatMessageType::TEAM_GET_STATUS:
@@ -303,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,15 +3,13 @@
 #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"
 
 PlayerContainer::PlayerContainer() {
 }
@@ -20,10 +18,6 @@ PlayerContainer::~PlayerContainer() {
 	mPlayers.clear();
 }
 
-TeamData::TeamData() {
-	lootFlag = Game::config->GetValue("default_team_loot") == "0" ? 0 : 1;
-}
-
 void PlayerContainer::InsertPlayer(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
 	PlayerData* data = new PlayerData();
@@ -44,7 +38,7 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	mNames[data->playerID] = GeneralUtils::UTF8ToUTF16(data->playerName);
 
 	mPlayers.insert(std::make_pair(data->playerID, data));
-	LOG("Added user: %s (%llu), zone: %i", data->playerName.c_str(), data->playerID, data->zoneID.GetMapID());
+	Game::logger->Log("PlayerContainer", "Added user: %s (%llu), zone: %i", data->playerName.c_str(), data->playerID, data->zoneID.GetMapID());
 
 	auto* insertLog = Database::CreatePreppedStmt("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);");
 
@@ -87,7 +81,7 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 		}
 	}
 
-	LOG("Removed user: %llu", playerID);
+	Game::logger->Log("PlayerContainer", "Removed user: %llu", playerID);
 	mPlayers.erase(playerID);
 
 	auto* insertLog = Database::CreatePreppedStmt("INSERT INTO activity_log (character_id, activity, time, map_id) VALUES (?, ?, ?, ?);");
@@ -110,7 +104,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;
 	}
@@ -152,7 +146,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);
@@ -213,14 +207,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;
@@ -359,7 +345,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);

dChatServer/PlayerContainer.h

@@ -18,7 +18,6 @@ struct PlayerData {
 };
 
 struct TeamData {
-	TeamData();
 	LWOOBJID teamID = LWOOBJID_EMPTY; // Internal use
 	LWOOBJID leaderID = LWOOBJID_EMPTY;
 	std::vector<LWOOBJID> memberIDs{};

dCommon/Amf3.h

@@ -2,7 +2,7 @@
 #define __AMF3__H__
 
 #include "dCommonVars.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "Game.h"
 
 #include <unordered_map>

dCommon/AmfSerialize.cpp

@@ -1,7 +1,7 @@
 #include "AmfSerialize.h"
 
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 // Writes an AMFValue pointer to a RakNet::BitStream
 template<>
@@ -29,7 +29,7 @@ void RakNet::BitStream::Write<AMFBaseValue&>(AMFBaseValue& value) {
 		break;
 	}
 	default: {
-		LOG("Encountered unwritable AMFType %i!", type);
+		Game::logger->Log("AmfSerialize", "Encountered unwritable AMFType %i!", type);
 	}
 	case eAmf::Undefined:
 	case eAmf::Null:

dCommon/BrickByBrickFix.cpp

@@ -9,7 +9,7 @@
 #include "Database.h"
 #include "Game.h"
 #include "ZCompression.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 //! Forward declarations
 
@@ -59,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, modelId, 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;
 			}
 
@@ -75,7 +75,8 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 					"</LXFML>",
 					completeUncompressedModel.length() >= 15 ? completeUncompressedModel.length() - 15 : 0) == std::string::npos
 					) {
-					LOG("Brick-by-brick model %llu will be deleted!", modelId);
+					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();
@@ -84,7 +85,8 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 				}
 			}
 		} else {
-			LOG("Brick-by-brick model %llu will be deleted!", modelId);
+			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();
@@ -138,10 +140,12 @@ uint32_t BrickByBrickFix::UpdateBrickByBrickModelsToSd0() {
 			insertionStatement->setInt64(2, modelId);
 			try {
 				insertionStatement->executeUpdate();
-				LOG("Updated model %i to sd0", modelId);
+				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."
+				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());
 			}
 		}

dCommon/CMakeLists.txt

@@ -4,7 +4,7 @@ set(DCOMMON_SOURCES
 		"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/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,7 +3,7 @@
 #include <random>
 
 class dServer;
-class Logger;
+class dLogger;
 class InstanceManager;
 class dChatFilter;
 class dConfig;
@@ -14,7 +14,7 @@ class EntityManager;
 class dZoneManager;
 
 namespace Game {
-	extern Logger* logger;
+	extern dLogger* logger;
 	extern dServer* server;
 	extern InstanceManager* im;
 	extern dChatFilter* chatFilter;

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;
@@ -126,11 +126,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);

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/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
 
@@ -33,7 +32,7 @@ constexpr uint32_t lowFrameDelta = FRAMES_TO_MS(lowFramerate);
 #define CBITSTREAM RakNet::BitStream bitStream;
 #define CINSTREAM RakNet::BitStream inStream(packet->data, packet->length, false);
 #define 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/eReplicaComponentType.h

@@ -101,7 +101,7 @@ 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,

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

@@ -55,7 +55,7 @@ CDClientManager::CDClientManager() {
 	CDBehaviorParameterTable::Instance().LoadValuesFromDatabase();
 	CDBehaviorTemplateTable::Instance().LoadValuesFromDatabase();
 	CDBrickIDTableTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDComponentsRegistryTable::Instance().LoadValuesFromDatabase());
+	CDComponentsRegistryTable::Instance().LoadValuesFromDatabase();
 	CDCurrencyTableTable::Instance().LoadValuesFromDatabase();
 	CDDestructibleComponentTable::Instance().LoadValuesFromDatabase();
 	CDEmoteTableTable::Instance().LoadValuesFromDatabase();
@@ -65,8 +65,8 @@ CDClientManager::CDClientManager() {
 	CDItemSetSkillsTable::Instance().LoadValuesFromDatabase();
 	CDItemSetsTable::Instance().LoadValuesFromDatabase();
 	CDLevelProgressionLookupTable::Instance().LoadValuesFromDatabase();
-	CDCLIENT_DONT_CACHE_TABLE(CDLootMatrixTable::Instance().LoadValuesFromDatabase());
-	CDCLIENT_DONT_CACHE_TABLE(CDLootTableTable::Instance().LoadValuesFromDatabase());
+	CDLootMatrixTable::Instance().LoadValuesFromDatabase();
+	CDLootTableTable::Instance().LoadValuesFromDatabase();
 	CDMissionEmailTable::Instance().LoadValuesFromDatabase();
 	CDMissionNPCComponentTable::Instance().LoadValuesFromDatabase();
 	CDMissionTasksTable::Instance().LoadValuesFromDatabase();

dDatabase/Database.cpp

@@ -1,7 +1,7 @@
 #include "Database.h"
 #include "Game.h"
 #include "dConfig.h"
-#include "Logger.h"
+#include "dLogger.h"
 using namespace std;
 
 #pragma warning (disable:4251) //Disables SQL warnings
@@ -64,8 +64,8 @@ void Database::Destroy(std::string source, bool log) {
 	if (!con) return;
 
 	if (log) {
-		if (source != "") LOG("Destroying MySQL connection from %s!", source.c_str());
-		else LOG("Destroying MySQL connection!");
+		if (source != "") Game::logger->Log("Database", "Destroying MySQL connection from %s!", source.c_str());
+		else Game::logger->Log("Database", "Destroying MySQL connection!");
 	}
 
 	con->close();
@@ -84,7 +84,7 @@ sql::PreparedStatement* Database::CreatePreppedStmt(const std::string& query) {
 
 	if (!con) {
 		Connect();
-		LOG("Trying to reconnect to MySQL");
+		Game::logger->Log("Database", "Trying to reconnect to MySQL");
 	}
 
 	if (!con->isValid() || con->isClosed()) {
@@ -93,7 +93,7 @@ sql::PreparedStatement* Database::CreatePreppedStmt(const std::string& query) {
 		con = nullptr;
 
 		Connect();
-		LOG("Trying to reconnect to MySQL from invalid or closed connection");
+		Game::logger->Log("Database", "Trying to reconnect to MySQL from invalid or closed connection");
 	}
 
 	auto* stmt = con->prepareStatement(str);

dDatabase/MigrationRunner.cpp

@@ -5,10 +5,10 @@
 #include "Database.h"
 #include "Game.h"
 #include "GeneralUtils.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "BinaryPathFinder.h"
 
-#include <fstream>
+#include <istream>
 
 Migration LoadMigration(std::string path) {
 	Migration migration{};
@@ -53,7 +53,7 @@ void MigrationRunner::RunMigrations() {
 		delete stmt;
 		if (doExit) continue;
 
-		LOG("Running migration: %s", migration.name.c_str());
+		Game::logger->Log("MigrationRunner", "Running migration: %s", migration.name.c_str());
 		if (migration.name == "dlu/5_brick_model_sd0.sql") {
 			runSd0Migrations = true;
 		} else {
@@ -67,7 +67,7 @@ void MigrationRunner::RunMigrations() {
 	}
 
 	if (finalSQL.empty() && !runSd0Migrations) {
-		LOG("Server database is up to date.");
+		Game::logger->Log("MigrationRunner", "Server database is up to date.");
 		return;
 	}
 
@@ -79,7 +79,7 @@ void MigrationRunner::RunMigrations() {
 				if (query.empty()) continue;
 				simpleStatement->execute(query.c_str());
 			} catch (sql::SQLException& e) {
-				LOG("Encountered error running migration: %s", e.what());
+				Game::logger->Log("MigrationRunner", "Encountered error running migration: %s", e.what());
 			}
 		}
 	}
@@ -87,9 +87,9 @@ void MigrationRunner::RunMigrations() {
 	// Do this last on the off chance none of the other migrations have been run yet.
 	if (runSd0Migrations) {
 		uint32_t numberOfUpdatedModels = BrickByBrickFix::UpdateBrickByBrickModelsToSd0();
-		LOG("%i models were updated from zlib to sd0.", numberOfUpdatedModels);
+		Game::logger->Log("MasterServer", "%i models were updated from zlib to sd0.", numberOfUpdatedModels);
 		uint32_t numberOfTruncatedModels = BrickByBrickFix::TruncateBrokenBrickByBrickXml();
-		LOG("%i models were truncated from the database.", numberOfTruncatedModels);
+		Game::logger->Log("MasterServer", "%i models were truncated from the database.", numberOfTruncatedModels);
 	}
 }
 
@@ -135,14 +135,14 @@ void MigrationRunner::RunSQLiteMigrations() {
 
 		// Doing these 1 migration at a time since one takes a long time and some may think it is crashing.
 		// This will at the least guarentee that the full migration needs to be run in order to be counted as "migrated".
-		LOG("Executing migration: %s.  This may take a while.  Do not shut down server.", migration.name.c_str());
+		Game::logger->Log("MigrationRunner", "Executing migration: %s.  This may take a while.  Do not shut down server.", migration.name.c_str());
 		CDClientDatabase::ExecuteQuery("BEGIN TRANSACTION;");
 		for (const auto& dml : GeneralUtils::SplitString(migration.data, ';')) {
 			if (dml.empty()) continue;
 			try {
 				CDClientDatabase::ExecuteDML(dml.c_str());
 			} catch (CppSQLite3Exception& e) {
-				LOG("Encountered error running DML command: (%i) : %s", e.errorCode(), e.errorMessage());
+				Game::logger->Log("MigrationRunner", "Encountered error running DML command: (%i) : %s", e.errorCode(), e.errorMessage());
 			}
 		}
 
@@ -154,5 +154,5 @@ void MigrationRunner::RunSQLiteMigrations() {
 		CDClientDatabase::ExecuteQuery("COMMIT;");
 	}
 
-	LOG("CDServer database is up to date.");
+	Game::logger->Log("MigrationRunner", "CDServer database is up to date.");
 }

dDatabase/Tables/CDBehaviorParameterTable.cpp

@@ -1,30 +1,26 @@
 #include "CDBehaviorParameterTable.h"
 #include "GeneralUtils.h"
 
-uint64_t GetKey(const uint32_t behaviorID, const uint32_t parameterID) {
-	uint64_t key = behaviorID;
-	key <<= 31U;
-	key |= parameterID;
-
-	return key;
-}
-
 void CDBehaviorParameterTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM BehaviorParameter");
+	uint32_t uniqueParameterId = 0;
+	uint64_t hash = 0;
 	while (!tableData.eof()) {
-		uint32_t behaviorID = tableData.getIntField("behaviorID", -1);
+		CDBehaviorParameter entry;
+		entry.behaviorID = tableData.getIntField("behaviorID", -1);
 		auto candidateStringToAdd = std::string(tableData.getStringField("parameterID", ""));
 		auto parameter = m_ParametersList.find(candidateStringToAdd);
-		uint32_t parameterId;
 		if (parameter != m_ParametersList.end()) {
-			parameterId = parameter->second;
+			entry.parameterID = parameter;
 		} else {
-			parameterId = m_ParametersList.insert(std::make_pair(candidateStringToAdd, m_ParametersList.size())).first->second;
+			entry.parameterID = m_ParametersList.insert(std::make_pair(candidateStringToAdd, uniqueParameterId)).first;
+			uniqueParameterId++;
 		}
-		uint64_t hash = GetKey(behaviorID, parameterId);
-		float value = tableData.getFloatField("value", -1.0f);
+		hash = entry.behaviorID;
+		hash = (hash << 31U) | entry.parameterID->second;
+		entry.value = tableData.getFloatField("value", -1.0f);
 
-		m_Entries.insert(std::make_pair(hash, value));
+		m_Entries.insert(std::make_pair(hash, entry));
 
 		tableData.nextRow();
 	}
@@ -34,21 +30,25 @@ void CDBehaviorParameterTable::LoadValuesFromDatabase() {
 float CDBehaviorParameterTable::GetValue(const uint32_t behaviorID, const std::string& name, const float defaultValue) {
 	auto parameterID = this->m_ParametersList.find(name);
 	if (parameterID == this->m_ParametersList.end()) return defaultValue;
-	auto hash = GetKey(behaviorID, parameterID->second);
+
+	uint64_t hash = behaviorID;
+
+	hash = (hash << 31U) | parameterID->second;
 
 	// Search for specific parameter
-	auto it = m_Entries.find(hash);
-	return it != m_Entries.end() ? it->second : defaultValue;
+	const auto& it = m_Entries.find(hash);
+	return it != m_Entries.end() ? it->second.value : defaultValue;
 }
 
 std::map<std::string, float> CDBehaviorParameterTable::GetParametersByBehaviorID(uint32_t behaviorID) {
 	uint64_t hashBase = behaviorID;
 	std::map<std::string, float> returnInfo;
-	for (auto& [parameterString, parameterId] : m_ParametersList) {
-		uint64_t hash = GetKey(hashBase, parameterId);
+	uint64_t hash;
+	for (auto& parameterCandidate : m_ParametersList) {
+		hash = (hashBase << 31U) | parameterCandidate.second;
 		auto infoCandidate = m_Entries.find(hash);
 		if (infoCandidate != m_Entries.end()) {
-			returnInfo.insert(std::make_pair(parameterString, infoCandidate->second));
+			returnInfo.insert(std::make_pair(infoCandidate->second.parameterID->first, infoCandidate->second.value));
 		}
 	}
 	return returnInfo;

dDatabase/Tables/CDBehaviorParameterTable.h

@@ -5,11 +5,15 @@
 #include <unordered_map>
 #include <unordered_set>
 
+struct CDBehaviorParameter {
+	unsigned int behaviorID;											//!< The Behavior ID
+	std::unordered_map<std::string, uint32_t>::iterator parameterID;   	//!< The Parameter ID
+	float value;            											//!< The value of the behavior template
+};
+
 class CDBehaviorParameterTable : public CDTable<CDBehaviorParameterTable> {
 private:
-	typedef uint64_t BehaviorParameterHash;
-	typedef float BehaviorParameterValue;
-	std::unordered_map<BehaviorParameterHash, BehaviorParameterValue> m_Entries;
+	std::unordered_map<uint64_t, CDBehaviorParameter> m_Entries;
 	std::unordered_map<std::string, uint32_t> m_ParametersList;
 public:
 	void LoadValuesFromDatabase();

dDatabase/Tables/CDComponentsRegistryTable.cpp

@@ -11,7 +11,6 @@ void CDComponentsRegistryTable::LoadValuesFromDatabase() {
 		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();
 	}
@@ -20,18 +19,19 @@ void CDComponentsRegistryTable::LoadValuesFromDatabase() {
 }
 
 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;
+	auto iter = mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
+
+	if (iter == this->mappedEntries.end()) {
+		return defaultValue;
 	}
 
-	// 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 = ?;");
+	return iter->second;
+	// Now get the data
+	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM ComponentsRegistry WHERE id = ? AND component_type = ?;");
 	query.bind(1, static_cast<int32_t>(id));
+	query.bind(2, static_cast<int32_t>(componentType));
 
 	auto tableData = query.execQuery();
-
 	while (!tableData.eof()) {
 		CDComponentsRegistry entry;
 		entry.id = tableData.getIntField("id", -1);
@@ -43,9 +43,7 @@ int32_t CDComponentsRegistryTable::GetByIDAndType(uint32_t id, eReplicaComponent
 		tableData.nextRow();
 	}
 
-	mappedEntries.insert_or_assign(id, 0);
-
-	auto iter = this->mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
+	iter = this->mappedEntries.find(((uint64_t)componentType) << 32 | ((uint64_t)id));
 
 	return iter == this->mappedEntries.end() ? defaultValue : iter->second;
 }

dDatabase/Tables/CDComponentsRegistryTable.h

@@ -13,7 +13,7 @@ struct CDComponentsRegistry {
 
 class CDComponentsRegistryTable : public CDTable<CDComponentsRegistryTable> {
 private:
-	std::unordered_map<uint64_t, uint32_t> mappedEntries; //id, component_type, component_id
+	std::map<uint64_t, uint32_t> mappedEntries; //id, component_type, component_id
 
 public:
 	void LoadValuesFromDatabase();

dDatabase/Tables/CDLootMatrixTable.cpp

@@ -1,18 +1,5 @@
 #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
@@ -24,6 +11,8 @@ void CDLootMatrixTable::LoadValuesFromDatabase() {
 		tableSize.nextRow();
 	}
 
+	tableSize.finalize();
+
 	// Reserve the size
 	this->entries.reserve(size);
 
@@ -31,28 +20,33 @@ void CDLootMatrixTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM LootMatrix");
 	while (!tableData.eof()) {
 		CDLootMatrix entry;
-		uint32_t lootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
+		entry.LootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
+		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.id = tableData.getIntField("id", -1);
+		entry.flagID = tableData.getIntField("flagID", -1);
+		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 
-		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));
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}
 
-	return this->entries[matrixId];
+	tableData.finalize();
+}
+
+std::vector<CDLootMatrix> CDLootMatrixTable::Query(std::function<bool(CDLootMatrix)> predicate) {
+
+	std::vector<CDLootMatrix> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
+
+	return data;
+}
+
+const std::vector<CDLootMatrix>& CDLootMatrixTable::GetEntries() const {
+	return this->entries;
 }
 

dDatabase/Tables/CDLootMatrixTable.h

@@ -4,26 +4,26 @@
 #include "CDTable.h"
 
 struct CDLootMatrix {
+	unsigned int LootMatrixIndex;           //!< The Loot Matrix Index
 	unsigned int LootTableIndex;            //!< The Loot Table Index
 	unsigned int RarityTableIndex;          //!< The Rarity Table Index
 	float percent;                   //!< The percent that this matrix is used?
 	unsigned int minToDrop;                 //!< The minimum amount of loot from this matrix to drop
 	unsigned int maxToDrop;                 //!< The maximum amount of loot from this matrix to drop
+	unsigned int id;                        //!< The ID of the Loot Matrix
 	unsigned int flagID;                    //!< ???
 	UNUSED(std::string gate_version);          //!< The Gate Version
 };
 
-typedef uint32_t LootMatrixIndex;
-typedef std::vector<CDLootMatrix> LootMatrixEntries;
-
 class CDLootMatrixTable : public CDTable<CDLootMatrixTable> {
+private:
+	std::vector<CDLootMatrix> entries;
+
 public:
 	void LoadValuesFromDatabase();
+	// Queries the table with a custom "where" clause
+	std::vector<CDLootMatrix> Query(std::function<bool(CDLootMatrix)> predicate);
 
-	// Gets a matrix by ID or inserts a blank one if none existed.
-	const LootMatrixEntries& GetMatrix(uint32_t matrixId);
-private:
-	CDLootMatrix ReadRow(CppSQLite3Query& tableData) const;
-	std::unordered_map<LootMatrixIndex, LootMatrixEntries> entries;
+	const std::vector<CDLootMatrix>& GetEntries() const;
 };
 

dDatabase/Tables/CDLootTableTable.cpp

@@ -1,41 +1,4 @@
 #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() {
 
@@ -48,6 +11,8 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 		tableSize.nextRow();
 	}
 
+	tableSize.finalize();
+
 	// Reserve the size
 	this->entries.reserve(size);
 
@@ -55,32 +20,32 @@ void CDLootTableTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM LootTable");
 	while (!tableData.eof()) {
 		CDLootTable entry;
-		uint32_t lootTableIndex = tableData.getIntField("LootTableIndex", -1);
+		entry.id = tableData.getIntField("id", -1);
+		entry.itemid = tableData.getIntField("itemid", -1);
+		entry.LootTableIndex = tableData.getIntField("LootTableIndex", -1);
+		entry.id = tableData.getIntField("id", -1);
+		entry.MissionDrop = tableData.getIntField("MissionDrop", -1) == 1 ? true : false;
+		entry.sortPriority = tableData.getIntField("sortPriority", -1);
 
-		this->entries[lootTableIndex].push_back(ReadRow(tableData));
+		this->entries.push_back(entry);
 		tableData.nextRow();
 	}
-	for (auto& [id, table] : this->entries) {
-		SortTable(table);
-	}
+
+	tableData.finalize();
 }
 
-const LootTableEntries& CDLootTableTable::GetTable(uint32_t tableId) {
-	auto itr = this->entries.find(tableId);
-	if (itr != this->entries.end()) {
-		return itr->second;
-	}
+//! Queries the table with a custom "where" clause
+std::vector<CDLootTable> CDLootTableTable::Query(std::function<bool(CDLootTable)> predicate) {
 
-	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM LootTable WHERE LootTableIndex = ?;");
-	query.bind(1, static_cast<int32_t>(tableId));
-	auto tableData = query.execQuery();
+	std::vector<CDLootTable> data = cpplinq::from(this->entries)
+		>> cpplinq::where(predicate)
+		>> cpplinq::to_vector();
 
-	while (!tableData.eof()) {
-		CDLootTable entry;
-		this->entries[tableId].push_back(ReadRow(tableData));
-		tableData.nextRow();
-	}
-	SortTable(this->entries[tableId]);
-
-	return this->entries[tableId];
+	return data;
 }
+
+//! Gets all the entries in the table
+const std::vector<CDLootTable>& CDLootTableTable::GetEntries() const {
+	return this->entries;
+}
+

dDatabase/Tables/CDLootTableTable.h

@@ -6,21 +6,20 @@
 struct CDLootTable {
 	unsigned int itemid;                 //!< The LOT of the item
 	unsigned int LootTableIndex;         //!< The Loot Table Index
+	unsigned int id;                     //!< The ID
 	bool MissionDrop;               //!< Whether or not this loot table is a mission drop
 	unsigned int sortPriority;           //!< The sorting priority
 };
 
-typedef uint32_t LootTableIndex;
-typedef std::vector<CDLootTable> LootTableEntries;
-
 class CDLootTableTable : public CDTable<CDLootTableTable> {
 private:
-	CDLootTable ReadRow(CppSQLite3Query& tableData) const;
-	std::unordered_map<LootTableIndex, LootTableEntries> entries;
+	std::vector<CDLootTable> entries;
 
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
-	const LootTableEntries& GetTable(uint32_t tableId);
+	std::vector<CDLootTable> Query(std::function<bool(CDLootTable)> predicate);
+
+	const std::vector<CDLootTable>& GetEntries() const;
 };
 

dDatabase/Tables/CDRarityTableTable.cpp

@@ -1,34 +1,24 @@
 #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;");
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM RarityTable");
 	while (!tableData.eof()) {
-		uint32_t rarityTableIndex = tableData.getIntField("RarityTableIndex", -1);
-
 		CDRarityTable entry;
+		uint32_t id = tableData.getIntField("id", -1);
 		entry.randmax = tableData.getFloatField("randmax", -1);
 		entry.rarity = tableData.getIntField("rarity", -1);
-		entries[rarityTableIndex].push_back(entry);
+		entry.RarityTableIndex = tableData.getIntField("RarityTableIndex", -1);
+
+		this->entries.insert_or_assign(id, entry);
 		tableData.nextRow();
 	}
+
+	tableData.finalize();
 }
 
-const std::vector<CDRarityTable>& CDRarityTableTable::GetRarityTable(uint32_t id) {
-	return entries[id];
+//! Queries the table with a custom "where" clause
+const std::optional<CDRarityTable> CDRarityTableTable::Get(uint32_t id) {
+	auto it = this->entries.find(id);
+	return it != this->entries.end() ? std::make_optional(it->second) : std::nullopt;
 }

dDatabase/Tables/CDRarityTableTable.h

@@ -4,20 +4,35 @@
 #include "CDTable.h"
 
 struct CDRarityTable {
+	unsigned int id;
 	float randmax;
 	unsigned int rarity;
-};
+	unsigned int RarityTableIndex;
 
-typedef std::vector<CDRarityTable> RarityTable;
+	friend bool operator> (const CDRarityTable& c1, const CDRarityTable& c2) {
+		return c1.rarity > c2.rarity;
+	}
+
+	friend bool operator>= (const CDRarityTable& c1, const CDRarityTable& c2) {
+		return c1.rarity >= c2.rarity;
+	}
+
+	friend bool operator< (const CDRarityTable& c1, const CDRarityTable& c2) {
+		return c1.rarity < c2.rarity;
+	}
+
+	friend bool operator<= (const CDRarityTable& c1, const CDRarityTable& c2) {
+		return c1.rarity <= c2.rarity;
+	}
+};
 
 class CDRarityTableTable : public CDTable<CDRarityTableTable> {
 private:
-	typedef uint32_t RarityTableIndex;
-	std::unordered_map<RarityTableIndex, std::vector<CDRarityTable>> entries;
+	std::unordered_map<uint32_t, CDRarityTable> entries;
 
 public:
 	void LoadValuesFromDatabase();
-
-	const std::vector<CDRarityTable>& GetRarityTable(uint32_t predicate);
+	// Queries the table with a custom "where" clause
+	const std::optional<CDRarityTable> Get(uint32_t predicate);
 };
 

dDatabase/Tables/CDRebuildComponentTable.cpp

@@ -1,26 +1,11 @@
 #include "CDRebuildComponentTable.h"
 
 void CDRebuildComponentTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RebuildComponent");
-	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 RebuildComponent");
 	while (!tableData.eof()) {
 		CDRebuildComponent entry;
-		entry.id = tableData.getIntField("id", -1);
+		uint32_t id = tableData.getIntField("id", -1);
 		entry.reset_time = tableData.getFloatField("reset_time", -1.0f);
 		entry.complete_time = tableData.getFloatField("complete_time", -1.0f);
 		entry.take_imagination = tableData.getIntField("take_imagination", -1);
@@ -31,23 +16,12 @@ void CDRebuildComponentTable::LoadValuesFromDatabase() {
 		entry.post_imagination_cost = tableData.getIntField("post_imagination_cost", -1);
 		entry.time_before_smash = tableData.getFloatField("time_before_smash", -1.0f);
 
-		this->entries.push_back(entry);
+		this->entries.insert_or_assign(id, entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
-std::vector<CDRebuildComponent> CDRebuildComponentTable::Query(std::function<bool(CDRebuildComponent)> predicate) {
-
-	std::vector<CDRebuildComponent> data = cpplinq::from(this->entries)
-		>> cpplinq::where(predicate)
-		>> cpplinq::to_vector();
-
-	return data;
+const std::optional<CDRebuildComponent> CDRebuildComponentTable::Get(uint32_t componentId) {
+	auto it = this->entries.find(componentId);
+	return it != this->entries.end() ? std::make_optional(it->second) : std::nullopt;
 }
-
-const std::vector<CDRebuildComponent>& CDRebuildComponentTable::GetEntries() const {
-	return this->entries;
-}
-

dDatabase/Tables/CDRebuildComponentTable.h

@@ -4,7 +4,6 @@
 #include "CDTable.h"
 
 struct CDRebuildComponent {
-	unsigned int id;                        //!< The component Id
 	float reset_time;               //!< The reset time
 	float complete_time;            //!< The complete time
 	unsigned int take_imagination;          //!< The amount of imagination it costs
@@ -18,13 +17,11 @@ struct CDRebuildComponent {
 
 class CDRebuildComponentTable : public CDTable<CDRebuildComponentTable> {
 private:
-	std::vector<CDRebuildComponent> entries;
+	std::unordered_map<uint32_t, CDRebuildComponent> entries;
 
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
-	std::vector<CDRebuildComponent> Query(std::function<bool(CDRebuildComponent)> predicate);
-
-	const std::vector<CDRebuildComponent>& GetEntries() const;
+	const std::optional<CDRebuildComponent> Get(uint32_t componentId);
 };
 

dDatabase/Tables/CDRewardsTable.cpp

@@ -4,14 +4,14 @@ void CDRewardsTable::LoadValuesFromDatabase() {
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM Rewards");
 	while (!tableData.eof()) {
 		CDRewards entry;
-		entry.id = tableData.getIntField("id", -1);
+		uint32_t 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));
+		m_entries.push_back(entry);
 		tableData.nextRow();
 	}
 
@@ -19,9 +19,9 @@ void CDRewardsTable::LoadValuesFromDatabase() {
 }
 
 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);
+	std::vector<CDRewards> result;
+	for (const auto& levelData : m_entries) {
+		if (levelData.levelID == levelID) result.push_back(levelData);
 	}
 
 	return result;

dDatabase/Tables/CDRewardsTable.h

@@ -3,7 +3,6 @@
 #include <string>
 
 struct CDRewards {
-	int32_t id;
 	int32_t levelID;
 	int32_t missionID;
 	int32_t rewardType;
@@ -14,10 +13,7 @@ struct CDRewards {
 class CDRewardsTable : public CDTable<CDRewardsTable> {
 public:
 	void LoadValuesFromDatabase();
-
-	static const std::string GetTableName() { return "Rewards"; };
 	std::vector<CDRewards> GetByLevelID(uint32_t levelID);
-
 private:
-	std::map<uint32_t, CDRewards> m_entries;
+	std::vector<CDRewards> m_entries;
 };

dDatabase/Tables/CDScriptComponentTable.cpp

@@ -1,39 +1,21 @@
 #include "CDScriptComponentTable.h"
 
 void CDScriptComponentTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ScriptComponent");
-	while (!tableSize.eof()) {
-		size = tableSize.getIntField(0, 0);
-
-		tableSize.nextRow();
-	}
-
-	tableSize.finalize();
-
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ScriptComponent");
 	while (!tableData.eof()) {
 		CDScriptComponent entry;
-		entry.id = tableData.getIntField("id", -1);
+		uint32_t id = tableData.getIntField("id", -1);
 		entry.script_name = tableData.getStringField("script_name", "");
 		entry.client_script_name = tableData.getStringField("client_script_name", "");
 
-		this->entries.insert(std::make_pair(entry.id, entry));
+		this->entries.insert_or_assign(id, entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
-const CDScriptComponent& CDScriptComponentTable::GetByID(unsigned int id) {
-	std::map<unsigned int, CDScriptComponent>::iterator it = this->entries.find(id);
-	if (it != this->entries.end()) {
-		return it->second;
-	}
-
-	return m_ToReturnWhenNoneFound;
+const std::optional<CDScriptComponent> CDScriptComponentTable::GetByID(unsigned int id) {
+	auto it = this->entries.find(id);
+	return (it != this->entries.end()) ? std::make_optional<CDScriptComponent>(it->second) : std::nullopt;
 }
 

dDatabase/Tables/CDScriptComponentTable.h

@@ -4,19 +4,16 @@
 #include "CDTable.h"
 
 struct CDScriptComponent {
-	unsigned int id;                        //!< The component ID
-	std::string script_name;           //!< The script name
-	std::string client_script_name;    //!< The client script name
+	std::string script_name;           		//!< The script name
+	std::string client_script_name;   		//!< The client script name
 };
 
 class CDScriptComponentTable : public CDTable<CDScriptComponentTable> {
 private:
-	std::map<unsigned int, CDScriptComponent> entries;
-	CDScriptComponent m_ToReturnWhenNoneFound;
-
+	std::unordered_map<unsigned int, CDScriptComponent> entries;
 public:
 	void LoadValuesFromDatabase();
 	// Gets an entry by scriptID
-	const CDScriptComponent& GetByID(unsigned int id);
+	const std::optional<CDScriptComponent> GetByID(unsigned int id);
 };
 

dDatabase/Tables/CDSkillBehaviorTable.cpp

@@ -1,27 +1,10 @@
 #include "CDSkillBehaviorTable.h"
 
 void CDSkillBehaviorTable::LoadValuesFromDatabase() {
-	m_empty = CDSkillBehavior();
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM SkillBehavior");
-	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 SkillBehavior");
 	while (!tableData.eof()) {
 		CDSkillBehavior entry;
-		entry.skillID = tableData.getIntField("skillID", -1);
+		uint32_t skillID = tableData.getIntField("skillID", -1);
 		UNUSED(entry.locStatus = tableData.getIntField("locStatus", -1));
 		entry.behaviorID = tableData.getIntField("behaviorID", -1);
 		entry.imaginationcost = tableData.getIntField("imaginationcost", -1);
@@ -41,20 +24,13 @@ void CDSkillBehaviorTable::LoadValuesFromDatabase() {
 		UNUSED(entry.gate_version = tableData.getStringField("gate_version", ""));
 		UNUSED(entry.cancelType = tableData.getIntField("cancelType", -1));
 
-		this->entries.insert(std::make_pair(entry.skillID, entry));
-		//this->entries.push_back(entry);
+		this->entries.insert_or_assign(skillID, entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
-const CDSkillBehavior& CDSkillBehaviorTable::GetSkillByID(unsigned int skillID) {
-	std::map<unsigned int, CDSkillBehavior>::iterator it = this->entries.find(skillID);
-	if (it != this->entries.end()) {
-		return it->second;
-	}
-
-	return m_empty;
+const std::optional<CDSkillBehavior> CDSkillBehaviorTable::GetSkillByID(unsigned int skillID) {
+	auto it = this->entries.find(skillID);
+	return it != this->entries.end() ? std::make_optional(it->second) : std::nullopt;
 }
 

dDatabase/Tables/CDSkillBehaviorTable.h

@@ -4,7 +4,6 @@
 #include "CDTable.h"
 
 struct CDSkillBehavior {
-	unsigned int skillID;               //!< The Skill ID of the skill
 	UNUSED(unsigned int locStatus);             //!< ??
 	unsigned int behaviorID;            //!< The Behavior ID of the skill
 	unsigned int imaginationcost;       //!< The imagination cost of the skill
@@ -27,13 +26,11 @@ struct CDSkillBehavior {
 
 class CDSkillBehaviorTable : public CDTable<CDSkillBehaviorTable> {
 private:
-	std::map<unsigned int, CDSkillBehavior> entries;
-	CDSkillBehavior m_empty;
-
+	std::unordered_map<uint32_t, CDSkillBehavior> entries;
 public:
 	void LoadValuesFromDatabase();
 
 	// Gets an entry by skillID
-	const CDSkillBehavior& GetSkillByID(unsigned int skillID);
+	const std::optional<CDSkillBehavior> GetSkillByID(unsigned int skillID);
 };
 

dDatabase/Tables/CDTable.h

@@ -5,6 +5,7 @@
 #include "DluAssert.h"
 
 #include <functional>
+#include <optional>
 #include <string>
 #include <vector>
 #include <map>

dDatabase/Tables/CDVendorComponentTable.cpp

@@ -1,50 +1,22 @@
 #include "CDVendorComponentTable.h"
 
 void CDVendorComponentTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM VendorComponent");
-	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 VendorComponent");
 	while (!tableData.eof()) {
 		CDVendorComponent entry;
-		entry.id = tableData.getIntField("id", -1);
-		entry.buyScalar = tableData.getFloatField("buyScalar", 0.0f);
+		uint32_t id = tableData.getIntField("id", -1);
+		entry.buyScalar = tableData.getFloatField("buyScalar", -1.0f);
 		entry.sellScalar = tableData.getFloatField("sellScalar", -1.0f);
 		entry.refreshTimeSeconds = tableData.getFloatField("refreshTimeSeconds", -1.0f);
 		entry.LootMatrixIndex = tableData.getIntField("LootMatrixIndex", -1);
 
-		this->entries.push_back(entry);
+		this->entries.insert_or_assign(id, entry);
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
-//! Queries the table with a custom "where" clause
-std::vector<CDVendorComponent> CDVendorComponentTable::Query(std::function<bool(CDVendorComponent)> predicate) {
-
-	std::vector<CDVendorComponent> data = cpplinq::from(this->entries)
-		>> cpplinq::where(predicate)
-		>> cpplinq::to_vector();
-
-	return data;
+const std::optional<CDVendorComponent> CDVendorComponentTable::Query(uint32_t id) {
+	const auto& iter = entries.find(id);
+	return iter != entries.end() ? std::make_optional(iter->second) : std::nullopt;
 }
-
-//! Gets all the entries in the table
-const std::vector<CDVendorComponent>& CDVendorComponentTable::GetEntries() const {
-	return this->entries;
-}
-

dDatabase/Tables/CDVendorComponentTable.h

@@ -4,7 +4,6 @@
 #include "CDTable.h"
 
 struct CDVendorComponent {
-	unsigned int id;           //!< The Component ID
 	float buyScalar;            //!< Buy Scalar (what does that mean?)
 	float sellScalar;          //!< Sell Scalar (what does that mean?)
 	float refreshTimeSeconds;  //!< The refresh time
@@ -13,13 +12,11 @@ struct CDVendorComponent {
 
 class CDVendorComponentTable : public CDTable<CDVendorComponentTable> {
 private:
-	std::vector<CDVendorComponent> entries;
+	std::unordered_map<uint32_t, CDVendorComponent> entries;
 
 public:
 	void LoadValuesFromDatabase();
 	// Queries the table with a custom "where" clause
-	std::vector<CDVendorComponent> Query(std::function<bool(CDVendorComponent)> predicate);
-
-	const std::vector<CDVendorComponent>& GetEntries(void) const;
+	const std::optional<CDVendorComponent> Query(uint32_t id);
 };
 

dDatabase/Tables/CDZoneTableTable.cpp

@@ -1,18 +1,6 @@
 #include "CDZoneTableTable.h"
 
 void CDZoneTableTable::LoadValuesFromDatabase() {
-
-	// First, get the size of the table
-	unsigned int size = 0;
-	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ZoneTable");
-	while (!tableSize.eof()) {
-		size = tableSize.getIntField(0, 0);
-
-		tableSize.nextRow();
-	}
-
-	tableSize.finalize();
-
 	// Now get the data
 	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM ZoneTable");
 	while (!tableData.eof()) {
@@ -48,18 +36,11 @@ void CDZoneTableTable::LoadValuesFromDatabase() {
 		this->m_Entries.insert(std::make_pair(entry.zoneID, entry));
 		tableData.nextRow();
 	}
-
-	tableData.finalize();
 }
 
 //! Queries the table with a zoneID to find.
-const CDZoneTable* CDZoneTableTable::Query(unsigned int zoneID) {
+const std::optional<CDZoneTable> CDZoneTableTable::Query(unsigned int zoneID) {
 	const auto& iter = m_Entries.find(zoneID);
-
-	if (iter != m_Entries.end()) {
-		return &iter->second;
-	}
-
-	return nullptr;
+	return iter != m_Entries.end() ? std::make_optional(iter->second) : std::nullopt;
 }
 

dDatabase/Tables/CDZoneTableTable.h

@@ -1,6 +1,5 @@
 #pragma once
 
-// Custom Classes
 #include "CDTable.h"
 
 struct CDZoneTable {
@@ -35,11 +34,11 @@ struct CDZoneTable {
 
 class CDZoneTableTable : public CDTable<CDZoneTableTable> {
 private:
-	std::map<unsigned int, CDZoneTable> m_Entries;
+	std::unordered_map<uint32_t, CDZoneTable> m_Entries;
 
 public:
 	void LoadValuesFromDatabase();
 
 	// Queries the table with a zoneID to find.
-	const CDZoneTable* Query(unsigned int zoneID);
+	const std::optional<CDZoneTable> Query(unsigned int zoneID);
 };

dGame/Character.cpp

@@ -2,7 +2,7 @@
 #include "User.h"
 #include "Database.h"
 #include "GeneralUtils.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "BitStream.h"
 #include "Game.h"
 #include <chrono>
@@ -145,16 +145,16 @@ void Character::DoQuickXMLDataParse() {
 	if (!m_Doc) return;
 
 	if (m_Doc->Parse(m_XMLData.c_str(), m_XMLData.size()) == 0) {
-		LOG("Loaded xmlData for character %s (%i)!", m_Name.c_str(), m_ID);
+		Game::logger->Log("Character", "Loaded xmlData for character %s (%i)!", m_Name.c_str(), m_ID);
 	} else {
-		LOG("Failed to load xmlData!");
+		Game::logger->Log("Character", "Failed to load xmlData!");
 		//Server::rakServer->CloseConnection(m_ParentUser->GetSystemAddress(), true);
 		return;
 	}
 
 	tinyxml2::XMLElement* mf = m_Doc->FirstChildElement("obj")->FirstChildElement("mf");
 	if (!mf) {
-		LOG("Failed to find mf tag!");
+		Game::logger->Log("Character", "Failed to find mf tag!");
 		return;
 	}
 
@@ -173,14 +173,14 @@ void Character::DoQuickXMLDataParse() {
 
 	tinyxml2::XMLElement* inv = m_Doc->FirstChildElement("obj")->FirstChildElement("inv");
 	if (!inv) {
-		LOG("Char has no inv!");
+		Game::logger->Log("Character", "Char has no inv!");
 		return;
 	}
 
 	tinyxml2::XMLElement* bag = inv->FirstChildElement("items")->FirstChildElement("in");
 
 	if (!bag) {
-		LOG("Couldn't find bag0!");
+		Game::logger->Log("Character", "Couldn't find bag0!");
 		return;
 	}
 
@@ -373,7 +373,7 @@ void Character::SaveXMLToDatabase() {
 
 	//Call upon the entity to update our xmlDoc:
 	if (!m_OurEntity) {
-		LOG("%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
+		Game::logger->Log("Character", "%i:%s didn't have an entity set while saving! CHARACTER WILL NOT BE SAVED!", this->GetID(), this->GetName().c_str());
 		return;
 	}
 
@@ -384,7 +384,7 @@ void Character::SaveXMLToDatabase() {
 	//For metrics, log the time it took to save:
 	auto end = std::chrono::system_clock::now();
 	std::chrono::duration<double> elapsed = end - start;
-	LOG("%i:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
+	Game::logger->Log("Character", "%i:%s Saved character to Database in: %fs", this->GetID(), this->GetName().c_str(), elapsed.count());
 }
 
 void Character::SetIsNewLogin() {
@@ -394,13 +394,12 @@ void Character::SetIsNewLogin() {
 
 	auto* currentChild = flags->FirstChildElement();
 	while (currentChild) {
-		auto* nextChild = currentChild->NextSiblingElement();
 		if (currentChild->Attribute("si")) {
 			flags->DeleteChild(currentChild);
-			LOG("Removed isLoggedIn flag from character %i:%s, saving character to database", GetID(), GetName().c_str());
+			Game::logger->Log("Character", "Removed isLoggedIn flag from character %i:%s, saving character to database", GetID(), GetName().c_str());
 			WriteToDatabase();
 		}
-		currentChild = nextChild;
+		currentChild = currentChild->NextSiblingElement();
 	}
 }
 
@@ -555,6 +554,15 @@ void Character::OnZoneLoad() {
 		return;
 	}
 
+	/**
+	 * Restrict old character to 1 million coins
+	 */
+	if (HasPermission(ePermissionMap::Old)) {
+		if (GetCoins() > 1000000) {
+			SetCoins(1000000, eLootSourceType::NONE);
+		}
+	}
+
 	auto* inventoryComponent = m_OurEntity->GetComponent<InventoryComponent>();
 
 	if (inventoryComponent == nullptr) {

dGame/Entity.cpp

@@ -2,7 +2,7 @@
 #include "Entity.h"
 #include "CDClientManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include <PacketUtils.h>
 #include <functional>
 #include "CDDestructibleComponentTable.h"
@@ -30,7 +30,7 @@
 #include "Component.h"
 #include "ControllablePhysicsComponent.h"
 #include "RenderComponent.h"
-#include "MultiZoneEntranceComponent.h"
+#include "RocketLaunchLupComponent.h"
 #include "CharacterComponent.h"
 #include "DestroyableComponent.h"
 #include "BuffComponent.h"
@@ -51,7 +51,6 @@
 #include "BuildBorderComponent.h"
 #include "MovementAIComponent.h"
 #include "VendorComponent.h"
-#include "DonationVendorComponent.h"
 #include "RocketLaunchpadControlComponent.h"
 #include "PropertyComponent.h"
 #include "BaseCombatAIComponent.h"
@@ -71,15 +70,10 @@
 #include "ShootingGalleryComponent.h"
 #include "RailActivatorComponent.h"
 #include "LUPExhibitComponent.h"
-#include "RacingSoundTriggerComponent.h"
 #include "TriggerComponent.h"
 #include "eGameMasterLevel.h"
 #include "eReplicaComponentType.h"
 #include "eReplicaPacketType.h"
-#include "ZoneControlComponent.h"
-#include "RacingStatsComponent.h"
-#include "CollectibleComponent.h"
-#include "ItemComponent.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -99,6 +93,7 @@ Entity::Entity(const LWOOBJID& objectID, EntityInfo info, Entity* parentEntity)
 	m_ParentEntity = parentEntity;
 	m_Character = nullptr;
 	m_GMLevel = eGameMasterLevel::CIVILIAN;
+	m_CollectibleID = 0;
 	m_NetworkID = 0;
 	m_Groups = {};
 	m_OwnerOverride = LWOOBJID_EMPTY;
@@ -156,7 +151,7 @@ void Entity::Initialize() {
 
 	const auto triggerInfo = GetVarAsString(u"trigger_id");
 
-	if (!triggerInfo.empty()) AddComponent<TriggerComponent>(triggerInfo);
+	if (!triggerInfo.empty()) m_Components.emplace(eReplicaComponentType::TRIGGER, new TriggerComponent(this, triggerInfo));
 
 	/**
 	 * Setup groups
@@ -187,17 +182,21 @@ void Entity::Initialize() {
 	if (m_TemplateID == 14) {
 		const auto simplePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SIMPLE_PHYSICS);
 
-		AddComponent<SimplePhysicsComponent>(simplePhysicsComponentID);
+		SimplePhysicsComponent* comp = new SimplePhysicsComponent(simplePhysicsComponentID, this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::SIMPLE_PHYSICS, comp));
 
-		AddComponent<ModelComponent>();
+		ModelComponent* modelcomp = new ModelComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::MODEL, modelcomp));
 
-		AddComponent<RenderComponent>();
+		RenderComponent* render = new RenderComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::RENDER, render));
 
-		auto* destroyableComponent = AddComponent<DestroyableComponent>();
+		auto destroyableComponent = new DestroyableComponent(this);
 		destroyableComponent->SetHealth(1);
 		destroyableComponent->SetMaxHealth(1.0f);
 		destroyableComponent->SetFaction(-1, true);
 		destroyableComponent->SetIsSmashable(true);
+		m_Components.insert(std::make_pair(eReplicaComponentType::DESTROYABLE, destroyableComponent));
 		// We have all our components.
 		return;
 	}
@@ -209,46 +208,49 @@ void Entity::Initialize() {
 	 */
 
 	if (GetParentUser()) {
-		AddComponent<MissionComponent>()->LoadFromXml(m_Character->GetXMLDoc());
+		auto missions = new MissionComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::MISSION, missions));
+		missions->LoadFromXml(m_Character->GetXMLDoc());
 	}
 
 	uint32_t petComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PET);
 	if (petComponentId > 0) {
-		AddComponent<PetComponent>(petComponentId);
+		m_Components.insert(std::make_pair(eReplicaComponentType::PET, new PetComponent(this, petComponentId)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ZONE_CONTROL) > 0) {
-		AddComponent<ZoneControlComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::ZONE_CONTROL, nullptr));
 	}
 
 	uint32_t possessableComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::POSSESSABLE);
 	if (possessableComponentId > 0) {
-		AddComponent<PossessableComponent>(possessableComponentId);
+		m_Components.insert(std::make_pair(eReplicaComponentType::POSSESSABLE, new PossessableComponent(this, possessableComponentId)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODULE_ASSEMBLY) > 0) {
-		AddComponent<ModuleAssemblyComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::MODULE_ASSEMBLY, new ModuleAssemblyComponent(this)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_STATS) > 0) {
-		AddComponent<RacingStatsComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::RACING_STATS, nullptr));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::LUP_EXHIBIT, -1) >= 0) {
-		AddComponent<LUPExhibitComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::LUP_EXHIBIT, new LUPExhibitComponent(this)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_CONTROL) > 0) {
-		AddComponent<RacingControlComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::RACING_CONTROL, new RacingControlComponent(this)));
 	}
 
 	const auto propertyEntranceComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY_ENTRANCE);
 	if (propertyEntranceComponentID > 0) {
-		AddComponent<PropertyEntranceComponent>(propertyEntranceComponentID);
+		m_Components.insert(std::make_pair(eReplicaComponentType::PROPERTY_ENTRANCE,
+			new PropertyEntranceComponent(propertyEntranceComponentID, this)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::CONTROLLABLE_PHYSICS) > 0) {
-		auto* controllablePhysics = AddComponent<ControllablePhysicsComponent>();
+		ControllablePhysicsComponent* controllablePhysics = new ControllablePhysicsComponent(this);
 
 		if (m_Character) {
 			controllablePhysics->LoadFromXml(m_Character->GetXMLDoc());
@@ -281,6 +283,8 @@ void Entity::Initialize() {
 			controllablePhysics->SetPosition(m_DefaultPosition);
 			controllablePhysics->SetRotation(m_DefaultRotation);
 		}
+
+		m_Components.insert(std::make_pair(eReplicaComponentType::CONTROLLABLE_PHYSICS, controllablePhysics));
 	}
 
 	// If an entity is marked a phantom, simple physics is made into phantom phyics.
@@ -288,56 +292,64 @@ void Entity::Initialize() {
 
 	const auto simplePhysicsComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SIMPLE_PHYSICS);
 	if (!markedAsPhantom && simplePhysicsComponentID > 0) {
-		AddComponent<SimplePhysicsComponent>(simplePhysicsComponentID);
+		SimplePhysicsComponent* comp = new SimplePhysicsComponent(simplePhysicsComponentID, this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::SIMPLE_PHYSICS, comp));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS) > 0) {
-		AddComponent<RigidbodyPhantomPhysicsComponent>();
+		RigidbodyPhantomPhysicsComponent* comp = new RigidbodyPhantomPhysicsComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS, comp));
 	}
 
 	if (markedAsPhantom || compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PHANTOM_PHYSICS) > 0) {
-		AddComponent<PhantomPhysicsComponent>()->SetPhysicsEffectActive(false);
+		PhantomPhysicsComponent* phantomPhysics = new PhantomPhysicsComponent(this);
+		phantomPhysics->SetPhysicsEffectActive(false);
+		m_Components.insert(std::make_pair(eReplicaComponentType::PHANTOM_PHYSICS, phantomPhysics));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::VEHICLE_PHYSICS) > 0) {
-		auto* vehiclePhysicsComponent = AddComponent<VehiclePhysicsComponent>();
+		VehiclePhysicsComponent* vehiclePhysicsComponent = new VehiclePhysicsComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::VEHICLE_PHYSICS, vehiclePhysicsComponent));
 		vehiclePhysicsComponent->SetPosition(m_DefaultPosition);
 		vehiclePhysicsComponent->SetRotation(m_DefaultRotation);
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SOUND_TRIGGER, -1) != -1) {
-		AddComponent<SoundTriggerComponent>();
-	} else if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_SOUND_TRIGGER, -1) != -1) {
-		AddComponent<RacingSoundTriggerComponent>();
+		auto* comp = new SoundTriggerComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::SOUND_TRIGGER, comp));
 	}
 
+	//Also check for the collectible id:
+	m_CollectibleID = GetVarAs<int32_t>(u"collectible_id");
+
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BUFF) > 0) {
-		AddComponent<BuffComponent>();
+		BuffComponent* comp = new BuffComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::BUFF, comp));
 	}
 
 	int collectibleComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::COLLECTIBLE);
 
 	if (collectibleComponentID > 0) {
-		AddComponent<CollectibleComponent>(GetVarAs<int32_t>(u"collectible_id"));
+		m_Components.insert(std::make_pair(eReplicaComponentType::COLLECTIBLE, nullptr));
 	}
 
 	/**
 	 * Multiple components require the destructible component.
 	 */
+
 	int buffComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BUFF);
 	int rebuildComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::QUICK_BUILD);
 
-	int componentID = -1;
+	int componentID = 0;
 	if (collectibleComponentID > 0) componentID = collectibleComponentID;
 	if (rebuildComponentID > 0) componentID = rebuildComponentID;
 	if (buffComponentID > 0) componentID = buffComponentID;
 
 	CDDestructibleComponentTable* destCompTable = CDClientManager::Instance().GetTable<CDDestructibleComponentTable>();
 	std::vector<CDDestructibleComponent> destCompData = destCompTable->Query([=](CDDestructibleComponent entry) { return (entry.id == componentID); });
-  
-	bool isSmashable = GetVarAs<int32_t>(u"is_smashable") != 0;
-	if (buffComponentID > 0 || collectibleComponentID > 0 || isSmashable) {
-		DestroyableComponent* comp = AddComponent<DestroyableComponent>();
+
+	if (buffComponentID > 0 || collectibleComponentID > 0) {
+		DestroyableComponent* comp = new DestroyableComponent(this);
 		if (m_Character) {
 			comp->LoadFromXml(m_Character->GetXMLDoc());
 		} else {
@@ -356,12 +368,10 @@ void Entity::Initialize() {
 					comp->SetMaxHealth(destCompData[0].life);
 					comp->SetMaxImagination(destCompData[0].imagination);
 					comp->SetMaxArmor(destCompData[0].armor);
-					comp->SetDeathBehavior(destCompData[0].death_behavior);
 
 					comp->SetIsSmashable(destCompData[0].isSmashable);
 
 					comp->SetLootMatrixID(destCompData[0].LootMatrixIndex);
-					Loot::CacheMatrix(destCompData[0].LootMatrixIndex);
 
 					// Now get currency information
 					uint32_t npcMinLevel = destCompData[0].level;
@@ -377,7 +387,7 @@ void Entity::Initialize() {
 					}
 
 					// extraInfo overrides. Client ORs the database smashable and the luz smashable.
-					comp->SetIsSmashable(comp->GetIsSmashable() | isSmashable);
+					comp->SetIsSmashable(comp->GetIsSmashable() | (GetVarAs<int32_t>(u"is_smashable") != 0));
 				}
 			} else {
 				comp->SetHealth(1);
@@ -410,39 +420,35 @@ void Entity::Initialize() {
 			}
 		}
 
-		// override the factions if needed.
-		auto setFaction = GetVarAsString(u"set_faction");
-		if (!setFaction.empty()) {
-			// TODO also split on space here however we do not have a general util for splitting on multiple characters yet.
-			std::vector<std::string> factionsToAdd = GeneralUtils::SplitString(setFaction, ';');
-			int32_t factionToAdd;
-			for (const auto faction : factionsToAdd) {
-				if (GeneralUtils::TryParse(faction, factionToAdd)) {
-					comp->AddFaction(factionToAdd, true);
-				}
-			}
-		}
+		m_Components.insert(std::make_pair(eReplicaComponentType::DESTROYABLE, comp));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::CHARACTER) > 0 || m_Character) {
 		// Character Component always has a possessor, level, and forced movement components
-		AddComponent<PossessorComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::POSSESSOR, new PossessorComponent(this)));
 
 		// load in the xml for the level
-		AddComponent<LevelProgressionComponent>()->LoadFromXml(m_Character->GetXMLDoc());
+		auto* levelComp = new LevelProgressionComponent(this);
+		levelComp->LoadFromXml(m_Character->GetXMLDoc());
+		m_Components.insert(std::make_pair(eReplicaComponentType::LEVEL_PROGRESSION, levelComp));
 
-		AddComponent<PlayerForcedMovementComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::PLAYER_FORCED_MOVEMENT, new PlayerForcedMovementComponent(this)));
 
-		AddComponent<CharacterComponent>(m_Character)->LoadFromXml(m_Character->GetXMLDoc());
+		CharacterComponent* charComp = new CharacterComponent(this, m_Character);
+		charComp->LoadFromXml(m_Character->GetXMLDoc());
+		m_Components.insert(std::make_pair(eReplicaComponentType::CHARACTER, charComp));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::INVENTORY) > 0 || m_Character) {
-		auto* xmlDoc = m_Character ? m_Character->GetXMLDoc() : nullptr;
-		AddComponent<InventoryComponent>(xmlDoc);
+		InventoryComponent* comp = nullptr;
+		if (m_Character) comp = new InventoryComponent(this, m_Character->GetXMLDoc());
+		else comp = new InventoryComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::INVENTORY, comp));
 	}
 	// if this component exists, then we initialize it. it's value is always 0
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MULTI_ZONE_ENTRANCE, -1) != -1) {
-		AddComponent<MultiZoneEntranceComponent>();
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ROCKET_LAUNCH_LUP, -1) != -1) {
+		auto comp = new RocketLaunchLupComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::ROCKET_LAUNCH_LUP, comp));
 	}
 
 	/**
@@ -457,9 +463,11 @@ void Entity::Initialize() {
 	if (scriptComponentID > 0 || m_Character) {
 		std::string clientScriptName;
 		if (!m_Character) {
-			CDScriptComponent scriptCompData = scriptCompTable->GetByID(scriptComponentID);
-			scriptName = scriptCompData.script_name;
-			clientScriptName = scriptCompData.client_script_name;
+			auto scriptCompData = scriptCompTable->GetByID(scriptComponentID);
+			if (scriptCompData) {
+				scriptName = scriptCompData->script_name;
+				clientScriptName = scriptCompData->client_script_name;
+			}
 		} else {
 			scriptName = "";
 		}
@@ -493,149 +501,157 @@ void Entity::Initialize() {
 	}
 
 	if (!scriptName.empty() || client || m_Character || scriptComponentID >= 0) {
-		AddComponent<ScriptComponent>(scriptName, true, client && scriptName.empty());
+		m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPT, new ScriptComponent(this, scriptName, true, client && scriptName.empty())));
 	}
 
 	// ZoneControl script
 	if (m_TemplateID == 2365) {
-		CDZoneTableTable* zoneTable = CDClientManager::Instance().GetTable<CDZoneTableTable>();
+		auto* zoneTable = CDClientManager::Instance().GetTable<CDZoneTableTable>();
 		const auto zoneID = Game::zoneManager->GetZoneID();
-		const CDZoneTable* zoneData = zoneTable->Query(zoneID.GetMapID());
+		auto zoneData = zoneTable->Query(zoneID.GetMapID());
 
-		if (zoneData != nullptr) {
+		if (zoneData) {
 			int zoneScriptID = zoneData->scriptID;
-			CDScriptComponent zoneScriptData = scriptCompTable->GetByID(zoneScriptID);
-			AddComponent<ScriptComponent>(zoneScriptData.script_name, true);
+			auto zoneScriptData = scriptCompTable->GetByID(zoneScriptID);
+			if (zoneScriptData) {
+				ScriptComponent* comp = new ScriptComponent(this, zoneScriptData->script_name, true);
+				m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPT, comp));
+			}
 		}
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SKILL, -1) != -1 || m_Character) {
-		AddComponent<SkillComponent>();
+		SkillComponent* comp = new SkillComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::SKILL, comp));
 	}
 
 	const auto combatAiId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BASE_COMBAT_AI);
 	if (combatAiId > 0) {
-		AddComponent<BaseCombatAIComponent>(combatAiId);
+		BaseCombatAIComponent* comp = new BaseCombatAIComponent(this, combatAiId);
+		m_Components.insert(std::make_pair(eReplicaComponentType::BASE_COMBAT_AI, comp));
 	}
 
 	if (int componentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::QUICK_BUILD) > 0) {
-		auto* rebuildComponent = AddComponent<RebuildComponent>();
+		RebuildComponent* comp = new RebuildComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::QUICK_BUILD, comp));
 
 		CDRebuildComponentTable* rebCompTable = CDClientManager::Instance().GetTable<CDRebuildComponentTable>();
-		std::vector<CDRebuildComponent> rebCompData = rebCompTable->Query([=](CDRebuildComponent entry) { return (entry.id == rebuildComponentID); });
+		auto rebCompData = rebCompTable->Get(rebuildComponentID);
 
-		if (rebCompData.size() > 0) {
-			rebuildComponent->SetResetTime(rebCompData[0].reset_time);
-			rebuildComponent->SetCompleteTime(rebCompData[0].complete_time);
-			rebuildComponent->SetTakeImagination(rebCompData[0].take_imagination);
-			rebuildComponent->SetInterruptible(rebCompData[0].interruptible);
-			rebuildComponent->SetSelfActivator(rebCompData[0].self_activator);
-			rebuildComponent->SetActivityId(rebCompData[0].activityID);
-			rebuildComponent->SetPostImaginationCost(rebCompData[0].post_imagination_cost);
-			rebuildComponent->SetTimeBeforeSmash(rebCompData[0].time_before_smash);
+		if (rebCompData) {
+			comp->SetResetTime(rebCompData->reset_time);
+			comp->SetCompleteTime(rebCompData->complete_time);
+			comp->SetTakeImagination(rebCompData->take_imagination);
+			comp->SetInterruptible(rebCompData->interruptible);
+			comp->SetSelfActivator(rebCompData->self_activator);
+			comp->SetActivityId(rebCompData->activityID);
+			comp->SetPostImaginationCost(rebCompData->post_imagination_cost);
+			comp->SetTimeBeforeSmash(rebCompData->time_before_smash);
 
 			const auto rebuildResetTime = GetVar<float>(u"rebuild_reset_time");
 
 			if (rebuildResetTime != 0.0f) {
-				rebuildComponent->SetResetTime(rebuildResetTime);
+				comp->SetResetTime(rebuildResetTime);
 
-				// Known bug with moving platform in FV that casues it to build at the end instead of the start.
-				// This extends the smash time so players can ride up the lift.
-				if (m_TemplateID == 9483)
+				if (m_TemplateID == 9483) // Look away!
 				{
-					rebuildComponent->SetResetTime(rebuildComponent->GetResetTime() + 25);
+					comp->SetResetTime(comp->GetResetTime() + 25);
 				}
 			}
 
 			const auto activityID = GetVar<int32_t>(u"activityID");
 
 			if (activityID > 0) {
-				rebuildComponent->SetActivityId(activityID);
-				Loot::CacheMatrix(activityID);
+				comp->SetActivityId(activityID);
 			}
 
 			const auto compTime = GetVar<float>(u"compTime");
 
 			if (compTime > 0) {
-				rebuildComponent->SetCompleteTime(compTime);
+				comp->SetCompleteTime(compTime);
 			}
 		}
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SWITCH, -1) != -1) {
-		AddComponent<SwitchComponent>();
+		SwitchComponent* comp = new SwitchComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::SWITCH, comp));
 	}
 
 	if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::VENDOR) > 0)) {
-		AddComponent<VendorComponent>();
-	} else if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::DONATION_VENDOR, -1) != -1)) {
-		AddComponent<DonationVendorComponent>();
+		VendorComponent* comp = new VendorComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::VENDOR, comp));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY_VENDOR, -1) != -1) {
-		AddComponent<PropertyVendorComponent>();
+		auto* component = new PropertyVendorComponent(this);
+		m_Components.insert_or_assign(eReplicaComponentType::PROPERTY_VENDOR, component);
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY_MANAGEMENT, -1) != -1) {
-		AddComponent<PropertyManagementComponent>();
+		auto* component = new PropertyManagementComponent(this);
+		m_Components.insert_or_assign(eReplicaComponentType::PROPERTY_MANAGEMENT, component);
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BOUNCER, -1) != -1) { // you have to determine it like this because all bouncers have a componentID of 0
-		AddComponent<BouncerComponent>();
+		BouncerComponent* comp = new BouncerComponent(this);
+		m_Components.insert(std::make_pair(eReplicaComponentType::BOUNCER, comp));
 	}
 
 	int32_t renderComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RENDER);
 	if ((renderComponentId > 0 && m_TemplateID != 2365) || m_Character) {
-		AddComponent<RenderComponent>(renderComponentId);
+		RenderComponent* render = new RenderComponent(this, renderComponentId);
+		m_Components.insert(std::make_pair(eReplicaComponentType::RENDER, render));
 	}
 
 	if ((compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MISSION_OFFER) > 0) || m_Character) {
-		AddComponent<MissionOfferComponent>(m_TemplateID);
+		m_Components.insert(std::make_pair(eReplicaComponentType::MISSION_OFFER, new MissionOfferComponent(this, m_TemplateID)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::BUILD_BORDER, -1) != -1) {
-		AddComponent<BuildBorderComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::BUILD_BORDER, new BuildBorderComponent(this)));
 	}
 
 	// Scripted activity component
 	int scriptedActivityID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SCRIPTED_ACTIVITY);
 	if ((scriptedActivityID > 0)) {
-		AddComponent<ScriptedActivityComponent>(scriptedActivityID);
+		m_Components.insert(std::make_pair(eReplicaComponentType::SCRIPTED_ACTIVITY, new ScriptedActivityComponent(this, scriptedActivityID)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MODEL, -1) != -1 && !GetComponent<PetComponent>()) {
-		AddComponent<ModelComponent>();
-		if (!HasComponent(eReplicaComponentType::DESTROYABLE)) {
-			auto* destroyableComponent = AddComponent<DestroyableComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::MODEL, new ModelComponent(this)));
+		if (m_Components.find(eReplicaComponentType::DESTROYABLE) == m_Components.end()) {
+			auto destroyableComponent = new DestroyableComponent(this);
 			destroyableComponent->SetHealth(1);
 			destroyableComponent->SetMaxHealth(1.0f);
 			destroyableComponent->SetFaction(-1, true);
 			destroyableComponent->SetIsSmashable(true);
+			m_Components.insert(std::make_pair(eReplicaComponentType::DESTROYABLE, destroyableComponent));
 		}
 	}
 
 	PetComponent* petComponent;
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ITEM) > 0 && !TryGetComponent(eReplicaComponentType::PET, petComponent) && !HasComponent(eReplicaComponentType::MODEL)) {
-		AddComponent<ItemComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::ITEM, nullptr));
 	}
 
 	// Shooting gallery component
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SHOOTING_GALLERY) > 0) {
-		AddComponent<ShootingGalleryComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::SHOOTING_GALLERY, new ShootingGalleryComponent(this)));
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::PROPERTY, -1) != -1) {
-		AddComponent<PropertyComponent>();
+		m_Components.insert(std::make_pair(eReplicaComponentType::PROPERTY, new PropertyComponent(this)));
 	}
 
 	const int rocketId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::ROCKET_LAUNCH);
 	if ((rocketId > 0)) {
-		AddComponent<RocketLaunchpadControlComponent>(rocketId);
+		m_Components.insert(std::make_pair(eReplicaComponentType::ROCKET_LAUNCH, new RocketLaunchpadControlComponent(this, rocketId)));
 	}
 
 	const int32_t railComponentID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RAIL_ACTIVATOR);
 	if (railComponentID > 0) {
-		AddComponent<RailActivatorComponent>(railComponentID);
+		m_Components.insert(std::make_pair(eReplicaComponentType::RAIL_ACTIVATOR, new RailActivatorComponent(this, railComponentID)));
 	}
 
 	int movementAIID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MOVEMENT_AI);
@@ -663,7 +679,7 @@ void Entity::Initialize() {
 				}
 			}
 
-			AddComponent<MovementAIComponent>(moveInfo);
+			m_Components.insert(std::make_pair(eReplicaComponentType::MOVEMENT_AI, new MovementAIComponent(this, moveInfo)));
 		}
 	} else if (petComponentId > 0 || combatAiId > 0 && GetComponent<BaseCombatAIComponent>()->GetTetherSpeed() > 0) {
 		MovementAIInfo moveInfo = MovementAIInfo();
@@ -674,18 +690,19 @@ void Entity::Initialize() {
 		moveInfo.wanderDelayMax = 5;
 		moveInfo.wanderDelayMin = 2;
 
-		AddComponent<MovementAIComponent>(moveInfo);
+		m_Components.insert(std::make_pair(eReplicaComponentType::MOVEMENT_AI, new MovementAIComponent(this, moveInfo)));
 	}
 
 	std::string pathName = GetVarAsString(u"attached_path");
 	const Path* path = Game::zoneManager->GetZone()->GetPath(pathName);
 
 	//Check to see if we have an attached path and add the appropiate component to handle it:
-	if (path) {
+	if (path){
 		// if we have a moving platform path, then we need a moving platform component
 		if (path->pathType == PathType::MovingPlatform) {
-			AddComponent<MovingPlatformComponent>(pathName);
-			// else if we are a movement path
+			MovingPlatformComponent* plat = new MovingPlatformComponent(this, pathName);
+			m_Components.insert(std::make_pair(eReplicaComponentType::MOVING_PLATFORM, plat));
+		// else if we are a movement path
 		} /*else if (path->pathType == PathType::Movement) {
 			auto movementAIcomp = GetComponent<MovementAIComponent>();
 			if (movementAIcomp){
@@ -698,7 +715,8 @@ void Entity::Initialize() {
 		// else we still need to setup moving platform if it has a moving platform comp but no path
 		int32_t movingPlatformComponentId = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::MOVING_PLATFORM, -1);
 		if (movingPlatformComponentId >= 0) {
-			AddComponent<MovingPlatformComponent>(pathName);
+			MovingPlatformComponent* plat = new MovingPlatformComponent(this, pathName);
+			m_Components.insert(std::make_pair(eReplicaComponentType::MOVING_PLATFORM, plat));
 		}
 	}
 
@@ -708,7 +726,8 @@ void Entity::Initialize() {
 		std::vector<CDProximityMonitorComponent> proxCompData = proxCompTable->Query([=](CDProximityMonitorComponent entry) { return (entry.id == proximityMonitorID); });
 		if (proxCompData.size() > 0) {
 			std::vector<std::string> proximityStr = GeneralUtils::SplitString(proxCompData[0].Proximities, ',');
-			AddComponent<ProximityMonitorComponent>(std::stoi(proximityStr[0]), std::stoi(proximityStr[1]));
+			ProximityMonitorComponent* comp = new ProximityMonitorComponent(this, std::stoi(proximityStr[0]), std::stoi(proximityStr[1]));
+			m_Components.insert(std::make_pair(eReplicaComponentType::PROXIMITY_MONITOR, comp));
 		}
 	}
 
@@ -799,6 +818,14 @@ bool Entity::HasComponent(const eReplicaComponentType componentId) const {
 	return m_Components.find(componentId) != m_Components.end();
 }
 
+void Entity::AddComponent(const eReplicaComponentType componentId, Component* component) {
+	if (HasComponent(componentId)) {
+		return;
+	}
+
+	m_Components.insert_or_assign(componentId, component);
+}
+
 std::vector<ScriptComponent*> Entity::GetScriptComponents() {
 	std::vector<ScriptComponent*> comps;
 	for (std::pair<eReplicaComponentType, void*> p : m_Components) {
@@ -827,13 +854,20 @@ void Entity::Unsubscribe(LWOOBJID scriptObjId, const std::string& notificationNa
 }
 
 void Entity::SetProximityRadius(float proxRadius, std::string name) {
-	auto* proxMon = GetComponent<ProximityMonitorComponent>();
-	if (!proxMon) proxMon = AddComponent<ProximityMonitorComponent>();
+	ProximityMonitorComponent* proxMon = GetComponent<ProximityMonitorComponent>();
+	if (!proxMon) {
+		proxMon = new ProximityMonitorComponent(this);
+		m_Components.insert_or_assign(eReplicaComponentType::PROXIMITY_MONITOR, proxMon);
+	}
 	proxMon->SetProximityRadius(proxRadius, name);
 }
 
 void Entity::SetProximityRadius(dpEntity* entity, std::string name) {
-	ProximityMonitorComponent* proxMon = AddComponent<ProximityMonitorComponent>();
+	ProximityMonitorComponent* proxMon = GetComponent<ProximityMonitorComponent>();
+	if (!proxMon) {
+		proxMon = new ProximityMonitorComponent(this);
+		m_Components.insert_or_assign(eReplicaComponentType::PROXIMITY_MONITOR, proxMon);
+	}
 	proxMon->SetProximityRadius(entity, name);
 }
 
@@ -883,20 +917,10 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 			outBitStream->Write1(); //ldf data
 
 			RakNet::BitStream settingStream;
-			int32_t numberOfValidKeys = m_Settings.size();
-
-			// Writing keys value pairs the client does not expect to receive or interpret will result in undefined behavior,
-			// so we need to filter out any keys that are not valid and fix the number of valid keys to be correct.
-			// TODO should make this more efficient so that we dont waste loops evaluating the same condition twice
-			for (LDFBaseData* data : m_Settings) {
-				if (!data || data->GetValueType() == eLDFType::LDF_TYPE_UNKNOWN) {
-					numberOfValidKeys--;
-				}
-			}
-			settingStream.Write<uint32_t>(numberOfValidKeys);
+			settingStream.Write<uint32_t>(m_Settings.size());
 
 			for (LDFBaseData* data : m_Settings) {
-				if (data && data->GetValueType() != eLDFType::LDF_TYPE_UNKNOWN) {
+				if (data) {
 					data->WriteToPacket(&settingStream);
 				}
 			}
@@ -915,6 +939,7 @@ void Entity::WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacke
 
 			RakNet::BitStream settingStream;
 			settingStream.Write<uint32_t>(ldfData.size());
+
 			for (LDFBaseData* data : ldfData) {
 				if (data) {
 					data->WriteToPacket(&settingStream);
@@ -990,77 +1015,73 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 	 */
 
 	bool destroyableSerialized = false;
-	bool bIsInitialUpdate = packetType == eReplicaPacketType::CONSTRUCTION;
+	bool bIsInitialUpdate = false;
+	if (packetType == eReplicaPacketType::CONSTRUCTION) bIsInitialUpdate = true;
+	unsigned int flags = 0;
 
 	PossessableComponent* possessableComponent;
 	if (TryGetComponent(eReplicaComponentType::POSSESSABLE, possessableComponent)) {
-		possessableComponent->Serialize(outBitStream, bIsInitialUpdate);
+		possessableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ModuleAssemblyComponent* moduleAssemblyComponent;
 	if (TryGetComponent(eReplicaComponentType::MODULE_ASSEMBLY, moduleAssemblyComponent)) {
-		moduleAssemblyComponent->Serialize(outBitStream, bIsInitialUpdate);
+		moduleAssemblyComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ControllablePhysicsComponent* controllablePhysicsComponent;
 	if (TryGetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS, controllablePhysicsComponent)) {
-		controllablePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate);
+		controllablePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SimplePhysicsComponent* simplePhysicsComponent;
 	if (TryGetComponent(eReplicaComponentType::SIMPLE_PHYSICS, simplePhysicsComponent)) {
-		simplePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate);
+		simplePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RigidbodyPhantomPhysicsComponent* rigidbodyPhantomPhysics;
 	if (TryGetComponent(eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS, rigidbodyPhantomPhysics)) {
-		rigidbodyPhantomPhysics->Serialize(outBitStream, bIsInitialUpdate);
+		rigidbodyPhantomPhysics->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	VehiclePhysicsComponent* vehiclePhysicsComponent;
 	if (TryGetComponent(eReplicaComponentType::VEHICLE_PHYSICS, vehiclePhysicsComponent)) {
-		vehiclePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate);
+		vehiclePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	PhantomPhysicsComponent* phantomPhysicsComponent;
 	if (TryGetComponent(eReplicaComponentType::PHANTOM_PHYSICS, phantomPhysicsComponent)) {
-		phantomPhysicsComponent->Serialize(outBitStream, bIsInitialUpdate);
+		phantomPhysicsComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SoundTriggerComponent* soundTriggerComponent;
 	if (TryGetComponent(eReplicaComponentType::SOUND_TRIGGER, soundTriggerComponent)) {
-		soundTriggerComponent->Serialize(outBitStream, bIsInitialUpdate);
-	}
-
-	RacingSoundTriggerComponent* racingSoundTriggerComponent;
-	if (TryGetComponent(eReplicaComponentType::RACING_SOUND_TRIGGER, racingSoundTriggerComponent)) {
-		racingSoundTriggerComponent->Serialize(outBitStream, bIsInitialUpdate);
+		soundTriggerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	BuffComponent* buffComponent;
 	if (TryGetComponent(eReplicaComponentType::BUFF, buffComponent)) {
-		buffComponent->Serialize(outBitStream, bIsInitialUpdate);
+		buffComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 
 		DestroyableComponent* destroyableComponent;
 		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent)) {
-			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate);
+			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		}
 		destroyableSerialized = true;
 	}
 
-	CollectibleComponent* collectibleComponent;
-	if (TryGetComponent(eReplicaComponentType::COLLECTIBLE, collectibleComponent)) {
+	if (HasComponent(eReplicaComponentType::COLLECTIBLE)) {
 		DestroyableComponent* destroyableComponent;
 		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
-			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate);
+			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		}
 		destroyableSerialized = true;
-		collectibleComponent->Serialize(outBitStream, bIsInitialUpdate);
+		outBitStream->Write(m_CollectibleID); // Collectable component
 	}
 
 	PetComponent* petComponent;
 	if (TryGetComponent(eReplicaComponentType::PET, petComponent)) {
-		petComponent->Serialize(outBitStream, bIsInitialUpdate);
+		petComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	CharacterComponent* characterComponent;
@@ -1068,7 +1089,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 
 		PossessorComponent* possessorComponent;
 		if (TryGetComponent(eReplicaComponentType::POSSESSOR, possessorComponent)) {
-			possessorComponent->Serialize(outBitStream, bIsInitialUpdate);
+			possessorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		} else {
 			// Should never happen, but just to be safe
 			outBitStream->Write0();
@@ -1076,7 +1097,7 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 
 		LevelProgressionComponent* levelProgressionComponent;
 		if (TryGetComponent(eReplicaComponentType::LEVEL_PROGRESSION, levelProgressionComponent)) {
-			levelProgressionComponent->Serialize(outBitStream, bIsInitialUpdate);
+			levelProgressionComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		} else {
 			// Should never happen, but just to be safe
 			outBitStream->Write0();
@@ -1084,116 +1105,109 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 
 		PlayerForcedMovementComponent* playerForcedMovementComponent;
 		if (TryGetComponent(eReplicaComponentType::PLAYER_FORCED_MOVEMENT, playerForcedMovementComponent)) {
-			playerForcedMovementComponent->Serialize(outBitStream, bIsInitialUpdate);
+			playerForcedMovementComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		} else {
 			// Should never happen, but just to be safe
 			outBitStream->Write0();
 		}
 
-		characterComponent->Serialize(outBitStream, bIsInitialUpdate);
+		characterComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	ItemComponent* itemComponent;
-	if (TryGetComponent(eReplicaComponentType::ITEM, itemComponent)) {
-		itemComponent->Serialize(outBitStream, bIsInitialUpdate);
+	if (HasComponent(eReplicaComponentType::ITEM)) {
+		outBitStream->Write0();
 	}
 
 	InventoryComponent* inventoryComponent;
 	if (TryGetComponent(eReplicaComponentType::INVENTORY, inventoryComponent)) {
-		inventoryComponent->Serialize(outBitStream, bIsInitialUpdate);
+		inventoryComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ScriptComponent* scriptComponent;
 	if (TryGetComponent(eReplicaComponentType::SCRIPT, scriptComponent)) {
-		scriptComponent->Serialize(outBitStream, bIsInitialUpdate);
+		scriptComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SkillComponent* skillComponent;
 	if (TryGetComponent(eReplicaComponentType::SKILL, skillComponent)) {
-		skillComponent->Serialize(outBitStream, bIsInitialUpdate);
+		skillComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	BaseCombatAIComponent* baseCombatAiComponent;
 	if (TryGetComponent(eReplicaComponentType::BASE_COMBAT_AI, baseCombatAiComponent)) {
-		baseCombatAiComponent->Serialize(outBitStream, bIsInitialUpdate);
+		baseCombatAiComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RebuildComponent* rebuildComponent;
 	if (TryGetComponent(eReplicaComponentType::QUICK_BUILD, rebuildComponent)) {
 		DestroyableComponent* destroyableComponent;
 		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
-			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate);
+			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 		}
 		destroyableSerialized = true;
-		rebuildComponent->Serialize(outBitStream, bIsInitialUpdate);
+		rebuildComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	MovingPlatformComponent* movingPlatformComponent;
 	if (TryGetComponent(eReplicaComponentType::MOVING_PLATFORM, movingPlatformComponent)) {
-		movingPlatformComponent->Serialize(outBitStream, bIsInitialUpdate);
+		movingPlatformComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	SwitchComponent* switchComponent;
 	if (TryGetComponent(eReplicaComponentType::SWITCH, switchComponent)) {
-		switchComponent->Serialize(outBitStream, bIsInitialUpdate);
+		switchComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	VendorComponent* vendorComponent;
 	if (TryGetComponent(eReplicaComponentType::VENDOR, vendorComponent)) {
-		vendorComponent->Serialize(outBitStream, bIsInitialUpdate);
-	}
-
-	DonationVendorComponent* donationVendorComponent;
-	if (TryGetComponent(eReplicaComponentType::DONATION_VENDOR, donationVendorComponent)) {
-		donationVendorComponent->Serialize(outBitStream, bIsInitialUpdate);
+		vendorComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	BouncerComponent* bouncerComponent;
 	if (TryGetComponent(eReplicaComponentType::BOUNCER, bouncerComponent)) {
-		bouncerComponent->Serialize(outBitStream, bIsInitialUpdate);
+		bouncerComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ScriptedActivityComponent* scriptedActivityComponent;
 	if (TryGetComponent(eReplicaComponentType::SCRIPTED_ACTIVITY, scriptedActivityComponent)) {
-		scriptedActivityComponent->Serialize(outBitStream, bIsInitialUpdate);
+		scriptedActivityComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ShootingGalleryComponent* shootingGalleryComponent;
 	if (TryGetComponent(eReplicaComponentType::SHOOTING_GALLERY, shootingGalleryComponent)) {
-		shootingGalleryComponent->Serialize(outBitStream, bIsInitialUpdate);
+		shootingGalleryComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RacingControlComponent* racingControlComponent;
 	if (TryGetComponent(eReplicaComponentType::RACING_CONTROL, racingControlComponent)) {
-		racingControlComponent->Serialize(outBitStream, bIsInitialUpdate);
+		racingControlComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	LUPExhibitComponent* lupExhibitComponent;
 	if (TryGetComponent(eReplicaComponentType::LUP_EXHIBIT, lupExhibitComponent)) {
-		lupExhibitComponent->Serialize(outBitStream, bIsInitialUpdate);
+		lupExhibitComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	ModelComponent* modelComponent;
 	if (TryGetComponent(eReplicaComponentType::MODEL, modelComponent)) {
-		modelComponent->Serialize(outBitStream, bIsInitialUpdate);
+		modelComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
 	RenderComponent* renderComponent;
 	if (TryGetComponent(eReplicaComponentType::RENDER, renderComponent)) {
-		renderComponent->Serialize(outBitStream, bIsInitialUpdate);
+		renderComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 	}
 
-	if (modelComponent || !destroyableSerialized) {
+	if (modelComponent) {
 		DestroyableComponent* destroyableComponent;
 		if (TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent) && !destroyableSerialized) {
-			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate);
+			destroyableComponent->Serialize(outBitStream, bIsInitialUpdate, flags);
 			destroyableSerialized = true;
 		}
 	}
 
-	ZoneControlComponent* zoneControlComponent;
-	if (TryGetComponent(eReplicaComponentType::ZONE_CONTROL, zoneControlComponent)) {
-		zoneControlComponent->Serialize(outBitStream, bIsInitialUpdate);
+	if (HasComponent(eReplicaComponentType::ZONE_CONTROL)) {
+		outBitStream->Write<uint32_t>(0x40000000);
 	}
 
 	// BBB Component, unused currently
@@ -1202,6 +1216,10 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 	outBitStream->Write0();
 }
 
+void Entity::ResetFlags() {
+	// Unused
+}
+
 void Entity::UpdateXMLDoc(tinyxml2::XMLDocument* doc) {
 	//This function should only ever be called from within Character, meaning doc should always exist when this is called.
 	//Naturally, we don't include any non-player components in this update function.
@@ -1523,17 +1541,7 @@ void Entity::Kill(Entity* murderer) {
 	}
 
 	if (!IsPlayer()) {
-		auto* destroyableComponent = GetComponent<DestroyableComponent>();
-		bool waitForDeathAnimation = false;
-
-		if (destroyableComponent) {
-			waitForDeathAnimation = destroyableComponent->GetDeathBehavior() == 0;
-		}
-
-		// Live waited a hard coded 12 seconds for death animations of type 0 before networking destruction!
-		constexpr float DelayDeathTime = 12.0f;
-		if (waitForDeathAnimation) AddCallbackTimer(DelayDeathTime, [this]() { Game::entityManager->DestroyEntity(this); });
-		else Game::entityManager->DestroyEntity(this);
+		Game::entityManager->DestroyEntity(this);
 	}
 
 	const auto& grpNameQBShowBricks = GetVar<std::string>(u"grpNameQBShowBricks");
@@ -1623,9 +1631,9 @@ void Entity::PickupItem(const LWOOBJID& objectID) {
 				std::vector<CDObjectSkills> skills = skillsTable->Query([=](CDObjectSkills entry) {return (entry.objectTemplate == p.second.lot); });
 				for (CDObjectSkills skill : skills) {
 					CDSkillBehaviorTable* skillBehTable = CDClientManager::Instance().GetTable<CDSkillBehaviorTable>();
-					CDSkillBehavior behaviorData = skillBehTable->GetSkillByID(skill.skillID);
-
-					SkillComponent::HandleUnmanaged(behaviorData.behaviorID, GetObjectID());
+					auto behaviorData = skillBehTable->GetSkillByID(skill.skillID);
+					if (!behaviorData) continue;
+					SkillComponent::HandleUnmanaged(behaviorData->behaviorID, GetObjectID());
 
 					auto* missionComponent = GetComponent<MissionComponent>();
 
@@ -2049,8 +2057,3 @@ void Entity::RetroactiveVaultSize() {
 
 	modelVault->SetSize(itemsVault->GetSize());
 }
-
-uint8_t Entity::GetCollectibleID() const {
-	auto* collectible = GetComponent<CollectibleComponent>();
-	return collectible ? collectible->GetCollectibleId() : 0;
-}

dGame/Entity.h

@@ -66,7 +66,7 @@ public:
 
 	eGameMasterLevel GetGMLevel() const { return m_GMLevel; }
 
-	uint8_t GetCollectibleID() const;
+	uint8_t GetCollectibleID() const { return uint8_t(m_CollectibleID); }
 
 	Entity* GetParentEntity() const { return m_ParentEntity; }
 
@@ -85,7 +85,6 @@ public:
 	bool GetPlayerReadyForUpdates() const { return m_PlayerIsReadyForUpdates; }
 
 	bool GetIsGhostingCandidate() const;
-	void SetIsGhostingCandidate(bool value) { m_IsGhostingCandidate = value; };
 
 	int8_t GetObservers() const;
 
@@ -174,6 +173,7 @@ public:
 
 	void WriteBaseReplicaData(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
 	void WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType packetType);
+	void ResetFlags();
 	void UpdateXMLDoc(tinyxml2::XMLDocument* doc);
 	void Update(float deltaTime);
 
@@ -274,9 +274,6 @@ public:
 	template<typename T>
 	T GetVarAs(const std::u16string& name) const;
 
-	template<typename ComponentType, typename... VaArgs>
-	ComponentType* AddComponent(VaArgs... args);
-
 	/**
 	 * Get the LDF data.
 	 */
@@ -504,36 +501,3 @@ T Entity::GetNetworkVar(const std::u16string& name) {
 
 	return LDFData<T>::Default;
 }
-
-/**
- * @brief Adds a component of type ComponentType to this entity and forwards the arguments to the constructor.
- *
- * @tparam ComponentType The component class type to add. Must derive from Component.
- * @tparam VaArgs The argument types to forward to the constructor.
- * @param args The arguments to forward to the constructor. The first argument passed to the ComponentType constructor will be this entity.
- * @return ComponentType* The added component. Will never return null.
- */
-template<typename ComponentType, typename... VaArgs>
-inline ComponentType* Entity::AddComponent(VaArgs... args) {
-	static_assert(std::is_base_of_v<Component, ComponentType>, "ComponentType must be a Component");
-
-	// Get the component if it already exists, or default construct a nullptr
-	auto*& componentToReturn = m_Components[ComponentType::ComponentType];
-
-	// If it doesn't exist, create it and forward the arguments to the constructor
-	if (!componentToReturn) {
-		componentToReturn = new ComponentType(this, std::forward<VaArgs>(args)...);
-	} else {
-		// In this case the block is already allocated and ready for use
-		// so we use a placement new to construct the component again as was requested by the caller.
-		// Placement new means we already have memory allocated for the object, so this just calls its constructor again.
-		// This is useful for when we want to create a new object in the same memory location as an old one.
-		componentToReturn->~Component();
-		new(componentToReturn) ComponentType(this, std::forward<VaArgs>(args)...);
-	}
-
-	// Finally return the created or already existing component.
-	// Because of the assert above, this should always be a ComponentType* but I need a way to guarantee the map cannot be modifed outside this function
-	// To allow a static cast here instead of a dynamic one.
-	return dynamic_cast<ComponentType*>(componentToReturn);
-}

dGame/EntityManager.cpp

@@ -16,7 +16,7 @@
 #include "dZoneManager.h"
 #include "MissionComponent.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "MessageIdentifiers.h"
 #include "dConfig.h"
 #include "eTriggerEventType.h"
@@ -176,9 +176,8 @@ void EntityManager::DestroyEntity(Entity* entity) {
 }
 
 void EntityManager::SerializeEntities() {
-	for (int32_t i = 0; i < m_EntitiesToSerialize.size(); i++) {
-		const LWOOBJID toSerialize = m_EntitiesToSerialize.at(i);
-		auto* entity = GetEntity(toSerialize);
+	for (auto entry = m_EntitiesToSerialize.begin(); entry != m_EntitiesToSerialize.end(); entry++) {
+		auto* entity = GetEntity(*entry);
 
 		if (!entity) continue;
 
@@ -193,7 +192,7 @@ void EntityManager::SerializeEntities() {
 
 		if (entity->GetIsGhostingCandidate()) {
 			for (auto* player : Player::GetAllPlayers()) {
-				if (player->IsObserved(toSerialize)) {
+				if (player->IsObserved(*entry)) {
 					Game::server->Send(&stream, player->GetSystemAddress(), false);
 				}
 			}
@@ -205,12 +204,11 @@ void EntityManager::SerializeEntities() {
 }
 
 void EntityManager::KillEntities() {
-	for (int32_t i = 0; i < m_EntitiesToKill.size(); i++) {
-		const LWOOBJID toKill = m_EntitiesToKill.at(i);
-		auto* entity = GetEntity(toKill);
+	for (auto entry = m_EntitiesToKill.begin(); entry != m_EntitiesToKill.end(); entry++) {
+		auto* entity = GetEntity(*entry);
 
 		if (!entity) {
-			LOG("Attempting to kill null entity %llu", toKill);
+			Game::logger->Log("EntityManager", "Attempting to kill null entity %llu", *entry);
 			continue;
 		}
 
@@ -224,9 +222,8 @@ void EntityManager::KillEntities() {
 }
 
 void EntityManager::DeleteEntities() {
-	for (int32_t i = 0; i < m_EntitiesToDelete.size(); i++) {
-		const LWOOBJID toDelete = m_EntitiesToDelete.at(i);
-		auto entityToDelete = GetEntity(toDelete);
+	for (auto entry = m_EntitiesToDelete.begin(); entry != m_EntitiesToDelete.end(); entry++) {
+		auto entityToDelete = GetEntity(*entry);
 		if (entityToDelete) {
 			// Get all this info first before we delete the player.
 			auto networkIdToErase = entityToDelete->GetNetworkId();
@@ -240,9 +237,9 @@ void EntityManager::DeleteEntities() {
 
 			if (ghostingToDelete != m_EntitiesToGhost.end()) m_EntitiesToGhost.erase(ghostingToDelete);
 		} else {
-			LOG("Attempted to delete non-existent entity %llu", toDelete);
+			Game::logger->Log("EntityManager", "Attempted to delete non-existent entity %llu", *entry);
 		}
-		m_Entities.erase(toDelete);
+		m_Entities.erase(*entry);
 	}
 	m_EntitiesToDelete.clear();
 }
@@ -301,16 +298,6 @@ std::vector<Entity*> EntityManager::GetEntitiesByLOT(const LOT& lot) const {
 	return entities;
 }
 
-std::vector<Entity*> EntityManager::GetEntitiesByProximity(NiPoint3 reference, float radius) const{
-	std::vector<Entity*> entities = {};
-	if (radius > 1000.0f) return entities;
-	for (const auto& entity : m_Entities) {
-		if (NiPoint3::Distance(reference, entity.second->GetPosition()) <= radius) entities.push_back(entity.second);
-	}
-	return entities;
-}
-
-
 Entity* EntityManager::GetZoneControlEntity() const {
 	return m_ZoneControlEntity;
 }
@@ -333,7 +320,7 @@ const std::unordered_map<std::string, LWOOBJID>& EntityManager::GetSpawnPointEnt
 
 void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr, const bool skipChecks) {
 	if (!entity) {
-		LOG("Attempted to construct null entity");
+		Game::logger->Log("EntityManager", "Attempted to construct null entity");
 		return;
 	}
 
@@ -596,6 +583,12 @@ bool EntityManager::GetGhostingEnabled() const {
 	return m_GhostingEnabled;
 }
 
+void EntityManager::ResetFlags() {
+	for (const auto& e : m_Entities) {
+		e.second->ResetFlags();
+	}
+}
+
 void EntityManager::ScheduleForKill(Entity* entity) {
 	// Deactivate switches if they die
 	if (!entity)

dGame/EntityManager.h

@@ -28,7 +28,6 @@ public:
 	std::vector<Entity*> GetEntitiesInGroup(const std::string& group);
 	std::vector<Entity*> GetEntitiesByComponent(eReplicaComponentType componentType) const;
 	std::vector<Entity*> GetEntitiesByLOT(const LOT& lot) const;
-	std::vector<Entity*> GetEntitiesByProximity(NiPoint3 reference, float radius) const;
 	Entity* GetZoneControlEntity() const;
 
 	// Get spawn point entity by spawn name
@@ -60,6 +59,8 @@ public:
 	Entity* GetGhostCandidate(int32_t id);
 	bool GetGhostingEnabled() const;
 
+	void ResetFlags();
+
 	void ScheduleForKill(Entity* entity);
 
 	void ScheduleForDeletion(LWOOBJID entity);

dGame/LeaderboardManager.cpp

@@ -8,7 +8,7 @@
 #include "Character.h"
 #include "Game.h"
 #include "GameMessages.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "dConfig.h"
 #include "CDClientManager.h"
 #include "GeneralUtils.h"
@@ -131,8 +131,8 @@ void Leaderboard::QueryToLdf(std::unique_ptr<sql::ResultSet>& rows) {
 			// Time:1
 			break;
 		case Type::Donations:
-			entry.push_back(new LDFData<int32_t>(u"Score", rows->getInt("primaryScore")));
-			// Score:1
+			entry.push_back(new LDFData<int32_t>(u"Points", rows->getInt("primaryScore")));
+			// Score:1				
 			break;
 		case Type::None:
 			// This type is included here simply to resolve a compiler warning on mac about unused enum types
@@ -170,32 +170,32 @@ void Leaderboard::SetupLeaderboard(bool weekly, uint32_t resultStart, uint32_t r
 	resultEnd++;
 	// We need everything except 1 column so i'm selecting * from leaderboard
 	const std::string queryBase =
-		R"QUERY(
-		WITH leaderboardsRanked AS (
-			SELECT leaderboard.*, charinfo.name,
-				RANK() OVER
-				(
+		R"QUERY( 
+		WITH leaderboardsRanked AS ( 
+			SELECT leaderboard.*, charinfo.name, 
+				RANK() OVER 
+				( 
 				ORDER BY %s, UNIX_TIMESTAMP(last_played) ASC, id DESC
-			) AS ranking
-				FROM leaderboard JOIN charinfo on charinfo.id = leaderboard.character_id
-				WHERE game_id = ? %s
-		),
-		myStanding AS (
-			SELECT
-				ranking as myRank
-			FROM leaderboardsRanked
-			WHERE id = ?
-		),
-		lowestRanking AS (
-			SELECT MAX(ranking) AS lowestRank
-				FROM leaderboardsRanked
-		)
-		SELECT leaderboardsRanked.*, character_id, UNIX_TIMESTAMP(last_played) as lastPlayed, leaderboardsRanked.name, leaderboardsRanked.ranking FROM leaderboardsRanked, myStanding, lowestRanking
-		WHERE leaderboardsRanked.ranking
-		BETWEEN
-		LEAST(GREATEST(CAST(myRank AS SIGNED) - 5, %i), lowestRanking.lowestRank - 9)
-		AND
-		LEAST(GREATEST(myRank + 5, %i), lowestRanking.lowestRank)
+			) AS ranking 
+				FROM leaderboard JOIN charinfo on charinfo.id = leaderboard.character_id 
+				WHERE game_id = ? %s 
+		), 
+		myStanding AS ( 
+			SELECT 
+				ranking as myRank 
+			FROM leaderboardsRanked 
+			WHERE id = ? 
+		), 
+		lowestRanking AS ( 
+			SELECT MAX(ranking) AS lowestRank 
+				FROM leaderboardsRanked 
+		) 
+		SELECT leaderboardsRanked.*, character_id, UNIX_TIMESTAMP(last_played) as lastPlayed, leaderboardsRanked.name, leaderboardsRanked.ranking FROM leaderboardsRanked, myStanding, lowestRanking 
+		WHERE leaderboardsRanked.ranking 
+		BETWEEN 
+		LEAST(GREATEST(CAST(myRank AS SIGNED) - 5, %i), lowestRanking.lowestRank - 9) 
+		AND 
+		LEAST(GREATEST(myRank + 5, %i), lowestRanking.lowestRank) 
 		ORDER BY ranking ASC;
 	)QUERY";
 
@@ -236,7 +236,7 @@ void Leaderboard::SetupLeaderboard(bool weekly, uint32_t resultStart, uint32_t r
 		baseLookup += std::to_string(static_cast<uint32_t>(this->relatedPlayer));
 	}
 	baseLookup += " LIMIT 1";
-	LOG_DEBUG("query is %s", baseLookup.c_str());
+	Game::logger->LogDebug("LeaderboardManager", "query is %s", baseLookup.c_str());
 	std::unique_ptr<sql::PreparedStatement> baseQuery(Database::CreatePreppedStmt(baseLookup));
 	baseQuery->setInt(1, this->gameID);
 	std::unique_ptr<sql::ResultSet> baseResult(baseQuery->executeQuery());
@@ -251,7 +251,7 @@ void Leaderboard::SetupLeaderboard(bool weekly, uint32_t resultStart, uint32_t r
 	int32_t res = snprintf(lookupBuffer.get(), STRING_LENGTH, queryBase.c_str(), orderBase.data(), filter.c_str(), resultStart, resultEnd);
 	DluAssert(res != -1);
 	std::unique_ptr<sql::PreparedStatement> query(Database::CreatePreppedStmt(lookupBuffer.get()));
-	LOG_DEBUG("Query is %s vars are %i %i %i", lookupBuffer.get(), this->gameID, this->relatedPlayer, relatedPlayerLeaderboardId);
+	Game::logger->LogDebug("LeaderboardManager", "Query is %s vars are %i %i %i", lookupBuffer.get(), this->gameID, this->relatedPlayer, relatedPlayerLeaderboardId);
 	query->setInt(1, this->gameID);
 	if (this->infoType == InfoType::Friends) {
 		query->setInt(2, this->relatedPlayer);
@@ -277,15 +277,15 @@ std::string FormatInsert(const Leaderboard::Type& type, const Score& score, cons
 	if (useUpdate) {
 		insertStatement =
 			R"QUERY(
-			UPDATE leaderboard
-			SET primaryScore = %f, secondaryScore = %f, tertiaryScore = %f,
+			UPDATE leaderboard 
+			SET primaryScore = %f, secondaryScore = %f, tertiaryScore = %f, 
 			timesPlayed = timesPlayed + 1 WHERE character_id = ? AND game_id = ?;
 			)QUERY";
 	} else {
 		insertStatement =
 			R"QUERY(
-			INSERT leaderboard SET
-			primaryScore = %f, secondaryScore = %f, tertiaryScore = %f,
+			INSERT leaderboard SET 
+			primaryScore = %f, secondaryScore = %f, tertiaryScore = %f, 
 			character_id = ?, game_id = ?;
 			)QUERY";
 	}
@@ -300,8 +300,9 @@ std::string FormatInsert(const Leaderboard::Type& type, const Score& score, cons
 
 void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activityId, const float primaryScore, const float secondaryScore, const float tertiaryScore) {
 	const Leaderboard::Type leaderboardType = GetLeaderboardType(activityId);
+	auto* lookup = "SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;";
 
-	std::unique_ptr<sql::PreparedStatement> query(Database::CreatePreppedStmt("SELECT * FROM leaderboard WHERE character_id = ? AND game_id = ?;"));
+	std::unique_ptr<sql::PreparedStatement> query(Database::CreatePreppedStmt(lookup));
 	query->setInt(1, playerID);
 	query->setInt(2, activityId);
 	std::unique_ptr<sql::ResultSet> myScoreResult(query->executeQuery());
@@ -336,7 +337,6 @@ void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activi
 		case Leaderboard::Type::UnusedLeaderboard4:
 		case Leaderboard::Type::Donations: {
 			oldScore.SetPrimaryScore(myScoreResult->getInt("primaryScore"));
-			newScore.SetPrimaryScore(oldScore.GetPrimaryScore() + newScore.GetPrimaryScore());
 			break;
 		}
 		case Leaderboard::Type::Racing: {
@@ -358,7 +358,7 @@ void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activi
 		}
 		case Leaderboard::Type::None:
 		default:
-			LOG("Unknown leaderboard type %i for game %i. Cannot save score!", leaderboardType, activityId);
+			Game::logger->Log("LeaderboardManager", "Unknown leaderboard type %i for game %i. Cannot save score!", leaderboardType, activityId);
 			return;
 		}
 		bool newHighScore = lowerScoreBetter ? newScore < oldScore : newScore > oldScore;
@@ -377,12 +377,12 @@ void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activi
 	} else {
 		saveQuery = FormatInsert(leaderboardType, newScore, false);
 	}
-	LOG("save query %s %i %i", saveQuery.c_str(), playerID, activityId);
+	Game::logger->Log("LeaderboardManager", "save query %s %i %i", saveQuery.c_str(), playerID, activityId);
 	std::unique_ptr<sql::PreparedStatement> saveStatement(Database::CreatePreppedStmt(saveQuery));
 	saveStatement->setInt(1, playerID);
 	saveStatement->setInt(2, activityId);
 	saveStatement->execute();
-
+	
 	// track wins separately
 	if (leaderboardType == Leaderboard::Type::Racing && tertiaryScore != 0.0f) {
 		std::unique_ptr<sql::PreparedStatement> winUpdate(Database::CreatePreppedStmt("UPDATE leaderboard SET numWins = numWins + 1 WHERE character_id = ? AND game_id = ?;"));

dGame/Player.cpp

@@ -7,7 +7,7 @@
 #include "MissionComponent.h"
 #include "UserManager.h"
 #include "EntityManager.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "ZoneInstanceManager.h"
 #include "WorldPackets.h"
 #include "dZoneManager.h"
@@ -260,7 +260,7 @@ void Player::SetDroppedCoins(uint64_t value) {
 }
 
 Player::~Player() {
-	LOG("Deleted player");
+	Game::logger->Log("Player", "Deleted player");
 
 	for (int32_t i = 0; i < m_ObservedEntitiesUsed; i++) {
 		const auto id = m_ObservedEntities[i];

dGame/TeamManager.cpp

@@ -1,14 +1,8 @@
 #include "TeamManager.h"
 #include "EntityManager.h"
-#include "Game.h"
-#include "dConfig.h"
 
 TeamManager* TeamManager::m_Address = nullptr; //For singleton method
 
-Team::Team() {
-	lootOption = Game::config->GetValue("default_team_loot") == "0" ? 0 : 1;
-}
-
 TeamManager::TeamManager() {
 }
 

dGame/TeamManager.h

@@ -2,15 +2,16 @@
 
 #include "Entity.h"
 
-struct Team {
-	Team();
+struct Team
+{
 	LWOOBJID teamID = LWOOBJID_EMPTY;
 	char lootOption = 0;
 	std::vector<LWOOBJID> members{};
 	char lootRound = 0;
 };
 
-class TeamManager {
+class TeamManager
+{
 public:
 	static TeamManager* Instance() {
 		if (!m_Address) {

dGame/TradingManager.cpp

@@ -4,7 +4,7 @@
 #include "InventoryComponent.h"
 #include "../dWorldServer/ObjectIDManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "Item.h"
 #include "Character.h"
 #include "CharacterComponent.h"
@@ -67,7 +67,7 @@ void Trade::SetAccepted(LWOOBJID participant, bool value) {
 	if (participant == m_ParticipantA) {
 		m_AcceptedA = !value;
 
-		LOG("Accepted from A (%d), B: (%d)", value, m_AcceptedB);
+		Game::logger->Log("Trade", "Accepted from A (%d), B: (%d)", value, m_AcceptedB);
 
 		auto* entityB = GetParticipantBEntity();
 
@@ -77,7 +77,7 @@ void Trade::SetAccepted(LWOOBJID participant, bool value) {
 	} else if (participant == m_ParticipantB) {
 		m_AcceptedB = !value;
 
-		LOG("Accepted from B (%d), A: (%d)", value, m_AcceptedA);
+		Game::logger->Log("Trade", "Accepted from B (%d), A: (%d)", value, m_AcceptedA);
 
 		auto* entityA = GetParticipantAEntity();
 
@@ -125,7 +125,7 @@ void Trade::Complete() {
 
 	// First verify both players have the coins and items requested for the trade.
 	if (characterA->GetCoins() < m_CoinsA || characterB->GetCoins() < m_CoinsB) {
-		LOG("Possible coin trade cheating attempt! Aborting trade.");
+		Game::logger->Log("TradingManager", "Possible coin trade cheating attempt! Aborting trade.");
 		return;
 	}
 
@@ -133,11 +133,11 @@ void Trade::Complete() {
 		auto* itemToRemove = inventoryA->FindItemById(tradeItem.itemId);
 		if (itemToRemove) {
 			if (itemToRemove->GetCount() < tradeItem.itemCount) {
-				LOG("Possible cheating attempt from %s in trading!!! Aborting trade", characterA->GetName().c_str());
+				Game::logger->Log("TradingManager", "Possible cheating attempt from %s in trading!!! Aborting trade", characterA->GetName().c_str());
 				return;
 			}
 		} else {
-			LOG("Possible cheating attempt from %s in trading due to item not being available!!!", characterA->GetName().c_str());
+			Game::logger->Log("TradingManager", "Possible cheating attempt from %s in trading due to item not being available!!!", characterA->GetName().c_str());
 			return;
 		}
 	}
@@ -146,11 +146,11 @@ void Trade::Complete() {
 		auto* itemToRemove = inventoryB->FindItemById(tradeItem.itemId);
 		if (itemToRemove) {
 			if (itemToRemove->GetCount() < tradeItem.itemCount) {
-				LOG("Possible cheating attempt from %s in trading!!! Aborting trade", characterB->GetName().c_str());
+				Game::logger->Log("TradingManager", "Possible cheating attempt from %s in trading!!! Aborting trade", characterB->GetName().c_str());
 				return;
 			}
 		} else {
-			LOG("Possible cheating attempt from %s in trading due to item not being available!!!  Aborting trade", characterB->GetName().c_str());
+			Game::logger->Log("TradingManager", "Possible cheating attempt from %s in trading due to item not being available!!!  Aborting trade", characterB->GetName().c_str());
 			return;
 		}
 	}
@@ -194,7 +194,7 @@ void Trade::SendUpdateToOther(LWOOBJID participant) {
 	uint64_t coins;
 	std::vector<TradeItem> itemIds;
 
-	LOG("Attempting to send trade update");
+	Game::logger->Log("Trade", "Attempting to send trade update");
 
 	if (participant == m_ParticipantA) {
 		other = GetParticipantBEntity();
@@ -228,7 +228,7 @@ void Trade::SendUpdateToOther(LWOOBJID participant) {
 		items.push_back(tradeItem);
 	}
 
-	LOG("Sending trade update");
+	Game::logger->Log("Trade", "Sending trade update");
 
 	GameMessages::SendServerTradeUpdate(other->GetObjectID(), coins, items, other->GetSystemAddress());
 }
@@ -279,7 +279,7 @@ Trade* TradingManager::NewTrade(LWOOBJID participantA, LWOOBJID participantB) {
 
 	trades[tradeId] = trade;
 
-	LOG("Created new trade between (%llu) <-> (%llu)", participantA, participantB);
+	Game::logger->Log("TradingManager", "Created new trade between (%llu) <-> (%llu)", participantA, participantB);
 
 	return trade;
 }

dGame/User.cpp

@@ -2,7 +2,7 @@
 #include "Database.h"
 #include "Character.h"
 #include "dServer.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "Game.h"
 #include "dZoneManager.h"
 #include "eServerDisconnectIdentifiers.h"
@@ -52,7 +52,7 @@ User::User(const SystemAddress& sysAddr, const std::string& username, const std:
 				LWOOBJID objID = res->getUInt64(1);
 				Character* character = new Character(uint32_t(objID), this);
 				m_Characters.push_back(character);
-				LOG("Loaded %llu as it is the last used char", objID);
+				Game::logger->Log("User", "Loaded %llu as it is the last used char", objID);
 			}
 		}
 
@@ -127,7 +127,7 @@ void User::UserOutOfSync() {
 	m_AmountOfTimesOutOfSync++;
 	if (m_AmountOfTimesOutOfSync > m_MaxDesyncAllowed) {
 		//YEET
-		LOG("User %s was out of sync %i times out of %i, disconnecting for suspected speedhacking.", m_Username.c_str(), m_AmountOfTimesOutOfSync, m_MaxDesyncAllowed);
+		Game::logger->Log("User", "User %s was out of sync %i times out of %i, disconnecting for suspected speedhacking.", m_Username.c_str(), m_AmountOfTimesOutOfSync, m_MaxDesyncAllowed);
 		Game::server->Disconnect(this->m_SystemAddress, eServerDisconnectIdentifiers::PLAY_SCHEDULE_TIME_DONE);
 	}
 }

dGame/UserManager.cpp

@@ -6,14 +6,14 @@
 
 #include "Database.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "User.h"
 #include <WorldPackets.h>
 #include "Character.h"
 #include <BitStream.h>
 #include "PacketUtils.h"
 #include "../dWorldServer/ObjectIDManager.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "GeneralUtils.h"
 #include "ZoneInstanceManager.h"
 #include "dServer.h"
@@ -28,8 +28,6 @@
 #include "eRenameResponse.h"
 #include "eConnectionType.h"
 #include "eChatInternalMessageType.h"
-#include "BitStreamUtils.h"
-#include "CheatDetection.h"
 
 UserManager* UserManager::m_Address = nullptr;
 
@@ -46,7 +44,7 @@ void UserManager::Initialize() {
 
 	AssetMemoryBuffer fnBuff = Game::assetManager->GetFileAsBuffer("names/minifigname_first.txt");
 	if (!fnBuff.m_Success) {
-		LOG("Failed to load %s", (Game::assetManager->GetResPath() / "names/minifigname_first.txt").string().c_str());
+		Game::logger->Log("UserManager", "Failed to load %s", (Game::assetManager->GetResPath() / "names/minifigname_first.txt").string().c_str());
 		throw std::runtime_error("Aborting initialization due to missing minifigure name file.");
 	}
 	std::istream fnStream = std::istream(&fnBuff);
@@ -59,7 +57,7 @@ void UserManager::Initialize() {
 
 	AssetMemoryBuffer mnBuff = Game::assetManager->GetFileAsBuffer("names/minifigname_middle.txt");
 	if (!mnBuff.m_Success) {
-		LOG("Failed to load %s", (Game::assetManager->GetResPath() / "names/minifigname_middle.txt").string().c_str());
+		Game::logger->Log("UserManager", "Failed to load %s", (Game::assetManager->GetResPath() / "names/minifigname_middle.txt").string().c_str());
 		throw std::runtime_error("Aborting initialization due to missing minifigure name file.");
 	}
 	std::istream mnStream = std::istream(&mnBuff);
@@ -72,7 +70,7 @@ void UserManager::Initialize() {
 
 	AssetMemoryBuffer lnBuff = Game::assetManager->GetFileAsBuffer("names/minifigname_last.txt");
 	if (!lnBuff.m_Success) {
-		LOG("Failed to load %s", (Game::assetManager->GetResPath() / "names/minifigname_last.txt").string().c_str());
+		Game::logger->Log("UserManager", "Failed to load %s", (Game::assetManager->GetResPath() / "names/minifigname_last.txt").string().c_str());
 		throw std::runtime_error("Aborting initialization due to missing minifigure name file.");
 	}
 	std::istream lnStream = std::istream(&lnBuff);
@@ -86,7 +84,7 @@ void UserManager::Initialize() {
 	//Load our pre-approved names:
 	AssetMemoryBuffer chatListBuff = Game::assetManager->GetFileAsBuffer("chatplus_en_us.txt");
 	if (!chatListBuff.m_Success) {
-		LOG("Failed to load %s", (Game::assetManager->GetResPath() / "chatplus_en_us.txt").string().c_str());
+		Game::logger->Log("UserManager", "Failed to load %s", (Game::assetManager->GetResPath() / "chatplus_en_us.txt").string().c_str());
 		throw std::runtime_error("Aborting initialization due to missing chat whitelist file.");
 	}
 	std::istream chatListStream = std::istream(&chatListBuff);
@@ -150,7 +148,7 @@ bool UserManager::DeleteUser(const SystemAddress& sysAddr) {
 
 void UserManager::DeletePendingRemovals() {
 	for (auto* user : m_UsersToDelete) {
-		LOG("Deleted user %i", user->GetAccountID());
+		Game::logger->Log("UserManager", "Deleted user %i", user->GetAccountID());
 
 		delete user;
 	}
@@ -205,38 +203,40 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
 	stmt->setUInt(1, u->GetAccountID());
 
 	sql::ResultSet* res = stmt->executeQuery();
-	std::vector<Character*>& chars = u->GetCharacters();
+	if (res->rowsCount() > 0) {
+		std::vector<Character*>& chars = u->GetCharacters();
+
+		for (size_t i = 0; i < chars.size(); ++i) {
+			if (chars[i]->GetEntity() == nullptr) // We don't have entity data to save
+			{
+				delete chars[i];
+
+				continue;
+			}
+
+			auto* skillComponent = chars[i]->GetEntity()->GetComponent<SkillComponent>();
+
+			if (skillComponent != nullptr) {
+				skillComponent->Reset();
+			}
+
+			Game::entityManager->DestroyEntity(chars[i]->GetEntity());
+
+			chars[i]->SaveXMLToDatabase();
+
+			chars[i]->GetEntity()->SetCharacter(nullptr);
 
-	for (size_t i = 0; i < chars.size(); ++i) {
-		if (chars[i]->GetEntity() == nullptr) // We don't have entity data to save
-		{
 			delete chars[i];
-
-			continue;
 		}
 
-		auto* skillComponent = chars[i]->GetEntity()->GetComponent<SkillComponent>();
+		chars.clear();
 
-		if (skillComponent != nullptr) {
-			skillComponent->Reset();
+		while (res->next()) {
+			LWOOBJID objID = res->getUInt64(1);
+			Character* character = new Character(uint32_t(objID), u);
+			character->SetIsNewLogin();
+			chars.push_back(character);
 		}
-
-		Game::entityManager->DestroyEntity(chars[i]->GetEntity());
-
-		chars[i]->SaveXMLToDatabase();
-
-		chars[i]->GetEntity()->SetCharacter(nullptr);
-		
-		delete chars[i];
-	}
-
-	chars.clear();
-
-	while (res->next()) {
-		LWOOBJID objID = res->getUInt64(1);
-		Character* character = new Character(uint32_t(objID), u);
-		character->SetIsNewLogin();
-		chars.push_back(character);
 	}
 
 	delete res;
@@ -251,41 +251,41 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 	std::string name = PacketUtils::ReadString(8, packet, true);
 
-	uint32_t firstNameIndex = PacketUtils::ReadU32(74, packet);
-	uint32_t middleNameIndex = PacketUtils::ReadU32(78, packet);
-	uint32_t lastNameIndex = PacketUtils::ReadU32(82, packet);
+	uint32_t firstNameIndex = PacketUtils::ReadPacketU32(74, packet);
+	uint32_t middleNameIndex = PacketUtils::ReadPacketU32(78, packet);
+	uint32_t lastNameIndex = PacketUtils::ReadPacketU32(82, packet);
 	std::string predefinedName = GetPredefinedName(firstNameIndex, middleNameIndex, lastNameIndex);
 
-	uint32_t shirtColor = PacketUtils::ReadU32(95, packet);
-	uint32_t shirtStyle = PacketUtils::ReadU32(99, packet);
-	uint32_t pantsColor = PacketUtils::ReadU32(103, packet);
-	uint32_t hairStyle = PacketUtils::ReadU32(107, packet);
-	uint32_t hairColor = PacketUtils::ReadU32(111, packet);
-	uint32_t lh = PacketUtils::ReadU32(115, packet);
-	uint32_t rh = PacketUtils::ReadU32(119, packet);
-	uint32_t eyebrows = PacketUtils::ReadU32(123, packet);
-	uint32_t eyes = PacketUtils::ReadU32(127, packet);
-	uint32_t mouth = PacketUtils::ReadU32(131, packet);
+	uint32_t shirtColor = PacketUtils::ReadPacketU32(95, packet);
+	uint32_t shirtStyle = PacketUtils::ReadPacketU32(99, packet);
+	uint32_t pantsColor = PacketUtils::ReadPacketU32(103, packet);
+	uint32_t hairStyle = PacketUtils::ReadPacketU32(107, packet);
+	uint32_t hairColor = PacketUtils::ReadPacketU32(111, packet);
+	uint32_t lh = PacketUtils::ReadPacketU32(115, packet);
+	uint32_t rh = PacketUtils::ReadPacketU32(119, packet);
+	uint32_t eyebrows = PacketUtils::ReadPacketU32(123, packet);
+	uint32_t eyes = PacketUtils::ReadPacketU32(127, packet);
+	uint32_t mouth = PacketUtils::ReadPacketU32(131, packet);
 
 	LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle);
 	LOT pantsLOT = FindCharPantsID(pantsColor);
 
 	if (name != "" && !UserManager::IsNameAvailable(name)) {
-		LOG("AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str());
+		Game::logger->Log("UserManager", "AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str());
 		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE);
 		return;
 	}
 
 	if (!IsNameAvailable(predefinedName)) {
-		LOG("AccountID: %i chose unavailable predefined name: %s", u->GetAccountID(), predefinedName.c_str());
+		Game::logger->Log("UserManager", "AccountID: %i chose unavailable predefined name: %s", u->GetAccountID(), predefinedName.c_str());
 		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::PREDEFINED_NAME_IN_USE);
 		return;
 	}
 
 	if (name == "") {
-		LOG("AccountID: %i is creating a character with predefined name: %s", u->GetAccountID(), predefinedName.c_str());
+		Game::logger->Log("UserManager", "AccountID: %i is creating a character with predefined name: %s", u->GetAccountID(), predefinedName.c_str());
 	} else {
-		LOG("AccountID: %i is creating a character with name: %s (temporary: %s)", u->GetAccountID(), name.c_str(), predefinedName.c_str());
+		Game::logger->Log("UserManager", "AccountID: %i is creating a character with name: %s (temporary: %s)", u->GetAccountID(), name.c_str(), predefinedName.c_str());
 	}
 
 	//Now that the name is ok, we can get an objectID from Master:
@@ -296,7 +296,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 		auto* overlapResult = overlapStmt->executeQuery();
 
 		if (overlapResult->next()) {
-			LOG("Character object id unavailable, check objectidtracker!");
+			Game::logger->Log("UserManager", "Character object id unavailable, check objectidtracker!");
 			WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
 			return;
 		}
@@ -383,26 +383,27 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet) {
 	User* u = GetUser(sysAddr);
 	if (!u) {
-		LOG("Couldn't get user to delete character");
+		Game::logger->Log("UserManager", "Couldn't get user to delete character");
 		return;
 	}
 
-	LWOOBJID objectID = PacketUtils::ReadS64(8, packet);
+	LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet);
 	uint32_t charID = static_cast<uint32_t>(objectID);
 
-	LOG("Received char delete req for ID: %llu (%u)", objectID, charID);
+	Game::logger->Log("UserManager", "Received char delete req for ID: %llu (%u)", objectID, charID);
 
-	bool hasCharacter = CheatDetection::VerifyLwoobjidIsSender(
-		objectID,
-		sysAddr,
-		CheckType::User,
-		"User %i tried to delete a character that it does not own!",
-		u->GetAccountID());
+	//Check if this user has this character:
+	bool hasCharacter = false;
+	std::vector<Character*>& characters = u->GetCharacters();
+	for (size_t i = 0; i < characters.size(); ++i) {
+		if (characters[i]->GetID() == charID) { hasCharacter = true; }
+	}
 
 	if (!hasCharacter) {
+		Game::logger->Log("UserManager", "User %i tried to delete a character that it does not own!", u->GetAccountID());
 		WorldPackets::SendCharacterDeleteResponse(sysAddr, false);
 	} else {
-		LOG("Deleting character %i", charID);
+		Game::logger->Log("UserManager", "Deleting character %i", charID);
 		{
 			sql::PreparedStatement* stmt = Database::CreatePreppedStmt("DELETE FROM charxml WHERE id=? LIMIT 1;");
 			stmt->setUInt64(1, charID);
@@ -422,7 +423,7 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 			stmt->execute();
 			delete stmt;
 			CBITSTREAM;
-			BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
+			PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION);
 			bitStream.Write(objectID);
 			Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
 		}
@@ -478,40 +479,32 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet) {
 	User* u = GetUser(sysAddr);
 	if (!u) {
-		LOG("Couldn't get user to delete character");
+		Game::logger->Log("UserManager", "Couldn't get user to delete character");
 		return;
 	}
 
-	LWOOBJID objectID = PacketUtils::ReadS64(8, packet);
+	LWOOBJID objectID = PacketUtils::ReadPacketS64(8, packet);
 	GeneralUtils::ClearBit(objectID, eObjectBits::CHARACTER);
 	GeneralUtils::ClearBit(objectID, eObjectBits::PERSISTENT);
 
 	uint32_t charID = static_cast<uint32_t>(objectID);
-	LOG("Received char rename request for ID: %llu (%u)", objectID, charID);
+	Game::logger->Log("UserManager", "Received char rename request for ID: %llu (%u)", objectID, charID);
 
 	std::string newName = PacketUtils::ReadString(16, packet, true);
 
 	Character* character = nullptr;
 
 	//Check if this user has this character:
-	bool ownsCharacter = CheatDetection::VerifyLwoobjidIsSender(
-		objectID,
-		sysAddr,
-		CheckType::User,
-		"User %i tried to rename a character that it does not own!",
-		u->GetAccountID());
+	bool hasCharacter = false;
+	std::vector<Character*>& characters = u->GetCharacters();
+	for (size_t i = 0; i < characters.size(); ++i) {
+		if (characters[i]->GetID() == charID) { hasCharacter = true; character = characters[i]; }
+	}
 
-	std::find_if(u->GetCharacters().begin(), u->GetCharacters().end(), [&](Character* c) {
-		if (c->GetID() == charID) {
-			character = c;
-			return true;
-		}
-		return false;
-		});
-
-	if (!ownsCharacter || !character) {
+	if (!hasCharacter || !character) {
+		Game::logger->Log("UserManager", "User %i tried to rename a character that it does not own!", u->GetAccountID());
 		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
-	} else if (ownsCharacter && character) {
+	} else if (hasCharacter && character) {
 		if (newName == character->GetName()) {
 			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
 			return;
@@ -526,7 +519,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 				stmt->execute();
 				delete stmt;
 
-				LOG("Character %s now known as %s", character->GetName().c_str(), newName.c_str());
+				Game::logger->Log("UserManager", "Character %s now known as %s", character->GetName().c_str(), newName.c_str());
 				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 			} else {
@@ -537,7 +530,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 				stmt->execute();
 				delete stmt;
 
-				LOG("Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
+				Game::logger->Log("UserManager", "Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
 				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
 				UserManager::RequestCharacterList(sysAddr);
 			}
@@ -545,7 +538,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_IN_USE);
 		}
 	} else {
-		LOG("Unknown error occurred when renaming character, either hasCharacter or character variable != true.");
+		Game::logger->Log("UserManager", "Unknown error occurred when renaming character, either hasCharacter or character variable != true.");
 		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
 	}
 }
@@ -553,7 +546,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID) {
 	User* u = GetUser(sysAddr);
 	if (!u) {
-		LOG("Couldn't get user to log in character");
+		Game::logger->Log("UserManager", "Couldn't get user to log in character");
 		return;
 	}
 
@@ -576,7 +569,7 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
 		if (zoneID == LWOZONEID_INVALID) zoneID = 1000; //Send char to VE
 
 		ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, zoneID, character->GetZoneClone(), false, [=](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string serverIP, uint16_t serverPort) {
-			LOG("Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", character->GetName().c_str(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
+			Game::logger->Log("UserManager", "Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", character->GetName().c_str(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
 			if (character) {
 				character->SetZoneID(zoneID);
 				character->SetZoneInstance(zoneInstance);
@@ -586,7 +579,7 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
 			return;
 			});
 	} else {
-		LOG("Unknown error occurred when logging in a character, either hasCharacter or character variable != true.");
+		Game::logger->Log("UserManager", "Unknown error occurred when logging in a character, either hasCharacter or character variable != true.");
 	}
 }
 
@@ -601,7 +594,7 @@ uint32_t FindCharShirtID(uint32_t shirtColor, uint32_t shirtStyle) {
 		tableData.finalize();
 		return shirtLOT;
 	} catch (const std::exception&) {
-		LOG("Failed to execute query! Using backup...");
+		Game::logger->Log("Character Create", "Failed to execute query! Using backup...");
 		// in case of no shirt found in CDServer, return problematic red vest.
 		return 4069;
 	}
@@ -616,7 +609,7 @@ uint32_t FindCharPantsID(uint32_t pantsColor) {
 		tableData.finalize();
 		return pantsLOT;
 	} catch (const std::exception&) {
-		LOG("Failed to execute query! Using backup...");
+		Game::logger->Log("Character Create", "Failed to execute query! Using backup...");
 		// in case of no pants color found in CDServer, return red pants.
 		return 2508;
 	}

dGame/dBehaviors/AirMovementBehavior.cpp

@@ -3,13 +3,13 @@
 #include "BehaviorContext.h"
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void AirMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	uint32_t handle{};
 
 	if (!bitStream->Read(handle)) {
-		LOG("Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("AirMovementBehavior", "Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 
@@ -26,14 +26,14 @@ void AirMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitS
 	uint32_t behaviorId{};
 
 	if (!bitStream->Read(behaviorId)) {
-		LOG("Unable to read behaviorId from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("AirMovementBehavior", "Unable to read behaviorId from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 
 	LWOOBJID target{};
 
 	if (!bitStream->Read(target)) {
-		LOG("Unable to read target from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("AirMovementBehavior", "Unable to read target from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 

dGame/dBehaviors/AndBehavior.cpp

@@ -1,7 +1,7 @@
 #include "AndBehavior.h"
 #include "BehaviorBranchContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void AndBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	for (auto* behavior : this->m_behaviors) {

dGame/dBehaviors/AreaOfEffectBehavior.cpp

@@ -4,130 +4,150 @@
 
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "BehaviorBranchContext.h"
 #include "BehaviorContext.h"
 #include "RebuildComponent.h"
 #include "DestroyableComponent.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void AreaOfEffectBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	uint32_t targetCount{};
 
 	if (!bitStream->Read(targetCount)) {
-		LOG("Unable to read targetCount from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
-		return;
-	}
-
-	if (this->m_useTargetPosition && branch.target == LWOOBJID_EMPTY) return;
-
-	if (targetCount == 0){
-		PlayFx(u"miss", context->originator);
+		Game::logger->Log("AreaOfEffectBehavior", "Unable to read targetCount from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 
 	if (targetCount > this->m_maxTargets) {
-		LOG("Serialized size is greater than max targets! Size: %i, Max: %i", targetCount, this->m_maxTargets);
 		return;
 	}
 
-	auto caster = context->caster;
-	if (this->m_useTargetAsCaster) context->caster = branch.target;
-
 	std::vector<LWOOBJID> targets;
+
 	targets.reserve(targetCount);
 
 	for (auto i = 0u; i < targetCount; ++i) {
 		LWOOBJID target{};
+
 		if (!bitStream->Read(target)) {
-			LOG("failed to read in target %i from bitStream, aborting target Handle!", i);
+			Game::logger->Log("AreaOfEffectBehavior", "failed to read in target %i from bitStream, aborting target Handle!", i);
+			return;
 		};
+
 		targets.push_back(target);
 	}
 
 	for (auto target : targets) {
 		branch.target = target;
+
 		this->m_action->Handle(context, bitStream, branch);
 	}
-	context->caster = caster;
-	PlayFx(u"cast", context->originator);
 }
 
 void AreaOfEffectBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
-	auto* caster = Game::entityManager->GetEntity(context->caster);
-	if (!caster) return;
+	auto* self = Game::entityManager->GetEntity(context->caster);
+	if (self == nullptr) {
+		Game::logger->Log("AreaOfEffectBehavior", "Invalid self for (%llu)!", context->originator);
 
-	// determine the position we are casting the AOE from
-	auto reference = branch.isProjectile ? branch.referencePosition : caster->GetPosition();
-	if (this->m_useTargetPosition) {
-		if (branch.target == LWOOBJID_EMPTY) return;
-		auto branchTarget = Game::entityManager->GetEntity(branch.target);
-		if (branchTarget) reference = branchTarget->GetPosition();
+		return;
 	}
 
-	reference += this->m_offset;
+	auto reference = branch.isProjectile ? branch.referencePosition : self->GetPosition();
 
-	std::vector<Entity*> targets {};
-	targets = Game::entityManager->GetEntitiesByProximity(reference, this->m_radius);
-	context->FilterTargets(targets, this->m_ignoreFactionList, this->m_includeFactionList, this->m_targetSelf, this->m_targetEnemy, this->m_targetFriend, this->m_targetTeam);
+	std::vector<Entity*> targets;
+
+	auto* presetTarget = Game::entityManager->GetEntity(branch.target);
+
+	if (presetTarget != nullptr) {
+		if (this->m_radius * this->m_radius >= Vector3::DistanceSquared(reference, presetTarget->GetPosition())) {
+			targets.push_back(presetTarget);
+		}
+	}
+
+	int32_t includeFaction = m_includeFaction;
+
+	if (self->GetLOT() == 14466) // TODO: Fix edge case
+	{
+		includeFaction = 1;
+	}
+
+	// Gets all of the valid targets, passing in if should target enemies and friends
+	for (auto validTarget : context->GetValidTargets(m_ignoreFaction, includeFaction, m_TargetSelf == 1, m_targetEnemy == 1, m_targetFriend == 1)) {
+		auto* entity = Game::entityManager->GetEntity(validTarget);
+
+		if (entity == nullptr) {
+			Game::logger->Log("AreaOfEffectBehavior", "Invalid target (%llu) for (%llu)!", validTarget, context->originator);
+
+			continue;
+		}
+
+		if (std::find(targets.begin(), targets.end(), entity) != targets.end()) {
+			continue;
+		}
+
+		auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
+
+		if (destroyableComponent == nullptr) {
+			continue;
+		}
+
+		if (destroyableComponent->HasFaction(m_ignoreFaction)) {
+			continue;
+		}
+
+		const auto distance = Vector3::DistanceSquared(reference, entity->GetPosition());
+
+		if (this->m_radius * this->m_radius >= distance && (this->m_maxTargets == 0 || targets.size() < this->m_maxTargets)) {
+			targets.push_back(entity);
+		}
+	}
 
-	// sort by distance
 	std::sort(targets.begin(), targets.end(), [reference](Entity* a, Entity* b) {
-		const auto aDistance = NiPoint3::Distance(a->GetPosition(), reference);
-		const auto bDistance = NiPoint3::Distance(b->GetPosition(), reference);
-		return aDistance < bDistance;
-		}
-	);
+		const auto aDistance = Vector3::DistanceSquared(a->GetPosition(), reference);
+		const auto bDistance = Vector3::DistanceSquared(b->GetPosition(), reference);
 
-	// resize if we have more than max targets allows
-	if (targets.size() > this->m_maxTargets) targets.resize(this->m_maxTargets);
+		return aDistance > bDistance;
+		});
 
-	bitStream->Write<uint32_t>(targets.size());
+	const uint32_t size = targets.size();
 
-	if (targets.size() == 0) {
-		PlayFx(u"miss", context->originator);
+	bitStream->Write(size);
+
+	if (size == 0) {
 		return;
-	} else {
-		context->foundTarget = true;
-		// write all the targets to the bitstream
-		for (auto* target : targets) {
-			bitStream->Write(target->GetObjectID());
-		}
+	}
 
-		// then cast all the actions
-		for (auto* target : targets) {
-			branch.target = target->GetObjectID();
-			this->m_action->Calculate(context, bitStream, branch);
-		}
-		PlayFx(u"cast", context->originator);
+	context->foundTarget = true;
+
+	for (auto* target : targets) {
+		bitStream->Write(target->GetObjectID());
+
+		PlayFx(u"cast", context->originator, target->GetObjectID());
+	}
+
+	for (auto* target : targets) {
+		branch.target = target->GetObjectID();
+
+		this->m_action->Calculate(context, bitStream, branch);
 	}
 }
 
 void AreaOfEffectBehavior::Load() {
-	this->m_action = GetAction("action"); // required
-	this->m_radius = GetFloat("radius", 0.0f); // required
-	this->m_maxTargets = GetInt("max targets", 100);
-	if (this->m_maxTargets == 0) this->m_maxTargets = 100;
-	this->m_useTargetPosition = GetBoolean("use_target_position", false);
-	this->m_useTargetAsCaster = GetBoolean("use_target_as_caster", false);
-	this->m_offset = NiPoint3(
-		GetFloat("offset_x", 0.0f),
-		GetFloat("offset_y", 0.0f),
-		GetFloat("offset_z", 0.0f)
-	);
+	this->m_action = GetAction("action");
 
-	// params after this are needed for filter targets
-	const auto parameters = GetParameterNames();
-	for (const auto& parameter : parameters) {
-		if (parameter.first.rfind("include_faction", 0) == 0) {
-			this->m_includeFactionList.push_front(parameter.second);
-		} else if (parameter.first.rfind("ignore_faction", 0) == 0) {
-			this->m_ignoreFactionList.push_front(parameter.second);
-		}
-	}
-	this->m_targetSelf = GetBoolean("target_self", false);
-	this->m_targetEnemy = GetBoolean("target_enemy", false);
-	this->m_targetFriend = GetBoolean("target_friend", false);
-	this->m_targetTeam = GetBoolean("target_team", false);
+	this->m_radius = GetFloat("radius");
+
+	this->m_maxTargets = GetInt("max targets");
+
+	this->m_ignoreFaction = GetInt("ignore_faction");
+
+	this->m_includeFaction = GetInt("include_faction");
+
+	this->m_TargetSelf = GetInt("target_self");
+
+	this->m_targetEnemy = GetInt("target_enemy");
+
+	this->m_targetFriend = GetInt("target_friend");
 }

dGame/dBehaviors/AreaOfEffectBehavior.h

@@ -1,26 +1,34 @@
 #pragma once
 #include "Behavior.h"
-#include <forward_list>
 
 class AreaOfEffectBehavior final : public Behavior
 {
 public:
-	explicit AreaOfEffectBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {}
-	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
-	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
-	void Load() override;
-private:
 	Behavior* m_action;
-	uint32_t m_maxTargets;
-	float m_radius;
-	bool m_useTargetPosition;
-	bool m_useTargetAsCaster;
-	NiPoint3 m_offset;
 
-	std::forward_list<int32_t> m_ignoreFactionList {};
-	std::forward_list<int32_t> m_includeFactionList {};
-	bool m_targetSelf;
-	bool m_targetEnemy;
-	bool m_targetFriend;
-	bool m_targetTeam;
+	uint32_t m_maxTargets;
+
+	float m_radius;
+
+	int32_t m_ignoreFaction;
+
+	int32_t m_includeFaction;
+
+	int32_t m_TargetSelf;
+
+	int32_t m_targetEnemy;
+
+	int32_t m_targetFriend;
+
+	/*
+	 * Inherited
+	 */
+	explicit AreaOfEffectBehavior(const uint32_t behaviorId) : Behavior(behaviorId) {
+	}
+
+	void Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+
+	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
+
+	void Load() override;
 };

dGame/dBehaviors/AttackDelayBehavior.cpp

@@ -2,13 +2,13 @@
 #include "BehaviorBranchContext.h"
 #include "BehaviorContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void AttackDelayBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	uint32_t handle{};
 
 	if (!bitStream->Read(handle)) {
-		LOG("Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("AttackDelayBehavior", "Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	};
 

dGame/dBehaviors/BasicAttackBehavior.cpp

@@ -1,7 +1,7 @@
 #include "BasicAttackBehavior.h"
 #include "BehaviorBranchContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "EntityManager.h"
 #include "DestroyableComponent.h"
 #include "BehaviorContext.h"
@@ -26,10 +26,10 @@ void BasicAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bi
 
 	uint16_t allocatedBits{};
 	if (!bitStream->Read(allocatedBits) || allocatedBits == 0) {
-		LOG_DEBUG("No allocated bits");
+		Game::logger->LogDebug("BasicAttackBehavior", "No allocated bits");
 		return;
 	}
-	LOG_DEBUG("Number of allocated bits %i", allocatedBits);
+	Game::logger->LogDebug("BasicAttackBehavior", "Number of allocated bits %i", allocatedBits);
 	const auto baseAddress = bitStream->GetReadOffset();
 
 	DoHandleBehavior(context, bitStream, branch);
@@ -40,13 +40,13 @@ void BasicAttackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bi
 void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	auto* targetEntity = Game::entityManager->GetEntity(branch.target);
 	if (!targetEntity) {
-		LOG("Target targetEntity %llu not found.", branch.target);
+		Game::logger->Log("BasicAttackBehavior", "Target targetEntity %llu not found.", branch.target);
 		return;
 	}
 
 	auto* destroyableComponent = targetEntity->GetComponent<DestroyableComponent>();
 	if (!destroyableComponent) {
-		LOG("No destroyable found on the obj/lot %llu/%i", branch.target, targetEntity->GetLOT());
+		Game::logger->Log("BasicAttackBehavior", "No destroyable found on the obj/lot %llu/%i", branch.target, targetEntity->GetLOT());
 		return;
 	}
 
@@ -55,7 +55,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 	bool isSuccess{};
 
 	if (!bitStream->Read(isBlocked)) {
-		LOG("Unable to read isBlocked");
+		Game::logger->Log("BasicAttackBehavior", "Unable to read isBlocked");
 		return;
 	}
 
@@ -67,7 +67,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 	}
 
 	if (!bitStream->Read(isImmune)) {
-		LOG("Unable to read isImmune");
+		Game::logger->Log("BasicAttackBehavior", "Unable to read isImmune");
 		return;
 	}
 
@@ -77,20 +77,20 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 	}
 
 	if (!bitStream->Read(isSuccess)) {
-		LOG("failed to read success from bitstream");
+		Game::logger->Log("BasicAttackBehavior", "failed to read success from bitstream");
 		return;
 	}
 
 	if (isSuccess) {
 		uint32_t armorDamageDealt{};
 		if (!bitStream->Read(armorDamageDealt)) {
-			LOG("Unable to read armorDamageDealt");
+			Game::logger->Log("BasicAttackBehavior", "Unable to read armorDamageDealt");
 			return;
 		}
 
 		uint32_t healthDamageDealt{};
 		if (!bitStream->Read(healthDamageDealt)) {
-			LOG("Unable to read healthDamageDealt");
+			Game::logger->Log("BasicAttackBehavior", "Unable to read healthDamageDealt");
 			return;
 		}
 
@@ -103,7 +103,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 
 		bool died{};
 		if (!bitStream->Read(died)) {
-			LOG("Unable to read died");
+			Game::logger->Log("BasicAttackBehavior", "Unable to read died");
 			return;
 		}
 		auto previousArmor = destroyableComponent->GetArmor();
@@ -114,7 +114,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 
 	uint8_t successState{};
 	if (!bitStream->Read(successState)) {
-		LOG("Unable to read success state");
+		Game::logger->Log("BasicAttackBehavior", "Unable to read success state");
 		return;
 	}
 
@@ -127,7 +127,7 @@ void BasicAttackBehavior::DoHandleBehavior(BehaviorContext* context, RakNet::Bit
 		break;
 	default:
 		if (static_cast<eBasicAttackSuccessTypes>(successState) != eBasicAttackSuccessTypes::FAILIMMUNE) {
-			LOG("Unknown success state (%i)!", successState);
+			Game::logger->Log("BasicAttackBehavior", "Unknown success state (%i)!", successState);
 			return;
 		}
 		this->m_OnFailImmune->Handle(context, bitStream, branch);
@@ -157,13 +157,13 @@ void BasicAttackBehavior::Calculate(BehaviorContext* context, RakNet::BitStream*
 void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	auto* targetEntity = Game::entityManager->GetEntity(branch.target);
 	if (!targetEntity) {
-		LOG("Target entity %llu is null!", branch.target);
+		Game::logger->Log("BasicAttackBehavior", "Target entity %llu is null!", branch.target);
 		return;
 	}
 
 	auto* destroyableComponent = targetEntity->GetComponent<DestroyableComponent>();
 	if (!destroyableComponent || !destroyableComponent->GetParent()) {
-		LOG("No destroyable component on %llu", branch.target);
+		Game::logger->Log("BasicAttackBehavior", "No destroyable component on %llu", branch.target);
 		return;
 	}
 
@@ -227,7 +227,7 @@ void BasicAttackBehavior::DoBehaviorCalculation(BehaviorContext* context, RakNet
 		break;
 	default:
 		if (static_cast<eBasicAttackSuccessTypes>(successState) != eBasicAttackSuccessTypes::FAILIMMUNE) {
-			LOG("Unknown success state (%i)!", successState);
+			Game::logger->Log("BasicAttackBehavior", "Unknown success state (%i)!", successState);
 			break;
 		}
 		this->m_OnFailImmune->Calculate(context, bitStream, branch);

dGame/dBehaviors/Behavior.cpp

@@ -4,7 +4,7 @@
 #include "Behavior.h"
 #include "CDActivitiesTable.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "BehaviorTemplates.h"
 #include "BehaviorBranchContext.h"
 #include <unordered_map>
@@ -175,7 +175,7 @@ Behavior* Behavior::CreateBehavior(const uint32_t behaviorId) {
 	case BehaviorTemplates::BEHAVIOR_SPEED:
 		behavior = new SpeedBehavior(behaviorId);
 		break;
-	case BehaviorTemplates::BEHAVIOR_DARK_INSPIRATION:
+	case BehaviorTemplates::BEHAVIOR_DARK_INSPIRATION: 
 		behavior = new DarkInspirationBehavior(behaviorId);
 		break;
 	case BehaviorTemplates::BEHAVIOR_LOOT_BUFF:
@@ -278,12 +278,12 @@ Behavior* Behavior::CreateBehavior(const uint32_t behaviorId) {
 	case BehaviorTemplates::BEHAVIOR_MOUNT: break;
 	case BehaviorTemplates::BEHAVIOR_SKILL_SET: break;
 	default:
-		//LOG("Failed to load behavior with invalid template id (%i)!", templateId);
+		//Game::logger->Log("Behavior", "Failed to load behavior with invalid template id (%i)!", templateId);
 		break;
 	}
 
 	if (behavior == nullptr) {
-		//LOG("Failed to load unimplemented template id (%i)!", templateId);
+		//Game::logger->Log("Behavior", "Failed to load unimplemented template id (%i)!", templateId);
 
 		behavior = new EmptyBehavior(behaviorId);
 	}
@@ -306,7 +306,7 @@ BehaviorTemplates Behavior::GetBehaviorTemplate(const uint32_t behaviorId) {
 	}
 
 	if (templateID == BehaviorTemplates::BEHAVIOR_EMPTY && behaviorId != 0) {
-		LOG("Failed to load behavior template with id (%i)!", behaviorId);
+		Game::logger->Log("Behavior", "Failed to load behavior template with id (%i)!", behaviorId);
 	}
 
 	return templateID;
@@ -426,7 +426,7 @@ Behavior::Behavior(const uint32_t behaviorId) {
 
 	// Make sure we do not proceed if we are trying to load an invalid behavior
 	if (templateInDatabase.behaviorID == 0) {
-		LOG("Failed to load behavior with id (%i)!", behaviorId);
+		Game::logger->Log("Behavior", "Failed to load behavior with id (%i)!", behaviorId);
 
 		this->m_effectId = 0;
 		this->m_effectHandle = nullptr;

dGame/dBehaviors/BehaviorContext.cpp

@@ -4,9 +4,9 @@
 #include "EntityManager.h"
 #include "SkillComponent.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "dServer.h"
-#include "BitStreamUtils.h"
+#include "PacketUtils.h"
 
 #include <sstream>
 
@@ -15,7 +15,6 @@
 #include "PhantomPhysicsComponent.h"
 #include "RebuildComponent.h"
 #include "eReplicaComponentType.h"
-#include "TeamManager.h"
 #include "eConnectionType.h"
 
 BehaviorSyncEntry::BehaviorSyncEntry() {
@@ -31,7 +30,7 @@ uint32_t BehaviorContext::GetUniqueSkillId() const {
 	auto* entity = Game::entityManager->GetEntity(this->originator);
 
 	if (entity == nullptr) {
-		LOG("Invalid entity for (%llu)!", this->originator);
+		Game::logger->Log("BehaviorContext", "Invalid entity for (%llu)!", this->originator);
 
 		return 0;
 	}
@@ -39,7 +38,7 @@ uint32_t BehaviorContext::GetUniqueSkillId() const {
 	auto* component = entity->GetComponent<SkillComponent>();
 
 	if (component == nullptr) {
-		LOG("No skill component attached to (%llu)!", this->originator);;
+		Game::logger->Log("BehaviorContext", "No skill component attached to (%llu)!", this->originator);;
 
 		return 0;
 	}
@@ -126,7 +125,7 @@ void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream* bit
 	}
 
 	if (!found) {
-		LOG("Failed to find behavior sync entry with sync id (%i)!", syncId);
+		Game::logger->Log("BehaviorContext", "Failed to find behavior sync entry with sync id (%i)!", syncId);
 
 		return;
 	}
@@ -135,7 +134,7 @@ void BehaviorContext::SyncBehavior(const uint32_t syncId, RakNet::BitStream* bit
 	const auto branch = entry.branchContext;
 
 	if (behavior == nullptr) {
-		LOG("Invalid behavior for sync id (%i)!", syncId);
+		Game::logger->Log("BehaviorContext", "Invalid behavior for sync id (%i)!", syncId);
 
 		return;
 	}
@@ -254,7 +253,7 @@ bool BehaviorContext::CalculateUpdate(const float deltaTime) {
 			// Write message
 			RakNet::BitStream message;
 
-			BitStreamUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
+			PacketUtils::WriteHeader(message, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 			message.Write(this->originator);
 			echo.Serialize(&message);
 
@@ -308,123 +307,46 @@ void BehaviorContext::Reset() {
 	this->scheduledUpdates.clear();
 }
 
-void BehaviorContext::FilterTargets(std::vector<Entity*>& targets, std::forward_list<int32_t>& ignoreFactionList, std::forward_list<int32_t>& includeFactionList, bool targetSelf, bool targetEnemy, bool targetFriend, bool targetTeam) const {
+std::vector<LWOOBJID> BehaviorContext::GetValidTargets(int32_t ignoreFaction, int32_t includeFaction, bool targetSelf, bool targetEnemy, bool targetFriend) const {
+	auto* entity = Game::entityManager->GetEntity(this->caster);
 
-	// if we aren't targeting anything, then clear the targets vector
-	if (!targetSelf && !targetEnemy && !targetFriend && !targetTeam && ignoreFactionList.empty() && includeFactionList.empty()) {
-		targets.clear();
-		return;
+	std::vector<LWOOBJID> targets;
+
+	if (entity == nullptr) {
+		Game::logger->Log("BehaviorContext", "Invalid entity for (%llu)!", this->originator);
+
+		return targets;
 	}
 
-	// if the caster is not there, return empty targets list
-	auto* caster = Game::entityManager->GetEntity(this->caster);
-	if (!caster) {
-		LOG_DEBUG("Invalid caster for (%llu)!", this->originator);
-		targets.clear();
-		return;
+	if (!ignoreFaction && !includeFaction) {
+		for (auto entry : entity->GetTargetsInPhantom()) {
+			auto* instance = Game::entityManager->GetEntity(entry);
+
+			if (instance == nullptr) {
+				continue;
+			}
+
+			targets.push_back(entry);
+		}
 	}
 
-	auto index = targets.begin();
-	while (index != targets.end()) {
-		auto candidate = *index;
-
-		// make sure we don't have a nullptr
-		if (!candidate) {
-			index = targets.erase(index);
-			continue;
+	if (ignoreFaction || includeFaction || (!entity->HasComponent(eReplicaComponentType::PHANTOM_PHYSICS) && targets.empty())) {
+		DestroyableComponent* destroyableComponent;
+		if (!entity->TryGetComponent(eReplicaComponentType::DESTROYABLE, destroyableComponent)) {
+			return targets;
 		}
 
-		// handle targeting the caster
-		if (candidate == caster){
-			// if we aren't targeting self, erase, otherise increment and continue
-			if (!targetSelf) index = targets.erase(index);
-			else index++;
-			continue;
-		}
+		auto entities = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS);
+		for (auto* candidate : entities) {
+			const auto id = candidate->GetObjectID();
 
-		// make sure that the entity is targetable
-		if (!CheckTargetingRequirements(candidate)) {
-			index = targets.erase(index);
-			continue;
-		}
-
-		// get factions to check against
-		// CheckTargetingRequirements checks for a destroyable component
-		// but we check again because bounds check are necessary
-		auto candidateDestroyableComponent = candidate->GetComponent<DestroyableComponent>();
-		if (!candidateDestroyableComponent) {
-			index = targets.erase(index);
-			continue;
-		}
-
-		// if they are dead, then earse and continue
-		if (candidateDestroyableComponent->GetIsDead()){
-			index = targets.erase(index);
-			continue;
-		}
-
-		// if their faction is explicitly included, increment and continue
-		auto candidateFactions = candidateDestroyableComponent->GetFactionIDs();
-		if (CheckFactionList(includeFactionList, candidateFactions)){
-			index++;
-			continue;
-		}
-
-		// check if they are a team member
-		if (targetTeam){
-			auto* team = TeamManager::Instance()->GetTeam(this->caster);
-			if (team){
-				// if we find a team member keep it and continue to skip enemy checks
-				if(std::find(team->members.begin(), team->members.end(), candidate->GetObjectID()) != team->members.end()){
-					index++;
-					continue;
-				}
+			if ((id != entity->GetObjectID() || targetSelf) && destroyableComponent->CheckValidity(id, ignoreFaction || includeFaction, targetEnemy, targetFriend)) {
+				targets.push_back(id);
 			}
 		}
-
-		// if the caster doesn't have a destroyable component, return an empty targets list
-		auto* casterDestroyableComponent = caster->GetComponent<DestroyableComponent>();
-		if (!casterDestroyableComponent) {
-			targets.clear();
-			return;
-		}
-
-		// if we arent targeting a friend, and they are a friend OR
-		// if we are not targeting enemies and they are an enemy OR.
-		// if we are ignoring their faction is explicitly ignored
-		// erase and continue
-		auto isEnemy = casterDestroyableComponent->IsEnemy(candidate);
-		if ((!targetFriend && !isEnemy) ||
-			(!targetEnemy && isEnemy) ||
-			CheckFactionList(ignoreFactionList, candidateFactions)) {
-			index = targets.erase(index);
-			continue;
-		}
-
-		index++;
 	}
-	return;
-}
 
-// some basic checks as well as the check that matters for this: if the quickbuild is complete
-bool BehaviorContext::CheckTargetingRequirements(const Entity* target) const {
-	// if the target is a nullptr, then it's not valid
-	if (!target) return false;
-
-	// ignore quickbuilds that aren't completed
-	auto* targetQuickbuildComponent = target->GetComponent<RebuildComponent>();
-	if (targetQuickbuildComponent && targetQuickbuildComponent->GetState() != eRebuildState::COMPLETED) return false;
-
-	return true;
-}
-
-// returns true if any of the object factions are in the faction list
-bool BehaviorContext::CheckFactionList(std::forward_list<int32_t>& factionList, std::vector<int32_t>& objectsFactions) const {
-	if (factionList.empty() || objectsFactions.empty()) return false;
-	for (auto faction : factionList){
-		if(std::find(objectsFactions.begin(), objectsFactions.end(), faction) != objectsFactions.end()) return true;
-	}
-	return false;
+	return targets;
 }
 
 

dGame/dBehaviors/BehaviorContext.h

@@ -6,7 +6,6 @@
 #include "GameMessages.h"
 
 #include <vector>
-#include <forward_list>
 
 class Behavior;
 
@@ -107,11 +106,7 @@ struct BehaviorContext
 
 	void Reset();
 
-	void FilterTargets(std::vector<Entity*>& targetsReference, std::forward_list<int32_t>& ignoreFaction, std::forward_list<int32_t>& includeFaction, const bool targetSelf = false, const bool targetEnemy = true, const bool targetFriend = false, const bool targetTeam = false) const;
-
-	bool CheckTargetingRequirements(const Entity* target) const;
-
-	bool CheckFactionList(std::forward_list<int32_t>& factionList, std::vector<int32_t>& objectsFactions) const;
+	std::vector<LWOOBJID> GetValidTargets(int32_t ignoreFaction = 0, int32_t includeFaction = 0, const bool targetSelf = false, const bool targetEnemy = true, const bool targetFriend = false) const;
 
 	explicit BehaviorContext(LWOOBJID originator, bool calculation = false);
 

dGame/dBehaviors/BehaviorSlot.h

@@ -2,9 +2,9 @@
 
 #ifndef BEHAVIORSLOT_H
 #define BEHAVIORSLOT_H
-#include <cstdint>
 
-enum class BehaviorSlot : int32_t {
+enum class BehaviorSlot
+{
 	Invalid = -1,
 	Primary,
 	Offhand,

dGame/dBehaviors/BlockBehavior.cpp

@@ -4,7 +4,7 @@
 #include "BehaviorBranchContext.h"
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "DestroyableComponent.h"
 
 void BlockBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
@@ -13,7 +13,7 @@ void BlockBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStrea
 	auto* entity = Game::entityManager->GetEntity(target);
 
 	if (entity == nullptr) {
-		LOG("Failed to find target (%llu)!", branch.target);
+		Game::logger->Log("DamageAbsorptionBehavior", "Failed to find target (%llu)!", branch.target);
 
 		return;
 	}
@@ -43,7 +43,7 @@ void BlockBehavior::UnCast(BehaviorContext* context, BehaviorBranchContext branc
 	auto* entity = Game::entityManager->GetEntity(target);
 
 	if (entity == nullptr) {
-		LOG("Failed to find target (%llu)!", branch.target);
+		Game::logger->Log("DamageAbsorptionBehavior", "Failed to find target (%llu)!", branch.target);
 
 		return;
 	}

dGame/dBehaviors/BuffBehavior.cpp

@@ -4,7 +4,7 @@
 #include "BehaviorBranchContext.h"
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "DestroyableComponent.h"
 
 void BuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
@@ -13,7 +13,7 @@ void BuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream
 	auto* entity = Game::entityManager->GetEntity(target);
 
 	if (entity == nullptr) {
-		LOG("Invalid target (%llu)!", target);
+		Game::logger->Log("BuffBehavior", "Invalid target (%llu)!", target);
 
 		return;
 	}
@@ -21,7 +21,7 @@ void BuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream
 	auto* component = entity->GetComponent<DestroyableComponent>();
 
 	if (component == nullptr) {
-		LOG("Invalid target, no destroyable component (%llu)!", target);
+		Game::logger->Log("BuffBehavior", "Invalid target, no destroyable component (%llu)!", target);
 
 		return;
 	}
@@ -47,7 +47,7 @@ void BuffBehavior::UnCast(BehaviorContext* context, BehaviorBranchContext branch
 	auto* entity = Game::entityManager->GetEntity(target);
 
 	if (entity == nullptr) {
-		LOG("Invalid target (%llu)!", target);
+		Game::logger->Log("BuffBehavior", "Invalid target (%llu)!", target);
 
 		return;
 	}
@@ -55,7 +55,7 @@ void BuffBehavior::UnCast(BehaviorContext* context, BehaviorBranchContext branch
 	auto* component = entity->GetComponent<DestroyableComponent>();
 
 	if (component == nullptr) {
-		LOG("Invalid target, no destroyable component (%llu)!", target);
+		Game::logger->Log("BuffBehavior", "Invalid target, no destroyable component (%llu)!", target);
 
 		return;
 	}

dGame/dBehaviors/CarBoostBehavior.cpp

@@ -5,7 +5,7 @@
 #include "BehaviorContext.h"
 #include "CharacterComponent.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "PossessableComponent.h"
 
 void CarBoostBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
@@ -17,7 +17,7 @@ void CarBoostBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitSt
 		return;
 	}
 
-	LOG("Activating car boost!");
+	Game::logger->Log("Car boost", "Activating car boost!");
 
 	auto* possessableComponent = entity->GetComponent<PossessableComponent>();
 	if (possessableComponent != nullptr) {
@@ -27,7 +27,7 @@ void CarBoostBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitSt
 
 			auto* characterComponent = possessor->GetComponent<CharacterComponent>();
 			if (characterComponent != nullptr) {
-				LOG("Tracking car boost!");
+				Game::logger->Log("Car boost", "Tracking car boost!");
 				characterComponent->UpdatePlayerStatistic(RacingCarBoostsActivated);
 			}
 		}

dGame/dBehaviors/ChainBehavior.cpp

@@ -1,13 +1,13 @@
 #include "ChainBehavior.h"
 #include "BehaviorBranchContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void ChainBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	uint32_t chainIndex{};
 
 	if (!bitStream->Read(chainIndex)) {
-		LOG("Unable to read chainIndex from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("ChainBehavior", "Unable to read chainIndex from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 
@@ -16,7 +16,7 @@ void ChainBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStrea
 	if (chainIndex < this->m_behaviors.size()) {
 		this->m_behaviors.at(chainIndex)->Handle(context, bitStream, branch);
 	} else {
-		LOG("chainIndex out of bounds, aborting handle of chain %i bits unread %i", chainIndex, bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("ChainBehavior", "chainIndex out of bounds, aborting handle of chain %i bits unread %i", chainIndex, bitStream->GetNumberOfUnreadBits());
 	}
 }
 

dGame/dBehaviors/ChargeUpBehavior.cpp

@@ -2,13 +2,13 @@
 #include "BehaviorBranchContext.h"
 #include "BehaviorContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void ChargeUpBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	uint32_t handle{};
 
 	if (!bitStream->Read(handle)) {
-		LOG("Unable to read handle from bitStream, aborting Handle! variable_type");
+		Game::logger->Log("ChargeUpBehavior", "Unable to read handle from bitStream, aborting Handle! variable_type");
 		return;
 	};
 

dGame/dBehaviors/DamageAbsorptionBehavior.cpp

@@ -4,14 +4,14 @@
 #include "BehaviorContext.h"
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "DestroyableComponent.h"
 
 void DamageAbsorptionBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	auto* target = Game::entityManager->GetEntity(branch.target);
 
 	if (target == nullptr) {
-		LOG("Failed to find target (%llu)!", branch.target);
+		Game::logger->Log("DamageAbsorptionBehavior", "Failed to find target (%llu)!", branch.target);
 
 		return;
 	}
@@ -37,7 +37,7 @@ void DamageAbsorptionBehavior::Timer(BehaviorContext* context, BehaviorBranchCon
 	auto* target = Game::entityManager->GetEntity(second);
 
 	if (target == nullptr) {
-		LOG("Failed to find target (%llu)!", second);
+		Game::logger->Log("DamageAbsorptionBehavior", "Failed to find target (%llu)!", second);
 
 		return;
 	}

dGame/dBehaviors/DamageReductionBehavior.cpp

@@ -4,14 +4,14 @@
 #include "BehaviorContext.h"
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "DestroyableComponent.h"
 
 void DamageReductionBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	auto* target = Game::entityManager->GetEntity(branch.target);
 
 	if (target == nullptr) {
-		LOG("Failed to find target (%llu)!", branch.target);
+		Game::logger->Log("DamageReductionBehavior", "Failed to find target (%llu)!", branch.target);
 
 		return;
 	}
@@ -35,7 +35,7 @@ void DamageReductionBehavior::Timer(BehaviorContext* context, BehaviorBranchCont
 	auto* target = Game::entityManager->GetEntity(second);
 
 	if (target == nullptr) {
-		LOG("Failed to find target (%llu)!", second);
+		Game::logger->Log("DamageReductionBehavior", "Failed to find target (%llu)!", second);
 
 		return;
 	}

dGame/dBehaviors/DarkInspirationBehavior.cpp

@@ -10,7 +10,7 @@ void DarkInspirationBehavior::Handle(BehaviorContext* context, RakNet::BitStream
 	auto* target = Game::entityManager->GetEntity(branch.target);
 
 	if (target == nullptr) {
-		LOG_DEBUG("Failed to find target (%llu)!", branch.target);
+		Game::logger->LogDebug("DarkInspirationBehavior", "Failed to find target (%llu)!", branch.target);
 		return;
 	}
 
@@ -29,7 +29,7 @@ void DarkInspirationBehavior::Calculate(BehaviorContext* context, RakNet::BitStr
 	auto* target = Game::entityManager->GetEntity(branch.target);
 
 	if (target == nullptr) {
-		LOG_DEBUG("Failed to find target (%llu)!", branch.target);
+		Game::logger->LogDebug("DarkInspirationBehavior", "Failed to find target (%llu)!", branch.target);
 
 		return;
 	}

dGame/dBehaviors/ForceMovementBehavior.cpp

@@ -4,7 +4,7 @@
 #include "ControllablePhysicsComponent.h"
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void ForceMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	if (this->m_hitAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitEnemyAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY && this->m_hitFactionAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
@@ -13,7 +13,7 @@ void ForceMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream*
 
 	uint32_t handle{};
 	if (!bitStream->Read(handle)) {
-		LOG("Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("ForceMovementBehavior", "Unable to read handle from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 	context->RegisterSyncBehavior(handle, this, branch, this->m_Duration);
@@ -22,13 +22,13 @@ void ForceMovementBehavior::Handle(BehaviorContext* context, RakNet::BitStream*
 void ForceMovementBehavior::Sync(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	uint32_t next{};
 	if (!bitStream->Read(next)) {
-		LOG("Unable to read target from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("ForceMovementBehavior", "Unable to read target from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 
 	LWOOBJID target{};
 	if (!bitStream->Read(target)) {
-		LOG("Unable to read target from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("ForceMovementBehavior", "Unable to read target from bitStream, aborting Sync! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	}
 

dGame/dBehaviors/HealBehavior.cpp

@@ -1,7 +1,7 @@
 #include "HealBehavior.h"
 #include "BehaviorBranchContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "EntityManager.h"
 #include "DestroyableComponent.h"
 #include "eReplicaComponentType.h"
@@ -11,7 +11,7 @@ void HealBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bit_strea
 	auto* entity = Game::entityManager->GetEntity(branch.target);
 
 	if (entity == nullptr) {
-		LOG("Failed to find entity for (%llu)!", branch.target);
+		Game::logger->Log("HealBehavior", "Failed to find entity for (%llu)!", branch.target);
 
 		return;
 	}
@@ -19,7 +19,7 @@ void HealBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bit_strea
 	auto* destroyable = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
 
 	if (destroyable == nullptr) {
-		LOG("Failed to find destroyable component for %(llu)!", branch.target);
+		Game::logger->Log("HealBehavior", "Failed to find destroyable component for %(llu)!", branch.target);
 
 		return;
 	}

dGame/dBehaviors/ImaginationBehavior.cpp

@@ -3,7 +3,7 @@
 #include "DestroyableComponent.h"
 #include "dpWorld.h"
 #include "EntityManager.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 
 void ImaginationBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bit_stream, const BehaviorBranchContext branch) {

dGame/dBehaviors/ImmunityBehavior.cpp

@@ -4,7 +4,7 @@
 #include "BehaviorContext.h"
 #include "EntityManager.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "DestroyableComponent.h"
 #include "ControllablePhysicsComponent.h"
 #include "eStateChangeType.h"
@@ -13,7 +13,7 @@ void ImmunityBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitSt
 	auto* target = Game::entityManager->GetEntity(branch.target);
 
 	if (!target) {
-		LOG("Failed to find target (%llu)!", branch.target);
+		Game::logger->Log("DamageAbsorptionBehavior", "Failed to find target (%llu)!", branch.target);
 		return;
 	}
 
@@ -59,7 +59,7 @@ void ImmunityBehavior::Timer(BehaviorContext* context, BehaviorBranchContext bra
 	auto* target = Game::entityManager->GetEntity(second);
 
 	if (!target) {
-		LOG("Failed to find target (%llu)!", second);
+		Game::logger->Log("DamageAbsorptionBehavior", "Failed to find target (%llu)!", second);
 		return;
 	}
 

dGame/dBehaviors/InterruptBehavior.cpp

@@ -2,7 +2,7 @@
 #include "BehaviorBranchContext.h"
 #include "BehaviorContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 #include "EntityManager.h"
 #include "SkillComponent.h"
 
@@ -12,7 +12,7 @@ void InterruptBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitS
 		bool unknown = false;
 
 		if (!bitStream->Read(unknown)) {
-			LOG("Unable to read unknown1 from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+			Game::logger->Log("InterruptBehavior", "Unable to read unknown1 from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 			return;
 		};
 
@@ -23,7 +23,7 @@ void InterruptBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitS
 		bool unknown = false;
 
 		if (!bitStream->Read(unknown)) {
-			LOG("Unable to read unknown2 from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+			Game::logger->Log("InterruptBehavior", "Unable to read unknown2 from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 			return;
 		};
 
@@ -35,7 +35,7 @@ void InterruptBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitS
 		bool unknown = false;
 
 		if (!bitStream->Read(unknown)) {
-			LOG("Unable to read unknown3 from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+			Game::logger->Log("InterruptBehavior", "Unable to read unknown3 from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 			return;
 		};
 	}

dGame/dBehaviors/KnockbackBehavior.cpp

@@ -7,13 +7,13 @@
 #include "GameMessages.h"
 #include "DestroyableComponent.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void KnockbackBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) {
 	bool unknown{};
 
 	if (!bitStream->Read(unknown)) {
-		LOG("Unable to read unknown from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("KnockbackBehavior", "Unable to read unknown from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	};
 }

dGame/dBehaviors/MovementSwitchBehavior.cpp

@@ -1,7 +1,7 @@
 #include "MovementSwitchBehavior.h"
 #include "BehaviorBranchContext.h"
 #include "Game.h"
-#include "Logger.h"
+#include "dLogger.h"
 
 void MovementSwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitStream, const BehaviorBranchContext branch) {
 	uint32_t movementType{};
@@ -15,7 +15,7 @@ void MovementSwitchBehavior::Handle(BehaviorContext* context, RakNet::BitStream*
 			this->m_movingAction->m_templateId == BehaviorTemplates::BEHAVIOR_EMPTY) {
 			return;
 		}
-		LOG("Unable to read movementType from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
+		Game::logger->Log("MovementSwitchBehavior", "Unable to read movementType from bitStream, aborting Handle! %i", bitStream->GetNumberOfUnreadBits());
 		return;
 	};