Remove extra includes

- Move code to CharacterComponent
- Remove extraneous interfaces
- Simplify some code greatly
- Change some types to return and take in const ref (only structs larger than 8 bytes benefit from this change.)
- Update code to use CharacterComponent for sending to zone instead of Player*.
- Remove static storage container (static containers can be destroyed before exit/terminate handler executes)

.env.example

@@ -1,9 +1,7 @@
 # Full path to the LEGO Universe client
-CLIENT_PATH=/Users/someuser/LEGO Universe
-# Can improve build time
-BUILD_THREADS=1
+CLIENT_PATH=./client
 # Updates NET_VERSION in CMakeVariables.txt
-BUILD_VERSION=171022
+NET_VERSION=171022
 # make sure this is a long random string
 # grab a "SHA 256-bit Key" from here: https://keygen.io/
 ACCOUNT_MANAGER_SECRET=
@@ -12,6 +10,5 @@ EXTERNAL_IP=localhost
 # Database values
 # Be careful with special characters here. It is more safe to use normal characters and/or numbers.
 MARIADB_USER=darkflame
-MARIADB_PASSWORD=SECRET_VALUE_CHANGE_ME
-MARIADB_ROOT_PASSWORD=SECRET_VALUE_CHANGE_ME
+MARIADB_PASSWORD=
 MARIADB_DATABASE=darkflame

CMakeLists.txt

@@ -51,7 +51,7 @@ set(RECASTNAVIGATION_EXAMPLES OFF CACHE BOOL "" FORCE)
 # Disabled no-register
 # Disabled unknown pragmas because Linux doesn't understand Windows pragmas.
 if(UNIX)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++17 -O2 -Wuninitialized -fPIC")
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -Wuninitialized -fPIC")
 	add_compile_definitions(_GLIBCXX_USE_CXX11_ABI=0 _GLIBCXX_USE_CXX17_ABI=0)
 
 	if(NOT APPLE)
@@ -314,6 +314,7 @@ add_subdirectory(dGame)
 add_subdirectory(dZoneManager)
 add_subdirectory(dNavigation)
 add_subdirectory(dPhysics)
+add_subdirectory(dServer)
 
 # Create a list of common libraries shared between all binaries
 set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "mariadbConnCpp" "magic_enum")

README.md

@@ -348,12 +348,40 @@ certutil -hashfile <file> SHA1
 Known good *SHA1* checksum of the Darkflame Universe client:
 - `91498e09b83ce69f46baf9e521d48f23fe502985` (packed client, zip compressed)
 
+
 # Docker
 
-## Standalone
+The Darkflame Server is automatically built and published as a Docker Container / [OCI](https://opencontainers.org/) Image to the GitHub Container Registry at:
+[`ghcr.io/darkflameuniverse/darkflameserver`](https://github.com/DarkflameUniverse/DarkflameServer/pkgs/container/darkflameserver).
 
-For standalone deployment, you can use the image provided via Github's Container Repository:
-`ghcr.io/darkflameuniverse/darkflameserver`
+## Compose
+
+You can use the `docker-compose` tool to [setup a MariaDB database](#database-setup), run the Darkflame Server and manage it with [Nexus Dashboard](https://github.com/DarkflameUniverse/NexusDashboard) all
+at once. For that:
+
+- [Install Docker Desktop](https://docs.docker.com/get-docker/)
+- Open the directory that contains your LU Client
+  - If the `legouniverse.exe` is in a subfolder called `client`, you're good to go. There may also be a folder `versions`.
+  - Otherwise, create a new `client` folder and move the exe and everything else (e.g. `res` and `locale`) in there. This is necessary to work around a bug in the client that will prevent that you to log back in after getting disconnected.
+- Download the [docker-compose.yml](docker-compose.yml) file and place it next to `client`.
+- Download the [.env.example](.env.example) file and place it next to `client` with the file name `.env`
+  - You may get warnings that this name starts with a dot, acknowledge those, this is intentional. Depending on your operating system, you may need to activate showing hidden files (e.g. Ctrl-H in Gnome on Linux) and/or file extensions ("File name extensions" in the "View" tab on Windows).
+  - Update the `ACCOUNT_MANAGER_SECRET` and `MARIADB_PASSWORD` with strong random passwords.
+    - Use a password generator like <https://keygen.io>
+    - Avoid `:` and `@` characters
+    - Once the database user is created, changing the password will not update it, so the server will just fail to connect.
+  - Set `EXTERNAL_IP` to your LAN IP or public IP if you want to host the game for friends & family
+- Open a terminal in the folder with the `docker-compose.yml` and `client`
+- Run `docker compose up -d`
+  - This might require `sudo` on Linux, and a recent version of [docker compose](https://docs.docker.com/compose/install/)
+- Run `docker exec -it dlu-darkflameserver-1 /app/MasterServer -a` and follow the instructions to create the initial admin account
+- Open <http://localhost:8000> to access Nexus Dashboard with the admin account to create normal users
+- Set `AUTHSERVERIP=0:localhost` in `client/boot.cfg`
+  - Replace `localhost` with the value of `EXTERNAL_IP` if you changed that earlier.
+  - Also make sure `UGCUSE3DSERVICES=7:` is set to `0`
+- Launch `legouniverse.exe`
+
+## Standalone
 
 This assumes that you have a database deployed to your host or in another docker container.
 
@@ -376,14 +404,6 @@ You will need to replace the `/path/to/`'s to reflect the paths on your host.
 
 Any config option in the `.ini`'s can be overridden with environmental variables: Ex: `log_to_console=1` from `shared_config.ini` would be overidden like  `-e LOG_TO_CONSOLE=0`
 
-## Compose
-
-See the [compose](docker-compose.yml) file in the root of the repo.
-
-This compose file is for a full deployment: MariaDB, DarkflameServer, and Nexus Dashboard.
-
-All of the environmental options are listed in the compose file so the can be pass through, or you can edit the compose file to suit your specific needs
-
 # Development Documentation
 This is a Work in Progress, but below are some quick links to documentaion for systems and structs in the server
 [Networked message structs](https://lcdruniverse.org/lu_packets/lu_packets/index.html)

dAuthServer/AuthServer.cpp

@@ -25,6 +25,9 @@
 #include "eAuthMessageType.h"
 
 #include "Game.h"
+#include "Server.h"
+
+
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;
@@ -33,7 +36,6 @@ namespace Game {
 	std::mt19937 randomEngine;
 }
 
-Logger* SetupLogger();
 void HandlePacket(Packet* packet);
 
 int main(int argc, char** argv) {
@@ -46,14 +48,11 @@ int main(int argc, char** argv) {
 	std::signal(SIGINT, Game::OnSignal);
 	std::signal(SIGTERM, Game::OnSignal);
 
-	//Create all the objects we need to run our service:
-	Game::logger = SetupLogger();
-	if (!Game::logger) return EXIT_FAILURE;
-
-	//Read our config:
 	Game::config = new dConfig("authconfig.ini");
-	Game::logger->SetLogToConsole(Game::config->GetValue("log_to_console") != "0");
-	Game::logger->SetLogDebugStatements(Game::config->GetValue("log_debug_statements") == "1");
+
+	//Create all the objects we need to run our service:
+	Server::SetupLogger("AuthServer");
+	if (!Game::logger) return EXIT_FAILURE;
 
 	LOG("Starting Auth server...");
 	LOG("Version: %s", PROJECT_VERSION);
@@ -162,18 +161,6 @@ int main(int argc, char** argv) {
 	return EXIT_SUCCESS;
 }
 
-Logger* SetupLogger() {
-	std::string logPath = (BinaryPathFinder::GetBinaryDir() / ("logs/AuthServer_" + std::to_string(time(nullptr)) + ".log")).string();
-	bool logToConsole = false;
-	bool logDebugStatements = false;
-#ifdef _DEBUG
-	logToConsole = true;
-	logDebugStatements = true;
-#endif
-
-	return new Logger(logPath, logToConsole, logDebugStatements);
-}
-
 void HandlePacket(Packet* packet) {
 	if (packet->length < 4) return;
 

dAuthServer/CMakeLists.txt

@@ -1,3 +1,7 @@
 add_executable(AuthServer "AuthServer.cpp")
-target_link_libraries(AuthServer ${COMMON_LIBRARIES})
+
+target_link_libraries(AuthServer ${COMMON_LIBRARIES} dServer)
+
+target_include_directories(AuthServer PRIVATE ${PROJECT_SOURCE_DIR}/dServer)
+
 add_compile_definitions(AuthServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")

dChatServer/CMakeLists.txt

@@ -6,7 +6,9 @@ set(DCHATSERVER_SOURCES
 
 add_executable(ChatServer "ChatServer.cpp")
 add_library(dChatServer ${DCHATSERVER_SOURCES})
+target_include_directories(dChatServer PRIVATE ${PROJECT_SOURCE_DIR}/dServer)
 add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")
 
 target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
-target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer)
+target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer)
+

dChatServer/ChatIgnoreList.cpp

@@ -2,7 +2,6 @@
 #include "PlayerContainer.h"
 #include "eChatInternalMessageType.h"
 #include "BitStreamUtils.h"
-#include "PacketUtils.h"
 #include "Game.h"
 #include "Logger.h"
 #include "eObjectBits.h"
@@ -26,37 +25,36 @@ void ChatIgnoreList::GetIgnoreList(Packet* packet) {
 	LWOOBJID playerId;
 	inStream.Read(playerId);
 
-	auto* receiver = Game::playerContainer.GetPlayerData(playerId);
+	auto& receiver = Game::playerContainer.GetPlayerDataMutable(playerId);
 	if (!receiver) {
 		LOG("Tried to get ignore list, but player %llu not found in container", playerId);
 		return;
 	}
 
-	if (!receiver->ignoredPlayers.empty()) {
-		LOG_DEBUG("Player %llu already has an ignore list", playerId);
-		return;
-	}
+	if (!receiver.ignoredPlayers.empty()) {
+		LOG_DEBUG("Player %llu already has an ignore list, but is requesting it again.", playerId);
+	} else {
+		auto ignoreList = Database::Get()->GetIgnoreList(static_cast<uint32_t>(playerId));
+		if (ignoreList.empty()) {
+			LOG_DEBUG("Player %llu has no ignores", playerId);
+			return;
+		}
 
-	auto ignoreList = Database::Get()->GetIgnoreList(static_cast<uint32_t>(playerId));
-	if (ignoreList.empty()) {
-		LOG_DEBUG("Player %llu has no ignores", playerId);
-		return;
-	}
-
-	for (auto& ignoredPlayer : ignoreList) {
-		receiver->ignoredPlayers.push_back(IgnoreData{ ignoredPlayer.id, ignoredPlayer.name });
-		GeneralUtils::SetBit(receiver->ignoredPlayers.back().playerId, eObjectBits::CHARACTER);
-		GeneralUtils::SetBit(receiver->ignoredPlayers.back().playerId, eObjectBits::PERSISTENT);
+		for (auto& ignoredPlayer : ignoreList) {
+			receiver.ignoredPlayers.emplace_back(ignoredPlayer.name, ignoredPlayer.id);
+			GeneralUtils::SetBit(receiver.ignoredPlayers.back().playerId, eObjectBits::CHARACTER);
+			GeneralUtils::SetBit(receiver.ignoredPlayers.back().playerId, eObjectBits::PERSISTENT);
+		}
 	}
 
 	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver->playerID, ChatIgnoreList::Response::GET_IGNORE);
+	WriteOutgoingReplyHeader(bitStream, receiver.playerID, ChatIgnoreList::Response::GET_IGNORE);
 
 	bitStream.Write<uint8_t>(false); // Probably is Is Free Trial, but we don't care about that
 	bitStream.Write<uint16_t>(0); // literally spacing due to struct alignment
 
-	bitStream.Write<uint16_t>(receiver->ignoredPlayers.size());
-	for (const auto& ignoredPlayer : receiver->ignoredPlayers) {
+	bitStream.Write<uint16_t>(receiver.ignoredPlayers.size());
+	for (const auto& ignoredPlayer : receiver.ignoredPlayers) {
 		bitStream.Write(ignoredPlayer.playerId);
 		bitStream.Write(LUWString(ignoredPlayer.playerName, 36));
 	}
@@ -69,14 +67,14 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 	LWOOBJID playerId;
 	inStream.Read(playerId);
 
-	auto* receiver = Game::playerContainer.GetPlayerData(playerId);
+	auto& receiver = Game::playerContainer.GetPlayerDataMutable(playerId);
 	if (!receiver) {
 		LOG("Tried to get ignore list, but player %llu not found in container", playerId);
 		return;
 	}
 
 	constexpr int32_t MAX_IGNORES = 32;
-	if (receiver->ignoredPlayers.size() > MAX_IGNORES) {
+	if (receiver.ignoredPlayers.size() > MAX_IGNORES) {
 		LOG_DEBUG("Player %llu has too many ignores", playerId);
 		return;
 	}
@@ -88,21 +86,21 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 	std::string toIgnoreStr = toIgnoreName.GetAsString();
 
 	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver->playerID, ChatIgnoreList::Response::ADD_IGNORE);
+	WriteOutgoingReplyHeader(bitStream, receiver.playerID, ChatIgnoreList::Response::ADD_IGNORE);
 
 	// Check if the player exists
 	LWOOBJID ignoredPlayerId = LWOOBJID_EMPTY;
-	if (toIgnoreStr == receiver->playerName || toIgnoreStr.find("[GM]") == 0) {
+	if (toIgnoreStr == receiver.playerName || toIgnoreStr.find("[GM]") == 0) {
 		LOG_DEBUG("Player %llu tried to ignore themselves", playerId);
 
 		bitStream.Write(ChatIgnoreList::AddResponse::GENERAL_ERROR);
-	} else if (std::count(receiver->ignoredPlayers.begin(), receiver->ignoredPlayers.end(), toIgnoreStr) > 0) {
+	} else if (std::count(receiver.ignoredPlayers.begin(), receiver.ignoredPlayers.end(), toIgnoreStr) > 0) {
 		LOG_DEBUG("Player %llu is already ignoring %s", playerId, toIgnoreStr.c_str());
 
 		bitStream.Write(ChatIgnoreList::AddResponse::ALREADY_IGNORED);
 	} else {
 		// Get the playerId falling back to query if not online
-		auto* playerData = Game::playerContainer.GetPlayerData(toIgnoreStr);
+		const auto& playerData = Game::playerContainer.GetPlayerData(toIgnoreStr);
 		if (!playerData) {
 			// Fall back to query
 			auto player = Database::Get()->GetCharacterInfo(toIgnoreStr);
@@ -112,7 +110,7 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 				ignoredPlayerId = player->id;
 			}
 		} else {
-			ignoredPlayerId = playerData->playerID;
+			ignoredPlayerId = playerData.playerID;
 		}
 
 		if (ignoredPlayerId != LWOOBJID_EMPTY) {
@@ -120,7 +118,7 @@ void ChatIgnoreList::AddIgnore(Packet* packet) {
 			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::CHARACTER);
 			GeneralUtils::SetBit(ignoredPlayerId, eObjectBits::PERSISTENT);
 
-			receiver->ignoredPlayers.push_back(IgnoreData{ ignoredPlayerId, toIgnoreStr });
+			receiver.ignoredPlayers.emplace_back(toIgnoreStr, ignoredPlayerId);
 			LOG_DEBUG("Player %llu is ignoring %s", playerId, toIgnoreStr.c_str());
 
 			bitStream.Write(ChatIgnoreList::AddResponse::SUCCESS);
@@ -141,7 +139,7 @@ void ChatIgnoreList::RemoveIgnore(Packet* packet) {
 	LWOOBJID playerId;
 	inStream.Read(playerId);
 
-	auto* receiver = Game::playerContainer.GetPlayerData(playerId);
+	auto& receiver = Game::playerContainer.GetPlayerDataMutable(playerId);
 	if (!receiver) {
 		LOG("Tried to get ignore list, but player %llu not found in container", playerId);
 		return;
@@ -153,17 +151,17 @@ void ChatIgnoreList::RemoveIgnore(Packet* packet) {
 	inStream.Read(removedIgnoreName);
 	std::string removedIgnoreStr = removedIgnoreName.GetAsString();
 
-	auto toRemove = std::remove(receiver->ignoredPlayers.begin(), receiver->ignoredPlayers.end(), removedIgnoreStr);
-	if (toRemove == receiver->ignoredPlayers.end()) {
+	auto toRemove = std::remove(receiver.ignoredPlayers.begin(), receiver.ignoredPlayers.end(), removedIgnoreStr);
+	if (toRemove == receiver.ignoredPlayers.end()) {
 		LOG_DEBUG("Player %llu is not ignoring %s", playerId, removedIgnoreStr.c_str());
 		return;
 	}
 
 	Database::Get()->RemoveIgnore(static_cast<uint32_t>(playerId), static_cast<uint32_t>(toRemove->playerId));
-	receiver->ignoredPlayers.erase(toRemove, receiver->ignoredPlayers.end());
+	receiver.ignoredPlayers.erase(toRemove, receiver.ignoredPlayers.end());
 
 	CBITSTREAM;
-	WriteOutgoingReplyHeader(bitStream, receiver->playerID, ChatIgnoreList::Response::REMOVE_IGNORE);
+	WriteOutgoingReplyHeader(bitStream, receiver.playerID, ChatIgnoreList::Response::REMOVE_IGNORE);
 
 	bitStream.Write<int8_t>(0);
 	LUWString playerNameSend(removedIgnoreStr, 33);

dChatServer/ChatPacketHandler.cpp

@@ -25,7 +25,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	LWOOBJID playerID = 0;
 	inStream.Read(playerID);
 
-	auto player = Game::playerContainer.GetPlayerData(playerID);
+	auto& player = Game::playerContainer.GetPlayerDataMutable(playerID);
 	if (!player) return;
 
 	auto friendsList = Database::Get()->GetFriendsList(playerID);
@@ -37,15 +37,15 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		GeneralUtils::SetBit(fd.friendID, eObjectBits::CHARACTER);
 
 		fd.isBestFriend = friendData.isBestFriend; //0 = friends, 1 = left_requested, 2 = right_requested, 3 = both_accepted - are now bffs
-		if (fd.isBestFriend) player->countOfBestFriends += 1;
+		if (fd.isBestFriend) player.countOfBestFriends += 1;
 		fd.friendName = friendData.friendName;
 
 		//Now check if they're online:
-		auto fr = Game::playerContainer.GetPlayerData(fd.friendID);
+		const auto& fr = Game::playerContainer.GetPlayerData(fd.friendID);
 
 		if (fr) {
 			fd.isOnline = true;
-			fd.zoneID = fr->zoneID;
+			fd.zoneID = fr.zoneID;
 
 			//Since this friend is online, we need to update them on the fact that we've just logged in:
 			SendFriendUpdate(fr, player, 1, fd.isBestFriend);
@@ -54,7 +54,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 			fd.zoneID = LWOZONEID();
 		}
 
-		player->friends.push_back(fd);
+		player.friends.push_back(fd);
 	}
 
 	//Now, we need to send the friendlist to the server they came from:
@@ -66,13 +66,13 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::GET_FRIENDS_LIST_RESPONSE);
 	bitStream.Write<uint8_t>(0);
 	bitStream.Write<uint16_t>(1); //Length of packet -- just writing one as it doesn't matter, client skips it.
-	bitStream.Write<uint16_t>(player->friends.size());
+	bitStream.Write<uint16_t>(player.friends.size());
 
-	for (auto& data : player->friends) {
+	for (const auto& data : player.friends) {
 		data.Serialize(bitStream);
 	}
 
-	SystemAddress sysAddr = player->sysAddr;
+	SystemAddress sysAddr = player.sysAddr;
 	SEND_PACKET;
 }
 
@@ -95,51 +95,49 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 	char isBestFriendRequest{};
 	inStream.Read(isBestFriendRequest);
 
-	auto requestor = Game::playerContainer.GetPlayerData(requestorPlayerID);
+	auto& requestor = Game::playerContainer.GetPlayerDataMutable(requestorPlayerID);
 	if (!requestor) {
 		LOG("No requestor player %llu sent to %s found.", requestorPlayerID, playerName.c_str());
 		return;
 	}
 
-	if (requestor->playerName == playerName) {
+	if (requestor.playerName == playerName) {
 		SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN);
 		return;
 	};
-	std::unique_ptr<PlayerData> requestee(Game::playerContainer.GetPlayerData(playerName));
+
+	auto& requestee = Game::playerContainer.GetPlayerDataMutable(playerName);
 
 	// Check if player is online first
 	if (isBestFriendRequest && !requestee) {
-		for (auto friendDataCandidate : requestor->friends) {
-			if (friendDataCandidate.friendName == playerName) {
-				requestee.reset(new PlayerData());
-				// Setup the needed info since you can add a best friend offline.
-				requestee->playerID = friendDataCandidate.friendID;
-				requestee->playerName = friendDataCandidate.friendName;
-				requestee->zoneID = LWOZONEID();
+		for (auto& friendDataCandidate : requestor.friends) {
+			if (friendDataCandidate.friendName != playerName) continue;
+			// Setup the needed info since you can add a best friend offline.
+			requestee.playerID = friendDataCandidate.friendID;
+			requestee.playerName = friendDataCandidate.friendName;
+			requestee.zoneID = LWOZONEID();
 
-				FriendData requesteeFriendData{};
-				requesteeFriendData.friendID = requestor->playerID;
-				requesteeFriendData.friendName = requestor->playerName;
-				requesteeFriendData.isFTP = false;
-				requesteeFriendData.isOnline = false;
-				requesteeFriendData.zoneID = requestor->zoneID;
-				requestee->friends.push_back(requesteeFriendData);
-				requestee->sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
-				break;
-			}
+			FriendData requesteeFriendData{};
+			requesteeFriendData.friendID = requestor.playerID;
+			requesteeFriendData.friendName = requestor.playerName;
+			requesteeFriendData.isFTP = false;
+			requesteeFriendData.isOnline = false;
+			requesteeFriendData.zoneID = requestor.zoneID;
+			requestee.friends.push_back(requesteeFriendData);
+			requestee.sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
+			break;
 		}
 	}
 
 	// If at this point we dont have a target, then they arent online and we cant send the request.
 	// Send the response code that corresponds to what the error is.
 	if (!requestee) {
-		requestee.reset(new PlayerData());
-		requestee->playerName = playerName;
+		requestee.playerName = playerName;
 		auto responseType = Database::Get()->GetCharacterInfo(playerName)
 			? eAddFriendResponseType::NOTONLINE
 			: eAddFriendResponseType::INVALIDCHARACTER;
 
-		SendFriendResponse(requestor, requestee.get(), responseType);
+		SendFriendResponse(requestor, requestee, responseType);
 		return;
 	}
 
@@ -147,7 +145,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 		uint8_t oldBestFriendStatus{};
 		uint8_t bestFriendStatus{};
-		auto bestFriendInfo = Database::Get()->GetBestFriendStatus(requestorPlayerID, requestee->playerID);
+		auto bestFriendInfo = Database::Get()->GetBestFriendStatus(requestorPlayerID, requestee.playerID);
 		if (bestFriendInfo) {
 			// Get the IDs
 			LWOOBJID queryPlayerID = bestFriendInfo->playerCharacterId;
@@ -174,51 +172,48 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		// Only do updates if there was a change in the bff status.
 		if (oldBestFriendStatus != bestFriendStatus) {
 			auto maxBestFriends = Game::playerContainer.GetMaxNumberOfBestFriends();
-			if (requestee->countOfBestFriends >= maxBestFriends || requestor->countOfBestFriends >= maxBestFriends) {
-				if (requestee->countOfBestFriends >= maxBestFriends) {
-					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
+			if (requestee.countOfBestFriends >= maxBestFriends || requestor.countOfBestFriends >= maxBestFriends) {
+				if (requestee.countOfBestFriends >= maxBestFriends) {
+					SendFriendResponse(requestor, requestee, eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
 				}
-				if (requestor->countOfBestFriends >= maxBestFriends) {
-					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
+				if (requestor.countOfBestFriends >= maxBestFriends) {
+					SendFriendResponse(requestor, requestee, eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
 				}
 			} else {
 				// Then update the database with this new info.
-				Database::Get()->SetBestFriendStatus(requestorPlayerID, requestee->playerID, bestFriendStatus);
+				Database::Get()->SetBestFriendStatus(requestorPlayerID, requestee.playerID, bestFriendStatus);
 				// Sent the best friend update here if the value is 3
 				if (bestFriendStatus == 3U) {
-					requestee->countOfBestFriends += 1;
-					requestor->countOfBestFriends += 1;
-					if (requestee->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee.get(), requestor, eAddFriendResponseType::ACCEPTED, false, true);
-					if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::ACCEPTED, false, true);
-					for (auto& friendData : requestor->friends) {
-						if (friendData.friendID == requestee->playerID) {
+					requestee.countOfBestFriends += 1;
+					requestor.countOfBestFriends += 1;
+					if (requestee.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestee, requestor, eAddFriendResponseType::ACCEPTED, false, true);
+					if (requestor.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee, eAddFriendResponseType::ACCEPTED, false, true);
+					for (auto& friendData : requestor.friends) {
+						if (friendData.friendID == requestee.playerID) {
 							friendData.isBestFriend = true;
 						}
 					}
-					for (auto& friendData : requestee->friends) {
-						if (friendData.friendID == requestor->playerID) {
+					for (auto& friendData : requestee.friends) {
+						if (friendData.friendID == requestor.playerID) {
 							friendData.isBestFriend = true;
 						}
 					}
 				}
 			}
 		} else {
-			if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::WAITINGAPPROVAL, true, true);
+			if (requestor.sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee, eAddFriendResponseType::WAITINGAPPROVAL, true, true);
 		}
 	} else {
 		auto maxFriends = Game::playerContainer.GetMaxNumberOfFriends();
-		if (requestee->friends.size() >= maxFriends) {
-			SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
-		} else if (requestor->friends.size() >= maxFriends) {
-			SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
+		if (requestee.friends.size() >= maxFriends) {
+			SendFriendResponse(requestor, requestee, eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
+		} else if (requestor.friends.size() >= maxFriends) {
+			SendFriendResponse(requestor, requestee, eAddFriendResponseType::YOURFRIENDSLISTFULL, false);
 		} else {
 			// Do not send this if we are requesting to be a best friend.
-			SendFriendRequest(requestee.get(), requestor);
+			SendFriendRequest(requestee, requestor);
 		}
 	}
-
-	// If the player is actually a player and not a ghost one defined above, release it from being deleted.
-	if (requestee->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) requestee.release();
 }
 
 void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
@@ -230,8 +225,8 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	std::string friendName = PacketUtils::ReadString(0x15, packet, true);
 
 	//Now to try and find both of these:
-	auto requestor = Game::playerContainer.GetPlayerData(playerID);
-	auto requestee = Game::playerContainer.GetPlayerData(friendName);
+	auto& requestor = Game::playerContainer.GetPlayerDataMutable(playerID);
+	auto& requestee = Game::playerContainer.GetPlayerDataMutable(friendName);
 	if (!requestor || !requestee) return;
 
 	eAddFriendResponseType serverResponseCode{};
@@ -254,8 +249,8 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 
 	// Now that we have handled the base cases, we need to check the other cases.
 	if (serverResponseCode == eAddFriendResponseType::ACCEPTED) {
-		for (auto friendData : requestor->friends) {
-			if (friendData.friendID == requestee->playerID) {
+		for (const auto& friendData : requestor.friends) {
+			if (friendData.friendID == requestee.playerID) {
 				serverResponseCode = eAddFriendResponseType::ALREADYFRIEND;
 				if (friendData.isBestFriend) {
 					isAlreadyBestFriends = 1U;
@@ -267,25 +262,23 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	// This message is NOT sent for best friends and is handled differently for those requests.
 	if (serverResponseCode == eAddFriendResponseType::ACCEPTED) {
 		// Add the each player to the others friend list.
-		FriendData requestorData;
-		requestorData.zoneID = requestor->zoneID;
-		requestorData.friendID = requestor->playerID;
-		requestorData.friendName = requestor->playerName;
+		auto& requestorData = requestee.friends.emplace_back();
+		requestorData.zoneID = requestor.zoneID;
+		requestorData.friendID = requestor.playerID;
+		requestorData.friendName = requestor.playerName;
 		requestorData.isBestFriend = false;
 		requestorData.isFTP = false;
 		requestorData.isOnline = true;
-		requestee->friends.push_back(requestorData);
 
-		FriendData requesteeData;
-		requesteeData.zoneID = requestee->zoneID;
-		requesteeData.friendID = requestee->playerID;
-		requesteeData.friendName = requestee->playerName;
+		auto& requesteeData = requestor.friends.emplace_back();
+		requesteeData.zoneID = requestee.zoneID;
+		requesteeData.friendID = requestee.playerID;
+		requesteeData.friendName = requestee.playerName;
 		requesteeData.isBestFriend = false;
 		requesteeData.isFTP = false;
 		requesteeData.isOnline = true;
-		requestor->friends.push_back(requesteeData);
 
-		Database::Get()->AddFriend(requestor->playerID, requestee->playerID);
+		Database::Get()->AddFriend(requestor.playerID, requestee.playerID);
 	}
 
 	if (serverResponseCode != eAddFriendResponseType::DECLINED) SendFriendResponse(requestor, requestee, serverResponseCode, isAlreadyBestFriends);
@@ -313,26 +306,27 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 	Database::Get()->RemoveFriend(playerID, friendID);
 
 	//Now, we need to send an update to notify the sender (and possibly, receiver) that their friendship has been ended:
-	auto goonA = Game::playerContainer.GetPlayerData(playerID);
+	auto& goonA = Game::playerContainer.GetPlayerDataMutable(playerID);
 	if (goonA) {
 		// Remove the friend from our list of friends
-		for (auto friendData = goonA->friends.begin(); friendData != goonA->friends.end(); friendData++) {
-			if ((*friendData).friendID == friendID) {
-				if ((*friendData).isBestFriend) --goonA->countOfBestFriends;
-				goonA->friends.erase(friendData);
+		for (auto friendData = goonA.friends.cbegin(); friendData != goonA.friends.cend(); friendData++) {
+			if (friendData->friendID == friendID) {
+				if (friendData->isBestFriend) --goonA.countOfBestFriends;
+				goonA.friends.erase(friendData);
 				break;
 			}
 		}
 		SendRemoveFriend(goonA, friendName, true);
 	}
 
-	auto goonB = Game::playerContainer.GetPlayerData(friendID);
+	auto& goonB = Game::playerContainer.GetPlayerDataMutable(friendID);
 	if (!goonB) return;
+
 	// Do it again for other person
-	for (auto friendData = goonB->friends.begin(); friendData != goonB->friends.end(); friendData++) {
-		if ((*friendData).friendID == playerID) {
-			if ((*friendData).isBestFriend) --goonB->countOfBestFriends;
-			goonB->friends.erase(friendData);
+	for (auto friendData = goonB.friends.cbegin(); friendData != goonB.friends.cend(); friendData++) {
+		if (friendData->friendID == playerID) {
+			if (friendData->isBestFriend) --goonB.countOfBestFriends;
+			goonB.friends.erase(friendData);
 			break;
 		}
 	}
@@ -346,13 +340,11 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
 
-	auto* sender = Game::playerContainer.GetPlayerData(playerID);
+	const auto& sender = Game::playerContainer.GetPlayerData(playerID);
 
-	if (sender == nullptr) return;
+	if (!sender) return;
 
-	if (Game::playerContainer.GetIsMuted(sender)) return;
-
-	const auto senderName = std::string(sender->playerName.c_str());
+	if (sender.GetIsMuted()) return;
 
 	inStream.SetReadOffset(0x14 * 8);
 
@@ -361,7 +353,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());
+	LOG("Got a message from (%s) [%d]: %s", sender.playerName.c_str(), channel, message.c_str());
 
 	if (channel != 8) return;
 
@@ -370,30 +362,28 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 	if (team == nullptr) return;
 
 	for (const auto memberId : team->memberIDs) {
-		auto* otherMember = Game::playerContainer.GetPlayerData(memberId);
+		const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
 
-		if (otherMember == nullptr) return;
-
-		const auto otherName = std::string(otherMember->playerName.c_str());
+		if (!otherMember) return;
 
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-		bitStream.Write(otherMember->playerID);
+		bitStream.Write(otherMember.playerID);
 
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
-		bitStream.Write(otherMember->playerID);
+		bitStream.Write(otherMember.playerID);
 		bitStream.Write<uint8_t>(8);
 		bitStream.Write<unsigned int>(69);
-		bitStream.Write(LUWString(senderName));
-		bitStream.Write(sender->playerID);
+		bitStream.Write(LUWString(sender.playerName));
+		bitStream.Write(sender.playerID);
 		bitStream.Write<uint16_t>(0);
 		bitStream.Write<uint8_t>(0); //not mythran nametag
-		bitStream.Write(LUWString(otherName));
+		bitStream.Write(LUWString(otherMember.playerName));
 		bitStream.Write<uint8_t>(0); //not mythran for receiver
 		bitStream.Write<uint8_t>(0); //teams?
 		bitStream.Write(LUWString(message, 512));
 
-		SystemAddress sysAddr = otherMember->sysAddr;
+		SystemAddress sysAddr = otherMember.sysAddr;
 		SEND_PACKET;
 	}
 }
@@ -404,35 +394,32 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	std::string message = PacketUtils::ReadString(0xAA, packet, true, 512);
 
 	//Get the bois:
-	auto goonA = Game::playerContainer.GetPlayerData(senderID);
-	auto goonB = Game::playerContainer.GetPlayerData(receiverName);
+	const auto& goonA = Game::playerContainer.GetPlayerData(senderID);
+	const auto& goonB = Game::playerContainer.GetPlayerData(receiverName);
 	if (!goonA || !goonB) return;
 
-	if (Game::playerContainer.GetIsMuted(goonA)) return;
-
-	std::string goonAName = goonA->playerName.c_str();
-	std::string goonBName = goonB->playerName.c_str();
+	if (goonA.GetIsMuted()) return;
 
 	//To the sender:
 	{
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-		bitStream.Write(goonA->playerID);
+		bitStream.Write(goonA.playerID);
 
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
-		bitStream.Write(goonA->playerID);
+		bitStream.Write(goonA.playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
-		bitStream.Write(LUWString(goonAName));
-		bitStream.Write(goonA->playerID);
+		bitStream.Write(LUWString(goonA.playerName));
+		bitStream.Write(goonA.playerID);
 		bitStream.Write<uint16_t>(0);
 		bitStream.Write<uint8_t>(0); //not mythran nametag
-		bitStream.Write(LUWString(goonBName));
+		bitStream.Write(LUWString(goonB.playerName));
 		bitStream.Write<uint8_t>(0); //not mythran for receiver
 		bitStream.Write<uint8_t>(0); //success
 		bitStream.Write(LUWString(message, 512));
 
-		SystemAddress sysAddr = goonA->sysAddr;
+		SystemAddress sysAddr = goonA.sysAddr;
 		SEND_PACKET;
 	}
 
@@ -440,22 +427,22 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	{
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-		bitStream.Write(goonB->playerID);
+		bitStream.Write(goonB.playerID);
 
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::PRIVATE_CHAT_MESSAGE);
-		bitStream.Write(goonA->playerID);
+		bitStream.Write(goonA.playerID);
 		bitStream.Write<uint8_t>(7);
 		bitStream.Write<unsigned int>(69);
-		bitStream.Write(LUWString(goonAName));
-		bitStream.Write(goonA->playerID);
+		bitStream.Write(LUWString(goonA.playerName));
+		bitStream.Write(goonA.playerID);
 		bitStream.Write<uint16_t>(0);
 		bitStream.Write<uint8_t>(0); //not mythran nametag
-		bitStream.Write(LUWString(goonBName));
+		bitStream.Write(LUWString(goonB.playerName));
 		bitStream.Write<uint8_t>(0); //not mythran for receiver
 		bitStream.Write<uint8_t>(3); //new whisper
 		bitStream.Write(LUWString(message, 512));
 
-		SystemAddress sysAddr = goonB->sysAddr;
+		SystemAddress sysAddr = goonB.sysAddr;
 		SEND_PACKET;
 	}
 }
@@ -466,11 +453,9 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
 	inStream.Read(playerID);
 	std::string invitedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
-	auto* player = Game::playerContainer.GetPlayerData(playerID);
+	const auto& player = Game::playerContainer.GetPlayerData(playerID);
 
-	if (player == nullptr) {
-		return;
-	}
+	if (!player) return;
 
 	auto* team = Game::playerContainer.GetTeam(playerID);
 
@@ -478,13 +463,11 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
 		team = Game::playerContainer.CreateTeam(playerID);
 	}
 
-	auto* other = Game::playerContainer.GetPlayerData(invitedPlayer);
+	const auto& other = Game::playerContainer.GetPlayerData(invitedPlayer);
 
-	if (other == nullptr) {
-		return;
-	}
+	if (!other) return;
 
-	if (Game::playerContainer.GetTeam(other->playerID) != nullptr) {
+	if (Game::playerContainer.GetTeam(other.playerID) != nullptr) {
 		return;
 	}
 
@@ -558,12 +541,12 @@ void ChatPacketHandler::HandleTeamKick(Packet* packet) {
 
 	LOG("(%llu) kicking (%s) from team", playerID, kickedPlayer.c_str());
 
-	auto* kicked = Game::playerContainer.GetPlayerData(kickedPlayer);
+	const auto& kicked = Game::playerContainer.GetPlayerData(kickedPlayer);
 
 	LWOOBJID kickedId = LWOOBJID_EMPTY;
 
-	if (kicked != nullptr) {
-		kickedId = kicked->playerID;
+	if (kicked) {
+		kickedId = kicked.playerID;
 	} else {
 		kickedId = Game::playerContainer.GetId(GeneralUtils::UTF8ToUTF16(kickedPlayer));
 	}
@@ -588,16 +571,16 @@ void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
 
 	LOG("(%llu) promoting (%s) to team leader", playerID, promotedPlayer.c_str());
 
-	auto* promoted = Game::playerContainer.GetPlayerData(promotedPlayer);
+	const auto& promoted = Game::playerContainer.GetPlayerData(promotedPlayer);
 
-	if (promoted == nullptr) return;
+	if (!promoted) return;
 
 	auto* team = Game::playerContainer.GetTeam(playerID);
 
 	if (team != nullptr) {
 		if (team->leaderID != playerID) return;
 
-		Game::playerContainer.PromoteMember(team, promoted->playerID);
+		Game::playerContainer.PromoteMember(team, promoted.playerID);
 	}
 }
 
@@ -630,10 +613,10 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 	inStream.Read(playerID);
 
 	auto* team = Game::playerContainer.GetTeam(playerID);
-	auto* data = Game::playerContainer.GetPlayerData(playerID);
+	const auto& data = Game::playerContainer.GetPlayerData(playerID);
 
-	if (team != nullptr && data != nullptr) {
-		if (team->local && data->zoneID.GetMapID() != team->zoneId.GetMapID() && data->zoneID.GetCloneID() != team->zoneId.GetCloneID()) {
+	if (team != nullptr && data) {
+		if (team->local && data.zoneID.GetMapID() != team->zoneId.GetMapID() && data.zoneID.GetCloneID() != team->zoneId.GetCloneID()) {
 			Game::playerContainer.RemoveMember(team, playerID, false, false, true, true);
 
 			return;
@@ -653,49 +636,49 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 
 		Game::playerContainer.TeamStatusUpdate(team);
 
-		const auto leaderName = GeneralUtils::UTF8ToUTF16(data->playerName);
+		const auto leaderName = GeneralUtils::UTF8ToUTF16(data.playerName);
 
 		for (const auto memberId : team->memberIDs) {
-			auto* otherMember = Game::playerContainer.GetPlayerData(memberId);
+			const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
 
 			if (memberId == playerID) continue;
 
 			const auto memberName = Game::playerContainer.GetName(memberId);
 
-			if (otherMember != nullptr) {
-				ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, data->playerID, data->zoneID);
+			if (otherMember) {
+				ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, data.playerID, data.zoneID);
 			}
-			ChatPacketHandler::SendTeamAddPlayer(data, false, team->local, false, memberId, memberName, otherMember != nullptr ? otherMember->zoneID : LWOZONEID(0, 0, 0));
+			ChatPacketHandler::SendTeamAddPlayer(data, false, team->local, false, memberId, memberName, otherMember ? otherMember.zoneID : LWOZONEID(0, 0, 0));
 		}
 
 		Game::playerContainer.UpdateTeamsOnWorld(team, false);
 	}
 }
 
-void ChatPacketHandler::SendTeamInvite(PlayerData* receiver, PlayerData* sender) {
+void ChatPacketHandler::SendTeamInvite(const PlayerData& receiver, const PlayerData& sender) {
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TEAM_INVITE);
 
-	bitStream.Write(LUWString(sender->playerName.c_str()));
-	bitStream.Write(sender->playerID);
+	bitStream.Write(LUWString(sender.playerName.c_str()));
+	bitStream.Write(sender.playerID);
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName) {
+void ChatPacketHandler::SendTeamInviteConfirm(const 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);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 	bitStream.Write(eGameMessageType::TEAM_INVITE_CONFIRM);
 
 	bitStream.Write(bLeaderIsFreeTrial);
@@ -710,19 +693,19 @@ void ChatPacketHandler::SendTeamInviteConfirm(PlayerData* receiver, bool bLeader
 		bitStream.Write(character);
 	}
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName) {
+void ChatPacketHandler::SendTeamStatus(const 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);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 	bitStream.Write(eGameMessageType::TEAM_GET_STATUS_RESPONSE);
 
 	bitStream.Write(i64LeaderID);
@@ -735,36 +718,36 @@ void ChatPacketHandler::SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderI
 		bitStream.Write(character);
 	}
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID) {
+void ChatPacketHandler::SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID) {
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 	bitStream.Write(eGameMessageType::TEAM_SET_LEADER);
 
 	bitStream.Write(i64PlayerID);
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID) {
+void ChatPacketHandler::SendTeamAddPlayer(const 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);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 	bitStream.Write(eGameMessageType::TEAM_ADD_PLAYER);
 
 	bitStream.Write(bIsFreeTrial);
@@ -776,24 +759,24 @@ void ChatPacketHandler::SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTria
 		bitStream.Write(character);
 	}
 	bitStream.Write1();
-	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID()) {
+	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
 		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
 	}
 	bitStream.Write(zoneID);
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName) {
+void ChatPacketHandler::SendTeamRemovePlayer(const 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);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 	bitStream.Write(eGameMessageType::TEAM_REMOVE_PLAYER);
 
 	bitStream.Write(bDisband);
@@ -807,32 +790,32 @@ void ChatPacketHandler::SendTeamRemovePlayer(PlayerData* receiver, bool bDisband
 		bitStream.Write(character);
 	}
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
+void ChatPacketHandler::SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID) {
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	CMSGHEADER;
 
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 	bitStream.Write(eGameMessageType::TEAM_SET_OFF_WORLD_FLAG);
 
 	bitStream.Write(i64PlayerID);
-	if (receiver->zoneID.GetCloneID() == zoneID.GetCloneID()) {
+	if (receiver.zoneID.GetCloneID() == zoneID.GetCloneID()) {
 		zoneID = LWOZONEID(zoneID.GetMapID(), zoneID.GetInstanceID(), 0);
 	}
 	bitStream.Write(zoneID);
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* playerData, uint8_t notifyType, uint8_t isBestFriend) {
+void ChatPacketHandler::SendFriendUpdate(const PlayerData& friendData, const PlayerData& playerData, uint8_t notifyType, uint8_t isBestFriend) {
 	/*chat notification is displayed if log in / out and friend is updated in friends list
 		[u8] - update type
 		Update types
@@ -848,38 +831,36 @@ void ChatPacketHandler::SendFriendUpdate(PlayerData* friendData, PlayerData* pla
 
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(friendData->playerID);
+	bitStream.Write(friendData.playerID);
 
 	//portion that will get routed:
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::UPDATE_FRIEND_NOTIFY);
 	bitStream.Write<uint8_t>(notifyType);
 
-	std::string playerName = playerData->playerName.c_str();
+	std::string playerName = playerData.playerName.c_str();
 
 	bitStream.Write(LUWString(playerName));
 
-	bitStream.Write(playerData->zoneID.GetMapID());
-	bitStream.Write(playerData->zoneID.GetInstanceID());
+	bitStream.Write(playerData.zoneID.GetMapID());
+	bitStream.Write(playerData.zoneID.GetInstanceID());
 
-	if (playerData->zoneID.GetCloneID() == friendData->zoneID.GetCloneID()) {
+	if (playerData.zoneID.GetCloneID() == friendData.zoneID.GetCloneID()) {
 		bitStream.Write(0);
 	} else {
-		bitStream.Write(playerData->zoneID.GetCloneID());
+		bitStream.Write(playerData.zoneID.GetCloneID());
 	}
 
 	bitStream.Write<uint8_t>(isBestFriend); //isBFF
 	bitStream.Write<uint8_t>(0); //isFTP
 
-	SystemAddress sysAddr = friendData->sysAddr;
+	SystemAddress sysAddr = friendData.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* sender) {
-	if (!receiver || !sender) return;
-
+void ChatPacketHandler::SendFriendRequest(const PlayerData& receiver, const PlayerData& sender) {
 	//Make sure people aren't requesting people that they're already friends with:
-	for (auto fr : receiver->friends) {
-		if (fr.friendID == sender->playerID) {
+	for (const auto& fr : receiver.friends) {
+		if (fr.friendID == sender.playerID) {
 			SendFriendResponse(sender, receiver, eAddFriendResponseType::ALREADYFRIEND, fr.isBestFriend);
 			return; //we have this player as a friend, yeet this function so it doesn't send another request.
 		}
@@ -887,54 +868,50 @@ void ChatPacketHandler::SendFriendRequest(PlayerData* receiver, PlayerData* send
 
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(receiver->playerID);
+	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()));
+	bitStream.Write(LUWString(sender.playerName));
 	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;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendFriendResponse(PlayerData* receiver, PlayerData* sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
-	if (!receiver || !sender) return;
-
+void ChatPacketHandler::SendFriendResponse(const PlayerData& receiver, const PlayerData& sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready, uint8_t isBestFriendRequest) {
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	// Portion that will get routed:
 	BitStreamUtils::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);
+	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()));
+	bitStream.Write(LUWString(sender.playerName));
 	// Then if this is an acceptance code, write the following extra info.
 	if (responseCode == eAddFriendResponseType::ACCEPTED) {
-		bitStream.Write(sender->playerID);
-		bitStream.Write(sender->zoneID);
+		bitStream.Write(sender.playerID);
+		bitStream.Write(sender.zoneID);
 		bitStream.Write(isBestFriendRequest); //isBFF
 		bitStream.Write<uint8_t>(0); //isFTP
 	}
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }
 
-void ChatPacketHandler::SendRemoveFriend(PlayerData* receiver, std::string& personToRemove, bool isSuccessful) {
-	if (!receiver) return;
-
+void ChatPacketHandler::SendRemoveFriend(const PlayerData& receiver, std::string& personToRemove, bool isSuccessful) {
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT_INTERNAL, eChatInternalMessageType::ROUTE_TO_PLAYER);
-	bitStream.Write(receiver->playerID);
+	bitStream.Write(receiver.playerID);
 
 	//portion that will get routed:
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::REMOVE_FRIEND_RESPONSE);
 	bitStream.Write<uint8_t>(isSuccessful); //isOnline
 	bitStream.Write(LUWString(personToRemove));
 
-	SystemAddress sysAddr = receiver->sysAddr;
+	SystemAddress sysAddr = receiver.sysAddr;
 	SEND_PACKET;
 }

dChatServer/ChatPacketHandler.h

@@ -4,6 +4,7 @@
 #include "BitStream.h"
 
 struct PlayerData;
+
 enum class eAddFriendResponseType : uint8_t;
 
 namespace ChatPacketHandler {
@@ -23,18 +24,18 @@ namespace ChatPacketHandler {
 	void HandleTeamLootOption(Packet* packet);
 	void HandleTeamStatusRequest(Packet* packet);
 
-	void SendTeamInvite(PlayerData* receiver, PlayerData* sender);
-	void SendTeamInviteConfirm(PlayerData* receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName);
-	void SendTeamStatus(PlayerData* receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName);
-	void SendTeamSetLeader(PlayerData* receiver, LWOOBJID i64PlayerID);
-	void SendTeamAddPlayer(PlayerData* receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID);
-	void SendTeamRemovePlayer(PlayerData* receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName);
-	void SendTeamSetOffWorldFlag(PlayerData* receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID);
+	void SendTeamInvite(const PlayerData& receiver, const PlayerData& sender);
+	void SendTeamInviteConfirm(const PlayerData& receiver, bool bLeaderIsFreeTrial, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, uint8_t ucResponseCode, std::u16string wsLeaderName);
+	void SendTeamStatus(const PlayerData& receiver, LWOOBJID i64LeaderID, LWOZONEID i64LeaderZoneID, uint8_t ucLootFlag, uint8_t ucNumOfOtherPlayers, std::u16string wsLeaderName);
+	void SendTeamSetLeader(const PlayerData& receiver, LWOOBJID i64PlayerID);
+	void SendTeamAddPlayer(const PlayerData& receiver, bool bIsFreeTrial, bool bLocal, bool bNoLootOnDeath, LWOOBJID i64PlayerID, std::u16string wsPlayerName, LWOZONEID zoneID);
+	void SendTeamRemovePlayer(const PlayerData& receiver, bool bDisband, bool bIsKicked, bool bIsLeaving, bool bLocal, LWOOBJID i64LeaderID, LWOOBJID i64PlayerID, std::u16string wsPlayerName);
+	void SendTeamSetOffWorldFlag(const PlayerData& receiver, LWOOBJID i64PlayerID, LWOZONEID zoneID);
 
 	//FriendData is the player we're SENDING this stuff to. Player is the friend that changed state.
-	void SendFriendUpdate(PlayerData* friendData, PlayerData* playerData, uint8_t notifyType, uint8_t isBestFriend);
+	void SendFriendUpdate(const PlayerData& friendData, const PlayerData& playerData, uint8_t notifyType, uint8_t isBestFriend);
 
-	void SendFriendRequest(PlayerData* receiver, PlayerData* sender);
-	void SendFriendResponse(PlayerData* receiver, PlayerData* sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready = 0U, uint8_t isBestFriendRequest = 0U);
-	void SendRemoveFriend(PlayerData* receiver, std::string& personToRemove, bool isSuccessful);
+	void SendFriendRequest(const PlayerData& receiver, const PlayerData& sender);
+	void SendFriendResponse(const PlayerData& receiver, const PlayerData& sender, eAddFriendResponseType responseCode, uint8_t isBestFriendsAlready = 0U, uint8_t isBestFriendRequest = 0U);
+	void SendRemoveFriend(const PlayerData& receiver, std::string& personToRemove, bool isSuccessful);
 };

dChatServer/ChatServer.cpp

@@ -22,6 +22,7 @@
 #include "ChatIgnoreList.h"
 
 #include "Game.h"
+#include "Server.h"
 
 //RakNet includes:
 #include "RakNetDefines.h"
@@ -38,7 +39,6 @@ namespace Game {
 	PlayerContainer playerContainer;
 }
 
-Logger* SetupLogger();
 void HandlePacket(Packet* packet);
 
 int main(int argc, char** argv) {
@@ -51,14 +51,13 @@ int main(int argc, char** argv) {
 	std::signal(SIGINT, Game::OnSignal);
 	std::signal(SIGTERM, Game::OnSignal);
 
+	Game::config = new dConfig("chatconfig.ini");
+
 	//Create all the objects we need to run our service:
-	Game::logger = SetupLogger();
+	Server::SetupLogger("ChatServer");
 	if (!Game::logger) return EXIT_FAILURE;
 
 	//Read our config:
-	Game::config = new dConfig("chatconfig.ini");
-	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: %s", PROJECT_VERSION);
@@ -182,18 +181,6 @@ int main(int argc, char** argv) {
 	return EXIT_SUCCESS;
 }
 
-Logger* SetupLogger() {
-	std::string logPath = (BinaryPathFinder::GetBinaryDir() / ("logs/ChatServer_" + std::to_string(time(nullptr)) + ".log")).string();
-	bool logToConsole = false;
-	bool logDebugStatements = false;
-#ifdef _DEBUG
-	logToConsole = true;
-	logDebugStatements = true;
-#endif
-
-	return new Logger(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.");

dChatServer/PlayerContainer.cpp

@@ -28,27 +28,32 @@ TeamData::TeamData() {
 
 void PlayerContainer::InsertPlayer(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	PlayerData* data = new PlayerData();
-	inStream.Read(data->playerID);
+	LWOOBJID playerId;
+	if (!inStream.Read(playerId)) {
+		LOG("Failed to read player ID");
+		return;
+	}
+
+	auto& data = m_Players[playerId];
+	data.playerID = playerId;
 
 	uint32_t len;
 	inStream.Read<uint32_t>(len);
 
 	for (int i = 0; i < len; i++) {
 		char character; inStream.Read<char>(character);
-		data->playerName += character;
+		data.playerName += character;
 	}
 
-	inStream.Read(data->zoneID);
-	inStream.Read(data->muteExpire);
-	data->sysAddr = packet->systemAddress;
+	inStream.Read(data.zoneID);
+	inStream.Read(data.muteExpire);
+	data.sysAddr = packet->systemAddress;
 
-	m_Names[data->playerID] = GeneralUtils::UTF8ToUTF16(data->playerName);
+	m_Names[data.playerID] = GeneralUtils::UTF8ToUTF16(data.playerName);
 
-	m_Players.insert(std::make_pair(data->playerID, data));
-	LOG("Added user: %s (%llu), zone: %i", data->playerName.c_str(), data->playerID, data->zoneID.GetMapID());
+	LOG("Added user: %s (%llu), zone: %i", data.playerName.c_str(), data.playerID, data.zoneID.GetMapID());
 
-	Database::Get()->UpdateActivityLog(data->playerID, eActivityType::PlayerLoggedIn, data->zoneID.GetMapID());
+	Database::Get()->UpdateActivityLog(data.playerID, eActivityType::PlayerLoggedIn, data.zoneID.GetMapID());
 }
 
 void PlayerContainer::RemovePlayer(Packet* packet) {
@@ -57,26 +62,27 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 	inStream.Read(playerID);
 
 	//Before they get kicked, we need to also send a message to their friends saying that they disconnected.
-	std::unique_ptr<PlayerData> player(this->GetPlayerData(playerID));
+	const auto& player = GetPlayerData(playerID);
 
-	if (player == nullptr) {
+	if (!player) {
+		LOG("Failed to find user: %llu", playerID);
 		return;
 	}
 
-	for (auto& fr : player->friends) {
-		auto fd = this->GetPlayerData(fr.friendID);
-		if (fd) ChatPacketHandler::SendFriendUpdate(fd, player.get(), 0, fr.isBestFriend);
+	for (const auto& fr : player.friends) {
+		const auto& fd = this->GetPlayerData(fr.friendID);
+		if (fd) ChatPacketHandler::SendFriendUpdate(fd, player, 0, fr.isBestFriend);
 	}
 
 	auto* team = GetTeam(playerID);
 
 	if (team != nullptr) {
-		const auto memberName = GeneralUtils::UTF8ToUTF16(std::string(player->playerName.c_str()));
+		const auto memberName = GeneralUtils::UTF8ToUTF16(player.playerName);
 
 		for (const auto memberId : team->memberIDs) {
-			auto* otherMember = GetPlayerData(memberId);
+			const auto& otherMember = GetPlayerData(memberId);
 
-			if (otherMember == nullptr) continue;
+			if (!otherMember) continue;
 
 			ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, playerID, { 0, 0, 0 });
 		}
@@ -85,7 +91,7 @@ void PlayerContainer::RemovePlayer(Packet* packet) {
 	LOG("Removed user: %llu", playerID);
 	m_Players.erase(playerID);
 
-	Database::Get()->UpdateActivityLog(playerID, eActivityType::PlayerLoggedOut, player->zoneID.GetMapID());
+	Database::Get()->UpdateActivityLog(playerID, eActivityType::PlayerLoggedOut, player.zoneID.GetMapID());
 }
 
 void PlayerContainer::MuteUpdate(Packet* packet) {
@@ -95,15 +101,15 @@ void PlayerContainer::MuteUpdate(Packet* packet) {
 	time_t expire = 0;
 	inStream.Read(expire);
 
-	auto* player = this->GetPlayerData(playerID);
+	auto& player = this->GetPlayerDataMutable(playerID);
 
-	if (player == nullptr) {
+	if (!player) {
 		LOG("Failed to find user: %llu", playerID);
 
 		return;
 	}
 
-	player->muteExpire = expire;
+	player.muteExpire = expire;
 
 	BroadcastMuteUpdate(playerID, expire);
 }
@@ -201,11 +207,11 @@ TeamData* PlayerContainer::GetTeam(LWOOBJID playerID) {
 }
 
 void PlayerContainer::AddMember(TeamData* team, LWOOBJID playerID) {
-	if (team->memberIDs.size() >= 4){
+	if (team->memberIDs.size() >= 4) {
 		LOG("Tried to add player to team that already had 4 players");
-		auto* player = GetPlayerData(playerID);
+		const auto& player = GetPlayerData(playerID);
 		if (!player) return;
-		ChatPackets::SendSystemMessage(player->sysAddr, u"The teams is full! You have not been added to a team!");
+		ChatPackets::SendSystemMessage(player.sysAddr, u"The teams is full! You have not been added to a team!");
 		return;
 	}
 
@@ -215,18 +221,18 @@ void PlayerContainer::AddMember(TeamData* team, LWOOBJID playerID) {
 
 	team->memberIDs.push_back(playerID);
 
-	auto* leader = GetPlayerData(team->leaderID);
-	auto* member = GetPlayerData(playerID);
+	const auto& leader = GetPlayerData(team->leaderID);
+	const auto& member = GetPlayerData(playerID);
 
-	if (leader == nullptr || member == nullptr) return;
+	if (!leader || !member) return;
 
-	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader->playerName);
-	const auto memberName = GeneralUtils::UTF8ToUTF16(member->playerName);
+	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader.playerName);
+	const auto memberName = GeneralUtils::UTF8ToUTF16(member.playerName);
 
-	ChatPacketHandler::SendTeamInviteConfirm(member, false, leader->playerID, leader->zoneID, team->lootFlag, 0, 0, leaderName);
+	ChatPacketHandler::SendTeamInviteConfirm(member, false, leader.playerID, leader.zoneID, team->lootFlag, 0, 0, leaderName);
 
 	if (!team->local) {
-		ChatPacketHandler::SendTeamSetLeader(member, leader->playerID);
+		ChatPacketHandler::SendTeamSetLeader(member, leader.playerID);
 	} else {
 		ChatPacketHandler::SendTeamSetLeader(member, LWOOBJID_EMPTY);
 	}
@@ -234,16 +240,16 @@ void PlayerContainer::AddMember(TeamData* team, LWOOBJID playerID) {
 	UpdateTeamsOnWorld(team, false);
 
 	for (const auto memberId : team->memberIDs) {
-		auto* otherMember = GetPlayerData(memberId);
+		const auto& otherMember = GetPlayerData(memberId);
 
 		if (otherMember == member) continue;
 
 		const auto otherMemberName = GetName(memberId);
 
-		ChatPacketHandler::SendTeamAddPlayer(member, false, team->local, false, memberId, otherMemberName, otherMember != nullptr ? otherMember->zoneID : LWOZONEID(0, 0, 0));
+		ChatPacketHandler::SendTeamAddPlayer(member, false, team->local, false, memberId, otherMemberName, otherMember ? otherMember.zoneID : LWOZONEID(0, 0, 0));
 
-		if (otherMember != nullptr) {
-			ChatPacketHandler::SendTeamAddPlayer(otherMember, false, team->local, false, member->playerID, memberName, member->zoneID);
+		if (otherMember) {
+			ChatPacketHandler::SendTeamAddPlayer(otherMember, false, team->local, false, member.playerID, memberName, member.zoneID);
 		}
 	}
 }
@@ -253,9 +259,9 @@ void PlayerContainer::RemoveMember(TeamData* team, LWOOBJID playerID, bool disba
 
 	if (index == team->memberIDs.end()) return;
 
-	auto* member = GetPlayerData(playerID);
+	const auto& member = GetPlayerData(playerID);
 
-	if (member != nullptr && !silent) {
+	if (member && !silent) {
 		ChatPacketHandler::SendTeamSetLeader(member, LWOOBJID_EMPTY);
 	}
 
@@ -266,9 +272,9 @@ void PlayerContainer::RemoveMember(TeamData* team, LWOOBJID playerID, bool disba
 			continue;
 		}
 
-		auto* otherMember = GetPlayerData(memberId);
+		const auto& otherMember = GetPlayerData(memberId);
 
-		if (otherMember == nullptr) continue;
+		if (!otherMember) continue;
 
 		ChatPacketHandler::SendTeamRemovePlayer(otherMember, disband, kicked, leaving, false, team->leaderID, playerID, memberName);
 	}
@@ -290,9 +296,9 @@ void PlayerContainer::PromoteMember(TeamData* team, LWOOBJID newLeader) {
 	team->leaderID = newLeader;
 
 	for (const auto memberId : team->memberIDs) {
-		auto* otherMember = GetPlayerData(memberId);
+		const auto& otherMember = GetPlayerData(memberId);
 
-		if (otherMember == nullptr) continue;
+		if (!otherMember) continue;
 
 		ChatPacketHandler::SendTeamSetLeader(otherMember, newLeader);
 	}
@@ -304,14 +310,14 @@ void PlayerContainer::DisbandTeam(TeamData* team) {
 	if (index == mTeams.end()) return;
 
 	for (const auto memberId : team->memberIDs) {
-		auto* otherMember = GetPlayerData(memberId);
+		const auto& otherMember = GetPlayerData(memberId);
 
-		if (otherMember == nullptr) continue;
+		if (!otherMember) continue;
 
-		const auto memberName = GeneralUtils::UTF8ToUTF16(otherMember->playerName);
+		const auto memberName = GeneralUtils::UTF8ToUTF16(otherMember.playerName);
 
 		ChatPacketHandler::SendTeamSetLeader(otherMember, LWOOBJID_EMPTY);
-		ChatPacketHandler::SendTeamRemovePlayer(otherMember, true, false, false, team->local, team->leaderID, otherMember->playerID, memberName);
+		ChatPacketHandler::SendTeamRemovePlayer(otherMember, true, false, false, team->local, team->leaderID, otherMember.playerID, memberName);
 	}
 
 	UpdateTeamsOnWorld(team, true);
@@ -326,19 +332,19 @@ void PlayerContainer::TeamStatusUpdate(TeamData* team) {
 
 	if (index == mTeams.end()) return;
 
-	auto* leader = GetPlayerData(team->leaderID);
+	const auto& leader = GetPlayerData(team->leaderID);
 
-	if (leader == nullptr) return;
+	if (!leader) return;
 
-	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader->playerName);
+	const auto leaderName = GeneralUtils::UTF8ToUTF16(leader.playerName);
 
 	for (const auto memberId : team->memberIDs) {
-		auto* otherMember = GetPlayerData(memberId);
+		const auto& otherMember = GetPlayerData(memberId);
 
-		if (otherMember == nullptr) continue;
+		if (!otherMember) continue;
 
 		if (!team->local) {
-			ChatPacketHandler::SendTeamStatus(otherMember, team->leaderID, leader->zoneID, team->lootFlag, 0, leaderName);
+			ChatPacketHandler::SendTeamStatus(otherMember, team->leaderID, leader.zoneID, team->lootFlag, 0, leaderName);
 		}
 	}
 
@@ -364,23 +370,42 @@ void PlayerContainer::UpdateTeamsOnWorld(TeamData* team, bool deleteTeam) {
 }
 
 std::u16string PlayerContainer::GetName(LWOOBJID playerID) {
-	const auto& pair = m_Names.find(playerID);
+	const auto iter = m_Names.find(playerID);
 
-	if (pair == m_Names.end()) return u"";
+	if (iter == m_Names.end()) return u"";
 
-	return pair->second;
+	return iter->second;
 }
 
 LWOOBJID PlayerContainer::GetId(const std::u16string& playerName) {
-	for (const auto& pair : m_Names) {
-		if (pair.second == playerName) {
-			return pair.first;
+	LWOOBJID toReturn = LWOOBJID_EMPTY;
+
+	for (const auto& [id, name] : m_Names) {
+		if (name == playerName) {
+			toReturn = id;
+			break;
 		}
 	}
 
-	return LWOOBJID_EMPTY;
+	return toReturn;
 }
 
-bool PlayerContainer::GetIsMuted(PlayerData* data) {
-	return data->muteExpire == 1 || data->muteExpire > time(NULL);
+PlayerData& PlayerContainer::GetPlayerDataMutable(const LWOOBJID& playerID) {
+	return m_Players[playerID];
+}
+
+PlayerData& PlayerContainer::GetPlayerDataMutable(const std::string& playerName) {
+	for (auto& [id, player] : m_Players) {
+		if (!player) continue;
+		if (player.playerName == playerName) return player;
+	}
+	return m_Players[LWOOBJID_EMPTY];
+}
+
+const PlayerData& PlayerContainer::GetPlayerData(const LWOOBJID& playerID) {
+	return GetPlayerDataMutable(playerID);
+}
+
+const PlayerData& PlayerContainer::GetPlayerData(const std::string& playerName) {
+	return GetPlayerDataMutable(playerName);
 }

dChatServer/PlayerContainer.h

@@ -8,6 +8,7 @@
 #include <unordered_map>
 
 struct IgnoreData {
+	IgnoreData(const std::string& name, const LWOOBJID& id) : playerName(name), playerId(id) {}
 	inline bool operator==(const std::string& other) const noexcept {
 		return playerName == other;
 	}
@@ -16,19 +17,31 @@ struct IgnoreData {
 		return playerId == other;
 	}
 
-	LWOOBJID playerId;
+	LWOOBJID playerId = LWOOBJID_EMPTY;
 	std::string playerName;
 };
 
 struct PlayerData {
-	LWOOBJID playerID;
+	operator bool() const noexcept {
+		return playerID != LWOOBJID_EMPTY;
+	}
+
+	bool operator==(const PlayerData& other) const noexcept {
+		return playerID == other.playerID;
+	}
+
+	bool GetIsMuted() const {
+		return muteExpire == 1 || muteExpire > time(NULL);
+	}
+
+	SystemAddress sysAddr{};
+	LWOZONEID zoneID{};
+	LWOOBJID playerID = LWOOBJID_EMPTY;
+	time_t muteExpire = 0;
+	uint8_t countOfBestFriends = 0;
 	std::string playerName;
-	SystemAddress sysAddr;
-	LWOZONEID zoneID;
 	std::vector<FriendData> friends;
 	std::vector<IgnoreData> ignoredPlayers;
-	time_t muteExpire;
-	uint8_t countOfBestFriends = 0;
 };
 
 struct TeamData {
@@ -52,22 +65,10 @@ public:
 	void CreateTeamServer(Packet* packet);
 	void BroadcastMuteUpdate(LWOOBJID player, time_t time);
 
-	PlayerData* GetPlayerData(const LWOOBJID& playerID) {
-		auto it = m_Players.find(playerID);
-		if (it != m_Players.end()) return it->second;
-		return nullptr;
-	}
-
-	PlayerData* GetPlayerData(const std::string& playerName) {
-		for (auto player : m_Players) {
-			if (player.second) {
-				std::string pn = player.second->playerName.c_str();
-				if (pn == playerName) return player.second;
-			}
-		}
-
-		return nullptr;
-	}
+	const PlayerData& GetPlayerData(const LWOOBJID& playerID);
+	const PlayerData& GetPlayerData(const std::string& playerName);
+	PlayerData& GetPlayerDataMutable(const LWOOBJID& playerID);
+	PlayerData& GetPlayerDataMutable(const std::string& playerName);
 
 	TeamData* CreateLocalTeam(std::vector<LWOOBJID> members);
 	TeamData* CreateTeam(LWOOBJID leader, bool local = false);
@@ -80,15 +81,12 @@ public:
 	void UpdateTeamsOnWorld(TeamData* team, bool deleteTeam);
 	std::u16string GetName(LWOOBJID playerID);
 	LWOOBJID GetId(const std::u16string& playerName);
-	bool GetIsMuted(PlayerData* data);
 	uint32_t GetMaxNumberOfBestFriends() { return m_MaxNumberOfBestFriends; }
 	uint32_t GetMaxNumberOfFriends() { return m_MaxNumberOfFriends; }
 
-	std::map<LWOOBJID, PlayerData*>& GetAllPlayerData() { return m_Players; }
-
 private:
 	LWOOBJID m_TeamIDCounter = 0;
-	std::map<LWOOBJID, PlayerData*> m_Players;
+	std::map<LWOOBJID, PlayerData> m_Players;
 	std::vector<TeamData*> mTeams;
 	std::unordered_map<LWOOBJID, std::u16string> m_Names;
 	uint32_t m_MaxNumberOfBestFriends = 5;

dCommon/PositionUpdate.h

@@ -0,0 +1,50 @@
+#ifndef __POSITIONUPDATE__H__
+#define __POSITIONUPDATE__H__
+
+#include "NiPoint3.h"
+#include "NiQuaternion.h"
+
+
+struct RemoteInputInfo {
+	RemoteInputInfo() {
+		m_RemoteInputX = 0;
+		m_RemoteInputY = 0;
+		m_IsPowersliding = false;
+		m_IsModified = false;
+	}
+
+	void operator=(const RemoteInputInfo& other) {
+		m_RemoteInputX = other.m_RemoteInputX;
+		m_RemoteInputY = other.m_RemoteInputY;
+		m_IsPowersliding = other.m_IsPowersliding;
+		m_IsModified = other.m_IsModified;
+	}
+
+	bool operator==(const RemoteInputInfo& other) {
+		return m_RemoteInputX == other.m_RemoteInputX && m_RemoteInputY == other.m_RemoteInputY && m_IsPowersliding == other.m_IsPowersliding && m_IsModified == other.m_IsModified;
+	}
+
+	float m_RemoteInputX;
+	float m_RemoteInputY;
+	bool m_IsPowersliding;
+	bool m_IsModified;
+};
+
+struct LocalSpaceInfo {
+	LWOOBJID objectId = LWOOBJID_EMPTY;
+	NiPoint3 position = NiPoint3::ZERO;
+	NiPoint3 linearVelocity = NiPoint3::ZERO;
+};
+
+struct PositionUpdate {
+	NiPoint3 position = NiPoint3::ZERO;
+	NiQuaternion rotation = NiQuaternion::IDENTITY;
+	bool onGround = false;
+	bool onRail = false;
+	NiPoint3 velocity = NiPoint3::ZERO;
+	NiPoint3 angularVelocity = NiPoint3::ZERO;
+	LocalSpaceInfo localSpaceInfo;
+	RemoteInputInfo remoteInputInfo;
+};
+
+#endif  //!__POSITIONUPDATE__H__

dCommon/dEnums/dCommonVars.h

@@ -130,7 +130,7 @@ public:
 	LWOOBJID friendID;
 	std::string friendName;
 
-	void Serialize(RakNet::BitStream& bitStream) {
+	void Serialize(RakNet::BitStream& bitStream) const {
 		bitStream.Write<uint8_t>(isOnline);
 		bitStream.Write<uint8_t>(isBestFriend);
 		bitStream.Write<uint8_t>(isFTP);

dCommon/dEnums/eGameMessageType.h

@@ -629,7 +629,7 @@ enum class eGameMessageType : uint16_t {
 	GET_INSTRUCTION_COUNT = 676,
 	GET_IS_NPC = 677,
 	ACTIVATE_BUBBLE_BUFF = 678,
-	DECTIVATE_BUBBLE_BUFF = 679, // thanks netdevil
+	DECTIVATE_BUBBLE_BUFF = 679, // This is spelled wrong in the client, so we misspell it here.
 	EXHIBIT_VOTE = 680,
 	ADD_PET_TO_PLAYER = 681,
 	REMOVE_PET_FROM_PLAYER = 682,

dCommon/dEnums/ePetAbilityType.h

@@ -0,0 +1,13 @@
+#ifndef __EPETABILITYTYPE__H__
+#define __EPETABILITYTYPE__H__
+
+#include <cstdint>
+
+enum class ePetAbilityType : uint32_t {
+	Invalid,
+	GoToObject,
+	JumpOnObject,
+	DigAtPosition
+};
+
+#endif  //!__EPETABILITYTYPE__H__

dDatabase/CDClientDatabase/CDClientDatabase.cpp

@@ -4,9 +4,13 @@
 // Static Variables
 static CppSQLite3DB* conn = new CppSQLite3DB();
 
+// Status Variables
+bool CDClientDatabase::isConnected = false;
+
 //! Opens a connection with the CDClient
 void CDClientDatabase::Connect(const std::string& filename) {
 	conn->open(filename.c_str());
+	isConnected = true;
 }
 
 //! Queries the CDClient

dDatabase/CDClientDatabase/CDClientDatabase.h

@@ -15,6 +15,10 @@
 
 //! The CDClient Database namespace
 namespace CDClientDatabase {
+	/**
+	 * Boolean defining the connection status of CDClient
+	*/
+	extern bool isConnected;
 
 	//! Opens a connection with the CDClient
 	/*!

dDatabase/CDClientDatabase/CDClientManager.cpp

@@ -3,6 +3,7 @@
 #include "CDAnimationsTable.h"
 #include "CDBehaviorParameterTable.h"
 #include "CDBehaviorTemplateTable.h"
+#include "CDClientDatabase.h"
 #include "CDComponentsRegistryTable.h"
 #include "CDCurrencyTableTable.h"
 #include "CDDestructibleComponentTable.h"
@@ -39,6 +40,8 @@
 #include "CDRailActivatorComponent.h"
 #include "CDRewardCodesTable.h"
 
+#include <exception>
+
 #ifndef CDCLIENT_CACHE_ALL
 // Uncomment this to cache the full cdclient database into memory. This will make the server load faster, but will use more memory.
 // A vanilla CDClient takes about 46MB of memory + the regular world data.
@@ -51,7 +54,16 @@
 	#define CDCLIENT_DONT_CACHE_TABLE(x)
 #endif
 
-CDClientManager::CDClientManager() {
+class CDClientConnectionException : public std::exception {
+public:
+	virtual const char* what() const throw() {
+		return "CDClientDatabase is not connected!";
+	}
+};
+
+void CDClientManager::LoadValuesFromDatabase() {
+	if (!CDClientDatabase::isConnected) throw CDClientConnectionException();
+
 	CDActivityRewardsTable::Instance().LoadValuesFromDatabase();
 	CDActivitiesTable::Instance().LoadValuesFromDatabase();
 	CDCLIENT_DONT_CACHE_TABLE(CDAnimationsTable::Instance().LoadValuesFromDatabase());
@@ -79,6 +91,7 @@ CDClientManager::CDClientManager() {
 	CDCLIENT_DONT_CACHE_TABLE(CDObjectsTable::Instance().LoadValuesFromDatabase());
 	CDPhysicsComponentTable::Instance().LoadValuesFromDatabase();
 	CDPackageComponentTable::Instance().LoadValuesFromDatabase();
+	CDPetComponentTable::Instance().LoadValuesFromDatabase();
 	CDProximityMonitorComponentTable::Instance().LoadValuesFromDatabase();
 	CDPropertyEntranceComponentTable::Instance().LoadValuesFromDatabase();
 	CDPropertyTemplateTable::Instance().LoadValuesFromDatabase();
@@ -92,3 +105,9 @@ CDClientManager::CDClientManager() {
 	CDVendorComponentTable::Instance().LoadValuesFromDatabase();
 	CDZoneTableTable::Instance().LoadValuesFromDatabase();
 }
+
+void CDClientManager::LoadValuesFromDefaults() {
+	LOG("Loading default CDClient tables!");
+
+	CDPetComponentTable::Instance().LoadValuesFromDefaults();
+}

dDatabase/CDClientDatabase/CDClientManager.h

@@ -11,7 +11,10 @@
  */
 class CDClientManager : public Singleton<CDClientManager> {
 public:
-	CDClientManager();
+	CDClientManager() = default;
+
+	void LoadValuesFromDatabase();
+	void LoadValuesFromDefaults();
 
 	/**
 	 * Fetch a table from CDClient

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.cpp

@@ -2,7 +2,7 @@
 
 void CDActivitiesTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Activities");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.h

@@ -4,22 +4,22 @@
 #include "CDTable.h"
 
 struct CDActivities {
-	unsigned int ActivityID;
-	unsigned int locStatus;
-	unsigned int instanceMapID;
-	unsigned int minTeams;
-	unsigned int maxTeams;
-	unsigned int minTeamSize;
-	unsigned int maxTeamSize;
-	unsigned int waitTime;
-	unsigned int startDelay;
+	uint32_t ActivityID;
+	uint32_t locStatus;
+	uint32_t instanceMapID;
+	uint32_t minTeams;
+	uint32_t maxTeams;
+	uint32_t minTeamSize;
+	uint32_t maxTeamSize;
+	uint32_t waitTime;
+	uint32_t startDelay;
 	bool requiresUniqueData;
-	unsigned int leaderboardType;
+	uint32_t leaderboardType;
 	bool localize;
-	int optionalCostLOT;
-	int optionalCostCount;
+	int32_t optionalCostLOT;
+	int32_t optionalCostCount;
 	bool showUIRewards;
-	unsigned int CommunityActivityFlagID;
+	uint32_t CommunityActivityFlagID;
 	std::string gate_version;
 	bool noTeamLootOnDeath;
 	float optionalPercentage;

dDatabase/CDClientDatabase/CDClientTables/CDActivityRewardsTable.cpp

@@ -3,7 +3,7 @@
 void CDActivityRewardsTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ActivityRewards");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDActivityRewardsTable.h

@@ -4,12 +4,12 @@
 #include "CDTable.h"
 
 struct CDActivityRewards {
-	unsigned int objectTemplate;        //!< The object template (?)
-	unsigned int ActivityRewardIndex;   //!< The activity reward index
-	int activityRating;                 //!< The activity rating
-	unsigned int LootMatrixIndex;       //!< The loot matrix index
-	unsigned int CurrencyIndex;         //!< The currency index
-	unsigned int ChallengeRating;       //!< The challenge rating
+	uint32_t objectTemplate;        //!< The object template (?)
+	uint32_t ActivityRewardIndex;   //!< The activity reward index
+	int32_t activityRating;                 //!< The activity rating
+	uint32_t LootMatrixIndex;       //!< The loot matrix index
+	uint32_t CurrencyIndex;         //!< The currency index
+	uint32_t ChallengeRating;       //!< The challenge rating
 	std::string description;            //!< The description
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDAnimationsTable.h

@@ -4,13 +4,13 @@
 #include <list>
 
 struct CDAnimation {
-	// unsigned int animationGroupID;
+	// uint32_t animationGroupID;
 	// std::string animation_type;
 	// The above two are a pair to represent a primary key in the map.
 	std::string animation_name;        //!< The animation name
 	float chance_to_play;           //!< The chance to play the animation
-	UNUSED_COLUMN(unsigned int min_loops;)                 //!< The minimum number of loops
-	UNUSED_COLUMN(unsigned int max_loops;)                 //!< The maximum number of loops
+	UNUSED_COLUMN(uint32_t min_loops;)                 //!< The minimum number of loops
+	UNUSED_COLUMN(uint32_t max_loops;)                 //!< The maximum number of loops
 	float animation_length;         //!< The animation length
 	UNUSED_COLUMN(bool hideEquip;)                 //!< Whether or not to hide the equip
 	UNUSED_COLUMN(bool ignoreUpperBody;)           //!< Whether or not to ignore the upper body

dDatabase/CDClientDatabase/CDClientTables/CDBehaviorTemplateTable.cpp

@@ -3,7 +3,7 @@
 void CDBehaviorTemplateTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM BehaviorTemplate");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDBehaviorTemplateTable.h

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

dDatabase/CDClientDatabase/CDClientTables/CDBrickIDTableTable.cpp

@@ -3,7 +3,7 @@
 void CDBrickIDTableTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM BrickIDTable");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDBrickIDTableTable.h

@@ -10,8 +10,8 @@
 
  //! BrickIDTable Entry Struct
 struct CDBrickIDTable {
-	unsigned int NDObjectID;
-	unsigned int LEGOBrickID;
+	uint32_t NDObjectID;
+	uint32_t LEGOBrickID;
 };
 
 

dDatabase/CDClientDatabase/CDClientTables/CDComponentsRegistryTable.h

@@ -7,9 +7,9 @@
 
 enum class eReplicaComponentType : uint32_t;
 struct CDComponentsRegistry {
-	unsigned int id;                    //!< The LOT is used as the ID
+	uint32_t id;                    //!< The LOT is used as the ID
 	eReplicaComponentType component_type;        //!< See ComponentTypes enum for values
-	unsigned int component_id;          //!< The ID used within the component's table (0 may either mean it's non-networked, or that the ID is actually 0
+	uint32_t component_id;          //!< The ID used within the component's table (0 may either mean it's non-networked, or that the ID is actually 0
 };
 
 

dDatabase/CDClientDatabase/CDClientTables/CDCurrencyTableTable.cpp

@@ -4,7 +4,7 @@
 void CDCurrencyTableTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM CurrencyTable");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDCurrencyTableTable.h

@@ -10,11 +10,11 @@
 
  //! CurrencyTable Struct
 struct CDCurrencyTable {
-	unsigned int currencyIndex;         //!< The Currency Index
-	unsigned int npcminlevel;           //!< The minimum level of the npc
-	unsigned int minvalue;              //!< The minimum currency
-	unsigned int maxvalue;              //!< The maximum currency
-	unsigned int id;                    //!< The ID of the currency index
+	uint32_t currencyIndex;         //!< The Currency Index
+	uint32_t npcminlevel;           //!< The minimum level of the npc
+	uint32_t minvalue;              //!< The minimum currency
+	uint32_t maxvalue;              //!< The maximum currency
+	uint32_t id;                    //!< The ID of the currency index
 };
 
 //! CurrencyTable table

dDatabase/CDClientDatabase/CDClientTables/CDDestructibleComponentTable.cpp

@@ -2,7 +2,7 @@
 
 void CDDestructibleComponentTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM DestructibleComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDDestructibleComponentTable.h

@@ -4,20 +4,20 @@
 #include "CDTable.h"
 
 struct CDDestructibleComponent {
-	unsigned int id;                            //!< The component ID from the ComponentsRegistry Table
-	int faction;                       //!< The Faction ID of the object
+	uint32_t id;                            //!< The component ID from the ComponentsRegistry Table
+	int32_t faction;                       //!< The Faction ID of the object
 	std::string factionList;               //!< A list of the faction IDs
-	int life;                          //!< The amount of life of the object
-	unsigned int imagination;                   //!< The amount of imagination of the object
-	int LootMatrixIndex;               //!< The Loot Matrix Index
-	int CurrencyIndex;                 //!< The Currency Index
-	unsigned int level;                         //!< ???
+	int32_t life;                          //!< The amount of life of the object
+	uint32_t imagination;                   //!< The amount of imagination of the object
+	int32_t LootMatrixIndex;               //!< The Loot Matrix Index
+	int32_t CurrencyIndex;                 //!< The Currency Index
+	uint32_t level;                         //!< ???
 	float armor;                        //!< The amount of armor of the object
-	unsigned int death_behavior;                //!< The behavior ID of the death behavior
+	uint32_t death_behavior;                //!< The behavior ID of the death behavior
 	bool isnpc;                         //!< Whether or not the object is an NPC
-	unsigned int attack_priority;               //!< ???
+	uint32_t attack_priority;               //!< ???
 	bool isSmashable;                   //!< Whether or not the object is smashable
-	int difficultyLevel;               //!< ???
+	int32_t difficultyLevel;               //!< ???
 };
 
 class CDDestructibleComponentTable : public CDTable<CDDestructibleComponentTable> {

dDatabase/CDClientDatabase/CDClientTables/CDEmoteTable.cpp

@@ -20,7 +20,7 @@ void CDEmoteTableTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
-CDEmoteTable* CDEmoteTableTable::GetEmote(int id) {
+CDEmoteTable* CDEmoteTableTable::GetEmote(int32_t id) {
 	auto itr = entries.find(id);
 	return itr != entries.end() ? &itr->second : nullptr;
 }

dDatabase/CDClientDatabase/CDClientTables/CDEmoteTable.h

@@ -16,11 +16,11 @@ struct CDEmoteTable {
 		gateVersion = "";
 	}
 
-	int ID;
+	int32_t ID;
 	std::string animationName;
 	std::string iconFilename;
-	int locState;
-	int channel;
+	int32_t locState;
+	int32_t channel;
 	bool locked;
 	bool localize;
 	std::string gateVersion;
@@ -33,5 +33,5 @@ private:
 public:
 	void LoadValuesFromDatabase();
 	// Returns an emote by ID
-	CDEmoteTable* GetEmote(int id);
+	CDEmoteTable* GetEmote(int32_t id);
 };

dDatabase/CDClientDatabase/CDClientTables/CDFeatureGatingTable.cpp

@@ -3,7 +3,7 @@
 void CDFeatureGatingTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM FeatureGating");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDInventoryComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDInventoryComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM InventoryComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDInventoryComponentTable.h

@@ -4,9 +4,9 @@
 #include "CDTable.h"
 
 struct CDInventoryComponent {
-	unsigned int id;                //!< The component ID for this object
-	unsigned int itemid;            //!< The LOT of the object
-	unsigned int count;             //!< The count of the items the object has
+	uint32_t id;                //!< The component ID for this object
+	uint32_t itemid;            //!< The LOT of the object
+	uint32_t count;             //!< The count of the items the object has
 	bool equip;             //!< Whether or not to equip the item
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDItemComponentTable.cpp

@@ -5,7 +5,7 @@ CDItemComponent CDItemComponentTable::Default = {};
 
 void CDItemComponentTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ItemComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);
@@ -69,7 +69,7 @@ void CDItemComponentTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
-const CDItemComponent& CDItemComponentTable::GetItemComponentByID(unsigned int skillID) {
+const CDItemComponent& CDItemComponentTable::GetItemComponentByID(uint32_t skillID) {
 	const auto& it = this->entries.find(skillID);
 	if (it != this->entries.end()) {
 		return it->second;

dDatabase/CDClientDatabase/CDClientTables/CDItemComponentTable.h

@@ -5,60 +5,60 @@
 #include "dCommonVars.h"
 
 struct CDItemComponent {
-	unsigned int id;                        //!< The Component ID
+	uint32_t id;                        //!< The Component ID
 	std::string equipLocation;         //!< The equip location
-	unsigned int baseValue;                 //!< The monetary base value of the item
+	uint32_t baseValue;                 //!< The monetary base value of the item
 	bool isKitPiece;                //!< Whether or not the item belongs to a kit
-	unsigned int rarity;                    //!< The rarity of the item
-	unsigned int itemType;                  //!< The item type
+	uint32_t rarity;                    //!< The rarity of the item
+	uint32_t itemType;                  //!< The item type
 	int64_t itemInfo;                  //!< The item info
 	bool inLootTable;               //!< Whether or not the item is in a loot table
 	bool inVendor;                  //!< Whether or not the item is in a vendor inventory
 	bool isUnique;                  //!< ???
 	bool isBOP;                     //!< ???
 	bool isBOE;                     //!< ???
-	unsigned int reqFlagID;                 //!< User must have completed this flag to get the item
-	unsigned int reqSpecialtyID;            //!< ???
-	unsigned int reqSpecRank;               //!< ???
-	unsigned int reqAchievementID;          //!< The required achievement must be completed
-	unsigned int stackSize;                 //!< The stack size of the item
-	unsigned int color1;                    //!< Something to do with item color...
-	unsigned int decal;                     //!< The decal of the item
-	unsigned int offsetGroupID;             //!< Something to do with group IDs
-	unsigned int buildTypes;                //!< Something to do with building
+	uint32_t reqFlagID;                 //!< User must have completed this flag to get the item
+	uint32_t reqSpecialtyID;            //!< ???
+	uint32_t reqSpecRank;               //!< ???
+	uint32_t reqAchievementID;          //!< The required achievement must be completed
+	uint32_t stackSize;                 //!< The stack size of the item
+	uint32_t color1;                    //!< Something to do with item color...
+	uint32_t decal;                     //!< The decal of the item
+	uint32_t offsetGroupID;             //!< Something to do with group IDs
+	uint32_t buildTypes;                //!< Something to do with building
 	std::string reqPrecondition;       //!< The required precondition
-	unsigned int animationFlag;             //!< The Animation Flag
-	unsigned int equipEffects;              //!< The effect played when the item is equipped
+	uint32_t animationFlag;             //!< The Animation Flag
+	uint32_t equipEffects;              //!< The effect played when the item is equipped
 	bool readyForQA;                //!< ???
-	unsigned int itemRating;                //!< ???
+	uint32_t itemRating;                //!< ???
 	bool isTwoHanded;               //!< Whether or not the item is double handed
-	unsigned int minNumRequired;            //!< Maybe the minimum number required for a mission, or to own this object?
-	unsigned int delResIndex;               //!< ???
-	unsigned int currencyLOT;               //!< ???
-	unsigned int altCurrencyCost;           //!< ???
+	uint32_t minNumRequired;            //!< Maybe the minimum number required for a mission, or to own this object?
+	uint32_t delResIndex;               //!< ???
+	uint32_t currencyLOT;               //!< ???
+	uint32_t altCurrencyCost;           //!< ???
 	std::string subItems;              //!< A comma seperate string of sub items (maybe for multi-itemed things like faction test gear set)
 	UNUSED(std::string audioEventUse);         //!< ???
 	bool noEquipAnimation;          //!< Whether or not there is an equip animation
-	unsigned int commendationLOT;           //!< The commendation LOT
-	unsigned int commendationCost;          //!< The commendation cost
+	uint32_t commendationLOT;           //!< The commendation LOT
+	uint32_t commendationCost;          //!< The commendation cost
 	UNUSED(std::string audioEquipMetaEventSet);    //!< ???
 	std::string currencyCosts;         //!< Used for crafting
 	UNUSED(std::string ingredientInfo);        //!< Unused
-	unsigned int locStatus;                 //!< ???
-	unsigned int forgeType;                 //!< Forge Type
+	uint32_t locStatus;                 //!< ???
+	uint32_t forgeType;                 //!< Forge Type
 	float SellMultiplier;           //!< Something to do with early vendors perhaps (but replaced)
 };
 
 class CDItemComponentTable : public CDTable<CDItemComponentTable> {
 private:
-	std::map<unsigned int, CDItemComponent> entries;
+	std::map<uint32_t, CDItemComponent> entries;
 
 public:
 	void LoadValuesFromDatabase();
 	static std::map<LOT, uint32_t> ParseCraftingCurrencies(const CDItemComponent& itemComponent);
 
 	// Gets an entry by ID
-	const CDItemComponent& GetItemComponentByID(unsigned int skillID);
+	const CDItemComponent& GetItemComponentByID(uint32_t skillID);
 
 	static CDItemComponent Default;
 };

dDatabase/CDClientDatabase/CDClientTables/CDItemSetSkillsTable.cpp

@@ -3,7 +3,7 @@
 void CDItemSetSkillsTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ItemSetSkills");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);
@@ -44,7 +44,7 @@ const std::vector<CDItemSetSkills>& CDItemSetSkillsTable::GetEntries() const {
 	return this->entries;
 }
 
-std::vector<CDItemSetSkills> CDItemSetSkillsTable::GetBySkillID(unsigned int SkillSetID) {
+std::vector<CDItemSetSkills> CDItemSetSkillsTable::GetBySkillID(uint32_t SkillSetID) {
 	std::vector<CDItemSetSkills> toReturn;
 
 	for (CDItemSetSkills entry : this->entries) {

dDatabase/CDClientDatabase/CDClientTables/CDItemSetSkillsTable.h

@@ -4,9 +4,9 @@
 #include "CDTable.h"
 
 struct CDItemSetSkills {
-	unsigned int SkillSetID;            //!< The skill set ID
-	unsigned int SkillID;               //!< The skill ID
-	unsigned int SkillCastType;         //!< The skill cast type
+	uint32_t SkillSetID;            //!< The skill set ID
+	uint32_t SkillID;               //!< The skill ID
+	uint32_t SkillCastType;         //!< The skill cast type
 };
 
 class CDItemSetSkillsTable : public CDTable<CDItemSetSkillsTable> {
@@ -20,5 +20,5 @@ public:
 
 	const std::vector<CDItemSetSkills>& GetEntries() const;
 
-	std::vector<CDItemSetSkills> GetBySkillID(unsigned int SkillSetID);
+	std::vector<CDItemSetSkills> GetBySkillID(uint32_t SkillSetID);
 };

dDatabase/CDClientDatabase/CDClientTables/CDItemSetsTable.cpp

@@ -3,7 +3,7 @@
 void CDItemSetsTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ItemSets");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDItemSetsTable.h

@@ -4,20 +4,20 @@
 #include "CDTable.h"
 
 struct CDItemSets {
-	unsigned int setID;             //!< The item set ID
-	unsigned int locStatus;         //!< The loc status
+	uint32_t setID;             //!< The item set ID
+	uint32_t locStatus;         //!< The loc status
 	std::string itemIDs;       //!< THe item IDs
-	unsigned int kitType;           //!< The item kit type
-	unsigned int kitRank;           //!< The item kit rank
-	unsigned int kitImage;          //!< The item kit image
-	unsigned int skillSetWith2;     //!< The skill set with 2
-	unsigned int skillSetWith3;     //!< The skill set with 3
-	unsigned int skillSetWith4;     //!< The skill set with 4
-	unsigned int skillSetWith5;     //!< The skill set with 5
-	unsigned int skillSetWith6;     //!< The skill set with 6
+	uint32_t kitType;           //!< The item kit type
+	uint32_t kitRank;           //!< The item kit rank
+	uint32_t kitImage;          //!< The item kit image
+	uint32_t skillSetWith2;     //!< The skill set with 2
+	uint32_t skillSetWith3;     //!< The skill set with 3
+	uint32_t skillSetWith4;     //!< The skill set with 4
+	uint32_t skillSetWith5;     //!< The skill set with 5
+	uint32_t skillSetWith6;     //!< The skill set with 6
 	bool localize;          //!< Whether or localize
 	std::string gate_version;  //!< The gate version
-	unsigned int kitID;             //!< The kit ID
+	uint32_t kitID;             //!< The kit ID
 	float priority;         //!< The priority
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDLevelProgressionLookupTable.cpp

@@ -3,7 +3,7 @@
 void CDLevelProgressionLookupTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LevelProgressionLookup");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDLevelProgressionLookupTable.h

@@ -4,8 +4,8 @@
 #include "CDTable.h"
 
 struct CDLevelProgressionLookup {
-	unsigned int id;                    //!< The Level ID
-	unsigned int requiredUScore;        //!< The required LEGO Score
+	uint32_t id;                    //!< The Level ID
+	uint32_t requiredUScore;        //!< The required LEGO Score
 	std::string BehaviorEffect;    //!< The behavior effect attached to this
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDLootMatrixTable.cpp

@@ -16,7 +16,7 @@ CDLootMatrix CDLootMatrixTable::ReadRow(CppSQLite3Query& tableData) const {
 void CDLootMatrixTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LootMatrix");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDLootMatrixTable.h

@@ -4,12 +4,12 @@
 #include "CDTable.h"
 
 struct CDLootMatrix {
-	unsigned int LootTableIndex;            //!< The Loot Table Index
-	unsigned int RarityTableIndex;          //!< The Rarity Table Index
+	uint32_t LootTableIndex;            //!< The Loot Table Index
+	uint32_t 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 flagID;                    //!< ???
+	uint32_t minToDrop;                 //!< The minimum amount of loot from this matrix to drop
+	uint32_t maxToDrop;                 //!< The maximum amount of loot from this matrix to drop
+	uint32_t flagID;                    //!< ???
 	UNUSED(std::string gate_version);          //!< The Gate Version
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.cpp

@@ -40,7 +40,7 @@ CDLootTable CDLootTableTable::ReadRow(CppSQLite3Query& tableData) const {
 void CDLootTableTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM LootTable");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDLootTableTable.h

@@ -4,10 +4,10 @@
 #include "CDTable.h"
 
 struct CDLootTable {
-	unsigned int itemid;                 //!< The LOT of the item
-	unsigned int LootTableIndex;         //!< The Loot Table Index
+	uint32_t itemid;                 //!< The LOT of the item
+	uint32_t LootTableIndex;         //!< The Loot Table Index
 	bool MissionDrop;               //!< Whether or not this loot table is a mission drop
-	unsigned int sortPriority;           //!< The sorting priority
+	uint32_t sortPriority;           //!< The sorting priority
 };
 
 typedef uint32_t LootTableIndex;

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.cpp

@@ -3,7 +3,7 @@
 void CDMissionEmailTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM MissionEmail");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDMissionEmailTable.h

@@ -4,13 +4,13 @@
 #include "CDTable.h"
 
 struct CDMissionEmail {
-	unsigned int ID;
-	unsigned int messageType;
-	unsigned int notificationGroup;
-	unsigned int missionID;
-	unsigned int attachmentLOT;
+	uint32_t ID;
+	uint32_t messageType;
+	uint32_t notificationGroup;
+	uint32_t missionID;
+	uint32_t attachmentLOT;
 	bool localize;
-	unsigned int locStatus;
+	uint32_t locStatus;
 	std::string gate_version;
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDMissionNPCComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM MissionNPCComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDMissionNPCComponentTable.h

@@ -4,8 +4,8 @@
 #include "CDTable.h"
 
 struct CDMissionNPCComponent {
-	unsigned int id;                //!< The ID
-	unsigned int missionID;         //!< The Mission ID
+	uint32_t id;                //!< The ID
+	uint32_t missionID;         //!< The Mission ID
 	bool offersMission;     //!< Whether or not this NPC offers a mission
 	bool acceptsMission;    //!< Whether or not this NPC accepts a mission
 	std::string gate_version;  //!< The gate version

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.cpp

@@ -3,7 +3,7 @@
 void CDMissionTasksTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM MissionTasks");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDMissionTasksTable.h

@@ -4,17 +4,17 @@
 #include "CDTable.h"
 
 struct CDMissionTasks {
-	unsigned int id;                //!< The Mission ID that the task belongs to
-	UNUSED(unsigned int locStatus);         //!< ???
-	unsigned int taskType;          //!< The task type
-	unsigned int target;            //!< The mission target
+	uint32_t id;                //!< The Mission ID that the task belongs to
+	UNUSED(uint32_t locStatus);         //!< ???
+	uint32_t taskType;          //!< The task type
+	uint32_t target;            //!< The mission target
 	std::string targetGroup;        //!< The mission target group
-	int targetValue;       //!< The target value
+	int32_t targetValue;       //!< The target value
 	std::string taskParam1;    //!< The task param 1
 	UNUSED(std::string largeTaskIcon); //!< ???
-	UNUSED(unsigned int IconID);            //!< ???
-	unsigned int uid;               //!< ???
-	UNUSED(unsigned int largeTaskIconID);   //!< ???
+	UNUSED(uint32_t IconID);            //!< ???
+	uint32_t uid;               //!< ???
+	UNUSED(uint32_t largeTaskIconID);   //!< ???
 	UNUSED(bool localize);          //!< Whether or not the task should be localized
 	UNUSED(std::string gate_version);  //!< ???
 };

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.cpp

@@ -5,7 +5,7 @@ CDMissions CDMissionsTable::Default = {};
 void CDMissionsTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Missions");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDMissionsTable.h

@@ -6,58 +6,58 @@
 #include <cstdint>
 
 struct CDMissions {
-	int id;                        //!< The Mission ID
+	int32_t id;                        //!< The Mission ID
 	std::string defined_type;          //!< The type of mission
 	std::string defined_subtype;       //!< The subtype of the mission
-	int UISortOrder;               //!< The UI Sort Order for the mission
-	int offer_objectID;            //!< The LOT of the mission giver
-	int target_objectID;           //!< The LOT of the mission's target
+	int32_t UISortOrder;               //!< The UI Sort Order for the mission
+	int32_t offer_objectID;            //!< The LOT of the mission giver
+	int32_t target_objectID;           //!< The LOT of the mission's target
 	int64_t reward_currency;           //!< The amount of currency to reward the player
-	int LegoScore;                 //!< The amount of LEGO Score to reward the player
+	int32_t LegoScore;                 //!< The amount of LEGO Score to reward the player
 	int64_t reward_reputation;         //!< The reputation to award the player
 	bool isChoiceReward;            //!< Whether or not the user has the option to choose their loot
-	int reward_item1;              //!< The first rewarded item
-	int reward_item1_count;        //!< The count of the first item to be rewarded
-	int reward_item2;              //!< The second rewarded item
-	int reward_item2_count;        //!< The count of the second item to be rewarded
-	int reward_item3;              //!< The third rewarded item
-	int reward_item3_count;        //!< The count of the third item to be rewarded
-	int reward_item4;              //!< The fourth rewarded item
-	int reward_item4_count;        //!< The count of the fourth item to be rewarded
-	int reward_emote;              //!< The first emote to be rewarded
-	int reward_emote2;             //!< The second emote to be rewarded
-	int reward_emote3;             //!< The third emote to be rewarded
-	int reward_emote4;             //!< The fourth emote to be rewarded
-	int reward_maximagination;     //!< The amount of max imagination to reward
-	int reward_maxhealth;          //!< The amount of max health to reward
-	int reward_maxinventory;       //!< The amount of max inventory to reward
-	int reward_maxmodel;           //!< ???
-	int reward_maxwidget;          //!< ???
-	int reward_maxwallet;          //!< ???
+	int32_t reward_item1;              //!< The first rewarded item
+	int32_t reward_item1_count;        //!< The count of the first item to be rewarded
+	int32_t reward_item2;              //!< The second rewarded item
+	int32_t reward_item2_count;        //!< The count of the second item to be rewarded
+	int32_t reward_item3;              //!< The third rewarded item
+	int32_t reward_item3_count;        //!< The count of the third item to be rewarded
+	int32_t reward_item4;              //!< The fourth rewarded item
+	int32_t reward_item4_count;        //!< The count of the fourth item to be rewarded
+	int32_t reward_emote;              //!< The first emote to be rewarded
+	int32_t reward_emote2;             //!< The second emote to be rewarded
+	int32_t reward_emote3;             //!< The third emote to be rewarded
+	int32_t reward_emote4;             //!< The fourth emote to be rewarded
+	int32_t reward_maximagination;     //!< The amount of max imagination to reward
+	int32_t reward_maxhealth;          //!< The amount of max health to reward
+	int32_t reward_maxinventory;       //!< The amount of max inventory to reward
+	int32_t reward_maxmodel;           //!< ???
+	int32_t reward_maxwidget;          //!< ???
+	int32_t reward_maxwallet;          //!< ???
 	bool repeatable;                //!< Whether or not this mission can be repeated (for instance, is it a daily mission)
 	int64_t reward_currency_repeatable;   //!< The repeatable reward
-	int reward_item1_repeatable;      //!< The first rewarded item
-	int reward_item1_repeat_count;    //!< The count of the first item to be rewarded
-	int reward_item2_repeatable;      //!< The second rewarded item
-	int reward_item2_repeat_count;    //!< The count of the second item to be rewarded
-	int reward_item3_repeatable;      //!< The third rewarded item
-	int reward_item3_repeat_count;    //!< The count of the third item to be rewarded
-	int reward_item4_repeatable;      //!< The fourth rewarded item
-	int reward_item4_repeat_count;    //!< The count of the fourth item to be rewarded
-	int time_limit;                //!< The time limit of the mission
+	int32_t reward_item1_repeatable;      //!< The first rewarded item
+	int32_t reward_item1_repeat_count;    //!< The count of the first item to be rewarded
+	int32_t reward_item2_repeatable;      //!< The second rewarded item
+	int32_t reward_item2_repeat_count;    //!< The count of the second item to be rewarded
+	int32_t reward_item3_repeatable;      //!< The third rewarded item
+	int32_t reward_item3_repeat_count;    //!< The count of the third item to be rewarded
+	int32_t reward_item4_repeatable;      //!< The fourth rewarded item
+	int32_t reward_item4_repeat_count;    //!< The count of the fourth item to be rewarded
+	int32_t time_limit;                //!< The time limit of the mission
 	bool isMission;                 //!< Maybe to differentiate between missions and achievements?
-	int missionIconID;             //!< The mission icon ID
+	int32_t missionIconID;             //!< The mission icon ID
 	std::string prereqMissionID;       //!< A '|' seperated list of prerequisite missions
 	bool localize;                  //!< Whether or not to localize the mission
 	bool inMOTD;                    //!< In Match of the Day(?)
 	int64_t cooldownTime;              //!< The mission cooldown time
 	bool isRandom;                  //!< ???
 	std::string randomPool;            //!< ???
-	int UIPrereqID;                //!< ???
+	int32_t UIPrereqID;                //!< ???
 	UNUSED(std::string gate_version);          //!< The gate version
 	UNUSED(std::string HUDStates);             //!< ???
-	UNUSED(int locStatus);                 //!< ???
-	int reward_bankinventory;      //!< The amount of bank space this mission rewards
+	UNUSED(int32_t locStatus);                 //!< ???
+	int32_t reward_bankinventory;      //!< The amount of bank space this mission rewards
 };
 
 class CDMissionsTable : public CDTable<CDMissionsTable> {

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDMovementAIComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM MovementAIComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDMovementAIComponentTable.h

@@ -4,7 +4,7 @@
 #include "CDTable.h"
 
 struct CDMovementAIComponent {
-	unsigned int id;
+	uint32_t id;
 	std::string MovementType;
 	float WanderChance;
 	float WanderDelayMin;

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.cpp

@@ -3,7 +3,7 @@
 void CDObjectSkillsTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ObjectSkills");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDObjectSkillsTable.h

@@ -4,10 +4,10 @@
 #include "CDTable.h"
 
 struct CDObjectSkills {
-	unsigned int objectTemplate;        //!< The LOT of the item
-	unsigned int skillID;               //!< The Skill ID of the object
-	unsigned int castOnType;            //!< ???
-	unsigned int AICombatWeight;        //!< ???
+	uint32_t objectTemplate;        //!< The LOT of the item
+	uint32_t skillID;               //!< The Skill ID of the object
+	uint32_t castOnType;            //!< ???
+	uint32_t AICombatWeight;        //!< ???
 };
 
 class CDObjectSkillsTable : public CDTable<CDObjectSkillsTable> {

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.cpp

@@ -2,7 +2,7 @@
 
 void CDObjectsTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM Objects");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);
@@ -40,7 +40,7 @@ void CDObjectsTable::LoadValuesFromDatabase() {
 	m_default.id = 0;
 }
 
-const CDObjects& CDObjectsTable::GetByID(unsigned int LOT) {
+const CDObjects& CDObjectsTable::GetByID(uint32_t LOT) {
 	const auto& it = this->entries.find(LOT);
 	if (it != this->entries.end()) {
 		return it->second;

dDatabase/CDClientDatabase/CDClientTables/CDObjectsTable.h

@@ -4,30 +4,30 @@
 #include "CDTable.h"
 
 struct CDObjects {
-	unsigned int id;                            //!< The LOT of the object
+	uint32_t id;                            //!< The LOT of the object
 	std::string name;                      //!< The internal name of the object
-	UNUSED(unsigned int placeable);                     //!< Whether or not the object is placable
+	UNUSED(uint32_t placeable);                     //!< Whether or not the object is placable
 	std::string type;                      //!< The object type
 	UNUSED(std::string description);               //!< An internal description of the object
-	UNUSED(unsigned int localize);                      //!< Whether or not the object should localize
-	UNUSED(unsigned int npcTemplateID);                 //!< Something related to NPCs...
+	UNUSED(uint32_t localize);                      //!< Whether or not the object should localize
+	UNUSED(uint32_t npcTemplateID);                 //!< Something related to NPCs...
 	UNUSED(std::string displayName);               //!< The display name of the object
 	float interactionDistance;          //!< The interaction distance of the object
-	UNUSED(unsigned int nametag);                       //!< ???
+	UNUSED(uint32_t nametag);                       //!< ???
 	UNUSED(std::string _internalNotes);            //!< Some internal notes (rarely used)
-	UNUSED(unsigned int locStatus);                     //!< ???
+	UNUSED(uint32_t locStatus);                     //!< ???
 	UNUSED(std::string gate_version);              //!< The gate version for the object
-	UNUSED(unsigned int HQ_valid);                      //!< Probably used for the Nexus HQ database on LEGOUniverse.com
+	UNUSED(uint32_t HQ_valid);                      //!< Probably used for the Nexus HQ database on LEGOUniverse.com
 };
 
 class CDObjectsTable : public CDTable<CDObjectsTable> {
 private:
-	std::map<unsigned int, CDObjects> entries;
+	std::map<uint32_t, CDObjects> entries;
 	CDObjects m_default;
 
 public:
 	void LoadValuesFromDatabase();
 	// Gets an entry by ID
-	const CDObjects& GetByID(unsigned int LOT);
+	const CDObjects& GetByID(uint32_t LOT);
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDPackageComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM PackageComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDPackageComponentTable.h

@@ -4,9 +4,9 @@
 #include "CDTable.h"
 
 struct CDPackageComponent {
-	unsigned int id;
-	unsigned int LootMatrixIndex;
-	unsigned int packageType;
+	uint32_t id;
+	uint32_t LootMatrixIndex;
+	uint32_t packageType;
 };
 
 class CDPackageComponentTable : public CDTable<CDPackageComponentTable> {

dDatabase/CDClientDatabase/CDClientTables/CDPetComponentTable.cpp

@@ -0,0 +1,61 @@
+#include "CDPetComponentTable.h"
+
+namespace {
+	// Default entries for fallback
+	CDPetComponent defaultEntry{
+		.id = 0,
+		UNUSED_ENTRY(.minTameUpdateTime = 60.0f,)
+		UNUSED_ENTRY(.maxTameUpdateTime = 300.0f,)
+		UNUSED_ENTRY(.percentTameChance = 101.0f,)
+		UNUSED_ENTRY(.tameability = 100.0f,)
+		UNUSED_ENTRY(.elementType = 1,)
+		.walkSpeed = 2.5f,
+		.runSpeed = 5.0f,
+		.sprintSpeed = 10.0f,
+		UNUSED_ENTRY(.idleTimeMin = 60.0f,)
+		UNUSED_ENTRY(.idleTimeMax = 300.0f,)
+		UNUSED_ENTRY(.petForm = 0,)
+		.imaginationDrainRate = 60.0f,
+		UNUSED_ENTRY(.AudioMetaEventSet = "",)
+		UNUSED_ENTRY(.buffIDs = "",)
+	};
+}
+
+void CDPetComponentTable::LoadValuesFromDatabase() {
+	auto tableData = CDClientDatabase::ExecuteQuery("SELECT * FROM PetComponent");
+	while (!tableData.eof()) {
+		const uint32_t componentID = tableData.getIntField("id", defaultEntry.id);
+
+		auto& entry = m_Entries[componentID];
+		entry.id = componentID;
+		UNUSED_COLUMN(entry.minTameUpdateTime = tableData.getFloatField("minTameUpdateTime", defaultEntry.minTameUpdateTime));
+		UNUSED_COLUMN(entry.maxTameUpdateTime = tableData.getFloatField("maxTameUpdateTime", defaultEntry.maxTameUpdateTime));
+		UNUSED_COLUMN(entry.percentTameChance = tableData.getFloatField("percentTameChance", defaultEntry.percentTameChance));
+		UNUSED_COLUMN(entry.tameability = tableData.getFloatField("tamability", defaultEntry.tameability)); // Mispelled as "tamability" in CDClient
+		UNUSED_COLUMN(entry.elementType = tableData.getIntField("elementType", defaultEntry.elementType));
+		entry.walkSpeed = static_cast<float>(tableData.getFloatField("walkSpeed", defaultEntry.walkSpeed));
+		entry.runSpeed = static_cast<float>(tableData.getFloatField("runSpeed", defaultEntry.runSpeed));
+		entry.sprintSpeed = static_cast<float>(tableData.getFloatField("sprintSpeed", defaultEntry.sprintSpeed));
+		UNUSED_COLUMN(entry.idleTimeMin = tableData.getFloatField("idleTimeMin", defaultEntry.idleTimeMin));
+		UNUSED_COLUMN(entry.idleTimeMax = tableData.getFloatField("idleTimeMax", defaultEntry.idleTimeMax));
+		UNUSED_COLUMN(entry.petForm = tableData.getIntField("petForm", defaultEntry.petForm));
+		entry.imaginationDrainRate = static_cast<float>(tableData.getFloatField("imaginationDrainRate", defaultEntry.imaginationDrainRate));
+		UNUSED_COLUMN(entry.AudioMetaEventSet = tableData.getStringField("AudioMetaEventSet", defaultEntry.AudioMetaEventSet));
+		UNUSED_COLUMN(entry.buffIDs = tableData.getStringField("buffIDs", defaultEntry.buffIDs));
+
+		tableData.nextRow();
+	}
+}
+
+void CDPetComponentTable::LoadValuesFromDefaults() {
+	m_Entries.insert(std::make_pair(defaultEntry.id, defaultEntry));
+}
+
+CDPetComponent& CDPetComponentTable::GetByID(const uint32_t componentID) {
+	auto itr = m_Entries.find(componentID);
+	if (itr == m_Entries.end()) {
+		LOG("Unable to load pet component (ID %i) values from database! Using default values instead.", componentID);
+		return defaultEntry;
+	}
+	return itr->second;
+}

dDatabase/CDClientDatabase/CDClientTables/CDPetComponentTable.h

@@ -0,0 +1,45 @@
+#pragma once
+#include "CDTable.h"
+#include <cstdint>
+#include <string>
+
+struct CDPetComponent {
+	uint32_t id;
+	UNUSED_COLUMN(float minTameUpdateTime;)
+	UNUSED_COLUMN(float maxTameUpdateTime;)
+	UNUSED_COLUMN(float percentTameChance;)
+	UNUSED_COLUMN(float tameability;) // Mispelled as "tamability" in CDClient
+	UNUSED_COLUMN(uint32_t elementType;)
+	float walkSpeed;
+	float runSpeed;
+	float sprintSpeed;
+	UNUSED_COLUMN(float idleTimeMin;)
+	UNUSED_COLUMN(float idleTimeMax;)
+	UNUSED_COLUMN(uint32_t petForm;)
+	float imaginationDrainRate;
+	UNUSED_COLUMN(std::string AudioMetaEventSet;)
+	UNUSED_COLUMN(std::string buffIDs;)
+};
+
+class CDPetComponentTable : public CDTable<CDPetComponentTable> {
+public:
+
+	/**
+	 * Load values from the CD client database
+	*/
+	void LoadValuesFromDatabase();
+	
+	/**
+	 * Load the default values into memory instead of attempting to connect to the CD client database
+	*/
+	void LoadValuesFromDefaults();
+
+	/**
+	 * Gets the pet component table corresponding to the pet component ID
+	 * @returns A reference to the corresponding table, or the default if one could not be found
+	*/
+	CDPetComponent& GetByID(const uint32_t componentID);
+	
+private:
+	std::map<uint32_t, CDPetComponent> m_Entries;
+};

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.cpp

@@ -28,7 +28,7 @@ void CDPhysicsComponentTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
-CDPhysicsComponent* CDPhysicsComponentTable::GetByID(unsigned int componentID) {
+CDPhysicsComponent* CDPhysicsComponentTable::GetByID(uint32_t componentID) {
 	auto itr = m_entries.find(componentID);
 	return itr != m_entries.end() ? &itr->second : nullptr;
 }

dDatabase/CDClientDatabase/CDClientTables/CDPhysicsComponentTable.h

@@ -3,7 +3,7 @@
 #include <string>
 
 struct CDPhysicsComponent {
-	int id;
+	int32_t id;
 	bool bStatic;
 	std::string physicsAsset;
 	UNUSED(bool jump);
@@ -12,8 +12,8 @@ struct CDPhysicsComponent {
 	UNUSED(float rotSpeed);
 	float playerHeight;
 	float playerRadius;
-	int pcShapeType;
-	int collisionGroup;
+	int32_t pcShapeType;
+	int32_t collisionGroup;
 	UNUSED(float airSpeed);
 	UNUSED(std::string boundaryAsset);
 	UNUSED(float jumpAirSpeed);
@@ -26,8 +26,8 @@ public:
 	void LoadValuesFromDatabase();
 
 	static const std::string GetTableName() { return "PhysicsComponent"; };
-	CDPhysicsComponent* GetByID(unsigned int componentID);
+	CDPhysicsComponent* GetByID(uint32_t componentID);
 
 private:
-	std::map<unsigned int, CDPhysicsComponent> m_entries;
+	std::map<uint32_t, CDPhysicsComponent> m_entries;
 };

dDatabase/CDClientDatabase/CDClientTables/CDProximityMonitorComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDProximityMonitorComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ProximityMonitorComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDProximityMonitorComponentTable.h

@@ -4,7 +4,7 @@
 #include "CDTable.h"
 
 struct CDProximityMonitorComponent {
-	unsigned int id;
+	uint32_t id;
 	std::string Proximities;
 	bool LoadOnClient;
 	bool LoadOnServer;

dDatabase/CDClientDatabase/CDClientTables/CDRarityTableTable.cpp

@@ -3,7 +3,7 @@
 void CDRarityTableTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RarityTable");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDRarityTableTable.h

@@ -5,7 +5,7 @@
 
 struct CDRarityTable {
 	float randmax;
-	unsigned int rarity;
+	uint32_t rarity;
 };
 
 typedef std::vector<CDRarityTable> RarityTable;

dDatabase/CDClientDatabase/CDClientTables/CDRebuildComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDRebuildComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RebuildComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDRebuildComponentTable.h

@@ -4,15 +4,15 @@
 #include "CDTable.h"
 
 struct CDRebuildComponent {
-	unsigned int id;                        //!< The component Id
+	uint32_t 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
+	uint32_t take_imagination;          //!< The amount of imagination it costs
 	bool interruptible;             //!< Whether or not the rebuild is interruptible
 	bool self_activator;            //!< Whether or not the rebuild is a rebuild activator itself
 	std::string custom_modules;        //!< The custom modules
-	unsigned int activityID;                //!< The activity ID
-	unsigned int post_imagination_cost;     //!< The post imagination cost
+	uint32_t activityID;                //!< The activity ID
+	uint32_t post_imagination_cost;     //!< The post imagination cost
 	float time_before_smash;        //!< The time before smash
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDRewardCodesTable.cpp

@@ -3,7 +3,7 @@
 void CDRewardCodesTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM RewardCodes");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDScriptComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDScriptComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ScriptComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);
@@ -28,8 +28,8 @@ void CDScriptComponentTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
-const CDScriptComponent& CDScriptComponentTable::GetByID(unsigned int id) {
-	std::map<unsigned int, CDScriptComponent>::iterator it = this->entries.find(id);
+const CDScriptComponent& CDScriptComponentTable::GetByID(uint32_t id) {
+	std::map<uint32_t, CDScriptComponent>::iterator it = this->entries.find(id);
 	if (it != this->entries.end()) {
 		return it->second;
 	}

dDatabase/CDClientDatabase/CDClientTables/CDScriptComponentTable.h

@@ -4,19 +4,19 @@
 #include "CDTable.h"
 
 struct CDScriptComponent {
-	unsigned int id;                        //!< The component ID
+	uint32_t id;                        //!< The component ID
 	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;
+	std::map<uint32_t, CDScriptComponent> entries;
 	CDScriptComponent m_ToReturnWhenNoneFound;
 
 public:
 	void LoadValuesFromDatabase();
 	// Gets an entry by scriptID
-	const CDScriptComponent& GetByID(unsigned int id);
+	const CDScriptComponent& GetByID(uint32_t id);
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDSkillBehaviorTable.cpp

@@ -4,7 +4,7 @@ void CDSkillBehaviorTable::LoadValuesFromDatabase() {
 	m_empty = CDSkillBehavior();
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM SkillBehavior");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);
@@ -49,8 +49,8 @@ void CDSkillBehaviorTable::LoadValuesFromDatabase() {
 	tableData.finalize();
 }
 
-const CDSkillBehavior& CDSkillBehaviorTable::GetSkillByID(unsigned int skillID) {
-	std::map<unsigned int, CDSkillBehavior>::iterator it = this->entries.find(skillID);
+const CDSkillBehavior& CDSkillBehaviorTable::GetSkillByID(uint32_t skillID) {
+	std::map<uint32_t, CDSkillBehavior>::iterator it = this->entries.find(skillID);
 	if (it != this->entries.end()) {
 		return it->second;
 	}

dDatabase/CDClientDatabase/CDClientTables/CDSkillBehaviorTable.h

@@ -4,36 +4,36 @@
 #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
-	unsigned int cooldowngroup;         //!< The cooldown group ID of the skill
+	uint32_t skillID;               //!< The Skill ID of the skill
+	UNUSED(uint32_t locStatus);             //!< ??
+	uint32_t behaviorID;            //!< The Behavior ID of the skill
+	uint32_t imaginationcost;       //!< The imagination cost of the skill
+	uint32_t cooldowngroup;         //!< The cooldown group ID of the skill
 	float cooldown;             //!< The cooldown time of the skill
 	UNUSED(bool isNpcEditor);           //!< ???
-	UNUSED(unsigned int skillIcon);             //!< The Skill Icon ID
+	UNUSED(uint32_t skillIcon);             //!< The Skill Icon ID
 	UNUSED(std::string oomSkillID);        //!< ???
-	UNUSED(unsigned int oomBehaviorEffectID);   //!< ???
-	UNUSED(unsigned int castTypeDesc);          //!< The cast type description(?)
-	UNUSED(unsigned int imBonusUI);             //!< The imagination bonus of the skill
-	UNUSED(nsigned int lifeBonusUI);           //!< The life bonus of the skill
-	UNUSED(unsigned int armorBonusUI);          //!< The armor bonus of the skill
-	UNUSED(unsigned int damageUI);             //!< ???
+	UNUSED(uint32_t oomBehaviorEffectID);   //!< ???
+	UNUSED(uint32_t castTypeDesc);          //!< The cast type description(?)
+	UNUSED(uint32_t imBonusUI);             //!< The imagination bonus of the skill
+	UNUSED(nint32_t lifeBonusUI);           //!< The life bonus of the skill
+	UNUSED(uint32_t armorBonusUI);          //!< The armor bonus of the skill
+	UNUSED(uint32_t damageUI);             //!< ???
 	UNUSED(bool hideIcon);              //!< Whether or not to show the icon
 	UNUSED(bool localize);              //!< ???
 	UNUSED(std::string gate_version);      //!< ???
-	UNUSED(unsigned int cancelType);            //!< The cancel type (?)
+	UNUSED(uint32_t cancelType);            //!< The cancel type (?)
 };
 
 class CDSkillBehaviorTable : public CDTable<CDSkillBehaviorTable> {
 private:
-	std::map<unsigned int, CDSkillBehavior> entries;
+	std::map<uint32_t, CDSkillBehavior> entries;
 	CDSkillBehavior m_empty;
 
 public:
 	void LoadValuesFromDatabase();
 
 	// Gets an entry by skillID
-	const CDSkillBehavior& GetSkillByID(unsigned int skillID);
+	const CDSkillBehavior& GetSkillByID(uint32_t skillID);
 };
 

dDatabase/CDClientDatabase/CDClientTables/CDTable.h

@@ -23,6 +23,9 @@
 // Enable this to skip some unused columns in some tables
 #define UNUSED_COLUMN(v)
 
+// Use this to skip unused defaults for unused entries in some tables
+#define UNUSED_ENTRY(v, x)
+
 #pragma warning (disable : 4244) //Disable double to float conversion warnings
 #pragma warning (disable : 4715) //Disable "not all control paths return a value"
 

dDatabase/CDClientDatabase/CDClientTables/CDVendorComponentTable.cpp

@@ -3,7 +3,7 @@
 void CDVendorComponentTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM VendorComponent");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);

dDatabase/CDClientDatabase/CDClientTables/CDVendorComponentTable.h

@@ -4,11 +4,11 @@
 #include "CDTable.h"
 
 struct CDVendorComponent {
-	unsigned int id;           //!< The Component ID
+	uint32_t 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
-	unsigned int LootMatrixIndex; //!< LootMatrixIndex of the vendor's items
+	uint32_t LootMatrixIndex; //!< LootMatrixIndex of the vendor's items
 };
 
 class CDVendorComponentTable : public CDTable<CDVendorComponentTable> {

dDatabase/CDClientDatabase/CDClientTables/CDZoneTableTable.cpp

@@ -3,7 +3,7 @@
 void CDZoneTableTable::LoadValuesFromDatabase() {
 
 	// First, get the size of the table
-	unsigned int size = 0;
+	uint32_t size = 0;
 	auto tableSize = CDClientDatabase::ExecuteQuery("SELECT COUNT(*) FROM ZoneTable");
 	while (!tableSize.eof()) {
 		size = tableSize.getIntField(0, 0);
@@ -53,7 +53,7 @@ void CDZoneTableTable::LoadValuesFromDatabase() {
 }
 
 //! Queries the table with a zoneID to find.
-const CDZoneTable* CDZoneTableTable::Query(unsigned int zoneID) {
+const CDZoneTable* CDZoneTableTable::Query(uint32_t zoneID) {
 	const auto& iter = m_Entries.find(zoneID);
 
 	if (iter != m_Entries.end()) {

dDatabase/CDClientDatabase/CDClientTables/CDZoneTableTable.h

@@ -4,14 +4,14 @@
 #include "CDTable.h"
 
 struct CDZoneTable {
-	unsigned int zoneID;                        //!< The Zone ID of the object
-	unsigned int locStatus;                     //!< The Locale Status(?)
+	uint32_t zoneID;                        //!< The Zone ID of the object
+	uint32_t locStatus;                     //!< The Locale Status(?)
 	std::string zoneName;                  //!< The name of the zone
-	unsigned int scriptID;                      //!< The Script ID of the zone (ScriptsTable)
+	uint32_t scriptID;                      //!< The Script ID of the zone (ScriptsTable)
 	float ghostdistance_min;            //!< The minimum ghosting distance
 	float ghostdistance;                //!< The ghosting distance
-	unsigned int population_soft_cap;           //!< The "soft cap" on the world population
-	unsigned int population_hard_cap;           //!< The "hard cap" on the world population
+	uint32_t population_soft_cap;           //!< The "soft cap" on the world population
+	uint32_t population_hard_cap;           //!< The "hard cap" on the world population
 	UNUSED(std::string DisplayDescription);        //!< The display description of the world
 	UNUSED(std::string mapFolder);                 //!< ???
 	float smashableMinDistance;         //!< The minimum smashable distance?
@@ -19,9 +19,9 @@ struct CDZoneTable {
 	UNUSED(std::string mixerProgram);              //!< ???
 	UNUSED(std::string clientPhysicsFramerate);    //!< The client physics framerate
 	std::string serverPhysicsFramerate;    //!< The server physics framerate
-	unsigned int zoneControlTemplate;           //!< The Zone Control template
-	unsigned int widthInChunks;                 //!< The width of the world in chunks
-	unsigned int heightInChunks;                //!< The height of the world in chunks
+	uint32_t zoneControlTemplate;           //!< The Zone Control template
+	uint32_t widthInChunks;                 //!< The width of the world in chunks
+	uint32_t heightInChunks;                //!< The height of the world in chunks
 	bool petsAllowed;                   //!< Whether or not pets are allowed in the world
 	bool localize;                      //!< Whether or not the world should be localized
 	float fZoneWeight;                  //!< ???
@@ -35,11 +35,11 @@ struct CDZoneTable {
 
 class CDZoneTableTable : public CDTable<CDZoneTableTable> {
 private:
-	std::map<unsigned int, CDZoneTable> m_Entries;
+	std::map<uint32_t, CDZoneTable> m_Entries;
 
 public:
 	void LoadValuesFromDatabase();
 
 	// Queries the table with a zoneID to find.
-	const CDZoneTable* Query(unsigned int zoneID);
+	const CDZoneTable* Query(uint32_t zoneID);
 };

dDatabase/CDClientDatabase/CDClientTables/CMakeLists.txt

@@ -23,6 +23,7 @@ set(DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES "CDActivitiesTable.cpp"
 	"CDMovementAIComponentTable.cpp"
 	"CDObjectSkillsTable.cpp"
 	"CDObjectsTable.cpp"
+	"CDPetComponentTable.cpp"
 	"CDPackageComponentTable.cpp"
 	"CDPhysicsComponentTable.cpp"
 	"CDPropertyEntranceComponentTable.cpp"

dGame/Entity.cpp

@@ -3,7 +3,6 @@
 #include "CDClientManager.h"
 #include "Game.h"
 #include "Logger.h"
-#include "PacketUtils.h"
 #include <functional>
 #include "CDDestructibleComponentTable.h"
 #include "CDClientDatabase.h"
@@ -25,6 +24,7 @@
 #include "eMissionTaskType.h"
 #include "eTriggerEventType.h"
 #include "eObjectBits.h"
+#include "PositionUpdate.h"
 
 //Component includes:
 #include "Component.h"
@@ -1222,39 +1222,56 @@ void Entity::UpdateXMLDoc(tinyxml2::XMLDocument* doc) {
 
 void Entity::Update(const float deltaTime) {
 	uint32_t timerPosition;
-	timerPosition = 0;
-	while (timerPosition < m_Timers.size()) {
-		m_Timers[timerPosition]->Update(deltaTime);
-		if (m_Timers[timerPosition]->GetTime() <= 0) {
-			const auto timerName = m_Timers[timerPosition]->GetName();
-
-			delete m_Timers[timerPosition];
+	for (timerPosition = 0; timerPosition < m_Timers.size();) {
+		auto& timer = m_Timers[timerPosition];
+		timer.Update(deltaTime);
+		// If the timer is expired, erase it and dont increment the position because the next timer will be at the same position.
+		// Before: [0, 1, 2, 3, ..., n]
+		// timerPosition  ^
+		// After:  [0, 1, 3, ..., n]
+		// timerPosition  ^
+		if (timer.GetTime() <= 0) {
+			// Remove the timer from the list of timers first so that scripts and events can remove timers without causing iterator invalidation
+			auto timerName = timer.GetName();
 			m_Timers.erase(m_Timers.begin() + timerPosition);
-
 			for (CppScripts::Script* script : CppScripts::GetEntityScripts(this)) {
 				script->OnTimerDone(this, timerName);
 			}
+
 			TriggerEvent(eTriggerEventType::TIMER_DONE, this);
+		} else {
+			// If the timer isnt expired, go to the next timer.
+			timerPosition++;
+		}
+	}
+
+	for (timerPosition = 0; timerPosition < m_CallbackTimers.size(); ) {
+		// If the timer is expired, erase it and dont increment the position because the next timer will be at the same position.
+		// Before: [0, 1, 2, 3, ..., n]
+		// timerPosition  ^
+		// After:  [0, 1, 3, ..., n]
+		// timerPosition  ^
+		auto& callbackTimer = m_CallbackTimers[timerPosition];
+		callbackTimer.Update(deltaTime);
+		if (callbackTimer.GetTime() <= 0) {
+			// Remove the timer from the list of timers first so that callbacks can remove timers without causing iterator invalidation
+			auto callback = callbackTimer.GetCallback();
+			m_CallbackTimers.erase(m_CallbackTimers.begin() + timerPosition);
+			callback();
 		} else {
 			timerPosition++;
 		}
 	}
 
-	for (int i = 0; i < m_CallbackTimers.size(); i++) {
-		m_CallbackTimers[i]->Update(deltaTime);
-		if (m_CallbackTimers[i]->GetTime() <= 0) {
-			m_CallbackTimers[i]->GetCallback()();
-			delete m_CallbackTimers[i];
-			m_CallbackTimers.erase(m_CallbackTimers.begin() + i);
-		}
+	// Add pending timers to the list of timers so they start next tick.
+	if (!m_PendingTimers.empty()) {
+		m_Timers.insert(m_Timers.end(), m_PendingTimers.begin(), m_PendingTimers.end());
+		m_PendingTimers.clear();
 	}
 
-	// Add pending timers to the list of timers so they start next tick.
-	if (m_PendingTimers.size() > 0) {
-		for (auto namedTimer : m_PendingTimers) {
-			m_Timers.push_back(namedTimer);
-		}
-		m_PendingTimers.clear();
+	if (!m_PendingCallbackTimers.empty()) {
+		m_CallbackTimers.insert(m_CallbackTimers.end(), m_PendingCallbackTimers.begin(), m_PendingCallbackTimers.end());
+		m_PendingCallbackTimers.clear();
 	}
 
 	if (IsSleeping()) {
@@ -1692,31 +1709,20 @@ void Entity::RemoveParent() {
 }
 
 void Entity::AddTimer(std::string name, float time) {
-	EntityTimer* timer = new EntityTimer(name, time);
-	m_PendingTimers.push_back(timer);
+	m_PendingTimers.emplace_back(name, time);
 }
 
 void Entity::AddCallbackTimer(float time, std::function<void()> callback) {
-	EntityCallbackTimer* timer = new EntityCallbackTimer(time, callback);
-	m_CallbackTimers.push_back(timer);
+	m_PendingCallbackTimers.emplace_back(time, callback);
 }
 
 bool Entity::HasTimer(const std::string& name) {
-	for (auto* timer : m_Timers) {
-		if (timer->GetName() == name) {
-			return true;
-		}
-	}
-
-	return false;
+	return std::find(m_Timers.begin(), m_Timers.end(), name) != m_Timers.end();
 }
 
 void Entity::CancelCallbackTimers() {
-	for (auto* callback : m_CallbackTimers) {
-		delete callback;
-	}
-
 	m_CallbackTimers.clear();
+	m_PendingCallbackTimers.clear();
 }
 
 void Entity::ScheduleKillAfterUpdate(Entity* murderer) {
@@ -1728,8 +1734,8 @@ void Entity::ScheduleKillAfterUpdate(Entity* murderer) {
 
 void Entity::CancelTimer(const std::string& name) {
 	for (int i = 0; i < m_Timers.size(); i++) {
-		if (m_Timers[i]->GetName() == name) {
-			delete m_Timers[i];
+		auto& timer = m_Timers[i];
+		if (timer == name) {
 			m_Timers.erase(m_Timers.begin() + i);
 			return;
 		}
@@ -1737,21 +1743,10 @@ void Entity::CancelTimer(const std::string& name) {
 }
 
 void Entity::CancelAllTimers() {
-	/*for (auto timer : m_Timers) {
-		if (timer) delete timer;
-	}*/
-
-	for (auto* timer : m_Timers) {
-		delete timer;
-	}
-
 	m_Timers.clear();
-
-	for (auto* callBackTimer : m_CallbackTimers) {
-		delete callBackTimer;
-	}
-
+	m_PendingTimers.clear();
 	m_CallbackTimers.clear();
+	m_PendingCallbackTimers.clear();
 }
 
 bool Entity::IsPlayer() const {
@@ -1884,7 +1879,7 @@ const NiQuaternion& Entity::GetRotation() const {
 	return NiQuaternion::IDENTITY;
 }
 
-void Entity::SetPosition(NiPoint3 position) {
+void Entity::SetPosition(const NiPoint3& position) {
 	auto* controllable = GetComponent<ControllablePhysicsComponent>();
 
 	if (controllable != nullptr) {
@@ -1912,7 +1907,7 @@ void Entity::SetPosition(NiPoint3 position) {
 	Game::entityManager->SerializeEntity(this);
 }
 
-void Entity::SetRotation(NiQuaternion rotation) {
+void Entity::SetRotation(const NiQuaternion& rotation) {
 	auto* controllable = GetComponent<ControllablePhysicsComponent>();
 
 	if (controllable != nullptr) {
@@ -2061,3 +2056,75 @@ uint8_t Entity::GetCollectibleID() const {
 	auto* collectible = GetComponent<CollectibleComponent>();
 	return collectible ? collectible->GetCollectibleId() : 0;
 }
+
+void Entity::ProcessPositionUpdate(PositionUpdate& update) {
+	if (!IsPlayer()) return;
+	auto* controllablePhysicsComponent = GetComponent<ControllablePhysicsComponent>();
+	if (!controllablePhysicsComponent) return;
+
+	auto* possessorComponent = GetComponent<PossessorComponent>();
+	bool updateChar = true;
+
+	if (possessorComponent) {
+		auto* possassableEntity = Game::entityManager->GetEntity(possessorComponent->GetPossessable());
+
+		if (possassableEntity) {
+			auto* possessableComponent = possassableEntity->GetComponent<PossessableComponent>();
+
+			// While possessing something, only update char if we are attached to the thing we are possessing
+			updateChar = possessableComponent && possessableComponent->GetPossessionType() == ePossessionType::ATTACHED_VISIBLE;
+
+			auto* havokVehiclePhysicsComponent = possassableEntity->GetComponent<HavokVehiclePhysicsComponent>();
+			if (havokVehiclePhysicsComponent) {
+				havokVehiclePhysicsComponent->SetPosition(update.position);
+				havokVehiclePhysicsComponent->SetRotation(update.rotation);
+				havokVehiclePhysicsComponent->SetIsOnGround(update.onGround);
+				havokVehiclePhysicsComponent->SetIsOnRail(update.onRail);
+				havokVehiclePhysicsComponent->SetVelocity(update.velocity);
+				havokVehiclePhysicsComponent->SetDirtyVelocity(update.velocity != NiPoint3::ZERO);
+				havokVehiclePhysicsComponent->SetAngularVelocity(update.angularVelocity);
+				havokVehiclePhysicsComponent->SetDirtyAngularVelocity(update.angularVelocity != NiPoint3::ZERO);
+				havokVehiclePhysicsComponent->SetRemoteInputInfo(update.remoteInputInfo);
+			} else {
+				// Need to get the mount's controllable physics
+				auto* possessedControllablePhysicsComponent = possassableEntity->GetComponent<ControllablePhysicsComponent>();
+				if (!possessedControllablePhysicsComponent) return;
+				possessedControllablePhysicsComponent->SetPosition(update.position);
+				possessedControllablePhysicsComponent->SetRotation(update.rotation);
+				possessedControllablePhysicsComponent->SetIsOnGround(update.onGround);
+				possessedControllablePhysicsComponent->SetIsOnRail(update.onRail);
+				possessedControllablePhysicsComponent->SetVelocity(update.velocity);
+				possessedControllablePhysicsComponent->SetDirtyVelocity(update.velocity != NiPoint3::ZERO);
+				possessedControllablePhysicsComponent->SetAngularVelocity(update.angularVelocity);
+				possessedControllablePhysicsComponent->SetDirtyAngularVelocity(update.angularVelocity != NiPoint3::ZERO);
+			}
+			Game::entityManager->SerializeEntity(possassableEntity);
+		}
+	}
+
+	if (!updateChar) {
+		update.velocity = NiPoint3::ZERO;
+		update.angularVelocity = NiPoint3::ZERO;
+	}
+
+	// Handle statistics
+	auto* characterComponent = GetComponent<CharacterComponent>();
+	if (characterComponent) {
+		characterComponent->TrackPositionUpdate(update.position);
+	}
+
+	controllablePhysicsComponent->SetPosition(update.position);
+	controllablePhysicsComponent->SetRotation(update.rotation);
+	controllablePhysicsComponent->SetIsOnGround(update.onGround);
+	controllablePhysicsComponent->SetIsOnRail(update.onRail);
+	controllablePhysicsComponent->SetVelocity(update.velocity);
+	controllablePhysicsComponent->SetDirtyVelocity(update.velocity != NiPoint3::ZERO);
+	controllablePhysicsComponent->SetAngularVelocity(update.angularVelocity);
+	controllablePhysicsComponent->SetDirtyAngularVelocity(update.angularVelocity != NiPoint3::ZERO);
+
+	auto* player = static_cast<Player*>(this);
+	player->SetGhostReferencePoint(update.position);
+	Game::entityManager->QueueGhostUpdate(player->GetObjectID());
+
+	if (updateChar) Game::entityManager->SerializeEntity(this);
+}

dGame/Entity.h

@@ -31,6 +31,7 @@ class Component;
 class Item;
 class Character;
 class EntityCallbackTimer;
+class PositionUpdate;
 enum class eTriggerEventType;
 enum class eGameMasterLevel : uint8_t;
 enum class eReplicaComponentType : uint32_t;
@@ -105,7 +106,7 @@ public:
 
 	virtual User* GetParentUser() const;
 
-	virtual SystemAddress GetSystemAddress() const { return UNASSIGNED_SYSTEM_ADDRESS; };
+	virtual const SystemAddress& GetSystemAddress() const { return UNASSIGNED_SYSTEM_ADDRESS; };
 
 	/**
 	 * Setters
@@ -123,13 +124,13 @@ public:
 
 	void SetNetworkId(uint16_t id);
 
-	void SetPosition(NiPoint3 position);
+	void SetPosition(const NiPoint3& position);
 
-	void SetRotation(NiQuaternion rotation);
+	void SetRotation(const NiQuaternion& rotation);
 
-	virtual void SetRespawnPos(NiPoint3 position) {}
+	virtual void SetRespawnPos(const NiPoint3& position) {}
 
-	virtual void SetRespawnRot(NiQuaternion rotation) {}
+	virtual void SetRespawnRot(const NiQuaternion& rotation) {}
 
 	virtual void SetSystemAddress(const SystemAddress& value) {};
 
@@ -160,6 +161,8 @@ public:
 	void AddChild(Entity* child);
 	void RemoveChild(Entity* child);
 	void RemoveParent();
+
+	// Adds a timer to start next frame with the given name and time.
 	void AddTimer(std::string name, float time);
 	void AddCallbackTimer(float time, std::function<void()> callback);
 	bool HasTimer(const std::string& name);
@@ -226,8 +229,8 @@ public:
 	void TriggerEvent(eTriggerEventType event, Entity* optionalTarget = nullptr);
 	void ScheduleDestructionAfterUpdate() { m_ShouldDestroyAfterUpdate = true; }
 
-	virtual NiPoint3 GetRespawnPosition() const { return NiPoint3::ZERO; }
-	virtual NiQuaternion GetRespawnRotation() const { return NiQuaternion::IDENTITY; }
+	virtual const NiPoint3& GetRespawnPosition() const { return NiPoint3::ZERO; }
+	virtual const NiQuaternion& GetRespawnRotation() const { return NiQuaternion::IDENTITY; }
 
 	void Sleep();
 	void Wake();
@@ -294,6 +297,8 @@ public:
 
 	Entity* GetScheduledKiller() { return m_ScheduleKiller; }
 
+	void ProcessPositionUpdate(PositionUpdate& update);
+
 protected:
 	LWOOBJID m_ObjectID;
 
@@ -324,9 +329,10 @@ protected:
 	std::vector<std::function<void(Entity* target)>> m_PhantomCollisionCallbacks;
 
 	std::unordered_map<eReplicaComponentType, Component*> m_Components;
-	std::vector<EntityTimer*> m_Timers;
-	std::vector<EntityTimer*> m_PendingTimers;
-	std::vector<EntityCallbackTimer*> m_CallbackTimers;
+	std::vector<EntityTimer> m_Timers;
+	std::vector<EntityTimer> m_PendingTimers;
+	std::vector<EntityCallbackTimer> m_CallbackTimers;
+	std::vector<EntityCallbackTimer> m_PendingCallbackTimers;
 
 	bool m_ShouldDestroyAfterUpdate = false;
 

dGame/EntityManager.cpp

@@ -11,7 +11,6 @@
 #include "SkillComponent.h"
 #include "SwitchComponent.h"
 #include "UserManager.h"
-#include "PacketUtils.h"
 #include "Metrics.hpp"
 #include "dZoneManager.h"
 #include "MissionComponent.h"
@@ -389,8 +388,6 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 		Game::server->Send(&stream, sysAddr, false);
 	}
 
-	// PacketUtils::SavePacket("[24]_"+std::to_string(entity->GetObjectID()) + "_" + std::to_string(m_SerializationCounter) + ".bin", (char*)stream.GetData(), stream.GetNumberOfBytesUsed());
-
 	if (entity->IsPlayer()) {
 		if (entity->GetGMLevel() > eGameMasterLevel::CIVILIAN) {
 			GameMessages::SendToggleGMInvis(entity->GetObjectID(), true, sysAddr);
@@ -434,8 +431,6 @@ void EntityManager::SerializeEntity(Entity* entity) {
 	if (std::find(m_EntitiesToSerialize.begin(), m_EntitiesToSerialize.end(), entity->GetObjectID()) == m_EntitiesToSerialize.end()) {
 		m_EntitiesToSerialize.push_back(entity->GetObjectID());
 	}
-
-	//PacketUtils::SavePacket(std::to_string(m_SerializationCounter) + "_[27]_"+std::to_string(entity->GetObjectID()) + ".bin", (char*)stream.GetData(), stream.GetNumberOfBytesUsed());
 }
 
 void EntityManager::DestructAllEntities(const SystemAddress& sysAddr) {

dGame/Player.cpp

@@ -3,162 +3,22 @@
 #include <ctime>
 
 #include "Character.h"
-#include "Database.h"
-#include "MissionComponent.h"
 #include "UserManager.h"
 #include "EntityManager.h"
+#include "Game.h"
 #include "Logger.h"
-#include "ZoneInstanceManager.h"
-#include "WorldPackets.h"
 #include "dZoneManager.h"
-#include "CharacterComponent.h"
-#include "Mail.h"
 #include "User.h"
 #include "CppScripts.h"
 #include "Loot.h"
 #include "eReplicaComponentType.h"
 
-std::vector<Player*> Player::m_Players = {};
+namespace {
+	std::vector<Player*> m_Players;
+};
 
-Player::Player(const LWOOBJID& objectID, const EntityInfo info, User* user, Entity* parentEntity) : Entity(objectID, info, parentEntity) {
-	m_ParentUser = user;
-	m_Character = m_ParentUser->GetLastUsedChar();
-	m_ParentUser->SetLoggedInChar(objectID);
-	m_GMLevel = m_Character->GetGMLevel();
-	m_SystemAddress = m_ParentUser->GetSystemAddress();
-	m_DroppedLoot = {};
-	m_DroppedCoins = 0;
-
-	m_GhostReferencePoint = NiPoint3::ZERO;
-	m_GhostOverridePoint = NiPoint3::ZERO;
-	m_GhostOverride = false;
-	m_ObservedEntitiesLength = 256;
-	m_ObservedEntitiesUsed = 0;
-	m_ObservedEntities.resize(m_ObservedEntitiesLength);
-
-	m_Character->SetEntity(this);
-
-	const auto& iter = std::find(m_Players.begin(), m_Players.end(), this);
-
-	if (iter != m_Players.end()) {
-		return;
-	}
-
-	m_Players.push_back(this);
-}
-
-User* Player::GetParentUser() const {
-	return m_ParentUser;
-}
-
-SystemAddress Player::GetSystemAddress() const {
-	return m_SystemAddress;
-}
-
-void Player::SetSystemAddress(const SystemAddress& value) {
-	m_SystemAddress = value;
-}
-
-void Player::SetRespawnPos(const NiPoint3 position) {
-	if (!m_Character) return;
-
-	m_respawnPos = position;
-
-	m_Character->SetRespawnPoint(Game::zoneManager->GetZone()->GetWorldID(), position);
-}
-
-void Player::SetRespawnRot(const NiQuaternion rotation) {
-	m_respawnRot = rotation;
-}
-
-NiPoint3 Player::GetRespawnPosition() const {
-	return m_respawnPos;
-}
-
-NiQuaternion Player::GetRespawnRotation() const {
-	return m_respawnRot;
-}
-
-void Player::SendMail(const LWOOBJID sender, const std::string& senderName, const std::string& subject, const std::string& body, LOT attachment, uint16_t attachmentCount) const {
-	Mail::SendMail(sender, senderName, this, subject, body, attachment, attachmentCount);
-}
-
-void Player::SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId) {
-	const auto objid = GetObjectID();
-
-	ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, zoneId, cloneId, false, [objid](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string serverIP, uint16_t serverPort) {
-		auto* entity = Game::entityManager->GetEntity(objid);
-
-		if (entity == nullptr) {
-			return;
-		}
-
-		const auto sysAddr = entity->GetSystemAddress();
-
-		auto* character = entity->GetCharacter();
-		auto* characterComponent = entity->GetComponent<CharacterComponent>();
-
-		if (character != nullptr && characterComponent != nullptr) {
-			character->SetZoneID(zoneID);
-			character->SetZoneInstance(zoneInstance);
-			character->SetZoneClone(zoneClone);
-
-			characterComponent->SetLastRocketConfig(u"");
-
-			character->SaveXMLToDatabase();
-		}
-
-		WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
-
-		Game::entityManager->DestructEntity(entity);
-		return;
-		});
-}
-
-void Player::AddLimboConstruction(LWOOBJID objectId) {
-	const auto& iter = std::find(m_LimboConstructions.begin(), m_LimboConstructions.end(), objectId);
-
-	if (iter != m_LimboConstructions.end()) {
-		return;
-	}
-
-	m_LimboConstructions.push_back(objectId);
-}
-
-void Player::RemoveLimboConstruction(LWOOBJID objectId) {
-	const auto& iter = std::find(m_LimboConstructions.begin(), m_LimboConstructions.end(), objectId);
-
-	if (iter == m_LimboConstructions.end()) {
-		return;
-	}
-
-	m_LimboConstructions.erase(iter);
-}
-
-void Player::ConstructLimboEntities() {
-	for (const auto objectId : m_LimboConstructions) {
-		auto* entity = Game::entityManager->GetEntity(objectId);
-
-		if (entity == nullptr) {
-			continue;
-		}
-
-		Game::entityManager->ConstructEntity(entity, m_SystemAddress);
-	}
-
-	m_LimboConstructions.clear();
-}
-
-std::map<LWOOBJID, Loot::Info>& Player::GetDroppedLoot() {
-	return m_DroppedLoot;
-}
-
-const NiPoint3& Player::GetGhostReferencePoint() const {
-	return m_GhostOverride ? m_GhostOverridePoint : m_GhostReferencePoint;
-}
-
-const NiPoint3& Player::GetOriginGhostReferencePoint() const {
-	return m_GhostReferencePoint;
+const std::vector<Player*>& Player::GetAllPlayers() {
+	return m_Players;
 }
 
 void Player::SetGhostReferencePoint(const NiPoint3& value) {
@@ -169,52 +29,94 @@ void Player::SetGhostOverridePoint(const NiPoint3& value) {
 	m_GhostOverridePoint = value;
 }
 
-const NiPoint3& Player::GetGhostOverridePoint() const {
-	return m_GhostOverridePoint;
+void Player::SetRespawnPos(const NiPoint3& position) {
+	if (!m_Character) return;
+
+	m_respawnPos = position;
+
+	m_Character->SetRespawnPoint(Game::zoneManager->GetZone()->GetWorldID(), position);
+
 }
 
-void Player::SetGhostOverride(bool value) {
-	m_GhostOverride = value;
+void Player::SetRespawnRot(const NiQuaternion& rotation) {
+	m_respawnRot = rotation;
 }
 
-bool Player::GetGhostOverride() const {
-	return m_GhostOverride;
+void Player::SetSystemAddress(const SystemAddress& value) {
+	m_SystemAddress = value;
+}
+
+Player::Player(const LWOOBJID& objectID, const EntityInfo info, User* user, Entity* parentEntity) : Entity(objectID, info, parentEntity) {
+	m_ParentUser = user;
+	m_Character = m_ParentUser->GetLastUsedChar();
+	m_ParentUser->SetLoggedInChar(objectID);
+	m_GMLevel = m_Character->GetGMLevel();
+	m_SystemAddress = m_ParentUser->GetSystemAddress();
+	m_DroppedCoins = 0;
+
+	m_GhostReferencePoint = NiPoint3::ZERO;
+	m_GhostOverridePoint = NiPoint3::ZERO;
+	m_GhostOverride = false;
+
+	int32_t initialObservedEntitiesCapacity = 256;
+	m_ObservedEntities.resize(initialObservedEntitiesCapacity);
+
+	m_Character->SetEntity(this);
+
+	const auto& iter = std::find(m_Players.begin(), m_Players.end(), this);
+
+	if (iter == m_Players.end()) {
+		m_Players.push_back(this);
+	}
+}
+
+void Player::AddLimboConstruction(LWOOBJID objectId) {
+	const auto iter = std::find(m_LimboConstructions.begin(), m_LimboConstructions.end(), objectId);
+	if (iter == m_LimboConstructions.end()) {
+		m_LimboConstructions.push_back(objectId);
+	}
+}
+
+void Player::RemoveLimboConstruction(LWOOBJID objectId) {
+	const auto iter = std::find(m_LimboConstructions.begin(), m_LimboConstructions.end(), objectId);
+	if (iter != m_LimboConstructions.end()) {
+		m_LimboConstructions.erase(iter);
+	}	
+}
+
+void Player::ConstructLimboEntities() {
+	for (const auto& objectId : m_LimboConstructions) {
+		auto* entity = Game::entityManager->GetEntity(objectId);
+		if (!entity) continue;
+
+		Game::entityManager->ConstructEntity(entity, m_SystemAddress);
+	}
+
+	m_LimboConstructions.clear();
 }
 
 void Player::ObserveEntity(int32_t id) {
-	for (int32_t i = 0; i < m_ObservedEntitiesUsed; i++) {
-		if (m_ObservedEntities[i] == 0 || m_ObservedEntities[i] == id) {
-			m_ObservedEntities[i] = id;
+	for (auto& observedEntity : m_ObservedEntities) {
+		if (observedEntity == 0 || observedEntity == id) {
+			observedEntity = id;
 
 			return;
 		}
 	}
 
-	const auto index = m_ObservedEntitiesUsed++;
+	m_ObservedEntities.reserve(m_ObservedEntities.size() + 1);
 
-	if (m_ObservedEntitiesUsed > m_ObservedEntitiesLength) {
-		m_ObservedEntities.resize(m_ObservedEntitiesLength + m_ObservedEntitiesLength);
-
-		m_ObservedEntitiesLength = m_ObservedEntitiesLength + m_ObservedEntitiesLength;
-	}
-
-	m_ObservedEntities[index] = id;
+	m_ObservedEntities.push_back(id);
 }
 
 bool Player::IsObserved(int32_t id) {
-	for (int32_t i = 0; i < m_ObservedEntitiesUsed; i++) {
-		if (m_ObservedEntities[i] == id) {
-			return true;
-		}
-	}
-
-	return false;
+	return std::find(m_ObservedEntities.begin(), m_ObservedEntities.end(), id) != m_ObservedEntities.end();
 }
 
 void Player::GhostEntity(int32_t id) {
-	for (int32_t i = 0; i < m_ObservedEntitiesUsed; i++) {
-		if (m_ObservedEntities[i] == id) {
-			m_ObservedEntities[i] = 0;
+	for (auto& observedEntity : m_ObservedEntities) {
+		if (observedEntity == id) {
+			observedEntity = 0;
 		}
 	}
 }
@@ -228,59 +130,44 @@ Player* Player::GetPlayer(const SystemAddress& sysAddr) {
 Player* Player::GetPlayer(const std::string& name) {
 	const auto characters = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::CHARACTER);
 
+	Player* player = nullptr;
 	for (auto* character : characters) {
 		if (!character->IsPlayer()) continue;
 		
 		if (GeneralUtils::CaseInsensitiveStringCompare(name, character->GetCharacter()->GetName())) {
-			return dynamic_cast<Player*>(character);
+			player = dynamic_cast<Player*>(character);
 		}
 	}
 
-	return nullptr;
+	return player;
 }
 
 Player* Player::GetPlayer(LWOOBJID playerID) {
+	Player* playerToReturn = nullptr;
 	for (auto* player : m_Players) {
 		if (player->GetObjectID() == playerID) {
-			return player;
+			playerToReturn = player;
 		}
 	}
 
-	return nullptr;
-}
-
-const std::vector<Player*>& Player::GetAllPlayers() {
-	return m_Players;
-}
-
-uint64_t Player::GetDroppedCoins() {
-	return m_DroppedCoins;
-}
-
-void Player::SetDroppedCoins(uint64_t value) {
-	m_DroppedCoins = value;
+	return playerToReturn;
 }
 
 Player::~Player() {
 	LOG("Deleted player");
 
-	for (int32_t i = 0; i < m_ObservedEntitiesUsed; i++) {
-		const auto id = m_ObservedEntities[i];
+	for (auto& observedEntity : m_ObservedEntities) {
+		if (observedEntity == 0) continue;
 
-		if (id == 0) {
-			continue;
-		}
-
-		auto* entity = Game::entityManager->GetGhostCandidate(id);
-
-		if (entity != nullptr) {
-			entity->SetObservers(entity->GetObservers() - 1);
-		}
+		auto* entity = Game::entityManager->GetGhostCandidate(observedEntity);
+		if (!entity) continue;
+		
+		entity->SetObservers(entity->GetObservers() - 1);
 	}
 
 	m_LimboConstructions.clear();
 
-	const auto& iter = std::find(m_Players.begin(), m_Players.end(), this);
+	const auto iter = std::find(m_Players.begin(), m_Players.end(), this);
 
 	if (iter == m_Players.end()) {
 		return;

dGame/Player.h

@@ -18,64 +18,44 @@ public:
 	 * Getters
 	 */
 
-	User* GetParentUser() const override;
+	User* GetParentUser() const override { return m_ParentUser; };
 
-	SystemAddress GetSystemAddress() const override;
+	const SystemAddress& GetSystemAddress() const override { return m_SystemAddress; };
 
-	NiPoint3 GetRespawnPosition() const override;
+	const NiPoint3& GetRespawnPosition() const override { return m_respawnPos; };
 
-	NiQuaternion GetRespawnRotation() const override;
+	const NiQuaternion& GetRespawnRotation() const override { return m_respawnRot; };
 
-	const NiPoint3& GetGhostReferencePoint() const;
+	const NiPoint3& GetGhostReferencePoint() const { return m_GhostOverride ? m_GhostOverridePoint : m_GhostReferencePoint; };
 
-	const NiPoint3& GetOriginGhostReferencePoint() const;
+	const NiPoint3& GetOriginGhostReferencePoint() const { return m_GhostReferencePoint; };
 
-	const NiPoint3& GetGhostOverridePoint() const;
+	const NiPoint3& GetGhostOverridePoint() const { return m_GhostOverridePoint; };
 
-	bool GetGhostOverride() const;
+	bool GetGhostOverride() const { return m_GhostOverride; };
 
-	std::map<LWOOBJID, Loot::Info>& GetDroppedLoot();
+	std::map<LWOOBJID, Loot::Info>& GetDroppedLoot() { return m_DroppedLoot; };
 
-	uint64_t GetDroppedCoins();
+	uint64_t GetDroppedCoins() const { return m_DroppedCoins; };
 
 	/**
 	 * Setters
 	 */
 
+	void SetGhostOverride(bool value) { m_GhostOverride = value; };
+
+	void SetDroppedCoins(const uint64_t value) { m_DroppedCoins = value; };
+
 	void SetSystemAddress(const SystemAddress& value) override;
 
-	void SetRespawnPos(NiPoint3 position) override;
+	void SetRespawnPos(const NiPoint3& position) override;
 
-	void SetRespawnRot(NiQuaternion rotation) override;
+	void SetRespawnRot(const NiQuaternion& rotation) override;
 
 	void SetGhostReferencePoint(const NiPoint3& value);
 
 	void SetGhostOverridePoint(const NiPoint3& value);
 
-	void SetGhostOverride(bool value);
-
-	void SetDroppedCoins(uint64_t value);
-
-	/**
-	 * Wrapper for sending an in-game mail.
-	 *
-	 * @param sender id of the sender. LWOOBJID_EMPTY for system mail
-	 * @param senderName name of the sender. Max 32 characters.
-	 * @param subject mail subject. Max 50 characters.
-	 * @param body mail body. Max 400 characters.
-	 * @param attachment LOT of the attached item. LOT_NULL if no attachment.
-	 * @param attachmentCount stack size for attachment.
-	 */
-	void SendMail(LWOOBJID sender, const std::string& senderName, const std::string& subject, const std::string& body, LOT attachment, uint16_t attachmentCount) const;
-
-	/**
-	 * Wrapper for transfering the player to another instance.
-	 *
-	 * @param zoneId zoneID for the new instance.
-	 * @param cloneId cloneID for the new instance.
-	 */
-	void SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId = 0);
-
 	/**
 	 * Ghosting
 	 */
@@ -86,11 +66,11 @@ public:
 
 	void ConstructLimboEntities();
 
-	void ObserveEntity(int32_t id);
+	void ObserveEntity(const int32_t id);
 
-	bool IsObserved(int32_t id);
+	bool IsObserved(const int32_t id);
 
-	void GhostEntity(int32_t id);
+	void GhostEntity(const int32_t id);
 
 	/**
 	 * Static methods
@@ -122,15 +102,9 @@ private:
 
 	std::vector<int32_t> m_ObservedEntities;
 
-	int32_t m_ObservedEntitiesLength;
-
-	int32_t m_ObservedEntitiesUsed;
-
 	std::vector<LWOOBJID> m_LimboConstructions;
 
 	std::map<LWOOBJID, Loot::Info> m_DroppedLoot;
 
 	uint64_t m_DroppedCoins;
-
-	static std::vector<Player*> m_Players;
 };

dGame/UserManager.cpp

@@ -11,7 +11,6 @@
 #include "WorldPackets.h"
 #include "Character.h"
 #include "BitStream.h"
-#include "PacketUtils.h"
 #include "ObjectIDManager.h"
 #include "Logger.h"
 #include "GeneralUtils.h"
@@ -216,31 +215,92 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
 		chars.push_back(character);
 	}
 
-	WorldPackets::SendCharacterList(sysAddr, u);
+	RakNet::BitStream bitStream;
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE);
+
+	std::vector<Character*> characters = u->GetCharacters();
+	bitStream.Write<uint8_t>(characters.size());
+	bitStream.Write<uint8_t>(0); //TODO: Pick the most recent played index.  character index in front, just picking 0
+
+	for (uint32_t i = 0; i < characters.size(); ++i) {
+		bitStream.Write(characters[i]->GetObjectID());
+		bitStream.Write<uint32_t>(0);
+
+		bitStream.Write(LUWString(characters[i]->GetName()));
+		bitStream.Write(LUWString(characters[i]->GetUnapprovedName()));
+
+		bitStream.Write<uint8_t>(characters[i]->GetNameRejected());
+		bitStream.Write<uint8_t>(false);
+
+		bitStream.Write(LUString("", 10));
+
+		bitStream.Write(characters[i]->GetShirtColor());
+		bitStream.Write(characters[i]->GetShirtStyle());
+		bitStream.Write(characters[i]->GetPantsColor());
+		bitStream.Write(characters[i]->GetHairStyle());
+		bitStream.Write(characters[i]->GetHairColor());
+		bitStream.Write(characters[i]->GetLeftHand());
+		bitStream.Write(characters[i]->GetRightHand());
+		bitStream.Write(characters[i]->GetEyebrows());
+		bitStream.Write(characters[i]->GetEyes());
+		bitStream.Write(characters[i]->GetMouth());
+		bitStream.Write<uint32_t>(0);
+
+		bitStream.Write<uint16_t>(characters[i]->GetZoneID());
+		bitStream.Write<uint16_t>(characters[i]->GetZoneInstance());
+		bitStream.Write(characters[i]->GetZoneClone());
+
+		bitStream.Write(characters[i]->GetLastLogin());
+
+		const auto& equippedItems = characters[i]->GetEquippedItems();
+		bitStream.Write<uint16_t>(equippedItems.size());
+
+		for (uint32_t j = 0; j < equippedItems.size(); ++j) {
+			bitStream.Write(equippedItems[j]);
+		}
+	}
+
+	SEND_PACKET;
 }
 
 void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet) {
 	User* u = GetUser(sysAddr);
 	if (!u) return;
+	
+	LUWString LUWStringName(33);
+	uint32_t firstNameIndex;
+	uint32_t middleNameIndex;
+	uint32_t lastNameIndex;
+	uint32_t shirtColor;
+	uint32_t shirtStyle;
+	uint32_t pantsColor;
+	uint32_t hairStyle;
+	uint32_t hairColor;
+	uint32_t lh;
+	uint32_t rh;
+	uint32_t eyebrows;
+	uint32_t eyes;
+	uint32_t mouth;
 
-	std::string name = PacketUtils::ReadString(8, packet, true);
+	CINSTREAM_SKIP_HEADER;
+	inStream.Read(LUWStringName);
+	inStream.Read(firstNameIndex);
+	inStream.Read(middleNameIndex);
+	inStream.Read(lastNameIndex);
+	inStream.IgnoreBytes(9);
+	inStream.Read(shirtColor);
+	inStream.Read(shirtStyle);
+	inStream.Read(pantsColor);
+	inStream.Read(hairStyle);
+	inStream.Read(hairColor);
+	inStream.Read(lh);
+	inStream.Read(rh);
+	inStream.Read(eyebrows);
+	inStream.Read(eyes);
+	inStream.Read(mouth);
 
-	uint32_t firstNameIndex = PacketUtils::ReadU32(74, packet);
-	uint32_t middleNameIndex = PacketUtils::ReadU32(78, packet);
-	uint32_t lastNameIndex = PacketUtils::ReadU32(82, packet);
+	const auto name = LUWStringName.GetAsString();
 	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);
-
 	LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle);
 	LOT pantsLOT = FindCharPantsID(pantsColor);
 
@@ -322,7 +382,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
 		UserManager::RequestCharacterList(sysAddr);
-	});
+		});
 }
 
 void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet) {
@@ -332,7 +392,9 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 		return;
 	}
 
-	LWOOBJID objectID = PacketUtils::ReadS64(8, packet);
+	CINSTREAM_SKIP_HEADER;
+	LWOOBJID objectID;
+	inStream.Read(objectID);
 	uint32_t charID = static_cast<uint32_t>(objectID);
 
 	LOG("Received char delete req for ID: %llu (%u)", objectID, charID);
@@ -366,14 +428,18 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 		return;
 	}
 
-	LWOOBJID objectID = PacketUtils::ReadS64(8, packet);
+	CINSTREAM_SKIP_HEADER;
+	LWOOBJID objectID;
+	inStream.Read(objectID);	
 	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);
 
-	std::string newName = PacketUtils::ReadString(16, packet, true);
+	LUWString LUWStringName(33);
+	inStream.Read(LUWStringName);
+	const auto newName = LUWStringName.GetAsString();
 
 	Character* character = nullptr;
 

dGame/dComponents/ActivityComponent.cpp

@@ -30,40 +30,36 @@
 #include "LeaderboardManager.h"
 
 ActivityComponent::ActivityComponent(Entity* parent, int32_t activityID) : Component(parent) {
-	if (activityID > 0) m_ActivityID = activityID;
-	else m_ActivityID = parent->GetVar<int32_t>(u"activityID");
-	CDActivitiesTable* activitiesTable = CDClientManager::Instance().GetTable<CDActivitiesTable>();
-	std::vector<CDActivities> activities = activitiesTable->Query([this](CDActivities entry) {return (entry.ActivityID == m_ActivityID); });
+	/*
+	* This is precisely what the client does functionally
+	* Use the component id as the default activity id and load its data from the database
+	* if activityID is specified and if that column exists in the activities table, update the activity info with that data.
+	*/
 
-	for (CDActivities activity : activities) {
-		m_ActivityInfo = activity;
-		if (static_cast<Leaderboard::Type>(activity.leaderboardType) == Leaderboard::Type::Racing && Game::config->GetValue("solo_racing") == "1") {
-			m_ActivityInfo.minTeamSize = 1;
-			m_ActivityInfo.minTeams = 1;
-		}
-		if (m_ActivityInfo.instanceMapID == -1) {
-			const auto& transferOverride = parent->GetVarAsString(u"transferZoneID");
-			if (!transferOverride.empty()) {
-				GeneralUtils::TryParse(transferOverride, m_ActivityInfo.instanceMapID);
-			}
-		}
+	m_ActivityID = activityID;
+	LoadActivityData(activityID);
+	if (m_Parent->HasVar(u"activityID")) {
+		m_ActivityID = parent->GetVar<int32_t>(u"activityID");
+		LoadActivityData(m_ActivityID);
 	}
 
 	auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
 
 	if (destroyableComponent) {
-		// check for LMIs and set the loot LMIs
+		// First lookup the loot matrix id for this component id.
 		CDActivityRewardsTable* activityRewardsTable = CDClientManager::Instance().GetTable<CDActivityRewardsTable>();
 		std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([=](CDActivityRewards entry) {return (entry.LootMatrixIndex == destroyableComponent->GetLootMatrixID()); });
 
 		uint32_t startingLMI = 0;
 
+		// If we have one, set the starting loot matrix id to that.
 		if (activityRewards.size() > 0) {
 			startingLMI = activityRewards[0].LootMatrixIndex;
 		}
 
 		if (startingLMI > 0) {
-			// now time for bodge :)
+			// We may have more than 1 loot matrix index to use depending ont the size of the team that is looting the activity.
+			// So this logic will get the rest of the loot matrix indices for this activity.
 
 			std::vector<CDActivityRewards> objectTemplateActivities = activityRewardsTable->Query([=](CDActivityRewards entry) {return (activityRewards[0].objectTemplate == entry.objectTemplate); });
 			for (const auto& item : objectTemplateActivities) {
@@ -74,6 +70,25 @@ ActivityComponent::ActivityComponent(Entity* parent, int32_t activityID) : Compo
 		}
 	}
 }
+void ActivityComponent::LoadActivityData(const int32_t activityId) {
+	CDActivitiesTable* activitiesTable = CDClientManager::Instance().GetTable<CDActivitiesTable>();
+	std::vector<CDActivities> activities = activitiesTable->Query([activityId](CDActivities entry) {return (entry.ActivityID == activityId); });
+
+	bool soloRacing = Game::config->GetValue("solo_racing") == "1";
+	for (CDActivities activity : activities) {
+		m_ActivityInfo = activity;
+		if (static_cast<Leaderboard::Type>(activity.leaderboardType) == Leaderboard::Type::Racing && soloRacing) {
+			m_ActivityInfo.minTeamSize = 1;
+			m_ActivityInfo.minTeams = 1;
+		}
+		if (m_ActivityInfo.instanceMapID == -1) {
+			const auto& transferOverride = m_Parent->GetVarAsString(u"transferZoneID");
+			if (!transferOverride.empty()) {
+				GeneralUtils::TryParse(transferOverride, m_ActivityInfo.instanceMapID);
+			}
+		}
+	}
+}
 
 void ActivityComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
 	outBitStream->Write(m_DirtyActivityInfo);

dGame/dComponents/ActivityComponent.h

@@ -152,6 +152,8 @@ class ActivityComponent : public Component {
 public:
 	ActivityComponent(Entity* parent, int32_t activityID);
 
+	void LoadActivityData(const int32_t activityId);
+
 	void Update(float deltaTime) override;
 	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
 

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -34,7 +34,6 @@ BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const uint32_t id):
 	m_MovementAI = nullptr;
 	m_Disabled = false;
 	m_SkillEntries = {};
-	m_MovementAI = nullptr;
 	m_SoftTimer = 5.0f;
 
 	//Grab the aggro information from BaseCombatAI:

dGame/dComponents/CharacterComponent.cpp

@@ -20,6 +20,8 @@
 #include "Database.h"
 #include "CDRewardCodesTable.h"
 #include "Mail.h"
+#include "ZoneInstanceManager.h"
+#include "WorldPackets.h"
 #include <ctime>
 
 CharacterComponent::CharacterComponent(Entity* parent, Character* character) : Component(parent) {
@@ -763,12 +765,12 @@ void CharacterComponent::AwardClaimCodes() {
 	if (!m_Parent) return;
 	auto* user = m_Parent->GetParentUser();
 	if (!user) return;
-	
+
 	auto rewardCodes = Database::Get()->GetRewardCodesByAccountID(user->GetAccountID());
 	if (rewardCodes.empty()) return;
 
 	auto* cdrewardCodes = CDClientManager::Instance().GetTable<CDRewardCodesTable>();
-	for (auto const rewardCode: rewardCodes){
+	for (auto const rewardCode : rewardCodes) {
 		LOG_DEBUG("Processing RewardCode %i", rewardCode);
 		const uint32_t rewardCodeIndex = rewardCode >> 6;
 		const uint32_t bitIndex = rewardCode % 64;
@@ -786,3 +788,32 @@ void CharacterComponent::AwardClaimCodes() {
 		Mail::SendMail(LWOOBJID_EMPTY, "%[MAIL_SYSTEM_NOTIFICATION]", m_Parent, subject.str(), body.str(), attachmentLOT, 1);
 	}
 }
+
+void CharacterComponent::SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId) const {
+	const auto objid = m_Parent->GetObjectID();
+
+	ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, zoneId, cloneId, false, [objid](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string serverIP, uint16_t serverPort) {
+		auto* entity = Game::entityManager->GetEntity(objid);
+
+		if (!entity) return;
+
+		const auto sysAddr = entity->GetSystemAddress();
+
+		auto* character = entity->GetCharacter();
+		auto* characterComponent = entity->GetComponent<CharacterComponent>();
+
+		if (character && characterComponent) {
+			character->SetZoneID(zoneID);
+			character->SetZoneInstance(zoneInstance);
+			character->SetZoneClone(zoneClone);
+
+			characterComponent->SetLastRocketConfig(u"");
+
+			character->SaveXMLToDatabase();
+		}
+
+		WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+
+		Game::entityManager->DestructEntity(entity);
+		});
+}

dGame/dComponents/CharacterComponent.h

@@ -281,6 +281,14 @@ public:
 
 	LWOOBJID GetCurrentInteracting() {return m_CurrentInteracting;};
 
+	/**
+	 * Sends a player to another zone with an optional clone ID
+	 *
+	 * @param zoneId zoneID for the new instance.
+	 * @param cloneId cloneID for the new instance.
+	 */
+	void SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId = 0) const;
+
 	/**
 	 * Character info regarding this character, including clothing styles, etc.
 	 */

dGame/dComponents/HavokVehiclePhysicsComponent.h

@@ -4,31 +4,7 @@
 #include "Entity.h"
 #include "PhysicsComponent.h"
 #include "eReplicaComponentType.h"
-
-struct RemoteInputInfo {
-	RemoteInputInfo() {
-		m_RemoteInputX = 0;
-		m_RemoteInputY = 0;
-		m_IsPowersliding = false;
-		m_IsModified = false;
-	}
-
-	void operator=(const RemoteInputInfo& other) {
-		m_RemoteInputX = other.m_RemoteInputX;
-		m_RemoteInputY = other.m_RemoteInputY;
-		m_IsPowersliding = other.m_IsPowersliding;
-		m_IsModified = other.m_IsModified;
-	}
-
-	bool operator==(const RemoteInputInfo& other) {
-		return m_RemoteInputX == other.m_RemoteInputX && m_RemoteInputY == other.m_RemoteInputY && m_IsPowersliding == other.m_IsPowersliding && m_IsModified == other.m_IsModified;
-	}
-
-	float m_RemoteInputX;
-	float m_RemoteInputY;
-	bool m_IsPowersliding;
-	bool m_IsModified;
-};
+#include "PositionUpdate.h"
 
 /**
  * Physics component for vehicles.