From af4acff261d579428e8eef042cc5359fa392f725 Mon Sep 17 00:00:00 2001 From: Ben Longbons Date: Tue, 27 May 2014 13:33:54 -0700 Subject: Generate the char server protocol --- src/proto2/any-user.hpp | 42 + src/proto2/char-map.hpp | 3428 +++++++++++++++++++++++++++++++++++++ src/proto2/char-user.hpp | 580 +++++++ src/proto2/fwd.hpp | 459 ++++- src/proto2/include_enums_test.cpp | 1 + src/proto2/include_mmo_test.cpp | 26 + src/proto2/include_strs_test.cpp | 3 + src/proto2/login-admin.hpp | 5 + src/proto2/login-char.hpp | 15 +- src/proto2/login-user.hpp | 40 +- src/proto2/map-user.hpp | 5 + src/proto2/types.hpp | 291 ++++ 12 files changed, 4852 insertions(+), 43 deletions(-) create mode 100644 src/proto2/include_mmo_test.cpp (limited to 'src/proto2') diff --git a/src/proto2/any-user.hpp b/src/proto2/any-user.hpp index d704233..da9b1bc 100644 --- a/src/proto2/any-user.hpp +++ b/src/proto2/any-user.hpp @@ -27,6 +27,19 @@ // This is a public protocol, and changes require client cooperation +// this is only needed for the payload packet right now, and that needs to die +#pragma pack(push, 1) + +template<> +struct Packet_Fixed<0x0081> +{ + static const uint16_t PACKET_ID = 0x0081; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t error_code = {}; +}; + template<> struct Packet_Fixed<0x7530> { @@ -56,6 +69,16 @@ struct Packet_Fixed<0x7532> }; +template<> +struct NetPacket_Fixed<0x0081> +{ + Little16 magic_packet_id; + Byte error_code; +}; +static_assert(offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0081>, error_code) == 2, "offsetof(NetPacket_Fixed<0x0081>, error_code) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x0081>) == 3, "sizeof(NetPacket_Fixed<0x0081>) == 3"); + template<> struct NetPacket_Fixed<0x7530> { @@ -83,6 +106,23 @@ static_assert(offsetof(NetPacket_Fixed<0x7532>, magic_packet_id) == 0, "offsetof static_assert(sizeof(NetPacket_Fixed<0x7532>) == 2, "sizeof(NetPacket_Fixed<0x7532>) == 2"); +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0081> *network, Packet_Fixed<0x0081> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->error_code, native.error_code); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0081> *native, NetPacket_Fixed<0x0081> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->error_code, network.error_code); + return rv; +} + inline __attribute__((warn_unused_result)) bool native_to_network(NetPacket_Fixed<0x7530> *network, Packet_Fixed<0x7530> native) { @@ -131,4 +171,6 @@ bool network_to_native(Packet_Fixed<0x7532> *native, NetPacket_Fixed<0x7532> net } +#pragma pack(pop) + #endif // TMWA_PROTO2_ANY_USER_HPP diff --git a/src/proto2/char-map.hpp b/src/proto2/char-map.hpp index 83f13a7..333c948 100644 --- a/src/proto2/char-map.hpp +++ b/src/proto2/char-map.hpp @@ -27,7 +27,3435 @@ // This is an internal protocol, and can be changed without notice +// this is only needed for the payload packet right now, and that needs to die +#pragma pack(push, 1) +template<> +struct Packet_Fixed<0x2af7> +{ + static const uint16_t PACKET_ID = 0x2af7; + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; +}; + +template<> +struct Packet_Fixed<0x2af8> +{ + static const uint16_t PACKET_ID = 0x2af8; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountName account_name = {}; + AccountPass account_pass = {}; + uint32_t unused = {}; + IP4Address ip = {}; + uint16_t port = {}; +}; + +template<> +struct Packet_Fixed<0x2af9> +{ + static const uint16_t PACKET_ID = 0x2af9; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t code = {}; +}; + +template<> +struct Packet_Head<0x2afa> +{ + static const uint16_t PACKET_ID = 0x2afa; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; +}; +template<> +struct Packet_Repeat<0x2afa> +{ + static const uint16_t PACKET_ID = 0x2afa; + + MapName map_name = {}; +}; + +template<> +struct Packet_Fixed<0x2afa> +{ + static const uint16_t PACKET_ID = 0x2afa; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + ItemNameId source_item_id = {}; + ItemNameId dest_item_id = {}; +}; + +template<> +struct Packet_Fixed<0x2afb> +{ + static const uint16_t PACKET_ID = 0x2afb; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t unknown = {}; + CharName whisper_name = {}; +}; + +template<> +struct Packet_Fixed<0x2afc> +{ + static const uint16_t PACKET_ID = 0x2afc; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + CharId char_id = {}; + uint32_t login_id1 = {}; + uint32_t login_id2 = {}; + IP4Address ip = {}; +}; + +template<> +struct Packet_Payload<0x2afd> +{ + static const uint16_t PACKET_ID = 0x2afd; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; + uint32_t login_id2 = {}; + TimeT connect_until = {}; + uint16_t packet_tmw_version = {}; + CharKey char_key = {}; + CharData char_data = {}; +}; + +template<> +struct Packet_Fixed<0x2afe> +{ + static const uint16_t PACKET_ID = 0x2afe; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; +}; + +template<> +struct Packet_Head<0x2aff> +{ + static const uint16_t PACKET_ID = 0x2aff; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + uint16_t users = {}; +}; +template<> +struct Packet_Repeat<0x2aff> +{ + static const uint16_t PACKET_ID = 0x2aff; + + CharId char_id = {}; +}; + +template<> +struct Packet_Fixed<0x2b00> +{ + static const uint16_t PACKET_ID = 0x2b00; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint32_t users = {}; +}; + +template<> +struct Packet_Payload<0x2b01> +{ + static const uint16_t PACKET_ID = 0x2b01; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; + CharId char_id = {}; + CharKey char_key = {}; + CharData char_data = {}; +}; + +template<> +struct Packet_Fixed<0x2b02> +{ + static const uint16_t PACKET_ID = 0x2b02; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint32_t login_id1 = {}; + uint32_t login_id2 = {}; + IP4Address ip = {}; +}; + +template<> +struct Packet_Fixed<0x2b03> +{ + static const uint16_t PACKET_ID = 0x2b03; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint8_t unknown = {}; +}; + +template<> +struct Packet_Head<0x2b04> +{ + static const uint16_t PACKET_ID = 0x2b04; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + IP4Address ip = {}; + uint16_t port = {}; +}; +template<> +struct Packet_Repeat<0x2b04> +{ + static const uint16_t PACKET_ID = 0x2b04; + + MapName map_name = {}; +}; + +template<> +struct Packet_Fixed<0x2b05> +{ + static const uint16_t PACKET_ID = 0x2b05; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint32_t login_id1 = {}; + uint32_t login_id2 = {}; + CharId char_id = {}; + MapName map_name = {}; + uint16_t x = {}; + uint16_t y = {}; + IP4Address map_ip = {}; + uint16_t map_port = {}; + SEX sex = {}; + IP4Address client_ip = {}; +}; + +template<> +struct Packet_Fixed<0x2b06> +{ + static const uint16_t PACKET_ID = 0x2b06; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint32_t error = {}; + uint32_t unknown = {}; + CharId char_id = {}; + MapName map_name = {}; + uint16_t x = {}; + uint16_t y = {}; + IP4Address map_ip = {}; + uint16_t map_port = {}; +}; + +template<> +struct Packet_Head<0x2b0a> +{ + static const uint16_t PACKET_ID = 0x2b0a; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; +}; +template<> +struct Packet_Repeat<0x2b0a> +{ + static const uint16_t PACKET_ID = 0x2b0a; + + uint8_t c = {}; +}; + +template<> +struct Packet_Fixed<0x2b0b> +{ + static const uint16_t PACKET_ID = 0x2b0b; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + GmLevel gm_level = {}; +}; + +template<> +struct Packet_Fixed<0x2b0c> +{ + static const uint16_t PACKET_ID = 0x2b0c; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + AccountEmail old_email = {}; + AccountEmail new_email = {}; +}; + +template<> +struct Packet_Fixed<0x2b0d> +{ + static const uint16_t PACKET_ID = 0x2b0d; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + SEX sex = {}; +}; + +template<> +struct Packet_Fixed<0x2b0e> +{ + static const uint16_t PACKET_ID = 0x2b0e; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + CharName char_name = {}; + uint16_t operation = {}; + HumanTimeDiff ban_add = {}; +}; + +template<> +struct Packet_Fixed<0x2b0f> +{ + static const uint16_t PACKET_ID = 0x2b0f; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + CharName char_name = {}; + uint16_t operation = {}; + uint16_t error = {}; +}; + +template<> +struct Packet_Head<0x2b10> +{ + static const uint16_t PACKET_ID = 0x2b10; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; +}; +template<> +struct Packet_Repeat<0x2b10> +{ + static const uint16_t PACKET_ID = 0x2b10; + + VarName name = {}; + uint32_t value = {}; +}; + +template<> +struct Packet_Head<0x2b11> +{ + static const uint16_t PACKET_ID = 0x2b11; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; +}; +template<> +struct Packet_Repeat<0x2b11> +{ + static const uint16_t PACKET_ID = 0x2b11; + + VarName name = {}; + uint32_t value = {}; +}; + +template<> +struct Packet_Fixed<0x2b12> +{ + static const uint16_t PACKET_ID = 0x2b12; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharId char_id = {}; + CharId partner_id = {}; +}; + +template<> +struct Packet_Fixed<0x2b13> +{ + static const uint16_t PACKET_ID = 0x2b13; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; +}; + +template<> +struct Packet_Fixed<0x2b14> +{ + static const uint16_t PACKET_ID = 0x2b14; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint8_t ban_not_status = {}; + TimeT status_or_ban_until = {}; +}; + +template<> +struct Packet_Head<0x2b15> +{ + static const uint16_t PACKET_ID = 0x2b15; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; +}; +template<> +struct Packet_Repeat<0x2b15> +{ + static const uint16_t PACKET_ID = 0x2b15; + + AccountId account_id = {}; + GmLevel gm_level = {}; +}; + +template<> +struct Packet_Fixed<0x2b16> +{ + static const uint16_t PACKET_ID = 0x2b16; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharId char_id = {}; +}; + +template<> +struct Packet_Head<0x3000> +{ + static const uint16_t PACKET_ID = 0x3000; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; +}; +template<> +struct Packet_Repeat<0x3000> +{ + static const uint16_t PACKET_ID = 0x3000; + + uint8_t c = {}; +}; + +template<> +struct Packet_Head<0x3001> +{ + static const uint16_t PACKET_ID = 0x3001; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + CharName from_char_name = {}; + CharName to_char_name = {}; +}; +template<> +struct Packet_Repeat<0x3001> +{ + static const uint16_t PACKET_ID = 0x3001; + + uint8_t c = {}; +}; + +template<> +struct Packet_Fixed<0x3002> +{ + static const uint16_t PACKET_ID = 0x3002; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharId char_id = {}; + uint8_t flag = {}; +}; + +template<> +struct Packet_Head<0x3003> +{ + static const uint16_t PACKET_ID = 0x3003; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + CharName char_name = {}; + GmLevel min_gm_level = {}; +}; +template<> +struct Packet_Repeat<0x3003> +{ + static const uint16_t PACKET_ID = 0x3003; + + uint8_t c = {}; +}; + +template<> +struct Packet_Head<0x3004> +{ + static const uint16_t PACKET_ID = 0x3004; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; +}; +template<> +struct Packet_Repeat<0x3004> +{ + static const uint16_t PACKET_ID = 0x3004; + + VarName name = {}; + uint32_t value = {}; +}; + +template<> +struct Packet_Fixed<0x3005> +{ + static const uint16_t PACKET_ID = 0x3005; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; +}; + +template<> +struct Packet_Fixed<0x3010> +{ + static const uint16_t PACKET_ID = 0x3010; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; +}; + +template<> +struct Packet_Payload<0x3011> +{ + static const uint16_t PACKET_ID = 0x3011; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; + Storage storage = {}; +}; + +template<> +struct Packet_Fixed<0x3020> +{ + static const uint16_t PACKET_ID = 0x3020; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + PartyName party_name = {}; + CharName char_name = {}; + MapName map_name = {}; + uint16_t level = {}; +}; + +template<> +struct Packet_Fixed<0x3021> +{ + static const uint16_t PACKET_ID = 0x3021; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; +}; + +template<> +struct Packet_Fixed<0x3022> +{ + static const uint16_t PACKET_ID = 0x3022; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + CharName char_name = {}; + MapName map_name = {}; + uint16_t level = {}; +}; + +template<> +struct Packet_Fixed<0x3023> +{ + static const uint16_t PACKET_ID = 0x3023; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + uint16_t exp = {}; + uint16_t item = {}; +}; + +template<> +struct Packet_Fixed<0x3024> +{ + static const uint16_t PACKET_ID = 0x3024; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; +}; + +template<> +struct Packet_Fixed<0x3025> +{ + static const uint16_t PACKET_ID = 0x3025; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + MapName map_name = {}; + uint8_t online = {}; + uint16_t level = {}; +}; + +template<> +struct Packet_Fixed<0x3026> +{ + static const uint16_t PACKET_ID = 0x3026; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; +}; + +template<> +struct Packet_Head<0x3027> +{ + static const uint16_t PACKET_ID = 0x3027; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + PartyId party_id = {}; + AccountId account_id = {}; +}; +template<> +struct Packet_Repeat<0x3027> +{ + static const uint16_t PACKET_ID = 0x3027; + + uint8_t c = {}; +}; + +template<> +struct Packet_Fixed<0x3028> +{ + static const uint16_t PACKET_ID = 0x3028; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + CharName char_name = {}; +}; + +template<> +struct Packet_Head<0x3800> +{ + static const uint16_t PACKET_ID = 0x3800; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; +}; +template<> +struct Packet_Repeat<0x3800> +{ + static const uint16_t PACKET_ID = 0x3800; + + uint8_t c = {}; +}; + +template<> +struct Packet_Head<0x3801> +{ + static const uint16_t PACKET_ID = 0x3801; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + CharId whisper_id = {}; + CharName src_char_name = {}; + CharName dst_char_name = {}; +}; +template<> +struct Packet_Repeat<0x3801> +{ + static const uint16_t PACKET_ID = 0x3801; + + uint8_t c = {}; +}; + +template<> +struct Packet_Fixed<0x3802> +{ + static const uint16_t PACKET_ID = 0x3802; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharName sender_char_name = {}; + uint8_t flag = {}; +}; + +template<> +struct Packet_Head<0x3803> +{ + static const uint16_t PACKET_ID = 0x3803; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + CharName char_name = {}; + GmLevel min_gm_level = {}; +}; +template<> +struct Packet_Repeat<0x3803> +{ + static const uint16_t PACKET_ID = 0x3803; + + uint8_t c = {}; +}; + +template<> +struct Packet_Head<0x3804> +{ + static const uint16_t PACKET_ID = 0x3804; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; +}; +template<> +struct Packet_Repeat<0x3804> +{ + static const uint16_t PACKET_ID = 0x3804; + + VarName name = {}; + uint32_t value = {}; +}; + +template<> +struct Packet_Payload<0x3810> +{ + static const uint16_t PACKET_ID = 0x3810; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + AccountId account_id = {}; + Storage storage = {}; +}; + +template<> +struct Packet_Fixed<0x3811> +{ + static const uint16_t PACKET_ID = 0x3811; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint8_t unknown = {}; +}; + +template<> +struct Packet_Fixed<0x3820> +{ + static const uint16_t PACKET_ID = 0x3820; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint8_t error = {}; + PartyId party_id = {}; + PartyName party_name = {}; +}; + +template<> +struct Packet_Head<0x3821> +{ + static const uint16_t PACKET_ID = 0x3821; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + PartyId party_id = {}; +}; +template<> +struct Packet_Option<0x3821> +{ + static const uint16_t PACKET_ID = 0x3821; + + PartyMost party_most = {}; +}; + +template<> +struct Packet_Fixed<0x3822> +{ + static const uint16_t PACKET_ID = 0x3822; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + uint8_t flag = {}; +}; + +template<> +struct Packet_Fixed<0x3823> +{ + static const uint16_t PACKET_ID = 0x3823; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + uint16_t exp = {}; + uint16_t item = {}; + uint8_t flag = {}; +}; + +template<> +struct Packet_Fixed<0x3824> +{ + static const uint16_t PACKET_ID = 0x3824; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + CharName char_name = {}; +}; + +template<> +struct Packet_Fixed<0x3825> +{ + static const uint16_t PACKET_ID = 0x3825; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + AccountId account_id = {}; + MapName map_name = {}; + uint8_t online = {}; + uint16_t level = {}; +}; + +template<> +struct Packet_Fixed<0x3826> +{ + static const uint16_t PACKET_ID = 0x3826; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + PartyId party_id = {}; + uint8_t flag = {}; +}; + +template<> +struct Packet_Head<0x3827> +{ + static const uint16_t PACKET_ID = 0x3827; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + PartyId party_id = {}; + AccountId account_id = {}; +}; +template<> +struct Packet_Repeat<0x3827> +{ + static const uint16_t PACKET_ID = 0x3827; + + uint8_t c = {}; +}; + + +template<> +struct NetPacket_Fixed<0x2af7> +{ + Little16 magic_packet_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x2af7>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2af7>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x2af7>) == 2, "sizeof(NetPacket_Fixed<0x2af7>) == 2"); + +template<> +struct NetPacket_Fixed<0x2af8> +{ + Little16 magic_packet_id; + NetString account_name; + NetString account_pass; + Little32 unused; + IP4Address ip; + Little16 port; +}; +static_assert(offsetof(NetPacket_Fixed<0x2af8>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2af8>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2af8>, account_name) == 2, "offsetof(NetPacket_Fixed<0x2af8>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2af8>, account_pass) == 26, "offsetof(NetPacket_Fixed<0x2af8>, account_pass) == 26"); +static_assert(offsetof(NetPacket_Fixed<0x2af8>, unused) == 50, "offsetof(NetPacket_Fixed<0x2af8>, unused) == 50"); +static_assert(offsetof(NetPacket_Fixed<0x2af8>, ip) == 54, "offsetof(NetPacket_Fixed<0x2af8>, ip) == 54"); +static_assert(offsetof(NetPacket_Fixed<0x2af8>, port) == 58, "offsetof(NetPacket_Fixed<0x2af8>, port) == 58"); +static_assert(sizeof(NetPacket_Fixed<0x2af8>) == 60, "sizeof(NetPacket_Fixed<0x2af8>) == 60"); + +template<> +struct NetPacket_Fixed<0x2af9> +{ + Little16 magic_packet_id; + Byte code; +}; +static_assert(offsetof(NetPacket_Fixed<0x2af9>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2af9>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2af9>, code) == 2, "offsetof(NetPacket_Fixed<0x2af9>, code) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2af9>) == 3, "sizeof(NetPacket_Fixed<0x2af9>) == 3"); + +template<> +struct NetPacket_Head<0x2afa> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; +}; +static_assert(offsetof(NetPacket_Head<0x2afa>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2afa>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2afa>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2afa>, magic_packet_length) == 2"); +static_assert(sizeof(NetPacket_Head<0x2afa>) == 4, "sizeof(NetPacket_Head<0x2afa>) == 4"); +template<> +struct NetPacket_Repeat<0x2afa> +{ + NetString map_name; +}; +static_assert(offsetof(NetPacket_Repeat<0x2afa>, map_name) == 0, "offsetof(NetPacket_Repeat<0x2afa>, map_name) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x2afa>) == 16, "sizeof(NetPacket_Repeat<0x2afa>) == 16"); + +template<> +struct NetPacket_Fixed<0x2afa> +{ + Little16 magic_packet_id; + Little32 source_item_id; + Little32 dest_item_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x2afa>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afa>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2afa>, source_item_id) == 2, "offsetof(NetPacket_Fixed<0x2afa>, source_item_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2afa>, dest_item_id) == 6, "offsetof(NetPacket_Fixed<0x2afa>, dest_item_id) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2afa>) == 10, "sizeof(NetPacket_Fixed<0x2afa>) == 10"); + +template<> +struct NetPacket_Fixed<0x2afb> +{ + Little16 magic_packet_id; + Byte unknown; + NetString whisper_name; +}; +static_assert(offsetof(NetPacket_Fixed<0x2afb>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afb>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2afb>, unknown) == 2, "offsetof(NetPacket_Fixed<0x2afb>, unknown) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2afb>, whisper_name) == 3, "offsetof(NetPacket_Fixed<0x2afb>, whisper_name) == 3"); +static_assert(sizeof(NetPacket_Fixed<0x2afb>) == 27, "sizeof(NetPacket_Fixed<0x2afb>) == 27"); + +template<> +struct NetPacket_Fixed<0x2afc> +{ + Little16 magic_packet_id; + Little32 account_id; + Little32 char_id; + Little32 login_id1; + Little32 login_id2; + IP4Address ip; +}; +static_assert(offsetof(NetPacket_Fixed<0x2afc>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afc>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2afc>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2afc>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2afc>, char_id) == 6, "offsetof(NetPacket_Fixed<0x2afc>, char_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2afc>, login_id1) == 10, "offsetof(NetPacket_Fixed<0x2afc>, login_id1) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x2afc>, login_id2) == 14, "offsetof(NetPacket_Fixed<0x2afc>, login_id2) == 14"); +static_assert(offsetof(NetPacket_Fixed<0x2afc>, ip) == 18, "offsetof(NetPacket_Fixed<0x2afc>, ip) == 18"); +static_assert(sizeof(NetPacket_Fixed<0x2afc>) == 22, "sizeof(NetPacket_Fixed<0x2afc>) == 22"); + +template<> +struct NetPacket_Payload<0x2afd> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; + Little32 login_id2; + Little32 connect_until; + Little16 packet_tmw_version; + CharKey char_key; + CharData char_data; +}; +static_assert(offsetof(NetPacket_Payload<0x2afd>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x2afd>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Payload<0x2afd>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x2afd>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Payload<0x2afd>, account_id) == 4, "offsetof(NetPacket_Payload<0x2afd>, account_id) == 4"); +static_assert(offsetof(NetPacket_Payload<0x2afd>, login_id2) == 8, "offsetof(NetPacket_Payload<0x2afd>, login_id2) == 8"); +static_assert(offsetof(NetPacket_Payload<0x2afd>, connect_until) == 12, "offsetof(NetPacket_Payload<0x2afd>, connect_until) == 12"); +static_assert(offsetof(NetPacket_Payload<0x2afd>, packet_tmw_version) == 16, "offsetof(NetPacket_Payload<0x2afd>, packet_tmw_version) == 16"); +static_assert(offsetof(NetPacket_Payload<0x2afd>, char_key) == 18, "offsetof(NetPacket_Payload<0x2afd>, char_key) == 18"); + +template<> +struct NetPacket_Fixed<0x2afe> +{ + Little16 magic_packet_id; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x2afe>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2afe>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2afe>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2afe>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2afe>) == 6, "sizeof(NetPacket_Fixed<0x2afe>) == 6"); + +template<> +struct NetPacket_Head<0x2aff> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little16 users; +}; +static_assert(offsetof(NetPacket_Head<0x2aff>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2aff>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2aff>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2aff>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2aff>, users) == 4, "offsetof(NetPacket_Head<0x2aff>, users) == 4"); +static_assert(sizeof(NetPacket_Head<0x2aff>) == 6, "sizeof(NetPacket_Head<0x2aff>) == 6"); +template<> +struct NetPacket_Repeat<0x2aff> +{ + Little32 char_id; +}; +static_assert(offsetof(NetPacket_Repeat<0x2aff>, char_id) == 0, "offsetof(NetPacket_Repeat<0x2aff>, char_id) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x2aff>) == 4, "sizeof(NetPacket_Repeat<0x2aff>) == 4"); + +template<> +struct NetPacket_Fixed<0x2b00> +{ + Little16 magic_packet_id; + Little32 users; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b00>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b00>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b00>, users) == 2, "offsetof(NetPacket_Fixed<0x2b00>, users) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2b00>) == 6, "sizeof(NetPacket_Fixed<0x2b00>) == 6"); + +template<> +struct NetPacket_Payload<0x2b01> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; + Little32 char_id; + CharKey char_key; + CharData char_data; +}; +static_assert(offsetof(NetPacket_Payload<0x2b01>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x2b01>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Payload<0x2b01>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x2b01>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Payload<0x2b01>, account_id) == 4, "offsetof(NetPacket_Payload<0x2b01>, account_id) == 4"); +static_assert(offsetof(NetPacket_Payload<0x2b01>, char_id) == 8, "offsetof(NetPacket_Payload<0x2b01>, char_id) == 8"); +static_assert(offsetof(NetPacket_Payload<0x2b01>, char_key) == 12, "offsetof(NetPacket_Payload<0x2b01>, char_key) == 12"); + +template<> +struct NetPacket_Fixed<0x2b02> +{ + Little16 magic_packet_id; + Little32 account_id; + Little32 login_id1; + Little32 login_id2; + IP4Address ip; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b02>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b02>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b02>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b02>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b02>, login_id1) == 6, "offsetof(NetPacket_Fixed<0x2b02>, login_id1) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2b02>, login_id2) == 10, "offsetof(NetPacket_Fixed<0x2b02>, login_id2) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x2b02>, ip) == 14, "offsetof(NetPacket_Fixed<0x2b02>, ip) == 14"); +static_assert(sizeof(NetPacket_Fixed<0x2b02>) == 18, "sizeof(NetPacket_Fixed<0x2b02>) == 18"); + +template<> +struct NetPacket_Fixed<0x2b03> +{ + Little16 magic_packet_id; + Little32 account_id; + Byte unknown; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b03>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b03>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b03>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b03>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b03>, unknown) == 6, "offsetof(NetPacket_Fixed<0x2b03>, unknown) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2b03>) == 7, "sizeof(NetPacket_Fixed<0x2b03>) == 7"); + +template<> +struct NetPacket_Head<0x2b04> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + IP4Address ip; + Little16 port; +}; +static_assert(offsetof(NetPacket_Head<0x2b04>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b04>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2b04>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b04>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2b04>, ip) == 4, "offsetof(NetPacket_Head<0x2b04>, ip) == 4"); +static_assert(offsetof(NetPacket_Head<0x2b04>, port) == 8, "offsetof(NetPacket_Head<0x2b04>, port) == 8"); +static_assert(sizeof(NetPacket_Head<0x2b04>) == 10, "sizeof(NetPacket_Head<0x2b04>) == 10"); +template<> +struct NetPacket_Repeat<0x2b04> +{ + NetString map_name; +}; +static_assert(offsetof(NetPacket_Repeat<0x2b04>, map_name) == 0, "offsetof(NetPacket_Repeat<0x2b04>, map_name) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x2b04>) == 16, "sizeof(NetPacket_Repeat<0x2b04>) == 16"); + +template<> +struct NetPacket_Fixed<0x2b05> +{ + Little16 magic_packet_id; + Little32 account_id; + Little32 login_id1; + Little32 login_id2; + Little32 char_id; + NetString map_name; + Little16 x; + Little16 y; + IP4Address map_ip; + Little16 map_port; + Byte sex; + IP4Address client_ip; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b05>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b05>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b05>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, login_id1) == 6, "offsetof(NetPacket_Fixed<0x2b05>, login_id1) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, login_id2) == 10, "offsetof(NetPacket_Fixed<0x2b05>, login_id2) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, char_id) == 14, "offsetof(NetPacket_Fixed<0x2b05>, char_id) == 14"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, map_name) == 18, "offsetof(NetPacket_Fixed<0x2b05>, map_name) == 18"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, x) == 34, "offsetof(NetPacket_Fixed<0x2b05>, x) == 34"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, y) == 36, "offsetof(NetPacket_Fixed<0x2b05>, y) == 36"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, map_ip) == 38, "offsetof(NetPacket_Fixed<0x2b05>, map_ip) == 38"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, map_port) == 42, "offsetof(NetPacket_Fixed<0x2b05>, map_port) == 42"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, sex) == 44, "offsetof(NetPacket_Fixed<0x2b05>, sex) == 44"); +static_assert(offsetof(NetPacket_Fixed<0x2b05>, client_ip) == 45, "offsetof(NetPacket_Fixed<0x2b05>, client_ip) == 45"); +static_assert(sizeof(NetPacket_Fixed<0x2b05>) == 49, "sizeof(NetPacket_Fixed<0x2b05>) == 49"); + +template<> +struct NetPacket_Fixed<0x2b06> +{ + Little16 magic_packet_id; + Little32 account_id; + Little32 error; + Little32 unknown; + Little32 char_id; + NetString map_name; + Little16 x; + Little16 y; + IP4Address map_ip; + Little16 map_port; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b06>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b06>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b06>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, error) == 6, "offsetof(NetPacket_Fixed<0x2b06>, error) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, unknown) == 10, "offsetof(NetPacket_Fixed<0x2b06>, unknown) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, char_id) == 14, "offsetof(NetPacket_Fixed<0x2b06>, char_id) == 14"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, map_name) == 18, "offsetof(NetPacket_Fixed<0x2b06>, map_name) == 18"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, x) == 34, "offsetof(NetPacket_Fixed<0x2b06>, x) == 34"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, y) == 36, "offsetof(NetPacket_Fixed<0x2b06>, y) == 36"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, map_ip) == 38, "offsetof(NetPacket_Fixed<0x2b06>, map_ip) == 38"); +static_assert(offsetof(NetPacket_Fixed<0x2b06>, map_port) == 42, "offsetof(NetPacket_Fixed<0x2b06>, map_port) == 42"); +static_assert(sizeof(NetPacket_Fixed<0x2b06>) == 44, "sizeof(NetPacket_Fixed<0x2b06>) == 44"); + +template<> +struct NetPacket_Head<0x2b0a> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Head<0x2b0a>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b0a>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2b0a>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b0a>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2b0a>, account_id) == 4, "offsetof(NetPacket_Head<0x2b0a>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x2b0a>) == 8, "sizeof(NetPacket_Head<0x2b0a>) == 8"); +template<> +struct NetPacket_Repeat<0x2b0a> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x2b0a>, c) == 0, "offsetof(NetPacket_Repeat<0x2b0a>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x2b0a>) == 1, "sizeof(NetPacket_Repeat<0x2b0a>) == 1"); + +template<> +struct NetPacket_Fixed<0x2b0b> +{ + Little16 magic_packet_id; + Little32 account_id; + Little32 gm_level; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b0b>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0b>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b0b>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0b>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b0b>, gm_level) == 6, "offsetof(NetPacket_Fixed<0x2b0b>, gm_level) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2b0b>) == 10, "sizeof(NetPacket_Fixed<0x2b0b>) == 10"); + +template<> +struct NetPacket_Fixed<0x2b0c> +{ + Little16 magic_packet_id; + Little32 account_id; + NetString old_email; + NetString new_email; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b0c>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0c>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b0c>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0c>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b0c>, old_email) == 6, "offsetof(NetPacket_Fixed<0x2b0c>, old_email) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2b0c>, new_email) == 46, "offsetof(NetPacket_Fixed<0x2b0c>, new_email) == 46"); +static_assert(sizeof(NetPacket_Fixed<0x2b0c>) == 86, "sizeof(NetPacket_Fixed<0x2b0c>) == 86"); + +template<> +struct NetPacket_Fixed<0x2b0d> +{ + Little16 magic_packet_id; + Little32 account_id; + Byte sex; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b0d>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0d>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b0d>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0d>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b0d>, sex) == 6, "offsetof(NetPacket_Fixed<0x2b0d>, sex) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2b0d>) == 7, "sizeof(NetPacket_Fixed<0x2b0d>) == 7"); + +template<> +struct NetPacket_Fixed<0x2b0e> +{ + Little16 magic_packet_id; + Little32 account_id; + NetString char_name; + Little16 operation; + NetHumanTimeDiff ban_add; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b0e>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0e>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b0e>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0e>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b0e>, char_name) == 6, "offsetof(NetPacket_Fixed<0x2b0e>, char_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2b0e>, operation) == 30, "offsetof(NetPacket_Fixed<0x2b0e>, operation) == 30"); +static_assert(offsetof(NetPacket_Fixed<0x2b0e>, ban_add) == 32, "offsetof(NetPacket_Fixed<0x2b0e>, ban_add) == 32"); +static_assert(sizeof(NetPacket_Fixed<0x2b0e>) == 44, "sizeof(NetPacket_Fixed<0x2b0e>) == 44"); + +template<> +struct NetPacket_Fixed<0x2b0f> +{ + Little16 magic_packet_id; + Little32 account_id; + NetString char_name; + Little16 operation; + Little16 error; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b0f>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b0f>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b0f>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b0f>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b0f>, char_name) == 6, "offsetof(NetPacket_Fixed<0x2b0f>, char_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2b0f>, operation) == 30, "offsetof(NetPacket_Fixed<0x2b0f>, operation) == 30"); +static_assert(offsetof(NetPacket_Fixed<0x2b0f>, error) == 32, "offsetof(NetPacket_Fixed<0x2b0f>, error) == 32"); +static_assert(sizeof(NetPacket_Fixed<0x2b0f>) == 34, "sizeof(NetPacket_Fixed<0x2b0f>) == 34"); + +template<> +struct NetPacket_Head<0x2b10> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Head<0x2b10>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b10>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2b10>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b10>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2b10>, account_id) == 4, "offsetof(NetPacket_Head<0x2b10>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x2b10>) == 8, "sizeof(NetPacket_Head<0x2b10>) == 8"); +template<> +struct NetPacket_Repeat<0x2b10> +{ + NetString name; + Little32 value; +}; +static_assert(offsetof(NetPacket_Repeat<0x2b10>, name) == 0, "offsetof(NetPacket_Repeat<0x2b10>, name) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x2b10>, value) == 32, "offsetof(NetPacket_Repeat<0x2b10>, value) == 32"); +static_assert(sizeof(NetPacket_Repeat<0x2b10>) == 36, "sizeof(NetPacket_Repeat<0x2b10>) == 36"); + +template<> +struct NetPacket_Head<0x2b11> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Head<0x2b11>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b11>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2b11>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b11>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2b11>, account_id) == 4, "offsetof(NetPacket_Head<0x2b11>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x2b11>) == 8, "sizeof(NetPacket_Head<0x2b11>) == 8"); +template<> +struct NetPacket_Repeat<0x2b11> +{ + NetString name; + Little32 value; +}; +static_assert(offsetof(NetPacket_Repeat<0x2b11>, name) == 0, "offsetof(NetPacket_Repeat<0x2b11>, name) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x2b11>, value) == 32, "offsetof(NetPacket_Repeat<0x2b11>, value) == 32"); +static_assert(sizeof(NetPacket_Repeat<0x2b11>) == 36, "sizeof(NetPacket_Repeat<0x2b11>) == 36"); + +template<> +struct NetPacket_Fixed<0x2b12> +{ + Little16 magic_packet_id; + Little32 char_id; + Little32 partner_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b12>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b12>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b12>, char_id) == 2, "offsetof(NetPacket_Fixed<0x2b12>, char_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b12>, partner_id) == 6, "offsetof(NetPacket_Fixed<0x2b12>, partner_id) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2b12>) == 10, "sizeof(NetPacket_Fixed<0x2b12>) == 10"); + +template<> +struct NetPacket_Fixed<0x2b13> +{ + Little16 magic_packet_id; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b13>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b13>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b13>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b13>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2b13>) == 6, "sizeof(NetPacket_Fixed<0x2b13>) == 6"); + +template<> +struct NetPacket_Fixed<0x2b14> +{ + Little16 magic_packet_id; + Little32 account_id; + Byte ban_not_status; + Little32 status_or_ban_until; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b14>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b14>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b14>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2b14>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2b14>, ban_not_status) == 6, "offsetof(NetPacket_Fixed<0x2b14>, ban_not_status) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2b14>, status_or_ban_until) == 7, "offsetof(NetPacket_Fixed<0x2b14>, status_or_ban_until) == 7"); +static_assert(sizeof(NetPacket_Fixed<0x2b14>) == 11, "sizeof(NetPacket_Fixed<0x2b14>) == 11"); + +template<> +struct NetPacket_Head<0x2b15> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; +}; +static_assert(offsetof(NetPacket_Head<0x2b15>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2b15>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2b15>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2b15>, magic_packet_length) == 2"); +static_assert(sizeof(NetPacket_Head<0x2b15>) == 4, "sizeof(NetPacket_Head<0x2b15>) == 4"); +template<> +struct NetPacket_Repeat<0x2b15> +{ + Little32 account_id; + Byte gm_level; +}; +static_assert(offsetof(NetPacket_Repeat<0x2b15>, account_id) == 0, "offsetof(NetPacket_Repeat<0x2b15>, account_id) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x2b15>, gm_level) == 4, "offsetof(NetPacket_Repeat<0x2b15>, gm_level) == 4"); +static_assert(sizeof(NetPacket_Repeat<0x2b15>) == 5, "sizeof(NetPacket_Repeat<0x2b15>) == 5"); + +template<> +struct NetPacket_Fixed<0x2b16> +{ + Little16 magic_packet_id; + Little32 char_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x2b16>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2b16>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2b16>, char_id) == 2, "offsetof(NetPacket_Fixed<0x2b16>, char_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2b16>) == 6, "sizeof(NetPacket_Fixed<0x2b16>) == 6"); + +template<> +struct NetPacket_Head<0x3000> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; +}; +static_assert(offsetof(NetPacket_Head<0x3000>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3000>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3000>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3000>, magic_packet_length) == 2"); +static_assert(sizeof(NetPacket_Head<0x3000>) == 4, "sizeof(NetPacket_Head<0x3000>) == 4"); +template<> +struct NetPacket_Repeat<0x3000> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3000>, c) == 0, "offsetof(NetPacket_Repeat<0x3000>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3000>) == 1, "sizeof(NetPacket_Repeat<0x3000>) == 1"); + +template<> +struct NetPacket_Head<0x3001> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + NetString from_char_name; + NetString to_char_name; +}; +static_assert(offsetof(NetPacket_Head<0x3001>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3001>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3001>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3001>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3001>, from_char_name) == 4, "offsetof(NetPacket_Head<0x3001>, from_char_name) == 4"); +static_assert(offsetof(NetPacket_Head<0x3001>, to_char_name) == 28, "offsetof(NetPacket_Head<0x3001>, to_char_name) == 28"); +static_assert(sizeof(NetPacket_Head<0x3001>) == 52, "sizeof(NetPacket_Head<0x3001>) == 52"); +template<> +struct NetPacket_Repeat<0x3001> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3001>, c) == 0, "offsetof(NetPacket_Repeat<0x3001>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3001>) == 1, "sizeof(NetPacket_Repeat<0x3001>) == 1"); + +template<> +struct NetPacket_Fixed<0x3002> +{ + Little16 magic_packet_id; + Little32 char_id; + Byte flag; +}; +static_assert(offsetof(NetPacket_Fixed<0x3002>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3002>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3002>, char_id) == 2, "offsetof(NetPacket_Fixed<0x3002>, char_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3002>, flag) == 6, "offsetof(NetPacket_Fixed<0x3002>, flag) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x3002>) == 7, "sizeof(NetPacket_Fixed<0x3002>) == 7"); + +template<> +struct NetPacket_Head<0x3003> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + NetString char_name; + Little16 min_gm_level; +}; +static_assert(offsetof(NetPacket_Head<0x3003>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3003>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3003>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3003>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3003>, char_name) == 4, "offsetof(NetPacket_Head<0x3003>, char_name) == 4"); +static_assert(offsetof(NetPacket_Head<0x3003>, min_gm_level) == 28, "offsetof(NetPacket_Head<0x3003>, min_gm_level) == 28"); +static_assert(sizeof(NetPacket_Head<0x3003>) == 30, "sizeof(NetPacket_Head<0x3003>) == 30"); +template<> +struct NetPacket_Repeat<0x3003> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3003>, c) == 0, "offsetof(NetPacket_Repeat<0x3003>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3003>) == 1, "sizeof(NetPacket_Repeat<0x3003>) == 1"); + +template<> +struct NetPacket_Head<0x3004> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Head<0x3004>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3004>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3004>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3004>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3004>, account_id) == 4, "offsetof(NetPacket_Head<0x3004>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x3004>) == 8, "sizeof(NetPacket_Head<0x3004>) == 8"); +template<> +struct NetPacket_Repeat<0x3004> +{ + NetString name; + Little32 value; +}; +static_assert(offsetof(NetPacket_Repeat<0x3004>, name) == 0, "offsetof(NetPacket_Repeat<0x3004>, name) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x3004>, value) == 32, "offsetof(NetPacket_Repeat<0x3004>, value) == 32"); +static_assert(sizeof(NetPacket_Repeat<0x3004>) == 36, "sizeof(NetPacket_Repeat<0x3004>) == 36"); + +template<> +struct NetPacket_Fixed<0x3005> +{ + Little16 magic_packet_id; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x3005>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3005>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3005>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3005>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x3005>) == 6, "sizeof(NetPacket_Fixed<0x3005>) == 6"); + +template<> +struct NetPacket_Fixed<0x3010> +{ + Little16 magic_packet_id; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x3010>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3010>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3010>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3010>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x3010>) == 6, "sizeof(NetPacket_Fixed<0x3010>) == 6"); + +template<> +struct NetPacket_Payload<0x3011> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; + Storage storage; +}; +static_assert(offsetof(NetPacket_Payload<0x3011>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x3011>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Payload<0x3011>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x3011>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Payload<0x3011>, account_id) == 4, "offsetof(NetPacket_Payload<0x3011>, account_id) == 4"); +static_assert(offsetof(NetPacket_Payload<0x3011>, storage) == 8, "offsetof(NetPacket_Payload<0x3011>, storage) == 8"); + +template<> +struct NetPacket_Fixed<0x3020> +{ + Little16 magic_packet_id; + Little32 account_id; + NetString party_name; + NetString char_name; + NetString map_name; + Little16 level; +}; +static_assert(offsetof(NetPacket_Fixed<0x3020>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3020>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3020>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3020>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3020>, party_name) == 6, "offsetof(NetPacket_Fixed<0x3020>, party_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3020>, char_name) == 30, "offsetof(NetPacket_Fixed<0x3020>, char_name) == 30"); +static_assert(offsetof(NetPacket_Fixed<0x3020>, map_name) == 54, "offsetof(NetPacket_Fixed<0x3020>, map_name) == 54"); +static_assert(offsetof(NetPacket_Fixed<0x3020>, level) == 70, "offsetof(NetPacket_Fixed<0x3020>, level) == 70"); +static_assert(sizeof(NetPacket_Fixed<0x3020>) == 72, "sizeof(NetPacket_Fixed<0x3020>) == 72"); + +template<> +struct NetPacket_Fixed<0x3021> +{ + Little16 magic_packet_id; + Little32 party_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x3021>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3021>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3021>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3021>, party_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x3021>) == 6, "sizeof(NetPacket_Fixed<0x3021>) == 6"); + +template<> +struct NetPacket_Fixed<0x3022> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + NetString char_name; + NetString map_name; + Little16 level; +}; +static_assert(offsetof(NetPacket_Fixed<0x3022>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3022>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3022>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3022>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3022>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3022>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3022>, char_name) == 10, "offsetof(NetPacket_Fixed<0x3022>, char_name) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x3022>, map_name) == 34, "offsetof(NetPacket_Fixed<0x3022>, map_name) == 34"); +static_assert(offsetof(NetPacket_Fixed<0x3022>, level) == 50, "offsetof(NetPacket_Fixed<0x3022>, level) == 50"); +static_assert(sizeof(NetPacket_Fixed<0x3022>) == 52, "sizeof(NetPacket_Fixed<0x3022>) == 52"); + +template<> +struct NetPacket_Fixed<0x3023> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + Little16 exp; + Little16 item; +}; +static_assert(offsetof(NetPacket_Fixed<0x3023>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3023>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3023>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3023>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3023>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3023>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3023>, exp) == 10, "offsetof(NetPacket_Fixed<0x3023>, exp) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x3023>, item) == 12, "offsetof(NetPacket_Fixed<0x3023>, item) == 12"); +static_assert(sizeof(NetPacket_Fixed<0x3023>) == 14, "sizeof(NetPacket_Fixed<0x3023>) == 14"); + +template<> +struct NetPacket_Fixed<0x3024> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x3024>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3024>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3024>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3024>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3024>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3024>, account_id) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x3024>) == 10, "sizeof(NetPacket_Fixed<0x3024>) == 10"); + +template<> +struct NetPacket_Fixed<0x3025> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + NetString map_name; + Byte online; + Little16 level; +}; +static_assert(offsetof(NetPacket_Fixed<0x3025>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3025>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3025>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3025>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3025>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3025>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3025>, map_name) == 10, "offsetof(NetPacket_Fixed<0x3025>, map_name) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x3025>, online) == 26, "offsetof(NetPacket_Fixed<0x3025>, online) == 26"); +static_assert(offsetof(NetPacket_Fixed<0x3025>, level) == 27, "offsetof(NetPacket_Fixed<0x3025>, level) == 27"); +static_assert(sizeof(NetPacket_Fixed<0x3025>) == 29, "sizeof(NetPacket_Fixed<0x3025>) == 29"); + +template<> +struct NetPacket_Fixed<0x3026> +{ + Little16 magic_packet_id; + Little32 party_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x3026>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3026>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3026>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3026>, party_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x3026>) == 6, "sizeof(NetPacket_Fixed<0x3026>) == 6"); + +template<> +struct NetPacket_Head<0x3027> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 party_id; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Head<0x3027>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3027>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3027>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3027>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3027>, party_id) == 4, "offsetof(NetPacket_Head<0x3027>, party_id) == 4"); +static_assert(offsetof(NetPacket_Head<0x3027>, account_id) == 8, "offsetof(NetPacket_Head<0x3027>, account_id) == 8"); +static_assert(sizeof(NetPacket_Head<0x3027>) == 12, "sizeof(NetPacket_Head<0x3027>) == 12"); +template<> +struct NetPacket_Repeat<0x3027> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3027>, c) == 0, "offsetof(NetPacket_Repeat<0x3027>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3027>) == 1, "sizeof(NetPacket_Repeat<0x3027>) == 1"); + +template<> +struct NetPacket_Fixed<0x3028> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + NetString char_name; +}; +static_assert(offsetof(NetPacket_Fixed<0x3028>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3028>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3028>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3028>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3028>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3028>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3028>, char_name) == 10, "offsetof(NetPacket_Fixed<0x3028>, char_name) == 10"); +static_assert(sizeof(NetPacket_Fixed<0x3028>) == 34, "sizeof(NetPacket_Fixed<0x3028>) == 34"); + +template<> +struct NetPacket_Head<0x3800> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; +}; +static_assert(offsetof(NetPacket_Head<0x3800>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3800>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3800>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3800>, magic_packet_length) == 2"); +static_assert(sizeof(NetPacket_Head<0x3800>) == 4, "sizeof(NetPacket_Head<0x3800>) == 4"); +template<> +struct NetPacket_Repeat<0x3800> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3800>, c) == 0, "offsetof(NetPacket_Repeat<0x3800>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3800>) == 1, "sizeof(NetPacket_Repeat<0x3800>) == 1"); + +template<> +struct NetPacket_Head<0x3801> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 whisper_id; + NetString src_char_name; + NetString dst_char_name; +}; +static_assert(offsetof(NetPacket_Head<0x3801>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3801>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3801>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3801>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3801>, whisper_id) == 4, "offsetof(NetPacket_Head<0x3801>, whisper_id) == 4"); +static_assert(offsetof(NetPacket_Head<0x3801>, src_char_name) == 8, "offsetof(NetPacket_Head<0x3801>, src_char_name) == 8"); +static_assert(offsetof(NetPacket_Head<0x3801>, dst_char_name) == 32, "offsetof(NetPacket_Head<0x3801>, dst_char_name) == 32"); +static_assert(sizeof(NetPacket_Head<0x3801>) == 56, "sizeof(NetPacket_Head<0x3801>) == 56"); +template<> +struct NetPacket_Repeat<0x3801> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3801>, c) == 0, "offsetof(NetPacket_Repeat<0x3801>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3801>) == 1, "sizeof(NetPacket_Repeat<0x3801>) == 1"); + +template<> +struct NetPacket_Fixed<0x3802> +{ + Little16 magic_packet_id; + NetString sender_char_name; + Byte flag; +}; +static_assert(offsetof(NetPacket_Fixed<0x3802>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3802>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3802>, sender_char_name) == 2, "offsetof(NetPacket_Fixed<0x3802>, sender_char_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3802>, flag) == 26, "offsetof(NetPacket_Fixed<0x3802>, flag) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x3802>) == 27, "sizeof(NetPacket_Fixed<0x3802>) == 27"); + +template<> +struct NetPacket_Head<0x3803> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + NetString char_name; + Little16 min_gm_level; +}; +static_assert(offsetof(NetPacket_Head<0x3803>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3803>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3803>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3803>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3803>, char_name) == 4, "offsetof(NetPacket_Head<0x3803>, char_name) == 4"); +static_assert(offsetof(NetPacket_Head<0x3803>, min_gm_level) == 28, "offsetof(NetPacket_Head<0x3803>, min_gm_level) == 28"); +static_assert(sizeof(NetPacket_Head<0x3803>) == 30, "sizeof(NetPacket_Head<0x3803>) == 30"); +template<> +struct NetPacket_Repeat<0x3803> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3803>, c) == 0, "offsetof(NetPacket_Repeat<0x3803>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3803>) == 1, "sizeof(NetPacket_Repeat<0x3803>) == 1"); + +template<> +struct NetPacket_Head<0x3804> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Head<0x3804>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3804>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3804>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3804>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3804>, account_id) == 4, "offsetof(NetPacket_Head<0x3804>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x3804>) == 8, "sizeof(NetPacket_Head<0x3804>) == 8"); +template<> +struct NetPacket_Repeat<0x3804> +{ + NetString name; + Little32 value; +}; +static_assert(offsetof(NetPacket_Repeat<0x3804>, name) == 0, "offsetof(NetPacket_Repeat<0x3804>, name) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x3804>, value) == 32, "offsetof(NetPacket_Repeat<0x3804>, value) == 32"); +static_assert(sizeof(NetPacket_Repeat<0x3804>) == 36, "sizeof(NetPacket_Repeat<0x3804>) == 36"); + +template<> +struct NetPacket_Payload<0x3810> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 account_id; + Storage storage; +}; +static_assert(offsetof(NetPacket_Payload<0x3810>, magic_packet_id) == 0, "offsetof(NetPacket_Payload<0x3810>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Payload<0x3810>, magic_packet_length) == 2, "offsetof(NetPacket_Payload<0x3810>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Payload<0x3810>, account_id) == 4, "offsetof(NetPacket_Payload<0x3810>, account_id) == 4"); +static_assert(offsetof(NetPacket_Payload<0x3810>, storage) == 8, "offsetof(NetPacket_Payload<0x3810>, storage) == 8"); + +template<> +struct NetPacket_Fixed<0x3811> +{ + Little16 magic_packet_id; + Little32 account_id; + Byte unknown; +}; +static_assert(offsetof(NetPacket_Fixed<0x3811>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3811>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3811>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3811>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3811>, unknown) == 6, "offsetof(NetPacket_Fixed<0x3811>, unknown) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x3811>) == 7, "sizeof(NetPacket_Fixed<0x3811>) == 7"); + +template<> +struct NetPacket_Fixed<0x3820> +{ + Little16 magic_packet_id; + Little32 account_id; + Byte error; + Little32 party_id; + NetString party_name; +}; +static_assert(offsetof(NetPacket_Fixed<0x3820>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3820>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3820>, account_id) == 2, "offsetof(NetPacket_Fixed<0x3820>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3820>, error) == 6, "offsetof(NetPacket_Fixed<0x3820>, error) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3820>, party_id) == 7, "offsetof(NetPacket_Fixed<0x3820>, party_id) == 7"); +static_assert(offsetof(NetPacket_Fixed<0x3820>, party_name) == 11, "offsetof(NetPacket_Fixed<0x3820>, party_name) == 11"); +static_assert(sizeof(NetPacket_Fixed<0x3820>) == 35, "sizeof(NetPacket_Fixed<0x3820>) == 35"); + +template<> +struct NetPacket_Head<0x3821> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 party_id; +}; +static_assert(offsetof(NetPacket_Head<0x3821>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3821>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3821>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3821>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3821>, party_id) == 4, "offsetof(NetPacket_Head<0x3821>, party_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x3821>) == 8, "sizeof(NetPacket_Head<0x3821>) == 8"); +template<> +struct NetPacket_Option<0x3821> +{ + PartyMost party_most; +}; +static_assert(offsetof(NetPacket_Option<0x3821>, party_most) == 0, "offsetof(NetPacket_Option<0x3821>, party_most) == 0"); + +template<> +struct NetPacket_Fixed<0x3822> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + Byte flag; +}; +static_assert(offsetof(NetPacket_Fixed<0x3822>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3822>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3822>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3822>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3822>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3822>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3822>, flag) == 10, "offsetof(NetPacket_Fixed<0x3822>, flag) == 10"); +static_assert(sizeof(NetPacket_Fixed<0x3822>) == 11, "sizeof(NetPacket_Fixed<0x3822>) == 11"); + +template<> +struct NetPacket_Fixed<0x3823> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + Little16 exp; + Little16 item; + Byte flag; +}; +static_assert(offsetof(NetPacket_Fixed<0x3823>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3823>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3823>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3823>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3823>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3823>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3823>, exp) == 10, "offsetof(NetPacket_Fixed<0x3823>, exp) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x3823>, item) == 12, "offsetof(NetPacket_Fixed<0x3823>, item) == 12"); +static_assert(offsetof(NetPacket_Fixed<0x3823>, flag) == 14, "offsetof(NetPacket_Fixed<0x3823>, flag) == 14"); +static_assert(sizeof(NetPacket_Fixed<0x3823>) == 15, "sizeof(NetPacket_Fixed<0x3823>) == 15"); + +template<> +struct NetPacket_Fixed<0x3824> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + NetString char_name; +}; +static_assert(offsetof(NetPacket_Fixed<0x3824>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3824>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3824>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3824>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3824>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3824>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3824>, char_name) == 10, "offsetof(NetPacket_Fixed<0x3824>, char_name) == 10"); +static_assert(sizeof(NetPacket_Fixed<0x3824>) == 34, "sizeof(NetPacket_Fixed<0x3824>) == 34"); + +template<> +struct NetPacket_Fixed<0x3825> +{ + Little16 magic_packet_id; + Little32 party_id; + Little32 account_id; + NetString map_name; + Byte online; + Little16 level; +}; +static_assert(offsetof(NetPacket_Fixed<0x3825>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3825>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3825>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3825>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3825>, account_id) == 6, "offsetof(NetPacket_Fixed<0x3825>, account_id) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x3825>, map_name) == 10, "offsetof(NetPacket_Fixed<0x3825>, map_name) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x3825>, online) == 26, "offsetof(NetPacket_Fixed<0x3825>, online) == 26"); +static_assert(offsetof(NetPacket_Fixed<0x3825>, level) == 27, "offsetof(NetPacket_Fixed<0x3825>, level) == 27"); +static_assert(sizeof(NetPacket_Fixed<0x3825>) == 29, "sizeof(NetPacket_Fixed<0x3825>) == 29"); + +template<> +struct NetPacket_Fixed<0x3826> +{ + Little16 magic_packet_id; + Little32 party_id; + Byte flag; +}; +static_assert(offsetof(NetPacket_Fixed<0x3826>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x3826>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x3826>, party_id) == 2, "offsetof(NetPacket_Fixed<0x3826>, party_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x3826>, flag) == 6, "offsetof(NetPacket_Fixed<0x3826>, flag) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x3826>) == 7, "sizeof(NetPacket_Fixed<0x3826>) == 7"); + +template<> +struct NetPacket_Head<0x3827> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + Little32 party_id; + Little32 account_id; +}; +static_assert(offsetof(NetPacket_Head<0x3827>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x3827>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x3827>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x3827>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x3827>, party_id) == 4, "offsetof(NetPacket_Head<0x3827>, party_id) == 4"); +static_assert(offsetof(NetPacket_Head<0x3827>, account_id) == 8, "offsetof(NetPacket_Head<0x3827>, account_id) == 8"); +static_assert(sizeof(NetPacket_Head<0x3827>) == 12, "sizeof(NetPacket_Head<0x3827>) == 12"); +template<> +struct NetPacket_Repeat<0x3827> +{ + Byte c; +}; +static_assert(offsetof(NetPacket_Repeat<0x3827>, c) == 0, "offsetof(NetPacket_Repeat<0x3827>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x3827>) == 1, "sizeof(NetPacket_Repeat<0x3827>) == 1"); + + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2af7> *network, Packet_Fixed<0x2af7> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2af7> *native, NetPacket_Fixed<0x2af7> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2af8> *network, Packet_Fixed<0x2af8> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_name, native.account_name); + rv &= native_to_network(&network->account_pass, native.account_pass); + rv &= native_to_network(&network->unused, native.unused); + rv &= native_to_network(&network->ip, native.ip); + rv &= native_to_network(&network->port, native.port); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2af8> *native, NetPacket_Fixed<0x2af8> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_name, network.account_name); + rv &= network_to_native(&native->account_pass, network.account_pass); + rv &= network_to_native(&native->unused, network.unused); + rv &= network_to_native(&native->ip, network.ip); + rv &= network_to_native(&native->port, network.port); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2af9> *network, Packet_Fixed<0x2af9> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->code, native.code); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2af9> *native, NetPacket_Fixed<0x2af9> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->code, network.code); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x2afa> *network, Packet_Head<0x2afa> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x2afa> *native, NetPacket_Head<0x2afa> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x2afa> *network, Packet_Repeat<0x2afa> native) +{ + bool rv = true; + rv &= native_to_network(&network->map_name, native.map_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x2afa> *native, NetPacket_Repeat<0x2afa> network) +{ + bool rv = true; + rv &= network_to_native(&native->map_name, network.map_name); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2afa> *network, Packet_Fixed<0x2afa> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->source_item_id, native.source_item_id); + rv &= native_to_network(&network->dest_item_id, native.dest_item_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2afa> *native, NetPacket_Fixed<0x2afa> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->source_item_id, network.source_item_id); + rv &= network_to_native(&native->dest_item_id, network.dest_item_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2afb> *network, Packet_Fixed<0x2afb> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->unknown, native.unknown); + rv &= native_to_network(&network->whisper_name, native.whisper_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2afb> *native, NetPacket_Fixed<0x2afb> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->unknown, network.unknown); + rv &= network_to_native(&native->whisper_name, network.whisper_name); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2afc> *network, Packet_Fixed<0x2afc> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->login_id1, native.login_id1); + rv &= native_to_network(&network->login_id2, native.login_id2); + rv &= native_to_network(&network->ip, native.ip); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2afc> *native, NetPacket_Fixed<0x2afc> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->login_id1, network.login_id1); + rv &= network_to_native(&native->login_id2, network.login_id2); + rv &= network_to_native(&native->ip, network.ip); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Payload<0x2afd> *network, Packet_Payload<0x2afd> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->login_id2, native.login_id2); + rv &= native_to_network(&network->connect_until, native.connect_until); + rv &= native_to_network(&network->packet_tmw_version, native.packet_tmw_version); + rv &= native_to_network(&network->char_key, native.char_key); + rv &= native_to_network(&network->char_data, native.char_data); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Payload<0x2afd> *native, NetPacket_Payload<0x2afd> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->login_id2, network.login_id2); + rv &= network_to_native(&native->connect_until, network.connect_until); + rv &= network_to_native(&native->packet_tmw_version, network.packet_tmw_version); + rv &= network_to_native(&native->char_key, network.char_key); + rv &= network_to_native(&native->char_data, network.char_data); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2afe> *network, Packet_Fixed<0x2afe> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2afe> *native, NetPacket_Fixed<0x2afe> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x2aff> *network, Packet_Head<0x2aff> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->users, native.users); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x2aff> *native, NetPacket_Head<0x2aff> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->users, network.users); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x2aff> *network, Packet_Repeat<0x2aff> native) +{ + bool rv = true; + rv &= native_to_network(&network->char_id, native.char_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x2aff> *native, NetPacket_Repeat<0x2aff> network) +{ + bool rv = true; + rv &= network_to_native(&native->char_id, network.char_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b00> *network, Packet_Fixed<0x2b00> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->users, native.users); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b00> *native, NetPacket_Fixed<0x2b00> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->users, network.users); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Payload<0x2b01> *network, Packet_Payload<0x2b01> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->char_key, native.char_key); + rv &= native_to_network(&network->char_data, native.char_data); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Payload<0x2b01> *native, NetPacket_Payload<0x2b01> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->char_key, network.char_key); + rv &= network_to_native(&native->char_data, network.char_data); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b02> *network, Packet_Fixed<0x2b02> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->login_id1, native.login_id1); + rv &= native_to_network(&network->login_id2, native.login_id2); + rv &= native_to_network(&network->ip, native.ip); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b02> *native, NetPacket_Fixed<0x2b02> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->login_id1, network.login_id1); + rv &= network_to_native(&native->login_id2, network.login_id2); + rv &= network_to_native(&native->ip, network.ip); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b03> *network, Packet_Fixed<0x2b03> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->unknown, native.unknown); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b03> *native, NetPacket_Fixed<0x2b03> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->unknown, network.unknown); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x2b04> *network, Packet_Head<0x2b04> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->ip, native.ip); + rv &= native_to_network(&network->port, native.port); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x2b04> *native, NetPacket_Head<0x2b04> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->ip, network.ip); + rv &= network_to_native(&native->port, network.port); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x2b04> *network, Packet_Repeat<0x2b04> native) +{ + bool rv = true; + rv &= native_to_network(&network->map_name, native.map_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x2b04> *native, NetPacket_Repeat<0x2b04> network) +{ + bool rv = true; + rv &= network_to_native(&native->map_name, network.map_name); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b05> *network, Packet_Fixed<0x2b05> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->login_id1, native.login_id1); + rv &= native_to_network(&network->login_id2, native.login_id2); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->map_name, native.map_name); + rv &= native_to_network(&network->x, native.x); + rv &= native_to_network(&network->y, native.y); + rv &= native_to_network(&network->map_ip, native.map_ip); + rv &= native_to_network(&network->map_port, native.map_port); + rv &= native_to_network(&network->sex, native.sex); + rv &= native_to_network(&network->client_ip, native.client_ip); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b05> *native, NetPacket_Fixed<0x2b05> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->login_id1, network.login_id1); + rv &= network_to_native(&native->login_id2, network.login_id2); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->map_name, network.map_name); + rv &= network_to_native(&native->x, network.x); + rv &= network_to_native(&native->y, network.y); + rv &= network_to_native(&native->map_ip, network.map_ip); + rv &= network_to_native(&native->map_port, network.map_port); + rv &= network_to_native(&native->sex, network.sex); + rv &= network_to_native(&native->client_ip, network.client_ip); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b06> *network, Packet_Fixed<0x2b06> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->error, native.error); + rv &= native_to_network(&network->unknown, native.unknown); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->map_name, native.map_name); + rv &= native_to_network(&network->x, native.x); + rv &= native_to_network(&network->y, native.y); + rv &= native_to_network(&network->map_ip, native.map_ip); + rv &= native_to_network(&network->map_port, native.map_port); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b06> *native, NetPacket_Fixed<0x2b06> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->error, network.error); + rv &= network_to_native(&native->unknown, network.unknown); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->map_name, network.map_name); + rv &= network_to_native(&native->x, network.x); + rv &= network_to_native(&native->y, network.y); + rv &= network_to_native(&native->map_ip, network.map_ip); + rv &= network_to_native(&native->map_port, network.map_port); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x2b0a> *network, Packet_Head<0x2b0a> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x2b0a> *native, NetPacket_Head<0x2b0a> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x2b0a> *network, Packet_Repeat<0x2b0a> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x2b0a> *native, NetPacket_Repeat<0x2b0a> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b0b> *network, Packet_Fixed<0x2b0b> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->gm_level, native.gm_level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b0b> *native, NetPacket_Fixed<0x2b0b> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->gm_level, network.gm_level); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b0c> *network, Packet_Fixed<0x2b0c> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->old_email, native.old_email); + rv &= native_to_network(&network->new_email, native.new_email); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b0c> *native, NetPacket_Fixed<0x2b0c> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->old_email, network.old_email); + rv &= network_to_native(&native->new_email, network.new_email); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b0d> *network, Packet_Fixed<0x2b0d> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->sex, native.sex); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b0d> *native, NetPacket_Fixed<0x2b0d> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->sex, network.sex); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b0e> *network, Packet_Fixed<0x2b0e> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->char_name, native.char_name); + rv &= native_to_network(&network->operation, native.operation); + rv &= native_to_network(&network->ban_add, native.ban_add); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b0e> *native, NetPacket_Fixed<0x2b0e> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->char_name, network.char_name); + rv &= network_to_native(&native->operation, network.operation); + rv &= network_to_native(&native->ban_add, network.ban_add); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b0f> *network, Packet_Fixed<0x2b0f> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->char_name, native.char_name); + rv &= native_to_network(&network->operation, native.operation); + rv &= native_to_network(&network->error, native.error); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b0f> *native, NetPacket_Fixed<0x2b0f> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->char_name, network.char_name); + rv &= network_to_native(&native->operation, network.operation); + rv &= network_to_native(&native->error, network.error); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x2b10> *network, Packet_Head<0x2b10> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x2b10> *native, NetPacket_Head<0x2b10> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x2b10> *network, Packet_Repeat<0x2b10> native) +{ + bool rv = true; + rv &= native_to_network(&network->name, native.name); + rv &= native_to_network(&network->value, native.value); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x2b10> *native, NetPacket_Repeat<0x2b10> network) +{ + bool rv = true; + rv &= network_to_native(&native->name, network.name); + rv &= network_to_native(&native->value, network.value); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x2b11> *network, Packet_Head<0x2b11> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x2b11> *native, NetPacket_Head<0x2b11> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x2b11> *network, Packet_Repeat<0x2b11> native) +{ + bool rv = true; + rv &= native_to_network(&network->name, native.name); + rv &= native_to_network(&network->value, native.value); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x2b11> *native, NetPacket_Repeat<0x2b11> network) +{ + bool rv = true; + rv &= network_to_native(&native->name, network.name); + rv &= network_to_native(&native->value, network.value); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b12> *network, Packet_Fixed<0x2b12> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->partner_id, native.partner_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b12> *native, NetPacket_Fixed<0x2b12> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->partner_id, network.partner_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b13> *network, Packet_Fixed<0x2b13> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b13> *native, NetPacket_Fixed<0x2b13> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b14> *network, Packet_Fixed<0x2b14> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->ban_not_status, native.ban_not_status); + rv &= native_to_network(&network->status_or_ban_until, native.status_or_ban_until); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b14> *native, NetPacket_Fixed<0x2b14> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->ban_not_status, network.ban_not_status); + rv &= network_to_native(&native->status_or_ban_until, network.status_or_ban_until); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x2b15> *network, Packet_Head<0x2b15> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x2b15> *native, NetPacket_Head<0x2b15> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x2b15> *network, Packet_Repeat<0x2b15> native) +{ + bool rv = true; + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->gm_level, native.gm_level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x2b15> *native, NetPacket_Repeat<0x2b15> network) +{ + bool rv = true; + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->gm_level, network.gm_level); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x2b16> *network, Packet_Fixed<0x2b16> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->char_id, native.char_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x2b16> *native, NetPacket_Fixed<0x2b16> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->char_id, network.char_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3000> *network, Packet_Head<0x3000> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3000> *native, NetPacket_Head<0x3000> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3000> *network, Packet_Repeat<0x3000> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3000> *native, NetPacket_Repeat<0x3000> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3001> *network, Packet_Head<0x3001> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->from_char_name, native.from_char_name); + rv &= native_to_network(&network->to_char_name, native.to_char_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3001> *native, NetPacket_Head<0x3001> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->from_char_name, network.from_char_name); + rv &= network_to_native(&native->to_char_name, network.to_char_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3001> *network, Packet_Repeat<0x3001> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3001> *native, NetPacket_Repeat<0x3001> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3002> *network, Packet_Fixed<0x3002> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->flag, native.flag); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3002> *native, NetPacket_Fixed<0x3002> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->flag, network.flag); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3003> *network, Packet_Head<0x3003> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->char_name, native.char_name); + rv &= native_to_network(&network->min_gm_level, native.min_gm_level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3003> *native, NetPacket_Head<0x3003> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->char_name, network.char_name); + rv &= network_to_native(&native->min_gm_level, network.min_gm_level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3003> *network, Packet_Repeat<0x3003> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3003> *native, NetPacket_Repeat<0x3003> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3004> *network, Packet_Head<0x3004> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3004> *native, NetPacket_Head<0x3004> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3004> *network, Packet_Repeat<0x3004> native) +{ + bool rv = true; + rv &= native_to_network(&network->name, native.name); + rv &= native_to_network(&network->value, native.value); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3004> *native, NetPacket_Repeat<0x3004> network) +{ + bool rv = true; + rv &= network_to_native(&native->name, network.name); + rv &= network_to_native(&native->value, network.value); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3005> *network, Packet_Fixed<0x3005> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3005> *native, NetPacket_Fixed<0x3005> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3010> *network, Packet_Fixed<0x3010> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3010> *native, NetPacket_Fixed<0x3010> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Payload<0x3011> *network, Packet_Payload<0x3011> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->storage, native.storage); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Payload<0x3011> *native, NetPacket_Payload<0x3011> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->storage, network.storage); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3020> *network, Packet_Fixed<0x3020> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->party_name, native.party_name); + rv &= native_to_network(&network->char_name, native.char_name); + rv &= native_to_network(&network->map_name, native.map_name); + rv &= native_to_network(&network->level, native.level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3020> *native, NetPacket_Fixed<0x3020> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->party_name, network.party_name); + rv &= network_to_native(&native->char_name, network.char_name); + rv &= network_to_native(&native->map_name, network.map_name); + rv &= network_to_native(&native->level, network.level); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3021> *network, Packet_Fixed<0x3021> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3021> *native, NetPacket_Fixed<0x3021> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3022> *network, Packet_Fixed<0x3022> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->char_name, native.char_name); + rv &= native_to_network(&network->map_name, native.map_name); + rv &= native_to_network(&network->level, native.level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3022> *native, NetPacket_Fixed<0x3022> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->char_name, network.char_name); + rv &= network_to_native(&native->map_name, network.map_name); + rv &= network_to_native(&native->level, network.level); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3023> *network, Packet_Fixed<0x3023> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->exp, native.exp); + rv &= native_to_network(&network->item, native.item); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3023> *native, NetPacket_Fixed<0x3023> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->exp, network.exp); + rv &= network_to_native(&native->item, network.item); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3024> *network, Packet_Fixed<0x3024> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3024> *native, NetPacket_Fixed<0x3024> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3025> *network, Packet_Fixed<0x3025> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->map_name, native.map_name); + rv &= native_to_network(&network->online, native.online); + rv &= native_to_network(&network->level, native.level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3025> *native, NetPacket_Fixed<0x3025> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->map_name, network.map_name); + rv &= network_to_native(&native->online, network.online); + rv &= network_to_native(&native->level, network.level); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3026> *network, Packet_Fixed<0x3026> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3026> *native, NetPacket_Fixed<0x3026> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3027> *network, Packet_Head<0x3027> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3027> *native, NetPacket_Head<0x3027> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3027> *network, Packet_Repeat<0x3027> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3027> *native, NetPacket_Repeat<0x3027> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3028> *network, Packet_Fixed<0x3028> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->char_name, native.char_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3028> *native, NetPacket_Fixed<0x3028> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->char_name, network.char_name); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3800> *network, Packet_Head<0x3800> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3800> *native, NetPacket_Head<0x3800> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3800> *network, Packet_Repeat<0x3800> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3800> *native, NetPacket_Repeat<0x3800> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3801> *network, Packet_Head<0x3801> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->whisper_id, native.whisper_id); + rv &= native_to_network(&network->src_char_name, native.src_char_name); + rv &= native_to_network(&network->dst_char_name, native.dst_char_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3801> *native, NetPacket_Head<0x3801> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->whisper_id, network.whisper_id); + rv &= network_to_native(&native->src_char_name, network.src_char_name); + rv &= network_to_native(&native->dst_char_name, network.dst_char_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3801> *network, Packet_Repeat<0x3801> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3801> *native, NetPacket_Repeat<0x3801> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3802> *network, Packet_Fixed<0x3802> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->sender_char_name, native.sender_char_name); + rv &= native_to_network(&network->flag, native.flag); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3802> *native, NetPacket_Fixed<0x3802> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->sender_char_name, network.sender_char_name); + rv &= network_to_native(&native->flag, network.flag); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3803> *network, Packet_Head<0x3803> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->char_name, native.char_name); + rv &= native_to_network(&network->min_gm_level, native.min_gm_level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3803> *native, NetPacket_Head<0x3803> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->char_name, network.char_name); + rv &= network_to_native(&native->min_gm_level, network.min_gm_level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3803> *network, Packet_Repeat<0x3803> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3803> *native, NetPacket_Repeat<0x3803> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3804> *network, Packet_Head<0x3804> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3804> *native, NetPacket_Head<0x3804> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3804> *network, Packet_Repeat<0x3804> native) +{ + bool rv = true; + rv &= native_to_network(&network->name, native.name); + rv &= native_to_network(&network->value, native.value); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3804> *native, NetPacket_Repeat<0x3804> network) +{ + bool rv = true; + rv &= network_to_native(&native->name, network.name); + rv &= network_to_native(&native->value, network.value); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Payload<0x3810> *network, Packet_Payload<0x3810> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->storage, native.storage); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Payload<0x3810> *native, NetPacket_Payload<0x3810> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->storage, network.storage); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3811> *network, Packet_Fixed<0x3811> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->unknown, native.unknown); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3811> *native, NetPacket_Fixed<0x3811> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->unknown, network.unknown); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3820> *network, Packet_Fixed<0x3820> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->error, native.error); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->party_name, native.party_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3820> *native, NetPacket_Fixed<0x3820> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->error, network.error); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->party_name, network.party_name); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3821> *network, Packet_Head<0x3821> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->party_id, native.party_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3821> *native, NetPacket_Head<0x3821> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->party_id, network.party_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Option<0x3821> *network, Packet_Option<0x3821> native) +{ + bool rv = true; + rv &= native_to_network(&network->party_most, native.party_most); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Option<0x3821> *native, NetPacket_Option<0x3821> network) +{ + bool rv = true; + rv &= network_to_native(&native->party_most, network.party_most); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3822> *network, Packet_Fixed<0x3822> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->flag, native.flag); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3822> *native, NetPacket_Fixed<0x3822> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->flag, network.flag); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3823> *network, Packet_Fixed<0x3823> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->exp, native.exp); + rv &= native_to_network(&network->item, native.item); + rv &= native_to_network(&network->flag, native.flag); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3823> *native, NetPacket_Fixed<0x3823> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->exp, network.exp); + rv &= network_to_native(&native->item, network.item); + rv &= network_to_native(&native->flag, network.flag); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3824> *network, Packet_Fixed<0x3824> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->char_name, native.char_name); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3824> *native, NetPacket_Fixed<0x3824> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->char_name, network.char_name); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3825> *network, Packet_Fixed<0x3825> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->map_name, native.map_name); + rv &= native_to_network(&network->online, native.online); + rv &= native_to_network(&network->level, native.level); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3825> *native, NetPacket_Fixed<0x3825> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->map_name, network.map_name); + rv &= network_to_native(&native->online, network.online); + rv &= network_to_native(&native->level, network.level); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x3826> *network, Packet_Fixed<0x3826> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->flag, native.flag); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x3826> *native, NetPacket_Fixed<0x3826> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->flag, network.flag); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x3827> *network, Packet_Head<0x3827> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->party_id, native.party_id); + rv &= native_to_network(&network->account_id, native.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x3827> *native, NetPacket_Head<0x3827> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->party_id, network.party_id); + rv &= network_to_native(&native->account_id, network.account_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x3827> *network, Packet_Repeat<0x3827> native) +{ + bool rv = true; + rv &= native_to_network(&network->c, native.c); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x3827> *native, NetPacket_Repeat<0x3827> network) +{ + bool rv = true; + rv &= network_to_native(&native->c, network.c); + return rv; +} + + +#pragma pack(pop) #endif // TMWA_PROTO2_CHAR_MAP_HPP diff --git a/src/proto2/char-user.hpp b/src/proto2/char-user.hpp index b31d9f1..3a51a2a 100644 --- a/src/proto2/char-user.hpp +++ b/src/proto2/char-user.hpp @@ -27,7 +27,587 @@ // This is a public protocol, and changes require client cooperation +// this is only needed for the payload packet right now, and that needs to die +#pragma pack(push, 1) +template<> +struct Packet_Fixed<0x0061> +{ + static const uint16_t PACKET_ID = 0x0061; + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountPass old_pass = {}; + AccountPass new_pass = {}; +}; + +template<> +struct Packet_Fixed<0x0062> +{ + static const uint16_t PACKET_ID = 0x0062; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t status = {}; +}; + +template<> +struct Packet_Fixed<0x0065> +{ + static const uint16_t PACKET_ID = 0x0065; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + AccountId account_id = {}; + uint32_t login_id1 = {}; + uint32_t login_id2 = {}; + uint16_t packet_tmw_version = {}; + SEX sex = {}; +}; + +template<> +struct Packet_Fixed<0x0066> +{ + static const uint16_t PACKET_ID = 0x0066; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t code = {}; +}; + +template<> +struct Packet_Fixed<0x0067> +{ + static const uint16_t PACKET_ID = 0x0067; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharName char_name = {}; + Stats6 stats = {}; + uint8_t slot = {}; + uint16_t hair_color = {}; + uint16_t hair_style = {}; +}; + +template<> +struct Packet_Fixed<0x0068> +{ + static const uint16_t PACKET_ID = 0x0068; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharId char_id = {}; + AccountEmail email = {}; +}; + +template<> +struct Packet_Head<0x006b> +{ + static const uint16_t PACKET_ID = 0x006b; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + // TODO remove this + uint16_t magic_packet_length = {}; + VString<19> unused = {}; +}; +template<> +struct Packet_Repeat<0x006b> +{ + static const uint16_t PACKET_ID = 0x006b; + + CharSelect char_select = {}; +}; + +template<> +struct Packet_Fixed<0x006c> +{ + static const uint16_t PACKET_ID = 0x006c; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t code = {}; +}; + +template<> +struct Packet_Fixed<0x006d> +{ + static const uint16_t PACKET_ID = 0x006d; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharSelect char_select = {}; +}; + +template<> +struct Packet_Fixed<0x006e> +{ + static const uint16_t PACKET_ID = 0x006e; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t code = {}; +}; + +template<> +struct Packet_Fixed<0x006f> +{ + static const uint16_t PACKET_ID = 0x006f; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; +}; + +template<> +struct Packet_Fixed<0x0070> +{ + static const uint16_t PACKET_ID = 0x0070; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + uint8_t code = {}; +}; + +template<> +struct Packet_Fixed<0x0071> +{ + static const uint16_t PACKET_ID = 0x0071; + + // TODO remove this + uint16_t magic_packet_id = PACKET_ID; + CharId char_id = {}; + MapName map_name = {}; + IP4Address ip = {}; + uint16_t port = {}; +}; + + +template<> +struct NetPacket_Fixed<0x0061> +{ + Little16 magic_packet_id; + NetString old_pass; + NetString new_pass; +}; +static_assert(offsetof(NetPacket_Fixed<0x0061>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0061>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0061>, old_pass) == 2, "offsetof(NetPacket_Fixed<0x0061>, old_pass) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x0061>, new_pass) == 26, "offsetof(NetPacket_Fixed<0x0061>, new_pass) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x0061>) == 50, "sizeof(NetPacket_Fixed<0x0061>) == 50"); + +template<> +struct NetPacket_Fixed<0x0062> +{ + Little16 magic_packet_id; + Byte status; +}; +static_assert(offsetof(NetPacket_Fixed<0x0062>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0062>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0062>, status) == 2, "offsetof(NetPacket_Fixed<0x0062>, status) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x0062>) == 3, "sizeof(NetPacket_Fixed<0x0062>) == 3"); + +template<> +struct NetPacket_Fixed<0x0065> +{ + Little16 magic_packet_id; + Little32 account_id; + Little32 login_id1; + Little32 login_id2; + Little16 packet_tmw_version; + Byte sex; +}; +static_assert(offsetof(NetPacket_Fixed<0x0065>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0065>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0065>, account_id) == 2, "offsetof(NetPacket_Fixed<0x0065>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x0065>, login_id1) == 6, "offsetof(NetPacket_Fixed<0x0065>, login_id1) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x0065>, login_id2) == 10, "offsetof(NetPacket_Fixed<0x0065>, login_id2) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x0065>, packet_tmw_version) == 14, "offsetof(NetPacket_Fixed<0x0065>, packet_tmw_version) == 14"); +static_assert(offsetof(NetPacket_Fixed<0x0065>, sex) == 16, "offsetof(NetPacket_Fixed<0x0065>, sex) == 16"); +static_assert(sizeof(NetPacket_Fixed<0x0065>) == 17, "sizeof(NetPacket_Fixed<0x0065>) == 17"); + +template<> +struct NetPacket_Fixed<0x0066> +{ + Little16 magic_packet_id; + Byte code; +}; +static_assert(offsetof(NetPacket_Fixed<0x0066>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0066>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0066>, code) == 2, "offsetof(NetPacket_Fixed<0x0066>, code) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x0066>) == 3, "sizeof(NetPacket_Fixed<0x0066>) == 3"); + +template<> +struct NetPacket_Fixed<0x0067> +{ + Little16 magic_packet_id; + NetString char_name; + NetStats6 stats; + Byte slot; + Little16 hair_color; + Little16 hair_style; +}; +static_assert(offsetof(NetPacket_Fixed<0x0067>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0067>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0067>, char_name) == 2, "offsetof(NetPacket_Fixed<0x0067>, char_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x0067>, stats) == 26, "offsetof(NetPacket_Fixed<0x0067>, stats) == 26"); +static_assert(offsetof(NetPacket_Fixed<0x0067>, slot) == 32, "offsetof(NetPacket_Fixed<0x0067>, slot) == 32"); +static_assert(offsetof(NetPacket_Fixed<0x0067>, hair_color) == 33, "offsetof(NetPacket_Fixed<0x0067>, hair_color) == 33"); +static_assert(offsetof(NetPacket_Fixed<0x0067>, hair_style) == 35, "offsetof(NetPacket_Fixed<0x0067>, hair_style) == 35"); +static_assert(sizeof(NetPacket_Fixed<0x0067>) == 37, "sizeof(NetPacket_Fixed<0x0067>) == 37"); + +template<> +struct NetPacket_Fixed<0x0068> +{ + Little16 magic_packet_id; + Little32 char_id; + NetString email; +}; +static_assert(offsetof(NetPacket_Fixed<0x0068>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0068>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0068>, char_id) == 2, "offsetof(NetPacket_Fixed<0x0068>, char_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x0068>, email) == 6, "offsetof(NetPacket_Fixed<0x0068>, email) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x0068>) == 46, "sizeof(NetPacket_Fixed<0x0068>) == 46"); + +template<> +struct NetPacket_Head<0x006b> +{ + Little16 magic_packet_id; + Little16 magic_packet_length; + NetString)> unused; +}; +static_assert(offsetof(NetPacket_Head<0x006b>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x006b>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x006b>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x006b>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x006b>, unused) == 4, "offsetof(NetPacket_Head<0x006b>, unused) == 4"); +static_assert(sizeof(NetPacket_Head<0x006b>) == 24, "sizeof(NetPacket_Head<0x006b>) == 24"); +template<> +struct NetPacket_Repeat<0x006b> +{ + NetCharSelect char_select; +}; +static_assert(offsetof(NetPacket_Repeat<0x006b>, char_select) == 0, "offsetof(NetPacket_Repeat<0x006b>, char_select) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x006b>) == 106, "sizeof(NetPacket_Repeat<0x006b>) == 106"); + +template<> +struct NetPacket_Fixed<0x006c> +{ + Little16 magic_packet_id; + Byte code; +}; +static_assert(offsetof(NetPacket_Fixed<0x006c>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006c>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x006c>, code) == 2, "offsetof(NetPacket_Fixed<0x006c>, code) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x006c>) == 3, "sizeof(NetPacket_Fixed<0x006c>) == 3"); + +template<> +struct NetPacket_Fixed<0x006d> +{ + Little16 magic_packet_id; + NetCharSelect char_select; +}; +static_assert(offsetof(NetPacket_Fixed<0x006d>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006d>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x006d>, char_select) == 2, "offsetof(NetPacket_Fixed<0x006d>, char_select) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x006d>) == 108, "sizeof(NetPacket_Fixed<0x006d>) == 108"); + +template<> +struct NetPacket_Fixed<0x006e> +{ + Little16 magic_packet_id; + Byte code; +}; +static_assert(offsetof(NetPacket_Fixed<0x006e>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006e>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x006e>, code) == 2, "offsetof(NetPacket_Fixed<0x006e>, code) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x006e>) == 3, "sizeof(NetPacket_Fixed<0x006e>) == 3"); + +template<> +struct NetPacket_Fixed<0x006f> +{ + Little16 magic_packet_id; +}; +static_assert(offsetof(NetPacket_Fixed<0x006f>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x006f>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x006f>) == 2, "sizeof(NetPacket_Fixed<0x006f>) == 2"); + +template<> +struct NetPacket_Fixed<0x0070> +{ + Little16 magic_packet_id; + Byte code; +}; +static_assert(offsetof(NetPacket_Fixed<0x0070>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0070>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0070>, code) == 2, "offsetof(NetPacket_Fixed<0x0070>, code) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x0070>) == 3, "sizeof(NetPacket_Fixed<0x0070>) == 3"); + +template<> +struct NetPacket_Fixed<0x0071> +{ + Little16 magic_packet_id; + Little32 char_id; + NetString map_name; + IP4Address ip; + Little16 port; +}; +static_assert(offsetof(NetPacket_Fixed<0x0071>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0071>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0071>, char_id) == 2, "offsetof(NetPacket_Fixed<0x0071>, char_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x0071>, map_name) == 6, "offsetof(NetPacket_Fixed<0x0071>, map_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x0071>, ip) == 22, "offsetof(NetPacket_Fixed<0x0071>, ip) == 22"); +static_assert(offsetof(NetPacket_Fixed<0x0071>, port) == 26, "offsetof(NetPacket_Fixed<0x0071>, port) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x0071>) == 28, "sizeof(NetPacket_Fixed<0x0071>) == 28"); + + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0061> *network, Packet_Fixed<0x0061> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->old_pass, native.old_pass); + rv &= native_to_network(&network->new_pass, native.new_pass); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0061> *native, NetPacket_Fixed<0x0061> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->old_pass, network.old_pass); + rv &= network_to_native(&native->new_pass, network.new_pass); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0062> *network, Packet_Fixed<0x0062> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->status, native.status); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0062> *native, NetPacket_Fixed<0x0062> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->status, network.status); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0065> *network, Packet_Fixed<0x0065> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->account_id, native.account_id); + rv &= native_to_network(&network->login_id1, native.login_id1); + rv &= native_to_network(&network->login_id2, native.login_id2); + rv &= native_to_network(&network->packet_tmw_version, native.packet_tmw_version); + rv &= native_to_network(&network->sex, native.sex); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0065> *native, NetPacket_Fixed<0x0065> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->account_id, network.account_id); + rv &= network_to_native(&native->login_id1, network.login_id1); + rv &= network_to_native(&native->login_id2, network.login_id2); + rv &= network_to_native(&native->packet_tmw_version, network.packet_tmw_version); + rv &= network_to_native(&native->sex, network.sex); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0066> *network, Packet_Fixed<0x0066> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->code, native.code); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0066> *native, NetPacket_Fixed<0x0066> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->code, network.code); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0067> *network, Packet_Fixed<0x0067> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->char_name, native.char_name); + rv &= native_to_network(&network->stats, native.stats); + rv &= native_to_network(&network->slot, native.slot); + rv &= native_to_network(&network->hair_color, native.hair_color); + rv &= native_to_network(&network->hair_style, native.hair_style); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0067> *native, NetPacket_Fixed<0x0067> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->char_name, network.char_name); + rv &= network_to_native(&native->stats, network.stats); + rv &= network_to_native(&native->slot, network.slot); + rv &= network_to_native(&native->hair_color, network.hair_color); + rv &= network_to_native(&native->hair_style, network.hair_style); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0068> *network, Packet_Fixed<0x0068> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->email, native.email); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0068> *native, NetPacket_Fixed<0x0068> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->email, network.email); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Head<0x006b> *network, Packet_Head<0x006b> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->magic_packet_length, native.magic_packet_length); + rv &= native_to_network(&network->unused, native.unused); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Head<0x006b> *native, NetPacket_Head<0x006b> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->magic_packet_length, network.magic_packet_length); + rv &= network_to_native(&native->unused, network.unused); + return rv; +} +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Repeat<0x006b> *network, Packet_Repeat<0x006b> native) +{ + bool rv = true; + rv &= native_to_network(&network->char_select, native.char_select); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Repeat<0x006b> *native, NetPacket_Repeat<0x006b> network) +{ + bool rv = true; + rv &= network_to_native(&native->char_select, network.char_select); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x006c> *network, Packet_Fixed<0x006c> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->code, native.code); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x006c> *native, NetPacket_Fixed<0x006c> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->code, network.code); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x006d> *network, Packet_Fixed<0x006d> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->char_select, native.char_select); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x006d> *native, NetPacket_Fixed<0x006d> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->char_select, network.char_select); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x006e> *network, Packet_Fixed<0x006e> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->code, native.code); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x006e> *native, NetPacket_Fixed<0x006e> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->code, network.code); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x006f> *network, Packet_Fixed<0x006f> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x006f> *native, NetPacket_Fixed<0x006f> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0070> *network, Packet_Fixed<0x0070> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->code, native.code); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0070> *native, NetPacket_Fixed<0x0070> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->code, network.code); + return rv; +} + +inline __attribute__((warn_unused_result)) +bool native_to_network(NetPacket_Fixed<0x0071> *network, Packet_Fixed<0x0071> native) +{ + bool rv = true; + rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); + rv &= native_to_network(&network->char_id, native.char_id); + rv &= native_to_network(&network->map_name, native.map_name); + rv &= native_to_network(&network->ip, native.ip); + rv &= native_to_network(&network->port, native.port); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Packet_Fixed<0x0071> *native, NetPacket_Fixed<0x0071> network) +{ + bool rv = true; + rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); + rv &= network_to_native(&native->char_id, network.char_id); + rv &= network_to_native(&native->map_name, network.map_name); + rv &= network_to_native(&native->ip, network.ip); + rv &= network_to_native(&native->port, network.port); + return rv; +} + + +#pragma pack(pop) #endif // TMWA_PROTO2_CHAR_USER_HPP diff --git a/src/proto2/fwd.hpp b/src/proto2/fwd.hpp index f050ab4..169f5e2 100644 --- a/src/proto2/fwd.hpp +++ b/src/proto2/fwd.hpp @@ -25,10 +25,14 @@ template class Packet_Fixed; template class NetPacket_Fixed; +template class Packet_Payload; +template class NetPacket_Payload; template class Packet_Head; template class NetPacket_Head; template class Packet_Repeat; template class NetPacket_Repeat; +template class Packet_Option; +template class NetPacket_Option; template<> struct Packet_Fixed<0x2709>; @@ -445,12 +449,458 @@ struct Packet_Fixed<0x006a>; template<> struct NetPacket_Fixed<0x006a>; + template<> -struct Packet_Fixed<0x0081>; +struct Packet_Fixed<0x2af7>; template<> -struct NetPacket_Fixed<0x0081>; +struct NetPacket_Fixed<0x2af7>; + +template<> +struct Packet_Fixed<0x2af8>; +template<> +struct NetPacket_Fixed<0x2af8>; + +template<> +struct Packet_Fixed<0x2af9>; +template<> +struct NetPacket_Fixed<0x2af9>; + +template<> +struct Packet_Head<0x2afa>; +template<> +struct NetPacket_Head<0x2afa>; +template<> +struct Packet_Repeat<0x2afa>; +template<> +struct NetPacket_Repeat<0x2afa>; + +template<> +struct Packet_Fixed<0x2afa>; +template<> +struct NetPacket_Fixed<0x2afa>; + +template<> +struct Packet_Fixed<0x2afb>; +template<> +struct NetPacket_Fixed<0x2afb>; + +template<> +struct Packet_Fixed<0x2afc>; +template<> +struct NetPacket_Fixed<0x2afc>; + +template<> +struct Packet_Payload<0x2afd>; +template<> +struct NetPacket_Payload<0x2afd>; + +template<> +struct Packet_Fixed<0x2afe>; +template<> +struct NetPacket_Fixed<0x2afe>; + +template<> +struct Packet_Head<0x2aff>; +template<> +struct NetPacket_Head<0x2aff>; +template<> +struct Packet_Repeat<0x2aff>; +template<> +struct NetPacket_Repeat<0x2aff>; + +template<> +struct Packet_Fixed<0x2b00>; +template<> +struct NetPacket_Fixed<0x2b00>; + +template<> +struct Packet_Payload<0x2b01>; +template<> +struct NetPacket_Payload<0x2b01>; + +template<> +struct Packet_Fixed<0x2b02>; +template<> +struct NetPacket_Fixed<0x2b02>; + +template<> +struct Packet_Fixed<0x2b03>; +template<> +struct NetPacket_Fixed<0x2b03>; + +template<> +struct Packet_Head<0x2b04>; +template<> +struct NetPacket_Head<0x2b04>; +template<> +struct Packet_Repeat<0x2b04>; +template<> +struct NetPacket_Repeat<0x2b04>; + +template<> +struct Packet_Fixed<0x2b05>; +template<> +struct NetPacket_Fixed<0x2b05>; + +template<> +struct Packet_Fixed<0x2b06>; +template<> +struct NetPacket_Fixed<0x2b06>; + +template<> +struct Packet_Head<0x2b0a>; +template<> +struct NetPacket_Head<0x2b0a>; +template<> +struct Packet_Repeat<0x2b0a>; +template<> +struct NetPacket_Repeat<0x2b0a>; + +template<> +struct Packet_Fixed<0x2b0b>; +template<> +struct NetPacket_Fixed<0x2b0b>; + +template<> +struct Packet_Fixed<0x2b0c>; +template<> +struct NetPacket_Fixed<0x2b0c>; + +template<> +struct Packet_Fixed<0x2b0d>; +template<> +struct NetPacket_Fixed<0x2b0d>; + +template<> +struct Packet_Fixed<0x2b0e>; +template<> +struct NetPacket_Fixed<0x2b0e>; + +template<> +struct Packet_Fixed<0x2b0f>; +template<> +struct NetPacket_Fixed<0x2b0f>; + +template<> +struct Packet_Head<0x2b10>; +template<> +struct NetPacket_Head<0x2b10>; +template<> +struct Packet_Repeat<0x2b10>; +template<> +struct NetPacket_Repeat<0x2b10>; + +template<> +struct Packet_Head<0x2b11>; +template<> +struct NetPacket_Head<0x2b11>; +template<> +struct Packet_Repeat<0x2b11>; +template<> +struct NetPacket_Repeat<0x2b11>; +template<> +struct Packet_Fixed<0x2b12>; +template<> +struct NetPacket_Fixed<0x2b12>; +template<> +struct Packet_Fixed<0x2b13>; +template<> +struct NetPacket_Fixed<0x2b13>; + +template<> +struct Packet_Fixed<0x2b14>; +template<> +struct NetPacket_Fixed<0x2b14>; + +template<> +struct Packet_Head<0x2b15>; +template<> +struct NetPacket_Head<0x2b15>; +template<> +struct Packet_Repeat<0x2b15>; +template<> +struct NetPacket_Repeat<0x2b15>; + +template<> +struct Packet_Fixed<0x2b16>; +template<> +struct NetPacket_Fixed<0x2b16>; + +template<> +struct Packet_Head<0x3000>; +template<> +struct NetPacket_Head<0x3000>; +template<> +struct Packet_Repeat<0x3000>; +template<> +struct NetPacket_Repeat<0x3000>; + +template<> +struct Packet_Head<0x3001>; +template<> +struct NetPacket_Head<0x3001>; +template<> +struct Packet_Repeat<0x3001>; +template<> +struct NetPacket_Repeat<0x3001>; + +template<> +struct Packet_Fixed<0x3002>; +template<> +struct NetPacket_Fixed<0x3002>; + +template<> +struct Packet_Head<0x3003>; +template<> +struct NetPacket_Head<0x3003>; +template<> +struct Packet_Repeat<0x3003>; +template<> +struct NetPacket_Repeat<0x3003>; + +template<> +struct Packet_Head<0x3004>; +template<> +struct NetPacket_Head<0x3004>; +template<> +struct Packet_Repeat<0x3004>; +template<> +struct NetPacket_Repeat<0x3004>; + +template<> +struct Packet_Fixed<0x3005>; +template<> +struct NetPacket_Fixed<0x3005>; + +template<> +struct Packet_Fixed<0x3010>; +template<> +struct NetPacket_Fixed<0x3010>; + +template<> +struct Packet_Payload<0x3011>; +template<> +struct NetPacket_Payload<0x3011>; + +template<> +struct Packet_Fixed<0x3020>; +template<> +struct NetPacket_Fixed<0x3020>; + +template<> +struct Packet_Fixed<0x3021>; +template<> +struct NetPacket_Fixed<0x3021>; + +template<> +struct Packet_Fixed<0x3022>; +template<> +struct NetPacket_Fixed<0x3022>; + +template<> +struct Packet_Fixed<0x3023>; +template<> +struct NetPacket_Fixed<0x3023>; + +template<> +struct Packet_Fixed<0x3024>; +template<> +struct NetPacket_Fixed<0x3024>; + +template<> +struct Packet_Fixed<0x3025>; +template<> +struct NetPacket_Fixed<0x3025>; + +template<> +struct Packet_Fixed<0x3026>; +template<> +struct NetPacket_Fixed<0x3026>; + +template<> +struct Packet_Head<0x3027>; +template<> +struct NetPacket_Head<0x3027>; +template<> +struct Packet_Repeat<0x3027>; +template<> +struct NetPacket_Repeat<0x3027>; + +template<> +struct Packet_Fixed<0x3028>; +template<> +struct NetPacket_Fixed<0x3028>; + +template<> +struct Packet_Head<0x3800>; +template<> +struct NetPacket_Head<0x3800>; +template<> +struct Packet_Repeat<0x3800>; +template<> +struct NetPacket_Repeat<0x3800>; + +template<> +struct Packet_Head<0x3801>; +template<> +struct NetPacket_Head<0x3801>; +template<> +struct Packet_Repeat<0x3801>; +template<> +struct NetPacket_Repeat<0x3801>; + +template<> +struct Packet_Fixed<0x3802>; +template<> +struct NetPacket_Fixed<0x3802>; + +template<> +struct Packet_Head<0x3803>; +template<> +struct NetPacket_Head<0x3803>; +template<> +struct Packet_Repeat<0x3803>; +template<> +struct NetPacket_Repeat<0x3803>; + +template<> +struct Packet_Head<0x3804>; +template<> +struct NetPacket_Head<0x3804>; +template<> +struct Packet_Repeat<0x3804>; +template<> +struct NetPacket_Repeat<0x3804>; + +template<> +struct Packet_Payload<0x3810>; +template<> +struct NetPacket_Payload<0x3810>; + +template<> +struct Packet_Fixed<0x3811>; +template<> +struct NetPacket_Fixed<0x3811>; + +template<> +struct Packet_Fixed<0x3820>; +template<> +struct NetPacket_Fixed<0x3820>; + +template<> +struct Packet_Head<0x3821>; +template<> +struct NetPacket_Head<0x3821>; +template<> +struct Packet_Option<0x3821>; +template<> +struct NetPacket_Option<0x3821>; + +template<> +struct Packet_Fixed<0x3822>; +template<> +struct NetPacket_Fixed<0x3822>; + +template<> +struct Packet_Fixed<0x3823>; +template<> +struct NetPacket_Fixed<0x3823>; + +template<> +struct Packet_Fixed<0x3824>; +template<> +struct NetPacket_Fixed<0x3824>; + +template<> +struct Packet_Fixed<0x3825>; +template<> +struct NetPacket_Fixed<0x3825>; + +template<> +struct Packet_Fixed<0x3826>; +template<> +struct NetPacket_Fixed<0x3826>; + +template<> +struct Packet_Head<0x3827>; +template<> +struct NetPacket_Head<0x3827>; +template<> +struct Packet_Repeat<0x3827>; +template<> +struct NetPacket_Repeat<0x3827>; + + +template<> +struct Packet_Fixed<0x0061>; +template<> +struct NetPacket_Fixed<0x0061>; + +template<> +struct Packet_Fixed<0x0062>; +template<> +struct NetPacket_Fixed<0x0062>; + +template<> +struct Packet_Fixed<0x0065>; +template<> +struct NetPacket_Fixed<0x0065>; + +template<> +struct Packet_Fixed<0x0066>; +template<> +struct NetPacket_Fixed<0x0066>; + +template<> +struct Packet_Fixed<0x0067>; +template<> +struct NetPacket_Fixed<0x0067>; + +template<> +struct Packet_Fixed<0x0068>; +template<> +struct NetPacket_Fixed<0x0068>; + +template<> +struct Packet_Head<0x006b>; +template<> +struct NetPacket_Head<0x006b>; +template<> +struct Packet_Repeat<0x006b>; +template<> +struct NetPacket_Repeat<0x006b>; + +template<> +struct Packet_Fixed<0x006c>; +template<> +struct NetPacket_Fixed<0x006c>; + +template<> +struct Packet_Fixed<0x006d>; +template<> +struct NetPacket_Fixed<0x006d>; + +template<> +struct Packet_Fixed<0x006e>; +template<> +struct NetPacket_Fixed<0x006e>; + +template<> +struct Packet_Fixed<0x006f>; +template<> +struct NetPacket_Fixed<0x006f>; + +template<> +struct Packet_Fixed<0x0070>; +template<> +struct NetPacket_Fixed<0x0070>; + +template<> +struct Packet_Fixed<0x0071>; +template<> +struct NetPacket_Fixed<0x0071>; template<> @@ -459,6 +909,11 @@ template<> struct NetPacket_Fixed<0x0212>; +template<> +struct Packet_Fixed<0x0081>; +template<> +struct NetPacket_Fixed<0x0081>; + template<> struct Packet_Fixed<0x7530>; template<> diff --git a/src/proto2/include_enums_test.cpp b/src/proto2/include_enums_test.cpp index 2b9ed36..49b4a95 100644 --- a/src/proto2/include_enums_test.cpp +++ b/src/proto2/include_enums_test.cpp @@ -21,3 +21,4 @@ #include "../poison.hpp" using Test_SEX = SEX; +using Test_Option = Option; diff --git a/src/proto2/include_mmo_test.cpp b/src/proto2/include_mmo_test.cpp new file mode 100644 index 0000000..feb2de2 --- /dev/null +++ b/src/proto2/include_mmo_test.cpp @@ -0,0 +1,26 @@ +#include "../mmo/mmo.hpp" +// include_mmo_test.cpp - testsuite for protocol includes +// +// Copyright © 2014 Ben Longbons +// +// This file is part of The Mana World (Athena server) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#include "../poison.hpp" + +using Test_CharKey = CharKey; +using Test_CharData = CharData; +using Test_PartyMost = PartyMost; +using Test_Storage = Storage; diff --git a/src/proto2/include_strs_test.cpp b/src/proto2/include_strs_test.cpp index 5bf516c..eeaed7c 100644 --- a/src/proto2/include_strs_test.cpp +++ b/src/proto2/include_strs_test.cpp @@ -24,4 +24,7 @@ using Test_AccountName = AccountName; using Test_AccountPass = AccountPass; using Test_AccountEmail = AccountEmail; using Test_ServerName = ServerName; +using Test_PartyName = PartyName; using Test_VarName = VarName; +using Test_CharName = CharName; +using Test_MapName = MapName; diff --git a/src/proto2/login-admin.hpp b/src/proto2/login-admin.hpp index f5cf0f7..7876d1d 100644 --- a/src/proto2/login-admin.hpp +++ b/src/proto2/login-admin.hpp @@ -27,6 +27,9 @@ // This is an internal protocol, and can be changed without notice +// this is only needed for the payload packet right now, and that needs to die +#pragma pack(push, 1) + template<> struct Packet_Head<0x2726> { @@ -2164,4 +2167,6 @@ bool network_to_native(Packet_Fixed<0x7955> *native, NetPacket_Fixed<0x7955> net } +#pragma pack(pop) + #endif // TMWA_PROTO2_LOGIN_ADMIN_HPP diff --git a/src/proto2/login-char.hpp b/src/proto2/login-char.hpp index 6b2004d..14d19a9 100644 --- a/src/proto2/login-char.hpp +++ b/src/proto2/login-char.hpp @@ -27,6 +27,9 @@ // This is an internal protocol, and can be changed without notice +// this is only needed for the payload packet right now, and that needs to die +#pragma pack(push, 1) + template<> struct Packet_Fixed<0x2709> { @@ -206,7 +209,7 @@ struct Packet_Fixed<0x2725> // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; - HumanTimeDiff deltas = {}; + HumanTimeDiff ban_add = {}; }; template<> @@ -532,11 +535,11 @@ struct NetPacket_Fixed<0x2725> { Little16 magic_packet_id; Little32 account_id; - NetHumanTimeDiff deltas; + NetHumanTimeDiff ban_add; }; static_assert(offsetof(NetPacket_Fixed<0x2725>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2725>, magic_packet_id) == 0"); static_assert(offsetof(NetPacket_Fixed<0x2725>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2725>, account_id) == 2"); -static_assert(offsetof(NetPacket_Fixed<0x2725>, deltas) == 6, "offsetof(NetPacket_Fixed<0x2725>, deltas) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2725>, ban_add) == 6, "offsetof(NetPacket_Fixed<0x2725>, ban_add) == 6"); static_assert(sizeof(NetPacket_Fixed<0x2725>) == 18, "sizeof(NetPacket_Fixed<0x2725>) == 18"); template<> @@ -975,7 +978,7 @@ bool native_to_network(NetPacket_Fixed<0x2725> *network, Packet_Fixed<0x2725> na bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); rv &= native_to_network(&network->account_id, native.account_id); - rv &= native_to_network(&network->deltas, native.deltas); + rv &= native_to_network(&network->ban_add, native.ban_add); return rv; } inline __attribute__((warn_unused_result)) @@ -984,7 +987,7 @@ bool network_to_native(Packet_Fixed<0x2725> *native, NetPacket_Fixed<0x2725> net bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); rv &= network_to_native(&native->account_id, network.account_id); - rv &= network_to_native(&native->deltas, network.deltas); + rv &= network_to_native(&native->ban_add, network.ban_add); return rv; } @@ -1204,4 +1207,6 @@ bool network_to_native(Packet_Fixed<0x2741> *native, NetPacket_Fixed<0x2741> net } +#pragma pack(pop) + #endif // TMWA_PROTO2_LOGIN_CHAR_HPP diff --git a/src/proto2/login-user.hpp b/src/proto2/login-user.hpp index dbdf322..7f0e5ea 100644 --- a/src/proto2/login-user.hpp +++ b/src/proto2/login-user.hpp @@ -27,6 +27,9 @@ // This is a public protocol, and changes require client cooperation +// this is only needed for the payload packet right now, and that needs to die +#pragma pack(push, 1) + template<> struct Packet_Head<0x0063> { @@ -99,16 +102,6 @@ struct Packet_Fixed<0x006a> timestamp_seconds_buffer error_message = {}; }; -template<> -struct Packet_Fixed<0x0081> -{ - static const uint16_t PACKET_ID = 0x0081; - - // TODO remove this - uint16_t magic_packet_id = PACKET_ID; - uint8_t error_code = {}; -}; - template<> struct NetPacket_Head<0x0063> @@ -196,16 +189,6 @@ static_assert(offsetof(NetPacket_Fixed<0x006a>, error_code) == 2, "offsetof(NetP static_assert(offsetof(NetPacket_Fixed<0x006a>, error_message) == 3, "offsetof(NetPacket_Fixed<0x006a>, error_message) == 3"); static_assert(sizeof(NetPacket_Fixed<0x006a>) == 23, "sizeof(NetPacket_Fixed<0x006a>) == 23"); -template<> -struct NetPacket_Fixed<0x0081> -{ - Little16 magic_packet_id; - Byte error_code; -}; -static_assert(offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0081>, magic_packet_id) == 0"); -static_assert(offsetof(NetPacket_Fixed<0x0081>, error_code) == 2, "offsetof(NetPacket_Fixed<0x0081>, error_code) == 2"); -static_assert(sizeof(NetPacket_Fixed<0x0081>) == 3, "sizeof(NetPacket_Fixed<0x0081>) == 3"); - inline __attribute__((warn_unused_result)) bool native_to_network(NetPacket_Head<0x0063> *network, Packet_Head<0x0063> native) @@ -335,22 +318,7 @@ bool network_to_native(Packet_Fixed<0x006a> *native, NetPacket_Fixed<0x006a> net return rv; } -inline __attribute__((warn_unused_result)) -bool native_to_network(NetPacket_Fixed<0x0081> *network, Packet_Fixed<0x0081> native) -{ - bool rv = true; - rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); - rv &= native_to_network(&network->error_code, native.error_code); - return rv; -} -inline __attribute__((warn_unused_result)) -bool network_to_native(Packet_Fixed<0x0081> *native, NetPacket_Fixed<0x0081> network) -{ - bool rv = true; - rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); - rv &= network_to_native(&native->error_code, network.error_code); - return rv; -} +#pragma pack(pop) #endif // TMWA_PROTO2_LOGIN_USER_HPP diff --git a/src/proto2/map-user.hpp b/src/proto2/map-user.hpp index d68f436..08d19fa 100644 --- a/src/proto2/map-user.hpp +++ b/src/proto2/map-user.hpp @@ -27,6 +27,9 @@ // This is a public protocol, and changes require client cooperation +// this is only needed for the payload packet right now, and that needs to die +#pragma pack(push, 1) + template<> struct Packet_Fixed<0x0212> { @@ -87,4 +90,6 @@ bool network_to_native(Packet_Fixed<0x0212> *native, NetPacket_Fixed<0x0212> net } +#pragma pack(pop) + #endif // TMWA_PROTO2_MAP_USER_HPP diff --git a/src/proto2/types.hpp b/src/proto2/types.hpp index 92413e3..594be22 100644 --- a/src/proto2/types.hpp +++ b/src/proto2/types.hpp @@ -29,6 +29,7 @@ # include "../mmo/enums.hpp" # include "../mmo/human_time_diff.hpp" # include "../mmo/ids.hpp" +# include "../mmo/mmo.hpp" # include "../mmo/strs.hpp" # include "../mmo/utils.hpp" # include "../mmo/version.hpp" @@ -71,6 +72,38 @@ bool network_to_native(VString *native, NetString network) return true; } +inline +bool native_to_network(NetString<24> *network, CharName native) +{ + VString<23> tmp = native.to__actual(); + bool rv = native_to_network(network, tmp); + return rv; +} +inline +bool network_to_native(CharName *native, NetString<24> network) +{ + VString<23> tmp; + bool rv = network_to_native(&tmp, network); + *native = stringish(tmp); + return rv; +} + +inline +bool native_to_network(NetString<16> *network, MapName native) +{ + XString tmp = native; + bool rv = native_to_network(network, VString<15>(tmp)); + return rv; +} +inline +bool network_to_native(MapName *native, NetString<16> network) +{ + VString<15> tmp; + bool rv = network_to_native(&tmp, network); + *native = stringish(tmp); + return rv; +} + template struct SkewedLength { @@ -109,6 +142,24 @@ bool network_to_native(SEX *native, Byte network) return rv; } inline __attribute__((warn_unused_result)) +bool native_to_network(Little16 *network, Option native) +{ + bool rv = true; + uint16_t tmp = static_cast(native); + rv &= native_to_network(network, tmp); + return rv; +} +inline __attribute__((warn_unused_result)) +bool network_to_native(Option *native, Little16 network) +{ + bool rv = true; + uint16_t tmp; + rv &= network_to_native(&tmp, network); + *native = static_cast