Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2026-10-02 02:43:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
130f3566ccbf1cd3d282c0859756591a8c312df2
DarkflameServer/tests/dGameTests/dNetTests/GuildPacketsTests.cpp
Aaron Kimbrell 130f3566cc wire: guild packets and DisplayGuildCreateBox as structs 
The guild packets of the 1.10.64 client (docs/Guilds.md) as Serialize/Deserialize structs, laid out the way the client's
packet handlers read them: GUILD_CREATE_RESPONSE, GUILD_INVITE, GUILD_INVITE_INITIAL_RESPONSE, _FINAL_RESPONSE,
_CONFIRM, GUILD_ADD_PLAYER, GUILD_REMOVE_PLAYER, GUILD_LOGIN_LOGOUT and GUILD_DATA (ClientPackets), the world packet
TMP_GUILD_CREATE the create box sends, the chat packets the client sends through its world (GUILD_INVITE,
GUILD_INVITE_RESPONSE, GUILD_LEAVE, GUILD_GET_ALL), DLU's world <-> chat packets (GUILD_CREATE, GUILD_KICK,
GUILD_GET_STATUS as the chat server's guild update to a world, and GUILD_SET_RANK and GUILD_DISBAND appended to
MessageType::Chat after CREATE_TEAM) and the game message DisplayGuildCreateBox (626). Fixed-size names always keep a
NUL, since the client reads them as C strings. Enums eGuildCreateResponse, eGuildInviteResponse,
eGuildInviteFinalResponse, eGuildRank and eGuildLeaveReason. Nothing sends them yet.

Check: GuildPacketsTests compares every packet with the bytes at the client's offsets. Nothing to check in game.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 06:48:40 -05:00

294 lines
12 KiB
C++
Raw Blame History

// Guild packets (docs/Guilds.md): the bytes the 1.10.64 client reads (offsets from its packet handlers), the bytes it
// sends, and DLU's world <-> chat packets.
#include "ChatPackets.h"
#include "ClientPackets.h"
#include "WorldPackets.h"
#include "PlayerMessages.h"
#include "GameDependencies.h"
#include "PacketTestUtils.h"
#include "dGameMessagesTests/GameMessageTestUtils.h"
#include <gtest/gtest.h>
using namespace PacketTestUtils;
using GameMessageTestUtils::RoundTrip;
using GameMessageTestUtils::ExpectTruncatedFails;
namespace {
// Little-endian bytes, the way the client's packed structs lie in memory
struct Bytes {
std::vector<uint8_t> data;
Bytes& U8(uint8_t value) { data.push_back(value); return *this; }
Bytes& U16(uint16_t value) { return U8(value & 0xFF).U8(value >> 8); }
Bytes& U32(uint32_t value) { return U16(value & 0xFFFF).U16(value >> 16); }
Bytes& U64(uint64_t value) { return U32(value & 0xFFFFFFFF).U32(value >> 32); }
// A fixed buffer of `size` UTF-16 characters, zero filled
Bytes& WStr(const std::u16string& text, size_t size) {
for (size_t i = 0; i < size; i++) U16(i < text.size() ? text[i] : 0);
return *this;
}
Bytes& Zone(uint16_t map, uint16_t instance, uint32_t clone) { return U16(map).U16(instance).U32(clone); }
// 0x53, connection type, packet id, padding
static Bytes Header(uint16_t connection, uint32_t id) { Bytes bytes; bytes.U8(0x53).U16(connection).U32(id).U8(0); return bytes; }
PacketBytes Packet() const { return { data, static_cast<uint32_t>(data.size() * 8) }; }
};
PacketBytes StructPacket(const LUBitStream& msg) {
RakNet::BitStream bitStream;
msg.WritePacket(bitStream);
return FromBitStream(bitStream);
}
constexpr uint16_t CLIENT = 5;
constexpr uint16_t CHAT = 2;
constexpr uint16_t WORLD = 4;
constexpr LWOOBJID PLAYER = 0x1000000000000123LL;
constexpr LWOOBJID OTHER = 0x1000000000000456LL;
}
class GuildPacketsTests : public GameDependenciesTest {
protected:
void SetUp() override { SetUpDependencies(); }
void TearDown() override { TearDownDependencies(); }
};
// ---- Server -> client. Offsets in the comments are the client's, from the byte after 0x53. ----
TEST_F(GuildPacketsTests, CreateResponse) {
ClientPackets::GuildCreateResponse response;
response.result = eGuildCreateResponse::CREATED;
response.guildID = 7;
response.guildName = "Brick Builders";
// +7 result, +8 u64, +16 wchar[31]: 78 bytes after 0x53
const auto expected = Bytes::Header(CLIENT, 37).U8(0).U64(7).WStr(u"Brick Builders", 31);
EXPECT_EQ(expected.data.size(), 79u);
EXPECT_PACKET_EQ(expected.Packet(), StructPacket(response));
const auto copy = RoundTrip(response);
EXPECT_EQ(copy.guildName, "Brick Builders");
ExpectTruncatedFails(response);
}
TEST_F(GuildPacketsTests, NamesAlwaysKeepANul) {
ClientPackets::GuildCreateResponse response;
response.guildName = std::string(40, 'x');
const auto packet = StructPacket(response);
ASSERT_EQ(packet.bytes.size(), 79u);
// the last character of the 31 is 0
EXPECT_EQ(packet.bytes[77], 0);
EXPECT_EQ(packet.bytes[78], 0);
EXPECT_EQ(packet.bytes[75], 'x');
}
TEST_F(GuildPacketsTests, Invite) {
ClientPackets::GuildInvite invite;
invite.inviterName = "Alice";
invite.guildName = "Brick Builders";
// +7 wchar[33] inviter, +73 wchar[31] guild
const auto expected = Bytes::Header(CLIENT, 39).WStr(u"Alice", 33).WStr(u"Brick Builders", 31);
EXPECT_PACKET_EQ(expected.Packet(), StructPacket(invite));
RoundTrip(invite);
}
TEST_F(GuildPacketsTests, InviteResponses) {
ClientPackets::GuildInviteInitialResponse initial;
initial.response = eGuildInviteResponse::INVITE_PENDING;
initial.playerName = "Bob";
EXPECT_PACKET_EQ(Bytes::Header(CLIENT, 40).U8(3).WStr(u"Bob", 33).Packet(), StructPacket(initial));
RoundTrip(initial);
ClientPackets::GuildInviteFinalResponse final;
final.response = eGuildInviteFinalResponse::DECLINED;
final.playerName = "Bob";
EXPECT_PACKET_EQ(Bytes::Header(CLIENT, 41).U8(1).WStr(u"Bob", 33).Packet(), StructPacket(final));
RoundTrip(final);
ClientPackets::GuildInviteConfirm confirm;
confirm.failed = true;
confirm.guildName = "Brick Builders";
EXPECT_PACKET_EQ(Bytes::Header(CLIENT, 42).U8(1).WStr(u"Brick Builders", 33).Packet(), StructPacket(confirm));
EXPECT_TRUE(RoundTrip(confirm).failed);
}
TEST_F(GuildPacketsTests, AddPlayer) {
ClientPackets::GuildAddPlayer add;
add.playerName = "Bob";
add.playerID = OTHER;
add.rank = eGuildRank::RECRUIT;
add.zoneID = LWOZONEID(1200, 3, 0);
add.online = true;
// +7 name, +73 id, +81 rank, +82 zone, +90 online: 91 bytes after 0x53
const auto expected = Bytes::Header(CLIENT, 43).WStr(u"Bob", 33).U64(OTHER).U8(4).Zone(1200, 3, 0).U8(1);
EXPECT_EQ(expected.data.size(), 92u);
EXPECT_PACKET_EQ(expected.Packet(), StructPacket(add));
const auto copy = RoundTrip(add);
EXPECT_EQ(copy.zoneID, add.zoneID);
ExpectTruncatedFails(add);
}
TEST_F(GuildPacketsTests, RemovePlayer) {
ClientPackets::GuildRemovePlayer remove;
remove.reason = eGuildLeaveReason::KICKED;
remove.playerName = "Bob";
remove.playerID = OTHER;
remove.newLeaderID = PLAYER;
// +7 reason, +8 name, +74 id, +82 new leader
const auto expected = Bytes::Header(CLIENT, 44).U8(1).WStr(u"Bob", 33).U64(OTHER).U64(PLAYER);
EXPECT_EQ(expected.data.size(), 91u);
EXPECT_PACKET_EQ(expected.Packet(), StructPacket(remove));
RoundTrip(remove);
}
TEST_F(GuildPacketsTests, LoginLogout) {
ClientPackets::GuildLoginLogout login;
login.playerName = "Bob";
login.playerID = OTHER;
login.online = true;
login.zoneID = LWOZONEID(1100, 2, 0);
login.worldUpdateOnly = true;
// +7 name, +73 id, +81 online, +82 zone, +90 world update only
const auto expected = Bytes::Header(CLIENT, 45).WStr(u"Bob", 33).U64(OTHER).U8(1).Zone(1100, 2, 0).U8(1);
EXPECT_EQ(expected.data.size(), 92u);
EXPECT_PACKET_EQ(expected.Packet(), StructPacket(login));
RoundTrip(login);
}
TEST_F(GuildPacketsTests, Data) {
ClientPackets::GuildData data;
data.guildName = "Brick Builders";
data.joinDate = "01/02/2026";
data.foundDate = "12/31/2025";
data.members.push_back({ eGuildRank::LEADER, true, LWOZONEID(1200, 1, 0), PLAYER, "Alice" });
data.members.push_back({ eGuildRank::RECRUIT, false, LWOZONEID(0, 0, 0), OTHER, "Bob" });
// +7 status, +8 name, +70 date, +92 date, +114 reputation, +118..127, +128 count, +130 members of 84 bytes
auto expected = Bytes::Header(CLIENT, 47).U8(0).WStr(u"Brick Builders", 31).WStr(u"01/02/2026", 11).WStr(u"12/31/2025", 11)
.U32(0).U32(0).U32(0).U16(0).U16(2);
EXPECT_EQ(expected.data.size(), 131u);
expected.U8(1).U8(1).Zone(1200, 1, 0).U64(PLAYER).WStr(u"Alice", 33);
expected.U8(4).U8(0).Zone(0, 0, 0).U64(OTHER).WStr(u"Bob", 33);
EXPECT_EQ(expected.data.size(), 131u + 2 * 84u);
EXPECT_PACKET_EQ(expected.Packet(), StructPacket(data));
const auto copy = RoundTrip(data);
ASSERT_EQ(copy.members.size(), 2u);
EXPECT_EQ(copy.members[0].name, "Alice");
EXPECT_EQ(copy.members[1].playerID, OTHER);
ExpectTruncatedFails(data);
}
// ---- Client -> server ----
TEST_F(GuildPacketsTests, TmpGuildCreateFromClient) {
// What SendTMPGuildCreate sends (69 bytes after 0x53): header, wchar[31]
const auto bytes = Bytes::Header(WORLD, 20).WStr(u"Brick Builders", 31);
RakNet::BitStream stream(const_cast<unsigned char*>(bytes.data.data()), bytes.data.size(), false);
LUBitStream header;
ASSERT_TRUE(header.ReadHeader(stream));
EXPECT_EQ(header.connectionType, ServiceType::WORLD);
EXPECT_EQ(header.internalPacketID, static_cast<uint32_t>(MessageType::World::TMP_GUILD_CREATE));
WorldPackets::TmpGuildCreate create;
ASSERT_TRUE(create.Deserialize(stream));
EXPECT_EQ(create.guildName, u"Brick Builders");
EXPECT_EQ(stream.GetNumberOfUnreadBits(), 0u);
EXPECT_PACKET_EQ(bytes.Packet(), StructPacket(create));
}
TEST_F(GuildPacketsTests, RoutedFromClientToChat) {
// The client's GUILD_INVITE (81 bytes after 0x53): header, u64 0, wchar[33]; the world routes it to chat with the
// sender in front and the first 4 bytes of the data dropped
WorldPackets::RoutePacket route;
const auto routed = Bytes().U64(0).WStr(u"Bob", 33);
route.size = static_cast<uint32_t>(routed.data.size());
route.routedService = ServiceType::CHAT;
route.routedMessageID = static_cast<uint32_t>(MessageType::Chat::GUILD_INVITE);
route.routedData = routed.data;
RakNet::BitStream bitStream;
route.ToChat(PLAYER).WritePacket(bitStream);
bitStream.ResetReadPointer();
LUBitStream header;
ASSERT_TRUE(header.ReadHeader(bitStream));
EXPECT_EQ(header.internalPacketID, static_cast<uint32_t>(MessageType::Chat::GUILD_INVITE));
ChatPackets::GuildInvite invite;
ASSERT_TRUE(invite.Deserialize(bitStream));
EXPECT_EQ(invite.playerID, PLAYER);
EXPECT_EQ(invite.invitedPlayer.GetAsString(), "Bob");
// GUILD_INVITE_RESPONSE (16 bytes): u64 0, u8 declined
route.routedMessageID = static_cast<uint32_t>(MessageType::Chat::GUILD_INVITE_RESPONSE);
route.routedData = Bytes().U64(0).U8(1).data;
route.size = 9;
RakNet::BitStream responseStream;
route.ToChat(PLAYER).WritePacket(responseStream);
ASSERT_TRUE(header.ReadHeader(responseStream));
ChatPackets::GuildInviteResponse response;
ASSERT_TRUE(response.Deserialize(responseStream));
EXPECT_EQ(response.playerID, PLAYER);
EXPECT_EQ(response.declined, 1);
// GUILD_LEAVE: the client says it is 81 bytes long; everything after the u64 is ignored
route.routedMessageID = static_cast<uint32_t>(MessageType::Chat::GUILD_LEAVE);
route.routedData = Bytes().U64(0).WStr(u"garbage", 33).data;
route.size = 74;
RakNet::BitStream leaveStream;
route.ToChat(PLAYER).WritePacket(leaveStream);
ASSERT_TRUE(header.ReadHeader(leaveStream));
ChatPackets::GuildLeave leave;
ASSERT_TRUE(leave.Deserialize(leaveStream));
EXPECT_EQ(leave.playerID, PLAYER);
// GUILD_GET_ALL (15 bytes): u64 0
route.routedMessageID = static_cast<uint32_t>(MessageType::Chat::GUILD_GET_ALL);
route.routedData = Bytes().U64(0).data;
route.size = 8;
RakNet::BitStream getAllStream;
route.ToChat(PLAYER).WritePacket(getAllStream);
ASSERT_TRUE(header.ReadHeader(getAllStream));
ChatPackets::GuildGetAll getAll;
ASSERT_TRUE(getAll.Deserialize(getAllStream));
EXPECT_EQ(getAll.playerID, PLAYER);
EXPECT_EQ(getAllStream.GetNumberOfUnreadBits(), 0u);
}
// ---- DLU's world <-> chat packets ----
TEST_F(GuildPacketsTests, WorldChatPackets) {
ChatPackets::GuildCreate create;
create.playerID = PLAYER;
create.guildName = LUWString(u"Brick Builders", 31);
EXPECT_PACKET_EQ(Bytes::Header(CHAT, 22).U64(PLAYER).WStr(u"Brick Builders", 31).Packet(), StructPacket(create));
RoundTrip(create);
ChatPackets::GuildKick kick;
kick.playerID = PLAYER;
kick.kickedPlayer = LUWString(u"Bob", 33);
EXPECT_PACKET_EQ(Bytes::Header(CHAT, 26).U64(PLAYER).U32(0).WStr(u"Bob", 33).Packet(), StructPacket(kick));
RoundTrip(kick);
ChatPackets::GuildSetRank rank;
rank.playerID = PLAYER;
rank.targetPlayer = LUWString(u"Bob", 33);
rank.rank = 2;
EXPECT_EQ(static_cast<uint32_t>(MessageType::Chat::GUILD_SET_RANK), static_cast<uint32_t>(MessageType::Chat::CREATE_TEAM) + 1);
RoundTrip(rank);
ChatPackets::GuildDisband disband;
disband.playerID = PLAYER;
EXPECT_EQ(static_cast<uint32_t>(MessageType::Chat::GUILD_DISBAND), static_cast<uint32_t>(MessageType::Chat::CREATE_TEAM) + 2);
RoundTrip(disband);
ChatPackets::GuildStatus status;
status.characterID = PLAYER;
status.guildID = 7;
status.guildName = LUWString(u"Brick Builders", 31);
EXPECT_PACKET_EQ(Bytes::Header(CHAT, 27).U64(PLAYER).U64(7).WStr(u"Brick Builders", 31).Packet(), StructPacket(status));
RoundTrip(status);
}
// ---- Game message ----
TEST_F(GuildPacketsTests, DisplayGuildCreateBox) {
GameMessages::DisplayGuildCreateBox box;
box.target = PLAYER;
// header 53 05 00 0c 00 00 00 00, target, msgId 626 (u16), bShow bit
EXPECT_PACKET_EQ(FromHex("5305000c00000000" "2301000000000010" "7202" "80", 145), GameMessageTestUtils::StructPacket(box));
RoundTrip(box);
}
Reference in New Issue View Git Blame Copy Permalink