more misc work

CMakeLists.txt

@@ -235,6 +235,8 @@ include_directories(
 
 	"dNet"
 
+	"dWeb"
+
 	"tests"
 	"tests/dCommonTests"
 	"tests/dGameTests"
@@ -301,6 +303,7 @@ add_subdirectory(dZoneManager)
 add_subdirectory(dNavigation)
 add_subdirectory(dPhysics)
 add_subdirectory(dServer)
+add_subdirectory(dWeb)
 
 # Create a list of common libraries shared between all binaries
 set(COMMON_LIBRARIES "dCommon" "dDatabase" "dNet" "raknet" "magic_enum")

dChatFilter/dChatFilter.cpp

@@ -105,7 +105,7 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowLis
 	}
 }
 
-std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
+std::set<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
 	if (gmLevel > eGameMasterLevel::FORUM_MODERATOR) return { }; //If anything but a forum mod, return true.
 	if (message.empty()) return { };
 	if (!allowList && m_DeniedWords.empty()) return { { 0, message.length() } };
@@ -114,7 +114,7 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::
 	std::string segment;
 	std::regex reg("(!*|\\?*|\\;*|\\.*|\\,*)");
 
-	std::vector<std::pair<uint8_t, uint8_t>> listOfBadSegments = std::vector<std::pair<uint8_t, uint8_t>>();
+	std::set<std::pair<uint8_t, uint8_t>> listOfBadSegments;
 
 	uint32_t position = 0;
 
@@ -127,17 +127,17 @@ std::vector<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::
 		size_t hash = CalculateHash(segment);
 
 		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && allowList) {
-			listOfBadSegments.emplace_back(position, originalSegment.length());
+			listOfBadSegments.emplace(position, originalSegment.length());
 		}
 
 		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
-			listOfBadSegments.emplace_back(position, originalSegment.length());
+			listOfBadSegments.emplace(position, originalSegment.length());
 		}
 
 		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
-			listOfBadSegments.emplace_back(position, originalSegment.length());
+			listOfBadSegments.emplace(position, originalSegment.length());
 		}
 
 		position += originalSegment.length() + 1;

dChatFilter/dChatFilter.h

@@ -24,7 +24,7 @@ public:
 	void ReadWordlistPlaintext(const std::string& filepath, bool allowList);
 	bool ReadWordlistDCF(const std::string& filepath, bool allowList);
 	void ExportWordlistToDCF(const std::string& filepath, bool allowList);
-	std::vector<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
+	std::set<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
 
 private:
 	bool m_DontGenerateDCF;

dChatServer/CMakeLists.txt

@@ -1,18 +1,18 @@
 set(DCHATSERVER_SOURCES
 	"ChatIgnoreList.cpp"
+	"ChatJSONUtils.cpp"
 	"ChatPacketHandler.cpp"
 	"PlayerContainer.cpp"
-	"ChatWebAPI.cpp"
-	"JSONUtils.cpp"
+	"ChatWeb.cpp"
 )
 
 add_executable(ChatServer "ChatServer.cpp")
-target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter")
+target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter" "${PROJECT_SOURCE_DIR}/dWeb")
 add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")
 
 add_library(dChatServer ${DCHATSERVER_SOURCES})
-target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer")
+target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer" "${PROJECT_SOURCE_DIR}/dChatFilter")
 
 target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
-target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer mongoose)
+target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer dWeb)
 

dChatServer/ChatJSONUtils.cpp

@@ -1,4 +1,4 @@
-#include "JSONUtils.h"
+#include "ChatJSONUtils.h"
 
 #include "json.hpp"
 
@@ -47,16 +47,3 @@ void to_json(json& data, const TeamData& teamData) {
 		members.push_back(playerData);
 	}
 }
-
-std::string JSONUtils::CheckRequiredData(const json& data, const std::vector<std::string>& requiredData) {
-	json check;
-	check["error"] = json::array();
-	for (const auto& required : requiredData) {
-		if (!data.contains(required)) {
-			check["error"].push_back("Missing Parameter: " + required);
-		} else if (data[required] == "") {
-			check["error"].push_back("Empty Parameter: " + required);
-		}
-	}
-	return check["error"].empty() ? "" : check.dump();
-}

dChatServer/ChatJSONUtils.h

@@ -1,5 +1,5 @@
-#ifndef __JSONUTILS_H__
-#define __JSONUTILS_H__
+#ifndef __CHATJSONUTILS_H__
+#define __CHATJSONUTILS_H__
 
 #include "json_fwd.hpp"
 #include "PlayerContainer.h"
@@ -9,9 +9,4 @@ void to_json(nlohmann::json& data, const PlayerContainer& playerContainer);
 void to_json(nlohmann::json& data, const TeamContainer& teamData);
 void to_json(nlohmann::json& data, const TeamData& teamData);
 
-namespace JSONUtils {
-	// check required data for reqeust
-	std::string CheckRequiredData(const nlohmann::json& data, const std::vector<std::string>& requiredData);
-}
-
-#endif // __JSONUTILS_H__
+#endif // __CHATJSONUTILS_H__

dChatServer/ChatPacketHandler.cpp

@@ -19,6 +19,8 @@
 #include "StringifiedEnum.h"
 #include "eGameMasterLevel.h"
 #include "ChatPackets.h"
+#include "json.hpp"
+#include "ChatWeb.h"
 
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:
@@ -364,7 +366,7 @@ void ChatPacketHandler::HandleGMLevelUpdate(Packet* packet) {
 
 void ChatPacketHandler::HandleWho(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	FindPlayerRequest request;
+	ChatPackets::FindPlayerRequest request;
 	request.Deserialize(inStream);
 
 	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
@@ -390,7 +392,7 @@ void ChatPacketHandler::HandleWho(Packet* packet) {
 
 void ChatPacketHandler::HandleShowAll(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	ShowAllRequest request;
+	ChatPackets::ShowAllRequest request;
 	request.Deserialize(inStream);
 
 	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
@@ -426,97 +428,106 @@ void ChatPacketHandler::HandleShowAll(Packet* packet) {
 // that are sent to the server. Because of this, there are large gaps of unused data in chat messages
 void ChatPacketHandler::HandleChatMessage(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	LWOOBJID playerID;
-	inStream.Read(playerID);
+	ChatMessage data;
+	LWOOBJID sender;
+	inStream.Read(sender);
+	LOG("Got a message from player %llu", sender);
 
-	const auto& sender = Game::playerContainer.GetPlayerData(playerID);
-	if (!sender || sender.GetIsMuted()) return;
+	data.sender = Game::playerContainer.GetPlayerData(sender);
+	if (!data.sender || data.sender.GetIsMuted()) return;
 
-	eChatChannel channel;
 	uint32_t size;
 
 	inStream.IgnoreBytes(4);
-	inStream.Read(channel);
+	inStream.Read(data.channel);
 	inStream.Read(size);
 	inStream.IgnoreBytes(77);
 
-	LUWString message(size);
-	inStream.Read(message);
+	data.message = LUWString(size);
+	inStream.Read(data.message);
 
-	LOG("Got a message from (%s) via [%s]: %s", sender.playerName.c_str(), StringifiedEnum::ToString(channel).data(), message.GetAsString().c_str());
+	LOG("Got message from (%s) via [%s]: %s", data.sender.playerName.c_str(), StringifiedEnum::ToString(data.channel).data(), data.message.GetAsString().c_str());
+	
+	
+	switch (data.channel) {
+		case eChatChannel::TEAM: {
+			auto* team = Game::playerContainer.GetTeam(data.sender.playerID);
+			if (team == nullptr) return;
+			data.teamID = team->teamID;
 
-	switch (channel) {
-	case eChatChannel::TEAM: {
-		auto* team = Game::playerContainer.GetTeam(playerID);
-		if (team == nullptr) return;
-
-		for (const auto memberId : team->memberIDs) {
-			const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
-			if (!otherMember) return;
-			SendPrivateChatMessage(sender, otherMember, otherMember, message, eChatChannel::TEAM, eChatMessageResponseCode::SENT);
+			for (const auto memberId : team->memberIDs) {
+				const auto& otherMember = Game::playerContainer.GetPlayerData(memberId);
+				if (!otherMember) return;
+				SendPrivateChatMessage(data.sender, otherMember, otherMember, data.message, eChatChannel::TEAM, eChatMessageResponseCode::SENT);
+			}
+			break;
 		}
-		break;
-	}
-	default:
-		LOG("Unhandled Chat channel [%s]", StringifiedEnum::ToString(channel).data());
-		break;
+		default:
+			LOG_DEBUG("Unhandled Chat channel [%s]", StringifiedEnum::ToString(data.channel).data());
+			break;
 	}
+	ChatWeb::SendWSChatMessage(data);
 }
 
 // the structure the client uses to send this packet is shared in many chat messages
 // that are sent to the server. Because of this, there are large gaps of unused data in chat messages
 void ChatPacketHandler::HandlePrivateChatMessage(Packet* packet) {
+	ChatMessage data;
+	data.channel = eChatChannel::GENERAL;
+
 	CINSTREAM_SKIP_HEADER;
 	LWOOBJID playerID;
 	inStream.Read(playerID);
 
-	const auto& sender = Game::playerContainer.GetPlayerData(playerID);
-	if (!sender || sender.GetIsMuted()) return;
+	data.sender = Game::playerContainer.GetPlayerData(playerID);
+	if (!data.sender || data.sender.GetIsMuted()) return;
 
-	eChatChannel channel;
 	uint32_t size;
-	LUWString LUReceiverName;
 
 	inStream.IgnoreBytes(4);
-	inStream.Read(channel);
-	if (channel != eChatChannel::PRIVATE_CHAT) LOG("WARNING: Received Private chat with the wrong channel!");
+	inStream.Read(data.channel);
+	if (data.channel != eChatChannel::PRIVATE_CHAT) LOG("WARNING: Received Private chat with the wrong channel!");
 
 	inStream.Read(size);
 	inStream.IgnoreBytes(77);
 
+	LUWString LUReceiverName;
 	inStream.Read(LUReceiverName);
 	auto receiverName = LUReceiverName.GetAsString();
 	inStream.IgnoreBytes(2);
 
-	LUWString message(size);
-	inStream.Read(message);
+	data.message = LUWString(size);
+	inStream.Read(data.message);
 
-	LOG("Got a message from (%s) via [%s]: %s to %s", sender.playerName.c_str(), StringifiedEnum::ToString(channel).data(), message.GetAsString().c_str(), receiverName.c_str());
+	LOG("Got a message from (%s) via [%s]: %s to %s", data.sender.playerName.c_str(), StringifiedEnum::ToString(data.channel).data(), data.message.GetAsString().c_str(), receiverName.c_str());
 
-	const auto& receiver = Game::playerContainer.GetPlayerData(receiverName);
-	if (!receiver) {
+	data.receiver = Game::playerContainer.GetPlayerData(receiverName);
+	if (!data.receiver) {
 		PlayerData otherPlayer;
 		otherPlayer.playerName = receiverName;
 		auto responseType = Database::Get()->GetCharacterInfo(receiverName)
 			? eChatMessageResponseCode::NOTONLINE
 			: eChatMessageResponseCode::GENERALERROR;
 
-		SendPrivateChatMessage(sender, otherPlayer, sender, message, eChatChannel::GENERAL, responseType);
+		SendPrivateChatMessage(data.sender, otherPlayer, data.sender, data.message, data.channel, responseType);
 		return;
 	}
 
 	// Check to see if they are friends
 	// only freinds can whispr each other
-	for (const auto& fr : receiver.friends) {
-		if (fr.friendID == sender.playerID) {
-			//To the sender:
-			SendPrivateChatMessage(sender, receiver, sender, message, eChatChannel::PRIVATE_CHAT, eChatMessageResponseCode::SENT);
-			//To the receiver:
-			SendPrivateChatMessage(sender, receiver, receiver, message, eChatChannel::PRIVATE_CHAT, eChatMessageResponseCode::RECEIVEDNEWWHISPER);
+	for (const auto& fr : data.receiver.friends) {
+		if (fr.friendID == data.sender.playerID) {
+			data.channel = eChatChannel::PRIVATE_CHAT;
+			// To the sender:
+			SendPrivateChatMessage(data.sender, data.receiver, data.sender, data.message, data.channel, eChatMessageResponseCode::SENT);
+			// To the receiver:
+			SendPrivateChatMessage(data.sender, data.receiver, data.receiver, data.message, data.channel, eChatMessageResponseCode::RECEIVEDNEWWHISPER);
+			// To the websocket:
+			ChatWeb::SendWSChatMessage(data);
 			return;
 		}
 	}
-	SendPrivateChatMessage(sender, receiver, sender, message, eChatChannel::GENERAL, eChatMessageResponseCode::NOTFRIENDS);
+	SendPrivateChatMessage(data.sender, data.receiver, data.sender, data.message, data.channel, eChatMessageResponseCode::NOTFRIENDS);
 }
 
 void ChatPacketHandler::SendPrivateChatMessage(const PlayerData& sender, const PlayerData& receiver, const PlayerData& routeTo, const LUWString& message, const eChatChannel channel, const eChatMessageResponseCode responseCode) {

dChatServer/ChatPacketHandler.h

@@ -2,8 +2,8 @@
 #include "dCommonVars.h"
 #include "dNetCommon.h"
 #include "BitStream.h"
-
-struct PlayerData;
+#include "PlayerContainer.h"
+#include "eChatMessageResponseCode.h"
 
 enum class eAddFriendResponseType : uint8_t;
 
@@ -34,14 +34,13 @@ enum class eChatChannel : uint8_t {
 };
 
 
-enum class eChatMessageResponseCode : uint8_t {
-    SENT = 0,
-    NOTONLINE,
-    GENERALERROR,
-    RECEIVEDNEWWHISPER,
-    NOTFRIENDS,
-    SENDERFREETRIAL,
-    RECEIVERFREETRIAL,
+
+struct ChatMessage {
+	LUWString message;
+	PlayerData sender;
+	PlayerData receiver;
+	eChatChannel channel;
+	LWOOBJID teamID;
 };
 
 namespace ChatPacketHandler {

dChatServer/ChatServer.cpp

@@ -28,7 +28,7 @@
 #include "RakNetDefines.h"
 #include "MessageIdentifiers.h"
 
-#include "ChatWebAPI.h"
+#include "ChatWeb.h"
 
 namespace Game {
 	Logger* logger = nullptr;
@@ -92,17 +92,18 @@ int main(int argc, char** argv) {
 		return EXIT_FAILURE;
 	}
 
-	// seyup the chat api web server
-	bool web_server_enabled = Game::config->GetValue("web_server_enabled") == "1";
-	ChatWebAPI chatwebapi;
-	if (web_server_enabled && !chatwebapi.Startup()){
-		// if we want the web api and it fails to start, exit
+	// setup the chat api web server
+	const uint32_t web_server_port = GeneralUtils::TryParse<uint32_t>(Game::config->GetValue("web_server_port")).value_or(2005);
+	if (Game::config->GetValue("web_server_enabled") == "1" && !Game::web.Startup("localhost", web_server_port)) {
+		// if we want the web server and it fails to start, exit
 		LOG("Failed to start web server, shutting down.");
 		Database::Destroy("ChatServer");
 		delete Game::logger;
 		delete Game::config;
 		return EXIT_FAILURE;
-	};
+	}
+
+	if (Game::web.IsEnabled()) ChatWeb::RegisterRoutes();
 
 	//Find out the master's IP:
 	std::string masterIP;
@@ -166,10 +167,8 @@ int main(int argc, char** argv) {
 			packet = nullptr;
 		}
 
-		//Check and handle web requests:
-		if (web_server_enabled) {
-			chatwebapi.ReceiveRequests();
-		}
+		// Check and handle web requests:
+		if (Game::web.IsEnabled()) Game::web.ReceiveRequests();
 
 		//Push our log every 30s:
 		if (framesSinceLastFlush >= logFlushTime) {
@@ -207,6 +206,7 @@ int main(int argc, char** argv) {
 }
 
 void HandlePacket(Packet* packet) {
+	LOG("Received packet with ID: %i", packet->data[0]);
 	if (packet->length < 1) return;
 	if (packet->data[0] == ID_DISCONNECTION_NOTIFICATION || packet->data[0] == ID_CONNECTION_LOST) {
 		LOG("A server has disconnected, erasing their connected players from the list.");

dChatServer/ChatWeb.cpp

@@ -0,0 +1,169 @@
+#include "ChatWeb.h"
+
+#include "Logger.h"
+#include "Game.h"
+#include "json.hpp"
+#include "dCommonVars.h"
+#include "MessageType/Chat.h"
+#include "dServer.h"
+#include "dConfig.h"
+#include "PlayerContainer.h"
+#include "GeneralUtils.h"
+#include "eHTTPMethod.h"
+#include "magic_enum.hpp"
+#include "ChatPackets.h"
+#include "StringifiedEnum.h"
+#include "Database.h"
+#include "ChatJSONUtils.h"
+#include "JSONUtils.h"
+#include "eGameMasterLevel.h"
+#include "dChatFilter.h"
+
+using json = nlohmann::json;
+
+void HandleHTTPPlayersRequest(HTTPReply& reply, std::string body) {
+	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) {
+	const json data = Game::playerContainer.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);
+	if (!data) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = "{\"error\":\"Invalid JSON\"}";
+		return;
+	}
+
+	const auto& good_data = data.value();
+	auto check = JSONUtils::CheckRequiredData(good_data, { "title", "message" });
+	if (!check.empty()) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = check;
+	} else {
+
+		ChatPackets::Announcement announcement;
+		announcement.title = good_data["title"];
+		announcement.message = good_data["message"];
+		announcement.Send(UNASSIGNED_SYSTEM_ADDRESS);
+
+		reply.status = eHTTPStatusCode::OK;
+		reply.message = "{\"status\":\"Announcement Sent\"}";
+	}
+}
+
+void HandleWSChat(mg_connection* connection, json data) {
+	auto check = JSONUtils::CheckRequiredData(data, { "user", "message", "gmlevel", "zone" });
+	if (!check.empty()) {
+		LOG_DEBUG("Received invalid websocket message: %s", check.c_str());
+	} else {
+		const auto user = data["user"].get<std::string>();
+		const auto message = data["message"].get<std::string>();
+		const auto gmlevel = GeneralUtils::TryParse<eGameMasterLevel>(data["gmlevel"].get<std::string>()).value_or(eGameMasterLevel::CIVILIAN);
+		const auto zone = data["zone"].get<uint32_t>();
+
+		const auto filter_check = Game::chatFilter->IsSentenceOkay(message, gmlevel);
+		if (!filter_check.empty()) {
+			LOG_DEBUG("Chat message \"%s\" from %s was not allowed", message.c_str(), user.c_str());
+			data["error"] = "Chat message blocked by filter";
+			data["filtered"] = json::array();
+			for (const auto& [start, len] : filter_check) {
+				data["filtered"].push_back(message.substr(start, len));
+			}
+			mg_ws_send(connection, data.dump().c_str(), data.dump().size(), WEBSOCKET_OP_TEXT);
+			return;
+		}
+		LOG("%s: %s", user.c_str(), message.c_str());
+
+		// bodge to test
+		CBITSTREAM;
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GENERAL_CHAT_MESSAGE);
+		bitStream.Write(zone);
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GENERAL_CHAT_MESSAGE);
+
+		bitStream.Write<uint64_t>(0);
+		bitStream.Write(eChatChannel::LOCAL);
+
+		bitStream.Write<uint32_t>(message.size());
+		bitStream.Write(LUWString(user));
+
+		bitStream.Write<uint64_t>(0);
+		bitStream.Write<uint16_t>(0);
+		bitStream.Write<char>(0);
+
+		for (uint32_t i = 0; i < message.size(); ++i) {
+			bitStream.Write<uint16_t>(message[i]);
+		}
+		bitStream.Write<uint16_t>(0);
+		Game::server->Send(bitStream, UNASSIGNED_SYSTEM_ADDRESS, true);
+	}
+}
+
+namespace ChatWeb {
+	void RegisterRoutes() {
+		// REST API v1 routes
+		std::string v1_route = "/api/v1/";
+		Game::web.RegisterHTTPRoute({
+			.path = v1_route + "players",
+			.method = eHTTPMethod::GET,
+			.handle = HandleHTTPPlayersRequest
+		});
+
+		Game::web.RegisterHTTPRoute({
+			.path = v1_route + "teams",
+			.method = eHTTPMethod::GET,
+			.handle = HandleHTTPTeamsRequest
+		});
+
+		Game::web.RegisterHTTPRoute({
+			.path = v1_route + "announce",
+			.method = eHTTPMethod::POST,
+			.handle = HandleHTTPAnnounceRequest
+		});
+
+		// WebSocket Events
+		Game::web.RegisterWSEvent({
+			.name = "chat",
+			.handle = HandleWSChat
+		});
+
+		// WebSocket subscriptions
+		Game::web.RegisterWSSubscription("chat");
+		Game::web.RegisterWSSubscription("player");
+		Game::web.RegisterWSSubscription("team");
+	}
+
+	void SendWSPlayerUpdate(const PlayerData& player, eActivityType activityType) {
+		json data;
+		data["player_data"] = player;
+		data["update_type"] = magic_enum::enum_name(activityType);
+		Game::web.SendWSMessage("player", data);
+	}
+
+	void SendWSChatMessage(const ChatMessage& chatMessage) {
+		json data;
+		data["message"] = chatMessage.message.GetAsString();
+		data["sender"] = chatMessage.sender;
+		data["channel"] = magic_enum::enum_name(chatMessage.channel);
+
+		switch (chatMessage.channel) {
+			case eChatChannel::TEAM:
+				data["teamID"] = chatMessage.teamID;
+				break;
+			case eChatChannel::PRIVATE_CHAT:
+				data["receiver"] = chatMessage.receiver;
+				break;
+			default:
+				// do nothing
+				break;
+		}
+		Game::web.SendWSMessage("chat", data);
+	}
+}
+

dChatServer/ChatWeb.h

@@ -0,0 +1,20 @@
+#ifndef __CHATWEB_H__
+#define __CHATWEB_H__
+
+#include <string>
+#include <functional>
+
+#include "Web.h"
+#include "PlayerContainer.h"
+#include "IActivityLog.h"
+#include "ChatPacketHandler.h"
+
+namespace ChatWeb {
+	void RegisterRoutes();
+	void SendWSPlayerUpdate(const PlayerData& player, eActivityType activityType);
+	void SendWSChatMessage(const ChatMessage& chatMessage);
+};
+
+
+#endif // __CHATWEB_H__
+

dChatServer/ChatWebAPI.cpp

@@ -1,197 +0,0 @@
-#include "ChatWebAPI.h"
-
-#include "Logger.h"
-#include "Game.h"
-#include "json.hpp"
-#include "dCommonVars.h"
-#include "MessageType/Chat.h"
-#include "dServer.h"
-#include "dConfig.h"
-#include "PlayerContainer.h"
-#include "JSONUtils.h"
-#include "GeneralUtils.h"
-#include "eHTTPMethod.h"
-#include "magic_enum.hpp"
-#include "ChatPackets.h"
-#include "StringifiedEnum.h"
-#include "Database.h"
-
-#ifdef DARKFLAME_PLATFORM_WIN32
-#pragma push_macro("DELETE")
-#undef DELETE
-#endif
-
-using json = nlohmann::json;
-
-typedef struct mg_connection mg_connection;
-typedef struct mg_http_message mg_http_message;
-
-namespace {
-	const char* json_content_type = "Content-Type: application/json\r\n";
-	std::map<std::pair<eHTTPMethod, std::string>, WebAPIHTTPRoute> Routes {};
-}
-
-bool ValidateAuthentication(const mg_http_message* http_msg) {
-	// TO DO: This is just a placeholder for now
-	// use tokens or something at a later point if we want to implement authentication
-	// bit using the listen bind address to limit external access is good enough to start with
-	return true;
-}
-
-bool ValidateJSON(std::optional<json> data, HTTPReply& reply) {
-	if (!data) {
-		reply.status = eHTTPStatusCode::BAD_REQUEST;
-		reply.message = "{\"error\":\"Invalid JSON\"}";
-		return false;
-	}
-	return true;
-}
-
-void HandlePlayersRequest(HTTPReply& reply, std::string body) {
-	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 HandleTeamsRequest(HTTPReply& reply, std::string body) {
-	const json data = Game::playerContainer.GetTeamContainer();
-	reply.status = data.empty() ? eHTTPStatusCode::NO_CONTENT : eHTTPStatusCode::OK;
-	reply.message = data.empty() ? "{\"error\":\"No Teams Online\"}" : data.dump();
-}
-
-void HandleAnnounceRequest(HTTPReply& reply, std::string body) {
-	auto data = GeneralUtils::TryParse<json>(body);
-	if (!ValidateJSON(data, reply)) return;
-
-	const auto& good_data = data.value();
-	auto check = JSONUtils::CheckRequiredData(good_data, { "title", "message" });
-	if (!check.empty()) {
-		reply.status = eHTTPStatusCode::BAD_REQUEST;
-		reply.message = check;
-	} else {
-
-		ChatPackets::Announcement announcement;
-		announcement.title = good_data["title"];
-		announcement.message = good_data["message"];
-		announcement.Send();
-
-		reply.status = eHTTPStatusCode::OK;
-		reply.message = "{\"status\":\"Announcement Sent\"}";
-	}
-}
-
-void HandleInvalidRoute(HTTPReply& reply) {
-	reply.status = eHTTPStatusCode::NOT_FOUND;
-	reply.message = "{\"error\":\"Invalid Route\"}";
-}
-
-void HandleHTTPMessage(mg_connection* connection, const mg_http_message* http_msg) {
-	HTTPReply reply;
-	
-	if (!http_msg) {
-		reply.status = eHTTPStatusCode::BAD_REQUEST;
-		reply.message = "{\"error\":\"Invalid Request\"}";
-	} else if (ValidateAuthentication(http_msg)) {
-		
-		// convert method from cstring to std string
-		std::string method_string(http_msg->method.buf, http_msg->method.len);
-		// get mehtod from mg to enum
-		const eHTTPMethod method = magic_enum::enum_cast<eHTTPMethod>(method_string).value_or(eHTTPMethod::INVALID);
-
-		// convert uri from cstring to std string
-		std::string uri(http_msg->uri.buf, http_msg->uri.len);
-		std::transform(uri.begin(), uri.end(), uri.begin(), ::tolower);
-
-		// convert body from cstring to std string
-		std::string body(http_msg->body.buf, http_msg->body.len);
-
-		
-		const auto routeItr = Routes.find({method, uri});
-
-		if (routeItr != Routes.end()) {
-			const auto& [_, route] = *routeItr;
-			route.handle(reply, body);
-		} else HandleInvalidRoute(reply);
-	} else {
-		reply.status = eHTTPStatusCode::UNAUTHORIZED;
-		reply.message = "{\"error\":\"Unauthorized\"}";
-	}
-	mg_http_reply(connection, static_cast<int>(reply.status), json_content_type, reply.message.c_str());
-}
-
-
-void HandleRequests(mg_connection* connection, int request, void* request_data) {
-	switch (request) {
-		case MG_EV_HTTP_MSG:
-			HandleHTTPMessage(connection, static_cast<mg_http_message*>(request_data));
-			break;
-		default:
-			break;
-	}
-}
-
-void ChatWebAPI::RegisterHTTPRoutes(WebAPIHTTPRoute route) {
-	auto [_, success] = Routes.try_emplace({ route.method, route.path }, route);
-	if (!success) {
-		LOG_DEBUG("Failed to register route %s", route.path.c_str());
-	} else {
-		LOG_DEBUG("Registered route %s", route.path.c_str());
-	}
-}
-
-ChatWebAPI::ChatWebAPI() {
-	mg_log_set(MG_LL_NONE);
-	mg_mgr_init(&mgr);  // Initialize event manager
-}
-
-ChatWebAPI::~ChatWebAPI() {
-	mg_mgr_free(&mgr);
-}
-
-bool ChatWebAPI::Startup() {
-	// Make listen address
-	// std::string listen_ip = Game::config->GetValue("web_server_listen_ip");
-	// if (listen_ip == "localhost") listen_ip = "127.0.0.1";
-
-	const std::string& listen_port = Game::config->GetValue("web_server_listen_port");
-	// const std::string& listen_address = "http://" + listen_ip + ":" + listen_port;
-	const std::string& listen_address = "http://localhost:" + listen_port;
-	LOG("Starting web server on %s", listen_address.c_str());
-
-	// Create HTTP listener
-	if (!mg_http_listen(&mgr, listen_address.c_str(), HandleRequests, NULL)) {
-		LOG("Failed to create web server listener on %s", listen_port.c_str());
-		return false;
-	}
-
-	// Register routes
-
-	// API v1 routes
-	std::string v1_route = "/api/v1/";
-	RegisterHTTPRoutes({
-		.path = v1_route + "players",
-		.method = eHTTPMethod::GET,
-		.handle = HandlePlayersRequest
-	});
-
-	RegisterHTTPRoutes({
-		.path = v1_route + "teams",
-		.method = eHTTPMethod::GET,
-		.handle = HandleTeamsRequest
-	});
-
-	RegisterHTTPRoutes({
-		.path = v1_route + "announce",
-		.method = eHTTPMethod::POST,
-		.handle = HandleAnnounceRequest
-	});
-	return true;
-}
-
-void ChatWebAPI::ReceiveRequests() {
-	mg_mgr_poll(&mgr, 15);
-}
-
-#ifdef DARKFLAME_PLATFORM_WIN32
-#pragma pop_macro("DELETE")
-#endif

dChatServer/ChatWebAPI.h

@@ -1,36 +0,0 @@
-#ifndef __CHATWEBAPI_H__
-#define __CHATWEBAPI_H__
-#include <string>
-#include <functional>
-
-#include "mongoose.h"
-#include "eHTTPStatusCode.h"
-
-enum class eHTTPMethod;
-
-typedef struct mg_mgr mg_mgr;
-
-struct HTTPReply {
-	eHTTPStatusCode status = eHTTPStatusCode::NOT_FOUND;
-	std::string message = "{\"error\":\"Not Found\"}";
-};
-
-struct WebAPIHTTPRoute {
-	std::string path;
-	eHTTPMethod method;
-	std::function<void(HTTPReply&, const std::string&)> handle;
-};
-
-class ChatWebAPI {
-public:
-	ChatWebAPI();
-	~ChatWebAPI();
-	void ReceiveRequests();
-	void RegisterHTTPRoutes(WebAPIHTTPRoute route);
-	bool Startup();
-private:
-	mg_mgr mgr;
-
-};
-
-#endif // __CHATWEBAPI_H__

dChatServer/PlayerContainer.cpp

@@ -12,6 +12,7 @@
 #include "ChatPackets.h"
 #include "dConfig.h"
 #include "MessageType/Chat.h"
+#include "ChatWeb.h"
 
 void PlayerContainer::Initialize() {
 	m_MaxNumberOfBestFriends =
@@ -58,8 +59,8 @@ void PlayerContainer::InsertPlayer(Packet* packet) {
 	m_PlayerCount++;
 
 	LOG("Added user: %s (%llu), zone: %i", data.playerName.c_str(), data.playerID, data.zoneID.GetMapID());
-
-	Database::Get()->UpdateActivityLog(data.playerID, eActivityType::PlayerLoggedIn, data.zoneID.GetMapID());
+	ChatWeb::SendWSPlayerUpdate(data, isLogin ? eActivityType::PlayerLoggedIn : eActivityType::PlayerChangedZone);
+	Database::Get()->UpdateActivityLog(data.playerID, isLogin ? eActivityType::PlayerLoggedIn : eActivityType::PlayerChangedZone, data.zoneID.GetMapID());
 	m_PlayersToRemove.erase(playerId);
 }
 
@@ -113,6 +114,8 @@ void PlayerContainer::RemovePlayer(const LWOOBJID playerID) {
 		}
 	}
 
+	ChatWeb::SendWSPlayerUpdate(player, eActivityType::PlayerLoggedOut);
+
 	m_PlayerCount--;
 	LOG("Removed user: %llu", playerID);
 	m_Players.erase(playerID);

dCommon/BrickByBrickFix.cpp

@@ -8,7 +8,6 @@
 
 #include "Database.h"
 #include "Game.h"
-#include "Sd0.h"
 #include "ZCompression.h"
 #include "Logger.h"
 
@@ -45,10 +44,10 @@ uint32_t BrickByBrickFix::TruncateBrokenBrickByBrickXml() {
 				}
 
 				// Ignore the valgrind warning about uninitialized values.  These are discarded later when we know the actual uncompressed size.
-				std::unique_ptr<uint8_t[]> uncompressedChunk(new uint8_t[Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE]);
+				std::unique_ptr<uint8_t[]> uncompressedChunk(new uint8_t[ZCompression::MAX_SD0_CHUNK_SIZE]);
 				int32_t err{};
 				int32_t actualUncompressedSize = ZCompression::Decompress(
-					compressedChunk.get(), chunkSize, uncompressedChunk.get(), Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE, err);
+					compressedChunk.get(), chunkSize, uncompressedChunk.get(), ZCompression::MAX_SD0_CHUNK_SIZE, err);
 
 				if (actualUncompressedSize != -1) {
 					uint32_t previousSize = completeUncompressedModel.size();
@@ -118,7 +117,7 @@ uint32_t BrickByBrickFix::UpdateBrickByBrickModelsToSd0() {
 			}
 
 			std::string outputString(sd0ConvertedModel.get(), oldLxfmlSizeWithHeader);
-			std::stringstream outputStringStream(outputString);
+			std::istringstream outputStringStream(outputString);
 
 			try {
 				Database::Get()->UpdateUgcModelData(model.id, outputStringStream);

dCommon/CMakeLists.txt

@@ -7,6 +7,7 @@ set(DCOMMON_SOURCES
 		"Logger.cpp"
 		"Game.cpp"
 		"GeneralUtils.cpp"
+		"JSONUtils.cpp"
 		"LDFFormat.cpp"
 		"Metrics.cpp"
 		"NiPoint3.cpp"
@@ -16,9 +17,6 @@ set(DCOMMON_SOURCES
 		"BrickByBrickFix.cpp"
 		"BinaryPathFinder.cpp"
 		"FdbToSqlite.cpp"
-		"TinyXmlUtils.cpp"
-		"Sd0.cpp"
-		"Lxfml.cpp"
 )
 
 # Workaround for compiler bug where the optimized code could result in a memcpy of 0 bytes, even though that isnt possible.

dCommon/JSONUtils.cpp

@@ -0,0 +1,18 @@
+#include "JSONUtils.h"
+#include "json.hpp"
+
+using json = nlohmann::json;
+
+std::string JSONUtils::CheckRequiredData(const json& data, const std::vector<std::string>& requiredData) {
+	json check;
+	check["error"] = json::array();
+	for (const auto& required : requiredData) {
+		if (!data.contains(required)) {
+			check["error"].push_back("Missing Parameter: " + required);
+		} else if (data[required] == "") {
+			check["error"].push_back("Empty Parameter: " + required);
+		}
+	}
+	return check["error"].empty() ? "" : check.dump();
+}
+

dCommon/JSONUtils.h

@@ -0,0 +1,11 @@
+#ifndef _JSONUTILS_H_
+#define _JSONUTILS_H_
+
+#include "json_fwd.hpp"
+
+namespace JSONUtils {
+	// check required data for reqeust
+	std::string CheckRequiredData(const nlohmann::json& data, const std::vector<std::string>& requiredData);
+}
+
+#endif // _JSONUTILS_H_

dCommon/Logger.h

@@ -29,8 +29,8 @@ constexpr const char* GetFileNameFromAbsolutePath(const char* path) {
 // they will not be valid constexpr and will be evaluated at runtime instead of compile time!
 // The full string is still stored in the binary, however the offset of the filename in the absolute paths
 // is used in the instruction instead of the start of the absolute 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)
+#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)
 
 // Writer class for writing data to files.
 class Writer {

dCommon/Lxfml.cpp

@@ -1,115 +0,0 @@
-#include "Lxfml.h"
-
-#include "GeneralUtils.h"
-#include "StringifiedEnum.h"
-#include "TinyXmlUtils.h"
-
-#include <ranges>
-
-Lxfml::Result Lxfml::NormalizePosition(const std::string_view data) {
-	Result toReturn;
-	tinyxml2::XMLDocument doc;
-	const auto err = doc.Parse(data.data());
-	if (err != tinyxml2::XML_SUCCESS) {
-		LOG("Failed to parse xml %s.", StringifiedEnum::ToString(err).data());
-		return toReturn;
-	}
-
-	TinyXmlUtils::DocumentReader reader(doc);
-	std::map<std::string/* refID */, std::string> transformations;
-
-	auto lxfml = reader["LXFML"];
-	if (!lxfml) {
-		LOG("Failed to find LXFML element.");
-		return toReturn;
-	}
-
-	// First get all the positions of bricks
-	for (const auto& brick : lxfml["Bricks"]) {
-		const auto* part = brick.FirstChildElement("Part");
-		if (part) {
-			const auto* bone = part->FirstChildElement("Bone");
-			if (bone) {
-				auto* transformation = bone->Attribute("transformation");
-				if (transformation) {
-					auto* refID = bone->Attribute("refID");
-					if (refID) transformations[refID] = transformation;
-				}
-			}
-		}
-	}
-
-	// These points are well out of bounds for an actual player
-	NiPoint3 lowest{ 10'000.0f, 10'000.0f, 10'000.0f };
-	NiPoint3 highest{ -10'000.0f, -10'000.0f, -10'000.0f };
-
-	// 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 (z < lowest.z) lowest.z = z;
-
-		if (highest.x < x) highest.x = x;
-		if (highest.y < y) highest.y = y;
-		if (highest.z < z) highest.z = z;
-	}
-
-	auto delta = (highest - lowest) / 2.0f;
-	auto newRootPos = lowest + delta;
-
-	// Clamp the Y to the lowest point on the model 
-	newRootPos.y = lowest.y;
-
-	// Adjust all positions to account for the new origin
-	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;
-		auto y = GeneralUtils::TryParse<float>(split[10]).value() - newRootPos.y;
-		auto z = GeneralUtils::TryParse<float>(split[11]).value() - newRootPos.z;
-		std::stringstream stream;
-		for (int i = 0; i < 9; i++) {
-			stream << split[i];
-			stream << ',';
-		}
-		stream << x << ',' << y << ',' << z;
-		transformation = stream.str();
-	}
-
-	// Finally write the new transformation back into the lxfml
-	for (auto& brick : lxfml["Bricks"]) {
-		auto* part = brick.FirstChildElement("Part");
-		if (part) {
-			auto* bone = part->FirstChildElement("Bone");
-			if (bone) {
-				auto* transformation = bone->Attribute("transformation");
-				if (transformation) {
-					auto* refID = bone->Attribute("refID");
-					if (refID) {
-						bone->SetAttribute("transformation", transformations[refID].c_str());
-					}
-				}
-			}
-		}
-	}
-
-	tinyxml2::XMLPrinter printer;
-	doc.Print(&printer);
-
-	toReturn.lxfml = printer.CStr();
-	toReturn.center = newRootPos;
-	return toReturn;
-}

dCommon/Lxfml.h

@@ -1,23 +0,0 @@
-// Darkflame Universe
-// Copyright 2025
-
-#ifndef LXFML_H
-#define LXFML_H
-
-#include <string>
-#include <string_view>
-
-#include "NiPoint3.h"
-
-namespace Lxfml {
-	struct Result {
-		std::string lxfml;
-		NiPoint3 center;
-	};
-
-	// 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);
-};
-
-#endif //!LXFML_H

dCommon/Sd0.cpp

@@ -1,150 +0,0 @@
-#include "Sd0.h"
-
-#include <array>
-#include <ranges>
-
-#include "BinaryIO.h"
-
-#include "Game.h"
-#include "Logger.h"
-
-#include "ZCompression.h"
-
-// Insert header if on first buffer
-void WriteHeader(Sd0::BinaryBuffer& chunk) {
-	chunk.push_back(Sd0::SD0_HEADER[0]);
-	chunk.push_back(Sd0::SD0_HEADER[1]);
-	chunk.push_back(Sd0::SD0_HEADER[2]);
-	chunk.push_back(Sd0::SD0_HEADER[3]);
-	chunk.push_back(Sd0::SD0_HEADER[4]);
-}
-
-// Write the size of the buffer to a chunk
-void WriteSize(Sd0::BinaryBuffer& chunk, uint32_t chunkSize) {
-	for (int i = 0; i < 4; i++) {
-		char toPush = chunkSize & 0xff;
-		chunkSize = chunkSize >> 8;
-		chunk.push_back(toPush);
-	}
-}
-
-int32_t GetDataOffset(bool firstBuffer) {
-	return firstBuffer ? 9 : 4;
-}
-
-Sd0::Sd0(std::istream& buffer) {
-	char header[5]{};
-
-	// Check if this is an sd0 buffer. It's possible we may be handed a zlib buffer directly due to old code so check for that too.
-	if (!BinaryIO::BinaryRead(buffer, header) || memcmp(header, SD0_HEADER, sizeof(header)) != 0) {
-		LOG("Failed to read SD0 header %i %i %i %i %i %i %i", buffer.good(), buffer.tellg(), header[0], header[1], header[2], header[3], header[4]);
-		LOG_DEBUG("This may be a zlib buffer directly? Trying again assuming its a zlib buffer.");
-		auto& firstChunk = m_Chunks.emplace_back();
-		WriteHeader(firstChunk);
-		buffer.seekg(0, std::ios::end);
-		uint32_t bufferSize = buffer.tellg();
-		buffer.seekg(0, std::ios::beg);
-		WriteSize(firstChunk, bufferSize);
-		firstChunk.resize(firstChunk.size() + bufferSize);
-		auto* dataStart = reinterpret_cast<char*>(firstChunk.data() + GetDataOffset(true));
-		if (!buffer.read(dataStart, bufferSize)) {
-			m_Chunks.pop_back();
-			LOG("Failed to read %u bytes from chunk %i", bufferSize, m_Chunks.size() - 1);
-		}
-		return;
-	}
-
-	while (buffer && buffer.peek() != std::istream::traits_type::eof()) {
-		uint32_t chunkSize{};
-		if (!BinaryIO::BinaryRead(buffer, chunkSize)) {
-			LOG("Failed to read chunk size from stream %lld %zu", buffer.tellg(), m_Chunks.size());
-			break;
-		}
-		auto& chunk = m_Chunks.emplace_back();
-		bool firstBuffer = m_Chunks.size() == 1;
-		auto dataOffset = GetDataOffset(firstBuffer);
-
-		// Insert header if on first buffer
-		if (firstBuffer) {
-			WriteHeader(chunk);
-		}
-
-		WriteSize(chunk, chunkSize);
-
-		chunk.resize(chunkSize + dataOffset);
-		auto* dataStart = reinterpret_cast<char*>(chunk.data() + dataOffset);
-		if (!buffer.read(dataStart, chunkSize)) {
-			m_Chunks.pop_back();
-			LOG("Failed to read %u bytes from chunk %i", chunkSize, m_Chunks.size() - 1);
-			break;
-		}
-	}
-}
-
-void Sd0::FromData(const uint8_t* data, size_t bufferSize) {
-	const auto originalBufferSize = bufferSize;
-	if (bufferSize == 0) return;
-
-	m_Chunks.clear();
-	while (bufferSize > 0) {
-		const auto numToCopy = std::min(MAX_UNCOMPRESSED_CHUNK_SIZE, bufferSize);
-		const auto* startOffset = data + originalBufferSize - bufferSize;
-		bufferSize -= numToCopy;
-		std::array<uint8_t, MAX_UNCOMPRESSED_CHUNK_SIZE> compressedChunk;
-		const auto compressedSize = ZCompression::Compress(
-			startOffset, numToCopy,
-			compressedChunk.data(), compressedChunk.size());
-
-		auto& chunk = m_Chunks.emplace_back();
-		bool firstBuffer = m_Chunks.size() == 1;
-		auto dataOffset = GetDataOffset(firstBuffer);
-
-		if (firstBuffer) {
-			WriteHeader(chunk);
-		}
-
-		WriteSize(chunk, compressedSize);
-
-		chunk.resize(compressedSize + dataOffset);
-		memcpy(chunk.data() + dataOffset, compressedChunk.data(), compressedSize);
-	}
-
-}
-
-std::string Sd0::GetAsStringUncompressed() const {
-	std::string toReturn;
-	bool first = true;
-	uint32_t totalSize{};
-	for (const auto& chunk : m_Chunks) {
-		auto dataOffset = GetDataOffset(first);
-		first = false;
-		const auto chunkSize = chunk.size();
-
-		auto oldSize = toReturn.size();
-		toReturn.resize(oldSize + MAX_UNCOMPRESSED_CHUNK_SIZE);
-		int32_t error{};
-		const auto uncompressedSize = ZCompression::Decompress(
-			chunk.data() + dataOffset, chunkSize - dataOffset,
-			reinterpret_cast<uint8_t*>(toReturn.data()) + oldSize, MAX_UNCOMPRESSED_CHUNK_SIZE,
-			error);
-
-		totalSize += uncompressedSize;
-	}
-
-	toReturn.resize(totalSize);
-	return toReturn;
-}
-
-std::stringstream Sd0::GetAsStream() const {
-	std::stringstream toReturn;
-
-	for (const auto& chunk : m_Chunks) {
-		toReturn.write(reinterpret_cast<const char*>(chunk.data()), chunk.size());
-	}
-
-	return toReturn;
-}
-
-const std::vector<Sd0::BinaryBuffer>& Sd0::GetAsVector() const {
-	return m_Chunks;
-}

dCommon/Sd0.h

@@ -1,42 +0,0 @@
-// Darkflame Universe
-// Copyright 2025
-
-#ifndef SD0_H
-#define SD0_H
-
-#include <fstream>
-#include <vector>
-
-// Sd0 is comprised of multiple zlib compressed buffers stored in a row.
-// The format starts with a SD0 header (see SD0_HEADER) followed by the size of a zlib buffer, and then the zlib buffer itself.
-// This repeats until end of file
-class Sd0 {
-public:
-	using BinaryBuffer = std::vector<uint8_t>;
-
-	static inline const char* SD0_HEADER = "sd0\x01\xff";
-
-	/**
-	 * @brief Max size of an inflated sd0 zlib chunk
-	 */
-	static constexpr inline size_t MAX_UNCOMPRESSED_CHUNK_SIZE = 1024 * 256;
-
-	// Read the input buffer into an internal chunk stream to be used later
-	Sd0(std::istream& buffer);
-
-	// Uncompresses the entire Sd0 buffer and returns it as a string
-	[[nodiscard]] std::string GetAsStringUncompressed() const;
-
-	// Gets the Sd0 buffer as a stream in its raw compressed form
-	[[nodiscard]] std::stringstream GetAsStream() const;
-
-	// Gets the Sd0 buffer as a vector in its raw compressed form
-	[[nodiscard]] const std::vector<BinaryBuffer>& GetAsVector() const;
-
-	// Compress data into a Sd0 buffer
-	void FromData(const uint8_t* data, size_t bufferSize);
-private:
-	std::vector<BinaryBuffer> m_Chunks{};
-};
-
-#endif //!SD0_H

dCommon/TinyXmlUtils.cpp

@@ -1,37 +0,0 @@
-#include "TinyXmlUtils.h"
-
-#include <tinyxml2.h>
-
-using namespace TinyXmlUtils;
-
-Element DocumentReader::operator[](const std::string_view elem) const {
-	return Element(m_Doc.FirstChildElement(elem.empty() ? nullptr : elem.data()), elem);
-}
-
-Element::Element(tinyxml2::XMLElement* xmlElem, const std::string_view elem) :
-	m_IteratedName{ elem },
-	m_Elem{ xmlElem } {
-}
-
-Element Element::operator[](const std::string_view elem) const {
-	const auto* usedElem = elem.empty() ? nullptr : elem.data();
-	auto* toReturn = m_Elem ? m_Elem->FirstChildElement(usedElem) : nullptr;
-	return Element(toReturn, m_IteratedName);
-}
-
-ElementIterator Element::begin() {
-	return ElementIterator(m_Elem ? m_Elem->FirstChildElement() : nullptr);
-}
-
-ElementIterator Element::end() {
-	return ElementIterator(nullptr);
-}
-
-ElementIterator::ElementIterator(tinyxml2::XMLElement* elem) :
-	m_CurElem{ elem } {
-}
-
-ElementIterator& ElementIterator::operator++() {
-	if (m_CurElem) m_CurElem = m_CurElem->NextSiblingElement();
-	return *this;
-}

dCommon/TinyXmlUtils.h

@@ -1,66 +0,0 @@
-// Darkflame Universe
-// Copyright 2025
-
-#ifndef TINYXMLUTILS_H
-#define TINYXMLUTILS_H
-
-#include <string>
-
-#include "DluAssert.h"
-
-#include <tinyxml2.h>
-
-namespace TinyXmlUtils {
-	// See cstdlib for iterator technicalities
-	struct ElementIterator {
-		ElementIterator(tinyxml2::XMLElement* elem);
-
-		ElementIterator& operator++();
-		[[nodiscard]] tinyxml2::XMLElement* operator->() { DluAssert(m_CurElem); return m_CurElem; }
-		[[nodiscard]] tinyxml2::XMLElement& operator*() { DluAssert(m_CurElem); return *m_CurElem; }
-
-		bool operator==(const ElementIterator& other) const { return other.m_CurElem == m_CurElem; }
-
-	private:
-		tinyxml2::XMLElement* m_CurElem{ nullptr };
-	};
-
-	// Wrapper class to act as an iterator over xml elements.
-	// All the normal rules that apply to Iterators in the std library apply here.
-	class Element {
-	public:
-		Element(tinyxml2::XMLElement* xmlElem, const std::string_view elem);
-
-		// The first child element of this element.
-		[[nodiscard]] ElementIterator begin();
-
-		// Always returns an ElementIterator which points to nullptr.
-		// TinyXml2 return NULL when you've reached the last child element so
-		// you can't do any funny one past end logic here.
-		[[nodiscard]] ElementIterator end();
-
-		// Get a child element
-		[[nodiscard]] Element operator[](const std::string_view elem) const;
-		[[nodiscard]] Element operator[](const char* elem) const { return operator[](std::string_view(elem)); };
-
-		// Whether or not data exists for this element
-		operator bool() const { return m_Elem != nullptr; }
-
-		[[nodiscard]] const tinyxml2::XMLElement* operator->() const { return m_Elem; }
-	private:
-		const char* GetElementName() const { return m_IteratedName.empty() ? nullptr : m_IteratedName.c_str(); }
-		const std::string m_IteratedName;
-		tinyxml2::XMLElement* m_Elem;
-	};
-
-	class DocumentReader {
-	public:
-		DocumentReader(tinyxml2::XMLDocument& doc) : m_Doc{ doc } {}
-
-		[[nodiscard]] Element operator[](const std::string_view elem) const;
-	private:
-		tinyxml2::XMLDocument& m_Doc;
-	};
-};
-
-#endif  //!TINYXMLUTILS_H

dCommon/ZCompression.h

@@ -8,5 +8,11 @@ namespace ZCompression {
 	int32_t Compress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst);
 
 	int32_t Decompress(const uint8_t* abSrc, int32_t nLenSrc, uint8_t* abDst, int32_t nLenDst, int32_t& nErr);
+
+	/**
+	 * @brief Max size of an inflated sd0 zlib chunk
+	 *
+	 */
+	constexpr uint32_t MAX_SD0_CHUNK_SIZE = 1024 * 256;
 }
 

dCommon/dClient/Pack.cpp

@@ -1,7 +1,6 @@
 #include "Pack.h"
 
 #include "BinaryIO.h"
-#include "Sd0.h"
 #include "ZCompression.h"
 
 Pack::Pack(const std::filesystem::path& filePath) {
@@ -107,7 +106,7 @@ bool Pack::ReadFileFromPack(const uint32_t crc, char** data, uint32_t* len) cons
 		pos += size; // Move pointer position the amount of bytes read to the right
 
 		int32_t err;
-		currentReadPos += ZCompression::Decompress(reinterpret_cast<uint8_t*>(chunk), size, reinterpret_cast<uint8_t*>(decompressedData + currentReadPos), Sd0::MAX_UNCOMPRESSED_CHUNK_SIZE, err);
+		currentReadPos += ZCompression::Decompress(reinterpret_cast<uint8_t*>(chunk), size, reinterpret_cast<uint8_t*>(decompressedData + currentReadPos), ZCompression::MAX_SD0_CHUNK_SIZE, err);
 
 		free(chunk);
 	}

dCommon/dEnums/eChatMessageResponseCode.h

@@ -0,0 +1,15 @@
+#ifndef __ECHATMESSAGERESPONSECODES__H__
+#define __ECHATMESSAGERESPONSECODES__H__
+
+#include <cstdint>
+enum class eChatMessageResponseCode : uint8_t {
+	SENT = 0,
+	NOTONLINE,
+	GENERALERROR,
+	RECEIVEDNEWWHISPER,
+	NOTFRIENDS,
+	SENDERFREETRIAL,
+	RECEIVERFREETRIAL,
+};
+
+#endif  //!__ECHATMESSAGERESPONSECODES__H__

dDatabase/CMakeLists.txt

@@ -1,7 +1,7 @@
 add_subdirectory(CDClientDatabase)
 add_subdirectory(GameDatabase)
 
-add_library(dDatabase STATIC "MigrationRunner.cpp" "ModelNormalizeMigration.cpp")
+add_library(dDatabase STATIC "MigrationRunner.cpp")
 
 add_custom_target(conncpp_dylib
 	${CMAKE_COMMAND} -E copy $<TARGET_FILE:MariaDB::ConnCpp> ${PROJECT_BINARY_DIR})

dDatabase/GameDatabase/ITables/IActivityLog.h

@@ -8,6 +8,7 @@
 enum class eActivityType : uint32_t {
 	PlayerLoggedIn,
 	PlayerLoggedOut,
+	PlayerChangedZone,
 };
 
 class IActivityLog {

dDatabase/GameDatabase/ITables/IPropertyContents.h

@@ -22,7 +22,7 @@ public:
 
 	// Inserts a new UGC model into the database.
 	virtual void InsertNewUgcModel(
-		std::stringstream& sd0Data,
+		std::istringstream& sd0Data,
 		const uint32_t blueprintId,
 		const uint32_t accountId,
 		const uint32_t characterId) = 0;
@@ -34,17 +34,9 @@ public:
 	virtual void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) = 0;
 
 	// Update the model position and rotation for the given property id.
-	virtual void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) = 0;
-	virtual void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<int32_t, 5> behaviorIDs) {
-		std::array<std::pair<int32_t, std::string>, 5> behaviors;
-		for (int32_t i = 0; i < behaviors.size(); i++) behaviors[i].first = behaviorIDs[i];
-		UpdateModel(modelID, position, rotation, behaviors);
-	}
+	virtual void UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) = 0;
 
 	// Remove the model for the given property id.
 	virtual void RemoveModel(const LWOOBJID& modelId) = 0;
-
-	// Gets a model by ID
-	virtual Model GetModel(const LWOOBJID modelID) = 0;
 };
 #endif  //!__IPROPERTIESCONTENTS__H__

dDatabase/GameDatabase/ITables/IUgc.h

@@ -12,7 +12,6 @@ public:
 	struct Model {
 		std::stringstream lxfmlData;
 		LWOOBJID id{};
-		LWOOBJID modelID{};
 	};
 
 	// Gets all UGC models for the given property id.
@@ -28,6 +27,6 @@ public:
 	virtual void DeleteUgcModelData(const LWOOBJID& modelId) = 0;
 
 	// Inserts a new UGC model into the database.
-	virtual void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) = 0;
+	virtual void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) = 0;
 };
 #endif  //!__IUGC__H__

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -48,7 +48,7 @@ public:
 	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
 	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
 	void DeleteUgcModelData(const LWOOBJID& modelId) override;
-	void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) override;
+	void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) override;
 	std::vector<IUgc::Model> GetAllUgcModels() override;
 	void CreateMigrationHistoryTable() override;
 	bool IsMigrationRun(const std::string_view str) override;
@@ -74,14 +74,14 @@ public:
 	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
 	void RemoveUnreferencedUgcModels() override;
 	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
+	void UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
 	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
-		std::stringstream& sd0Data,
+		std::istringstream& sd0Data,
 		const uint32_t blueprintId,
 		const uint32_t accountId,
 		const uint32_t characterId) override;
@@ -126,7 +126,6 @@ public:
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
 	bool IsNameInUse(const std::string_view name) override;
-	IPropertyContents::Model GetModel(const LWOOBJID modelID) override;
 	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
 private:
 

dDatabase/GameDatabase/MySQL/Tables/PropertyContents.cpp

@@ -52,39 +52,14 @@ void MySQLDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const IPr
 	}
 }
 
-void MySQLDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
+void MySQLDatabase::UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
 	ExecuteUpdate(
 		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ?, "
 		"behavior_1 = ?, behavior_2 = ?, behavior_3 = ?, behavior_4 = ?, behavior_5 = ? WHERE id = ?;",
 		position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w,
-		behaviors[0].first, behaviors[1].first, behaviors[2].first, behaviors[3].first, behaviors[4].first, modelID);
+		behaviors[0].first, behaviors[1].first, behaviors[2].first, behaviors[3].first, behaviors[4].first, propertyId);
 }
 
 void MySQLDatabase::RemoveModel(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
 }
-
-IPropertyContents::Model MySQLDatabase::GetModel(const LWOOBJID modelID) {
-	auto result = ExecuteSelect("SELECT * FROM properties_contents WHERE id = ?", modelID);
-
-	IPropertyContents::Model model{};
-	while (result->next()) {
-		model.id = result->getUInt64("id");
-		model.lot = static_cast<LOT>(result->getUInt("lot"));
-		model.position.x = result->getFloat("x");
-		model.position.y = result->getFloat("y");
-		model.position.z = result->getFloat("z");
-		model.rotation.w = result->getFloat("rw");
-		model.rotation.x = result->getFloat("rx");
-		model.rotation.y = result->getFloat("ry");
-		model.rotation.z = result->getFloat("rz");
-		model.ugcId = result->getUInt64("ugc_id");
-		model.behaviors[0] = result->getInt("behavior_1");
-		model.behaviors[1] = result->getInt("behavior_2");
-		model.behaviors[2] = result->getInt("behavior_3");
-		model.behaviors[3] = result->getInt("behavior_4");
-		model.behaviors[4] = result->getInt("behavior_5");
-	}
-
-	return model;
-}

dDatabase/GameDatabase/MySQL/Tables/Ugc.cpp

@@ -2,7 +2,7 @@
 
 std::vector<IUgc::Model> MySQLDatabase::GetUgcModels(const LWOOBJID& propertyId) {
 	auto result = ExecuteSelect(
-		"SELECT lxfml, u.id as ugcID, pc.id as modelID FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
+		"SELECT lxfml, u.id FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
 		propertyId);
 
 	std::vector<IUgc::Model> toReturn;
@@ -13,8 +13,7 @@ std::vector<IUgc::Model> MySQLDatabase::GetUgcModels(const LWOOBJID& propertyId)
 		// blob is owned by the query, so we need to do a deep copy :/
 		std::unique_ptr<std::istream> blob(result->getBlob("lxfml"));
 		model.lxfmlData << blob->rdbuf();
-		model.id = result->getUInt64("ugcID");
-		model.modelID = result->getUInt64("modelID");
+		model.id = result->getUInt64("id");
 		toReturn.push_back(std::move(model));
 	}
 
@@ -22,14 +21,13 @@ std::vector<IUgc::Model> MySQLDatabase::GetUgcModels(const LWOOBJID& propertyId)
 }
 
 std::vector<IUgc::Model> MySQLDatabase::GetAllUgcModels() {
-	auto result = ExecuteSelect("SELECT u.id AS ugcID, lxfml, pc.id AS modelID FROM ugc AS u JOIN properties_contents AS pc ON pc.ugc_id = u.id WHERE pc.lot = 14 AND pc.ugc_id IS NOT NULL;");
+	auto result = ExecuteSelect("SELECT id, lxfml FROM ugc;");
 
 	std::vector<IUgc::Model> models;
 	models.reserve(result->rowsCount());
 	while (result->next()) {
 		IUgc::Model model;
-		model.id = result->getInt64("ugcID");
-		model.modelID = result->getUInt64("modelID");
+		model.id = result->getInt64("id");
 
 		// blob is owned by the query, so we need to do a deep copy :/
 		std::unique_ptr<std::istream> blob(result->getBlob("lxfml"));
@@ -45,7 +43,7 @@ void MySQLDatabase::RemoveUnreferencedUgcModels() {
 }
 
 void MySQLDatabase::InsertNewUgcModel(
-	std:: stringstream& sd0Data, // cant be const sad
+	std::istringstream& sd0Data, // cant be const sad
 	const uint32_t blueprintId,
 	const uint32_t accountId,
 	const uint32_t characterId) {
@@ -67,7 +65,7 @@ void MySQLDatabase::DeleteUgcModelData(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE ugc_id = ?;", modelId);
 }
 
-void MySQLDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) {
+void MySQLDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) {
 	const std::istream stream(lxfml.rdbuf());
 	ExecuteUpdate("UPDATE ugc SET lxfml = ? WHERE id = ?;", &stream, modelId);
 }

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -46,7 +46,7 @@ public:
 	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
 	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
 	void DeleteUgcModelData(const LWOOBJID& modelId) override;
-	void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) override;
+	void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) override;
 	std::vector<IUgc::Model> GetAllUgcModels() override;
 	void CreateMigrationHistoryTable() override;
 	bool IsMigrationRun(const std::string_view str) override;
@@ -72,14 +72,14 @@ public:
 	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
 	void RemoveUnreferencedUgcModels() override;
 	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
+	void UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
 	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
-		std::stringstream& sd0Data,
+		std::istringstream& sd0Data,
 		const uint32_t blueprintId,
 		const uint32_t accountId,
 		const uint32_t characterId) override;
@@ -124,7 +124,6 @@ public:
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
 	bool IsNameInUse(const std::string_view name) override;
-	IPropertyContents::Model GetModel(const LWOOBJID modelID) override;
 private:
 	CppSQLite3Statement CreatePreppedStmt(const std::string& query);
 

dDatabase/GameDatabase/SQLite/Tables/PropertyContents.cpp

@@ -52,41 +52,14 @@ void SQLiteDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const IP
 	}
 }
 
-void SQLiteDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
+void SQLiteDatabase::UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
 	ExecuteUpdate(
 		"UPDATE properties_contents SET x = ?, y = ?, z = ?, rx = ?, ry = ?, rz = ?, rw = ?, "
 		"behavior_1 = ?, behavior_2 = ?, behavior_3 = ?, behavior_4 = ?, behavior_5 = ? WHERE id = ?;",
 		position.x, position.y, position.z, rotation.x, rotation.y, rotation.z, rotation.w,
-		behaviors[0].first, behaviors[1].first, behaviors[2].first, behaviors[3].first, behaviors[4].first, modelID);
+		behaviors[0].first, behaviors[1].first, behaviors[2].first, behaviors[3].first, behaviors[4].first, propertyId);
 }
 
 void SQLiteDatabase::RemoveModel(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE id = ?;", modelId);
 }
-
-IPropertyContents::Model SQLiteDatabase::GetModel(const LWOOBJID modelID) {
-	auto [_, result] = ExecuteSelect("SELECT * FROM properties_contents WHERE id = ?", modelID);
-
-	IPropertyContents::Model model{};
-	if (!result.eof()) {
-		do {
-			model.id = result.getInt64Field("id");
-			model.lot = static_cast<LOT>(result.getIntField("lot"));
-			model.position.x = result.getFloatField("x");
-			model.position.y = result.getFloatField("y");
-			model.position.z = result.getFloatField("z");
-			model.rotation.w = result.getFloatField("rw");
-			model.rotation.x = result.getFloatField("rx");
-			model.rotation.y = result.getFloatField("ry");
-			model.rotation.z = result.getFloatField("rz");
-			model.ugcId = result.getInt64Field("ugc_id");
-			model.behaviors[0] = result.getIntField("behavior_1");
-			model.behaviors[1] = result.getIntField("behavior_2");
-			model.behaviors[2] = result.getIntField("behavior_3");
-			model.behaviors[3] = result.getIntField("behavior_4");
-			model.behaviors[4] = result.getIntField("behavior_5");
-		} while (result.nextRow());
-	}
-
-	return model;
-}

dDatabase/GameDatabase/SQLite/Tables/Ugc.cpp

@@ -2,7 +2,7 @@
 
 std::vector<IUgc::Model> SQLiteDatabase::GetUgcModels(const LWOOBJID& propertyId) {
 	auto [_, result] = ExecuteSelect(
-		"SELECT lxfml, u.id AS ugcID, pc.id AS modelID FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
+		"SELECT lxfml, u.id FROM ugc AS u JOIN properties_contents AS pc ON u.id = pc.ugc_id WHERE lot = 14 AND property_id = ? AND pc.ugc_id IS NOT NULL;",
 		propertyId);
 
 	std::vector<IUgc::Model> toReturn;
@@ -13,8 +13,7 @@ std::vector<IUgc::Model> SQLiteDatabase::GetUgcModels(const LWOOBJID& propertyId
 		int blobSize{};
 		const auto* blob = result.getBlobField("lxfml", blobSize);
 		model.lxfmlData << std::string(reinterpret_cast<const char*>(blob), blobSize);
-		model.id = result.getInt64Field("ugcID");
-		model.modelID = result.getInt64Field("modelID");
+		model.id = result.getInt64Field("id");
 		toReturn.push_back(std::move(model));
 		result.nextRow();
 	}
@@ -23,13 +22,12 @@ std::vector<IUgc::Model> SQLiteDatabase::GetUgcModels(const LWOOBJID& propertyId
 }
 
 std::vector<IUgc::Model> SQLiteDatabase::GetAllUgcModels() {
-	auto [_, result] = ExecuteSelect("SELECT u.id AS ugcID, pc.id AS modelID, lxfml FROM ugc AS u JOIN properties_contents AS pc ON pc.id = u.id;");
+	auto [_, result] = ExecuteSelect("SELECT id, lxfml FROM ugc;");
 
 	std::vector<IUgc::Model> models;
 	while (!result.eof()) {
 		IUgc::Model model;
-		model.id = result.getInt64Field("ugcID");
-		model.modelID = result.getInt64Field("modelID");
+		model.id = result.getInt64Field("id");
 
 		int blobSize{};
 		const auto* blob = result.getBlobField("lxfml", blobSize);
@@ -46,7 +44,7 @@ void SQLiteDatabase::RemoveUnreferencedUgcModels() {
 }
 
 void SQLiteDatabase::InsertNewUgcModel(
-	std::stringstream& sd0Data, // cant be const sad
+	std::istringstream& sd0Data, // cant be const sad
 	const uint32_t blueprintId,
 	const uint32_t accountId,
 	const uint32_t characterId) {
@@ -68,7 +66,7 @@ void SQLiteDatabase::DeleteUgcModelData(const LWOOBJID& modelId) {
 	ExecuteDelete("DELETE FROM properties_contents WHERE ugc_id = ?;", modelId);
 }
 
-void SQLiteDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) {
+void SQLiteDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) {
 	const std::istream stream(lxfml.rdbuf());
 	ExecuteUpdate("UPDATE ugc SET lxfml = ? WHERE id = ?;", &stream, modelId);
 }

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.cpp

@@ -60,7 +60,7 @@ void TestSQLDatabase::DeleteUgcModelData(const LWOOBJID& modelId) {
 
 }
 
-void TestSQLDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) {
+void TestSQLDatabase::UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) {
 
 }
 
@@ -164,7 +164,7 @@ void TestSQLDatabase::InsertNewPropertyModel(const LWOOBJID& propertyId, const I
 
 }
 
-void TestSQLDatabase::UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
+void TestSQLDatabase::UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) {
 
 }
 
@@ -188,7 +188,7 @@ void TestSQLDatabase::InsertNewMail(const MailInfo& mail) {
 
 }
 
-void TestSQLDatabase::InsertNewUgcModel(std::stringstream& sd0Data, const uint32_t blueprintId, const uint32_t accountId, const uint32_t characterId) {
+void TestSQLDatabase::InsertNewUgcModel(std::istringstream& sd0Data, const uint32_t blueprintId, const uint32_t accountId, const uint32_t characterId) {
 
 }
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -25,7 +25,7 @@ class TestSQLDatabase : public GameDatabase {
 	void RemoveFriend(const uint32_t playerAccountId, const uint32_t friendAccountId) override;
 	void UpdateActivityLog(const uint32_t characterId, const eActivityType activityType, const LWOMAPID mapId) override;
 	void DeleteUgcModelData(const LWOOBJID& modelId) override;
-	void UpdateUgcModelData(const LWOOBJID& modelId, std::stringstream& lxfml) override;
+	void UpdateUgcModelData(const LWOOBJID& modelId, std::istringstream& lxfml) override;
 	std::vector<IUgc::Model> GetAllUgcModels() override;
 	void CreateMigrationHistoryTable() override;
 	bool IsMigrationRun(const std::string_view str) override;
@@ -51,14 +51,14 @@ class TestSQLDatabase : public GameDatabase {
 	std::vector<IPropertyContents::Model> GetPropertyModels(const LWOOBJID& propertyId) override;
 	void RemoveUnreferencedUgcModels() override;
 	void InsertNewPropertyModel(const LWOOBJID& propertyId, const IPropertyContents::Model& model, const std::string_view name) override;
-	void UpdateModel(const LWOOBJID& modelID, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
+	void UpdateModel(const LWOOBJID& propertyId, const NiPoint3& position, const NiQuaternion& rotation, const std::array<std::pair<int32_t, std::string>, 5>& behaviors) override;
 	void RemoveModel(const LWOOBJID& modelId) override;
 	void UpdatePerformanceCost(const LWOZONEID& zoneId, const float performanceCost) override;
 	void InsertNewBugReport(const IBugReports::Info& info) override;
 	void InsertCheatDetection(const IPlayerCheatDetections::Info& info) override;
 	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
-		std::stringstream& sd0Data,
+		std::istringstream& sd0Data,
 		const uint32_t blueprintId,
 		const uint32_t accountId,
 		const uint32_t characterId) override;
@@ -104,7 +104,6 @@ class TestSQLDatabase : public GameDatabase {
 	uint32_t GetAccountCount() override { return 0; };
 
 	bool IsNameInUse(const std::string_view name) override { return false; };
-	IPropertyContents::Model GetModel(const LWOOBJID modelID) override { return {}; }
 };
 
 #endif  //!TESTSQLDATABASE_H

dDatabase/MigrationRunner.cpp

@@ -7,7 +7,6 @@
 #include "GeneralUtils.h"
 #include "Logger.h"
 #include "BinaryPathFinder.h"
-#include "ModelNormalizeMigration.h"
 
 #include <fstream>
 
@@ -36,7 +35,7 @@ void MigrationRunner::RunMigrations() {
 	Database::Get()->CreateMigrationHistoryTable();
 
 	// has to be here because when moving the files to the new folder, the migration_history table is not updated so it will run them all again.
-
+	
 	const auto migrationFolder = Database::GetMigrationFolder();
 	if (!Database::Get()->IsMigrationRun("17_migration_for_migrations.sql") && migrationFolder == "mysql") {
 		LOG("Running migration: 17_migration_for_migrations.sql");
@@ -46,7 +45,6 @@ void MigrationRunner::RunMigrations() {
 
 	std::string finalSQL = "";
 	bool runSd0Migrations = false;
-	bool runNormalizeMigrations = false;
 	for (const auto& entry : GeneralUtils::GetSqlFileNamesFromFolder((BinaryPathFinder::GetBinaryDir() / "./migrations/dlu/" / migrationFolder).string())) {
 		auto migration = LoadMigration("dlu/" + migrationFolder + "/", entry);
 
@@ -59,8 +57,6 @@ void MigrationRunner::RunMigrations() {
 		LOG("Running migration: %s", migration.name.c_str());
 		if (migration.name == "5_brick_model_sd0.sql") {
 			runSd0Migrations = true;
-		} else if (migration.name.ends_with("_normalize_model_positions.sql")) {
-			runNormalizeMigrations = true;
 		} else {
 			finalSQL.append(migration.data.c_str());
 		}
@@ -68,7 +64,7 @@ void MigrationRunner::RunMigrations() {
 		Database::Get()->InsertMigration(migration.name);
 	}
 
-	if (finalSQL.empty() && !runSd0Migrations && !runNormalizeMigrations) {
+	if (finalSQL.empty() && !runSd0Migrations) {
 		LOG("Server database is up to date.");
 		return;
 	}
@@ -92,10 +88,6 @@ void MigrationRunner::RunMigrations() {
 		uint32_t numberOfTruncatedModels = BrickByBrickFix::TruncateBrokenBrickByBrickXml();
 		LOG("%i models were truncated from the database.", numberOfTruncatedModels);
 	}
-
-	if (runNormalizeMigrations) {
-		ModelNormalizeMigration::Run();
-	}
 }
 
 void MigrationRunner::RunSQLiteMigrations() {

dDatabase/ModelNormalizeMigration.cpp

@@ -1,30 +0,0 @@
-#include "ModelNormalizeMigration.h"
-
-#include "Database.h"
-#include "Lxfml.h"
-#include "Sd0.h"
-
-void ModelNormalizeMigration::Run() {
-	const auto oldCommit = Database::Get()->GetAutoCommit();
-	Database::Get()->SetAutoCommit(false);
-	for (auto& [lxfmlData, id, modelID] : Database::Get()->GetAllUgcModels()) {
-		const auto model = Database::Get()->GetModel(modelID);
-		// only BBB models (lot 14) and models with a position of NiPoint3::ZERO need to have their position fixed.
-		if (model.position != NiPoint3Constant::ZERO || model.lot != 14) continue;
-	
-		Sd0 sd0(lxfmlData);
-		const auto asStr = sd0.GetAsStringUncompressed();
-		const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr);
-		if (newCenter == NiPoint3Constant::ZERO) {
-			LOG("Failed to update model %llu due to failure reading xml.");
-			continue;
-		}
-
-		LOG("Updated model %llu to have a center of %f %f %f", modelID, newCenter.x, newCenter.y, newCenter.z);
-		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
-		auto asStream = sd0.GetAsStream();
-		Database::Get()->UpdateModel(model.id, newCenter, model.rotation, model.behaviors);
-		Database::Get()->UpdateUgcModelData(id, asStream);
-	}
-	Database::Get()->SetAutoCommit(oldCommit);
-}

dDatabase/ModelNormalizeMigration.h

@@ -1,11 +0,0 @@
-// Darkflame Universe
-// Copyright 2025
-
-#ifndef MODELNORMALIZEMIGRATION_H
-#define MODELNORMALIZEMIGRATION_H
-
-namespace ModelNormalizeMigration {
-	void Run();
-};
-
-#endif //!MODELNORMALIZEMIGRATION_H

dGame/EntityManager.cpp

@@ -99,7 +99,7 @@ Entity* EntityManager::CreateEntity(EntityInfo info, User* user, Entity* parentE
 		}
 
 		// Exclude the zone control object from any flags
-		if (!controller) {
+		if (!controller && info.lot != 14) {
 
 			// The client flags means the client should render the entity
 			GeneralUtils::SetBit(id, eObjectBits::CLIENT);

dGame/dGameMessages/GameMessages.cpp

@@ -102,8 +102,6 @@
 #include "CDComponentsRegistryTable.h"
 #include "CDObjectsTable.h"
 #include "eItemType.h"
-#include "Lxfml.h"
-#include "Sd0.h"
 
 void GameMessages::SendFireEventClientSide(const LWOOBJID& objectID, const SystemAddress& sysAddr, std::u16string args, const LWOOBJID& object, int64_t param1, int param2, const LWOOBJID& sender) {
 	CBITSTREAM;
@@ -2576,6 +2574,18 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 		TODO Apparently the bricks are supposed to be taken via MoveInventoryBatch?
 	*/
 
+	////Decompress the SD0 from the client so we can process the lxfml properly
+	//uint8_t* outData = new uint8_t[327680];
+	//int32_t error;
+	//int32_t size = ZCompression::Decompress(inData, lxfmlSize, outData, 327680, error);
+
+	//if (size == -1) {
+	//	LOG("Failed to decompress LXFML: (%i)", error);
+	//	return;
+	//}
+	//
+	//std::string lxfml(reinterpret_cast<char*>(outData), size); //std::string version of the decompressed data!
+
 	//Now, the cave of dragons:
 
 	//We runs this in async because the http library here is blocking, meaning it'll halt the thread.
@@ -2603,25 +2613,16 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 		LWOOBJID propertyId = LWOOBJID_EMPTY;
 		if (propertyInfo) propertyId = propertyInfo->id;
 
-		// Save the binary data to the Sd0 buffer
+		//Insert into ugc:
 		std::string str(sd0Data.get(), sd0Size);
 		std::istringstream sd0DataStream(str);
-		Sd0 sd0(sd0DataStream);
-
-		// Uncompress the data and normalize the position
-		const auto asStr = sd0.GetAsStringUncompressed();
-		const auto [newLxfml, newCenter] = Lxfml::NormalizePosition(asStr);
-
-		// Recompress the data and save to the database
-		sd0.FromData(reinterpret_cast<const uint8_t*>(newLxfml.data()), newLxfml.size());
-		auto sd0AsStream = sd0.GetAsStream();
-		Database::Get()->InsertNewUgcModel(sd0AsStream, blueprintIDSmall, entity->GetCharacter()->GetParentUser()->GetAccountID(), entity->GetCharacter()->GetID());
+		Database::Get()->InsertNewUgcModel(sd0DataStream, blueprintIDSmall, entity->GetCharacter()->GetParentUser()->GetAccountID(), entity->GetCharacter()->GetID());
 
 		//Insert into the db as a BBB model:
 		IPropertyContents::Model model;
 		model.id = newIDL;
 		model.ugcId = blueprintIDSmall;
-		model.position = newCenter;
+		model.position = NiPoint3Constant::ZERO;
 		model.rotation = NiQuaternion(0.0f, 0.0f, 0.0f, 0.0f);
 		model.lot = 14;
 		Database::Get()->InsertNewPropertyModel(propertyId, model, "Objects_14_name");
@@ -2647,9 +2648,6 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 		//}
 
 		//Tell the client their model is saved: (this causes us to actually pop out of our current state):
-		const auto& newSd0 = sd0.GetAsVector();
-		uint32_t sd0Size{};
-		for (const auto& chunk : newSd0) sd0Size += chunk.size();
 		CBITSTREAM;
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::BLUEPRINT_SAVE_RESPONSE);
 		bitStream.Write(localId);
@@ -2657,9 +2655,9 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 		bitStream.Write<uint32_t>(1);
 		bitStream.Write(blueprintID);
 
-		bitStream.Write(sd0Size);
+		bitStream.Write<uint32_t>(sd0Size);
 
-		for (const auto& chunk : newSd0) bitStream.WriteAlignedBytes(reinterpret_cast<const unsigned char*>(chunk.data()), chunk.size());
+		bitStream.WriteAlignedBytes(reinterpret_cast<unsigned char*>(sd0Data.get()), sd0Size);
 
 		SEND_PACKET;
 
@@ -2667,7 +2665,7 @@ void GameMessages::HandleBBBSaveRequest(RakNet::BitStream& inStream, Entity* ent
 
 		EntityInfo info;
 		info.lot = 14;
-		info.pos = newCenter;
+		info.pos = {};
 		info.rot = {};
 		info.spawner = nullptr;
 		info.spawnerID = entity->GetObjectID();

dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp

@@ -296,15 +296,12 @@ namespace GMGreaterThanZeroCommands {
 		if (!splitArgs.empty() && !splitArgs.at(0).empty()) displayZoneData = splitArgs.at(0) == "1";
 		if (splitArgs.size() > 1) displayIndividualPlayers = splitArgs.at(1) == "1";
 
-		ShowAllRequest request {
-			.requestor = entity->GetObjectID(),
-			.displayZoneData = displayZoneData,
-			.displayIndividualPlayers = displayIndividualPlayers
-		};
+		ChatPackets::ShowAllRequest request;
+		request.requestor = entity->GetObjectID();
+		request.displayZoneData = displayZoneData;
+		request.displayIndividualPlayers = displayIndividualPlayers;
 
-		CBITSTREAM;
-		request.Serialize(bitStream);
-		Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
+		request.Send(Game::chatSysAddr);
 	}
 
 	void FindPlayer(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
@@ -313,14 +310,11 @@ namespace GMGreaterThanZeroCommands {
 			return;
 		}
 
-		FindPlayerRequest request {
-			.requestor = entity->GetObjectID(),
-			.playerName = LUWString(args)
-		};
+		ChatPackets::FindPlayerRequest request;
+		request.requestor = entity->GetObjectID();
+		request.playerName = LUWString(args);
 
-		CBITSTREAM;
-		request.Serialize(bitStream);
-		Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
+		request.Send(Game::chatSysAddr);
 	}
 
 	void Spectate(Entity* entity, const SystemAddress& sysAddr, const std::string args) {

dNet/BitStreamUtils.h

@@ -61,6 +61,9 @@ struct LUBitStream {
 	void WriteHeader(RakNet::BitStream& bitStream) const;
 	bool ReadHeader(RakNet::BitStream& bitStream);
 	void Send(const SystemAddress& sysAddr) const;
+	void Broadcast() const {
+		Send(UNASSIGNED_SYSTEM_ADDRESS);
+	};
 
 	virtual void Serialize(RakNet::BitStream& bitStream) const {}
 	virtual bool Deserialize(RakNet::BitStream& bitStream) { return true; }

dNet/ChatPackets.cpp

@@ -11,99 +11,136 @@
 #include "dServer.h"
 #include "eConnectionType.h"
 #include "MessageType/Chat.h"
-
-void ShowAllRequest::Serialize(RakNet::BitStream& bitStream) {
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::SHOW_ALL);
-	bitStream.Write(this->requestor);
-	bitStream.Write(this->displayZoneData);
-	bitStream.Write(this->displayIndividualPlayers);
-}
-
-void ShowAllRequest::Deserialize(RakNet::BitStream& inStream) {
-	inStream.Read(this->requestor);
-	inStream.Read(this->displayZoneData);
-	inStream.Read(this->displayIndividualPlayers);
-}
-
-void FindPlayerRequest::Serialize(RakNet::BitStream& bitStream) {
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::WHO);
-	bitStream.Write(this->requestor);
-	bitStream.Write(this->playerName);
-}
-
-void FindPlayerRequest::Deserialize(RakNet::BitStream& inStream) {
-	inStream.Read(this->requestor);
-	inStream.Read(this->playerName);
-}
-
-void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel, const std::string& senderName, LWOOBJID playerObjectID, bool senderMythran, const std::u16string& message) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GENERAL_CHAT_MESSAGE);
-
-	bitStream.Write<uint64_t>(0);
-	bitStream.Write(chatChannel);
-
-	bitStream.Write<uint32_t>(message.size());
-	bitStream.Write(LUWString(senderName));
-
-	bitStream.Write(playerObjectID);
-	bitStream.Write<uint16_t>(0);
-	bitStream.Write<char>(0);
-
-	for (uint32_t i = 0; i < message.size(); ++i) {
-		bitStream.Write<uint16_t>(message[i]);
-	}
-	bitStream.Write<uint16_t>(0);
-
-	SEND_PACKET_BROADCAST;
-}
-
-void ChatPackets::SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GENERAL_CHAT_MESSAGE);
-
-	bitStream.Write<uint64_t>(0);
-	bitStream.Write<char>(4);
-
-	bitStream.Write<uint32_t>(message.size());
-	bitStream.Write(LUWString("", 33));
-
-	bitStream.Write<uint64_t>(0);
-	bitStream.Write<uint16_t>(0);
-	bitStream.Write<char>(0);
-
-	for (uint32_t i = 0; i < message.size(); ++i) {
-		bitStream.Write<uint16_t>(message[i]);
+namespace ChatPackets {
+	void ShowAllRequest::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->requestor);
+		bitStream.Write(this->displayZoneData);
+		bitStream.Write(this->displayIndividualPlayers);
 	}
 
-	bitStream.Write<uint16_t>(0);
-
-	//This is so Wincent's announcement works:
-	if (sysAddr != UNASSIGNED_SYSTEM_ADDRESS) {
-		SEND_PACKET;
-		return;
+	bool ShowAllRequest::Deserialize(RakNet::BitStream& inStream) {
+		VALIDATE_READ(inStream.Read(this->requestor));
+		VALIDATE_READ(inStream.Read(this->displayZoneData));
+		VALIDATE_READ(inStream.Read(this->displayIndividualPlayers));
+		return true;
 	}
 
-	SEND_PACKET_BROADCAST;
-}
+	void FindPlayerRequest::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->requestor);
+		bitStream.Write(this->playerName);
+	}
 
-void ChatPackets::SendMessageFail(const SystemAddress& sysAddr) {
-	//0x00 - "Chat is currently disabled."
-	//0x01 - "Upgrade to a full LEGO Universe Membership to chat with other players."
+	bool FindPlayerRequest::Deserialize(RakNet::BitStream& inStream) {
+		VALIDATE_READ(inStream.Read(this->requestor));
+		VALIDATE_READ(inStream.Read(this->playerName));
+		return true;
+	}
 
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::SEND_CANNED_TEXT);
-	bitStream.Write<uint8_t>(0); //response type, options above ^
-	//docs say there's a wstring here-- no idea what it's for, or if it's even needed so leaving it as is for now.
-	SEND_PACKET;
-}
+	void ChatMessage::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write<uint64_t>(0);// senderID
+		bitStream.Write(chatChannel);
 
-void ChatPackets::Announcement::Send() {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GM_ANNOUNCE);
-	bitStream.Write<uint32_t>(title.size());
-	bitStream.Write(title);
-	bitStream.Write<uint32_t>(message.size());
-	bitStream.Write(message);
-	SEND_PACKET_BROADCAST;
+		bitStream.Write<uint32_t>(message.GetAsString().size());
+		bitStream.Write(LUWString(senderName));
+
+		bitStream.Write(playerObjectID); // senderID
+		bitStream.Write<uint16_t>(0); // sourceID
+		bitStream.Write(responseCode);
+		bitStream.Write(message);
+		
+	}
+
+	bool ChatMessage::Deserialize(RakNet::BitStream& inStream) {
+		//TODO: Implement this
+		return false;
+	}
+	void ChatMessage::Handle(){
+		
+	}
+
+	void WorldChatMessage::Serialize(RakNet::BitStream& bitStream) const {
+
+	}
+	bool WorldChatMessage::Deserialize(RakNet::BitStream& inStream) {
+		VALIDATE_READ(inStream.Read(chatChannel));
+		uint16_t padding;
+		VALIDATE_READ(inStream.Read(padding));
+		uint32_t messageLength;
+		VALIDATE_READ(inStream.Read(messageLength));
+		string message_tmp;
+		for (uint32_t i = 0; i < messageLength; ++i) {
+			uint16_t character;
+			VALIDATE_READ(inStream.Read(character));
+			message_tmp.push_back(character);
+		}
+		
+		return true;
+	}
+	void WorldChatMessage::Handle() {
+
+	}
+
+
+	void PrivateChatMessage::Serialize(RakNet::BitStream& bitStream) const {
+
+	}
+	bool PrivateChatMessage::Deserialize(RakNet::BitStream& inStream) {
+
+	}
+	void PrivateChatMessage::Handle() {
+
+	}
+
+
+	void UserChatMessage::Serialize(RakNet::BitStream& bitStream) const {
+
+	}
+	bool UserChatMessage::Deserialize(RakNet::BitStream& inStream) {
+
+	}
+	void UserChatMessage::Handle() {
+
+	}
+
+	
+
+	void SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast) {
+		CBITSTREAM;
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GENERAL_CHAT_MESSAGE);
+
+		bitStream.Write<uint64_t>(0);
+		bitStream.Write<char>(4);
+
+		bitStream.Write<uint32_t>(message.size());
+		bitStream.Write(LUWString("", 33));
+
+		bitStream.Write<uint64_t>(0);
+		bitStream.Write<uint16_t>(0);
+		bitStream.Write<char>(0);
+
+		for (uint32_t i = 0; i < message.size(); ++i) {
+			bitStream.Write<uint16_t>(message[i]);
+		}
+
+		bitStream.Write<uint16_t>(0);
+
+		//This is so Wincent's announcement works:
+		if (sysAddr != UNASSIGNED_SYSTEM_ADDRESS) {
+			SEND_PACKET;
+			return;
+		}
+
+		SEND_PACKET_BROADCAST;
+	}
+
+	void MessageFailure::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(this->cannedText);
+	}
+
+	void Announcement::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write<uint32_t>(title.size());
+		bitStream.Write(title);
+		bitStream.Write<uint32_t>(message.size());
+		bitStream.Write(message);
+	}
 }

dNet/ChatPackets.h

@@ -10,33 +10,85 @@ struct SystemAddress;
 
 #include <string>
 #include "dCommonVars.h"
+#include "BitStreamUtils.h"
+#include "MessageType/Chat.h"
+#include "eChatMessageResponseCode.h"
 
-struct ShowAllRequest{
-	LWOOBJID requestor = LWOOBJID_EMPTY;
-	bool displayZoneData = true;
-	bool displayIndividualPlayers = true;
-	void Serialize(RakNet::BitStream& bitStream);
-	void Deserialize(RakNet::BitStream& inStream);
-};
-
-struct FindPlayerRequest{
-	LWOOBJID requestor = LWOOBJID_EMPTY;
-	LUWString playerName;
-	void Serialize(RakNet::BitStream& bitStream);
-	void Deserialize(RakNet::BitStream& inStream);
+enum class eCannedText : uint8_t {
+	CHAT_DISABLED = 0,
+	F2P_CHAT_DISABLED = 1
 };
 
 namespace ChatPackets {
+	void SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast = false);
 
-	struct Announcement {
-		std::string title;
-		std::string message;
-		void Send();
+	struct ShowAllRequest : public LUBitStream {
+		LWOOBJID requestor = LWOOBJID_EMPTY;
+		bool displayZoneData = true;
+		bool displayIndividualPlayers = true;
+
+		ShowAllRequest() : LUBitStream(eConnectionType::CHAT, MessageType::Chat::WHO) {};
+
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& inStream) override;
 	};
 
-	void SendChatMessage(const SystemAddress& sysAddr, char chatChannel, const std::string& senderName, LWOOBJID playerObjectID, bool senderMythran, const std::u16string& message);
-	void SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, bool broadcast = false);
-	void SendMessageFail(const SystemAddress& sysAddr);
+	struct FindPlayerRequest : public LUBitStream {
+		LWOOBJID requestor = LWOOBJID_EMPTY;
+		LUWString playerName;
+		FindPlayerRequest() : LUBitStream(eConnectionType::CHAT, MessageType::Chat::WHO) {};
+
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& inStream) override;
+	};
+
+	struct Announcement : public LUBitStream {
+		std::string title;
+		std::string message;
+
+		Announcement() : LUBitStream(eConnectionType::CHAT, MessageType::Chat::GM_ANNOUNCE) {};
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct ChatMessage : public LUBitStream {
+		char chatChannel;
+		std::string senderName;
+		LWOOBJID playerObjectID;
+		bool senderMythran;
+		eChatMessageResponseCode responseCode = eChatMessageResponseCode::SENT;
+		LUWString message;
+
+		ChatMessage() : LUBitStream(eConnectionType::CHAT, MessageType::Chat::GENERAL_CHAT_MESSAGE) {};
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& inStream) override;
+		virtual void Handle() override {};
+	};
+
+	struct WorldChatMessage : public ChatMessage {
+		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual void Handle() override;
+	};
+
+	struct PrivateChatMessage : public ChatMessage {
+		virtual bool Deserialize(RakNet::BitStream& inStream) override;
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual void Handle() override;
+	};
+
+	struct UserChatMessage : public ChatMessage {
+		virtual bool Deserialize(RakNet::BitStream& inStream) override;
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual void Handle() override;
+	};
+
+	// Should be in client packets since it is a client connection type, but whatever
+	struct MessageFailure : public LUBitStream {
+		eCannedText cannedText = eCannedText::CHAT_DISABLED;
+	
+		MessageFailure() : LUBitStream(eConnectionType::CLIENT, MessageType::Chat::SEND_CANNED_TEXT) {};
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+	};
 };
 
 #endif // CHATPACKETS_H

dNet/ClientPackets.h

@@ -13,12 +13,6 @@ class PositionUpdate;
 
 struct Packet;
 
-struct ChatMessage {
-	uint8_t chatChannel = 0;
-	uint16_t unknown = 0;
-	std::u16string message;
-};
-
 struct ChatModerationRequest {
 	uint8_t chatLevel = 0;
 	uint8_t requestID = 0;
@@ -27,7 +21,6 @@ struct ChatModerationRequest {
 };
 
 namespace ClientPackets {
-	ChatMessage HandleChatMessage(Packet* packet);
 	PositionUpdate HandleClientPositionUpdate(Packet* packet);
 	ChatModerationRequest HandleChatModerationRequest(Packet* packet);
 	int32_t SendTop5HelpIssues(Packet* packet);

dNet/WorldPackets.cpp

@@ -134,7 +134,7 @@ void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, int64_t rep
 	LOG("Sent CreateCharacter for ID: %llu", player);
 }
 
-void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<std::pair<uint8_t, uint8_t>> unacceptedItems) {
+void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::set<std::pair<uint8_t, uint8_t>> unacceptedItems) {
 	CBITSTREAM;
 	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHAT_MODERATION_STRING);
 
@@ -183,4 +183,4 @@ void WorldPackets::SendDebugOuput(const SystemAddress& sysAddr, const std::strin
 	bitStream.Write<uint32_t>(data.size());
 	bitStream.Write(data);
 	SEND_PACKET;
-}
+}

dNet/WorldPackets.h

@@ -10,9 +10,6 @@ struct SystemAddress;
 enum class eGameMasterLevel : uint8_t;
 enum class eCharacterCreationResponse : uint8_t;
 enum class eRenameResponse : uint8_t;
-namespace RakNet {
-	class BitStream;
-};
 
 struct HTTPMonitorInfo {
 	uint16_t port = 80;
@@ -32,7 +29,7 @@ namespace WorldPackets {
 	void SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift);
 	void SendServerState(const SystemAddress& sysAddr);
 	void SendCreateCharacter(const SystemAddress& sysAddr, int64_t reputation, LWOOBJID player, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm);
-	void SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<std::pair<uint8_t, uint8_t>> unacceptedItems);
+	void SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::set<std::pair<uint8_t, uint8_t>> unacceptedItems);
 	void SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel);
 	void SendHTTPMonitorInfo(const SystemAddress& sysAddr, const HTTPMonitorInfo& info);
 	void SendDebugOuput(const SystemAddress& sysAddr, const std::string& data);

dWeb/CMakeLists.txt

@@ -0,0 +1,7 @@
+set(DWEB_SOURCES
+	"Web.cpp")
+
+add_library(dWeb STATIC ${DWEB_SOURCES})
+
+target_include_directories(dWeb PUBLIC ".")
+target_link_libraries(dWeb dCommon mongoose)

dWeb/Web.cpp

@@ -0,0 +1,289 @@
+#include "Web.h"
+#include "Game.h"
+#include "magic_enum.hpp"
+#include "json.hpp"
+#include "Logger.h"
+#include "eHTTPMethod.h"
+#include "GeneralUtils.h"
+#include "JSONUtils.h"
+
+namespace Game {
+	Web web;
+}
+
+namespace {
+	const char* json_content_type = "Content-Type: application/json\r\n";
+	std::map<std::pair<eHTTPMethod, std::string>, HTTPRoute> g_HTTPRoutes;
+	std::map<std::string, WSEvent> g_WSEvents;
+	std::vector<std::string> g_WSSubscriptions;
+}
+
+using json = nlohmann::json;
+
+bool ValidateAuthentication(const mg_http_message* http_msg) {
+	// TO DO: This is just a placeholder for now
+	// use tokens or something at a later point if we want to implement authentication
+	// bit using the listen bind address to limit external access is good enough to start with
+	return true;
+}
+
+void HandleHTTPMessage(mg_connection* connection, const mg_http_message* http_msg) {
+	if (g_HTTPRoutes.empty()) return;
+
+	HTTPReply reply;
+	
+	if (!http_msg) {
+		reply.status = eHTTPStatusCode::BAD_REQUEST;
+		reply.message = "{\"error\":\"Invalid Request\"}";
+	} else if (ValidateAuthentication(http_msg)) {
+		
+		// convert method from cstring to std string
+		std::string method_string(http_msg->method.buf, http_msg->method.len);
+		// get mehtod from mg to enum
+		const eHTTPMethod method = magic_enum::enum_cast<eHTTPMethod>(method_string).value_or(eHTTPMethod::INVALID);
+
+		// convert uri from cstring to std string
+		std::string uri(http_msg->uri.buf, http_msg->uri.len);
+		std::transform(uri.begin(), uri.end(), uri.begin(), ::tolower);
+
+		// convert body from cstring to std string
+		std::string body(http_msg->body.buf, http_msg->body.len);
+
+		// Special case for websocket
+		if (uri == "/ws" && method == eHTTPMethod::GET) {
+			mg_ws_upgrade(connection, const_cast<mg_http_message*>(http_msg), NULL);
+			LOG("Upgraded connection to websocket: %d.%d.%d.%d:%i", MG_IPADDR_PARTS(&connection->rem.ip), connection->rem.port);
+			return;
+		}
+
+		const auto routeItr = g_HTTPRoutes.find({method, uri});
+		if (routeItr != g_HTTPRoutes.end()) {
+			const auto& [_, route] = *routeItr;
+			route.handle(reply, body);
+		} else {
+			reply.status = eHTTPStatusCode::NOT_FOUND;
+			reply.message = "{\"error\":\"Not Found\"}";
+		}
+	} else {
+		reply.status = eHTTPStatusCode::UNAUTHORIZED;
+		reply.message = "{\"error\":\"Unauthorized\"}";
+	}
+	mg_http_reply(connection, static_cast<int>(reply.status), json_content_type, reply.message.c_str());
+}
+
+
+void HandleWSMessage(mg_connection* connection, const mg_ws_message* ws_msg) {
+	if (!ws_msg) {
+		LOG_DEBUG("Received invalid websocket message");
+		return;
+	} else {
+		LOG_DEBUG("Received websocket message: %.*s", static_cast<uint32_t>(ws_msg->data.len), ws_msg->data.buf);
+		auto data = GeneralUtils::TryParse<json>(std::string(ws_msg->data.buf, ws_msg->data.len));
+		if (data) {
+			const auto& good_data = data.value();
+			auto check = JSONUtils::CheckRequiredData(good_data, { "event" });
+			if (!check.empty()) {
+				LOG_DEBUG("Received invalid websocket message: %s", check.c_str());
+			} else {
+				const auto event = good_data["event"].get<std::string>();
+				const auto eventItr = g_WSEvents.find(event);
+				if (eventItr != g_WSEvents.end()) {
+					const auto& [_, event] = *eventItr;
+					event.handle(connection, good_data);
+				} else {
+					LOG_DEBUG("Received invalid websocket event: %s", event.c_str());
+				}
+			}
+		} else {
+			LOG_DEBUG("Received invalid websocket message: %.*s", static_cast<uint32_t>(ws_msg->data.len), ws_msg->data.buf);
+		}
+	}
+}
+
+void HandleWSSubscribe(mg_connection* connection, json data) {
+	auto check = JSONUtils::CheckRequiredData(data, { "subscription" });
+	if (!check.empty()) {
+		LOG_DEBUG("Received invalid websocket message: %s", check.c_str());
+	} else {
+		const auto subscription = data["subscription"].get<std::string>();
+		LOG_DEBUG("subscription %s subscribed", subscription.c_str());
+		// check subscription vector
+		auto subItr = std::find(g_WSSubscriptions.begin(), g_WSSubscriptions.end(), subscription);
+		if (subItr != g_WSSubscriptions.end()) {
+			// get index of subscription
+			auto index = std::distance(g_WSSubscriptions.begin(), subItr);
+			connection->data[index] = 1;
+			mg_ws_send(connection, "{\"status\":\"subscribed\"}", 23, WEBSOCKET_OP_TEXT);
+		}
+	}
+}
+
+void HandleWSUnsubscribe(mg_connection* connection, json data) {
+	auto check = JSONUtils::CheckRequiredData(data, { "subscription" });
+	if (!check.empty()) {
+		LOG_DEBUG("Received invalid websocket message: %s", check.c_str());
+	} else {
+		const auto subscription = data["subscription"].get<std::string>();
+		LOG_DEBUG("subscription %s unsubscribed", subscription.c_str());
+		// check subscription vector
+		auto subItr = std::find(g_WSSubscriptions.begin(), g_WSSubscriptions.end(), subscription);
+		if (subItr != g_WSSubscriptions.end()) {
+			// get index of subscription
+			auto index = std::distance(g_WSSubscriptions.begin(), subItr);
+			connection->data[index] = 0;
+			mg_ws_send(connection, "{\"status\":\"unsubscribed\"}", 25, WEBSOCKET_OP_TEXT);
+		}
+	}
+}
+
+void HandleWSGetSubscriptions(mg_connection* connection, json data) {
+	// list subscribed and non subscribed subscriptions
+	json response;
+	// check subscription vector
+	for (const auto& sub : g_WSSubscriptions) {
+		auto subItr = std::find(g_WSSubscriptions.begin(), g_WSSubscriptions.end(), sub);
+		if (subItr != g_WSSubscriptions.end()) {
+			// get index of subscription
+			auto index = std::distance(g_WSSubscriptions.begin(), subItr);
+			if (connection->data[index] == 1) {
+				response["subscribed"].push_back(sub);
+			} else {
+				response["unsubscribed"].push_back(sub);
+			}
+		}
+	}
+	mg_ws_send(connection, response.dump().c_str(), response.dump().size(), WEBSOCKET_OP_TEXT);
+}
+
+void HandleMessages(mg_connection* connection, int message, void* message_data) {
+	if (!Game::web.IsEnabled()) return;
+	switch (message) {
+		case MG_EV_HTTP_MSG:
+			HandleHTTPMessage(connection, static_cast<mg_http_message*>(message_data));
+			break;
+		case MG_EV_WS_MSG:
+			HandleWSMessage(connection, static_cast<mg_ws_message*>(message_data));
+			break;
+		default:
+			break;
+	}
+}
+
+// Redirect logs to our logger
+static void DLOG(char ch, void *param) {
+	static char buf[256];
+	static size_t len;
+	if (ch != '\n') buf[len++] = ch; // we provide the newline in our logger
+	if (ch == '\n' || len >= sizeof(buf)) {
+		LOG_DEBUG("%.*s", static_cast<int>(len), buf);
+		len = 0;
+	}
+}
+
+void Web::RegisterHTTPRoute(HTTPRoute route) {
+	if (!Game::web.enabled) {
+		LOG_DEBUG("Failed to register HTTP route %s: web server not enabled", route.path.c_str());
+		return;
+	}
+
+	auto [_, success] = g_HTTPRoutes.try_emplace({ route.method, route.path }, route);
+	if (!success) {
+		LOG_DEBUG("Failed to register HTTP route %s", route.path.c_str());
+	} else {
+		LOG_DEBUG("Registered HTTP route %s", route.path.c_str());
+	}
+}
+
+void Web::RegisterWSEvent(WSEvent event) {
+	if (!Game::web.enabled) {
+		LOG_DEBUG("Failed to register WS event %s: web server not enabled", event.name.c_str());
+		return;
+	}
+
+	auto [_, success] = g_WSEvents.try_emplace(event.name, event);
+	if (!success) {
+		LOG_DEBUG("Failed to register WS event %s", event.name.c_str());
+	} else {
+		LOG_DEBUG("Registered WS event %s", event.name.c_str());
+	}
+}
+
+void Web::RegisterWSSubscription(const std::string& subscription) {
+	if (!Game::web.enabled) {
+		LOG_DEBUG("Failed to register WS subscription %s: web server not enabled", subscription.c_str());
+		return;
+	}
+
+	// check that subsction is not already in the vector
+	auto subItr = std::find(g_WSSubscriptions.begin(), g_WSSubscriptions.end(), subscription);
+	if (subItr != g_WSSubscriptions.end()) {
+		LOG_DEBUG("Failed to register WS subscription %s: duplicate", subscription.c_str());
+	} else {
+		LOG_DEBUG("Registered WS subscription %s", subscription.c_str());
+		g_WSSubscriptions.push_back(subscription);
+	}
+}
+
+Web::Web() {
+	mg_log_set_fn(DLOG, NULL); // Redirect logs to our logger
+	mg_log_set(MG_LL_DEBUG);
+	mg_mgr_init(&mgr); // Initialize event manager
+}
+
+Web::~Web() {
+	mg_mgr_free(&mgr);
+}
+
+bool Web::Startup(const std::string& listen_ip, const uint32_t listen_port) {
+
+	// Make listen address
+	const std::string& listen_address = "http://" + listen_ip + ":" + std::to_string(listen_port);
+	LOG("Starting web server on %s", listen_address.c_str());
+
+	// Create HTTP listener
+	if (!mg_http_listen(&mgr, listen_address.c_str(), HandleMessages, NULL)) {
+		LOG("Failed to create web server listener on %s", listen_address.c_str());
+		return false;
+	}
+	
+	// WebSocket Events
+	Game::web.RegisterWSEvent({
+		.name = "subscribe",
+		.handle = HandleWSSubscribe
+	});
+
+	Game::web.RegisterWSEvent({
+		.name = "unsubscribe",
+		.handle = HandleWSUnsubscribe
+	});
+
+	Game::web.RegisterWSEvent({
+		.name = "getSubscriptions",
+		.handle = HandleWSGetSubscriptions
+	});
+	enabled = true;
+	return true;
+}
+
+void Web::ReceiveRequests() {
+	mg_mgr_poll(&mgr, 15);
+}
+
+void Web::SendWSMessage(const std::string subscription, json& data) {
+	if (!Game::web.enabled) return; // don't attempt to send if web is not enabled
+
+	// find subscription
+	auto subItr = std::find(g_WSSubscriptions.begin(), g_WSSubscriptions.end(), subscription);
+	if (subItr == g_WSSubscriptions.end()) {
+		LOG_DEBUG("Failed to send WS message: subscription %s not found", subscription.c_str());
+		return;
+	}
+	// tell it the event type
+	data["event"] = subscription;
+	auto index = std::distance(g_WSSubscriptions.begin(), subItr);
+	for (struct mg_connection *wc = Game::web.mgr.conns; wc != NULL; wc = wc->next) {
+		if (wc->is_websocket && wc->data[index] == 1) {
+			mg_ws_send(wc, data.dump().c_str(), data.dump().size(), WEBSOCKET_OP_TEXT);
+		}
+	}
+}

dWeb/Web.h

@@ -0,0 +1,52 @@
+#ifndef __WEB_H__
+#define __WEB_H__
+
+#include <functional>
+#include <string>
+#include <optional>
+#include "mongoose.h"
+#include "json_fwd.hpp"
+#include "eHTTPStatusCode.h"
+
+class Web;
+namespace Game {
+	extern Web web;
+}
+
+enum class eHTTPMethod;
+
+typedef struct mg_mgr mg_mgr;
+
+struct HTTPReply {
+	eHTTPStatusCode status = eHTTPStatusCode::NOT_FOUND;
+	std::string message = "{\"error\":\"Not Found\"}";
+};
+
+struct HTTPRoute {
+	std::string path;
+	eHTTPMethod method;
+	std::function<void(HTTPReply&, const std::string&)> handle;
+};
+
+struct WSEvent {
+	std::string name;
+	std::function<void(mg_connection*, nlohmann::json)> handle;
+};
+
+class Web {
+public:
+	Web();
+	~Web();
+	void ReceiveRequests();
+	void static SendWSMessage(std::string sub, nlohmann::json& message);
+	bool Startup(const std::string& listen_ip, const uint32_t listen_port);
+	void RegisterHTTPRoute(HTTPRoute route);
+	void RegisterWSEvent(WSEvent event);
+	void RegisterWSSubscription(const std::string& subscription);
+	bool IsEnabled() const { return enabled; };
+private:
+	mg_mgr mgr;
+	bool enabled = false;
+};
+
+#endif // !__WEB_H__

dWorldServer/WorldServer.cpp

@@ -647,6 +647,21 @@ void HandlePacketChat(Packet* packet) {
 
 				break;
 			}
+			case MessageType::Chat::GENERAL_CHAT_MESSAGE: {
+				// First get the zone and check if we should forward it
+				CINSTREAM_SKIP_HEADER;
+				uint32_t zoneID;
+				inStream.Read(zoneID);
+				if (zoneID != Game::server->GetZoneID()) return;
+				//Write our stream outwards:
+				CBITSTREAM;
+				unsigned char data;
+				while (inStream.Read(data)) {
+					bitStream.Write(data);
+				}
+				SEND_PACKET_BROADCAST;
+				break;
+			}
 			default:
 				LOG("Received an unknown chat: %i", int(packet->data[3]));
 			}
@@ -1118,8 +1133,6 @@ void HandlePacket(Packet* packet) {
 						GeneralUtils::SetBit(blueprintID, eObjectBits::CHARACTER);
 						GeneralUtils::SetBit(blueprintID, eObjectBits::PERSISTENT);
 
-						// Workaround for not having a UGC server to get model LXFML onto the client so it
-						// can generate the physics and nif for the object.
 						CBITSTREAM;
 						BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::BLUEPRINT_SAVE_RESPONSE);
 						bitStream.Write<LWOOBJID>(LWOOBJID_EMPTY); //always zero so that a check on the client passes
@@ -1291,7 +1304,7 @@ void HandlePacket(Packet* packet) {
 			}
 		}
 
-		std::vector<std::pair<uint8_t, uint8_t>> segments = Game::chatFilter->IsSentenceOkay(request.message, entity->GetGMLevel(), !(isBestFriend && request.chatLevel == 1));
+		auto segments = Game::chatFilter->IsSentenceOkay(request.message, entity->GetGMLevel(), !(isBestFriend && request.chatLevel == 1));
 
 		bool bAllClean = segments.empty();
 
@@ -1306,10 +1319,9 @@ void HandlePacket(Packet* packet) {
 
 	case MessageType::World::GENERAL_CHAT_MESSAGE: {
 		if (chatDisabled) {
-			ChatPackets::SendMessageFail(packet->systemAddress);
+			ChatPackets::MessageFailure().Send(packet->systemAddress);
 		} else {
-			auto chatMessage = ClientPackets::HandleChatMessage(packet);
-
+			ChatPackets::WorldChatMessage inChatMessage;
 			// TODO: Find a good home for the logic in this case.
 			User* user = UserManager::Instance()->GetUser(packet->systemAddress);
 			if (!user) {
@@ -1330,7 +1342,36 @@ void HandlePacket(Packet* packet) {
 
 			std::string sMessage = GeneralUtils::UTF16ToWTF8(chatMessage.message);
 			LOG("%s: %s", playerName.c_str(), sMessage.c_str());
-			ChatPackets::SendChatMessage(packet->systemAddress, chatMessage.chatChannel, playerName, user->GetLoggedInChar(), isMythran, chatMessage.message);
+
+			ChatPackets::ChatMessage outChatMessage; 
+			outChatMessage.chatChannel = chatMessage.chatChannel;
+			outChatMessage.message = chatMessage.message;
+			
+			outChatMessage.Broadcast();
+
+			{
+				// TODO: make it so we don't write this manually, but instead use a proper read and writes
+				// aka: this is awful and should be fixed, but I can't be bothered to do it right now
+				// Forward to the chat server
+				CBITSTREAM;
+				BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::GENERAL_CHAT_MESSAGE);
+
+				bitStream.Write(user->GetLoggedInChar());
+				bitStream.Write<uint32_t>(chatMessage.message.size());
+				bitStream.Write(chatMessage.chatChannel);
+				bitStream.Write<uint32_t>(chatMessage.message.size());
+
+				for (uint32_t i = 0; i < 77; ++i) {
+					bitStream.Write<uint8_t>(0);
+				}
+
+				for (uint32_t i = 0; i < chatMessage.message.size(); ++i) {
+					bitStream.Write<uint16_t>(chatMessage.message[i]);
+				}
+				bitStream.Write<uint16_t>(0);
+				Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, Game::chatSysAddr, false);
+			}
+
 		}
 
 		break;
@@ -1419,6 +1460,7 @@ void WorldShutdownProcess(uint32_t zoneId) {
 	if (PropertyManagementComponent::Instance() != nullptr) {
 		LOG("Saving ALL property data for zone %i clone %i!", zoneId, PropertyManagementComponent::Instance()->GetCloneId());
 		PropertyManagementComponent::Instance()->Save();
+		Database::Get()->RemoveUnreferencedUgcModels();
 		LOG("ALL property data saved for zone %i clone %i!", zoneId, PropertyManagementComponent::Instance()->GetCloneId());
 	}
 

docs/asyncapi.yaml

@@ -0,0 +1,163 @@
+asyncapi: 2.0.0
+info:
+  title: DarkflameServer WebSocket API
+  version: 1.0.0
+  description: API documentation for DarkflameServer WebSocket endpoints
+
+servers:
+  production:
+    url: http://localhost:2005/ws
+    protocol: http
+    description: Production server
+
+channels:
+  chat:
+    subscribe:
+      summary: Subscribe to chat messages
+      message:
+        contentType: application/json
+        payload:
+          $ref: '#/components/schemas/ChatMessage'
+    publish:
+      summary: Send a chat message
+      message:
+        contentType: application/json
+        payload:
+          $ref: '#/components/schemas/ChatMessage'
+
+  player:
+    subscribe:
+      summary: Subscribe to player updates
+      message:
+        contentType: application/json
+        payload:
+          $ref: '#/components/schemas/PlayerUpdate'
+
+  team:
+    subscribe:
+      summary: Subscribe to team updates
+      message:
+        contentType: application/json
+        payload:
+          $ref: '#/components/schemas/TeamUpdate'
+
+  subscribe:
+    publish:
+      summary: Subscribe to an event
+      message:
+        contentType: application/json
+        payload:
+          $ref: '#/components/schemas/Subscription'
+
+  unsubscribe:
+    publish:
+      summary: Unsubscribe from an event
+      message:
+        contentType: application/json
+        payload:
+          $ref: '#/components/schemas/Subscription'
+
+components:
+  schemas:
+    ChatMessage:
+      type: object
+      properties:
+        user:
+          type: string
+          example: "Player1"
+        message:
+          type: string
+          example: "Hello, world!"
+        gmlevel:
+          type: integer
+          minimum: 0
+          maximum: 9
+          example: 0
+        zone:
+          type: integer
+          example: 1000
+
+    PlayerUpdate:
+      type: object
+      properties:
+        player_data:
+          $ref: '#/components/schemas/Player'
+        update_type:
+          type: string
+          example: "JOIN"
+
+    TeamUpdate:
+      type: object
+      properties:
+        team_data:
+          $ref: '#/components/schemas/Team'
+        update_type:
+          type: string
+          example: "CREATE"
+
+    Subscription:
+      type: object
+      required:
+        - subscription
+      properties:
+        subscription:
+          type: string
+          example: "chat_local"
+
+    Player:
+      type: object
+      properties:
+        id:
+          type: integer
+          format: int64
+          example: 1152921508901824000
+        gm_level:
+          type: integer
+          format: uint8
+          example: 0
+        name:
+          type: string
+          example: thisisatestname
+        muted:
+          type: boolean
+          example: false
+        zone_id:
+          $ref: '#/components/schemas/ZoneID'
+
+    ZoneID:
+      type: object
+      properties:
+        map_id:
+          type: integer
+          format: uint16
+          example: 1200
+        instance_id:
+          type: integer
+          format: uint16
+          example: 2
+        clone_id:
+          type: integer
+          format: uint32
+          example: 0
+
+    Team:
+      type: object
+      properties:
+        id:
+          type: integer
+          format: int64
+          example: 1152921508901824000
+        loot_flag:
+          type: integer
+          format: uint8
+          example: 1
+        local:
+          type: boolean
+          example: false
+        leader:
+          type: string
+          example: thisisatestname
+        members:
+          type: array
+          items:
+            $ref: '#/components/schemas/Player'

docs/openapi.yaml

@@ -0,0 +1,121 @@
+openapi: 3.0.0
+info:
+  title: DarkflameServer API
+  version: 1.0.0
+  description: API documentation for DarkflameServer HTTP endpoints
+
+servers:
+  - url: http://localhost:2005/api/v1
+
+paths:
+  /players:
+    get:
+      summary: Get list of online players
+      responses:
+        '200':
+          description: A list of online players
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Player'
+        '204':
+          description: No players online
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+                    example: "No Players Online"
+
+  /teams:
+    get:
+      summary: Get list of online teams
+      responses:
+        '200':
+          description: A list of online teams
+          content:
+            application/json:
+              schema:
+                type: array
+                items:
+                  $ref: '#/components/schemas/Team'
+        '204':
+          description: No teams online
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+                    example: "No Teams Online"
+
+  /announce:
+    post:
+      summary: Send an announcement
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/Announcement'
+      responses:
+        '200':
+          description: Announcement sent successfully
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  status:
+                    type: string
+                    example: "Announcement Sent"
+        '400':
+          description: Invalid JSON or missing required fields
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  error:
+                    type: string
+                    example: "Invalid JSON"
+
+components:
+  schemas:
+    Player:
+      type: object
+      properties:
+        playerID:
+          type: integer
+          example: 12345
+        playerName:
+          type: string
+          example: "Player1"
+
+    Team:
+      type: object
+      properties:
+        teamID:
+          type: integer
+          example: 67890
+        teamName:
+          type: string
+          example: "Team1"
+
+    Announcement:
+      type: object
+      required:
+        - title
+        - message
+      properties:
+        title:
+          type: string
+          example: "Server Maintenance"
+        message:
+          type: string
+          example: "The server will be down for maintenance at 10 PM."

migrations/dlu/mysql/19_normalize_model_positions.sql

@@ -1 +0,0 @@
-/* See ModelNormalizeMigration.cpp for details */

migrations/dlu/sqlite/2_normalize_model_positions.sql

@@ -1 +0,0 @@
-/* See ModelNormalizeMigration.cpp for details */