Cache build directory when using docker with BuildKit

tested that news screen no longer shows up on every other world load

CMakeLists.txt

@@ -235,8 +235,6 @@ include_directories(
 
 	"dNet"
 
-	"dWeb"
-
 	"tests"
 	"tests/dCommonTests"
 	"tests/dGameTests"
@@ -303,7 +301,6 @@ 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")

Dockerfile

@@ -11,7 +11,12 @@ COPY --chmod=0500 ./build.sh /app/
 
 RUN sed -i 's/MARIADB_CONNECTOR_COMPILE_JOBS__=.*/MARIADB_CONNECTOR_COMPILE_JOBS__=2/' /app/CMakeVariables.txt 
 
-RUN ./build.sh
+RUN --mount=type=cache,target=/app/build,id=build-cache \
+    mkdir -p /app/build /tmp/persisted-build && \
+    cd /app/build && \
+    cmake .. && \
+    make -j$(nproc --ignore 1) && \
+    cp -r /app/build/* /tmp/persisted-build/
 
 FROM debian:12 as runtime
 
@@ -23,23 +28,23 @@ RUN --mount=type=cache,id=build-apt-cache,target=/var/cache/apt \
     rm -rf /var/lib/apt/lists/*
 
 # Grab libraries and load them
-COPY --from=build /app/build/mariadbcpp/libmariadbcpp.so /usr/local/lib/
+COPY --from=build /tmp/persisted-build/mariadbcpp/libmariadbcpp.so /usr/local/lib/
 RUN ldconfig
 
 # Server bins
-COPY --from=build /app/build/*Server /app/
+COPY --from=build /tmp/persisted-build/*Server /app/
 
 # Necessary suplimentary files
-COPY --from=build /app/build/*.ini /app/configs/
-COPY --from=build /app/build/vanity/*.* /app/vanity/
-COPY --from=build /app/build/navmeshes /app/navmeshes
-COPY --from=build /app/build/migrations /app/migrations
-COPY --from=build /app/build/*.dcf /app/
+COPY --from=build /tmp/persisted-build/*.ini /app/configs/
+COPY --from=build /tmp/persisted-build/vanity/*.* /app/vanity/
+COPY --from=build /tmp/persisted-build/navmeshes /app/navmeshes
+COPY --from=build /tmp/persisted-build/migrations /app/migrations
+COPY --from=build /tmp/persisted-build/*.dcf /app/
 
 # backup of config and vanity files to copy to the host incase 
 # of a mount clobbering the copy from above
-COPY --from=build /app/build/*.ini /app/default-configs/ 
-COPY --from=build /app/build/vanity/*.* /app/default-vanity/
+COPY --from=build /tmp/persisted-build/*.ini /app/default-configs/ 
+COPY --from=build /tmp/persisted-build/vanity/*.* /app/default-vanity/
 
 # needed as the container runs with the root user
 # and therefore sudo doesn't exist

dChatFilter/dChatFilter.cpp

@@ -105,7 +105,7 @@ void dChatFilter::ExportWordlistToDCF(const std::string& filepath, bool allowLis
 	}
 }
 
-std::set<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList) {
+std::vector<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::set<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::str
 	std::string segment;
 	std::regex reg("(!*|\\?*|\\;*|\\.*|\\,*)");
 
-	std::set<std::pair<uint8_t, uint8_t>> listOfBadSegments;
+	std::vector<std::pair<uint8_t, uint8_t>> listOfBadSegments = std::vector<std::pair<uint8_t, uint8_t>>();
 
 	uint32_t position = 0;
 
@@ -127,17 +127,17 @@ std::set<std::pair<uint8_t, uint8_t>> dChatFilter::IsSentenceOkay(const std::str
 		size_t hash = CalculateHash(segment);
 
 		if (std::find(m_UserUnapprovedWordCache.begin(), m_UserUnapprovedWordCache.end(), hash) != m_UserUnapprovedWordCache.end() && allowList) {
-			listOfBadSegments.emplace(position, originalSegment.length());
+			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
 		if (std::find(m_ApprovedWords.begin(), m_ApprovedWords.end(), hash) == m_ApprovedWords.end() && allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
-			listOfBadSegments.emplace(position, originalSegment.length());
+			listOfBadSegments.emplace_back(position, originalSegment.length());
 		}
 
 		if (std::find(m_DeniedWords.begin(), m_DeniedWords.end(), hash) != m_DeniedWords.end() && !allowList) {
 			m_UserUnapprovedWordCache.push_back(hash);
-			listOfBadSegments.emplace(position, originalSegment.length());
+			listOfBadSegments.emplace_back(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::set<std::pair<uint8_t, uint8_t>> IsSentenceOkay(const std::string& message, eGameMasterLevel gmLevel, bool allowList = true);
+	std::vector<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"
-	"ChatWeb.cpp"
+	"ChatWebAPI.cpp"
+	"JSONUtils.cpp"
 )
 
 add_executable(ChatServer "ChatServer.cpp")
-target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter" "${PROJECT_SOURCE_DIR}/dWeb")
+target_include_directories(ChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dChatFilter")
 add_compile_definitions(ChatServer PRIVATE PROJECT_VERSION="\"${PROJECT_VERSION}\"")
 
 add_library(dChatServer ${DCHATSERVER_SOURCES})
-target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer" "${PROJECT_SOURCE_DIR}/dChatFilter")
+target_include_directories(dChatServer PRIVATE "${PROJECT_SOURCE_DIR}/dServer")
 
 target_link_libraries(dChatServer ${COMMON_LIBRARIES} dChatFilter)
-target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer dWeb)
+target_link_libraries(ChatServer ${COMMON_LIBRARIES} dChatFilter dChatServer dServer mongoose)
 

dChatServer/ChatPacketHandler.cpp

@@ -19,8 +19,6 @@
 #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:
@@ -366,7 +364,7 @@ void ChatPacketHandler::HandleGMLevelUpdate(Packet* packet) {
 
 void ChatPacketHandler::HandleWho(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	ChatPackets::FindPlayerRequest request;
+	FindPlayerRequest request;
 	request.Deserialize(inStream);
 
 	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
@@ -392,7 +390,7 @@ void ChatPacketHandler::HandleWho(Packet* packet) {
 
 void ChatPacketHandler::HandleShowAll(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
-	ChatPackets::ShowAllRequest request;
+	ShowAllRequest request;
 	request.Deserialize(inStream);
 
 	const auto& sender = Game::playerContainer.GetPlayerData(request.requestor);
@@ -428,106 +426,97 @@ 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;
-	ChatMessage data;
-	LWOOBJID sender;
-	inStream.Read(sender);
-	LOG("Got a message from player %llu", sender);
+	LWOOBJID playerID;
+	inStream.Read(playerID);
 
-	data.sender = Game::playerContainer.GetPlayerData(sender);
-	if (!data.sender || data.sender.GetIsMuted()) return;
+	const auto& sender = Game::playerContainer.GetPlayerData(playerID);
+	if (!sender || sender.GetIsMuted()) return;
 
+	eChatChannel channel;
 	uint32_t size;
 
 	inStream.IgnoreBytes(4);
-	inStream.Read(data.channel);
+	inStream.Read(channel);
 	inStream.Read(size);
 	inStream.IgnoreBytes(77);
 
-	data.message = LUWString(size);
-	inStream.Read(data.message);
+	LUWString message(size);
+	inStream.Read(message);
 
-	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;
+	LOG("Got a message from (%s) via [%s]: %s", sender.playerName.c_str(), StringifiedEnum::ToString(channel).data(), message.GetAsString().c_str());
 
-			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;
+	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);
 		}
-		default:
-			LOG_DEBUG("Unhandled Chat channel [%s]", StringifiedEnum::ToString(data.channel).data());
-			break;
+		break;
+	}
+	default:
+		LOG("Unhandled Chat channel [%s]", StringifiedEnum::ToString(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);
 
-	data.sender = Game::playerContainer.GetPlayerData(playerID);
-	if (!data.sender || data.sender.GetIsMuted()) return;
+	const auto& sender = Game::playerContainer.GetPlayerData(playerID);
+	if (!sender || sender.GetIsMuted()) return;
 
+	eChatChannel channel;
 	uint32_t size;
+	LUWString LUReceiverName;
 
 	inStream.IgnoreBytes(4);
-	inStream.Read(data.channel);
-	if (data.channel != eChatChannel::PRIVATE_CHAT) LOG("WARNING: Received Private chat with the wrong channel!");
+	inStream.Read(channel);
+	if (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);
 
-	data.message = LUWString(size);
-	inStream.Read(data.message);
+	LUWString message(size);
+	inStream.Read(message);
 
-	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());
+	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());
 
-	data.receiver = Game::playerContainer.GetPlayerData(receiverName);
-	if (!data.receiver) {
+	const auto& receiver = Game::playerContainer.GetPlayerData(receiverName);
+	if (!receiver) {
 		PlayerData otherPlayer;
 		otherPlayer.playerName = receiverName;
 		auto responseType = Database::Get()->GetCharacterInfo(receiverName)
 			? eChatMessageResponseCode::NOTONLINE
 			: eChatMessageResponseCode::GENERALERROR;
 
-		SendPrivateChatMessage(data.sender, otherPlayer, data.sender, data.message, data.channel, responseType);
+		SendPrivateChatMessage(sender, otherPlayer, sender, message, eChatChannel::GENERAL, responseType);
 		return;
 	}
 
 	// Check to see if they are friends
 	// only freinds can whispr each other
-	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);
+	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);
 			return;
 		}
 	}
-	SendPrivateChatMessage(data.sender, data.receiver, data.sender, data.message, data.channel, eChatMessageResponseCode::NOTFRIENDS);
+	SendPrivateChatMessage(sender, receiver, sender, message, eChatChannel::GENERAL, 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"
-#include "PlayerContainer.h"
-#include "eChatMessageResponseCode.h"
+
+struct PlayerData;
 
 enum class eAddFriendResponseType : uint8_t;
 
@@ -34,13 +34,14 @@ enum class eChatChannel : uint8_t {
 };
 
 
-
-struct ChatMessage {
-	LUWString message;
-	PlayerData sender;
-	PlayerData receiver;
-	eChatChannel channel;
-	LWOOBJID teamID;
+enum class eChatMessageResponseCode : uint8_t {
+    SENT = 0,
+    NOTONLINE,
+    GENERALERROR,
+    RECEIVEDNEWWHISPER,
+    NOTFRIENDS,
+    SENDERFREETRIAL,
+    RECEIVERFREETRIAL,
 };
 
 namespace ChatPacketHandler {

dChatServer/ChatServer.cpp

@@ -28,7 +28,7 @@
 #include "RakNetDefines.h"
 #include "MessageIdentifiers.h"
 
-#include "ChatWeb.h"
+#include "ChatWebAPI.h"
 
 namespace Game {
 	Logger* logger = nullptr;
@@ -92,18 +92,17 @@ int main(int argc, char** argv) {
 		return EXIT_FAILURE;
 	}
 
-	// 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
+	// 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
 		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;
@@ -167,8 +166,10 @@ int main(int argc, char** argv) {
 			packet = nullptr;
 		}
 
-		// Check and handle web requests:
-		if (Game::web.IsEnabled()) Game::web.ReceiveRequests();
+		//Check and handle web requests:
+		if (web_server_enabled) {
+			chatwebapi.ReceiveRequests();
+		}
 
 		//Push our log every 30s:
 		if (framesSinceLastFlush >= logFlushTime) {
@@ -206,7 +207,6 @@ 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

@@ -1,169 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-#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

@@ -0,0 +1,197 @@
+#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

@@ -0,0 +1,36 @@
+#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/JSONUtils.cpp

@@ -1,4 +1,4 @@
-#include "ChatJSONUtils.h"
+#include "JSONUtils.h"
 
 #include "json.hpp"
 
@@ -47,3 +47,16 @@ 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/JSONUtils.h

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

dChatServer/PlayerContainer.cpp

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

dCommon/CMakeLists.txt

@@ -7,7 +7,6 @@ set(DCOMMON_SOURCES
 		"Logger.cpp"
 		"Game.cpp"
 		"GeneralUtils.cpp"
-		"JSONUtils.cpp"
 		"LDFFormat.cpp"
 		"Metrics.cpp"
 		"NiPoint3.cpp"

dCommon/JSONUtils.cpp

@@ -1,18 +0,0 @@
-#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

@@ -1,11 +0,0 @@
-#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/dEnums/eChatMessageResponseCode.h

@@ -1,15 +0,0 @@
-#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/GameDatabase/ITables/IActivityLog.h

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

dGame/Character.cpp

@@ -204,6 +204,7 @@ void Character::DoQuickXMLDataParse() {
 		while (currentChild) {
 			const auto* temp = currentChild->Attribute("v");
 			const auto* id = currentChild->Attribute("id");
+			const auto* si = currentChild->Attribute("si");
 			if (temp && id) {
 				uint32_t index = 0;
 				uint64_t value = 0;
@@ -212,6 +213,9 @@ void Character::DoQuickXMLDataParse() {
 				value = std::stoull(temp);
 
 				m_PlayerFlags.insert(std::make_pair(index, value));
+			} else if (si) {
+				auto value = GeneralUtils::TryParse<uint32_t>(si);
+				if (value) m_SessionFlags.insert(value.value());
 			}
 			currentChild = currentChild->NextSiblingElement();
 		}

dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp

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

dMasterServer/InstanceManager.cpp

@@ -273,6 +273,16 @@ Instance* InstanceManager::FindInstance(LWOMAPID mapID, LWOINSTANCEID instanceID
 	return nullptr;
 }
 
+Instance* InstanceManager::FindInstanceWithPrivate(LWOMAPID mapID, LWOINSTANCEID instanceID) {
+	for (Instance* i : m_Instances) {
+		if (i && i->GetMapID() == mapID && i->GetInstanceID() == instanceID && !i->GetShutdownComplete() && !i->GetIsShuttingDown()) {
+			return i;
+		}
+	}
+
+	return nullptr;
+}
+
 Instance* InstanceManager::CreatePrivateInstance(LWOMAPID mapID, LWOCLONEID cloneID, const std::string& password) {
 	auto* instance = FindPrivateInstance(password);
 

dMasterServer/InstanceManager.h

@@ -76,25 +76,25 @@ public:
 	void Shutdown();
 
 private:
-	std::string m_IP;
-	uint32_t m_Port;
-	LWOZONEID m_ZoneID;
-	int m_MaxClientsSoftCap;
-	int m_MaxClientsHardCap;
-	int m_CurrentClientCount;
-	std::vector<Player> m_Players;
-	SystemAddress m_SysAddr;
-	bool m_Ready;
-	bool m_IsShuttingDown;
-	std::vector<PendingInstanceRequest> m_PendingRequests;
-	std::vector<PendingInstanceRequest> m_PendingAffirmations;
+	std::string m_IP{};
+	uint32_t m_Port{};
+	LWOZONEID m_ZoneID{};
+	int m_MaxClientsSoftCap{};
+	int m_MaxClientsHardCap{};
+	int m_CurrentClientCount{};
+	std::vector<Player> m_Players{};
+	SystemAddress m_SysAddr{};
+	bool m_Ready{};
+	bool m_IsShuttingDown{};
+	std::vector<PendingInstanceRequest> m_PendingRequests{};
+	std::vector<PendingInstanceRequest> m_PendingAffirmations{};
 
-	uint32_t m_AffirmationTimeout;
+	uint32_t m_AffirmationTimeout{};
 
-	bool m_IsPrivate;
-	std::string m_Password;
+	bool m_IsPrivate{};
+	std::string m_Password{};
 
-	bool m_Shutdown;
+	bool m_Shutdown{};
 
 	//Private functions:
 };
@@ -125,6 +125,7 @@ public:
 
 	Instance* FindInstance(LWOMAPID mapID, bool isFriendTransfer, LWOCLONEID cloneId = 0);
 	Instance* FindInstance(LWOMAPID mapID, LWOINSTANCEID instanceID);
+	Instance* FindInstanceWithPrivate(LWOMAPID mapID, LWOINSTANCEID instanceID);
 
 	Instance* CreatePrivateInstance(LWOMAPID mapID, LWOCLONEID cloneID, const std::string& password);
 	Instance* FindPrivateInstance(const std::string& password);

dMasterServer/MasterServer.cpp

@@ -42,6 +42,7 @@
 #include "Server.h"
 #include "CDZoneTableTable.h"
 #include "eGameMasterLevel.h"
+#include "StringifiedEnum.h"
 
 #ifdef DARKFLAME_PLATFORM_UNIX
 
@@ -556,7 +557,7 @@ void HandlePacket(Packet* packet) {
 			Instance* in = Game::im->GetInstance(zoneID, false, zoneClone);
 
 			for (auto* instance : Game::im->GetInstances()) {
-				LOG("Instance: %i/%i/%i -> %i", instance->GetMapID(), instance->GetCloneID(), instance->GetInstanceID(), instance == in);
+				LOG("Instance: %i/%i/%i -> %i %s", instance->GetMapID(), instance->GetCloneID(), instance->GetInstanceID(), instance == in, instance->GetSysAddr().ToString());
 			}
 
 			if (in && !in->GetIsReady()) //Instance not ready, make a pending request
@@ -597,15 +598,10 @@ void HandlePacket(Packet* packet) {
 				if (!Game::im->IsPortInUse(theirPort)) {
 					Instance* in = new Instance(theirIP.string, theirPort, theirZoneID, theirInstanceID, 0, 12, 12);
 
-					SystemAddress copy;
-					copy.binaryAddress = packet->systemAddress.binaryAddress;
-					copy.port = packet->systemAddress.port;
-
-					in->SetSysAddr(copy);
+					in->SetSysAddr(packet->systemAddress);
 					Game::im->AddInstance(in);
 				} else {
-					auto instance = Game::im->FindInstance(
-						theirZoneID, static_cast<uint16_t>(theirInstanceID));
+					auto* instance = Game::im->FindInstanceWithPrivate(theirZoneID, static_cast<LWOINSTANCEID>(theirInstanceID));
 					if (instance) {
 						instance->SetSysAddr(packet->systemAddress);
 					}
@@ -613,22 +609,14 @@ void HandlePacket(Packet* packet) {
 			}
 
 			if (theirServerType == ServerType::Chat) {
-				SystemAddress copy;
-				copy.binaryAddress = packet->systemAddress.binaryAddress;
-				copy.port = packet->systemAddress.port;
-
-				chatServerMasterPeerSysAddr = copy;
+				chatServerMasterPeerSysAddr = packet->systemAddress;
 			}
 
 			if (theirServerType == ServerType::Auth) {
-				SystemAddress copy;
-				copy.binaryAddress = packet->systemAddress.binaryAddress;
-				copy.port = packet->systemAddress.port;
-
-				authServerMasterPeerSysAddr = copy;
+				authServerMasterPeerSysAddr = packet->systemAddress;
 			}
 
-			LOG("Received server info, instance: %i port: %i", theirInstanceID, theirPort);
+			LOG("Received %s server info, instance: %i port: %i", StringifiedEnum::ToString(theirServerType).data(), theirInstanceID, theirPort);
 
 			break;
 		}
@@ -692,7 +680,7 @@ void HandlePacket(Packet* packet) {
 			if (instance) {
 				instance->AddPlayer(Player());
 			} else {
-				printf("Instance missing? What?");
+				LOG("Instance missing? What?");
 			}
 			break;
 		}
@@ -733,8 +721,8 @@ void HandlePacket(Packet* packet) {
 				inStream.Read<char>(character);
 				password += character;
 			}
-
-			Game::im->CreatePrivateInstance(mapId, cloneId, password.c_str());
+			auto* newInst = Game::im->CreatePrivateInstance(mapId, cloneId, password.c_str());
+			LOG("Creating private zone %i/%i/%i with password %s", newInst->GetMapID(), newInst->GetCloneID(), newInst->GetInstanceID(), password.c_str());
 
 			break;
 		}
@@ -835,11 +823,10 @@ void HandlePacket(Packet* packet) {
 		}
 
 		case MessageType::Master::SHUTDOWN_RESPONSE: {
-			RakNet::BitStream inStream(packet->data, packet->length, false);
-			uint64_t header = inStream.Read(header);
+			CINSTREAM_SKIP_HEADER;
 
 			auto* instance = Game::im->GetInstanceBySysAddr(packet->systemAddress);
-
+			LOG("Got shutdown response from %s", packet->systemAddress.ToString());
 			if (instance == nullptr) {
 				return;
 			}

dNet/BitStreamUtils.h

@@ -61,9 +61,6 @@ 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,136 +11,99 @@
 #include "dServer.h"
 #include "eConnectionType.h"
 #include "MessageType/Chat.h"
-namespace ChatPackets {
-	void ShowAllRequest::Serialize(RakNet::BitStream& bitStream) const {
-		bitStream.Write(this->requestor);
-		bitStream.Write(this->displayZoneData);
-		bitStream.Write(this->displayIndividualPlayers);
-	}
 
-	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;
-	}
-
-	void FindPlayerRequest::Serialize(RakNet::BitStream& bitStream) const {
-		bitStream.Write(this->requestor);
-		bitStream.Write(this->playerName);
-	}
-
-	bool FindPlayerRequest::Deserialize(RakNet::BitStream& inStream) {
-		VALIDATE_READ(inStream.Read(this->requestor));
-		VALIDATE_READ(inStream.Read(this->playerName));
-		return true;
-	}
-
-	void ChatMessage::Serialize(RakNet::BitStream& bitStream) const {
-		bitStream.Write<uint64_t>(0);// senderID
-		bitStream.Write(chatChannel);
-
-		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);
-	}
+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]);
+	}
+
+	bitStream.Write<uint16_t>(0);
+
+	//This is so Wincent's announcement works:
+	if (sysAddr != UNASSIGNED_SYSTEM_ADDRESS) {
+		SEND_PACKET;
+		return;
+	}
+
+	SEND_PACKET_BROADCAST;
+}
+
+void ChatPackets::SendMessageFail(const SystemAddress& sysAddr) {
+	//0x00 - "Chat is currently disabled."
+	//0x01 - "Upgrade to a full LEGO Universe Membership to chat with other players."
+
+	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 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;
 }

dNet/ChatPackets.h

@@ -10,85 +10,33 @@ struct SystemAddress;
 
 #include <string>
 #include "dCommonVars.h"
-#include "BitStreamUtils.h"
-#include "MessageType/Chat.h"
-#include "eChatMessageResponseCode.h"
 
-enum class eCannedText : uint8_t {
-	CHAT_DISABLED = 0,
-	F2P_CHAT_DISABLED = 1
+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);
 };
 
 namespace ChatPackets {
-	void SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast = false);
 
-	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;
-	};
-
-	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 {
+	struct Announcement {
 		std::string title;
 		std::string message;
-
-		Announcement() : LUBitStream(eConnectionType::CHAT, MessageType::Chat::GM_ANNOUNCE) {};
-		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		void Send();
 	};
 
-	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;
-	};
+	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);
 };
 
 #endif // CHATPACKETS_H

dNet/ClientPackets.h

@@ -13,6 +13,12 @@ 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;
@@ -21,6 +27,7 @@ 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::set<std::pair<uint8_t, uint8_t>> unacceptedItems) {
+void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<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,6 +10,9 @@ 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;
@@ -29,7 +32,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::set<std::pair<uint8_t, uint8_t>> unacceptedItems);
+	void SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<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

@@ -1,7 +0,0 @@
-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

@@ -1,289 +0,0 @@
-#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

@@ -1,52 +0,0 @@
-#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,21 +647,6 @@ 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]));
 			}
@@ -1304,7 +1289,7 @@ void HandlePacket(Packet* packet) {
 			}
 		}
 
-		auto segments = Game::chatFilter->IsSentenceOkay(request.message, entity->GetGMLevel(), !(isBestFriend && request.chatLevel == 1));
+		std::vector<std::pair<uint8_t, uint8_t>> segments = Game::chatFilter->IsSentenceOkay(request.message, entity->GetGMLevel(), !(isBestFriend && request.chatLevel == 1));
 
 		bool bAllClean = segments.empty();
 
@@ -1319,9 +1304,10 @@ void HandlePacket(Packet* packet) {
 
 	case MessageType::World::GENERAL_CHAT_MESSAGE: {
 		if (chatDisabled) {
-			ChatPackets::MessageFailure().Send(packet->systemAddress);
+			ChatPackets::SendMessageFail(packet->systemAddress);
 		} else {
-			ChatPackets::WorldChatMessage inChatMessage;
+			auto chatMessage = ClientPackets::HandleChatMessage(packet);
+
 			// TODO: Find a good home for the logic in this case.
 			User* user = UserManager::Instance()->GetUser(packet->systemAddress);
 			if (!user) {
@@ -1342,36 +1328,7 @@ void HandlePacket(Packet* packet) {
 
 			std::string sMessage = GeneralUtils::UTF16ToWTF8(chatMessage.message);
 			LOG("%s: %s", playerName.c_str(), sMessage.c_str());
-
-			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);
-			}
-
+			ChatPackets::SendChatMessage(packet->systemAddress, chatMessage.chatChannel, playerName, user->GetLoggedInChar(), isMythran, chatMessage.message);
 		}
 
 		break;

docs/asyncapi.yaml

@@ -1,163 +0,0 @@
-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

@@ -1,121 +0,0 @@
-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."