Welp, ended up doing client as well since world and client are in the wroing places.

dChatServer/ChatPacketHandler.cpp

@@ -20,6 +20,7 @@
 #include "eGameMasterLevel.h"
 #include "ChatPackets.h"
 #include "TeamContainer.h"
+#include "eChatChannel.h"
 
 void ChatPacketHandler::HandleFriendlistRequest(Packet* packet) {
 	//Get from the packet which player we want to do something with:

dChatServer/ChatPacketHandler.h

@@ -6,33 +6,7 @@
 struct PlayerData;
 
 enum class eAddFriendResponseType : uint8_t;
-
+enum class eChatChannel : uint8_t;
-enum class eChatChannel : uint8_t {
-	SYSTEMNOTIFY = 0,
-	SYSTEMWARNING,
-	SYSTEMERROR,
-	BROADCAST,
-	LOCAL,
-	LOCALNOANIM,
-	EMOTE,
-	PRIVATE_CHAT,
-	TEAM,
-	TEAMLOCAL,
-	GUILD,
-	GUILDNOTIFY,
-	PROPERTY,
-	ADMIN,
-	COMBATDAMAGE,
-	COMBATHEALING,
-	COMBATLOOT,
-	COMBATEXP,
-	COMBATDEATH,
-	GENERAL,
-	TRADE,
-	LFG,
-	USER
-};
-
 
 enum class eChatMessageResponseCode : uint8_t {
 	SENT = 0,

dCommon/dEnums/eChatChannel.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#ifndef __ECHATCHANNEL__H__
+#define __ECHATCHANNEL__H__
+
+#include <cstdint>
+
+
+
+enum class eChatChannel : uint8_t {
+	SYSTEMNOTIFY = 0,
+	SYSTEMWARNING,
+	SYSTEMERROR,
+	BROADCAST,
+	LOCAL,
+	LOCALNOANIM,
+	EMOTE,
+	PRIVATE_CHAT,
+	TEAM,
+	TEAMLOCAL,
+	GUILD,
+	GUILDNOTIFY,
+	PROPERTY,
+	ADMIN,
+	COMBATDAMAGE,
+	COMBATHEALING,
+	COMBATLOOT,
+	COMBATEXP,
+	COMBATDEATH,
+	GENERAL,
+	TRADE,
+	LFG,
+	USER
+};
+
+#endif  //!__ECHATCHANNEL__H__

dGame/UserManager.cpp

@@ -8,7 +8,7 @@
 #include "Game.h"
 #include "Logger.h"
 #include "User.h"
-#include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "Character.h"
 #include "BitStream.h"
 #include "ObjectIDManager.h"
@@ -308,13 +308,17 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 	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);
+		ClientPackets::CharacterCreationResponse response;
+		response.response = eCharacterCreationResponse::CUSTOM_NAME_IN_USE;
+		response.Send(sysAddr);
 		return;
 	}
 
 	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);
+		ClientPackets::CharacterCreationResponse response;
+		response.response = eCharacterCreationResponse::PREDEFINED_NAME_IN_USE;
+		response.Send(sysAddr);
 		return;
 	}
 
@@ -328,7 +332,8 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 	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);
+			ClientPackets::CharacterCreationResponse response;
+			response.response = eCharacterCreationResponse::OBJECT_ID_UNAVAILABLE;
 			return;
 		}
 
@@ -393,8 +398,10 @@ void UserManager::CreateCharacter(const SystemAddress& sysAddr, Packet* packet)
 
 		//Now finally insert our character xml:
 		Database::Get()->InsertCharacterXml(objectID, xml.str());
-
+		
-		WorldPackets::SendCharacterCreationResponse(sysAddr, eCharacterCreationResponse::SUCCESS);
+		ClientPackets::CharacterCreationResponse response;
+		response.response = eCharacterCreationResponse::SUCCESS;
+		response.Send(sysAddr);
 		UserManager::RequestCharacterList(sysAddr);
 		});
 }
@@ -419,10 +426,12 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 		CheckType::User,
 		"User %i tried to delete a character that it does not own!",
 		u->GetAccountID());
-
+	
+	ClientPackets::CharacterDeleteResponse response;
 	if (!hasCharacter) {
-		WorldPackets::SendCharacterDeleteResponse(sysAddr, false);
+		response.success = false;		
 	} else {
+		response.success = true;
 		LOG("Deleting character %i", charID);
 		Database::Get()->DeleteCharacter(charID);
 
@@ -430,9 +439,9 @@ void UserManager::DeleteCharacter(const SystemAddress& sysAddr, Packet* packet)
 		BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, MessageType::Chat::UNEXPECTED_DISCONNECT);
 		bitStream.Write(objectID);
 		Game::chatServer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE, 0, Game::chatSysAddr, false);
-
-		WorldPackets::SendCharacterDeleteResponse(sysAddr, true);
 	}
+	response.Send(sysAddr);
+
 }
 
 void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet) {
@@ -473,32 +482,34 @@ void UserManager::RenameCharacter(const SystemAddress& sysAddr, Packet* packet)
 		return false;
 		});
 
+	ClientPackets::CharacterRenameResponse response;
 	if (!ownsCharacter || !character) {
-		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
+			response.response = eRenameResponse::UNKNOWN_ERROR;
+
 	} else if (ownsCharacter && character) {
 		if (newName == character->GetName()) {
-			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_UNAVAILABLE);
+			response.response = eRenameResponse::NAME_UNAVAILABLE;
-			return;
+		
-		}
+		} else if (!Database::Get()->GetCharacterInfo(newName)) {
-
-		if (!Database::Get()->GetCharacterInfo(newName)) {
 			if (IsNamePreapproved(newName)) {
 				Database::Get()->SetCharacterName(charID, newName);
 				LOG("Character %s now known as %s", character->GetName().c_str(), newName.c_str());
-				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
+				response.response = eRenameResponse::SUCCESS;
-				UserManager::RequestCharacterList(sysAddr);
 			} else {
 				Database::Get()->SetPendingCharacterName(charID, newName);
 				LOG("Character %s has been renamed to %s and is pending approval by a moderator.", character->GetName().c_str(), newName.c_str());
-				WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::SUCCESS);
+				response.response = eRenameResponse::SUCCESS;
-				UserManager::RequestCharacterList(sysAddr);
 			}
 		} else {
-			WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::NAME_IN_USE);
+			response.response = eRenameResponse::NAME_IN_USE;
 		}
 	} else {
 		LOG("Unknown error occurred when renaming character, either hasCharacter or character variable != true.");
-		WorldPackets::SendCharacterRenameResponse(sysAddr, eRenameResponse::UNKNOWN_ERROR);
+		response.response = eRenameResponse::UNKNOWN_ERROR;
+	}
+	response.Send(sysAddr);
+	if (response.response == eRenameResponse::SUCCESS) {
+		UserManager::RequestCharacterList(sysAddr);
 	}
 }
 
@@ -537,7 +548,11 @@ void UserManager::LoginCharacter(const SystemAddress& sysAddr, uint32_t playerID
 				character->SetZoneInstance(zoneInstance);
 				character->SetZoneClone(zoneClone);
 			}
-			WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+			ClientPackets::TransferToWorld response;
+			response.serverIP = serverIP;
+			response.serverPort = serverPort;
+			response.mythranShift = mythranShift;
+			response.Send(sysAddr);
 			return;
 			});
 	} else {

dGame/dBehaviors/PropertyTeleportBehavior.cpp

@@ -5,7 +5,7 @@
 #include "Character.h"
 #include "CharacterComponent.h"
 #include "ChatPackets.h"
-#include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "EntityManager.h"
 #include "Game.h"
 #include "ZoneInstanceManager.h"
@@ -55,7 +55,11 @@ void PropertyTeleportBehavior::Handle(BehaviorContext* context, RakNet::BitStrea
 
 		entity->GetCharacter()->SaveXMLToDatabase();
 
-		WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+		ClientPackets::TransferToWorld response;
+		response.serverIP = serverIP;
+		response.serverPort = serverPort;
+		response.mythranShift = mythranShift;
+		response.Send(sysAddr);
 		return;
 		});
 }

dGame/dComponents/ActivityComponent.cpp

@@ -7,7 +7,7 @@
 #include "ZoneInstanceManager.h"
 #include "Game.h"
 #include "Logger.h"
-#include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "EntityManager.h"
 #include "ChatPackets.h"
 #include "BitStreamUtils.h"
@@ -537,7 +537,11 @@ void ActivityInstance::StartZone() {
 				player->GetCharacter()->SetZoneClone(zoneClone);
 			}
 
-			WorldPackets::SendTransferToWorld(player->GetSystemAddress(), serverIP, serverPort, mythranShift);
+			ClientPackets::TransferToWorld response;
+			response.serverIP = serverIP;
+			response.serverPort = serverPort;
+			response.mythranShift = mythranShift;
+			response.Send(player->GetSystemAddress());
 			return;
 			});
 	}

dGame/dComponents/CharacterComponent.cpp

@@ -21,7 +21,7 @@
 #include "CDRewardCodesTable.h"
 #include "Mail.h"
 #include "ZoneInstanceManager.h"
-#include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "MessageType/Game.h"
 #include <ctime>
 
@@ -868,8 +868,11 @@ void CharacterComponent::SendToZone(LWOMAPID zoneId, LWOCLONEID cloneId) const {
 			character->SaveXMLToDatabase();
 		}
 
-		WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+		ClientPackets::TransferToWorld response;
-
+		response.serverIP = serverIP;
+		response.serverPort = serverPort;
+		response.mythranShift = mythranShift;
+		response.Send(sysAddr);
 		Game::entityManager->DestructEntity(entity);
 		});
 }

dGame/dGameMessages/GameMessages.cpp

@@ -17,7 +17,7 @@
 #include "CppScripts.h"
 #include "UserManager.h"
 #include "ZoneInstanceManager.h"
-#include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "Item.h"
 #include "ZCompression.h"
 #include "dConfig.h"
@@ -4936,7 +4936,11 @@ void GameMessages::HandleFireEventServerSide(RakNet::BitStream& inStream, Entity
 				character->SetZoneClone(zoneClone);
 			}
 
-			WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+			ClientPackets::TransferToWorld response;
+			response.serverIP = serverIP;
+			response.serverPort = serverPort;
+			response.mythranShift = mythranShift;
+			response.Send(sysAddr);
 			return;
 			});
 	}

dGame/dUtilities/SlashCommands/DEVGMCommands.cpp

@@ -17,7 +17,7 @@
 #include "UserManager.h"
 #include "User.h"
 #include "VanityUtilities.h"
-#include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "ZoneInstanceManager.h"
 
 // Database
@@ -73,7 +73,13 @@ namespace DEVGMCommands {
 		bool success = user->GetMaxGMLevel() >= level;
 
 		if (success) {
-			WorldPackets::SendGMLevelChange(entity->GetSystemAddress(), success, user->GetMaxGMLevel(), entity->GetGMLevel(), level);
+			ClientPackets::GMLevelChange response;
+			response.success = success;
+			response.prevLevel = entity->GetGMLevel();
+			response.newLevel = level;
+			response.highestLevel = user->GetMaxGMLevel();
+			response.Send(entity->GetSystemAddress());
+			
 			GameMessages::SendChatModeUpdate(entity->GetObjectID(), level);
 			entity->SetGMLevel(level);
 			LOG("User %s (%i) has changed their GM level to %i for charID %llu", user->GetUsername().c_str(), user->GetAccountID(), level, entity->GetObjectID());
@@ -81,7 +87,13 @@ namespace DEVGMCommands {
 
 #ifndef DEVELOPER_SERVER
 		if ((entity->GetGMLevel() > user->GetMaxGMLevel()) || (entity->GetGMLevel() > eGameMasterLevel::CIVILIAN && user->GetMaxGMLevel() == eGameMasterLevel::JUNIOR_DEVELOPER)) {
-			WorldPackets::SendGMLevelChange(entity->GetSystemAddress(), true, user->GetMaxGMLevel(), entity->GetGMLevel(), eGameMasterLevel::CIVILIAN);
+			ClientPackets::GMLevelChange response;
+			response.success = false;
+			response.prevLevel = entity->GetGMLevel();
+			response.newLevel = eGameMasterLevel::CIVILIAN;
+			response.highestLevel = user->GetMaxGMLevel();
+			response.Send(entity->GetSystemAddress());
+
 			GameMessages::SendChatModeUpdate(entity->GetObjectID(), eGameMasterLevel::CIVILIAN);
 			entity->SetGMLevel(eGameMasterLevel::CIVILIAN);
 
@@ -1061,7 +1073,11 @@ namespace DEVGMCommands {
 
 				entity->GetCharacter()->SaveXMLToDatabase();
 
-				WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+				ClientPackets::TransferToWorld response;
+				response.serverIP = serverIP;
+				response.serverPort = serverPort;
+				response.mythranShift = mythranShift;
+				response.Send(sysAddr);
 				return;
 				});
 		} else {

dGame/dUtilities/SlashCommands/GMZeroCommands.cpp

@@ -10,7 +10,7 @@
 #include "PlayerManager.h"
 #include "SlashCommandHandler.h"
 #include "VanityUtilities.h"
-#include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "ZoneInstanceManager.h"
 #include "Database.h"
 
@@ -179,7 +179,11 @@ namespace GMZeroCommands {
 
 			entity->GetCharacter()->SaveXMLToDatabase();
 
-			WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+			ClientPackets::TransferToWorld response;
+			response.serverIP = serverIP;
+			response.serverPort = serverPort;
+			response.mythranShift = mythranShift;
+			response.Send(sysAddr);
 			});
 	}
 
@@ -205,7 +209,11 @@ namespace GMZeroCommands {
 
 			entity->GetCharacter()->SaveXMLToDatabase();
 
-			WorldPackets::SendTransferToWorld(sysAddr, serverIP, serverPort, mythranShift);
+			ClientPackets::TransferToWorld response;
+			response.serverIP = serverIP;
+			response.serverPort = serverPort;
+			response.mythranShift = mythranShift;
+			response.Send(sysAddr);
 			});
 	}
 

dNet/ClientPackets.cpp

@@ -6,6 +6,139 @@
 #include "ClientPackets.h"
 #include "dCommonVars.h"
 #include "PositionUpdate.h"
+#include "LDFFormat.h"
+#include "ZCompression.h"
+
+namespace ClientPackets {
+	void LoadStaticZone::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write<uint16_t>(zoneID.GetMapID());
+		bitStream.Write<uint16_t>(zoneID.GetInstanceID());
+		bitStream.Write<uint32_t>(checksum);
+		bitStream.Write<uint8_t>(editorEnabled);
+		bitStream.Write<uint8_t>(editorLevel);
+		bitStream.Write(position.x);
+		bitStream.Write(position.y);
+		bitStream.Write(position.z);
+		bitStream.Write<uint32_t>(instanceType);
+	}
+	void CharacterCreationResponse::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write(response);
+	}
+	
+	void CharacterRenameResponse::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write(response);
+	}
+
+	void CharacterDeleteResponse::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write<uint8_t>(success);
+	}
+
+	void TransferToWorld::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write(LUString(serverIP));
+		bitStream.Write<uint16_t>(serverPort);
+		bitStream.Write<uint8_t>(mythranShift);
+	}
+
+	void ServerState::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write<uint8_t>(serverReady);
+	}
+	void CreateCharacter::Serialize(RakNet::BitStream &bitStream) const {
+
+		RakNet::BitStream data;
+
+		data.Write<uint32_t>(7); //LDF key count
+		std::unique_ptr<LDFData<LWOOBJID>> objidLDF(new LDFData<LWOOBJID>(u"objid", objid));
+		objidLDF->WriteToPacket(data);
+
+		std::unique_ptr<LDFData<LOT>> templateIDLDF(new LDFData<LOT>(u"template", templateID));
+		templateIDLDF->WriteToPacket(data);
+
+		std::unique_ptr<LDFData<std::u16string>> nameLDF(new LDFData<std::u16string>(u"name", name));
+		nameLDF->WriteToPacket(data);
+
+		std::unique_ptr<LDFData<int32_t>> gmlevelLDF(new LDFData<int32_t>(u"gmlevel", static_cast<int32_t>(gmLevel)));
+		gmlevelLDF->WriteToPacket(data);
+
+		std::unique_ptr<LDFData<int32_t>> chatModeLDF(new LDFData<int32_t>(u"chatmode", static_cast<int32_t>(chatMode)));
+		chatModeLDF->WriteToPacket(data);
+
+		std::unique_ptr<LDFData<std::string>> xmlConfigData(new LDFData<std::string>(u"xmlData", xmlData));
+		xmlConfigData->WriteToPacket(data);
+
+		std::unique_ptr<LDFData<int64_t>> reputationLdf(new LDFData<int64_t>(u"reputation", reputation));
+		reputationLdf->WriteToPacket(data);
+
+		//Compress the data before sending:
+		const uint32_t reservedSize = ZCompression::GetMaxCompressedLength(data.GetNumberOfBytesUsed());
+		uint8_t* compressedData = new uint8_t[reservedSize];
+
+		if (!compressedData) {
+			throw std::runtime_error("Failed to allocate memory for compressed data");
+		}
+
+		size_t size = ZCompression::Compress(data.GetData(), data.GetNumberOfBytesUsed(), compressedData, reservedSize);
+
+		assert(size <= reservedSize);
+
+		bitStream.Write<uint32_t>(size + 9); //size of data + header bytes (8)
+		bitStream.Write<uint8_t>(1);         //compressed boolean, true
+		bitStream.Write<uint32_t>(data.GetNumberOfBytesUsed());
+		bitStream.Write<uint32_t>(size);
+
+		/**
+		 * In practice, this warning serves no purpose for us.  We allocate the max memory needed on the heap
+		 * and then compress the data.  In the off chance that the compression actually increases the size,
+		 * an assertion is done to prevent bad data from being saved or sent.
+		 */
+	#pragma warning(disable:6385) // C6385 Reading invalid data from 'compressedData'.
+		bitStream.WriteAlignedBytes(compressedData, size);
+	#pragma warning(default:6385)
+		delete[] compressedData;
+	};
+
+	void ChatModerationString::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write<uint8_t>(rejectedWords.empty()); // Accepted
+		bitStream.Write<uint16_t>(0); // padding
+
+		bitStream.Write(chatChannel);
+		bitStream.Write(chatMode);
+
+		bitStream.Write(LUWString(receiver, 42));
+
+		for (auto it : rejectedWords) {
+			bitStream.Write<uint8_t>(it.first); // start index
+			bitStream.Write<uint8_t>(it.second); // length
+		}
+
+		// Pad out the rest of the packet
+		// The client expects 64 items, so we need to write 64 - rejectedWords.size() empty items
+		for (int i = rejectedWords.size(); 64 > i; i++) {
+			bitStream.Write<uint16_t>(0);
+		}
+
+	}
+
+	void GMLevelChange::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write<uint8_t>(success);
+		bitStream.Write(static_cast<uint16_t>(highestLevel));
+		bitStream.Write(static_cast<uint16_t>(prevLevel));
+		bitStream.Write(static_cast<uint16_t>(newLevel));
+	}
+
+	void DebugOutput::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write<uint32_t>(data.size());
+		bitStream.Write(data);
+	}
+
+	void HTTPMonitorInfoResponse::Serialize(RakNet::BitStream &bitStream) const {
+		bitStream.Write<uint16_t>(port);
+		bitStream.Write<uint8_t>(openWeb);
+		bitStream.Write<uint8_t>(supportsSum);
+		bitStream.Write<uint8_t>(supportsDetail);
+		bitStream.Write<uint8_t>(supportsWho);
+		bitStream.Write<uint8_t>(supportsObjects);
+	}
+}
 
 ChatMessage ClientPackets::HandleChatMessage(Packet* packet) {
 	CINSTREAM_SKIP_HEADER;
@@ -114,10 +247,3 @@ ChatModerationRequest ClientPackets::HandleChatModerationRequest(Packet* packet)
 
 	return request;
 }
-
-int32_t ClientPackets::SendTop5HelpIssues(Packet* packet) {
-	CINSTREAM_SKIP_HEADER;
-	int32_t language = 0;
-	inStream.Read(language);
-	return language;
-}

dNet/ClientPackets.h

@@ -8,6 +8,10 @@
 
 #include <cstdint>
 #include <string>
+#include "BitStreamUtils.h"
+#include "eGameMasterLevel.h"
+#include "eChatChannel.h"
+#include "dCommonVars.h"
 
 class PositionUpdate;
 
@@ -26,11 +30,118 @@ struct ChatModerationRequest {
 	std::string message;
 };
 
+
+class User;
+struct SystemAddress;
+enum class eCharacterCreationResponse : uint8_t;
+enum class eRenameResponse : uint8_t;
+
 namespace ClientPackets {
 	ChatMessage HandleChatMessage(Packet* packet);
 	PositionUpdate HandleClientPositionUpdate(Packet* packet);
 	ChatModerationRequest HandleChatModerationRequest(Packet* packet);
-	int32_t SendTop5HelpIssues(Packet* packet);
+
+	struct LoadStaticZone : public LUBitStream {
+		LWOZONEID zoneID;
+		uint32_t checksum = 0;
+		bool editorEnabled = false;
+		uint8_t editorLevel = 0;
+		NiPoint3 position = NiPoint3Constant::ZERO;
+		uint32_t instanceType = 0;
+
+		LoadStaticZone() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::LOAD_STATIC_ZONE) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+
+	};
+
+	struct CharacterCreationResponse : public LUBitStream {
+		eCharacterCreationResponse response;
+
+		CharacterCreationResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CHARACTER_CREATE_RESPONSE) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct CharacterRenameResponse : public LUBitStream {
+		eRenameResponse response;
+
+		CharacterRenameResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CHARACTER_RENAME_RESPONSE) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct CharacterDeleteResponse : public LUBitStream {
+		bool success;
+
+		CharacterDeleteResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::DELETE_CHARACTER_RESPONSE) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct TransferToWorld : public LUBitStream {
+		std::string serverIP;
+		uint32_t serverPort = 0;
+		bool mythranShift = false;
+
+		TransferToWorld() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::TRANSFER_TO_WORLD) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct ServerState : public LUBitStream {
+		bool serverReady = false;
+
+		ServerState() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::SERVER_STATES) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct CreateCharacter : public LUBitStream {
+		LWOOBJID objid = 0;
+		LOT templateID = 1;
+		std::u16string name;
+		eGameMasterLevel gmLevel = eGameMasterLevel::CIVILIAN;
+		int32_t chatMode = 0;
+		std::string xmlData;
+		int64_t reputation = 0;
+
+		CreateCharacter() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CREATE_CHARACTER) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct ChatModerationString : public LUBitStream {
+		eChatChannel chatChannel = eChatChannel::SYSTEMNOTIFY;
+		uint8_t chatMode = 0;
+		std::string receiver;
+		std::set<std::pair<uint8_t, uint8_t>> rejectedWords;
+
+		ChatModerationString() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::CHAT_MODERATION_STRING) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+	
+	struct GMLevelChange : public LUBitStream {
+		bool success = false;
+		eGameMasterLevel highestLevel = eGameMasterLevel::CIVILIAN;
+		eGameMasterLevel prevLevel = eGameMasterLevel::CIVILIAN;
+		eGameMasterLevel newLevel = eGameMasterLevel::CIVILIAN;
+
+		GMLevelChange() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::MAKE_GM_RESPONSE) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct DebugOutput : public LUBitStream {
+		std::string data;
+
+		DebugOutput() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::DEBUG_OUTPUT) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
+
+	struct HTTPMonitorInfoResponse : public LUBitStream {
+		uint16_t port = 80;
+		bool openWeb = false;
+		bool supportsSum = false;
+		bool supportsDetail = false;
+		bool supportsWho = false;
+		bool supportsObjects = false;
+
+		HTTPMonitorInfoResponse() : LUBitStream(eConnectionType::CLIENT, MessageType::Client::HTTP_MONITOR_INFO_RESPONSE) {};
+		void Serialize(RakNet::BitStream& bitStream) const override;
+	};
 };
 
 #endif // CLIENTPACKETS_H

dNet/WorldPackets.cpp

@@ -1,186 +1,42 @@
 #include "WorldPackets.h"
-#include "dCommonVars.h"
+#include "Amf3.h"
-#include "BitStream.h"
+#include "dConfig.h"
-#include "GeneralUtils.h"
+#include "GameMessages.h"
-#include "Logger.h"
+#include "Entity.h"
-#include "Game.h"
-#include "LDFFormat.h"
-#include "dServer.h"
-#include "ZCompression.h"
-#include "eConnectionType.h"
-#include "BitStreamUtils.h"
 
-#include <iostream>
+namespace WorldPackets {
-
+	
-void HTTPMonitorInfo::Serialize(RakNet::BitStream &bitStream) const {
+	bool UIHelpTop5::Deserialize(RakNet::BitStream& bitStream) {
-	bitStream.Write(port);
+		VALIDATE_READ(bitStream.Read(languageCode));
-	bitStream.Write<uint8_t>(openWeb);
+		return true;
-	bitStream.Write<uint8_t>(supportsSum);
-	bitStream.Write<uint8_t>(supportsDetail);
-	bitStream.Write<uint8_t>(supportsWho);
-	bitStream.Write<uint8_t>(supportsObjects);
-}
-
-void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum, LWOZONEID zone) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::LOAD_STATIC_ZONE);
-
-	bitStream.Write<uint16_t>(zone.GetMapID());
-	bitStream.Write<uint16_t>(zone.GetInstanceID());
-	//bitStream.Write<uint32_t>(zone.GetCloneID());
-	bitStream.Write(0);
-
-	bitStream.Write(checksum);
-	bitStream.Write<uint16_t>(0);     // ??
-
-	bitStream.Write(x);
-	bitStream.Write(y);
-	bitStream.Write(z);
-
-	bitStream.Write<uint32_t>(0);     // Change this to eventually use 4 on activity worlds
-
-	SEND_PACKET;
-}
-
-void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHARACTER_CREATE_RESPONSE);
-	bitStream.Write(response);
-	SEND_PACKET;
-}
-
-void WorldPackets::SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHARACTER_RENAME_RESPONSE);
-	bitStream.Write(response);
-	SEND_PACKET;
-}
-
-void WorldPackets::SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::DELETE_CHARACTER_RESPONSE);
-	bitStream.Write<uint8_t>(response);
-	SEND_PACKET;
-}
-
-void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::TRANSFER_TO_WORLD);
-
-	bitStream.Write(LUString(serverIP));
-	bitStream.Write<uint16_t>(serverPort);
-	bitStream.Write<uint8_t>(mythranShift);
-
-	SEND_PACKET;
-}
-
-void WorldPackets::SendServerState(const SystemAddress& sysAddr) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::SERVER_STATES);
-	bitStream.Write<uint8_t>(1); //If the server is receiving this request, it probably is ready anyway.
-	SEND_PACKET;
-}
-
-void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, int64_t reputation, LWOOBJID player, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm) {
-	RakNet::BitStream bitStream;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CREATE_CHARACTER);
-
-	RakNet::BitStream data;
-	data.Write<uint32_t>(7); //LDF key count
-
-	std::unique_ptr<LDFData<LWOOBJID>> objid(new LDFData<LWOOBJID>(u"objid", player));
-	std::unique_ptr<LDFData<LOT>> lot(new LDFData<LOT>(u"template", 1));
-	std::unique_ptr<LDFData<std::string>> xmlConfigData(new LDFData<std::string>(u"xmlData", xmlData));
-	std::unique_ptr<LDFData<std::u16string>> name(new LDFData<std::u16string>(u"name", username));
-	std::unique_ptr<LDFData<int32_t>> gmlevel(new LDFData<int32_t>(u"gmlevel", static_cast<int32_t>(gm)));
-	std::unique_ptr<LDFData<int32_t>> chatmode(new LDFData<int32_t>(u"chatmode", static_cast<int32_t>(gm)));
-	std::unique_ptr<LDFData<int64_t>> reputationLdf(new LDFData<int64_t>(u"reputation", reputation));
-
-	objid->WriteToPacket(data);
-	lot->WriteToPacket(data);
-	name->WriteToPacket(data);
-	gmlevel->WriteToPacket(data);
-	chatmode->WriteToPacket(data);
-	xmlConfigData->WriteToPacket(data);
-	reputationLdf->WriteToPacket(data);
-
-	//Compress the data before sending:
-    const uint32_t reservedSize = ZCompression::GetMaxCompressedLength(data.GetNumberOfBytesUsed());
-    uint8_t* compressedData = new uint8_t[reservedSize];
-
-	// TODO There should be better handling here for not enough memory...
-	if (!compressedData) return;
-
-	size_t size = ZCompression::Compress(data.GetData(), data.GetNumberOfBytesUsed(), compressedData, reservedSize);
-
-	assert(size <= reservedSize);
-
-	bitStream.Write<uint32_t>(size + 9); //size of data + header bytes (8)
-	bitStream.Write<uint8_t>(1);         //compressed boolean, true
-	bitStream.Write<uint32_t>(data.GetNumberOfBytesUsed());
-	bitStream.Write<uint32_t>(size);
-
-	/**
-	 * In practice, this warning serves no purpose for us.  We allocate the max memory needed on the heap
-	 * and then compress the data.  In the off chance that the compression actually increases the size,
-	 * an assertion is done to prevent bad data from being saved or sent.
-	 */
-#pragma warning(disable:6385) // C6385 Reading invalid data from 'compressedData'.
-	bitStream.WriteAlignedBytes(compressedData, size);
-#pragma warning(default:6385)
-
-	SEND_PACKET;
-	delete[] compressedData;
-	LOG("Sent CreateCharacter for ID: %llu", player);
-}
-
-void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::set<std::pair<uint8_t, uint8_t>> unacceptedItems) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::CHAT_MODERATION_STRING);
-
-	bitStream.Write<uint8_t>(unacceptedItems.empty()); // Is sentence ok?
-	bitStream.Write<uint16_t>(0x16); // Source ID, unknown
-
-	bitStream.Write<uint8_t>(requestID); // request ID
-	bitStream.Write<char>(0); // chat mode
-
-	bitStream.Write(LUWString(receiver, 42)); // receiver name
-
-	for (auto it : unacceptedItems) {
-		bitStream.Write<uint8_t>(it.first); // start index
-		bitStream.Write<uint8_t>(it.second); // length
 	}
 
-	for (int i = unacceptedItems.size(); 64 > i; i++) {
+	void UIHelpTop5::Handle() {
-		bitStream.Write<uint16_t>(0);
+		AMFArrayValue data;
+		switch (languageCode) {
+			case eLanguageCodeID::EN_US:
+				// Summaries
+				data.Insert("Summary0", Game::config->GetValue("help_0_summary"));
+				data.Insert("Summary1", Game::config->GetValue("help_1_summary"));
+				data.Insert("Summary2", Game::config->GetValue("help_2_summary"));
+				data.Insert("Summary3", Game::config->GetValue("help_3_summary"));
+				data.Insert("Summary4", Game::config->GetValue("help_4_summary"));
+
+				// Descriptions
+				data.Insert("Description0", Game::config->GetValue("help_0_description"));
+				data.Insert("Description1", Game::config->GetValue("help_1_description"));
+				data.Insert("Description2", Game::config->GetValue("help_2_description"));
+				data.Insert("Description3", Game::config->GetValue("help_3_description"));
+				data.Insert("Description4", Game::config->GetValue("help_4_description"));
+				break;
+			case eLanguageCodeID::PL_US:
+			case eLanguageCodeID::DE_DE:
+			case eLanguageCodeID::EN_GB:
+			default:
+				break;
+		}
+		GameMessages::SendUIMessageServerToSingleClient(player, sysAddr, "UIHelpTop5", data);
 	}
+	
 
-	SEND_PACKET;
-}
-
-void WorldPackets::SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::MAKE_GM_RESPONSE);
-
-	bitStream.Write<uint8_t>(success);
-	bitStream.Write(static_cast<uint16_t>(highestLevel));
-	bitStream.Write(static_cast<uint16_t>(prevLevel));
-	bitStream.Write(static_cast<uint16_t>(newLevel));
-
-	SEND_PACKET;
-}
-
-void WorldPackets::SendHTTPMonitorInfo(const SystemAddress& sysAddr, const HTTPMonitorInfo& info) {
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::HTTP_MONITOR_INFO_RESPONSE);
-	info.Serialize(bitStream);
-	SEND_PACKET;
-}
-
-void WorldPackets::SendDebugOuput(const SystemAddress& sysAddr, const std::string& data){
-	CBITSTREAM;
-	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, MessageType::Client::DEBUG_OUTPUT);
-	bitStream.Write<uint32_t>(data.size());
-	bitStream.Write(data);
-	SEND_PACKET;
 }

dNet/WorldPackets.h

@@ -2,40 +2,30 @@
 #define WORLDPACKETS_H
 
 #include "dCommonVars.h"
-#include <vector>
+#include "BitStreamUtils.h"
-#include <string>
+#include "MessageType/World.h"
 
-class User;
+class Entity;
-struct SystemAddress;
+enum class eLanguageCodeID : int32_t {
-enum class eGameMasterLevel : uint8_t;
+	EN_US = 0,
-enum class eCharacterCreationResponse : uint8_t;
+	PL_US = 1,
-enum class eRenameResponse : uint8_t;
+	DE_DE = 2,
-namespace RakNet {
+	EN_GB = 3
-	class BitStream;
-};
-
-struct HTTPMonitorInfo {
-	uint16_t port = 80;
-	bool openWeb = false;
-	bool supportsSum = false;
-	bool supportsDetail = false;
-	bool supportsWho = false;
-	bool supportsObjects = false;
-	void Serialize(RakNet::BitStream &bitstream) const;
 };
 
 namespace WorldPackets {
-	void SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum, LWOZONEID zone);
+
-	void SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response);
+	struct UIHelpTop5: public LUBitStream {
-	void SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response);
+		eLanguageCodeID languageCode = eLanguageCodeID::EN_US;
-	void SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response);
+
-	void SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift);
+		// should these be shoved up to the base class?
-	void SendServerState(const SystemAddress& sysAddr);
+		SystemAddress sysAddr = UNASSIGNED_SYSTEM_ADDRESS;
-	void SendCreateCharacter(const SystemAddress& sysAddr, int64_t reputation, LWOOBJID player, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm);
+		Entity* player = nullptr;
-	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);
+		UIHelpTop5() : LUBitStream(eConnectionType::WORLD, MessageType::World::UI_HELP_TOP_5) {};
-	void SendHTTPMonitorInfo(const SystemAddress& sysAddr, const HTTPMonitorInfo& info);
+		bool Deserialize(RakNet::BitStream& bitStream) override;
-	void SendDebugOuput(const SystemAddress& sysAddr, const std::string& data);
+		void Handle() override;
+	};
 }
 
 #endif // WORLDPACKETS_H

dWorldServer/WorldServer.cpp

@@ -31,6 +31,7 @@
 #include "AuthPackets.h"
 #include "BitStreamUtils.h"
 #include "WorldPackets.h"
+#include "ClientPackets.h"
 #include "UserManager.h"
 #include "CDClientManager.h"
 #include "CDClientDatabase.h"
@@ -715,18 +716,15 @@ void HandleMasterPacket(Packet* packet) {
 
 			auto zone = Game::zoneManager->GetZone();
 			if (zone) {
-				float x = 0.0f;
+				NiPoint3 pos = NiPoint3Constant::ZERO;
-				float y = 0.0f;
-				float z = 0.0f;
-
 				if (zone->GetZoneID().GetMapID() == 1100) {
-					auto pos = zone->GetSpawnPos();
+					pos = zone->GetSpawnPos();
-					x = pos.x;
-					y = pos.y;
-					z = pos.z;
 				}
 
-				WorldPackets::SendLoadStaticZone(it->second.sysAddr, x, y, z, zone->GetChecksum(), Game::zoneManager->GetZoneID());
+				ClientPackets::LoadStaticZone load;
+				load.zoneID = Game::zoneManager->GetZoneID();
+				load.checksum = zone->GetChecksum();
+				load.position = pos;
 			}
 
 			if (Game::server->GetZoneID() == 0) {
@@ -1040,8 +1038,17 @@ void HandlePacket(Packet* packet) {
 				auto* characterComponent = player->GetComponent<CharacterComponent>();
 				if (!characterComponent) return;
 
-				WorldPackets::SendCreateCharacter(packet->systemAddress, player->GetComponent<CharacterComponent>()->GetReputation(), player->GetObjectID(), c->GetXMLData(), username, c->GetGMLevel());
+				ClientPackets::CreateCharacter createCharacter;
-				WorldPackets::SendServerState(packet->systemAddress);
+				createCharacter.objid = player->GetObjectID();
+				createCharacter.name = username;
+				createCharacter.gmLevel = c->GetGMLevel();
+				createCharacter.xmlData = c->GetXMLData();
+				createCharacter.reputation = player->GetComponent<CharacterComponent>()->GetReputation();
+				createCharacter.Send(packet->systemAddress);
+
+				ClientPackets::ServerState serverState;
+				serverState.serverReady = true;
+				serverState.Send(packet->systemAddress);
 
 				const auto respawnPoint = player->GetCharacter()->GetRespawnPoint(Game::zoneManager->GetZone()->GetWorldID());
 
@@ -1336,7 +1343,10 @@ void HandlePacket(Packet* packet) {
 		}
 
 		user->SetLastChatMessageApproved(bAllClean);
-		WorldPackets::SendChatModerationResponse(packet->systemAddress, bAllClean, request.requestID, request.receiver, segments);
+		ClientPackets::ChatModerationString response;
+		response.receiver = request.receiver;
+		response.rejectedWords = segments;
+		response.Send(packet->systemAddress);
 		break;
 	}
 
@@ -1392,13 +1402,8 @@ void HandlePacket(Packet* packet) {
 
 
 	case MessageType::World::UI_HELP_TOP_5: {
-		auto language = ClientPackets::SendTop5HelpIssues(packet);
+		WorldPackets::UIHelpTop5 help;
-		// TODO: Handle different languages in a nice way
+		help.Deserialize(inStream);
-		// 0: en_US
-		// 1: pl_US
-		// 2: de_DE
-		// 3: en_GB
-
 		// TODO: Find a good home for the logic in this case.
 		auto* user = UserManager::Instance()->GetUser(packet->systemAddress);
 		if (!user) return;
@@ -1406,23 +1411,10 @@ void HandlePacket(Packet* packet) {
 		if (!character) return;
 		auto* entity = character->GetEntity();
 		if (!entity) return;
-
+		help.sysAddr = packet->systemAddress;
-		AMFArrayValue data;
+		help.player = entity;
-		// Summaries
+		help.Handle();
-		data.Insert("Summary0", Game::config->GetValue("help_0_summary"));
+		
-		data.Insert("Summary1", Game::config->GetValue("help_1_summary"));
-		data.Insert("Summary2", Game::config->GetValue("help_2_summary"));
-		data.Insert("Summary3", Game::config->GetValue("help_3_summary"));
-		data.Insert("Summary4", Game::config->GetValue("help_4_summary"));
-
-		// Descriptions
-		data.Insert("Description0", Game::config->GetValue("help_0_description"));
-		data.Insert("Description1", Game::config->GetValue("help_1_description"));
-		data.Insert("Description2", Game::config->GetValue("help_2_description"));
-		data.Insert("Description3", Game::config->GetValue("help_3_description"));
-		data.Insert("Description4", Game::config->GetValue("help_4_description"));
-
-		GameMessages::SendUIMessageServerToSingleClient(entity, packet->systemAddress, "UIHelpTop5", data);
 		break;
 	}