Merge branch 'main' into MSVCCompilerFlags

dGame/dUtilities/CheatDetection.cpp

@@ -130,12 +130,6 @@ bool CheatDetection::VerifyLwoobjidIsSender(const LWOOBJID& id, const SystemAddr
 
 	// This will be true if the player does not possess the entity they are trying to send a packet as.
 	// or if the user does not own the character they are trying to send a packet as.
-	if (invalidPacket) {
-		va_list args;
-		va_start(args, messageIfNotSender);
-		LogAndSaveFailedAntiCheatCheck(id, sysAddr, checkType, messageIfNotSender, args);
-		va_end(args);
-	}
 
 	return !invalidPacket;
 }

dGame/dUtilities/Mail.cpp

@@ -94,35 +94,6 @@ void Mail::SendMail(const LWOOBJID sender, const std::string& senderName, LWOOBJ
 	SendNotification(sysAddr, 1); //Show the "one new mail" message
 }
 
-//Because we need it:
-std::string ReadWStringAsString(RakNet::BitStream& bitStream, uint32_t size) {
-	std::string toReturn = "";
-	uint8_t buffer;
-	bool isFinishedReading = false;
-
-	for (uint32_t i = 0; i < size; ++i) {
-		bitStream.Read(buffer);
-		if (!isFinishedReading) toReturn.push_back(buffer);
-		if (buffer == '\0') isFinishedReading = true; //so we don't continue to read garbage as part of the string.
-		bitStream.Read(buffer); //Read the null term
-	}
-
-	return toReturn;
-}
-
-void WriteStringAsWString(RakNet::BitStream& bitStream, std::string str, uint32_t size) {
-	uint32_t sizeToFill = size - str.size();
-
-	for (uint32_t i = 0; i < str.size(); ++i) {
-		bitStream.Write(str[i]);
-		bitStream.Write(uint8_t(0));
-	}
-
-	for (uint32_t i = 0; i < sizeToFill; ++i) {
-		bitStream.Write(uint16_t(0));
-	}
-}
-
 void Mail::HandleMailStuff(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* entity) {
 	int mailStuffID = 0;
 	packet.Read(mailStuffID);
@@ -176,11 +147,20 @@ void Mail::HandleSendMail(RakNet::BitStream& packet, const SystemAddress& sysAdd
 		return;
 	}
 
-	std::string subject = ReadWStringAsString(packet, 50);
-	std::string body = ReadWStringAsString(packet, 400);
-	std::string recipient = ReadWStringAsString(packet, 32);
+	LUWString subjectRead(50);
+	packet.Read(subjectRead);
+
+	LUWString bodyRead(400);
+	packet.Read(bodyRead);
+	
+	LUWString recipientRead(32);
+	packet.Read(recipientRead);
+
+	const std::string subject = subjectRead.GetAsString();
+	const std::string body = bodyRead.GetAsString();
+
 	//Cleanse recipient:
-	recipient = std::regex_replace(recipient, std::regex("[^0-9a-zA-Z]+"), "");
+	const std::string recipient = std::regex_replace(recipientRead.GetAsString(), std::regex("[^0-9a-zA-Z]+"), "");
 
 	uint64_t unknown64 = 0;
 	LWOOBJID attachmentID;
@@ -267,40 +247,44 @@ void Mail::HandleDataRequest(RakNet::BitStream& packet, const SystemAddress& sys
 	RakNet::BitStream bitStream;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAIL);
 	bitStream.Write(int(MailMessageID::MailData));
-	bitStream.Write(int(0));
+	bitStream.Write(int(0)); // throttled
 
-	bitStream.Write<uint16_t>(playerMail.size());
+	bitStream.Write<uint16_t>(playerMail.size()); // size
 	bitStream.Write<uint16_t>(0);
 
 	for (const auto& mail : playerMail) {
 		bitStream.Write(mail.id); //MailID
 
-		WriteStringAsWString(bitStream, mail.subject.c_str(), 50); //subject
-		WriteStringAsWString(bitStream, mail.body.c_str(), 400); //body
-		WriteStringAsWString(bitStream, mail.senderUsername.c_str(), 32); //sender
+		const LUWString subject(mail.subject, 50);
+		bitStream.Write(subject); //subject
+		const LUWString body(mail.body, 400);
+		bitStream.Write(body); //body
+		const LUWString sender(mail.senderUsername, 32);
+		bitStream.Write(sender); //sender
+		bitStream.Write(uint32_t(0)); // packing
 
-		bitStream.Write(uint32_t(0));
-		bitStream.Write(uint64_t(0));
+		bitStream.Write(uint64_t(0)); // attachedCurrency
 
 		bitStream.Write(mail.itemID); //Attachment ID
 		LOT lot = mail.itemLOT;
 		if (lot <= 0) bitStream.Write(LOT(-1));
 		else bitStream.Write(lot);
-		bitStream.Write(uint32_t(0));
+		bitStream.Write(uint32_t(0)); // packing
 
-		bitStream.Write(mail.itemSubkey); //Attachment subKey
-		bitStream.Write<uint16_t>(mail.itemCount); //Attachment count
+		bitStream.Write(mail.itemSubkey); // Attachment subKey
 
-		bitStream.Write(uint32_t(0));
-		bitStream.Write(uint16_t(0));
+		bitStream.Write<uint16_t>(mail.itemCount); // Attachment count
+		bitStream.Write(uint8_t(0)); // subject type (used for auction)
+		bitStream.Write(uint8_t(0)); // packing
+		bitStream.Write(uint32_t(0)); //  packing
 
-		bitStream.Write<uint64_t>(mail.timeSent); //time sent (twice?)
-		bitStream.Write<uint64_t>(mail.timeSent);
+		bitStream.Write<uint64_t>(mail.timeSent); // expiration date
+		bitStream.Write<uint64_t>(mail.timeSent);// send date
 		bitStream.Write<uint8_t>(mail.wasRead); //was read
 
-		bitStream.Write(uint8_t(0));
-		bitStream.Write(uint16_t(0));
-		bitStream.Write(uint32_t(0));
+		bitStream.Write(uint8_t(0)); // isLocalized
+		bitStream.Write(uint16_t(0)); // packing
+		bitStream.Write(uint32_t(0)); // packing
 	}
 
 	Game::server->Send(bitStream, sysAddr, false);

dGame/dUtilities/Preconditions.cpp

@@ -26,17 +26,18 @@ Precondition::Precondition(const uint32_t condition) {
 	if (result.eof()) {
 		this->type = PreconditionType::ItemEquipped;
 		this->count = 1;
-		this->values = { 0 };
+		this->values.clear();
+		this->values.push_back(0);
 
 		LOG("Failed to find precondition of id (%i)!", condition);
 
 		return;
 	}
 
-	this->type = static_cast<PreconditionType>(result.fieldIsNull(0) ? 0 : result.getIntField(0));
+	this->type = static_cast<PreconditionType>(result.fieldIsNull("type") ? 0 : result.getIntField("type"));
 
-	if (!result.fieldIsNull(1)) {
-		std::istringstream stream(result.getStringField(1));
+	if (!result.fieldIsNull("targetLOT")) {
+		std::istringstream stream(result.getStringField("targetLOT"));
 		std::string token;
 
 		while (std::getline(stream, token, ',')) {
@@ -45,7 +46,7 @@ Precondition::Precondition(const uint32_t condition) {
 		}
 	}
 
-	this->count = result.fieldIsNull(2) ? 1 : result.getIntField(2);
+	this->count = result.fieldIsNull("targetCount") ? 1 : result.getIntField("targetCount");
 
 	result.finalize();
 }
@@ -138,21 +139,20 @@ bool Precondition::CheckValue(Entity* player, const uint32_t value, bool evaluat
 	case PreconditionType::DoesNotHaveItem:
 		return inventoryComponent->IsEquipped(value) < count;
 	case PreconditionType::HasAchievement:
-		mission = missionComponent->GetMission(value);
-
-		return mission == nullptr || mission->GetMissionState() >= eMissionState::COMPLETE;
+		if (missionComponent == nullptr) return false;
+		return missionComponent->GetMissionState(value) >= eMissionState::COMPLETE;
 	case PreconditionType::MissionAvailable:
-		mission = missionComponent->GetMission(value);
-
-		return mission == nullptr || mission->GetMissionState() >= eMissionState::AVAILABLE;
+		if (missionComponent == nullptr) return false;
+		return missionComponent->GetMissionState(value) == eMissionState::AVAILABLE || missionComponent->GetMissionState(value) == eMissionState::COMPLETE_AVAILABLE;
 	case PreconditionType::OnMission:
-		mission = missionComponent->GetMission(value);
-
-		return mission == nullptr || mission->GetMissionState() >= eMissionState::ACTIVE;
+		if (missionComponent == nullptr) return false;
+		return  missionComponent->GetMissionState(value) == eMissionState::ACTIVE || 
+				missionComponent->GetMissionState(value) == eMissionState::COMPLETE_ACTIVE ||
+				missionComponent->GetMissionState(value) == eMissionState::READY_TO_COMPLETE ||
+				missionComponent->GetMissionState(value) == eMissionState::COMPLETE_READY_TO_COMPLETE;
 	case PreconditionType::MissionComplete:
-		mission = missionComponent->GetMission(value);
-
-		return mission == nullptr ? false : mission->GetMissionState() >= eMissionState::COMPLETE;
+		if (missionComponent == nullptr) return false;
+		return missionComponent->GetMissionState(value) >= eMissionState::COMPLETE;
 	case PreconditionType::PetDeployed:
 		return false; // TODO
 	case PreconditionType::HasFlag:

dGame/dUtilities/SlashCommandHandler.cpp

@@ -8,6 +8,7 @@
 #include "SlashCommandHandler.h"
 
 #include <iomanip>
+#include <ranges>
 
 #include "DEVGMCommands.h"
 #include "GMGreaterThanZeroCommands.h"
@@ -19,7 +20,7 @@
 #include "dServer.h"
 
 namespace {
-	std::vector<Command> CommandInfos;
+	std::map<std::string, Command> CommandInfos;
 	std::map<std::string, Command> RegisteredCommands;
 }
 
@@ -30,7 +31,6 @@ void SlashCommandHandler::RegisterCommand(Command command) {
 	}
 
 	for (const auto& alias : command.aliases) {
-		LOG_DEBUG("Registering command %s", alias.c_str());
 		auto [_, success] = RegisteredCommands.try_emplace(alias, command);
 		// Don't allow duplicate commands
 		if (!success) {
@@ -38,9 +38,8 @@ void SlashCommandHandler::RegisterCommand(Command command) {
 			continue;
 		}
 	}
-
-	CommandInfos.push_back(command);
-};
+	CommandInfos[command.aliases[0]] = command;
+}
 
 void SlashCommandHandler::HandleChatCommand(const std::u16string& chat, Entity* entity, const SystemAddress& sysAddr) {
 	auto input = GeneralUtils::UTF16ToWTF8(chat);
@@ -61,11 +60,9 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& chat, Entity*
 			if (commandHandle.requiredLevel > eGameMasterLevel::CIVILIAN) Database::Get()->InsertSlashCommandUsage(entity->GetObjectID(), input);
 			commandHandle.handle(entity, sysAddr, args);
 		} else if (entity->GetGMLevel() != eGameMasterLevel::CIVILIAN) {
-			// We don't need to tell civilians they aren't high enough level
 			error = "You are not high enough GM level to use \"" + command + "\"";
 		}
 	} else if (entity->GetGMLevel() == eGameMasterLevel::CIVILIAN) {
-		// We don't need to tell civilians commands don't exist
 		error = "Command " + command + " does not exist!";
 	}
 
@@ -74,41 +71,76 @@ void SlashCommandHandler::HandleChatCommand(const std::u16string& chat, Entity*
 	}
 }
 
-// This commands in here so we can access the CommandInfos to display info
 void GMZeroCommands::Help(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
 	std::ostringstream feedback;
-	if (args.empty()) {
-		feedback << "----- Commands -----";
-		for (const auto& command : CommandInfos) {
-			// TODO: Limit displaying commands based on GM level they require
-			if (command.requiredLevel > entity->GetGMLevel()) continue;
-			LOG("Help command: %s", command.aliases[0].c_str());
-			feedback << "\n/" << command.aliases[0] << ": " << command.help;
+	constexpr size_t pageSize = 10;
+
+	std::string trimmedArgs = args;
+	trimmedArgs.erase(trimmedArgs.begin(), std::find_if_not(trimmedArgs.begin(), trimmedArgs.end(), [](unsigned char ch) {
+		return std::isspace(ch);
+		}));
+	trimmedArgs.erase(std::find_if_not(trimmedArgs.rbegin(), trimmedArgs.rend(), [](unsigned char ch) {
+		return std::isspace(ch);
+		}).base(), trimmedArgs.end());
+
+	std::optional<uint32_t> parsedPage = GeneralUtils::TryParse<uint32_t>(trimmedArgs);
+	if (trimmedArgs.empty() || parsedPage.has_value()) {
+		size_t page = parsedPage.value_or(1);
+
+		std::map<std::string, Command> accessibleCommands;
+		for (const auto& [commandName, command] : CommandInfos) {
+			if (command.requiredLevel <= entity->GetGMLevel()) {
+				accessibleCommands.emplace(commandName, command);
+			}
 		}
-	} else {
-		bool foundCommand = false;
-		for (const auto& command : CommandInfos) {
-			if (std::ranges::find(command.aliases, args) == command.aliases.end()) continue;
 
-			if (entity->GetGMLevel() < command.requiredLevel) break;
-			foundCommand = true;
-			feedback << "----- " << command.aliases.at(0) << " -----\n";
-			// info can be a localizable string
-			feedback << command.info;
-			if (command.aliases.size() == 1) break;
+		size_t totalPages = (accessibleCommands.size() + pageSize - 1) / pageSize;
 
-			feedback << "\nAliases: ";
-			for (size_t i = 0; i < command.aliases.size(); i++) {
+		if (page < 1 || page > totalPages) {
+			feedback << "Invalid page number. Total pages: " << totalPages;
+			GameMessages::SendSlashCommandFeedbackText(entity, GeneralUtils::ASCIIToUTF16(feedback.str()));
+			return;
+		}
+
+		auto it = accessibleCommands.begin();
+		std::advance(it, (page - 1) * pageSize);
+		size_t endIdx = std::min(page * pageSize, accessibleCommands.size());
+
+		feedback << "----- Commands (Page " << page << " of " << totalPages << ") -----";
+		for (size_t i = (page - 1) * pageSize; i < endIdx; ++i, ++it) {
+			feedback << "\n/" << it->first << ": " << it->second.help;
+		}
+
+		const auto feedbackStr = feedback.str();
+		if (!feedbackStr.empty()) {
+			GameMessages::SendSlashCommandFeedbackText(entity, GeneralUtils::ASCIIToUTF16(feedbackStr));
+		}
+		return;
+	}
+
+	auto it = std::ranges::find_if(CommandInfos, [&trimmedArgs](const auto& pair) {
+		return std::ranges::find(pair.second.aliases, trimmedArgs) != pair.second.aliases.end();
+		});
+
+	if (it != CommandInfos.end() && entity->GetGMLevel() >= it->second.requiredLevel) {
+		const auto& command = it->second;
+		feedback << "----- " << it->first << " Info -----\n";
+		feedback << command.info << "\n";
+		if (command.aliases.size() > 1) {
+			feedback << "Aliases: ";
+			for (size_t i = 0; i < command.aliases.size(); ++i) {
 				if (i > 0) feedback << ", ";
 				feedback << command.aliases[i];
 			}
 		}
-
-		// Let GameMasters know if the command doesn't exist
-		if (!foundCommand && entity->GetGMLevel() > eGameMasterLevel::CIVILIAN) feedback << "Command " << std::quoted(args) << " does not exist!";
+	} else {
+		feedback << "Command not found.";
 	}
+
 	const auto feedbackStr = feedback.str();
-	if (!feedbackStr.empty()) GameMessages::SendSlashCommandFeedbackText(entity, GeneralUtils::ASCIIToUTF16(feedbackStr));
+	if (!feedbackStr.empty()) {
+		GameMessages::SendSlashCommandFeedbackText(entity, GeneralUtils::ASCIIToUTF16(feedbackStr));
+	}
 }
 
 void SlashCommandHandler::SendAnnouncement(const std::string& title, const std::string& message) {
@@ -878,11 +910,38 @@ void SlashCommandHandler::Startup() {
 	};
 	RegisterCommand(TitleCommand);
 
+	Command ShowAllCommand{
+		.help = "Show all online players across World Servers",
+		.info = "Usage: /showall (displayZoneData: Default 1) (displayIndividualPlayers: Default 1)",
+		.aliases = { "showall" },
+		.handle = GMGreaterThanZeroCommands::ShowAll,
+		.requiredLevel = eGameMasterLevel::JUNIOR_MODERATOR
+	};
+	RegisterCommand(ShowAllCommand);
+
+	Command FindPlayerCommand{
+		.help = "Find the World Server a player is in if they are online",
+		.info = "Find the World Server a player is in if they are online",
+		.aliases = { "findplayer" },
+		.handle = GMGreaterThanZeroCommands::FindPlayer,
+		.requiredLevel = eGameMasterLevel::JUNIOR_MODERATOR
+	};
+	RegisterCommand(FindPlayerCommand);
+
+	Command SpectateCommand{
+		.help = "Spectate a player",
+		.info = "Specify a player name to spectate. They must be in the same world as you. Leave blank to stop spectating",
+		.aliases = { "spectate", "follow" },
+		.handle = GMGreaterThanZeroCommands::Spectate,
+		.requiredLevel = eGameMasterLevel::JUNIOR_MODERATOR
+	};
+	RegisterCommand(SpectateCommand);
 
 	// Register GM Zero Commands
+
 	Command HelpCommand{
 		.help = "Display command info",
-		.info = "If a command is given, display detailed info on that command. Otherwise display a list of commands with short desctiptions.",
+		.info = "If a command is given, display detailed info on that command. Otherwise display a list of commands with short descriptions.",
 		.aliases = { "help", "h"},
 		.handle = GMZeroCommands::Help,
 		.requiredLevel = eGameMasterLevel::CIVILIAN
@@ -997,4 +1056,383 @@ void SlashCommandHandler::Startup() {
 	};
 	RegisterCommand(InstanceInfoCommand);
 
+	//Commands that are handled by the client
+
+	Command faqCommand{
+		.help = "Show the LU FAQ Page",
+		.info = "Show the LU FAQ Page",
+		.aliases = {"faq","faqs"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(faqCommand);
+
+	Command teamChatCommand{
+		.help = "Send a message to your teammates.",
+		.info = "Send a message to your teammates.",
+		.aliases = {"team","t"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(teamChatCommand);
+
+	Command showStoreCommand{
+		.help = "Show the LEGO shop page.",
+		.info = "Show the LEGO shop page.",
+		.aliases = {"shop","store"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(showStoreCommand);
+
+	Command minigamesCommand{
+		.help = "Show the LEGO minigames page!",
+		.info = "Show the LEGO minigames page!",
+		.aliases = {"minigames"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(minigamesCommand);
+
+	Command forumsCommand{
+		.help = "Show the LU Forums!",
+		.info = "Show the LU Forums!",
+		.aliases = {"forums"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(forumsCommand);
+
+	Command exitGameCommand{
+		.help = "Exit to desktop",
+		.info = "Exit to desktop",
+		.aliases = {"exit","quit"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(exitGameCommand);
+
+	Command thumbsUpCommand{
+		.help = "Oh, yeah!",
+		.info = "Oh, yeah!",
+		.aliases = {"thumb","thumbs","thumbsup"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(thumbsUpCommand);
+
+	Command victoryCommand{
+		.help = "Victory!",
+		.info = "Victory!",
+		.aliases = {"victory!"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(victoryCommand);
+
+	Command backflipCommand{
+		.help = "Do a flip!",
+		.info = "Do a flip!",
+		.aliases = {"backflip"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(backflipCommand);
+
+	Command clapCommand{
+		.help = "A round of applause!",
+		.info = "A round of applause!",
+		.aliases = {"clap"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(clapCommand);
+
+	Command logoutCharacterCommand{
+		.help = "Returns you to the character select screen.",
+		.info = "Returns you to the character select screen.",
+		.aliases = {"camp","logoutcharacter"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(logoutCharacterCommand);
+
+	Command sayCommand{
+		.help = "Say something outloud so that everyone can hear you",
+		.info = "Say something outloud so that everyone can hear you",
+		.aliases = {"s","say"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(sayCommand);
+
+	Command whisperCommand{
+		.help = "Send a private message to another player.",
+		.info = "Send a private message to another player.",
+		.aliases = {"tell","w","whisper"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(whisperCommand);
+
+	Command locationCommand{
+		.help = "Output your current location on the map to the chat box.",
+		.info = "Output your current location on the map to the chat box.",
+		.aliases = {"loc","locate","location"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(locationCommand);
+
+	Command logoutCommand{
+		.help = "Returns you to the login screen.",
+		.info = "Returns you to the login screen.",
+		.aliases = {"logout","logoutaccount"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(logoutCommand);
+
+	Command shrugCommand{
+		.help = "I dunno...",
+		.info = "I dunno...",
+		.aliases = {"shrug"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(shrugCommand);
+
+	Command leaveTeamCommand{
+		.help = "Leave your current team.",
+		.info = "Leave your current team.",
+		.aliases = {"leave","leaveteam","teamleave","tleave"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(leaveTeamCommand);
+
+	Command teamLootTypeCommand{
+		.help = "[rr|ffa] Set the loot for your current team (round-robin/free for all).",
+		.info = "[rr|ffa] Set the loot for your current team (round-robin/free for all).",
+		.aliases = {"setloot","teamsetloot","tloot","tsetloot"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(teamLootTypeCommand);
+
+	Command removeFriendCommand{
+		.help = "[name] Removes a player from your friends list.",
+		.info = "[name] Removes a player from your friends list.",
+		.aliases = {"removefriend"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(removeFriendCommand);
+
+	Command yesCommand{
+		.help = "Aye aye, captain!",
+		.info = "Aye aye, captain!",
+		.aliases = {"yes"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(yesCommand);
+
+	Command teamInviteCommand{
+		.help = "[name] Invite a player to your team.",
+		.info = "[name] Invite a player to your team.",
+		.aliases = {"invite","inviteteam","teaminvite","tinvite"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(teamInviteCommand);
+
+	Command danceCommand{
+		.help = "Dance 'til you can't dance no more.",
+		.info = "Dance 'til you can't dance no more.",
+		.aliases = {"dance"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(danceCommand);
+
+	Command sighCommand{
+		.help = "Another day, another brick.",
+		.info = "Another day, another brick.",
+		.aliases = {"sigh"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(sighCommand);
+
+	Command recommendedOptionsCommand{
+		.help = "Sets the recommended performance options in the cfg file",
+		.info = "Sets the recommended performance options in the cfg file",
+		.aliases = {"recommendedperfoptions"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(recommendedOptionsCommand);
+
+	Command setTeamLeaderCommand{
+		.help = "[name] Set the leader for your current team.",
+		.info = "[name] Set the leader for your current team.",
+		.aliases = {"leader","setleader","teamsetleader","tleader","tsetleader"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(setTeamLeaderCommand);
+
+	Command cringeCommand{
+		.help = "I don't even want to talk about it...",
+		.info = "I don't even want to talk about it...",
+		.aliases = {"cringe"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(cringeCommand);
+
+	Command talkCommand{
+		.help = "Jibber Jabber",
+		.info = "Jibber Jabber",
+		.aliases = {"talk"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(talkCommand);
+
+	Command cancelQueueCommand{
+		.help = "Cancel Your position in the queue if you are in one.",
+		.info = "Cancel Your position in the queue if you are in one.",
+		.aliases = {"cancelqueue"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(cancelQueueCommand);
+
+	Command lowPerformanceCommand{
+		.help = "Sets the default low-spec performance options in the cfg file",
+		.info = "Sets the default low-spec performance options in the cfg file",
+		.aliases = {"perfoptionslow"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(lowPerformanceCommand);
+
+	Command kickFromTeamCommand{
+		.help = "[name] Kick a player from your current team.",
+		.info = "[name] Kick a player from your current team.",
+		.aliases = {"kick","kickplayer","teamkickplayer","tkick","tkickplayer"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(kickFromTeamCommand);
+
+	Command thanksCommand{
+		.help = "Express your gratitude for another.",
+		.info = "Express your gratitude for another.",
+		.aliases = {"thanks"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(thanksCommand);
+
+	Command waveCommand{
+		.help = "Wave to other players.",
+		.info = "Wave to other players.",
+		.aliases = {"wave"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(waveCommand);
+
+	Command whyCommand{
+		.help = "Why|!?!!",
+		.info = "Why|!?!!",
+		.aliases = {"why"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(whyCommand);
+
+	Command midPerformanceCommand{
+		.help = "Sets the default medium-spec performance options in the cfg file",
+		.info = "Sets the default medium-spec performance options in the cfg file",
+		.aliases = {"perfoptionsmid"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(midPerformanceCommand);
+
+	Command highPerformanceCommand{
+		.help = "Sets the default high-spec performance options in the cfg file",
+		.info = "Sets the default high-spec performance options in the cfg file",
+		.aliases = {"perfoptionshigh"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(highPerformanceCommand);
+
+	Command gaspCommand{
+		.help = "Oh my goodness!",
+		.info = "Oh my goodness!",
+		.aliases = {"gasp"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(gaspCommand);
+
+	Command ignoreCommand{
+		.help = "[name] Add a player to your ignore list.",
+		.info = "[name] Add a player to your ignore list.",
+		.aliases = {"addignore"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(ignoreCommand);
+
+	Command addFriendCommand{
+		.help = "[name] Add a player to your friends list.",
+		.info = "[name] Add a player to your friends list.",
+		.aliases = {"addfriend"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(addFriendCommand);
+
+	Command cryCommand{
+		.help = "Show everyone your 'Aw' face.",
+		.info = "Show everyone your 'Aw' face.",
+		.aliases = {"cry"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(cryCommand);
+
+	Command giggleCommand{
+		.help = "A good little chuckle",
+		.info = "A good little chuckle",
+		.aliases = {"giggle"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(giggleCommand);
+
+	Command saluteCommand{
+		.help = "For those about to build...",
+		.info = "For those about to build...",
+		.aliases = {"salute"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(saluteCommand);
+
+	Command removeIgnoreCommand{
+		.help = "[name] Removes a player from your ignore list.",
+		.info = "[name] Removes a player from your ignore list.",
+		.aliases = {"removeIgnore"},
+		.handle = GMZeroCommands::ClientHandled,
+		.requiredLevel = eGameMasterLevel::CIVILIAN
+	};
+	RegisterCommand(removeIgnoreCommand);
 }

dGame/dUtilities/SlashCommands/DEVGMCommands.cpp

@@ -41,6 +41,7 @@
 #include "ScriptedActivityComponent.h"
 #include "SkillComponent.h"
 #include "TriggerComponent.h"
+#include "RigidbodyPhantomPhysicsComponent.h"
 
 // Enums
 #include "eGameMasterLevel.h"
@@ -704,7 +705,7 @@ namespace DEVGMCommands {
 		auto tables = query.execQuery();
 
 		while (!tables.eof()) {
-			std::string message = std::to_string(tables.getIntField(0)) + " - " + tables.getStringField(1);
+			std::string message = std::to_string(tables.getIntField("id")) + " - " + tables.getStringField("name");
 			ChatPackets::SendSystemMessage(sysAddr, GeneralUtils::UTF8ToUTF16(message, message.size()));
 			tables.nextRow();
 		}
@@ -1129,8 +1130,13 @@ namespace DEVGMCommands {
 	void SpawnPhysicsVerts(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
 		//Go tell physics to spawn all the vertices:
 		auto entities = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::PHANTOM_PHYSICS);
-		for (auto en : entities) {
-			auto phys = static_cast<PhantomPhysicsComponent*>(en->GetComponent(eReplicaComponentType::PHANTOM_PHYSICS));
+		for (const auto* en : entities) {
+			const auto* phys = static_cast<PhantomPhysicsComponent*>(en->GetComponent(eReplicaComponentType::PHANTOM_PHYSICS));
+			if (phys)
+				phys->SpawnVertices();
+		}
+		for (const auto* en : Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::RIGID_BODY_PHANTOM_PHYSICS)) {
+			const auto* phys = en->GetComponent<RigidbodyPhantomPhysicsComponent>();
 			if (phys)
 				phys->SpawnVertices();
 		}

dGame/dUtilities/SlashCommands/DEVGMCommands.h

@@ -1,3 +1,6 @@
+#ifndef DEVGMCOMMANDS_H
+#define DEVGMCOMMANDS_H
+
 namespace DEVGMCommands {
 	void SetGMLevel(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void ToggleNameplate(Entity* entity, const SystemAddress& sysAddr, const std::string args);
@@ -70,4 +73,6 @@ namespace DEVGMCommands {
 	void RollLoot(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void CastSkill(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void DeleteInven(Entity* entity, const SystemAddress& sysAddr, const std::string args);
-}
+}
+
+#endif  //!DEVGMCOMMANDS_H

dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp

@@ -287,4 +287,54 @@ namespace GMGreaterThanZeroCommands {
 		std::string name = entity->GetCharacter()->GetName() + " - " + args;
 		GameMessages::SendSetName(entity->GetObjectID(), GeneralUtils::UTF8ToUTF16(name), UNASSIGNED_SYSTEM_ADDRESS);
 	}
+
+	void ShowAll(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		bool displayZoneData = true;
+		bool displayIndividualPlayers = true;
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+		
+		if (!splitArgs.empty() && !splitArgs.at(0).empty()) displayZoneData = splitArgs.at(0) == "1";
+		if (splitArgs.size() > 1) displayIndividualPlayers = splitArgs.at(1) == "1";
+
+		ShowAllRequest request {
+			.requestor = entity->GetObjectID(),
+			.displayZoneData = displayZoneData,
+			.displayIndividualPlayers = displayIndividualPlayers
+		};
+
+		CBITSTREAM;
+		request.Serialize(bitStream);
+		Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
+	}
+
+	void FindPlayer(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		if (args.empty()) {
+			GameMessages::SendSlashCommandFeedbackText(entity, u"No player Given");
+			return;
+		}
+
+		FindPlayerRequest request {
+			.requestor = entity->GetObjectID(),
+			.playerName = LUWString(args)
+		};
+
+		CBITSTREAM;
+		request.Serialize(bitStream);
+		Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
+	}
+
+	void Spectate(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		if (args.empty()) {
+			GameMessages::SendForceCameraTargetCycle(entity, false, eCameraTargetCyclingMode::DISALLOW_CYCLING, entity->GetObjectID());
+			return;
+		}
+
+		auto player = PlayerManager::GetPlayer(args);
+		if (!player) {
+			GameMessages::SendSlashCommandFeedbackText(entity, u"Player not found");
+			return;
+		}
+		GameMessages::SendSlashCommandFeedbackText(entity, u"Spectating Player");
+		GameMessages::SendForceCameraTargetCycle(entity, false, eCameraTargetCyclingMode::DISALLOW_CYCLING, player->GetObjectID());
+	}
 }

dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.h

@@ -1,3 +1,6 @@
+#ifndef GMGREATERTHANZEROCOMMANDS_H
+#define GMGREATERTHANZEROCOMMANDS_H
+
 namespace GMGreaterThanZeroCommands {
 	void Kick(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void MailItem(Entity* entity, const SystemAddress& sysAddr, const std::string args);
@@ -10,4 +13,9 @@ namespace GMGreaterThanZeroCommands {
 	void GmInvis(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void SetName(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void Title(Entity* entity, const SystemAddress& sysAddr, const std::string args);
-}
+	void ShowAll(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void FindPlayer(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Spectate(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+}
+
+#endif  //!GMGREATERTHANZEROCOMMANDS_H

dGame/dUtilities/SlashCommands/GMZeroCommands.cpp

@@ -224,5 +224,9 @@ namespace GMZeroCommands {
 
 		ChatPackets::SendSystemMessage(sysAddr, u"Map: " + (GeneralUtils::to_u16string(zoneId.GetMapID())) + u"\nClone: " + (GeneralUtils::to_u16string(zoneId.GetCloneID())) + u"\nInstance: " + (GeneralUtils::to_u16string(zoneId.GetInstanceID())));
 	}
+
+	//For client side commands
+	void ClientHandled(Entity* entity, const SystemAddress& sysAddr, const std::string args) {}
+
 };
 

dGame/dUtilities/SlashCommands/GMZeroCommands.h

@@ -1,3 +1,6 @@
+#ifndef GMZEROCOMMANDS_H
+#define GMZEROCOMMANDS_H
+
 namespace GMZeroCommands {
 	void Help(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void Credits(Entity* entity, const SystemAddress& sysAddr, const std::string args);
@@ -12,4 +15,7 @@ namespace GMZeroCommands {
 	void LeaveZone(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void Resurrect(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 	void InstanceInfo(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ClientHandled(Entity* entity, const SystemAddress& sysAddr, const std::string args);
 }
+
+#endif  //!GMZEROCOMMANDS_H

dGame/dUtilities/VanityUtilities.cpp

@@ -285,7 +285,6 @@ void ParseXml(const std::string& file) {
 				}
 
 				if (zoneID.value() != currentZoneID) {
-					LOG_DEBUG("Skipping (%s) %i location because it is in %i and not the current zone (%i)", name, lot, zoneID.value(), currentZoneID);
 					continue;
 				}