WIP working state

tested that jawbox works as intended now for donation counting on the leaderboards

.github/copilot-instructions.md

@@ -0,0 +1,29 @@
+# GitHub Copilot Instructions
+
+ * c++20 standard, please use the latest features except NO modules.
+   * use `.contains` for searching in associative containers
+ * use const as much as possible.  If it can be const, it should be made const
+ * DO NOT USE const_cast EVER.
+ * use `cstdint` bitwidth types ALWAYS for integral types.
+ * NEVER use std::wstring. If wide strings are necessary, use std::u16string with conversion utilties in GeneralUtils.h.
+ * Functions are ALWAYS PascalCase.
+ * local variables are camelCase
+ * NEVER use snake case
+ * indentation is TABS, not SPACES.
+ * TABS are 4 spaces by default
+ * Use trailing braces ALWAYS
+ * global variables are prefixed with `g_`
+ * if global variables or functions are needed, they should be located in an anonymous namespace
+ * Use `GeneralUtils::TryParse` for ANY parsing of strings to integrals.
+ * Use brace initialization when possible.
+ * ALWAYS default initialize variables.
+ * Pointers should be avoided unless necessary. Use references when the pointer has been checked and should not be null
+ * headers should be as compact as possible. Do NOT include extra data that isnt needed.
+ * Remember to include logs (LOG macro uses printf style logging) while putting verbose logs under LOG_DEBUG.
+ * NEVER USE `RakNet::BitStream::ReadBit`
+ * NEVER assume pointers are good, always check if they are null. Once a pointer is checked and is known to be non-null, further accesses no longer need checking
+ * Be wary of TOCTOU. Prevent all possible issues relating to TOCTOU.
+ * new memory allocations should never be used unless absolutely necessary.
+    * new for reconstruction of objects is allowed
+ * Prefer following the format of the file over correct formatting.  Consistency over correctness.
+ * When using auto, ALWAYS put a * for pointers.

CMakeLists.txt

@@ -110,6 +110,8 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
 find_package(MariaDB)
+find_package(OpenSSL REQUIRED)
+
 
 # Create a /resServer directory
 make_directory(${CMAKE_BINARY_DIR}/resServer)
@@ -126,7 +128,7 @@ endif()
 message(STATUS "Variable: DLU_CONFIG_DIR = ${DLU_CONFIG_DIR}")
 
 # Copy resource files on first build
-set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "blocklist.dcf")
+set(RESOURCE_FILES "sharedconfig.ini" "authconfig.ini" "chatconfig.ini" "worldconfig.ini" "masterconfig.ini" "dashboardconfig.ini" "blocklist.dcf")
 message(STATUS "Checking resource file integrity")
 
 include(Utils)
@@ -322,6 +324,7 @@ endif()
 add_subdirectory(dWorldServer)
 add_subdirectory(dAuthServer)
 add_subdirectory(dChatServer)
+add_subdirectory(dDashboardServer)
 add_subdirectory(dMasterServer) # Add MasterServer last so it can rely on the other binaries
 
 target_precompile_headers(

dChatServer/ChatServer.cpp

@@ -202,8 +202,11 @@ int main(int argc, char** argv) {
 	//Delete our objects here:
 	Database::Destroy("ChatServer");
 	delete Game::server;
+	Game::server = nullptr;
 	delete Game::logger;
+	Game::logger = nullptr;
 	delete Game::config;
+	Game::config = nullptr;
 
 	return EXIT_SUCCESS;
 }

dChatServer/ChatWeb.cpp

@@ -19,23 +19,24 @@
 #include "eGameMasterLevel.h"
 #include "dChatFilter.h"
 #include "TeamContainer.h"
+#include "HTTPContext.h"
 
 using json = nlohmann::json;
 
-void HandleHTTPPlayersRequest(HTTPReply& reply, std::string body) {
+void HandleHTTPPlayersRequest(HTTPReply& reply, const HTTPContext& context) {
 	const json data = Game::playerContainer;
 	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
 	reply.message = data.empty() ? "{\"error\":\"No Players Online\"}" : data.dump();
 }
 
-void HandleHTTPTeamsRequest(HTTPReply& reply, std::string body) {
+void HandleHTTPTeamsRequest(HTTPReply& reply, const HTTPContext& context) {
 	const json data = TeamContainer::GetTeamContainer();
 	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
 	reply.message = data.empty() ? "{\"error\":\"No Teams Online\"}" : data.dump();
 }
 
-void HandleHTTPAnnounceRequest(HTTPReply& reply, std::string body) {
-	auto data = GeneralUtils::TryParse<json>(body);
+void HandleHTTPAnnounceRequest(HTTPReply& reply, const HTTPContext& context) {
+	auto data = GeneralUtils::TryParse<json>(context.body);
 	if (!data) {
 		reply.status = eHTTPStatusCode::BAD_REQUEST;
 		reply.message = "{\"error\":\"Invalid JSON\"}";
@@ -96,18 +97,21 @@ namespace ChatWeb {
 		Game::web.RegisterHTTPRoute({
 			.path = v1_route + "players",
 			.method = eHTTPMethod::GET,
+			.middleware = {},
 			.handle = HandleHTTPPlayersRequest
 		});
 
 		Game::web.RegisterHTTPRoute({
 			.path = v1_route + "teams",
 			.method = eHTTPMethod::GET,
+			.middleware = {},
 			.handle = HandleHTTPTeamsRequest
 		});
 
 		Game::web.RegisterHTTPRoute({
 			.path = v1_route + "announce",
 			.method = eHTTPMethod::POST,
+			.middleware = {},
 			.handle = HandleHTTPAnnounceRequest
 		});
 

dChatServer/TeamContainer.cpp

@@ -477,7 +477,7 @@ TeamData* TeamContainer::CreateLocalTeam(std::vector<LWOOBJID> members) {
 		}
 	}
 
-	newTeam->lootFlag = 1;
+	newTeam->lootFlag = 0;
 
 	TeamStatusUpdate(newTeam);
 

dCommon/Amf3.h

@@ -374,6 +374,21 @@ public:
 		return value->Insert<AmfType>("value", std::make_unique<AmfType>());
 	}
 
+	AMFArrayValue& PushDebug(const NiPoint3& point) {
+		PushDebug<AMFDoubleValue>("X") = point.x;
+		PushDebug<AMFDoubleValue>("Y") = point.y;
+		PushDebug<AMFDoubleValue>("Z") = point.z;
+		return *this;
+	}
+
+	AMFArrayValue& PushDebug(const NiQuaternion& rot) {
+		PushDebug<AMFDoubleValue>("W") = rot.w;
+		PushDebug<AMFDoubleValue>("X") = rot.x;
+		PushDebug<AMFDoubleValue>("Y") = rot.y;
+		PushDebug<AMFDoubleValue>("Z") = rot.z;
+		return *this;
+	}
+
 private:
 	/**
 	 * The associative portion.  These values are key'd with strings to an AMFValue.

dCommon/Logger.cpp

@@ -96,3 +96,17 @@ bool Logger::GetLogToConsole() const {
 	}
 	return toReturn;
 }
+
+FuncEntry::FuncEntry(const char* funcName, const char* fileName, const uint32_t line) {
+	m_FuncName = funcName;
+	if (!m_FuncName) m_FuncName = "Unknown";
+	m_Line = line;
+	m_FileName = fileName;
+	LOG("--> %s::%s:%i", m_FileName, m_FuncName, m_Line);
+}
+
+FuncEntry::~FuncEntry() {
+	if (!m_FuncName || !m_FileName) return;
+
+	LOG("<-- %s::%s:%i", m_FileName, m_FuncName, m_Line);
+}

dCommon/Logger.h

@@ -32,6 +32,19 @@ constexpr const char* GetFileNameFromAbsolutePath(const char* path) {
 #define LOG(message, ...) do { auto str_ = FILENAME_AND_LINE; Game::logger->Log(str_, message, ##__VA_ARGS__); } while(0)
 #define LOG_DEBUG(message, ...) do { auto str_ = FILENAME_AND_LINE; Game::logger->LogDebug(str_, message, ##__VA_ARGS__); } while(0)
 
+// Place this right at the start of a function. Will log a message when called and then once you leave the function.
+#define LOG_ENTRY auto str_ = GetFileNameFromAbsolutePath(__FILE__); FuncEntry funcEntry_(__FUNCTION__, str_, __LINE__)
+
+class FuncEntry {
+public:
+	FuncEntry(const char* funcName, const char* fileName, const uint32_t line);
+	~FuncEntry();
+private:
+	const char* m_FuncName = nullptr;
+	const char* m_FileName = nullptr;
+	uint32_t m_Line = 0;
+};
+
 // Writer class for writing data to files.
 class Writer {
 public:

dCommon/Lxfml.cpp

@@ -5,13 +5,43 @@
 #include "TinyXmlUtils.h"
 
 #include <ranges>
+#include <unordered_map>
+#include <unordered_set>
+#include <functional>
+#include <sstream>
+
+namespace {
+	// The base LXFML xml file to use when creating new models.
+	std::string g_base = R"(<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<LXFML versionMajor="5" versionMinor="0">
+<Meta>
+    <Application name="LEGO Universe" versionMajor="0" versionMinor="0"/>
+    <Brand name="LEGOUniverse"/>
+    <BrickSet version="457"/>
+</Meta>
+<Bricks>
+</Bricks>
+<RigidSystems>
+</RigidSystems>
+<GroupSystems>
+    <GroupSystem>
+    </GroupSystem>
+</GroupSystems>
+</LXFML>)";
+}
 
 Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoint3& curPosition) {
 	Result toReturn;
+	
+	// Handle empty or invalid input
+	if (data.empty()) {
+		return toReturn;
+	}
+	
 	tinyxml2::XMLDocument doc;
-	const auto err = doc.Parse(data.data());
+	// Use length-based parsing to avoid expensive string copy
+	const auto err = doc.Parse(data.data(), data.size());
 	if (err != tinyxml2::XML_SUCCESS) {
-		LOG("Failed to parse xml %s.", StringifiedEnum::ToString(err).data());
 		return toReturn;
 	}
 
@@ -20,7 +50,6 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 
 	auto lxfml = reader["LXFML"];
 	if (!lxfml) {
-		LOG("Failed to find LXFML element.");
 		return toReturn;
 	}
 
@@ -49,16 +78,19 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 		// Calculate the lowest and highest points on the entire model
 		for (const auto& transformation : transformations | std::views::values) {
 			auto split = GeneralUtils::SplitString(transformation, ',');
-			if (split.size() < 12) {
-				LOG("Not enough in the split?");
-				continue;
-			}
-
-			auto x = GeneralUtils::TryParse<float>(split[9]).value();
-			auto y = GeneralUtils::TryParse<float>(split[10]).value();
-			auto z = GeneralUtils::TryParse<float>(split[11]).value();
-			if (x < lowest.x) lowest.x = x;
-			if (y < lowest.y) lowest.y = y;
+		if (split.size() < 12) continue;
+	
+		auto xOpt = GeneralUtils::TryParse<float>(split[9]);
+		auto yOpt = GeneralUtils::TryParse<float>(split[10]);
+		auto zOpt = GeneralUtils::TryParse<float>(split[11]);
+			
+		if (!xOpt.has_value() || !yOpt.has_value() || !zOpt.has_value()) continue;
+		
+		auto x = xOpt.value();
+		auto y = yOpt.value();
+		auto z = zOpt.value();
+		if (x < lowest.x) lowest.x = x;
+		if (y < lowest.y) lowest.y = y;
 			if (z < lowest.z) lowest.z = z;
 
 			if (highest.x < x) highest.x = x;
@@ -87,13 +119,19 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 	for (auto& transformation : transformations | std::views::values) {
 		auto split = GeneralUtils::SplitString(transformation, ',');
 		if (split.size() < 12) {
-			LOG("Not enough in the split?");
 			continue;
 		}
 
-		auto x = GeneralUtils::TryParse<float>(split[9]).value() - newRootPos.x + curPosition.x;
-		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y + curPosition.y;
-		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z + curPosition.z;
+		auto xOpt = GeneralUtils::TryParse<float>(split[9]);
+		auto yOpt = GeneralUtils::TryParse<float>(split[10]);
+		auto zOpt = GeneralUtils::TryParse<float>(split[11]);
+		
+		if (!xOpt.has_value() || !yOpt.has_value() || !zOpt.has_value()) {
+			continue;
+		}		
+		auto x = xOpt.value() - newRootPos.x + curPosition.x;
+		auto y = yOpt.value() - newRootPos.y + curPosition.y;
+		auto z = zOpt.value() - newRootPos.z + curPosition.z;
 		std::stringstream stream;
 		for (int i = 0; i < 9; i++) {
 			stream << split[i];
@@ -128,3 +166,345 @@ Lxfml::Result Lxfml::NormalizePosition(const std::string_view data, const NiPoin
 	toReturn.center = newRootPos;
 	return toReturn;
 }
+
+// Deep-clone an XMLElement (attributes, text, and child elements) into a target document
+// with maximum depth protection to prevent infinite loops
+static tinyxml2::XMLElement* CloneElementDeep(const tinyxml2::XMLElement* src, tinyxml2::XMLDocument& dstDoc, int maxDepth = 100) {
+	if (!src || maxDepth <= 0) return nullptr;
+	auto* dst = dstDoc.NewElement(src->Name());
+
+	// copy attributes
+	for (const tinyxml2::XMLAttribute* attr = src->FirstAttribute(); attr; attr = attr->Next()) {
+		dst->SetAttribute(attr->Name(), attr->Value());
+	}
+
+	// copy children (elements and text)
+	for (const tinyxml2::XMLNode* child = src->FirstChild(); child; child = child->NextSibling()) {
+		if (const tinyxml2::XMLElement* childElem = child->ToElement()) {
+			// Recursively clone child elements with decremented depth
+			auto* clonedChild = CloneElementDeep(childElem, dstDoc, maxDepth - 1);
+			if (clonedChild) dst->InsertEndChild(clonedChild);
+		} else if (const tinyxml2::XMLText* txt = child->ToText()) {
+			auto* n = dstDoc.NewText(txt->Value());
+			dst->InsertEndChild(n);
+		} else if (const tinyxml2::XMLComment* c = child->ToComment()) {
+			auto* n = dstDoc.NewComment(c->Value());
+			dst->InsertEndChild(n);
+		}
+	}
+
+	return dst;
+}
+
+std::vector<Lxfml::Result> Lxfml::Split(const std::string_view data, const NiPoint3& curPosition) {
+	std::vector<Result> results;
+	
+	// Handle empty or invalid input
+	if (data.empty()) {
+		return results;
+	}
+	
+	// Prevent processing extremely large inputs that could cause hangs
+	if (data.size() > 10000000) { // 10MB limit
+		return results;
+	}
+	
+	tinyxml2::XMLDocument doc;
+	// Use length-based parsing to avoid expensive string copy
+	const auto err = doc.Parse(data.data(), data.size());
+	if (err != tinyxml2::XML_SUCCESS) {
+		return results;
+	}
+
+	auto* lxfml = doc.FirstChildElement("LXFML");
+	if (!lxfml) {
+		return results;
+	}
+
+	// Build maps: partRef -> Part element, partRef -> Brick element, boneRef -> partRef, brickRef -> Brick element
+	std::unordered_map<std::string, tinyxml2::XMLElement*> partRefToPart;
+	std::unordered_map<std::string, tinyxml2::XMLElement*> partRefToBrick;
+	std::unordered_map<std::string, std::string> boneRefToPartRef;
+	std::unordered_map<std::string, tinyxml2::XMLElement*> brickByRef;
+
+	auto* bricksParent = lxfml->FirstChildElement("Bricks");
+	if (bricksParent) {
+		for (auto* brick = bricksParent->FirstChildElement("Brick"); brick; brick = brick->NextSiblingElement("Brick")) {
+			const char* brickRef = brick->Attribute("refID");
+			if (brickRef) brickByRef.emplace(std::string(brickRef), brick);
+			for (auto* part = brick->FirstChildElement("Part"); part; part = part->NextSiblingElement("Part")) {
+				const char* partRef = part->Attribute("refID");
+				if (partRef) {
+					partRefToPart.emplace(std::string(partRef), part);
+					partRefToBrick.emplace(std::string(partRef), brick);
+				}
+				auto* bone = part->FirstChildElement("Bone");
+				if (bone) {
+					const char* boneRef = bone->Attribute("refID");
+					if (boneRef) boneRefToPartRef.emplace(std::string(boneRef), partRef ? std::string(partRef) : std::string());
+				}
+			}
+		}
+	}
+
+	// Collect RigidSystem elements
+	std::vector<tinyxml2::XMLElement*> rigidSystems;
+	auto* rigidSystemsParent = lxfml->FirstChildElement("RigidSystems");
+	if (rigidSystemsParent) {
+		for (auto* rs = rigidSystemsParent->FirstChildElement("RigidSystem"); rs; rs = rs->NextSiblingElement("RigidSystem")) {
+			rigidSystems.push_back(rs);
+		}
+	}
+
+	// Collect top-level groups (immediate children of GroupSystem)
+	std::vector<tinyxml2::XMLElement*> groupRoots;
+	auto* groupSystemsParent = lxfml->FirstChildElement("GroupSystems");
+	if (groupSystemsParent) {
+		for (auto* gs = groupSystemsParent->FirstChildElement("GroupSystem"); gs; gs = gs->NextSiblingElement("GroupSystem")) {
+			for (auto* group = gs->FirstChildElement("Group"); group; group = group->NextSiblingElement("Group")) {
+				groupRoots.push_back(group);
+			}
+		}
+	}
+
+	// Track used bricks and rigidsystems
+	std::unordered_set<std::string> usedBrickRefs;
+	std::unordered_set<tinyxml2::XMLElement*> usedRigidSystems;
+
+	// Track used groups to avoid processing them twice
+	std::unordered_set<tinyxml2::XMLElement*> usedGroups;
+
+	// Helper to create output document from sets of brick refs and rigidsystem pointers
+	auto makeOutput = [&](const std::unordered_set<std::string>& bricksToInclude, const std::vector<tinyxml2::XMLElement*>& rigidSystemsToInclude, const std::vector<tinyxml2::XMLElement*>& groupsToInclude = {}) {
+		tinyxml2::XMLDocument outDoc;
+		outDoc.Parse(g_base.c_str());
+		auto* outRoot = outDoc.FirstChildElement("LXFML");
+		auto* outBricks = outRoot->FirstChildElement("Bricks");
+		auto* outRigidSystems = outRoot->FirstChildElement("RigidSystems");
+		auto* outGroupSystems = outRoot->FirstChildElement("GroupSystems");
+
+		// clone and insert bricks
+		for (const auto& bref : bricksToInclude) {
+			auto it = brickByRef.find(bref);
+			if (it == brickByRef.end()) continue;
+			tinyxml2::XMLElement* cloned = CloneElementDeep(it->second, outDoc);
+			if (cloned) outBricks->InsertEndChild(cloned);
+		}
+
+		// clone and insert rigidsystems
+		for (auto* rsPtr : rigidSystemsToInclude) {
+			tinyxml2::XMLElement* cloned = CloneElementDeep(rsPtr, outDoc);
+			if (cloned) outRigidSystems->InsertEndChild(cloned);
+		}
+
+		// clone and insert group(s) if requested
+		if (outGroupSystems && !groupsToInclude.empty()) {
+			// clear default children
+			while (outGroupSystems->FirstChild()) outGroupSystems->DeleteChild(outGroupSystems->FirstChild());
+			// create a GroupSystem element and append requested groups
+			auto* newGS = outDoc.NewElement("GroupSystem");
+			for (auto* gptr : groupsToInclude) {
+				tinyxml2::XMLElement* clonedG = CloneElementDeep(gptr, outDoc);
+				if (clonedG) newGS->InsertEndChild(clonedG);
+			}
+			outGroupSystems->InsertEndChild(newGS);
+		}
+
+		// Print to string
+		tinyxml2::XMLPrinter printer;
+		outDoc.Print(&printer);
+		// Normalize position and compute center using existing helper
+		std::string xmlString = printer.CStr();
+		if (xmlString.size() > 5000000) { // 5MB limit for normalization
+			Result emptyResult;
+			emptyResult.lxfml = xmlString;
+			return emptyResult;
+		}
+		auto normalized = NormalizePosition(xmlString, curPosition);
+		return normalized;
+	};
+
+	// 1) Process groups (each top-level Group becomes one output; nested groups are included)
+	for (auto* groupRoot : groupRoots) {
+		// Skip if this group was already processed as part of another group
+		if (usedGroups.find(groupRoot) != usedGroups.end()) continue;
+
+		// Helper to collect all partRefs in a group's subtree
+		std::function<void(const tinyxml2::XMLElement*, std::unordered_set<std::string>&)> collectParts = [&](const tinyxml2::XMLElement* g, std::unordered_set<std::string>& partRefs) {
+			if (!g) return;
+			const char* partAttr = g->Attribute("partRefs");
+			if (partAttr) {
+				for (auto& tok : GeneralUtils::SplitString(partAttr, ',')) partRefs.insert(tok);
+			}
+			for (auto* child = g->FirstChildElement("Group"); child; child = child->NextSiblingElement("Group")) collectParts(child, partRefs);
+		};
+
+		// Collect all groups that need to be merged into this output
+		std::vector<tinyxml2::XMLElement*> groupsToInclude{ groupRoot };
+		usedGroups.insert(groupRoot);
+
+		// Build initial sets of bricks and boneRefs from the starting group
+		std::unordered_set<std::string> partRefs;
+		collectParts(groupRoot, partRefs);
+
+		std::unordered_set<std::string> bricksIncluded;
+		std::unordered_set<std::string> boneRefsIncluded;
+		for (const auto& pref : partRefs) {
+			auto pit = partRefToBrick.find(pref);
+			if (pit != partRefToBrick.end()) {
+				const char* bref = pit->second->Attribute("refID");
+				if (bref) bricksIncluded.insert(std::string(bref));
+			}
+			auto partIt = partRefToPart.find(pref);
+			if (partIt != partRefToPart.end()) {
+				auto* bone = partIt->second->FirstChildElement("Bone");
+				if (bone) {
+					const char* bref = bone->Attribute("refID");
+					if (bref) boneRefsIncluded.insert(std::string(bref));
+				}
+			}
+		}
+
+		// Iteratively include any RigidSystems that reference any boneRefsIncluded
+		// and check if those rigid systems' bricks span other groups
+		bool changed = true;
+		std::vector<tinyxml2::XMLElement*> rigidSystemsToInclude;
+		int maxIterations = 1000; // Safety limit to prevent infinite loops
+		int iteration = 0;
+		while (changed && iteration < maxIterations) {
+			changed = false;
+			iteration++;
+
+			// First, expand rigid systems based on current boneRefsIncluded
+			for (auto* rs : rigidSystems) {
+				if (usedRigidSystems.find(rs) != usedRigidSystems.end()) continue;
+				// parse boneRefs of this rigid system (from its <Rigid> children)
+				bool intersects = false;
+				std::vector<std::string> rsBoneRefs;
+				for (auto* rigid = rs->FirstChildElement("Rigid"); rigid; rigid = rigid->NextSiblingElement("Rigid")) {
+					const char* battr = rigid->Attribute("boneRefs");
+					if (!battr) continue;
+					for (auto& tok : GeneralUtils::SplitString(battr, ',')) {
+						rsBoneRefs.push_back(tok);
+						if (boneRefsIncluded.find(tok) != boneRefsIncluded.end()) intersects = true;
+					}
+				}
+				if (!intersects) continue;
+				// include this rigid system and all boneRefs it references
+				usedRigidSystems.insert(rs);
+				rigidSystemsToInclude.push_back(rs);
+				for (const auto& br : rsBoneRefs) {
+					boneRefsIncluded.insert(br);
+					auto bpIt = boneRefToPartRef.find(br);
+					if (bpIt != boneRefToPartRef.end()) {
+						auto partRef = bpIt->second;
+						auto pbIt = partRefToBrick.find(partRef);
+						if (pbIt != partRefToBrick.end()) {
+							const char* bref = pbIt->second->Attribute("refID");
+							if (bref && bricksIncluded.insert(std::string(bref)).second) changed = true;
+						}
+					}
+				}
+			}
+
+			// Second, check if the newly included bricks span any other groups
+			// If so, merge those groups into the current output
+			for (auto* otherGroup : groupRoots) {
+				if (usedGroups.find(otherGroup) != usedGroups.end()) continue;
+
+				// Collect partRefs from this other group
+				std::unordered_set<std::string> otherPartRefs;
+				collectParts(otherGroup, otherPartRefs);
+
+				// Check if any of these partRefs correspond to bricks we've already included
+				bool spansOtherGroup = false;
+				for (const auto& pref : otherPartRefs) {
+					auto pit = partRefToBrick.find(pref);
+					if (pit != partRefToBrick.end()) {
+						const char* bref = pit->second->Attribute("refID");
+						if (bref && bricksIncluded.find(std::string(bref)) != bricksIncluded.end()) {
+							spansOtherGroup = true;
+							break;
+						}
+					}
+				}
+
+				if (spansOtherGroup) {
+					// Merge this group into the current output
+					usedGroups.insert(otherGroup);
+					groupsToInclude.push_back(otherGroup);
+					changed = true;
+
+					// Add all partRefs, boneRefs, and bricks from this group
+					for (const auto& pref : otherPartRefs) {
+						auto pit = partRefToBrick.find(pref);
+						if (pit != partRefToBrick.end()) {
+							const char* bref = pit->second->Attribute("refID");
+							if (bref) bricksIncluded.insert(std::string(bref));
+						}
+						auto partIt = partRefToPart.find(pref);
+						if (partIt != partRefToPart.end()) {
+							auto* bone = partIt->second->FirstChildElement("Bone");
+							if (bone) {
+								const char* bref = bone->Attribute("refID");
+								if (bref) boneRefsIncluded.insert(std::string(bref));
+							}
+						}
+					}
+				}
+			}
+		}
+		
+		if (iteration >= maxIterations) {
+			// Iteration limit reached, stop processing to prevent infinite loops
+			// The file is likely malformed, so just skip further processing
+			return results;
+		}		
+		// include bricks from bricksIncluded into used set
+		for (const auto& b : bricksIncluded) usedBrickRefs.insert(b);
+
+		// make output doc and push result (include all merged groups' XML)
+		auto normalized = makeOutput(bricksIncluded, rigidSystemsToInclude, groupsToInclude);
+		results.push_back(normalized);
+	}
+
+	// 2) Process remaining RigidSystems (each becomes its own file)
+	for (auto* rs : rigidSystems) {
+		if (usedRigidSystems.find(rs) != usedRigidSystems.end()) continue;
+		std::unordered_set<std::string> bricksIncluded;
+		// collect boneRefs referenced by this rigid system
+		for (auto* rigid = rs->FirstChildElement("Rigid"); rigid; rigid = rigid->NextSiblingElement("Rigid")) {
+			const char* battr = rigid->Attribute("boneRefs");
+			if (!battr) continue;
+			for (auto& tok : GeneralUtils::SplitString(battr, ',')) {
+				auto bpIt = boneRefToPartRef.find(tok);
+				if (bpIt != boneRefToPartRef.end()) {
+					auto partRef = bpIt->second;
+					auto pbIt = partRefToBrick.find(partRef);
+					if (pbIt != partRefToBrick.end()) {
+						const char* bref = pbIt->second->Attribute("refID");
+						if (bref) bricksIncluded.insert(std::string(bref));
+					}
+				}
+			}
+		}
+		// mark used
+		for (const auto& b : bricksIncluded) usedBrickRefs.insert(b);
+		usedRigidSystems.insert(rs);
+
+		std::vector<tinyxml2::XMLElement*> rsVec{ rs };
+		auto normalized = makeOutput(bricksIncluded, rsVec);
+		results.push_back(normalized);
+	}
+
+	// 3) Any remaining bricks not included become their own files
+	for (const auto& [bref, brickPtr] : brickByRef) {
+		if (usedBrickRefs.find(bref) != usedBrickRefs.end()) continue;
+		std::unordered_set<std::string> bricksIncluded{ bref };
+		auto normalized = makeOutput(bricksIncluded, {});
+		results.push_back(normalized);
+		usedBrickRefs.insert(bref);
+	}
+
+	return results;
+}

dCommon/Lxfml.h

@@ -6,6 +6,7 @@
 
 #include <string>
 #include <string_view>
+#include <vector>
 
 #include "NiPoint3.h"
 
@@ -18,6 +19,7 @@ namespace Lxfml {
 	// Normalizes a LXFML model to be positioned relative to its local 0, 0, 0 rather than a game worlds 0, 0, 0.
 	// Returns a struct of its new center and the updated LXFML containing these edits.
 	[[nodiscard]] Result NormalizePosition(const std::string_view data, const NiPoint3& curPosition = NiPoint3Constant::ZERO);
+	[[nodiscard]] std::vector<Result> Split(const std::string_view data, const NiPoint3& curPosition = NiPoint3Constant::ZERO);
 
 	// these are only for the migrations due to a bug in one of the implementations.
 	[[nodiscard]] Result NormalizePositionOnlyFirstPart(const std::string_view data);

dCommon/dClient/AssetManager.h

@@ -81,6 +81,9 @@ public:
 	[[nodiscard]]
 	AssetStream GetFile(const char* name) const;
 
+	[[nodiscard]]
+	AssetStream GetFile(const std::string& name) const { return GetFile(name.c_str()); };
+
 private:
 	void LoadPackIndex();
 

dCommon/dEnums/MessageType/Master.h

@@ -27,6 +27,8 @@ namespace MessageType {
 		AFFIRM_TRANSFER_REQUEST,
 		AFFIRM_TRANSFER_RESPONSE,
 
-		NEW_SESSION_ALERT
+		NEW_SESSION_ALERT,
+
+		REQUEST_SERVER_LIST
 	};
 }

dCommon/dEnums/ServiceType.h

@@ -5,7 +5,8 @@ enum class ServiceType : uint16_t {
 	COMMON = 0,
 	AUTH,
 	CHAT,
-	WORLD = 4,
+	DASHBOARD,
+	WORLD,
 	CLIENT,
 	MASTER,
 	UNKNOWN

dDashboardServer/CMakeLists.txt

@@ -0,0 +1,58 @@
+set(DDASHBOARDSERVER_SOURCES
+	"DashboardServer.cpp"
+)
+
+add_subdirectory(routes)
+add_subdirectory(auth)
+
+add_executable(DashboardServer ${DDASHBOARDSERVER_SOURCES})
+
+target_include_directories(DashboardServer PRIVATE
+	"${PROJECT_SOURCE_DIR}/dCommon"
+	"${PROJECT_SOURCE_DIR}/dCommon/dClient"
+	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
+	"${PROJECT_SOURCE_DIR}/dDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/MySQL"
+	"${PROJECT_SOURCE_DIR}/dNet"
+	"${PROJECT_SOURCE_DIR}/dWeb"
+	"${PROJECT_SOURCE_DIR}/dServer"
+	"${PROJECT_SOURCE_DIR}/thirdparty"
+	"${PROJECT_SOURCE_DIR}/thirdparty/nlohmann"
+	"${PROJECT_SOURCE_DIR}/dDashboardServer"
+	"${PROJECT_SOURCE_DIR}/dDashboardServer/auth"
+	"${PROJECT_SOURCE_DIR}/dDashboardServer/routes"
+)
+
+target_link_libraries(DashboardServer ${COMMON_LIBRARIES} dWeb dServer bcrypt OpenSSL::Crypto DashboardRoutes DashboardAuth)
+
+
+# Copy static files and templates to build directory (always copy)
+add_custom_command(TARGET DashboardServer POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E remove_directory
+	${CMAKE_BINARY_DIR}/dDashboardServer/static
+	COMMENT "Removing old static files"
+)
+
+add_custom_command(TARGET DashboardServer POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_directory
+	${CMAKE_CURRENT_SOURCE_DIR}/static
+	${CMAKE_BINARY_DIR}/dDashboardServer/static
+	COMMENT "Copying DashboardServer static files"
+)
+
+add_custom_command(TARGET DashboardServer POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E remove_directory
+	${CMAKE_BINARY_DIR}/dDashboardServer/templates
+	COMMENT "Removing old templates"
+)
+
+add_custom_command(TARGET DashboardServer POST_BUILD
+	COMMAND ${CMAKE_COMMAND} -E copy_directory
+	${CMAKE_CURRENT_SOURCE_DIR}/templates
+	${CMAKE_BINARY_DIR}/dDashboardServer/templates
+	COMMENT "Copying DashboardServer templates"
+)

dDashboardServer/DashboardServer.cpp

@@ -0,0 +1,203 @@
+#include <chrono>
+#include <cstdlib>
+#include <iostream>
+#include <thread>
+#include <csignal>
+#include <memory>
+
+#include "CDClientDatabase.h"
+#include "CDClientManager.h"
+#include "Database.h"
+#include "dConfig.h"
+#include "Logger.h"
+#include "dServer.h"
+#include "AssetManager.h"
+#include "BinaryPathFinder.h"
+#include "ServiceType.h"
+#include "MessageType/Master.h"
+#include "Game.h"
+#include "BitStreamUtils.h"
+#include "Diagnostics.h"
+#include "Web.h"
+#include "Server.h"
+
+#include "ServerState.h"
+#include "APIRoutes.h"
+#include "StaticRoutes.h"
+#include "DashboardRoutes.h"
+#include "WSRoutes.h"
+#include "AuthRoutes.h"
+#include "AuthMiddleware.h"
+
+namespace Game {
+	Logger* logger = nullptr;
+	dServer* server = nullptr;
+	dConfig* config = nullptr;
+	Game::signal_t lastSignal = 0;
+	std::mt19937 randomEngine;
+}
+
+// Define global server state
+namespace ServerState {
+	ServerStatus g_AuthStatus{};
+	ServerStatus g_ChatStatus{};
+	std::vector<WorldInstanceInfo> g_WorldInstances{};
+	std::mutex g_StatusMutex{};
+}
+
+namespace {
+	dServer* g_Server = nullptr;
+	bool g_RequestedServerList = false;
+}
+
+int main(int argc, char** argv) {
+	Diagnostics::SetProduceMemoryDump(true);
+	std::signal(SIGINT, Game::OnSignal);
+	std::signal(SIGTERM, Game::OnSignal);
+
+	uint32_t maxClients = 999;
+	uint32_t ourPort = 2006;
+	std::string ourIP = "127.0.0.1";
+
+	// Read config
+	Game::config = new dConfig("dashboardconfig.ini");
+
+	// Setup logger
+	Server::SetupLogger("DashboardServer");
+	if (!Game::logger) return EXIT_FAILURE;
+	Game::config->LogSettings();
+
+	LOG("Starting Dashboard Server");
+
+	// Load settings
+	if (Game::config->GetValue("max_clients") != "") 
+		maxClients = std::stoi(Game::config->GetValue("max_clients"));
+	
+	if (Game::config->GetValue("port") != "") 
+		ourPort = std::atoi(Game::config->GetValue("port").c_str());
+	
+	if (Game::config->GetValue("listen_ip") != "") 
+		ourIP = Game::config->GetValue("listen_ip");
+
+	// Connect to CDClient database
+	try {
+		const std::string cdclientPath = BinaryPathFinder::GetBinaryDir() / "resServer/CDServer.sqlite";
+		CDClientDatabase::Connect(cdclientPath);
+	} catch (std::exception& ex) {
+		LOG("Failed to connect to CDClient database: %s", ex.what());
+		return EXIT_FAILURE;
+	}
+
+	// Connect to the database
+	try {
+		Database::Connect();
+	} catch (std::exception& ex) {
+		LOG("Failed to connect to the database: %s", ex.what());
+		return EXIT_FAILURE;
+	}
+
+	// Get master info from database
+	std::string masterIP = "localhost";
+	uint32_t masterPort = 1000;
+	std::string masterPassword;
+	auto masterInfo = Database::Get()->GetMasterInfo();
+	if (masterInfo) {
+		masterIP = masterInfo->ip;
+		masterPort = masterInfo->port;
+		masterPassword = masterInfo->password;
+	}
+
+	// Setup network server for communicating with Master
+	g_Server = new dServer(
+		masterIP,
+		ourPort,
+		0,
+		maxClients,
+		false,
+		false,
+		Game::logger,
+		masterIP,
+		masterPort,
+		ServiceType::DASHBOARD, // Connect as dashboard to master
+		Game::config,
+		&Game::lastSignal,
+		masterPassword
+	);
+
+	// Initialize web server
+	if (!Game::web.Startup(ourIP, ourPort)) {
+		LOG("Failed to start web server on %s:%d", ourIP.c_str(), ourPort);
+		return EXIT_FAILURE;
+	}
+
+	// Register global middleware
+	Game::web.AddGlobalMiddleware(std::make_shared<AuthMiddleware>());
+
+	// Register routes in order: API, Static, Auth, WebSocket, Dashboard (dashboard MUST be last)
+	RegisterAPIRoutes();
+	RegisterStaticRoutes();
+	RegisterAuthRoutes();
+	RegisterWSRoutes();
+	RegisterDashboardRoutes(); // Must be last - catches all unmatched routes
+
+	LOG("Dashboard Server started successfully on %s:%d", ourIP.c_str(), ourPort);
+	LOG("Connected to Master Server at %s:%d", masterIP.c_str(), masterPort);
+
+	// Main loop
+	auto lastTime = std::chrono::high_resolution_clock::now();
+	auto lastBroadcast = lastTime;
+	auto currentTime = lastTime;
+	constexpr float deltaTime = 1.0f / 60.0f; // 60 FPS
+	constexpr float broadcastInterval = 2000.0f; // Broadcast every 2 seconds
+
+	while (!Game::ShouldShutdown()) {
+		currentTime = std::chrono::high_resolution_clock::now();
+		const auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - lastTime).count();
+		const auto elapsedSinceBroadcast = std::chrono::duration_cast<std::chrono::milliseconds>(currentTime - lastBroadcast).count();
+
+		if (elapsed >= 1000.0f / 60.0f) {
+			// // Handle master server packets
+			// Packet* packet = g_Server->ReceiveFromMaster();
+			// if (packet) {
+			// 	RakNet::BitStream bitStream(packet->data, packet->length, false);
+			// 	PacketHandler::HandlePacket(bitStream, packet->systemAddress);
+			// 	g_Server->DeallocateMasterPacket(packet);
+			// }
+
+			// // Handle RakNet protocol packets from connected servers
+			// packet = g_Server->Receive();
+			// while (packet) {
+			// 	RakNet::BitStream bitStream(packet->data, packet->length, false);
+			// 	PacketHandler::HandlePacket(bitStream, packet->systemAddress);
+			// 	g_Server->DeallocatePacket(packet);
+			// 	packet = g_Server->Receive();
+			// }
+
+			// Handle web requests
+			Game::web.ReceiveRequests();
+
+			// Broadcast dashboard updates periodically
+			if (elapsedSinceBroadcast >= broadcastInterval) {
+				BroadcastDashboardUpdate();
+				lastBroadcast = currentTime;
+			}
+
+			lastTime = currentTime;
+		}
+
+		std::this_thread::sleep_for(std::chrono::milliseconds(1));
+	}
+
+	// Cleanup
+	Database::Destroy("DashboardServer");
+	delete g_Server;
+	g_Server = nullptr;
+	delete Game::logger;
+	Game::logger = nullptr;
+	delete Game::config;
+	Game::config = nullptr;
+
+	return EXIT_SUCCESS;
+}
+
+

dDashboardServer/auth/AuthMiddleware.cpp

@@ -0,0 +1,132 @@
+#include "AuthMiddleware.h"
+#include "DashboardAuthService.h"
+#include "Game.h"
+#include "Logger.h"
+#include <string>
+#include <cctype>
+
+// Helper to extract cookie value from header
+static std::string ExtractCookieValue(const std::string& cookieHeader, const std::string& cookieName) {
+	std::string searchStr = cookieName + "=";
+	size_t pos = cookieHeader.find(searchStr);
+	
+	if (pos == std::string::npos) {
+		return "";
+	}
+	
+	size_t valueStart = pos + searchStr.length();
+	size_t valueEnd = cookieHeader.find(";", valueStart);
+	
+	if (valueEnd == std::string::npos) {
+		valueEnd = cookieHeader.length();
+	}
+	
+	std::string value = cookieHeader.substr(valueStart, valueEnd - valueStart);
+	
+	// URL decode the value
+	std::string decoded;
+	for (size_t i = 0; i < value.length(); ++i) {
+		if (value[i] == '%' && i + 2 < value.length()) {
+			std::string hex = value.substr(i + 1, 2);
+			char* endptr;
+			int charCode = static_cast<int>(std::strtol(hex.c_str(), &endptr, 16));
+			if (endptr - hex.c_str() == 2) {
+				decoded += static_cast<char>(charCode);
+				i += 2;
+				continue;
+			}
+		}
+		decoded += value[i];
+	}
+	
+	return decoded;
+}
+
+std::string AuthMiddleware::ExtractTokenFromQueryString(const std::string& queryString) {
+	if (queryString.empty()) {
+		return "";
+	}
+
+	// Parse query string to find token parameter
+	// Expected format: "?token=eyJhbGc..."
+	std::string tokenPrefix = "token=";
+	size_t tokenPos = queryString.find(tokenPrefix);
+	
+	if (tokenPos == std::string::npos) {
+		return "";
+	}
+
+	// Extract token value (from "token=" to next "&" or end of string)
+	size_t valueStart = tokenPos + tokenPrefix.length();
+	size_t valueEnd = queryString.find("&", valueStart);
+	
+	if (valueEnd == std::string::npos) {
+		valueEnd = queryString.length();
+	}
+
+	return queryString.substr(valueStart, valueEnd - valueStart);
+}
+
+std::string AuthMiddleware::ExtractTokenFromCookies(const std::string& cookieHeader) {
+	if (cookieHeader.empty()) {
+		return "";
+	}
+
+	// Extract dashboardToken cookie value
+	return ExtractCookieValue(cookieHeader, "dashboardToken");
+}
+
+std::string AuthMiddleware::ExtractTokenFromAuthHeader(const std::string& authHeader) {
+	if (authHeader.empty()) {
+		return "";
+	}
+
+	// Check for "Bearer <token>" format
+	if (authHeader.substr(0, 7) == "Bearer ") {
+		return authHeader.substr(7);
+	}
+
+	// Check for "Token <token>" format
+	if (authHeader.substr(0, 6) == "Token ") {
+		return authHeader.substr(6);
+	}
+
+	// If no prefix, assume raw token
+	return authHeader;
+}
+
+bool AuthMiddleware::Process(HTTPContext& context, HTTPReply& reply) {
+	// Try to extract token from various sources (in priority order)
+	std::string token = ExtractTokenFromQueryString(context.queryString);
+	
+	if (token.empty()) {
+		const std::string& cookieHeader = context.GetHeader("Cookie");
+		token = ExtractTokenFromCookies(cookieHeader);
+	}
+	
+	if (token.empty()) {
+		const std::string& authHeader = context.GetHeader("Authorization");
+		token = ExtractTokenFromAuthHeader(authHeader);
+	}
+
+	// If we found a token, try to verify it
+	if (!token.empty()) {
+		std::string username;
+		uint8_t gmLevel{};
+		
+		if (DashboardAuthService::VerifyToken(token, username, gmLevel)) {
+			context.isAuthenticated = true;
+			context.authenticatedUser = username;
+			context.gmLevel = gmLevel;
+			LOG_DEBUG("User %s authenticated via API token (GM level %d)", username.c_str(), gmLevel);
+			return true;
+		} else {
+			LOG_DEBUG("Invalid authentication token provided");
+			return true;  // Continue - let routes decide if auth is required
+		}
+	}
+
+	// No token found - continue without authentication
+	// Routes can use RequireAuthMiddleware to enforce authentication
+	return true;
+}

dDashboardServer/auth/AuthMiddleware.h

@@ -0,0 +1,34 @@
+#ifndef __AUTHMIDDLEWARE_H__
+#define __AUTHMIDDLEWARE_H__
+
+#include <string>
+#include <memory>
+#include "IHTTPMiddleware.h"
+
+/**
+ * AuthMiddleware: Extracts and verifies authentication tokens
+ * 
+ * Token extraction sources (in priority order):
+ * 1. Query parameter: ?token=eyJhbGc...
+ * 2. Cookie: dashboardToken=...
+ * 3. Authorization header: Bearer <token> or Token <token>
+ * 
+ * Sets HTTPContext.isAuthenticated, HTTPContext.authenticatedUser,
+ * and HTTPContext.gmLevel if token is valid.
+ */
+class AuthMiddleware final : public IHTTPMiddleware {
+public:
+	AuthMiddleware() = default;
+	~AuthMiddleware() override = default;
+
+	bool Process(HTTPContext& context, HTTPReply& reply) override;
+	std::string GetName() const override { return "AuthMiddleware"; }
+
+private:
+	// Extract token from various sources
+	static std::string ExtractTokenFromQueryString(const std::string& queryString);
+	static std::string ExtractTokenFromCookies(const std::string& cookieHeader);
+	static std::string ExtractTokenFromAuthHeader(const std::string& authHeader);
+};
+
+#endif // !__AUTHMIDDLEWARE_H__

dDashboardServer/auth/CMakeLists.txt

@@ -0,0 +1,28 @@
+set(DASHBOARDAUTH_SOURCES
+	"JWTUtils.cpp"
+	"DashboardAuthService.cpp"
+	"AuthMiddleware.cpp"
+	"RequireAuthMiddleware.cpp"
+)
+
+add_library(DashboardAuth STATIC ${DASHBOARDAUTH_SOURCES})
+
+target_include_directories(DashboardAuth PRIVATE
+	"${PROJECT_SOURCE_DIR}/dCommon"
+	"${PROJECT_SOURCE_DIR}/dCommon/dClient"
+	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
+	"${PROJECT_SOURCE_DIR}/dDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/MySQL"
+	"${PROJECT_SOURCE_DIR}/dNet"
+	"${PROJECT_SOURCE_DIR}/dWeb"
+	"${PROJECT_SOURCE_DIR}/dServer"
+	"${PROJECT_SOURCE_DIR}/thirdparty"
+	"${PROJECT_SOURCE_DIR}/thirdparty/nlohmann"
+	"${PROJECT_SOURCE_DIR}/dDashboardServer/auth"
+)
+
+target_link_libraries(DashboardAuth PRIVATE ${COMMON_LIBRARIES} dWeb dServer bcrypt OpenSSL::Crypto)

dDashboardServer/auth/DashboardAuthService.cpp

@@ -0,0 +1,144 @@
+#include "DashboardAuthService.h"
+#include "JWTUtils.h"
+#include "Database.h"
+#include "Logger.h"
+#include "Game.h"
+#include "dConfig.h"
+#include "GeneralUtils.h"
+#include <bcrypt/bcrypt.h>
+#include <ctime>
+
+namespace {
+	constexpr int64_t LOCKOUT_DURATION = 15 * 60; // 15 minutes in seconds
+
+}
+
+DashboardAuthService::LoginResult DashboardAuthService::Login(
+	const std::string& username, 
+	const std::string& password, 
+	bool rememberMe) {
+
+	LoginResult result;
+
+	if (username.empty() || password.empty()) {
+		result.message = "Username and password are required";
+		return result;
+	}
+
+	if (password.length() > 40) {
+		result.message = "Password exceeds maximum length (40 characters)";
+		return result;
+	}
+
+	try {
+		// Get account info
+		auto accountInfo = Database::Get()->GetAccountInfo(username);
+		if (!accountInfo) {
+			result.message = "Invalid username or password";
+			LOG_DEBUG("Login attempt for non-existent user: %s", username.c_str());
+			return result;
+		}
+
+		uint32_t accountId = accountInfo->id;
+
+		// Check if account is locked
+		bool isLockedOut = Database::Get()->IsLockedOut(accountId);
+
+		if (isLockedOut) {
+			// Record failed attempt even without checking password
+			Database::Get()->RecordFailedAttempt(accountId);
+			uint8_t failedAttempts = Database::Get()->GetFailedAttempts(accountId);
+			
+			result.message = "Account is locked due to too many failed attempts";
+			result.accountLocked = true;
+			LOG("Login attempt on locked account: %s (failed attempts: %d)", username.c_str(), failedAttempts);
+			return result;
+		}
+
+		// Check password
+		if (::bcrypt_checkpw(password.c_str(), accountInfo->bcryptPassword.c_str()) != 0) {
+			// Record failed attempt
+			Database::Get()->RecordFailedAttempt(accountId);
+			uint8_t newFailedAttempts = Database::Get()->GetFailedAttempts(accountId);
+
+			// Lock account after 3 failed attempts
+			if (newFailedAttempts >= 3) {
+				int64_t lockoutUntil = std::time(nullptr) + LOCKOUT_DURATION;
+				Database::Get()->SetLockout(accountId, lockoutUntil);
+				result.message = "Account locked due to too many failed attempts";
+				result.accountLocked = true;
+				LOG("Account locked after failed attempts: %s", username.c_str());
+			} else {
+				result.message = "Invalid username or password";
+				LOG_DEBUG("Failed login attempt for user: %s (attempt %d/3)", 
+					username.c_str(), newFailedAttempts);
+			}
+			return result;
+		}
+
+		// Check GM level
+		if (!HasDashboardAccess(static_cast<uint8_t>(accountInfo->maxGmLevel))) {
+			result.message = "Access denied: insufficient permissions";
+			LOG("Access denied for non-admin user: %s", username.c_str());
+			return result;
+		}
+
+		// Successful login
+		Database::Get()->ClearFailedAttempts(accountId);
+		result.success = true;
+		result.gmLevel = static_cast<uint8_t>(accountInfo->maxGmLevel);
+		result.token = JWTUtils::GenerateToken(username, result.gmLevel, rememberMe);
+		result.message = "Login successful";
+
+		LOG("Successful login: %s (GM Level: %d)", username.c_str(), result.gmLevel);
+		return result;
+
+	} catch (const std::exception& ex) {
+		result.message = "An error occurred during login";
+		LOG("Error during login process: %s", ex.what());
+		return result;
+	}
+}
+
+bool DashboardAuthService::VerifyToken(const std::string& token, std::string& username, uint8_t& gmLevel) {
+	JWTUtils::JWTPayload payload;
+	if (!JWTUtils::ValidateToken(token, payload)) {
+		LOG_DEBUG("Token validation failed: invalid or expired JWT");
+		return false;
+	}
+
+	username = payload.username;
+	gmLevel = payload.gmLevel;
+
+	// Optionally verify user still exists and has access
+	try {
+		auto accountInfo = Database::Get()->GetAccountInfo(username);
+		if (!accountInfo || !HasDashboardAccess(static_cast<uint8_t>(accountInfo->maxGmLevel))) {
+			LOG_DEBUG("Token verification failed: user no longer has access");
+			return false;
+		}
+	} catch (const std::exception& ex) {
+		LOG_DEBUG("Error verifying user during token validation: %s", ex.what());
+		return false;
+	}
+
+	LOG_DEBUG("Token verified successfully for user: %s (GM Level: %d)", username.c_str(), gmLevel);
+	return true;
+}
+
+bool DashboardAuthService::HasDashboardAccess(uint8_t gmLevel) {
+	// Get minimum GM level from config (default 0 = any user)
+	uint8_t minGmLevel = 0;
+	
+	if (Game::config) {
+		const std::string& minGmLevelStr = Game::config->GetValue("min_dashboard_gm_level");
+		if (!minGmLevelStr.empty()) {
+			const auto parsed = GeneralUtils::TryParse<uint8_t>(minGmLevelStr);
+			if (parsed) {
+				minGmLevel = parsed.value();
+			}
+		}
+	}
+	
+	return gmLevel >= minGmLevel;
+}

dDashboardServer/auth/DashboardAuthService.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <string>
+#include <cstdint>
+
+/**
+ * Dashboard authentication service
+ * Handles user login, password verification, and account lockout
+ */
+class DashboardAuthService {
+public:
+	/**
+	 * Login result structure
+	 */
+	struct LoginResult {
+		bool success{false};
+		std::string message{};
+		std::string token{}; // JWT token if successful
+		uint8_t gmLevel{0}; // GM level if successful
+		bool accountLocked{false}; // Account is locked out
+	};
+
+	/**
+	 * Attempt to log in with username and password
+	 * @param username The username
+	 * @param password The plaintext password (max 40 characters)
+	 * @param rememberMe If true, extends token expiration to 30 days
+	 * @return LoginResult with success status and JWT token if successful
+	 */
+	static LoginResult Login(const std::string& username, const std::string& password, bool rememberMe = false);
+
+	/**
+	 * Verify that a token is valid and get the username
+	 * @param token The JWT token
+	 * @param username Output parameter for the username
+	 * @param gmLevel Output parameter for the GM level
+	 * @return true if token is valid
+	 */
+	static bool VerifyToken(const std::string& token, std::string& username, uint8_t& gmLevel);
+
+	/**
+	 * Check if user has required GM level for dashboard access
+	 * @param gmLevel The user's GM level
+	 * @return true if user can access dashboard (GM level > 0)
+	 */
+	static bool HasDashboardAccess(uint8_t gmLevel);
+};

dDashboardServer/auth/JWTUtils.cpp

@@ -0,0 +1,186 @@
+#include "JWTUtils.h"
+#include "GeneralUtils.h"
+#include "Logger.h"
+#include "json.hpp"
+#include <ctime>
+#include <cstring>
+#include <openssl/hmac.h>
+#include <openssl/sha.h>
+
+namespace {
+	std::string g_Secret = "default-secret-change-me";
+
+	// Simple base64 encoding
+	std::string Base64Encode(const std::string& input) {
+		static const char* base64_chars = 
+			"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+		std::string ret;
+		int i = 0;
+		unsigned char char_array_3[3];
+		unsigned char char_array_4[4];
+
+		for (size_t n = 0; n < input.length(); n++) {
+			char_array_3[i++] = input[n];
+			if (i == 3) {
+				char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+				char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+				char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+				char_array_4[3] = char_array_3[2] & 0x3f;
+				for (i = 0; i < 4; i++) ret += base64_chars[char_array_4[i]];
+				i = 0;
+			}
+		}
+
+		if (i) {
+			for (int j = i; j < 3; j++) char_array_3[j] = '\0';
+			char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+			char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+			char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+			for (int j = 0; j <= i; j++) ret += base64_chars[char_array_4[j]];
+			while (i++ < 3) ret += '=';
+		}
+
+		return ret;
+	}
+
+	// Simple base64 decoding
+	std::string Base64Decode(const std::string& encoded_string) {
+		static const std::string base64_chars = 
+			"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+		int in_len = encoded_string.size();
+		int i = 0, j = 0, in_ = 0;
+		unsigned char char_array_4[4], char_array_3[3];
+		std::string ret;
+
+		while (in_len-- && (encoded_string[in_] != '=') && 
+			   (isalnum(encoded_string[in_]) || encoded_string[in_] == '+' || encoded_string[in_] == '/')) {
+			char_array_4[i++] = encoded_string[in_]; in_++;
+			if (i == 4) {
+				for (i = 0; i < 4; i++) char_array_4[i] = base64_chars.find(char_array_4[i]);
+				char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+				char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+				char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+				for (i = 0; i < 3; i++) ret += char_array_3[i];
+				i = 0;
+			}
+		}
+
+		if (i) {
+			for (j = i; j < 4; j++) char_array_4[j] = 0;
+			for (j = 0; j < 4; j++) char_array_4[j] = base64_chars.find(char_array_4[j]);
+			char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+			char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+			for (j = 0; j < i - 1; j++) ret += char_array_3[j];
+		}
+
+		return ret;
+	}
+
+	// HMAC-SHA256
+	std::string HmacSha256(const std::string& key, const std::string& message) {
+		unsigned char* digest = HMAC(EVP_sha256(), 
+			reinterpret_cast<const unsigned char*>(key.c_str()), key.length(),
+			reinterpret_cast<const unsigned char*>(message.c_str()), message.length(),
+			nullptr, nullptr);
+		
+		std::string result(reinterpret_cast<char*>(digest), SHA256_DIGEST_LENGTH);
+		return result;
+	}
+
+	// Create signature for JWT
+	std::string CreateSignature(const std::string& header, const std::string& payload, const std::string& secret) {
+		std::string message = header + "." + payload;
+		std::string signature = HmacSha256(secret, message);
+		return Base64Encode(signature);
+	}
+
+	// Verify JWT signature
+	bool VerifySignature(const std::string& header, const std::string& payload, const std::string& signature, const std::string& secret) {
+		std::string expected = CreateSignature(header, payload, secret);
+		return signature == expected;
+	}
+}
+
+namespace JWTUtils {
+	void SetSecretKey(const std::string& secret) {
+		if (secret.empty()) {
+			LOG("Warning: JWT secret key is empty, using default");
+			return;
+		}
+		g_Secret = secret;
+	}
+
+	std::string GenerateToken(const std::string& username, uint8_t gmLevel, bool rememberMe) {
+		// Header
+		std::string header = R"({"alg":"HS256","typ":"JWT"})";
+		std::string encodedHeader = Base64Encode(header);
+
+		// Payload
+		int64_t now = std::time(nullptr);
+		int64_t expiresAt = now + (rememberMe ? 30 * 24 * 60 * 60 : 24 * 60 * 60); // 30 days or 24 hours
+
+		std::string payload = R"({"username":")" + username + R"(","gmLevel":)" + std::to_string(gmLevel) + 
+			R"(,"rememberMe":)" + (rememberMe ? "true" : "false") +
+			R"(,"iat":)" + std::to_string(now) +
+			R"(,"exp":)" + std::to_string(expiresAt) + "}";
+		std::string encodedPayload = Base64Encode(payload);
+
+		// Signature
+		std::string signature = CreateSignature(encodedHeader, encodedPayload, g_Secret);
+
+		return encodedHeader + "." + encodedPayload + "." + signature;
+	}
+
+	bool ValidateToken(const std::string& token, JWTPayload& payload) {
+		// Split token into parts
+		size_t firstDot = token.find('.');
+		size_t secondDot = token.find('.', firstDot + 1);
+
+		if (firstDot == std::string::npos || secondDot == std::string::npos) {
+			LOG_DEBUG("Invalid JWT format");
+			return false;
+		}
+
+		std::string header = token.substr(0, firstDot);
+		std::string encodedPayload = token.substr(firstDot + 1, secondDot - firstDot - 1);
+		std::string signature = token.substr(secondDot + 1);
+
+		// Verify signature
+		if (!VerifySignature(header, encodedPayload, signature, g_Secret)) {
+			LOG_DEBUG("Invalid JWT signature");
+			return false;
+		}
+
+		// Decode and parse payload
+		std::string decodedPayload = Base64Decode(encodedPayload);
+		try {
+			auto json = nlohmann::json::parse(decodedPayload);
+			
+			payload.username = json.value("username", "");
+			payload.gmLevel = json.value("gmLevel", 0);
+			payload.rememberMe = json.value("rememberMe", false);
+			payload.issuedAt = json.value("iat", 0);
+			payload.expiresAt = json.value("exp", 0);
+
+			if (payload.username.empty()) {
+				LOG_DEBUG("JWT missing username");
+				return false;
+			}
+
+			// Check expiration
+			if (IsTokenExpired(payload.expiresAt)) {
+				LOG_DEBUG("JWT token expired");
+				return false;
+			}
+
+			return true;
+		} catch (const std::exception& ex) {
+			LOG_DEBUG("Error parsing JWT payload: %s", ex.what());
+			return false;
+		}
+	}
+
+	bool IsTokenExpired(int64_t expiresAt) {
+		return std::time(nullptr) > expiresAt;
+	}
+}

dDashboardServer/auth/JWTUtils.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <string>
+#include <ctime>
+#include "json_fwd.hpp"
+
+/**
+ * JWT Token utilities for dashboard authentication
+ * Provides secure token generation, validation, and parsing
+ */
+namespace JWTUtils {
+	/**
+	 * JWT payload structure
+	 */
+	struct JWTPayload {
+		std::string username{};
+		uint8_t gmLevel{0};
+		bool rememberMe{false};
+		int64_t issuedAt{0};
+		int64_t expiresAt{0};
+	};
+
+	/**
+	 * Generate a new JWT token
+	 * @param username The username to encode in the token
+	 * @param gmLevel The GM level of the user
+	 * @param rememberMe If true, extends token expiration to 30 days; otherwise 24 hours
+	 * @return Signed JWT token string
+	 */
+	std::string GenerateToken(const std::string& username, uint8_t gmLevel, bool rememberMe = false);
+
+	/**
+	 * Validate and decode a JWT token
+	 * @param token The JWT token to validate
+	 * @param payload Output parameter for the decoded payload
+	 * @return true if token is valid and not expired, false otherwise
+	 */
+	bool ValidateToken(const std::string& token, JWTPayload& payload);
+
+	/**
+	 * Check if a token is expired
+	 * @param expiresAt Expiration timestamp
+	 * @return true if token is expired
+	 */
+	bool IsTokenExpired(int64_t expiresAt);
+
+	/**
+	 * Set the JWT secret key (must be called once at startup)
+	 * @param secret The secret key for signing tokens
+	 */
+	void SetSecretKey(const std::string& secret);
+}

dDashboardServer/auth/RequireAuthMiddleware.cpp

@@ -0,0 +1,35 @@
+#include "RequireAuthMiddleware.h"
+#include "HTTPContext.h"
+#include "Web.h"
+#include "Game.h"
+#include "Logger.h"
+
+RequireAuthMiddleware::RequireAuthMiddleware(uint8_t minGmLevel) : minGmLevel(minGmLevel) {}
+
+bool RequireAuthMiddleware::Process(HTTPContext& context, HTTPReply& reply) {
+	// Check if user is authenticated
+	if (!context.isAuthenticated) {
+		LOG_DEBUG("Unauthorized access attempt to %s from %s", context.path.c_str(), context.clientIP.c_str());
+		reply.status = eHTTPStatusCode::FOUND;
+		reply.message = "";
+		reply.location = "/login";
+		reply.contentType = eContentType::TEXT_HTML;
+		return false;  // Stop middleware chain and send reply
+	}
+
+	// Check if user has required GM level
+	if (context.gmLevel < minGmLevel) {
+		LOG_DEBUG("Forbidden access attempt by user %s (GM level %d < %d required) to %s from %s",
+			context.authenticatedUser.c_str(), context.gmLevel, minGmLevel, 
+			context.path.c_str(), context.clientIP.c_str());
+		reply.status = eHTTPStatusCode::FORBIDDEN;
+		reply.message = "{\"error\":\"Forbidden - Insufficient permissions\"}";
+		reply.contentType = eContentType::APPLICATION_JSON;
+		return false;  // Stop middleware chain and send reply
+	}
+
+	// Authentication passed
+	LOG_DEBUG("User %s authenticated with GM level %d accessing %s",
+		context.authenticatedUser.c_str(), context.gmLevel, context.path.c_str());
+	return true;  // Continue to next middleware or route handler
+}

dDashboardServer/auth/RequireAuthMiddleware.h

@@ -0,0 +1,30 @@
+#ifndef __REQUIREAUTHMIDDLEWARE_H__
+#define __REQUIREAUTHMIDDLEWARE_H__
+
+#include <memory>
+#include <cstdint>
+#include "IHTTPMiddleware.h"
+
+/**
+ * RequireAuthMiddleware: Enforces authentication on protected routes
+ * 
+ * Returns 401 Unauthorized if user is not authenticated
+ * Returns 403 Forbidden if user's GM level is below minimum required
+ */
+class RequireAuthMiddleware final : public IHTTPMiddleware {
+public:
+	/**
+	 * @param minGmLevel Minimum GM level required to access this route
+	 *                   0 = any authenticated user, higher numbers = GM-only
+	 */
+	explicit RequireAuthMiddleware(uint8_t minGmLevel = 0);
+	~RequireAuthMiddleware() override = default;
+
+	bool Process(HTTPContext& context, HTTPReply& reply) override;
+	std::string GetName() const override { return "RequireAuthMiddleware"; }
+
+private:
+	uint8_t minGmLevel;
+};
+
+#endif // !__REQUIREAUTHMIDDLEWARE_H__

dDashboardServer/routes/APIRoutes.cpp

@@ -0,0 +1,443 @@
+#include "APIRoutes.h"
+#include "ServerState.h"
+#include "Web.h"
+#include "eHTTPMethod.h"
+#include "json.hpp"
+#include "Game.h"
+#include "Database.h"
+#include "Logger.h"
+#include "HTTPContext.h"
+#include "RequireAuthMiddleware.h"
+#include <memory>
+
+void RegisterAPIRoutes() {
+	// GET /api/status - Get overall server status
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/status",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			nlohmann::json response = ServerState::GetServerStateJson();
+			
+			reply.status = eHTTPStatusCode::OK;
+			reply.message = response.dump();
+			reply.contentType = eContentType::APPLICATION_JSON;
+		}
+	});
+
+	// GET /api/players - Get list of online players
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/players",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			nlohmann::json response = {
+				{"players", nlohmann::json::array()},
+				{"count", 0}
+			};
+			
+			reply.status = eHTTPStatusCode::OK;
+			reply.message = response.dump();
+			reply.contentType = eContentType::APPLICATION_JSON;
+		}
+	});
+
+	// GET /api/accounts/count - Get total account count
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/accounts/count",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				const uint32_t count = Database::Get()->GetAccountCount();
+				nlohmann::json response = {{"count", count}};
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/accounts/count: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /api/characters/count - Get total character count
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/characters/count",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				const uint32_t count = Database::Get()->GetCharacterCount();
+				nlohmann::json response = {{"count", count}};
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/characters/count: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// POST /api/tables/accounts - Get accounts table data (DataTables.js format)
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/tables/accounts",
+		.method = eHTTPMethod::POST,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Only admins (GM > 0) can access table data
+				if (context.gmLevel == 0) {
+					reply.status = eHTTPStatusCode::FORBIDDEN;
+					reply.message = "{\"error\":\"Forbidden - Admin access required\"}"; 
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+
+				nlohmann::json requestData = nlohmann::json::parse(context.body);
+
+				// Extract DataTables parameters
+				uint32_t draw = requestData.value("draw", 1);
+				uint32_t start = requestData.value("start", 0);
+				uint32_t length = requestData.value("length", 10);
+				
+				// Extract search - it can be a string or an object with a "value" property
+				std::string search = "";
+				if (requestData.contains("search")) {
+					if (requestData["search"].is_string()) {
+						search = requestData["search"].get<std::string>();
+					} else if (requestData["search"].is_object() && requestData["search"].contains("value")) {
+						search = requestData["search"]["value"].get<std::string>();
+					}
+				}
+				
+				uint32_t orderColumn = 0;
+				bool orderAsc = true;
+
+				// Extract order parameters
+				if (requestData.contains("order") && requestData["order"].is_array() && requestData["order"].size() > 0) {
+					orderColumn = requestData["order"][0].value("column", 0);
+					orderAsc = requestData["order"][0].value("dir", "asc") == "asc";
+				}
+
+				// Get the accounts table data
+			nlohmann::json response = Database::Get()->GetAccountsTable(start, length, search, orderColumn, orderAsc);
+
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const nlohmann::json::exception& jsonEx) {
+				LOG("JSON error in /api/tables/accounts: %s", jsonEx.what());
+				reply.status = eHTTPStatusCode::BAD_REQUEST;
+				reply.message = "{\"error\":\"Invalid JSON\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/tables/accounts: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// POST /api/tables/characters - Get characters table data (DataTables.js format)
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/tables/characters",
+		.method = eHTTPMethod::POST,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Only admins (GM > 0) can access table data
+				if (context.gmLevel == 0) {
+					reply.status = eHTTPStatusCode::FORBIDDEN;
+					reply.message = "{\"error\":\"Forbidden - Admin access required\"}";
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+
+				nlohmann::json requestData = nlohmann::json::parse(context.body);
+
+				uint32_t draw = requestData.value("draw", 1);
+				uint32_t start = requestData.value("start", 0);
+				uint32_t length = requestData.value("length", 10);
+				
+				std::string search = "";
+				if (requestData.contains("search")) {
+					if (requestData["search"].is_string()) {
+						search = requestData["search"].get<std::string>();
+					} else if (requestData["search"].is_object() && requestData["search"].contains("value")) {
+						search = requestData["search"]["value"].get<std::string>();
+					}
+				}
+				
+				uint32_t orderColumn = 0;
+				bool orderAsc = true;
+
+				if (requestData.contains("order") && requestData["order"].is_array() && requestData["order"].size() > 0) {
+					orderColumn = requestData["order"][0].value("column", 0);
+					orderAsc = requestData["order"][0].value("dir", "asc") == "asc";
+				}
+
+				std::string tableData = Database::Get()->GetCharactersTable(start, length, search, orderColumn, orderAsc);
+
+				nlohmann::json response = nlohmann::json::parse(tableData);
+				response["draw"] = draw;
+
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const nlohmann::json::exception& jsonEx) {
+				LOG("JSON error in /api/tables/characters: %s", jsonEx.what());
+				reply.status = eHTTPStatusCode::BAD_REQUEST;
+				reply.message = "{\"error\":\"Invalid JSON\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/tables/characters: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// POST /api/tables/play_keys - Get play keys table data (DataTables.js format)
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/tables/play_keys",
+		.method = eHTTPMethod::POST,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {				// Only admins (GM > 0) can access table data
+				if (context.gmLevel == 0) {
+					reply.status = eHTTPStatusCode::FORBIDDEN;
+					reply.message = "{\"error\":\"Forbidden - Admin access required\"}";
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+				nlohmann::json requestData = nlohmann::json::parse(context.body);
+
+				uint32_t draw = requestData.value("draw", 1);
+				uint32_t start = requestData.value("start", 0);
+				uint32_t length = requestData.value("length", 10);
+				
+				std::string search = "";
+				if (requestData.contains("search")) {
+					if (requestData["search"].is_string()) {
+						search = requestData["search"].get<std::string>();
+					} else if (requestData["search"].is_object() && requestData["search"].contains("value")) {
+						search = requestData["search"]["value"].get<std::string>();
+					}
+				}
+				
+				uint32_t orderColumn = 0;
+				bool orderAsc = true;
+
+				if (requestData.contains("order") && requestData["order"].is_array() && requestData["order"].size() > 0) {
+					orderColumn = requestData["order"][0].value("column", 0);
+					orderAsc = requestData["order"][0].value("dir", "asc") == "asc";
+				}
+
+				std::string tableData = Database::Get()->GetPlayKeysTable(start, length, search, orderColumn, orderAsc);
+
+				nlohmann::json response = nlohmann::json::parse(tableData);
+				response["draw"] = draw;
+
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const nlohmann::json::exception& jsonEx) {
+				LOG("JSON error in /api/tables/play_keys: %s", jsonEx.what());
+				reply.status = eHTTPStatusCode::BAD_REQUEST;
+				reply.message = "{\"error\":\"Invalid JSON\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/tables/play_keys: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// POST /api/tables/properties - Get properties table data (DataTables.js format)
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/tables/properties",
+		.method = eHTTPMethod::POST,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Only admins (GM > 0) can access table data
+				if (context.gmLevel == 0) {
+					reply.status = eHTTPStatusCode::FORBIDDEN;
+					reply.message = "{\"error\":\"Forbidden - Admin access required\"}";
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+
+				nlohmann::json requestData = nlohmann::json::parse(context.body);
+
+				uint32_t draw = requestData.value("draw", 1);
+				uint32_t start = requestData.value("start", 0);
+				uint32_t length = requestData.value("length", 10);
+				
+				std::string search = "";
+				if (requestData.contains("search")) {
+					if (requestData["search"].is_string()) {
+						search = requestData["search"].get<std::string>();
+					} else if (requestData["search"].is_object() && requestData["search"].contains("value")) {
+						search = requestData["search"]["value"].get<std::string>();
+					}
+				}
+				
+				uint32_t orderColumn = 0;
+				bool orderAsc = true;
+
+				if (requestData.contains("order") && requestData["order"].is_array() && requestData["order"].size() > 0) {
+					orderColumn = requestData["order"][0].value("column", 0);
+					orderAsc = requestData["order"][0].value("dir", "asc") == "asc";
+				}
+
+				std::string tableData = Database::Get()->GetPropertiesTable(start, length, search, orderColumn, orderAsc);
+
+				nlohmann::json response = nlohmann::json::parse(tableData);
+				response["draw"] = draw;
+
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const nlohmann::json::exception& jsonEx) {
+				LOG("JSON error in /api/tables/properties: %s", jsonEx.what());
+				reply.status = eHTTPStatusCode::BAD_REQUEST;
+				reply.message = "{\"error\":\"Invalid JSON\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/tables/properties: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// POST /api/tables/bug_reports - Get bug reports table data (DataTables.js format)
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/tables/bug_reports",
+		.method = eHTTPMethod::POST,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {				// Only admins (GM > 0) can access table data
+				if (context.gmLevel == 0) {
+					reply.status = eHTTPStatusCode::FORBIDDEN;
+					reply.message = "{\"error\":\"Forbidden - Admin access required\"}";
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+				nlohmann::json requestData = nlohmann::json::parse(context.body);
+
+				uint32_t draw = requestData.value("draw", 1);
+				uint32_t start = requestData.value("start", 0);
+				uint32_t length = requestData.value("length", 10);
+				
+				std::string search = "";
+				if (requestData.contains("search")) {
+					if (requestData["search"].is_string()) {
+						search = requestData["search"].get<std::string>();
+					} else if (requestData["search"].is_object() && requestData["search"].contains("value")) {
+						search = requestData["search"]["value"].get<std::string>();
+					}
+				}
+				
+				uint32_t orderColumn = 0;
+				bool orderAsc = true;
+
+				if (requestData.contains("order") && requestData["order"].is_array() && requestData["order"].size() > 0) {
+					orderColumn = requestData["order"][0].value("column", 0);
+					orderAsc = requestData["order"][0].value("dir", "asc") == "asc";
+				}
+
+				std::string tableData = Database::Get()->GetBugReportsTable(start, length, search, orderColumn, orderAsc);
+
+				nlohmann::json response = nlohmann::json::parse(tableData);
+				response["draw"] = draw;
+
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const nlohmann::json::exception& jsonEx) {
+				LOG("JSON error in /api/tables/bug_reports: %s", jsonEx.what());
+				reply.status = eHTTPStatusCode::BAD_REQUEST;
+				reply.message = "{\"error\":\"Invalid JSON\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/tables/bug_reports: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /api/accounts/:id - Get single account by ID
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/accounts/:id",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Extract account ID from URL path
+				const std::string path = context.path;
+				size_t lastSlash = path.rfind('/');
+				if (lastSlash == std::string::npos) {
+					reply.status = eHTTPStatusCode::BAD_REQUEST;
+					reply.message = "{\"error\":\"Invalid account ID\"}";
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+
+				std::string idStr = path.substr(lastSlash + 1);
+				uint32_t accountId = 0;
+				try {
+					accountId = std::stoul(idStr);
+				} catch (...) {
+					reply.status = eHTTPStatusCode::BAD_REQUEST;
+					reply.message = "{\"error\":\"Invalid account ID\"}";
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+
+				// Permission check: GM 0 can only view own account, GM > 0 can view any account
+				if (context.gmLevel == 0) {
+					// Regular user - get their own account ID
+					auto currentUserInfo = Database::Get()->GetAccountInfo(context.authenticatedUser);
+					if (!currentUserInfo.has_value() || currentUserInfo->id != accountId) {
+						reply.status = eHTTPStatusCode::FORBIDDEN;
+						reply.message = "{\"error\":\"Forbidden - You do not have permission to view this account\"}";
+						reply.contentType = eContentType::APPLICATION_JSON;
+						return;
+					}
+				}
+
+				// Get account data
+			nlohmann::json response = Database::Get()->GetAccountById(accountId);
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = response.dump();
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const nlohmann::json::exception& jsonEx) {
+				LOG("JSON error in /api/accounts/:id: %s", jsonEx.what());
+				reply.status = eHTTPStatusCode::BAD_REQUEST;
+				reply.message = "{\"error\":\"Invalid JSON\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (std::exception& ex) {
+				LOG("Error in /api/accounts/:id: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Database error\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+}
+

dDashboardServer/routes/APIRoutes.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void RegisterAPIRoutes();

dDashboardServer/routes/AuthRoutes.cpp

@@ -0,0 +1,102 @@
+#include "AuthRoutes.h"
+#include "DashboardAuthService.h"
+#include "json.hpp"
+#include "Logger.h"
+#include "GeneralUtils.h"
+#include "Web.h"
+#include "eHTTPMethod.h"
+#include "HTTPContext.h"
+
+void RegisterAuthRoutes() {
+	// POST /api/auth/login
+	// Request body: { "username": "string", "password": "string", "rememberMe": boolean }
+	// Response: { "success": boolean, "message": "string", "token": "string", "gmLevel": number }
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/auth/login",
+		.method = eHTTPMethod::POST,
+		.middleware = {},
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				auto json = nlohmann::json::parse(context.body);
+				std::string username = json.value("username", "");
+				std::string password = json.value("password", "");
+				bool rememberMe = json.value("rememberMe", false);
+
+				// Validate input
+				if (username.empty() || password.empty()) {
+					reply.message = R"({"success":false,"message":"Username and password are required"})";
+					reply.status = eHTTPStatusCode::BAD_REQUEST;
+					return;
+				}
+
+				if (password.length() > 40) {
+					reply.message = R"({"success":false,"message":"Password exceeds maximum length"})";
+					reply.status = eHTTPStatusCode::BAD_REQUEST;
+					return;
+				}
+
+				// Attempt login
+				auto result = DashboardAuthService::Login(username, password, rememberMe);
+
+				nlohmann::json response;
+				response["success"] = result.success;
+				response["message"] = result.message;
+				if (result.success) {
+					response["token"] = result.token;
+					response["gmLevel"] = result.gmLevel;
+				}
+
+				reply.message = response.dump();
+				reply.status = result.success ? eHTTPStatusCode::OK : eHTTPStatusCode::UNAUTHORIZED;
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const std::exception& ex) {
+				LOG("Error processing login request: %s", ex.what());
+				reply.message = R"({"success":false,"message":"Internal server error"})";
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// POST /api/auth/verify
+	// Request body: { "token": "string" }
+	// Response: { "valid": boolean, "username": "string", "gmLevel": number }
+	Game::web.RegisterHTTPRoute({
+		.path = "/api/auth/verify",
+		.method = eHTTPMethod::POST,
+		.middleware = {},
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				auto json = nlohmann::json::parse(context.body);
+				std::string token = json.value("token", "");
+
+				if (token.empty()) {
+					reply.message = R"({"valid":false})";
+					reply.status = eHTTPStatusCode::BAD_REQUEST;
+					reply.contentType = eContentType::APPLICATION_JSON;
+					return;
+				}
+
+				std::string username;
+				uint8_t gmLevel{};
+				bool valid = DashboardAuthService::VerifyToken(token, username, gmLevel);
+
+				nlohmann::json response;
+				response["valid"] = valid;
+				if (valid) {
+					response["username"] = username;
+					response["gmLevel"] = gmLevel;
+				}
+
+				reply.message = response.dump();
+				reply.status = eHTTPStatusCode::OK;
+				reply.contentType = eContentType::APPLICATION_JSON;
+			} catch (const std::exception& ex) {
+				LOG("Error processing verify request: %s", ex.what());
+				reply.message = R"({"valid":false})";
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+}

dDashboardServer/routes/AuthRoutes.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "Web.h"
+
+/**
+ * Register authentication routes
+ * /api/auth/login - POST login endpoint
+ * /api/auth/verify - POST verify token endpoint
+ */
+void RegisterAuthRoutes();

dDashboardServer/routes/CMakeLists.txt

@@ -0,0 +1,30 @@
+set(DASHBOARDROUTES_SOURCES
+	"APIRoutes.cpp"
+	"StaticRoutes.cpp"
+	"DashboardRoutes.cpp"
+	"WSRoutes.cpp"
+	"AuthRoutes.cpp"
+)
+
+add_library(DashboardRoutes STATIC ${DASHBOARDROUTES_SOURCES})
+
+target_include_directories(DashboardRoutes PRIVATE
+	"${PROJECT_SOURCE_DIR}/dCommon"
+	"${PROJECT_SOURCE_DIR}/dCommon/dClient"
+	"${PROJECT_SOURCE_DIR}/dCommon/dEnums"
+	"${PROJECT_SOURCE_DIR}/dDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/CDClientDatabase/CDClientTables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/ITables"
+	"${PROJECT_SOURCE_DIR}/dDatabase/GameDatabase/MySQL"
+	"${PROJECT_SOURCE_DIR}/dNet"
+	"${PROJECT_SOURCE_DIR}/dWeb"
+	"${PROJECT_SOURCE_DIR}/dServer"
+	"${PROJECT_SOURCE_DIR}/thirdparty"
+	"${PROJECT_SOURCE_DIR}/thirdparty/nlohmann"
+	"${PROJECT_SOURCE_DIR}/dDashboardServer/auth"
+	"${PROJECT_SOURCE_DIR}/dDashboardServer/routes"
+)
+
+target_link_libraries(DashboardRoutes PRIVATE ${COMMON_LIBRARIES} dWeb dServer)

dDashboardServer/routes/DashboardRoutes.cpp

@@ -0,0 +1,291 @@
+#include "DashboardRoutes.h"
+#include "ServerState.h"
+#include "Web.h"
+#include "HTTPContext.h"
+#include "eHTTPMethod.h"
+#include "json.hpp"
+#include "Game.h"
+#include "Database.h"
+#include "Logger.h"
+#include "inja.hpp"
+#include "AuthMiddleware.h"
+#include "RequireAuthMiddleware.h"
+
+void RegisterDashboardRoutes() {
+	// GET / - Main dashboard page (requires authentication)
+	Game::web.RegisterHTTPRoute({
+		.path = "/",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Initialize inja environment
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+				
+				// Prepare data for template
+				nlohmann::json data = context.GetUserDataJson();
+				
+				// Server status - merge with server state
+				nlohmann::json serverState = ServerState::GetServerStateJson();
+				data.merge_patch(serverState);
+				
+				// Statistics
+				data["stats"]["onlinePlayers"] = 0; // TODO: Get from server communication
+				data["stats"]["totalAccounts"] = Database::Get()->GetAccountCount();
+				data["stats"]["totalCharacters"] = Database::Get()->GetCharacterCount();
+				
+				// Render template
+				const std::string html = env.render_file("index.jinja2", data);
+				
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Failed to render template\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /login - Login page (no authentication required)
+	Game::web.RegisterHTTPRoute({
+		.path = "/login",
+		.method = eHTTPMethod::GET,
+		.middleware = {},
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Initialize inja environment
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+				
+				// Render template with empty user data (not authenticated)
+				nlohmann::json data = context.GetUserDataJson();
+				const std::string html = env.render_file("login.jinja2", data);
+				
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering login template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Failed to render login page\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /accounts/:id - View single account
+	Game::web.RegisterHTTPRoute({
+		.path = "/accounts/:id",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(0) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Extract account ID from URL path
+				const std::string path = context.path;
+				size_t lastSlash = path.rfind('/');
+				if (lastSlash == std::string::npos) {
+					reply.status = eHTTPStatusCode::NOT_FOUND;
+					reply.message = "<h1>404 - Account not found</h1>";
+					reply.contentType = eContentType::TEXT_HTML;
+					return;
+				}
+
+				std::string idStr = path.substr(lastSlash + 1);
+				uint32_t accountId = 0;
+				try {
+					accountId = std::stoul(idStr);
+				} catch (...) {
+					reply.status = eHTTPStatusCode::NOT_FOUND;
+					reply.message = "<h1>404 - Invalid account ID</h1>";
+					reply.contentType = eContentType::TEXT_HTML;
+					return;
+				}
+
+				// Permission check: GM 0 can only view own account, GM > 0 can view any account
+				if (context.gmLevel == 0) {
+					LOG("Regular user '%s' (GM level 0) is trying to access account ID %u", context.authenticatedUser.c_str(), accountId);
+					// Regular user - get their own account ID
+					auto currentUserInfo = Database::Get()->GetAccountInfo(context.authenticatedUser);
+					if (!currentUserInfo.has_value() || currentUserInfo->id != accountId) {
+						LOG("Permission denied: user '%s' cannot access account ID %u", context.authenticatedUser.c_str(), accountId);
+						reply.status = eHTTPStatusCode::FORBIDDEN;
+						reply.message = "<h1>403 - Forbidden</h1><p>You do not have permission to view this account.</p>";
+						reply.contentType = eContentType::TEXT_HTML;
+						return;
+					}
+				}
+
+				// Get account data from API
+			nlohmann::json account = Database::Get()->GetAccountById(accountId);
+			
+			// Check if account was found
+			if (account.contains("error")) {
+				reply.status = eHTTPStatusCode::NOT_FOUND;
+				reply.message = "<h1>404 - Account not found</h1>";
+				reply.contentType = eContentType::TEXT_HTML;
+				return;
+			}
+				// Initialize inja environment
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+
+				// Prepare data for template
+				nlohmann::json data = context.GetUserDataJson();
+				data["account"] = account;
+
+				// Render template
+				const std::string html = env.render_file("account-view.jinja2", data);
+
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering account view template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "<h1>500 - Server Error</h1>";
+				reply.contentType = eContentType::TEXT_HTML;
+			}
+		}
+	});
+
+	// GET /accounts - Accounts management page
+	Game::web.RegisterHTTPRoute({
+		.path = "/accounts",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(1) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				// Initialize inja environment
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+
+				// Prepare data for template
+				nlohmann::json data = context.GetUserDataJson();
+
+				// Render template
+				const std::string html = env.render_file("accounts.jinja2", data);
+
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering accounts template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Failed to render accounts page\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /characters - Characters management page
+	Game::web.RegisterHTTPRoute({
+		.path = "/characters",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(1) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+				
+				nlohmann::json data = context.GetUserDataJson();
+				const std::string html = env.render_file("characters.jinja2", data);
+				
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering characters template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Failed to render characters page\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /play_keys - Play keys management page
+	Game::web.RegisterHTTPRoute({
+		.path = "/play_keys",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(1) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+				
+				nlohmann::json data = context.GetUserDataJson();
+				const std::string html = env.render_file("play_keys.jinja2", data);
+				
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering play_keys template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Failed to render play_keys page\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /properties - Properties management page
+	Game::web.RegisterHTTPRoute({
+		.path = "/properties",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(1) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+				
+				nlohmann::json data = context.GetUserDataJson();
+				const std::string html = env.render_file("properties.jinja2", data);
+				
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering properties template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Failed to render properties page\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+
+	// GET /bug_reports - Bug reports management page
+	Game::web.RegisterHTTPRoute({
+		.path = "/bug_reports",
+		.method = eHTTPMethod::GET,
+		.middleware = { std::make_shared<RequireAuthMiddleware>(1) },
+		.handle = [](HTTPReply& reply, const HTTPContext& context) {
+			try {
+				inja::Environment env{"dDashboardServer/templates/"};
+				env.set_trim_blocks(true);
+				env.set_lstrip_blocks(true);
+				
+				nlohmann::json data = context.GetUserDataJson();
+				const std::string html = env.render_file("bug_reports.jinja2", data);
+				
+				reply.status = eHTTPStatusCode::OK;
+				reply.message = html;
+				reply.contentType = eContentType::TEXT_HTML;
+			} catch (const std::exception& ex) {
+				LOG("Error rendering bug_reports template: %s", ex.what());
+				reply.status = eHTTPStatusCode::INTERNAL_SERVER_ERROR;
+				reply.message = "{\"error\":\"Failed to render bug_reports page\"}";
+				reply.contentType = eContentType::APPLICATION_JSON;
+			}
+		}
+	});
+}

dDashboardServer/routes/DashboardRoutes.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include "json.hpp"
+
+class HTTPContext;
+
+void RegisterDashboardRoutes();

dDashboardServer/routes/ServerState.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <chrono>
+#include <vector>
+#include <string>
+#include <cstdint>
+#include "json.hpp"
+
+struct ServerStatus {
+	bool online{false};
+	uint32_t players{0};
+	std::string version{};
+	std::chrono::steady_clock::time_point lastSeen{};
+};
+
+struct WorldInstanceInfo {
+	uint32_t mapID{0};
+	uint32_t instanceID{0};
+	uint32_t cloneID{0};
+	uint32_t players{0};
+	std::string ip{};
+	uint32_t port{0};
+	bool isPrivate{false};
+};
+
+namespace ServerState {
+	extern ServerStatus g_AuthStatus;
+	extern ServerStatus g_ChatStatus;
+	extern std::vector<WorldInstanceInfo> g_WorldInstances;
+
+	// Helper function to get all server state as JSON
+	inline nlohmann::json GetServerStateJson() {
+		nlohmann::json data;
+		data["auth"]["online"] = g_AuthStatus.online;
+		data["auth"]["players"] = g_AuthStatus.players;
+		data["chat"]["online"] = g_ChatStatus.online;
+		data["chat"]["players"] = g_ChatStatus.players;
+
+		data["worlds"] = nlohmann::json::array();
+		for (const auto& world : g_WorldInstances) {
+			data["worlds"].push_back({
+				{"mapID", world.mapID},
+				{"instanceID", world.instanceID},
+				{"cloneID", world.cloneID},
+				{"players", world.players},
+				{"isPrivate", world.isPrivate}
+			});
+		}
+
+		return data;
+	}
+}

dDashboardServer/routes/StaticRoutes.cpp

@@ -0,0 +1,68 @@
+#include "StaticRoutes.h"
+#include "Web.h"
+#include "HTTPContext.h"
+#include "eHTTPMethod.h"
+#include "Game.h"
+#include "Logger.h"
+#include <fstream>
+#include <sstream>
+
+namespace {
+	std::string ReadFileToString(const std::string& filePath) {
+		std::ifstream file(filePath);
+		if (!file.is_open()) {
+			LOG("Failed to open file: %s", filePath.c_str());
+			return "";
+		}
+		std::stringstream buffer{};
+		buffer << file.rdbuf();
+		return buffer.str();
+	}
+
+	eContentType GetContentType(const std::string& filePath) {
+		if (filePath.ends_with(".css")) {
+			return eContentType::TEXT_CSS;
+		} else if (filePath.ends_with(".js")) {
+			return eContentType::TEXT_JAVASCRIPT;
+		} else if (filePath.ends_with(".html")) {
+			return eContentType::TEXT_HTML;
+		} else if (filePath.ends_with(".png")) {
+			return eContentType::IMAGE_PNG;
+		} else if (filePath.ends_with(".jpg") || filePath.ends_with(".jpeg")) {
+			return eContentType::IMAGE_JPEG;
+		} else if (filePath.ends_with(".json")) {
+			return eContentType::APPLICATION_JSON;
+		}
+		return eContentType::TEXT_PLAIN;
+	}
+
+	void ServeStaticFile(const std::string& urlPath, const std::string& filePath) {
+		Game::web.RegisterHTTPRoute({
+			.path = urlPath,
+			.method = eHTTPMethod::GET,
+			.middleware = {},
+			.handle = [filePath](HTTPReply& reply, const HTTPContext& context) {
+				const std::string content = ReadFileToString(filePath);
+				if (content.empty()) {
+					reply.status = eHTTPStatusCode::NOT_FOUND;
+					reply.message = "{\"error\":\"File not found\"}";
+					reply.contentType = eContentType::APPLICATION_JSON;
+				} else {
+					reply.status = eHTTPStatusCode::OK;
+					reply.message = content;
+					reply.contentType = GetContentType(filePath);
+				}
+			}
+		});
+	}
+}
+
+void RegisterStaticRoutes() {
+	// Serve CSS files
+	ServeStaticFile("/css/dashboard.css", "dDashboardServer/static/css/dashboard.css");
+	ServeStaticFile("/css/login.css", "dDashboardServer/static/css/login.css");
+	
+	// Serve JavaScript files
+	ServeStaticFile("/js/dashboard.js", "dDashboardServer/static/js/dashboard.js");
+	ServeStaticFile("/js/login.js", "dDashboardServer/static/js/login.js");
+}

dDashboardServer/routes/StaticRoutes.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void RegisterStaticRoutes();

dDashboardServer/routes/WSRoutes.cpp

@@ -0,0 +1,35 @@
+#include "WSRoutes.h"
+#include "ServerState.h"
+#include "Web.h"
+#include "json.hpp"
+#include "Game.h"
+#include "Database.h"
+#include "Logger.h"
+
+void RegisterWSRoutes() {
+	// Register WebSocket subscriptions for real-time updates
+	Game::web.RegisterWSSubscription("dashboard_update");
+	Game::web.RegisterWSSubscription("server_status");
+	Game::web.RegisterWSSubscription("player_joined");
+	Game::web.RegisterWSSubscription("player_left");
+	
+	// dashboard_update: Broadcasts complete dashboard data every 2 seconds
+	// Other subscriptions can be triggered by events from the master server
+}
+
+void BroadcastDashboardUpdate() {
+	// Get server state data (auth, chat, worlds) - mutex is acquired internally
+	nlohmann::json data = ServerState::GetServerStateJson();
+	
+	// Add statistics
+	try {
+		data["stats"]["onlinePlayers"] = 0; // TODO: Get from server communication
+		data["stats"]["totalAccounts"] = Database::Get()->GetAccountCount();
+		data["stats"]["totalCharacters"] = Database::Get()->GetCharacterCount();
+	} catch (const std::exception& ex) {
+		LOG_DEBUG("Error getting stats: %s", ex.what());
+	}
+	
+	// Broadcast to all connected WebSocket clients subscribed to "dashboard_update"
+	Game::web.SendWSMessage("dashboard_update", data);
+}

dDashboardServer/routes/WSRoutes.h

@@ -0,0 +1,4 @@
+#pragma once
+
+void RegisterWSRoutes();
+void BroadcastDashboardUpdate();

dDashboardServer/static/css/dashboard.css

@@ -0,0 +1,495 @@
+/* Minimal custom styling - mostly Bootstrap5 utilities */
+
+body {
+	font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+	margin: 0;
+	padding: 0;
+}
+
+body.d-flex.bg-dark.text-white {
+	background-color: #0d0d0d;
+	color: #fff;
+}
+
+/* Sidebar adjustments */
+.navbar.flex-column {
+	box-shadow: 0.125rem 0 0.25rem rgba(0, 0, 0, 0.075);
+}
+
+.navbar.flex-column .navbar-nav {
+	width: 100%;
+}
+
+.navbar.flex-column .nav-link {
+	padding: 0.75rem 1.25rem;
+	border-left: 3px solid transparent;
+	transition: all 0.3s ease;
+}
+
+.navbar.flex-column .nav-link:hover {
+	background-color: rgba(255, 255, 255, 0.1);
+	border-left-color: #667eea;
+	padding-left: 1.5rem;
+}
+
+.navbar.flex-column .nav-link.active {
+	background-color: rgba(255, 255, 255, 0.1);
+	border-left-color: #667eea;
+}
+
+main {
+	display: flex;
+	flex-direction: column;
+	padding: 0;
+	min-height: 100vh;
+}
+
+/* Responsive design */
+@media (max-width: 991.98px) {
+	body {
+		display: block !important;
+	}
+	
+	main {
+		margin-left: 0 !important;
+	}
+	
+	.navbar.flex-column {
+		width: 100% !important;
+		height: auto !important;
+		position: relative !important;
+		top: auto !important;
+		start: auto !important;
+	}
+}
+
+.navbar {
+	box-shadow: 0 0.125rem 0.25rem rgba(0, 0, 0, 0.075);
+}
+
+.username {
+	font-weight: 600;
+	color: #667eea;
+	font-size: 1.1em;
+}
+
+.logout-btn {
+	padding: 10px 20px;
+	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+	color: white;
+	border: none;
+	border-radius: 5px;
+	cursor: pointer;
+	font-weight: 600;
+	transition: opacity 0.3s;
+}
+
+.logout-btn:hover {
+	opacity: 0.9;
+}
+
+.grid {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+	gap: 20px;
+	margin-bottom: 20px;
+}
+
+.stat {
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	padding: 10px 0;
+	border-bottom: 1px solid #eee;
+}
+
+.stat:last-child {
+	border-bottom: none;
+}
+
+.stat-label {
+	color: #666;
+	font-weight: 500;
+}
+
+.stat-value {
+	color: #333;
+	font-weight: bold;
+	font-size: 1.2em;
+}
+
+.status {
+	display: inline-block;
+	padding: 5px 15px;
+	border-radius: 20px;
+	font-size: 0.9em;
+	font-weight: bold;
+}
+
+.status.online {
+	background: #4caf50;
+	color: white;
+}
+
+.status.offline {
+	background: #f44336;
+	color: white;
+}
+
+.world-list {
+	max-height: 300px;
+	overflow-y: auto;
+}
+
+.world-item {
+	padding: 15px;
+	background: #f5f5f5;
+	border-radius: 5px;
+	margin-bottom: 10px;
+}
+
+.world-item h3 {
+	color: #333;
+	margin-bottom: 8px;
+}
+
+.world-detail {
+	color: #666;
+	font-size: 0.9em;
+	margin: 3px 0;
+}
+
+.loading {
+	text-align: center;
+	padding: 20px;
+	color: #666;
+}
+
+/* Dark theme for data tables and containers */
+
+/* Container margin for sidebar layout */
+.account-view-container,
+.accounts-container,
+.characters-container,
+.play-keys-container,
+.properties-container,
+.bug-reports-container {
+	margin-left: 280px;
+	padding: 20px;
+}
+
+/* Table card styling */
+.table-card {
+	background-color: #1a1a1a;
+	border: 1px solid #333;
+	border-radius: 0.5rem;
+	box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+}
+
+.table-header {
+	background-color: #222;
+	padding: 1.5rem;
+	border-bottom: 1px solid #333;
+	border-radius: 0.5rem 0.5rem 0 0;
+}
+
+.table-header h2 {
+	margin: 0;
+	color: #fff;
+}
+
+.table-body {
+	padding: 1.5rem;
+}
+
+/* Bootstrap card overrides for dark theme */
+.card {
+	background-color: #1a1a1a;
+	border: 1px solid #333;
+	border-radius: 0.5rem;
+	box-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
+	margin-bottom: 1.5rem;
+}
+
+.card-header {
+	background-color: #222;
+	padding: 1.5rem;
+	border-bottom: 1px solid #333;
+	border-radius: 0.5rem 0.5rem 0 0;
+}
+
+.card-header h2 {
+	margin: 0;
+	color: #fff;
+}
+
+.card-body {
+	padding: 1.5rem;
+}
+
+/* Table styling */
+.table-dark {
+	color: #fff;
+}
+
+.table-dark thead {
+	background-color: #2a2a2a;
+}
+
+.table-dark thead th {
+	border-bottom: 2px solid #444;
+	color: #aaa;
+	font-weight: 600;
+	text-transform: uppercase;
+	font-size: 0.875rem;
+	padding: 1rem;
+}
+
+.table-dark tbody td {
+	padding: 0.875rem 1rem;
+	border-bottom: 1px solid #333;
+	vertical-align: middle;
+}
+
+.table-dark tbody tr:hover {
+	background-color: #252525;
+}
+
+/* DataTables customization */
+.dataTables_wrapper {
+	color: #fff;
+}
+
+.dataTables_wrapper .dataTables_filter input {
+	background-color: #2a2a2a;
+	color: #fff;
+	border: 1px solid #444;
+	border-radius: 0.25rem;
+	padding: 0.4rem 0.6rem;
+}
+
+.dataTables_wrapper .dataTables_filter input::placeholder {
+	color: #888;
+}
+
+.dataTables_wrapper .dataTables_info {
+	color: #aaa;
+	padding: 1rem;
+}
+
+.dataTables_wrapper .dataTables_paginate .paginate_button {
+	background: #2a2a2a;
+	color: #fff;
+	border: 1px solid #444;
+	margin: 0 2px;
+	padding: 0.4rem 0.8rem;
+	border-radius: 0.25rem;
+	cursor: pointer;
+	transition: all 0.2s;
+}
+
+.dataTables_wrapper .dataTables_paginate .paginate_button:hover {
+	background: #3a3a3a;
+	border: 1px solid #555;
+}
+
+.dataTables_wrapper .dataTables_paginate .paginate_button.current {
+	background: #0d6efd;
+	border: 1px solid #0d6efd;
+}
+
+.dataTables_wrapper .dataTables_paginate .paginate_button.disabled {
+	opacity: 0.5;
+	cursor: not-allowed;
+}
+
+.dataTables_wrapper .dataTables_length select {
+	background-color: #2a2a2a;
+	color: #fff;
+	border: 1px solid #444;
+	padding: 0.4rem 0.6rem;
+	border-radius: 0.25rem;
+}
+
+/* Detail grid layout */
+.detail-grid {
+	display: grid;
+	grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
+	gap: 1.5rem;
+}
+
+.detail-item {
+	background-color: #0a0a0a;
+	padding: 1rem;
+	border-radius: 0.25rem;
+	border-left: 3px solid #0d6efd;
+}
+
+.detail-label {
+	color: #999;
+	font-size: 0.875rem;
+	text-transform: uppercase;
+	letter-spacing: 0.5px;
+	margin-bottom: 0.5rem;
+}
+
+.detail-value {
+	color: #fff;
+	font-size: 1rem;
+	font-weight: 500;
+}
+
+/* Badge styling */
+.badge {
+	display: inline-block;
+	padding: 0.35rem 0.6rem;
+	font-size: 0.8rem;
+	font-weight: 500;
+	border-radius: 0.25rem;
+}
+
+.badge-active {
+	background-color: #28a745;
+	color: #fff;
+}
+
+.badge-inactive {
+	background-color: #6c757d;
+	color: #fff;
+}
+
+.badge-banned {
+	background-color: #dc3545;
+	color: #fff;
+}
+
+.badge-locked {
+	background-color: #ffc107;
+	color: #000;
+}
+
+.badge-gm {
+	background-color: #17a2b8;
+	color: #fff;
+}
+
+.badge-approved {
+	background-color: #28a745;
+	color: #fff;
+}
+
+.badge-pending {
+	background-color: #ffc107;
+	color: #000;
+}
+
+/* Button styling */
+.button-group {
+	display: flex;
+	gap: 0.5rem;
+	margin-top: 1.5rem;
+}
+
+.btn {
+	padding: 0.5rem 1rem;
+	border-radius: 0.25rem;
+	border: none;
+	cursor: pointer;
+	font-weight: 500;
+	transition: all 0.2s;
+}
+
+.btn-sm {
+	padding: 0.25rem 0.5rem;
+	font-size: 0.75rem;
+}
+
+.btn-primary {
+	background-color: #0d6efd;
+	color: #fff;
+}
+
+.btn-primary:hover {
+	background-color: #0b5ed7;
+}
+
+.btn-secondary {
+	background-color: #6c757d;
+	color: #fff;
+}
+
+.btn-secondary:hover {
+	background-color: #5c636a;
+}
+
+.btn-danger {
+	background-color: #dc3545;
+	color: #fff;
+}
+
+.btn-danger:hover {
+	background-color: #c82333;
+}
+
+.btn-info {
+	background-color: #17a2b8;
+	color: #fff;
+}
+
+.btn-info:hover {
+	background-color: #138496;
+}
+
+.btn-warning {
+	background-color: #ffc107;
+	color: #000;
+}
+
+.btn-warning:hover {
+	background-color: #e0a800;
+}
+
+/* Action buttons */
+.account-actions {
+	display: flex;
+	gap: 0.5rem;
+}
+
+/* Utility classes */
+.text-muted {
+	color: #999 !important;
+}
+
+.back-link {
+	color: #0d6efd;
+	text-decoration: none;
+	margin-bottom: 1rem;
+	display: inline-block;
+}
+
+.back-link:hover {
+	text-decoration: underline;
+}
+
+.report-preview {
+	max-width: 200px;
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}
+
+.search-section {
+	margin-bottom: 1.5rem;
+}
+
+.search-input {
+	background-color: #2a2a2a;
+	border: 1px solid #444;
+	color: #fff;
+	padding: 0.5rem;
+	border-radius: 0.25rem;
+}
+
+.search-input::placeholder {
+	color: #888;
+}

dDashboardServer/static/css/login.css

@@ -0,0 +1,30 @@
+/* Custom styling for login page on top of Bootstrap5 */
+
+body {
+	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+	font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+}
+
+.card {
+	border-radius: 0.5rem;
+	box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2) !important;
+}
+
+.btn-primary {
+	background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+	border: none;
+}
+
+.btn-primary:hover {
+	background: linear-gradient(135deg, #5568d3 0%, #6a3f93 100%);
+}
+
+.form-control:focus {
+	border-color: #667eea;
+	box-shadow: 0 0 0 0.2rem rgba(102, 126, 234, 0.25);
+}
+
+h1 {
+	color: #333;
+	font-weight: 600;
+}

dDashboardServer/static/js/dashboard.js

@@ -0,0 +1,240 @@
+let ws = null;
+let reconnectAttempts = 0;
+const maxReconnectAttempts = 5;
+const reconnectDelay = 3000;
+
+// Helper function to get cookie value
+function getCookie(name) {
+	const nameEQ = name + '=';
+	const cookies = document.cookie.split(';');
+	for (let cookie of cookies) {
+		cookie = cookie.trim();
+		if (cookie.indexOf(nameEQ) === 0) {
+			return decodeURIComponent(cookie.substring(nameEQ.length));
+		}
+	}
+	return null;
+}
+
+// Helper function to delete cookie
+function deleteCookie(name) {
+	document.cookie = `${name}=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/; SameSite=Strict`;
+}
+
+// Check authentication on page load
+function checkAuthentication() {
+	// Check localStorage first (most secure)
+	let token = localStorage.getItem('dashboardToken');
+	
+	// Fallback to cookie if localStorage empty
+	if (!token) {
+		token = getCookie('dashboardToken');
+	}
+	
+	if (!token) {
+		// Redirect to login if no token
+		window.location.href = '/login';
+		return false;
+	}
+	
+	// Verify token is valid (asynchronous)
+	fetch('/api/auth/verify', {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify({ token: token })
+	})
+	.then(res => {
+		if (!res.ok) {
+			console.error('Verify endpoint returned:', res.status);
+			throw new Error(`HTTP ${res.status}`);
+		}
+		return res.json();
+	})
+	.then(data => {
+		console.log('Token verification response:', data);
+		if (!data.valid) {
+			// Token is invalid/expired, delete cookies and redirect to login
+			console.log('Token verification failed, redirecting to login');
+			deleteCookie('dashboardToken');
+			deleteCookie('gmLevel');
+			localStorage.removeItem('dashboardToken');
+			window.location.href = '/login';
+		} else {
+			// Update UI with username
+			console.log('Token verified, user:', data.username);
+			const usernameElement = document.querySelector('.username');
+			if (usernameElement) {
+				usernameElement.textContent = data.username || 'User';
+			} else {
+				console.warn('Username element not found in DOM');
+			}
+			// Now that verification is complete, connect to WebSocket
+			setTimeout(() => {
+				console.log('Starting WebSocket connection');
+				connectWebSocket();
+			}, 100);
+		}
+	})
+	.catch(err => {
+		console.error('Token verification error:', err);
+		// Network error - log but don't redirect immediately
+		// This prevents redirect loops on network issues
+	});
+	
+	return true;
+}
+
+// Get token from localStorage or cookie
+function getAuthToken() {
+	let token = localStorage.getItem('dashboardToken');
+	if (!token) {
+		token = getCookie('dashboardToken');
+	}
+	console.log('getAuthToken called, token available:', !!token);
+	return token;
+}
+
+// Logout function
+function logout() {
+	deleteCookie('dashboardToken');
+	deleteCookie('gmLevel');
+	localStorage.removeItem('dashboardToken');
+	window.location.href = '/login';
+}
+
+function connectWebSocket() {
+	const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+	const token = getAuthToken();
+	if (!token) {
+		console.error('No token available for WebSocket connection');
+		window.location.href = '/login';
+		return;
+	}
+	
+	console.log(`WebSocket connection attempt ${reconnectAttempts + 1}/${maxReconnectAttempts}`);
+	
+	// Connect to WebSocket without token in URL (token is in cookies)
+	const wsUrl = `${protocol}//${window.location.host}/ws`;
+	console.log(`Connecting to WebSocket: ${wsUrl}`);
+	
+	try {
+		ws = new WebSocket(wsUrl);
+		
+		ws.onopen = () => {
+			console.log('WebSocket connected');
+			reconnectAttempts = 0;
+			
+			// Subscribe to dashboard updates
+			ws.send(JSON.stringify({
+				event: 'subscribe',
+				subscription: 'dashboard_update'
+			}));
+			
+			document.getElementById('connection-status')?.remove();
+		};
+		
+		ws.onmessage = (event) => {
+			try {
+				const data = JSON.parse(event.data);
+				
+				// Handle subscription confirmation
+				if (data.subscribed) {
+					console.log('Subscribed to:', data.subscribed);
+					return;
+				}
+				
+				// Handle dashboard updates
+				if (data.event === 'dashboard_update') {
+					updateDashboard(data);
+				}
+			} catch (error) {
+				console.error('Error parsing WebSocket message:', error);
+			}
+		};
+		
+		ws.onerror = (error) => {
+			console.error('WebSocket error:', error);
+		};
+		
+		ws.onclose = () => {
+			console.log('WebSocket disconnected');
+			ws = null;
+			
+			// Show connection status
+			showConnectionStatus('Disconnected - Attempting to reconnect...');
+			
+			// Attempt to reconnect with exponential backoff
+			if (reconnectAttempts < maxReconnectAttempts) {
+				reconnectAttempts++;
+				const backoffDelay = reconnectDelay * Math.pow(2, reconnectAttempts - 1);
+				console.log(`Reconnecting in ${backoffDelay}ms (attempt ${reconnectAttempts}/${maxReconnectAttempts})`);
+				setTimeout(connectWebSocket, backoffDelay);
+			} else {
+				console.error('Max reconnection attempts reached');
+				showConnectionStatus('Connection lost - Reload page to reconnect');
+			}
+		};
+	} catch (error) {
+		console.error('Failed to create WebSocket:', error);
+		showConnectionStatus('Failed to connect - Reload page to retry');
+	}
+}
+
+function showConnectionStatus(message) {
+	let statusEl = document.getElementById('connection-status');
+	if (!statusEl) {
+		statusEl = document.createElement('div');
+		statusEl.id = 'connection-status';
+		statusEl.style.cssText = 'position: fixed; top: 10px; right: 10px; background: #f44336; color: white; padding: 10px 20px; border-radius: 4px; z-index: 1000;';
+		document.body.appendChild(statusEl);
+	}
+	statusEl.textContent = message;
+}
+
+function updateDashboard(data) {
+	// Update server status
+	if (data.auth) {
+		document.getElementById('auth-status').textContent = data.auth.online ? 'Online' : 'Offline';
+		document.getElementById('auth-status').className = 'status ' + (data.auth.online ? 'online' : 'offline');
+	}
+	
+	if (data.chat) {
+		document.getElementById('chat-status').textContent = data.chat.online ? 'Online' : 'Offline';
+		document.getElementById('chat-status').className = 'status ' + (data.chat.online ? 'online' : 'offline');
+	}
+	
+	// Update world instances
+	if (data.worlds) {
+		document.getElementById('world-count').textContent = data.worlds.length;
+		
+		const worldList = document.getElementById('world-list');
+		if (data.worlds.length === 0) {
+			worldList.innerHTML = '<div class="loading">No active world instances</div>';
+		} else {
+			worldList.innerHTML = data.worlds.map(world => `
+				<div class="world-item">
+					<h3>Zone ${world.mapID} - Instance ${world.instanceID}</h3>
+					<div class="world-detail">Clone ID: ${world.cloneID}</div>
+					<div class="world-detail">Players: ${world.players}</div>
+					<div class="world-detail">Type: ${world.isPrivate ? 'Private' : 'Public'}</div>
+				</div>
+			`).join('');
+		}
+	}
+	
+	// Update statistics
+	if (data.stats) {
+		if (data.stats.onlinePlayers !== undefined) {
+			document.getElementById('online-players').textContent = data.stats.onlinePlayers;
+		}
+		if (data.stats.totalAccounts !== undefined) {
+			document.getElementById('total-accounts').textContent = data.stats.totalAccounts;
+		}
+		if (data.stats.totalCharacters !== undefined) {
+			document.getElementById('total-characters').textContent = data.stats.totalCharacters;
+		}
+	}
+}
+
+// Connect on page load
+connectWebSocket();

dDashboardServer/static/js/login.js

@@ -0,0 +1,99 @@
+// Check if user is already logged in
+function checkExistingToken() {
+	const token = localStorage.getItem('dashboardToken');
+	if (token) {
+		verifyTokenAndRedirect(token);
+	}
+}
+
+function verifyTokenAndRedirect(token) {
+	fetch('/api/auth/verify', {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify({ token: token })
+	})
+	.then(res => res.json())
+	.then(data => {
+		if (data.valid) {
+			window.location.href = '/';
+		}
+	})
+	.catch(err => console.error('Token verification failed:', err));
+}
+
+function showAlert(message, type) {
+	const alert = document.getElementById('alert');
+	alert.textContent = message;
+	alert.className = 'alert';
+	if (type === 'error') {
+		alert.classList.add('alert-danger');
+	} else if (type === 'success') {
+		alert.classList.add('alert-success');
+	}
+	alert.style.display = 'block';
+}
+
+// Wait for DOM to be ready
+document.addEventListener('DOMContentLoaded', () => {
+	const loginForm = document.getElementById('loginForm');
+	if (!loginForm) {
+		console.error('Login form not found');
+		return;
+	}
+
+	loginForm.addEventListener('submit', async (e) => {
+		e.preventDefault();
+
+		const username = document.getElementById('username').value;
+		const password = document.getElementById('password').value;
+		const rememberMe = document.getElementById('rememberMe').checked;
+
+		// Validate input
+		if (!username || !password) {
+			showAlert('Username and password are required', 'error');
+			return;
+		}
+
+		if (password.length > 40) {
+			showAlert('Password exceeds maximum length (40 characters)', 'error');
+			return;
+		}
+
+		// Show loading state
+		document.getElementById('loading').style.display = 'inline-block';
+		document.getElementById('loginBtn').disabled = true;
+
+		try {
+			const response = await fetch('/api/auth/login', {
+				method: 'POST',
+				headers: { 'Content-Type': 'application/json' },
+				body: JSON.stringify({ username, password, rememberMe })
+			});
+
+			const data = await response.json();
+
+			if (data.success) {
+				// Store token in localStorage (also set as cookie for API calls)
+				localStorage.setItem('dashboardToken', data.token);
+				document.cookie = `dashboardToken=${data.token}; path=/; SameSite=Strict`;
+				showAlert('Login successful! Redirecting...', 'success');
+				
+				// Redirect after a short delay (no token in URL)
+				setTimeout(() => {
+					window.location.href = '/';
+				}, 1000);
+			} else {
+				showAlert(data.message || 'Login failed', 'error');
+				document.getElementById('loading').style.display = 'none';
+				document.getElementById('loginBtn').disabled = false;
+			}
+		} catch (error) {
+			showAlert('Network error: ' + error.message, 'error');
+			document.getElementById('loading').style.display = 'none';
+			document.getElementById('loginBtn').disabled = false;
+		}
+	});
+
+	// Check existing token on page load
+	checkExistingToken();
+});

dDashboardServer/templates/account-view.jinja2

@@ -0,0 +1,137 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Account - DarkflameServer{% endblock %}
+
+{% block css %}{% endblock %}
+
+{% block content %}
+	<div class="account-view-container">
+		<div class="container-fluid">
+			<a href="/accounts" class="back-link">← Back to Accounts</a>
+
+			<div class="card">
+				<div class="card-header">
+					<h2>Account #{{ account.id }} - {{ account.name }}</h2>
+					<p class="text-muted">View account details and manage settings</p>
+				</div>
+				<div class="card-body">
+					<div class="detail-grid">
+						<div class="detail-item">
+							<div class="detail-label">Account ID</div>
+							<div class="detail-value">{{ account.id }}</div>
+						</div>
+
+						<div class="detail-item">
+							<div class="detail-label">Username</div>
+							<div class="detail-value">{{ account.name }}</div>
+						</div>
+
+						<div class="detail-item">
+							<div class="detail-label">Created</div>
+							<div class="detail-value">{{ account.created_at }}</div>
+						</div>
+
+						<div class="detail-item">
+							<div class="detail-label">GM Level</div>
+							<div class="detail-value">
+								{% if account.gm_level > 0 %}
+									<span class="badge badge-gm">GM {{ account.gm_level }}</span>
+								{% else %}
+									<span class="badge badge-inactive">User</span>
+								{% endif %}
+							</div>
+						</div>
+
+						<div class="detail-item">
+							<div class="detail-label">Ban Status</div>
+							<div class="detail-value">
+								{% if account.banned %}
+									<span class="badge badge-banned">BANNED</span>
+								{% else %}
+									<span class="badge badge-active">Active</span>
+								{% endif %}
+							</div>
+						</div>
+
+						<div class="detail-item">
+							<div class="detail-label">Lock Status</div>
+							<div class="detail-value">
+								{% if account.locked %}
+									<span class="badge badge-locked">LOCKED</span>
+								{% else %}
+									<span class="badge badge-active">Unlocked</span>
+								{% endif %}
+							</div>
+						</div>
+
+						<div class="detail-item">
+							<div class="detail-label">Mute Expires</div>
+							<div class="detail-value">
+								{% if account.mute_expire > 0 %}
+									<span>{{ account.mute_expire }}</span>
+								{% else %}
+									<span class="text-muted">Not muted</span>
+								{% endif %}
+							</div>
+						</div>
+					</div>
+
+					<div class="button-group">
+						<button class="btn btn-primary" onclick="EditAccount()">Edit Account</button>
+						{% if not account.banned %}
+							<button class="btn btn-danger" onclick="BanAccount()">Ban Account</button>
+						{% else %}
+							<button class="btn btn-secondary" onclick="UnbanAccount()">Unban Account</button>
+						{% endif %}
+						{% if not account.locked %}
+							<button class="btn btn-danger" onclick="LockAccount()">Lock Account</button>
+						{% else %}
+							<button class="btn btn-secondary" onclick="UnlockAccount()">Unlock Account</button>
+						{% endif %}
+					</div>
+				</div>
+			</div>
+
+			<!-- TODO: Add modals for edit, ban, lock operations -->
+			<!-- TODO: Add character list for this account -->
+			<!-- TODO: Add login history -->
+		</div>
+	</div>
+{% endblock %}
+
+{% block scripts %}
+	<script>
+		function EditAccount() {
+			alert("Edit functionality coming soon");
+			// TODO: Open edit modal
+		}
+
+		function BanAccount() {
+			if (confirm("Are you sure you want to ban this account?")) {
+				alert("Ban functionality coming soon");
+				// TODO: Call ban API endpoint
+			}
+		}
+
+		function UnbanAccount() {
+			if (confirm("Are you sure you want to unban this account?")) {
+				alert("Unban functionality coming soon");
+				// TODO: Call unban API endpoint
+			}
+		}
+
+		function LockAccount() {
+			if (confirm("Are you sure you want to lock this account?")) {
+				alert("Lock functionality coming soon");
+				// TODO: Call lock API endpoint
+			}
+		}
+
+		function UnlockAccount() {
+			if (confirm("Are you sure you want to unlock this account?")) {
+				alert("Unlock functionality coming soon");
+				// TODO: Call unlock API endpoint
+			}
+		}
+	</script>
+{% endblock %}

dDashboardServer/templates/accounts.jinja2

@@ -0,0 +1,133 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Accounts - DarkflameServer{% endblock %}
+
+{% block css %}{% endblock %}
+
+{% block content %}
+	<div class="accounts-container">
+		<div class="container-fluid">
+			<div class="table-card">
+				<div class="table-header">
+                    <h2 class="mb-0">Accounts</h2>
+                    <p class="text-muted">View and manage user accounts</p>
+				</div>
+				<div class="table-body">
+					<div class="table-responsive">
+						<table id="accountsTable" class="table table-dark table-hover mb-0">
+							<thead>
+								<tr>
+									<th>ID</th>
+									<th>Username</th>
+									<th>Banned</th>
+									<th>Locked</th>
+									<th>GM Level</th>
+									<th>Mute Expires</th>
+									<th>Created</th>
+									<th>Actions</th>
+								</tr>
+							</thead>
+							<tbody>
+								<!-- Data populated by DataTables -->
+							</tbody>
+						</table>
+					</div>
+				</div>
+			</div>
+		</div>
+	</div>
+{% endblock %}
+
+{% block scripts %}
+	<script>
+		$(document).ready(function() {
+			// Initialize DataTable with server-side processing
+			$('#accountsTable').DataTable({
+				processing: true,
+				serverSide: true,
+				pageLength: 25,
+				lengthMenu: [10, 25, 50, 100],
+				ajax: {
+					url: '/api/tables/accounts',
+					type: 'POST',
+					contentType: 'application/json',
+					data: function(d) {
+						return JSON.stringify(d);
+					},
+					error: function(xhr, error, thrown) {
+						console.error('Error loading accounts:', error);
+						if (xhr.status === 401) {
+							window.location.href = '/login';
+						}
+					}
+				},
+				columns: [
+					{ data: 'id' },
+					{ data: 'name' },
+					{
+						data: 'banned',
+						render: function(data) {
+							return data ? '<span class="badge badge-banned">Banned</span>' : '<span class="badge bg-success">Active</span>';
+						}
+					},
+					{
+						data: 'locked',
+						render: function(data) {
+							return data ? '<span class="badge badge-locked">Locked</span>' : '<span class="badge bg-secondary">Unlocked</span>';
+						}
+					},
+					{
+						data: 'gm_level',
+						render: function(data) {
+							if (data === 0) return '-';
+							return '<span class="badge badge-gm">Level ' + data + '</span>';
+						}
+					},
+					{
+						data: 'mute_expire',
+						render: function(data) {
+							if (data === 0) return 'Not Muted';
+							const now = Math.floor(Date.now() / 1000);
+							const isMuted = data > now;
+							const date = new Date(data * 1000);
+							const dateStr = date.toLocaleString();
+							if (isMuted) {
+								return '<span class="badge bg-danger">Muted until ' + dateStr + '</span>';
+							} else {
+								return '<span class="badge bg-success">Expired ' + dateStr + '</span>';
+							}
+						}
+					},
+					{
+						data: 'created_at',
+						render: function(data) {
+							return data ? new Date(data).toLocaleString() : '-';
+						}
+					},
+					{
+						data: 'id',
+						render: function(data) {
+							return '<div class="account-actions">' +
+								'<button class="btn btn-sm btn-info" onclick="viewAccount(' + data + ')" title="View">👁️</button>' +
+								'<button class="btn btn-sm btn-warning" onclick="editAccount(' + data + ')" title="Edit">✏️</button>' +
+								'</div>';
+						},
+						orderable: false,
+						searchable: false
+					}
+				],
+				order: [[0, 'asc']],
+				stateSave: false
+			});
+		});
+
+		function viewAccount(id) {
+			window.location.href = '/accounts/' + id;
+		}
+
+		function editAccount(id) {
+			alert('Edit account: ' + id);
+			// TODO: Implement account edit modal
+		}
+	</script>
+{% endblock %}

dDashboardServer/templates/base.jinja2

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>{% block title %}DarkflameServer{% endblock %}</title>
+	<link href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/5.3.0/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-9ndCyUaIbzAi2FUVXJi0CjmCapSmO7SnpJef0486qhLnuZ2cdeRhO02iuK6FUUVM" crossorigin="anonymous">
+	<link href="https://cdn.datatables.net/v/bs5/jq-3.7.0/dt-2.3.7/b-3.2.6/fh-4.0.6/sc-2.4.3/datatables.min.css" rel="stylesheet" integrity="sha384-XMNDGLb5fN9IqhIrVXOAtGKcz4KCr+JSHXGZ1TDXQPDukbEAfmLPjHdCXhgK93fv" crossorigin="anonymous">
+	<link rel="stylesheet" href="/css/dashboard.css">
+	{% block css %}{% endblock %}
+</head>
+<body class="d-flex bg-dark text-white">
+	{% if username and username != "" %}
+	{% include "header.jinja2" %}
+	{% endif %}
+
+	<div class="container-fluid py-3">
+		{% block content_before %}{% endblock %}
+		{% block content %}{% endblock %}
+		{% block content_after %}{% endblock %}
+	</div>
+
+	<footer class="mt-5 pt-5 border-top border-secondary text-center pb-3">
+		{% block footer %}
+		<p class="text-muted small">DarkflameServer Dashboard &copy; 2024</p>
+		{% endblock %}
+	</footer>
+
+	<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/5.3.0/js/bootstrap.bundle.min.js" integrity="sha384-geWF76RCwLtnZ8qwWowPQNguL3RmwHVBC9FhGdlKrxdiJJigb/j/68SIy3Te4Bkz" crossorigin="anonymous"></script>
+	<script src="https://cdn.datatables.net/v/bs5/jq-3.7.0/dt-2.3.7/b-3.2.6/fh-4.0.6/sc-2.4.3/datatables.min.js" integrity="sha384-BPUXtS4tH3onFfu5m+dPbFfpLOXQwSWGwrsNWxOAAwqqJx6tJHhFkGF6uitrmEui" crossorigin="anonymous"></script>
+
+	{% block scripts %}{% endblock %}
+</body>
+</html>

dDashboardServer/templates/bug_reports.jinja2

@@ -0,0 +1,97 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Bug Reports - DarkflameServer{% endblock %}
+
+{% block css %}{% endblock %}
+
+{% block content %}
+	<div class="bug-reports-container">
+		<div class="table-card">
+			<div class="table-header">
+				<h2 class="mb-0">Bug Reports</h2>
+				<p class="text-muted">View and manage bug reports from players</p>
+			</div>
+			<div class="table-body">
+				<table id="bugReportsTable" class="table table-dark table-striped table-hover">
+					<thead>
+						<tr>
+							<th>ID</th>
+							<th>Player</th>
+							<th>Client Version</th>
+							<th>Submitted</th>
+							<th>Report Preview</th>
+							<th>Actions</th>
+						</tr>
+					</thead>
+					<tbody>
+						<!-- Data populated by DataTables -->
+					</tbody>
+				</table>
+			</div>
+		</div>
+	</div>
+{% endblock %}
+
+{% block scripts %}
+	<script>
+		$(document).ready(function() {
+			// Initialize DataTable with server-side processing
+			$('#bugReportsTable').DataTable({
+				processing: true,
+				serverSide: true,
+				pageLength: 25,
+				lengthMenu: [10, 25, 50, 100],
+				ajax: {
+					url: '/api/tables/bug_reports',
+					type: 'POST',
+					contentType: 'application/json',
+					data: function(d) {
+						return JSON.stringify(d);
+					}
+				},
+				columns: [
+					{ data: 'id' },
+					{ data: 'other_player_id' },
+					{ data: 'client_version' },
+					{
+						data: 'submitted',
+						render: function(data) {
+							return data ? new Date(data).toLocaleString() : '-';
+						}
+					},
+					{
+						data: 'body',
+						render: function(data) {
+							return '<span class="report-preview" title="' + (data || '') + '">' + (data || '-') + '</span>';
+						}
+					},
+					{
+						data: 'id',
+						render: function(data) {
+							return '<div class="account-actions">' +
+								'<button class="btn btn-sm btn-info" onclick="viewReport(' + data + ')" title="View">👁️</button>' +
+								'<button class="btn btn-sm btn-danger" onclick="deleteReport(' + data + ')" title="Delete">🗑️</button>' +
+								'</div>';
+						},
+						orderable: false,
+						searchable: false
+					}
+				],
+				order: [[0, 'desc']],
+				stateSave: false
+			});
+		});
+
+		function viewReport(id) {
+			alert('View report: ' + id);
+			// TODO: Implement report view modal
+		}
+
+		function deleteReport(id) {
+			if (confirm('Are you sure you want to delete this report?')) {
+				alert('Delete report: ' + id);
+				// TODO: Implement report deletion
+			}
+		}
+	</script>
+{% endblock %}

dDashboardServer/templates/characters.jinja2

@@ -0,0 +1,90 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Characters - DarkflameServer{% endblock %}
+
+{% block css %}{% endblock %}
+
+{% block content %}
+	<div class="characters-container">
+		<div class="table-card">
+			<div class="table-header">
+				<h2 class="mb-0">Characters</h2>
+				<p class="text-muted">View and manage player characters</p>
+			</div>
+			<div class="table-body">
+				<table id="charactersTable" class="table table-dark table-striped table-hover">
+					<thead>
+						<tr>
+							<th>ID</th>
+							<th>Name</th>
+							<th>Account</th>
+							<th>Last Login</th>
+							<th>Actions</th>
+						</tr>
+					</thead>
+					<tbody>
+						<!-- Data populated by DataTables -->
+					</tbody>
+				</table>
+			</div>
+		</div>
+	</div>
+{% endblock %}
+
+{% block scripts %}
+	<script>
+		$(document).ready(function() {
+			// Initialize DataTable with server-side processing
+			$('#charactersTable').DataTable({
+				processing: true,
+				serverSide: true,
+				pageLength: 25,
+				lengthMenu: [10, 25, 50, 100],
+				ajax: {
+					url: '/api/tables/characters',
+					type: 'POST',
+					contentType: 'application/json',
+					data: function(d) {
+						return JSON.stringify(d);
+					}
+				},
+				columns: [
+					{ data: 'id' },
+					{ data: 'name' },
+					{ data: 'account_name' },
+					{
+						data: 'last_login',
+						render: function(data) {
+							if (data === 0) return 'Never';
+							const date = new Date(data * 1000);
+							return date.toLocaleString();
+						}
+					},
+					{
+						data: 'id',
+						render: function(data) {
+							return '<div class="account-actions">' +
+								'<button class="btn btn-sm btn-info" onclick="viewCharacter(' + data + ')" title="View">👁️</button>' +
+								'<button class="btn btn-sm btn-warning" onclick="editCharacter(' + data + ')" title="Edit">✏️</button>' +
+								'</div>';
+						},
+						orderable: false,
+						searchable: false
+					}
+				],
+				order: [[0, 'asc']],
+				stateSave: false
+			});
+		});
+
+		function viewCharacter(id) {
+			alert('View character: ' + id);
+			// TODO: Implement character view modal
+		}
+
+		function editCharacter(id) {
+			alert('Edit character: ' + id);
+			// TODO: Implement character edit modal
+		}
+	</script>
+{% endblock %}

dDashboardServer/templates/header.jinja2

@@ -0,0 +1,30 @@
+{# Navigation #}
+<nav class="navbar navbar-dark bg-dark flex-column" style="width: 280px; height: 100vh; position: fixed; left: 0; top: 0; overflow-y: auto;">
+	<div class="p-3">
+		<a class="navbar-brand fw-bold" href="/">🎮 DarkflameServer</a>
+	</div>
+
+	<ul class="navbar-nav flex-column w-100 flex-grow-1 p-3">
+		<li class="nav-item">
+			<a class="nav-link" href="/">Home</a>
+		</li>
+		<li class="nav-item">
+			<a class="nav-link" href="/accounts">Accounts</a>
+		</li>
+		<li class="nav-item">
+			<a class="nav-link" href="/characters">Characters</a>
+		</li>
+		<li class="nav-item">
+			<a class="nav-link" href="/play_keys">Play Keys</a>
+		</li>
+		<li class="nav-item">
+			<a class="nav-link" href="/properties">Properties</a>
+		</li>
+		<li class="nav-item">
+			<a class="nav-link" href="/bug_reports">Bug Reports</a>
+		</li>
+		<li class="nav-item mt-auto">
+			<a class="nav-link" href="#" id="logoutBtn">Logout</a>
+		</li>
+	</ul>
+</nav>

dDashboardServer/templates/index.jinja2

@@ -0,0 +1,35 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Dashboard - DarkflameServer{% endblock %}
+
+{% block content %}
+	<!-- Main Content -->
+	<main style="margin-left: 280px;">
+		<div class="container-fluid p-3 p-md-4">
+
+			<div class="row g-3">
+				{% include "server_status.jinja2" %}
+				{% include "statistics.jinja2" %}
+			</div>
+
+			{% include "world_instances.jinja2" %}
+		</div>
+	</main>
+{% endblock %}
+
+{% block scripts %}
+	<script src="/js/dashboard.js"></script>
+	<script>
+		// Check authentication and initialize dashboard
+		document.addEventListener('DOMContentLoaded', () => {
+			// checkAuthentication is now async and calls connectWebSocket when ready
+			checkAuthentication();
+			
+			// Setup logout button
+			document.getElementById('logoutBtn').addEventListener('click', (e) => {
+				e.preventDefault();
+				logout();
+			});
+		});
+	</script>
+{% endblock %}

dDashboardServer/templates/login.jinja2

@@ -0,0 +1,53 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Dashboard Login - DarkflameServer{% endblock %}
+
+{% block extra_css %}
+	<link rel="stylesheet" href="/css/login.css">
+{% endblock %}
+
+{% block content %}
+	<div class="min-vh-100 d-flex align-items-center justify-content-center">
+		<div class="container">
+			<div class="row justify-content-center">
+				<div class="col-md-6 col-lg-5">
+					<div class="card shadow-lg border-0">
+						<div class="card-body p-5">
+							<h1 class="text-center mb-4">🎮 DarkflameServer</h1>
+							
+							<div id="alert" class="alert" role="alert" style="display: none;"></div>
+							
+							<form id="loginForm">
+								<div class="mb-3">
+									<label for="username" class="form-label">Username</label>
+									<input type="text" class="form-control" id="username" name="username" required autofocus>
+								</div>
+								
+								<div class="mb-3">
+									<label for="password" class="form-label">Password</label>
+									<input type="password" class="form-control" id="password" name="password" required maxlength="40">
+								</div>
+								
+								<div class="mb-3 form-check">
+									<input type="checkbox" class="form-check-input" id="rememberMe" name="rememberMe">
+									<label class="form-check-label" for="rememberMe">
+										Remember me for 30 days
+									</label>
+								</div>
+								
+								<button type="submit" class="btn btn-primary w-100" id="loginBtn">
+									<span id="loading" class="spinner-border spinner-border-sm me-2" role="status" aria-hidden="true" style="display: none;"></span>
+									<span>Login</span>
+								</button>
+							</form>
+						</div>
+					</div>
+				</div>
+			</div>
+		</div>
+	</div>
+{% endblock %}
+
+{% block scripts %}
+	<script src="/js/login.js"></script>
+{% endblock %}

dDashboardServer/templates/play_keys.jinja2

@@ -0,0 +1,95 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Play Keys - DarkflameServer{% endblock %}
+
+{% block css %}{% endblock %}
+
+{% block content %}
+	<div class="play-keys-container">
+		<div class="table-card">
+			<div class="table-header">
+				<h2 class="mb-0">Play Keys</h2>
+				<p class="text-muted">View and manage play keys</p>
+			</div>
+			<div class="table-body">
+				<table id="playKeysTable" class="table table-dark table-striped table-hover">
+					<thead>
+						<tr>
+							<th>ID</th>
+							<th>Key String</th>
+							<th>Uses Remaining</th>
+							<th>Created</th>
+							<th>Status</th>
+							<th>Actions</th>
+						</tr>
+					</thead>
+					<tbody>
+						<!-- Data populated by DataTables -->
+					</tbody>
+				</table>
+			</div>
+		</div>
+	</div>
+{% endblock %}
+
+{% block scripts %}
+	<script>
+		$(document).ready(function() {
+			// Initialize DataTable with server-side processing
+			$('#playKeysTable').DataTable({
+				processing: true,
+				serverSide: true,
+				pageLength: 25,
+				lengthMenu: [10, 25, 50, 100],
+				ajax: {
+					url: '/api/tables/play_keys',
+					type: 'POST',
+					contentType: 'application/json',
+					data: function(d) {
+						return JSON.stringify(d);
+					}
+				},
+				columns: [
+					{ data: 'id' },
+					{ data: 'key_string' },
+					{ data: 'key_uses' },
+					{
+						data: 'created_at',
+						render: function(data) {
+							return data ? new Date(data).toLocaleString() : '-';
+						}
+					},
+					{
+						data: 'active',
+						render: function(data) {
+							return data ? '<span class="badge badge-active">Active</span>' : '<span class="badge badge-inactive">Inactive</span>';
+						}
+					},
+					{
+						data: 'id',
+						render: function(data) {
+							return '<div class="account-actions">' +
+								'<button class="btn btn-sm btn-info" onclick="viewKey(' + data + ')" title="View">👁️</button>' +
+								'<button class="btn btn-sm btn-warning" onclick="editKey(' + data + ')" title="Edit">✏️</button>' +
+								'</div>';
+						},
+						orderable: false,
+						searchable: false
+					}
+				],
+				order: [[0, 'asc']],
+				stateSave: false
+			});
+		});
+
+		function viewKey(id) {
+			alert('View key: ' + id);
+			// TODO: Implement key view modal
+		}
+
+		function editKey(id) {
+			alert('Edit key: ' + id);
+			// TODO: Implement key edit modal
+		}
+	</script>
+{% endblock %}

dDashboardServer/templates/properties.jinja2

@@ -0,0 +1,92 @@
+{% extends "base.jinja2" %}
+
+{% block title %}Properties - DarkflameServer{% endblock %}
+
+{% block css %}{% endblock %}
+
+{% block content %}
+	<div class="properties-container">
+		<div class="table-card">
+			<div class="table-header">
+				<h2 class="mb-0">Properties</h2>
+				<p class="text-muted">View and manage player properties</p>
+			</div>
+			<div class="table-body">
+				<table id="propertiesTable" class="table table-dark table-striped table-hover">
+					<thead>
+						<tr>
+							<th>ID</th>
+							<th>Name</th>
+							<th>Owner ID</th>
+							<th>Moderation Status</th>
+							<th>Reputation</th>
+							<th>Zone</th>
+							<th>Actions</th>
+						</tr>
+					</thead>
+					<tbody>
+						<!-- Data populated by DataTables -->
+					</tbody>
+				</table>
+			</div>
+		</div>
+	</div>
+{% endblock %}
+
+{% block scripts %}
+	<script>
+		$(document).ready(function() {
+			// Initialize DataTable with server-side processing
+			$('#propertiesTable').DataTable({
+				processing: true,
+				serverSide: true,
+				pageLength: 25,
+				lengthMenu: [10, 25, 50, 100],
+				ajax: {
+					url: '/api/tables/properties',
+					type: 'POST',
+					contentType: 'application/json',
+					data: function(d) {
+						return JSON.stringify(d);
+					}
+				},
+				columns: [
+					{ data: 'id' },
+					{ data: 'name' },
+					{ data: 'owner_id' },
+					{
+						data: 'mod_approved',
+						render: function(data) {
+							return data ? '<span class="badge badge-approved">Approved</span>' : '<span class="badge badge-pending">Pending</span>';
+						}
+					},
+					{ data: 'reputation' },
+					{ data: 'zone_id' },
+					{
+						data: 'id',
+						render: function(data) {
+							return '<div class="account-actions">' +
+								'<button class="btn btn-sm btn-info" onclick="viewProperty(' + data + ')" title="View">👁️</button>' +
+								'<button class="btn btn-sm btn-warning" onclick="editProperty(' + data + ')" title="Edit">✏️</button>' +
+								'</div>';
+						},
+						orderable: false,
+						searchable: false
+					}
+				],
+				order: [[0, 'asc']],
+				stateSave: false
+			});
+		});
+
+		function viewProperty(id) {
+			alert('View property: ' + id);
+			// TODO: Implement property view modal
+		}
+
+		function editProperty(id) {
+			alert('Edit property: ' + id);
+			// TODO: Implement property edit modal
+		}
+	</script>
+{% endblock %}

dDashboardServer/templates/server_status.jinja2

@@ -0,0 +1,29 @@
+<div class="col-md-6 col-lg-4">
+	<div class="card border-0 shadow-sm h-100">
+		<div class="card-header bg-light">
+			<h5 class="mb-0">Server Status</h5>
+		</div>
+		<div class="card-body">
+			<div class="d-flex justify-content-between align-items-center mb-3">
+				<span>Auth Server</span>
+				{% if auth.online %}
+					<span class="badge bg-success" id="auth-status">Online</span>
+				{% else %}
+					<span class="badge bg-danger" id="auth-status">Offline</span>
+				{% endif %}
+			</div>
+			<div class="d-flex justify-content-between align-items-center mb-3">
+				<span>Chat Server</span>
+				{% if chat.online %}
+					<span class="badge bg-success" id="chat-status">Online</span>
+				{% else %}
+					<span class="badge bg-danger" id="chat-status">Offline</span>
+				{% endif %}
+			</div>
+			<div class="d-flex justify-content-between align-items-center">
+				<span>Active Worlds</span>
+				<span class="badge bg-primary" id="world-count">{{ length(worlds) }}</span>
+			</div>
+		</div>
+	</div>
+</div>

dDashboardServer/templates/statistics.jinja2

@@ -0,0 +1,21 @@
+<div class="col-md-6 col-lg-4">
+	<div class="card border-0 shadow-sm h-100">
+		<div class="card-header bg-light">
+			<h5 class="mb-0">Statistics</h5>
+		</div>
+		<div class="card-body">
+			<div class="d-flex justify-content-between align-items-center mb-3">
+				<span>Online Players</span>
+				<span class="badge bg-info" id="online-players">{{ stats.onlinePlayers }}</span>
+			</div>
+			<div class="d-flex justify-content-between align-items-center mb-3">
+				<span>Total Accounts</span>
+				<span class="badge bg-info" id="total-accounts">{{ stats.totalAccounts }}</span>
+			</div>
+			<div class="d-flex justify-content-between align-items-center">
+				<span>Total Characters</span>
+				<span class="badge bg-info" id="total-characters">{{ stats.totalCharacters }}</span>
+			</div>
+		</div>
+	</div>
+</div>

dDashboardServer/templates/world_instances.jinja2

@@ -0,0 +1,37 @@
+<div class="card border-0 shadow-sm mt-4">
+	<div class="card-header bg-light">
+		<h5 class="mb-0">Active World Instances</h5>
+	</div>
+	<div class="card-body">
+		<div id="world-list">
+			{% if length(worlds) == 0 %}
+				<p class="text-muted text-center mb-0">No active world instances</p>
+			{% else %}
+				<div class="table-responsive">
+					<table class="table table-sm mb-0">
+						<thead class="table-light">
+							<tr>
+								<th>Zone</th>
+								<th>Instance</th>
+								<th>Clone</th>
+								<th>Players</th>
+								<th>Type</th>
+							</tr>
+						</thead>
+						<tbody>
+							{% for world in worlds %}
+							<tr>
+								<td>{{ world.mapID }}</td>
+								<td>{{ world.instanceID }}</td>
+								<td>{{ world.cloneID }}</td>
+								<td><span class="badge bg-secondary">{{ world.players }}</span></td>
+								<td>{% if world.isPrivate %}<span class="badge bg-warning">Private</span>{% else %}<span class="badge bg-primary">Public</span>{% endif %}</td>
+							</tr>
+							{% endfor %}
+						</tbody>
+					</table>
+				</div>
+			{% endif %}
+		</div>
+	</div>
+</div>

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.cpp

@@ -1,6 +1,5 @@
 #include "CDActivitiesTable.h"
 
-
 void CDActivitiesTable::LoadValuesFromDatabase() {
 	// First, get the size of the table
 	uint32_t size = 0;
@@ -56,3 +55,13 @@ std::vector<CDActivities> CDActivitiesTable::Query(std::function<bool(CDActiviti
 
 	return data;
 }
+
+std::optional<const CDActivities> CDActivitiesTable::GetActivity(const uint32_t activityID) {
+	auto& entries = GetEntries();
+	for (const auto& entry : entries) {
+		if (entry.ActivityID == activityID) {
+			return entry;
+		}
+	}
+	return std::nullopt;
+}

dDatabase/CDClientDatabase/CDClientTables/CDActivitiesTable.h

@@ -2,6 +2,7 @@
 
 // Custom Classes
 #include "CDTable.h"
+#include <optional>
 
 struct CDActivities {
 	uint32_t ActivityID;
@@ -31,4 +32,5 @@ public:
 
 	// Queries the table with a custom "where" clause
 	std::vector<CDActivities> Query(std::function<bool(CDActivities)> predicate);
+	std::optional<const CDActivities> GetActivity(const uint32_t activityID);
 };

dDatabase/GameDatabase/ITables/IAccounts.h

@@ -5,6 +5,7 @@
 #include <optional>
 #include <string>
 #include <string_view>
+#include "json.hpp"
 
 enum class eGameMasterLevel : uint8_t;
 
@@ -39,6 +40,30 @@ public:
 	virtual void UpdateAccountGmLevel(const uint32_t accountId, const eGameMasterLevel gmLevel) = 0;
 
 	virtual uint32_t GetAccountCount() = 0;
+
+	// Login attempt tracking methods
+	// Record a failed login attempt
+	virtual void RecordFailedAttempt(const uint32_t accountId) = 0;
+
+	// Clear failed login attempts and update last login time
+	virtual void ClearFailedAttempts(const uint32_t accountId) = 0;
+
+	// Set account lockout
+	virtual void SetLockout(const uint32_t accountId, const int64_t lockoutUntil) = 0;
+
+	// Check if account is locked out
+	virtual bool IsLockedOut(const uint32_t accountId) = 0;
+
+	// Get failed attempt count
+	virtual uint8_t GetFailedAttempts(const uint32_t accountId) = 0;
+
+	// Get paginated list of accounts with optional search/filtering for DataTables
+	// Returns a JSON object with the account data and metadata
+	virtual nlohmann::json GetAccountsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) = 0;
+
+	// Get a single account by ID
+	// Returns a JSON object with the account details
+	virtual nlohmann::json GetAccountById(uint32_t accountId) = 0;
 };
 
 #endif  //!__IACCOUNTS__H__

dDatabase/GameDatabase/ITables/IBugReports.h

@@ -2,6 +2,7 @@
 #define __IBUGREPORTS__H__
 
 #include <cstdint>
+#include <string>
 #include <string_view>
 
 class IBugReports {
@@ -16,5 +17,9 @@ public:
 
 	// Add a new bug report to the database.
 	virtual void InsertNewBugReport(const Info& info) = 0;
+
+	// Get paginated list of bug reports with optional search/filtering for DataTables
+	// Returns a JSON-formatted string with the bug report data and metadata
+	virtual std::string GetBugReportsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) = 0;
 };
 #endif  //!__IBUGREPORTS__H__

dDatabase/GameDatabase/ITables/ICharInfo.h

@@ -33,6 +33,9 @@ public:
 	// Get the character ids for the given account.
 	virtual std::vector<LWOOBJID> GetAccountCharacterIds(const LWOOBJID accountId) = 0;
 
+	// Get the total number of characters in the database.
+	virtual uint32_t GetCharacterCount() = 0;
+
 	// Insert a new character into the database.
 	virtual void InsertNewCharacter(const ICharInfo::Info info) = 0;
 

dDatabase/GameDatabase/ITables/ICharXml.h

@@ -15,6 +15,10 @@ public:
 
 	// Insert the character xml for the given character id.
 	virtual void InsertCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) = 0;
+
+	// Get paginated list of characters with optional search/filtering for DataTables
+	// Returns a JSON-formatted string with the character data and metadata
+	virtual std::string GetCharactersTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) = 0;
 };
 
 #endif  //!__ICHARXML__H__

dDatabase/GameDatabase/ITables/IPlayKeys.h

@@ -3,6 +3,8 @@
 
 #include <cstdint>
 #include <optional>
+#include <string>
+#include <string_view>
 
 class IPlayKeys {
 public:
@@ -10,6 +12,10 @@ public:
 	// Optional of bool may seem pointless, however the optional indicates if the playkey exists
 	// and the bool indicates if the playkey is active.
 	virtual std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) = 0;
+
+	// Get paginated list of play keys with optional search/filtering for DataTables
+	// Returns a JSON-formatted string with the play key data and metadata
+	virtual std::string GetPlayKeysTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) = 0;
 };
 
 #endif  //!__IPLAYKEYS__H__

dDatabase/GameDatabase/ITables/IProperty.h

@@ -64,5 +64,9 @@ public:
 	
 	// Insert a new property into the database.
 	virtual void InsertNewProperty(const IProperty::Info& info, const uint32_t templateId, const LWOZONEID& zoneId) = 0;
+
+	// Get paginated list of properties with optional search/filtering for DataTables
+	// Returns a JSON-formatted string with the property data and metadata
+	virtual std::string GetPropertiesTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) = 0;
 };
 #endif  //!__IPROPERTY__H__

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -60,6 +60,7 @@ public:
 	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
 	void InsertNewCharacter(const ICharInfo::Info info) override;
 	void InsertCharacterXml(const LWOOBJID accountId, const std::string_view lxfml) override;
+	std::string GetCharactersTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 	std::vector<LWOOBJID> GetAccountCharacterIds(LWOOBJID accountId) override;
 	void DeleteCharacter(const LWOOBJID characterId) override;
 	void SetCharacterName(const LWOOBJID characterId, const std::string_view name) override;
@@ -79,6 +80,7 @@ public:
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
+	std::string GetBugReportsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
@@ -103,6 +105,7 @@ public:
 	void InsertDefaultPersistentId() override;
 	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
 	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
+	std::string GetPlayKeysTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
 	void AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
 	void RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
@@ -126,10 +129,19 @@ public:
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
+	uint32_t GetCharacterCount() override;
+	void RecordFailedAttempt(const uint32_t accountId) override;
+	void ClearFailedAttempts(const uint32_t accountId) override;
+	void SetLockout(const uint32_t accountId, const int64_t lockoutUntil) override;
+	bool IsLockedOut(const uint32_t accountId) override;
+	uint8_t GetFailedAttempts(const uint32_t accountId) override;
+	nlohmann::json GetAccountsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
+	nlohmann::json GetAccountById(uint32_t accountId) override;
 	bool IsNameInUse(const std::string_view name) override;
 	std::optional<IPropertyContents::Model> GetModel(const LWOOBJID modelID) override;
 	std::optional<IUgc::Model> GetUgcModel(const LWOOBJID ugcId) override;
 	std::optional<IProperty::Info> GetPropertyInfo(const LWOOBJID id) override;
+	std::string GetPropertiesTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
 private:
 

dDatabase/GameDatabase/MySQL/Tables/Accounts.cpp

@@ -1,6 +1,7 @@
 #include "MySQLDatabase.h"
 
 #include "eGameMasterLevel.h"
+#include "json.hpp"
 
 std::optional<IAccounts::Info> MySQLDatabase::GetAccountInfo(const std::string_view username) {
 	auto result = ExecuteSelect("SELECT id, password, banned, locked, play_key_id, gm_level, mute_expire FROM accounts WHERE name = ? LIMIT 1;", username);
@@ -45,3 +46,142 @@ uint32_t MySQLDatabase::GetAccountCount() {
 	auto res = ExecuteSelect("SELECT COUNT(*) as count FROM accounts;");
 	return res->next() ? res->getUInt("count") : 0;
 }
+
+void MySQLDatabase::RecordFailedAttempt(const uint32_t accountId) {
+	ExecuteUpdate("UPDATE accounts SET failed_attempts = failed_attempts + 1 WHERE id = ?;", accountId);
+}
+
+void MySQLDatabase::ClearFailedAttempts(const uint32_t accountId) {
+	ExecuteUpdate("UPDATE accounts SET failed_attempts = 0, lockout_time = NULL, last_login = NOW() WHERE id = ?;", accountId);
+}
+
+void MySQLDatabase::SetLockout(const uint32_t accountId, const int64_t lockoutUntil) {
+	ExecuteUpdate("UPDATE accounts SET lockout_time = FROM_UNIXTIME(?) WHERE id = ?;", lockoutUntil, accountId);
+}
+
+bool MySQLDatabase::IsLockedOut(const uint32_t accountId) {
+	auto result = ExecuteSelect("SELECT lockout_time FROM accounts WHERE id = ?;", accountId);
+	if (!result->next()) {
+		return false;
+	}
+
+	// If lockout_time is set and in the future, account is locked
+	const char* lockoutTime = result->getString("lockout_time").c_str();
+	if (lockoutTime == nullptr || strlen(lockoutTime) == 0) {
+		return false;
+	}
+
+	// Simplified check - if lockout_time exists and is not null, it's locked
+	return true;
+}
+
+uint8_t MySQLDatabase::GetFailedAttempts(const uint32_t accountId) {
+	auto result = ExecuteSelect("SELECT failed_attempts FROM accounts WHERE id = ?;", accountId);
+	if (!result->next()) {
+		return 0;
+	}
+
+	return result->getUInt("failed_attempts");
+}
+
+nlohmann::json MySQLDatabase::GetAccountsTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, name, banned, locked, gm_level, mute_expire, created_at FROM accounts";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE name LIKE CONCAT('%', ?, '%')";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "name"; break;
+		case 2: orderColumnName = "banned"; break;
+		case 3: orderColumnName = "locked"; break;
+		case 4: orderColumnName = "gm_level"; break;
+		case 5: orderColumnName = "mute_expire"; break;
+		case 6: orderColumnName = "created_at"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ?, ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM accounts;";
+	auto totalCountResult = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult->next() ? totalCountResult->getUInt("count") : 0;
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM accounts WHERE name LIKE CONCAT('%', ?, '%');";
+		auto filteredCountResult = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult->next() ? filteredCountResult->getUInt("count") : 0;
+	}
+
+	// Execute main query
+	std::unique_ptr<sql::ResultSet> result;
+	if (!search.empty()) {
+		result = ExecuteSelect(mainQuery, search, start, length);
+	} else {
+		result = ExecuteSelect(mainQuery, start, length);
+	}
+
+	// Build response JSON
+	nlohmann::json accountsArray = nlohmann::json::array();
+
+	while (result->next()) {
+		nlohmann::json account = {
+			{"id", result->getUInt("id")},
+			{"name", result->getString("name")},
+			{"banned", result->getBoolean("banned")},
+			{"locked", result->getBoolean("locked")},
+			{"gm_level", result->getInt("gm_level")},
+			{"mute_expire", result->getUInt64("mute_expire")},
+			{"created_at", result->getString("created_at")}
+		};
+		accountsArray.push_back(account);
+	}
+
+	nlohmann::json response = {
+		{"draw", 1},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", accountsArray}
+	};
+
+	return response;
+}
+
+nlohmann::json MySQLDatabase::GetAccountById(uint32_t accountId) {
+	try {
+		const std::string query = "SELECT id, name, banned, locked, gm_level, mute_expire, created_at FROM accounts WHERE id = ?;";
+		auto result = ExecuteSelect(query, accountId);
+
+		if (!result->next()) {
+			return nlohmann::json{{"error", "Account not found"}};
+		}
+
+		nlohmann::json account = {
+			{"id", result->getUInt("id")},
+			{"name", result->getString("name")},
+			{"banned", result->getBoolean("banned")},
+			{"locked", result->getBoolean("locked")},
+			{"gm_level", result->getInt("gm_level")},
+			{"mute_expire", result->getUInt64("mute_expire")},
+			{"created_at", result->getString("created_at")}
+		};
+
+		return account;
+	} catch (const sql::SQLException& e) {
+		LOG_DEBUG("SQL Error: %s", e.what());
+		return nlohmann::json{{"error", "Database error"}};
+	}
+}

dDatabase/GameDatabase/MySQL/Tables/BugReports.cpp

@@ -4,3 +4,77 @@ void MySQLDatabase::InsertNewBugReport(const IBugReports::Info& info) {
 	ExecuteInsert("INSERT INTO `bug_reports`(body, client_version, other_player_id, selection, reporter_id) VALUES (?, ?, ?, ?, ?)",
 		info.body, info.clientVersion, info.otherPlayer, info.selection, info.characterId);
 }
+
+#include "json.hpp"
+
+std::string MySQLDatabase::GetBugReportsTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, body, client_version, other_player_id, selection, submitted FROM bug_reports";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE body LIKE CONCAT('%', ?, '%') OR other_player_id LIKE CONCAT('%', ?, '%')";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "other_player_id"; break;
+		case 2: orderColumnName = "client_version"; break;
+		case 3: orderColumnName = "submitted"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ?, ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM bug_reports;";
+	auto totalCountResult = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult->next() ? totalCountResult->getUInt("count") : 0;
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM bug_reports WHERE body LIKE CONCAT('%', ?, '%') OR other_player_id LIKE CONCAT('%', ?, '%');";
+		auto filteredCountResult = ExecuteSelect(filteredCountQuery, search, search);
+		filteredRecords = filteredCountResult->next() ? filteredCountResult->getUInt("count") : 0;
+	}
+
+	// Execute main query
+	std::unique_ptr<sql::ResultSet> result;
+	if (!search.empty()) {
+		result = ExecuteSelect(mainQuery, search, search, start, length);
+	} else {
+		result = ExecuteSelect(mainQuery, start, length);
+	}
+
+	// Build response JSON
+	nlohmann::json reportsArray = nlohmann::json::array();
+
+	while (result->next()) {
+		nlohmann::json report = {
+			{"id", result->getUInt("id")},
+			{"other_player_id", result->getString("other_player_id")},
+			{"client_version", result->getString("client_version")},
+			{"selection", result->getString("selection")},
+			{"submitted", result->getString("submitted")},
+			{"body", result->getString("body")}
+		};
+		reportsArray.push_back(report);
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", reportsArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/MySQL/Tables/CharInfo.cpp

@@ -54,6 +54,11 @@ std::vector<LWOOBJID> MySQLDatabase::GetAccountCharacterIds(const LWOOBJID accou
 	return toReturn;
 }
 
+uint32_t MySQLDatabase::GetCharacterCount() {
+	auto res = ExecuteSelect("SELECT COUNT(*) as count FROM charinfo;");
+	return res->next() ? res->getUInt("count") : 0;
+}
+
 void MySQLDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 	ExecuteInsert(
 		"INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`) VALUES (?,?,?,?,?,?)",

dDatabase/GameDatabase/MySQL/Tables/CharXml.cpp

@@ -17,3 +17,75 @@ void MySQLDatabase::UpdateCharacterXml(const LWOOBJID charId, const std::string_
 void MySQLDatabase::InsertCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) {
 	ExecuteInsert("INSERT INTO `charxml` (`id`, `xml_data`) VALUES (?,?)", characterId, lxfml);
 }
+
+#include "json.hpp"
+
+std::string MySQLDatabase::GetCharactersTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT c.id, c.name, c.account_id, c.last_login, a.name as account_name FROM charinfo c JOIN accounts a ON c.account_id = a.id";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE c.name LIKE CONCAT('%', ?, '%')";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "c.id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "c.id"; break;
+		case 1: orderColumnName = "c.name"; break;
+		case 2: orderColumnName = "a.name"; break;
+		case 3: orderColumnName = "c.last_login"; break;
+		default: orderColumnName = "c.id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ?, ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM charinfo;";
+	auto totalCountResult = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult->next() ? totalCountResult->getUInt("count") : 0;
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM charinfo WHERE name LIKE CONCAT('%', ?, '%');";
+		auto filteredCountResult = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult->next() ? filteredCountResult->getUInt("count") : 0;
+	}
+
+	// Execute main query
+	std::unique_ptr<sql::ResultSet> result;
+	if (!search.empty()) {
+		result = ExecuteSelect(mainQuery, search, start, length);
+	} else {
+		result = ExecuteSelect(mainQuery, start, length);
+	}
+
+	// Build response JSON
+	nlohmann::json charactersArray = nlohmann::json::array();
+
+	while (result->next()) {
+		nlohmann::json character = {
+			{"id", result->getUInt64("id")},
+			{"name", result->getString("name")},
+			{"account_name", result->getString("account_name")},
+			{"last_login", result->getUInt64("last_login")}
+		};
+		charactersArray.push_back(character);
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", charactersArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/MySQL/Tables/PlayKeys.cpp

@@ -9,3 +9,77 @@ std::optional<bool> MySQLDatabase::IsPlaykeyActive(const int32_t playkeyId) {
 
 	return keyCheckRes->getBoolean("active");
 }
+
+#include "json.hpp"
+
+std::string MySQLDatabase::GetPlayKeysTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, key_string, key_uses, created_at, active FROM play_keys";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE key_string LIKE CONCAT('%', ?, '%')";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "key_string"; break;
+		case 2: orderColumnName = "key_uses"; break;
+		case 3: orderColumnName = "created_at"; break;
+		case 4: orderColumnName = "active"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ?, ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM play_keys;";
+	auto totalCountResult = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult->next() ? totalCountResult->getUInt("count") : 0;
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM play_keys WHERE key_string LIKE CONCAT('%', ?, '%');";
+		auto filteredCountResult = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult->next() ? filteredCountResult->getUInt("count") : 0;
+	}
+
+	// Execute main query
+	std::unique_ptr<sql::ResultSet> result;
+	if (!search.empty()) {
+		result = ExecuteSelect(mainQuery, search, start, length);
+	} else {
+		result = ExecuteSelect(mainQuery, start, length);
+	}
+
+	// Build response JSON
+	nlohmann::json keysArray = nlohmann::json::array();
+
+	while (result->next()) {
+		nlohmann::json key = {
+			{"id", result->getUInt("id")},
+			{"key_string", result->getString("key_string")},
+			{"key_uses", result->getUInt("key_uses")},
+			{"created_at", result->getString("created_at")},
+			{"active", result->getBoolean("active")}
+		};
+		keysArray.push_back(key);
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", keysArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/MySQL/Tables/Property.cpp

@@ -198,3 +198,79 @@ std::optional<IProperty::Info> MySQLDatabase::GetPropertyInfo(const LWOOBJID id)
 
 	return ReadPropertyInfo(propertyEntry);
 }
+
+#include "json.hpp"
+
+std::string MySQLDatabase::GetPropertiesTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, owner_id, name, mod_approved, reputation, zone_id FROM properties";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE name LIKE CONCAT('%', ?, '%')";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "name"; break;
+		case 2: orderColumnName = "owner_id"; break;
+		case 3: orderColumnName = "mod_approved"; break;
+		case 4: orderColumnName = "reputation"; break;
+		case 5: orderColumnName = "zone_id"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ?, ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM properties;";
+	auto totalCountResult = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult->next() ? totalCountResult->getUInt("count") : 0;
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM properties WHERE name LIKE CONCAT('%', ?, '%');";
+		auto filteredCountResult = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult->next() ? filteredCountResult->getUInt("count") : 0;
+	}
+
+	// Execute main query
+	std::unique_ptr<sql::ResultSet> result;
+	if (!search.empty()) {
+		result = ExecuteSelect(mainQuery, search, start, length);
+	} else {
+		result = ExecuteSelect(mainQuery, start, length);
+	}
+
+	// Build response JSON
+	nlohmann::json propertiesArray = nlohmann::json::array();
+
+	while (result->next()) {
+		nlohmann::json property = {
+			{"id", result->getUInt64("id")},
+			{"owner_id", result->getUInt64("owner_id")},
+			{"name", result->getString("name")},
+			{"mod_approved", result->getBoolean("mod_approved")},
+			{"reputation", result->getUInt64("reputation")},
+			{"zone_id", result->getUInt("zone_id")}
+		};
+		propertiesArray.push_back(property);
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", propertiesArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -58,6 +58,7 @@ public:
 	std::optional<IAccounts::Info> GetAccountInfo(const std::string_view username) override;
 	void InsertNewCharacter(const ICharInfo::Info info) override;
 	void InsertCharacterXml(const LWOOBJID accountId, const std::string_view lxfml) override;
+	std::string GetCharactersTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 	std::vector<LWOOBJID> GetAccountCharacterIds(LWOOBJID accountId) override;
 	void DeleteCharacter(const LWOOBJID characterId) override;
 	void SetCharacterName(const LWOOBJID characterId, const std::string_view name) override;
@@ -77,6 +78,7 @@ public:
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
+	std::string GetBugReportsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
@@ -101,6 +103,7 @@ public:
 	void InsertDefaultPersistentId() override;
 	std::optional<uint32_t> GetDonationTotal(const uint32_t activityId) override;
 	std::optional<bool> IsPlaykeyActive(const int32_t playkeyId) override;
+	std::string GetPlayKeysTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 	std::vector<IUgc::Model> GetUgcModels(const LWOOBJID& propertyId) override;
 	void AddIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
 	void RemoveIgnore(const LWOOBJID playerId, const LWOOBJID ignoredPlayerId) override;
@@ -124,10 +127,19 @@ public:
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
+	uint32_t GetCharacterCount() override;
+	void RecordFailedAttempt(const uint32_t accountId) override;
+	void ClearFailedAttempts(const uint32_t accountId) override;
+	void SetLockout(const uint32_t accountId, const int64_t lockoutUntil) override;
+	bool IsLockedOut(const uint32_t accountId) override;
+	uint8_t GetFailedAttempts(const uint32_t accountId) override;
+	nlohmann::json GetAccountsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
+	nlohmann::json GetAccountById(uint32_t accountId) override;
 	bool IsNameInUse(const std::string_view name) override;
 	std::optional<IPropertyContents::Model> GetModel(const LWOOBJID modelID) override;
 	std::optional<IUgc::Model> GetUgcModel(const LWOOBJID ugcId) override;
 	std::optional<IProperty::Info> GetPropertyInfo(const LWOOBJID id) override;
+	std::string GetPropertiesTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override;
 private:
 	CppSQLite3Statement CreatePreppedStmt(const std::string& query);
 

dDatabase/GameDatabase/SQLite/Tables/Accounts.cpp

@@ -2,6 +2,7 @@
 
 #include "eGameMasterLevel.h"
 #include "Database.h"
+#include "json.hpp"
 
 std::optional<IAccounts::Info> SQLiteDatabase::GetAccountInfo(const std::string_view username) {
 	auto [_, result] = ExecuteSelect("SELECT * FROM accounts WHERE name = ? LIMIT 1", username);
@@ -48,3 +49,137 @@ uint32_t SQLiteDatabase::GetAccountCount() {
 
 	return res.getIntField("count");
 }
+void SQLiteDatabase::RecordFailedAttempt(const uint32_t accountId) {
+	ExecuteUpdate("UPDATE accounts SET failed_attempts = failed_attempts + 1 WHERE id = ?;", accountId);
+}
+
+void SQLiteDatabase::ClearFailedAttempts(const uint32_t accountId) {
+	ExecuteUpdate("UPDATE accounts SET failed_attempts = 0, lockout_time = NULL, last_login = CURRENT_TIMESTAMP WHERE id = ?;", accountId);
+}
+
+void SQLiteDatabase::SetLockout(const uint32_t accountId, const int64_t lockoutUntil) {
+	ExecuteUpdate("UPDATE accounts SET lockout_time = datetime(?, 'unixepoch') WHERE id = ?;", lockoutUntil, accountId);
+}
+
+bool SQLiteDatabase::IsLockedOut(const uint32_t accountId) {
+	auto [_, result] = ExecuteSelect("SELECT lockout_time FROM accounts WHERE id = ?;", accountId);
+	if (result.eof()) {
+		return false;
+	}
+
+	const char* lockoutTime = result.getStringField("lockout_time");
+	if (lockoutTime == nullptr || strlen(lockoutTime) == 0 || strcmp(lockoutTime, "0") == 0) {
+		return false;
+	}
+
+	// If lockout_time is set and in the future, account is locked
+	// For now, simplified check - if lockout_time exists, it's locked
+	return true;
+}
+
+uint8_t SQLiteDatabase::GetFailedAttempts(const uint32_t accountId) {
+	auto [_, result] = ExecuteSelect("SELECT failed_attempts FROM accounts WHERE id = ?;", accountId);
+	if (result.eof()) {
+		return 0;
+	}
+
+	return result.getIntField("failed_attempts");
+}
+
+nlohmann::json SQLiteDatabase::GetAccountsTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, name, banned, locked, gm_level, mute_expire, created_at FROM accounts";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE name LIKE '%' || ? || '%'";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "name"; break;
+		case 2: orderColumnName = "banned"; break;
+		case 3: orderColumnName = "locked"; break;
+		case 4: orderColumnName = "gm_level"; break;
+		case 5: orderColumnName = "mute_expire"; break;
+		case 6: orderColumnName = "created_at"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ? OFFSET ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM accounts;";
+	auto [_, totalCountResult] = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult.eof() ? 0 : totalCountResult.getIntField("count");
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM accounts WHERE name LIKE '%' || ? || '%';";
+		auto [__, filteredCountResult] = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult.eof() ? 0 : filteredCountResult.getIntField("count");
+	}
+
+	// Execute main query
+	auto [stmt, result] = !search.empty() ? 
+		ExecuteSelect(mainQuery, search, length, start) :
+		ExecuteSelect(mainQuery, length, start);
+
+	// Build response JSON
+	nlohmann::json accountsArray = nlohmann::json::array();
+
+	while (!result.eof()) {
+		nlohmann::json account = {
+			{"id", result.getIntField("id")},
+			{"name", result.getStringField("name")},
+			{"banned", result.getIntField("banned")},
+			{"locked", result.getIntField("locked")},
+			{"gm_level", result.getIntField("gm_level")},
+			{"mute_expire", result.getInt64Field("mute_expire")},
+			{"created_at", result.getStringField("created_at")}
+		};
+		accountsArray.push_back(account);
+		result.nextRow();
+	}
+
+	nlohmann::json response = {
+		{"draw", 1},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", accountsArray}
+	};
+
+	return response;
+}
+nlohmann::json SQLiteDatabase::GetAccountById(uint32_t accountId) {
+	try {
+		auto [_, result] = ExecuteSelect("SELECT * FROM accounts WHERE id = ? LIMIT 1;", accountId);
+
+		if (result.eof()) {
+			return nlohmann::json{{"error", "Account not found"}};
+		}
+
+		nlohmann::json account = {
+			{"id", result.getIntField("id")},
+			{"name", result.getStringField("name")},
+			{"banned", result.getIntField("banned")},
+			{"locked", result.getIntField("locked")},
+			{"gm_level", result.getIntField("gm_level")},
+			{"mute_expire", result.getInt64Field("mute_expire")},
+			{"created_at", result.getStringField("created_at")}
+		};
+
+		return account;
+	} catch (const CppSQLite3Exception& e) {
+		LOG_DEBUG("SQLite Error: %s", e.errorMessage());
+		return nlohmann::json{{"error", "Database error"}};
+	}
+}

dDatabase/GameDatabase/SQLite/Tables/BugReports.cpp

@@ -4,3 +4,75 @@ void SQLiteDatabase::InsertNewBugReport(const IBugReports::Info& info) {
 	ExecuteInsert("INSERT INTO `bug_reports`(body, client_version, other_player_id, selection, reporter_id) VALUES (?, ?, ?, ?, ?)",
 		info.body, info.clientVersion, info.otherPlayer, info.selection, info.characterId);
 }
+
+#include "json.hpp"
+
+std::string SQLiteDatabase::GetBugReportsTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, body, client_version, other_player_id, selection, submitted FROM bug_reports";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE body LIKE '%' || ? || '%' OR other_player_id LIKE '%' || ? || '%'";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "other_player_id"; break;
+		case 2: orderColumnName = "client_version"; break;
+		case 3: orderColumnName = "submitted"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ? OFFSET ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM bug_reports;";
+	auto [__, totalCountResult] = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult.eof() ? 0 : totalCountResult.getIntField("count");
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM bug_reports WHERE body LIKE '%' || ? || '%' OR other_player_id LIKE '%' || ? || '%';";
+		auto [___, filteredCountResult] = ExecuteSelect(filteredCountQuery, search, search);
+		filteredRecords = filteredCountResult.eof() ? 0 : filteredCountResult.getIntField("count");
+	}
+
+	// Execute main query
+	auto [stmt, result] = !search.empty() ? 
+		ExecuteSelect(mainQuery, search, search, length, start) :
+		ExecuteSelect(mainQuery, length, start);
+
+	// Build response JSON
+	nlohmann::json reportsArray = nlohmann::json::array();
+
+	while (!result.eof()) {
+		nlohmann::json report = {
+			{"id", result.getIntField("id")},
+			{"other_player_id", result.getStringField("other_player_id")},
+			{"client_version", result.getStringField("client_version")},
+			{"selection", result.getStringField("selection")},
+			{"submitted", result.getStringField("submitted")},
+			{"body", result.getStringField("body")}
+		};
+		reportsArray.push_back(report);
+		result.nextRow();
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", reportsArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/SQLite/Tables/CharInfo.cpp

@@ -55,6 +55,13 @@ std::vector<LWOOBJID> SQLiteDatabase::GetAccountCharacterIds(const LWOOBJID acco
 	return toReturn;
 }
 
+uint32_t SQLiteDatabase::GetCharacterCount() {
+	auto [_, res] = ExecuteSelect("SELECT COUNT(*) as count FROM charinfo;");
+	if (res.eof()) return 0;
+
+	return res.getIntField("count");
+}
+
 void SQLiteDatabase::InsertNewCharacter(const ICharInfo::Info info) {
 	ExecuteInsert(
 		"INSERT INTO `charinfo`(`id`, `account_id`, `name`, `pending_name`, `needs_rename`, `last_login`, `prop_clone_id`) VALUES (?,?,?,?,?,?,(SELECT IFNULL(MAX(`prop_clone_id`), 0) + 1 FROM `charinfo`))",

dDatabase/GameDatabase/SQLite/Tables/CharXml.cpp

@@ -17,3 +17,73 @@ void SQLiteDatabase::UpdateCharacterXml(const LWOOBJID charId, const std::string
 void SQLiteDatabase::InsertCharacterXml(const LWOOBJID characterId, const std::string_view lxfml) {
 	ExecuteInsert("INSERT INTO `charxml` (`id`, `xml_data`) VALUES (?,?)", characterId, lxfml);
 }
+
+#include "json.hpp"
+
+std::string SQLiteDatabase::GetCharactersTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT c.id, c.name, c.account_id, c.last_login, a.name as account_name FROM charinfo c JOIN accounts a ON c.account_id = a.id";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE c.name LIKE '%' || ? || '%'";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "c.id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "c.id"; break;
+		case 1: orderColumnName = "c.name"; break;
+		case 2: orderColumnName = "a.name"; break;
+		case 3: orderColumnName = "c.last_login"; break;
+		default: orderColumnName = "c.id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ? OFFSET ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM charinfo;";
+	auto [__, totalCountResult] = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult.eof() ? 0 : totalCountResult.getIntField("count");
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM charinfo WHERE name LIKE '%' || ? || '%';";
+		auto [___, filteredCountResult] = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult.eof() ? 0 : filteredCountResult.getIntField("count");
+	}
+
+	// Execute main query
+	auto [stmt, result] = !search.empty() ? 
+		ExecuteSelect(mainQuery, search, length, start) :
+		ExecuteSelect(mainQuery, length, start);
+
+	// Build response JSON
+	nlohmann::json charactersArray = nlohmann::json::array();
+
+	while (!result.eof()) {
+		nlohmann::json character = {
+			{"id", result.getInt64Field("id")},
+			{"name", result.getStringField("name")},
+			{"account_name", result.getStringField("account_name")},
+			{"last_login", result.getInt64Field("last_login")}
+		};
+		charactersArray.push_back(character);
+		result.nextRow();
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", charactersArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/SQLite/Tables/PlayKeys.cpp

@@ -9,3 +9,75 @@ std::optional<bool> SQLiteDatabase::IsPlaykeyActive(const int32_t playkeyId) {
 
 	return keyCheckRes.getIntField("active");
 }
+
+#include "json.hpp"
+
+std::string SQLiteDatabase::GetPlayKeysTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, key_string, key_uses, created_at, active FROM play_keys";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE key_string LIKE '%' || ? || '%'";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "key_string"; break;
+		case 2: orderColumnName = "key_uses"; break;
+		case 3: orderColumnName = "created_at"; break;
+		case 4: orderColumnName = "active"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ? OFFSET ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM play_keys;";
+	auto [__, totalCountResult] = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult.eof() ? 0 : totalCountResult.getIntField("count");
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM play_keys WHERE key_string LIKE '%' || ? || '%';";
+		auto [___, filteredCountResult] = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult.eof() ? 0 : filteredCountResult.getIntField("count");
+	}
+
+	// Execute main query
+	auto [stmt, result] = !search.empty() ? 
+		ExecuteSelect(mainQuery, search, length, start) :
+		ExecuteSelect(mainQuery, length, start);
+
+	// Build response JSON
+	nlohmann::json keysArray = nlohmann::json::array();
+
+	while (!result.eof()) {
+		nlohmann::json key = {
+			{"id", result.getIntField("id")},
+			{"key_string", result.getStringField("key_string")},
+			{"key_uses", result.getIntField("key_uses")},
+			{"created_at", result.getStringField("created_at")},
+			{"active", result.getIntField("active")}
+		};
+		keysArray.push_back(key);
+		result.nextRow();
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", keysArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/SQLite/Tables/Property.cpp

@@ -200,3 +200,77 @@ std::optional<IProperty::Info> SQLiteDatabase::GetPropertyInfo(const LWOOBJID id
 
 	return ReadPropertyInfo(propertyEntry);
 }
+
+#include "json.hpp"
+
+std::string SQLiteDatabase::GetPropertiesTable(uint32_t start, uint32_t length, const std::string_view search, uint32_t orderColumn, bool orderAsc) {
+	// Build base query
+	std::string baseQuery = "SELECT id, owner_id, name, mod_approved, reputation, zone_id FROM properties";
+	std::string whereClause;
+	std::string orderClause;
+
+	// Add search filter if provided
+	if (!search.empty()) {
+		whereClause = " WHERE name LIKE '%' || ? || '%'";
+	}
+
+	// Map column indices to database columns
+	std::string orderColumnName = "id";
+	switch (orderColumn) {
+		case 0: orderColumnName = "id"; break;
+		case 1: orderColumnName = "name"; break;
+		case 2: orderColumnName = "owner_id"; break;
+		case 3: orderColumnName = "mod_approved"; break;
+		case 4: orderColumnName = "reputation"; break;
+		case 5: orderColumnName = "zone_id"; break;
+		default: orderColumnName = "id";
+	}
+
+	orderClause = " ORDER BY " + orderColumnName + (orderAsc ? " ASC" : " DESC");
+
+	// Build the main query
+	std::string mainQuery = baseQuery + whereClause + orderClause + " LIMIT ? OFFSET ?;";
+
+	// Get total count
+	std::string totalCountQuery = "SELECT COUNT(*) as count FROM properties;";
+	auto [__, totalCountResult] = ExecuteSelect(totalCountQuery);
+	uint32_t totalRecords = totalCountResult.eof() ? 0 : totalCountResult.getIntField("count");
+
+	// Get filtered count
+	uint32_t filteredRecords = totalRecords;
+	if (!search.empty()) {
+		std::string filteredCountQuery = "SELECT COUNT(*) as count FROM properties WHERE name LIKE '%' || ? || '%';";
+		auto [___, filteredCountResult] = ExecuteSelect(filteredCountQuery, search);
+		filteredRecords = filteredCountResult.eof() ? 0 : filteredCountResult.getIntField("count");
+	}
+
+	// Execute main query
+	auto [stmt, result] = !search.empty() ? 
+		ExecuteSelect(mainQuery, search, length, start) :
+		ExecuteSelect(mainQuery, length, start);
+
+	// Build response JSON
+	nlohmann::json propertiesArray = nlohmann::json::array();
+
+	while (!result.eof()) {
+		nlohmann::json property = {
+			{"id", result.getInt64Field("id")},
+			{"owner_id", result.getInt64Field("owner_id")},
+			{"name", result.getStringField("name")},
+			{"mod_approved", result.getIntField("mod_approved")},
+			{"reputation", result.getInt64Field("reputation")},
+			{"zone_id", result.getIntField("zone_id")}
+		};
+		propertiesArray.push_back(property);
+		result.nextRow();
+	}
+
+	nlohmann::json response = {
+		{"draw", 0},
+		{"recordsTotal", totalRecords},
+		{"recordsFiltered", filteredRecords},
+		{"data", propertiesArray}
+	};
+
+	return response.dump();
+}

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -103,6 +103,18 @@ class TestSQLDatabase : public GameDatabase {
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<LWOOBJID> characterId) override {};
 	void DeleteUgcBuild(const LWOOBJID bigId) override {};
 	uint32_t GetAccountCount() override { return 0; };
+	uint32_t GetCharacterCount() override { return 0; };
+	void RecordFailedAttempt(const uint32_t accountId) override {};
+	void ClearFailedAttempts(const uint32_t accountId) override {};
+	void SetLockout(const uint32_t accountId, const int64_t lockoutUntil) override {};
+	bool IsLockedOut(const uint32_t accountId) override { return false; };
+	uint8_t GetFailedAttempts(const uint32_t accountId) override { return 0; };
+	nlohmann::json GetAccountsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override { return nlohmann::json::object(); };
+	nlohmann::json GetAccountById(uint32_t accountId) override { return nlohmann::json::object(); };
+	std::string GetCharactersTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override { return "{}"; };
+	std::string GetPlayKeysTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override { return "{}"; };
+	std::string GetPropertiesTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override { return "{}"; };
+	std::string GetBugReportsTable(uint32_t start, uint32_t length, const std::string_view search = "", uint32_t orderColumn = 0, bool orderAsc = true) override { return "{}"; };
 
 	bool IsNameInUse(const std::string_view name) override { return false; };
 	std::optional<IPropertyContents::Model> GetModel(const LWOOBJID modelID) override { return {}; }

dGame/Entity.cpp

@@ -84,6 +84,8 @@
 #include "GhostComponent.h"
 #include "AchievementVendorComponent.h"
 #include "VanityUtilities.h"
+#include "ObjectIDManager.h"
+#include "ePlayerFlag.h"
 
 // Table includes
 #include "CDComponentsRegistryTable.h"
@@ -187,12 +189,20 @@ Entity::~Entity() {
 	}
 
 	if (m_ParentEntity) {
+		GameMessages::ChildRemoved removedMsg{};
+		removedMsg.childID = m_ObjectID;
+		removedMsg.target = m_ParentEntity->GetObjectID();
+		removedMsg.Send();
 		m_ParentEntity->RemoveChild(this);
 	}
 }
 
 void Entity::Initialize() {
-	RegisterMsg(MessageType::Game::REQUEST_SERVER_OBJECT_INFO, this, &Entity::MsgRequestServerObjectInfo);
+	RegisterMsg<GameMessages::RequestServerObjectInfo>(this, &Entity::MsgRequestServerObjectInfo);
+	RegisterMsg<GameMessages::DropClientLoot>(this, &Entity::MsgDropClientLoot);
+	RegisterMsg<GameMessages::GetFactionTokenType>(this, &Entity::MsgGetFactionTokenType);
+	RegisterMsg<GameMessages::PickupItem>(this, &Entity::MsgPickupItem);
+	RegisterMsg<GameMessages::ChildRemoved>(this, &Entity::MsgChildRemoved);
 	/**
 	 * Setup trigger
 	 */
@@ -287,7 +297,7 @@ void Entity::Initialize() {
 		AddComponent<LUPExhibitComponent>(lupExhibitID);
 	}
 
-	const auto racingControlID =compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_CONTROL);
+	const auto racingControlID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::RACING_CONTROL);
 	if (racingControlID > 0) {
 		AddComponent<RacingControlComponent>(racingControlID);
 	}
@@ -419,6 +429,7 @@ void Entity::Initialize() {
 					comp->SetIsSmashable(destCompData[0].isSmashable);
 
 					comp->SetLootMatrixID(destCompData[0].LootMatrixIndex);
+					comp->SetCurrencyIndex(destCompData[0].CurrencyIndex);
 					Loot::CacheMatrix(destCompData[0].LootMatrixIndex);
 
 					// Now get currency information
@@ -493,7 +504,7 @@ void Entity::Initialize() {
 		auto& systemAddress = m_Character->GetParentUser() ? m_Character->GetParentUser()->GetSystemAddress() : UNASSIGNED_SYSTEM_ADDRESS;
 		AddComponent<CharacterComponent>(characterID, m_Character, systemAddress)->LoadFromXml(m_Character->GetXMLDoc());
 
-		AddComponent<GhostComponent>(characterID);
+		AddComponent<GhostComponent>(characterID)->LoadFromXml(m_Character->GetXMLDoc());
 	}
 
 	const auto inventoryID = compRegistryTable->GetByIDAndType(m_TemplateID, eReplicaComponentType::INVENTORY);
@@ -1663,7 +1674,7 @@ void Entity::AddLootItem(const Loot::Info& info) const {
 
 	auto* const characterComponent = GetComponent<CharacterComponent>();
 	if (!characterComponent) return;
-
+	LOG("Player %llu has been allowed to pickup %i with id %llu", m_ObjectID, info.lot, info.id);
 	auto& droppedLoot = characterComponent->GetDroppedLoot();
 	droppedLoot[info.id] = info;
 }
@@ -2247,6 +2258,7 @@ bool Entity::MsgRequestServerObjectInfo(GameMessages::GameMsg& msg) {
 	response.Insert("objectID", std::to_string(m_ObjectID));
 	response.Insert("serverInfo", true);
 	GameMessages::GetObjectReportInfo info{};
+	info.clientID = requestInfo.clientId;
 	info.bVerbose = requestInfo.bVerbose;
 	info.info = response.InsertArray("data");
 	auto& objectInfo = info.info->PushDebug("Object Details");
@@ -2275,3 +2287,78 @@ bool Entity::MsgRequestServerObjectInfo(GameMessages::GameMsg& msg) {
 	if (client) GameMessages::SendUIMessageServerToSingleClient("ToggleObjectDebugger", response, client->GetSystemAddress());
 	return true;
 }
+
+bool Entity::MsgDropClientLoot(GameMessages::GameMsg& msg) {
+	auto& dropLootMsg = static_cast<GameMessages::DropClientLoot&>(msg);
+
+	if (dropLootMsg.item != LOT_NULL && dropLootMsg.item != 0) {
+		Loot::Info info{
+			.id = dropLootMsg.lootID,
+			.lot = dropLootMsg.item,
+			.count = dropLootMsg.count,
+		};
+		AddLootItem(info);
+	}
+
+	if (dropLootMsg.item == LOT_NULL && dropLootMsg.currency != 0) {
+		RegisterCoinDrop(dropLootMsg.currency);
+	}
+
+	return true;
+}
+
+bool Entity::MsgGetFlag(GameMessages::GameMsg& msg) {
+	auto& flagMsg = static_cast<GameMessages::GetFlag&>(msg);
+	if (m_Character) flagMsg.flag = m_Character->GetPlayerFlag(flagMsg.flagID);
+	return true;
+}
+bool Entity::MsgGetFactionTokenType(GameMessages::GameMsg& msg) {
+	auto& tokenMsg = static_cast<GameMessages::GetFactionTokenType&>(msg);
+	GameMessages::GetFlag getFlagMsg{};
+
+	getFlagMsg.flagID = ePlayerFlag::ASSEMBLY_FACTION;
+	MsgGetFlag(getFlagMsg);
+	if (getFlagMsg.flag) tokenMsg.tokenType = 8318;
+
+	getFlagMsg.flagID = ePlayerFlag::SENTINEL_FACTION;
+	MsgGetFlag(getFlagMsg);
+	if (getFlagMsg.flag) tokenMsg.tokenType = 8319;
+
+	getFlagMsg.flagID = ePlayerFlag::PARADOX_FACTION;
+	MsgGetFlag(getFlagMsg);
+	if (getFlagMsg.flag) tokenMsg.tokenType = 8320;
+
+	getFlagMsg.flagID = ePlayerFlag::VENTURE_FACTION;
+	MsgGetFlag(getFlagMsg);
+	if (getFlagMsg.flag) tokenMsg.tokenType = 8321;
+
+	LOG("Returning token type %i", tokenMsg.tokenType);
+	return tokenMsg.tokenType != LOT_NULL;
+}
+
+bool Entity::MsgPickupItem(GameMessages::GameMsg& msg) {
+	auto& pickupItemMsg = static_cast<GameMessages::PickupItem&>(msg);
+	if (GetObjectID() == pickupItemMsg.lootOwnerID) {
+		PickupItem(pickupItemMsg.lootID);
+	} else {
+		auto* const characterComponent = GetComponent<CharacterComponent>();
+		if (!characterComponent) return false;
+		auto& droppedLoot = characterComponent->GetDroppedLoot();
+		const auto it = droppedLoot.find(pickupItemMsg.lootID);
+		if (it != droppedLoot.end()) {
+			CDObjectsTable* objectsTable = CDClientManager::GetTable<CDObjectsTable>();
+			const CDObjects& object = objectsTable->GetByID(it->second.lot);
+			if (object.id != 0 && object.type == "Powerup") {
+				return false; // Let powerups be duplicated
+			}
+		}
+		droppedLoot.erase(pickupItemMsg.lootID);
+	}
+
+	return true;
+}
+
+bool Entity::MsgChildRemoved(GameMessages::GameMsg& msg) {
+	GetScript()->OnChildRemoved(*this, static_cast<GameMessages::ChildRemoved&>(msg));
+	return true;
+}

dGame/Entity.h

@@ -176,6 +176,11 @@ public:
 	void AddComponent(eReplicaComponentType componentId, Component* component);
 
 	bool MsgRequestServerObjectInfo(GameMessages::GameMsg& msg);
+	bool MsgDropClientLoot(GameMessages::GameMsg& msg);
+	bool MsgGetFlag(GameMessages::GameMsg& msg);
+	bool MsgGetFactionTokenType(GameMessages::GameMsg& msg);
+	bool MsgPickupItem(GameMessages::GameMsg& msg);
+	bool MsgChildRemoved(GameMessages::GameMsg& msg);
 
 	// This is expceted to never return nullptr, an assert checks this.
 	CppScripts::Script* const GetScript() const;
@@ -342,6 +347,12 @@ public:
 		RegisterMsg(msgId, std::bind(handler, self, std::placeholders::_1));
 	}
 
+	template<typename T>
+	inline void RegisterMsg(auto* self, const auto handler) {
+		T msg;
+		RegisterMsg(msg.msgId, self, handler);
+	}
+
 	/**
 	 * @brief The observable for player entity position updates.
 	 */
@@ -600,5 +611,5 @@ auto Entity::GetComponents() const {
 
 template<typename... T>
 auto Entity::GetComponentsMut() const {
-	return std::tuple{GetComponent<T>()...};
+	return std::tuple{ GetComponent<T>()... };
 }

dGame/EntityManager.cpp

@@ -361,16 +361,24 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 		LOG("Attempted to construct null entity");
 		return;
 	}
+	// Don't construct GM invisible entities unless it's for the GM themselves
+	// GMs can see other GMs if they are the same or lower level
+	GameMessages::GetGMInvis getGMInvisMsg;
+	getGMInvisMsg.Send(entity->GetObjectID());
+	if (getGMInvisMsg.bGMInvis && sysAddr != entity->GetSystemAddress()) {
+		auto* toUser = UserManager::Instance()->GetUser(sysAddr);
+		if (!toUser) return;
+		auto* constructedUser = UserManager::Instance()->GetUser(entity->GetSystemAddress());
+		if (!constructedUser) return;
+		if (toUser->GetMaxGMLevel() < constructedUser->GetMaxGMLevel()) return;
+	}
 
 	if (entity->GetNetworkId() == 0) {
 		uint16_t networkId;
-
 		if (!m_LostNetworkIds.empty()) {
 			networkId = m_LostNetworkIds.top();
 			m_LostNetworkIds.pop();
-		} else {
-			networkId = ++m_NetworkIdCounter;
-		}
+		} else networkId = ++m_NetworkIdCounter;
 
 		entity->SetNetworkId(networkId);
 	}
@@ -379,10 +387,8 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 		if (std::find(m_EntitiesToGhost.begin(), m_EntitiesToGhost.end(), entity) == m_EntitiesToGhost.end()) {
 			m_EntitiesToGhost.push_back(entity);
 		}
-
 		if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
 			CheckGhosting(entity);
-
 			return;
 		}
 	}
@@ -413,14 +419,9 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 		Game::server->Send(stream, sysAddr, false);
 	}
 
-	if (entity->IsPlayer()) {
-		if (entity->GetGMLevel() > eGameMasterLevel::CIVILIAN) {
-			GameMessages::SendToggleGMInvis(entity->GetObjectID(), true, sysAddr);
-		}
-	}
 }
 
-void EntityManager::ConstructAllEntities(const SystemAddress& sysAddr) {
+void EntityManager::ConstructAllEntities(const SystemAddress& sysAddr) {	
 	//ZoneControl is special:
 	ConstructEntity(m_ZoneControlEntity, sysAddr);
 
@@ -488,11 +489,7 @@ void EntityManager::QueueGhostUpdate(LWOOBJID playerID) {
 void EntityManager::UpdateGhosting() {
 	for (const auto playerID : m_PlayersToUpdateGhosting) {
 		auto* player = PlayerManager::GetPlayer(playerID);
-
-		if (player == nullptr) {
-			continue;
-		}
-
+		if (!player) continue;
 		UpdateGhosting(player);
 	}
 
@@ -519,6 +516,7 @@ void EntityManager::UpdateGhosting(Entity* player) {
 
 		const auto distance = NiPoint3::DistanceSquared(referencePoint, entityPoint);
 
+
 		auto ghostingDistanceMax = m_GhostDistanceMaxSquared;
 		auto ghostingDistanceMin = m_GhostDistanceMinSqaured;
 
@@ -555,35 +553,25 @@ void EntityManager::UpdateGhosting(Entity* player) {
 }
 
 void EntityManager::CheckGhosting(Entity* entity) {
-	if (entity == nullptr) {
-		return;
-	}
+	if (!entity) return;
 
 	const auto& referencePoint = entity->GetPosition();
-
 	for (auto* player : PlayerManager::GetAllPlayers()) {
 		auto* ghostComponent = player->GetComponent<GhostComponent>();
 		if (!ghostComponent) continue;
 
 		const auto& entityPoint = ghostComponent->GetGhostReferencePoint();
-
 		const auto id = entity->GetObjectID();
-
 		const auto observed = ghostComponent->IsObserved(id);
-
 		const auto distance = NiPoint3::DistanceSquared(referencePoint, entityPoint);
 
 		if (observed && distance > m_GhostDistanceMaxSquared) {
 			ghostComponent->GhostEntity(id);
-
 			DestructEntity(entity, player->GetSystemAddress());
-
 			entity->SetObservers(entity->GetObservers() - 1);
 		} else if (!observed && m_GhostDistanceMinSqaured > distance) {
 			ghostComponent->ObserveEntity(id);
-
 			ConstructEntity(entity, player->GetSystemAddress());
-
 			entity->SetObservers(entity->GetObservers() + 1);
 		}
 	}

dGame/LeaderboardManager.cpp

@@ -289,6 +289,10 @@ void LeaderboardManager::SaveScore(const LWOOBJID& playerID, const GameID activi
 			ILeaderboard::Score oldScoreFlipped{oldScore->secondaryScore, oldScore->primaryScore, oldScore->tertiaryScore};
 			ILeaderboard::Score newScoreFlipped{newScore.secondaryScore, newScore.primaryScore, newScore.tertiaryScore};
 			newHighScore = newScoreFlipped > oldScoreFlipped;
+		} else if (leaderboardType == Leaderboard::Type::Donations) {
+			// Donations just need to go up if updated
+			newHighScore = true;
+			newScore.primaryScore += oldScore->primaryScore;
 		}
 
 		if (newHighScore) {

dGame/TeamManager.cpp

@@ -9,6 +9,16 @@ Team::Team() {
 	lootOption = Game::config->GetValue("default_team_loot") == "0" ? 0 : 1;
 }
 
+LWOOBJID Team::GetNextLootOwner() {
+	lootRound++;
+
+	if (lootRound >= members.size()) {
+		lootRound = 0;
+	}
+
+	return members[lootRound];
+}
+
 TeamManager::TeamManager() {
 }
 

dGame/TeamManager.h

@@ -4,6 +4,8 @@
 
 struct Team {
 	Team();
+
+	LWOOBJID GetNextLootOwner();
 	LWOOBJID teamID = LWOOBJID_EMPTY;
 	char lootOption = 0;
 	std::vector<LWOOBJID> members{};

dGame/User.h

@@ -31,7 +31,7 @@ public:
 	std::string& GetSessionKey() { return m_SessionKey; }
 	SystemAddress& GetSystemAddress() { return m_SystemAddress; }
 
-	eGameMasterLevel GetMaxGMLevel() { return m_MaxGMLevel; }
+	eGameMasterLevel GetMaxGMLevel() const { return m_MaxGMLevel; }
 	uint32_t GetLastCharID() { return m_LastCharID; }
 	void SetLastCharID(uint32_t newCharID) { m_LastCharID = newCharID; }
 

dGame/dBehaviors/AndBehavior.cpp

@@ -10,7 +10,9 @@ void AndBehavior::Handle(BehaviorContext* context, RakNet::BitStream& bitStream,
 }
 
 void AndBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitStream, const BehaviorBranchContext branch) {
+	LOG_ENTRY;
 	for (auto* behavior : this->m_behaviors) {
+		LOG("%i calculating %i", m_behaviorId, behavior->GetBehaviorID());
 		behavior->Calculate(context, bitStream, branch);
 	}
 }

dGame/dBehaviors/Behavior.h

@@ -95,4 +95,6 @@ public:
 
 	Behavior& operator=(const Behavior& other) = default;
 	Behavior& operator=(Behavior&& other) = default;
+
+	uint32_t GetBehaviorID() const { return m_behaviorId; }
 };

dGame/dBehaviors/TacArcBehavior.cpp

@@ -114,7 +114,6 @@ 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 (validTarget->GetIsDead()) continue;
 
@@ -147,13 +146,28 @@ void TacArcBehavior::Calculate(BehaviorContext* context, RakNet::BitStream& bitS
 		}
 	}
 
-	std::sort(targets.begin(), targets.end(), [reference](Entity* a, Entity* b) {
+	std::sort(targets.begin(), targets.end(), [this, reference, combatAi](Entity* a, Entity* b) {
 		const auto aDistance = Vector3::DistanceSquared(reference, a->GetPosition());
 		const auto bDistance = Vector3::DistanceSquared(reference, b->GetPosition());
 
-		return aDistance > bDistance;
+		return aDistance < bDistance;
 		});
 
+
+	if (m_useAttackPriority) {
+		// this should be using the attack priority column on the destroyable component
+		// We want targets with no threat level to remain the same order as above
+		// std::stable_sort(targets.begin(), targets.end(), [combatAi](Entity* a, Entity* b) {
+		// 	const auto aThreat = combatAi->GetThreat(a->GetObjectID());
+		// 	const auto bThreat = combatAi->GetThreat(b->GetObjectID());
+
+		// 	If enabled for this behavior, prioritize threat over distance
+		// 	return aThreat > bThreat;
+		// 	});
+	}
+
+	// After we've sorted and found our closest targets, size the vector down in case there are too many
+	if (m_maxTargets > 0 && targets.size() > m_maxTargets) targets.resize(m_maxTargets);
 	const auto hit = !targets.empty();
 	bitStream.Write(hit);
 

dGame/dComponents/ActivityComponent.cpp

@@ -45,33 +45,6 @@ ActivityComponent::ActivityComponent(Entity* parent, int32_t componentID) : Comp
 		m_ActivityID = parent->GetVar<int32_t>(u"activityID");
 		LoadActivityData(m_ActivityID);
 	}
-
-	auto* destroyableComponent = m_Parent->GetComponent<DestroyableComponent>();
-
-	if (destroyableComponent) {
-		// First lookup the loot matrix id for this component id.
-		CDActivityRewardsTable* activityRewardsTable = CDClientManager::GetTable<CDActivityRewardsTable>();
-		std::vector<CDActivityRewards> activityRewards = activityRewardsTable->Query([=](CDActivityRewards entry) {return (entry.LootMatrixIndex == destroyableComponent->GetLootMatrixID()); });
-
-		uint32_t startingLMI = 0;
-
-		// If we have one, set the starting loot matrix id to that.
-		if (activityRewards.size() > 0) {
-			startingLMI = activityRewards[0].LootMatrixIndex;
-		}
-
-		if (startingLMI > 0) {
-			// We may have more than 1 loot matrix index to use depending ont the size of the team that is looting the activity.
-			// So this logic will get the rest of the loot matrix indices for this activity.
-
-			std::vector<CDActivityRewards> objectTemplateActivities = activityRewardsTable->Query([=](CDActivityRewards entry) {return (activityRewards[0].objectTemplate == entry.objectTemplate); });
-			for (const auto& item : objectTemplateActivities) {
-				if (item.activityRating > 0 && item.activityRating < 5) {
-					m_ActivityLootMatrices.insert({ item.activityRating, item.LootMatrixIndex });
-				}
-			}
-		}
-	}
 }
 void ActivityComponent::LoadActivityData(const int32_t activityId) {
 	CDActivitiesTable* activitiesTable = CDClientManager::GetTable<CDActivitiesTable>();
@@ -698,10 +671,6 @@ bool ActivityComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
 		}
 	}
 	
-	auto& lootMatrices = activityInfo.PushDebug("Loot Matrices");
-	for (const auto& [activityRating, lootMatrixID] : m_ActivityLootMatrices) {
-		lootMatrices.PushDebug<AMFIntValue>("Loot Matrix " + std::to_string(activityRating)) = lootMatrixID;
-	}
 	activityInfo.PushDebug<AMFIntValue>("ActivityID") = m_ActivityID;
 	return true;
 }

dGame/dComponents/ActivityComponent.h

@@ -215,6 +215,10 @@ public:
 	 */
 	int GetActivityID() { return m_ActivityInfo.ActivityID; }
 
+	// Whether or not team loot should be dropped on death for this activity
+	// if true, and a player is supposed to get loot, they are skipped
+	bool GetNoTeamLootOnDeath() const { return m_ActivityInfo.noTeamLootOnDeath; }
+
 	/**
 	 * Returns if this activity has a lobby, e.g. if it needs to instance players to some other map
 	 * @return true if this activity has a lobby, false otherwise
@@ -341,12 +345,6 @@ public:
 	 */
 	void SetInstanceMapID(uint32_t mapID) { m_ActivityInfo.instanceMapID = mapID; };
 
-	/**
-	 * Returns the LMI that this activity points to for a team size
-	 * @param teamSize the team size to get the LMI for
-	 * @return the LMI that this activity points to for a team size
-	 */
-	uint32_t GetLootMatrixForTeamSize(uint32_t teamSize) { return m_ActivityLootMatrices[teamSize]; }
 private:
 
 	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
@@ -370,11 +368,6 @@ private:
 	 */
 	std::vector<ActivityPlayer*> m_ActivityPlayers;
 
-	/**
-	 * LMIs for team sizes
-	 */
-	std::unordered_map<uint32_t, uint32_t> m_ActivityLootMatrices;
-
 	/**
 	 * The activity id
 	 */

dGame/dComponents/BaseCombatAIComponent.cpp

@@ -27,8 +27,13 @@
 #include "CDComponentsRegistryTable.h"
 #include "CDPhysicsComponentTable.h"
 #include "dNavMesh.h"
+#include "Amf3.h"
 
 BaseCombatAIComponent::BaseCombatAIComponent(Entity* parent, const int32_t componentID) : Component(parent, componentID) {
+	{
+		using namespace GameMessages;
+		RegisterMsg<GetObjectReportInfo>(this, &BaseCombatAIComponent::MsgGetObjectReportInfo);
+	}
 	m_Target = LWOOBJID_EMPTY;
 	m_DirtyStateOrTarget = true;
 	m_State = AiState::spawn;
@@ -839,3 +844,73 @@ void BaseCombatAIComponent::IgnoreThreat(const LWOOBJID threat, const float valu
 	SetThreat(threat, 0.0f);
 	m_Target = LWOOBJID_EMPTY;
 }
+
+bool BaseCombatAIComponent::MsgGetObjectReportInfo(GameMessages::GameMsg& msg) {
+	using enum AiState;
+	auto& reportMsg = static_cast<GameMessages::GetObjectReportInfo&>(msg);
+	auto& cmptType = reportMsg.info->PushDebug("Base Combat AI");
+	cmptType.PushDebug<AMFIntValue>("Component ID") = GetComponentID();
+	auto& targetInfo = cmptType.PushDebug("Current Target Info");
+	targetInfo.PushDebug<AMFStringValue>("Current Target ID") = std::to_string(m_Target);
+	// if (m_Target != LWOOBJID_EMPTY) {
+		// LWOGameMessages::ObjGetName nameMsg(m_CurrentTarget);
+		// SEND_GAMEOBJ_MSG(nameMsg);
+		// if (!nameMsg.msg.name.empty()) targetInfo.PushDebug("Name") = nameMsg.msg.name;
+	// }
+
+	auto& roundInfo = cmptType.PushDebug("Round Info");
+	// roundInfo.PushDebug<AMFDoubleValue>("Combat Round Time") = m_CombatRoundLength;
+	// roundInfo.PushDebug<AMFDoubleValue>("Minimum Time") = m_MinRoundLength;
+	// roundInfo.PushDebug<AMFDoubleValue>("Maximum Time") = m_MaxRoundLength;
+	// roundInfo.PushDebug<AMFDoubleValue>("Selected Time") = m_SelectedTime;
+	// roundInfo.PushDebug<AMFDoubleValue>("Combat Start Delay") = m_CombatStartDelay;
+	std::string curState;
+	switch (m_State) {
+		case idle: curState = "Idling"; break;
+		case aggro: curState = "Aggroed"; break;
+		case tether: curState = "Returning to Tether"; break;
+		case spawn: curState = "Spawn"; break;
+		case dead: curState = "Dead"; break;
+		default: curState = "Unknown or Undefined"; break;
+	}
+	cmptType.PushDebug<AMFStringValue>("Current Combat State") = curState;
+
+	//switch (m_CombatBehaviorType) {
+	//	case 0: curState = "Passive"; break;
+	//	case 1: curState = "Aggressive"; break;
+	//	case 2: curState = "Passive (Turret)"; break;
+	//	case 3: curState = "Aggressive (Turret)"; break;
+	//	default: curState = "Unknown or Undefined"; break;
+	//}
+	//cmptType.PushDebug("Current Combat Behavior State") = curState;
+
+	//switch (m_CombatRole) {
+	//	case 0: curState = "Melee"; break;
+	//	case 1: curState = "Ranged"; break;
+	//	case 2: curState = "Support"; break;
+	//	default: curState = "Unknown or Undefined"; break;
+	//}
+	//cmptType.PushDebug("Current Combat Role") = curState;
+
+	auto& tetherPoint = cmptType.PushDebug("Tether Point");
+	tetherPoint.PushDebug<AMFDoubleValue>("X") = m_StartPosition.x;
+	tetherPoint.PushDebug<AMFDoubleValue>("Y") = m_StartPosition.y;
+	tetherPoint.PushDebug<AMFDoubleValue>("Z") = m_StartPosition.z;
+	cmptType.PushDebug<AMFDoubleValue>("Hard Tether Radius") = m_HardTetherRadius;
+	cmptType.PushDebug<AMFDoubleValue>("Soft Tether Radius") = m_SoftTetherRadius;
+	cmptType.PushDebug<AMFDoubleValue>("Aggro Radius") = m_AggroRadius;
+	cmptType.PushDebug<AMFDoubleValue>("Tether Speed") = m_TetherSpeed;
+	cmptType.PushDebug<AMFDoubleValue>("Aggro Speed") = m_TetherSpeed;
+	// cmptType.PushDebug<AMFDoubleValue>("Specified Min Range") = m_SpecificMinRange;
+	// cmptType.PushDebug<AMFDoubleValue>("Specified Max Range") = m_SpecificMaxRange;
+	auto& threats = cmptType.PushDebug("Target Threats");
+	for (const auto& [id, threat] : m_ThreatEntries) {
+		threats.PushDebug<AMFDoubleValue>(std::to_string(id)) = threat;
+	}
+
+	auto& ignoredThreats = cmptType.PushDebug("Temp Ignored Threats");
+	for (const auto& [id, threat] : m_ThreatEntries) {
+		ignoredThreats.PushDebug<AMFDoubleValue>(std::to_string(id) + " - Time") = threat;
+	}
+	return true;
+}

dGame/dComponents/BaseCombatAIComponent.h

@@ -234,6 +234,8 @@ public:
 	// Ignore a threat for a certain amount of time
 	void IgnoreThreat(const LWOOBJID target, const float time);
 
+	bool MsgGetObjectReportInfo(GameMessages::GameMsg& msg);
+
 private:
 	/**
 	 * Returns the current target or the target that currently is the largest threat to this entity

dGame/dComponents/BouncerComponent.cpp

@@ -8,15 +8,33 @@
 #include "GameMessages.h"
 #include "BitStream.h"
 #include "eTriggerEventType.h"
+#include "Amf3.h"
 
 BouncerComponent::BouncerComponent(Entity* parent, const int32_t componentID) : Component(parent, componentID) {
 	m_PetEnabled = false;
 	m_PetBouncerEnabled = false;
 	m_PetSwitchLoaded = false;
+	m_Destination = GeneralUtils::TryParse<NiPoint3>(
+		GeneralUtils::SplitString(m_Parent->GetVarAsString(u"bouncer_destination"), '\x1f'))
+		.value_or(NiPoint3Constant::ZERO);
+	m_Speed = GeneralUtils::TryParse<float>(m_Parent->GetVarAsString(u"bouncer_speed")).value_or(-1.0f);
+	m_UsesHighArc = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"bouncer_uses_high_arc")).value_or(false);
+	m_LockControls = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"lock_controls")).value_or(false);
+	m_IgnoreCollision = !GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"ignore_collision")).value_or(true);
+	m_StickLanding = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"stickLanding")).value_or(false);
+	m_UsesGroupName = GeneralUtils::TryParse<bool>(m_Parent->GetVarAsString(u"uses_group_name")).value_or(false);
+	m_GroupName = m_Parent->GetVarAsString(u"grp_name");
+	m_MinNumTargets = GeneralUtils::TryParse<int32_t>(m_Parent->GetVarAsString(u"num_targets_to_activate")).value_or(1);
+	m_CinematicPath = m_Parent->GetVarAsString(u"attached_cinematic_path");
 
 	if (parent->GetLOT() == 7625) {
 		LookupPetSwitch();
 	}
+
+	{
+		using namespace GameMessages;
+		RegisterMsg<GetObjectReportInfo>(this, &BouncerComponent::MsgGetObjectReportInfo);
+	}
 }
 
 BouncerComponent::~BouncerComponent() {
@@ -94,3 +112,54 @@ void BouncerComponent::LookupPetSwitch() {
 			});
 	}
 }
+
+bool BouncerComponent::MsgGetObjectReportInfo(GameMessages::GameMsg& msg) {
+	auto& reportMsg = static_cast<GameMessages::GetObjectReportInfo&>(msg);
+	auto& cmptType = reportMsg.info->PushDebug("Bouncer");
+	cmptType.PushDebug<AMFIntValue>("Component ID") = GetComponentID();
+	auto& destPos = cmptType.PushDebug("Destination Position");
+	if (m_Destination != NiPoint3Constant::ZERO) {
+		destPos.PushDebug(m_Destination);
+	} else {
+		destPos.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Bouncer has no target position, is likely missing config data");
+	}
+
+
+	if (m_Speed == -1.0f) {
+		cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Bouncer has no speed value, is likely missing config data");
+	} else {
+		cmptType.PushDebug<AMFDoubleValue>("Bounce Speed") = m_Speed;
+	}
+	cmptType.PushDebug<AMFStringValue>("Bounce trajectory arc") = m_UsesHighArc ? "High Arc" : "Low Arc";
+	cmptType.PushDebug<AMFBoolValue>("Collision Enabled") = m_IgnoreCollision;
+	cmptType.PushDebug<AMFBoolValue>("Stick Landing") = m_StickLanding;
+	cmptType.PushDebug<AMFBoolValue>("Locks character's controls") = m_LockControls;
+	if (!m_CinematicPath.empty()) cmptType.PushDebug<AMFStringValue>("Cinematic Camera Path (plays during bounce)") = m_CinematicPath;
+
+	auto* switchComponent = m_Parent->GetComponent<SwitchComponent>();
+	auto& respondsToFactions = cmptType.PushDebug("Responds to Factions");
+	if (!switchComponent || switchComponent->GetFactionsToRespondTo().empty()) respondsToFactions.PushDebug("Faction 1");
+	else {
+		for (const auto faction : switchComponent->GetFactionsToRespondTo()) {
+			respondsToFactions.PushDebug(("Faction " + std::to_string(faction)));
+		}
+	}
+
+	cmptType.PushDebug<AMFBoolValue>("Uses a group name for interactions") = m_UsesGroupName;
+	if (!m_UsesGroupName) {
+		if (m_MinNumTargets > 1) {
+			cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Bouncer has a required number of objects to activate, but no group for interactions.");
+		}
+
+		if (!m_GroupName.empty()) {
+			cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Has a group name for interactions , but is marked to not use that name.");
+		}
+	} else {
+		if (m_GroupName.empty()) {
+			cmptType.PushDebug("<font color=\'#FF0000\'>WARNING:</font> Set to use a group name for inter actions, but no group name is assigned");
+		}
+		cmptType.PushDebug<AMFIntValue>("Number of interactions to activate bouncer") = m_MinNumTargets;
+	}
+
+	return true;
+}

dGame/dComponents/BouncerComponent.h

@@ -51,6 +51,8 @@ public:
 	 */
 	void LookupPetSwitch();
 
+	bool MsgGetObjectReportInfo(GameMessages::GameMsg& msg);
+
 private:
 	/**
 	 * Whether this bouncer needs to be activated by a pet
@@ -66,6 +68,36 @@ private:
 	 * Whether the pet switch for this bouncer has been located
 	 */
 	bool m_PetSwitchLoaded;
+
+	// The bouncer destination
+	NiPoint3 m_Destination;
+
+	// The speed at which the player is bounced
+	float m_Speed{};
+
+	// Whether to use a high arc for the bounce trajectory
+	bool m_UsesHighArc{};
+
+	// Lock controls when bouncing
+	bool m_LockControls{};
+	
+	// Ignore collision when bouncing
+	bool m_IgnoreCollision{};
+
+	// Stick the landing afterwards or let the player slide
+	bool m_StickLanding{};
+	
+	// Whether or not there is a group name
+	bool m_UsesGroupName{};
+
+	// The group name for targets
+	std::string m_GroupName{};
+
+	// The number of targets to activate the bouncer
+	int32_t m_MinNumTargets{};
+
+	// The cinematic path to play during the bounce
+	std::string m_CinematicPath{};
 };
 
 #endif // BOUNCERCOMPONENT_H

dGame/dComponents/CharacterComponent.cpp

@@ -515,12 +515,12 @@ void CharacterComponent::RocketUnEquip(Entity* player) {
 }
 
 void CharacterComponent::TrackMissionCompletion(bool isAchievement) {
-	UpdatePlayerStatistic(MissionsCompleted);
-
 	// Achievements are tracked separately for the zone
 	if (isAchievement) {
 		const auto mapID = Game::zoneManager->GetZoneID().GetMapID();
 		GetZoneStatisticsForMap(mapID).m_AchievementsCollected++;
+	} else {
+		UpdatePlayerStatistic(MissionsCompleted);
 	}
 }
 

dGame/dComponents/CollectibleComponent.cpp

@@ -1,5 +1,39 @@
 #include "CollectibleComponent.h"
 
+#include "MissionComponent.h"
+#include "dServer.h"
+#include "Amf3.h"
+
+CollectibleComponent::CollectibleComponent(Entity* parentEntity, const int32_t componentID, const int32_t collectibleId) :
+	Component(parentEntity, componentID), m_CollectibleId(collectibleId) {
+	using namespace GameMessages;
+	RegisterMsg<GetObjectReportInfo>(this, &CollectibleComponent::MsgGetObjectReportInfo);
+}
+
 void CollectibleComponent::Serialize(RakNet::BitStream& outBitStream, bool isConstruction) {
 	outBitStream.Write(GetCollectibleId());
 }
+
+bool CollectibleComponent::MsgGetObjectReportInfo(GameMessages::GameMsg& msg) {
+	auto& reportMsg = static_cast<GameMessages::GetObjectReportInfo&>(msg);
+	auto& cmptType = reportMsg.info->PushDebug("Collectible");
+	auto collectibleID = static_cast<uint32_t>(m_CollectibleId) + static_cast<uint32_t>(Game::server->GetZoneID() << 8);
+
+	cmptType.PushDebug<AMFIntValue>("Component ID") = GetComponentID();
+
+	cmptType.PushDebug<AMFIntValue>("Collectible ID") = GetCollectibleId();
+	cmptType.PushDebug<AMFIntValue>("Mission Tracking ID (for save data)") = collectibleID;
+
+	auto* localCharEntity = Game::entityManager->GetEntity(reportMsg.clientID);
+	bool collected = false;
+	if (localCharEntity) {
+		auto* missionComponent = localCharEntity->GetComponent<MissionComponent>();
+
+		if (m_CollectibleId != 0) {
+			collected = missionComponent->HasCollectible(collectibleID);
+		}
+	}
+
+	cmptType.PushDebug<AMFBoolValue>("Has been collected") = collected;
+	return true;
+}

dGame/dComponents/CollectibleComponent.h

@@ -7,10 +7,12 @@
 class CollectibleComponent final : public Component {
 public:
 	static constexpr eReplicaComponentType ComponentType = eReplicaComponentType::COLLECTIBLE;
-	CollectibleComponent(Entity* parentEntity, const int32_t componentID, const int32_t collectibleId) : Component(parentEntity, componentID), m_CollectibleId(collectibleId) {}
+	CollectibleComponent(Entity* parentEntity, const int32_t componentID, const int32_t collectibleId);
 
 	int16_t GetCollectibleId() const { return m_CollectibleId; }
 	void Serialize(RakNet::BitStream& outBitStream, bool isConstruction) override;
+
+	bool MsgGetObjectReportInfo(GameMessages::GameMsg& msg);
 private:
 	int16_t m_CollectibleId = 0;
 };

dGame/dComponents/DestroyableComponent.cpp

@@ -3,6 +3,9 @@
 #include "Logger.h"
 #include "Game.h"
 #include "dConfig.h"
+#include "CDLootMatrixTable.h"
+#include "CDLootTableTable.h"
+#include "CDRarityTableTable.h"
 
 #include "Amf3.h"
 #include "AmfSerialize.h"
@@ -85,6 +88,7 @@ DestroyableComponent::DestroyableComponent(Entity* parent, const int32_t compone
 
 	RegisterMsg<GetObjectReportInfo>(this, &DestroyableComponent::OnGetObjectReportInfo);
 	RegisterMsg<GameMessages::SetFaction>(this, &DestroyableComponent::OnSetFaction);
+	RegisterMsg<GameMessages::IsDead>(this, &DestroyableComponent::OnIsDead);
 }
 
 DestroyableComponent::~DestroyableComponent() {
@@ -694,6 +698,8 @@ void DestroyableComponent::NotifySubscribers(Entity* attacker, uint32_t damage)
 }
 
 void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType, const std::u16string& deathType, uint32_t skillID) {
+	if (m_IsDead) return;
+
 	//check if hardcore mode is enabled
 	if (Game::entityManager->GetHardcoreMode()) {
 		DoHardcoreModeDrops(source);
@@ -706,6 +712,7 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 		Game::entityManager->SerializeEntity(m_Parent);
 	}
 
+	m_IsDead = true;
 	m_KillerID = source;
 
 	auto* owner = Game::entityManager->GetEntity(source);
@@ -748,41 +755,12 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 
 	const auto isPlayer = m_Parent->IsPlayer();
 
-	GameMessages::SendDie(m_Parent, source, source, true, killType, deathType, 0, 0, 0, isPlayer, false, 1);
+	GameMessages::SendDie(m_Parent, source, source, true, killType, deathType, 0, 0, 0, isPlayer, true, 1);
 
 	//NANI?!
 	if (!isPlayer) {
 		if (owner != nullptr) {
-			auto* team = TeamManager::Instance()->GetTeam(owner->GetObjectID());
-
-			if (team != nullptr && m_Parent->GetComponent<BaseCombatAIComponent>() != nullptr) {
-				LWOOBJID specificOwner = LWOOBJID_EMPTY;
-				auto* scriptedActivityComponent = m_Parent->GetComponent<ScriptedActivityComponent>();
-				uint32_t teamSize = team->members.size();
-				uint32_t lootMatrixId = GetLootMatrixID();
-
-				if (scriptedActivityComponent) {
-					lootMatrixId = scriptedActivityComponent->GetLootMatrixForTeamSize(teamSize);
-				}
-
-				if (team->lootOption == 0) { // Round robin
-					specificOwner = TeamManager::Instance()->GetNextLootOwner(team);
-
-					auto* member = Game::entityManager->GetEntity(specificOwner);
-
-					if (member) Loot::DropLoot(member, m_Parent->GetObjectID(), lootMatrixId, GetMinCoins(), GetMaxCoins());
-				} else {
-					for (const auto memberId : team->members) { // Free for all
-						auto* member = Game::entityManager->GetEntity(memberId);
-
-						if (member == nullptr) continue;
-
-						Loot::DropLoot(member, m_Parent->GetObjectID(), lootMatrixId, GetMinCoins(), GetMaxCoins());
-					}
-				}
-			} else { // drop loot for non team user
-				Loot::DropLoot(owner, m_Parent->GetObjectID(), GetLootMatrixID(), GetMinCoins(), GetMaxCoins());
-			}
+			Loot::DropLoot(owner, m_Parent->GetObjectID(), GetLootMatrixID(), GetMinCoins(), GetMaxCoins());
 		}
 	} else {
 		//Check if this zone allows coin drops
@@ -799,8 +777,15 @@ void DestroyableComponent::Smash(const LWOOBJID source, const eKillType killType
 
 				coinsTotal -= coinsToLose;
 
-				Loot::DropLoot(m_Parent, m_Parent->GetObjectID(), -1, coinsToLose, coinsToLose);
-				character->SetCoins(coinsTotal, eLootSourceType::PICKUP);
+				GameMessages::DropClientLoot lootMsg{};
+				lootMsg.target = m_Parent->GetObjectID();
+				lootMsg.ownerID = m_Parent->GetObjectID();
+				lootMsg.currency = coinsToLose;
+				lootMsg.spawnPos = m_Parent->GetPosition();
+				lootMsg.sourceID = source;
+				lootMsg.item = LOT_NULL;
+				lootMsg.Send();
+				character->SetCoins(coinsTotal, eLootSourceType::DELETION);
 			}
 		}
 
@@ -1000,7 +985,14 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 						for (const auto item : itemMap | std::views::values) {
 							// Don't drop excluded items or null ones
 							if (!item || Game::entityManager->GetHardcoreExcludedItemDrops().contains(item->GetLot())) continue;
-							GameMessages::SendDropClientLoot(m_Parent, source, item->GetLot(), 0, m_Parent->GetPosition(), item->GetCount());
+							GameMessages::DropClientLoot lootMsg{};
+							lootMsg.target = m_Parent->GetObjectID();
+							lootMsg.ownerID = m_Parent->GetObjectID();
+							lootMsg.sourceID = m_Parent->GetObjectID();
+							lootMsg.item = item->GetLot();
+							lootMsg.count = 1;
+							lootMsg.spawnPos = m_Parent->GetPosition();
+							for (int i = 0; i < item->GetCount(); i++) Loot::DropItem(*m_Parent, lootMsg);
 							item->SetCount(0, false, false);
 						}
 						Game::entityManager->SerializeEntity(m_Parent);
@@ -1023,12 +1015,24 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 
 			//drop all coins:
 			constexpr auto MAX_TO_DROP_PER_GM = 100'000;
+			GameMessages::DropClientLoot lootMsg{};
+			lootMsg.target = m_Parent->GetObjectID();
+			lootMsg.ownerID = m_Parent->GetObjectID();
+			lootMsg.spawnPos = m_Parent->GetPosition();
+			lootMsg.sourceID = source;
+			lootMsg.item = LOT_NULL;
+			lootMsg.Send();
+			lootMsg.Send(m_Parent->GetSystemAddress());
 			while (coinsToDrop > MAX_TO_DROP_PER_GM) {
 				LOG("Dropping 100,000, %llu left", coinsToDrop);
-				GameMessages::SendDropClientLoot(m_Parent, source, LOT_NULL, MAX_TO_DROP_PER_GM, m_Parent->GetPosition());
-				coinsToDrop -= MAX_TO_DROP_PER_GM;
+				lootMsg.currency = 100'000;
+				lootMsg.Send();
+				lootMsg.Send(m_Parent->GetSystemAddress());
+				coinsToDrop -= 100'000;
 			}
-			GameMessages::SendDropClientLoot(m_Parent, source, LOT_NULL, coinsToDrop, m_Parent->GetPosition());
+			lootMsg.currency = coinsToDrop;
+			lootMsg.Send();
+			lootMsg.Send(m_Parent->GetSystemAddress());
 		}
 		return;
 	}
@@ -1043,8 +1047,8 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 			auto maxHealth = GetMaxHealth();
 			const auto uscoreMultiplier = Game::entityManager->GetHardcoreUscoreEnemiesMultiplier();
 			const bool isUscoreReducedLot =
-			Game::entityManager->GetHardcoreUscoreReducedLots().contains(lot) ||
-			Game::entityManager->GetHardcoreUscoreReduced();
+				Game::entityManager->GetHardcoreUscoreReducedLots().contains(lot) ||
+				Game::entityManager->GetHardcoreUscoreReduced();
 			const auto uscoreReduction = isUscoreReducedLot ? Game::entityManager->GetHardcoreUscoreReduction() : 1.0f;
 
 			int uscore = maxHealth * Game::entityManager->GetHardcoreUscoreEnemiesMultiplier() * uscoreReduction;
@@ -1059,38 +1063,89 @@ void DestroyableComponent::DoHardcoreModeDrops(const LWOOBJID source) {
 
 bool DestroyableComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
 	auto& reportInfo = static_cast<GameMessages::GetObjectReportInfo&>(msg);
-
 	auto& destroyableInfo = reportInfo.info->PushDebug("Destroyable");
-	destroyableInfo.PushDebug<AMFIntValue>("Health") = m_iHealth;
-	destroyableInfo.PushDebug<AMFDoubleValue>("Max Health") = m_fMaxHealth;
-	destroyableInfo.PushDebug<AMFIntValue>("Armor") = m_iArmor;
-	destroyableInfo.PushDebug<AMFDoubleValue>("Max Armor") = m_fMaxArmor;
-	destroyableInfo.PushDebug<AMFIntValue>("Imagination") = m_iImagination;
-	destroyableInfo.PushDebug<AMFDoubleValue>("Max Imagination") = m_fMaxImagination;
-	destroyableInfo.PushDebug<AMFIntValue>("Damage To Absorb") = m_DamageToAbsorb;
-	destroyableInfo.PushDebug<AMFBoolValue>("Is GM Immune") = m_IsGMImmune;
-	destroyableInfo.PushDebug<AMFBoolValue>("Is Shielded") = m_IsShielded;
+	destroyableInfo.PushDebug<AMFIntValue>("DestructibleComponent DB Table Template ID") = m_ComponentID;
+
+	if (m_CurrencyIndex == -1) {
+		destroyableInfo.PushDebug<AMFBoolValue>("Has Loot Currency") = false;
+	} else {
+		destroyableInfo.PushDebug<AMFIntValue>("Loot Currency ID") = m_CurrencyIndex;
+		auto& detailedCoinInfo = destroyableInfo.PushDebug("Coin Info");
+		detailedCoinInfo.PushDebug<AMFIntValue>("Min Coins") = m_MinCoins;
+		detailedCoinInfo.PushDebug<AMFIntValue>("Max Coins") = m_MaxCoins;
+	}
+
+	if (m_LootMatrixID == -1 || m_LootMatrixID == 0) {
+		destroyableInfo.PushDebug<AMFBoolValue>("Has Loot Matrix") = false;
+	} else {
+		auto& lootInfo = destroyableInfo.PushDebug("Loot Info");
+		lootInfo.PushDebug<AMFIntValue>("Loot Matrix ID") = m_LootMatrixID;
+		auto* const componentsRegistryTable = CDClientManager::GetTable<CDComponentsRegistryTable>();
+		auto* const itemComponentTable = CDClientManager::GetTable<CDItemComponentTable>();
+		auto* const lootMatrixTable = CDClientManager::GetTable<CDLootMatrixTable>();
+		auto* const lootTableTable = CDClientManager::GetTable<CDLootTableTable>();
+		auto* const rarityTableTable = CDClientManager::GetTable<CDRarityTableTable>();
+
+		const auto& matrix = lootMatrixTable->GetMatrix(m_LootMatrixID);
+
+		for (const auto& entry : matrix) {
+			auto& thisEntry = lootInfo.PushDebug("Loot table Index - " + std::to_string(entry.LootTableIndex));
+			thisEntry.PushDebug<AMFDoubleValue>("Percent chance to drop") = entry.percent * 100.0f;
+			thisEntry.PushDebug<AMFDoubleValue>("Minimum amount to drop") = entry.minToDrop;
+			thisEntry.PushDebug<AMFDoubleValue>("Maximum amount to drop") = entry.maxToDrop;
+			const auto& lootTable = lootTableTable->GetTable(entry.LootTableIndex);
+			const auto& rarityTable = rarityTableTable->GetRarityTable(entry.RarityTableIndex);
+
+			auto& thisRarity = thisEntry.PushDebug("Rarity");
+			for (const auto& rarity : rarityTable) {
+				thisRarity.PushDebug<AMFDoubleValue>("Rarity " + std::to_string(rarity.rarity)) = rarity.randmax;
+			}
+
+			auto& thisItems = thisEntry.PushDebug("Drop(s) Info");
+			for (const auto& loot : lootTable) {
+				uint32_t itemComponentId = componentsRegistryTable->GetByIDAndType(loot.itemid, eReplicaComponentType::ITEM);
+				uint32_t rarity = itemComponentTable->GetItemComponentByID(itemComponentId).rarity;
+				auto title = "%[Objects_" + std::to_string(loot.itemid) + "_name] " + std::to_string(loot.itemid);
+				if (loot.MissionDrop) title += " - Mission Drop";
+				thisItems.PushDebug(title);
+			}
+		}
+	}
+
+	auto* const entity = Game::entityManager->GetEntity(reportInfo.clientID);
+	destroyableInfo.PushDebug<AMFBoolValue>("Is on your team") = entity ? IsFriend(entity) : false;
+	auto& stats = destroyableInfo.PushDebug("Statistics");
+	stats.PushDebug<AMFIntValue>("Health") = m_iHealth;
+	stats.PushDebug<AMFDoubleValue>("Maximum Health") = m_fMaxHealth;
+	stats.PushDebug<AMFIntValue>("Armor") = m_iArmor;
+	stats.PushDebug<AMFDoubleValue>("Maximum Armor") = m_fMaxArmor;
+	stats.PushDebug<AMFIntValue>("Imagination") = m_iImagination;
+	stats.PushDebug<AMFDoubleValue>("Maximum Imagination") = m_fMaxImagination;
+	stats.PushDebug<AMFIntValue>("Damage Absorption Points") = m_DamageToAbsorb;
+	stats.PushDebug<AMFBoolValue>("Is GM Immune") = m_IsGMImmune;
+	stats.PushDebug<AMFBoolValue>("Is Shielded") = m_IsShielded;
 	destroyableInfo.PushDebug<AMFIntValue>("Attacks To Block") = m_AttacksToBlock;
 	destroyableInfo.PushDebug<AMFIntValue>("Damage Reduction") = m_DamageReduction;
-	auto& factions = destroyableInfo.PushDebug("Factions");
-	size_t i = 0;
+	std::stringstream factionsStream;
 	for (const auto factionID : m_FactionIDs) {
-		factions.PushDebug<AMFStringValue>(std::to_string(i++) + " " + std::to_string(factionID)) = "";
+		factionsStream << factionID << " ";
 	}
-	auto& enemyFactions = destroyableInfo.PushDebug("Enemy Factions");
-	i = 0;
+
+	destroyableInfo.PushDebug<AMFStringValue>("Factions") = factionsStream.str();
+
+	factionsStream.str("");
 	for (const auto enemyFactionID : m_EnemyFactionIDs) {
-		enemyFactions.PushDebug<AMFStringValue>(std::to_string(i++) + " " + std::to_string(enemyFactionID)) = "";
+		factionsStream << enemyFactionID << " ";
 	}
-	destroyableInfo.PushDebug<AMFBoolValue>("Is Smashable") = m_IsSmashable;
-	destroyableInfo.PushDebug<AMFBoolValue>("Is Dead") = m_IsDead;
+
+	destroyableInfo.PushDebug<AMFStringValue>("Enemy Factions") = factionsStream.str();
+
+	destroyableInfo.PushDebug<AMFBoolValue>("Is A Smashable") = m_IsSmashable;
 	destroyableInfo.PushDebug<AMFBoolValue>("Is Smashed") = m_IsSmashed;
 	destroyableInfo.PushDebug<AMFBoolValue>("Is Module Assembly") = m_IsModuleAssembly;
 	destroyableInfo.PushDebug<AMFDoubleValue>("Explode Factor") = m_ExplodeFactor;
 	destroyableInfo.PushDebug<AMFBoolValue>("Has Threats") = m_HasThreats;
-	destroyableInfo.PushDebug<AMFIntValue>("Loot Matrix ID") = m_LootMatrixID;
-	destroyableInfo.PushDebug<AMFIntValue>("Min Coins") = m_MinCoins;
-	destroyableInfo.PushDebug<AMFIntValue>("Max Coins") = m_MaxCoins;
+
 	destroyableInfo.PushDebug<AMFStringValue>("Killer ID") = std::to_string(m_KillerID);
 
 	// "Scripts"; idk what to do about scripts yet
@@ -1105,7 +1160,25 @@ bool DestroyableComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
 	immuneCounts.PushDebug<AMFIntValue>("Quickbuild Interrupt") = m_ImmuneToQuickbuildInterruptCount;
 	immuneCounts.PushDebug<AMFIntValue>("Pull To Point") = m_ImmuneToPullToPointCount;
 
-	destroyableInfo.PushDebug<AMFIntValue>("Death Behavior") = m_DeathBehavior;
+	auto& deathInfo = destroyableInfo.PushDebug("Death Info");
+	deathInfo.PushDebug<AMFBoolValue>("Is Dead") = m_IsDead;
+	switch (m_DeathBehavior) {
+	case 0:
+		deathInfo.PushDebug<AMFStringValue>("Death Behavior") = "Fade";
+		break;
+	case 1:
+		deathInfo.PushDebug<AMFStringValue>("Death Behavior") = "Stay";
+		break;
+	case 2:
+		deathInfo.PushDebug<AMFStringValue>("Death Behavior") = "Immediate";
+		break;
+	case -1:
+		deathInfo.PushDebug<AMFStringValue>("Death Behavior") = "Invulnerable";
+		break;
+	default:
+		deathInfo.PushDebug<AMFStringValue>("Death Behavior") = "Other";
+		break;
+	}
 	destroyableInfo.PushDebug<AMFDoubleValue>("Damage Cooldown Timer") = m_DamageCooldownTimer;
 
 	return true;
@@ -1118,3 +1191,9 @@ bool DestroyableComponent::OnSetFaction(GameMessages::GameMsg& msg) {
 	SetFaction(modifyFaction.factionID, modifyFaction.bIgnoreChecks);
 	return true;
 }
+
+bool DestroyableComponent::OnIsDead(GameMessages::GameMsg& msg) {
+	auto& isDeadMsg = static_cast<GameMessages::IsDead&>(msg);
+	isDeadMsg.bDead = m_IsDead || (GetHealth() == 0 && GetArmor() == 0);
+	return true;
+}

dGame/dComponents/DestroyableComponent.h

@@ -370,6 +370,8 @@ public:
 	 */
 	uint32_t GetLootMatrixID() const { return m_LootMatrixID; }
 
+	void SetCurrencyIndex(int32_t currencyIndex) { m_CurrencyIndex = currencyIndex; }
+
 	/**
 	 * Returns the ID of the entity that killed this entity, if any
 	 * @return the ID of the entity that killed this entity, if any
@@ -470,6 +472,9 @@ public:
 
 	bool OnGetObjectReportInfo(GameMessages::GameMsg& msg);
 	bool OnSetFaction(GameMessages::GameMsg& msg);
+	bool OnIsDead(GameMessages::GameMsg& msg);
+
+	void SetIsDead(const bool value) { m_IsDead = value; }
 
 	static Implementation<bool, const Entity*> IsEnemyImplentation;
 	static Implementation<bool, const Entity*> IsFriendImplentation;
@@ -585,6 +590,9 @@ private:
 	 */
 	uint32_t m_LootMatrixID;
 
+	// The currency index to determine how much loot to drop
+	int32_t m_CurrencyIndex{ -1 };
+
 	/**
 	 * The min amount of coins that will drop when this entity is smashed
 	 */

dGame/dComponents/GhostComponent.cpp

@@ -1,9 +1,21 @@
 #include "GhostComponent.h"
+#include "PlayerManager.h"
+#include "Character.h"
+#include "ControllablePhysicsComponent.h"
+#include "UserManager.h"
+#include "User.h"
+
+#include "Amf3.h"
+#include "GameMessages.h"
 
 GhostComponent::GhostComponent(Entity* parent, const int32_t componentID) : Component(parent, componentID) {
 	m_GhostReferencePoint = NiPoint3Constant::ZERO;
 	m_GhostOverridePoint = NiPoint3Constant::ZERO;
 	m_GhostOverride = false;
+
+	RegisterMsg<GameMessages::ToggleGMInvis>(this, &GhostComponent::OnToggleGMInvis);
+	RegisterMsg<GameMessages::GetGMInvis>(this, &GhostComponent::OnGetGMInvis);
+	RegisterMsg<GameMessages::GetObjectReportInfo>(this, &GhostComponent::MsgGetObjectReportInfo);
 }
 
 GhostComponent::~GhostComponent() {
@@ -17,6 +29,26 @@ GhostComponent::~GhostComponent() {
 	}
 }
 
+void GhostComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
+	auto* objElement = doc.FirstChildElement("obj");
+	if (!objElement) return;
+	auto* ghstElement = objElement->FirstChildElement("ghst");
+	if (!ghstElement) return;
+	m_IsGMInvisible = ghstElement->BoolAttribute("i");
+}
+
+void GhostComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
+	auto* objElement = doc.FirstChildElement("obj");
+	if (!objElement) return;
+	auto* ghstElement = objElement->FirstChildElement("ghst");
+	if (ghstElement) objElement->DeleteChild(ghstElement);
+	// Only save if GM invisible
+	const auto* const user = UserManager::Instance()->GetUser(m_Parent->GetSystemAddress());
+	if (!m_IsGMInvisible || !user || user->GetMaxGMLevel() < eGameMasterLevel::FORUM_MODERATOR) return;
+	ghstElement = objElement->InsertNewChildElement("ghst");
+	if (ghstElement) ghstElement->SetAttribute("i", m_IsGMInvisible);
+}
+
 void GhostComponent::SetGhostReferencePoint(const NiPoint3& value) {
 	m_GhostReferencePoint = value;
 }
@@ -55,3 +87,51 @@ bool GhostComponent::IsObserved(LWOOBJID id) {
 void GhostComponent::GhostEntity(LWOOBJID id) {
 	m_ObservedEntities.erase(id);
 }
+
+bool GhostComponent::OnToggleGMInvis(GameMessages::GameMsg& msg) {
+	// TODO: disabled for now while bugs are fixed
+	return false;
+	auto& gmInvisMsg = static_cast<GameMessages::ToggleGMInvis&>(msg);
+	gmInvisMsg.bStateOut = !m_IsGMInvisible;
+	m_IsGMInvisible = !m_IsGMInvisible;
+	LOG_DEBUG("GM Invisibility toggled to: %s", m_IsGMInvisible ? "true" : "false");
+	gmInvisMsg.Send(UNASSIGNED_SYSTEM_ADDRESS);
+	auto* thisUser = UserManager::Instance()->GetUser(m_Parent->GetSystemAddress());
+	for (const auto& player : PlayerManager::GetAllPlayers()) {
+		if (!player || player->GetObjectID() == m_Parent->GetObjectID()) continue;
+		auto* toUser = UserManager::Instance()->GetUser(player->GetSystemAddress());
+		if (m_IsGMInvisible) {
+			if (toUser->GetMaxGMLevel() < thisUser->GetMaxGMLevel()) {
+				Game::entityManager->DestructEntity(m_Parent, player->GetSystemAddress());
+			}
+		} else {
+			if (toUser->GetMaxGMLevel() >= thisUser->GetMaxGMLevel()) {
+				Game::entityManager->ConstructEntity(m_Parent, player->GetSystemAddress());
+				auto* controllableComp = m_Parent->GetComponent<ControllablePhysicsComponent>();
+				controllableComp->SetDirtyPosition(true);
+			}
+		}
+	}
+	Game::entityManager->SerializeEntity(m_Parent);
+
+	return true;
+}
+
+bool GhostComponent::OnGetGMInvis(GameMessages::GameMsg& msg) {
+	LOG_DEBUG("GM Invisibility requested: %s", m_IsGMInvisible ? "true" : "false");
+	auto& gmInvisMsg = static_cast<GameMessages::GetGMInvis&>(msg);
+	// TODO: disabled for now while bugs are fixed
+	// gmInvisMsg.bGMInvis = m_IsGMInvisible;
+	// return gmInvisMsg.bGMInvis;
+	gmInvisMsg.bGMInvis = false;
+	return false;
+}
+
+bool GhostComponent::MsgGetObjectReportInfo(GameMessages::GameMsg& msg) {
+	auto& reportMsg = static_cast<GameMessages::GetObjectReportInfo&>(msg);
+	auto& cmptType = reportMsg.info->PushDebug("Ghost");
+	cmptType.PushDebug<AMFIntValue>("Component ID") = GetComponentID();
+	cmptType.PushDebug<AMFBoolValue>("Is GM Invis") = false;
+
+	return true;
+}

dGame/dComponents/GhostComponent.h

@@ -7,11 +7,17 @@
 
 class NiPoint3;
 
+namespace tinyxml2 {
+	class XMLDocument;
+}
+
 class GhostComponent final : public Component {
 public:
 	static inline const eReplicaComponentType ComponentType = eReplicaComponentType::GHOST;
 	GhostComponent(Entity* parent, const int32_t componentID);
 	~GhostComponent() override;
+	void LoadFromXml(const tinyxml2::XMLDocument& doc) override;
+	void UpdateXml(tinyxml2::XMLDocument& doc) override;
 
 	void SetGhostOverride(bool value) { m_GhostOverride = value; };
 
@@ -39,7 +45,14 @@ public:
 
 	void GhostEntity(const LWOOBJID id);
 
+	bool OnToggleGMInvis(GameMessages::GameMsg& msg);
+
+	bool OnGetGMInvis(GameMessages::GameMsg& msg);
+	
+	bool MsgGetObjectReportInfo(GameMessages::GameMsg& msg);
+
 private:
+
 	NiPoint3 m_GhostReferencePoint;
 
 	NiPoint3 m_GhostOverridePoint;
@@ -49,6 +62,9 @@ private:
 	std::unordered_set<LWOOBJID> m_LimboConstructions;
 
 	bool m_GhostOverride;
+
+	bool m_IsGMInvisible{ false };
+	
 };
 
 #endif  //!__GHOSTCOMPONENT__H__

dGame/dComponents/InventoryComponent.cpp

@@ -39,10 +39,13 @@
 #include "CDObjectSkillsTable.h"
 #include "CDSkillBehaviorTable.h"
 #include "StringifiedEnum.h"
+#include "Amf3.h"
 
 #include <ranges>
 
 InventoryComponent::InventoryComponent(Entity* parent, const int32_t componentID) : Component(parent, componentID) {
+	using namespace GameMessages;
+	RegisterMsg<GetObjectReportInfo>(this, &InventoryComponent::OnGetObjectReportInfo);
 	this->m_Dirty = true;
 	this->m_Equipped = {};
 	this->m_Pushed = {};
@@ -279,7 +282,14 @@ void InventoryComponent::AddItem(
 
 			case 1:
 				for (size_t i = 0; i < size; i++) {
-					GameMessages::SendDropClientLoot(this->m_Parent, this->m_Parent->GetObjectID(), lot, 0, this->m_Parent->GetPosition(), 1);
+					GameMessages::DropClientLoot lootMsg{};
+					lootMsg.target = m_Parent->GetObjectID();
+					lootMsg.ownerID = m_Parent->GetObjectID();
+					lootMsg.sourceID = m_Parent->GetObjectID();
+					lootMsg.item = lot;
+					lootMsg.count = 1;
+					lootMsg.spawnPos = m_Parent->GetPosition();
+					Loot::DropItem(*m_Parent, lootMsg);
 				}
 
 				break;
@@ -440,7 +450,7 @@ Item* InventoryComponent::FindItemBySubKey(LWOOBJID id, eInventoryType inventory
 	}
 }
 
-bool InventoryComponent::HasSpaceForLoot(const std::unordered_map<LOT, int32_t>& loot) {
+bool InventoryComponent::HasSpaceForLoot(const Loot::Return& loot) {
 	std::unordered_map<eInventoryType, int32_t> spaceOffset{};
 
 	uint32_t slotsNeeded = 0;
@@ -626,7 +636,7 @@ void InventoryComponent::UpdateXml(tinyxml2::XMLDocument& document) {
 	for (const auto& pair : this->m_Inventories) {
 		auto* inventory = pair.second;
 
-		static const auto EXCLUDED_INVENTORIES = {VENDOR_BUYBACK, MODELS_IN_BBB, ITEM_SETS};
+		static const auto EXCLUDED_INVENTORIES = { VENDOR_BUYBACK, MODELS_IN_BBB, ITEM_SETS };
 		if (std::ranges::find(EXCLUDED_INVENTORIES, inventory->GetType()) != EXCLUDED_INVENTORIES.end()) {
 			continue;
 		}
@@ -1793,3 +1803,99 @@ void InventoryComponent::RegenerateItemIDs() {
 		inventory->RegenerateItemIDs();
 	}
 }
+
+std::string DebugInvToString(const eInventoryType inv, bool verbose) {
+	switch (inv) {
+	case ITEMS:
+		return "Backpack";
+	case VAULT_ITEMS:
+		return "Bank";
+	case BRICKS:
+		return verbose ? "Bricks" : "Bricks (contents only shown in high-detail report)";
+	case MODELS_IN_BBB:
+		return "Models in BBB";
+	case TEMP_ITEMS:
+		return "Temp Equip";
+	case MODELS:
+		return verbose ? "Model" : "Model (contents only shown in high-detail report)";
+	case TEMP_MODELS:
+		return "Module";
+	case BEHAVIORS:
+		return "B3 Behavior";
+	case PROPERTY_DEEDS:
+		return "Property";
+	case BRICKS_IN_BBB:
+		return "Brick In BBB";
+	case VENDOR:
+		return "Vendor";
+	case VENDOR_BUYBACK:
+		return "BuyBack";
+	case QUEST:
+		return "Quest";
+	case DONATION:
+		return "Donation";
+	case VAULT_MODELS:
+		return "Bank Model";
+	case ITEM_SETS:
+		return "Bank Behavior";
+	case INVALID:
+		return "Invalid";
+	case ALL:
+		return "All";
+	}
+
+	return "";
+}
+
+bool InventoryComponent::OnGetObjectReportInfo(GameMessages::GameMsg& msg) {
+	auto& report = static_cast<GameMessages::GetObjectReportInfo&>(msg);
+	auto& cmpt = report.info->PushDebug("Inventory");
+	cmpt.PushDebug<AMFIntValue>("Component ID") = GetComponentID();
+	uint32_t numItems = 0;
+	for (auto* inventory : m_Inventories | std::views::values) numItems += inventory->GetItems().size();
+	cmpt.PushDebug<AMFIntValue>("Inventory Item Count") = numItems;
+
+	auto& itemsInBags = cmpt.PushDebug("Items in bags");
+	for (const auto& [id, inventoryMut] : m_Inventories) {
+		if (!inventoryMut) continue;
+		const auto* const inventory = inventoryMut;
+		auto& curInv = itemsInBags.PushDebug(DebugInvToString(id, report.bVerbose) + " - " + std::to_string(id));
+		for (uint32_t i = 0; i < inventory->GetSize(); i++) {
+			const auto* const item = inventory->FindItemBySlot(i);
+			if (!item) continue;
+
+			std::stringstream ss;
+			ss << "%[Objects_" << item->GetLot() << "_name] Slot " << item->GetSlot();
+			auto& slot = curInv.PushDebug(ss.str());
+			slot.PushDebug<AMFStringValue>("Object ID") = std::to_string(item->GetId());
+			slot.PushDebug<AMFIntValue>("LOT") = item->GetLot();
+			if (item->GetSubKey() != LWOOBJID_EMPTY) slot.PushDebug<AMFStringValue>("Subkey") = std::to_string(item->GetSubKey());
+			slot.PushDebug<AMFIntValue>("Count") = item->GetCount();
+			slot.PushDebug<AMFIntValue>("Slot") = item->GetSlot();
+			slot.PushDebug<AMFBoolValue>("Bind on pickup") = item->GetInfo().isBOP;
+			slot.PushDebug<AMFBoolValue>("Bind on equip") = item->GetInfo().isBOE;
+			slot.PushDebug<AMFBoolValue>("Is currently bound") = item->GetBound();
+			auto& extra = slot.PushDebug("Extra Info");
+			for (const auto* const setting : item->GetConfig()) {
+				if (setting) extra.PushDebug<AMFStringValue>(GeneralUtils::UTF16ToWTF8(setting->GetKey())) = setting->GetValueAsString();
+			}
+		}
+	}
+
+	auto& equipped = cmpt.PushDebug("Equipped Items");
+	for (const auto& [location, info] : GetEquippedItems()) {
+		std::stringstream ss;
+		ss << "%[Objects_" << info.lot << "_name]";
+		auto& equipSlot = equipped.PushDebug(ss.str());
+		equipSlot.PushDebug<AMFStringValue>("Location") = location;
+		equipSlot.PushDebug<AMFStringValue>("Object ID") = std::to_string(info.id);
+		equipSlot.PushDebug<AMFIntValue>("Slot") = info.slot;
+		equipSlot.PushDebug<AMFIntValue>("Count") = info.count;
+		auto& extra = equipSlot.PushDebug("Extra Info");
+		for (const auto* const setting : info.config) {
+			if (setting) extra.PushDebug<AMFStringValue>(GeneralUtils::UTF16ToWTF8(setting->GetKey())) = setting->GetValueAsString();
+		}
+	}
+
+	return true;
+}