chore: cleanup LU(W)string writing (#1188)

* chore: cleanup LU(W)string writing and add methods for reading remove redunent "packet" from packet reading helpers move write header to bitstreamutils since it's not packet related add tests for reading/writing LU(W)Strings * remove un-needed function defintions in header * make reading and writing more efficient * p p * quotes * remove unneeded default --------- Co-authored-by: David Markowitz <39972741+EmosewaMC@users.noreply.github.com>
2025-08-08 03:34:10 +00:00 · 2023-09-20 20:06:28 -05:00
parent ca78a166d9
commit 08020cd86d
27 changed files with 537 additions and 275 deletions
--- a/dNet/AuthPackets.cpp
+++ b/dNet/AuthPackets.cpp
@@ -1,5 +1,6 @@
 #include "AuthPackets.h"
 #include "PacketUtils.h"
+#include "BitStreamUtils.h"

 #include "dNetCommon.h"
 #include "dServer.h"
@@ -39,7 +40,7 @@ void AuthPackets::HandleHandshake(dServer* server, Packet* packet) {

 void AuthPackets::SendHandshake(dServer* server, const SystemAddress& sysAddr, const std::string& nextServerIP, uint16_t nextServerPort, const ServerType serverType) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::VERSION_CONFIRM);
 	uint32_t netVersion;
 	if (!GeneralUtils::TryParse(Game::config->GetValue("client_net_version"), netVersion)) {
 		Game::logger->Log("AuthPackets", "Failed to parse client_net_version. Cannot authenticate to %s:%i", nextServerIP.c_str(), nextServerPort);
@@ -197,20 +198,19 @@ void AuthPackets::HandleLoginRequest(dServer* server, Packet* packet) {

 void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAddr, eLoginResponse responseCode, const std::string& errorMsg, const std::string& wServerIP, uint16_t wServerPort, std::string username) {
 	RakNet::BitStream packet;
-	PacketUtils::WriteHeader(packet, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE);
+	BitStreamUtils::WriteHeader(packet, eConnectionType::CLIENT, eClientMessageType::LOGIN_RESPONSE);

 	packet.Write(static_cast<uint8_t>(responseCode));

-	PacketUtils::WritePacketString("Talk_Like_A_Pirate", 33, &packet);
-
-	// 7 unknown strings - perhaps other IP addresses?
-	PacketUtils::WritePacketString("", 33, &packet);
-	PacketUtils::WritePacketString("", 33, &packet);
-	PacketUtils::WritePacketString("", 33, &packet);
-	PacketUtils::WritePacketString("", 33, &packet);
-	PacketUtils::WritePacketString("", 33, &packet);
-	PacketUtils::WritePacketString("", 33, &packet);
-	PacketUtils::WritePacketString("", 33, &packet);
+	// Event Gating
+	packet.Write(LUString("Talk_Like_A_Pirate"));
+	packet.Write(LUString(""));
+	packet.Write(LUString(""));
+	packet.Write(LUString(""));
+	packet.Write(LUString(""));
+	packet.Write(LUString(""));
+	packet.Write(LUString(""));
+	packet.Write(LUString(""));

 	packet.Write(static_cast<uint16_t>(1));         // Version Major
 	packet.Write(static_cast<uint16_t>(10));        // Version Current
@@ -220,34 +220,34 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd
 	uint32_t sessionKey = GeneralUtils::GenerateRandomNumber<uint32_t>();
 	std::string userHash = std::to_string(sessionKey);
 	userHash = md5(userHash);
-	PacketUtils::WritePacketWString(userHash, 33, &packet);
+	packet.Write(LUWString(userHash));

 	// Write the Character and Chat IPs
-	PacketUtils::WritePacketString(wServerIP, 33, &packet);
-	PacketUtils::WritePacketString("", 33, &packet);
+	packet.Write(LUString(wServerIP));
+	packet.Write(LUString(""));

 	// Write the Character and Chat Ports
 	packet.Write(static_cast<uint16_t>(wServerPort));
 	packet.Write(static_cast<uint16_t>(0));

-	// Write another IP
-	PacketUtils::WritePacketString("", 33, &packet);
+	// CDN Key
+	packet.Write(LUString(""));

-	// Write a GUID or something...
-	PacketUtils::WritePacketString("00000000-0000-0000-0000-000000000000", 37, &packet);
+	// CDN Ticket
+	packet.Write(LUString("00000000-0000-0000-0000-000000000000", 37));

-	packet.Write(static_cast<uint32_t>(0));         // ???
+	packet.Write(static_cast<uint32_t>(0)); // Language

 	// Write the localization
-	PacketUtils::WritePacketString("US", 3, &packet);
+	packet.Write(LUString("US", 3));

-	packet.Write(static_cast<uint8_t>(false));      // User first logged in?
-	packet.Write(static_cast<uint8_t>(false));      // User is F2P?
-	packet.Write(static_cast<uint64_t>(0));         // ???
+	packet.Write(static_cast<uint8_t>(false)); // Just upgraded from F2P
+	packet.Write(static_cast<uint8_t>(false)); // User is F2P
+	packet.Write(static_cast<uint64_t>(0)); // Time Remaining in F2P

 	// Write custom error message
 	packet.Write(static_cast<uint16_t>(errorMsg.length()));
-	PacketUtils::WritePacketWString(errorMsg, static_cast<uint32_t>(errorMsg.length()), &packet);
+	packet.Write(LUWString(errorMsg, static_cast<uint32_t>(errorMsg.length())));

 	// Here write auth logs
 	packet.Write(static_cast<uint32_t>(20));
@@ -263,9 +263,9 @@ void AuthPackets::SendLoginResponse(dServer* server, const SystemAddress& sysAdd
 	//Inform the master server that we've created a session for this user:
 	{
 		CBITSTREAM;
-		PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SET_SESSION_KEY);
+		BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SET_SESSION_KEY);
 		bitStream.Write(sessionKey);
-		PacketUtils::WriteString(bitStream, username, 66);
+		bitStream.Write(LUString(username, 66));
 		server->SendToMaster(&bitStream);

 		server->GetLogger()->Log("AuthPackets", "Set sessionKey: %i for user %s", sessionKey, username.c_str());
--- a/dNet/BitStreamUtils.h
+++ b/dNet/BitStreamUtils.h
@@ -0,0 +1,104 @@
+#ifndef __BITSTREAMUTILS__H__
+#define __BITSTREAMUTILS__H__
+
+#include "GeneralUtils.h"
+#include "MessageIdentifiers.h"
+#include "BitStream.h"
+#include <string>
+
+enum class eConnectionType : uint16_t;
+
+struct LUString {
+	std::string string;
+	uint32_t size;
+
+	LUString(uint32_t size) {
+		this->size = size;
+	};
+	LUString(std::string string, uint32_t size = 33) {
+		this->string = string;
+		this->size = size;
+	};
+	std::u16string GetAsU16String() const {
+		return GeneralUtils::ASCIIToUTF16(this->string);
+	};
+};
+
+struct LUWString {
+	std::u16string string;
+	uint32_t size;
+
+	LUWString(uint32_t size) {
+		this->size = size;
+	};
+	LUWString(std::u16string string, uint32_t size = 33) {
+		this->string = string;
+		this->size = size;
+	};
+	LUWString(std::string string, uint32_t size = 33) {
+		this->string = GeneralUtils::ASCIIToUTF16(string);
+		this->size = size;
+	};
+	std::string GetAsString() const {
+		return GeneralUtils::UTF16ToWTF8(this->string);
+	};
+};
+
+namespace BitStreamUtils {
+	template<typename T>
+	void WriteHeader(RakNet::BitStream& bitStream, eConnectionType connectionType, T internalPacketID) {
+		bitStream.Write<uint8_t>(MessageID(ID_USER_PACKET_ENUM));
+		bitStream.Write<eConnectionType>(connectionType);
+		bitStream.Write<uint32_t>(static_cast<uint32_t>(internalPacketID));
+		bitStream.Write<uint8_t>(0);
+	}
+
+}
+
+namespace RakNet {
+#ifndef __BITSTREAM_NATIVE_END
+#error No definition for big endian reading of LUString
+#endif
+
+	template <>
+	inline bool RakNet::BitStream::Read<LUString>(LUString& value) {
+		value.string.resize(value.size);
+		bool res = ReadBits(reinterpret_cast<unsigned char*>(value.string.data()), BYTES_TO_BITS(value.string.size()), true);
+		if (!res) return false;
+		value.string.erase(std::find(value.string.begin(), value.string.end(), '\0'), value.string.end());
+		return res;
+	}
+
+	template <>
+	inline bool RakNet::BitStream::Read<LUWString>(LUWString& value) {
+		value.string.resize(value.size);
+		bool res = ReadBits(reinterpret_cast<unsigned char*>(value.string.data()), BYTES_TO_BITS(value.string.size()) * sizeof(std::u16string::value_type), true);
+		if (!res) return false;
+		value.string.erase(std::find(value.string.begin(), value.string.end(), u'\0'), value.string.end());
+		return res;
+	}
+
+	template <>
+	inline void RakNet::BitStream::Write<std::string>(std::string value) {
+		this->WriteBits(reinterpret_cast<const unsigned char*>(value.data()), BYTES_TO_BITS(value.size()));
+	}
+
+	template <>
+	inline void RakNet::BitStream::Write<std::u16string>(std::u16string value) {
+		this->WriteBits(reinterpret_cast<const unsigned char*>(value.data()), BYTES_TO_BITS(value.size()) * sizeof(std::u16string::value_type));
+	}
+
+	template <>
+	inline void RakNet::BitStream::Write<LUString>(LUString value) {
+		value.string.resize(value.size);
+		this->Write(value.string);
+	}
+
+	template <>
+	inline void RakNet::BitStream::Write<LUWString>(LUWString value) {
+		value.string.resize(value.size);
+		this->Write(value.string);
+	}
+};
+
+#endif  //!__BITSTREAMUTILS__H__
--- a/dNet/ChatPackets.cpp
+++ b/dNet/ChatPackets.cpp
@@ -8,19 +8,20 @@
 #include "BitStream.h"
 #include "Game.h"
 #include "PacketUtils.h"
+#include "BitStreamUtils.h"
 #include "dServer.h"
 #include "eConnectionType.h"
 #include "eChatMessageType.h"

 void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel, const std::string& senderName, LWOOBJID playerObjectID, bool senderMythran, const std::u16string& message) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);

 	bitStream.Write(static_cast<uint64_t>(0));
 	bitStream.Write(chatChannel);

 	bitStream.Write(static_cast<uint32_t>(message.size()));
-	PacketUtils::WriteWString(bitStream, senderName, 33);
+	bitStream.Write(LUWString(senderName));

 	bitStream.Write(playerObjectID);
 	bitStream.Write(static_cast<uint16_t>(0));
@@ -36,13 +37,13 @@ void ChatPackets::SendChatMessage(const SystemAddress& sysAddr, char chatChannel

 void ChatPackets::SendSystemMessage(const SystemAddress& sysAddr, const std::u16string& message, const bool broadcast) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CHAT, eChatMessageType::GENERAL_CHAT_MESSAGE);

 	bitStream.Write(static_cast<uint64_t>(0));
 	bitStream.Write(static_cast<char>(4));

 	bitStream.Write(static_cast<uint32_t>(message.size()));
-	PacketUtils::WriteWString(bitStream, "", 33);
+	bitStream.Write(LUWString("", 33));

 	bitStream.Write(static_cast<uint64_t>(0));
 	bitStream.Write(static_cast<uint16_t>(0));
@@ -68,7 +69,7 @@ void ChatPackets::SendMessageFail(const SystemAddress& sysAddr) {
 	//0x01 - "Upgrade to a full LEGO Universe Membership to chat with other players."

 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SEND_CANNED_TEXT);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::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;
--- a/dNet/MasterPackets.cpp
+++ b/dNet/MasterPackets.cpp
@@ -5,19 +5,20 @@
 #include "dServer.h"
 #include "eConnectionType.h"
 #include "eMasterMessageType.h"
+#include "BitStreamUtils.h"

 #include <string>

 void MasterPackets::SendPersistentIDRequest(dServer* server, uint64_t requestID) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID);
 	bitStream.Write(requestID);
 	server->SendToMaster(&bitStream);
 }

 void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, uint32_t objID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PERSISTENT_ID_RESPONSE);

 	bitStream.Write(requestID);
 	bitStream.Write(objID);
@@ -27,7 +28,7 @@ void MasterPackets::SendPersistentIDResponse(dServer* server, const SystemAddres

 void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t cloneID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER);

 	bitStream.Write(requestID);
 	bitStream.Write(static_cast<uint8_t>(mythranShift));
@@ -39,7 +40,7 @@ void MasterPackets::SendZoneTransferRequest(dServer* server, uint64_t requestID,

 void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint32_t cloneID, const std::string& password) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::CREATE_PRIVATE_ZONE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::CREATE_PRIVATE_ZONE);

 	bitStream.Write(zoneID);
 	bitStream.Write(cloneID);
@@ -54,7 +55,7 @@ void MasterPackets::SendZoneCreatePrivate(dServer* server, uint32_t zoneID, uint

 void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID, bool mythranShift, const std::string& password) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PRIVATE_ZONE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_PRIVATE_ZONE);

 	bitStream.Write(requestID);
 	bitStream.Write(static_cast<uint8_t>(mythranShift));
@@ -69,7 +70,7 @@ void MasterPackets::SendZoneRequestPrivate(dServer* server, uint64_t requestID,

 void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCEID instanceId) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::WORLD_READY);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::WORLD_READY);

 	bitStream.Write(zoneId);
 	bitStream.Write(instanceId);
@@ -79,7 +80,7 @@ void MasterPackets::SendWorldReady(dServer* server, LWOMAPID zoneId, LWOINSTANCE

 void MasterPackets::SendZoneTransferResponse(dServer* server, const SystemAddress& sysAddr, uint64_t requestID, bool mythranShift, uint32_t zoneID, uint32_t zoneInstance, uint32_t zoneClone, const std::string& serverIP, uint32_t serverPort) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE);

 	bitStream.Write(requestID);
 	bitStream.Write(static_cast<uint8_t>(mythranShift));
@@ -87,7 +88,7 @@ void MasterPackets::SendZoneTransferResponse(dServer* server, const SystemAddres
 	bitStream.Write(zoneInstance);
 	bitStream.Write(zoneClone);
 	bitStream.Write(static_cast<uint16_t>(serverPort));
-	PacketUtils::WriteString(bitStream, serverIP, static_cast<uint32_t>(serverIP.size() + 1));
+	bitStream.Write(LUString(serverIP, static_cast<uint32_t>(serverIP.size() + 1)));

 	server->Send(&bitStream, sysAddr, false);
 }
@@ -111,13 +112,13 @@ void MasterPackets::HandleServerInfo(Packet* packet) {

 void MasterPackets::SendServerInfo(dServer* server, Packet* packet) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SERVER_INFO);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::MASTER, eMasterMessageType::SERVER_INFO);

 	bitStream.Write(server->GetPort());
 	bitStream.Write(server->GetZoneID());
 	bitStream.Write(server->GetInstanceID());
 	bitStream.Write(server->GetServerType());
-	PacketUtils::WriteString(bitStream, server->GetIP(), server->GetIP().size());
+	bitStream.Write(LUString(server->GetIP(), server->GetIP().size()));

 	server->SendToMaster(&bitStream);
 }
--- a/dNet/PacketUtils.cpp
+++ b/dNet/PacketUtils.cpp
@@ -4,7 +4,7 @@
 #include "dLogger.h"
 #include "Game.h"

-uint16_t PacketUtils::ReadPacketU16(uint32_t startLoc, Packet* packet) {
+uint16_t PacketUtils::ReadU16(uint32_t startLoc, Packet* packet) {
 	if (startLoc + 2 > packet->length) return 0;

 	std::vector<unsigned char> t;
@@ -12,7 +12,7 @@ uint16_t PacketUtils::ReadPacketU16(uint32_t startLoc, Packet* packet) {
 	return *(uint16_t*)t.data();
 }

-uint32_t PacketUtils::ReadPacketU32(uint32_t startLoc, Packet* packet) {
+uint32_t PacketUtils::ReadU32(uint32_t startLoc, Packet* packet) {
 	if (startLoc + 4 > packet->length) return 0;

 	std::vector<unsigned char> t;
@@ -22,7 +22,7 @@ uint32_t PacketUtils::ReadPacketU32(uint32_t startLoc, Packet* packet) {
 	return *(uint32_t*)t.data();
 }

-uint64_t PacketUtils::ReadPacketU64(uint32_t startLoc, Packet* packet) {
+uint64_t PacketUtils::ReadU64(uint32_t startLoc, Packet* packet) {
 	if (startLoc + 8 > packet->length) return 0;

 	std::vector<unsigned char> t;
@@ -30,7 +30,7 @@ uint64_t PacketUtils::ReadPacketU64(uint32_t startLoc, Packet* packet) {
 	return *(uint64_t*)t.data();
 }

-int64_t PacketUtils::ReadPacketS64(uint32_t startLoc, Packet* packet) {
+int64_t PacketUtils::ReadS64(uint32_t startLoc, Packet* packet) {
 	if (startLoc + 8 > packet->length) return 0;

 	std::vector<unsigned char> t;
@@ -59,81 +59,6 @@ std::string PacketUtils::ReadString(uint32_t startLoc, Packet* packet, bool wide
 	return readString;
 }

-void PacketUtils::WritePacketString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream) {
-	uint32_t size = static_cast<uint32_t>(string.size());
-	uint32_t remSize = static_cast<uint32_t>(maxSize - size);
-
-	if (size > maxSize) size = maxSize;
-
-	for (uint32_t i = 0; i < size; ++i) {
-		bitStream->Write(static_cast<char>(string[i]));
-	}
-
-	for (uint32_t j = 0; j < remSize; ++j) {
-		bitStream->Write(static_cast<char>(0));
-	}
-}
-
-void PacketUtils::WriteString(RakNet::BitStream& bitStream, const std::string& s, uint32_t maxSize) {
-	uint32_t size = s.size();
-	uint32_t emptySize = maxSize - size;
-
-	if (size > maxSize) size = maxSize;
-
-	for (uint32_t i = 0; i < size; i++) {
-		bitStream.Write((char)s[i]);
-	}
-
-	for (uint32_t i = 0; i < emptySize; i++) {
-		bitStream.Write((char)0);
-	}
-}
-
-void PacketUtils::WriteWString(RakNet::BitStream& bitStream, const std::string& string, uint32_t maxSize) {
-	uint32_t size = static_cast<uint32_t>(string.length());
-	uint32_t remSize = static_cast<uint32_t>(maxSize - size);
-
-	if (size > maxSize) size = maxSize;
-
-	for (uint32_t i = 0; i < size; ++i) {
-		bitStream.Write(static_cast<uint16_t>(string[i]));
-	}
-
-	for (uint32_t j = 0; j < remSize; ++j) {
-		bitStream.Write(static_cast<uint16_t>(0));
-	}
-}
-
-void PacketUtils::WriteWString(RakNet::BitStream& bitStream, const std::u16string& string, uint32_t maxSize) {
-	uint32_t size = static_cast<uint32_t>(string.length());
-	uint32_t remSize = static_cast<uint32_t>(maxSize - size);
-
-	if (size > maxSize) size = maxSize;
-
-	for (uint32_t i = 0; i < size; ++i) {
-		bitStream.Write(static_cast<uint16_t>(string[i]));
-	}
-
-	for (uint32_t j = 0; j < remSize; ++j) {
-		bitStream.Write(static_cast<uint16_t>(0));
-	}
-}
-
-void PacketUtils::WritePacketWString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream) {
-	uint32_t size = static_cast<uint32_t>(string.length());
-	uint32_t remSize = static_cast<uint32_t>(maxSize - size);
-
-	if (size > maxSize) size = maxSize;
-
-	for (uint32_t i = 0; i < size; ++i) {
-		bitStream->Write(static_cast<uint16_t>(string[i]));
-	}
-
-	for (uint32_t j = 0; j < remSize; ++j) {
-		bitStream->Write(static_cast<uint16_t>(0));
-	}
-}
-
 //! Saves a packet to the filesystem
 void PacketUtils::SavePacket(const std::string& filename, const char* data, size_t length) {
 	//If we don't log to the console, don't save the bin files either. This takes up a lot of time.
--- a/dNet/PacketUtils.h
+++ b/dNet/PacketUtils.h
@@ -8,26 +8,11 @@
 enum class eConnectionType : uint16_t;

 namespace PacketUtils {
-	template<typename T>
-	void WriteHeader(RakNet::BitStream& bitStream, eConnectionType connectionType, T internalPacketID) {
-		bitStream.Write<uint8_t>(MessageID(ID_USER_PACKET_ENUM));
-		bitStream.Write<eConnectionType>(connectionType);
-		bitStream.Write<uint32_t>(static_cast<uint32_t>(internalPacketID));
-		bitStream.Write<uint8_t>(0);
-	}
-
-	uint16_t ReadPacketU16(uint32_t startLoc, Packet* packet);
-	uint32_t ReadPacketU32(uint32_t startLoc, Packet* packet);
-	uint64_t ReadPacketU64(uint32_t startLoc, Packet* packet);
-	int64_t ReadPacketS64(uint32_t startLoc, Packet* packet);
+	uint16_t ReadU16(uint32_t startLoc, Packet* packet);
+	uint32_t ReadU32(uint32_t startLoc, Packet* packet);
+	uint64_t ReadU64(uint32_t startLoc, Packet* packet);
+	int64_t ReadS64(uint32_t startLoc, Packet* packet);
 	std::string ReadString(uint32_t startLoc, Packet* packet, bool wide, uint32_t maxLen = 33);
-
-	void WritePacketString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream);
-	void WriteString(RakNet::BitStream& bitStream, const std::string& s, uint32_t maxSize);
-	void WriteWString(RakNet::BitStream& bitStream, const std::string& string, uint32_t maxSize);
-	void WriteWString(RakNet::BitStream& bitStream, const std::u16string& string, uint32_t maxSize);
-	void WritePacketWString(const std::string& string, uint32_t maxSize, RakNet::BitStream* bitStream);
-
 	void SavePacket(const std::string& filename, const char* data, size_t length);
 };

--- a/dNet/WorldPackets.cpp
+++ b/dNet/WorldPackets.cpp
@@ -14,10 +14,11 @@
 #include "CharacterComponent.h"
 #include "ZCompression.h"
 #include "eConnectionType.h"
+#include "BitStreamUtils.h"

 void WorldPackets::SendLoadStaticZone(const SystemAddress& sysAddr, float x, float y, float z, uint32_t checksum) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::LOAD_STATIC_ZONE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::LOAD_STATIC_ZONE);

 	auto zone = Game::zoneManager->GetZone()->GetZoneID();
 	bitStream.Write(static_cast<uint16_t>(zone.GetMapID()));
@@ -41,7 +42,7 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
 	if (!user) return;

 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_LIST_RESPONSE);

 	std::vector<Character*> characters = user->GetCharacters();
 	bitStream.Write(static_cast<uint8_t>(characters.size()));
@@ -51,13 +52,13 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {
 		bitStream.Write(characters[i]->GetObjectID());
 		bitStream.Write(static_cast<uint32_t>(0));

-		PacketUtils::WriteWString(bitStream, characters[i]->GetName(), 33);
-		PacketUtils::WriteWString(bitStream, characters[i]->GetUnapprovedName(), 33);
+		bitStream.Write(LUWString(characters[i]->GetName()));
+		bitStream.Write(LUWString(characters[i]->GetUnapprovedName()));

 		bitStream.Write(static_cast<uint8_t>(characters[i]->GetNameRejected()));
 		bitStream.Write(static_cast<uint8_t>(false));

-		PacketUtils::WriteString(bitStream, "", 10);
+		bitStream.Write(LUString("", 10));

 		bitStream.Write(characters[i]->GetShirtColor());
 		bitStream.Write(characters[i]->GetShirtStyle());
@@ -90,30 +91,30 @@ void WorldPackets::SendCharacterList(const SystemAddress& sysAddr, User* user) {

 void WorldPackets::SendCharacterCreationResponse(const SystemAddress& sysAddr, eCharacterCreationResponse response) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_CREATE_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_CREATE_RESPONSE);
 	bitStream.Write(response);
 	SEND_PACKET;
 }

 void WorldPackets::SendCharacterRenameResponse(const SystemAddress& sysAddr, eRenameResponse response) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_RENAME_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHARACTER_RENAME_RESPONSE);
 	bitStream.Write(response);
 	SEND_PACKET;
 }

 void WorldPackets::SendCharacterDeleteResponse(const SystemAddress& sysAddr, bool response) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::DELETE_CHARACTER_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::DELETE_CHARACTER_RESPONSE);
 	bitStream.Write(static_cast<uint8_t>(response));
 	SEND_PACKET;
 }

 void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::string& serverIP, uint32_t serverPort, bool mythranShift) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TRANSFER_TO_WORLD);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::TRANSFER_TO_WORLD);

-	PacketUtils::WriteString(bitStream, serverIP, 33);
+	bitStream.Write(LUString(serverIP));
 	bitStream.Write(static_cast<uint16_t>(serverPort));
 	bitStream.Write(static_cast<uint8_t>(mythranShift));

@@ -122,14 +123,14 @@ void WorldPackets::SendTransferToWorld(const SystemAddress& sysAddr, const std::

 void WorldPackets::SendServerState(const SystemAddress& sysAddr) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SERVER_STATES);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::SERVER_STATES);
 	bitStream.Write(static_cast<uint8_t>(1)); //If the server is receiving this request, it probably is ready anyway.
 	SEND_PACKET;
 }

 void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* entity, const std::string& xmlData, const std::u16string& username, eGameMasterLevel gm) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CREATE_CHARACTER);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CREATE_CHARACTER);

 	RakNet::BitStream data;
 	data.Write<uint32_t>(7); //LDF key count
@@ -198,7 +199,7 @@ void WorldPackets::SendCreateCharacter(const SystemAddress& sysAddr, Entity* ent

 void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool requestAccepted, uint32_t requestID, const std::string& receiver, std::vector<std::pair<uint8_t, uint8_t>> unacceptedItems) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHAT_MODERATION_STRING);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::CHAT_MODERATION_STRING);

 	bitStream.Write<uint8_t>(unacceptedItems.empty()); // Is sentence ok?
 	bitStream.Write<uint16_t>(0x16); // Source ID, unknown
@@ -206,7 +207,7 @@ void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool
 	bitStream.Write(static_cast<uint8_t>(requestID)); // request ID
 	bitStream.Write(static_cast<char>(0)); // chat mode

-	PacketUtils::WritePacketWString(receiver, 42, &bitStream); // receiver name
+	bitStream.Write(LUWString(receiver, 42)); // receiver name

 	for (auto it : unacceptedItems) {
 		bitStream.Write<uint8_t>(it.first); // start index
@@ -222,7 +223,7 @@ void WorldPackets::SendChatModerationResponse(const SystemAddress& sysAddr, bool

 void WorldPackets::SendGMLevelChange(const SystemAddress& sysAddr, bool success, eGameMasterLevel highestLevel, eGameMasterLevel prevLevel, eGameMasterLevel newLevel) {
 	CBITSTREAM;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAKE_GM_RESPONSE);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::CLIENT, eClientMessageType::MAKE_GM_RESPONSE);

 	bitStream.Write<uint8_t>(success);
 	bitStream.Write(static_cast<uint16_t>(highestLevel));
--- a/dNet/ZoneInstanceManager.cpp
+++ b/dNet/ZoneInstanceManager.cpp
@@ -28,10 +28,10 @@ void ZoneInstanceManager::RequestZoneTransfer(dServer* server, uint32_t zoneID,
 void ZoneInstanceManager::HandleRequestZoneTransferResponse(uint64_t requestID, Packet* packet) {

 	bool mythranShift = static_cast<bool>(packet->data[16]);
-	uint32_t zoneID = PacketUtils::ReadPacketU32(17, packet);
-	uint32_t zoneInstance = PacketUtils::ReadPacketU32(21, packet);
-	uint32_t zoneClone = PacketUtils::ReadPacketU32(25, packet);
-	uint16_t serverPort = PacketUtils::ReadPacketU16(29, packet);
+	uint32_t zoneID = PacketUtils::ReadU32(17, packet);
+	uint32_t zoneInstance = PacketUtils::ReadU32(21, packet);
+	uint32_t zoneClone = PacketUtils::ReadU32(25, packet);
+	uint16_t serverPort = PacketUtils::ReadU16(29, packet);
 	std::string serverIP = PacketUtils::ReadString(31, packet, false);

 	for (uint32_t i = 0; i < this->requests.size(); ++i) {
--- a/dNet/dServer.cpp
+++ b/dNet/dServer.cpp
@@ -11,6 +11,7 @@
 #include "eMasterMessageType.h"

 #include "PacketUtils.h"
+#include "BitStreamUtils.h"
 #include "MasterPackets.h"
 #include "ZoneInstanceManager.h"

@@ -123,7 +124,7 @@ Packet* dServer::ReceiveFromMaster() {
 			if (static_cast<eConnectionType>(packet->data[1]) == eConnectionType::MASTER) {
 				switch (static_cast<eMasterMessageType>(packet->data[3])) {
 				case eMasterMessageType::REQUEST_ZONE_TRANSFER_RESPONSE: {
-					uint64_t requestID = PacketUtils::ReadPacketU64(8, packet);
+					uint64_t requestID = PacketUtils::ReadU64(8, packet);
 					ZoneInstanceManager::Instance()->HandleRequestZoneTransferResponse(requestID, packet);
 					break;
 				}
@@ -168,7 +169,7 @@ void dServer::SendToMaster(RakNet::BitStream* bitStream) {

 void dServer::Disconnect(const SystemAddress& sysAddr, eServerDisconnectIdentifiers disconNotifyID) {
 	RakNet::BitStream bitStream;
-	PacketUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::DISCONNECT_NOTIFY);
+	BitStreamUtils::WriteHeader(bitStream, eConnectionType::SERVER, eServerMessageType::DISCONNECT_NOTIFY);
 	bitStream.Write(disconNotifyID);
 	mPeer->Send(&bitStream, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, sysAddr, false);