Merge remote-tracking branch 'origin/main' into dCinema

dGame/dUtilities/BrickDatabase.cpp

@@ -29,15 +29,14 @@ const BrickList& BrickDatabase::GetBricks(const LxfmlPath& lxfmlPath) {
 		return emptyCache;
 	}
 
-	auto* doc = new tinyxml2::XMLDocument();
-	if (doc->Parse(data.str().c_str(), data.str().size()) != 0) {
-		delete doc;
+	tinyxml2::XMLDocument doc;
+	if (doc.Parse(data.str().c_str(), data.str().size()) != 0) {
 		return emptyCache;
 	}
 
 	BrickList parts;
 
-	auto* lxfml = doc->FirstChildElement("LXFML");
+	auto* lxfml = doc.FirstChildElement("LXFML");
 	auto* bricks = lxfml->FirstChildElement("Bricks");
 	std::string searchTerm = "Brick";
 
@@ -86,7 +85,5 @@ const BrickList& BrickDatabase::GetBricks(const LxfmlPath& lxfmlPath) {
 
 	m_Cache[lxfmlPath] = parts;
 
-	delete doc;
-
 	return m_Cache[lxfmlPath];
 }

dGame/dUtilities/CMakeLists.txt

@@ -9,9 +9,15 @@ set(DGAME_DUTILITIES_SOURCES "BrickDatabase.cpp"
 	"ServerPreconditions.cpp"
 	"VanityUtilities.cpp")
 
+add_subdirectory(SlashCommands)
+
+foreach(file ${DGAME_DUTILITIES_SLASHCOMMANDS})
+	set(DGAME_DUTILITIES_SOURCES ${DGAME_DUTILITIES_SOURCES} "SlashCommands/${file}")
+endforeach()
+
 add_library(dUtilities OBJECT ${DGAME_DUTILITIES_SOURCES})
 target_precompile_headers(dUtilities REUSE_FROM dGameBase)
-target_include_directories(dUtilities PUBLIC "."
+target_include_directories(dUtilities PUBLIC "." "SlashCommands"
 	PRIVATE
 	"${PROJECT_SOURCE_DIR}/dGame/dComponents"
 	"${PROJECT_SOURCE_DIR}/dGame/dInventory" # transitive via PossessableComponent.h

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();
 }

dGame/dUtilities/SlashCommandHandler.h

@@ -7,13 +7,28 @@
 #define SLASHCOMMANDHANDLER_H
 
 #include "RakNetTypes.h"
+#include "eGameMasterLevel.h"
 #include <string>
 
 class Entity;
 
+struct Command {
+	std::string help;
+	std::string info;
+	std::vector<std::string> aliases;
+	std::function<void(Entity*, const SystemAddress&,const std::string)> handle;
+	eGameMasterLevel requiredLevel = eGameMasterLevel::OPERATOR;
+};
+
 namespace SlashCommandHandler {
 	void HandleChatCommand(const std::u16string& command, Entity* entity, const SystemAddress& sysAddr);
 	void SendAnnouncement(const std::string& title, const std::string& message);
+	void RegisterCommand(Command info);
+	void Startup();
 };
 
+namespace GMZeroCommands {
+	void Help(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+}
+
 #endif // SLASHCOMMANDHANDLER_H

dGame/dUtilities/SlashCommands/CMakeLists.txt

@@ -0,0 +1,6 @@
+set(DGAME_DUTILITIES_SLASHCOMMANDS
+	"DEVGMCommands.cpp"
+	"GMGreaterThanZeroCommands.cpp"
+	"GMZeroCommands.cpp"
+	PARENT_SCOPE
+)

dGame/dUtilities/SlashCommands/DEVGMCommands.h

@@ -0,0 +1,78 @@
+#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);
+	void ToggleSkipCinematics(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Kill(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Metrics(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Announce(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetAnnTitle(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetAnnMsg(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ShutdownUniverse(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetMinifig(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void TestMap(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ReportProxPhys(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SpawnPhysicsVerts(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Teleport(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ActivateSpawner(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void AddMission(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Boost(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Unboost(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Buff(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void BuffMe(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void BuffMed(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ClearFlag(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void CompleteMission(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void CreatePrivate(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void DebugUi(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Dismount(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ReloadConfig(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ForceSave(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Freecam(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void FreeMoney(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void GetNavmeshHeight(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void GiveUScore(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void GmAddItem(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Inspect(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ListSpawns(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void LocRow(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Lookup(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void PlayAnimation(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void PlayEffect(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void PlayLvlFx(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void PlayRebuildFx(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Pos(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void RefillStats(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Reforge(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ResetMission(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Rot(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void RunMacro(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetControlScheme(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetCurrency(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetFlag(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetInventorySize(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetUiState(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Spawn(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SpawnGroup(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SpeedBoost(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void StartCelebration(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void StopEffect(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Toggle(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void TpAll(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void TriggerSpawner(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void UnlockEmote(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetLevel(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetSkillSlot(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetFaction(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void AddFaction(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void GetFactions(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void SetRewardCode(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Crash(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	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

@@ -0,0 +1,340 @@
+#include "GMGreaterThanZeroCommands.h"
+
+// Classes
+#include "Character.h"
+#include "ChatPackets.h"
+#include "dServer.h"
+#include "PlayerManager.h"
+#include "User.h"
+
+// Database
+#include "Database.h"
+
+// Components
+#include "DestroyableComponent.h"
+#include "PropertyManagementComponent.h"
+
+// Enums
+#include "eChatMessageType.h"
+#include "eServerDisconnectIdentifiers.h"
+#include "eObjectBits.h"
+
+namespace GMGreaterThanZeroCommands {
+
+	void Kick(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+		if (splitArgs.size() == 1) {
+			auto* player = PlayerManager::GetPlayer(splitArgs[0]);
+
+			std::u16string username = GeneralUtils::UTF8ToUTF16(splitArgs[0]);
+			if (player == nullptr) {
+				ChatPackets::SendSystemMessage(sysAddr, u"Count not find player of name: " + username);
+				return;
+			}
+
+			Game::server->Disconnect(player->GetSystemAddress(), eServerDisconnectIdentifiers::KICK);
+
+			ChatPackets::SendSystemMessage(sysAddr, u"Kicked: " + username);
+		} else {
+			ChatPackets::SendSystemMessage(sysAddr, u"Correct usage: /kick <username>");
+		}
+	}
+
+	void Ban(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+
+		if (splitArgs.size() == 1) {
+			auto* player = PlayerManager::GetPlayer(splitArgs[0]);
+
+			uint32_t accountId = 0;
+
+			if (player == nullptr) {
+				auto characterInfo = Database::Get()->GetCharacterInfo(splitArgs[0]);
+
+				if (characterInfo) {
+					accountId = characterInfo->accountId;
+				}
+
+				if (accountId == 0) {
+					ChatPackets::SendSystemMessage(sysAddr, u"Count not find player of name: " + GeneralUtils::UTF8ToUTF16(splitArgs[0]));
+
+					return;
+				}
+			} else {
+				auto* character = player->GetCharacter();
+				auto* user = character != nullptr ? character->GetParentUser() : nullptr;
+				if (user) accountId = user->GetAccountID();
+			}
+
+			if (accountId != 0) Database::Get()->UpdateAccountBan(accountId, true);
+
+			if (player != nullptr) {
+				Game::server->Disconnect(player->GetSystemAddress(), eServerDisconnectIdentifiers::FREE_TRIAL_EXPIRED);
+			}
+
+			ChatPackets::SendSystemMessage(sysAddr, u"Banned: " + GeneralUtils::ASCIIToUTF16(splitArgs[0]));
+		} else {
+			ChatPackets::SendSystemMessage(sysAddr, u"Correct usage: /ban <username>");
+		}
+	}
+
+	void MailItem(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+		if (splitArgs.size() < 2) return;
+
+		const auto& playerName = splitArgs[0];
+
+		auto playerInfo = Database::Get()->GetCharacterInfo(playerName);
+
+		uint32_t receiverID = 0;
+		if (!playerInfo) {
+			ChatPackets::SendSystemMessage(sysAddr, u"Failed to find that player");
+
+			return;
+		}
+
+		receiverID = playerInfo->id;
+
+		const auto lot = GeneralUtils::TryParse<LOT>(splitArgs.at(1));
+
+		if (!lot) {
+			ChatPackets::SendSystemMessage(sysAddr, u"Invalid item lot.");
+			return;
+		}
+
+		IMail::MailInfo mailInsert;
+		mailInsert.senderId = entity->GetObjectID();
+		mailInsert.senderUsername = "Darkflame Universe";
+		mailInsert.receiverId = receiverID;
+		mailInsert.recipient = playerName;
+		mailInsert.subject = "Lost item";
+		mailInsert.body = "This is a replacement item for one you lost.";
+		mailInsert.itemID = LWOOBJID_EMPTY;
+		mailInsert.itemLOT = lot.value();
+		mailInsert.itemSubkey = LWOOBJID_EMPTY;
+		mailInsert.itemCount = 1;
+		Database::Get()->InsertNewMail(mailInsert);
+
+		ChatPackets::SendSystemMessage(sysAddr, u"Mail sent");
+	}
+
+	void ApproveProperty(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		if (PropertyManagementComponent::Instance() != nullptr) {
+			PropertyManagementComponent::Instance()->UpdateApprovedStatus(true);
+		}
+	}
+
+	void Mute(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+
+		if (splitArgs.size() >= 1) {
+			auto* player = PlayerManager::GetPlayer(splitArgs[0]);
+
+			uint32_t accountId = 0;
+			LWOOBJID characterId = 0;
+
+			if (player == nullptr) {
+				auto characterInfo = Database::Get()->GetCharacterInfo(splitArgs[0]);
+
+				if (characterInfo) {
+					accountId = characterInfo->accountId;
+					characterId = characterInfo->id;
+
+					GeneralUtils::SetBit(characterId, eObjectBits::CHARACTER);
+					GeneralUtils::SetBit(characterId, eObjectBits::PERSISTENT);
+				}
+
+				if (accountId == 0) {
+					ChatPackets::SendSystemMessage(sysAddr, u"Count not find player of name: " + GeneralUtils::UTF8ToUTF16(splitArgs[0]));
+
+					return;
+				}
+			} else {
+				auto* character = player->GetCharacter();
+				auto* user = character != nullptr ? character->GetParentUser() : nullptr;
+				if (user) accountId = user->GetAccountID();
+				characterId = player->GetObjectID();
+			}
+
+			time_t expire = 1; // Default to indefinate mute
+
+			if (splitArgs.size() >= 2) {
+				const auto days = GeneralUtils::TryParse<uint32_t>(splitArgs[1]);
+				if (!days) {
+					ChatPackets::SendSystemMessage(sysAddr, u"Invalid days.");
+
+					return;
+				}
+
+				std::optional<uint32_t> hours;
+				if (splitArgs.size() >= 3) {
+					hours = GeneralUtils::TryParse<uint32_t>(splitArgs[2]);
+					if (!hours) {
+						ChatPackets::SendSystemMessage(sysAddr, u"Invalid hours.");
+
+						return;
+					}
+				}
+
+				expire = time(NULL);
+				expire += 24 * 60 * 60 * days.value();
+				expire += 60 * 60 * hours.value_or(0);
+			}
+
+			if (accountId != 0) Database::Get()->UpdateAccountUnmuteTime(accountId, expire);
+
+			char buffer[32] = "brought up for review.\0";
+
+			if (expire != 1) {
+				std::tm* ptm = std::localtime(&expire);
+				// Format: Mo, 15.06.2009 20:20:00
+				std::strftime(buffer, 32, "%a, %d.%m.%Y %H:%M:%S", ptm);
+			}
+
+			const auto timeStr = GeneralUtils::ASCIIToUTF16(std::string(buffer));
+
+			ChatPackets::SendSystemMessage(sysAddr, u"Muted: " + GeneralUtils::UTF8ToUTF16(splitArgs[0]) + u" until " + timeStr);
+
+			//Notify chat about it
+			CBITSTREAM;
+			BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GM_MUTE);
+
+			bitStream.Write(characterId);
+			bitStream.Write(expire);
+
+			Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
+		} else {
+			ChatPackets::SendSystemMessage(sysAddr, u"Correct usage: /mute <username> <days (optional)> <hours (optional)>");
+		}
+	}
+
+	void Fly(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+		auto* character = entity->GetCharacter();
+
+		if (character) {
+			bool isFlying = character->GetIsFlying();
+
+			if (isFlying) {
+				GameMessages::SendSetJetPackMode(entity, false);
+
+				character->SetIsFlying(false);
+			} else {
+				float speedScale = 1.0f;
+
+				if (splitArgs.size() >= 1) {
+					const auto tempScaleStore = GeneralUtils::TryParse<float>(splitArgs.at(0));
+
+					if (tempScaleStore) {
+						speedScale = tempScaleStore.value();
+					} else {
+						ChatPackets::SendSystemMessage(sysAddr, u"Failed to parse speed scale argument.");
+					}
+				}
+
+				float airSpeed = 20 * speedScale;
+				float maxAirSpeed = 30 * speedScale;
+				float verticalVelocity = 1.5 * speedScale;
+
+				GameMessages::SendSetJetPackMode(entity, true, true, false, 167, airSpeed, maxAirSpeed, verticalVelocity);
+
+				character->SetIsFlying(true);
+			}
+		}
+	}
+
+	void AttackImmune(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+		if (splitArgs.empty()) return;
+
+		auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
+
+		const auto state = GeneralUtils::TryParse<int32_t>(splitArgs[0]);
+
+		if (!state) {
+			ChatPackets::SendSystemMessage(sysAddr, u"Invalid state.");
+			return;
+		}
+
+		if (destroyableComponent) destroyableComponent->SetIsImmune(state.value());
+	}
+
+	void GmImmune(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto splitArgs = GeneralUtils::SplitString(args, ' ');
+		if (splitArgs.empty()) return;
+
+		auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
+
+		const auto state = GeneralUtils::TryParse<int32_t>(splitArgs[0]);
+
+		if (!state) {
+			ChatPackets::SendSystemMessage(sysAddr, u"Invalid state.");
+			return;
+		}
+
+		if (destroyableComponent) destroyableComponent->SetIsGMImmune(state.value());
+	}
+
+	void GmInvis(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		GameMessages::SendToggleGMInvis(entity->GetObjectID(), true, UNASSIGNED_SYSTEM_ADDRESS);
+	}
+
+	void SetName(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		GameMessages::SendSetName(entity->GetObjectID(), GeneralUtils::UTF8ToUTF16(args), UNASSIGNED_SYSTEM_ADDRESS);
+	}
+
+	void Title(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		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

@@ -0,0 +1,21 @@
+#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);
+	void Ban(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void ApproveProperty(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Mute(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Fly(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void AttackImmune(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void GmImmune(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	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

@@ -0,0 +1,232 @@
+#include "GMZeroCommands.h"
+
+// Classes
+#include "Amf3.h"
+#include "BinaryPathFinder.h"
+#include "ChatPackets.h"
+#include "dServer.h"
+#include "dZoneManager.h"
+#include "Mail.h"
+#include "PlayerManager.h"
+#include "SlashCommandHandler.h"
+#include "VanityUtilities.h"
+#include "WorldPackets.h"
+#include "ZoneInstanceManager.h"
+
+// Components
+#include "BuffComponent.h"
+#include "CharacterComponent.h"
+#include "DestroyableComponent.h"
+#include "ScriptedActivityComponent.h"
+#include "SkillComponent.h"
+
+// Emuns
+#include "eGameMasterLevel.h"
+
+namespace GMZeroCommands {
+	void Pvp(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		auto* character = entity->GetComponent<CharacterComponent>();
+
+		if (character == nullptr) {
+			LOG("Failed to find character component!");
+			return;
+		}
+
+		character->SetPvpEnabled(!character->GetPvpEnabled());
+		Game::entityManager->SerializeEntity(entity);
+
+		std::stringstream message;
+		message << character->GetName() << " changed their PVP flag to " << std::to_string(character->GetPvpEnabled()) << "!";
+
+		ChatPackets::SendSystemMessage(UNASSIGNED_SYSTEM_ADDRESS, GeneralUtils::UTF8ToUTF16(message.str()), true);
+	}
+
+	void Who(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		ChatPackets::SendSystemMessage(
+			sysAddr,
+			u"Players in this instance: (" + GeneralUtils::to_u16string(PlayerManager::GetAllPlayers().size()) + u")"
+		);
+
+		for (auto* player : PlayerManager::GetAllPlayers()) {
+			const auto& name = player->GetCharacter()->GetName();
+
+			ChatPackets::SendSystemMessage(
+				sysAddr,
+				GeneralUtils::UTF8ToUTF16(player == entity ? name + " (you)" : name)
+			);
+		}
+	}
+
+	void Ping(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		if (!args.empty() && args.starts_with("-l")) {
+			std::stringstream message;
+			message << "Your latest ping: " << std::to_string(Game::server->GetLatestPing(sysAddr)) << "ms";
+
+			ChatPackets::SendSystemMessage(sysAddr, GeneralUtils::ASCIIToUTF16(message.str()));
+		} else {
+			std::stringstream message;
+			message << "Your average ping: " << std::to_string(Game::server->GetPing(sysAddr)) << "ms";
+
+			ChatPackets::SendSystemMessage(sysAddr, GeneralUtils::ASCIIToUTF16(message.str()));
+		}
+	}
+
+	void FixStats(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		// Reset skill component and buff component
+		auto* skillComponent = entity->GetComponent<SkillComponent>();
+		auto* buffComponent = entity->GetComponent<BuffComponent>();
+		auto* destroyableComponent = entity->GetComponent<DestroyableComponent>();
+
+		// If any of the components are nullptr, return
+		if (skillComponent == nullptr || buffComponent == nullptr || destroyableComponent == nullptr) {
+			return;
+		}
+
+		// Reset skill component
+		skillComponent->Reset();
+
+		// Reset buff component
+		buffComponent->Reset();
+
+		// Fix the destroyable component
+		destroyableComponent->FixStats();
+	}
+
+	void Credits(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto& customText = VanityUtilities::ParseMarkdown((BinaryPathFinder::GetBinaryDir() / "vanity/CREDITS.md").string());
+
+		{
+			AMFArrayValue args;
+
+			args.Insert("state", "Story");
+
+			GameMessages::SendUIMessageServerToSingleClient(entity, entity->GetSystemAddress(), "pushGameState", args);
+		}
+
+		entity->AddCallbackTimer(0.5f, [customText, entity]() {
+			AMFArrayValue args;
+
+			args.Insert("visible", true);
+			args.Insert("text", customText);
+
+			LOG("Sending %s", customText.c_str());
+
+			GameMessages::SendUIMessageServerToSingleClient(entity, entity->GetSystemAddress(), "ToggleStoryBox", args);
+			});
+	}
+
+	void Info(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto& customText = VanityUtilities::ParseMarkdown((BinaryPathFinder::GetBinaryDir() / "vanity/INFO.md").string());
+
+		{
+			AMFArrayValue args;
+
+			args.Insert("state", "Story");
+
+			GameMessages::SendUIMessageServerToSingleClient(entity, entity->GetSystemAddress(), "pushGameState", args);
+		}
+
+		entity->AddCallbackTimer(0.5f, [customText, entity]() {
+			AMFArrayValue args;
+
+			args.Insert("visible", true);
+			args.Insert("text", customText);
+
+			LOG("Sending %s", customText.c_str());
+
+			GameMessages::SendUIMessageServerToSingleClient(entity, entity->GetSystemAddress(), "ToggleStoryBox", args);
+			});
+	}
+
+	void LeaveZone(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto currentZone = Game::zoneManager->GetZone()->GetZoneID().GetMapID();
+		LWOMAPID newZone = 0;
+
+		if (currentZone == 1001 || currentZone % 100 == 0) {
+			ChatPackets::SendSystemMessage(sysAddr, u"You are not in an instanced zone.");
+			return;
+		} else {
+			newZone = (currentZone / 100) * 100;
+		}
+		// If new zone would be inaccessible, then default to Avant Gardens.
+		if (!Game::zoneManager->CheckIfAccessibleZone(newZone)) newZone = 1100;
+
+		ChatPackets::SendSystemMessage(sysAddr, u"Leaving zone...");
+
+		const auto objid = entity->GetObjectID();
+
+		ZoneInstanceManager::Instance()->RequestZoneTransfer(Game::server, newZone, 0, false, [objid](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string serverIP, uint16_t serverPort) {
+			auto* entity = Game::entityManager->GetEntity(objid);
+
+			if (entity == nullptr) {
+				return;
+			}
+
+			const auto sysAddr = entity->GetSystemAddress();
+
+			LOG("Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", entity->GetCharacter()->GetName().c_str(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
+
+			if (entity->GetCharacter()) {
+				entity->GetCharacter()->SetZoneID(zoneID);
+				entity->GetCharacter()->SetZoneInstance(zoneInstance);
+				entity->GetCharacter()->SetZoneClone(zoneClone);
+			}
+
+			entity->GetCharacter()->SaveXMLToDatabase();
+
+			WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+			});
+	}
+
+	void Join(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		auto splitArgs = GeneralUtils::SplitString(args, ' ');
+		if (splitArgs.empty()) return;
+
+		ChatPackets::SendSystemMessage(sysAddr, u"Requesting private map...");
+		const auto& password = splitArgs[0];
+
+		ZoneInstanceManager::Instance()->RequestPrivateZone(Game::server, false, password, [=](bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, std::string serverIP, uint16_t serverPort) {
+			LOG("Transferring %s to Zone %i (Instance %i | Clone %i | Mythran Shift: %s) with IP %s and Port %i", sysAddr.ToString(), zoneID, zoneInstance, zoneClone, mythranShift == true ? "true" : "false", serverIP.c_str(), serverPort);
+
+			if (entity->GetCharacter()) {
+				entity->GetCharacter()->SetZoneID(zoneID);
+				entity->GetCharacter()->SetZoneInstance(zoneInstance);
+				entity->GetCharacter()->SetZoneClone(zoneClone);
+			}
+
+			entity->GetCharacter()->SaveXMLToDatabase();
+
+			WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+			});
+	}
+
+	void Die(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		entity->Smash(entity->GetObjectID());
+	}
+
+	void Resurrect(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		ScriptedActivityComponent* scriptedActivityComponent = Game::zoneManager->GetZoneControlObject()->GetComponent<ScriptedActivityComponent>();
+
+		if (scriptedActivityComponent) { // check if user is in activity world and if so, they can't resurrect
+			ChatPackets::SendSystemMessage(sysAddr, u"You cannot resurrect in an activity world.");
+			return;
+		}
+
+		GameMessages::SendResurrect(entity);
+	}
+
+	void RequestMailCount(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		Mail::HandleNotificationRequest(entity->GetSystemAddress(), entity->GetObjectID());
+	}
+
+	void InstanceInfo(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
+		const auto zoneId = Game::zoneManager->GetZone()->GetZoneID();
+
+		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

@@ -0,0 +1,21 @@
+#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);
+	void Info(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Die(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Ping(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Pvp(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void RequestMailCount(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Who(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void FixStats(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	void Join(Entity* entity, const SystemAddress& sysAddr, const std::string args);
+	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;
 				}