From b06dd5aaa0cf47b0b6f73ae858b2e2c267e60bbf Mon Sep 17 00:00:00 2001 From: Ben Longbons Date: Mon, 19 May 2014 21:05:38 -0700 Subject: make packets be non-type templates --- src/login/login.cpp | 166 ++++---- src/net/packets.cpp | 4 +- src/net/packets.hpp | 215 +++++----- src/proto2/any-user.hpp | 50 ++- src/proto2/fwd.hpp | 483 ++++++++++++++-------- src/proto2/login-admin.hpp | 986 +++++++++++++++++++++++++-------------------- src/proto2/login-char.hpp | 512 ++++++++++++----------- src/proto2/map-user.hpp | 26 +- 8 files changed, 1369 insertions(+), 1073 deletions(-) (limited to 'src') diff --git a/src/login/login.cpp b/src/login/login.cpp index d553d7c..7170a59 100644 --- a/src/login/login.cpp +++ b/src/login/login.cpp @@ -731,14 +731,14 @@ auto iter_char_sessions() -> decltype(filter_iterator(&server_session static void send_GM_accounts(void) { - std::vector tail; + std::vector> tail; for (const AuthData& ad : auth_data) { // send only existing accounts. We can not create a GM account when server is online. if (GmLevel GM_value = isGM(ad.account_id)) { - SPacket_0x2732_Repeat item; + Packet_Repeat<0x2732> item; item.account_id = ad.account_id; item.gm_level = GM_value; tail.push_back(item); @@ -1001,7 +1001,7 @@ void parse_fromchar(Session *s) // request from map-server via char-server to reload GM accounts (by Yor). case 0x2709: { - RPacket_0x2709_Fixed fixed; + Packet_Fixed<0x2709> fixed; rv = recv_fpacket<0x2709, 2>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1016,7 +1016,7 @@ void parse_fromchar(Session *s) case 0x2712: // request from char-server to authentify an account { - RPacket_0x2712_Fixed fixed; + Packet_Fixed<0x2712> fixed; rv = recv_fpacket<0x2712, 19>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1041,22 +1041,22 @@ void parse_fromchar(Session *s) { if (ad.account_id == acc) { - SPacket_0x2729_Head head_29; + Packet_Head<0x2729> head_29; head_29.account_id = acc; - std::vector repeat_29; + std::vector> repeat_29; int j; for (j = 0; j < ad.account_reg2_num; j++) { - SPacket_0x2729_Repeat item; + Packet_Repeat<0x2729> item; item.name = ad.account_reg2[j].str; item.value = ad.account_reg2[j].value; repeat_29.push_back(item); } send_vpacket<0x2729, 8, 36>(s, head_29, repeat_29); - SPacket_0x2713_Fixed fixed_13; + Packet_Fixed<0x2713> fixed_13; fixed_13.account_id = acc; fixed_13.invalid = 0; fixed_13.email = ad.email; @@ -1075,7 +1075,7 @@ void parse_fromchar(Session *s) LOGIN_LOG("Char-server '%s': authentification of the account %d REFUSED (ip: %s).\n"_fmt, server[id].name, acc, ip); - SPacket_0x2713_Fixed fixed_13; + Packet_Fixed<0x2713> fixed_13; fixed_13.account_id = acc; fixed_13.invalid = 1; // fixed_13.email @@ -1089,7 +1089,7 @@ void parse_fromchar(Session *s) case 0x2714: { - RPacket_0x2714_Fixed fixed; + Packet_Fixed<0x2714> fixed; rv = recv_fpacket<0x2714, 6>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1103,7 +1103,7 @@ void parse_fromchar(Session *s) // we receive a e-mail creation of an account with a default e-mail (no answer) case 0x2715: { - RPacket_0x2715_Fixed fixed; + Packet_Fixed<0x2715> fixed; rv = recv_fpacket<0x2715, 46>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1135,7 +1135,7 @@ void parse_fromchar(Session *s) // We receive an e-mail/limited time request, because a player comes back from a map-server to the char-server case 0x2716: { - RPacket_0x2716_Fixed fixed; + Packet_Fixed<0x2716> fixed; rv = recv_fpacket<0x2716, 6>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1148,7 +1148,7 @@ void parse_fromchar(Session *s) LOGIN_LOG("Char-server '%s': e-mail of the account %d found (ip: %s).\n"_fmt, server[id].name, account_id, ip); - SPacket_0x2717_Fixed fixed_17; + Packet_Fixed<0x2717> fixed_17; fixed_17.account_id = account_id; fixed_17.email = ad.email; fixed_17.connect_until = ad.connect_until_time; @@ -1167,7 +1167,7 @@ void parse_fromchar(Session *s) case 0x2720: // To become GM request { - RPacket_0x2720_Head head; + Packet_Head<0x2720> head; AString repeat; rv = recv_vpacket<0x2720, 8, 1>(s, head, repeat); if (rv != RecvResult::Complete) @@ -1176,7 +1176,7 @@ void parse_fromchar(Session *s) { AccountId acc = head.account_id; - SPacket_0x2721_Fixed fixed_21; + Packet_Fixed<0x2721> fixed_21; fixed_21.account_id = acc; fixed_21.gm_level = GmLevel(); @@ -1255,7 +1255,7 @@ void parse_fromchar(Session *s) // Map server send information to change an email of an account via char-server case 0x2722: // 0x2722 .L .40B .40B { - RPacket_0x2722_Fixed fixed; + Packet_Fixed<0x2722> fixed; rv = recv_fpacket<0x2722, 86>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1305,7 +1305,7 @@ void parse_fromchar(Session *s) // Receiving of map-server via char-server a status change resquest (by Yor) case 0x2724: { - RPacket_0x2724_Fixed fixed; + Packet_Fixed<0x2724> fixed; rv = recv_fpacket<0x2724, 10>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1324,7 +1324,7 @@ void parse_fromchar(Session *s) ip); if (statut != 0) { - SPacket_0x2731_Fixed fixed_31; + Packet_Fixed<0x2731> fixed_31; fixed_31.account_id = acc; fixed_31.ban_not_status = 0; fixed_31.status_or_ban_until = static_cast(statut); @@ -1359,7 +1359,7 @@ void parse_fromchar(Session *s) case 0x2725: // Receiving of map-server via char-server a ban resquest (by Yor) { - RPacket_0x2725_Fixed fixed; + Packet_Fixed<0x2725> fixed; rv = recv_fpacket<0x2725, 18>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1402,7 +1402,7 @@ void parse_fromchar(Session *s) timestamp, tmpstr, ip); - SPacket_0x2731_Fixed fixed_31; + Packet_Fixed<0x2731> fixed_31; fixed_31.account_id = ad.account_id; fixed_31.ban_not_status = 1; fixed_31.status_or_ban_until = timestamp; @@ -1450,7 +1450,7 @@ void parse_fromchar(Session *s) case 0x2727: // Change of sex (sex is reversed) { - RPacket_0x2727_Fixed fixed; + Packet_Fixed<0x2727> fixed; rv = recv_fpacket<0x2727, 6>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1478,7 +1478,7 @@ void parse_fromchar(Session *s) } ad.sex = sex; - SPacket_0x2723_Fixed fixed_23; + Packet_Fixed<0x2723> fixed_23; fixed_23.account_id = acc; fixed_23.sex = sex; @@ -1500,8 +1500,8 @@ void parse_fromchar(Session *s) case 0x2728: // We receive account_reg2 from a char-server, and we send them to other char-servers. { - RPacket_0x2728_Head head; - std::vector repeat; + Packet_Head<0x2728> head; + std::vector> repeat; rv = recv_vpacket<0x2728, 8, 36>(s, head, repeat); if (rv != RecvResult::Complete) break; @@ -1524,8 +1524,8 @@ void parse_fromchar(Session *s) ad.account_reg2_num = count; // Sending information towards the other char-servers. - SPacket_0x2729_Head head_29; - std::vector repeat_29(repeat.size()); + Packet_Head<0x2729> head_29; + std::vector> repeat_29(repeat.size()); head_29.account_id = head.account_id; for (size_t j = 0; j < count; ++j) { @@ -1551,7 +1551,7 @@ void parse_fromchar(Session *s) case 0x272a: // Receiving of map-server via char-server a unban resquest (by Yor) { - RPacket_0x272a_Fixed fixed; + Packet_Fixed<0x272a> fixed; rv = recv_fpacket<0x272a, 6>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1587,7 +1587,7 @@ void parse_fromchar(Session *s) // request from char-server to change account password case 0x2740: // 0x2740 .L .24B .24B { - RPacket_0x2740_Fixed fixed; + Packet_Fixed<0x2740> fixed; rv = recv_fpacket<0x2740, 54>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1627,7 +1627,7 @@ void parse_fromchar(Session *s) } } x2740_out: - SPacket_0x2741_Fixed fixed_41; + Packet_Fixed<0x2741> fixed_41; fixed_41.account_id = acc; fixed_41.status = status; send_fpacket<0x2741, 7>(s, fixed_41); @@ -1684,7 +1684,7 @@ void parse_admin(Session *s) { case 0x7530: // Request of the server version { - RPacket_0x7530_Fixed fixed; + Packet_Fixed<0x7530> fixed; rv = recv_fpacket<0x7530, 2>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1692,7 +1692,7 @@ void parse_admin(Session *s) LOGIN_LOG("'ladmin': Sending of the server version (ip: %s)\n"_fmt, ip); - SPacket_0x7531_Fixed fixed_31; + Packet_Fixed<0x7531> fixed_31; fixed_31.version = CURRENT_LOGIN_SERVER_VERSION; send_fpacket<0x7531, 10>(s, fixed_31); break; @@ -1700,7 +1700,7 @@ void parse_admin(Session *s) case 0x7532: // Request of end of connection { - RPacket_0x7532_Fixed fixed; + Packet_Fixed<0x7532> fixed; rv = recv_fpacket<0x7532, 2>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1713,7 +1713,7 @@ void parse_admin(Session *s) case 0x7920: // Request of an accounts list { - RPacket_0x7920_Fixed fixed; + Packet_Fixed<0x7920> fixed; rv = recv_fpacket<0x7920, 10>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1728,14 +1728,14 @@ void parse_admin(Session *s) st, ed, ip); // Sending accounts information - std::vector repeat_21; + std::vector> repeat_21; for (const AuthData& ad : auth_data) { AccountId account_id = ad.account_id; if (!(account_id < st) && !(ed < account_id)) { - SPacket_0x7921_Repeat info; + Packet_Repeat<0x7921> info; info.account_id = account_id; info.gm_level = isGM(account_id); info.account_name = ad.userid; @@ -1755,7 +1755,7 @@ void parse_admin(Session *s) case 0x7924: { // [Fate] Itemfrob package: change item IDs - RPacket_0x7924_Fixed fixed; + Packet_Fixed<0x7924> fixed; rv = recv_fpacket<0x7924, 10>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1765,14 +1765,14 @@ void parse_admin(Session *s) send_fpacket<0x7924, 10>(ss, fixed); } - SPacket_0x7925_Fixed fixed_25; + Packet_Fixed<0x7925> fixed_25; send_fpacket<0x7925, 2>(s, fixed_25); break; } case 0x7930: // Request for an account creation { - RPacket_0x7930_Fixed fixed; + Packet_Fixed<0x7930> fixed; rv = recv_fpacket<0x7930, 91>(s, fixed); if (rv != RecvResult::Complete) break; @@ -1785,7 +1785,7 @@ void parse_admin(Session *s) ma.lastlogin = stringish("-"_s); ma.sex = fixed.sex; - SPacket_0x7931_Fixed fixed_31; + Packet_Fixed<0x7931> fixed_31; fixed_31.account_id = AccountId(); fixed_31.account_name = ma.userid; if (ma.userid.size() < 4 || ma.passwd.size() < 4) @@ -1831,19 +1831,19 @@ void parse_admin(Session *s) case 0x7932: // Request for an account deletion { - RPacket_0x7932_Fixed fixed; + Packet_Fixed<0x7932> fixed; rv = recv_fpacket<0x7932, 26>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x7933_Fixed fixed_33; + Packet_Fixed<0x7933> fixed_33; fixed_33.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); AuthData *ad = search_account(account_name); if (ad) { // Char-server is notified of deletion (for characters deletion). - SPacket_0x2730_Fixed fixed_30; + Packet_Fixed<0x2730> fixed_30; fixed_30.account_id = ad->account_id; for (Session *ss : iter_char_sessions()) @@ -1878,12 +1878,12 @@ void parse_admin(Session *s) case 0x7934: // Request to change a password { - RPacket_0x7934_Fixed fixed; + Packet_Fixed<0x7934> fixed; rv = recv_fpacket<0x7934, 50>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x7935_Fixed fixed_35; + Packet_Fixed<0x7935> fixed_35; fixed_35.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); AuthData *ad = search_account(account_name); @@ -1908,13 +1908,13 @@ void parse_admin(Session *s) case 0x7936: // Request to modify a state { - RPacket_0x7936_Fixed fixed; + Packet_Fixed<0x7936> fixed; rv = recv_fpacket<0x7936, 50>(s, fixed); if (rv != RecvResult::Complete) break; { - SPacket_0x7937_Fixed fixed_37; + Packet_Fixed<0x7937> fixed_37; fixed_37.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); int statut = fixed.status; @@ -1944,7 +1944,7 @@ void parse_admin(Session *s) ad->userid, statut, ip); if (ad->state == 0) { - SPacket_0x2731_Fixed fixed_31; + Packet_Fixed<0x2731> fixed_31; fixed_31.account_id = ad->account_id; fixed_31.ban_not_status = 0; fixed_31.status_or_ban_until = static_cast(statut); @@ -1977,18 +1977,18 @@ void parse_admin(Session *s) case 0x7938: // Request for servers list and # of online players { - RPacket_0x7938_Fixed fixed; + Packet_Fixed<0x7938> fixed; rv = recv_fpacket<0x7938, 2>(s, fixed); if (rv != RecvResult::Complete) break; LOGIN_LOG("'ladmin': Sending of servers list (ip: %s)\n"_fmt, ip); - std::vector repeat_39; + std::vector> repeat_39; for (int i = 0; i < MAX_SERVERS; i++) { if (server_session[i]) { - SPacket_0x7939_Repeat info; + Packet_Repeat<0x7939> info; info.ip = server[i].ip; info.port = server[i].port; info.name = server[i].name; @@ -2004,12 +2004,12 @@ void parse_admin(Session *s) case 0x793a: // Request to password check { - RPacket_0x793a_Fixed fixed; + Packet_Fixed<0x793a> fixed; rv = recv_fpacket<0x793a, 50>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x793b_Fixed fixed_3b; + Packet_Fixed<0x793b> fixed_3b; fixed_3b.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); const AuthData *ad = search_account(account_name); @@ -2042,12 +2042,12 @@ void parse_admin(Session *s) case 0x793c: // Request to modify sex { - RPacket_0x793c_Fixed fixed; + Packet_Fixed<0x793c> fixed; rv = recv_fpacket<0x793c, 27>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x793d_Fixed fixed_3d; + Packet_Fixed<0x793d> fixed_3d; fixed_3d.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); fixed_3d.account_name = account_name; @@ -2079,7 +2079,7 @@ void parse_admin(Session *s) ad->userid, sex_to_char(sex), ip); // send to all char-server the change - SPacket_0x2723_Fixed fixed_23; + Packet_Fixed<0x2723> fixed_23; fixed_23.account_id = ad->account_id; fixed_23.sex = ad->sex; @@ -2107,12 +2107,12 @@ void parse_admin(Session *s) case 0x793e: // Request to modify GM level { - RPacket_0x793e_Fixed fixed; + Packet_Fixed<0x793e> fixed; rv = recv_fpacket<0x793e, 27>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x793f_Fixed fixed_3f; + Packet_Fixed<0x793f> fixed_3f; fixed_3f.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); fixed_3f.account_name = account_name; @@ -2229,12 +2229,12 @@ void parse_admin(Session *s) case 0x7940: // Request to modify e-mail { - RPacket_0x7940_Fixed fixed; + Packet_Fixed<0x7940> fixed; rv = recv_fpacket<0x7940, 66>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x7941_Fixed fixed_41; + Packet_Fixed<0x7941> fixed_41; fixed_41.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); fixed_41.account_name = account_name; @@ -2269,13 +2269,13 @@ void parse_admin(Session *s) case 0x7942: // Request to modify memo field { - RPacket_0x7942_Head head; + Packet_Head<0x7942> head; AString repeat; rv = recv_vpacket<0x7942, 28, 1>(s, head, repeat); if (rv != RecvResult::Complete) break; - SPacket_0x7943_Fixed fixed_43; + Packet_Fixed<0x7943> fixed_43; fixed_43.account_id = AccountId(); AccountName account_name = stringish(head.account_name.to_print()); AuthData *ad = search_account(account_name); @@ -2309,12 +2309,12 @@ void parse_admin(Session *s) case 0x7944: // Request to found an account id { - RPacket_0x7944_Fixed fixed; + Packet_Fixed<0x7944> fixed; rv = recv_fpacket<0x7944, 26>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x7945_Fixed fixed_45; + Packet_Fixed<0x7945> fixed_45; fixed_45.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); const AuthData *ad = search_account(account_name); @@ -2338,13 +2338,13 @@ void parse_admin(Session *s) case 0x7946: // Request to found an account name { - RPacket_0x7946_Fixed fixed; + Packet_Fixed<0x7946> fixed; rv = recv_fpacket<0x7946, 6>(s, fixed); if (rv != RecvResult::Complete) break; AccountId account_id = fixed.account_id; - SPacket_0x7947_Fixed fixed_47; + Packet_Fixed<0x7947> fixed_47; fixed_47.account_id = account_id; fixed_47.account_name = {}; for (const AuthData& ad : auth_data) @@ -2367,12 +2367,12 @@ void parse_admin(Session *s) case 0x7948: // Request to change the validity limit (timestamp) (absolute value) { - RPacket_0x7948_Fixed fixed; + Packet_Fixed<0x7948> fixed; rv = recv_fpacket<0x7948, 30>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x7949_Fixed fixed_49; + Packet_Fixed<0x7949> fixed_49; { fixed_49.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); @@ -2409,12 +2409,12 @@ void parse_admin(Session *s) case 0x794a: // Request to change the final date of a banishment (timestamp) (absolute value) { - RPacket_0x794a_Fixed fixed; + Packet_Fixed<0x794a> fixed; rv = recv_fpacket<0x794a, 30>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x794b_Fixed fixed_4b; + Packet_Fixed<0x794b> fixed_4b; { fixed_4b.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); @@ -2437,7 +2437,7 @@ void parse_admin(Session *s) { if (timestamp) { - SPacket_0x2731_Fixed fixed_31; + Packet_Fixed<0x2731> fixed_31; fixed_31.account_id = ad->account_id; fixed_31.ban_not_status = 1; fixed_31.status_or_ban_until = timestamp; @@ -2473,12 +2473,12 @@ void parse_admin(Session *s) case 0x794c: // Request to change the final date of a banishment (timestamp) (relative change) { - RPacket_0x794c_Fixed fixed; + Packet_Fixed<0x794c> fixed; rv = recv_fpacket<0x794c, 38>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x794d_Fixed fixed_4d; + Packet_Fixed<0x794d> fixed_4d; { fixed_4d.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); @@ -2522,7 +2522,7 @@ void parse_admin(Session *s) { if (timestamp) { - SPacket_0x2731_Fixed fixed_31; + Packet_Fixed<0x2731> fixed_31; fixed_31.account_id = ad->account_id; fixed_31.ban_not_status = 1; fixed_31.status_or_ban_until = timestamp; @@ -2572,13 +2572,13 @@ void parse_admin(Session *s) case 0x794e: // Request to send a broadcast message { - RPacket_0x794e_Head head; + Packet_Head<0x794e> head; AString repeat; rv = recv_vpacket<0x794e, 8, 1>(s, head, repeat); if (rv != RecvResult::Complete) break; - SPacket_0x794f_Fixed fixed_4f; + Packet_Fixed<0x794f> fixed_4f; fixed_4f.error = -1; if (!repeat) { @@ -2604,7 +2604,7 @@ void parse_admin(Session *s) message, ip); // send same message to all char-servers (no answer) - SPacket_0x2726_Head head_26; + Packet_Head<0x2726> head_26; head_26.unused = head.unused; for (Session *ss : iter_char_sessions()) @@ -2620,12 +2620,12 @@ void parse_admin(Session *s) case 0x7950: // Request to change the validity limite (timestamp) (relative change) { - RPacket_0x7950_Fixed fixed; + Packet_Fixed<0x7950> fixed; rv = recv_fpacket<0x7950, 38>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x7951_Fixed fixed_51; + Packet_Fixed<0x7951> fixed_51; { fixed_51.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); @@ -2713,12 +2713,12 @@ void parse_admin(Session *s) case 0x7952: // Request about informations of an account (by account name) { - RPacket_0x7952_Fixed fixed; + Packet_Fixed<0x7952> fixed; rv = recv_fpacket<0x7952, 26>(s, fixed); if (rv != RecvResult::Complete) break; - SPacket_0x7953_Head head_53; + Packet_Head<0x7953> head_53; head_53.account_id = AccountId(); AccountName account_name = stringish(fixed.account_name.to_print()); const AuthData *ad = search_account(account_name); @@ -2756,13 +2756,13 @@ void parse_admin(Session *s) case 0x7954: // Request about information of an account (by account id) { - RPacket_0x7954_Fixed fixed; + Packet_Fixed<0x7954> fixed; rv = recv_fpacket<0x7954, 6>(s, fixed); if (rv != RecvResult::Complete) break; AccountId account_id = fixed.account_id; - SPacket_0x7953_Head head_53; + Packet_Head<0x7953> head_53; head_53.account_id = account_id; head_53.account_name = AccountName(); for (const AuthData& ad : auth_data) @@ -2799,7 +2799,7 @@ void parse_admin(Session *s) case 0x7955: // Request to reload GM file (no answer) { - RPacket_0x7955_Fixed fixed; + Packet_Fixed<0x7955> fixed; rv = recv_fpacket<0x7955, 2>(s, fixed); if (rv != RecvResult::Complete) break; diff --git a/src/net/packets.cpp b/src/net/packets.cpp index 5595b1d..112bed0 100644 --- a/src/net/packets.cpp +++ b/src/net/packets.cpp @@ -18,8 +18,8 @@ // You should have received a copy of the GNU General Public License // along with this program. If not, see . -# include "../io/cxxstdio.hpp" -# include "../io/write.hpp" +#include "../io/cxxstdio.hpp" +#include "../io/write.hpp" #include "vomit.hpp" diff --git a/src/net/packets.hpp b/src/net/packets.hpp index 2e3d77c..c0f3ecb 100644 --- a/src/net/packets.hpp +++ b/src/net/packets.hpp @@ -25,7 +25,10 @@ # include "../ints/little.hpp" - #include "../io/fwd.hpp" +# include "../io/fwd.hpp" + +// ordering violation, should invert +# include "../proto2/fwd.hpp" # include "socket.hpp" @@ -66,55 +69,55 @@ bool packet_peek_id(Session *s, uint16_t *packet_id) return okay; } -template +template __attribute__((warn_unused_result)) -SendResult net_send_fpacket(Session *s, const F& fixed) +SendResult net_send_fpacket(Session *s, const NetPacket_Fixed& fixed) { - bool ok = packet_send(s, reinterpret_cast(&fixed), sizeof(F)); + bool ok = packet_send(s, reinterpret_cast(&fixed), sizeof(NetPacket_Fixed)); return ok ? SendResult::Success : SendResult::Fail; } -template +template __attribute__((warn_unused_result)) -SendResult net_send_vpacket(Session *s, const H& head, const std::vector& repeat) +SendResult net_send_vpacket(Session *s, const NetPacket_Head& head, const std::vector>& repeat) { - bool ok = packet_send(s, reinterpret_cast(&head), sizeof(H)); - ok &= packet_send(s, reinterpret_cast(repeat.data()), repeat.size() * sizeof(R)); + bool ok = packet_send(s, reinterpret_cast(&head), sizeof(NetPacket_Head)); + ok &= packet_send(s, reinterpret_cast(repeat.data()), repeat.size() * sizeof(NetPacket_Repeat)); return ok ? SendResult::Success : SendResult::Fail; } -template +template __attribute__((warn_unused_result)) -RecvResult net_recv_fpacket(Session *s, F& fixed) +RecvResult net_recv_fpacket(Session *s, NetPacket_Fixed& fixed) { - bool ok = packet_fetch(s, 0, reinterpret_cast(&fixed), sizeof(F)); + bool ok = packet_fetch(s, 0, reinterpret_cast(&fixed), sizeof(NetPacket_Fixed)); if (ok) { - packet_discard(s, sizeof(F)); + packet_discard(s, sizeof(NetPacket_Fixed)); return RecvResult::Complete; } return RecvResult::Incomplete; } -template +template __attribute__((warn_unused_result)) -RecvResult net_recv_vpacket(Session *s, H& head, std::vector& repeat) +RecvResult net_recv_vpacket(Session *s, NetPacket_Head& head, std::vector>& repeat) { - bool ok = packet_fetch(s, 0, reinterpret_cast(&head), sizeof(H)); + bool ok = packet_fetch(s, 0, reinterpret_cast(&head), sizeof(NetPacket_Head)); if (ok) { - HNat nat; + Packet_Head nat; if (!network_to_native(&nat, head)) return RecvResult::Error; if (packet_avail(s) < nat.magic_packet_length) return RecvResult::Incomplete; - if (nat.magic_packet_length < sizeof(H)) + if (nat.magic_packet_length < sizeof(NetPacket_Head)) return RecvResult::Error; - size_t bytes_repeat = nat.magic_packet_length - sizeof(H); - if (bytes_repeat % sizeof(R)) + size_t bytes_repeat = nat.magic_packet_length - sizeof(NetPacket_Head); + if (bytes_repeat % sizeof(NetPacket_Repeat)) return RecvResult::Error; - repeat.resize(bytes_repeat / sizeof(R)); - if (packet_fetch(s, sizeof(H), reinterpret_cast(repeat.data()), bytes_repeat)) + repeat.resize(bytes_repeat / sizeof(NetPacket_Repeat)); + if (packet_fetch(s, sizeof(NetPacket_Head), reinterpret_cast(repeat.data()), bytes_repeat)) { packet_discard(s, nat.magic_packet_length); return RecvResult::Complete; @@ -125,13 +128,13 @@ RecvResult net_recv_vpacket(Session *s, H& head, std::vector& repeat) } -template -void send_fpacket(Session *s, const F& fixed) +template +void send_fpacket(Session *s, const Packet_Fixed& fixed) { - static_assert(id == F::PACKET_ID, "F::PACKET_ID"); - static_assert(size == sizeof(typename F::NetType), "F::NetType"); + static_assert(id == Packet_Fixed::PACKET_ID, "Packet_Fixed::PACKET_ID"); + static_assert(size == sizeof(NetPacket_Fixed), "sizeof(NetPacket_Fixed)"); - typename F::NetType net_fixed; + NetPacket_Fixed net_fixed; if (!native_to_network(&net_fixed, fixed)) { s->set_eof(); @@ -142,17 +145,17 @@ void send_fpacket(Session *s, const F& fixed) s->set_eof(); } -template -void send_vpacket(Session *s, H& head, const std::vector& repeat) +template +void send_vpacket(Session *s, Packet_Head& head, const std::vector>& repeat) { - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "sizeof(NetPacket_Head)"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "sizeof(NetPacket_Repeat)"); - typename H::NetType net_head; + NetPacket_Head net_head; // since these are already allocated, can't overflow address space - size_t total_size = sizeof(typename H::NetType) + repeat.size() * sizeof(typename R::NetType); + size_t total_size = sizeof(NetPacket_Head) + repeat.size() * sizeof(NetPacket_Repeat); // truncates head.magic_packet_length = total_size; if (head.magic_packet_length != total_size) @@ -161,7 +164,7 @@ void send_vpacket(Session *s, H& head, const std::vector& repeat) return; } // TODO potentially avoid the allocation - std::vector net_repeat(repeat.size()); + std::vector> net_repeat(repeat.size()); if (!native_to_network(&net_head, head)) { s->set_eof(); @@ -180,16 +183,16 @@ void send_vpacket(Session *s, H& head, const std::vector& repeat) s->set_eof(); } -template +template __attribute__((warn_unused_result)) -RecvResult recv_fpacket(Session *s, F& fixed) +RecvResult recv_fpacket(Session *s, Packet_Fixed& fixed) { - static_assert(id == F::PACKET_ID, "F::PACKET_ID"); - static_assert(size == sizeof(typename F::NetType), "F::NetType"); + static_assert(id == Packet_Fixed::PACKET_ID, "Packet_Fixed::PACKET_ID"); + static_assert(size == sizeof(NetPacket_Fixed), "NetPacket_Fixed"); - typename F::NetType net_fixed; + NetPacket_Fixed net_fixed; RecvResult rv = net_recv_fpacket(s, net_fixed); - assert (fixed.magic_packet_id == F::PACKET_ID); + assert (fixed.magic_packet_id == Packet_Fixed::PACKET_ID); if (rv == RecvResult::Complete) { if (!network_to_native(&fixed, net_fixed)) @@ -198,19 +201,19 @@ RecvResult recv_fpacket(Session *s, F& fixed) return rv; } -template +template __attribute__((warn_unused_result)) -RecvResult recv_vpacket(Session *s, H& head, std::vector& repeat) +RecvResult recv_vpacket(Session *s, Packet_Head& head, std::vector>& repeat) { - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); - - typename H::NetType net_head; - std::vector net_repeat; - RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); - assert (head.magic_packet_id == H::PACKET_ID); + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "NetPacket_Head"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "NetPacket_Repeat"); + + NetPacket_Head net_head; + std::vector> net_repeat; + RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); + assert (head.magic_packet_id == Packet_Head::PACKET_ID); if (rv == RecvResult::Complete) { if (!network_to_native(&head, net_head)) @@ -227,22 +230,18 @@ RecvResult recv_vpacket(Session *s, H& head, std::vector& repeat) // convenience for trailing strings -struct VarStringNetType +template +void send_vpacket(Session *s, Packet_Head& head, const XString& repeat) { - char c; -}; + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "NetPacket_Head"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "NetPacket_Repeat"); + static_assert(repeatsize == 1, "repeatsize"); -template -void send_vpacket(Session *s, H& head, const XString& repeat) -{ - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - // static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == 1, "R::NetType"); - - typename H::NetType net_head; + NetPacket_Head net_head; // since it's already allocated, it can't overflow address space - size_t total_length = sizeof(typename H::NetType) + (repeat.size() + 1) * sizeof(VarStringNetType); + size_t total_length = sizeof(NetPacket_Head) + (repeat.size() + 1) * sizeof(NetPacket_Repeat); head.magic_packet_length = total_length; if (head.magic_packet_length != total_length) { @@ -250,7 +249,7 @@ void send_vpacket(Session *s, H& head, const XString& repeat) return; } // TODO potentially avoid the allocation - std::vector net_repeat(repeat.size() + 1); + std::vector> net_repeat(repeat.size() + 1); if (!native_to_network(&net_head, head)) { s->set_eof(); @@ -258,27 +257,28 @@ void send_vpacket(Session *s, H& head, const XString& repeat) } for (size_t i = 0; i < repeat.size(); ++i) { - net_repeat[i].c = repeat[i]; + net_repeat[i].c = Byte{static_cast(repeat[i])}; } - net_repeat[repeat.size()].c = '\0'; + net_repeat[repeat.size()].c = Byte{static_cast('\0')}; SendResult rv = net_send_vpacket(s, net_head, net_repeat); if (rv != SendResult::Success) s->set_eof(); } -template +template __attribute__((warn_unused_result)) -RecvResult recv_vpacket(Session *s, H& head, AString& repeat) +RecvResult recv_vpacket(Session *s, Packet_Head& head, AString& repeat) { - static_assert(id == H::PACKET_ID, "H::PACKET_ID"); - static_assert(headsize == sizeof(typename H::NetType), "H::NetType"); - //static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == 1, "R::NetType"); - - typename H::NetType net_head; - std::vector net_repeat; - RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); - assert (head.magic_packet_id == H::PACKET_ID); + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "NetPacket_Head"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "NetPacket_Repeat"); + static_assert(repeatsize == 1, "repeatsize"); + + NetPacket_Head net_head; + std::vector> net_repeat; + RecvResult rv = net_recv_vpacket(s, net_head, net_repeat); + assert (head.magic_packet_id == Packet_Head::PACKET_ID); if (rv == RecvResult::Complete) { if (!network_to_native(&head, net_head)) @@ -295,59 +295,30 @@ RecvResult recv_vpacket(Session *s, H& head, AString& repeat) // if there is nothing in the head but the id and length, use the below -// TODO make this go away with template specialization - -template -struct NetCommonPacketHead -{ - Little16 magic_packet_id; - Little16 magic_packet_length; -}; - -template -struct CommonPacketHead -{ - using NetType = NetCommonPacketHead; - static const uint16_t PACKET_ID = PKT_ID; - - uint16_t magic_packet_id = PACKET_ID; - uint16_t magic_packet_length; -}; - -template -bool native_to_network(NetCommonPacketHead *net, CommonPacketHead nat) -{ - return native_to_network(&net->magic_packet_id, nat.magic_packet_id) - && native_to_network(&net->magic_packet_length, nat.magic_packet_length); -} - -template -bool network_to_native(CommonPacketHead *nat, NetCommonPacketHead net) -{ - return network_to_native(&nat->magic_packet_id, net.magic_packet_id) - && network_to_native(&nat->magic_packet_length, net.magic_packet_length); -} - -template -void send_packet_repeatonly(Session *s, const std::vector& v) +template +void send_packet_repeatonly(Session *s, const std::vector>& v) { + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "repeat headsize"); static_assert(headsize == 4, "repeat headsize"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "sizeof(NetPacket_Repeat)"); - CommonPacketHead head; + Packet_Head head; send_vpacket(s, head, v); } -template +template __attribute__((warn_unused_result)) -RecvResult recv_packet_repeatonly(Session *s, std::vector& v) +RecvResult recv_packet_repeatonly(Session *s, std::vector>& v) { + static_assert(id == Packet_Head::PACKET_ID, "Packet_Head::PACKET_ID"); + static_assert(headsize == sizeof(NetPacket_Head), "repeat headsize"); static_assert(headsize == 4, "repeat headsize"); - static_assert(id == R::PACKET_ID, "R::PACKET_ID"); - static_assert(repeatsize == sizeof(typename R::NetType), "R::NetType"); + static_assert(id == Packet_Repeat::PACKET_ID, "Packet_Repeat::PACKET_ID"); + static_assert(repeatsize == sizeof(NetPacket_Repeat), "sizeof(NetPacket_Repeat)"); - CommonPacketHead head; + Packet_Head head; return recv_vpacket(s, head, v); } diff --git a/src/proto2/any-user.hpp b/src/proto2/any-user.hpp index 037171c..ea2e20d 100644 --- a/src/proto2/any-user.hpp +++ b/src/proto2/any-user.hpp @@ -27,66 +27,72 @@ // This is a public protocol, and changes require client cooperation -struct RPacket_0x7530_Fixed +template<> +struct Packet_Fixed<0x7530> { - using NetType = NetRPacket_0x7530_Fixed; static const uint16_t PACKET_ID = 0x7530; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; }; -struct SPacket_0x7531_Fixed +template<> +struct Packet_Fixed<0x7531> { - using NetType = NetSPacket_0x7531_Fixed; static const uint16_t PACKET_ID = 0x7531; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; Version version = {}; }; -struct RPacket_0x7532_Fixed +template<> +struct Packet_Fixed<0x7532> { - using NetType = NetRPacket_0x7532_Fixed; static const uint16_t PACKET_ID = 0x7532; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; }; -struct NetRPacket_0x7530_Fixed +template<> +struct NetPacket_Fixed<0x7530> { Little16 magic_packet_id; }; -static_assert(offsetof(NetRPacket_0x7530_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7530_Fixed, magic_packet_id) == 0"); -static_assert(sizeof(NetRPacket_0x7530_Fixed) == 2, "sizeof(NetRPacket_0x7530_Fixed) == 2"); -struct NetSPacket_0x7531_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7530>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7530>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x7530>) == 2, "sizeof(NetPacket_Fixed<0x7530>) == 2"); +template<> +struct NetPacket_Fixed<0x7531> { Little16 magic_packet_id; NetVersion version; }; -static_assert(offsetof(NetSPacket_0x7531_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7531_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7531_Fixed, version) == 2, "offsetof(NetSPacket_0x7531_Fixed, version) == 2"); -static_assert(sizeof(NetSPacket_0x7531_Fixed) == 10, "sizeof(NetSPacket_0x7531_Fixed) == 10"); -struct NetRPacket_0x7532_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7531>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7531>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7531>, version) == 2, "offsetof(NetPacket_Fixed<0x7531>, version) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x7531>) == 10, "sizeof(NetPacket_Fixed<0x7531>) == 10"); +template<> +struct NetPacket_Fixed<0x7532> { Little16 magic_packet_id; }; -static_assert(offsetof(NetRPacket_0x7532_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7532_Fixed, magic_packet_id) == 0"); -static_assert(sizeof(NetRPacket_0x7532_Fixed) == 2, "sizeof(NetRPacket_0x7532_Fixed) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7532>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7532>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x7532>) == 2, "sizeof(NetPacket_Fixed<0x7532>) == 2"); inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7530_Fixed *network, RPacket_0x7530_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7530> *network, Packet_Fixed<0x7530> 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(RPacket_0x7530_Fixed *native, NetRPacket_0x7530_Fixed network) +bool network_to_native(Packet_Fixed<0x7530> *native, NetPacket_Fixed<0x7530> 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(NetSPacket_0x7531_Fixed *network, SPacket_0x7531_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7531> *network, Packet_Fixed<0x7531> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -94,7 +100,7 @@ bool native_to_network(NetSPacket_0x7531_Fixed *network, SPacket_0x7531_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7531_Fixed *native, NetSPacket_0x7531_Fixed network) +bool network_to_native(Packet_Fixed<0x7531> *native, NetPacket_Fixed<0x7531> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -102,14 +108,14 @@ bool network_to_native(SPacket_0x7531_Fixed *native, NetSPacket_0x7531_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7532_Fixed *network, RPacket_0x7532_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7532> *network, Packet_Fixed<0x7532> 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(RPacket_0x7532_Fixed *native, NetRPacket_0x7532_Fixed network) +bool network_to_native(Packet_Fixed<0x7532> *native, NetPacket_Fixed<0x7532> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); diff --git a/src/proto2/fwd.hpp b/src/proto2/fwd.hpp index a18d0ef..f8dc786 100644 --- a/src/proto2/fwd.hpp +++ b/src/proto2/fwd.hpp @@ -21,170 +21,337 @@ # include "../sanity.hpp" -struct RPacket_0x2709_Fixed; -struct NetRPacket_0x2709_Fixed; -struct RPacket_0x2712_Fixed; -struct NetRPacket_0x2712_Fixed; -struct SPacket_0x2713_Fixed; -struct NetSPacket_0x2713_Fixed; -struct RPacket_0x2714_Fixed; -struct NetRPacket_0x2714_Fixed; -struct RPacket_0x2715_Fixed; -struct NetRPacket_0x2715_Fixed; -struct RPacket_0x2716_Fixed; -struct NetRPacket_0x2716_Fixed; -struct SPacket_0x2717_Fixed; -struct NetSPacket_0x2717_Fixed; -struct RPacket_0x2720_Head; -struct NetRPacket_0x2720_Head; -struct RPacket_0x2720_Repeat; -struct NetRPacket_0x2720_Repeat; -struct SPacket_0x2721_Fixed; -struct NetSPacket_0x2721_Fixed; -struct RPacket_0x2722_Fixed; -struct NetRPacket_0x2722_Fixed; -struct SPacket_0x2723_Fixed; -struct NetSPacket_0x2723_Fixed; -struct RPacket_0x2724_Fixed; -struct NetRPacket_0x2724_Fixed; -struct RPacket_0x2725_Fixed; -struct NetRPacket_0x2725_Fixed; -struct RPacket_0x2727_Fixed; -struct NetRPacket_0x2727_Fixed; -struct RPacket_0x2728_Head; -struct NetRPacket_0x2728_Head; -struct RPacket_0x2728_Repeat; -struct NetRPacket_0x2728_Repeat; -struct SPacket_0x2729_Head; -struct NetSPacket_0x2729_Head; -struct SPacket_0x2729_Repeat; -struct NetSPacket_0x2729_Repeat; -struct RPacket_0x272a_Fixed; -struct NetRPacket_0x272a_Fixed; -struct SPacket_0x2730_Fixed; -struct NetSPacket_0x2730_Fixed; -struct SPacket_0x2731_Fixed; -struct NetSPacket_0x2731_Fixed; -struct SPacket_0x2732_Head; -struct NetSPacket_0x2732_Head; -struct SPacket_0x2732_Repeat; -struct NetSPacket_0x2732_Repeat; -struct RPacket_0x2740_Fixed; -struct NetRPacket_0x2740_Fixed; -struct SPacket_0x2741_Fixed; -struct NetSPacket_0x2741_Fixed; +# include -struct SPacket_0x2726_Head; -struct NetSPacket_0x2726_Head; -struct SPacket_0x2726_Repeat; -struct NetSPacket_0x2726_Repeat; -struct RPacket_0x7920_Fixed; -struct NetRPacket_0x7920_Fixed; -struct SPacket_0x7921_Head; -struct NetSPacket_0x7921_Head; -struct SPacket_0x7921_Repeat; -struct NetSPacket_0x7921_Repeat; -struct RPacket_0x7924_Fixed; -struct NetRPacket_0x7924_Fixed; -struct SPacket_0x7925_Fixed; -struct NetSPacket_0x7925_Fixed; -struct RPacket_0x7930_Fixed; -struct NetRPacket_0x7930_Fixed; -struct SPacket_0x7931_Fixed; -struct NetSPacket_0x7931_Fixed; -struct RPacket_0x7932_Fixed; -struct NetRPacket_0x7932_Fixed; -struct SPacket_0x7933_Fixed; -struct NetSPacket_0x7933_Fixed; -struct RPacket_0x7934_Fixed; -struct NetRPacket_0x7934_Fixed; -struct SPacket_0x7935_Fixed; -struct NetSPacket_0x7935_Fixed; -struct RPacket_0x7936_Fixed; -struct NetRPacket_0x7936_Fixed; -struct SPacket_0x7937_Fixed; -struct NetSPacket_0x7937_Fixed; -struct RPacket_0x7938_Fixed; -struct NetRPacket_0x7938_Fixed; -struct SPacket_0x7939_Head; -struct NetSPacket_0x7939_Head; -struct SPacket_0x7939_Repeat; -struct NetSPacket_0x7939_Repeat; -struct RPacket_0x793a_Fixed; -struct NetRPacket_0x793a_Fixed; -struct SPacket_0x793b_Fixed; -struct NetSPacket_0x793b_Fixed; -struct RPacket_0x793c_Fixed; -struct NetRPacket_0x793c_Fixed; -struct SPacket_0x793d_Fixed; -struct NetSPacket_0x793d_Fixed; -struct RPacket_0x793e_Fixed; -struct NetRPacket_0x793e_Fixed; -struct SPacket_0x793f_Fixed; -struct NetSPacket_0x793f_Fixed; -struct RPacket_0x7940_Fixed; -struct NetRPacket_0x7940_Fixed; -struct SPacket_0x7941_Fixed; -struct NetSPacket_0x7941_Fixed; -struct RPacket_0x7942_Head; -struct NetRPacket_0x7942_Head; -struct RPacket_0x7942_Repeat; -struct NetRPacket_0x7942_Repeat; -struct SPacket_0x7943_Fixed; -struct NetSPacket_0x7943_Fixed; -struct RPacket_0x7944_Fixed; -struct NetRPacket_0x7944_Fixed; -struct SPacket_0x7945_Fixed; -struct NetSPacket_0x7945_Fixed; -struct RPacket_0x7946_Fixed; -struct NetRPacket_0x7946_Fixed; -struct SPacket_0x7947_Fixed; -struct NetSPacket_0x7947_Fixed; -struct RPacket_0x7948_Fixed; -struct NetRPacket_0x7948_Fixed; -struct SPacket_0x7949_Fixed; -struct NetSPacket_0x7949_Fixed; -struct RPacket_0x794a_Fixed; -struct NetRPacket_0x794a_Fixed; -struct SPacket_0x794b_Fixed; -struct NetSPacket_0x794b_Fixed; -struct RPacket_0x794c_Fixed; -struct NetRPacket_0x794c_Fixed; -struct SPacket_0x794d_Fixed; -struct NetSPacket_0x794d_Fixed; -struct RPacket_0x794e_Head; -struct NetRPacket_0x794e_Head; -struct RPacket_0x794e_Repeat; -struct NetRPacket_0x794e_Repeat; -struct SPacket_0x794f_Fixed; -struct NetSPacket_0x794f_Fixed; -struct RPacket_0x7950_Fixed; -struct NetRPacket_0x7950_Fixed; -struct SPacket_0x7951_Fixed; -struct NetSPacket_0x7951_Fixed; -struct RPacket_0x7952_Fixed; -struct NetRPacket_0x7952_Fixed; -struct SPacket_0x7953_Head; -struct NetSPacket_0x7953_Head; -struct SPacket_0x7953_Repeat; -struct NetSPacket_0x7953_Repeat; -struct RPacket_0x7954_Fixed; -struct NetRPacket_0x7954_Fixed; -struct RPacket_0x7955_Fixed; -struct NetRPacket_0x7955_Fixed; +template class Packet_Fixed; +template class NetPacket_Fixed; +template class Packet_Head; +template class NetPacket_Head; +template class Packet_Repeat; +template class NetPacket_Repeat; +template<> +struct Packet_Fixed<0x2709>; +template<> +struct NetPacket_Fixed<0x2709>; +template<> +struct Packet_Fixed<0x2712>; +template<> +struct NetPacket_Fixed<0x2712>; +template<> +struct Packet_Fixed<0x2713>; +template<> +struct NetPacket_Fixed<0x2713>; +template<> +struct Packet_Fixed<0x2714>; +template<> +struct NetPacket_Fixed<0x2714>; +template<> +struct Packet_Fixed<0x2715>; +template<> +struct NetPacket_Fixed<0x2715>; +template<> +struct Packet_Fixed<0x2716>; +template<> +struct NetPacket_Fixed<0x2716>; +template<> +struct Packet_Fixed<0x2717>; +template<> +struct NetPacket_Fixed<0x2717>; +template<> +struct Packet_Head<0x2720>; +template<> +struct NetPacket_Head<0x2720>; +template<> +struct Packet_Repeat<0x2720>; +template<> +struct NetPacket_Repeat<0x2720>; +template<> +struct Packet_Fixed<0x2721>; +template<> +struct NetPacket_Fixed<0x2721>; +template<> +struct Packet_Fixed<0x2722>; +template<> +struct NetPacket_Fixed<0x2722>; +template<> +struct Packet_Fixed<0x2723>; +template<> +struct NetPacket_Fixed<0x2723>; +template<> +struct Packet_Fixed<0x2724>; +template<> +struct NetPacket_Fixed<0x2724>; +template<> +struct Packet_Fixed<0x2725>; +template<> +struct NetPacket_Fixed<0x2725>; +template<> +struct Packet_Fixed<0x2727>; +template<> +struct NetPacket_Fixed<0x2727>; +template<> +struct Packet_Head<0x2728>; +template<> +struct NetPacket_Head<0x2728>; +template<> +struct Packet_Repeat<0x2728>; +template<> +struct NetPacket_Repeat<0x2728>; +template<> +struct Packet_Head<0x2729>; +template<> +struct NetPacket_Head<0x2729>; +template<> +struct Packet_Repeat<0x2729>; +template<> +struct NetPacket_Repeat<0x2729>; +template<> +struct Packet_Fixed<0x272a>; +template<> +struct NetPacket_Fixed<0x272a>; +template<> +struct Packet_Fixed<0x2730>; +template<> +struct NetPacket_Fixed<0x2730>; +template<> +struct Packet_Fixed<0x2731>; +template<> +struct NetPacket_Fixed<0x2731>; +template<> +struct Packet_Head<0x2732>; +template<> +struct NetPacket_Head<0x2732>; +template<> +struct Packet_Repeat<0x2732>; +template<> +struct NetPacket_Repeat<0x2732>; +template<> +struct Packet_Fixed<0x2740>; +template<> +struct NetPacket_Fixed<0x2740>; +template<> +struct Packet_Fixed<0x2741>; +template<> +struct NetPacket_Fixed<0x2741>; +template<> +struct Packet_Head<0x2726>; +template<> +struct NetPacket_Head<0x2726>; +template<> +struct Packet_Repeat<0x2726>; +template<> +struct NetPacket_Repeat<0x2726>; +template<> +struct Packet_Fixed<0x7920>; +template<> +struct NetPacket_Fixed<0x7920>; +template<> +struct Packet_Head<0x7921>; +template<> +struct NetPacket_Head<0x7921>; +template<> +struct Packet_Repeat<0x7921>; +template<> +struct NetPacket_Repeat<0x7921>; +template<> +struct Packet_Fixed<0x7924>; +template<> +struct NetPacket_Fixed<0x7924>; +template<> +struct Packet_Fixed<0x7925>; +template<> +struct NetPacket_Fixed<0x7925>; +template<> +struct Packet_Fixed<0x7930>; +template<> +struct NetPacket_Fixed<0x7930>; +template<> +struct Packet_Fixed<0x7931>; +template<> +struct NetPacket_Fixed<0x7931>; +template<> +struct Packet_Fixed<0x7932>; +template<> +struct NetPacket_Fixed<0x7932>; +template<> +struct Packet_Fixed<0x7933>; +template<> +struct NetPacket_Fixed<0x7933>; +template<> +struct Packet_Fixed<0x7934>; +template<> +struct NetPacket_Fixed<0x7934>; +template<> +struct Packet_Fixed<0x7935>; +template<> +struct NetPacket_Fixed<0x7935>; +template<> +struct Packet_Fixed<0x7936>; +template<> +struct NetPacket_Fixed<0x7936>; +template<> +struct Packet_Fixed<0x7937>; +template<> +struct NetPacket_Fixed<0x7937>; +template<> +struct Packet_Fixed<0x7938>; +template<> +struct NetPacket_Fixed<0x7938>; +template<> +struct Packet_Head<0x7939>; +template<> +struct NetPacket_Head<0x7939>; +template<> +struct Packet_Repeat<0x7939>; +template<> +struct NetPacket_Repeat<0x7939>; +template<> +struct Packet_Fixed<0x793a>; +template<> +struct NetPacket_Fixed<0x793a>; +template<> +struct Packet_Fixed<0x793b>; +template<> +struct NetPacket_Fixed<0x793b>; +template<> +struct Packet_Fixed<0x793c>; +template<> +struct NetPacket_Fixed<0x793c>; +template<> +struct Packet_Fixed<0x793d>; +template<> +struct NetPacket_Fixed<0x793d>; +template<> +struct Packet_Fixed<0x793e>; +template<> +struct NetPacket_Fixed<0x793e>; +template<> +struct Packet_Fixed<0x793f>; +template<> +struct NetPacket_Fixed<0x793f>; +template<> +struct Packet_Fixed<0x7940>; +template<> +struct NetPacket_Fixed<0x7940>; +template<> +struct Packet_Fixed<0x7941>; +template<> +struct NetPacket_Fixed<0x7941>; +template<> +struct Packet_Head<0x7942>; +template<> +struct NetPacket_Head<0x7942>; +template<> +struct Packet_Repeat<0x7942>; +template<> +struct NetPacket_Repeat<0x7942>; +template<> +struct Packet_Fixed<0x7943>; +template<> +struct NetPacket_Fixed<0x7943>; +template<> +struct Packet_Fixed<0x7944>; +template<> +struct NetPacket_Fixed<0x7944>; +template<> +struct Packet_Fixed<0x7945>; +template<> +struct NetPacket_Fixed<0x7945>; +template<> +struct Packet_Fixed<0x7946>; +template<> +struct NetPacket_Fixed<0x7946>; +template<> +struct Packet_Fixed<0x7947>; +template<> +struct NetPacket_Fixed<0x7947>; +template<> +struct Packet_Fixed<0x7948>; +template<> +struct NetPacket_Fixed<0x7948>; +template<> +struct Packet_Fixed<0x7949>; +template<> +struct NetPacket_Fixed<0x7949>; +template<> +struct Packet_Fixed<0x794a>; +template<> +struct NetPacket_Fixed<0x794a>; +template<> +struct Packet_Fixed<0x794b>; +template<> +struct NetPacket_Fixed<0x794b>; +template<> +struct Packet_Fixed<0x794c>; +template<> +struct NetPacket_Fixed<0x794c>; +template<> +struct Packet_Fixed<0x794d>; +template<> +struct NetPacket_Fixed<0x794d>; +template<> +struct Packet_Head<0x794e>; +template<> +struct NetPacket_Head<0x794e>; +template<> +struct Packet_Repeat<0x794e>; +template<> +struct NetPacket_Repeat<0x794e>; +template<> +struct Packet_Fixed<0x794f>; +template<> +struct NetPacket_Fixed<0x794f>; +template<> +struct Packet_Fixed<0x7950>; +template<> +struct NetPacket_Fixed<0x7950>; +template<> +struct Packet_Fixed<0x7951>; +template<> +struct NetPacket_Fixed<0x7951>; +template<> +struct Packet_Fixed<0x7952>; +template<> +struct NetPacket_Fixed<0x7952>; +template<> +struct Packet_Head<0x7953>; +template<> +struct NetPacket_Head<0x7953>; +template<> +struct Packet_Repeat<0x7953>; +template<> +struct NetPacket_Repeat<0x7953>; +template<> +struct Packet_Fixed<0x7954>; +template<> +struct NetPacket_Fixed<0x7954>; +template<> +struct Packet_Fixed<0x7955>; +template<> +struct NetPacket_Fixed<0x7955>; -struct SPacket_0x0212_Fixed; -struct NetSPacket_0x0212_Fixed; -struct RPacket_0x7530_Fixed; -struct NetRPacket_0x7530_Fixed; -struct SPacket_0x7531_Fixed; -struct NetSPacket_0x7531_Fixed; -struct RPacket_0x7532_Fixed; -struct NetRPacket_0x7532_Fixed; + +template<> +struct Packet_Fixed<0x0212>; +template<> +struct NetPacket_Fixed<0x0212>; + +template<> +struct Packet_Fixed<0x7530>; +template<> +struct NetPacket_Fixed<0x7530>; +template<> +struct Packet_Fixed<0x7531>; +template<> +struct NetPacket_Fixed<0x7531>; +template<> +struct Packet_Fixed<0x7532>; +template<> +struct NetPacket_Fixed<0x7532>; #endif // TMWA_PROTO2_FWD_HPP diff --git a/src/proto2/login-admin.hpp b/src/proto2/login-admin.hpp index 005ecfc..fed3ad6 100644 --- a/src/proto2/login-admin.hpp +++ b/src/proto2/login-admin.hpp @@ -27,42 +27,47 @@ // This is an internal protocol, and can be changed without notice -struct SPacket_0x2726_Head +template<> +struct Packet_Head<0x2726> { - using NetType = NetSPacket_0x2726_Head; static const uint16_t PACKET_ID = 0x2726; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; uint16_t unused = {}; + // TODO remove this uint32_t magic_packet_length = {}; }; -struct SPacket_0x2726_Repeat +template<> +struct Packet_Repeat<0x2726> { - using NetType = NetSPacket_0x2726_Repeat; static const uint16_t PACKET_ID = 0x2726; uint8_t c = {}; }; -struct RPacket_0x7920_Fixed +template<> +struct Packet_Fixed<0x7920> { - using NetType = NetRPacket_0x7920_Fixed; static const uint16_t PACKET_ID = 0x7920; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId start_account_id = {}; AccountId end_account_id = {}; }; -struct SPacket_0x7921_Head +template<> +struct Packet_Head<0x7921> { - using NetType = NetSPacket_0x7921_Head; static const uint16_t PACKET_ID = 0x7921; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; + // TODO remove this uint16_t magic_packet_length = {}; }; -struct SPacket_0x7921_Repeat +template<> +struct Packet_Repeat<0x7921> { - using NetType = NetSPacket_0x7921_Repeat; static const uint16_t PACKET_ID = 0x7921; AccountId account_id = {}; @@ -72,115 +77,128 @@ struct SPacket_0x7921_Repeat uint32_t login_count = {}; uint32_t status = {}; }; -struct RPacket_0x7924_Fixed +template<> +struct Packet_Fixed<0x7924> { - using NetType = NetRPacket_0x7924_Fixed; static const uint16_t PACKET_ID = 0x7924; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; ItemNameId source_item_id = {}; ItemNameId dest_item_id = {}; }; -struct SPacket_0x7925_Fixed +template<> +struct Packet_Fixed<0x7925> { - using NetType = NetSPacket_0x7925_Fixed; static const uint16_t PACKET_ID = 0x7925; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; }; -struct RPacket_0x7930_Fixed +template<> +struct Packet_Fixed<0x7930> { - using NetType = NetRPacket_0x7930_Fixed; static const uint16_t PACKET_ID = 0x7930; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; AccountPass password = {}; SEX sex = {}; AccountEmail email = {}; }; -struct SPacket_0x7931_Fixed +template<> +struct Packet_Fixed<0x7931> { - using NetType = NetSPacket_0x7931_Fixed; static const uint16_t PACKET_ID = 0x7931; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7932_Fixed +template<> +struct Packet_Fixed<0x7932> { - using NetType = NetRPacket_0x7932_Fixed; static const uint16_t PACKET_ID = 0x7932; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; }; -struct SPacket_0x7933_Fixed +template<> +struct Packet_Fixed<0x7933> { - using NetType = NetSPacket_0x7933_Fixed; static const uint16_t PACKET_ID = 0x7933; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7934_Fixed +template<> +struct Packet_Fixed<0x7934> { - using NetType = NetRPacket_0x7934_Fixed; static const uint16_t PACKET_ID = 0x7934; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; AccountPass password = {}; }; -struct SPacket_0x7935_Fixed +template<> +struct Packet_Fixed<0x7935> { - using NetType = NetSPacket_0x7935_Fixed; static const uint16_t PACKET_ID = 0x7935; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7936_Fixed +template<> +struct Packet_Fixed<0x7936> { - using NetType = NetRPacket_0x7936_Fixed; static const uint16_t PACKET_ID = 0x7936; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; uint32_t status = {}; timestamp_seconds_buffer error_message = {}; }; -struct SPacket_0x7937_Fixed +template<> +struct Packet_Fixed<0x7937> { - using NetType = NetSPacket_0x7937_Fixed; static const uint16_t PACKET_ID = 0x7937; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; uint32_t status = {}; }; -struct RPacket_0x7938_Fixed +template<> +struct Packet_Fixed<0x7938> { - using NetType = NetRPacket_0x7938_Fixed; static const uint16_t PACKET_ID = 0x7938; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; }; -struct SPacket_0x7939_Head +template<> +struct Packet_Head<0x7939> { - using NetType = NetSPacket_0x7939_Head; static const uint16_t PACKET_ID = 0x7939; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; + // TODO remove this uint16_t magic_packet_length = {}; }; -struct SPacket_0x7939_Repeat +template<> +struct Packet_Repeat<0x7939> { - using NetType = NetSPacket_0x7939_Repeat; static const uint16_t PACKET_ID = 0x7939; IP4Address ip = {}; @@ -190,250 +208,278 @@ struct SPacket_0x7939_Repeat uint16_t maintenance = {}; uint16_t is_new = {}; }; -struct RPacket_0x793a_Fixed +template<> +struct Packet_Fixed<0x793a> { - using NetType = NetRPacket_0x793a_Fixed; static const uint16_t PACKET_ID = 0x793a; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; AccountPass password = {}; }; -struct SPacket_0x793b_Fixed +template<> +struct Packet_Fixed<0x793b> { - using NetType = NetSPacket_0x793b_Fixed; static const uint16_t PACKET_ID = 0x793b; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x793c_Fixed +template<> +struct Packet_Fixed<0x793c> { - using NetType = NetRPacket_0x793c_Fixed; static const uint16_t PACKET_ID = 0x793c; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; SEX sex = {}; }; -struct SPacket_0x793d_Fixed +template<> +struct Packet_Fixed<0x793d> { - using NetType = NetSPacket_0x793d_Fixed; static const uint16_t PACKET_ID = 0x793d; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x793e_Fixed +template<> +struct Packet_Fixed<0x793e> { - using NetType = NetRPacket_0x793e_Fixed; static const uint16_t PACKET_ID = 0x793e; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; GmLevel gm_level = {}; }; -struct SPacket_0x793f_Fixed +template<> +struct Packet_Fixed<0x793f> { - using NetType = NetSPacket_0x793f_Fixed; static const uint16_t PACKET_ID = 0x793f; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7940_Fixed +template<> +struct Packet_Fixed<0x7940> { - using NetType = NetRPacket_0x7940_Fixed; static const uint16_t PACKET_ID = 0x7940; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; AccountEmail email = {}; }; -struct SPacket_0x7941_Fixed +template<> +struct Packet_Fixed<0x7941> { - using NetType = NetSPacket_0x7941_Fixed; static const uint16_t PACKET_ID = 0x7941; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7942_Head +template<> +struct Packet_Head<0x7942> { - using NetType = NetRPacket_0x7942_Head; static const uint16_t PACKET_ID = 0x7942; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; + // TODO remove this uint16_t magic_packet_length = {}; }; -struct RPacket_0x7942_Repeat +template<> +struct Packet_Repeat<0x7942> { - using NetType = NetRPacket_0x7942_Repeat; static const uint16_t PACKET_ID = 0x7942; uint8_t c = {}; }; -struct SPacket_0x7943_Fixed +template<> +struct Packet_Fixed<0x7943> { - using NetType = NetSPacket_0x7943_Fixed; static const uint16_t PACKET_ID = 0x7943; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7944_Fixed +template<> +struct Packet_Fixed<0x7944> { - using NetType = NetRPacket_0x7944_Fixed; static const uint16_t PACKET_ID = 0x7944; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; }; -struct SPacket_0x7945_Fixed +template<> +struct Packet_Fixed<0x7945> { - using NetType = NetSPacket_0x7945_Fixed; static const uint16_t PACKET_ID = 0x7945; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7946_Fixed +template<> +struct Packet_Fixed<0x7946> { - using NetType = NetRPacket_0x7946_Fixed; static const uint16_t PACKET_ID = 0x7946; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; }; -struct SPacket_0x7947_Fixed +template<> +struct Packet_Fixed<0x7947> { - using NetType = NetSPacket_0x7947_Fixed; static const uint16_t PACKET_ID = 0x7947; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; }; -struct RPacket_0x7948_Fixed +template<> +struct Packet_Fixed<0x7948> { - using NetType = NetRPacket_0x7948_Fixed; static const uint16_t PACKET_ID = 0x7948; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; TimeT valid_until = {}; }; -struct SPacket_0x7949_Fixed +template<> +struct Packet_Fixed<0x7949> { - using NetType = NetSPacket_0x7949_Fixed; static const uint16_t PACKET_ID = 0x7949; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; TimeT valid_until = {}; }; -struct RPacket_0x794a_Fixed +template<> +struct Packet_Fixed<0x794a> { - using NetType = NetRPacket_0x794a_Fixed; static const uint16_t PACKET_ID = 0x794a; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; TimeT ban_until = {}; }; -struct SPacket_0x794b_Fixed +template<> +struct Packet_Fixed<0x794b> { - using NetType = NetSPacket_0x794b_Fixed; static const uint16_t PACKET_ID = 0x794b; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; TimeT ban_until = {}; }; -struct RPacket_0x794c_Fixed +template<> +struct Packet_Fixed<0x794c> { - using NetType = NetRPacket_0x794c_Fixed; static const uint16_t PACKET_ID = 0x794c; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; HumanTimeDiff ban_add = {}; }; -struct SPacket_0x794d_Fixed +template<> +struct Packet_Fixed<0x794d> { - using NetType = NetSPacket_0x794d_Fixed; static const uint16_t PACKET_ID = 0x794d; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; TimeT ban_until = {}; }; -struct RPacket_0x794e_Head +template<> +struct Packet_Head<0x794e> { - using NetType = NetRPacket_0x794e_Head; static const uint16_t PACKET_ID = 0x794e; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; uint16_t unused = {}; + // TODO remove this uint32_t magic_packet_length = {}; }; -struct RPacket_0x794e_Repeat +template<> +struct Packet_Repeat<0x794e> { - using NetType = NetRPacket_0x794e_Repeat; static const uint16_t PACKET_ID = 0x794e; uint8_t c = {}; }; -struct SPacket_0x794f_Fixed +template<> +struct Packet_Fixed<0x794f> { - using NetType = NetSPacket_0x794f_Fixed; static const uint16_t PACKET_ID = 0x794f; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; uint16_t error = {}; }; -struct RPacket_0x7950_Fixed +template<> +struct Packet_Fixed<0x7950> { - using NetType = NetRPacket_0x7950_Fixed; static const uint16_t PACKET_ID = 0x7950; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; HumanTimeDiff valid_add = {}; }; -struct SPacket_0x7951_Fixed +template<> +struct Packet_Fixed<0x7951> { - using NetType = NetSPacket_0x7951_Fixed; static const uint16_t PACKET_ID = 0x7951; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountName account_name = {}; TimeT valid_until = {}; }; -struct RPacket_0x7952_Fixed +template<> +struct Packet_Fixed<0x7952> { - using NetType = NetRPacket_0x7952_Fixed; static const uint16_t PACKET_ID = 0x7952; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountName account_name = {}; }; -struct SPacket_0x7953_Head +template<> +struct Packet_Head<0x7953> { - using NetType = NetSPacket_0x7953_Head; static const uint16_t PACKET_ID = 0x7953; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; GmLevel gm_level = {}; @@ -447,66 +493,74 @@ struct SPacket_0x7953_Head AccountEmail email = {}; TimeT connect_until = {}; TimeT ban_until = {}; + // TODO remove this uint16_t magic_packet_length = {}; }; -struct SPacket_0x7953_Repeat +template<> +struct Packet_Repeat<0x7953> { - using NetType = NetSPacket_0x7953_Repeat; static const uint16_t PACKET_ID = 0x7953; uint8_t c = {}; }; -struct RPacket_0x7954_Fixed +template<> +struct Packet_Fixed<0x7954> { - using NetType = NetRPacket_0x7954_Fixed; static const uint16_t PACKET_ID = 0x7954; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; }; -struct RPacket_0x7955_Fixed +template<> +struct Packet_Fixed<0x7955> { - using NetType = NetRPacket_0x7955_Fixed; static const uint16_t PACKET_ID = 0x7955; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; }; -struct NetSPacket_0x2726_Head +template<> +struct NetPacket_Head<0x2726> { Little16 magic_packet_id; Little16 unused; SkewedLength magic_packet_length; }; -static_assert(offsetof(NetSPacket_0x2726_Head, magic_packet_id) == 0, "offsetof(NetSPacket_0x2726_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2726_Head, unused) == 2, "offsetof(NetSPacket_0x2726_Head, unused) == 2"); -static_assert(offsetof(NetSPacket_0x2726_Head, magic_packet_length) == 4, "offsetof(NetSPacket_0x2726_Head, magic_packet_length) == 4"); -static_assert(sizeof(NetSPacket_0x2726_Head) == 8, "sizeof(NetSPacket_0x2726_Head) == 8"); -struct NetSPacket_0x2726_Repeat +static_assert(offsetof(NetPacket_Head<0x2726>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2726>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2726>, unused) == 2, "offsetof(NetPacket_Head<0x2726>, unused) == 2"); +static_assert(offsetof(NetPacket_Head<0x2726>, magic_packet_length) == 4, "offsetof(NetPacket_Head<0x2726>, magic_packet_length) == 4"); +static_assert(sizeof(NetPacket_Head<0x2726>) == 8, "sizeof(NetPacket_Head<0x2726>) == 8"); +template<> +struct NetPacket_Repeat<0x2726> { Byte c; }; -static_assert(offsetof(NetSPacket_0x2726_Repeat, c) == 0, "offsetof(NetSPacket_0x2726_Repeat, c) == 0"); -static_assert(sizeof(NetSPacket_0x2726_Repeat) == 1, "sizeof(NetSPacket_0x2726_Repeat) == 1"); -struct NetRPacket_0x7920_Fixed +static_assert(offsetof(NetPacket_Repeat<0x2726>, c) == 0, "offsetof(NetPacket_Repeat<0x2726>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x2726>) == 1, "sizeof(NetPacket_Repeat<0x2726>) == 1"); +template<> +struct NetPacket_Fixed<0x7920> { Little16 magic_packet_id; Little32 start_account_id; Little32 end_account_id; }; -static_assert(offsetof(NetRPacket_0x7920_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7920_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7920_Fixed, start_account_id) == 2, "offsetof(NetRPacket_0x7920_Fixed, start_account_id) == 2"); -static_assert(offsetof(NetRPacket_0x7920_Fixed, end_account_id) == 6, "offsetof(NetRPacket_0x7920_Fixed, end_account_id) == 6"); -static_assert(sizeof(NetRPacket_0x7920_Fixed) == 10, "sizeof(NetRPacket_0x7920_Fixed) == 10"); -struct NetSPacket_0x7921_Head +static_assert(offsetof(NetPacket_Fixed<0x7920>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7920>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7920>, start_account_id) == 2, "offsetof(NetPacket_Fixed<0x7920>, start_account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7920>, end_account_id) == 6, "offsetof(NetPacket_Fixed<0x7920>, end_account_id) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7920>) == 10, "sizeof(NetPacket_Fixed<0x7920>) == 10"); +template<> +struct NetPacket_Head<0x7921> { Little16 magic_packet_id; Little16 magic_packet_length; }; -static_assert(offsetof(NetSPacket_0x7921_Head, magic_packet_id) == 0, "offsetof(NetSPacket_0x7921_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7921_Head, magic_packet_length) == 2, "offsetof(NetSPacket_0x7921_Head, magic_packet_length) == 2"); -static_assert(sizeof(NetSPacket_0x7921_Head) == 4, "sizeof(NetSPacket_0x7921_Head) == 4"); -struct NetSPacket_0x7921_Repeat +static_assert(offsetof(NetPacket_Head<0x7921>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x7921>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x7921>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x7921>, magic_packet_length) == 2"); +static_assert(sizeof(NetPacket_Head<0x7921>) == 4, "sizeof(NetPacket_Head<0x7921>) == 4"); +template<> +struct NetPacket_Repeat<0x7921> { Little32 account_id; Byte gm_level; @@ -515,30 +569,33 @@ struct NetSPacket_0x7921_Repeat Little32 login_count; Little32 status; }; -static_assert(offsetof(NetSPacket_0x7921_Repeat, account_id) == 0, "offsetof(NetSPacket_0x7921_Repeat, account_id) == 0"); -static_assert(offsetof(NetSPacket_0x7921_Repeat, gm_level) == 4, "offsetof(NetSPacket_0x7921_Repeat, gm_level) == 4"); -static_assert(offsetof(NetSPacket_0x7921_Repeat, account_name) == 5, "offsetof(NetSPacket_0x7921_Repeat, account_name) == 5"); -static_assert(offsetof(NetSPacket_0x7921_Repeat, sex) == 29, "offsetof(NetSPacket_0x7921_Repeat, sex) == 29"); -static_assert(offsetof(NetSPacket_0x7921_Repeat, login_count) == 30, "offsetof(NetSPacket_0x7921_Repeat, login_count) == 30"); -static_assert(offsetof(NetSPacket_0x7921_Repeat, status) == 34, "offsetof(NetSPacket_0x7921_Repeat, status) == 34"); -static_assert(sizeof(NetSPacket_0x7921_Repeat) == 38, "sizeof(NetSPacket_0x7921_Repeat) == 38"); -struct NetRPacket_0x7924_Fixed +static_assert(offsetof(NetPacket_Repeat<0x7921>, account_id) == 0, "offsetof(NetPacket_Repeat<0x7921>, account_id) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x7921>, gm_level) == 4, "offsetof(NetPacket_Repeat<0x7921>, gm_level) == 4"); +static_assert(offsetof(NetPacket_Repeat<0x7921>, account_name) == 5, "offsetof(NetPacket_Repeat<0x7921>, account_name) == 5"); +static_assert(offsetof(NetPacket_Repeat<0x7921>, sex) == 29, "offsetof(NetPacket_Repeat<0x7921>, sex) == 29"); +static_assert(offsetof(NetPacket_Repeat<0x7921>, login_count) == 30, "offsetof(NetPacket_Repeat<0x7921>, login_count) == 30"); +static_assert(offsetof(NetPacket_Repeat<0x7921>, status) == 34, "offsetof(NetPacket_Repeat<0x7921>, status) == 34"); +static_assert(sizeof(NetPacket_Repeat<0x7921>) == 38, "sizeof(NetPacket_Repeat<0x7921>) == 38"); +template<> +struct NetPacket_Fixed<0x7924> { Little16 magic_packet_id; Little32 source_item_id; Little32 dest_item_id; }; -static_assert(offsetof(NetRPacket_0x7924_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7924_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7924_Fixed, source_item_id) == 2, "offsetof(NetRPacket_0x7924_Fixed, source_item_id) == 2"); -static_assert(offsetof(NetRPacket_0x7924_Fixed, dest_item_id) == 6, "offsetof(NetRPacket_0x7924_Fixed, dest_item_id) == 6"); -static_assert(sizeof(NetRPacket_0x7924_Fixed) == 10, "sizeof(NetRPacket_0x7924_Fixed) == 10"); -struct NetSPacket_0x7925_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7924>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7924>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7924>, source_item_id) == 2, "offsetof(NetPacket_Fixed<0x7924>, source_item_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7924>, dest_item_id) == 6, "offsetof(NetPacket_Fixed<0x7924>, dest_item_id) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7924>) == 10, "sizeof(NetPacket_Fixed<0x7924>) == 10"); +template<> +struct NetPacket_Fixed<0x7925> { Little16 magic_packet_id; }; -static_assert(offsetof(NetSPacket_0x7925_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7925_Fixed, magic_packet_id) == 0"); -static_assert(sizeof(NetSPacket_0x7925_Fixed) == 2, "sizeof(NetSPacket_0x7925_Fixed) == 2"); -struct NetRPacket_0x7930_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7925>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7925>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x7925>) == 2, "sizeof(NetPacket_Fixed<0x7925>) == 2"); +template<> +struct NetPacket_Fixed<0x7930> { Little16 magic_packet_id; NetString account_name; @@ -546,99 +603,109 @@ struct NetRPacket_0x7930_Fixed char sex; NetString email; }; -static_assert(offsetof(NetRPacket_0x7930_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7930_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7930_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7930_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x7930_Fixed, password) == 26, "offsetof(NetRPacket_0x7930_Fixed, password) == 26"); -static_assert(offsetof(NetRPacket_0x7930_Fixed, sex) == 50, "offsetof(NetRPacket_0x7930_Fixed, sex) == 50"); -static_assert(offsetof(NetRPacket_0x7930_Fixed, email) == 51, "offsetof(NetRPacket_0x7930_Fixed, email) == 51"); -static_assert(sizeof(NetRPacket_0x7930_Fixed) == 91, "sizeof(NetRPacket_0x7930_Fixed) == 91"); -struct NetSPacket_0x7931_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7930>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7930>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7930>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7930>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7930>, password) == 26, "offsetof(NetPacket_Fixed<0x7930>, password) == 26"); +static_assert(offsetof(NetPacket_Fixed<0x7930>, sex) == 50, "offsetof(NetPacket_Fixed<0x7930>, sex) == 50"); +static_assert(offsetof(NetPacket_Fixed<0x7930>, email) == 51, "offsetof(NetPacket_Fixed<0x7930>, email) == 51"); +static_assert(sizeof(NetPacket_Fixed<0x7930>) == 91, "sizeof(NetPacket_Fixed<0x7930>) == 91"); +template<> +struct NetPacket_Fixed<0x7931> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x7931_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7931_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7931_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7931_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7931_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7931_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x7931_Fixed) == 30, "sizeof(NetSPacket_0x7931_Fixed) == 30"); -struct NetRPacket_0x7932_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7931>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7931>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7931>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7931>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7931>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7931>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7931>) == 30, "sizeof(NetPacket_Fixed<0x7931>) == 30"); +template<> +struct NetPacket_Fixed<0x7932> { Little16 magic_packet_id; NetString account_name; }; -static_assert(offsetof(NetRPacket_0x7932_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7932_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7932_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7932_Fixed, account_name) == 2"); -static_assert(sizeof(NetRPacket_0x7932_Fixed) == 26, "sizeof(NetRPacket_0x7932_Fixed) == 26"); -struct NetSPacket_0x7933_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7932>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7932>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7932>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7932>, account_name) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x7932>) == 26, "sizeof(NetPacket_Fixed<0x7932>) == 26"); +template<> +struct NetPacket_Fixed<0x7933> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x7933_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7933_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7933_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7933_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7933_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7933_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x7933_Fixed) == 30, "sizeof(NetSPacket_0x7933_Fixed) == 30"); -struct NetRPacket_0x7934_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7933>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7933>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7933>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7933>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7933>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7933>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7933>) == 30, "sizeof(NetPacket_Fixed<0x7933>) == 30"); +template<> +struct NetPacket_Fixed<0x7934> { Little16 magic_packet_id; NetString account_name; NetString password; }; -static_assert(offsetof(NetRPacket_0x7934_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7934_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7934_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7934_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x7934_Fixed, password) == 26, "offsetof(NetRPacket_0x7934_Fixed, password) == 26"); -static_assert(sizeof(NetRPacket_0x7934_Fixed) == 50, "sizeof(NetRPacket_0x7934_Fixed) == 50"); -struct NetSPacket_0x7935_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7934>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7934>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7934>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7934>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7934>, password) == 26, "offsetof(NetPacket_Fixed<0x7934>, password) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x7934>) == 50, "sizeof(NetPacket_Fixed<0x7934>) == 50"); +template<> +struct NetPacket_Fixed<0x7935> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x7935_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7935_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7935_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7935_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7935_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7935_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x7935_Fixed) == 30, "sizeof(NetSPacket_0x7935_Fixed) == 30"); -struct NetRPacket_0x7936_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7935>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7935>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7935>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7935>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7935>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7935>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7935>) == 30, "sizeof(NetPacket_Fixed<0x7935>) == 30"); +template<> +struct NetPacket_Fixed<0x7936> { Little16 magic_packet_id; NetString account_name; Little32 status; NetString error_message; }; -static_assert(offsetof(NetRPacket_0x7936_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7936_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7936_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7936_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x7936_Fixed, status) == 26, "offsetof(NetRPacket_0x7936_Fixed, status) == 26"); -static_assert(offsetof(NetRPacket_0x7936_Fixed, error_message) == 30, "offsetof(NetRPacket_0x7936_Fixed, error_message) == 30"); -static_assert(sizeof(NetRPacket_0x7936_Fixed) == 50, "sizeof(NetRPacket_0x7936_Fixed) == 50"); -struct NetSPacket_0x7937_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7936>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7936>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7936>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7936>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7936>, status) == 26, "offsetof(NetPacket_Fixed<0x7936>, status) == 26"); +static_assert(offsetof(NetPacket_Fixed<0x7936>, error_message) == 30, "offsetof(NetPacket_Fixed<0x7936>, error_message) == 30"); +static_assert(sizeof(NetPacket_Fixed<0x7936>) == 50, "sizeof(NetPacket_Fixed<0x7936>) == 50"); +template<> +struct NetPacket_Fixed<0x7937> { Little16 magic_packet_id; Little32 account_id; NetString account_name; Little32 status; }; -static_assert(offsetof(NetSPacket_0x7937_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7937_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7937_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7937_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7937_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7937_Fixed, account_name) == 6"); -static_assert(offsetof(NetSPacket_0x7937_Fixed, status) == 30, "offsetof(NetSPacket_0x7937_Fixed, status) == 30"); -static_assert(sizeof(NetSPacket_0x7937_Fixed) == 34, "sizeof(NetSPacket_0x7937_Fixed) == 34"); -struct NetRPacket_0x7938_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7937>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7937>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7937>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7937>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7937>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7937>, account_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x7937>, status) == 30, "offsetof(NetPacket_Fixed<0x7937>, status) == 30"); +static_assert(sizeof(NetPacket_Fixed<0x7937>) == 34, "sizeof(NetPacket_Fixed<0x7937>) == 34"); +template<> +struct NetPacket_Fixed<0x7938> { Little16 magic_packet_id; }; -static_assert(offsetof(NetRPacket_0x7938_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7938_Fixed, magic_packet_id) == 0"); -static_assert(sizeof(NetRPacket_0x7938_Fixed) == 2, "sizeof(NetRPacket_0x7938_Fixed) == 2"); -struct NetSPacket_0x7939_Head +static_assert(offsetof(NetPacket_Fixed<0x7938>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7938>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x7938>) == 2, "sizeof(NetPacket_Fixed<0x7938>) == 2"); +template<> +struct NetPacket_Head<0x7939> { Little16 magic_packet_id; Little16 magic_packet_length; }; -static_assert(offsetof(NetSPacket_0x7939_Head, magic_packet_id) == 0, "offsetof(NetSPacket_0x7939_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7939_Head, magic_packet_length) == 2, "offsetof(NetSPacket_0x7939_Head, magic_packet_length) == 2"); -static_assert(sizeof(NetSPacket_0x7939_Head) == 4, "sizeof(NetSPacket_0x7939_Head) == 4"); -struct NetSPacket_0x7939_Repeat +static_assert(offsetof(NetPacket_Head<0x7939>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x7939>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x7939>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x7939>, magic_packet_length) == 2"); +static_assert(sizeof(NetPacket_Head<0x7939>) == 4, "sizeof(NetPacket_Head<0x7939>) == 4"); +template<> +struct NetPacket_Repeat<0x7939> { IP4Address ip; Little16 port; @@ -647,276 +714,304 @@ struct NetSPacket_0x7939_Repeat Little16 maintenance; Little16 is_new; }; -static_assert(offsetof(NetSPacket_0x7939_Repeat, ip) == 0, "offsetof(NetSPacket_0x7939_Repeat, ip) == 0"); -static_assert(offsetof(NetSPacket_0x7939_Repeat, port) == 4, "offsetof(NetSPacket_0x7939_Repeat, port) == 4"); -static_assert(offsetof(NetSPacket_0x7939_Repeat, name) == 6, "offsetof(NetSPacket_0x7939_Repeat, name) == 6"); -static_assert(offsetof(NetSPacket_0x7939_Repeat, users) == 26, "offsetof(NetSPacket_0x7939_Repeat, users) == 26"); -static_assert(offsetof(NetSPacket_0x7939_Repeat, maintenance) == 28, "offsetof(NetSPacket_0x7939_Repeat, maintenance) == 28"); -static_assert(offsetof(NetSPacket_0x7939_Repeat, is_new) == 30, "offsetof(NetSPacket_0x7939_Repeat, is_new) == 30"); -static_assert(sizeof(NetSPacket_0x7939_Repeat) == 32, "sizeof(NetSPacket_0x7939_Repeat) == 32"); -struct NetRPacket_0x793a_Fixed +static_assert(offsetof(NetPacket_Repeat<0x7939>, ip) == 0, "offsetof(NetPacket_Repeat<0x7939>, ip) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x7939>, port) == 4, "offsetof(NetPacket_Repeat<0x7939>, port) == 4"); +static_assert(offsetof(NetPacket_Repeat<0x7939>, name) == 6, "offsetof(NetPacket_Repeat<0x7939>, name) == 6"); +static_assert(offsetof(NetPacket_Repeat<0x7939>, users) == 26, "offsetof(NetPacket_Repeat<0x7939>, users) == 26"); +static_assert(offsetof(NetPacket_Repeat<0x7939>, maintenance) == 28, "offsetof(NetPacket_Repeat<0x7939>, maintenance) == 28"); +static_assert(offsetof(NetPacket_Repeat<0x7939>, is_new) == 30, "offsetof(NetPacket_Repeat<0x7939>, is_new) == 30"); +static_assert(sizeof(NetPacket_Repeat<0x7939>) == 32, "sizeof(NetPacket_Repeat<0x7939>) == 32"); +template<> +struct NetPacket_Fixed<0x793a> { Little16 magic_packet_id; NetString account_name; NetString password; }; -static_assert(offsetof(NetRPacket_0x793a_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x793a_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x793a_Fixed, account_name) == 2, "offsetof(NetRPacket_0x793a_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x793a_Fixed, password) == 26, "offsetof(NetRPacket_0x793a_Fixed, password) == 26"); -static_assert(sizeof(NetRPacket_0x793a_Fixed) == 50, "sizeof(NetRPacket_0x793a_Fixed) == 50"); -struct NetSPacket_0x793b_Fixed +static_assert(offsetof(NetPacket_Fixed<0x793a>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x793a>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x793a>, account_name) == 2, "offsetof(NetPacket_Fixed<0x793a>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x793a>, password) == 26, "offsetof(NetPacket_Fixed<0x793a>, password) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x793a>) == 50, "sizeof(NetPacket_Fixed<0x793a>) == 50"); +template<> +struct NetPacket_Fixed<0x793b> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x793b_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x793b_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x793b_Fixed, account_id) == 2, "offsetof(NetSPacket_0x793b_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x793b_Fixed, account_name) == 6, "offsetof(NetSPacket_0x793b_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x793b_Fixed) == 30, "sizeof(NetSPacket_0x793b_Fixed) == 30"); -struct NetRPacket_0x793c_Fixed +static_assert(offsetof(NetPacket_Fixed<0x793b>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x793b>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x793b>, account_id) == 2, "offsetof(NetPacket_Fixed<0x793b>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x793b>, account_name) == 6, "offsetof(NetPacket_Fixed<0x793b>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x793b>) == 30, "sizeof(NetPacket_Fixed<0x793b>) == 30"); +template<> +struct NetPacket_Fixed<0x793c> { Little16 magic_packet_id; NetString account_name; char sex; }; -static_assert(offsetof(NetRPacket_0x793c_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x793c_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x793c_Fixed, account_name) == 2, "offsetof(NetRPacket_0x793c_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x793c_Fixed, sex) == 26, "offsetof(NetRPacket_0x793c_Fixed, sex) == 26"); -static_assert(sizeof(NetRPacket_0x793c_Fixed) == 27, "sizeof(NetRPacket_0x793c_Fixed) == 27"); -struct NetSPacket_0x793d_Fixed +static_assert(offsetof(NetPacket_Fixed<0x793c>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x793c>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x793c>, account_name) == 2, "offsetof(NetPacket_Fixed<0x793c>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x793c>, sex) == 26, "offsetof(NetPacket_Fixed<0x793c>, sex) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x793c>) == 27, "sizeof(NetPacket_Fixed<0x793c>) == 27"); +template<> +struct NetPacket_Fixed<0x793d> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x793d_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x793d_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x793d_Fixed, account_id) == 2, "offsetof(NetSPacket_0x793d_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x793d_Fixed, account_name) == 6, "offsetof(NetSPacket_0x793d_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x793d_Fixed) == 30, "sizeof(NetSPacket_0x793d_Fixed) == 30"); -struct NetRPacket_0x793e_Fixed +static_assert(offsetof(NetPacket_Fixed<0x793d>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x793d>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x793d>, account_id) == 2, "offsetof(NetPacket_Fixed<0x793d>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x793d>, account_name) == 6, "offsetof(NetPacket_Fixed<0x793d>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x793d>) == 30, "sizeof(NetPacket_Fixed<0x793d>) == 30"); +template<> +struct NetPacket_Fixed<0x793e> { Little16 magic_packet_id; NetString account_name; Byte gm_level; }; -static_assert(offsetof(NetRPacket_0x793e_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x793e_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x793e_Fixed, account_name) == 2, "offsetof(NetRPacket_0x793e_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x793e_Fixed, gm_level) == 26, "offsetof(NetRPacket_0x793e_Fixed, gm_level) == 26"); -static_assert(sizeof(NetRPacket_0x793e_Fixed) == 27, "sizeof(NetRPacket_0x793e_Fixed) == 27"); -struct NetSPacket_0x793f_Fixed +static_assert(offsetof(NetPacket_Fixed<0x793e>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x793e>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x793e>, account_name) == 2, "offsetof(NetPacket_Fixed<0x793e>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x793e>, gm_level) == 26, "offsetof(NetPacket_Fixed<0x793e>, gm_level) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x793e>) == 27, "sizeof(NetPacket_Fixed<0x793e>) == 27"); +template<> +struct NetPacket_Fixed<0x793f> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x793f_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x793f_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x793f_Fixed, account_id) == 2, "offsetof(NetSPacket_0x793f_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x793f_Fixed, account_name) == 6, "offsetof(NetSPacket_0x793f_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x793f_Fixed) == 30, "sizeof(NetSPacket_0x793f_Fixed) == 30"); -struct NetRPacket_0x7940_Fixed +static_assert(offsetof(NetPacket_Fixed<0x793f>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x793f>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x793f>, account_id) == 2, "offsetof(NetPacket_Fixed<0x793f>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x793f>, account_name) == 6, "offsetof(NetPacket_Fixed<0x793f>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x793f>) == 30, "sizeof(NetPacket_Fixed<0x793f>) == 30"); +template<> +struct NetPacket_Fixed<0x7940> { Little16 magic_packet_id; NetString account_name; NetString email; }; -static_assert(offsetof(NetRPacket_0x7940_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7940_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7940_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7940_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x7940_Fixed, email) == 26, "offsetof(NetRPacket_0x7940_Fixed, email) == 26"); -static_assert(sizeof(NetRPacket_0x7940_Fixed) == 66, "sizeof(NetRPacket_0x7940_Fixed) == 66"); -struct NetSPacket_0x7941_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7940>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7940>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7940>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7940>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7940>, email) == 26, "offsetof(NetPacket_Fixed<0x7940>, email) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x7940>) == 66, "sizeof(NetPacket_Fixed<0x7940>) == 66"); +template<> +struct NetPacket_Fixed<0x7941> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x7941_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7941_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7941_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7941_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7941_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7941_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x7941_Fixed) == 30, "sizeof(NetSPacket_0x7941_Fixed) == 30"); -struct NetRPacket_0x7942_Head +static_assert(offsetof(NetPacket_Fixed<0x7941>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7941>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7941>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7941>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7941>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7941>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7941>) == 30, "sizeof(NetPacket_Fixed<0x7941>) == 30"); +template<> +struct NetPacket_Head<0x7942> { Little16 magic_packet_id; NetString account_name; SkewedLength magic_packet_length; }; -static_assert(offsetof(NetRPacket_0x7942_Head, magic_packet_id) == 0, "offsetof(NetRPacket_0x7942_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7942_Head, account_name) == 2, "offsetof(NetRPacket_0x7942_Head, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x7942_Head, magic_packet_length) == 26, "offsetof(NetRPacket_0x7942_Head, magic_packet_length) == 26"); -static_assert(sizeof(NetRPacket_0x7942_Head) == 28, "sizeof(NetRPacket_0x7942_Head) == 28"); -struct NetRPacket_0x7942_Repeat +static_assert(offsetof(NetPacket_Head<0x7942>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x7942>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x7942>, account_name) == 2, "offsetof(NetPacket_Head<0x7942>, account_name) == 2"); +static_assert(offsetof(NetPacket_Head<0x7942>, magic_packet_length) == 26, "offsetof(NetPacket_Head<0x7942>, magic_packet_length) == 26"); +static_assert(sizeof(NetPacket_Head<0x7942>) == 28, "sizeof(NetPacket_Head<0x7942>) == 28"); +template<> +struct NetPacket_Repeat<0x7942> { Byte c; }; -static_assert(offsetof(NetRPacket_0x7942_Repeat, c) == 0, "offsetof(NetRPacket_0x7942_Repeat, c) == 0"); -static_assert(sizeof(NetRPacket_0x7942_Repeat) == 1, "sizeof(NetRPacket_0x7942_Repeat) == 1"); -struct NetSPacket_0x7943_Fixed +static_assert(offsetof(NetPacket_Repeat<0x7942>, c) == 0, "offsetof(NetPacket_Repeat<0x7942>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x7942>) == 1, "sizeof(NetPacket_Repeat<0x7942>) == 1"); +template<> +struct NetPacket_Fixed<0x7943> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x7943_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7943_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7943_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7943_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7943_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7943_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x7943_Fixed) == 30, "sizeof(NetSPacket_0x7943_Fixed) == 30"); -struct NetRPacket_0x7944_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7943>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7943>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7943>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7943>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7943>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7943>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7943>) == 30, "sizeof(NetPacket_Fixed<0x7943>) == 30"); +template<> +struct NetPacket_Fixed<0x7944> { Little16 magic_packet_id; NetString account_name; }; -static_assert(offsetof(NetRPacket_0x7944_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7944_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7944_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7944_Fixed, account_name) == 2"); -static_assert(sizeof(NetRPacket_0x7944_Fixed) == 26, "sizeof(NetRPacket_0x7944_Fixed) == 26"); -struct NetSPacket_0x7945_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7944>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7944>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7944>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7944>, account_name) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x7944>) == 26, "sizeof(NetPacket_Fixed<0x7944>) == 26"); +template<> +struct NetPacket_Fixed<0x7945> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x7945_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7945_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7945_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7945_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7945_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7945_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x7945_Fixed) == 30, "sizeof(NetSPacket_0x7945_Fixed) == 30"); -struct NetRPacket_0x7946_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7945>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7945>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7945>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7945>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7945>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7945>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7945>) == 30, "sizeof(NetPacket_Fixed<0x7945>) == 30"); +template<> +struct NetPacket_Fixed<0x7946> { Little16 magic_packet_id; Little32 account_id; }; -static_assert(offsetof(NetRPacket_0x7946_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7946_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7946_Fixed, account_id) == 2, "offsetof(NetRPacket_0x7946_Fixed, account_id) == 2"); -static_assert(sizeof(NetRPacket_0x7946_Fixed) == 6, "sizeof(NetRPacket_0x7946_Fixed) == 6"); -struct NetSPacket_0x7947_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7946>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7946>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7946>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7946>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x7946>) == 6, "sizeof(NetPacket_Fixed<0x7946>) == 6"); +template<> +struct NetPacket_Fixed<0x7947> { Little16 magic_packet_id; Little32 account_id; NetString account_name; }; -static_assert(offsetof(NetSPacket_0x7947_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7947_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7947_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7947_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7947_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7947_Fixed, account_name) == 6"); -static_assert(sizeof(NetSPacket_0x7947_Fixed) == 30, "sizeof(NetSPacket_0x7947_Fixed) == 30"); -struct NetRPacket_0x7948_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7947>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7947>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7947>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7947>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7947>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7947>, account_name) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x7947>) == 30, "sizeof(NetPacket_Fixed<0x7947>) == 30"); +template<> +struct NetPacket_Fixed<0x7948> { Little16 magic_packet_id; NetString account_name; Little32 valid_until; }; -static_assert(offsetof(NetRPacket_0x7948_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7948_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7948_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7948_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x7948_Fixed, valid_until) == 26, "offsetof(NetRPacket_0x7948_Fixed, valid_until) == 26"); -static_assert(sizeof(NetRPacket_0x7948_Fixed) == 30, "sizeof(NetRPacket_0x7948_Fixed) == 30"); -struct NetSPacket_0x7949_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7948>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7948>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7948>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7948>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7948>, valid_until) == 26, "offsetof(NetPacket_Fixed<0x7948>, valid_until) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x7948>) == 30, "sizeof(NetPacket_Fixed<0x7948>) == 30"); +template<> +struct NetPacket_Fixed<0x7949> { Little16 magic_packet_id; Little32 account_id; NetString account_name; Little32 valid_until; }; -static_assert(offsetof(NetSPacket_0x7949_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7949_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7949_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7949_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7949_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7949_Fixed, account_name) == 6"); -static_assert(offsetof(NetSPacket_0x7949_Fixed, valid_until) == 30, "offsetof(NetSPacket_0x7949_Fixed, valid_until) == 30"); -static_assert(sizeof(NetSPacket_0x7949_Fixed) == 34, "sizeof(NetSPacket_0x7949_Fixed) == 34"); -struct NetRPacket_0x794a_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7949>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7949>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7949>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7949>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7949>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7949>, account_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x7949>, valid_until) == 30, "offsetof(NetPacket_Fixed<0x7949>, valid_until) == 30"); +static_assert(sizeof(NetPacket_Fixed<0x7949>) == 34, "sizeof(NetPacket_Fixed<0x7949>) == 34"); +template<> +struct NetPacket_Fixed<0x794a> { Little16 magic_packet_id; NetString account_name; Little32 ban_until; }; -static_assert(offsetof(NetRPacket_0x794a_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x794a_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x794a_Fixed, account_name) == 2, "offsetof(NetRPacket_0x794a_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x794a_Fixed, ban_until) == 26, "offsetof(NetRPacket_0x794a_Fixed, ban_until) == 26"); -static_assert(sizeof(NetRPacket_0x794a_Fixed) == 30, "sizeof(NetRPacket_0x794a_Fixed) == 30"); -struct NetSPacket_0x794b_Fixed +static_assert(offsetof(NetPacket_Fixed<0x794a>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x794a>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x794a>, account_name) == 2, "offsetof(NetPacket_Fixed<0x794a>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x794a>, ban_until) == 26, "offsetof(NetPacket_Fixed<0x794a>, ban_until) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x794a>) == 30, "sizeof(NetPacket_Fixed<0x794a>) == 30"); +template<> +struct NetPacket_Fixed<0x794b> { Little16 magic_packet_id; Little32 account_id; NetString account_name; Little32 ban_until; }; -static_assert(offsetof(NetSPacket_0x794b_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x794b_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x794b_Fixed, account_id) == 2, "offsetof(NetSPacket_0x794b_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x794b_Fixed, account_name) == 6, "offsetof(NetSPacket_0x794b_Fixed, account_name) == 6"); -static_assert(offsetof(NetSPacket_0x794b_Fixed, ban_until) == 30, "offsetof(NetSPacket_0x794b_Fixed, ban_until) == 30"); -static_assert(sizeof(NetSPacket_0x794b_Fixed) == 34, "sizeof(NetSPacket_0x794b_Fixed) == 34"); -struct NetRPacket_0x794c_Fixed +static_assert(offsetof(NetPacket_Fixed<0x794b>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x794b>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x794b>, account_id) == 2, "offsetof(NetPacket_Fixed<0x794b>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x794b>, account_name) == 6, "offsetof(NetPacket_Fixed<0x794b>, account_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x794b>, ban_until) == 30, "offsetof(NetPacket_Fixed<0x794b>, ban_until) == 30"); +static_assert(sizeof(NetPacket_Fixed<0x794b>) == 34, "sizeof(NetPacket_Fixed<0x794b>) == 34"); +template<> +struct NetPacket_Fixed<0x794c> { Little16 magic_packet_id; NetString account_name; NetHumanTimeDiff ban_add; }; -static_assert(offsetof(NetRPacket_0x794c_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x794c_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x794c_Fixed, account_name) == 2, "offsetof(NetRPacket_0x794c_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x794c_Fixed, ban_add) == 26, "offsetof(NetRPacket_0x794c_Fixed, ban_add) == 26"); -static_assert(sizeof(NetRPacket_0x794c_Fixed) == 38, "sizeof(NetRPacket_0x794c_Fixed) == 38"); -struct NetSPacket_0x794d_Fixed +static_assert(offsetof(NetPacket_Fixed<0x794c>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x794c>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x794c>, account_name) == 2, "offsetof(NetPacket_Fixed<0x794c>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x794c>, ban_add) == 26, "offsetof(NetPacket_Fixed<0x794c>, ban_add) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x794c>) == 38, "sizeof(NetPacket_Fixed<0x794c>) == 38"); +template<> +struct NetPacket_Fixed<0x794d> { Little16 magic_packet_id; Little32 account_id; NetString account_name; Little32 ban_until; }; -static_assert(offsetof(NetSPacket_0x794d_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x794d_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x794d_Fixed, account_id) == 2, "offsetof(NetSPacket_0x794d_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x794d_Fixed, account_name) == 6, "offsetof(NetSPacket_0x794d_Fixed, account_name) == 6"); -static_assert(offsetof(NetSPacket_0x794d_Fixed, ban_until) == 30, "offsetof(NetSPacket_0x794d_Fixed, ban_until) == 30"); -static_assert(sizeof(NetSPacket_0x794d_Fixed) == 34, "sizeof(NetSPacket_0x794d_Fixed) == 34"); -struct NetRPacket_0x794e_Head +static_assert(offsetof(NetPacket_Fixed<0x794d>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x794d>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x794d>, account_id) == 2, "offsetof(NetPacket_Fixed<0x794d>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x794d>, account_name) == 6, "offsetof(NetPacket_Fixed<0x794d>, account_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x794d>, ban_until) == 30, "offsetof(NetPacket_Fixed<0x794d>, ban_until) == 30"); +static_assert(sizeof(NetPacket_Fixed<0x794d>) == 34, "sizeof(NetPacket_Fixed<0x794d>) == 34"); +template<> +struct NetPacket_Head<0x794e> { Little16 magic_packet_id; Little16 unused; SkewedLength magic_packet_length; }; -static_assert(offsetof(NetRPacket_0x794e_Head, magic_packet_id) == 0, "offsetof(NetRPacket_0x794e_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x794e_Head, unused) == 2, "offsetof(NetRPacket_0x794e_Head, unused) == 2"); -static_assert(offsetof(NetRPacket_0x794e_Head, magic_packet_length) == 4, "offsetof(NetRPacket_0x794e_Head, magic_packet_length) == 4"); -static_assert(sizeof(NetRPacket_0x794e_Head) == 8, "sizeof(NetRPacket_0x794e_Head) == 8"); -struct NetRPacket_0x794e_Repeat +static_assert(offsetof(NetPacket_Head<0x794e>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x794e>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x794e>, unused) == 2, "offsetof(NetPacket_Head<0x794e>, unused) == 2"); +static_assert(offsetof(NetPacket_Head<0x794e>, magic_packet_length) == 4, "offsetof(NetPacket_Head<0x794e>, magic_packet_length) == 4"); +static_assert(sizeof(NetPacket_Head<0x794e>) == 8, "sizeof(NetPacket_Head<0x794e>) == 8"); +template<> +struct NetPacket_Repeat<0x794e> { Byte c; }; -static_assert(offsetof(NetRPacket_0x794e_Repeat, c) == 0, "offsetof(NetRPacket_0x794e_Repeat, c) == 0"); -static_assert(sizeof(NetRPacket_0x794e_Repeat) == 1, "sizeof(NetRPacket_0x794e_Repeat) == 1"); -struct NetSPacket_0x794f_Fixed +static_assert(offsetof(NetPacket_Repeat<0x794e>, c) == 0, "offsetof(NetPacket_Repeat<0x794e>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x794e>) == 1, "sizeof(NetPacket_Repeat<0x794e>) == 1"); +template<> +struct NetPacket_Fixed<0x794f> { Little16 magic_packet_id; Little16 error; }; -static_assert(offsetof(NetSPacket_0x794f_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x794f_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x794f_Fixed, error) == 2, "offsetof(NetSPacket_0x794f_Fixed, error) == 2"); -static_assert(sizeof(NetSPacket_0x794f_Fixed) == 4, "sizeof(NetSPacket_0x794f_Fixed) == 4"); -struct NetRPacket_0x7950_Fixed +static_assert(offsetof(NetPacket_Fixed<0x794f>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x794f>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x794f>, error) == 2, "offsetof(NetPacket_Fixed<0x794f>, error) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x794f>) == 4, "sizeof(NetPacket_Fixed<0x794f>) == 4"); +template<> +struct NetPacket_Fixed<0x7950> { Little16 magic_packet_id; NetString account_name; NetHumanTimeDiff valid_add; }; -static_assert(offsetof(NetRPacket_0x7950_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7950_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7950_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7950_Fixed, account_name) == 2"); -static_assert(offsetof(NetRPacket_0x7950_Fixed, valid_add) == 26, "offsetof(NetRPacket_0x7950_Fixed, valid_add) == 26"); -static_assert(sizeof(NetRPacket_0x7950_Fixed) == 38, "sizeof(NetRPacket_0x7950_Fixed) == 38"); -struct NetSPacket_0x7951_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7950>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7950>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7950>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7950>, account_name) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7950>, valid_add) == 26, "offsetof(NetPacket_Fixed<0x7950>, valid_add) == 26"); +static_assert(sizeof(NetPacket_Fixed<0x7950>) == 38, "sizeof(NetPacket_Fixed<0x7950>) == 38"); +template<> +struct NetPacket_Fixed<0x7951> { Little16 magic_packet_id; Little32 account_id; NetString account_name; Little32 valid_until; }; -static_assert(offsetof(NetSPacket_0x7951_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x7951_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7951_Fixed, account_id) == 2, "offsetof(NetSPacket_0x7951_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7951_Fixed, account_name) == 6, "offsetof(NetSPacket_0x7951_Fixed, account_name) == 6"); -static_assert(offsetof(NetSPacket_0x7951_Fixed, valid_until) == 30, "offsetof(NetSPacket_0x7951_Fixed, valid_until) == 30"); -static_assert(sizeof(NetSPacket_0x7951_Fixed) == 34, "sizeof(NetSPacket_0x7951_Fixed) == 34"); -struct NetRPacket_0x7952_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7951>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7951>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7951>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7951>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7951>, account_name) == 6, "offsetof(NetPacket_Fixed<0x7951>, account_name) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x7951>, valid_until) == 30, "offsetof(NetPacket_Fixed<0x7951>, valid_until) == 30"); +static_assert(sizeof(NetPacket_Fixed<0x7951>) == 34, "sizeof(NetPacket_Fixed<0x7951>) == 34"); +template<> +struct NetPacket_Fixed<0x7952> { Little16 magic_packet_id; NetString account_name; }; -static_assert(offsetof(NetRPacket_0x7952_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7952_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7952_Fixed, account_name) == 2, "offsetof(NetRPacket_0x7952_Fixed, account_name) == 2"); -static_assert(sizeof(NetRPacket_0x7952_Fixed) == 26, "sizeof(NetRPacket_0x7952_Fixed) == 26"); -struct NetSPacket_0x7953_Head +static_assert(offsetof(NetPacket_Fixed<0x7952>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7952>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7952>, account_name) == 2, "offsetof(NetPacket_Fixed<0x7952>, account_name) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x7952>) == 26, "sizeof(NetPacket_Fixed<0x7952>) == 26"); +template<> +struct NetPacket_Head<0x7953> { Little16 magic_packet_id; Little32 account_id; @@ -933,44 +1028,47 @@ struct NetSPacket_0x7953_Head Little32 ban_until; SkewedLength magic_packet_length; }; -static_assert(offsetof(NetSPacket_0x7953_Head, magic_packet_id) == 0, "offsetof(NetSPacket_0x7953_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x7953_Head, account_id) == 2, "offsetof(NetSPacket_0x7953_Head, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x7953_Head, gm_level) == 6, "offsetof(NetSPacket_0x7953_Head, gm_level) == 6"); -static_assert(offsetof(NetSPacket_0x7953_Head, account_name) == 7, "offsetof(NetSPacket_0x7953_Head, account_name) == 7"); -static_assert(offsetof(NetSPacket_0x7953_Head, sex) == 31, "offsetof(NetSPacket_0x7953_Head, sex) == 31"); -static_assert(offsetof(NetSPacket_0x7953_Head, login_count) == 32, "offsetof(NetSPacket_0x7953_Head, login_count) == 32"); -static_assert(offsetof(NetSPacket_0x7953_Head, state) == 36, "offsetof(NetSPacket_0x7953_Head, state) == 36"); -static_assert(offsetof(NetSPacket_0x7953_Head, error_message) == 40, "offsetof(NetSPacket_0x7953_Head, error_message) == 40"); -static_assert(offsetof(NetSPacket_0x7953_Head, last_login_string) == 60, "offsetof(NetSPacket_0x7953_Head, last_login_string) == 60"); -static_assert(offsetof(NetSPacket_0x7953_Head, ip_string) == 84, "offsetof(NetSPacket_0x7953_Head, ip_string) == 84"); -static_assert(offsetof(NetSPacket_0x7953_Head, email) == 100, "offsetof(NetSPacket_0x7953_Head, email) == 100"); -static_assert(offsetof(NetSPacket_0x7953_Head, connect_until) == 140, "offsetof(NetSPacket_0x7953_Head, connect_until) == 140"); -static_assert(offsetof(NetSPacket_0x7953_Head, ban_until) == 144, "offsetof(NetSPacket_0x7953_Head, ban_until) == 144"); -static_assert(offsetof(NetSPacket_0x7953_Head, magic_packet_length) == 148, "offsetof(NetSPacket_0x7953_Head, magic_packet_length) == 148"); -static_assert(sizeof(NetSPacket_0x7953_Head) == 150, "sizeof(NetSPacket_0x7953_Head) == 150"); -struct NetSPacket_0x7953_Repeat +static_assert(offsetof(NetPacket_Head<0x7953>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x7953>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x7953>, account_id) == 2, "offsetof(NetPacket_Head<0x7953>, account_id) == 2"); +static_assert(offsetof(NetPacket_Head<0x7953>, gm_level) == 6, "offsetof(NetPacket_Head<0x7953>, gm_level) == 6"); +static_assert(offsetof(NetPacket_Head<0x7953>, account_name) == 7, "offsetof(NetPacket_Head<0x7953>, account_name) == 7"); +static_assert(offsetof(NetPacket_Head<0x7953>, sex) == 31, "offsetof(NetPacket_Head<0x7953>, sex) == 31"); +static_assert(offsetof(NetPacket_Head<0x7953>, login_count) == 32, "offsetof(NetPacket_Head<0x7953>, login_count) == 32"); +static_assert(offsetof(NetPacket_Head<0x7953>, state) == 36, "offsetof(NetPacket_Head<0x7953>, state) == 36"); +static_assert(offsetof(NetPacket_Head<0x7953>, error_message) == 40, "offsetof(NetPacket_Head<0x7953>, error_message) == 40"); +static_assert(offsetof(NetPacket_Head<0x7953>, last_login_string) == 60, "offsetof(NetPacket_Head<0x7953>, last_login_string) == 60"); +static_assert(offsetof(NetPacket_Head<0x7953>, ip_string) == 84, "offsetof(NetPacket_Head<0x7953>, ip_string) == 84"); +static_assert(offsetof(NetPacket_Head<0x7953>, email) == 100, "offsetof(NetPacket_Head<0x7953>, email) == 100"); +static_assert(offsetof(NetPacket_Head<0x7953>, connect_until) == 140, "offsetof(NetPacket_Head<0x7953>, connect_until) == 140"); +static_assert(offsetof(NetPacket_Head<0x7953>, ban_until) == 144, "offsetof(NetPacket_Head<0x7953>, ban_until) == 144"); +static_assert(offsetof(NetPacket_Head<0x7953>, magic_packet_length) == 148, "offsetof(NetPacket_Head<0x7953>, magic_packet_length) == 148"); +static_assert(sizeof(NetPacket_Head<0x7953>) == 150, "sizeof(NetPacket_Head<0x7953>) == 150"); +template<> +struct NetPacket_Repeat<0x7953> { Byte c; }; -static_assert(offsetof(NetSPacket_0x7953_Repeat, c) == 0, "offsetof(NetSPacket_0x7953_Repeat, c) == 0"); -static_assert(sizeof(NetSPacket_0x7953_Repeat) == 1, "sizeof(NetSPacket_0x7953_Repeat) == 1"); -struct NetRPacket_0x7954_Fixed +static_assert(offsetof(NetPacket_Repeat<0x7953>, c) == 0, "offsetof(NetPacket_Repeat<0x7953>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x7953>) == 1, "sizeof(NetPacket_Repeat<0x7953>) == 1"); +template<> +struct NetPacket_Fixed<0x7954> { Little16 magic_packet_id; Little32 account_id; }; -static_assert(offsetof(NetRPacket_0x7954_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7954_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x7954_Fixed, account_id) == 2, "offsetof(NetRPacket_0x7954_Fixed, account_id) == 2"); -static_assert(sizeof(NetRPacket_0x7954_Fixed) == 6, "sizeof(NetRPacket_0x7954_Fixed) == 6"); -struct NetRPacket_0x7955_Fixed +static_assert(offsetof(NetPacket_Fixed<0x7954>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7954>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x7954>, account_id) == 2, "offsetof(NetPacket_Fixed<0x7954>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x7954>) == 6, "sizeof(NetPacket_Fixed<0x7954>) == 6"); +template<> +struct NetPacket_Fixed<0x7955> { Little16 magic_packet_id; }; -static_assert(offsetof(NetRPacket_0x7955_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x7955_Fixed, magic_packet_id) == 0"); -static_assert(sizeof(NetRPacket_0x7955_Fixed) == 2, "sizeof(NetRPacket_0x7955_Fixed) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x7955>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x7955>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x7955>) == 2, "sizeof(NetPacket_Fixed<0x7955>) == 2"); inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2726_Head *network, SPacket_0x2726_Head native) +bool native_to_network(NetPacket_Head<0x2726> *network, Packet_Head<0x2726> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -979,7 +1077,7 @@ bool native_to_network(NetSPacket_0x2726_Head *network, SPacket_0x2726_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2726_Head *native, NetSPacket_0x2726_Head network) +bool network_to_native(Packet_Head<0x2726> *native, NetPacket_Head<0x2726> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -988,21 +1086,21 @@ bool network_to_native(SPacket_0x2726_Head *native, NetSPacket_0x2726_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2726_Repeat *network, SPacket_0x2726_Repeat native) +bool native_to_network(NetPacket_Repeat<0x2726> *network, Packet_Repeat<0x2726> native) { bool rv = true; rv &= native_to_network(&network->c, native.c); return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2726_Repeat *native, NetSPacket_0x2726_Repeat network) +bool network_to_native(Packet_Repeat<0x2726> *native, NetPacket_Repeat<0x2726> network) { bool rv = true; rv &= network_to_native(&native->c, network.c); return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7920_Fixed *network, RPacket_0x7920_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7920> *network, Packet_Fixed<0x7920> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1011,7 +1109,7 @@ bool native_to_network(NetRPacket_0x7920_Fixed *network, RPacket_0x7920_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7920_Fixed *native, NetRPacket_0x7920_Fixed network) +bool network_to_native(Packet_Fixed<0x7920> *native, NetPacket_Fixed<0x7920> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1020,7 +1118,7 @@ bool network_to_native(RPacket_0x7920_Fixed *native, NetRPacket_0x7920_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7921_Head *network, SPacket_0x7921_Head native) +bool native_to_network(NetPacket_Head<0x7921> *network, Packet_Head<0x7921> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1028,7 +1126,7 @@ bool native_to_network(NetSPacket_0x7921_Head *network, SPacket_0x7921_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7921_Head *native, NetSPacket_0x7921_Head network) +bool network_to_native(Packet_Head<0x7921> *native, NetPacket_Head<0x7921> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1036,7 +1134,7 @@ bool network_to_native(SPacket_0x7921_Head *native, NetSPacket_0x7921_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7921_Repeat *network, SPacket_0x7921_Repeat native) +bool native_to_network(NetPacket_Repeat<0x7921> *network, Packet_Repeat<0x7921> native) { bool rv = true; rv &= native_to_network(&network->account_id, native.account_id); @@ -1048,7 +1146,7 @@ bool native_to_network(NetSPacket_0x7921_Repeat *network, SPacket_0x7921_Repeat return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7921_Repeat *native, NetSPacket_0x7921_Repeat network) +bool network_to_native(Packet_Repeat<0x7921> *native, NetPacket_Repeat<0x7921> network) { bool rv = true; rv &= network_to_native(&native->account_id, network.account_id); @@ -1060,7 +1158,7 @@ bool network_to_native(SPacket_0x7921_Repeat *native, NetSPacket_0x7921_Repeat n return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7924_Fixed *network, RPacket_0x7924_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7924> *network, Packet_Fixed<0x7924> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1069,7 +1167,7 @@ bool native_to_network(NetRPacket_0x7924_Fixed *network, RPacket_0x7924_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7924_Fixed *native, NetRPacket_0x7924_Fixed network) +bool network_to_native(Packet_Fixed<0x7924> *native, NetPacket_Fixed<0x7924> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1078,21 +1176,21 @@ bool network_to_native(RPacket_0x7924_Fixed *native, NetRPacket_0x7924_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7925_Fixed *network, SPacket_0x7925_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7925> *network, Packet_Fixed<0x7925> 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(SPacket_0x7925_Fixed *native, NetSPacket_0x7925_Fixed network) +bool network_to_native(Packet_Fixed<0x7925> *native, NetPacket_Fixed<0x7925> 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(NetRPacket_0x7930_Fixed *network, RPacket_0x7930_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7930> *network, Packet_Fixed<0x7930> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1103,7 +1201,7 @@ bool native_to_network(NetRPacket_0x7930_Fixed *network, RPacket_0x7930_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7930_Fixed *native, NetRPacket_0x7930_Fixed network) +bool network_to_native(Packet_Fixed<0x7930> *native, NetPacket_Fixed<0x7930> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1114,7 +1212,7 @@ bool network_to_native(RPacket_0x7930_Fixed *native, NetRPacket_0x7930_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7931_Fixed *network, SPacket_0x7931_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7931> *network, Packet_Fixed<0x7931> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1123,7 +1221,7 @@ bool native_to_network(NetSPacket_0x7931_Fixed *network, SPacket_0x7931_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7931_Fixed *native, NetSPacket_0x7931_Fixed network) +bool network_to_native(Packet_Fixed<0x7931> *native, NetPacket_Fixed<0x7931> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1132,7 +1230,7 @@ bool network_to_native(SPacket_0x7931_Fixed *native, NetSPacket_0x7931_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7932_Fixed *network, RPacket_0x7932_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7932> *network, Packet_Fixed<0x7932> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1140,7 +1238,7 @@ bool native_to_network(NetRPacket_0x7932_Fixed *network, RPacket_0x7932_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7932_Fixed *native, NetRPacket_0x7932_Fixed network) +bool network_to_native(Packet_Fixed<0x7932> *native, NetPacket_Fixed<0x7932> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1148,7 +1246,7 @@ bool network_to_native(RPacket_0x7932_Fixed *native, NetRPacket_0x7932_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7933_Fixed *network, SPacket_0x7933_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7933> *network, Packet_Fixed<0x7933> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1157,7 +1255,7 @@ bool native_to_network(NetSPacket_0x7933_Fixed *network, SPacket_0x7933_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7933_Fixed *native, NetSPacket_0x7933_Fixed network) +bool network_to_native(Packet_Fixed<0x7933> *native, NetPacket_Fixed<0x7933> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1166,7 +1264,7 @@ bool network_to_native(SPacket_0x7933_Fixed *native, NetSPacket_0x7933_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7934_Fixed *network, RPacket_0x7934_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7934> *network, Packet_Fixed<0x7934> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1175,7 +1273,7 @@ bool native_to_network(NetRPacket_0x7934_Fixed *network, RPacket_0x7934_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7934_Fixed *native, NetRPacket_0x7934_Fixed network) +bool network_to_native(Packet_Fixed<0x7934> *native, NetPacket_Fixed<0x7934> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1184,7 +1282,7 @@ bool network_to_native(RPacket_0x7934_Fixed *native, NetRPacket_0x7934_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7935_Fixed *network, SPacket_0x7935_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7935> *network, Packet_Fixed<0x7935> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1193,7 +1291,7 @@ bool native_to_network(NetSPacket_0x7935_Fixed *network, SPacket_0x7935_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7935_Fixed *native, NetSPacket_0x7935_Fixed network) +bool network_to_native(Packet_Fixed<0x7935> *native, NetPacket_Fixed<0x7935> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1202,7 +1300,7 @@ bool network_to_native(SPacket_0x7935_Fixed *native, NetSPacket_0x7935_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7936_Fixed *network, RPacket_0x7936_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7936> *network, Packet_Fixed<0x7936> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1212,7 +1310,7 @@ bool native_to_network(NetRPacket_0x7936_Fixed *network, RPacket_0x7936_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7936_Fixed *native, NetRPacket_0x7936_Fixed network) +bool network_to_native(Packet_Fixed<0x7936> *native, NetPacket_Fixed<0x7936> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1222,7 +1320,7 @@ bool network_to_native(RPacket_0x7936_Fixed *native, NetRPacket_0x7936_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7937_Fixed *network, SPacket_0x7937_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7937> *network, Packet_Fixed<0x7937> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1232,7 +1330,7 @@ bool native_to_network(NetSPacket_0x7937_Fixed *network, SPacket_0x7937_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7937_Fixed *native, NetSPacket_0x7937_Fixed network) +bool network_to_native(Packet_Fixed<0x7937> *native, NetPacket_Fixed<0x7937> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1242,21 +1340,21 @@ bool network_to_native(SPacket_0x7937_Fixed *native, NetSPacket_0x7937_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7938_Fixed *network, RPacket_0x7938_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7938> *network, Packet_Fixed<0x7938> 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(RPacket_0x7938_Fixed *native, NetRPacket_0x7938_Fixed network) +bool network_to_native(Packet_Fixed<0x7938> *native, NetPacket_Fixed<0x7938> 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(NetSPacket_0x7939_Head *network, SPacket_0x7939_Head native) +bool native_to_network(NetPacket_Head<0x7939> *network, Packet_Head<0x7939> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1264,7 +1362,7 @@ bool native_to_network(NetSPacket_0x7939_Head *network, SPacket_0x7939_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7939_Head *native, NetSPacket_0x7939_Head network) +bool network_to_native(Packet_Head<0x7939> *native, NetPacket_Head<0x7939> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1272,7 +1370,7 @@ bool network_to_native(SPacket_0x7939_Head *native, NetSPacket_0x7939_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7939_Repeat *network, SPacket_0x7939_Repeat native) +bool native_to_network(NetPacket_Repeat<0x7939> *network, Packet_Repeat<0x7939> native) { bool rv = true; rv &= native_to_network(&network->ip, native.ip); @@ -1284,7 +1382,7 @@ bool native_to_network(NetSPacket_0x7939_Repeat *network, SPacket_0x7939_Repeat return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7939_Repeat *native, NetSPacket_0x7939_Repeat network) +bool network_to_native(Packet_Repeat<0x7939> *native, NetPacket_Repeat<0x7939> network) { bool rv = true; rv &= network_to_native(&native->ip, network.ip); @@ -1296,7 +1394,7 @@ bool network_to_native(SPacket_0x7939_Repeat *native, NetSPacket_0x7939_Repeat n return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x793a_Fixed *network, RPacket_0x793a_Fixed native) +bool native_to_network(NetPacket_Fixed<0x793a> *network, Packet_Fixed<0x793a> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1305,7 +1403,7 @@ bool native_to_network(NetRPacket_0x793a_Fixed *network, RPacket_0x793a_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x793a_Fixed *native, NetRPacket_0x793a_Fixed network) +bool network_to_native(Packet_Fixed<0x793a> *native, NetPacket_Fixed<0x793a> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1314,7 +1412,7 @@ bool network_to_native(RPacket_0x793a_Fixed *native, NetRPacket_0x793a_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x793b_Fixed *network, SPacket_0x793b_Fixed native) +bool native_to_network(NetPacket_Fixed<0x793b> *network, Packet_Fixed<0x793b> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1323,7 +1421,7 @@ bool native_to_network(NetSPacket_0x793b_Fixed *network, SPacket_0x793b_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x793b_Fixed *native, NetSPacket_0x793b_Fixed network) +bool network_to_native(Packet_Fixed<0x793b> *native, NetPacket_Fixed<0x793b> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1332,7 +1430,7 @@ bool network_to_native(SPacket_0x793b_Fixed *native, NetSPacket_0x793b_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x793c_Fixed *network, RPacket_0x793c_Fixed native) +bool native_to_network(NetPacket_Fixed<0x793c> *network, Packet_Fixed<0x793c> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1341,7 +1439,7 @@ bool native_to_network(NetRPacket_0x793c_Fixed *network, RPacket_0x793c_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x793c_Fixed *native, NetRPacket_0x793c_Fixed network) +bool network_to_native(Packet_Fixed<0x793c> *native, NetPacket_Fixed<0x793c> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1350,7 +1448,7 @@ bool network_to_native(RPacket_0x793c_Fixed *native, NetRPacket_0x793c_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x793d_Fixed *network, SPacket_0x793d_Fixed native) +bool native_to_network(NetPacket_Fixed<0x793d> *network, Packet_Fixed<0x793d> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1359,7 +1457,7 @@ bool native_to_network(NetSPacket_0x793d_Fixed *network, SPacket_0x793d_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x793d_Fixed *native, NetSPacket_0x793d_Fixed network) +bool network_to_native(Packet_Fixed<0x793d> *native, NetPacket_Fixed<0x793d> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1368,7 +1466,7 @@ bool network_to_native(SPacket_0x793d_Fixed *native, NetSPacket_0x793d_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x793e_Fixed *network, RPacket_0x793e_Fixed native) +bool native_to_network(NetPacket_Fixed<0x793e> *network, Packet_Fixed<0x793e> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1377,7 +1475,7 @@ bool native_to_network(NetRPacket_0x793e_Fixed *network, RPacket_0x793e_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x793e_Fixed *native, NetRPacket_0x793e_Fixed network) +bool network_to_native(Packet_Fixed<0x793e> *native, NetPacket_Fixed<0x793e> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1386,7 +1484,7 @@ bool network_to_native(RPacket_0x793e_Fixed *native, NetRPacket_0x793e_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x793f_Fixed *network, SPacket_0x793f_Fixed native) +bool native_to_network(NetPacket_Fixed<0x793f> *network, Packet_Fixed<0x793f> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1395,7 +1493,7 @@ bool native_to_network(NetSPacket_0x793f_Fixed *network, SPacket_0x793f_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x793f_Fixed *native, NetSPacket_0x793f_Fixed network) +bool network_to_native(Packet_Fixed<0x793f> *native, NetPacket_Fixed<0x793f> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1404,7 +1502,7 @@ bool network_to_native(SPacket_0x793f_Fixed *native, NetSPacket_0x793f_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7940_Fixed *network, RPacket_0x7940_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7940> *network, Packet_Fixed<0x7940> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1413,7 +1511,7 @@ bool native_to_network(NetRPacket_0x7940_Fixed *network, RPacket_0x7940_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7940_Fixed *native, NetRPacket_0x7940_Fixed network) +bool network_to_native(Packet_Fixed<0x7940> *native, NetPacket_Fixed<0x7940> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1422,7 +1520,7 @@ bool network_to_native(RPacket_0x7940_Fixed *native, NetRPacket_0x7940_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7941_Fixed *network, SPacket_0x7941_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7941> *network, Packet_Fixed<0x7941> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1431,7 +1529,7 @@ bool native_to_network(NetSPacket_0x7941_Fixed *network, SPacket_0x7941_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7941_Fixed *native, NetSPacket_0x7941_Fixed network) +bool network_to_native(Packet_Fixed<0x7941> *native, NetPacket_Fixed<0x7941> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1440,7 +1538,7 @@ bool network_to_native(SPacket_0x7941_Fixed *native, NetSPacket_0x7941_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7942_Head *network, RPacket_0x7942_Head native) +bool native_to_network(NetPacket_Head<0x7942> *network, Packet_Head<0x7942> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1449,7 +1547,7 @@ bool native_to_network(NetRPacket_0x7942_Head *network, RPacket_0x7942_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7942_Head *native, NetRPacket_0x7942_Head network) +bool network_to_native(Packet_Head<0x7942> *native, NetPacket_Head<0x7942> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1458,21 +1556,21 @@ bool network_to_native(RPacket_0x7942_Head *native, NetRPacket_0x7942_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7942_Repeat *network, RPacket_0x7942_Repeat native) +bool native_to_network(NetPacket_Repeat<0x7942> *network, Packet_Repeat<0x7942> native) { bool rv = true; rv &= native_to_network(&network->c, native.c); return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7942_Repeat *native, NetRPacket_0x7942_Repeat network) +bool network_to_native(Packet_Repeat<0x7942> *native, NetPacket_Repeat<0x7942> network) { bool rv = true; rv &= network_to_native(&native->c, network.c); return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7943_Fixed *network, SPacket_0x7943_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7943> *network, Packet_Fixed<0x7943> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1481,7 +1579,7 @@ bool native_to_network(NetSPacket_0x7943_Fixed *network, SPacket_0x7943_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7943_Fixed *native, NetSPacket_0x7943_Fixed network) +bool network_to_native(Packet_Fixed<0x7943> *native, NetPacket_Fixed<0x7943> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1490,7 +1588,7 @@ bool network_to_native(SPacket_0x7943_Fixed *native, NetSPacket_0x7943_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7944_Fixed *network, RPacket_0x7944_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7944> *network, Packet_Fixed<0x7944> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1498,7 +1596,7 @@ bool native_to_network(NetRPacket_0x7944_Fixed *network, RPacket_0x7944_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7944_Fixed *native, NetRPacket_0x7944_Fixed network) +bool network_to_native(Packet_Fixed<0x7944> *native, NetPacket_Fixed<0x7944> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1506,7 +1604,7 @@ bool network_to_native(RPacket_0x7944_Fixed *native, NetRPacket_0x7944_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7945_Fixed *network, SPacket_0x7945_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7945> *network, Packet_Fixed<0x7945> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1515,7 +1613,7 @@ bool native_to_network(NetSPacket_0x7945_Fixed *network, SPacket_0x7945_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7945_Fixed *native, NetSPacket_0x7945_Fixed network) +bool network_to_native(Packet_Fixed<0x7945> *native, NetPacket_Fixed<0x7945> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1524,7 +1622,7 @@ bool network_to_native(SPacket_0x7945_Fixed *native, NetSPacket_0x7945_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7946_Fixed *network, RPacket_0x7946_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7946> *network, Packet_Fixed<0x7946> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1532,7 +1630,7 @@ bool native_to_network(NetRPacket_0x7946_Fixed *network, RPacket_0x7946_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7946_Fixed *native, NetRPacket_0x7946_Fixed network) +bool network_to_native(Packet_Fixed<0x7946> *native, NetPacket_Fixed<0x7946> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1540,7 +1638,7 @@ bool network_to_native(RPacket_0x7946_Fixed *native, NetRPacket_0x7946_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7947_Fixed *network, SPacket_0x7947_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7947> *network, Packet_Fixed<0x7947> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1549,7 +1647,7 @@ bool native_to_network(NetSPacket_0x7947_Fixed *network, SPacket_0x7947_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7947_Fixed *native, NetSPacket_0x7947_Fixed network) +bool network_to_native(Packet_Fixed<0x7947> *native, NetPacket_Fixed<0x7947> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1558,7 +1656,7 @@ bool network_to_native(SPacket_0x7947_Fixed *native, NetSPacket_0x7947_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7948_Fixed *network, RPacket_0x7948_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7948> *network, Packet_Fixed<0x7948> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1567,7 +1665,7 @@ bool native_to_network(NetRPacket_0x7948_Fixed *network, RPacket_0x7948_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7948_Fixed *native, NetRPacket_0x7948_Fixed network) +bool network_to_native(Packet_Fixed<0x7948> *native, NetPacket_Fixed<0x7948> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1576,7 +1674,7 @@ bool network_to_native(RPacket_0x7948_Fixed *native, NetRPacket_0x7948_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7949_Fixed *network, SPacket_0x7949_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7949> *network, Packet_Fixed<0x7949> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1586,7 +1684,7 @@ bool native_to_network(NetSPacket_0x7949_Fixed *network, SPacket_0x7949_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7949_Fixed *native, NetSPacket_0x7949_Fixed network) +bool network_to_native(Packet_Fixed<0x7949> *native, NetPacket_Fixed<0x7949> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1596,7 +1694,7 @@ bool network_to_native(SPacket_0x7949_Fixed *native, NetSPacket_0x7949_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x794a_Fixed *network, RPacket_0x794a_Fixed native) +bool native_to_network(NetPacket_Fixed<0x794a> *network, Packet_Fixed<0x794a> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1605,7 +1703,7 @@ bool native_to_network(NetRPacket_0x794a_Fixed *network, RPacket_0x794a_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x794a_Fixed *native, NetRPacket_0x794a_Fixed network) +bool network_to_native(Packet_Fixed<0x794a> *native, NetPacket_Fixed<0x794a> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1614,7 +1712,7 @@ bool network_to_native(RPacket_0x794a_Fixed *native, NetRPacket_0x794a_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x794b_Fixed *network, SPacket_0x794b_Fixed native) +bool native_to_network(NetPacket_Fixed<0x794b> *network, Packet_Fixed<0x794b> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1624,7 +1722,7 @@ bool native_to_network(NetSPacket_0x794b_Fixed *network, SPacket_0x794b_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x794b_Fixed *native, NetSPacket_0x794b_Fixed network) +bool network_to_native(Packet_Fixed<0x794b> *native, NetPacket_Fixed<0x794b> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1634,7 +1732,7 @@ bool network_to_native(SPacket_0x794b_Fixed *native, NetSPacket_0x794b_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x794c_Fixed *network, RPacket_0x794c_Fixed native) +bool native_to_network(NetPacket_Fixed<0x794c> *network, Packet_Fixed<0x794c> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1643,7 +1741,7 @@ bool native_to_network(NetRPacket_0x794c_Fixed *network, RPacket_0x794c_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x794c_Fixed *native, NetRPacket_0x794c_Fixed network) +bool network_to_native(Packet_Fixed<0x794c> *native, NetPacket_Fixed<0x794c> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1652,7 +1750,7 @@ bool network_to_native(RPacket_0x794c_Fixed *native, NetRPacket_0x794c_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x794d_Fixed *network, SPacket_0x794d_Fixed native) +bool native_to_network(NetPacket_Fixed<0x794d> *network, Packet_Fixed<0x794d> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1662,7 +1760,7 @@ bool native_to_network(NetSPacket_0x794d_Fixed *network, SPacket_0x794d_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x794d_Fixed *native, NetSPacket_0x794d_Fixed network) +bool network_to_native(Packet_Fixed<0x794d> *native, NetPacket_Fixed<0x794d> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1672,7 +1770,7 @@ bool network_to_native(SPacket_0x794d_Fixed *native, NetSPacket_0x794d_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x794e_Head *network, RPacket_0x794e_Head native) +bool native_to_network(NetPacket_Head<0x794e> *network, Packet_Head<0x794e> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1681,7 +1779,7 @@ bool native_to_network(NetRPacket_0x794e_Head *network, RPacket_0x794e_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x794e_Head *native, NetRPacket_0x794e_Head network) +bool network_to_native(Packet_Head<0x794e> *native, NetPacket_Head<0x794e> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1690,21 +1788,21 @@ bool network_to_native(RPacket_0x794e_Head *native, NetRPacket_0x794e_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x794e_Repeat *network, RPacket_0x794e_Repeat native) +bool native_to_network(NetPacket_Repeat<0x794e> *network, Packet_Repeat<0x794e> native) { bool rv = true; rv &= native_to_network(&network->c, native.c); return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x794e_Repeat *native, NetRPacket_0x794e_Repeat network) +bool network_to_native(Packet_Repeat<0x794e> *native, NetPacket_Repeat<0x794e> network) { bool rv = true; rv &= network_to_native(&native->c, network.c); return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x794f_Fixed *network, SPacket_0x794f_Fixed native) +bool native_to_network(NetPacket_Fixed<0x794f> *network, Packet_Fixed<0x794f> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1712,7 +1810,7 @@ bool native_to_network(NetSPacket_0x794f_Fixed *network, SPacket_0x794f_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x794f_Fixed *native, NetSPacket_0x794f_Fixed network) +bool network_to_native(Packet_Fixed<0x794f> *native, NetPacket_Fixed<0x794f> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1720,7 +1818,7 @@ bool network_to_native(SPacket_0x794f_Fixed *native, NetSPacket_0x794f_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7950_Fixed *network, RPacket_0x7950_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7950> *network, Packet_Fixed<0x7950> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1729,7 +1827,7 @@ bool native_to_network(NetRPacket_0x7950_Fixed *network, RPacket_0x7950_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7950_Fixed *native, NetRPacket_0x7950_Fixed network) +bool network_to_native(Packet_Fixed<0x7950> *native, NetPacket_Fixed<0x7950> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1738,7 +1836,7 @@ bool network_to_native(RPacket_0x7950_Fixed *native, NetRPacket_0x7950_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7951_Fixed *network, SPacket_0x7951_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7951> *network, Packet_Fixed<0x7951> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1748,7 +1846,7 @@ bool native_to_network(NetSPacket_0x7951_Fixed *network, SPacket_0x7951_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7951_Fixed *native, NetSPacket_0x7951_Fixed network) +bool network_to_native(Packet_Fixed<0x7951> *native, NetPacket_Fixed<0x7951> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1758,7 +1856,7 @@ bool network_to_native(SPacket_0x7951_Fixed *native, NetSPacket_0x7951_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7952_Fixed *network, RPacket_0x7952_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7952> *network, Packet_Fixed<0x7952> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1766,7 +1864,7 @@ bool native_to_network(NetRPacket_0x7952_Fixed *network, RPacket_0x7952_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7952_Fixed *native, NetRPacket_0x7952_Fixed network) +bool network_to_native(Packet_Fixed<0x7952> *native, NetPacket_Fixed<0x7952> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1774,7 +1872,7 @@ bool network_to_native(RPacket_0x7952_Fixed *native, NetRPacket_0x7952_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7953_Head *network, SPacket_0x7953_Head native) +bool native_to_network(NetPacket_Head<0x7953> *network, Packet_Head<0x7953> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1794,7 +1892,7 @@ bool native_to_network(NetSPacket_0x7953_Head *network, SPacket_0x7953_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7953_Head *native, NetSPacket_0x7953_Head network) +bool network_to_native(Packet_Head<0x7953> *native, NetPacket_Head<0x7953> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1814,21 +1912,21 @@ bool network_to_native(SPacket_0x7953_Head *native, NetSPacket_0x7953_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x7953_Repeat *network, SPacket_0x7953_Repeat native) +bool native_to_network(NetPacket_Repeat<0x7953> *network, Packet_Repeat<0x7953> native) { bool rv = true; rv &= native_to_network(&network->c, native.c); return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x7953_Repeat *native, NetSPacket_0x7953_Repeat network) +bool network_to_native(Packet_Repeat<0x7953> *native, NetPacket_Repeat<0x7953> network) { bool rv = true; rv &= network_to_native(&native->c, network.c); return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7954_Fixed *network, RPacket_0x7954_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7954> *network, Packet_Fixed<0x7954> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -1836,7 +1934,7 @@ bool native_to_network(NetRPacket_0x7954_Fixed *network, RPacket_0x7954_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x7954_Fixed *native, NetRPacket_0x7954_Fixed network) +bool network_to_native(Packet_Fixed<0x7954> *native, NetPacket_Fixed<0x7954> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -1844,14 +1942,14 @@ bool network_to_native(RPacket_0x7954_Fixed *native, NetRPacket_0x7954_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x7955_Fixed *network, RPacket_0x7955_Fixed native) +bool native_to_network(NetPacket_Fixed<0x7955> *network, Packet_Fixed<0x7955> 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(RPacket_0x7955_Fixed *native, NetRPacket_0x7955_Fixed network) +bool network_to_native(Packet_Fixed<0x7955> *native, NetPacket_Fixed<0x7955> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); diff --git a/src/proto2/login-char.hpp b/src/proto2/login-char.hpp index 9c0ba74..8f3a99e 100644 --- a/src/proto2/login-char.hpp +++ b/src/proto2/login-char.hpp @@ -27,18 +27,20 @@ // This is an internal protocol, and can be changed without notice -struct RPacket_0x2709_Fixed +template<> +struct Packet_Fixed<0x2709> { - using NetType = NetRPacket_0x2709_Fixed; static const uint16_t PACKET_ID = 0x2709; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; }; -struct RPacket_0x2712_Fixed +template<> +struct Packet_Fixed<0x2712> { - using NetType = NetRPacket_0x2712_Fixed; static const uint16_t PACKET_ID = 0x2712; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; uint32_t login_id1 = {}; @@ -46,225 +48,251 @@ struct RPacket_0x2712_Fixed SEX sex = {}; IP4Address ip = {}; }; -struct SPacket_0x2713_Fixed +template<> +struct Packet_Fixed<0x2713> { - using NetType = NetSPacket_0x2713_Fixed; static const uint16_t PACKET_ID = 0x2713; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; uint8_t invalid = {}; AccountEmail email = {}; TimeT connect_until = {}; }; -struct RPacket_0x2714_Fixed +template<> +struct Packet_Fixed<0x2714> { - using NetType = NetRPacket_0x2714_Fixed; static const uint16_t PACKET_ID = 0x2714; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; uint32_t users = {}; }; -struct RPacket_0x2715_Fixed +template<> +struct Packet_Fixed<0x2715> { - using NetType = NetRPacket_0x2715_Fixed; static const uint16_t PACKET_ID = 0x2715; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountEmail email = {}; }; -struct RPacket_0x2716_Fixed +template<> +struct Packet_Fixed<0x2716> { - using NetType = NetRPacket_0x2716_Fixed; static const uint16_t PACKET_ID = 0x2716; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; }; -struct SPacket_0x2717_Fixed +template<> +struct Packet_Fixed<0x2717> { - using NetType = NetSPacket_0x2717_Fixed; static const uint16_t PACKET_ID = 0x2717; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountEmail email = {}; TimeT connect_until = {}; }; -struct RPacket_0x2720_Head +template<> +struct Packet_Head<0x2720> { - using NetType = NetRPacket_0x2720_Head; static const uint16_t PACKET_ID = 0x2720; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; + // TODO remove this uint16_t magic_packet_length = {}; AccountId account_id = {}; }; -struct RPacket_0x2720_Repeat +template<> +struct Packet_Repeat<0x2720> { - using NetType = NetRPacket_0x2720_Repeat; static const uint16_t PACKET_ID = 0x2720; uint8_t c = {}; }; -struct SPacket_0x2721_Fixed +template<> +struct Packet_Fixed<0x2721> { - using NetType = NetSPacket_0x2721_Fixed; static const uint16_t PACKET_ID = 0x2721; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; GmLevel gm_level = {}; }; -struct RPacket_0x2722_Fixed +template<> +struct Packet_Fixed<0x2722> { - using NetType = NetRPacket_0x2722_Fixed; static const uint16_t PACKET_ID = 0x2722; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountEmail old_email = {}; AccountEmail new_email = {}; }; -struct SPacket_0x2723_Fixed +template<> +struct Packet_Fixed<0x2723> { - using NetType = NetSPacket_0x2723_Fixed; static const uint16_t PACKET_ID = 0x2723; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; SEX sex = {}; }; -struct RPacket_0x2724_Fixed +template<> +struct Packet_Fixed<0x2724> { - using NetType = NetRPacket_0x2724_Fixed; static const uint16_t PACKET_ID = 0x2724; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; uint32_t status = {}; }; -struct RPacket_0x2725_Fixed +template<> +struct Packet_Fixed<0x2725> { - using NetType = NetRPacket_0x2725_Fixed; static const uint16_t PACKET_ID = 0x2725; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; HumanTimeDiff deltas = {}; }; -struct RPacket_0x2727_Fixed +template<> +struct Packet_Fixed<0x2727> { - using NetType = NetRPacket_0x2727_Fixed; static const uint16_t PACKET_ID = 0x2727; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; }; -struct RPacket_0x2728_Head +template<> +struct Packet_Head<0x2728> { - using NetType = NetRPacket_0x2728_Head; static const uint16_t PACKET_ID = 0x2728; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; + // TODO remove this uint16_t magic_packet_length = {}; AccountId account_id = {}; }; -struct RPacket_0x2728_Repeat +template<> +struct Packet_Repeat<0x2728> { - using NetType = NetRPacket_0x2728_Repeat; static const uint16_t PACKET_ID = 0x2728; VarName name = {}; uint32_t value = {}; }; -struct SPacket_0x2729_Head +template<> +struct Packet_Head<0x2729> { - using NetType = NetSPacket_0x2729_Head; static const uint16_t PACKET_ID = 0x2729; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; + // TODO remove this uint16_t magic_packet_length = {}; AccountId account_id = {}; }; -struct SPacket_0x2729_Repeat +template<> +struct Packet_Repeat<0x2729> { - using NetType = NetSPacket_0x2729_Repeat; static const uint16_t PACKET_ID = 0x2729; VarName name = {}; uint32_t value = {}; }; -struct RPacket_0x272a_Fixed +template<> +struct Packet_Fixed<0x272a> { - using NetType = NetRPacket_0x272a_Fixed; static const uint16_t PACKET_ID = 0x272a; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; }; -struct SPacket_0x2730_Fixed +template<> +struct Packet_Fixed<0x2730> { - using NetType = NetSPacket_0x2730_Fixed; static const uint16_t PACKET_ID = 0x2730; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; }; -struct SPacket_0x2731_Fixed +template<> +struct Packet_Fixed<0x2731> { - using NetType = NetSPacket_0x2731_Fixed; static const uint16_t PACKET_ID = 0x2731; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; uint8_t ban_not_status = {}; TimeT status_or_ban_until = {}; }; -struct SPacket_0x2732_Head +template<> +struct Packet_Head<0x2732> { - using NetType = NetSPacket_0x2732_Head; static const uint16_t PACKET_ID = 0x2732; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; + // TODO remove this uint16_t magic_packet_length = {}; }; -struct SPacket_0x2732_Repeat +template<> +struct Packet_Repeat<0x2732> { - using NetType = NetSPacket_0x2732_Repeat; static const uint16_t PACKET_ID = 0x2732; AccountId account_id = {}; GmLevel gm_level = {}; }; -struct RPacket_0x2740_Fixed +template<> +struct Packet_Fixed<0x2740> { - using NetType = NetRPacket_0x2740_Fixed; static const uint16_t PACKET_ID = 0x2740; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; AccountPass old_pass = {}; AccountPass new_pass = {}; }; -struct SPacket_0x2741_Fixed +template<> +struct Packet_Fixed<0x2741> { - using NetType = NetSPacket_0x2741_Fixed; static const uint16_t PACKET_ID = 0x2741; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; AccountId account_id = {}; uint8_t status = {}; }; -struct NetRPacket_0x2709_Fixed +template<> +struct NetPacket_Fixed<0x2709> { Little16 magic_packet_id; }; -static_assert(offsetof(NetRPacket_0x2709_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2709_Fixed, magic_packet_id) == 0"); -static_assert(sizeof(NetRPacket_0x2709_Fixed) == 2, "sizeof(NetRPacket_0x2709_Fixed) == 2"); -struct NetRPacket_0x2712_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2709>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2709>, magic_packet_id) == 0"); +static_assert(sizeof(NetPacket_Fixed<0x2709>) == 2, "sizeof(NetPacket_Fixed<0x2709>) == 2"); +template<> +struct NetPacket_Fixed<0x2712> { Little16 magic_packet_id; Little32 account_id; @@ -273,14 +301,15 @@ struct NetRPacket_0x2712_Fixed Byte sex; IP4Address ip; }; -static_assert(offsetof(NetRPacket_0x2712_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2712_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2712_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2712_Fixed, account_id) == 2"); -static_assert(offsetof(NetRPacket_0x2712_Fixed, login_id1) == 6, "offsetof(NetRPacket_0x2712_Fixed, login_id1) == 6"); -static_assert(offsetof(NetRPacket_0x2712_Fixed, login_id2) == 10, "offsetof(NetRPacket_0x2712_Fixed, login_id2) == 10"); -static_assert(offsetof(NetRPacket_0x2712_Fixed, sex) == 14, "offsetof(NetRPacket_0x2712_Fixed, sex) == 14"); -static_assert(offsetof(NetRPacket_0x2712_Fixed, ip) == 15, "offsetof(NetRPacket_0x2712_Fixed, ip) == 15"); -static_assert(sizeof(NetRPacket_0x2712_Fixed) == 19, "sizeof(NetRPacket_0x2712_Fixed) == 19"); -struct NetSPacket_0x2713_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2712>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2712>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2712>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2712>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2712>, login_id1) == 6, "offsetof(NetPacket_Fixed<0x2712>, login_id1) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2712>, login_id2) == 10, "offsetof(NetPacket_Fixed<0x2712>, login_id2) == 10"); +static_assert(offsetof(NetPacket_Fixed<0x2712>, sex) == 14, "offsetof(NetPacket_Fixed<0x2712>, sex) == 14"); +static_assert(offsetof(NetPacket_Fixed<0x2712>, ip) == 15, "offsetof(NetPacket_Fixed<0x2712>, ip) == 15"); +static_assert(sizeof(NetPacket_Fixed<0x2712>) == 19, "sizeof(NetPacket_Fixed<0x2712>) == 19"); +template<> +struct NetPacket_Fixed<0x2713> { Little16 magic_packet_id; Little32 account_id; @@ -288,245 +317,268 @@ struct NetSPacket_0x2713_Fixed NetString email; Little32 connect_until; }; -static_assert(offsetof(NetSPacket_0x2713_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x2713_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2713_Fixed, account_id) == 2, "offsetof(NetSPacket_0x2713_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x2713_Fixed, invalid) == 6, "offsetof(NetSPacket_0x2713_Fixed, invalid) == 6"); -static_assert(offsetof(NetSPacket_0x2713_Fixed, email) == 7, "offsetof(NetSPacket_0x2713_Fixed, email) == 7"); -static_assert(offsetof(NetSPacket_0x2713_Fixed, connect_until) == 47, "offsetof(NetSPacket_0x2713_Fixed, connect_until) == 47"); -static_assert(sizeof(NetSPacket_0x2713_Fixed) == 51, "sizeof(NetSPacket_0x2713_Fixed) == 51"); -struct NetRPacket_0x2714_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2713>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2713>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2713>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2713>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2713>, invalid) == 6, "offsetof(NetPacket_Fixed<0x2713>, invalid) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2713>, email) == 7, "offsetof(NetPacket_Fixed<0x2713>, email) == 7"); +static_assert(offsetof(NetPacket_Fixed<0x2713>, connect_until) == 47, "offsetof(NetPacket_Fixed<0x2713>, connect_until) == 47"); +static_assert(sizeof(NetPacket_Fixed<0x2713>) == 51, "sizeof(NetPacket_Fixed<0x2713>) == 51"); +template<> +struct NetPacket_Fixed<0x2714> { Little16 magic_packet_id; Little32 users; }; -static_assert(offsetof(NetRPacket_0x2714_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2714_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2714_Fixed, users) == 2, "offsetof(NetRPacket_0x2714_Fixed, users) == 2"); -static_assert(sizeof(NetRPacket_0x2714_Fixed) == 6, "sizeof(NetRPacket_0x2714_Fixed) == 6"); -struct NetRPacket_0x2715_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2714>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2714>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2714>, users) == 2, "offsetof(NetPacket_Fixed<0x2714>, users) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2714>) == 6, "sizeof(NetPacket_Fixed<0x2714>) == 6"); +template<> +struct NetPacket_Fixed<0x2715> { Little16 magic_packet_id; Little32 account_id; NetString email; }; -static_assert(offsetof(NetRPacket_0x2715_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2715_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2715_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2715_Fixed, account_id) == 2"); -static_assert(offsetof(NetRPacket_0x2715_Fixed, email) == 6, "offsetof(NetRPacket_0x2715_Fixed, email) == 6"); -static_assert(sizeof(NetRPacket_0x2715_Fixed) == 46, "sizeof(NetRPacket_0x2715_Fixed) == 46"); -struct NetRPacket_0x2716_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2715>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2715>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2715>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2715>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2715>, email) == 6, "offsetof(NetPacket_Fixed<0x2715>, email) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2715>) == 46, "sizeof(NetPacket_Fixed<0x2715>) == 46"); +template<> +struct NetPacket_Fixed<0x2716> { Little16 magic_packet_id; Little32 account_id; }; -static_assert(offsetof(NetRPacket_0x2716_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2716_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2716_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2716_Fixed, account_id) == 2"); -static_assert(sizeof(NetRPacket_0x2716_Fixed) == 6, "sizeof(NetRPacket_0x2716_Fixed) == 6"); -struct NetSPacket_0x2717_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2716>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2716>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2716>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2716>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2716>) == 6, "sizeof(NetPacket_Fixed<0x2716>) == 6"); +template<> +struct NetPacket_Fixed<0x2717> { Little16 magic_packet_id; Little32 account_id; NetString email; Little32 connect_until; }; -static_assert(offsetof(NetSPacket_0x2717_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x2717_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2717_Fixed, account_id) == 2, "offsetof(NetSPacket_0x2717_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x2717_Fixed, email) == 6, "offsetof(NetSPacket_0x2717_Fixed, email) == 6"); -static_assert(offsetof(NetSPacket_0x2717_Fixed, connect_until) == 46, "offsetof(NetSPacket_0x2717_Fixed, connect_until) == 46"); -static_assert(sizeof(NetSPacket_0x2717_Fixed) == 50, "sizeof(NetSPacket_0x2717_Fixed) == 50"); -struct NetRPacket_0x2720_Head +static_assert(offsetof(NetPacket_Fixed<0x2717>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2717>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2717>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2717>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2717>, email) == 6, "offsetof(NetPacket_Fixed<0x2717>, email) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2717>, connect_until) == 46, "offsetof(NetPacket_Fixed<0x2717>, connect_until) == 46"); +static_assert(sizeof(NetPacket_Fixed<0x2717>) == 50, "sizeof(NetPacket_Fixed<0x2717>) == 50"); +template<> +struct NetPacket_Head<0x2720> { Little16 magic_packet_id; Little16 magic_packet_length; Little32 account_id; }; -static_assert(offsetof(NetRPacket_0x2720_Head, magic_packet_id) == 0, "offsetof(NetRPacket_0x2720_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2720_Head, magic_packet_length) == 2, "offsetof(NetRPacket_0x2720_Head, magic_packet_length) == 2"); -static_assert(offsetof(NetRPacket_0x2720_Head, account_id) == 4, "offsetof(NetRPacket_0x2720_Head, account_id) == 4"); -static_assert(sizeof(NetRPacket_0x2720_Head) == 8, "sizeof(NetRPacket_0x2720_Head) == 8"); -struct NetRPacket_0x2720_Repeat +static_assert(offsetof(NetPacket_Head<0x2720>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2720>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2720>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2720>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2720>, account_id) == 4, "offsetof(NetPacket_Head<0x2720>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x2720>) == 8, "sizeof(NetPacket_Head<0x2720>) == 8"); +template<> +struct NetPacket_Repeat<0x2720> { Byte c; }; -static_assert(offsetof(NetRPacket_0x2720_Repeat, c) == 0, "offsetof(NetRPacket_0x2720_Repeat, c) == 0"); -static_assert(sizeof(NetRPacket_0x2720_Repeat) == 1, "sizeof(NetRPacket_0x2720_Repeat) == 1"); -struct NetSPacket_0x2721_Fixed +static_assert(offsetof(NetPacket_Repeat<0x2720>, c) == 0, "offsetof(NetPacket_Repeat<0x2720>, c) == 0"); +static_assert(sizeof(NetPacket_Repeat<0x2720>) == 1, "sizeof(NetPacket_Repeat<0x2720>) == 1"); +template<> +struct NetPacket_Fixed<0x2721> { Little16 magic_packet_id; Little32 account_id; Little32 gm_level; }; -static_assert(offsetof(NetSPacket_0x2721_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x2721_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2721_Fixed, account_id) == 2, "offsetof(NetSPacket_0x2721_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x2721_Fixed, gm_level) == 6, "offsetof(NetSPacket_0x2721_Fixed, gm_level) == 6"); -static_assert(sizeof(NetSPacket_0x2721_Fixed) == 10, "sizeof(NetSPacket_0x2721_Fixed) == 10"); -struct NetRPacket_0x2722_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2721>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2721>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2721>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2721>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2721>, gm_level) == 6, "offsetof(NetPacket_Fixed<0x2721>, gm_level) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2721>) == 10, "sizeof(NetPacket_Fixed<0x2721>) == 10"); +template<> +struct NetPacket_Fixed<0x2722> { Little16 magic_packet_id; Little32 account_id; NetString old_email; NetString new_email; }; -static_assert(offsetof(NetRPacket_0x2722_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2722_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2722_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2722_Fixed, account_id) == 2"); -static_assert(offsetof(NetRPacket_0x2722_Fixed, old_email) == 6, "offsetof(NetRPacket_0x2722_Fixed, old_email) == 6"); -static_assert(offsetof(NetRPacket_0x2722_Fixed, new_email) == 46, "offsetof(NetRPacket_0x2722_Fixed, new_email) == 46"); -static_assert(sizeof(NetRPacket_0x2722_Fixed) == 86, "sizeof(NetRPacket_0x2722_Fixed) == 86"); -struct NetSPacket_0x2723_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2722>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2722>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2722>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2722>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2722>, old_email) == 6, "offsetof(NetPacket_Fixed<0x2722>, old_email) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2722>, new_email) == 46, "offsetof(NetPacket_Fixed<0x2722>, new_email) == 46"); +static_assert(sizeof(NetPacket_Fixed<0x2722>) == 86, "sizeof(NetPacket_Fixed<0x2722>) == 86"); +template<> +struct NetPacket_Fixed<0x2723> { Little16 magic_packet_id; Little32 account_id; Byte sex; }; -static_assert(offsetof(NetSPacket_0x2723_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x2723_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2723_Fixed, account_id) == 2, "offsetof(NetSPacket_0x2723_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x2723_Fixed, sex) == 6, "offsetof(NetSPacket_0x2723_Fixed, sex) == 6"); -static_assert(sizeof(NetSPacket_0x2723_Fixed) == 7, "sizeof(NetSPacket_0x2723_Fixed) == 7"); -struct NetRPacket_0x2724_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2723>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2723>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2723>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2723>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2723>, sex) == 6, "offsetof(NetPacket_Fixed<0x2723>, sex) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2723>) == 7, "sizeof(NetPacket_Fixed<0x2723>) == 7"); +template<> +struct NetPacket_Fixed<0x2724> { Little16 magic_packet_id; Little32 account_id; Little32 status; }; -static_assert(offsetof(NetRPacket_0x2724_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2724_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2724_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2724_Fixed, account_id) == 2"); -static_assert(offsetof(NetRPacket_0x2724_Fixed, status) == 6, "offsetof(NetRPacket_0x2724_Fixed, status) == 6"); -static_assert(sizeof(NetRPacket_0x2724_Fixed) == 10, "sizeof(NetRPacket_0x2724_Fixed) == 10"); -struct NetRPacket_0x2725_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2724>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2724>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2724>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2724>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2724>, status) == 6, "offsetof(NetPacket_Fixed<0x2724>, status) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2724>) == 10, "sizeof(NetPacket_Fixed<0x2724>) == 10"); +template<> +struct NetPacket_Fixed<0x2725> { Little16 magic_packet_id; Little32 account_id; NetHumanTimeDiff deltas; }; -static_assert(offsetof(NetRPacket_0x2725_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2725_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2725_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2725_Fixed, account_id) == 2"); -static_assert(offsetof(NetRPacket_0x2725_Fixed, deltas) == 6, "offsetof(NetRPacket_0x2725_Fixed, deltas) == 6"); -static_assert(sizeof(NetRPacket_0x2725_Fixed) == 18, "sizeof(NetRPacket_0x2725_Fixed) == 18"); -struct NetRPacket_0x2727_Fixed +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(sizeof(NetPacket_Fixed<0x2725>) == 18, "sizeof(NetPacket_Fixed<0x2725>) == 18"); +template<> +struct NetPacket_Fixed<0x2727> { Little16 magic_packet_id; Little32 account_id; }; -static_assert(offsetof(NetRPacket_0x2727_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2727_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2727_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2727_Fixed, account_id) == 2"); -static_assert(sizeof(NetRPacket_0x2727_Fixed) == 6, "sizeof(NetRPacket_0x2727_Fixed) == 6"); -struct NetRPacket_0x2728_Head +static_assert(offsetof(NetPacket_Fixed<0x2727>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2727>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2727>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2727>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2727>) == 6, "sizeof(NetPacket_Fixed<0x2727>) == 6"); +template<> +struct NetPacket_Head<0x2728> { Little16 magic_packet_id; Little16 magic_packet_length; Little32 account_id; }; -static_assert(offsetof(NetRPacket_0x2728_Head, magic_packet_id) == 0, "offsetof(NetRPacket_0x2728_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2728_Head, magic_packet_length) == 2, "offsetof(NetRPacket_0x2728_Head, magic_packet_length) == 2"); -static_assert(offsetof(NetRPacket_0x2728_Head, account_id) == 4, "offsetof(NetRPacket_0x2728_Head, account_id) == 4"); -static_assert(sizeof(NetRPacket_0x2728_Head) == 8, "sizeof(NetRPacket_0x2728_Head) == 8"); -struct NetRPacket_0x2728_Repeat +static_assert(offsetof(NetPacket_Head<0x2728>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2728>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2728>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2728>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2728>, account_id) == 4, "offsetof(NetPacket_Head<0x2728>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x2728>) == 8, "sizeof(NetPacket_Head<0x2728>) == 8"); +template<> +struct NetPacket_Repeat<0x2728> { NetString name; Little32 value; }; -static_assert(offsetof(NetRPacket_0x2728_Repeat, name) == 0, "offsetof(NetRPacket_0x2728_Repeat, name) == 0"); -static_assert(offsetof(NetRPacket_0x2728_Repeat, value) == 32, "offsetof(NetRPacket_0x2728_Repeat, value) == 32"); -static_assert(sizeof(NetRPacket_0x2728_Repeat) == 36, "sizeof(NetRPacket_0x2728_Repeat) == 36"); -struct NetSPacket_0x2729_Head +static_assert(offsetof(NetPacket_Repeat<0x2728>, name) == 0, "offsetof(NetPacket_Repeat<0x2728>, name) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x2728>, value) == 32, "offsetof(NetPacket_Repeat<0x2728>, value) == 32"); +static_assert(sizeof(NetPacket_Repeat<0x2728>) == 36, "sizeof(NetPacket_Repeat<0x2728>) == 36"); +template<> +struct NetPacket_Head<0x2729> { Little16 magic_packet_id; Little16 magic_packet_length; Little32 account_id; }; -static_assert(offsetof(NetSPacket_0x2729_Head, magic_packet_id) == 0, "offsetof(NetSPacket_0x2729_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2729_Head, magic_packet_length) == 2, "offsetof(NetSPacket_0x2729_Head, magic_packet_length) == 2"); -static_assert(offsetof(NetSPacket_0x2729_Head, account_id) == 4, "offsetof(NetSPacket_0x2729_Head, account_id) == 4"); -static_assert(sizeof(NetSPacket_0x2729_Head) == 8, "sizeof(NetSPacket_0x2729_Head) == 8"); -struct NetSPacket_0x2729_Repeat +static_assert(offsetof(NetPacket_Head<0x2729>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2729>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2729>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2729>, magic_packet_length) == 2"); +static_assert(offsetof(NetPacket_Head<0x2729>, account_id) == 4, "offsetof(NetPacket_Head<0x2729>, account_id) == 4"); +static_assert(sizeof(NetPacket_Head<0x2729>) == 8, "sizeof(NetPacket_Head<0x2729>) == 8"); +template<> +struct NetPacket_Repeat<0x2729> { NetString name; Little32 value; }; -static_assert(offsetof(NetSPacket_0x2729_Repeat, name) == 0, "offsetof(NetSPacket_0x2729_Repeat, name) == 0"); -static_assert(offsetof(NetSPacket_0x2729_Repeat, value) == 32, "offsetof(NetSPacket_0x2729_Repeat, value) == 32"); -static_assert(sizeof(NetSPacket_0x2729_Repeat) == 36, "sizeof(NetSPacket_0x2729_Repeat) == 36"); -struct NetRPacket_0x272a_Fixed +static_assert(offsetof(NetPacket_Repeat<0x2729>, name) == 0, "offsetof(NetPacket_Repeat<0x2729>, name) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x2729>, value) == 32, "offsetof(NetPacket_Repeat<0x2729>, value) == 32"); +static_assert(sizeof(NetPacket_Repeat<0x2729>) == 36, "sizeof(NetPacket_Repeat<0x2729>) == 36"); +template<> +struct NetPacket_Fixed<0x272a> { Little16 magic_packet_id; Little32 account_id; }; -static_assert(offsetof(NetRPacket_0x272a_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x272a_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x272a_Fixed, account_id) == 2, "offsetof(NetRPacket_0x272a_Fixed, account_id) == 2"); -static_assert(sizeof(NetRPacket_0x272a_Fixed) == 6, "sizeof(NetRPacket_0x272a_Fixed) == 6"); -struct NetSPacket_0x2730_Fixed +static_assert(offsetof(NetPacket_Fixed<0x272a>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x272a>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x272a>, account_id) == 2, "offsetof(NetPacket_Fixed<0x272a>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x272a>) == 6, "sizeof(NetPacket_Fixed<0x272a>) == 6"); +template<> +struct NetPacket_Fixed<0x2730> { Little16 magic_packet_id; Little32 account_id; }; -static_assert(offsetof(NetSPacket_0x2730_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x2730_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2730_Fixed, account_id) == 2, "offsetof(NetSPacket_0x2730_Fixed, account_id) == 2"); -static_assert(sizeof(NetSPacket_0x2730_Fixed) == 6, "sizeof(NetSPacket_0x2730_Fixed) == 6"); -struct NetSPacket_0x2731_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2730>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2730>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2730>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2730>, account_id) == 2"); +static_assert(sizeof(NetPacket_Fixed<0x2730>) == 6, "sizeof(NetPacket_Fixed<0x2730>) == 6"); +template<> +struct NetPacket_Fixed<0x2731> { Little16 magic_packet_id; Little32 account_id; Byte ban_not_status; Little32 status_or_ban_until; }; -static_assert(offsetof(NetSPacket_0x2731_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x2731_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2731_Fixed, account_id) == 2, "offsetof(NetSPacket_0x2731_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x2731_Fixed, ban_not_status) == 6, "offsetof(NetSPacket_0x2731_Fixed, ban_not_status) == 6"); -static_assert(offsetof(NetSPacket_0x2731_Fixed, status_or_ban_until) == 7, "offsetof(NetSPacket_0x2731_Fixed, status_or_ban_until) == 7"); -static_assert(sizeof(NetSPacket_0x2731_Fixed) == 11, "sizeof(NetSPacket_0x2731_Fixed) == 11"); -struct NetSPacket_0x2732_Head +static_assert(offsetof(NetPacket_Fixed<0x2731>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2731>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2731>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2731>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2731>, ban_not_status) == 6, "offsetof(NetPacket_Fixed<0x2731>, ban_not_status) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2731>, status_or_ban_until) == 7, "offsetof(NetPacket_Fixed<0x2731>, status_or_ban_until) == 7"); +static_assert(sizeof(NetPacket_Fixed<0x2731>) == 11, "sizeof(NetPacket_Fixed<0x2731>) == 11"); +template<> +struct NetPacket_Head<0x2732> { Little16 magic_packet_id; Little16 magic_packet_length; }; -static_assert(offsetof(NetSPacket_0x2732_Head, magic_packet_id) == 0, "offsetof(NetSPacket_0x2732_Head, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2732_Head, magic_packet_length) == 2, "offsetof(NetSPacket_0x2732_Head, magic_packet_length) == 2"); -static_assert(sizeof(NetSPacket_0x2732_Head) == 4, "sizeof(NetSPacket_0x2732_Head) == 4"); -struct NetSPacket_0x2732_Repeat +static_assert(offsetof(NetPacket_Head<0x2732>, magic_packet_id) == 0, "offsetof(NetPacket_Head<0x2732>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Head<0x2732>, magic_packet_length) == 2, "offsetof(NetPacket_Head<0x2732>, magic_packet_length) == 2"); +static_assert(sizeof(NetPacket_Head<0x2732>) == 4, "sizeof(NetPacket_Head<0x2732>) == 4"); +template<> +struct NetPacket_Repeat<0x2732> { Little32 account_id; Byte gm_level; }; -static_assert(offsetof(NetSPacket_0x2732_Repeat, account_id) == 0, "offsetof(NetSPacket_0x2732_Repeat, account_id) == 0"); -static_assert(offsetof(NetSPacket_0x2732_Repeat, gm_level) == 4, "offsetof(NetSPacket_0x2732_Repeat, gm_level) == 4"); -static_assert(sizeof(NetSPacket_0x2732_Repeat) == 5, "sizeof(NetSPacket_0x2732_Repeat) == 5"); -struct NetRPacket_0x2740_Fixed +static_assert(offsetof(NetPacket_Repeat<0x2732>, account_id) == 0, "offsetof(NetPacket_Repeat<0x2732>, account_id) == 0"); +static_assert(offsetof(NetPacket_Repeat<0x2732>, gm_level) == 4, "offsetof(NetPacket_Repeat<0x2732>, gm_level) == 4"); +static_assert(sizeof(NetPacket_Repeat<0x2732>) == 5, "sizeof(NetPacket_Repeat<0x2732>) == 5"); +template<> +struct NetPacket_Fixed<0x2740> { Little16 magic_packet_id; Little32 account_id; NetString old_pass; NetString new_pass; }; -static_assert(offsetof(NetRPacket_0x2740_Fixed, magic_packet_id) == 0, "offsetof(NetRPacket_0x2740_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetRPacket_0x2740_Fixed, account_id) == 2, "offsetof(NetRPacket_0x2740_Fixed, account_id) == 2"); -static_assert(offsetof(NetRPacket_0x2740_Fixed, old_pass) == 6, "offsetof(NetRPacket_0x2740_Fixed, old_pass) == 6"); -static_assert(offsetof(NetRPacket_0x2740_Fixed, new_pass) == 30, "offsetof(NetRPacket_0x2740_Fixed, new_pass) == 30"); -static_assert(sizeof(NetRPacket_0x2740_Fixed) == 54, "sizeof(NetRPacket_0x2740_Fixed) == 54"); -struct NetSPacket_0x2741_Fixed +static_assert(offsetof(NetPacket_Fixed<0x2740>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2740>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2740>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2740>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2740>, old_pass) == 6, "offsetof(NetPacket_Fixed<0x2740>, old_pass) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x2740>, new_pass) == 30, "offsetof(NetPacket_Fixed<0x2740>, new_pass) == 30"); +static_assert(sizeof(NetPacket_Fixed<0x2740>) == 54, "sizeof(NetPacket_Fixed<0x2740>) == 54"); +template<> +struct NetPacket_Fixed<0x2741> { Little16 magic_packet_id; Little32 account_id; Byte status; }; -static_assert(offsetof(NetSPacket_0x2741_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x2741_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x2741_Fixed, account_id) == 2, "offsetof(NetSPacket_0x2741_Fixed, account_id) == 2"); -static_assert(offsetof(NetSPacket_0x2741_Fixed, status) == 6, "offsetof(NetSPacket_0x2741_Fixed, status) == 6"); -static_assert(sizeof(NetSPacket_0x2741_Fixed) == 7, "sizeof(NetSPacket_0x2741_Fixed) == 7"); +static_assert(offsetof(NetPacket_Fixed<0x2741>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x2741>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x2741>, account_id) == 2, "offsetof(NetPacket_Fixed<0x2741>, account_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x2741>, status) == 6, "offsetof(NetPacket_Fixed<0x2741>, status) == 6"); +static_assert(sizeof(NetPacket_Fixed<0x2741>) == 7, "sizeof(NetPacket_Fixed<0x2741>) == 7"); inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2709_Fixed *network, RPacket_0x2709_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2709> *network, Packet_Fixed<0x2709> 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(RPacket_0x2709_Fixed *native, NetRPacket_0x2709_Fixed network) +bool network_to_native(Packet_Fixed<0x2709> *native, NetPacket_Fixed<0x2709> 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(NetRPacket_0x2712_Fixed *network, RPacket_0x2712_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2712> *network, Packet_Fixed<0x2712> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -538,7 +590,7 @@ bool native_to_network(NetRPacket_0x2712_Fixed *network, RPacket_0x2712_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2712_Fixed *native, NetRPacket_0x2712_Fixed network) +bool network_to_native(Packet_Fixed<0x2712> *native, NetPacket_Fixed<0x2712> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -550,7 +602,7 @@ bool network_to_native(RPacket_0x2712_Fixed *native, NetRPacket_0x2712_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2713_Fixed *network, SPacket_0x2713_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2713> *network, Packet_Fixed<0x2713> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -561,7 +613,7 @@ bool native_to_network(NetSPacket_0x2713_Fixed *network, SPacket_0x2713_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2713_Fixed *native, NetSPacket_0x2713_Fixed network) +bool network_to_native(Packet_Fixed<0x2713> *native, NetPacket_Fixed<0x2713> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -572,7 +624,7 @@ bool network_to_native(SPacket_0x2713_Fixed *native, NetSPacket_0x2713_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2714_Fixed *network, RPacket_0x2714_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2714> *network, Packet_Fixed<0x2714> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -580,7 +632,7 @@ bool native_to_network(NetRPacket_0x2714_Fixed *network, RPacket_0x2714_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2714_Fixed *native, NetRPacket_0x2714_Fixed network) +bool network_to_native(Packet_Fixed<0x2714> *native, NetPacket_Fixed<0x2714> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -588,7 +640,7 @@ bool network_to_native(RPacket_0x2714_Fixed *native, NetRPacket_0x2714_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2715_Fixed *network, RPacket_0x2715_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2715> *network, Packet_Fixed<0x2715> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -597,7 +649,7 @@ bool native_to_network(NetRPacket_0x2715_Fixed *network, RPacket_0x2715_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2715_Fixed *native, NetRPacket_0x2715_Fixed network) +bool network_to_native(Packet_Fixed<0x2715> *native, NetPacket_Fixed<0x2715> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -606,7 +658,7 @@ bool network_to_native(RPacket_0x2715_Fixed *native, NetRPacket_0x2715_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2716_Fixed *network, RPacket_0x2716_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2716> *network, Packet_Fixed<0x2716> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -614,7 +666,7 @@ bool native_to_network(NetRPacket_0x2716_Fixed *network, RPacket_0x2716_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2716_Fixed *native, NetRPacket_0x2716_Fixed network) +bool network_to_native(Packet_Fixed<0x2716> *native, NetPacket_Fixed<0x2716> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -622,7 +674,7 @@ bool network_to_native(RPacket_0x2716_Fixed *native, NetRPacket_0x2716_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2717_Fixed *network, SPacket_0x2717_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2717> *network, Packet_Fixed<0x2717> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -632,7 +684,7 @@ bool native_to_network(NetSPacket_0x2717_Fixed *network, SPacket_0x2717_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2717_Fixed *native, NetSPacket_0x2717_Fixed network) +bool network_to_native(Packet_Fixed<0x2717> *native, NetPacket_Fixed<0x2717> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -642,7 +694,7 @@ bool network_to_native(SPacket_0x2717_Fixed *native, NetSPacket_0x2717_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2720_Head *network, RPacket_0x2720_Head native) +bool native_to_network(NetPacket_Head<0x2720> *network, Packet_Head<0x2720> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -651,7 +703,7 @@ bool native_to_network(NetRPacket_0x2720_Head *network, RPacket_0x2720_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2720_Head *native, NetRPacket_0x2720_Head network) +bool network_to_native(Packet_Head<0x2720> *native, NetPacket_Head<0x2720> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -660,21 +712,21 @@ bool network_to_native(RPacket_0x2720_Head *native, NetRPacket_0x2720_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2720_Repeat *network, RPacket_0x2720_Repeat native) +bool native_to_network(NetPacket_Repeat<0x2720> *network, Packet_Repeat<0x2720> native) { bool rv = true; rv &= native_to_network(&network->c, native.c); return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2720_Repeat *native, NetRPacket_0x2720_Repeat network) +bool network_to_native(Packet_Repeat<0x2720> *native, NetPacket_Repeat<0x2720> network) { bool rv = true; rv &= network_to_native(&native->c, network.c); return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2721_Fixed *network, SPacket_0x2721_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2721> *network, Packet_Fixed<0x2721> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -683,7 +735,7 @@ bool native_to_network(NetSPacket_0x2721_Fixed *network, SPacket_0x2721_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2721_Fixed *native, NetSPacket_0x2721_Fixed network) +bool network_to_native(Packet_Fixed<0x2721> *native, NetPacket_Fixed<0x2721> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -692,7 +744,7 @@ bool network_to_native(SPacket_0x2721_Fixed *native, NetSPacket_0x2721_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2722_Fixed *network, RPacket_0x2722_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2722> *network, Packet_Fixed<0x2722> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -702,7 +754,7 @@ bool native_to_network(NetRPacket_0x2722_Fixed *network, RPacket_0x2722_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2722_Fixed *native, NetRPacket_0x2722_Fixed network) +bool network_to_native(Packet_Fixed<0x2722> *native, NetPacket_Fixed<0x2722> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -712,7 +764,7 @@ bool network_to_native(RPacket_0x2722_Fixed *native, NetRPacket_0x2722_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2723_Fixed *network, SPacket_0x2723_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2723> *network, Packet_Fixed<0x2723> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -721,7 +773,7 @@ bool native_to_network(NetSPacket_0x2723_Fixed *network, SPacket_0x2723_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2723_Fixed *native, NetSPacket_0x2723_Fixed network) +bool network_to_native(Packet_Fixed<0x2723> *native, NetPacket_Fixed<0x2723> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -730,7 +782,7 @@ bool network_to_native(SPacket_0x2723_Fixed *native, NetSPacket_0x2723_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2724_Fixed *network, RPacket_0x2724_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2724> *network, Packet_Fixed<0x2724> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -739,7 +791,7 @@ bool native_to_network(NetRPacket_0x2724_Fixed *network, RPacket_0x2724_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2724_Fixed *native, NetRPacket_0x2724_Fixed network) +bool network_to_native(Packet_Fixed<0x2724> *native, NetPacket_Fixed<0x2724> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -748,7 +800,7 @@ bool network_to_native(RPacket_0x2724_Fixed *native, NetRPacket_0x2724_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2725_Fixed *network, RPacket_0x2725_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2725> *network, Packet_Fixed<0x2725> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -757,7 +809,7 @@ bool native_to_network(NetRPacket_0x2725_Fixed *network, RPacket_0x2725_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2725_Fixed *native, NetRPacket_0x2725_Fixed network) +bool network_to_native(Packet_Fixed<0x2725> *native, NetPacket_Fixed<0x2725> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -766,7 +818,7 @@ bool network_to_native(RPacket_0x2725_Fixed *native, NetRPacket_0x2725_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2727_Fixed *network, RPacket_0x2727_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2727> *network, Packet_Fixed<0x2727> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -774,7 +826,7 @@ bool native_to_network(NetRPacket_0x2727_Fixed *network, RPacket_0x2727_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2727_Fixed *native, NetRPacket_0x2727_Fixed network) +bool network_to_native(Packet_Fixed<0x2727> *native, NetPacket_Fixed<0x2727> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -782,7 +834,7 @@ bool network_to_native(RPacket_0x2727_Fixed *native, NetRPacket_0x2727_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2728_Head *network, RPacket_0x2728_Head native) +bool native_to_network(NetPacket_Head<0x2728> *network, Packet_Head<0x2728> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -791,7 +843,7 @@ bool native_to_network(NetRPacket_0x2728_Head *network, RPacket_0x2728_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2728_Head *native, NetRPacket_0x2728_Head network) +bool network_to_native(Packet_Head<0x2728> *native, NetPacket_Head<0x2728> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -800,7 +852,7 @@ bool network_to_native(RPacket_0x2728_Head *native, NetRPacket_0x2728_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2728_Repeat *network, RPacket_0x2728_Repeat native) +bool native_to_network(NetPacket_Repeat<0x2728> *network, Packet_Repeat<0x2728> native) { bool rv = true; rv &= native_to_network(&network->name, native.name); @@ -808,7 +860,7 @@ bool native_to_network(NetRPacket_0x2728_Repeat *network, RPacket_0x2728_Repeat return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2728_Repeat *native, NetRPacket_0x2728_Repeat network) +bool network_to_native(Packet_Repeat<0x2728> *native, NetPacket_Repeat<0x2728> network) { bool rv = true; rv &= network_to_native(&native->name, network.name); @@ -816,7 +868,7 @@ bool network_to_native(RPacket_0x2728_Repeat *native, NetRPacket_0x2728_Repeat n return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2729_Head *network, SPacket_0x2729_Head native) +bool native_to_network(NetPacket_Head<0x2729> *network, Packet_Head<0x2729> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -825,7 +877,7 @@ bool native_to_network(NetSPacket_0x2729_Head *network, SPacket_0x2729_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2729_Head *native, NetSPacket_0x2729_Head network) +bool network_to_native(Packet_Head<0x2729> *native, NetPacket_Head<0x2729> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -834,7 +886,7 @@ bool network_to_native(SPacket_0x2729_Head *native, NetSPacket_0x2729_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2729_Repeat *network, SPacket_0x2729_Repeat native) +bool native_to_network(NetPacket_Repeat<0x2729> *network, Packet_Repeat<0x2729> native) { bool rv = true; rv &= native_to_network(&network->name, native.name); @@ -842,7 +894,7 @@ bool native_to_network(NetSPacket_0x2729_Repeat *network, SPacket_0x2729_Repeat return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2729_Repeat *native, NetSPacket_0x2729_Repeat network) +bool network_to_native(Packet_Repeat<0x2729> *native, NetPacket_Repeat<0x2729> network) { bool rv = true; rv &= network_to_native(&native->name, network.name); @@ -850,7 +902,7 @@ bool network_to_native(SPacket_0x2729_Repeat *native, NetSPacket_0x2729_Repeat n return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x272a_Fixed *network, RPacket_0x272a_Fixed native) +bool native_to_network(NetPacket_Fixed<0x272a> *network, Packet_Fixed<0x272a> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -858,7 +910,7 @@ bool native_to_network(NetRPacket_0x272a_Fixed *network, RPacket_0x272a_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x272a_Fixed *native, NetRPacket_0x272a_Fixed network) +bool network_to_native(Packet_Fixed<0x272a> *native, NetPacket_Fixed<0x272a> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -866,7 +918,7 @@ bool network_to_native(RPacket_0x272a_Fixed *native, NetRPacket_0x272a_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2730_Fixed *network, SPacket_0x2730_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2730> *network, Packet_Fixed<0x2730> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -874,7 +926,7 @@ bool native_to_network(NetSPacket_0x2730_Fixed *network, SPacket_0x2730_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2730_Fixed *native, NetSPacket_0x2730_Fixed network) +bool network_to_native(Packet_Fixed<0x2730> *native, NetPacket_Fixed<0x2730> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -882,7 +934,7 @@ bool network_to_native(SPacket_0x2730_Fixed *native, NetSPacket_0x2730_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2731_Fixed *network, SPacket_0x2731_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2731> *network, Packet_Fixed<0x2731> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -892,7 +944,7 @@ bool native_to_network(NetSPacket_0x2731_Fixed *network, SPacket_0x2731_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2731_Fixed *native, NetSPacket_0x2731_Fixed network) +bool network_to_native(Packet_Fixed<0x2731> *native, NetPacket_Fixed<0x2731> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -902,7 +954,7 @@ bool network_to_native(SPacket_0x2731_Fixed *native, NetSPacket_0x2731_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2732_Head *network, SPacket_0x2732_Head native) +bool native_to_network(NetPacket_Head<0x2732> *network, Packet_Head<0x2732> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -910,7 +962,7 @@ bool native_to_network(NetSPacket_0x2732_Head *network, SPacket_0x2732_Head nati return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2732_Head *native, NetSPacket_0x2732_Head network) +bool network_to_native(Packet_Head<0x2732> *native, NetPacket_Head<0x2732> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -918,7 +970,7 @@ bool network_to_native(SPacket_0x2732_Head *native, NetSPacket_0x2732_Head netwo return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2732_Repeat *network, SPacket_0x2732_Repeat native) +bool native_to_network(NetPacket_Repeat<0x2732> *network, Packet_Repeat<0x2732> native) { bool rv = true; rv &= native_to_network(&network->account_id, native.account_id); @@ -926,7 +978,7 @@ bool native_to_network(NetSPacket_0x2732_Repeat *network, SPacket_0x2732_Repeat return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2732_Repeat *native, NetSPacket_0x2732_Repeat network) +bool network_to_native(Packet_Repeat<0x2732> *native, NetPacket_Repeat<0x2732> network) { bool rv = true; rv &= network_to_native(&native->account_id, network.account_id); @@ -934,7 +986,7 @@ bool network_to_native(SPacket_0x2732_Repeat *native, NetSPacket_0x2732_Repeat n return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetRPacket_0x2740_Fixed *network, RPacket_0x2740_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2740> *network, Packet_Fixed<0x2740> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -944,7 +996,7 @@ bool native_to_network(NetRPacket_0x2740_Fixed *network, RPacket_0x2740_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(RPacket_0x2740_Fixed *native, NetRPacket_0x2740_Fixed network) +bool network_to_native(Packet_Fixed<0x2740> *native, NetPacket_Fixed<0x2740> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); @@ -954,7 +1006,7 @@ bool network_to_native(RPacket_0x2740_Fixed *native, NetRPacket_0x2740_Fixed net return rv; } inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x2741_Fixed *network, SPacket_0x2741_Fixed native) +bool native_to_network(NetPacket_Fixed<0x2741> *network, Packet_Fixed<0x2741> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -963,7 +1015,7 @@ bool native_to_network(NetSPacket_0x2741_Fixed *network, SPacket_0x2741_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x2741_Fixed *native, NetSPacket_0x2741_Fixed network) +bool network_to_native(Packet_Fixed<0x2741> *native, NetPacket_Fixed<0x2741> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); diff --git a/src/proto2/map-user.hpp b/src/proto2/map-user.hpp index 90102f7..4da94cf 100644 --- a/src/proto2/map-user.hpp +++ b/src/proto2/map-user.hpp @@ -27,11 +27,12 @@ // This is a public protocol, and changes require client cooperation -struct SPacket_0x0212_Fixed +template<> +struct Packet_Fixed<0x0212> { - using NetType = NetSPacket_0x0212_Fixed; static const uint16_t PACKET_ID = 0x0212; + // TODO remove this uint16_t magic_packet_id = PACKET_ID; BlockId npc_id = {}; uint16_t command = {}; @@ -40,7 +41,8 @@ struct SPacket_0x0212_Fixed uint16_t y = {}; }; -struct NetSPacket_0x0212_Fixed +template<> +struct NetPacket_Fixed<0x0212> { Little16 magic_packet_id; Little32 npc_id; @@ -49,16 +51,16 @@ struct NetSPacket_0x0212_Fixed Little16 x; Little16 y; }; -static_assert(offsetof(NetSPacket_0x0212_Fixed, magic_packet_id) == 0, "offsetof(NetSPacket_0x0212_Fixed, magic_packet_id) == 0"); -static_assert(offsetof(NetSPacket_0x0212_Fixed, npc_id) == 2, "offsetof(NetSPacket_0x0212_Fixed, npc_id) == 2"); -static_assert(offsetof(NetSPacket_0x0212_Fixed, command) == 6, "offsetof(NetSPacket_0x0212_Fixed, command) == 6"); -static_assert(offsetof(NetSPacket_0x0212_Fixed, id) == 8, "offsetof(NetSPacket_0x0212_Fixed, id) == 8"); -static_assert(offsetof(NetSPacket_0x0212_Fixed, x) == 12, "offsetof(NetSPacket_0x0212_Fixed, x) == 12"); -static_assert(offsetof(NetSPacket_0x0212_Fixed, y) == 14, "offsetof(NetSPacket_0x0212_Fixed, y) == 14"); -static_assert(sizeof(NetSPacket_0x0212_Fixed) == 16, "sizeof(NetSPacket_0x0212_Fixed) == 16"); +static_assert(offsetof(NetPacket_Fixed<0x0212>, magic_packet_id) == 0, "offsetof(NetPacket_Fixed<0x0212>, magic_packet_id) == 0"); +static_assert(offsetof(NetPacket_Fixed<0x0212>, npc_id) == 2, "offsetof(NetPacket_Fixed<0x0212>, npc_id) == 2"); +static_assert(offsetof(NetPacket_Fixed<0x0212>, command) == 6, "offsetof(NetPacket_Fixed<0x0212>, command) == 6"); +static_assert(offsetof(NetPacket_Fixed<0x0212>, id) == 8, "offsetof(NetPacket_Fixed<0x0212>, id) == 8"); +static_assert(offsetof(NetPacket_Fixed<0x0212>, x) == 12, "offsetof(NetPacket_Fixed<0x0212>, x) == 12"); +static_assert(offsetof(NetPacket_Fixed<0x0212>, y) == 14, "offsetof(NetPacket_Fixed<0x0212>, y) == 14"); +static_assert(sizeof(NetPacket_Fixed<0x0212>) == 16, "sizeof(NetPacket_Fixed<0x0212>) == 16"); inline __attribute__((warn_unused_result)) -bool native_to_network(NetSPacket_0x0212_Fixed *network, SPacket_0x0212_Fixed native) +bool native_to_network(NetPacket_Fixed<0x0212> *network, Packet_Fixed<0x0212> native) { bool rv = true; rv &= native_to_network(&network->magic_packet_id, native.magic_packet_id); @@ -70,7 +72,7 @@ bool native_to_network(NetSPacket_0x0212_Fixed *network, SPacket_0x0212_Fixed na return rv; } inline __attribute__((warn_unused_result)) -bool network_to_native(SPacket_0x0212_Fixed *native, NetSPacket_0x0212_Fixed network) +bool network_to_native(Packet_Fixed<0x0212> *native, NetPacket_Fixed<0x0212> network) { bool rv = true; rv &= network_to_native(&native->magic_packet_id, network.magic_packet_id); -- cgit v1.2.3-70-g09d2