more misc work

* Update build-and-test.yml

* Update build-and-test.yml

* Update build-and-test.yml

* Update build-and-test.yml

* Update build-and-test.yml

* Update build-and-test.yml

* specify up to 3.31

* fix: mail claiming item

tested that I can claim an item without an error

.github/workflows/build-and-test.yml

@@ -16,12 +16,12 @@ jobs:
         os: [ windows-2022, ubuntu-22.04, macos-13 ]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@85e6279cec87321a52edac9c87bce653a07cf6c2
       with:
         submodules: true
     - name: Add msbuild to PATH (Windows only)
       if: ${{ matrix.os == 'windows-2022' }}
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@767f00a3f09872d96a0cb9fcd5e6a4ff33311330
       with:
         vs-version: '[17,18)'
         msbuild-architecture: x64
@@ -30,12 +30,16 @@ jobs:
       run: |
         brew install openssl@3
         sudo xcode-select -s /Applications/Xcode_15.2.app/Contents/Developer
+    - name: Get CMake 3.x
+      uses: lukka/get-cmake@28983e0d3955dba2bb0a6810caae0c6cf268ec0c
+      with:
+        cmakeVersion: "~3.25.0"  # <--= optional, use most recent 3.25.x version
     - name: cmake
-      uses: lukka/run-cmake@v10
+      uses: lukka/run-cmake@67c73a83a46f86c4e0b96b741ac37ff495478c38
       with:
         workflowPreset: "ci-${{matrix.os}}"
     - name: artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@6027e3dd177782cd8ab9af838c04fd81a07f1d47
       with:
         name: build-${{matrix.os}}
         path: |

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")

README.md

@@ -78,7 +78,7 @@ git clone --recursive https://github.com/DarkflameUniverse/DarkflameServer
 
 ### Windows packages
 Ensure that you have either the [MSVC C++ compiler](https://visualstudio.microsoft.com/vs/features/cplusplus/) (recommended) or the [Clang compiler](https://github.com/llvm/llvm-project/releases/) installed.
-You'll also need to download and install [CMake](https://cmake.org/download/) (version <font size="4">**CMake version 3.25**</font> or later!).
+You'll also need to download and install [CMake](https://cmake.org/download/) (<font size="4">**version 3.25**</font> up to <font size="4">**version 3.31**</font>!).
 
 ### MacOS packages
 Ensure you have [brew](https://brew.sh) installed.
@@ -100,7 +100,7 @@ sudo apt install build-essential gcc zlib1g-dev libssl-dev openssl mariadb-serve
 ```
 
 #### Required CMake version
-This project uses <font size="4">**CMake version 3.25**</font> or higher and as such you will need to ensure you have this version installed.
+This project uses <font size="4">**CMake version 3.25**</font> up to <font size="4">**version 3.31**</font> and as such you will need to ensure you have this version installed.
 You can check your CMake version by using the following command in a terminal.
 ```bash
 cmake --version

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,196 +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;
-	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/CMakeLists.txt

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

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/dClient/AssetManager.cpp

@@ -6,6 +6,9 @@
 
 #include "zlib.h"
 
+constexpr uint32_t CRC32_INIT = 0xFFFFFFFF;
+constexpr auto NULL_TERMINATOR = std::string_view{"\0\0\0", 4};
+
 AssetManager::AssetManager(const std::filesystem::path& path) {
 	if (!std::filesystem::is_directory(path)) {
 		throw std::runtime_error("Attempted to load asset bundle (" + path.string() + ") however it is not a valid directory.");
@@ -18,12 +21,20 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 
 		m_RootPath = m_Path;
 		m_ResPath = (m_Path / "client" / "res");
-	} else if (std::filesystem::exists(m_Path / ".." / "versions") && std::filesystem::exists(m_Path / "res")) {
+	} else if (std::filesystem::exists(m_Path / "res" / "pack")) {
+		if (!std::filesystem::exists(m_Path / ".." / "versions")) {
+			throw std::runtime_error("No \"versions\" directory found in the parent directories of \"res\" - packed asset bundle cannot be loaded.");
+		}
+		
 		m_AssetBundleType = eAssetBundleType::Packed;
 
 		m_RootPath = (m_Path / "..");
 		m_ResPath = (m_Path / "res");
-	} else if (std::filesystem::exists(m_Path / "pack") && std::filesystem::exists(m_Path / ".." / ".." / "versions")) {
+	} else if (std::filesystem::exists(m_Path / "pack")) {
+		if (!std::filesystem::exists(m_Path / ".." / ".." / "versions")) {
+			throw std::runtime_error("No \"versions\" directory found in the parent directories of \"res\" - packed asset bundle cannot be loaded.");
+		}
+		
 		m_AssetBundleType = eAssetBundleType::Packed;
 
 		m_RootPath = (m_Path / ".." / "..");
@@ -48,6 +59,7 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 			break;
 		}
 		case eAssetBundleType::None:
+			[[fallthrough]];
 		case eAssetBundleType::Unpacked: {
 			break;
 		}
@@ -55,19 +67,10 @@ AssetManager::AssetManager(const std::filesystem::path& path) {
 }
 
 void AssetManager::LoadPackIndex() {
-	m_PackIndex = new PackIndex(m_RootPath);
+	m_PackIndex = PackIndex(m_RootPath);
 }
 
-std::filesystem::path AssetManager::GetResPath() {
-	return m_ResPath;
-}
-
-eAssetBundleType AssetManager::GetAssetBundleType() {
-	return m_AssetBundleType;
-}
-
-bool AssetManager::HasFile(const char* name) {
-	auto fixedName = std::string(name);
+bool AssetManager::HasFile(std::string fixedName) const {
 	std::transform(fixedName.begin(), fixedName.end(), fixedName.begin(), [](uint8_t c) { return std::tolower(c); });
 
 	// Special case for unpacked client have BrickModels in upper case
@@ -81,8 +84,7 @@ bool AssetManager::HasFile(const char* name) {
 	std::replace(fixedName.begin(), fixedName.end(), '/', '\\');
 	if (fixedName.rfind("client\\res\\", 0) != 0) fixedName = "client\\res\\" + fixedName;
 
-	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
-	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
+	const auto crc = crc32b(crc32b(CRC32_INIT, fixedName), NULL_TERMINATOR);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
@@ -93,8 +95,7 @@ bool AssetManager::HasFile(const char* name) {
 	return false;
 }
 
-bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
-	auto fixedName = std::string(name);
+bool AssetManager::GetFile(std::string fixedName, char** data, uint32_t* len) const {
 	std::transform(fixedName.begin(), fixedName.end(), fixedName.begin(), [](uint8_t c) { return std::tolower(c); });
 	std::replace(fixedName.begin(), fixedName.end(), '\\', '/'); // On the off chance someone has the wrong slashes, force forward slashes
 
@@ -129,8 +130,7 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 		fixedName = "client\\res\\" + fixedName;
 	}
 	int32_t packIndex = -1;
-	uint32_t crc = crc32b(0xFFFFFFFF, reinterpret_cast<uint8_t*>(const_cast<char*>(fixedName.c_str())), fixedName.size());
-	crc = crc32b(crc, reinterpret_cast<Bytef*>(const_cast<char*>("\0\0\0\0")), 4);
+	auto crc = crc32b(crc32b(CRC32_INIT, fixedName), NULL_TERMINATOR);
 
 	for (const auto& item : this->m_PackIndex->GetPackFileIndices()) {
 		if (item.m_Crc == crc) {
@@ -144,15 +144,13 @@ bool AssetManager::GetFile(const char* name, char** data, uint32_t* len) {
 		return false;
 	}
 
-	auto packs = this->m_PackIndex->GetPacks();
-	auto* pack = packs.at(packIndex);
-
-	bool success = pack->ReadFileFromPack(crc, data, len);
+	const auto& pack = this->m_PackIndex->GetPacks().at(packIndex);
+	const bool success = pack.ReadFileFromPack(crc, data, len);
 
 	return success;
 }
 
-AssetStream AssetManager::GetFile(const char* name) {
+AssetStream AssetManager::GetFile(const char* name) const {
 	char* buf; uint32_t len;
 
 	bool success = this->GetFile(name, &buf, &len);
@@ -160,23 +158,15 @@ AssetStream AssetManager::GetFile(const char* name) {
 	return AssetStream(buf, len, success);
 }
 
-uint32_t AssetManager::crc32b(uint32_t base, uint8_t* message, size_t l) {
-	size_t i, j;
-	uint32_t crc, msb;
-
-	crc = base;
-	for (i = 0; i < l; i++) {
+uint32_t AssetManager::crc32b(uint32_t crc, const std::string_view message) {
+	for (const auto byte : message) {
 		// xor next byte to upper bits of crc
-		crc ^= (static_cast<unsigned int>(message[i]) << 24);
-		for (j = 0; j < 8; j++) { // Do eight times.
-			msb = crc >> 31;
+		crc ^= (static_cast<uint32_t>(std::bit_cast<uint8_t>(byte)) << 24);
+		for (size_t _ = 0; _ < 8; _++) { // Do eight times.
+			const uint32_t msb = crc >> 31;
 			crc <<= 1;
 			crc ^= (0 - msb) & 0x04C11DB7;
 		}
 	}
 	return crc; // don't complement crc on output
 }
-
-AssetManager::~AssetManager() {
-	delete m_PackIndex;
-}

dCommon/dClient/AssetManager.h

@@ -61,23 +61,32 @@ struct AssetStream : std::istream {
 class AssetManager {
 public:
 	AssetManager(const std::filesystem::path& path);
-	~AssetManager();
 
-	std::filesystem::path GetResPath();
-	eAssetBundleType GetAssetBundleType();
+	[[nodiscard]]
+	const std::filesystem::path& GetResPath() const {
+		return m_ResPath;
+	}
+	
+	[[nodiscard]]
+	eAssetBundleType GetAssetBundleType() const {
+		return m_AssetBundleType;
+	}
 
-	bool HasFile(const char* name);
-	bool GetFile(const char* name, char** data, uint32_t* len);
-	AssetStream GetFile(const char* name);
+	[[nodiscard]]
+	bool HasFile(std::string name) const;
+
+	[[nodiscard]]
+	bool GetFile(std::string name, char** data, uint32_t* len) const;
+
+	[[nodiscard]]
+	AssetStream GetFile(const char* name) const;
 
 private:
 	void LoadPackIndex();
 
 	// Modified crc algorithm (mpeg2)
 	// Reference: https://stackoverflow.com/questions/54339800/how-to-modify-crc-32-to-crc-32-mpeg-2
-	inline uint32_t crc32b(uint32_t base, uint8_t* message, size_t l);
-
-	bool m_SuccessfullyLoaded;
+	static inline uint32_t crc32b(uint32_t crc, std::string_view message);
 
 	std::filesystem::path m_Path;
 	std::filesystem::path m_RootPath;
@@ -85,5 +94,5 @@ private:
 
 	eAssetBundleType m_AssetBundleType = eAssetBundleType::None;
 
-	PackIndex* m_PackIndex;
+	std::optional<PackIndex> m_PackIndex;
 };

dCommon/dClient/Pack.cpp

@@ -21,19 +21,20 @@ Pack::Pack(const std::filesystem::path& filePath) {
 
 	m_FileStream.seekg(recordCountPos, std::ios::beg);
 
-	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_RecordCount);
+	uint32_t recordCount = 0;
+	BinaryIO::BinaryRead<uint32_t>(m_FileStream, recordCount);
 
-	for (int i = 0; i < m_RecordCount; i++) {
+	m_Records.reserve(recordCount);
+	std::generate_n(std::back_inserter(m_Records), recordCount, [&] {
 		PackRecord record;
 		BinaryIO::BinaryRead<PackRecord>(m_FileStream, record);
-
-		m_Records.push_back(record);
-	}
+		return record;
+	});
 
 	m_FileStream.close();
 }
 
-bool Pack::HasFile(uint32_t crc) {
+bool Pack::HasFile(const uint32_t crc) const {
 	for (const auto& record : m_Records) {
 		if (record.m_Crc == crc) {
 			return true;
@@ -43,7 +44,7 @@ bool Pack::HasFile(uint32_t crc) {
 	return false;
 }
 
-bool Pack::ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) {
+bool Pack::ReadFileFromPack(const uint32_t crc, char** data, uint32_t* len) const {
 	// Time for some wacky C file reading for speed reasons
 
 	PackRecord pkRecord{};

dCommon/dClient/Pack.h

@@ -24,16 +24,17 @@ struct PackRecord {
 class Pack {
 public:
 	Pack(const std::filesystem::path& filePath);
-	~Pack() = default;
 
-	bool HasFile(uint32_t crc);
-	bool ReadFileFromPack(uint32_t crc, char** data, uint32_t* len);
+	[[nodiscard]]
+	bool HasFile(uint32_t crc) const;
+
+	[[nodiscard]]
+	bool ReadFileFromPack(uint32_t crc, char** data, uint32_t* len) const;
 private:
 	std::ifstream m_FileStream;
 	std::filesystem::path m_FilePath;
 
 	char m_Version[7];
 
-	uint32_t m_RecordCount;
 	std::vector<PackRecord> m_Records;
 };

dCommon/dClient/PackIndex.cpp

@@ -6,38 +6,32 @@
 PackIndex::PackIndex(const std::filesystem::path& filePath) {
 	m_FileStream = std::ifstream(filePath / "versions" / "primary.pki", std::ios::in | std::ios::binary);
 
+	uint32_t packPathCount = 0;
 	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_Version);
-	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_PackPathCount);
+	BinaryIO::BinaryRead<uint32_t>(m_FileStream, packPathCount);
 	
-	m_PackPaths.resize(m_PackPathCount);
+	m_PackPaths.resize(packPathCount);
 	for (auto& item : m_PackPaths) {
 		BinaryIO::ReadString<uint32_t>(m_FileStream, item, BinaryIO::ReadType::String);
 	}
 
-	BinaryIO::BinaryRead<uint32_t>(m_FileStream, m_PackFileIndexCount);
+	uint32_t packFileIndexCount = 0;
+	BinaryIO::BinaryRead<uint32_t>(m_FileStream, packFileIndexCount);
 
-	for (int i = 0; i < m_PackFileIndexCount; i++) {
+	m_PackFileIndices.reserve(packFileIndexCount);
+	std::generate_n(std::back_inserter(m_PackFileIndices), packFileIndexCount, [&] {
 		PackFileIndex packFileIndex;
 		BinaryIO::BinaryRead<PackFileIndex>(m_FileStream, packFileIndex);
-
-		m_PackFileIndices.push_back(packFileIndex);
-	}
+		return packFileIndex;
+	});
 
 	LOG("Loaded pack catalog with %i pack files and %i files", m_PackPaths.size(), m_PackFileIndices.size());
 
+	m_Packs.reserve(m_PackPaths.size());
 	for (auto& item : m_PackPaths) {
 		std::replace(item.begin(), item.end(), '\\', '/');
-
-		auto* pack = new Pack(filePath / item);
-
-		m_Packs.push_back(pack);
+		m_Packs.emplace_back(filePath / item);
 	}
 
 	m_FileStream.close();
 }
-
-PackIndex::~PackIndex() {
-	for (const auto* item : m_Packs) {
-		delete item;
-	}
-}

dCommon/dClient/PackIndex.h

@@ -21,20 +21,23 @@ struct PackFileIndex {
 class PackIndex {
 public:
 	PackIndex(const std::filesystem::path& filePath);
-	~PackIndex();
 
-	const std::vector<std::string>& GetPackPaths() { return m_PackPaths; }
-	const std::vector<PackFileIndex>& GetPackFileIndices() { return m_PackFileIndices; }
-	const std::vector<Pack*>& GetPacks() { return m_Packs; }
+	[[nodiscard]]
+	const std::vector<std::string>& GetPackPaths() const { return m_PackPaths; }
+
+	[[nodiscard]]
+	const std::vector<PackFileIndex>& GetPackFileIndices() const { return m_PackFileIndices; }
+
+	[[nodiscard]]
+	const std::vector<Pack>& GetPacks() const { return m_Packs; }
 private:
 	std::ifstream m_FileStream;
 
 	uint32_t m_Version;
 
-	uint32_t m_PackPathCount;
 	std::vector<std::string> m_PackPaths;
-	uint32_t m_PackFileIndexCount;
+
 	std::vector<PackFileIndex> m_PackFileIndices;
 
-	std::vector<Pack*> m_Packs;
+	std::vector<Pack> m_Packs;
 };

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__

dCommon/dEnums/eConnectionType.h

@@ -7,7 +7,8 @@ enum class eConnectionType : uint16_t {
 	CHAT,
 	WORLD = 4,
 	CLIENT,
-	MASTER
+	MASTER,
+	UNKNOWN
 };
 
 #endif  //!__ECONNECTIONTYPE__H__

dCommon/dEnums/eInventoryType.h

@@ -28,7 +28,8 @@ enum eInventoryType : uint32_t {
 	DONATION,
 	VAULT_MODELS,
 	ITEM_SETS, //internal, technically this is BankBehaviors.
-	INVALID // made up, for internal use!!!, Technically this called the ALL inventory.
+	INVALID, // made up, for internal use!!!, Technically this called the ALL inventory.
+	ALL, // Use this to search all inventories instead of a specific one.
 };
 
 class InventoryType {

dDatabase/GameDatabase/ITables/IActivityLog.h

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

dDatabase/GameDatabase/ITables/ICharInfo.h

@@ -44,6 +44,8 @@ public:
 
 	// Updates the given character ids last login to be right now.
 	virtual void UpdateLastLoggedInCharacter(const uint32_t characterId) = 0;
+
+	virtual bool IsNameInUse(const std::string_view name) = 0;
 };
 
 #endif  //!__ICHARINFO__H__

dDatabase/GameDatabase/ITables/IMail.h

@@ -8,27 +8,10 @@
 #include "dCommonVars.h"
 #include "NiQuaternion.h"
 #include "NiPoint3.h"
-
+#include "MailInfo.h"
+ 
 class IMail {
 public:
-	struct MailInfo {
-		std::string senderUsername;
-		std::string recipient;
-		std::string subject;
-		std::string body;
-		uint64_t id{};
-		uint32_t senderId{};
-		uint32_t receiverId{};
-		uint64_t timeSent{};
-		bool wasRead{};
-		struct {
-			LWOOBJID itemID{};
-			int32_t itemCount{};
-			LOT itemLOT{};
-			LWOOBJID itemSubkey{};
-		};
-	};
-
 	// Insert a new mail into the database.
 	virtual void InsertNewMail(const MailInfo& mail) = 0;
 

dDatabase/GameDatabase/MySQL/MySQLDatabase.h

@@ -79,14 +79,14 @@ public:
 	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 IMail::MailInfo& mail) override;
+	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
 		std::istringstream& sd0Data,
 		const uint32_t blueprintId,
 		const uint32_t accountId,
 		const uint32_t characterId) override;
-	std::vector<IMail::MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
-	std::optional<IMail::MailInfo> GetMail(const uint64_t mailId) override;
+	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
 	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
 	void MarkMailRead(const uint64_t mailId) override;
 	void DeleteMail(const uint64_t mailId) override;
@@ -124,8 +124,9 @@ public:
 	void IncrementTimesPlayed(const uint32_t playerId, const uint32_t gameId) override;
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
-	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
 	uint32_t GetAccountCount() override;
+	bool IsNameInUse(const std::string_view name) override;
+	sql::PreparedStatement* CreatePreppedStmt(const std::string& query);
 private:
 
 	// Generic query functions that can be used for any query.

dDatabase/GameDatabase/MySQL/Tables/CharInfo.cpp

@@ -76,3 +76,9 @@ void MySQLDatabase::SetPendingCharacterName(const uint32_t characterId, const st
 void MySQLDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
 	ExecuteUpdate("UPDATE charinfo SET last_login = ? WHERE id = ? LIMIT 1", static_cast<uint32_t>(time(NULL)), characterId);
 }
+
+bool MySQLDatabase::IsNameInUse(const std::string_view name) {
+	auto result = ExecuteSelect("SELECT name FROM charinfo WHERE name = ? or pending_name = ? LIMIT 1;", name, name);
+
+	return result->next();
+}

dDatabase/GameDatabase/MySQL/Tables/Mail.cpp

@@ -1,6 +1,7 @@
 #include "MySQLDatabase.h"
 
-void MySQLDatabase::InsertNewMail(const IMail::MailInfo& mail) {
+
+void MySQLDatabase::InsertNewMail(const MailInfo& mail) {
 	ExecuteInsert(
 		"INSERT INTO `mail` "
 		"(`sender_id`, `sender_name`, `receiver_id`, `receiver_name`, `time_sent`, `subject`, `body`, `attachment_id`, `attachment_lot`, `attachment_subkey`, `attachment_count`, `was_read`)"
@@ -18,17 +19,17 @@ void MySQLDatabase::InsertNewMail(const IMail::MailInfo& mail) {
 		mail.itemCount);
 }
 
-std::vector<IMail::MailInfo> MySQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> MySQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
 	auto res = ExecuteSelect(
 		"SELECT id, subject, body, sender_name, attachment_id, attachment_lot, attachment_subkey, attachment_count, was_read, time_sent"
 		" FROM mail WHERE receiver_id=? limit ?;",
 		characterId, numberOfMail);
 
-	std::vector<IMail::MailInfo> toReturn;
+	std::vector<MailInfo> toReturn;
 	toReturn.reserve(res->rowsCount());
 
 	while (res->next()) {
-		IMail::MailInfo mail;
+		MailInfo mail;
 		mail.id = res->getUInt64("id");
 		mail.subject = res->getString("subject").c_str();
 		mail.body = res->getString("body").c_str();
@@ -46,14 +47,14 @@ std::vector<IMail::MailInfo> MySQLDatabase::GetMailForPlayer(const uint32_t char
 	return toReturn;
 }
 
-std::optional<IMail::MailInfo> MySQLDatabase::GetMail(const uint64_t mailId) {
+std::optional<MailInfo> MySQLDatabase::GetMail(const uint64_t mailId) {
 	auto res = ExecuteSelect("SELECT attachment_lot, attachment_count FROM mail WHERE id=? LIMIT 1;", mailId);
 
 	if (!res->next()) {
 		return std::nullopt;
 	}
 
-	IMail::MailInfo toReturn;
+	MailInfo toReturn;
 	toReturn.itemLOT = res->getInt("attachment_lot");
 	toReturn.itemCount = res->getInt("attachment_count");
 

dDatabase/GameDatabase/SQLite/SQLiteDatabase.h

@@ -77,14 +77,14 @@ public:
 	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 IMail::MailInfo& mail) override;
+	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
 		std::istringstream& sd0Data,
 		const uint32_t blueprintId,
 		const uint32_t accountId,
 		const uint32_t characterId) override;
-	std::vector<IMail::MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
-	std::optional<IMail::MailInfo> GetMail(const uint64_t mailId) override;
+	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
 	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
 	void MarkMailRead(const uint64_t mailId) override;
 	void DeleteMail(const uint64_t mailId) override;
@@ -123,6 +123,7 @@ public:
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override;
 	void DeleteUgcBuild(const LWOOBJID bigId) override;
 	uint32_t GetAccountCount() override;
+	bool IsNameInUse(const std::string_view name) override;
 private:
 	CppSQLite3Statement CreatePreppedStmt(const std::string& query);
 

dDatabase/GameDatabase/SQLite/Tables/CharInfo.cpp

@@ -77,3 +77,9 @@ void SQLiteDatabase::SetPendingCharacterName(const uint32_t characterId, const s
 void SQLiteDatabase::UpdateLastLoggedInCharacter(const uint32_t characterId) {
 	ExecuteUpdate("UPDATE charinfo SET last_login = ? WHERE id = ?;", static_cast<uint32_t>(time(NULL)), characterId);
 }
+
+bool SQLiteDatabase::IsNameInUse(const std::string_view name) {
+	auto [_, result] = ExecuteSelect("SELECT name FROM charinfo WHERE name = ? or pending_name = ? LIMIT 1;", name, name);
+
+	return !result.eof();
+}

dDatabase/GameDatabase/SQLite/Tables/Mail.cpp

@@ -1,6 +1,6 @@
 #include "SQLiteDatabase.h"
 
-void SQLiteDatabase::InsertNewMail(const IMail::MailInfo& mail) {
+void SQLiteDatabase::InsertNewMail(const MailInfo& mail) {
 	ExecuteInsert(
 		"INSERT INTO `mail` "
 		"(`sender_id`, `sender_name`, `receiver_id`, `receiver_name`, `time_sent`, `subject`, `body`, `attachment_id`, `attachment_lot`, `attachment_subkey`, `attachment_count`, `was_read`)"
@@ -18,16 +18,16 @@ void SQLiteDatabase::InsertNewMail(const IMail::MailInfo& mail) {
 		mail.itemCount);
 }
 
-std::vector<IMail::MailInfo> SQLiteDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> SQLiteDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
 	auto [_, res] = ExecuteSelect(
 		"SELECT id, subject, body, sender_name, attachment_id, attachment_lot, attachment_subkey, attachment_count, was_read, time_sent"
 		" FROM mail WHERE receiver_id=? limit ?;",
 		characterId, numberOfMail);
 
-	std::vector<IMail::MailInfo> toReturn;
+	std::vector<MailInfo> toReturn;
 
 	while (!res.eof()) {
-		IMail::MailInfo mail;
+		MailInfo mail;
 		mail.id = res.getInt64Field("id");
 		mail.subject = res.getStringField("subject");
 		mail.body = res.getStringField("body");
@@ -46,14 +46,14 @@ std::vector<IMail::MailInfo> SQLiteDatabase::GetMailForPlayer(const uint32_t cha
 	return toReturn;
 }
 
-std::optional<IMail::MailInfo> SQLiteDatabase::GetMail(const uint64_t mailId) {
+std::optional<MailInfo> SQLiteDatabase::GetMail(const uint64_t mailId) {
 	auto [_, res] = ExecuteSelect("SELECT attachment_lot, attachment_count FROM mail WHERE id=? LIMIT 1;", mailId);
 
 	if (res.eof()) {
 		return std::nullopt;
 	}
 
-	IMail::MailInfo toReturn;
+	MailInfo toReturn;
 	toReturn.itemLOT = res.getIntField("attachment_lot");
 	toReturn.itemCount = res.getIntField("attachment_count");
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.cpp

@@ -184,7 +184,7 @@ void TestSQLDatabase::InsertCheatDetection(const IPlayerCheatDetections::Info& i
 
 }
 
-void TestSQLDatabase::InsertNewMail(const IMail::MailInfo& mail) {
+void TestSQLDatabase::InsertNewMail(const MailInfo& mail) {
 
 }
 
@@ -192,11 +192,11 @@ void TestSQLDatabase::InsertNewUgcModel(std::istringstream& sd0Data, const uint3
 
 }
 
-std::vector<IMail::MailInfo> TestSQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
+std::vector<MailInfo> TestSQLDatabase::GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) {
 	return {};
 }
 
-std::optional<IMail::MailInfo> TestSQLDatabase::GetMail(const uint64_t mailId) {
+std::optional<MailInfo> TestSQLDatabase::GetMail(const uint64_t mailId) {
 	return {};
 }
 

dDatabase/GameDatabase/TestSQL/TestSQLDatabase.h

@@ -56,14 +56,14 @@ class TestSQLDatabase : public GameDatabase {
 	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 IMail::MailInfo& mail) override;
+	void InsertNewMail(const MailInfo& mail) override;
 	void InsertNewUgcModel(
 		std::istringstream& sd0Data,
 		const uint32_t blueprintId,
 		const uint32_t accountId,
 		const uint32_t characterId) override;
-	std::vector<IMail::MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
-	std::optional<IMail::MailInfo> GetMail(const uint64_t mailId) override;
+	std::vector<MailInfo> GetMailForPlayer(const uint32_t characterId, const uint32_t numberOfMail) override;
+	std::optional<MailInfo> GetMail(const uint64_t mailId) override;
 	uint32_t GetUnreadMailCount(const uint32_t characterId) override;
 	void MarkMailRead(const uint64_t mailId) override;
 	void DeleteMail(const uint64_t mailId) override;
@@ -102,6 +102,8 @@ class TestSQLDatabase : public GameDatabase {
 	void InsertUgcBuild(const std::string& modules, const LWOOBJID bigId, const std::optional<uint32_t> characterId) override {};
 	void DeleteUgcBuild(const LWOOBJID bigId) override {};
 	uint32_t GetAccountCount() override { return 0; };
+
+	bool IsNameInUse(const std::string_view name) override { return false; };
 };
 
 #endif  //!TESTSQLDATABASE_H

dGame/UserManager.cpp

@@ -305,13 +305,13 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 	LOT shirtLOT = FindCharShirtID(shirtColor, shirtStyle);
 	LOT pantsLOT = FindCharPantsID(pantsColor);
 
-	if (!name.empty() && Database::Get()->GetCharacterInfo(name)) {
+	if (!name.empty() && Database::Get()->IsNameInUse(name)) {
 		LOG("AccountID: %i chose unavailable name: %s", u->GetAccountID(), name.c_str());
 		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::CUSTOM_NAME_IN_USE);
 		return;
 	}
 
-	if (Database::Get()->GetCharacterInfo(predefinedName)) {
+	if (Database::Get()->IsNameInUse(predefinedName)) {
 		LOG("AccountID: %i chose unavailable predefined name: %s", u->GetAccountID(), predefinedName.c_str());
 		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::PREDEFINED_NAME_IN_USE);
 		return;
@@ -324,7 +324,7 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 	}
 
 	//Now that the name is ok, we can get an objectID from Master:
-	ObjectIDManager::RequestPersistentID([=, this](uint32_t objectID) mutable {
+	ObjectIDManager::RequestPersistentID([=, this](uint32_t objectID) {
 		if (Database::Get()->GetCharacterInfo(objectID)) {
 			LOG("Character object id unavailable, check object_id_tracker!");
 			WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE);
@@ -369,13 +369,14 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 		// If predefined name is invalid, change it to be their object id
 		// that way more than one player can create characters if the predefined name files are not provided
-		if (predefinedName == "INVALID") {
+		auto assignedPredefinedName = predefinedName;
+		if (assignedPredefinedName == "INVALID") {
 			std::stringstream nameObjID;
 			nameObjID << "minifig" << objectID;
-			predefinedName = nameObjID.str();
+			assignedPredefinedName = nameObjID.str();
 		}
 
-		std::string_view nameToAssign = !name.empty() && nameOk ? name : predefinedName;
+		std::string_view nameToAssign = !name.empty() && nameOk ? name : assignedPredefinedName;
 		std::string pendingName = !name.empty() && !nameOk ? name : "";
 
 		ICharInfo::Info info;

dGame/dComponents/CharacterComponent.cpp

@@ -828,7 +828,7 @@ void CharacterComponent::AwardClaimCodes() {
 		subject << "%[RewardCodes_" << rewardCode << "_subjectText]";
 		std::ostringstream body;
 		body << "%[RewardCodes_" << rewardCode << "_bodyText]";
-		Mail::SendMail(LWOOBJID_EMPTY, "%[MAIL_SYSTEM_NOTIFICATION]", m_Parent, subject.str(), body.str(), attachmentLOT, 1);
+		Mail::SendMail(m_Parent, subject.str(), body.str(), attachmentLOT, 1);
 	}
 }
 

dGame/dComponents/InventoryComponent.cpp

@@ -150,11 +150,11 @@ uint32_t InventoryComponent::GetLotCount(const LOT lot) const {
 	return count;
 }
 
-uint32_t InventoryComponent::GetLotCountNonTransfer(LOT lot) const {
+uint32_t InventoryComponent::GetLotCountNonTransfer(LOT lot, bool includeVault) const {
 	uint32_t count = 0;
 
 	for (const auto& inventory : m_Inventories) {
-		if (IsTransferInventory(inventory.second->GetType())) continue;
+		if (IsTransferInventory(inventory.second->GetType(), includeVault)) continue;
 
 		count += inventory.second->GetLotCount(lot);
 	}
@@ -274,7 +274,7 @@ void InventoryComponent::AddItem(
 
 			switch (sourceType) {
 			case 0:
-				Mail::SendMail(LWOOBJID_EMPTY, "Darkflame Universe", m_Parent, "Lost Reward", "You received an item and didn't have room for it.", lot, size);
+				Mail::SendMail(m_Parent, "%[MAIL_ACTIVITY_OVERFLOW_HEADER]", "%[MAIL_ACTIVITY_OVERFLOW_BODY]", lot, size);
 				break;
 
 			case 1:
@@ -305,21 +305,35 @@ bool InventoryComponent::RemoveItem(const LOT lot, const uint32_t count, eInvent
 		LOG("Attempted to remove 0 of item (%i) from the inventory!", lot);
 		return false;
 	}
-	if (inventoryType == INVALID) inventoryType = Inventory::FindInventoryTypeForLot(lot);
-	auto* inventory = GetInventory(inventoryType);
-	if (!inventory) return false;
+	if (inventoryType != eInventoryType::ALL) {
+		if (inventoryType == INVALID) inventoryType = Inventory::FindInventoryTypeForLot(lot);
+		auto* inventory = GetInventory(inventoryType);
+		if (!inventory) return false;
 
-	auto left = std::min<uint32_t>(count, inventory->GetLotCount(lot));
-	if (left != count) return false;
+		auto left = std::min<uint32_t>(count, inventory->GetLotCount(lot));
+		if (left != count) return false;
 
-	while (left > 0) {
-		auto* item = FindItemByLot(lot, inventoryType, false, ignoreBound);
-		if (!item) break;
-		const auto delta = std::min<uint32_t>(left, item->GetCount());
-		item->SetCount(item->GetCount() - delta, silent);
-		left -= delta;
+		while (left > 0) {
+			auto* item = FindItemByLot(lot, inventoryType, false, ignoreBound);
+			if (!item) break;
+			const auto delta = std::min<uint32_t>(left, item->GetCount());
+			item->SetCount(item->GetCount() - delta, silent);
+			left -= delta;
+		}
+		return true;
+	} else {
+		auto left = count;
+		for (const auto& inventory : m_Inventories | std::views::values) {
+			while (left > 0 && inventory->GetLotCount(lot) > 0) {
+				auto* item = inventory->FindItemByLot(lot, false, ignoreBound);
+				if (!item) break;
+				const auto delta = std::min<uint32_t>(item->GetCount(), left);
+				item->SetCount(item->GetCount() - delta, silent);
+				left -= delta;
+			}
+		}
+		return left == 0;
 	}
-	return true;
 }
 
 void InventoryComponent::MoveItemToInventory(Item* item, const eInventoryType inventory, const uint32_t count, const bool showFlyingLot, bool isModMoveAndEquip, const bool ignoreEquipped, const int32_t preferredSlot) {
@@ -1318,8 +1332,8 @@ BehaviorSlot InventoryComponent::FindBehaviorSlot(const eItemType type) {
 	}
 }
 
-bool InventoryComponent::IsTransferInventory(eInventoryType type) {
-	return type == VENDOR_BUYBACK || type == VAULT_ITEMS || type == VAULT_MODELS || type == TEMP_ITEMS || type == TEMP_MODELS || type == MODELS_IN_BBB;
+bool InventoryComponent::IsTransferInventory(eInventoryType type, bool includeVault) {
+	return type == VENDOR_BUYBACK || (includeVault && (type == VAULT_ITEMS || type == VAULT_MODELS)) || type == TEMP_ITEMS || type == TEMP_MODELS || type == MODELS_IN_BBB;
 }
 
 uint32_t InventoryComponent::FindSkill(const LOT lot) {

dGame/dComponents/InventoryComponent.h

@@ -100,7 +100,7 @@ public:
 	 * @param lot the lot to search for
 	 * @return the amount of items this entity possesses of the specified lot
 	 */
-	uint32_t GetLotCountNonTransfer(LOT lot) const;
+	uint32_t GetLotCountNonTransfer(LOT lot, bool includeVault = true) const;
 
 	/**
 	 * Returns the items that are currently equipped by this entity
@@ -373,7 +373,7 @@ public:
 	 * @param type the inventory type to check
 	 * @return if the inventory type is a temp inventory
 	 */
-	static bool IsTransferInventory(eInventoryType type);
+	static bool IsTransferInventory(eInventoryType type, bool includeVault = true);
 
 	/**
 	 * Finds the skill related to the passed LOT from the ObjectSkills table

dGame/dComponents/MissionComponent.cpp

@@ -99,17 +99,8 @@ void MissionComponent::AcceptMission(const uint32_t missionId, const bool skipCh
 	mission->Accept();
 
 	this->m_Missions.insert_or_assign(missionId, mission);
-
-	if (missionId == 1728) {
-		//Needs to send a mail
-
-		auto address = m_Parent->GetSystemAddress();
-
-		Mail::HandleNotificationRequest(address, m_Parent->GetObjectID());
-	}
 }
 
-
 void MissionComponent::CompleteMission(const uint32_t missionId, const bool skipChecks, const bool yieldRewards) {
 	// Get the mission first
 	auto* mission = this->GetMission(missionId);
@@ -521,7 +512,7 @@ void MissionComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 
 		auto* mission = new Mission(this, missionId);
 
-		mission->LoadFromXml(*doneM);
+		mission->LoadFromXmlDone(*doneM);
 
 		doneM = doneM->NextSiblingElement();
 
@@ -536,9 +527,9 @@ void MissionComponent::LoadFromXml(const tinyxml2::XMLDocument& doc) {
 
 		currentM->QueryAttribute("id", &missionId);
 
-		auto* mission = new Mission(this, missionId);
+		auto* mission = m_Missions.contains(missionId) ? m_Missions[missionId] : new Mission(this, missionId);
 
-		mission->LoadFromXml(*currentM);
+		mission->LoadFromXmlCur(*currentM);
 
 		if (currentM->QueryAttribute("o", &missionOrder) == tinyxml2::XML_SUCCESS && mission->IsMission()) {
 			mission->SetUniqueMissionOrderID(missionOrder);
@@ -574,20 +565,23 @@ void MissionComponent::UpdateXml(tinyxml2::XMLDocument& doc) {
 		auto* mission = pair.second;
 
 		if (mission) {
-			const auto complete = mission->IsComplete();
+			const auto completions = mission->GetCompletions();
 
 			auto* m = doc.NewElement("m");
 
-			if (complete) {
-				mission->UpdateXml(*m);
+			if (completions > 0) {
+				mission->UpdateXmlDone(*m);
 
 				done->LinkEndChild(m);
 
-				continue;
+				if (mission->IsComplete()) continue;
+
+				m = doc.NewElement("m");
 			}
+
 			if (mission->IsMission()) m->SetAttribute("o", mission->GetUniqueMissionOrderID());
 
-			mission->UpdateXml(*m);
+			mission->UpdateXmlCur(*m);
 
 			cur->LinkEndChild(m);
 		}

dGame/dMission/Mission.cpp

@@ -65,7 +65,7 @@ Mission::Mission(MissionComponent* missionComponent, const uint32_t missionId) {
 	}
 }
 
-void Mission::LoadFromXml(const tinyxml2::XMLElement& element) {
+void Mission::LoadFromXmlDone(const tinyxml2::XMLElement& element) {
 	// Start custom XML
 	if (element.Attribute("state") != nullptr) {
 		m_State = static_cast<eMissionState>(std::stoul(element.Attribute("state")));
@@ -76,11 +76,15 @@ void Mission::LoadFromXml(const tinyxml2::XMLElement& element) {
 		m_Completions = std::stoul(element.Attribute("cct"));
 
 		m_Timestamp = std::stoul(element.Attribute("cts"));
-
-		if (IsComplete()) {
-			return;
-		}
 	}
+}
+
+void Mission::LoadFromXmlCur(const tinyxml2::XMLElement& element) {
+	// Start custom XML
+	if (element.Attribute("state") != nullptr) {
+		m_State = static_cast<eMissionState>(std::stoul(element.Attribute("state")));
+	}
+	// End custom XML
 
 	auto* task = element.FirstChildElement();
 
@@ -132,7 +136,7 @@ void Mission::LoadFromXml(const tinyxml2::XMLElement& element) {
 	}
 }
 
-void Mission::UpdateXml(tinyxml2::XMLElement& element) {
+void Mission::UpdateXmlDone(tinyxml2::XMLElement& element) {
 	// Start custom XML
 	element.SetAttribute("state", static_cast<unsigned int>(m_State));
 	// End custom XML
@@ -141,15 +145,21 @@ void Mission::UpdateXml(tinyxml2::XMLElement& element) {
 
 	element.SetAttribute("id", static_cast<unsigned int>(info.id));
 
-	if (m_Completions > 0) {
-		element.SetAttribute("cct", static_cast<unsigned int>(m_Completions));
+	element.SetAttribute("cct", static_cast<unsigned int>(m_Completions));
 
-		element.SetAttribute("cts", static_cast<unsigned int>(m_Timestamp));
+	element.SetAttribute("cts", static_cast<unsigned int>(m_Timestamp));
+}
 
-		if (IsComplete()) {
-			return;
-		}
-	}
+void Mission::UpdateXmlCur(tinyxml2::XMLElement& element) {
+	// Start custom XML
+	element.SetAttribute("state", static_cast<unsigned int>(m_State));
+	// End custom XML
+
+	element.DeleteChildren();
+
+	element.SetAttribute("id", static_cast<unsigned int>(info.id));
+
+	if (IsComplete()) return;
 
 	for (auto* task : m_Tasks) {
 		if (task->GetType() == eMissionTaskType::COLLECTION ||

dGame/dMission/Mission.h

@@ -28,8 +28,13 @@ public:
 	Mission(MissionComponent* missionComponent, uint32_t missionId);
 	~Mission();
 
-	void LoadFromXml(const tinyxml2::XMLElement& element);
-	void UpdateXml(tinyxml2::XMLElement& element);
+	// XML functions to load and save completed mission state to xml
+	void LoadFromXmlDone(const tinyxml2::XMLElement& element);
+	void UpdateXmlDone(tinyxml2::XMLElement& element);
+
+	// XML functions to load and save current mission state and task data to xml
+	void LoadFromXmlCur(const tinyxml2::XMLElement& element);
+	void UpdateXmlCur(tinyxml2::XMLElement& element);
 
 	/**
 	 * Returns the ID of this mission

dGame/dUtilities/Mail.cpp

@@ -26,12 +26,279 @@
 #include "eMissionTaskType.h"
 #include "eReplicaComponentType.h"
 #include "eConnectionType.h"
+#include "User.h"
+#include "StringifiedEnum.h"
+
+namespace {
+	const std::string DefaultSender = "%[MAIL_SYSTEM_NOTIFICATION]";
+}
+
+namespace Mail {
+	std::map<eMessageID, std::function<std::unique_ptr<MailLUBitStream>()>> g_Handlers = {
+		{eMessageID::SendRequest, []() {
+			return std::make_unique<SendRequest>();
+		}},
+		{eMessageID::DataRequest, []() {
+			return std::make_unique<DataRequest>();
+		}},
+		{eMessageID::AttachmentCollectRequest, []() {
+			return std::make_unique<AttachmentCollectRequest>();
+		}},
+		{eMessageID::DeleteRequest, []() {
+			return std::make_unique<DeleteRequest>();
+		}},
+		{eMessageID::ReadRequest, []() {
+			return std::make_unique<ReadRequest>();
+		}},
+		{eMessageID::NotificationRequest, []() {
+			return std::make_unique<NotificationRequest>();
+		}},
+	};
+
+	void MailLUBitStream::Serialize(RakNet::BitStream& bitStream) const {
+		bitStream.Write(messageID);
+	}
+
+	bool MailLUBitStream::Deserialize(RakNet::BitStream& bitstream) {
+		VALIDATE_READ(bitstream.Read(messageID));
+		return true;
+	}
+
+	bool SendRequest::Deserialize(RakNet::BitStream& bitStream) {
+		VALIDATE_READ(mailInfo.Deserialize(bitStream));
+		return true;
+	}
+
+	void SendRequest::Handle() {
+		SendResponse response;
+		auto* character = player->GetCharacter();
+		if (character && !(character->HasPermission(ePermissionMap::RestrictedMailAccess) || character->GetParentUser()->GetIsMuted())) {
+			mailInfo.recipient = std::regex_replace(mailInfo.recipient, std::regex("[^0-9a-zA-Z]+"), "");
+			auto receiverID = Database::Get()->GetCharacterInfo(mailInfo.recipient);
+
+			if (!receiverID) {
+				response.status = eSendResponse::RecipientNotFound;
+			} else if (GeneralUtils::CaseInsensitiveStringCompare(mailInfo.recipient, character->GetName()) || receiverID->id == character->GetID()) {
+				response.status = eSendResponse::CannotMailSelf;
+			} else {
+				uint32_t mailCost = Game::zoneManager->GetWorldConfig()->mailBaseFee;
+				uint32_t stackSize = 0;
+				
+				auto inventoryComponent = player->GetComponent<InventoryComponent>();
+				Item* item = nullptr;
+
+				bool hasAttachment = mailInfo.itemID != 0 && mailInfo.itemCount > 0;
+
+				if (hasAttachment) {
+					item = inventoryComponent->FindItemById(mailInfo.itemID);
+					if (item) {
+						mailCost += (item->GetInfo().baseValue * Game::zoneManager->GetWorldConfig()->mailPercentAttachmentFee);
+						mailInfo.itemLOT = item->GetLot();
+					}
+				}
+
+				if (hasAttachment && !item) {
+					response.status = eSendResponse::AttachmentNotFound;
+				} else if (player->GetCharacter()->GetCoins() - mailCost < 0) {
+					response.status = eSendResponse::NotEnoughCoins;
+				} else {
+					bool removeSuccess = true;
+					// Remove coins and items from the sender
+					player->GetCharacter()->SetCoins(player->GetCharacter()->GetCoins() - mailCost, eLootSourceType::MAIL);
+					if (inventoryComponent && hasAttachment && item) {
+						removeSuccess = inventoryComponent->RemoveItem(mailInfo.itemLOT, mailInfo.itemCount, INVALID, true);
+						auto* missionComponent = player->GetComponent<MissionComponent>();
+						if (missionComponent && removeSuccess) missionComponent->Progress(eMissionTaskType::GATHER, mailInfo.itemLOT, LWOOBJID_EMPTY, "", -mailInfo.itemCount);
+					}
+
+					// we passed all the checks, now we can actully send the mail
+					if (removeSuccess) {
+						mailInfo.senderId = character->GetID();
+						mailInfo.senderUsername = character->GetName();
+						mailInfo.receiverId = receiverID->id;
+						mailInfo.itemSubkey = LWOOBJID_EMPTY;
+
+						//clear out the attachementID
+						mailInfo.itemID = 0;
+
+						Database::Get()->InsertNewMail(mailInfo);
+						response.status = eSendResponse::Success;
+						character->SaveXMLToDatabase(); 
+					} else {
+						response.status = eSendResponse::AttachmentNotFound;
+					}
+				}
+			}
+		} else {
+			response.status = eSendResponse::SenderAccountIsMuted;
+		}
+		response.Send(sysAddr);
+	}
+
+	void SendResponse::Serialize(RakNet::BitStream& bitStream) const {
+		MailLUBitStream::Serialize(bitStream);
+		bitStream.Write(status);
+	}
+
+	void NotificationResponse::Serialize(RakNet::BitStream& bitStream) const {
+		MailLUBitStream::Serialize(bitStream);
+		bitStream.Write(status);
+		bitStream.Write<uint64_t>(0); // unused
+		bitStream.Write<uint64_t>(0); // unused
+		bitStream.Write(auctionID);
+		bitStream.Write<uint64_t>(0); // unused
+		bitStream.Write(mailCount);
+		bitStream.Write<uint32_t>(0); // packing
+	}
+
+	void DataRequest::Handle() {
+		const auto* character = player->GetCharacter();
+		if (!character) return;
+		auto playerMail = Database::Get()->GetMailForPlayer(character->GetID(), 20);
+		DataResponse response;
+		response.playerMail = playerMail;
+		response.Send(sysAddr);
+	}
+
+	void DataResponse::Serialize(RakNet::BitStream& bitStream) const {
+		MailLUBitStream::Serialize(bitStream);
+		bitStream.Write(this->throttled);
+	
+		bitStream.Write<uint16_t>(this->playerMail.size());
+		bitStream.Write<uint16_t>(0); // packing
+		for (const auto& mail : this->playerMail) {
+			mail.Serialize(bitStream);
+		}
+	}
+
+	bool AttachmentCollectRequest::Deserialize(RakNet::BitStream& bitStream) {
+		uint32_t unknown;
+		VALIDATE_READ(bitStream.Read(unknown));
+		VALIDATE_READ(bitStream.Read(mailID));
+		VALIDATE_READ(bitStream.Read(playerID));
+		return true;
+	}
+
+	void AttachmentCollectRequest::Handle() {
+		AttachmentCollectResponse response;
+		response.mailID = mailID;
+		auto inv = player->GetComponent<InventoryComponent>();
+
+		if (mailID > 0 && playerID == player->GetObjectID() && inv) {
+			auto playerMail = Database::Get()->GetMail(mailID);
+			if (!playerMail) {
+				response.status = eAttachmentCollectResponse::MailNotFound;
+			} else if (!inv->HasSpaceForLoot({ {playerMail->itemLOT, playerMail->itemCount} })) {
+				response.status = eAttachmentCollectResponse::NoSpaceInInventory;
+			} else {
+				inv->AddItem(playerMail->itemLOT, playerMail->itemCount, eLootSourceType::MAIL);
+				Database::Get()->ClaimMailItem(mailID);
+				response.status = eAttachmentCollectResponse::Success;
+			}
+		}
+		response.Send(sysAddr);
+	}
+
+	void AttachmentCollectResponse::Serialize(RakNet::BitStream& bitStream) const {
+		MailLUBitStream::Serialize(bitStream);
+		bitStream.Write(status);
+		bitStream.Write(mailID);
+	}
+
+	bool DeleteRequest::Deserialize(RakNet::BitStream& bitStream) {
+		int32_t unknown;
+		VALIDATE_READ(bitStream.Read(unknown));
+		VALIDATE_READ(bitStream.Read(mailID));
+		VALIDATE_READ(bitStream.Read(playerID));
+		return true;
+	}
+
+	void DeleteRequest::Handle() {
+		DeleteResponse response;
+		response.mailID = mailID;
+
+		auto mailData = Database::Get()->GetMail(mailID);
+		if (mailData && !(mailData->itemLOT != 0 && mailData->itemCount > 0)) {
+			Database::Get()->DeleteMail(mailID);
+			response.status = eDeleteResponse::Success;
+		} else if (mailData && mailData->itemLOT != 0 && mailData->itemCount > 0) {
+			response.status = eDeleteResponse::HasAttachments;
+		} else {
+			response.status = eDeleteResponse::NotFound;
+		}
+		response.Send(sysAddr);
+	}
+
+	void DeleteResponse::Serialize(RakNet::BitStream& bitStream) const {
+		MailLUBitStream::Serialize(bitStream);
+		bitStream.Write(status);
+		bitStream.Write(mailID);
+	}
+
+	bool ReadRequest::Deserialize(RakNet::BitStream& bitStream) {
+		int32_t unknown;
+		VALIDATE_READ(bitStream.Read(unknown));
+		VALIDATE_READ(bitStream.Read(mailID));
+		return true;
+	}
+
+	void ReadRequest::Handle() {
+		ReadResponse response;
+		response.mailID = mailID;
+
+		if (Database::Get()->GetMail(mailID)) {
+			response.status = eReadResponse::Success;
+			Database::Get()->MarkMailRead(mailID);
+		}	
+		response.Send(sysAddr);
+	}
+
+	void ReadResponse::Serialize(RakNet::BitStream& bitStream) const {
+		MailLUBitStream::Serialize(bitStream);
+		bitStream.Write(status);
+		bitStream.Write(mailID);
+	}
+
+	void NotificationRequest::Handle() {
+		NotificationResponse response;
+		auto character = player->GetCharacter();
+		if (character) {
+			auto unreadMailCount = Database::Get()->GetUnreadMailCount(character->GetID());
+			response.status = eNotificationResponse::NewMail;
+			response.mailCount = unreadMailCount;
+		}
+		response.Send(sysAddr);
+	}
+}
+
+// Non Stuct Functions
+void Mail::HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player) {
+	MailLUBitStream data;
+	if (!data.Deserialize(inStream)) {
+		LOG_DEBUG("Error Reading Mail header");
+		return;
+	}
+
+	auto it = g_Handlers.find(data.messageID);
+	if (it != g_Handlers.end()) {
+		auto request = it->second();
+		request->sysAddr = sysAddr;
+		request->player = player;
+		if (!request->Deserialize(inStream)) {
+			LOG_DEBUG("Error Reading Mail Request: %s", StringifiedEnum::ToString(data.messageID).data());
+			return;
+		}
+		request->Handle();
+	} else {
+		LOG_DEBUG("Unhandled Mail Request with ID: %i", data.messageID);
+	}
+}
 
 void Mail::SendMail(const Entity* recipient, const std::string& subject, const std::string& body, const LOT attachment,
 	const uint16_t attachmentCount) {
 	SendMail(
 		LWOOBJID_EMPTY,
-		ServerName,
+		DefaultSender,
 		recipient->GetObjectID(),
 		recipient->GetCharacter()->GetName(),
 		subject,
@@ -46,7 +313,7 @@ void Mail::SendMail(const LWOOBJID recipient, const std::string& recipientName,
 	const std::string& body, const LOT attachment, const uint16_t attachmentCount, const SystemAddress& sysAddr) {
 	SendMail(
 		LWOOBJID_EMPTY,
-		ServerName,
+		DefaultSender,
 		recipient,
 		recipientName,
 		subject,
@@ -75,7 +342,7 @@ void Mail::SendMail(const LWOOBJID sender, const std::string& senderName, const
 void Mail::SendMail(const LWOOBJID sender, const std::string& senderName, LWOOBJID recipient,
 	const std::string& recipientName, const std::string& subject, const std::string& body, const LOT attachment,
 	const uint16_t attachmentCount, const SystemAddress& sysAddr) {
-	IMail::MailInfo mailInsert;
+	MailInfo mailInsert;
 	mailInsert.senderUsername = senderName;
 	mailInsert.recipient = recipientName;
 	mailInsert.subject = subject;
@@ -90,316 +357,7 @@ void Mail::SendMail(const LWOOBJID sender, const std::string& senderName, LWOOBJ
 	Database::Get()->InsertNewMail(mailInsert);
 
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) return; // TODO: Echo to chat server
-
-	SendNotification(sysAddr, 1); //Show the "one new mail" message
-}
-
-void Mail::HandleMailStuff(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* entity) {
-	int mailStuffID = 0;
-	packet.Read(mailStuffID);
-
-	auto returnVal = std::async(std::launch::async, [&packet, &sysAddr, entity, mailStuffID]() {
-		Mail::MailMessageID stuffID = MailMessageID(mailStuffID);
-		switch (stuffID) {
-		case MailMessageID::AttachmentCollect:
-			Mail::HandleAttachmentCollect(packet, sysAddr, entity);
-			break;
-		case MailMessageID::DataRequest:
-			Mail::HandleDataRequest(packet, sysAddr, entity);
-			break;
-		case MailMessageID::MailDelete:
-			Mail::HandleMailDelete(packet, sysAddr);
-			break;
-		case MailMessageID::MailRead:
-			Mail::HandleMailRead(packet, sysAddr);
-			break;
-		case MailMessageID::NotificationRequest:
-			Mail::HandleNotificationRequest(sysAddr, entity->GetObjectID());
-			break;
-		case MailMessageID::Send:
-			Mail::HandleSendMail(packet, sysAddr, entity);
-			break;
-		default:
-			LOG("Unhandled and possibly undefined MailStuffID: %i", int(stuffID));
-		}
-		});
-}
-
-void Mail::HandleSendMail(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* entity) {
-	//std::string subject = GeneralUtils::WStringToString(ReadFromPacket(packet, 50));
-	//std::string body = GeneralUtils::WStringToString(ReadFromPacket(packet, 400));
-	//std::string recipient = GeneralUtils::WStringToString(ReadFromPacket(packet, 32));
-
-	// Check if the player has restricted mail access
-	auto* character = entity->GetCharacter();
-
-	if (!character) return;
-
-	if (character->HasPermission(ePermissionMap::RestrictedMailAccess)) {
-		// Send a message to the player
-		ChatPackets::SendSystemMessage(
-			sysAddr,
-			u"This character has restricted mail access."
-		);
-
-		Mail::SendSendResponse(sysAddr, Mail::MailSendResponse::AccountIsMuted);
-
-		return;
-	}
-
-	LUWString subjectRead(50);
-	packet.Read(subjectRead);
-
-	LUWString bodyRead(400);
-	packet.Read(bodyRead);
-
-	LUWString recipientRead(32);
-	packet.Read(recipientRead);
-
-	const std::string subject = subjectRead.GetAsString();
-	const std::string body = bodyRead.GetAsString();
-
-	//Cleanse recipient:
-	const std::string recipient = std::regex_replace(recipientRead.GetAsString(), std::regex("[^0-9a-zA-Z]+"), "");
-
-	uint64_t unknown64 = 0;
-	LWOOBJID attachmentID;
-	uint16_t attachmentCount;
-
-	packet.Read(unknown64);
-	packet.Read(attachmentID);
-	packet.Read(attachmentCount); //We don't care about the rest of the packet.
-	uint32_t itemID = static_cast<uint32_t>(attachmentID);
-	LOT itemLOT = 0;
-	//Inventory::InventoryType itemType;
-	int mailCost = Game::zoneManager->GetWorldConfig()->mailBaseFee;
-	int stackSize = 0;
-	auto inv = static_cast<InventoryComponent*>(entity->GetComponent(eReplicaComponentType::INVENTORY));
-	Item* item = nullptr;
-
-	if (itemID > 0 && attachmentCount > 0 && inv) {
-		item = inv->FindItemById(attachmentID);
-		if (item) {
-			mailCost += (item->GetInfo().baseValue * Game::zoneManager->GetWorldConfig()->mailPercentAttachmentFee);
-			stackSize = item->GetCount();
-			itemLOT = item->GetLot();
-		} else {
-			Mail::SendSendResponse(sysAddr, MailSendResponse::AttachmentNotFound);
-			return;
-		}
-	}
-
-	//Check if we can even send this mail (negative coins bug):
-	if (entity->GetCharacter()->GetCoins() - mailCost < 0) {
-		Mail::SendSendResponse(sysAddr, MailSendResponse::NotEnoughCoins);
-		return;
-	}
-
-	//Get the receiver's id:
-	auto receiverID = Database::Get()->GetCharacterInfo(recipient);
-
-	if (!receiverID) {
-		Mail::SendSendResponse(sysAddr, Mail::MailSendResponse::RecipientNotFound);
-		return;
-	}
-
-	//Check if we have a valid receiver:
-	if (GeneralUtils::CaseInsensitiveStringCompare(recipient, character->GetName()) || receiverID->id == character->GetID()) {
-		Mail::SendSendResponse(sysAddr, Mail::MailSendResponse::CannotMailSelf);
-		return;
-	} else {
-		IMail::MailInfo mailInsert;
-		mailInsert.senderUsername = character->GetName();
-		mailInsert.recipient = recipient;
-		mailInsert.subject = subject;
-		mailInsert.body = body;
-		mailInsert.senderId = character->GetID();
-		mailInsert.receiverId = receiverID->id;
-		mailInsert.itemCount = attachmentCount;
-		mailInsert.itemID = itemID;
-		mailInsert.itemLOT = itemLOT;
-		mailInsert.itemSubkey = LWOOBJID_EMPTY;
-		Database::Get()->InsertNewMail(mailInsert);
-	}
-
-	Mail::SendSendResponse(sysAddr, Mail::MailSendResponse::Success);
-	entity->GetCharacter()->SetCoins(entity->GetCharacter()->GetCoins() - mailCost, eLootSourceType::MAIL);
-
-	LOG("Seeing if we need to remove item with ID/count/LOT: %i %i %i", itemID, attachmentCount, itemLOT);
-
-	if (inv && itemLOT != 0 && attachmentCount > 0 && item) {
-		LOG("Trying to remove item with ID/count/LOT: %i %i %i", itemID, attachmentCount, itemLOT);
-		inv->RemoveItem(itemLOT, attachmentCount, INVALID, true);
-
-		auto* missionCompoent = entity->GetComponent<MissionComponent>();
-
-		if (missionCompoent != nullptr) {
-			missionCompoent->Progress(eMissionTaskType::GATHER, itemLOT, LWOOBJID_EMPTY, "", -attachmentCount);
-		}
-	}
-
-	character->SaveXMLToDatabase();
-}
-
-void Mail::HandleDataRequest(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* player) {
-	auto playerMail = Database::Get()->GetMailForPlayer(player->GetCharacter()->GetID(), 20);
-
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
-	bitStream.Write(int(MailMessageID::MailData));
-	bitStream.Write(int(0)); // throttled
-
-	bitStream.Write<uint16_t>(playerMail.size()); // size
-	bitStream.Write<uint16_t>(0);
-
-	for (const auto& mail : playerMail) {
-		bitStream.Write(mail.id); //MailID
-
-		const LUWString subject(mail.subject, 50);
-		bitStream.Write(subject); //subject
-		const LUWString body(mail.body, 400);
-		bitStream.Write(body); //body
-		const LUWString sender(mail.senderUsername, 32);
-		bitStream.Write(sender); //sender
-		bitStream.Write(uint32_t(0)); // packing
-
-		bitStream.Write(uint64_t(0)); // attachedCurrency
-
-		bitStream.Write(mail.itemID); //Attachment ID
-		LOT lot = mail.itemLOT;
-		if (lot <= 0) bitStream.Write(LOT(-1));
-		else bitStream.Write(lot);
-		bitStream.Write(uint32_t(0)); // packing
-
-		bitStream.Write(mail.itemSubkey); // Attachment subKey
-
-		bitStream.Write<uint16_t>(mail.itemCount); // Attachment count
-		bitStream.Write(uint8_t(0)); // subject type (used for auction)
-		bitStream.Write(uint8_t(0)); // packing
-		bitStream.Write(uint32_t(0)); //  packing
-
-		bitStream.Write<uint64_t>(mail.timeSent); // expiration date
-		bitStream.Write<uint64_t>(mail.timeSent);// send date
-		bitStream.Write<uint8_t>(mail.wasRead); //was read
-
-		bitStream.Write(uint8_t(0)); // isLocalized
-		bitStream.Write(uint16_t(0)); // packing
-		bitStream.Write(uint32_t(0)); // packing
-	}
-
-	Game::server->Send(bitStream, sysAddr, false);
-}
-
-void Mail::HandleAttachmentCollect(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* player) {
-	int unknown;
-	uint64_t mailID;
-	LWOOBJID playerID;
-	packet.Read(unknown);
-	packet.Read(mailID);
-	packet.Read(playerID);
-
-	if (mailID > 0 && playerID == player->GetObjectID()) {
-		auto playerMail = Database::Get()->GetMail(mailID);
-
-		LOT attachmentLOT = 0;
-		uint32_t attachmentCount = 0;
-
-		if (playerMail) {
-			attachmentLOT = playerMail->itemLOT;
-			attachmentCount = playerMail->itemCount;
-		}
-
-		auto inv = player->GetComponent<InventoryComponent>();
-		if (!inv) return;
-
-		inv->AddItem(attachmentLOT, attachmentCount, eLootSourceType::MAIL);
-
-		Mail::SendAttachmentRemoveConfirm(sysAddr, mailID);
-
-		Database::Get()->ClaimMailItem(mailID);
-	}
-}
-
-void Mail::HandleMailDelete(RakNet::BitStream& packet, const SystemAddress& sysAddr) {
-	int unknown;
-	uint64_t mailID;
-	LWOOBJID playerID;
-	packet.Read(unknown);
-	packet.Read(mailID);
-	packet.Read(playerID);
-
-	if (mailID > 0) Mail::SendDeleteConfirm(sysAddr, mailID, playerID);
-}
-
-void Mail::HandleMailRead(RakNet::BitStream& packet, const SystemAddress& sysAddr) {
-	int unknown;
-	uint64_t mailID;
-	packet.Read(unknown);
-	packet.Read(mailID);
-
-	if (mailID > 0) Mail::SendReadConfirm(sysAddr, mailID);
-}
-
-void Mail::HandleNotificationRequest(const SystemAddress& sysAddr, uint32_t objectID) {
-	auto unreadMailCount = Database::Get()->GetUnreadMailCount(objectID);
-
-	if (unreadMailCount > 0) Mail::SendNotification(sysAddr, unreadMailCount);
-}
-
-void Mail::SendSendResponse(const SystemAddress& sysAddr, MailSendResponse response) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
-	bitStream.Write(int(MailMessageID::SendResponse));
-	bitStream.Write(int(response));
-	Game::server->Send(bitStream, sysAddr, false);
-}
-
-void Mail::SendNotification(const SystemAddress& sysAddr, int mailCount) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
-	uint64_t messageType = 2;
-	uint64_t s1 = 0;
-	uint64_t s2 = 0;
-	uint64_t s3 = 0;
-	uint64_t s4 = 0;
-
-	bitStream.Write(messageType);
-	bitStream.Write(s1);
-	bitStream.Write(s2);
-	bitStream.Write(s3);
-	bitStream.Write(s4);
-	bitStream.Write(mailCount);
-	bitStream.Write(int(0)); //Unknown
-	Game::server->Send(bitStream, sysAddr, false);
-}
-
-void Mail::SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
-	bitStream.Write(int(MailMessageID::AttachmentCollectConfirm));
-	bitStream.Write(int(0)); //unknown
-	bitStream.Write(mailID);
-	Game::server->Send(bitStream, sysAddr, false);
-}
-
-void Mail::SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOOBJID playerID) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
-	bitStream.Write(int(MailMessageID::MailDeleteConfirm));
-	bitStream.Write(int(0)); //unknown
-	bitStream.Write(mailID);
-	Game::server->Send(bitStream, sysAddr, false);
-
-	Database::Get()->DeleteMail(mailID);
-}
-
-void Mail::SendReadConfirm(const SystemAddress& sysAddr, uint64_t mailID) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAIL);
-	bitStream.Write(int(MailMessageID::MailReadConfirm));
-	bitStream.Write(int(0)); //unknown
-	bitStream.Write(mailID);
-	Game::server->Send(bitStream, sysAddr, false);
-
-	Database::Get()->MarkMailRead(mailID);
+	NotificationResponse response;
+	response.status = eNotificationResponse::NewMail;
+	response.Send(sysAddr);
 }

dGame/dUtilities/Mail.h

@@ -1,43 +1,210 @@
-#pragma once
+#ifndef __MAIL_H__
+#define __MAIL_H__
+
+#include <cstdint>
 #include "BitStream.h"
 #include "RakNetTypes.h"
 #include "dCommonVars.h"
+#include "BitStreamUtils.h"
+#include "MailInfo.h"
 
 class Entity;
 
 namespace Mail {
-	enum class MailMessageID {
-		Send = 0x00,
-		SendResponse = 0x01,
-		DataRequest = 0x03,
-		MailData = 0x04,
-		AttachmentCollect = 0x05,
-		AttachmentCollectConfirm = 0x06,
-		MailDelete = 0x07,
-		MailDeleteConfirm = 0x08,
-		MailRead = 0x09,
-		MailReadConfirm = 0x0a,
-		NotificationRequest = 0x0b
+	enum class eMessageID : uint32_t {
+		SendRequest = 0,
+		SendResponse,
+		NotificationResponse,
+		DataRequest,
+		DataResponse,
+		AttachmentCollectRequest,
+		AttachmentCollectResponse,
+		DeleteRequest,
+		DeleteResponse,
+		ReadRequest,
+		ReadResponse,
+		NotificationRequest,
+		AuctionCreate,
+		AuctionCreationResponse,
+		AuctionCancel,
+		AuctionCancelResponse,
+		AuctionList,
+		AuctionListResponse,
+		AuctionBid,
+		AuctionBidResponse,
+		UnknownError
 	};
 
-	enum class MailSendResponse {
+	enum class eSendResponse : uint32_t {
 		Success = 0,
 		NotEnoughCoins,
 		AttachmentNotFound,
 		ItemCannotBeMailed,
 		CannotMailSelf,
 		RecipientNotFound,
-		DifferentFaction,
-		Unknown,
+		RecipientDifferentFaction,
+		UnHandled7,
 		ModerationFailure,
-		AccountIsMuted,
-		UnknownFailure,
+		SenderAccountIsMuted,
+		UnHandled10,
 		RecipientIsIgnored,
-		UnknownFailure3,
-		RecipientIsFTP
+		UnHandled12,
+		RecipientIsFTP,
+		UnknownError
 	};
 
-	const std::string ServerName = "Darkflame Universe";
+	enum class eDeleteResponse : uint32_t {
+		Success = 0,
+		HasAttachments,
+		NotFound,
+		Throttled,
+		UnknownError
+	};
+
+	enum class eAttachmentCollectResponse : uint32_t {
+		Success = 0,
+		AttachmentNotFound,
+		NoSpaceInInventory,
+		MailNotFound,
+		Throttled,
+		UnknownError
+	};
+
+	enum class eNotificationResponse : uint32_t {
+		NewMail = 0,
+		UnHandled,
+		AuctionWon,
+		AuctionSold,
+		AuctionOutbided,
+		AuctionExpired,
+		AuctionCancelled,
+		AuctionUpdated,
+		UnknownError
+	};
+
+	enum class eReadResponse : uint32_t {
+		Success = 0,
+		UnknownError
+	};
+
+	enum class eAuctionCreateResponse : uint32_t {
+		Success = 0,
+		NotEnoughMoney,
+		ItemNotFound,
+		ItemNotSellable,
+		UnknownError
+	};
+
+	enum class eAuctionCancelResponse : uint32_t {
+		NotFound = 0,
+		NotYours,
+		HasBid,
+		NoLongerExists,
+		UnknownError
+	};
+
+	struct MailLUBitStream : public LUBitStream {
+		eMessageID messageID = eMessageID::UnknownError;
+		SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
+		Entity* player = nullptr;
+
+		MailLUBitStream() = default;
+		MailLUBitStream(eMessageID _messageID) : LUBitStream(eConnectionType::CLIENT, MessageType::Client::MAIL), messageID{_messageID} {};
+
+		virtual void Serialize(RakNet::BitStream& bitStream) const override;
+		virtual bool Deserialize(RakNet::BitStream& bitStream) override;
+		virtual void Handle() override {};
+	};
+
+	struct SendRequest : public MailLUBitStream {
+		MailInfo mailInfo;
+
+		bool Deserialize(RakNet::BitStream& bitStream) override;
+		void Handle() override;
+	};
+
+	struct SendResponse :public MailLUBitStream {
+		eSendResponse status = eSendResponse::UnknownError;
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct NotificationResponse : public MailLUBitStream {
+		eNotificationResponse status = eNotificationResponse::UnknownError;
+		LWOOBJID auctionID = LWOOBJID_EMPTY;
+		uint32_t mailCount = 1;
+		NotificationResponse() : MailLUBitStream(eMessageID::NotificationResponse) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct DataRequest : public MailLUBitStream {
+		bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
+		void Handle() override;
+	};
+
+	struct DataResponse : public MailLUBitStream {
+		uint32_t throttled = 0;
+		std::vector<MailInfo> playerMail;
+
+		DataResponse() : MailLUBitStream(eMessageID::DataResponse) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+
+	};
+
+	struct AttachmentCollectRequest : public MailLUBitStream {
+		uint64_t mailID = 0;
+		LWOOBJID playerID = LWOOBJID_EMPTY;
+
+		AttachmentCollectRequest() : MailLUBitStream(eMessageID::AttachmentCollectRequest) {};
+		bool Deserialize(RakNet::BitStream& bitStream) override;
+		void Handle() override;
+	};
+
+	struct AttachmentCollectResponse : public MailLUBitStream {
+		eAttachmentCollectResponse status = eAttachmentCollectResponse::UnknownError;
+		uint64_t mailID = 0;
+		AttachmentCollectResponse() : MailLUBitStream(eMessageID::AttachmentCollectResponse) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct DeleteRequest : public MailLUBitStream {
+		uint64_t mailID = 0;
+		LWOOBJID playerID = LWOOBJID_EMPTY;
+
+		DeleteRequest() : MailLUBitStream(eMessageID::DeleteRequest) {};
+		bool Deserialize(RakNet::BitStream& bitStream) override;
+		void Handle() override;
+	};
+
+	struct DeleteResponse : public MailLUBitStream {
+		eDeleteResponse status = eDeleteResponse::UnknownError;
+		uint64_t mailID = 0;
+		DeleteResponse() : MailLUBitStream(eMessageID::DeleteResponse) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct ReadRequest : public MailLUBitStream {
+		uint64_t mailID = 0;
+
+		ReadRequest() : MailLUBitStream(eMessageID::ReadRequest) {};
+		bool Deserialize(RakNet::BitStream& bitStream) override;
+		void Handle() override;
+	};
+
+	struct ReadResponse : public MailLUBitStream {
+		uint64_t mailID = 0;
+		eReadResponse status = eReadResponse::UnknownError;
+
+		ReadResponse() : MailLUBitStream(eMessageID::ReadResponse) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct NotificationRequest : public MailLUBitStream {
+		NotificationRequest() : MailLUBitStream(eMessageID::NotificationRequest) {};
+		bool Deserialize(RakNet::BitStream& bitStream) override { return true; };
+		void Handle() override;
+	};
+
+	void HandleMail(RakNet::BitStream& inStream, const SystemAddress& sysAddr, Entity* player);
 
 	void SendMail(
 		const Entity* recipient,
@@ -78,18 +245,6 @@ namespace Mail {
 		uint16_t attachmentCount,
 		const SystemAddress& sysAddr
 	);
-
-	void HandleMailStuff(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* entity);
-	void HandleSendMail(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* entity);
-	void HandleDataRequest(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* player);
-	void HandleAttachmentCollect(RakNet::BitStream& packet, const SystemAddress& sysAddr, Entity* player);
-	void HandleMailDelete(RakNet::BitStream& packet, const SystemAddress& sysAddr);
-	void HandleMailRead(RakNet::BitStream& packet, const SystemAddress& sysAddr);
-	void HandleNotificationRequest(const SystemAddress& sysAddr, uint32_t objectID);
-
-	void SendSendResponse(const SystemAddress& sysAddr, MailSendResponse response);
-	void SendNotification(const SystemAddress& sysAddr, int mailCount);
-	void SendAttachmentRemoveConfirm(const SystemAddress& sysAddr, uint64_t mailID);
-	void SendDeleteConfirm(const SystemAddress& sysAddr, uint64_t mailID, LWOOBJID playerID);
-	void SendReadConfirm(const SystemAddress& sysAddr, uint64_t mailID);
 };
+
+#endif // !__MAIL_H__

dGame/dUtilities/SlashCommandHandler.cpp

@@ -996,7 +996,7 @@ void SlashCommandHandler::Startup() {
 	Command RequestMailCountCommand{
 		.help = "Gets the players mail count",
 		.info = "Sends notification with number of unread messages in the player's mailbox",
-		.aliases = { "requestmailcount" },
+		.aliases = { "requestmailcount", "checkmail" },
 		.handle = GMZeroCommands::RequestMailCount,
 		.requiredLevel = eGameMasterLevel::CIVILIAN
 	};

dGame/dUtilities/SlashCommands/GMGreaterThanZeroCommands.cpp

@@ -102,7 +102,7 @@ namespace GMGreaterThanZeroCommands {
 			return;
 		}
 
-		IMail::MailInfo mailInsert;
+		MailInfo mailInsert;
 		mailInsert.senderId = entity->GetObjectID();
 		mailInsert.senderUsername = "Darkflame Universe";
 		mailInsert.receiverId = receiverID;
@@ -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) {

dGame/dUtilities/SlashCommands/GMZeroCommands.cpp

@@ -12,6 +12,7 @@
 #include "VanityUtilities.h"
 #include "WorldPackets.h"
 #include "ZoneInstanceManager.h"
+#include "Database.h"
 
 // Components
 #include "BuffComponent.h"
@@ -216,7 +217,10 @@ namespace GMZeroCommands {
 	}
 
 	void RequestMailCount(Entity* entity, const SystemAddress& sysAddr, const std::string args) {
-		Mail::HandleNotificationRequest(entity->GetSystemAddress(), entity->GetObjectID());
+		Mail::NotificationResponse response;
+		response.status = Mail::eNotificationResponse::NewMail;
+		response.mailCount = Database::Get()->GetUnreadMailCount(entity->GetCharacter()->GetID());
+		response.Send(sysAddr);
 	}
 
 	void InstanceInfo(Entity* entity, const SystemAddress& sysAddr, const std::string args) {

dMasterServer/MasterServer.cpp

@@ -43,6 +43,13 @@
 #include "CDZoneTableTable.h"
 #include "eGameMasterLevel.h"
 
+#ifdef DARKFLAME_PLATFORM_UNIX
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#endif
+
 namespace Game {
 	Logger* logger = nullptr;
 	dServer* server = nullptr;
@@ -455,6 +462,12 @@ int main(int argc, char** argv) {
 			}
 		}
 
+#ifdef DARKFLAME_PLATFORM_UNIX
+		// kill off dead zombie instances
+		int status{};
+		waitpid(static_cast<pid_t>(-1), &status, WNOHANG);
+#endif
+
 		t += std::chrono::milliseconds(masterFrameDelta);
 		std::this_thread::sleep_until(t);
 	}

dNet/BitStreamUtils.cpp

@@ -0,0 +1,30 @@
+#include "BitStreamUtils.h"
+#include "dServer.h"
+#include "BitStream.h"
+#include "PacketUtils.h"
+
+
+void LUBitStream::WriteHeader(RakNet::BitStream& bitStream) const {
+	bitStream.Write<MessageID>(ID_USER_PACKET_ENUM);
+	bitStream.Write(this->connectionType);
+	bitStream.Write(this->internalPacketID);
+	bitStream.Write<uint8_t>(0); // padding
+}
+
+bool LUBitStream::ReadHeader(RakNet::BitStream& bitStream) {
+	MessageID messageID;
+	bitStream.Read(messageID);
+	if (messageID != ID_USER_PACKET_ENUM) return false;
+	VALIDATE_READ(bitStream.Read(this->connectionType));
+	VALIDATE_READ(bitStream.Read(this->internalPacketID));
+	uint8_t padding;
+	VALIDATE_READ(bitStream.Read<uint8_t>(padding));
+	return true;
+}
+
+void LUBitStream::Send(const SystemAddress& sysAddr) const {
+	RakNet::BitStream bitStream;
+	this->WriteHeader(bitStream);
+	this->Serialize(bitStream);
+	Game::server->Send(bitStream, sysAddr, sysAddr == UNASSIGNED_SYSTEM_ADDRESS);
+}

dNet/BitStreamUtils.h

@@ -2,12 +2,13 @@
 #define __BITSTREAMUTILS__H__
 
 #include "GeneralUtils.h"
-#include "MessageIdentifiers.h"
 #include "BitStream.h"
+#include "MessageIdentifiers.h"
+#include "eConnectionType.h"
 #include <string>
 #include <algorithm>
 
-enum class eConnectionType : uint16_t;
+#define VALIDATE_READ(x) do { if (!x) return false; } while (0)
 
 struct LUString {
 	std::string string;
@@ -45,6 +46,31 @@ struct LUWString {
 	};
 };
 
+struct LUBitStream {
+	eConnectionType connectionType = eConnectionType::UNKNOWN;
+	uint32_t internalPacketID = 0xFFFFFFFF;
+
+	LUBitStream() = default;
+
+	template <typename T> 
+	LUBitStream(eConnectionType connectionType, T internalPacketID) {
+		this->connectionType = connectionType;
+		this->internalPacketID = static_cast<uint32_t>(internalPacketID);
+	}
+
+	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; }
+	virtual void Handle() {};
+};
+
+
 namespace BitStreamUtils {
 	template<typename T>
 	void WriteHeader(RakNet::BitStream& bitStream, eConnectionType connectionType, T internalPacketID) {
@@ -53,7 +79,6 @@ namespace BitStreamUtils {
 		bitStream.Write(static_cast<uint32_t>(internalPacketID));
 		bitStream.Write<uint8_t>(0);
 	}
-
 }
 
 namespace RakNet {

dNet/CMakeLists.txt

@@ -1,7 +1,9 @@
 set(DNET_SOURCES "AuthPackets.cpp"
+	"BitStreamUtils.cpp"
 	"ChatPackets.cpp"
 	"ClientPackets.cpp"
 	"dServer.cpp"
+	"MailInfo.cpp"
 	"MasterPackets.cpp"
 	"PacketUtils.cpp"
 	"WorldPackets.cpp"

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/MailInfo.cpp

@@ -0,0 +1,63 @@
+#include "MailInfo.h"
+#include "BitStream.h"
+#include "DluAssert.h"
+
+void MailInfo::Serialize(RakNet::BitStream& bitStream) const {
+	bitStream.Write(id);
+	const LUWString subject(this->subject, 50);
+	bitStream.Write(subject);
+	const LUWString body(this->body, 400);
+	bitStream.Write(body);
+	const LUWString sender(this->senderUsername, 32);
+	bitStream.Write(sender);
+	bitStream.Write<uint32_t>(0); // packing
+
+	bitStream.Write<uint64_t>(0); // attachedCurrency
+	bitStream.Write(itemID);
+
+	LOT lot = itemLOT;
+	if (lot <= 0) bitStream.Write<LOT>(LOT_NULL);
+	else bitStream.Write(lot);
+	bitStream.Write<uint32_t>(0); // packing
+
+	bitStream.Write(itemSubkey);
+
+	bitStream.Write(itemCount);
+	bitStream.Write<uint8_t>(0); // subject type (used for auction)
+	bitStream.Write<uint8_t>(0); // packing
+	bitStream.Write<uint32_t>(0); //  packing
+
+	bitStream.Write<uint64_t>(timeSent); // expiration date
+	bitStream.Write<uint64_t>(timeSent);// send date
+	bitStream.Write<uint8_t>(wasRead); // was read
+
+	bitStream.Write<uint8_t>(0); // isLocalized
+	bitStream.Write<uint16_t>(1033); // language code
+	bitStream.Write<uint32_t>(0); // packing
+}
+
+bool MailInfo::Deserialize(RakNet::BitStream& bitStream) {
+	LUWString subject(50);
+	VALIDATE_READ(bitStream.Read(subject));
+	this->subject = subject.GetAsString();
+
+	LUWString body(400);
+	VALIDATE_READ(bitStream.Read(body));
+	this->body = body.GetAsString();
+
+	LUWString recipientName(32);
+	VALIDATE_READ(bitStream.Read(recipientName));
+	this->recipient = recipientName.GetAsString();
+
+	uint64_t unknown;
+	VALIDATE_READ(bitStream.Read(unknown));
+
+	VALIDATE_READ(bitStream.Read(itemID));
+	VALIDATE_READ(bitStream.Read(itemCount));
+	VALIDATE_READ(bitStream.Read(languageCode));
+	bitStream.IgnoreBytes(4); // padding
+
+	DluAssert(bitStream.GetNumberOfUnreadBits() == 0);
+
+	return true;
+}

dNet/MailInfo.h

@@ -0,0 +1,34 @@
+#ifndef __MAILINFO_H__
+#define __MAILINFO_H__
+
+#include <string>
+#include <cstdint>
+#include "dCommonVars.h"
+
+namespace RakNet {
+	class BitStream;
+}
+
+struct MailInfo {
+	std::string senderUsername;
+	std::string recipient;
+	std::string subject;
+	std::string body;
+	uint64_t id{};
+	uint32_t senderId{};
+	uint32_t receiverId{};
+	uint64_t timeSent{};
+	bool wasRead{};
+	uint16_t languageCode{};
+	struct {
+		LWOOBJID itemID{};
+		int16_t itemCount{};
+		LOT itemLOT{};
+		LWOOBJID itemSubkey{};
+	};
+
+	void Serialize(RakNet::BitStream& bitStream) const;
+	bool Deserialize(RakNet::BitStream& bitStream);
+};
+
+#endif // __MAILINFO_H__

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

dScripts/02_server/DLU/DLUVanityTeleportingObject.cpp

@@ -16,6 +16,7 @@ void DLUVanityTeleportingObject::OnStartup(Entity* self) {
 
 void DLUVanityTeleportingObject::OnTimerDone(Entity* self, std::string timerName) {
 	if (timerName == "setupTeleport") {
+		RenderComponent::PlayAnimation(self, u"interact");
 		GameMessages::SendPlayFXEffect(self->GetObjectID(), 6478, u"teleportBeam", "teleportBeam");
 		GameMessages::SendPlayFXEffect(self->GetObjectID(), 6478, u"teleportRings", "teleportRings");
 
@@ -27,7 +28,6 @@ void DLUVanityTeleportingObject::OnTimerDone(Entity* self, std::string timerName
 	} else if (timerName == "teleport") {
 		std::vector<VanityObjectLocation>& locations = m_Object->m_Locations[Game::server->GetZoneID()];
 
-	selectLocation:
 		VanityObjectLocation& newLocation = locations[GeneralUtils::GenerateRandomNumber<size_t>(0, locations.size() - 1)];
 
 		// try to get not the same position, but if we get the same one twice, it's fine

dScripts/02_server/Map/AM/AmTeapotServer.cpp

@@ -8,16 +8,11 @@ void AmTeapotServer::OnUse(Entity* self, Entity* user) {
 	auto* inventoryComponent = user->GetComponent<InventoryComponent>();
 	if (!inventoryComponent) return;
 
-	auto* blueFlowerItem = inventoryComponent->FindItemByLot(BLUE_FLOWER_LEAVES, eInventoryType::ITEMS);
-	if (!blueFlowerItem) {
-		blueFlowerItem = inventoryComponent->FindItemByLot(BLUE_FLOWER_LEAVES, eInventoryType::VAULT_ITEMS);
-		if (!blueFlowerItem) return;
-	}
-
 	// The client allows you to use the teapot only if you have a stack of 10 leaves in some inventory somewhere.
-	if (blueFlowerItem->GetCount() >= 10) {
-		blueFlowerItem->SetCount(blueFlowerItem->GetCount() - 10);
+	if (inventoryComponent->GetLotCountNonTransfer(BLUE_FLOWER_LEAVES, false) >= 10) {
+		inventoryComponent->RemoveItem(BLUE_FLOWER_LEAVES, 10, eInventoryType::ALL);
 		inventoryComponent->AddItem(WU_S_IMAGINATION_TEA, 1);
 	}
+
 	GameMessages::SendTerminateInteraction(user->GetObjectID(), eTerminateType::FROM_INTERACTION, self->GetObjectID());
 }

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]));
 			}
@@ -833,15 +848,20 @@ void HandlePacket(Packet* packet) {
 	}
 
 	if (packet->data[0] != ID_USER_PACKET_ENUM || packet->length < 4) return;
-	if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::SERVER) {
-		if (static_cast<MessageType::Server>(packet->data[3]) == MessageType::Server::VERSION_CONFIRM) {
+
+	CINSTREAM;
+	LUBitStream luBitStream;
+	luBitStream.ReadHeader(inStream);
+
+	if (luBitStream.connectionType == eConnectionType::SERVER) {
+		if (static_cast<MessageType::Server>(luBitStream.internalPacketID) == MessageType::Server::VERSION_CONFIRM) {
 			AuthPackets::HandleHandshake(Game::server, packet);
 		}
 	}
 
-	if (static_cast<eConnectionType>(packet->data[1]) != eConnectionType::WORLD) return;
+	if (luBitStream.connectionType != eConnectionType::WORLD) return;
 
-	switch (static_cast<MessageType::World>(packet->data[3])) {
+	switch (static_cast<MessageType::World>(luBitStream.internalPacketID)) {
 	case MessageType::World::VALIDATION: {
 		CINSTREAM_SKIP_HEADER;
 		LUWString username;
@@ -1187,11 +1207,7 @@ void HandlePacket(Packet* packet) {
 	}
 
 	case MessageType::World::MAIL: {
-		RakNet::BitStream bitStream(packet->data, packet->length, false);
-		// FIXME: Change this to the macro to skip the header...
-		LWOOBJID space;
-		bitStream.Read(space);
-		Mail::HandleMailStuff(bitStream, packet->systemAddress, UserManager::Instance()->GetUser(packet->systemAddress)->GetLastUsedChar()->GetEntity());
+		Mail::HandleMail(inStream, packet->systemAddress, UserManager::Instance()->GetUser(packet->systemAddress)->GetLastUsedChar()->GetEntity());
 		break;
 	}
 
@@ -1288,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();
 
@@ -1303,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) {
@@ -1327,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;

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."

resources/chatconfig.ini

@@ -9,5 +9,6 @@ max_number_of_friends=50
 
 web_server_enabled=0
 
-web_server_listen_ip=127.0.0.1
+# Unused for now
+# web_server_listen_ip=127.0.0.1
 web_server_listen_port=2005