Player: Saving fixes

Address issue of allowing a character to be saved before they were ready for updates.

README.md

@@ -23,6 +23,9 @@ We do not recommend hosting public servers. Darkflame Universe is intended for s
 ### Supply of resource files
 Darkflame Universe is a server emulator and does not distribute any LEGO® Universe files. A separate game client is required to setup this server emulator and play the game, which we cannot supply. Users are strongly suggested to refer to the safe checksums listed [here](#verifying-your-client-files) to see if a client will work.
 
+## Step by step walkthrough for a single-player server
+If you would like a setup for a single player server only on a Windows machine, use the [Native Windows Setup Guide by HailStorm](https://gist.github.com/HailStorm32/169df65a47a104199b5cc57d10fa57de) and skip this README.
+
 ## Steps to setup server
 * [Clone this repository](#clone-the-repository)
 * [Install dependencies](#install-dependencies)

dAuthServer/AuthServer.cpp

@@ -94,6 +94,8 @@ int main(int argc, char** argv) {
 	uint32_t framesSinceMasterDisconnect = 0;
 	uint32_t framesSinceLastSQLPing = 0;
 
+	AuthPackets::LoadClaimCodes();
+	
 	while (!Game::shouldShutdown) {
 		//Check if we're still connected to master:
 		if (!Game::server->GetIsConnectedToMaster()) {

dChatServer/CMakeLists.txt

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

dChatServer/ChatIgnoreList.cpp

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

dChatServer/ChatIgnoreList.h

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

dChatServer/ChatPacketHandler.cpp

@@ -19,15 +19,13 @@
 #include "eClientMessageType.h"
 #include "eGameMessageType.h"
 
-extern PlayerContainer playerContainer;
-
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
 	CINSTREAM_SKIP_HEADER;
 	LWOOBJID playerID = 0;
 	inStream.Read(playerID);
 
-	auto player = playerContainer.GetPlayerData(playerID);
+	auto player = Game::playerContainer.GetPlayerData(playerID);
 	if (!player) return;
 
 	auto friendsList = Database::Get()->GetFriendsList(playerID);
@@ -43,7 +41,7 @@ void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 		fd.friendName = friendData.friendName;
 
 		//Now check if they're online:
-		auto fr = playerContainer.GetPlayerData(fd.friendID);
+		auto fr = Game::playerContainer.GetPlayerData(fd.friendID);
 
 		if (fr) {
 			fd.isOnline = true;
@@ -97,7 +95,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 	char isBestFriendRequest{};
 	inStream.Read(isBestFriendRequest);
 
-	auto requestor = playerContainer.GetPlayerData(requestorPlayerID);
+	auto requestor = Game::playerContainer.GetPlayerData(requestorPlayerID);
 	if (!requestor) {
 		LOG("No requestor player %llu sent to %s found.", requestorPlayerID, playerName.c_str());
 		return;
@@ -107,7 +105,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 		SendFriendResponse(requestor, requestor, eAddFriendResponseType::MYTHRAN);
 		return;
 	};
-	std::unique_ptr<PlayerData> requestee(playerContainer.GetPlayerData(playerName));
+	std::unique_ptr<PlayerData> requestee(Game::playerContainer.GetPlayerData(playerName));
 
 	// Check if player is online first
 	if (isBestFriendRequest && !requestee) {
@@ -175,7 +173,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 
 		// Only do updates if there was a change in the bff status.
 		if (oldBestFriendStatus != bestFriendStatus) {
-			auto maxBestFriends = playerContainer.GetMaxNumberOfBestFriends();
+			auto maxBestFriends = Game::playerContainer.GetMaxNumberOfBestFriends();
 			if (requestee->countOfBestFriends >= maxBestFriends || requestor->countOfBestFriends >= maxBestFriends) {
 				if (requestee->countOfBestFriends >= maxBestFriends) {
 					SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
@@ -208,7 +206,7 @@ void ChatPacketHandler::HandleFriendRequest(Packet* packet) {
 			if (requestor->sysAddr != UNASSIGNED_SYSTEM_ADDRESS) SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::WAITINGAPPROVAL, true, true);
 		}
 	} else {
-		auto maxFriends = playerContainer.GetMaxNumberOfFriends();
+		auto maxFriends = Game::playerContainer.GetMaxNumberOfFriends();
 		if (requestee->friends.size() >= maxFriends) {
 			SendFriendResponse(requestor, requestee.get(), eAddFriendResponseType::THEIRFRIENDLISTFULL, false);
 		} else if (requestor->friends.size() >= maxFriends) {
@@ -232,8 +230,8 @@ void ChatPacketHandler::HandleFriendResponse(Packet* packet) {
 	std::string friendName = PacketUtils::ReadString(0x15, packet, true);
 
 	//Now to try and find both of these:
-	auto requestor = playerContainer.GetPlayerData(playerID);
-	auto requestee = playerContainer.GetPlayerData(friendName);
+	auto requestor = Game::playerContainer.GetPlayerData(playerID);
+	auto requestee = Game::playerContainer.GetPlayerData(friendName);
 	if (!requestor || !requestee) return;
 
 	eAddFriendResponseType serverResponseCode{};
@@ -315,7 +313,7 @@ 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 = playerContainer.GetPlayerData(playerID);
+	auto goonA = Game::playerContainer.GetPlayerData(playerID);
 	if (goonA) {
 		// Remove the friend from our list of friends
 		for (auto friendData = goonA->friends.begin(); friendData != goonA->friends.end(); friendData++) {
@@ -328,7 +326,7 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 		SendRemoveFriend(goonA, friendName, true);
 	}
 
-	auto goonB = playerContainer.GetPlayerData(friendID);
+	auto goonB = Game::playerContainer.GetPlayerData(friendID);
 	if (!goonB) return;
 	// Do it again for other person
 	for (auto friendData = goonB->friends.begin(); friendData != goonB->friends.end(); friendData++) {
@@ -339,7 +337,7 @@ void ChatPacketHandler::HandleRemoveFriend(Packet* packet) {
 		}
 	}
 
-	std::string goonAName = GeneralUtils::UTF16ToWTF8(playerContainer.GetName(playerID));
+	std::string goonAName = GeneralUtils::UTF16ToWTF8(Game::playerContainer.GetName(playerID));
 	SendRemoveFriend(goonB, goonAName, true);
 }
 
@@ -348,11 +346,11 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
 
-	auto* sender = playerContainer.GetPlayerData(playerID);
+	auto* sender = Game::playerContainer.GetPlayerData(playerID);
 
 	if (sender == nullptr) return;
 
-	if (playerContainer.GetIsMuted(sender)) return;
+	if (Game::playerContainer.GetIsMuted(sender)) return;
 
 	const auto senderName = std::string(sender->playerName.c_str());
 
@@ -367,12 +365,12 @@ void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 
 	if (channel != 8) return;
 
-	auto* team = playerContainer.GetTeam(playerID);
+	auto* team = Game::playerContainer.GetTeam(playerID);
 
 	if (team == nullptr) return;
 
 	for (const auto memberId : team->memberIDs) {
-		auto* otherMember = playerContainer.GetPlayerData(memberId);
+		auto* otherMember = Game::playerContainer.GetPlayerData(memberId);
 
 		if (otherMember == nullptr) return;
 
@@ -406,11 +404,11 @@ void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
 	std::string message = PacketUtils::ReadString(0xAA, packet, true, 512);
 
 	//Get the bois:
-	auto goonA = playerContainer.GetPlayerData(senderID);
-	auto goonB = playerContainer.GetPlayerData(receiverName);
+	auto goonA = Game::playerContainer.GetPlayerData(senderID);
+	auto goonB = Game::playerContainer.GetPlayerData(receiverName);
 	if (!goonA || !goonB) return;
 
-	if (playerContainer.GetIsMuted(goonA)) return;
+	if (Game::playerContainer.GetIsMuted(goonA)) return;
 
 	std::string goonAName = goonA->playerName.c_str();
 	std::string goonBName = goonB->playerName.c_str();
@@ -468,25 +466,25 @@ void ChatPacketHandler::HandleTeamInvite(Packet* packet) {
 	inStream.Read(playerID);
 	std::string invitedPlayer = PacketUtils::ReadString(0x14, packet, true);
 
-	auto* player = playerContainer.GetPlayerData(playerID);
+	auto* player = Game::playerContainer.GetPlayerData(playerID);
 
 	if (player == nullptr) {
 		return;
 	}
 
-	auto* team = playerContainer.GetTeam(playerID);
+	auto* team = Game::playerContainer.GetTeam(playerID);
 
 	if (team == nullptr) {
-		team = playerContainer.CreateTeam(playerID);
+		team = Game::playerContainer.CreateTeam(playerID);
 	}
 
-	auto* other = playerContainer.GetPlayerData(invitedPlayer);
+	auto* other = Game::playerContainer.GetPlayerData(invitedPlayer);
 
 	if (other == nullptr) {
 		return;
 	}
 
-	if (playerContainer.GetTeam(other->playerID) != nullptr) {
+	if (Game::playerContainer.GetTeam(other->playerID) != nullptr) {
 		return;
 	}
 
@@ -519,12 +517,12 @@ void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
 		return;
 	}
 
-	auto* team = playerContainer.GetTeam(leaderID);
+	auto* team = Game::playerContainer.GetTeam(leaderID);
 
 	if (team == nullptr) {
 		LOG("Failed to find team for leader (%llu)", leaderID);
 
-		team = playerContainer.GetTeam(playerID);
+		team = Game::playerContainer.GetTeam(playerID);
 	}
 
 	if (team == nullptr) {
@@ -532,7 +530,7 @@ void ChatPacketHandler::HandleTeamInviteResponse(Packet* packet) {
 		return;
 	}
 
-	playerContainer.AddMember(team, playerID);
+	Game::playerContainer.AddMember(team, playerID);
 }
 
 void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
@@ -542,12 +540,12 @@ void ChatPacketHandler::HandleTeamLeave(Packet* packet) {
 	uint32_t size = 0;
 	inStream.Read(size);
 
-	auto* team = playerContainer.GetTeam(playerID);
+	auto* team = Game::playerContainer.GetTeam(playerID);
 
 	LOG("(%llu) leaving team", playerID);
 
 	if (team != nullptr) {
-		playerContainer.RemoveMember(team, playerID, false, false, true);
+		Game::playerContainer.RemoveMember(team, playerID, false, false, true);
 	}
 }
 
@@ -560,24 +558,24 @@ void ChatPacketHandler::HandleTeamKick(Packet* packet) {
 
 	LOG("(%llu) kicking (%s) from team", playerID, kickedPlayer.c_str());
 
-	auto* kicked = playerContainer.GetPlayerData(kickedPlayer);
+	auto* kicked = Game::playerContainer.GetPlayerData(kickedPlayer);
 
 	LWOOBJID kickedId = LWOOBJID_EMPTY;
 
 	if (kicked != nullptr) {
 		kickedId = kicked->playerID;
 	} else {
-		kickedId = playerContainer.GetId(GeneralUtils::UTF8ToUTF16(kickedPlayer));
+		kickedId = Game::playerContainer.GetId(GeneralUtils::UTF8ToUTF16(kickedPlayer));
 	}
 
 	if (kickedId == LWOOBJID_EMPTY) return;
 
-	auto* team = playerContainer.GetTeam(playerID);
+	auto* team = Game::playerContainer.GetTeam(playerID);
 
 	if (team != nullptr) {
 		if (team->leaderID != playerID || team->leaderID == kickedId) return;
 
-		playerContainer.RemoveMember(team, kickedId, false, true, false);
+		Game::playerContainer.RemoveMember(team, kickedId, false, true, false);
 	}
 }
 
@@ -590,16 +588,16 @@ void ChatPacketHandler::HandleTeamPromote(Packet* packet) {
 
 	LOG("(%llu) promoting (%s) to team leader", playerID, promotedPlayer.c_str());
 
-	auto* promoted = playerContainer.GetPlayerData(promotedPlayer);
+	auto* promoted = Game::playerContainer.GetPlayerData(promotedPlayer);
 
 	if (promoted == nullptr) return;
 
-	auto* team = playerContainer.GetTeam(playerID);
+	auto* team = Game::playerContainer.GetTeam(playerID);
 
 	if (team != nullptr) {
 		if (team->leaderID != playerID) return;
 
-		playerContainer.PromoteMember(team, promoted->playerID);
+		Game::playerContainer.PromoteMember(team, promoted->playerID);
 	}
 }
 
@@ -613,16 +611,16 @@ void ChatPacketHandler::HandleTeamLootOption(Packet* packet) {
 	char option;
 	inStream.Read(option);
 
-	auto* team = playerContainer.GetTeam(playerID);
+	auto* team = Game::playerContainer.GetTeam(playerID);
 
 	if (team != nullptr) {
 		if (team->leaderID != playerID) return;
 
 		team->lootFlag = option;
 
-		playerContainer.TeamStatusUpdate(team);
+		Game::playerContainer.TeamStatusUpdate(team);
 
-		playerContainer.UpdateTeamsOnWorld(team, false);
+		Game::playerContainer.UpdateTeamsOnWorld(team, false);
 	}
 }
 
@@ -631,18 +629,18 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 	LWOOBJID playerID = LWOOBJID_EMPTY;
 	inStream.Read(playerID);
 
-	auto* team = playerContainer.GetTeam(playerID);
-	auto* data = playerContainer.GetPlayerData(playerID);
+	auto* team = Game::playerContainer.GetTeam(playerID);
+	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()) {
-			playerContainer.RemoveMember(team, playerID, false, false, true, true);
+			Game::playerContainer.RemoveMember(team, playerID, false, false, true, true);
 
 			return;
 		}
 
 		if (team->memberIDs.size() <= 1 && !team->local) {
-			playerContainer.DisbandTeam(team);
+			Game::playerContainer.DisbandTeam(team);
 
 			return;
 		}
@@ -653,16 +651,16 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 			ChatPacketHandler::SendTeamSetLeader(data, LWOOBJID_EMPTY);
 		}
 
-		playerContainer.TeamStatusUpdate(team);
+		Game::playerContainer.TeamStatusUpdate(team);
 
 		const auto leaderName = GeneralUtils::UTF8ToUTF16(data->playerName);
 
 		for (const auto memberId : team->memberIDs) {
-			auto* otherMember = playerContainer.GetPlayerData(memberId);
+			auto* otherMember = Game::playerContainer.GetPlayerData(memberId);
 
 			if (memberId == playerID) continue;
 
-			const auto memberName = playerContainer.GetName(memberId);
+			const auto memberName = Game::playerContainer.GetName(memberId);
 
 			if (otherMember != nullptr) {
 				ChatPacketHandler::SendTeamSetOffWorldFlag(otherMember, data->playerID, data->zoneID);
@@ -670,7 +668,7 @@ void ChatPacketHandler::HandleTeamStatusRequest(Packet* packet) {
 			ChatPacketHandler::SendTeamAddPlayer(data, false, team->local, false, memberId, memberName, otherMember != nullptr ? otherMember->zoneID : LWOZONEID(0, 0, 0));
 		}
 
-		playerContainer.UpdateTeamsOnWorld(team, false);
+		Game::playerContainer.UpdateTeamsOnWorld(team, false);
 	}
 }
 

dChatServer/ChatServer.cpp

@@ -19,6 +19,7 @@
 #include "eChatMessageType.h"
 #include "eChatInternalMessageType.h"
 #include "eWorldMessageType.h"
+#include "ChatIgnoreList.h"
 
 #include "Game.h"
 
@@ -34,14 +35,12 @@ namespace Game {
 	AssetManager* assetManager = nullptr;
 	bool shouldShutdown = false;
 	std::mt19937 randomEngine;
+	PlayerContainer playerContainer;
 }
 
-
 Logger* SetupLogger();
 void HandlePacket(Packet* packet);
 
-PlayerContainer playerContainer;
-
 int main(int argc, char** argv) {
 	constexpr uint32_t chatFramerate = mediumFramerate;
 	constexpr uint32_t chatFrameDelta = mediumFrameDelta;
@@ -108,7 +107,7 @@ int main(int argc, char** argv) {
 	
 	Game::randomEngine = std::mt19937(time(0));
 
-	playerContainer.Initialize();
+	Game::playerContainer.Initialize();
 
 	//Run it until server gets a kill message from Master:
 	auto t = std::chrono::high_resolution_clock::now();
@@ -200,19 +199,19 @@ void HandlePacket(Packet* packet) {
 	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::CHAT_INTERNAL) {
 		switch (static_cast<eChatInternalMessageType>(packet->data[3])) {
 		case eChatInternalMessageType::PLAYER_ADDED_NOTIFICATION:
-			playerContainer.InsertPlayer(packet);
+			Game::playerContainer.InsertPlayer(packet);
 			break;
 
 		case eChatInternalMessageType::PLAYER_REMOVED_NOTIFICATION:
-			playerContainer.RemovePlayer(packet);
+			Game::playerContainer.RemovePlayer(packet);
 			break;
 
 		case eChatInternalMessageType::MUTE_UPDATE:
-			playerContainer.MuteUpdate(packet);
+			Game::playerContainer.MuteUpdate(packet);
 			break;
 
 		case eChatInternalMessageType::CREATE_TEAM:
-			playerContainer.CreateTeamServer(packet);
+			Game::playerContainer.CreateTeamServer(packet);
 			break;
 
 		case eChatInternalMessageType::ANNOUNCEMENT: {
@@ -234,7 +233,15 @@ void HandlePacket(Packet* packet) {
 			break;
 
 		case eChatMessageType::GET_IGNORE_LIST:
-			LOG("Asked for ignore list, but is unimplemented right now.");
+			ChatIgnoreList::GetIgnoreList(packet);
+			break;
+
+		case eChatMessageType::ADD_IGNORE:
+			ChatIgnoreList::AddIgnore(packet);
+			break;
+
+		case eChatMessageType::REMOVE_IGNORE:
+			ChatIgnoreList::RemoveIgnore(packet);
 			break;
 
 		case eChatMessageType::TEAM_GET_STATUS:

dChatServer/PlayerContainer.h

@@ -7,12 +7,26 @@
 #include "dServer.h"
 #include <unordered_map>
 
+struct IgnoreData {
+	inline bool operator==(const std::string& other) const noexcept {
+		return playerName == other;
+	}
+
+	inline bool operator==(const LWOOBJID& other) const noexcept {
+		return playerId == other;
+	}
+
+	LWOOBJID playerId;
+	std::string playerName;
+};
+
 struct PlayerData {
 	LWOOBJID playerID;
 	std::string playerName;
 	SystemAddress sysAddr;
 	LWOZONEID zoneID;
 	std::vector<FriendData> friends;
+	std::vector<IgnoreData> ignoredPlayers;
 	time_t muteExpire;
 	uint8_t countOfBestFriends = 0;
 };

dCommon/Game.h

@@ -12,6 +12,7 @@ class AssetManager;
 struct SystemAddress;
 class EntityManager;
 class dZoneManager;
+class PlayerContainer;
 
 namespace Game {
 	extern Logger* logger;
@@ -26,4 +27,5 @@ namespace Game {
 	extern bool shouldShutdown;
 	extern EntityManager* entityManager;
 	extern dZoneManager* zoneManager;
+	extern PlayerContainer playerContainer;
 }

dCommon/dEnums/ePlayerFlag.h

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

dCommon/dEnums/eReplicaComponentType.h

@@ -34,7 +34,7 @@ enum class eReplicaComponentType : uint32_t {
 	PLATFORM_BOUNDARY,
 	MODULE,
 	ARCADE,
-	VEHICLE_PHYSICS, // Havok demo based
+	HAVOK_VEHICLE_PHYSICS,
 	MOVEMENT_AI,
 	EXHIBIT,
 	OVERHEAD_ICON,
@@ -50,7 +50,7 @@ enum class eReplicaComponentType : uint32_t {
 	PROPERTY_ENTRANCE,
 	FX,
 	PROPERTY_MANAGEMENT,
-	VEHICLE_PHYSICS_NEW, // internal physics based on havok
+	VEHICLE_PHYSICS,
 	PHYSICS_SYSTEM,
 	QUICK_BUILD,
 	SWITCH,

dDatabase/CDClientDatabase/CDClientManager.cpp

@@ -37,6 +37,7 @@
 #include "CDPropertyTemplateTable.h"
 #include "CDFeatureGatingTable.h"
 #include "CDRailActivatorComponent.h"
+#include "CDRewardCodesTable.h"
 
 // Uncomment this to cache the full cdclient database into memory. This will make the server load faster, but will use more memory.
 // A vanilla CDClient takes about 46MB of memory + the regular world data.
@@ -82,6 +83,7 @@ CDClientManager::CDClientManager() {
 	CDRailActivatorComponentTable::Instance().LoadValuesFromDatabase();
 	CDRarityTableTable::Instance().LoadValuesFromDatabase();
 	CDRebuildComponentTable::Instance().LoadValuesFromDatabase();
+	CDRewardCodesTable::Instance().LoadValuesFromDatabase();
 	CDRewardsTable::Instance().LoadValuesFromDatabase();
 	CDScriptComponentTable::Instance().LoadValuesFromDatabase();
 	CDSkillBehaviorTable::Instance().LoadValuesFromDatabase();

dDatabase/CDClientDatabase/CDClientTables/CDFeatureGatingTable.cpp

@@ -44,7 +44,7 @@ std::vector<CDFeatureGating> CDFeatureGatingTable::Query(std::function<bool(CDFe
 
 bool CDFeatureGatingTable::FeatureUnlocked(const CDFeatureGating& feature) const {
 	for (const auto& entry : entries) {
-		if (entry.featureName == feature.featureName && entry >= feature) {
+		if (entry.featureName == feature.featureName && feature >= entry) {
 			return true;
 		}
 	}

dDatabase/CDClientDatabase/CDClientTables/CDRewardCodesTable.cpp

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

dDatabase/CDClientDatabase/CDClientTables/CDRewardCodesTable.h

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

dDatabase/CDClientDatabase/CDClientTables/CDTable.h

@@ -8,6 +8,7 @@
 #include <string>
 #include <vector>
 #include <map>
+#include <cstdint>
 
 // CPPLinq
 #ifdef _WIN32

dDatabase/CDClientDatabase/CDClientTables/CMakeLists.txt

@@ -31,6 +31,7 @@ set(DDATABASE_CDCLIENTDATABASE_CDCLIENTTABLES_SOURCES "CDActivitiesTable.cpp"
 	"CDRailActivatorComponent.cpp"
 	"CDRarityTableTable.cpp"
 	"CDRebuildComponentTable.cpp"
+	"CDRewardCodesTable.cpp"
 	"CDRewardsTable.cpp"
 	"CDScriptComponentTable.cpp"
 	"CDSkillBehaviorTable.cpp"

dDatabase/GameDatabase/GameDatabase.h

@@ -21,6 +21,8 @@
 #include "ICharInfo.h"
 #include "IAccounts.h"
 #include "IActivityLog.h"
+#include "IIgnoreList.h"
+#include "IAccountsRewardCodes.h"
 
 namespace sql {
 	class Statement;
@@ -38,7 +40,7 @@ class GameDatabase :
 	public IMail, public ICommandLog, public IPlayerCheatDetections, public IBugReports,
 	public IPropertyContents, public IProperty, public IPetNames, public ICharXml,
 	public IMigrationHistory, public IUgc, public IFriends, public ICharInfo,
-	public IAccounts, public IActivityLog {
+	public IAccounts, public IActivityLog, public IAccountsRewardCodes, public IIgnoreList {
 public:
 	virtual ~GameDatabase() = default;
 	// TODO: These should be made private.

dDatabase/GameDatabase/ITables/IAccountsRewardCodes.h

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

dDatabase/GameDatabase/ITables/IIgnoreList.h

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

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -103,6 +103,11 @@ public:
 	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
 	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
 	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
+	void AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	void RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) override;
+	std::vector<IIgnoreList::Info> GetIgnoreList(const uint32_t playerId) override;
+	void InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) override;
+	std::vector<uint32_t> GetRewardCodesByAccountID(const uint32_t account_id) override;
 private:
 
 	// Generic query functions that can be used for any query.

dDatabase/GameDatabase/MySQL/Tables/AccountsRewardCodes.cpp

@@ -0,0 +1,17 @@
+#include "MySQLDatabase.h"
+
+void MySQLDatabase::InsertRewardCode(const uint32_t account_id, const uint32_t reward_code) {
+	ExecuteInsert("INSERT IGNORE INTO accounts_rewardcodes (account_id, rewardcode) VALUES (?, ?);", account_id, reward_code);
+}
+
+std::vector<uint32_t> MySQLDatabase::GetRewardCodesByAccountID(const uint32_t account_id) {
+	auto result = ExecuteSelect("SELECT rewardcode FROM accounts_rewardcodes WHERE account_id = ?;", account_id);
+
+	std::vector<uint32_t> toReturn;
+	toReturn.reserve(result->rowsCount());
+	while (result->next()) {
+		toReturn.push_back(result->getUInt("rewardcode"));
+	}
+
+	return toReturn;
+}

dDatabase/GameDatabase/MySQL/Tables/CMakeLists.txt

@@ -1,11 +1,13 @@
 set(DDATABASES_DATABASES_MYSQL_TABLES_SOURCES
 	"Accounts.cpp"
+	"AccountsRewardCodes.cpp"
 	"ActivityLog.cpp"
 	"BugReports.cpp"
 	"CharInfo.cpp"
 	"CharXml.cpp"
 	"CommandLog.cpp"
 	"Friends.cpp"
+	"IgnoreList.cpp"
 	"Leaderboard.cpp"
 	"Mail.cpp"
 	"MigrationHistory.cpp"

dDatabase/GameDatabase/MySQL/Tables/IgnoreList.cpp

@@ -0,0 +1,22 @@
+#include "MySQLDatabase.h"
+
+std::vector<IIgnoreList::Info> MySQLDatabase::GetIgnoreList(const uint32_t playerId) {
+	auto result = ExecuteSelect("SELECT ci.name AS name, il.ignored_player_id AS ignore_id FROM ignore_list AS il JOIN charinfo AS ci ON il.ignored_player_id = ci.id WHERE il.player_id = ?", playerId);
+
+	std::vector<IIgnoreList::Info> ignoreList;
+
+	ignoreList.reserve(result->rowsCount());
+	while (result->next()) {
+		ignoreList.push_back(IIgnoreList::Info{ result->getString("name").c_str(), result->getUInt("ignore_id") });
+	}
+
+	return ignoreList;
+}
+
+void MySQLDatabase::AddIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+	ExecuteInsert("INSERT IGNORE INTO ignore_list (player_id, ignored_player_id) VALUES (?, ?)", playerId, ignoredPlayerId);
+}
+
+void MySQLDatabase::RemoveIgnore(const uint32_t playerId, const uint32_t ignoredPlayerId) {
+	ExecuteDelete("DELETE FROM ignore_list WHERE player_id = ? AND ignored_player_id = ?", playerId, ignoredPlayerId);
+}

dGame/Character.cpp

@@ -314,6 +314,11 @@ void Character::SaveXMLToDatabase() {
 		return;
 	}
 
+	if (!m_OurEntity->GetPlayerReadyForUpdates()) {
+		LOG("Attempted to save before player %i:%s was not ready for updates. Character will NOT be saved.", GetID(), GetName().c_str());
+		return;
+	}
+
 	m_OurEntity->UpdateXMLDoc(m_Doc);
 
 	WriteToDatabase();

dGame/Entity.cpp

@@ -62,7 +62,7 @@
 #include "ModelComponent.h"
 #include "ZCompression.h"
 #include "PetComponent.h"
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "PossessableComponent.h"
 #include "PossessorComponent.h"
 #include "ModuleAssemblyComponent.h"
@@ -299,10 +299,10 @@ void Entity::Initialize() {
 		AddComponent<PhantomPhysicsComponent>()->SetPhysicsEffectActive(false);
 	}
 
-	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::VEHICLE_PHYSICS) > 0) {
-		auto* vehiclePhysicsComponent = AddComponent<VehiclePhysicsComponent>();
-		vehiclePhysicsComponent->SetPosition(m_DefaultPosition);
-		vehiclePhysicsComponent->SetRotation(m_DefaultRotation);
+	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::HAVOK_VEHICLE_PHYSICS) > 0) {
+		auto* havokVehiclePhysicsComponent = AddComponent<HavokVehiclePhysicsComponent>();
+		havokVehiclePhysicsComponent->SetPosition(m_DefaultPosition);
+		havokVehiclePhysicsComponent->SetRotation(m_DefaultRotation);
 	}
 
 	if (compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::SOUND_TRIGGER, -1) != -1) {
@@ -554,6 +554,12 @@ void Entity::Initialize() {
 				Loot::CacheMatrix(activityID);
 			}
 
+			const auto timeBeforeSmash = GetVar<float>(u"tmeSmsh");
+
+			if (timeBeforeSmash > 0) {
+				rebuildComponent->SetTimeBeforeSmash(timeBeforeSmash);
+			}
+
 			const auto compTime = GetVar<float>(u"compTime");
 
 			if (compTime > 0) {
@@ -738,7 +744,7 @@ void Entity::Initialize() {
 			!HasComponent(eReplicaComponentType::PHANTOM_PHYSICS) &&
 			!HasComponent(eReplicaComponentType::PROPERTY) &&
 			!HasComponent(eReplicaComponentType::RACING_CONTROL) &&
-			!HasComponent(eReplicaComponentType::VEHICLE_PHYSICS)
+			!HasComponent(eReplicaComponentType::HAVOK_VEHICLE_PHYSICS)
 			)
 			//if (HasComponent(eReplicaComponentType::BASE_COMBAT_AI))
 		{
@@ -1017,9 +1023,9 @@ void Entity::WriteComponents(RakNet::BitStream* outBitStream, eReplicaPacketType
 		rigidbodyPhantomPhysics->Serialize(outBitStream, bIsInitialUpdate);
 	}
 
-	VehiclePhysicsComponent* vehiclePhysicsComponent;
-	if (TryGetComponent(eReplicaComponentType::VEHICLE_PHYSICS, vehiclePhysicsComponent)) {
-		vehiclePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate);
+	HavokVehiclePhysicsComponent* havokVehiclePhysicsComponent;
+	if (TryGetComponent(eReplicaComponentType::HAVOK_VEHICLE_PHYSICS, havokVehiclePhysicsComponent)) {
+		havokVehiclePhysicsComponent->Serialize(outBitStream, bIsInitialUpdate);
 	}
 
 	PhantomPhysicsComponent* phantomPhysicsComponent;
@@ -1503,7 +1509,7 @@ void Entity::Smash(const LWOOBJID source, const eKillType killType, const std::u
 	destroyableComponent->Smash(source, killType, deathType);
 }
 
-void Entity::Kill(Entity* murderer) {
+void Entity::Kill(Entity* murderer, const eKillType killType) {
 	if (!m_PlayerIsReadyForUpdates) return;
 
 	for (const auto& cb : m_DieCallbacks) {
@@ -1527,7 +1533,7 @@ void Entity::Kill(Entity* murderer) {
 		bool waitForDeathAnimation = false;
 
 		if (destroyableComponent) {
-			waitForDeathAnimation = destroyableComponent->GetDeathBehavior() == 0;
+			waitForDeathAnimation = destroyableComponent->GetDeathBehavior() == 0 && killType != eKillType::SILENT;
 		}
 
 		// Live waited a hard coded 12 seconds for death animations of type 0 before networking destruction!
@@ -1840,7 +1846,7 @@ const NiPoint3& Entity::GetPosition() const {
 		return simple->GetPosition();
 	}
 
-	auto* vehicel = GetComponent<VehiclePhysicsComponent>();
+	auto* vehicel = GetComponent<HavokVehiclePhysicsComponent>();
 
 	if (vehicel != nullptr) {
 		return vehicel->GetPosition();
@@ -1868,7 +1874,7 @@ const NiQuaternion& Entity::GetRotation() const {
 		return simple->GetRotation();
 	}
 
-	auto* vehicel = GetComponent<VehiclePhysicsComponent>();
+	auto* vehicel = GetComponent<HavokVehiclePhysicsComponent>();
 
 	if (vehicel != nullptr) {
 		return vehicel->GetRotation();
@@ -1896,7 +1902,7 @@ void Entity::SetPosition(NiPoint3 position) {
 		simple->SetPosition(position);
 	}
 
-	auto* vehicel = GetComponent<VehiclePhysicsComponent>();
+	auto* vehicel = GetComponent<HavokVehiclePhysicsComponent>();
 
 	if (vehicel != nullptr) {
 		vehicel->SetPosition(position);
@@ -1924,7 +1930,7 @@ void Entity::SetRotation(NiQuaternion rotation) {
 		simple->SetRotation(rotation);
 	}
 
-	auto* vehicel = GetComponent<VehiclePhysicsComponent>();
+	auto* vehicel = GetComponent<HavokVehiclePhysicsComponent>();
 
 	if (vehicel != nullptr) {
 		vehicel->SetRotation(rotation);

dGame/Entity.h

@@ -210,7 +210,7 @@ public:
 	void RequestActivityExit(Entity* sender, LWOOBJID player, bool canceled);
 
 	void Smash(const LWOOBJID source = LWOOBJID_EMPTY, const eKillType killType = eKillType::VIOLENT, const std::u16string& deathType = u"");
-	void Kill(Entity* murderer = nullptr);
+	void Kill(Entity* murderer = nullptr, const eKillType killType = eKillType::SILENT);
 	void AddRebuildCompleteCallback(const std::function<void(Entity* user)>& callback) const;
 	void AddCollisionPhantomCallback(const std::function<void(Entity* target)>& callback);
 	void AddDieCallback(const std::function<void()>& callback);

dGame/UserManager.cpp

@@ -207,7 +207,7 @@ void UserManager::RequestCharacterList(const SystemAddress& sysAddr) {
 		chars[i]->SaveXMLToDatabase();
 
 		chars[i]->GetEntity()->SetCharacter(nullptr);
-		
+
 		delete chars[i];
 	}
 
@@ -275,60 +275,58 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 		}
 
 		std::stringstream xml;
-		xml << "<obj v=\"1\"><mf hc=\"" << hairColor << "\" hs=\"" << hairStyle << "\" hd=\"0\" t=\"" << shirtColor << "\" l=\"" << pantsColor;
+		xml << "<obj v=\"1\">";
+
+		xml << "<mf hc=\"" << hairColor << "\" hs=\"" << hairStyle << "\" hd=\"0\" t=\"" << shirtColor << "\" l=\"" << pantsColor;
 		xml << "\" hdc=\"0\" cd=\"" << shirtStyle << "\" lh=\"" << lh << "\" rh=\"" << rh << "\" es=\"" << eyebrows << "\" ";
 		xml << "ess=\"" << eyes << "\" ms=\"" << mouth << "\"/>";
 
 		xml << "<char acct=\"" << u->GetAccountID() << "\" cc=\"0\" gm=\"0\" ft=\"0\" llog=\"" << time(NULL) << "\" ";
 		xml << "ls=\"0\" lzx=\"-626.5847\" lzy=\"613.3515\" lzz=\"-28.6374\" lzrx=\"0.0\" lzry=\"0.7015\" lzrz=\"0.0\" lzrw=\"0.7126\" ";
 		xml << "stt=\"0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;0;\"></char>";
+
 		xml << "<dest hm=\"4\" hc=\"4\" im=\"0\" ic=\"0\" am=\"0\" ac=\"0\" d=\"0\"/>";
+
 		xml << "<inv><bag><b t=\"0\" m=\"20\"/><b t=\"1\" m=\"40\"/><b t=\"2\" m=\"240\"/><b t=\"3\" m=\"240\"/><b t=\"14\" m=\"40\"/></bag><items><in t=\"0\">";
-		std::string xmlSave1 = xml.str();
 
-		ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t idforshirt) {
-			std::stringstream xml2;
+		LWOOBJID lwoidforshirt = ObjectIDManager::GenerateRandomObjectID();
+		LWOOBJID lwoidforpants;
 
-			LWOOBJID lwoidforshirt = idforshirt;
-			GeneralUtils::SetBit(lwoidforshirt, eObjectBits::CHARACTER);
-			GeneralUtils::SetBit(lwoidforshirt, eObjectBits::PERSISTENT);
-			xml2 << xmlSave1 << "<i l=\"" << shirtLOT << "\" id=\"" << lwoidforshirt << "\" s=\"0\" c=\"1\" eq=\"1\" b=\"1\"/>";
+		do {
+			lwoidforpants = ObjectIDManager::GenerateRandomObjectID();
+		} while (lwoidforpants == lwoidforshirt); //Make sure we don't have the same ID for both shirt and pants
 
-			std::string xmlSave2 = xml2.str();
+		GeneralUtils::SetBit(lwoidforshirt, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(lwoidforshirt, eObjectBits::PERSISTENT);
+		GeneralUtils::SetBit(lwoidforpants, eObjectBits::CHARACTER);
+		GeneralUtils::SetBit(lwoidforpants, eObjectBits::PERSISTENT);
 
-			ObjectIDManager::Instance()->RequestPersistentID([=](uint32_t idforpants) {
-				LWOOBJID lwoidforpants = idforpants;
-				GeneralUtils::SetBit(lwoidforpants, eObjectBits::CHARACTER);
-				GeneralUtils::SetBit(lwoidforpants, eObjectBits::PERSISTENT);
+		xml << "<i l=\"" << shirtLOT << "\" id=\"" << lwoidforshirt << "\" s=\"0\" c=\"1\" eq=\"1\" b=\"1\"/>";
+		xml << "<i l=\"" << pantsLOT << "\" id=\"" << lwoidforpants << "\" s=\"1\" c=\"1\" eq=\"1\" b=\"1\"/>";
 
-				std::stringstream xml3;
-				xml3 << xmlSave2 << "<i l=\"" << pantsLOT << "\" id=\"" << lwoidforpants << "\" s=\"1\" c=\"1\" eq=\"1\" b=\"1\"/>";
+		xml << "</in></items></inv><lvl l=\"1\" cv=\"1\" sb=\"500\"/><flag></flag></obj>";
 
-				xml3 << "</in></items></inv><lvl l=\"1\" cv=\"1\" sb=\"500\"/><flag></flag></obj>";
+		//Check to see if our name was pre-approved:
+		bool nameOk = IsNamePreapproved(name);
+		if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
 
-				//Check to see if our name was pre-approved:
-				bool nameOk = IsNamePreapproved(name);
-				if (!nameOk && u->GetMaxGMLevel() > eGameMasterLevel::FORUM_MODERATOR) nameOk = true;
+		std::string_view nameToAssign = !name.empty() && nameOk ? name : predefinedName;
+		std::string pendingName = !name.empty() && !nameOk ? name : "";
 
-				std::string_view nameToAssign = !name.empty() && nameOk ? name : predefinedName;
-				std::string pendingName = !name.empty() && !nameOk ? name : "";
+		ICharInfo::Info info;
+		info.name = nameToAssign;
+		info.pendingName = pendingName;
+		info.id = objectID;
+		info.accountId = u->GetAccountID();
 
-				ICharInfo::Info info;
-				info.name = nameToAssign;
-				info.pendingName = pendingName;
-				info.id = objectID;
-				info.accountId = u->GetAccountID();
+		Database::Get()->InsertNewCharacter(info);
 
-				Database::Get()->InsertNewCharacter(info);
+		//Now finally insert our character xml:
+		Database::Get()->InsertCharacterXml(objectID, xml.str());
 
-				//Now finally insert our character xml:
-				Database::Get()->InsertCharacterXml(objectID, xml3.str());
-
-				WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
-				UserManager::RequestCharacterList(sysAddr);
-				});
-			});
-		});
+		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
+		UserManager::RequestCharacterList(sysAddr);
+	});
 }
 
 void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet) {
@@ -407,7 +405,7 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 			return;
 		}
 
-		if (Database::Get()->GetCharacterInfo(newName)) {
+		if (!Database::Get()->GetCharacterInfo(newName)) {
 			if (IsNamePreapproved(newName)) {
 				Database::Get()->SetCharacterName(charID, newName);
 				LOG("Character %s now known as %s", character->GetName().c_str(), newName.c_str());
@@ -466,16 +464,18 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
 
 uint32_t FindCharShirtID(uint32_t shirtColor, uint32_t shirtStyle) {
 	try {
-		std::string shirtQuery = "select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == \"character create shirt\" AND icc.color1 == ";
-		shirtQuery += std::to_string(shirtColor);
-		shirtQuery += " AND icc.decal == ";
-		shirtQuery = shirtQuery + std::to_string(shirtStyle);
-		auto tableData = CDClientDatabase::ExecuteQuery(shirtQuery);
-		auto shirtLOT = tableData.getIntField(0, -1);
+		auto stmt = CDClientDatabase::CreatePreppedStmt(
+			"select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ? AND icc.decal == ?"
+		);
+		stmt.bind(1, "character create shirt");
+		stmt.bind(2, static_cast<int>(shirtColor));
+		stmt.bind(3, static_cast<int>(shirtStyle));
+		auto tableData = stmt.execQuery();
+		auto shirtLOT = tableData.getIntField(0, 4069);
 		tableData.finalize();
 		return shirtLOT;
-	} catch (const std::exception&) {
-		LOG("Failed to execute query! Using backup...");
+	} catch (const std::exception& ex) {
+		LOG("Could not look up shirt %i %i: %s", shirtColor, shirtStyle, ex.what());
 		// in case of no shirt found in CDServer, return problematic red vest.
 		return 4069;
 	}
@@ -483,14 +483,17 @@ uint32_t FindCharShirtID(uint32_t shirtColor, uint32_t shirtStyle) {
 
 uint32_t FindCharPantsID(uint32_t pantsColor) {
 	try {
-		std::string pantsQuery = "select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == \"cc pants\" AND icc.color1 == ";
-		pantsQuery += std::to_string(pantsColor);
-		auto tableData = CDClientDatabase::ExecuteQuery(pantsQuery);
-		auto pantsLOT = tableData.getIntField(0, -1);
+		auto stmt = CDClientDatabase::CreatePreppedStmt(
+			"select obj.id from Objects as obj JOIN (select * from ComponentsRegistry as cr JOIN ItemComponent as ic on ic.id = cr.component_id where cr.component_type == 11) as icc on icc.id = obj.id where lower(obj._internalNotes) == ? AND icc.color1 == ?"
+		);
+		stmt.bind(1, "cc pants");
+		stmt.bind(2, static_cast<int>(pantsColor));
+		auto tableData = stmt.execQuery();
+		auto pantsLOT = tableData.getIntField(0, 2508);
 		tableData.finalize();
 		return pantsLOT;
-	} catch (const std::exception&) {
-		LOG("Failed to execute query! Using backup...");
+	} catch (const std::exception& ex) {
+		LOG("Could not look up pants %i: %s", pantsColor, ex.what());
 		// in case of no pants color found in CDServer, return red pants.
 		return 2508;
 	}

dGame/dBehaviors/ApplyBuffBehavior.cpp

@@ -15,7 +15,7 @@ void ApplyBuffBehavior::Handle(BehaviorContext* context, RakNet::BitStream* bitS
 	if (buffComponent == nullptr) return;
 
 	buffComponent->ApplyBuff(m_BuffId, m_Duration, context->originator, addImmunity, cancelOnDamaged, cancelOnDeath,
-		cancelOnLogout, cancelonRemoveBuff, cancelOnUi, cancelOnUnequip, cancelOnZone);
+		cancelOnLogout, cancelonRemoveBuff, cancelOnUi, cancelOnUnequip, cancelOnZone, m_ApplyOnTeammates);
 }
 
 void ApplyBuffBehavior::UnCast(BehaviorContext* context, BehaviorBranchContext branch) {
@@ -45,4 +45,5 @@ void ApplyBuffBehavior::Load() {
 	cancelOnUi = GetBoolean("cancel_on_ui");
 	cancelOnUnequip = GetBoolean("cancel_on_unequip");
 	cancelOnZone = GetBoolean("cancel_on_zone");
+	m_ApplyOnTeammates = GetBoolean("apply_on_teammates");
 }

dGame/dBehaviors/ApplyBuffBehavior.h

@@ -31,4 +31,6 @@ public:
 	void Calculate(BehaviorContext* context, RakNet::BitStream* bitStream, BehaviorBranchContext branch) override;
 
 	void Load() override;
+private:
+	bool m_ApplyOnTeammates;
 };

dGame/dBehaviors/JetPackBehavior.cpp

@@ -38,10 +38,12 @@ void JetPackBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bit
 }
 
 void JetPackBehavior::Load() {
-	this->m_WarningEffectID = GetInt("warning_effect_id");
-	this->m_Airspeed = GetFloat("airspeed");
-	this->m_MaxAirspeed = GetFloat("max_airspeed");
-	this->m_VerticalVelocity = GetFloat("vertical_velocity");
-	this->m_EnableHover = GetBoolean("enable_hover");
-	this->m_BypassChecks = GetBoolean("bypass_checks", true);
+	this->m_WarningEffectID = GetInt("warning_effect_id", -1);
+	this->m_Airspeed = GetFloat("airspeed", 10);
+	this->m_MaxAirspeed = GetFloat("max_airspeed", 15);
+	this->m_VerticalVelocity = GetFloat("vertical_velocity", 1);
+	this->m_EnableHover = GetBoolean("enable_hover", false);
+
+	// TODO: Implement proper jetpack checks, so we can set this default to false
+	this->m_BypassChecks = GetBoolean("bypass_checks", true); 
 }

dGame/dBehaviors/TacArcBehavior.cpp

@@ -104,7 +104,7 @@ void TacArcBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitS
 
 	const auto casterPosition = self->GetPosition();
 
-	auto reference = self->GetPosition(); //+ m_offset;
+	auto reference = self->GetPosition() + m_offset;
 
 	targets.clear();
 
@@ -114,46 +114,34 @@ void TacArcBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitS
 	context->FilterTargets(validTargets, this->m_ignoreFactionList, this->m_includeFactionList, this->m_targetSelf, this->m_targetEnemy, this->m_targetFriend, this->m_targetTeam);
 
 	for (auto validTarget : validTargets) {
-		if (targets.size() >= this->m_maxTargets) {
-			break;
-		}
-
-		if (std::find(targets.begin(), targets.end(), validTarget) != targets.end()) {
-			continue;
-		}
-
+		if (targets.size() >= this->m_maxTargets) break;
+		if (std::find(targets.begin(), targets.end(), validTarget) != targets.end()) continue;
 		if (validTarget->GetIsDead()) continue;
 
-		const auto otherPosition = validTarget->GetPosition();
+		const auto targetPos = validTarget->GetPosition();
 
-		const auto heightDifference = std::abs(otherPosition.y - casterPosition.y);
-
-		/*if (otherPosition.y > reference.y && heightDifference > this->m_upperBound || otherPosition.y < reference.y && heightDifference > this->m_lowerBound)
-		{
+		// make sure we aren't too high or low in comparison to the targer
+		const auto heightDifference = std::abs(reference.y - targetPos.y);
+		if (targetPos.y > reference.y && heightDifference > this->m_upperBound || targetPos.y < reference.y && heightDifference > this->m_lowerBound)
 			continue;
-		}*/
 
 		const auto forward = self->GetRotation().GetForwardVector();
 
 		// forward is a normalized vector of where the caster is facing.
-		// otherPosition is the position of the target.
+		// targetPos is the position of the target.
 		// reference is the position of the caster.
 		// If we cast a ray forward from the caster, does it come within m_farWidth of the target?
 
-		const auto distance = Vector3::Distance(reference, otherPosition);
+		const auto distance = Vector3::Distance(reference, targetPos);
 
 		if (m_method == 2) {
 			NiPoint3 rayPoint = casterPosition + forward * distance;
-
-			if (m_farWidth > 0 && Vector3::DistanceSquared(rayPoint, otherPosition) > this->m_farWidth * this->m_farWidth) {
+			if (m_farWidth > 0 && Vector3::DistanceSquared(rayPoint, targetPos) > this->m_farWidth * this->m_farWidth)
 				continue;
-			}
 		}
 
-		auto normalized = (reference - otherPosition) / distance;
-
+		auto normalized = (reference - targetPos) / distance;
 		const float degreeAngle = std::abs(Vector3::Angle(forward, normalized) * (180 / 3.14) - 180);
-
 		if (distance >= this->m_minRange && this->m_maxRange >= distance && degreeAngle <= 2 * this->m_angle) {
 			targets.push_back(validTarget);
 		}
@@ -167,33 +155,26 @@ void TacArcBehavior::Calculate(BehaviorContext* context, RakNet::BitStream* bitS
 		});
 
 	const auto hit = !targets.empty();
-
 	bitStream->Write(hit);
 
 	if (this->m_checkEnv) {
 		const auto blocked = false; // TODO
-
 		bitStream->Write(blocked);
 	}
 
 	if (hit) {
-		if (combatAi != nullptr) {
-			combatAi->LookAt(targets[0]->GetPosition());
-		}
+		if (combatAi) combatAi->LookAt(targets[0]->GetPosition());
 
 		context->foundTarget = true; // We want to continue with this behavior
-
 		const auto count = static_cast<uint32_t>(targets.size());
 
 		bitStream->Write(count);
-
 		for (auto* target : targets) {
 			bitStream->Write(target->GetObjectID());
 		}
 
 		for (auto* target : targets) {
 			branch.target = target->GetObjectID();
-
 			this->m_action->Calculate(context, bitStream, branch);
 		}
 	} else {
@@ -214,8 +195,8 @@ void TacArcBehavior::Load() {
 		GetFloat("offset_z", 0.0f)
 	);
 	this->m_method = GetInt("method", 1);
-	this->m_upperBound = GetFloat("upper_bound", 4.4f);
-	this->m_lowerBound = GetFloat("lower_bound", 0.4f);
+	this->m_upperBound = std::abs(GetFloat("upper_bound", 4.4f));
+	this->m_lowerBound = std::abs(GetFloat("lower_bound", 0.4f));
 	this->m_usePickedTarget = GetBoolean("use_picked_target", false);
 	this->m_useTargetPostion = GetBoolean("use_target_position", false);
 	this->m_checkEnv = GetBoolean("check_env", false);

dGame/dComponents/BuffComponent.cpp

@@ -11,9 +11,21 @@
 #include "EntityManager.h"
 #include "CDClientManager.h"
 #include "CDSkillBehaviorTable.h"
+#include "TeamManager.h"
 
 std::unordered_map<int32_t, std::vector<BuffParameter>> BuffComponent::m_Cache{};
 
+namespace {
+	std::map<std::string, std::string> BuffFx = {
+		{ "overtime", "OTB_" },
+		{ "max_health", "HEALTH_" },
+		{ "max_imagination", "IMAGINATION_" },
+		{ "max_armor", "ARMOR_" },
+		{ "speed", "SPEED_" },
+		{ "loot", "LOOT_" }
+	};
+}
+
 BuffComponent::BuffComponent(Entity* parent) : Component(parent) {
 }
 
@@ -22,32 +34,38 @@ BuffComponent::~BuffComponent() {
 
 void BuffComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
 	if (!bIsInitialUpdate) return;
-	if (m_Buffs.empty()) {
-		outBitStream->Write0();
-	} else {
-		outBitStream->Write1();
+	outBitStream->Write(!m_Buffs.empty());
+	if (!m_Buffs.empty()) {
 		outBitStream->Write<uint32_t>(m_Buffs.size());
 
-		for (const auto& buff : m_Buffs) {
-			outBitStream->Write<uint32_t>(buff.first);
-			outBitStream->Write0();
-			outBitStream->Write0();
-			outBitStream->Write0();
-			outBitStream->Write0();
-			outBitStream->Write0();
-			outBitStream->Write0();
-			outBitStream->Write0();
-			outBitStream->Write0();
-			outBitStream->Write0();
+		for (const auto& [id, buff] : m_Buffs) {
+			outBitStream->Write<uint32_t>(id);
+			outBitStream->Write(buff.time != 0.0f);
+			if (buff.time != 0.0f) outBitStream->Write(static_cast<uint32_t>(buff.time * 1000.0f));
+			outBitStream->Write(buff.cancelOnDeath);
+			outBitStream->Write(buff.cancelOnZone);
+			outBitStream->Write(buff.cancelOnDamaged);
+			outBitStream->Write(buff.cancelOnRemoveBuff);
+			outBitStream->Write(buff.cancelOnUi);
+			outBitStream->Write(buff.cancelOnLogout);
+			outBitStream->Write(buff.cancelOnUnequip);
+			outBitStream->Write0(); // Cancel on Damage Absorb Ran Out. Generally false from what I can tell
 
-			outBitStream->Write0();
-			outBitStream->Write0();
+			auto* team = TeamManager::Instance()->GetTeam(buff.source);
+			bool addedByTeammate = false;
+			if (team) {
+				addedByTeammate = std::count(team->members.begin(), team->members.end(), m_Parent->GetObjectID()) > 0;
+			}
 
-			outBitStream->Write<uint32_t>(0);
+			outBitStream->Write(addedByTeammate); // Added by teammate. If source is in the same team as the target, this is true. Otherwise, false.
+			outBitStream->Write(buff.applyOnTeammates);
+			if (addedByTeammate) outBitStream->Write(buff.source);
+
+			outBitStream->Write<uint32_t>(buff.refCount);
 		}
 	}
 
-	outBitStream->Write0();
+	outBitStream->Write0(); // something to do with immunity buffs?
 }
 
 void BuffComponent::Update(float deltaTime) {
@@ -83,17 +101,55 @@ void BuffComponent::Update(float deltaTime) {
 	}
 }
 
+const std::string& GetFxName(const std::string& buffname) {
+	const auto& toReturn = BuffFx[buffname];
+	if (toReturn.empty()) {
+		LOG_DEBUG("No fx name for %s", buffname.c_str());
+	}
+	return toReturn;
+}
+
+void BuffComponent::ApplyBuffFx(uint32_t buffId, const BuffParameter& buff) {
+	std::string fxToPlay;
+	const auto& buffName = GetFxName(buff.name);
+
+	if (buffName.empty()) return;
+
+	fxToPlay += std::to_string(buffId);
+	LOG_DEBUG("Playing %s %i", fxToPlay.c_str(), buff.effectId);
+	GameMessages::SendPlayFXEffect(m_Parent->GetObjectID(), buff.effectId, u"cast", fxToPlay, LWOOBJID_EMPTY, 1.07f, 1.0f, false);
+}
+
+void BuffComponent::RemoveBuffFx(uint32_t buffId, const BuffParameter& buff) {
+	std::string fxToPlay;
+	const auto& buffName = GetFxName(buff.name);
+
+	if (buffName.empty()) return;
+
+	fxToPlay += std::to_string(buffId);
+	LOG_DEBUG("Stopping %s", fxToPlay.c_str());
+	GameMessages::SendStopFXEffect(m_Parent, false, fxToPlay);
+}
+
 void BuffComponent::ApplyBuff(const int32_t id, const float duration, const LWOOBJID source, bool addImmunity,
 	bool cancelOnDamaged, bool cancelOnDeath, bool cancelOnLogout, bool cancelOnRemoveBuff,
-	bool cancelOnUi, bool cancelOnUnequip, bool cancelOnZone) {
+	bool cancelOnUi, bool cancelOnUnequip, bool cancelOnZone, bool applyOnTeammates) {
 	// Prevent buffs from stacking.
 	if (HasBuff(id)) {
+		m_Buffs[id].refCount++;
+		m_Buffs[id].time = duration;
 		return;
 	}
 
+	auto* team = TeamManager::Instance()->GetTeam(source);
+	bool addedByTeammate = false;
+	if (team) {
+		addedByTeammate = std::count(team->members.begin(), team->members.end(), m_Parent->GetObjectID()) > 0;
+	}
+
 	GameMessages::SendAddBuff(const_cast<LWOOBJID&>(m_Parent->GetObjectID()), source, (uint32_t)id,
 		(uint32_t)duration * 1000, addImmunity, cancelOnDamaged, cancelOnDeath,
-		cancelOnLogout, cancelOnRemoveBuff, cancelOnUi, cancelOnUnequip, cancelOnZone);
+		cancelOnLogout, cancelOnRemoveBuff, cancelOnUi, cancelOnUnequip, cancelOnZone, addedByTeammate, applyOnTeammates);
 
 	float tick = 0;
 	float stacks = 0;
@@ -121,17 +177,43 @@ void BuffComponent::ApplyBuff(const int32_t id, const float duration, const LWOO
 	buff.stacks = stacks;
 	buff.source = source;
 	buff.behaviorID = behaviorID;
+	buff.cancelOnDamaged = cancelOnDamaged;
+	buff.cancelOnDeath = cancelOnDeath;
+	buff.cancelOnLogout = cancelOnLogout;
+	buff.cancelOnRemoveBuff = cancelOnRemoveBuff;
+	buff.cancelOnUi = cancelOnUi;
+	buff.cancelOnUnequip = cancelOnUnequip;
+	buff.cancelOnZone = cancelOnZone;
+	buff.refCount = 1;
 
 	m_Buffs.emplace(id, buff);
+
+	auto* parent = GetParent();
+	if (!cancelOnDeath) return;
+
+	m_Parent->AddDieCallback([parent, id]() {
+		LOG_DEBUG("Removing buff %i because parent died", id);
+		if (!parent) return;
+		auto* buffComponent = parent->GetComponent<BuffComponent>();
+		if (buffComponent) buffComponent->RemoveBuff(id, false, false, true);
+		});
 }
 
-void BuffComponent::RemoveBuff(int32_t id, bool fromUnEquip, bool removeImmunity) {
+void BuffComponent::RemoveBuff(int32_t id, bool fromUnEquip, bool removeImmunity, bool ignoreRefCount) {
 	const auto& iter = m_Buffs.find(id);
 
 	if (iter == m_Buffs.end()) {
 		return;
 	}
 
+	if (!ignoreRefCount && !iter->second.cancelOnRemoveBuff) {
+		iter->second.refCount--;
+		LOG_DEBUG("refCount for buff %i is now %i", id, iter->second.refCount);
+		if (iter->second.refCount > 0) {
+			return;
+		}
+	}
+
 	GameMessages::SendRemoveBuff(m_Parent, fromUnEquip, removeImmunity, id);
 
 	m_Buffs.erase(iter);
@@ -146,6 +228,7 @@ bool BuffComponent::HasBuff(int32_t id) {
 void BuffComponent::ApplyBuffEffect(int32_t id) {
 	const auto& parameters = GetBuffParameters(id);
 	for (const auto& parameter : parameters) {
+		ApplyBuffFx(id, parameter);
 		if (parameter.name == "max_health") {
 			const auto maxHealth = parameter.value;
 
@@ -182,6 +265,7 @@ void BuffComponent::ApplyBuffEffect(int32_t id) {
 void BuffComponent::RemoveBuffEffect(int32_t id) {
 	const auto& parameters = GetBuffParameters(id);
 	for (const auto& parameter : parameters) {
+		RemoveBuffFx(id, parameter);
 		if (parameter.name == "max_health") {
 			const auto maxHealth = parameter.value;
 
@@ -251,13 +335,25 @@ void BuffComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 
 	auto* buffEntry = buffElement->FirstChildElement("b");
 
-	while (buffEntry != nullptr) {
+	while (buffEntry) {
 		int32_t id = buffEntry->IntAttribute("id");
 		float t = buffEntry->FloatAttribute("t");
 		float tk = buffEntry->FloatAttribute("tk");
+		float tt = buffEntry->FloatAttribute("tt");
 		int32_t s = buffEntry->FloatAttribute("s");
 		LWOOBJID sr = buffEntry->Int64Attribute("sr");
 		int32_t b = buffEntry->IntAttribute("b");
+		int32_t refCount = buffEntry->IntAttribute("refCount");
+
+		bool cancelOnDamaged = buffEntry->BoolAttribute("cancelOnDamaged");
+		bool cancelOnDeath = buffEntry->BoolAttribute("cancelOnDeath");
+		bool cancelOnLogout = buffEntry->BoolAttribute("cancelOnLogout");
+		bool cancelOnRemoveBuff = buffEntry->BoolAttribute("cancelOnRemoveBuff");
+		bool cancelOnUi = buffEntry->BoolAttribute("cancelOnUi");
+		bool cancelOnUnequip = buffEntry->BoolAttribute("cancelOnUnequip");
+		bool cancelOnZone = buffEntry->BoolAttribute("cancelOnZone");
+		bool applyOnTeammates = buffEntry->BoolAttribute("applyOnTeammates");
+
 
 		Buff buff;
 		buff.id = id;
@@ -266,6 +362,18 @@ void BuffComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 		buff.stacks = s;
 		buff.source = sr;
 		buff.behaviorID = b;
+		buff.refCount = refCount;
+		buff.tickTime = tt;
+
+		buff.cancelOnDamaged = cancelOnDamaged;
+		buff.cancelOnDeath = cancelOnDeath;
+		buff.cancelOnLogout = cancelOnLogout;
+		buff.cancelOnRemoveBuff = cancelOnRemoveBuff;
+		buff.cancelOnUi = cancelOnUi;
+		buff.cancelOnUnequip = cancelOnUnequip;
+		buff.cancelOnZone = cancelOnZone;
+		buff.applyOnTeammates = applyOnTeammates;
+
 
 		m_Buffs.emplace(id, buff);
 
@@ -288,15 +396,27 @@ void BuffComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 		buffElement->DeleteChildren();
 	}
 
-	for (const auto& buff : m_Buffs) {
+	for (const auto& [id, buff] : m_Buffs) {
 		auto* buffEntry = doc->NewElement("b");
+		if (buff.cancelOnZone || buff.cancelOnLogout) continue;
 
-		buffEntry->SetAttribute("id", buff.first);
-		buffEntry->SetAttribute("t", buff.second.time);
-		buffEntry->SetAttribute("tk", buff.second.tick);
-		buffEntry->SetAttribute("s", buff.second.stacks);
-		buffEntry->SetAttribute("sr", buff.second.source);
-		buffEntry->SetAttribute("b", buff.second.behaviorID);
+		buffEntry->SetAttribute("id", id);
+		buffEntry->SetAttribute("t", buff.time);
+		buffEntry->SetAttribute("tk", buff.tick);
+		buffEntry->SetAttribute("tt", buff.tickTime);
+		buffEntry->SetAttribute("s", buff.stacks);
+		buffEntry->SetAttribute("sr", buff.source);
+		buffEntry->SetAttribute("b", buff.behaviorID);
+		buffEntry->SetAttribute("refCount", buff.refCount);
+
+		buffEntry->SetAttribute("cancelOnDamaged", buff.cancelOnDamaged);
+		buffEntry->SetAttribute("cancelOnDeath", buff.cancelOnDeath);
+		buffEntry->SetAttribute("cancelOnLogout", buff.cancelOnLogout);
+		buffEntry->SetAttribute("cancelOnRemoveBuff", buff.cancelOnRemoveBuff);
+		buffEntry->SetAttribute("cancelOnUi", buff.cancelOnUi);
+		buffEntry->SetAttribute("cancelOnUnequip", buff.cancelOnUnequip);
+		buffEntry->SetAttribute("cancelOnZone", buff.cancelOnZone);
+		buffEntry->SetAttribute("applyOnTeammates", buff.applyOnTeammates);
 
 		buffElement->LinkEndChild(buffEntry);
 	}
@@ -309,8 +429,7 @@ const std::vector<BuffParameter>& BuffComponent::GetBuffParameters(int32_t buffI
 		return pair->second;
 	}
 
-	auto query = CDClientDatabase::CreatePreppedStmt(
-		"SELECT * FROM BuffParameters WHERE BuffID = ?;");
+	auto query = CDClientDatabase::CreatePreppedStmt("SELECT * FROM BuffParameters WHERE BuffID = ?;");
 	query.bind(1, (int)buffId);
 
 	auto result = query.execQuery();
@@ -321,11 +440,12 @@ const std::vector<BuffParameter>& BuffComponent::GetBuffParameters(int32_t buffI
 		BuffParameter param;
 
 		param.buffId = buffId;
-		param.name = result.getStringField(1);
-		param.value = result.getFloatField(2);
+		param.name = result.getStringField("ParameterName");
+		param.value = result.getFloatField("NumberValue");
+		param.effectId = result.getIntField("EffectID");
 
 		if (!result.fieldIsNull(3)) {
-			std::istringstream stream(result.getStringField(3));
+			std::istringstream stream(result.getStringField("StringValue"));
 			std::string token;
 
 			while (std::getline(stream, token, ',')) {

dGame/dComponents/BuffComponent.h

@@ -14,8 +14,7 @@ class Entity;
 /**
  * Extra information on effects to apply after applying a buff, for example whether to buff armor, imag or health and by how much
  */
-struct BuffParameter
-{
+struct BuffParameter {
 	int32_t buffId;
 	std::string name;
 	float value;
@@ -26,8 +25,7 @@ struct BuffParameter
 /**
  * Meta information about a buff that can be applied, e.g. how long it's applied, who applied it, etc.
  */
-struct Buff
-{
+struct Buff {
 	int32_t id = 0;
 	float time = 0;
 	float tick = 0;
@@ -35,6 +33,15 @@ struct Buff
 	int32_t stacks = 0;
 	LWOOBJID source = 0;
 	int32_t behaviorID = 0;
+	bool cancelOnDamaged = false;
+	bool cancelOnDeath = false;
+	bool cancelOnLogout = false;
+	bool cancelOnRemoveBuff = false;
+	bool cancelOnUi = false;
+	bool cancelOnUnequip = false;
+	bool cancelOnZone = false;
+	bool applyOnTeammates = false;
+	uint32_t refCount = 0;
 };
 
 /**
@@ -74,14 +81,17 @@ public:
 	 */
 	void ApplyBuff(int32_t id, float duration, LWOOBJID source, bool addImmunity = false, bool cancelOnDamaged = false,
 		bool cancelOnDeath = true, bool cancelOnLogout = false, bool cancelOnRemoveBuff = true,
-		bool cancelOnUi = false, bool cancelOnUnequip = false, bool cancelOnZone = false);
+		bool cancelOnUi = false, bool cancelOnUnequip = false, bool cancelOnZone = false, bool applyOnTeammates = false);
+
+	void ApplyBuffFx(uint32_t buffId, const BuffParameter& buffName);
+	void RemoveBuffFx(uint32_t buffId, const BuffParameter& buffName);
 
 	/**
 	 * Removes a buff from the parent entity, reversing its effects
 	 * @param id the id of the buff to remove
 	 * @param removeImmunity whether or not to remove immunity on removing the buff
 	 */
-	void RemoveBuff(int32_t id, bool fromUnEquip = false, bool removeImmunity = false);
+	void RemoveBuff(int32_t id, bool fromUnEquip = false, bool removeImmunity = false, bool ignoreRefCount = false);
 
 	/**
 	 * Returns whether or not the entity has a buff identified by `id`

dGame/dComponents/CMakeLists.txt

@@ -43,7 +43,7 @@ set(DGAME_DCOMPONENTS_SOURCES "BaseCombatAIComponent.cpp"
 	"SoundTriggerComponent.cpp"
 	"SwitchComponent.cpp"
 	"TriggerComponent.cpp"
-	"VehiclePhysicsComponent.cpp"
+	"HavokVehiclePhysicsComponent.cpp"
 	"VendorComponent.cpp"
 	"ZoneControlComponent.cpp"
 	PARENT_SCOPE

dGame/dComponents/CharacterComponent.cpp

@@ -10,12 +10,16 @@
 #include "InventoryComponent.h"
 #include "ControllablePhysicsComponent.h"
 #include "EntityManager.h"
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "GameMessages.h"
 #include "Item.h"
 #include "Amf3.h"
 #include "eGameMasterLevel.h"
 #include "eGameActivity.h"
+#include "User.h"
+#include "Database.h"
+#include "CDRewardCodesTable.h"
+#include "Mail.h"
 #include <ctime>
 
 CharacterComponent::CharacterComponent(Entity* parent, Character* character) : Component(parent) {
@@ -74,10 +78,14 @@ CharacterComponent::~CharacterComponent() {
 void CharacterComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
 
 	if (bIsInitialUpdate) {
-		outBitStream->Write0();
-		outBitStream->Write0();
-		outBitStream->Write0();
-		outBitStream->Write0();
+		outBitStream->Write(m_ClaimCodes[0] != 0);
+		if (m_ClaimCodes[0] != 0) outBitStream->Write(m_ClaimCodes[0]);
+		outBitStream->Write(m_ClaimCodes[1] != 0);
+		if (m_ClaimCodes[1] != 0) outBitStream->Write(m_ClaimCodes[1]);
+		outBitStream->Write(m_ClaimCodes[2] != 0);
+		if (m_ClaimCodes[2] != 0) outBitStream->Write(m_ClaimCodes[2]);
+		outBitStream->Write(m_ClaimCodes[3] != 0);
+		if (m_ClaimCodes[3] != 0) outBitStream->Write(m_ClaimCodes[3]);
 
 		outBitStream->Write(m_Character->GetHairColor());
 		outBitStream->Write(m_Character->GetHairStyle());
@@ -186,6 +194,13 @@ void CharacterComponent::LoadFromXml(tinyxml2::XMLDocument* doc) {
 		SetReputation(0);
 	}
 
+	character->QueryUnsigned64Attribute("co", &m_ClaimCodes[0]);
+	character->QueryUnsigned64Attribute("co1", &m_ClaimCodes[1]);
+	character->QueryUnsigned64Attribute("co2", &m_ClaimCodes[2]);
+	character->QueryUnsigned64Attribute("co3", &m_ClaimCodes[3]);
+
+	AwardClaimCodes();
+
 	character->QueryInt64Attribute("ls", &m_Uscore);
 
 	// Load the statistics
@@ -308,6 +323,11 @@ void CharacterComponent::UpdateXml(tinyxml2::XMLDocument* doc) {
 		return;
 	}
 
+	if (m_ClaimCodes[0] != 0) character->SetAttribute("co", m_ClaimCodes[0]);
+	if (m_ClaimCodes[1] != 0) character->SetAttribute("co1", m_ClaimCodes[1]);
+	if (m_ClaimCodes[2] != 0) character->SetAttribute("co2", m_ClaimCodes[2]);
+	if (m_ClaimCodes[3] != 0) character->SetAttribute("co3", m_ClaimCodes[3]);
+
 	character->SetAttribute("ls", m_Uscore);
 	// Custom attribute to keep track of reputation.
 	character->SetAttribute("rpt", GetReputation());
@@ -738,3 +758,31 @@ void CharacterComponent::UpdateClientMinimap(bool showFaction, std::string ventu
 	arrayToSend.Insert(ventureVisionType, showFaction);
 	GameMessages::SendUIMessageServerToSingleClient(m_Parent, m_Parent ? m_Parent->GetSystemAddress() : UNASSIGNED_SYSTEM_ADDRESS, "SetFactionVisibility", arrayToSend);
 }
+
+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){
+		LOG_DEBUG("Processing RewardCode %i", rewardCode);
+		const uint32_t rewardCodeIndex = rewardCode >> 6;
+		const uint32_t bitIndex = rewardCode % 64;
+		if (GeneralUtils::CheckBit(m_ClaimCodes[rewardCodeIndex], bitIndex)) continue;
+		m_ClaimCodes[rewardCodeIndex] = GeneralUtils::SetBit(m_ClaimCodes[rewardCodeIndex], bitIndex);
+
+		// Don't send it on this one since it's default and the mail doesn't make sense
+		if (rewardCode == 30) continue;
+
+		auto attachmentLOT = cdrewardCodes->GetAttachmentLOT(rewardCode);
+		std::ostringstream subject;
+		subject << "%[RewardCodes_" << rewardCode << "_subjectText]";
+		std::ostringstream body;
+		body << "%[RewardCodes_" << rewardCode << "_bodyText]";
+		Mail::SendMail(LWOOBJID_EMPTY, "%[MAIL_SYSTEM_NOTIFICATION]", m_Parent, subject.str(), body.str(), attachmentLOT, 1);
+	}
+}

dGame/dComponents/CharacterComponent.h

@@ -10,6 +10,7 @@
 #include "CDMissionsTable.h"
 #include "tinyxml2.h"
 #include "eReplicaComponentType.h"
+#include <array>
 
 enum class eGameActivity : uint32_t;
 
@@ -566,6 +567,10 @@ private:
 	LWOOBJID m_LastRocketItemID = LWOOBJID_EMPTY;
 
 	LWOOBJID m_CurrentInteracting = LWOOBJID_EMPTY;
+
+	std::array<uint64_t, 4> m_ClaimCodes{};
+
+	void AwardClaimCodes();
 };
 
 #endif // CHARACTERCOMPONENT_H

dGame/dComponents/DestroyableComponent.cpp

@@ -796,7 +796,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 		}
 	}
 
-	m_Parent->Kill(owner);
+	m_Parent->Kill(owner, killType);
 }
 
 void DestroyableComponent::SetFaction(int32_t factionID, bool ignoreChecks) {

dGame/dComponents/HavokVehiclePhysicsComponent.cpp

@@ -1,7 +1,7 @@
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "EntityManager.h"
 
-VehiclePhysicsComponent::VehiclePhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
+HavokVehiclePhysicsComponent::HavokVehiclePhysicsComponent(Entity* parent) : PhysicsComponent(parent) {
 	m_Velocity = NiPoint3::ZERO;
 	m_AngularVelocity = NiPoint3::ZERO;
 	m_IsOnGround = true;
@@ -12,45 +12,45 @@ VehiclePhysicsComponent::VehiclePhysicsComponent(Entity* parent) : PhysicsCompon
 	m_EndBehavior = GeneralUtils::GenerateRandomNumber<uint32_t>(0, 7);
 }
 
-void VehiclePhysicsComponent::SetVelocity(const NiPoint3& vel) {
+void HavokVehiclePhysicsComponent::SetVelocity(const NiPoint3& vel) {
 	if (vel == m_Velocity) return;
 	m_DirtyPosition = true;
 	m_Velocity = vel;
 }
 
-void VehiclePhysicsComponent::SetAngularVelocity(const NiPoint3& vel) {
+void HavokVehiclePhysicsComponent::SetAngularVelocity(const NiPoint3& vel) {
 	if (vel == m_AngularVelocity) return;
 	m_DirtyPosition = true;
 	m_AngularVelocity = vel;
 }
 
-void VehiclePhysicsComponent::SetIsOnGround(bool val) {
+void HavokVehiclePhysicsComponent::SetIsOnGround(bool val) {
 	if (val == m_IsOnGround) return;
 	m_DirtyPosition = true;
 	m_IsOnGround = val;
 }
 
-void VehiclePhysicsComponent::SetIsOnRail(bool val) {
+void HavokVehiclePhysicsComponent::SetIsOnRail(bool val) {
 	if (val == m_IsOnRail) return;
 	m_DirtyPosition = true;
 	m_IsOnRail = val;
 }
 
-void VehiclePhysicsComponent::SetRemoteInputInfo(const RemoteInputInfo& remoteInputInfo) {
+void HavokVehiclePhysicsComponent::SetRemoteInputInfo(const RemoteInputInfo& remoteInputInfo) {
 	if (m_RemoteInputInfo == remoteInputInfo) return;
 	this->m_RemoteInputInfo = remoteInputInfo;
 	m_DirtyRemoteInput = true;
 }
 
-void VehiclePhysicsComponent::SetDirtyVelocity(bool val) {
+void HavokVehiclePhysicsComponent::SetDirtyVelocity(bool val) {
 	m_DirtyVelocity = val;
 }
 
-void VehiclePhysicsComponent::SetDirtyAngularVelocity(bool val) {
+void HavokVehiclePhysicsComponent::SetDirtyAngularVelocity(bool val) {
 	m_DirtyAngularVelocity = val;
 }
 
-void VehiclePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
+void HavokVehiclePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
 	outBitStream->Write(bIsInitialUpdate || m_DirtyPosition);
 
 	if (bIsInitialUpdate || m_DirtyPosition) {
@@ -111,7 +111,7 @@ void VehiclePhysicsComponent::Serialize(RakNet::BitStream* outBitStream, bool bI
 	outBitStream->Write0();
 }
 
-void VehiclePhysicsComponent::Update(float deltaTime) {
+void HavokVehiclePhysicsComponent::Update(float deltaTime) {
 	if (m_SoftUpdate > 5) {
 		Game::entityManager->SerializeEntity(m_Parent);
 		m_SoftUpdate = 0;

dGame/dComponents/HavokVehiclePhysicsComponent.h

@@ -6,6 +6,13 @@
 #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;
@@ -26,11 +33,11 @@ struct RemoteInputInfo {
 /**
  * Physics component for vehicles.
  */
-class VehiclePhysicsComponent : public PhysicsComponent {
+class HavokVehiclePhysicsComponent : public PhysicsComponent {
 public:
-	inline static const eReplicaComponentType ComponentType = eReplicaComponentType::VEHICLE_PHYSICS;
+	inline static const eReplicaComponentType ComponentType = eReplicaComponentType::HAVOK_VEHICLE_PHYSICS;
 
-	VehiclePhysicsComponent(Entity* parentEntity);
+	HavokVehiclePhysicsComponent(Entity* parentEntity);
 
 	void Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) override;
 

dGame/dComponents/InventoryComponent.cpp

@@ -19,7 +19,7 @@
 #include "PossessorComponent.h"
 #include "PossessableComponent.h"
 #include "ModuleAssemblyComponent.h"
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "CharacterComponent.h"
 #include "dZoneManager.h"
 #include "PropertyManagementComponent.h"
@@ -981,7 +981,7 @@ void InventoryComponent::HandlePossession(Item* item) {
 	auto* mount = Game::entityManager->CreateEntity(info, nullptr, m_Parent);
 
 	// Check to see if the mount is a vehicle, if so, flip it
-	auto* vehicleComponent = mount->GetComponent<VehiclePhysicsComponent>();
+	auto* vehicleComponent = mount->GetComponent<HavokVehiclePhysicsComponent>();
 	if (vehicleComponent) characterComponent->SetIsRacing(true);
 
 	// Setup the destroyable stats

dGame/dComponents/PhantomPhysicsComponent.cpp

@@ -402,10 +402,10 @@ void PhantomPhysicsComponent::SetDirection(const NiPoint3& pos) {
 void PhantomPhysicsComponent::SpawnVertices() {
 	if (!m_dpEntity) return;
 
-	std::cout << m_Parent->GetObjectID() << std::endl;
+	LOG("%llu", m_Parent->GetObjectID());
 	auto box = static_cast<dpShapeBox*>(m_dpEntity->GetShape());
 	for (auto vert : box->GetVertices()) {
-		std::cout << vert.x << ", " << vert.y << ", " << vert.z << std::endl;
+		LOG("%f, %f, %f", vert.x, vert.y, vert.z);
 
 		EntityInfo info;
 		info.lot = 33;

dGame/dComponents/PropertyManagementComponent.h

@@ -164,6 +164,8 @@ public:
 
 	LWOCLONEID GetCloneId() { return clone_Id; };
 
+	LWOOBJID GetId() const noexcept { return propertyId; }
+
 private:
 	/**
 	 * This

dGame/dComponents/RacingControlComponent.cpp

@@ -17,7 +17,7 @@
 #include "PossessorComponent.h"
 #include "eRacingTaskParam.h"
 #include "Spawner.h"
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "dServer.h"
 #include "dZoneManager.h"
 #include "dConfig.h"
@@ -51,7 +51,7 @@ RacingControlComponent::RacingControlComponent(Entity* parent)
 
 	m_MainWorld = 1200;
 	const auto worldID = Game::server->GetZoneID();
-	if (Game::zoneManager->CheckIfAccessibleZone((worldID/10)*10)) m_MainWorld = (worldID/10)*10;
+	if (Game::zoneManager->CheckIfAccessibleZone((worldID / 10) * 10)) m_MainWorld = (worldID / 10) * 10;
 
 	m_ActivityID = 42;
 	CDActivitiesTable* activitiesTable = CDClientManager::Instance().GetTable<CDActivitiesTable>();
@@ -72,7 +72,7 @@ void RacingControlComponent::OnPlayerLoaded(Entity* player) {
 	// If the race has already started, send the player back to the main world.
 	if (m_Loaded || !vehicle) {
 		auto* playerInstance = dynamic_cast<Player*>(player);
-		if(playerInstance){
+		if (playerInstance) {
 			playerInstance->SendToZone(m_MainWorld);
 		}
 		return;
@@ -106,12 +106,12 @@ void RacingControlComponent::LoadPlayerVehicle(Entity* player,
 	if (item == nullptr) {
 		LOG("Failed to find item");
 		auto* playerInstance = dynamic_cast<Player*>(player);
-		if(playerInstance){
+		if (playerInstance) {
 			m_LoadedPlayers--;
 			playerInstance->SendToZone(m_MainWorld);
 		}
 		return;
-		
+
 	}
 
 	// Calculate the vehicle's starting position.
@@ -213,6 +213,7 @@ void RacingControlComponent::LoadPlayerVehicle(Entity* player,
 			 0,
 			 0,
 			 0 });
+		m_AllPlayersReady = false;
 	}
 
 	// Construct and serialize everything when done.
@@ -330,7 +331,7 @@ void RacingControlComponent::OnRequestDie(Entity* player) {
 				// Reset imagination to half its current value, rounded up to the nearest value divisible by 10, as it was done in live.
 				if (destroyableComponent) destroyableComponent->SetImagination(respawnImagination);
 				Game::entityManager->SerializeEntity(vehicle);
-			});
+				});
 
 			auto* characterComponent = player->GetComponent<CharacterComponent>();
 			if (characterComponent != nullptr) {
@@ -384,11 +385,11 @@ void RacingControlComponent::HandleMessageBoxResponse(Entity* player, int32_t bu
 
 		// Calculate the score, different loot depending on player count
 		auto playersRating = m_LoadedPlayers;
-		if(m_LoadedPlayers == 1 && m_SoloRacing) {
+		if (m_LoadedPlayers == 1 && m_SoloRacing) {
 			playersRating *= 2;
 		}
 
-        const auto score = playersRating * 10 + data->finished;
+		const auto score = playersRating * 10 + data->finished;
 		Loot::GiveActivityLoot(player, m_Parent, m_ActivityID, score);
 
 		// Giving rewards
@@ -436,64 +437,82 @@ void RacingControlComponent::HandleMessageBoxResponse(Entity* player, int32_t bu
 
 void RacingControlComponent::Serialize(RakNet::BitStream* outBitStream, bool bIsInitialUpdate) {
 	// BEGIN Scripted Activity
-
 	outBitStream->Write1();
 
 	outBitStream->Write(static_cast<uint32_t>(m_RacingPlayers.size()));
 	for (const auto& player : m_RacingPlayers) {
 		outBitStream->Write(player.playerID);
 
-		for (int i = 0; i < 10; i++) {
-			outBitStream->Write(player.data[i]);
-		}
+		outBitStream->Write(player.data[0]);
+		if (player.finished != 0) outBitStream->Write<float>(player.raceTime);
+		else outBitStream->Write(player.data[1]);
+		if (player.finished != 0) outBitStream->Write<float>(player.bestLapTime);
+		else outBitStream->Write(player.data[2]);
+		if (player.finished == 1) outBitStream->Write<float>(1.0f);
+		else outBitStream->Write(player.data[3]);
+		outBitStream->Write(player.data[4]);
+		outBitStream->Write(player.data[5]);
+		outBitStream->Write(player.data[6]);
+		outBitStream->Write(player.data[7]);
+		outBitStream->Write(player.data[8]);
+		outBitStream->Write(player.data[9]);
 	}
 
 	// END Scripted Activity
 
-	outBitStream->Write1(); // Dirty?
+	outBitStream->Write1();
 	outBitStream->Write(static_cast<uint16_t>(m_RacingPlayers.size()));
 
-	outBitStream->Write(!m_RacingPlayers.empty());
-	if (!m_RacingPlayers.empty()) {
+	outBitStream->Write(!m_AllPlayersReady);
+	if (!m_AllPlayersReady) {
+		int32_t numReady = 0;
 		for (const auto& player : m_RacingPlayers) {
-			outBitStream->Write1(); // Has more date
-
+			outBitStream->Write1(); // Has more player data
 			outBitStream->Write(player.playerID);
 			outBitStream->Write(player.vehicleID);
 			outBitStream->Write(player.playerIndex);
 			outBitStream->Write(player.playerLoaded);
+			if (player.playerLoaded) numReady++;
 		}
 
 		outBitStream->Write0(); // No more data
+		if (numReady == m_RacingPlayers.size()) m_AllPlayersReady = true;
 	}
 
 	outBitStream->Write(!m_RacingPlayers.empty());
 	if (!m_RacingPlayers.empty()) {
 		for (const auto& player : m_RacingPlayers) {
+			if (player.finished == 0) continue;
 			outBitStream->Write1(); // Has more date
 
 			outBitStream->Write(player.playerID);
-			outBitStream->Write<uint32_t>(0);
+			outBitStream->Write(player.finished);
 		}
 
 		outBitStream->Write0(); // No more data
 	}
 
-	outBitStream->Write1(); // Dirty?
-
-	outBitStream->Write(m_RemainingLaps);
-
-	outBitStream->Write(static_cast<uint16_t>(m_PathName.size()));
-	for (const auto character : m_PathName) {
-		outBitStream->Write(character);
+	outBitStream->Write(bIsInitialUpdate);
+	if (bIsInitialUpdate) {
+		outBitStream->Write(m_RemainingLaps);
+		outBitStream->Write(static_cast<uint16_t>(m_PathName.size()));
+		for (const auto character : m_PathName) {
+			outBitStream->Write(character);
+		}
 	}
 
-	outBitStream->Write1(); // ???
-	outBitStream->Write1(); // ???
+	outBitStream->Write(!m_RacingPlayers.empty());
+	if (!m_RacingPlayers.empty()) {
+		for (const auto& player : m_RacingPlayers) {
+			if (player.finished == 0) continue;
+			outBitStream->Write1(); // Has more data
+			outBitStream->Write(player.playerID);
+			outBitStream->Write<float>(player.bestLapTime);
+			outBitStream->Write<float>(player.raceTime);
+		}
 
-	outBitStream->Write(m_LeadingPlayer);
-	outBitStream->Write(m_RaceBestLap);
-	outBitStream->Write(m_RaceBestTime);
+		outBitStream->Write0(); // No more data
+	}
 }
 
 RacingPlayerInfo* RacingControlComponent::GetPlayerData(LWOOBJID playerID) {
@@ -569,7 +588,7 @@ void RacingControlComponent::Update(float deltaTime) {
 
 				LoadPlayerVehicle(player, positionNumber + 1, true);
 
-				m_Loaded = true;
+				Game::entityManager->SerializeEntity(m_Parent);
 			}
 
 			m_Loaded = true;
@@ -757,6 +776,8 @@ void RacingControlComponent::Update(float deltaTime) {
 			continue;
 		}
 
+		if (m_Finished != 0) Game::entityManager->SerializeEntity(m_Parent);
+
 		// Loop through all the waypoints and see if the player has reached a
 		// new checkpoint
 		uint32_t respawnIndex = 0;
@@ -849,8 +870,6 @@ void RacingControlComponent::Update(float deltaTime) {
 						if (characterComponent != nullptr) {
 							characterComponent->TrackRaceCompleted(m_Finished == 1);
 						}
-
-						// TODO: Figure out how to update the GUI leaderboard.
 					}
 				}
 
@@ -865,28 +884,3 @@ void RacingControlComponent::Update(float deltaTime) {
 		}
 	}
 }
-
-std::string RacingControlComponent::FormatTimeString(time_t time) {
-	int32_t min = time / 60;
-	time -= min * 60;
-	int32_t sec = time;
-
-	std::string minText;
-	std::string secText;
-
-	if (min <= 0) {
-		minText = "0";
-	} else {
-		minText = std::to_string(min);
-	}
-
-	if (sec <= 0) {
-		secText = "00";
-	} else if (sec <= 9) {
-		secText = "0" + std::to_string(sec);
-	} else {
-		secText = std::to_string(sec);
-	}
-
-	return minText + ":" + secText + ".00";
-}

dGame/dComponents/RacingControlComponent.h

@@ -151,13 +151,6 @@ public:
 	 */
 	RacingPlayerInfo* GetPlayerData(LWOOBJID playerID);
 
-	/**
-	 * Formats a time to a string, currently unused
-	 * @param time the time to format
-	 * @return the time formatted as string
-	 */
-	static std::string FormatTimeString(time_t time);
-
 private:
 
 	/**
@@ -251,4 +244,5 @@ private:
 	 * Value for message box response to know if we are exiting the race via the activity dialogue
 	 */
 	const int32_t m_ActivityExitConfirm = 1;
+	bool m_AllPlayersReady = false;
 };

dGame/dGameMessages/GameMessageHandler.cpp

@@ -34,6 +34,8 @@
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
 #include "eConnectionType.h"
+#include "ePlayerFlag.h"
+#include "dConfig.h"
 
 using namespace std;
 
@@ -173,6 +175,13 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		GameMessages::SendPlayerReady(entity, sysAddr);
 		GameMessages::SendPlayerReady(Game::zoneManager->GetZoneControlObject(), sysAddr);
 
+		if (Game::config->GetValue("allow_players_to_skip_cinematics") != "1"
+			|| !entity->GetCharacter()
+			|| !entity->GetCharacter()->GetPlayerFlag(ePlayerFlag::DLU_SKIP_CINEMATICS)) return;
+		entity->AddCallbackTimer(0.5f, [entity, sysAddr]() {
+			if (!entity) return;
+			GameMessages::SendEndCinematic(entity->GetObjectID(), u"", sysAddr);
+			});
 		break;
 	}
 
@@ -244,13 +253,6 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 
 	case eGameMessageType::REQUEST_RESURRECT: {
 		GameMessages::SendResurrect(entity);
-		/*auto* dest = static_cast<DestroyableComponent*>(entity->GetComponent(eReplicaComponentType::DESTROYABLE));
-		if (dest) {
-			dest->SetHealth(4);
-			dest->SetArmor(0);
-			dest->SetImagination(6);
-			Game::entityManager->SerializeEntity(entity);
-		}*/
 		break;
 	}
 	case eGameMessageType::GET_HOT_PROPERTY_DATA: {
@@ -339,11 +341,8 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 		RakNet::BitStream bitStreamLocal;
 		BitStreamUtils::WriteHeader(bitStreamLocal, eConnectionType::CLIENT, eClientMessageType::GAME_MSG);
 		bitStreamLocal.Write(entity->GetObjectID());
-		//bitStreamLocal.Write((unsigned short)eGameMessageType::ECHO_SYNC_SKILL);
-		//bitStreamLocal.Write(inStream);
 
 		SyncSkill sync = SyncSkill(inStream); // inStream replaced &bitStream
-		//sync.Serialize(&bitStreamLocal);
 
 		ostringstream buffer;
 
@@ -353,8 +352,6 @@ void GameMessageHandler::HandleMessage(RakNet::BitStream* inStream, const System
 			buffer << setw(2) << hex << setfill('0') << (int)s << " ";
 		}
 
-		//cout << buffer.str() << endl;
-
 		if (usr != nullptr) {
 			RakNet::BitStream* bs = new RakNet::BitStream((unsigned char*)sync.sBitStream.c_str(), sync.sBitStream.size(), false);
 

dGame/dGameMessages/GameMessages.cpp

@@ -43,6 +43,7 @@
 #include "eControlScheme.h"
 #include "eStateChangeType.h"
 #include "eConnectionType.h"
+#include "ePlayerFlag.h"
 
 #include <sstream>
 #include <future>
@@ -70,7 +71,7 @@
 #include "MovingPlatformComponent.h"
 #include "PetComponent.h"
 #include "ModuleAssemblyComponent.h"
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "RenderComponent.h"
 #include "PossessableComponent.h"
 #include "PossessorComponent.h"
@@ -943,14 +944,7 @@ void GameMessages::SendResurrect(Entity* entity) {
 				destroyableComponent->SetImagination(imaginationToRestore);
 			}
 		}
-		});
-
-
-	auto cont = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
-	if (cont && entity->GetLOT() == 1) {
-		cont->SetPosition(entity->GetRespawnPosition());
-		cont->SetRotation(entity->GetRespawnRotation());
-	}
+	});
 
 	CBITSTREAM;
 	CMSGHEADER;
@@ -1143,18 +1137,16 @@ void GameMessages::SendPlayerReachedRespawnCheckpoint(Entity* entity, const NiPo
 	bitStream.Write(position.y);
 	bitStream.Write(position.z);
 
-	auto con = static_cast<ControllablePhysicsComponent*>(entity->GetComponent(eReplicaComponentType::CONTROLLABLE_PHYSICS));
-	if (con) {
-		auto rot = con->GetRotation();
-		bitStream.Write(rot.x);
-		bitStream.Write(rot.y);
-		bitStream.Write(rot.z);
-		bitStream.Write(rot.w);
+	const bool isNotIdentity = rotation != NiQuaternion::IDENTITY;
+	bitStream.Write(isNotIdentity);
+	
+	if (isNotIdentity) {
+		bitStream.Write(rotation.w);
+		bitStream.Write(rotation.x);
+		bitStream.Write(rotation.y);
+		bitStream.Write(rotation.z);
 	}
 
-	//bitStream.Write(position);
-	//bitStream.Write(rotation);
-
 	SystemAddress sysAddr = entity->GetSystemAddress();
 	SEND_PACKET;
 }
@@ -4485,7 +4477,7 @@ void GameMessages::SendVehicleNotifyFinishedRace(LWOOBJID objectId, const System
 
 void GameMessages::SendAddBuff(LWOOBJID& objectID, const LWOOBJID& casterID, uint32_t buffID, uint32_t msDuration,
 	bool addImmunity, bool cancelOnDamaged, bool cancelOnDeath, bool cancelOnLogout,
-	bool cancelOnRemoveBuff, bool cancelOnUi, bool cancelOnUnequip, bool cancelOnZone,
+	bool cancelOnRemoveBuff, bool cancelOnUi, bool cancelOnUnequip, bool cancelOnZone, bool addedByTeammate, bool applyOnTeammates,
 	const SystemAddress& sysAddr) {
 	CBITSTREAM;
 	CMSGHEADER;
@@ -4493,27 +4485,29 @@ void GameMessages::SendAddBuff(LWOOBJID& objectID, const LWOOBJID& casterID, uin
 	bitStream.Write(objectID);
 	bitStream.Write(eGameMessageType::ADD_BUFF);
 
-	bitStream.Write(false); // Added by teammate
-	bitStream.Write(false); // Apply on teammates
-	bitStream.Write(false); // Cancel on damage absorb ran out
+	bitStream.Write(addedByTeammate); // Added by teammate
+	bitStream.Write(applyOnTeammates); // Apply on teammates
 	bitStream.Write(cancelOnDamaged);
 	bitStream.Write(cancelOnDeath);
 	bitStream.Write(cancelOnLogout);
+
 	bitStream.Write(false); // Cancel on move
 	bitStream.Write(cancelOnRemoveBuff);
-
 	bitStream.Write(cancelOnUi);
 	bitStream.Write(cancelOnUnequip);
 	bitStream.Write(cancelOnZone);
+
 	bitStream.Write(false); // Ignore immunities
 	bitStream.Write(addImmunity);
 	bitStream.Write(false); // Use ref count
 
-	bitStream.Write(buffID);
-	bitStream.Write(msDuration);
+	bitStream.Write(casterID != LWOOBJID_EMPTY);
+	if (casterID != LWOOBJID_EMPTY) bitStream.Write(casterID);
 
-	bitStream.Write(casterID);
-	bitStream.Write(casterID);
+	bitStream.Write(buffID);
+
+	bitStream.Write(msDuration != 0);
+	if (msDuration != 0) bitStream.Write(msDuration);
 
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) SEND_PACKET_BROADCAST;
 	SEND_PACKET;
@@ -5016,6 +5010,14 @@ void GameMessages::HandlePlayEmote(RakNet::BitStream* inStream, Entity* entity)
 	if (emoteID == 0) return;
 	std::string sAnimationName = "deaded"; //Default name in case we fail to get the emote
 
+	CDEmoteTableTable* emotes = CDClientManager::Instance().GetTable<CDEmoteTableTable>();
+	if (emotes) {
+		CDEmoteTable* emote = emotes->GetEmote(emoteID);
+		if (emote) sAnimationName = emote->animationName;
+	}
+
+	RenderComponent::PlayAnimation(entity, sAnimationName);
+
 	MissionComponent* missionComponent = entity->GetComponent<MissionComponent>();
 	if (!missionComponent) return;
 
@@ -5041,14 +5043,6 @@ void GameMessages::HandlePlayEmote(RakNet::BitStream* inStream, Entity* entity)
 			missionComponent->Progress(eMissionTaskType::EMOTE, emoteID, scripted->GetObjectID());
 		}
 	}
-
-	CDEmoteTableTable* emotes = CDClientManager::Instance().GetTable<CDEmoteTableTable>();
-	if (emotes) {
-		CDEmoteTable* emote = emotes->GetEmote(emoteID);
-		if (emote) sAnimationName = emote->animationName;
-	}
-
-	RenderComponent::PlayAnimation(entity, sAnimationName);
 }
 
 void GameMessages::HandleModularBuildConvertModel(RakNet::BitStream* inStream, Entity* entity, const SystemAddress& sysAddr) {
@@ -5161,6 +5155,14 @@ void GameMessages::HandleMissionDialogOK(RakNet::BitStream* inStream, Entity* en
 	} else if (iMissionState == eMissionState::READY_TO_COMPLETE || iMissionState == eMissionState::COMPLETE_READY_TO_COMPLETE) {
 		missionComponent->CompleteMission(missionID);
 	}
+
+	if (Game::config->GetValue("allow_players_to_skip_cinematics") != "1"
+	|| !player->GetCharacter()
+	|| !player->GetCharacter()->GetPlayerFlag(ePlayerFlag::DLU_SKIP_CINEMATICS)) return;
+	player->AddCallbackTimer(0.5f, [player]() {
+		if (!player) return;
+		GameMessages::SendEndCinematic(player->GetObjectID(), u"", player->GetSystemAddress());
+	});
 }
 
 void GameMessages::HandleRequestLinkedMission(RakNet::BitStream* inStream, Entity* entity) {

dGame/dGameMessages/GameMessages.h

@@ -206,7 +206,7 @@ namespace GameMessages {
 	void SendAddBuff(LWOOBJID& objectID, const LWOOBJID& casterID, uint32_t buffID, uint32_t msDuration,
 		bool addImmunity = false, bool cancelOnDamaged = false, bool cancelOnDeath = true,
 		bool cancelOnLogout = false, bool cancelOnRemoveBuff = true, bool cancelOnUi = false,
-		bool cancelOnUnequip = false, bool cancelOnZone = false, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
+		bool cancelOnUnequip = false, bool cancelOnZone = false, bool addedByTeammate = false, bool applyOnTeammates = false, const SystemAddress& sysAddr = UNASSIGNED_SYSTEM_ADDRESS);
 
 	void SendToggleGMInvis(LWOOBJID objectId, bool enabled, const SystemAddress& sysAddr);
 

dGame/dUtilities/SlashCommandHandler.cpp

@@ -59,7 +59,7 @@
 #include "dpShapeSphere.h"
 #include "PossessableComponent.h"
 #include "PossessorComponent.h"
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "BuffComponent.h"
 #include "SkillComponent.h"
 #include "VanityUtilities.h"
@@ -83,8 +83,10 @@
 #include "eChatInternalMessageType.h"
 #include "eMasterMessageType.h"
 
+#include "CDRewardCodesTable.h"
 #include "CDObjectsTable.h"
 #include "CDZoneTableTable.h"
+#include "ePlayerFlag.h"
 
 void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entity* entity, const SystemAddress& sysAddr) {
 	auto commandCopy = command;
@@ -171,6 +173,21 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		return;
 	}
 
+	if (chatCommand == "toggleskipcinematics" && (Game::config->GetValue("allow_players_to_skip_cinematics") == "1" || entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER)) {
+		auto* character = entity->GetCharacter();
+		if (!character) return;
+		bool current = character->GetPlayerFlag(ePlayerFlag::DLU_SKIP_CINEMATICS);
+		character->SetPlayerFlag(ePlayerFlag::DLU_SKIP_CINEMATICS, !current);
+		if (!current) {
+			ChatPackets::SendSystemMessage(sysAddr, u"You have elected to skip cinematics. Note that not all cinematics can be skipped, but most will be skipped now.");
+		} else {
+			ChatPackets::SendSystemMessage(sysAddr, u"Cinematics will no longer be skipped.");
+		}
+
+		return;
+	}
+
+
 	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 	//HANDLE ALL NON GM SLASH COMMANDS RIGHT HERE!
 	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
@@ -925,9 +942,9 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 			auto* possassableEntity = Game::entityManager->GetEntity(possessorComponent->GetPossessable());
 
 			if (possassableEntity != nullptr) {
-				auto* vehiclePhysicsComponent = possassableEntity->GetComponent<VehiclePhysicsComponent>();
-				if (vehiclePhysicsComponent) {
-					vehiclePhysicsComponent->SetPosition(pos);
+				auto* havokVehiclePhysicsComponent = possassableEntity->GetComponent<HavokVehiclePhysicsComponent>();
+				if (havokVehiclePhysicsComponent) {
+					havokVehiclePhysicsComponent->SetPosition(pos);
 					Game::entityManager->SerializeEntity(possassableEntity);
 				} else GameMessages::SendTeleport(possassableEntity->GetObjectID(), pos, NiQuaternion(), sysAddr);
 			}
@@ -1372,7 +1389,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 		ChatPackets::SendSystemMessage(sysAddr, u"<" + (GeneralUtils::to_u16string(position.x)) + u", " + (GeneralUtils::to_u16string(position.y)) + u", " + (GeneralUtils::to_u16string(position.z)) + u">");
 
-		std::cout << position.x << ", " << position.y << ", " << position.z << std::endl;
+		LOG("Position: %f, %f, %f", position.x, position.y, position.z);
 	}
 
 	if (chatCommand == "rot" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER) {
@@ -1380,14 +1397,14 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 		ChatPackets::SendSystemMessage(sysAddr, u"<" + (GeneralUtils::to_u16string(rotation.w)) + u", " + (GeneralUtils::to_u16string(rotation.x)) + u", " + (GeneralUtils::to_u16string(rotation.y)) + u", " + (GeneralUtils::to_u16string(rotation.z)) + u">");
 
-		std::cout << rotation.w << ", " << rotation.x << ", " << rotation.y << ", " << rotation.z << std::endl;
+		LOG("Rotation: %f, %f, %f, %f", rotation.w, rotation.x, rotation.y, rotation.z);
 	}
 
 	if (chatCommand == "locrow" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER) {
 		const auto position = entity->GetPosition();
 		const auto rotation = entity->GetRotation();
 
-		std::cout << "<location x=\"" << position.x << "\" y=\"" << position.y << "\" z=\"" << position.z << "\" rw=\"" << rotation.w << "\" rx=\"" << rotation.x << "\" ry=\"" << rotation.y << "\" rz=\"" << rotation.z << "\" />" << std::endl;
+		LOG("<location x=\"%f\" y=\"%f\" z=\"%f\" rw=\"%f\" rx=\"%f\" ry=\"%f\" rz=\"%f\" />", position.x, position.y, position.z, rotation.w, rotation.x, rotation.y, rotation.z);
 	}
 
 	if (chatCommand == "playlvlfx" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER) {
@@ -1652,7 +1669,7 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 
 					auto sphere = static_cast<dpShapeSphere*>(prox.second->GetShape());
 					auto pos = prox.second->GetPosition();
-					std::cout << prox.first << ", r: " << sphere->GetRadius() << ", pos: " << pos.x << "," << pos.y << "," << pos.z << std::endl;
+					LOG("Proximity: %s, r: %f, pos: %f, %f, %f", prox.first.c_str(), sphere->GetRadius(), pos.x, pos.y, pos.z);
 				}
 			}
 		}
@@ -1895,6 +1912,13 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& command, Entit
 		}
 	}
 
+	if (chatCommand == "setrewardcode" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() == 1) {
+		auto* cdrewardCodes = CDClientManager::Instance().GetTable<CDRewardCodesTable>();
+
+		auto id = cdrewardCodes->GetCodeID(args[0]);
+		if (id != -1) Database::Get()->InsertRewardCode(user->GetAccountID(), id);
+	}
+
 	if (chatCommand == "inspect" && entity->GetGMLevel() >= eGameMasterLevel::DEVELOPER && args.size() >= 1) {
 		Entity* closest = nullptr;
 

dNet/AuthPackets.cpp

@@ -29,6 +29,22 @@
 #include "eMasterMessageType.h"
 #include "eGameMasterLevel.h"
 
+namespace {
+	std::vector<uint32_t> claimCodes;
+}
+
+void AuthPackets::LoadClaimCodes() {
+	if(!claimCodes.empty()) return;
+	auto rcstring = Game::config->GetValue("rewardcodes");
+	auto codestrings = GeneralUtils::SplitString(rcstring, ',');
+	for(auto const &codestring: codestrings){
+		uint32_t code = -1;
+		if(GeneralUtils::TryParse(codestring, code) && code != -1){
+			claimCodes.push_back(code);
+		}
+	}
+}
+
 void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {
 	RakNet::BitStream inStream(packet->data, packet->length, false);
 	uint64_t header = inStream.Read(header);
@@ -129,6 +145,10 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {
 			AuthPackets::SendLoginResponse(server, system, eLoginResponse::SUCCESS, "", zoneIP, zonePort, username);
 			});
 	}
+
+	for(auto const code: claimCodes){
+		Database::Get()->InsertRewardCode(accountInfo->id, code);
+	}
 }
 
 void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username) {

dNet/AuthPackets.h

@@ -15,6 +15,8 @@ namespace AuthPackets {
 
 	void HandleLoginRequest(dServer* server, Packet* packet);
 	void SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username);
+	void LoadClaimCodes();
+
 }
 
 #endif // AUTHPACKETS_H

dNet/ClientPackets.cpp

@@ -27,7 +27,7 @@
 #include "Zone.h"
 #include "PossessorComponent.h"
 #include "PossessableComponent.h"
-#include "VehiclePhysicsComponent.h"
+#include "HavokVehiclePhysicsComponent.h"
 #include "dConfig.h"
 #include "CharacterComponent.h"
 #include "Database.h"
@@ -187,17 +187,17 @@ void ClientPackets::HandleClientPositionUpdate(const SystemAddress& sysAddr, Pac
 				if (possessableComponent->GetPossessionType() != ePossessionType::ATTACHED_VISIBLE) updateChar = false;
 			}
 
-			auto* vehiclePhysicsComponent = possassableEntity->GetComponent<VehiclePhysicsComponent>();
-			if (vehiclePhysicsComponent != nullptr) {
-				vehiclePhysicsComponent->SetPosition(position);
-				vehiclePhysicsComponent->SetRotation(rotation);
-				vehiclePhysicsComponent->SetIsOnGround(onGround);
-				vehiclePhysicsComponent->SetIsOnRail(onRail);
-				vehiclePhysicsComponent->SetVelocity(velocity);
-				vehiclePhysicsComponent->SetDirtyVelocity(velocityFlag);
-				vehiclePhysicsComponent->SetAngularVelocity(angVelocity);
-				vehiclePhysicsComponent->SetDirtyAngularVelocity(angVelocityFlag);
-				vehiclePhysicsComponent->SetRemoteInputInfo(remoteInput);
+			auto* havokVehiclePhysicsComponent = possassableEntity->GetComponent<HavokVehiclePhysicsComponent>();
+			if (havokVehiclePhysicsComponent != nullptr) {
+				havokVehiclePhysicsComponent->SetPosition(position);
+				havokVehiclePhysicsComponent->SetRotation(rotation);
+				havokVehiclePhysicsComponent->SetIsOnGround(onGround);
+				havokVehiclePhysicsComponent->SetIsOnRail(onRail);
+				havokVehiclePhysicsComponent->SetVelocity(velocity);
+				havokVehiclePhysicsComponent->SetDirtyVelocity(velocityFlag);
+				havokVehiclePhysicsComponent->SetAngularVelocity(angVelocity);
+				havokVehiclePhysicsComponent->SetDirtyAngularVelocity(angVelocityFlag);
+				havokVehiclePhysicsComponent->SetRemoteInputInfo(remoteInput);
 			} else {
 				// Need to get the mount's controllable physics
 				auto* controllablePhysicsComponent = possassableEntity->GetComponent<ControllablePhysicsComponent>();

dPhysics/dpEntity.cpp

@@ -22,7 +22,7 @@ dpEntity::dpEntity(const LWOOBJID& objectID, dpShapeType shapeType, bool isStati
 		break;
 
 	default:
-		std::cout << "No shape for shapeType: " << (int)shapeType << std::endl;
+		LOG("No shape for shapeType: %d", static_cast<int32_t>(shapeType));
 	}
 }
 
@@ -83,15 +83,9 @@ void dpEntity::CheckCollision(dpEntity* other) {
 	if (isColliding && !wasFound) {
 		m_CurrentlyCollidingObjects.emplace(other->GetObjectID(), other);
 		m_NewObjects.push_back(other);
-
-		//if (m_CollisionShape->GetShapeType() == dpShapeType::Sphere && other->GetShape()->GetShapeType() == dpShapeType::Sphere)
-			//std::cout << "started sphere col at: " << other->GetPosition().x << ", " << other->GetPosition().y << ", " << other->GetPosition().z << std::endl;
 	} else if (!isColliding && wasFound) {
 		m_CurrentlyCollidingObjects.erase(other->GetObjectID());
 		m_RemovedObjects.push_back(other);
-
-		//if (m_CollisionShape->GetShapeType() == dpShapeType::Sphere && other->GetShape()->GetShapeType() == dpShapeType::Sphere)
-		//	std::cout << "stopped sphere col at: " << other->GetPosition().x << ", " << other->GetPosition().y << ", " << other->GetPosition().z << std::endl;
 	}
 }
 

dPhysics/dpGrid.cpp

@@ -8,8 +8,6 @@ dpGrid::dpGrid(int numCells, int cellSize) {
 	CELL_SIZE = cellSize;
 	m_DeleteGrid = true;
 
-	//dumb method but i can't be bothered
-
 	//fill x
 	for (int i = 0; i < NUM_CELLS; i++) {
 		m_Cells.push_back(std::vector<std::forward_list<dpEntity*>>());

dPhysics/dpShapeBase.cpp

@@ -10,7 +10,7 @@ dpShapeBase::~dpShapeBase() {
 }
 
 bool dpShapeBase::IsColliding(dpShapeBase* other) {
-	std::cout << "Base shapes do not have any *shape* to them, and thus cannot be overlapping." << std::endl;
-	std::cout << "You should be using a shape class inherited from this base class." << std::endl;
+	LOG("Base shapes do not have any *shape* to them, and thus cannot be overlapping.");
+	LOG("You should be using a shape class inherited from this base class.");
 	return false;
 }

dPhysics/dpShapeBox.cpp

@@ -34,7 +34,7 @@ bool dpShapeBox::IsColliding(dpShapeBase* other) {
 		return dpCollisionChecks::CheckBoxes(m_ParentEntity, other->GetParentEntity());
 
 	default:
-		std::cout << "No collision detection for: " << (int)m_ShapeType << "-to-" << (int)other->GetShapeType() << " collision!" << std::endl;
+		LOG("No collision detection for: %i-to-%i collision!", static_cast<int32_t>(m_ShapeType), static_cast<int32_t>(other->GetShapeType()));
 	}
 
 	return false;
@@ -72,10 +72,7 @@ void dpShapeBox::SetScale(float scale) {
 	m_Height *= scale;
 	m_Depth *= scale;
 
-	//fuuuckkk yoouu
 	InitVertices();
-
-	//SetRotation(m_ParentEntity->GetRotation());
 }
 
 void dpShapeBox::SetRotation(const NiQuaternion& rotation) {

dPhysics/dpShapeSphere.cpp

@@ -1,5 +1,7 @@
 #include "dpShapeSphere.h"
 #include "dpCollisionChecks.h"
+#include "Game.h"
+#include "Logger.h"
 #include <iostream>
 
 dpShapeSphere::dpShapeSphere(dpEntity* parentEntity, float radius) :
@@ -22,7 +24,7 @@ bool dpShapeSphere::IsColliding(dpShapeBase* other) {
 		return dpCollisionChecks::CheckSphereBox(m_ParentEntity, other->GetParentEntity());
 
 	default:
-		std::cout << "No collision detection for: " << (int)m_ShapeType << "-to-" << (int)other->GetShapeType() << " collision!" << std::endl;
+		LOG("No collision detection for: %i-to-%i collision!", static_cast<int32_t>(m_ShapeType), static_cast<int32_t>(other->GetShapeType()));
 	}
 
 	return false;

dPhysics/main.cpp

@@ -1,35 +0,0 @@
-//This file included for reference only
-
-/*#include <iostream>
-#include <chrono>
-#include <thread>
-#include "dpWorld.h"
-
-#include "NiQuaternion.hpp"
-#include "NiPoint3.hpp"
-
-int main() {
-	std::cout << "dPhysics test engine" << std::endl;
-
-	//Test rotation code:
-	NiPoint3 p(1.0f, 0.0f, 0.0f);
-
-	float angle = 45.0f;
-	NiQuaternion q = NiQuaternion::CreateFromAxisAngle(NiPoint3(0.0f, 0.0f, 1.0f), angle);
-
-	NiPoint3 rotated = p.RotateByQuaternion(q);
-
-	std::cout << "OG: " << p.x << ", " << p.y << ", " << p.z << std::endl;
-	std::cout << "Quater: " << q.x << ", " << q.y << ", " << q.z << ", " << q.w << " angle: " << angle << std::endl;
-	std::cout << "Rotated: " << rotated.x << ", " << rotated.y << ", " << rotated.z << std::endl;
-
-	//Test some collisions:
-	dpWorld::GetInstance().Initialize(1000);
-
-	while (true) {
-		dpWorld::GetInstance().StepWorld(1.0f/60.0f);
-		std::this_thread::sleep_for(std::chrono::milliseconds(16));
-	}
-
-	return 0;
-}*/

dScripts/BasePropertyServer.cpp

@@ -101,7 +101,7 @@ void BasePropertyServer::BasePlayerLoaded(Entity* self, Entity* player) {
 				missionComponent->Progress(
 					eMissionTaskType::VISIT_PROPERTY,
 					mapID.GetMapID(),
-					mapID.GetCloneID()
+					PropertyManagementComponent::Instance()->GetId()
 				);
 			}
 		}

dWorldServer/WorldServer.cpp

@@ -1033,9 +1033,8 @@ void HandlePacket(Packet* packet) {
 				Game::entityManager->ConstructAllEntities(packet->systemAddress);
 
 				auto* characterComponent = player->GetComponent<CharacterComponent>();
-				if (characterComponent) {
-					player->GetComponent<CharacterComponent>()->RocketUnEquip(player);
-				}
+				if (!characterComponent) return;
+				characterComponent->RocketUnEquip(player);
 
 				// Do charxml fixes here
 				auto* levelComponent = player->GetComponent<LevelProgressionComponent>();

dZoneManager/Level.cpp

@@ -16,6 +16,12 @@
 #include "AssetManager.h"
 #include "dConfig.h"
 
+void Level::SceneObjectDataChunk::PrintAllObjects() const {
+	for (const auto& [id, sceneObj] : objects) {
+		LOG("ID: %d LOT: %d", id, sceneObj.lot);
+	}
+}
+
 Level::Level(Zone* parentZone, const std::string& filepath) {
 	m_ParentZone = parentZone;
 
@@ -33,9 +39,9 @@ Level::Level(Zone* parentZone, const std::string& filepath) {
 }
 
 Level::~Level() {
-	for (std::map<uint32_t, Header>::iterator it = m_ChunkHeaders.begin(); it != m_ChunkHeaders.end(); ++it) {
-		if (it->second.id == Level::ChunkTypeID::FileInfo) delete it->second.fileInfo;
-		if (it->second.id == Level::ChunkTypeID::SceneObjectData) delete it->second.sceneObjects;
+	for (auto& [id, header] : m_ChunkHeaders) {
+		if (header.id == Level::ChunkTypeID::FileInfo) delete header.fileInfo;
+		if (header.id == Level::ChunkTypeID::SceneObjectData) delete header.sceneObjects;
 	}
 }
 
@@ -248,8 +254,8 @@ void Level::ReadSceneObjectDataChunk(std::istream& file, Header& header) {
 		BinaryIO::BinaryRead(file, obj.id);
 		BinaryIO::BinaryRead(file, obj.lot);
 
-		/*if (header.fileInfo->version >= 0x26)*/ BinaryIO::BinaryRead(file, obj.value1);
-		/*if (header.fileInfo->version >= 0x20)*/ BinaryIO::BinaryRead(file, obj.value2);
+		/*if (header.fileInfo->version >= 0x26)*/ BinaryIO::BinaryRead(file, obj.nodeType);
+		/*if (header.fileInfo->version >= 0x20)*/ BinaryIO::BinaryRead(file, obj.glomId);
 
 		BinaryIO::BinaryRead(file, obj.position);
 		BinaryIO::BinaryRead(file, obj.rotation);

dZoneManager/Level.h

@@ -30,11 +30,7 @@ public:
 	struct SceneObjectDataChunk {
 		std::map<LWOOBJID, SceneObject> objects;
 
-		const void PrintAllObjects() {
-			for (std::map<LWOOBJID, SceneObject>::iterator it = objects.begin(); it != objects.end(); ++it) {
-				std::cout << "\t ID: " << it->first << " LOT: " << it->second.lot << std::endl;
-			}
-		}
+		void PrintAllObjects() const;
 
 		uint32_t GetObjectCount() { return objects.size(); }
 	};

dZoneManager/Zone.h

@@ -148,6 +148,8 @@ struct PropertyPath {
 	float repMultiplier;
 	PropertyRentalPeriod rentalPeriod;
 	PropertyAchievmentRequired achievementRequired;
+
+	// Player respawn coordinates in the main zone (not the property zone)
 	NiPoint3 playerZoneCoords;
 	float maxBuildHeight;
 };

dZoneManager/dZMCommon.h

@@ -12,8 +12,8 @@ struct mapCompareLwoSceneIDs {
 struct SceneObject {
 	LWOOBJID id;
 	LOT lot;
-	uint32_t value1;
-	uint32_t value2;
+	uint32_t nodeType;
+	uint32_t glomId;
 	NiPoint3 position;
 	NiQuaternion rotation;
 	float scale = 1.0f;

docs/Commands.md

@@ -14,6 +14,8 @@
 |resurrect|`/resurrect`|Resurrects the player.||
 |requestmailcount|`/requestmailcount`|Sends notification with number of unread messages in the player's mailbox.||
 |who|`/who`|Displays in chat all players on the instance.||
+|togglenameplate|`/togglenameplate`|Turns the nameplate above your head that is visible to other players off and on.|8 or if `allow_nameplate_off` is set to exactly `1` in the settings|
+|toggleskipcinematics|`/toggleskipcinematics`|Skips mission and world load related cinematics.|8 or if `allow_players_to_skip_cinematics` is set to exactly `1` in the settings then 0|
 
 ## Moderation Commands
 
@@ -49,7 +51,6 @@ These commands are primarily for development and testing. The usage of many of t
 
 |Command|Usage|Description|Admin Level Requirement|
 |--- |--- |--- |--- |
-|togglenameplate|`/togglenameplate`|Turns the nameplate above your head that is visible to other players off and on.|8 or if `allow_nameplate_off` is set to exactly `1` in the settings|
 |fix-stats|`/fix-stats`|Resets skills, buffs, and destroyables.||
 |join|`/join <password>`|Joins a private zone with given password.||
 |leave-zone|`/leave-zone`|If you are in an instanced zone, transfers you to the closest main world. For example, if you are in an instance of Avant Gardens Survival or the Spider Queen Battle, you are sent to Avant Gardens. If you are in the Battle of Nimbus Station, you are sent to Nimbus Station.||
@@ -112,6 +113,7 @@ These commands are primarily for development and testing. The usage of many of t
 |setfaction|`/setfaction <faction id>`|Clears the users current factions and sets it|8|
 |addfaction|`/addfaction <faction id>`|Add the faction to the users list of factions|8|
 |getfactions|`/getfactions`|Shows the player's factions|8|
+|setrewardcode|`/setrewardcode <code>`|Sets the rewardcode for the account you are logged into if it's a valid rewardcode, See cdclient table `RewardCodes`|8|
 ## Detailed `/inspect` Usage
 
 `/inspect <component> (-m <waypoint> | -a <animation> | -s | -p | -f (faction) | -t)`

migrations/dlu/13_ignore_list.sql

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS ignore_list (
+	player_id BIGINT NOT NULL REFERENCES charinfo(id) ON DELETE CASCADE,
+	ignored_player_id BIGINT NOT NULL REFERENCES charinfo(id) ON DELETE CASCADE,
+
+	PRIMARY KEY (player_id, ignored_player_id)
+);

migrations/dlu/14_reward_codes.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS accounts_rewardcodes (
+    account_id INT NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
+    rewardcode INT NOT NULL,
+    PRIMARY KEY (account_id, rewardcode)
+);

resources/authconfig.ini

@@ -4,3 +4,11 @@ port=1001
 # 0 or 1, should ignore playkeys
 # If 1 everyone with an account will be able to login, regardless of if they have a key or not
 dont_use_keys=0
+
+# list of rewardcodes to set on the accounts by default
+# ex: 30,1,0,3
+# See RewardCodes in the CDclient for what codes exist
+# Default 4,30
+# 4 allows LEGOClub access
+# 30 makes the client not consume bricks when in bbb mode
+rewardcodes=4,30

resources/worldconfig.ini

@@ -61,6 +61,7 @@ allow_nameplate_off=0
 # Turn logging of IP addresses for anti-cheat reporting on (1) or off(0)
 log_ip_addresses_for_anti_cheat=1
 
+# These are the 5 items items that are shown in the "Help" menu in-game along with their coresponding descriptions below.
 help_0_summary=Got an issue?
 help_1_summary=Stuck loading?
 help_2_summary=Missing features?
@@ -72,3 +73,6 @@ help_1_description=Try switching networks, using a VPN, or using your phone's ho
 help_2_description=While DarkflameServer is a mostly complete emulator, there are still some features that aren't implemented. You can track these on the GitHub issues page.<br/><br/>
 help_3_description=Skill issue!<br/><br/>
 help_4_description=Visit Discussions on the DarkflameServer GitHub page<br/>to ask questions and collaborate with other devs!<br/><br/>
+
+# Toggleable quality of life feature to allow users to skip most cinematics. 
+allow_players_to_skip_cinematics=0

tests/dCommonTests/Amf3Tests.cpp

@@ -71,25 +71,15 @@ TEST(dCommonTests, AMF3InsertionAssociativeTest) {
 	array.Insert<std::vector<uint32_t>>("Undefined", {});
 	array.Insert("Null", nullptr);
 
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<const char*>("CString")->GetValueType(), eAmf::String);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<std::string>("String")->GetValueType(), eAmf::String);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<bool>("False")->GetValueType(), eAmf::False);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<bool>("True")->GetValueType(), eAmf::True);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<int32_t>("Integer")->GetValueType(), eAmf::Integer);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<double>("Double")->GetValueType(), eAmf::Double);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.GetArray("Array")->GetValueType(), eAmf::Array);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<nullptr_t>("Null")->GetValueType(), eAmf::Null);
-	std::cout << "test" << std::endl;
 	ASSERT_EQ(array.Get<std::vector<uint32_t>>("Undefined")->GetValueType(), eAmf::Undefined);
-	std::cout << "test" << std::endl;
 }
 
 TEST(dCommonTests, AMF3InsertionDenseTest) {