• 119.网络游戏逆向分析与漏洞攻防-邮件系统数据分析-邮件读取与删除功能的封装

    免责声明：内容仅供学习参考，请合法利用知识，禁止进行违法犯罪活动！

    如果看不懂、不知道现在做的什么，那就跟着做完看效果，代码看不懂是正常的，只要会抄就行，抄着抄着就能懂了

    内容参考于：易道云信息技术研究院

    上一个内容：118.邮件管理的界面与功能设计

    码云版本号：e9ad9663fa9e1bdcfad1205763437677dda5b8b4

    代码下载地址，在 titan 目录下，文件名为：titan-邮件读取与删除功能的封装.zip

    链接：https://pan.baidu.com/s/1W-JpUcGOWbSJmMdmtMzYZg

    提取码：q9n5

    --来自百度网盘超级会员V4的分享

    HOOK引擎，文件名为：黑兔sdk升级版.zip

    链接：https://pan.baidu.com/s/1IB-Zs6hi3yU8LC2f-8hIEw

    提取码：78h8

    --来自百度网盘超级会员V4的分享

    以 118.邮件管理的界面与功能设计 它的代码为基础进行修改

    效果图：

    上一个内容把邮件的显示从接收的地方处理基本上是处理完了，接下来就是从发送的地方处理（比如邮件的读取、删除）

    首先在打开邮箱窗口的时候，如下图，会发送 350 0，接收两个15数据包，15数据包之前在背包物品分析的哪里知道15数据包是用来初始化一个背包结构的，所以邮箱也算一个背包，背包的编码23或25

    删除邮件发送了一个跟MD5码一样的东西

    这个码是value_12

    然后经过对比value_2表示是否度过邮件

    下图是一个未读的邮件

    已读

    是否系统邮件是value_4，101表示系统邮件，1表示普通邮件，为什么说value_4是表示系统邮件或者为什么value_?是什么什么，这都是通过多个数据包对比得出一个结果进行猜测的，就感觉它像

    上一个内容中有一个66，通过逆向分析看到66前面要加 ui_system_mail_source_ 这一段，如下图，打开邮箱再下断点，否则看不到下图的 ui_system_mail_source_66

    关闭邮箱窗口之前分析的是350 6、350 7、81 3，然后今天发现81 3发送的时机与350 6、350 7不一样（之前一样可能因为巧了），所以直接把81 3给排除了，关闭邮箱窗口是 350 6、350 7

    这里有一个350 7

    上图单个350 7是点击下图红框的关闭按钮触发的，所以350 6是关闭邮箱窗口，350 7是关闭打开邮件窗口

    付费邮件

    它有个350 10，它看着像是上图的邮件付费

    CWndMail.cpp文件的修改：修改了 OnBnClickedButton1函数

    1. // CWndMail.cpp: 实现文件
    2. //
    3.  
    4. #include "pch.h"
    5. #include "CWndMail.h"
    6. #include "afxdialogex.h"
    7. #include "resource.h"
    8. #include "CUI.h"
    9. #include "extern_all.h"
    10.  
    11. // CWndMail 对话框
    12.  
    13. IMPLEMENT_DYNAMIC(CWndMail, CDialogEx)
    14.  
    15. CWndMail::CWndMail(CWnd* pParent /*=nullptr*/)
    16. 	: CDialogEx(IDD_DIALOG2, pParent)
    17. {
    18.  
    19. }
    20.  
    21. CWndMail::~CWndMail()
    22. {
    23. }
    24.  
    25. void CWndMail::DoDataExchange(CDataExchange* pDX)
    26. {
    27. 	CDialogEx::DoDataExchange(pDX);
    28. 	DDX_Control(pDX, IDC_LIST3, lstA);
    29. }
    30.  
    31. BOOL CWndMail::OnInitDialog()
    32. {
    33. 	CDialogEx::OnInitDialog();
    34.  
    35. 	CUI* ui = (CUI*)Client;
    36. 	ui->SetListView(&lstA);
    37. 	lstA.InsertColumn(0, L"寄件人", 0, 130);
    38. 	lstA.InsertColumn(1, L"标题", 0, 130);
    39. 	lstA.InsertColumn(2, L"时间", 0, 130);
    40.  
    41. 	return TRUE;
    42. }
    43.  
    44.  
    45. BEGIN_MESSAGE_MAP(CWndMail, CDialogEx)
    46. 	ON_BN_CLICKED(IDC_BUTTON1, &CWndMail::OnBnClickedButton1)
    47. END_MESSAGE_MAP()
    48.  
    49.  
    50. // CWndMail 消息处理程序
    51.  
    52.  
    53. void CWndMail::OnBnClickedButton1()
    54. {
    55. 	lstA.DeleteAllItems();
    56. 	for (int i = 0; i < Client->Player.mailBox.size(); i++)
    57. 	{
    58. 		CString txt, sender, title;
    59. 		sender = Client->Player.mailBox[i]->sender;
    60. 		title = Client->Player.mailBox[i]->title;
    61. 		txt.Format(L"%s", Client->Player.mailBox[i]->title);
    62. 		if(Client->Player.mailBox[i]->type == 101){
    63. 			CStringA titleA,senderA;
    64. 			titleA = title;
    65. 			senderA = sender;
    66. 			senderA = "ui_system_mail_source_" + senderA;
    67. 			title = txtManger->ReadTextById(titleA.GetBuffer());
    68. 			sender = txtManger->ReadTextById(senderA.GetBuffer());
    69. 		}
    70. 		lstA.InsertItem(0, sender);
    71. 		lstA.SetItemText(0, 0, sender);
    72. 		lstA.SetItemText(0, 1, title);
    73. 		txt = Client->Player.mailBox[i]->szTime;
    74. 		lstA.SetItemText(0, 2, txt);
    75.  
    76. 	}
    77. }
    78.  
    79.

    NetClient.cpp文件的修改：新加 MailBox函数、OpenMailBox函数、CloseMailBox函数、Mail函数、MailEx函数、GetMail函数

    1. #include "pch.h"
    2. #include "NetClient.h"
    3. #include "extern_all.h"
    4.  
    5. bool NetClient::login(const char* Id, const char* Pass)
    6. {
    7.     
    8.   const int bufflen = sizeof(DATA_LOGIN) + 1;
    9.   char buff[bufflen];
    10.   DATA_LOGIN data;
    11.   // 有些操作系统这样写会报错，因为内存不对齐，现在Windows下没事
    12.   //PDATALOGIN _data = (PDATALOGIN)(buff + 1);
    13.   // 这样写就能解决内存对齐问题
    14.   PDATALOGIN _data =&data;
    15.   int len = strlen(Id);
    16.   memcpy(_data->Id, Id, len);
    17.   len = strlen(Pass);
    18.   memcpy(_data->Pass, Pass, len);
    19.   memcpy(buff+1, _data, sizeof(DATA_LOGIN));
    20.   buff[0] = I_LOGIN;
    21.   return  NetSend(buff, sizeof(buff));
    22.   
    23. }
    24.  
    25. bool NetClient::DelRole(const wchar_t* rolename)
    26. {
    27.     PROLEDATA _role = GetRoleByName(rolename);
    28.     if (_role == nullptr) {
    29.         return false;
    30.     }
    31.     else {
    32.         return DelRole(rolename, _role->name.lenth);
    33.     }
    34.     return false;
    35. }
    36.  
    37. bool NetClient::StartCreateRole()
    38. {
    39.     NET_CREATEROLE_START _data;
    40.     return NetSend(&_data.op, _data.len);
    41. }
    42.  
    43. bool NetClient::SelectCamp(const char* _campname)
    44. {
    45.     NET_SEND_BUFF _buff;
    46.     NET_SEND_CHOOSECAMP _data;
    47.     _data.opcode.Set(SC_CHOOSECAMP);
    48.     _data.camps.Set(_campname);
    49.     /* 
    50.         sizeof(_data) / sizeof(EnCode)的原因
    51.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    52.         全是 EnCode 这个结构
    53.     */
    54.     short count = sizeof(_data) / sizeof(EnCode);
    55.     _buff.count = count;
    56.  
    57.     /*
    58.         CodeMe函数给 _buff.buff里写数据参数的数据
    59.         也就是给0A开头数据包里写，数据参数个数后面的内容
    60.         然后返回值是写了多长的数据
    61.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    62.     */
    63.     int ilen = _data.CodeMe(count, _buff.buff);
    64.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    65.     return NetSend(&_buff.op, ilen);
    66. }
    67.  
    68. //性别 0 男 1 女
    69. //
    70. //阵营 1 艾森赫特 2 格兰蒂尔
    71. //
    72. //种族 1 布冯特人 3 格洛玛人 4 尤恩图人 6 喀什人
    73. //
    74. //职业 1 仲裁者 3秘法师 6 猎魔人 8 元素法师
    75. //
    76. //脸型 0 1 2 3
    77. bool NetClient::CreateRole(wchar_t* name, double sex, double camp, double race, double occu, const char* photo, const char* infos, const char* txt, double faceShape)
    78. {
    79.     // rolecount > 4说明角色的数量够了
    80.     if (rolecount > 4)return false;
    81.     int index = 0;
    82.     bool roleindex[5]{true, true, true, true, true };
    83.     for (int i = 0; i < rolecount; i++) {
    84.         roleindex[roles[i].index] = false;
    85.     }
    86.    
    87.     for (int i = 0; i < 5; i++)
    88.     {
    89.         if (roleindex[i]) {
    90.             index = i;
    91.             break;
    92.         }
    93.     }
    94.  
    95.     // wchar_t _name[] = L"am52111";
    96.     NS_CREATEROLE_HEAD_BUFF _buff;
    97.     CREATE_ROLE_DATAS _data;
    98.     _data.sex.Set(sex);
    99.     _data.camp.Set(camp);
    100.     _data.face.Set(race);
    101.     _data.occu.Set(occu);
    102.     _data.faceSahpe.Set(faceShape);
    103.     //_data.Photo.Set("gui\BG_team\TeamRole\Teamrole_zq_humF_001.PNG");
    104.     _data.Photo.Set(photo);
    105.     //_data.Infos.Set("Face,0;Hat,0;Eyes,0;Beard,0;Ears,0;Tail,0;Finger,0;Cloth,0;Pants,0;Gloves,0;Shoes,0;Trait,0;HairColor,0;SkinColor,0;SkinMtl,0;Tattoo,0;TattooColor,16777215;");
    106.     _data.Infos.Set(infos);
    107.     _data.Txt.Set(txt);
    108.     short count = sizeof(_data) / sizeof(EnCode);
    109.     _buff.count = count;
    110.     _buff.index = index;
    111.     int lenth = wcslen(name) + 1;
    112.     lenth = lenth * 2;
    113.     memcpy(_buff.name, name, lenth);
    114.     int ilen = _data.CodeMe(count, _buff.buff);
    115.     ilen = ilen + sizeof(NET_SEHD_CREATEROLE_HEAD) - 3;
    116.     return NetSend(&_buff.op, ilen);
    117. }
    118.  
    119. bool NetClient::SelectRole(const wchar_t* rolename)
    120. {
    121.     PROLEDATA roles = GetRoleByName(rolename);
    122.     if (roles == nullptr)return false;
    123.     NS_SELECTROLE _data;
    124.     memcpy(_data.buff, roles->name.value(), roles->name.lenth);
    125.     
    126.     return NetSend((char*)&_data, sizeof(_data));
    127. }
    128.  
    129. bool NetClient::Fall()
    130. {
    131.     NET_SEND_BUFF _buff;
    132.     FALL_DATA_STOP _data2;
    133.     _data2.opcode.Set(SC_FALL_HEADER);
    134.     _data2.Mode.Set(0x2);
    135.     _data2.StartH.Set(Player.h);
    136.     _data2.NextH.Set(Player.h - 12);
    137.     _data2.EndH.Set(Player.h - 120);
    138.     /*
    139.         sizeof(_data) / sizeof(EnCode)的原因
    140.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    141.         全是 EnCode 这个结构
    142.     */
    143.     short count = sizeof(_data2) / sizeof(EnCode);
    144.     _buff.count = count;
    145.  
    146.  
    147.     /*
    148.         CodeMe函数给 _buff.buff里写数据参数的数据
    149.         也就是给0A开头数据包里写，数据参数个数后面的内容
    150.         然后返回值是写了多长的数据
    151.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    152.     */
    153.     int ilen = _data2.CodeMe(count, _buff.buff);
    154.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    155.     return NetSend(&_buff.op, ilen);
    156.  
    157. }
    158.  
    159. void NetClient::Teleport(float x, float h, float y, float face)
    160. {
    161.     // 修正坐标
    162.      //PAIM aim = GetAimByName(L"r");
    163.      //if (aim == nullptr) {
    164.      //	return;
    165.      //}
    166.  
    167.      // 目的地坐标
    168.      //float decX = aim->x;
    169.      //float decH = aim->h;
    170.      //float decY = aim->y;
    171.  /*   float decX = 3843.776123f;
    172.     float decH = 11.731983f;
    173.     float decY = -2005.533813f;
    174.     float face = 0.0f;*/
    175.  
    176.     union {
    177.         unsigned nt = 0xFFC00000;
    178.         float fNan;
    179.     }v;
    180.     /*
    181.         这里的参数虽然都是无效值，但不见得就非要全部是无效值
    182.         可能只设置x坐标就可以，可能值设置y坐标就可以，可能要设置x、y坐标就可以。。。
    183.         现在全部设置成无效值了，如果游戏服务端有这个漏洞，我们角色的坐标就会
    184.         全部设置成无效值，然后按照逻辑来讲下一次设置坐标的函数可以任意修改
    185.         然后还可能有的游戏设置NaN不成功，这种的可以多试几个修改坐标或者其它数据的函数
    186.         如果还都不行那就没办法了
    187.     */
    188.     //MoveWJump(v.fNan, v.fNan, v.fNan, v.fNan, v.fNan, v.fNan, v.fNan); // 可以把坐标设置成nan
    189.     //MoveWalk(v.fNan, v.fNan, v.fNan, v.fNan, v.fNan, v.fNan, v.fNan); // 可以把坐标设置成nan
    190.     MoveStop(v.fNan, v.fNan, v.fNan, v.fNan); // 可以把坐标设置成nan
    191.     MoveStop(x, h, y, face);
    192.     // 利用修正坐标数据包瞬移
    193.     SetCoord(Player.lId, x, h, y, face);
    194. }
    195.  
    196. bool NetClient::MoveStop(float x, float h, float y, float face)
    197. {
    198.     NET_SEND_BUFF _buff;
    199.     MOVE_DATA_STOP _data;
    200.     _data.opcode.Set(SC_MOVE_HEADER);
    201.     _data.Mode.Set(0x0);
    202.     _data.Count.Set(4);
    203.     _data.x.Set(x);
    204.     _data.h.Set(h);
    205.     _data.y.Set(y);
    206.     _data.face.Set(face);
    207.     /*
    208.         sizeof(_data) / sizeof(EnCode)的原因
    209.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    210.         全是 EnCode 这个结构
    211.     */
    212.     short count = sizeof(_data) / sizeof(EnCode);
    213.     _buff.count = count;
    214.  
    215.  
    216.     /*
    217.         CodeMe函数给 _buff.buff里写数据参数的数据
    218.         也就是给0A开头数据包里写，数据参数个数后面的内容
    219.         然后返回值是写了多长的数据
    220.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    221.     */
    222.     int ilen = _data.CodeMe(count, _buff.buff);
    223.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    224.     return NetSend(&_buff.op, ilen);
    225. }
    226.  
    227. bool NetClient::MoveJump(float x, float h, float y, float face, float oldy, float xNext, float yNext)
    228. {
    229.     NET_SEND_BUFF _buff;
    230.     MOVE_DATA_JUMP _data;
    231.     _data.opcode.Set(SC_MOVE_HEADER);
    232.     _data.Mode.Set(0x2);
    233.     _data.Count.Set(9);
    234.     _data.x.Set(x);
    235.     _data.h.Set(h);
    236.     _data.y.Set(y);
    237.  
    238.     _data.xNext.Set(xNext);
    239.     _data.yNext.Set(yNext);
    240.     _data.MoveSpeed.Set(Player.MoveSpeed);
    241.     _data.JumpSpeed.Set(Player.JumpSpeed);
    242.     _data.GSpeed.Set(0.0f);
    243.     _data.face.Set(face);
    244.  
    245.     /*
    246.         sizeof(_data) / sizeof(EnCode)的原因
    247.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    248.         全是 EnCode 这个结构
    249.     */
    250.     short count = sizeof(_data) / sizeof(EnCode);
    251.     _buff.count = count;
    252.  
    253.  
    254.     /*
    255.         CodeMe函数给 _buff.buff里写数据参数的数据
    256.         也就是给0A开头数据包里写，数据参数个数后面的内容
    257.         然后返回值是写了多长的数据
    258.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    259.     */
    260.     int ilen = _data.CodeMe(count, _buff.buff);
    261.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    262.     return NetSend(&_buff.op, ilen);
    263. }
    264.  
    265. bool NetClient::MoveWalk(float x, float h, float y, float face, float oldy, float xNext, float yNext)
    266. {
    267.     NET_SEND_BUFF _buff;
    268.     MOVE_DATA_WALK _data;
    269.     _data.opcode.Set(SC_MOVE_HEADER);
    270.     _data.Mode.Set(0x1);
    271.     _data.Count.Set(8);
    272.     _data.x.Set(x);
    273.     _data.h.Set(h);
    274.     _data.y.Set(y);
    275.  
    276.     _data.xNext.Set(xNext);
    277.     _data.yNext.Set(yNext);
    278.     _data.MoveSpeed.Set(Player.MoveSpeed);
    279.     _data.GSpeed.Set(0.0f);
    280.     _data.face.Set(face);
    281.  
    282.     /*
    283.         sizeof(_data) / sizeof(EnCode)的原因
    284.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    285.         全是 EnCode 这个结构
    286.     */
    287.     short count = sizeof(_data) / sizeof(EnCode);
    288.     _buff.count = count;
    289.  
    290.  
    291.     /*
    292.         CodeMe函数给 _buff.buff里写数据参数的数据
    293.         也就是给0A开头数据包里写，数据参数个数后面的内容
    294.         然后返回值是写了多长的数据
    295.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    296.     */
    297.     int ilen = _data.CodeMe(count, _buff.buff);
    298.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    299.     return NetSend(&_buff.op, ilen);
    300. }
    301.  
    302. bool NetClient::MoveWJump(float x, float h, float y, float face, float oldy, float xNext, float yNext)
    303. {
    304.     NET_SEND_BUFF _buff;
    305.     MOVE_DATA_WJUMP _data;
    306.     _data.opcode.Set(SC_MOVE_HEADER);
    307.     _data.Mode.Set(0x3);
    308.     _data.Count.Set(7);
    309.     _data.x.Set(x);
    310.     _data.h.Set(h);
    311.     _data.y.Set(y);
    312.  
    313.     _data.xNext.Set(xNext);
    314.     _data.yNext.Set(yNext);
    315.     _data.MoveSpeed.Set(Player.MoveSpeed);
    316.     _data.face.Set(face);
    317.  
    318.     /*
    319.         sizeof(_data) / sizeof(EnCode)的原因
    320.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    321.         全是 EnCode 这个结构
    322.     */
    323.     short count = sizeof(_data) / sizeof(EnCode);
    324.     _buff.count = count;
    325.  
    326.  
    327.     /*
    328.         CodeMe函数给 _buff.buff里写数据参数的数据
    329.         也就是给0A开头数据包里写，数据参数个数后面的内容
    330.         然后返回值是写了多长的数据
    331.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    332.     */
    333.     int ilen = _data.CodeMe(count, _buff.buff);
    334.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    335.     return NetSend(&_buff.op, ilen);
    336. }
    337.  
    338. bool NetClient::UseSkill(const char* _skillName, float x, float h, float y, float face, float xTarget, float hTarget, float yTarget, int rInt1, int rInt2, int rInt3)
    339. {
    340.     NET_SEND_BUFF _buff;
    341.     USESKILL_DATA _data;
    342.     _data.opcode.Set(SC_USESKILL);
    343.     _data.skillName.Set(_skillName);
    344.     _data.x.Set(x);
    345.     _data.h.Set(h);
    346.     _data.y.Set(y);
    347.     _data.xTarget.Set(xTarget);
    348.     _data.hTarget.Set(hTarget);
    349.     _data.yTarget.Set(yTarget);
    350.     _data.un0.Set(rInt1);
    351.     _data.un1.Set(rInt2);
    352.     _data.un2.Set(rInt3);
    353.     //_data.face.Set(face);
    354.     _data.face.Set(0);
    355.  
    356.     /*
    357.         sizeof(_data) / sizeof(EnCode)的原因
    358.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    359.         全是 EnCode 这个结构
    360.     */
    361.     short count = sizeof(_data) / sizeof(EnCode);
    362.     _buff.count = count;
    363.  
    364.  
    365.     /*
    366.         CodeMe函数给 _buff.buff里写数据参数的数据
    367.         也就是给0A开头数据包里写，数据参数个数后面的内容
    368.         然后返回值是写了多长的数据
    369.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    370.     */
    371.     int ilen = _data.CodeMe(count, _buff.buff);
    372.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    373.     return NetSend(&_buff.op, ilen);
    374. }
    375.  
    376. bool NetClient::UseItem(short BagIndex, short Index)
    377. {
    378.     NET_SEND_BUFF _buff;
    379.     ITEM_USE_DATA _data;
    380.     _data.opcode.Set(SC_ITEM_USE);
    381.     _data.MainIndex.Set(BagIndex);
    382.     _data.Index.Set(Index);
    383.  
    384.     /*
    385.         sizeof(_data) / sizeof(EnCode)的原因
    386.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    387.         全是 EnCode 这个结构
    388.     */
    389.     short count = sizeof(_data) / sizeof(EnCode);
    390.     _buff.count = count;
    391.  
    392.  
    393.     /*
    394.         CodeMe函数给 _buff.buff里写数据参数的数据
    395.         也就是给0A开头数据包里写，数据参数个数后面的内容
    396.         然后返回值是写了多长的数据
    397.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    398.     */
    399.     int ilen = _data.CodeMe(count, _buff.buff);
    400.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    401.     return NetSend(&_buff.op, ilen);
    402. }
    403.  
    404. bool NetClient::ExChangeItem(short BagIndex, short Index, short tBagindex, short tIndex, bool IsEmpty)
    405. {
    406.     NET_SEND_BUFF _buff;
    407.     ITEM_EXCHANGE_DATA _data;
    408.  
    409.     if(IsEmpty)
    410.         _data.opcode.Set(SC_ITEM_EXCHANGE);
    411.     else
    412.         _data.opcode.Set(SC_ITEM_EXCHANGEEX);
    413.  
    414.     _data.MainIndex.Set(BagIndex);
    415.     _data.Index.Set(Index);
    416.     _data.TargetId.Set(tBagindex);
    417.     _data.TargetIndex.Set(tIndex);
    418.  
    419.     /*
    420.         sizeof(_data) / sizeof(EnCode)的原因
    421.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    422.         全是 EnCode 这个结构
    423.     */
    424.     short count = sizeof(_data) / sizeof(EnCode);
    425.     _buff.count = count;
    426.  
    427.  
    428.     /*
    429.         CodeMe函数给 _buff.buff里写数据参数的数据
    430.         也就是给0A开头数据包里写，数据参数个数后面的内容
    431.         然后返回值是写了多长的数据
    432.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    433.     */
    434.     int ilen = _data.CodeMe(count, _buff.buff);
    435.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    436.     return NetSend(&_buff.op, ilen);
    437. }
    438.  
    439. bool NetClient::DropItem(short BagIndex, short Index, short Amount)
    440. {
    441.     NET_SEND_BUFF _buff;
    442.     ITEM_DROP_DATA _data;
    443.     _data.opcode.Set(SC_ITEM_DROP);
    444.     _data.MainIndex.Set(BagIndex);
    445.     _data.Index.Set(Index);
    446.     _data.Amount.Set(Amount);
    447.  
    448.     /*
    449.         sizeof(_data) / sizeof(EnCode)的原因
    450.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    451.         全是 EnCode 这个结构
    452.     */
    453.     short count = sizeof(_data) / sizeof(EnCode);
    454.     _buff.count = count;
    455.  
    456.  
    457.     /*
    458.         CodeMe函数给 _buff.buff里写数据参数的数据
    459.         也就是给0A开头数据包里写，数据参数个数后面的内容
    460.         然后返回值是写了多长的数据
    461.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    462.     */
    463.     int ilen = _data.CodeMe(count, _buff.buff);
    464.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    465.     return NetSend(&_buff.op, ilen);
    466. }
    467.  
    468. bool NetClient::SplitItem(short BagIndex, short Index, short tBagindex, short tIndex, short Amount)
    469. {
    470.     NET_SEND_BUFF _buff;
    471.     ITEM_SPLIT_DATA _data;
    472.     _data.opcode.Set(SC_ITEM_SPLIT);
    473.  
    474.     _data.MainIndex.Set(BagIndex);
    475.     _data.Index.Set(Index);
    476.     _data.TargetId.Set(tBagindex);
    477.     _data.TargetIndex.Set(tIndex);
    478.     _data.TargetAmount.Set(Amount);
    479.     /*
    480.         sizeof(_data) / sizeof(EnCode)的原因
    481.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    482.         全是 EnCode 这个结构
    483.     */
    484.     short count = sizeof(_data) / sizeof(EnCode);
    485.     _buff.count = count;
    486.  
    487.  
    488.     /*
    489.         CodeMe函数给 _buff.buff里写数据参数的数据
    490.         也就是给0A开头数据包里写，数据参数个数后面的内容
    491.         然后返回值是写了多长的数据
    492.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    493.     */
    494.     int ilen = _data.CodeMe(count, _buff.buff);
    495.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    496.     return NetSend(&_buff.op, ilen);
    497. }
    498.  
    499. bool NetClient::Mount(short Index)
    500. {
    501.     NET_SEND_BUFF _buff;
    502.     MOUNT_DATA _data;
    503.     _data.opcode.Set(SC_MOUNT);
    504.     _data.Index.Set(Index);
    505.  
    506.     /*
    507.         sizeof(_data) / sizeof(EnCode)的原因
    508.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    509.         全是 EnCode 这个结构
    510.     */
    511.     short count = sizeof(_data) / sizeof(EnCode);
    512.     _buff.count = count;
    513.  
    514.  
    515.     /*
    516.         CodeMe函数给 _buff.buff里写数据参数的数据
    517.         也就是给0A开头数据包里写，数据参数个数后面的内容
    518.         然后返回值是写了多长的数据
    519.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    520.     */
    521.     int ilen = _data.CodeMe(count, _buff.buff);
    522.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    523.     return NetSend(&_buff.op, ilen);
    524. }
    525.  
    526. PROLEDATA NetClient::GetRoleByName(const wchar_t* rolename)
    527. {
    528.     //PROLEDATA result = nullptr;
    529.     for (int i = 0; i < rolecount; i++)
    530.     {
    531.         // StrCmpW判断两个字符串是否相同
    532.         // 比较时区分大小写，如果字符串相同返回0
    533.         if (StrCmpW(roles[i].name.value(), rolename) == 0) {
    534.             return &roles[i];
    535.         }
    536.  
    537.     }
    538.     return nullptr;
    539. }
    540.  
    541. bool NetClient::PickItem(short id, short Index)
    542. {
    543.     NET_SEND_BUFF _buff;
    544.     ITEM_PICK_DATA _data;
    545.     _data.opcode.Set(id);
    546.     _data.Index.Set(Index);
    547.  
    548.     /*
    549.         sizeof(_data) / sizeof(EnCode)的原因
    550.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    551.         全是 EnCode 这个结构
    552.     */
    553.     short count = sizeof(_data) / sizeof(EnCode);
    554.     _buff.count = count;
    555.  
    556.  
    557.     /*
    558.         CodeMe函数给 _buff.buff里写数据参数的数据
    559.         也就是给0A开头数据包里写，数据参数个数后面的内容
    560.         然后返回值是写了多长的数据
    561.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    562.     */
    563.     int ilen = _data.CodeMe(count, _buff.buff);
    564.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    565.     return NetSend(&_buff.op, ilen);
    566. }
    567.  
    568. bool NetClient::Talk(wchar_t* txt, int PdId, double un)
    569. {
    570.     NET_SEND_BUFF _buff;
    571.     CHAT_PUBLIC _data;
    572.     _data.opcode.Set(SC_CHAT);
    573.     _data.ChartId.Set(PdId);
    574.     _data.txt.Set(txt);
    575.     _data.un.Set(un);
    576.     /*
    577.         sizeof(_data) / sizeof(EnCode)的原因
    578.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    579.         全是 EnCode 这个结构
    580.     */
    581.     short count = sizeof(_data) / sizeof(EnCode);
    582.     _buff.count = count;
    583.  
    584.     /*
    585.         CodeMe函数给 _buff.buff里写数据参数的数据
    586.         也就是给0A开头数据包里写，数据参数个数后面的内容
    587.         然后返回值是写了多长的数据
    588.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    589.     */
    590.     int ilen = _data.CodeMe(count, _buff.buff);
    591.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    592.     return NetSend(&_buff.op, ilen);
    593. }
    594.  
    595. bool NetClient::TalkTo(wchar_t* name, wchar_t* txt, double un)
    596. {
    597.     NET_SEND_BUFF _buff;
    598.     CHAT_PRIVATE _data;
    599.     _data.opcode.Set(SC_CHAT);
    600.     _data.ChartId.Set(3);
    601.     _data.txt.Set(txt);
    602.     _data.name.Set(name);
    603.     _data.un.Set(un);
    604.     /*
    605.         sizeof(_data) / sizeof(EnCode)的原因
    606.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    607.         全是 EnCode 这个结构
    608.     */
    609.     short count = sizeof(_data) / sizeof(EnCode);
    610.     _buff.count = count;
    611.  
    612.     /*
    613.         CodeMe函数给 _buff.buff里写数据参数的数据
    614.         也就是给0A开头数据包里写，数据参数个数后面的内容
    615.         然后返回值是写了多长的数据
    616.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    617.     */
    618.     int ilen = _data.CodeMe(count, _buff.buff);
    619.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    620.     return NetSend(&_buff.op, ilen);
    621. }
    622.  
    623. bool NetClient::HeartBeep()
    624. {
    625.     NET_SEND_BUFF _buff;
    626.     HEART_BEEP _data;
    627.     _data.opcode.Set(SC_BEEP);
    628.     _data.tick.Set(3);
    629.     /*
    630.         sizeof(_data) / sizeof(EnCode)的原因
    631.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    632.         全是 EnCode 这个结构
    633.     */
    634.     short count = sizeof(_data) / sizeof(EnCode);
    635.     _buff.count = count;
    636.  
    637.     /*
    638.         CodeMe函数给 _buff.buff里写数据参数的数据
    639.         也就是给0A开头数据包里写，数据参数个数后面的内容
    640.         然后返回值是写了多长的数据
    641.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    642.     */
    643.     int ilen = _data.CodeMe(count, _buff.buff);
    644.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    645.     return NetSend(&_buff.op, ilen);
    646. }
    647.  
    648. bool NetClient::BuyItem(int shopPage, int shopIndex, int itemIndex, int Amount)
    649. {
    650.     NET_SEND_BUFF _buff;
    651.     ITEM_BUY_DATA _data;
    652.     const char* shopId;
    653.     auto _object = Client->GetGameOBJECTUnion((short)OBJECT_TYPE::Shop);
    654.     if ((_object) && (_object->item)) {
    655.         shopId = _object->item[0]->ShopID.GetBuffer();
    656.     }
    657.     else return false;
    658.  
    659.     _data.opcode.Set(SC_ITEM_SHOP);
    660.     _data.opMode.Set(SC_ITEM_SHOP_BUY);
    661.     _data.ShopId.Set(shopId);
    662.     _data.ShopPage.Set(shopPage);
    663.     _data.ShopIndex.Set(shopIndex);
    664.     _data.Index.Set(itemIndex);
    665.     _data.Amount.Set(Amount);
    666.     _data.un1.Set(0);
    667.     _data.un2.Set(0);
    668.  
    669.     /*
    670.         sizeof(_data) / sizeof(EnCode)的原因
    671.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    672.         全是 EnCode 这个结构
    673.     */
    674.     short count = sizeof(_data) / sizeof(EnCode);
    675.     _buff.count = count;
    676.  
    677.     /*
    678.         CodeMe函数给 _buff.buff里写数据参数的数据
    679.         也就是给0A开头数据包里写，数据参数个数后面的内容
    680.         然后返回值是写了多长的数据
    681.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    682.     */
    683.     int ilen = _data.CodeMe(count, _buff.buff);
    684.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    685.     return NetSend(&_buff.op, ilen);
    686. }
    687.  
    688. bool NetClient::HeartLoop()
    689. {
    690.     NET_SEND_BUFF _buff;
    691.     HEART_LOOP _data;
    692.     _data.opcode.Set(SC_LOOP);
    693.     _data.tick.Set(GetTickCount64());
    694.     _data.txt.Set("");
    695.     /*
    696.         sizeof(_data) / sizeof(EnCode)的原因
    697.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    698.         全是 EnCode 这个结构
    699.     */
    700.     short count = sizeof(_data) / sizeof(EnCode);
    701.     _buff.count = count;
    702.  
    703.     /*
    704.         CodeMe函数给 _buff.buff里写数据参数的数据
    705.         也就是给0A开头数据包里写，数据参数个数后面的内容
    706.         然后返回值是写了多长的数据
    707.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    708.     */
    709.     int ilen = _data.CodeMe(count, _buff.buff);
    710.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    711.     return NetSend(&_buff.op, ilen);
    712. }
    713.  
    714. bool NetClient::Backtoroles()
    715. {
    716.     // 返回角色
    717.     NET_SEND_BUFF _buff;
    718.     NSR_CHEAD _data;
    719.     _data.opcode.Set(SC_REONLINE);
    720.  
    721.     /*
    722.         sizeof(_data) / sizeof(EnCode)的原因
    723.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    724.         全是 EnCode 这个结构
    725.     */
    726.     short count = sizeof(_data) / sizeof(EnCode);
    727.     _buff.count = count;
    728.  
    729.     /*
    730.         CodeMe函数给 _buff.buff里写数据参数的数据
    731.         也就是给0A开头数据包里写，数据参数个数后面的内容
    732.         然后返回值是写了多长的数据
    733.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    734.     */
    735.     int ilen = _data.CodeMe(count, _buff.buff);
    736.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    737.     return NetSend(&_buff.op, ilen);
    738. }
    739.  
    740. bool NetClient::SoldItem(int MainIndex, int Index, int Amount)
    741. {
    742.     NET_SEND_BUFF _buff;
    743.     ITEM_SOLD_DATA _data;
    744.  
    745.     const char* shopId;
    746.     auto _object = GetGameOBJECTUnion((short)OBJECT_TYPE::Shop);
    747.     if ((_object) && (_object->item)) {
    748.         shopId = _object->item[0]->ShopID.GetBuffer();
    749.     }
    750.     else return false;
    751.  
    752.     _data.opcode.Set(SC_ITEM_SHOP);
    753.     _data.opMode.Set(SC_ITEM_SHOP_SOLD);
    754.     _data.un1.Set(0);
    755.     _data.ShopId.Set(shopId);
    756.     _data.MainIndex.Set(MainIndex);
    757.     _data.Index.Set(Index);
    758.     _data.Amount.Set(Amount);
    759.  
    760.     /*
    761.         sizeof(_data) / sizeof(EnCode)的原因
    762.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    763.         全是 EnCode 这个结构
    764.     */
    765.     short count = sizeof(_data) / sizeof(EnCode);
    766.     _buff.count = count;
    767.  
    768.     /*
    769.         CodeMe函数给 _buff.buff里写数据参数的数据
    770.         也就是给0A开头数据包里写，数据参数个数后面的内容
    771.         然后返回值是写了多长的数据
    772.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    773.     */
    774.     int ilen = _data.CodeMe(count, _buff.buff);
    775.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    776.     return NetSend(&_buff.op, ilen);
    777. }
    778.  
    779. bool NetClient::DelRole(const wchar_t* rolename, unsigned _len)
    780. {
    781.     DATA_DELROLE _data;
    782.     _data.op = 0x06;
    783.     _data.len = _len;
    784.     memcpy(_data.buff, rolename, _len);
    785.     return NetSend((char*)&_data, sizeof(DATA_DELROLE) - 1);
    786. }
    787.  
    788. PAIM NetClient::GetAimById(long long lId)
    789. {
    790.     if (Player.lId == 0)return &Player;// 我们玩家的数据未初始化其它的也不能初始化
    791.     if (Player.lId == lId)return &Player;
    792.     for (int i = 0; i < MAX_AIM; i++)
    793.     {
    794.         if ((Aimlst[i] != nullptr) && (Aimlst[i]->lId == lId)) {
    795.             return Aimlst[i];
    796.         }
    797.     }
    798.     return CreateAim(lId);
    799. }
    800.  
    801. PAIM NetClient::CreateAim(long long lId)
    802. {
    803.     for (int i = 0; i < MAX_AIM; i++)
    804.     {
    805.         if (Aimlst[i] == nullptr) {
    806.             Aimlst[i] = new AIM();
    807.             Aimlst[i]->lId = lId;
    808.             return Aimlst[i];
    809.         }
    810.         else if (Aimlst[i]->Isfree) {
    811.             Aimlst[i]->lId = lId;
    812.             return Aimlst[i];
    813.         }
    814.     }
    815.     return nullptr;
    816. }
    817.  
    818. void NetClient::RemoveAimById(long long lId)
    819. {
    820.     for (int i = 0; i < MAX_AIM; i++)
    821.     {
    822.         if ((Aimlst[i] != nullptr) && (Aimlst[i]->lId == lId)) {
    823.             // CString _txt;
    824.             // _txt.Format(L"附近的 %s 消失", Aimlst[i]->Name);
    825.             // AfxMessageBox(_txt);
    826.             Aimlst[i]->Release();
    827.         }
    828.     }
    829. }
    830.  
    831. POBJECT_UNION NetClient::GetGameOBJECTUnion(short MainIndex)
    832. {
    833.     switch (MainIndex)
    834.     {
    835.     case 1:
    836.         return &Equip;
    837.     case 2:
    838.         return &Item;
    839.     case 3:
    840.         return &ItemEx;
    841.     case 8:
    842.         return &MountBag;
    843.     case 0x28:
    844.         return &Skill;
    845.     case 0x3D:
    846.         return &Shop;
    847.     case 0x50:
    848.         return &Pickup;
    849.     }
    850.     return nullptr;
    851. }
    852.  
    853. POBJECTBASE NetClient::GetGameOBJECT(short MainIndex, short Index)
    854. {
    855.     POBJECT_UNION _objectTable = GetGameOBJECTUnion(MainIndex);
    856.  
    857.     if (_objectTable) {
    858.         return _objectTable->item[Index];
    859.     }
    860.     return nullptr;
    861. }
    862.  
    863. POBJECTBASE NetClient::ReSetGameOBJECT(short MainIndex, short max)
    864. {
    865.     max = max + 1;
    866.     POBJECT_UNION _objectTable = GetGameOBJECTUnion(MainIndex);
    867.  
    868.     if (_objectTable) {
    869.         _objectTable->Count = max;
    870.         if (_objectTable->item) {
    871.             if (max > _objectTable->MaxCount) {
    872.                 if (MainIndex == 0x28) {
    873.                     delete[] _objectTable->skill;
    874.                     delete[] _objectTable->skillAry;
    875.                 }
    876.                 else {
    877.                     delete[] _objectTable->item;
    878.                     delete[] _objectTable->itemAry;
    879.                 }
    880.             }
    881.             else {
    882.               
    883.                 for (int i = 0; i < _objectTable->MaxCount; i++)
    884.                 {
    885.                     _objectTable->item[i]->Isfree = true;
    886.                 }
    887.                 return  _objectTable->item[0];
    888.             }
    889.         }else   _objectTable->MaxCount = max;
    890.  
    891.         if (MainIndex == 0x28) {
    892.             _objectTable->skill = new PSKILL[max];
    893.             _objectTable->skillAry = new SKILL[max];
    894.             for (int i = 0; i < max; i++) _objectTable->skill[i] = &_objectTable->skillAry[i];
    895.         }
    896.         else {
    897.             _objectTable->item = new PITEM[max];
    898.             _objectTable->itemAry = new ITEM[max];
    899.             for (int i = 0; i < max; i++) _objectTable->item[i] = &_objectTable->itemAry[i];
    900.         }
    901.  
    902.         return  _objectTable->item[0];
    903.     }
    904.  
    905.     return nullptr;
    906. }
    907.  
    908. void NetClient::ExChangeOBJECT(short MainIndex, short IndexFrom, short IndexTo)
    909. {
    910.     POBJECT_UNION _objectTable = GetGameOBJECTUnion(MainIndex);
    911.     if (_objectTable) {
    912.         POBJECTBASE* _base = _objectTable->item;
    913.         POBJECTBASE _tmp = _base[IndexFrom];
    914.         _base[IndexFrom] = _base[IndexTo];
    915.         _base[IndexTo] = _tmp;
    916.     }
    917. }
    918.  
    919. void NetClient::DestoryOBJECT(short MainIndex, short Index)
    920. {
    921.     POBJECTBASE base = GetGameOBJECT(MainIndex, Index);
    922.     if (base)base->Isfree = true;
    923. }
    924.  
    925. PAIM NetClient::GetAimByName(const wchar_t* name)
    926. {
    927.     for (int i = 0; i < MAX_AIM; i++)
    928.     {
    929.         if ((Aimlst[i] != nullptr) && (!Aimlst[i]->Isfree) && (Aimlst[i]->Name == name)) {
    930.             return Aimlst[i];
    931.         }
    932.     }
    933.     return nullptr;
    934. }
    935.  
    936. // x,y是玩家的坐标，targetX,targetY是目标的坐标
    937. float NetClient::GetFace(float x, float y, float targetX, float targetY)
    938. {
    939.     // 计算差值
    940.     x = targetX - x;
    941.     y = targetY - y;
    942.     double pi = 3.14159265358979323846;
    943.  
    944.     double p = atan2(x, y); // atan2是计算三角形弧度atan2函数返回值-pi ~ pi，负的3.1415926...到正的3.1415926...
    945.     
    946.     // 如果x是负数atan2函数返回值必定是在三四象限里，也就是一个负π
    947.     if (x < 0) {
    948.         p = pi * 2 + p;
    949.     }
    950.     return p;
    951. }
    952.  
    953. void NetClient::FaceTo(const wchar_t* name)
    954. {
    955.     PAIM _aim = GetAimByName(name);
    956.     if (_aim) {
    957.         float _face = GetFace(Player.x, Player.y, _aim->x, _aim->y);
    958.         MoveStop(Player.x, Player.h, Player.y, _face);
    959.     }
    960. }
    961.  
    962. void NetClient::Init(PNetOperation _send, PNetOperation _recv)
    963. {
    964.     NetSend = _send;
    965.     NetRecv = _recv;
    966.  
    967.     for (int i = 0; i < 0x100; i++) {
    968.         SendProc[i] = &NetClient::DefaultProc;
    969.         RecvProc[i] = &NetClient::DefaultProc;
    970.     }
    971.     // 注册登录数据包处理函数
    972.     SendProc[I_LOGIN] = &NetClient::OnClientlogin;
    973.     SendProc[I_CREATEROLE_START] = &NetClient::OnClientStartCreateRole;
    974.     SendProc[I_DELROLE] = &NetClient::OnClientDelRole;
    975.     SendProc[I_SEND_CUSTOM] = &NetClient::OnClientSendCustom;
    976.     SendProc[I_CREATEROLE] = &NetClient::OnClientCreateRole;
    977.     SendProc[I_SELECT_ROLE] = &NetClient::OnClientSelectRole;
    978.     // 注册数据登录失败数据包处理函数
    979.     RecvProc[S_TIPS] = &NetClient::OnSvrTips;
    980.     RecvProc[S_LOGINOK] = &NetClient::OnSvrloginOk;
    981.     RecvProc[S_CREATEROLE_START] = &NetClient::OnSvrStartCreateRole;
    982.     RecvProc[S_NOTICE] = &NetClient::OnSverNotice;
    983.     RecvProc[S_NOTICE_COM] = &NetClient::OnSverNotice;
    984.     RecvProc[S_OBJECT] = &NetClient::OnSverObject;
    985.     RecvProc[S_STRUCT] = &NetClient::OnSverStruct;
    986.     RecvProc[S_OBJECT_INIT] = &NetClient::OnSvrObjectInit;
    987.     RecvProc[S_OBJECT_INITEX] = &NetClient::OnSvrObjectInitEx;
    988.     RecvProc[S_OBJECT_INITEX_UCOM] = &NetClient::OnSvrObjectInitEx;
    989.     RecvProc[S_UPDATECORD] = &NetClient::OnSvrUpdateCord;
    990.     RecvProc[S_UPDATEPRO] = &NetClient::OnSvrUpdateProperty;
    991.     RecvProc[S_UPDATEPROMU] = &NetClient::OnSvrUpdatePropertyMu;
    992.     RecvProc[S_UPDATEPROMU_COM] = &NetClient::OnSvrUpdatePropertyMu;
    993.     RecvProc[S_OBJECT_REMOVE] = &NetClient::OnSvrRemoveObjectMu;
    994.     RecvProc[S_UPDATECORDEX] = &NetClient::OnSvrUpdateCordEx;
    995.     RecvProc[S_GAMEBASE] = &NetClient::OnSvrGameBase;
    996.     RecvProc[S_GAMEBASE_RESET] = &NetClient::OnSvrGameBaseReset;
    997.     RecvProc[S_GAMEBASE_EXCHANGE] = &NetClient::OnSvrGameBaseExChange;
    998.     RecvProc[S_GAMEBASE_DROP] = &NetClient::OnSvrGameBaseDestroy;
    999.     RecvProc[S_GAMEBASE_SET] = &NetClient::OnSvrGameBaseSet;
    1000.     RecvProc[S_STRUCT_INIT] = &NetClient::OnSvrStructInit;
    1001.     RecvProc[S_STRUCT_INITEX] = &NetClient::OnSvrStructInit;
    1002.     RecvProc[S_STRUCT_CLEAR] = &NetClient::OnSvrStructClear;
    1003.     RecvProc[S_STRUCT_DELETE] = &NetClient::OnSvrStructDelete;
    1004.     RecvProc[S_STRUCT_UPDATE] = &NetClient::OnSvrStructUpdate;
    1005. }
    1006.  
    1007. bool NetClient::SetCoord(long long lId, float x, float h, float y, float face)
    1008. {
    1009.     NR_UPDATECOORD head;
    1010.     head.lId = lId;
    1011.     head.x = x;
    1012.     head.h = h;
    1013.     head.y = y;
    1014.     head.face = face;
    1015.     return NetRecv(&head.op, head.len);
    1016. }
    1017.  
    1018. bool NetClient::SetProperty(long long lId, int ProType, void* value)
    1019. {
    1020.     NR_OBJECT_UPDATEPRO head;
    1021.     head.lId = lId;
    1022.     head.itype = ProType;
    1023.  
    1024.     int valueType = ObjectTable[ProType].type;
    1025.     int valueSize = data_desc[2][valueType].lenth;
    1026.     int bufflen = 14;
    1027.     switch (valueType)
    1028.     {
    1029.         case 1:
    1030.         case 2:
    1031.         case 3:
    1032.         case 4:
    1033.         case 5:
    1034.         case 6:
    1035.         case 9:
    1036.             memcpy(head.buff, value, valueSize);
    1037.             bufflen = bufflen + valueSize;
    1038.             break;
    1039.         case 7:
    1040.             head.lenth = strlen((char*)value) + 1;
    1041.             memcpy(head.buffEnd, value, head.lenth);
    1042.             bufflen = bufflen + 4 + head.lenth;
    1043.             break;
    1044.         case 8:
    1045.             head.lenth = wcslen((wchar_t*)value) + 1;
    1046.             head.lenth = head.lenth + 2;
    1047.             memcpy(head.buffEnd, value, head.lenth);
    1048.             bufflen = bufflen + 4 + head.lenth;
    1049.             break;
    1050.     default:
    1051.         break;
    1052.     }
    1053.  
    1054.     return NetRecv(&head.op, bufflen);
    1055. }
    1056.  
    1057. bool NetClient::OnDelRole(wchar_t* rolename, unsigned _len)
    1058. {
    1059.     // AfxMessageBox(rolename);
    1060.     return true;
    1061. }
    1062.  
    1063. void NetClient::Onlogin(const char* Id, const char* Pass)
    1064. {
    1065.     
    1066.     /*
    1067.     const int bufflen = sizeof(DATA_LOGIN) + 1;
    1068.     char buff[bufflen];
    1069.     DATA_LOGIN data;
    1070.     // 有些操作系统这样写会报错，因为内存不对齐，现在Windows下没事
    1071.     //PDATALOGIN _data = (PDATALOGIN)(buff + 1);
    1072.     // 这样写就能解决内存对齐问题
    1073.     PDATALOGIN _data =&data;
    1074.     int len = strlen(Id);
    1075.     memcpy(_data->Id, Id, len);
    1076.     len = strlen(Pass);
    1077.     memcpy(_data->Pass, Pass, len);
    1078.     memcpy(buff+1, _data, sizeof(DATA_LOGIN));
    1079.     buff[0] = I_LOGIN;
    1080.     return  NetSend(buff, sizeof(buff));
    1081.     */
    1082. }
    1083.  
    1084. bool NetClient::OnStartCreateRole(int code)
    1085. {
    1086.     return true;
    1087. }
    1088.  
    1089. bool NetClient::OnCreateRole(PNS_CREATEROLE _header, PCREATE_ROLE_DATAS _body)
    1090. {
    1091.     return true;
    1092. }
    1093.  
    1094. bool NetClient::OnSendCustom(PNET_SEND_CHEAD _coder, char*& buffer, unsigned& len)
    1095. {
    1096.     switch (_coder->opcode.value())
    1097.     {
    1098.     case SC_CHOOSECAMP:
    1099.         return OnChooseCamp((PNS_CHOOSECAMP)_coder);
    1100.     case SC_CHAT:
    1101.         return OnChat((PCHAT_DATA)_coder);
    1102.     case SC_BEEP:
    1103.         return OnHeartBeep((PHEART_BEEP)_coder);
    1104.     case SC_LOOP:
    1105.         return OnHeartLoop((PHEART_LOOP)_coder);
    1106.     case SC_INITED:
    1107.         return OnInited();
    1108.      case SC_REONLINE:
    1109.     //case SC_INIT_START:
    1110.     //case SC_HAND:
    1111.     //case SC_HAND_IN:
    1112.     //    return false;
    1113.     case SC_MOVE_HEADER:
    1114.         return OnMove((PMOVE_DATA)_coder);
    1115.     case SC_FALL_HEADER:
    1116.         return OnFall((PFALL_DATA_START)_coder);
    1117.     case SC_INWATER:
    1118.       return false;
    1119.     case SC_USESKILL:
    1120.         return OnUseSkill((PUSESKILL)_coder);
    1121.     default:
    1122.         return true;
    1123.     }
    1124.     return true;
    1125. }
    1126.  
    1127. bool NetClient::OnSelectRole(wchar_t* rolename)
    1128. {
    1129.     //AfxMessageBox(rolename);
    1130.     return true;
    1131. }
    1132.  
    1133. bool NetClient::OnChooseCamp(PNS_CHOOSECAMP _coder)
    1134. {
    1135.     PNS_CHOOSECAMP _p = (PNS_CHOOSECAMP)_coder;
    1136.    
    1137.     return true;
    1138. }
    1139.  
    1140. bool NetClient::OnChat(PCHAT_DATA _coder)
    1141. {
    1142.     switch (_coder->ChartId)
    1143.     {
    1144.     case 3:// 私聊
    1145.         return OnChatPrivate((PCHAT_PRV)_coder);
    1146.     case 1:// 附近频道
    1147.     case 2:// 区域频道
    1148.     case 6:// 公会频道
    1149.     case 9:// 阵营频道
    1150.     case 21:// 喊话频道
    1151.         return OnChatPublic((PCHAT_PUB)_coder);
    1152.         break;
    1153.     }
    1154.     return true;
    1155. }
    1156.  
    1157. bool NetClient::OnChatPublic(PCHAT_PUB _coder)
    1158. {
    1159.     return true;
    1160. }
    1161.  
    1162. bool NetClient::OnChatPrivate(PCHAT_PRV _coder)
    1163. {
    1164.     return true;
    1165. }
    1166.  
    1167. bool NetClient::OnHeartBeep(PHEART_BEEP _coder)
    1168. {
    1169.     return true; // 返回false会拦截81心跳包不给服务端发送
    1170. }
    1171.  
    1172. bool NetClient::OnHeartLoop(PHEART_LOOP _coder)
    1173. {
    1174.     return true; // 返回false会拦截SC_LOOP心跳包不给服务端发送
    1175. }
    1176.  
    1177. bool NetClient::MailBox(int optype)
    1178. {
    1179.     NET_SEND_BUFF _buff;
    1180.     MAIL_OPERAION _data;
    1181.  
    1182.     _data.opcode.Set(SC_MAIL);
    1183.     _data.optype.Set(optype);
    1184.  
    1185.     /*
    1186.         sizeof(_data) / sizeof(EnCode)的原因
    1187.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    1188.         全是 EnCode 这个结构
    1189.     */
    1190.     short count = sizeof(_data) / sizeof(EnCode);
    1191.     _buff.count = count;
    1192.  
    1193.     /*
    1194.         CodeMe函数给 _buff.buff里写数据参数的数据
    1195.         也就是给0A开头数据包里写，数据参数个数后面的内容
    1196.         然后返回值是写了多长的数据
    1197.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    1198.     */
    1199.     int ilen = _data.CodeMe(count, _buff.buff);
    1200.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    1201.     return NetSend(&_buff.op, ilen);
    1202. }
    1203.  
    1204. bool NetClient::OnMove(PMOVE_DATA _coder)
    1205. {
    1206.     switch (_coder->Mode)
    1207.     {
    1208.         case 0:
    1209.             return OnMoveStop((PMOVE_DATA_STOP)_coder);
    1210.         case 1:
    1211.             return OnMoveWalk((PMOVE_DATA_WALK)_coder);
    1212.         case 2:
    1213.             return OnMoveJump((PMOVE_DATA_JUMP)_coder);
    1214.         case 3:
    1215.             return OnMoveWJump((PMOVE_DATA_WJUMP)_coder);
    1216.     }
    1217.     return false;
    1218. }
    1219.  
    1220. bool NetClient::OpenMailBox()
    1221. {
    1222.     return MailBox(SC_MAIL_OPENBOX);
    1223. }
    1224.  
    1225. bool NetClient::CloseMailBox()
    1226. {
    1227.     bool ret;
    1228.     ret = MailBox(SC_MAIL_CLOSEMAIL);
    1229.     return ret && MailBox(SC_MAIL_CLOSEBOX);
    1230. }
    1231.  
    1232. bool NetClient::Mail(const char* guid, int optype)
    1233. {
    1234.     NET_SEND_BUFF _buff;
    1235.     MAIL_OPERAION_RD _data;
    1236.  
    1237.     _data.opcode.Set(SC_MAIL);
    1238.     _data.optype.Set(optype);
    1239.     _data.Guid.Set(guid);
    1240.  
    1241.     /*
    1242.         sizeof(_data) / sizeof(EnCode)的原因
    1243.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    1244.         全是 EnCode 这个结构
    1245.     */
    1246.     short count = sizeof(_data) / sizeof(EnCode);
    1247.     _buff.count = count;
    1248.  
    1249.     /*
    1250.         CodeMe函数给 _buff.buff里写数据参数的数据
    1251.         也就是给0A开头数据包里写，数据参数个数后面的内容
    1252.         然后返回值是写了多长的数据
    1253.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    1254.     */
    1255.     int ilen = _data.CodeMe(count, _buff.buff);
    1256.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    1257.     return NetSend(&_buff.op, ilen);
    1258. }
    1259.  
    1260. // 移动中处理函数
    1261. bool NetClient::OnMoveWalk(PMOVE_DATA_WALK _coder)
    1262. {
    1263.     /*float* MoveSpeed = (float*)_coder->MoveSpeed.oldPointer;
    1264.     MoveSpeed[0] = 5.0f;*/
    1265.     /*if (HideMode) {
    1266.         float* f = (float*)_coder->h.oldPointer;
    1267.         f[0] = f[0] + 5;
    1268.     }*/
    1269.     return true;
    1270. }
    1271.  
    1272. // 停止移动处理函数
    1273. bool NetClient::OnMoveStop(PMOVE_DATA_STOP _coder)
    1274. {
    1275.   /*  if (HideMode) {
    1276.         float* f = (float*)_coder->h.oldPointer;
    1277.         f[0] = f[0] + 5;
    1278.     }*/
    1279.     return true;
    1280. }
    1281.  
    1282. // 跳跃处理函数
    1283. bool NetClient::OnMoveJump(PMOVE_DATA_JUMP _coder)
    1284. {
    1285.     //float* MoveSpeed = (float*)_coder->MoveSpeed.oldPointer;
    1286.     //MoveSpeed[0] = 5.0f;
    1287.     //if(HideMode) {
    1288.     //    float* f = (float*)_coder->h.oldPointer;
    1289.     //    f[0] = f[0] + 5;
    1290.     //}
    1291.     return true;
    1292. }
    1293.  
    1294. bool NetClient::MailEx(const char* guid, int optype, int opother)
    1295. {
    1296.     NET_SEND_BUFF _buff;
    1297.     MAIL_OPERAION_GET _data;
    1298.  
    1299.     _data.opcode.Set(SC_MAIL);
    1300.     _data.optype.Set(optype);
    1301.     _data.Guid.Set(guid);
    1302.     _data.opother.Set(opother);
    1303.  
    1304.  
    1305.     /*
    1306.         sizeof(_data) / sizeof(EnCode)的原因
    1307.         NET_SEND_CHOOSECAMP结构体里面，没别 东西
    1308.         全是 EnCode 这个结构
    1309.     */
    1310.     short count = sizeof(_data) / sizeof(EnCode);
    1311.     _buff.count = count;
    1312.  
    1313.     /*
    1314.         CodeMe函数给 _buff.buff里写数据参数的数据
    1315.         也就是给0A开头数据包里写，数据参数个数后面的内容
    1316.         然后返回值是写了多长的数据
    1317.         也就是给0A开头数据包里的数据参数个数后面的数据写了多长
    1318.     */
    1319.     int ilen = _data.CodeMe(count, _buff.buff);
    1320.     ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
    1321.     return NetSend(&_buff.op, ilen);
    1322. }
    1323.  
    1324. bool NetClient::GetMail(const char* guid)
    1325. {
    1326.     bool ret;
    1327.     ret = MailEx(guid);
    1328.     return ret && Mail(guid, SC_MAIL_GETSC);
    1329. }
    1330.  
    1331. // 移动时跳跃
    1332. bool NetClient::OnMoveWJump(PMOVE_DATA_WJUMP _coder)
    1333. {
    1334.    /* float* MoveSpeed = (float*)_coder->MoveSpeed.oldPointer;
    1335.     MoveSpeed[0] = 5.0f;*/
    1336.     //if(HideMode) {
    1337.     //    float* f = (float*)_coder->h.oldPointer;
    1338.     //    f[0] = f[0] + 5;
    1339.     //}
    1340.     return true;
    1341. }
    1342.  
    1343. bool NetClient::OnFall(PFALL_DATA_START _coder)
    1344. {
    1345.     return true;
    1346. }
    1347.  
    1348. bool NetClient::OnSvrChat(PCHAT_PRV _coder)
    1349. {
    1350.     //AfxMessageBox(_coder->name);
    1351.     //AfxMessageBox(_coder->txt);
    1352.     //switch (_coder->ChartId)
    1353.     //{
    1354.     //case 3:// 私聊
    1355.     //    return OnChatPrivate((PCHAT_PRV)_coder);
    1356.     //case 1:// 附近频道
    1357.     //case 2:// 区域频道
    1358.     //case 6:// 公会频道
    1359.     //case 9:// 阵营频道
    1360.     //case 21:// 喊话频道
    1361.     //    return OnChatPublic((PCHAT_PUB)_coder);
    1362.     //    break;
    1363.     //}
    1364.     return true;
    1365. }
    1366.  
    1367. bool NetClient::OnUseSkill(PUSESKILL _coder)
    1368. {
    1369.     // 无法x坐标无效，会无法释放技能
    1370.     /*float* f = (float*)_coder->x.oldPointer;
    1371.     f[0] = 0;*/
    1372.     return true;
    1373. }
    1374.  
    1375. bool NetClient::OnInited()
    1376. {
    1377.  
    1378.     return true;
    1379. }
    1380.  
    1381. bool NetClient::Tips(int code)
    1382. {
    1383. #ifdef  Anly
    1384.     CString txt;
    1385.     if (code == 51001) {
    1386.         txt = L"登陆失败,易道云通行证不存在!";
    1387.     }else if (code == 51002) {
    1388.         txt = L"登录失败,密码错误!";
    1389.     }else if (code == 21101) {
    1390.         txt = L"人物重名!";
    1391.     }else if (code == 21109) {
    1392.         txt = L"名字过长或包含非法字符!";
    1393.     }
    1394.     else {
    1395.         txt.Format(L"未知登录错误:%d", code);
    1396.     }
    1397.  
    1398.  
    1399.     anly->SendData(TTYPE::I_LOG, 0, txt.GetBuffer(), (txt.GetLength() + 1)*2);
    1400. #endif
    1401.     return true;
    1402. }
    1403.  
    1404. void NetClient::loginok(ROLE_DATA* _roles, int count)
    1405. {
    1406.     logined = true;
    1407.     if(roles) delete[] roles;
    1408.     roles = _roles;
    1409.     rolecount = count;
    1410. }
    1411.  
    1412. bool NetClient::OnScrStartCreateRole(short code, wchar_t* _txt)
    1413. {
    1414.     return true;
    1415. }
    1416.  
    1417. bool NetClient::OnSvrNotice(PNET_SEND_CHEAD _coder, int count, char*& buffer, unsigned& len)
    1418. {
    1419.     if (_coder->msgHeader == "chat") {
    1420.         return OnSvrChat((PCHAT_PRV)_coder);
    1421.     }
    1422.  
    1423.     return true;
    1424. }
    1425.  
    1426. bool NetClient::OnRecvData(char*& buff, unsigned& len)
    1427. {
    1428. #ifdef  Anly
    1429. 	anly->SendData(TTYPE::I_RECV, buff[0], buff, len);
    1430. #endif
    1431.     return (this->*RecvProc[buff[0]])(buff, len);
    1432. }
    1433.  
    1434. bool NetClient::OnSendData(char*& buff, unsigned& len)
    1435. {
    1436. #ifdef  Anly
    1437. 	anly->SendData(TTYPE::I_SEND, buff[0], buff, len);
    1438. #endif
    1439.     return (this->*SendProc[buff[0]])(buff, len);
    1440. }
    1441.  
    1442. bool NetClient::OnConnect(char*& ip, unsigned& port)
    1443. {
    1444. #ifdef  Anly
    1445.     // 长度24的原因，它是宽字节要，一个文字要2个字节，一共是10个文字加上结尾的0是11个
    1446.     // 所以 11 乘以2，然后再加2 
    1447.     anly->SendData(TTYPE::I_LOG, 0, L"服务器正在连接。。。", 24);
    1448. #endif
    1449.     return true;
    1450. }
    1451.  
    1452.  
    1453. // 默认的数据处理函数
    1454. bool NetClient::DefaultProc(char*&, unsigned&)
    1455. {
    1456.     return true;
    1457. }
    1458.  
    1459. // 复制过来的内容
    1460. bool NetClient::OnClientlogin(char*& buff, unsigned& len)
    1461. {
    1462.     PDATALOGIN _data = (PDATALOGIN)(buff + 1);
    1463.     char* _id = _data->Id;
    1464.     _data = (PDATALOGIN)(buff + 1 + _data->lenId - 0x10);
    1465.     char* _pass = _data->Pass;
    1466.  
    1467.     Onlogin(_id, _pass);
    1468.  
    1469.     /* 修改账号密码
    1470.     len = sizeof(DATA_LOGIN) + 1;
    1471.     buff = new char[len];
    1472.     DATA_LOGIN data;
    1473.     PDATALOGIN _data = &data;
    1474.     buff[0] = 0x2;
    1476.     CStringA _id = "";// 补充账号
    1477.     CStringA _pass = "";// 补充密码
    1478.     memcpy(_data->Id, _id.GetBuffer(), _id.GetLength());
    1479.     memcpy(_data->Pass, _pass.GetBuffer(), _pass.GetLength());
    1480.     memcpy(buff + 1, _data, len - 1);
    1481.     */
    1482.     /* 监控登录数据
    1483.     PDATALOGIN _data = (PDATALOGIN)buff;
    1484.     CStringA _id = _data->Id;
    1485.     _data = (PDATALOGIN)(buff + _data->lenId - 0x10);
    1486.     CStringA _pass = _data->Pass;
    1487.     CStringA _tmp;
    1488.     // 请求登录 账号[% s]密码[% s] 这个内容别人在逆向的时候就会看到
    1489.     // 所以这种东西需要自己搞个编码来代替它
    1491.      _tmp.Format("请求登录 账号[%s]密码[%s]", _id, _pass);
    1492. #ifdef  Anly
    1493.     anly->SendData(TTYPE::I_DIS, 1, _tmp.GetBuffer(), _tmp.GetAllocLength());
    1494. #endif
    1495.     */
    1496.  
    1497.     /*
    1498.         返回false，游戏无法发送数据包
    1499.         原因看调用此此函数的位置 OnSend 函数（if (SendDealProc[buff[0]]((buff + 1), len - 1))）
    1500.     */
    1501.     return true;
    1502. }
    1503.  
    1504. bool NetClient::OnClientStartCreateRole(char*& buff, unsigned& len)
    1505. {
    1506.     // 申请进入创建角色界面
    1507.     int* code = (int*)&buff[1];
    1508.     return OnStartCreateRole(code[0]);
    1509. }
    1510.  
    1511. bool NetClient::OnClientCreateRole(char*& buff, unsigned& len) {
    1512.     PNS_CREATEROLE head = (PNS_CREATEROLE)(buff - 3);
    1513.     int icount = head->count;
    1514.     if (icount < 1)return true;
    1515.     char* buffStart = (char*)head + sizeof(NET_SEHD_CREATEROLE_HEAD);
    1516. #ifdef Anly
    1517.     GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0], 1);// 翻译解析约定数据
    1518. #endif // Anly
    1519.  
    1520.     EnCode codes[sizeof(CREATE_ROLE_DATAS) / sizeof(EnCode)]{};
    1521.     int stDecode = 0;
    1522.     while (stDecode < icount) {
    1523.         codes[stDecode++] = buffStart;
    1524.     }
    1525.  
    1526.  
    1527.     /*
    1528.         OnCreateRole(head, (PCREATE_ROLE_DATAS)codes) 数据包传给虚函数
    1529.         如果想对发送创建角色数据包做些什么直接继承NetClient重写OnCreateRole函数既可以了
    1530.     */
    1531.     return OnCreateRole(head, (PCREATE_ROLE_DATAS)codes);// 返回false屏蔽05开头的数据包，也就是创建角色发送的数据包
    1532. }
    1533.  
    1534. bool NetClient::OnClientSendCustom(char*& buff, unsigned& len) {
    1535.     PNET_SEND_HEAD head = (PNET_SEND_HEAD)(buff - 1);
    1536.     int icount = head->count;
    1537.     if (icount < 1)return true;
    1538.     char* buffStart = (char*)head + sizeof(NET_SEND_HEAD);
    1539.     if (buffStart[0] != 0x02) {
    1540.  
    1541. #ifdef  Anly
    1542.         if (icount < MAX_SEND_COUNT)
    1543.             anly->SendData(TTYPE::I_DIS, I_SEND_CUSTOM, "SEND_CUSTOM MAX_SEND_COUNT 内存解码器空间不足", 46);
    1544.  
    1545.         anly->SendData(TTYPE::I_DIS, I_SEND_CUSTOM, "SEND_CUSTOM 发现异常数据", 25);
    1546. #endif
    1547.         return true;
    1548.     }
    1549.  
    1550. #ifdef  Anly
    1551.     GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0], 1);
    1552. #endif
    1553.  
    1554.     int stDecode = 0;
    1555.     EnCode codes[MAX_SEND_COUNT]{};
    1556.     while (stDecode < icount) {
    1557.         codes[stDecode++] = buffStart;
    1558.     }
    1559.  
    1560.     /*
    1561.         OnSendCustom((PNET_SEND_CHEAD)codes, buff, len); 数据包传给虚函数
    1562.         如果想对发送数据的0A开头的据包做些什么直接继承NetClient重写OnSendCustom函数既可以了
    1563.     */
    1564.     return OnSendCustom((PNET_SEND_CHEAD)codes, buff, len);
    1565.  
    1566. }
    1567.  
    1568. bool NetClient::OnClientSelectRole(char*& buff, unsigned& len) {
    1569.     PNS_SELECTROLE p = (PNS_SELECTROLE)buff;
    1570.     return OnSelectRole((wchar_t*)(p->buff));
    1571. }
    1572.  
    1573. bool NetClient::OnClientDelRole(char*& buff, unsigned& len) {
    1574.  
    1575.     PDATADELROLE p = (PDATADELROLE)buff;
    1576.     return OnDelRole((wchar_t*)(p->buff), p->len);
    1577.  
    1578.  
    1579.  
    1580.     // 返回值改为false将拦截发送的删除角色数据包
    1581.     // 详情看注册 OnDelRole 函数的位置，Init函数
    1582.     // return true;
    1583. }
    1584.  
    1585. // 接收数据截取区
    1586.  
    1587. bool NetClient::OnSvrTips(char*& buff, unsigned& len) {
    1588.     int* code = (int*)&buff[1];
    1589.     return Tips(code[0]);
    1590. }
    1591.  
    1592. bool NetClient::OnSvrloginOk(char*& buff, unsigned& len) {
    1593.  
    1594.     PDATALOGINOK _p = (PDATALOGINOK)&buff[1];
    1595.     ROLE_DATA* roleDatas = nullptr;
    1596.     if (_p->RoleCount > 0) {
    1597.         char* buffStart = buff + 1 + sizeof(DATA_LOGIN_OK);
    1598.  
    1599. #ifdef Anly
    1600.         GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0]);
    1601. #endif // Anly
    1602.  
    1603.         roleDatas = new ROLE_DATA[_p->RoleCount];
    1604.         for (int i = 0; i < _p->RoleCount; i++)
    1605.         {
    1606.             roleDatas[i].byte.Init(buffStart, 0);
    1607.             roleDatas[i].index.Init(buffStart, 0);
    1608.             roleDatas[i].un1.Init(buffStart, 0);
    1609.             roleDatas[i].name.Init(buffStart, 0);
    1610.             roleDatas[i].infos.Init(buffStart, 0);
    1611.             roleDatas[i].un2.Init(buffStart, 0);
    1612.             roleDatas[i].un3.Init(buffStart, 0);
    1613.         }
    1614.         loginok(roleDatas, _p->RoleCount);
    1615.     }
    1616.     return true;
    1617. }
    1618.  
    1619. bool NetClient::OnSverObject(char*& buff, unsigned& len) {
    1620.     PNR_HEAD head = (PNR_HEAD)(buff - 1);
    1621.     //head->count;
    1622.  
    1623.     if (ObjectTable) {
    1624.         delete[] ObjectTable;
    1625.     }
    1626.  
    1627.     if (ObjectTxt) {
    1628.         delete[] ObjectTxt;
    1629.     }
    1630.  
    1631.     ObjectTable = new OBJECT_DESC[head->count];
    1632.     ObjectTxt = new char[len];
    1633.     memcpy(ObjectTxt, buff, len);// 这里怕 buff 的内容被游戏释放掉，后面我们用的时候没法用，所以把buff的内容复制到我们的变量里
    1634.     char* buffStart = ObjectTxt + sizeof(NR_HEAD)-1;
    1635. //#ifdef Anly
    1636. //    CStringA szTxtA;
    1637. //    CStringA szTmp;
    1638. //#endif // Anly
    1639. //#ifdef Anly
    1640. //    szTmp.Format("[%X]%s:%d\r\n", i, ObjectTable[i].name, ObjectTable[i].type);
    1641. //    szTxtA += szTmp;
    1642. //#endif // Anly
    1643. //#ifdef  Anly
    1644. //    anly->SendData(TTYPE::I_DIS, S_OBJECT, szTxtA.GetBuffer(), szTxtA.GetAllocLength() + 1);
    1645. //#endif // Anly
    1646.     for (int i = 0; i < head->count; i++)
    1647.     {
    1648.         ObjectTable[i].name = buffStart;
    1649.         buffStart = buffStart + strlen(ObjectTable[i].name) + 1;
    1650.         ObjectTable[i].type = buffStart[0];
    1651.         buffStart++;
    1652.     }
    1653.  
    1654. #ifdef Anly
    1655.     GameAnlyer->CreateObjectfiles(ObjectTable, head->count);
    1656. #endif // Anly
    1657.  
    1658.  
    1659.  
    1660.     return true;
    1661. }
    1662. bool NetClient::OnSverStruct(char*& buff, unsigned& len) {
    1663.     PNR_HEAD head = (PNR_HEAD)(buff - 1);
    1664.     
    1665.     MaxStruct = head->count;
    1666.  
    1667.     if (StructTable) {
    1668.         delete[] StructTable;
    1669.     }
    1670.  
    1671.     if (StructTxt) {
    1672.         delete[] StructTxt;
    1673.     }
    1674.  
    1675.     StructTable = new STRUCT_DESC[head->count];
    1676.     StructTxt = new char[len];
    1677.     memcpy(StructTxt, buff, len);
    1678.     char* buffStart = StructTxt + sizeof(NR_HEAD) - 1;
    1679.  
    1680.     unsigned MaxOffSet = 0;
    1681.  
    1682.     for (int i = 0; i < head->count; i++)
    1683.     {
    1684.         StructTable[i].name = buffStart;
    1685.         buffStart = buffStart + strlen(StructTable[i].name) + 1;
    1686.         short* icount = (short*)buffStart;
    1687.         StructTable[i].count = icount[0];
    1688.         buffStart = buffStart + 2;
    1689.         StructTable[i].buff = buffStart;
    1690.         buffStart = buffStart + icount[0];
    1691.         MaxOffSet += StructTable[i].count;
    1692.     }
    1693.     if (StructOffSet) delete[] StructOffSet;
    1694.     StructOffSet = new short[MaxOffSet];
    1695.  
    1696. #ifdef Anly
    1697.     GameAnlyer->CreateStructfile(StructTable, head->count);
    1698. #endif // Anly
    1699.  
    1700.     // 初始化偏移表
    1701.     InitStruct(StructTable, head->count, StructOffSet);
    1702.  
    1703.     return true;
    1704. }
    1705. bool NetClient::OnSvrObjectInit(char*& buff, unsigned& len)
    1706. {
    1707.     /*
    1708.         00 00 00 00 00 00 00 为了内存对齐补充了7个0，也就是 un1[6] 和 len
    1709.         28 op
    1710.         CD 48 00 01 62 A7 DE 04 PNR_OBJINIT:lId
    1711.         C1 AA FB C3 PNR_OBJINIT:x;
    1712.         3D FF 22 41 PNR_OBJINIT:h;
    1713.         D7 0B 4A 44 PNR_OBJINIT:y;
    1714.         52 B8 06 40 PNR_OBJINIT:face;
    1715.         C1 AA FB C3 PNR_OBJINIT:tx;
    1716.         3D FF 22 41 PNR_OBJINIT:th;
    1717.         D7 0B 4A 44 PNR_OBJINIT:ty;
    1718.         52 B8 06 40 PNR_OBJINIT:tface;
    1719.         00 00 00 00 PNR_OBJINIT:un2[0]
    1720.         00 00 00 00 PNR_OBJINIT:un2[1]
    1721.         00 00 00 00 PNR_OBJINIT:un2[2]
    1722.         00 00 00 00 PNR_OBJINIT:un2[3]
    1723.         00 00 00 00 PNR_OBJINIT:un2[4]
    1724.         61 00       PNR_OBJINIT:icount;
    1726.         
    1727.         1B 00 (char*)head + sizeof(NR_OBNJECT_INIT) - 2;也就是指向到了 PNR_OBJINIT:type 这个位置
    1728.         0C 00 00 00 CA 4E 5A 66 53 62 01 80 4E 86 00 00 1D 00
    1729.     */
    1730.     // 初始化对象
    1731.     PNR_OBJINIT head = (PNR_OBJINIT)(buff - 7);
    1732.     char* buffStart = (char*)head + sizeof(NR_OBNJECT_INIT) - 2;
    1733.  
    1734.     //int nStart = (int)&Player.lId;
    1735.     //int nEnd = (int)&Player.endclass;
    1736.     //memcpy(&Player.lId, &head->lId, nEnd - nStart);
    1737.     Player.SetHeadDatas(&head->lId);
    1738. #ifdef  Anly
    1739.     GameAnlyer->AnlyData(buffStart, buff + len, head->icount, S_OBJECT_INIT, ObjectTable);
    1740. #endif
    1741.  
    1742.     int iProc = 0;
    1743.     while (iProc < head->icount)
    1744.     {
    1745.         Player.UpdateData(buffStart);
    1746.         iProc++;
    1747.     }
    1748.  
    1749.     return true;
    1750. }
    1751. bool NetClient::OnSvrObjectInitEx(char*& buff, unsigned& len)
    1752. {
    1753.     // 初始化对象
    1754.     PNR_OBJINITEX head = (PNR_OBJINITEX)(buff - 5);
    1755.     char* buffStart;
    1756.  
    1757.     /*int nStart = (int)&Player.lId;
    1758.     int nEnd = (int)&Player.endclass;
    1759.     memcpy(&Player.lId, &head->lId, nEnd - nStart);*/
    1760.  
    1761.     int iObjectCount = 0;
    1762.     short objCount = head->obj_count; // 可以理解为一共有多少个接收的28数据
    1763.     while (iObjectCount < objCount) {
    1764.         PAIM _paim = GetAimById(head->lId);
    1765.         _paim->SetHeadDatas(&head->lId);
    1766.        
    1767.         buffStart = (char*)head + sizeof(NR_OBNJECT_INITEX) - 2;
    1768.         short refCount = head->icount; // 接收的28数据里的数据参数个数
    1769.         short iref = 0;
    1770. #ifdef  Anly
    1771.         GameAnlyer->AnlyData(buffStart, buff + len, refCount, S_OBJECT_INITEX, ObjectTable);
    1772. #endif
    1773.         while (iref < refCount) {
    1774.             _paim->UpdateData(buffStart);
    1775.             iref++;
    1776.         }
    1777.         head = (PNR_OBJINITEX)(buffStart - 8);
    1778.  
    1779.         iObjectCount++;
    1780.     }
    1781.  
    1782.     return true;
    1783. }
    1784. bool NetClient::OnSvrUpdateCord(char*& buff, unsigned& len)
    1785. {
    1786.     /*
    1787.     00 00 00 00 00 head
    1788.     21 02 00 
    1789.     CD 14 00 01 CD 14 00 00 第一个坐标数据
    1790.     6D BF 54 43 
    1791.     A6 FA C7 3F 
    1792.     8C 52 A9 C1 
    1793.     CB 30 06 40 
    1794.     00 00 00 00 
    1795.     DB 0F C9 41 
    1796.     00 00 00 00 
    1797.     00 00 00 00 
    1798.     01 00 00 00 State
    1800.     CD 14 00 01 CD 14 00 00 第二个坐标数据
    1801.     61 41 5B 43 
    1802.     A6 FA C7 3F 
    1803.     C5 8A C7 C1 
    1804.     CB 30 06 40 
    1805.     9A 99 99 3E 
    1806.     DB 0F C9 40 
    1807.     00 00 00 00 
    1808.     00 00 00 00 
    1809.     01 00 00 00 
    1810.     
    1811.     */
    1812.     // 初始化对象
    1813.     PNR_OBJINITEX head = (PNR_OBJINITEX)(buff - 5);
    1814.  
    1815.     /*int nStart = (int)&Player.lId;
    1816.     int nEnd = (int)&Player.endclass;
    1817.     memcpy(&Player.lId, &head->lId, nEnd - nStart);*/
    1818.  
    1819.     int iObjectCount = 0;
    1820.     short objCount = head->obj_count; // 可以理解为一共有多少个接收的28数据
    1821.     while (iObjectCount < objCount) {
    1822.         PAIM _paim = GetAimById(head->lId);
    1823.         _paim->SetHeadDatas(&head->lId);
    1824.         CStringA txtA;
    1825.         txtA.Format("x:%f h:%f y:%f", head->x, head->h, head->y);
    1826. #ifdef  Anly
    1827.         anly->SendData(TTYPE::I_DIS, S_UPDATECORD, txtA.GetBuffer(), txtA.GetAllocLength() + 1);
    1828. #endif
    1829.         head = (PNR_OBJINITEX)((char*)&head->State - 4);
    1830.         iObjectCount++;
    1831.     }
    1832.     return true;
    1833. }
    1834. bool NetClient::OnSvrUpdateProperty(char*& buff, unsigned& len)
    1835. {
    1836.     // 初始化对象
    1837.     PNR_OBJECT_UP head = (PNR_OBJECT_UP)(buff - 6);
    1838.     PGAMEOBJ _object = nullptr;
    1839.  
    1840.     char* buffStart = (char*)&head->itype;
    1841.     short refcount = head->icount;
    1842.     int iref = 0;
    1843. #ifdef  Anly
    1844.     GameAnlyer->AnlyData(buffStart, buff + len, refcount, S_UPDATEPRO, ObjectTable);
    1845. #endif
    1846.     if (head->MsgId ) {
    1847.         _object = GetGameOBJECT(head->Index[0], head->Index[1]);
    1848.     }
    1849.     else {
    1850.  
    1851.         _object = GetAimById(head->lId);
    1852.       
    1853.     }
    1854.  
    1855.     while ((iref < refcount)&&(_object)) {
    1856.         _object->UpdateData(buffStart);
    1857.         iref++;
    1858.     }
    1859.  
    1860.     return true;
    1861. }
    1862. bool NetClient::OnSvrUpdatePropertyMu(char*& buff, unsigned& len)
    1863. {
    1864.     // 初始化对象
    1865.     PNR_OBJECT_UPMU head = (PNR_OBJECT_UPMU)(buff - 5);
    1866.  
    1867.     int iobjCount = 0;
    1868.     short objCount = head->objCount; // 可以理解为一共有多少个接收的28数据
    1869.     char* buffStart;
    1870.     /*
    1871.       数据包是下方的样子，
    1872.         2D 
    1873.         01 00 objCount
    1874.         9B 49 00 01 D5 8C 98 05  GetAimById(head->lId);
    1875.         02 00 
    1876.         25 00 (char*)&head->itype
    1877.         18 00 00 00 
    1878.         29 00 BA 01 00 00 
    1879.         
    1880.         while (iobjCount < objCount) 里获取的是
    1881.         9B 49 00 01 D5 8C 98 05
    1882.         02 00
    1883.         25 00 18 00 00 00
    1884.         29 00 BA 01 00 00 这一块数据
    1886.          while (iref++ < refCount) 里获取的是
    1887.          25 00 18 00 00 00
    1889.         (PNR_OBJECT_UPMU)(buffStart - 8); 移动到下一个
    1890.         9B 49 00 01 D5 8C 98 05  GetAimById(head->lId);
    1891.         02 00
    1892.         25 00 (char*)&head->itype
    1893.         18 00 00 00
    1894.         29 00 BA 01 00 00 这个数据
    1896.     */
    1897.     while (iobjCount < objCount) {
    1898.         PAIM _paim = GetAimById(head->lId);
    1899.         buffStart = (char*)&head->itype;
    1900.  
    1901.         short refCount = head->icount; // 接收的28数据里的数据参数个数
    1902.         short iref = 0;
    1903.  
    1904. #ifdef  Anly
    1905.         GameAnlyer->AnlyData(buffStart, buff + len, refCount, S_UPDATEPROMU, ObjectTable);
    1906. #endif
    1907.  
    1908.         while (iref++ < refCount) {
    1909.             _paim->UpdateData(buffStart);
    1910.         }
    1911.         head = (PNR_OBJECT_UPMU)(buffStart - 8);
    1912.         iobjCount++;
    1913.     }
    1914.  
    1915.     return true;
    1916. }
    1917. bool NetClient::OnSvrRemoveObjectMu(char*& buff, unsigned& len)
    1918. {
    1919.     // 初始化对象
    1920.     PNR_OBJECT_REMOVEMU head = nullptr;
    1921.     head = (PNR_OBJECT_REMOVEMU)(buff - &head->op);
    1922.  
    1923.     int iobjCount = head->objCount;
    1924.     
    1925.     for (int i = 0; i < iobjCount; i++)
    1926.     {
    1927.         RemoveAimById(head->lId[i]);
    1928.     }
    1929.  
    1930.     return true;
    1931. }
    1932.  
    1933. /*
    1934.     1F
    1935.     87 44 00 01 7F B0 D6 05
    1936.     FE AD DE C3
    1937.     6C F5 46 42
    1938.     07 FD 36 C4
    1939.     90 D9 9C 40
    1940. */
    1941. bool NetClient::OnSvrUpdateCordEx(char*& buff, unsigned& len)
    1942. {
    1943.     // 初始化对象
    1944.     PNR_UPDATECOORD head = nullptr;
    1945.     head = (PNR_UPDATECOORD)(buff - &head->op);
    1946.     PAIM aim = GetAimById(head->lId);
    1947.  
    1948.     if (aim) {
    1949.         return aim->SetHeadCord(&head->lId);
    1950.     }
    1951.  
    1952.     return true;
    1953. }
    1954. bool NetClient::OnSvrGameBase(char*& buff, unsigned& len)
    1955. {
    1956.     // 初始化对象
    1957.     PNR_GAMEBASE head = nullptr; 
    1958.     head = (PNR_GAMEBASE)(buff - &head->op);
    1959.     char* buffStart = (char*)head + sizeof(NR_GAMEBASE);
    1960.  
    1961.     //int nStart = (int)&Player.lId;
    1962.     //int nEnd = (int)&Player.endclass;
    1963.     //memcpy(&Player.lId, &head->lId, nEnd - nStart);
    1964.     //Player.SetHeadDatas(&head->lId);
    1965. #ifdef  Anly
    1966.     CStringA szTxt;
    1967.     szTxt.Format("%X %X", head->type, head->index);
    1968.     anly->SendData(TTYPE::I_DIS, S_GAMEBASE, szTxt.GetBuffer(), szTxt.GetAllocLength() + 1);
    1969.     GameAnlyer->AnlyData(buffStart, buff + len, head->count, S_GAMEBASE, ObjectTable);
    1970. #endif
    1971.     POBJECTBASE object = GetGameOBJECT(head->type, head->index);
    1972.     if (object == nullptr)return true;
    1973.  
    1974.     object->MainIndex = head->type;
    1975.     object->Index = head->index;
    1976.  
    1977.     int iProc = 0;
    1978.     while (iProc < head->count)
    1979.     {
    1980.         object->UpdateData(buffStart);
    1981.         iProc++;
    1982.     }
    1983.  
    1984.     return true;
    1985. }
    1986. bool NetClient::OnSvrGameBaseReset(char*& buff, unsigned& len)
    1987. {
    1988.     PNR_GAMEBASE_RESET head = nullptr;
    1989.     head = (PNR_GAMEBASE_RESET)(buff - &head->op);
    1990.     POBJECTBASE object = ReSetGameOBJECT(head->type, head->max);
    1991.     if (object) {
    1992.         char* buffStart = (char*)head + sizeof(NR_GAMEBASE);
    1993.         int iProc = 0;
    1994.         while (iProc < head->count)
    1995.         {
    1996.             object->UpdateData(buffStart);
    1997.             iProc++;
    1998.         }
    1999.  
    2000.     }
    2001.     return true;
    2002. }
    2003. bool NetClient::OnSvrGameBaseExChange(char*& buff, unsigned& len)
    2004. {
    2005.     PNR_GAMEBASE_EXCHANGE head = nullptr;
    2006.     head = (PNR_GAMEBASE_EXCHANGE)(buff - &head->op);
    2007.     ExChangeOBJECT(head->MainIndex, head->IndexFrom, head->IndexTo);
    2008.     return true;
    2009. }
    2010. bool NetClient::OnSvrGameBaseDestroy(char*& buff, unsigned& len)
    2011. {
    2012.     PNR_GAMEBASE_DROP head = nullptr;
    2013.     head = (PNR_GAMEBASE_DROP)(buff - &head->op);
    2014.     DestoryOBJECT(head->MainIndex, head->Index);
    2015.     return true;
    2016. }
    2017. bool NetClient::OnSvrGameBaseSet(char*& buff, unsigned& len)
    2018. {
    2019.     PNR_GAMEBASE_SET head = nullptr;
    2020.     head = (PNR_GAMEBASE_SET)(buff - &head->op);
    2021.     POBJECTBASE object = ReSetGameOBJECT(head->MainIndex, 0);
    2022.     if (object) {
    2023.         char* buffStart = head->buff;
    2024.         int iProc = 0;
    2025.         while (iProc < head->count)
    2026.         {
    2027.             object->UpdateData(buffStart);
    2028.             iProc++;
    2029.         }
    2030.  
    2031.     }
    2032.     return true;
    2033. }
    2034. bool NetClient::OnSvrStructInit(char*& buff, unsigned& len)
    2035. {
    2036.     PNR_STRUCT_INIT head = nullptr;
    2037.     head = (PNR_STRUCT_INIT)(buff - &head->op);
    2038.  
    2039. #ifdef Anly
    2040.     GameAnlyer->AnlyStruct(head, buff + len, S_STRUCT_INIT, StructTable);
    2041. #endif
    2042.  
    2043.     if (head->optype) {
    2044.         return true;
    2045.     }
    2046.     else {
    2047.         PAIM aim = GetAimById(head->lId);
    2048.         if (aim->CreateStruct(head->StructIndex, head->Start, head->Count)) {
    2049.             char* buffStart = head->buff;
    2050.             int iProc = 0;
    2051.             while (iProc < head->Count)
    2052.             {
    2053.                 UpdateStruct(aim, head->StructIndex, head->Start + iProc, buffStart);
    2054.                 iProc++;
    2055.             }
    2056.         }else return true;
    2057.     }
    2058.  
    2059. }
    2060. bool NetClient::UpdateStruct(PAIM aim, short structIndex, short index, char*& buff)
    2061. {
    2062.     void* base = aim->GetStruct(structIndex, index);
    2063.     if (!base) return false;
    2064.     short icount = StructTable[structIndex].count;
    2065.     
    2066.     short iProc = 0;
    2067.     while (iProc < icount) {
    2068.         short type = StructTable[structIndex].buff[iProc];
    2069.  
    2070.         switch (type)
    2071.         {
    2072.             case 1:
    2073.                 UpdateStructByte(base, aim, structIndex, iProc, buff);
    2074.                 break;
    2075.             case 2:
    2076.                 UpdateStructShort(base, aim, structIndex, iProc, buff);
    2077.                 break;
    2078.             case 3:
    2079.                 UpdateStructInt(base, aim, structIndex, iProc, buff);
    2080.                 break;
    2081.             case 5:
    2082.                 UpdateStructfloat(base, aim, structIndex, iProc, buff);
    2083.                 break;
    2084.             case 6:
    2085.                 UpdateStructDouble(base, aim, structIndex, iProc, buff);
    2086.                 break;
    2087.             case 7:
    2088.                 UpdateStructAscii(base, aim, structIndex, iProc, buff);
    2089.                 break;
    2090.             case 8:
    2091.                 UpdateStructUnicode(base, aim, structIndex, iProc, buff);
    2092.                 break;
    2093.             case 4:
    2094.             case 9:
    2095.                 UpdateStructInt64(base, aim, structIndex, iProc, buff);
    2096.                 break;
    2097.             default:
    2098.                 return false;
    2099.         }
    2100.  
    2101.         iProc++;
    2102.     }
    2103.     return true;
    2104. }
    2105. bool NetClient::OnSvrStructClear(char*& buff, unsigned& len)
    2106. {
    2107.     PNR_STRUCT_INIT head = nullptr;
    2108.     head = (PNR_STRUCT_INIT)(buff - &head->op);
    2109.     if (head->optype) {
    2110.         return true;
    2111.     }
    2112.     else {
    2113.         PAIM aim = GetAimById(head->lId);
    2114.         aim->DeleteStruct(head->StructIndex);
    2115.     }
    2116.     return true;
    2117. }
    2118. bool NetClient::OnSvrStructDelete(char*& buff, unsigned& len)
    2119. {
    2120.     PNR_STRUCT_INIT head = nullptr;
    2121.     head = (PNR_STRUCT_INIT)(buff - &head->op);
    2122.     if (head->optype) {
    2123.         return true;
    2124.     }
    2125.     else {
    2126.         PAIM aim = GetAimById(head->lId);
    2127.         aim->DeleteStruct(head->StructIndex, head->DelIndex);
    2128.     }
    2129.     return true;
    2130. }
    2131. bool NetClient::OnSvrStructUpdate(char*& buff, unsigned& len)
    2132. {
    2133.     PNR_STRUCT_UPDATE head = nullptr;
    2134.     head = (PNR_STRUCT_UPDATE)(buff - &head->op);
    2135.     if (head->optype) {
    2136.         return true;
    2137.     }
    2138.     else {
    2139. #ifdef Anly
    2140.         GameAnlyer->AnlyStruct(head, buff + len, S_STRUCT_UPDATE, StructTable);
    2141. #endif
    2142.         PAIM aim = GetAimById(head->lId);
    2143.         char* buffStart = head->buff;
    2144.         UpdateStruct(aim, head->StructIndex, buffStart, head->Count);
    2145.     }
    2146.     return true;
    2147. }
    2148. bool NetClient::UpdateStructByte(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2149. {
    2150.     char* writer = (char*)((char*)base + StructTable[structIndex].offset[index]);
    2151.     writer[0] = buff[0];
    2152.     buff = buff + sizeof(char);
    2153.     return true;
    2154. }
    2155. bool NetClient::UpdateStructShort(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2156. {
    2157.     short* writer = (short*)((char*)base + StructTable[structIndex].offset[index]);
    2158.     short* wtstream = (short*)buff;
    2159.     writer[0] = wtstream[0];
    2160.     buff = buff + sizeof(short);
    2161.     return true;
    2162. }
    2163. bool NetClient::UpdateStructInt(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2164. {
    2165.     int* writer = (int*)((char*)base + StructTable[structIndex].offset[index]);
    2166.     int* wtstream = (int*)buff;
    2167.     writer[0] = wtstream[0];
    2168.     buff = buff + sizeof(int);
    2169.     return true;
    2170. }
    2171. bool NetClient::UpdateStructInt64(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2172. {
    2173.     long long* writer = (long long*)((char*)base + StructTable[structIndex].offset[index]);
    2174.     long long* wtstream = (long long*)buff;
    2175.     writer[0] = wtstream[0];
    2176.     buff = buff + sizeof(long long);
    2177.     return true;
    2178. }
    2179. bool NetClient::UpdateStructfloat(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2180. {
    2181.     float* writer = (float*)((char*)base + StructTable[structIndex].offset[index]);
    2182.     float* wtstream = (float*)buff;
    2183.     writer[0] = wtstream[0];
    2184.     buff = buff + sizeof(float);
    2185.     return true;
    2186. }
    2187. bool NetClient::UpdateStruct(PAIM aim, short structIndex, char*& buff, short count)
    2188. {
    2189.     short iProc = 0;
    2190.     while (iProc < count) {
    2191.         short* pindex = (short*)buff;
    2192.         buff = buff + 2;
    2193.         char* sIndex = buff;
    2194.         void* base = aim->GetStruct(structIndex, pindex[0]);
    2195.         if (!base)return true;
    2196.         short type = StructTable[structIndex].buff[sIndex[0]];
    2197.         buff = buff + 1;
    2198.         switch (type)
    2199.         {
    2200.         case 1:
    2201.             UpdateStructByte(base, aim, structIndex, sIndex[0], buff);
    2202.             break;
    2203.         case 2:
    2204.             UpdateStructShort(base, aim, structIndex, sIndex[0], buff);
    2205.             break;
    2206.         case 3:
    2207.             UpdateStructInt(base, aim, structIndex, sIndex[0], buff);
    2208.             break;
    2209.         case 5:
    2210.             UpdateStructfloat(base, aim, structIndex, sIndex[0], buff);
    2211.             break;
    2212.         case 6:
    2213.             UpdateStructDouble(base, aim, structIndex, sIndex[0], buff);
    2214.             break;
    2215.         case 7:
    2216.             UpdateStructAscii(base, aim, structIndex, sIndex[0], buff);
    2217.             break;
    2218.         case 8:
    2219.             UpdateStructUnicode(base, aim, structIndex, sIndex[0], buff);
    2220.             break;
    2221.         case 4:
    2222.         case 9:
    2223.             UpdateStructInt64(base, aim, structIndex, sIndex[0], buff);
    2224.             break;
    2225.         default:
    2226.             return false;
    2227.         }
    2228.         iProc++;
    2229.     }
    2230.     return true;
    2231. }
    2232. bool NetClient::UpdateStructDouble(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2233. {
    2234.     double* writer = (double*)((char*)base + StructTable[structIndex].offset[index]);
    2235.     double* wtstream = (double*)buff;
    2236.     writer[0] = wtstream[0];
    2237.     buff = buff + sizeof(double);
    2238.     return true;
    2239. }
    2240. bool NetClient::UpdateStructAscii(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2241. {
    2242.     GASCII* writer = (GASCII*)((char*)base + StructTable[structIndex].offset[index]);
    2243.     int* Plen = (int*)buff;// 如果是字符串，第一个字节是一个int类型，用来表示字符串的长度
    2244.     buff = buff + 4;
    2245.     writer[0] = buff;
    2246.     buff = buff + Plen[0];
    2247.     return true;
    2248. }
    2249. bool NetClient::UpdateStructUnicode(void* base, PAIM aim, short structIndex, short index, char*& buff)
    2250. {
    2251.     GUNICODE* writer = (GUNICODE*)((char*)base + StructTable[structIndex].offset[index]);
    2252.     int* Plen = (int*)buff;// 如果是字符串，第一个字节是一个int类型，用来表示字符串的长度
    2253.     buff = buff + 4;
    2254.     writer[0] = (wchar_t*)buff;// 如果是宽字节需要强制转换，不然会乱码
    2255.     buff = buff + Plen[0];
    2256.     //CString txt;
    2257.     //txt.Format(L"%s %d", writer[0], StructTable[structIndex].offset[index]);
    2258.     //AfxMessageBox(txt);
    2259.     return true;
    2260. }
    2261. /*
    2262.  OnSverrNotice函数处理的数据包格式如下
    2263.     1E 06 00
    2264.     06 11 00 00 00 70 6C 61 79 5F 70 6F 69 6E 74 5F 73 6F 75 6E 64 00
    2265.     06 01 00 00 00 00
    2266.     04 2C 92 87 C5
    2267.     04 FA 03 BF 42
    2268.     04 33 14 BD 45
    2269.     02 00 00 00 00
    2270.     1E 06 00 是 PNR_NOTICE_HEAD
    2271.     06 11 00 00 00 70 6C 61 79 5F 70 6F 69 6E 74 5F 73 6F 75 6E 64 00是一个EnCode
    2272.     06 01 00 00 00 00是一个EnCode
    2273.     04 2C 92 87 C5是一个EnCode
    2274.     04 FA 03 BF 42是一个EnCode
    2275.     04 33 14 BD 45是一个EnCode
    2276.     02 00 00 00 00是一个EnCode
    2277. */
    2278. bool NetClient::OnSverNotice(char*& buff, unsigned& len) {
    2279.     PNR_NOTICE_HEAD head = (PNR_NOTICE_HEAD)(buff - 1);
    2280.     int icount = head->count;
    2281.     char* buffStart = (char*)head + sizeof(NR_NOTICE_HEAD);
    2282.     if (icount < 1) {
    2283.         return true;
    2284.     }
    2285.     if (icount > MAX_RECV_COUNT) {
    2286. #ifdef  Anly
    2287.         anly->SendData(TTYPE::I_DIS, S_NOTICE, "S_NOTICE 解码器内存不足", 24);
    2288. #endif
    2289.         return true;
    2290.     }
    2291.  
    2292. #ifdef  Anly
    2293.     GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0], 1);
    2294. #endif
    2295.  
    2296.     int stDecode = 0;
    2297.     EnCode codes[MAX_RECV_COUNT]{};
    2298.     while (stDecode < icount) {
    2299.         codes[stDecode++] = buffStart;
    2300.     }
    2301.     return OnSvrNotice((PNET_SEND_CHEAD)codes, icount, buff, len);
    2302. }
    2303.  
    2304. bool NetClient::OnSvrStartCreateRole(char*& buff, unsigned& len) {
    2305.     short* _st = (short*)&buff[1];
    2306.     wchar_t* _txt = (wchar_t*)&buff[3];
    2307. #ifdef  Anly
    2308.     CString txt;
    2309.     CStringA txtA;
    2310.     txt.Format(L"code:%d\r\n%s", _st[0], _txt);
    2311.     txtA = txt;
    2312.     //AfxMessageBox(txtA);
    2313.     anly->SendData(TTYPE::I_DIS, S_CREATEROLE_START, txtA.GetBuffer(), txt.GetAllocLength() + 1);
    2314. #endif
    2315.     /*
    2316.         OnSendCustom((PNET_SEND_CHEAD)codes, buff, len); 数据包传给虚函数
    2317.         如果想对0A开头的据包做些什么直接继承NetClient重写OnSendCustom函数既可以了
    2318.     */
    2319.     return OnScrStartCreateRole(_st[0], _txt);
    2320. }
    2321.  
    2322.

    NetClient.h文件的修改：新加 MailBox函数、OpenMailBox函数、CloseMailBox函数、Mail函数、MailEx函数、GetMail函数

    1. #pragma once
    2. #include "NetClass.h"
    3. #include "AIM.h"
    4. #include "ITEM.h"
    5. #include "SKILL.h"
    6. #include "GameSTRUCTRENAME.h"
    7.  
    8. #define CAMP_NAME_QH "xuanrenQH"
    9. #define CAMP_NAME_ZE "xuanrenZQ"
    10.  
    11. #define MAX_AIM 0x200
    12.  
    13. enum class OBJECT_TYPE {
    14. 	Equip = 0x01, // 装备栏，18 01 是装备，用于列表交换
    15. 	MountBag = 0x08, // 坐骑栏，18 08 是坐骑背包，用于列表交换
    16. 	Item = 0x02, // 物品栏，18 02 是角色背包，用于列表交换
    17. 	ItemEx = 0x03, // 扩展栏，18 03 是扩展背包，用于列表交换
    18. 	Skill = 0x28,  // 技能栏，18 28 是技能信息，用于列表交换
    19. 	Shop = 0x3D, // 商店，18 3D
    20. 	Pickup = 0x50 // 捨取，18 50 是打怪，怪死了之后掉落的捨取弹框
    21. };
    22.  
    23. typedef struct OBJECT_UNION {
    24. 	union {
    25. 		PITEM* item = nullptr;
    26. 		PSKILL* skill;
    27. 	};
    28.  
    29. 	/*
    30. 		short EquipMax = 0; // 装备栏数据个数
    31. 		short MountMax = 0; // 坐骑栏数据个数
    32. 		short ItemMax = 0; // 物品栏数据个数
    33. 		short ItemExMax = 0; // 扩展栏数据个数
    34. 		short SkillMax = 0; // 技能栏数据个数
    35. 	*/
    36. 	short Count = 0;
    37. 	short MaxCount = 0; // 装备栏数据个数，坐骑栏数据个数，物品栏数据个数，扩展栏数据个数，技能栏数据个数
    38. 	
    39. 	/*
    40. 		PITEM EquipAry = nullptr; // 装备栏，18 01 是装备，用于存放真正的数据
    41. 		PITEM MountBagAry = nullptr; // 坐骑栏，18 08 是坐骑背包，用于存放真正的数据
    42. 		PITEM ItemBagAry = nullptr; // 物品栏，18 02 是角色背包，用于存放真正的数据
    43. 		PITEM ItemExAry = nullptr; // 扩展栏，18 03 是扩展背包，用于存放真正的数据
    44. 		PSKILL SkillAry = nullptr;  // 技能栏，18 28 是技能信息，用于存放真正的数据
    45. 	*/
    46. 	union {
    47. 		PSKILL skillAry = nullptr;
    48. 		PITEM itemAry;
    49. 		void* Pointer;
    50. 	};
    51. }*POBJECT_UNION;
    52.  
    53. typedef bool (*PNetOperation)(char* buff, unsigned len);
    54.  
    55. class NetClient // 监视客户端每一个操作
    56. {
    57. 	typedef bool (NetClient::* DATAPROC)(char*&, unsigned&);
    58. public:
    59. 	AIM Player; // 玩家角色
    60. 	/* 
    61. 		怪物列表，最好排序，使用lId排序，然后使用二分查找实现快速查询
    62. 		结构用链表或者数组都可以
    63. 		怪物或附近玩家这种东西不可能会很多
    64. 		如果太多电脑处理不过来，所以数组设置为0x100大小差不多够用
    65. 	*/
    66. 	PAIM Aimlst[MAX_AIM]{};
    67. 	// 用来控制飞天
    68. 	bool HideMode;
    69. 	/*
    70. 		18 01 是装备
    71. 		18 02 是角色背包
    72. 		18 03 是扩展背包
    73. 		18 08 是坐骑背包
    74. 		18 31 是攻击技能
    75. 		18 28 是移动类型技能
    76. 		18 3D 商店数据
    77. 		18 50 捨取窗口数据
    78. 	*/
    79. 	OBJECT_UNION Equip; // 装备栏，18 01 是装备，用于列表交换
    80. 	OBJECT_UNION MountBag; // 坐骑栏，18 08 是坐骑背包，用于列表交换
    81. 	OBJECT_UNION Item; // 物品栏，18 02 是角色背包，用于列表交换
    82. 	OBJECT_UNION ItemEx; // 扩展栏，18 03 是扩展背包，用于列表交换
    83. 	OBJECT_UNION Skill;  // 技能栏，18 28 是技能信息，用于列表交换
    84. 	OBJECT_UNION Shop; // 商店，18 3D
    85. 	OBJECT_UNION Pickup; // 捨取，18 50 是打怪，怪死了之后掉落的捨取弹框
    86.  
    87. 	POBJECT_UNION GetGameOBJECTUnion(short MainIndex);// 获取一个物品或技能
    88. protected:
    89. 	PSTRUCT_DESC StructTable = nullptr;
    90. 	short* StructOffSet = nullptr; // 偏移表
    91. 	short MaxStruct = 0; // 结构体数量
    92.  
    93. 	char* StructTxt = nullptr;
    94. 	POBJ_DESC ObjectTable = nullptr;// 游戏的数据类型表
    95. 	char* ObjectTxt = nullptr;
    96. 	DATAPROC SendProc[0x100];
    97. 	DATAPROC RecvProc[0x100];
    98. 	bool DefaultProc(char*&, unsigned&);
    99. 	PNetOperation NetSend = nullptr;
    100. 	PNetOperation NetRecv = nullptr;
    101.  
    102. protected: // 消息处理函数-SEND
    103. 	bool OnClientlogin(char*& buff, unsigned& len); // 登录数据包的处理 I_LOGIN
    104. 	bool OnClientStartCreateRole(char*& buff, unsigned& len);  // 申请进入创建角色界面 I_CREATEROLE_START
    105. 	bool OnClientDelRole(char*& buff, unsigned& len);
    106. 	bool OnClientSendCustom(char*& buff, unsigned& len);
    107. 	bool OnClientCreateRole(char*& buff, unsigned& len);
    108. 	bool OnClientSelectRole(char*& buff, unsigned& len);
    109. protected: // 消息处理函数-RECV
    110. 	bool OnSvrTips(char*& buff, unsigned& len);
    111. 	bool OnSvrloginOk(char*& buff, unsigned& len);
    112. 	bool OnSvrStartCreateRole(char*& buff, unsigned& len);
    113. 	bool OnSverNotice(char*& buff, unsigned& len);
    114. 	bool OnSverObject(char*& buff, unsigned& len);
    115. 	bool OnSverStruct(char*& buff, unsigned& len);
    116. 	bool OnSvrObjectInit(char*& buff, unsigned& len);
    117. 	bool OnSvrObjectInitEx(char*& buff, unsigned& len);
    118. 	bool OnSvrUpdateCord(char*& buff, unsigned& len);
    119. 	bool OnSvrUpdateProperty(char*& buff, unsigned& len);
    120. 	bool OnSvrUpdatePropertyMu(char*& buff, unsigned& len);
    121. 	bool OnSvrRemoveObjectMu(char*& buff, unsigned& len);
    122. 	bool OnSvrUpdateCordEx(char*& buff, unsigned& len);
    123. 	bool OnSvrGameBase(char*& buff, unsigned& len);
    124. 	bool OnSvrGameBaseReset(char*& buff, unsigned& len);
    125. 	bool OnSvrGameBaseExChange(char*& buff, unsigned& len);
    126. 	bool OnSvrGameBaseDestroy(char*& buff, unsigned& len);
    127. 	bool OnSvrGameBaseSet(char*& buff, unsigned& len);
    128. 	bool OnSvrStructInit(char*& buff, unsigned& len); // 结构体数据初始化
    129. 	bool OnSvrStructClear(char*& buff, unsigned& len); // 结构体数据重置
    130. 	bool OnSvrStructDelete(char*& buff, unsigned& len); // 结构体数据删除
    131. 	bool OnSvrStructUpdate(char*& buff, unsigned& len); // 结构体数据更新
    132. 	
    133.  
    134. 	bool UpdateStruct(PAIM aim, short structIndex, char*& buff, short count); // 结构体数据更新
    135. 	bool UpdateStruct(PAIM aim, short structIndex, short index,char*& buff); // 结构体数据更新
    136. 	bool virtual UpdateStructByte(void* base, PAIM aim, short structIndex, short index,char*& buff);
    137. 	bool virtual UpdateStructShort(void* base, PAIM aim, short structIndex, short index,char*& buff);
    138. 	bool virtual UpdateStructInt(void* base, PAIM aim, short structIndex, short index,char*& buff);
    139. 	bool virtual UpdateStructInt64(void* base, PAIM aim, short structIndex, short index,char*& buff);
    140. 	bool virtual UpdateStructfloat(void* base, PAIM aim, short structIndex, short index,char*& buff);
    141. 	bool virtual UpdateStructDouble(void* base, PAIM aim, short structIndex, short index,char*& buff);
    142. 	bool virtual UpdateStructAscii(void* base, PAIM aim, short structIndex, short index,char*& buff);
    143. 	bool virtual UpdateStructUnicode(void* base, PAIM aim, short structIndex, short index,char*& buff);
    144. public:
    145. 	PROLEDATA roles;
    146. 	unsigned rolecount;
    147. 	bool logined = false;
    148. private:
    149.  
    150. 	bool DelRole(const wchar_t* rolename, unsigned _len);
    151. 	PAIM GetAimById(long long lId);
    152. 	PAIM CreateAim(long long lId);
    153. 	void RemoveAimById(long long lId);
    154. 	POBJECTBASE GetGameOBJECT(short MainIndex, short Index);// 获取一个物品或技能
    155. 	POBJECTBASE ReSetGameOBJECT(short MainIndex, short max);
    156. 	// 交换物品
    157. 	void ExChangeOBJECT(short MainIndex, short IndexFrom, short IndexTo);
    158. 	// 删除物品
    159. 	void DestoryOBJECT(short MainIndex, short Index);
    160. public:
    161. 	// 通过角色名获取附近角色的信息
    162. 	PAIM GetAimByName(const wchar_t* name);
    163. 	// 获取面向
    164. 	float GetFace(float x, float y, float targetX, float targetY);
    165. 	// 通过附近角色名获取它的信息，然后通过它的信息里的坐标，再通过我们角色坐标计算面向，效果就是面向 GetAimByName(name); 这个角色
    166. 	void FaceTo(const wchar_t* name);
    167. public:
    168. 	void virtual Init(PNetOperation _send, PNetOperation _recv);
    169. 	// 模拟接收的数据包
    170. 	bool SetCoord(long long lId, float x, float h, float y, float face);
    171. 	bool SetProperty(long long lId, int ProType, void* value);
    172. 	/*
    173. 		模拟登陆的方法
    174. 		Id是账号
    175. 		Pass是密码
    176. 		它要基于发送的方法实现，因为我们没有连接socket的操作
    177. 	*/
    178. 	bool login(const char* Id, const char* Pass);
    179. 	bool DelRole(const wchar_t* rolename);
    180. 	bool StartCreateRole();// 用于创建角色
    181. 	bool SelectCamp(const char* _campname);// 选择阵营
    182. 	/*
    183. 		性别 0 男 1 女
    185. 		阵营 1 艾森赫特 2 格兰蒂尔
    187. 		种族 1 布冯特人 3 格洛玛人 4 尤恩图人 6 喀什人
    189. 		职业 1 仲裁者 3秘法师 6 猎魔人 8 元素法师
    191. 		脸型 0 1 2 3
    192. 	*/
    193. 	bool CreateRole(wchar_t* name,double sex, double camp, double face, double occu, const char* photo, const char*infos, const char* txt, double faceShape);// 角色创建
    194. 	// 选择角色并且登录进游戏
    195. 	bool SelectRole(const wchar_t* rolename);
    196. 	// 坠落
    197. 	bool Fall();
    198. 	// 瞬移
    199. 	void Teleport(float x, float h, float y, float face);
    200. 	// 模拟停止
    201. 	bool MoveStop(float x, float h, float y, float face);
    202. 	// 原地跳
    203. 	bool MoveJump(float x, float h, float y, float face, float oldy, float xNext, float yNext);
    204. 	// 移动开始
    205. 	bool MoveWalk(float x, float h, float y, float face, float oldy, float xNext, float yNext);
    206. 	// 应该是移动时跳跃
    207. 	bool MoveWJump(float x, float h, float y, float face, float oldy, float xNext, float yNext);
    208. 	// 使用技能
    209. 	bool UseSkill(const char* _skillName, float x, float h, float y, float face, float xTarget = 0, float hTarget = 0, float yTarget = 0, int rInt1 = 0, int rInt2 = 0, int rInt3 = 0);
    210. 	// 使用物品
    211. 	bool UseItem(short BagIndex,short Index);
    212. 	// 交换物品
    213. 	bool ExChangeItem(short BagIndex,short Index, short tBagindex, short tIndex, bool IsEmpty = true);
    214. 	// 丢弃物品
    215. 	bool DropItem(short BagIndex,short Index, short Amount);
    216. 	// 拆分物品
    217. 	bool SplitItem(short BagIndex, short Index, short tBagindex, short tIndex, short Amount);
    218. 	// 召唤或解除坐骑
    219. 	bool Mount(short Index);
    220. 	// 拾取物品
    221. 	bool PickItem(short id, short Index);
    222. 	// 商店购买物品
    223. 	bool BuyItem(int shopPage, int shopIndex, int itemIndex, int Amount);
    224. 	// 卖物品给商店
    225. 	bool SoldItem(int MainIndex, int Index, int Amount);
    226. 	// 操作邮箱
    227. 	bool MailBox(int optype);
    228. 	// 打开邮箱窗口
    229. 	bool OpenMailBox();
    230. 	// 关闭邮箱窗口
    231. 	bool CloseMailBox();
    232. 	// 删除邮件
    233. 	bool Mail(const char* guid, int optype = SC_MAIL_READ);
    234. 	// 接收附件
    235. 	bool MailEx(const char* guid, int optype = SC_MAIL_GET, int opother = -1);
    236. 	// 接收附件
    237. 	bool GetMail(const char* guid);
    238.  
    239. 	// 根据角色名字获取一个登录成功数据包（选择角色列表里的一个数据）
    240. 	PROLEDATA GetRoleByName(const wchar_t* rolename);
    241. 	bool Talk(wchar_t* txt, int PdId = 1, double un = 0.0);
    242. 	bool TalkTo(wchar_t* name, wchar_t* txt, double un = 0.0);
    243. 	bool HeartBeep();// 心跳数据包（5秒）
    244. 	bool HeartLoop();// 延迟心跳数据包（20秒）
    245. 	bool Backtoroles(); // 返回到选择角色界面
    246. public:
    247. 	// 用于拦截游戏删除角色功能
    248. 	bool virtual OnDelRole(wchar_t* rolename, unsigned _len);
    249. 	// 用于拦截游戏登录功能
    250. 	void virtual Onlogin(const char* Id, const char*Pass);
    251. 	// 用于拦截游戏创建角色功能
    252. 	bool virtual OnStartCreateRole(int code);
    253. 	// 拦截创建角色
    254. 	bool virtual OnCreateRole(PNS_CREATEROLE _header, PCREATE_ROLE_DATAS _body);
    255. 	// opcode意思是操作码，count意思是数量，buffStart意思是解码的内容开始，buffend意思是解码的内容结束，buffer是原始的数据，len是原始数据的长度
    256. 	// char& buffer, int& len这俩参数带&的原因是，在 OnSendCustom 里进行修改之后，通过&的方式传递回去
    257. 	bool virtual OnSendCustom(PNET_SEND_CHEAD _coder, char*& buffer, unsigned& len);// 拦截0xA开头发送的数据包
    258. 	bool virtual OnSelectRole(wchar_t* rolename);
    259. public:
    260. 	// 针对SendCustom的单独处理
    261. 	bool virtual OnChooseCamp(PNS_CHOOSECAMP _coder);
    262. 	bool virtual OnChat(PCHAT_DATA _coder);
    263. 	bool virtual OnChatPublic(PCHAT_PUB _coder);
    264. 	bool virtual OnChatPrivate(PCHAT_PRV _coder);
    265. 	bool virtual OnHeartBeep(PHEART_BEEP _coder);
    266. 	bool virtual OnHeartLoop(PHEART_LOOP _coder);
    267. 	// 分发移动处理函数
    268. 	bool virtual OnMove(PMOVE_DATA _coder);
    269. 	// 移动中处理函数
    270. 	bool virtual OnMoveWalk(PMOVE_DATA_WALK _coder);
    271. 	// 停止移动处理函数
    272. 	bool virtual OnMoveStop(PMOVE_DATA_STOP _coder);
    273. 	// 跳跃处理函数
    274. 	bool virtual OnMoveJump(PMOVE_DATA_JUMP _coder);
    275. 	// 移动时跳跃
    276. 	bool virtual OnMoveWJump(PMOVE_DATA_WJUMP _coder);
    277. 	//  分发坠落函数
    278. 	bool virtual OnFall(PFALL_DATA_START _coder);
    279. 	// 针对Notice的单独处理
    280. 	bool virtual OnSvrChat(PCHAT_PRV _coder);
    281. 	bool virtual OnUseSkill(PUSESKILL _coder);
    282. 	bool virtual OnInited(); // 发送完了964数据包，表示角色上线
    283.  
    284. public:
    285. 	// 处理失败，参数是错误码
    286. 	bool virtual Tips(int code);
    287. 	void virtual loginok(ROLE_DATA* _roles, int count);
    288. 	bool virtual OnScrStartCreateRole(short code,wchar_t* _txt);
    289. 	bool virtual OnSvrNotice(PNET_SEND_CHEAD _coder, int count, char*& buffer, unsigned& len);
    290. public:
    291. 	bool virtual OnRecvData(char*& buff, unsigned& len);
    292. 	bool virtual OnSendData(char*& buff, unsigned& len);
    293. 	bool virtual OnConnect(char*& ip, unsigned& port);
    294.  
    295. };
    296.  
    297.

    NetClass.h文件的修改：新加 SC_MAIL宏、SC_MAIL_OPENBOX宏、SC_MAIL_READ宏、SC_MAIL_GETSC宏、SC_MAIL_DELETE宏、SC_MAIL_CLOSEMAIL宏、SC_MAIL_CLOSEBOX宏、SC_MAIL_GET宏、SC_MAIL_PAY宏、MAIL_OPERAION类、MAIL_OPERAION_RD类、MAIL_OPERAION_GET类

    1. #pragma once
    2. #include "EnCode.h"
    3.  
    4. // 数据包头
    5. // 发送
    6. #define I_LOGIN 0x2 // 登录
    7. #define I_CREATEROLE_START 0x3 // 创建角色发送数据包的头
    8. #define I_SELECT_ROLE 0x04 // 选择角色进入游戏的数据包头
    9. #define I_CREATEROLE 0x05 // 创建角色给服务端发送的数据包头
    10. #define I_DELROLE 0x6 // 删除角色发送数据包的头
    11. #define I_SEND_CUSTOM 0x0A // 进入游戏之后大部分数据包的头
    12.  
    13. // 接收
    14. #define S_TIPS 0x3 // 服务端返回错误的数据包头
    15. #define S_LOGINOK 0x4 // 登录成功的返回数据包的头
    16. // 创建角色服务端反馈的数据（发送03 01 00 00 00这个数据包服务端返回的数据包头）
    17. #define S_CREATEROLE_START 0x05
    18. #define S_OBJECT 0x9 // 数据类型表
    19. #define S_STRUCT 0xA // 里面有玩家角色坐标信息，进入游戏时它有数据结构描述的信息
    20. #define S_UPDATEPRO 0x10 // 更新角色怪物信息
    21. #define S_STRUCT_INITEX 0x11 // 结构体数据创建
    22. #define S_STRUCT_DELETE 0x12 // 删除结构体
    23. #define S_STRUCT_UPDATE 0x13 // 更新结构体
    24. #define S_STRUCT_CLEAR 0x14 // 重置结构
    25. #define S_GAMEBASE_RESET 0x15 // 通知更新数据
    26. #define S_GAMEBASE_SET 0x17 // 初步猜测是 通知更新数据0x15的补充
    27. #define S_GAMEBASE 0x18 // 杂项数据包，里面有技能的信息、装备的信息 还有未知的信息
    28. #define S_GAMEBASE_DROP 0x19 // 删除物品
    29. #define S_NOTICE 0x1E // 里面有聊天数据
    30. #define S_UPDATECORDEX 0x1F // 坐标修正
    31. #define S_UPDATECORD 0x21 // 坐标更新
    32. #define S_NOTICE_COM 0x27 // 里面有聊天数据
    33. #define S_OBJECT_INIT 0x28 // 里面有角色基础信息
    34. #define S_STRUCT_INIT 0x29 // 邮箱初始化或者说是初始化邮件，结构体数据创建
    35. #define S_GAMEBASE_EXCHANGE 0x2B // 物品交换
    36. #define S_UPDATEPROMU 0x2D // 更新信息
    37. #define S_UPDATEPROMU_COM 0x2E // 更新信息
    38. #define S_OBJECT_INITEX_UCOM 0x2F // 里面有附近NPC、玩家初始化信息，与0x30数据包一样只是它未压缩
    39. #define S_OBJECT_INITEX 0x30 // 里面有附近NPC、玩家初始化信息
    40. #define S_OBJECT_REMOVE 0x31 // 附近角色或怪物消失
    41.  
    42. /*
    43. 	最多的数据项, 0A开头的数据包里有数据参数个数，这个宏就是用来设定
    44. 	数据参数个数最大数量是多少，0A开头的数据包目前见过最大
    45. 	数据参数个数是十几个，这里写20应该完全够用，如果不够用
    46. 	到时候再增加
    47. */
    48. #define MAX_SEND_COUNT 100
    49. #define MAX_RECV_COUNT 100
    50. // 发送数据操作码定义
    51. #define SC_CHOOSECAMP 591 // 阵营选择操作码
    52. #define SC_CHAT 1
    53. #define SC_BEEP 81
    54. #define SC_LOOP 1015
    55. // 游戏客户端处理完进入游戏按钮触发的数据包之后，发送的请求
    56. #define SC_INITED 964
    57. #define SC_REONLINE 860
    58. #define SC_INIT_START 661
    59. #define SC_HAND 962
    60. #define SC_HAND_IN 102
    61.  
    62. #define SC_MOVE_HEADER 15 // 移动
    63. #define SC_FALL_HEADER 890 // 坠入摔血
    64. #define SC_INWATER 478 // 只要发了这个数据包就说明在水下了
    65. #define SC_USESKILL 211 // 使用技能
    66.  
    67. #define SC_ITEM_USE 31 // 使用物品发送的操作码
    68. #define SC_ITEM_EXCHANGE 30 // 交换物品发送的操作码-物品与空位置交换
    69. #define SC_ITEM_EXCHANGEEX 40 // 交换物品发送的操作码-物品与物品交换
    70. #define SC_ITEM_DROP 34 // 丢弃物品发送的操作码
    71. #define SC_ITEM_SPLIT 33 // 拆分物品发送的操作码
    72. #define SC_MOUNT 243 // 召唤或解除坐骑
    73.  
    74. #define SC_ITEM_PICK_START 380 // 拾取物品，后发送
    75. #define SC_ITEM_PICK_END 1008 // 拾取物品，优先发送
    76. #define SC_ITEM_SHOP 70 // 买/卖商店物品的数据头
    77. #define SC_ITEM_SHOP_BUY 20 // 买商店物品操作码
    78. #define SC_ITEM_SHOP_SOLD 21 // 卖物品给商店操作码
    79.  
    80. #define SC_MAIL 350 // 数据包操作码
    81. #define SC_MAIL_OPENBOX 0 // 打开邮箱窗口
    82. #define SC_MAIL_READ 3 // 读取邮件
    83. #define SC_MAIL_GETSC 4 // 收取附件
    84. #define SC_MAIL_DELETE 5 // 删除邮件
    85. #define SC_MAIL_CLOSEMAIL 6 // 关闭邮箱
    86. #define SC_MAIL_CLOSEBOX 7 // 关闭打开邮件窗口
    87. #define SC_MAIL_GET 8 // 收取附件
    88. #define SC_MAIL_PAY 10 // 给邮件付费
    89.  
    90. /*
    91. 	00 00 00 00 00 00 内存对齐补的0
    92. 	13 00 数据包头
    93. 	4D 49 00 01 6C 3D 4E 0A 接收者的id
    94. 	48 00 数据类型编号
    95. 	0F 00 数据个数
    96. 	04 00 00 04 00 00 00 72 00 00 00 发邮件的角色名
    97. 	04 00 01 21 00 00 00 35 38 41 39 34 42 43 30 43 44 39 42 34 38 42 34 39 36 33 46 46 37 38 39 46 46 30 42 30 41 35 37 00 校验码
    98. 	04 00 02 01
    99. 	04 00 03 00 8D 27 00 00 00 00 00
    100. 	04 00 04 01
    101. 	04 00 05 01
    102. 	04 00 06 10 00 00 00 71 00 31 00 71 00 31 00 71 00 31 00 31 00 00 00 邮件主题
    103. 	04 00 07 1C 00 00 00 1C 00 71 00 32 00 71 00 32 00 71 00 32 00 71 00 32 00 71 00 32 00 71 00 1D 00 00 00 邮件内容
    104. 	04 00 08 02 00 00 00 30 00
    105. 	04 00 09 42 00 00 00 3C 50 6F 73 74 20 67 6F 6C 64 3D 22 30 22 20 74 72 61 64 65 3D 22 30 22 20 74 69 6D 65 3D 22 32 30 32 34 2D 36 2D 31 32 20 32 30 3A 34 34 3A 35 30 22 20 75 72 67 65 6E 74 3D 22 31 22 20 2F 3E 0A 00 xml的东西里面有时间、是否加急、金币、物品的信息
    106. 	04 00 0A 13 00 00 00 32 30 32 34 2D 36 2D 31 32 20 32 30 3A 34 34 3A 35 30 00
    107. 	04 00 0B 00
    108. 	04 00 0C 21 00 00 00 42 37 30 45 33 41 35 46 41 36 30 41 34 37 42 30 39 38 32 46 43 46 37 35 37 31 44 39 32 34 32 46 00 校验码
    109. 	04 00 0D 02 00 00 00 30 00
    110. 	04 00 0E 01
    111. */
    112.  
    113. typedef struct NR_STRUCT_UPDATE {
    114. 	char un[6];
    115. 	char op = 0x29;
    116. 	char optype;
    117. 	union {
    118. 		long long lId;
    119. 		unsigned Index[2];
    120. 	};
    121. 	short StructIndex;
    122. 	short Count;
    123. 	char buff[2];
    124. }*PNR_STRUCT_UPDATE;
    125.  
    126. /*
    127. 	29 00
    128. 	9A 49 00 01 B1 5C 8C 0A
    129. 	48 00 表示48号结构体
    130. 	00 00 从什么位置开始修改
    131. 	04 00 修改几个
    133. 	11 00
    134. 	4D 49 00 01 6C 3D 4E 0A
    135. 	48 00
    136. 	04 00 从什么位置开始
    137. 	01 00 更新几个数据
    139. 	14 00 数据包头
    140. 	C3 45 00 01 4F 32 E7 0A 应该是人物id
    141. 	08 00 结构体序号
    143. 	12 00 数据包头
    144. 	AF 49 00 01 DA 03 50 0A 应该是人物id
    145. 	48 00 结构体序号
    146. 	01 00 删除的邮件序号
    148. */
    149.  
    150. typedef struct NR_STRUCT_INIT {
    151. 	char un[6];
    152. 	char op = 0x29;
    153. 	char optype;
    154. 	union {
    155. 		long long lId;
    156. 		unsigned Index[2];
    157. 	};
    158. 	short StructIndex;
    159. 	union {
    160. 		short Start;
    161. 		short DelIndex;
    162. 	};
    163. 	short Count;
    164. 	char buff[2];
    165. }*PNR_STRUCT_INIT;
    166.  
    167. /*
    168. 	17 op
    169. 	3D 00 背包编码（商店也是属于背包的一种） MainIndex
    170. 	01 00 参数个数 count
    171. 	FB 01 buff[2]
    172. 	0F 00 00 00 53 68 6F 70 5F 79 73 5F 71 68 5F 30 30 31 00 参数
    173. */
    174. typedef struct NR_GAMEBASE_SET {
    175. 	char un;
    176. 	char op;
    177. 	short MainIndex;
    178. 	unsigned short count;
    179. 	char buff[2];
    180.  
    181. }*PNR_GAMEBASE_SET;
    182.  
    183. /*
    184. 	交换物品的数据包
    185.     00 为了内存对齐补个0
    186. 	2B 
    187. 	02 00 
    188. 	04 00 
    189. 	06 00
    191. 	丢弃接收的数据包
    192. 	00 为了内存对齐补个0
    193. 	19
    194. 	02 00
    195. 	04 00
    196. */
    197. typedef struct NR_GAMEBASE_EXCHANGE {
    198. 	char un;
    199. 	char op = S_GAMEBASE_EXCHANGE;
    200. 	short MainIndex;
    201. 	union {
    202. 		short IndexFrom;
    203. 		short Index;
    204. 	};
    205. 	short IndexTo;
    206. }NR_GAMEBASE_DROP, *PNR_GAMEBASE_DROP, *PNR_GAMEBASE_EXCHANGE;
    207.  
    208. /*
    209.  	00 为了内存对齐补个0
    210. 	15 
    211. 	40 00 
    212. 	0E 00 
    213. 	01 00 
    214. 	FA 01 0E 00 00 00 
    215.  ------------------------------------------
    216. 	00 为了内存对齐补个0
    217. 	18
    218. 	28 00
    219. 	13 00
    220. 	05 00
    221. 	BC 01
    222. 	E8 03 00 00 61
    223. 	01 12 00 00 00 53 6B 69 6C 6C 5F 47 6C 31 32 34 30 5F 30 31 5F 31 00
    224. 	F8 01 01 00
    225. 	07 00 01 00 00 00
    226. 	B6 00 20 4E 00 00
    227. */
    228. typedef struct NR_GAMEBASE {// 15与18数据包的头部，当前用于技能与装备的结构
    229. 	char un;
    230. 	char op;
    231. 	short type;
    232. 	union 
    233. 	{
    234. 		short index;
    235. 		short max;
    236. 	};
    237. 	short count;
    238. }NR_GAMEBASE_RESET, *PNR_GAMEBASE, *PNR_GAMEBASE_RESET;
    239. /*
    240. 	1F
    241. 	87 44 00 01 7F B0 D6 05
    242. 	FE AD DE C3
    243. 	6C F5 46 42
    244. 	07 FD 36 C4
    245. 	90 D9 9C 40
    246. */
    247. typedef struct NR_UPDATECOORD {
    248. 	char un[6];
    249. 	char len = sizeof(NR_UPDATECOORD) - 7;
    250. 	char op = S_UPDATECORDEX;
    251. 	long long lId;
    252. 	float x;
    253. 	float h;
    254. 	float y;
    255. 	float face;
    256. }*PNR_UPDATECOORD;
    257.  
    258. /*
    259. 	31 
    260. 	01 00 个数
    261. 	9B 49 00 01 D5 8C 98 05 id
    262. 	内存对齐
    263. 	00 00 00 00 00 31 01 00 // 补五个0与id的8字节对齐
    264. 	9B 49 00 01 D5 8C 98 05 
    265. */
    266. typedef struct NR_OBJECT_REMOVEMU {
    267. 	char un[4];
    268. 	char len;
    269. 	char op = 0x31;
    270. 	short objCount = 0;
    271. 	long long lId[2];// 这里是一个指针，[]里写什么都行
    272. }*PNR_OBJECT_REMOVEMU;
    273. /*
    274. 	角色怪物数据更新结构 2D和2E
    275. 	00 00 00 00 00 2D 01 00
    276. 	9B 49 00 01 D5 8C 98 05
    277. 	02 00
    278. 	25 00 18 00 00 00
    279. 	29 00 BA 01 00 00
    280. */
    281. typedef struct NR_OBJECT_UPDATEPROMU {
    282. 	char un1[4]; // 为了向id数据的8字节对齐
    283. 	char len;
    284. 	char op = 0x2D;
    285. 	short objCount = 0;
    286. 	long long lId;
    287. 	short icount;
    288. 	short itype;
    289. }NR_OBJECT_UPMU, * PNR_OBJECT_UPMU;
    290.  
    291. /*角色怪物基本信息更新 接收的10数据包结构体*/
    292. /*
    293. 	00 00 为了内存对齐补零
    294. 	10 00
    295. 	78 48 00 01 FC 61 79 05
    296. 	01 00
    297. 	29 00 65 09 00 00
    298. */
    299. typedef struct NR_OBJECT_UPDATEPRO {
    300. 	char un1[5]; // 为了向id数据的8字节对齐
    301. 	char len;
    302. 	char op = 0x10;
    303. 	char MsgId = 0x00;
    304. 	union
    305. 	{
    306. 		long long lId;
    307. 		unsigned Index[2];
    308. 	};
    309. 	short icount = 1;
    310. 	short itype;
    311. 	union
    312. 	{
    313. 		char buff[0x04];
    314. 		int lenth;
    315. 	};
    316. 	char buffEnd[0x196];
    317. }NR_OBJECT_UP, *PNR_OBJECT_UP;
    318. /*
    319.   角色怪物初始化结构
    320. 	00 00 00 00 00 30 0B 00
    321. 	82 0B 00 01 82 0B 00 00
    322. 	69 59 F8 C3
    323. 	67 49 FF 41
    324. 	FE 55 9C 42
    325. 	C6 70 BA 40
    326. 	A8 8F 07 C4
    327. 	06 52 58 41
    328. 	3B D0 2A 43
    329. 	C6 70 BA 40
    330. 	00 00 20 41
    331. 	00 00 00 00
    332. 	00 00 00 00
    333. 	00 00 00 00
    334. 	04 00 00 00
    335. 	11 00
    336. */
    337.  
    338. typedef struct NR_OBNJECT_INITEX {
    339. 	char un1[4];
    340. 	char len = sizeof(NR_OBNJECT_INITEX) - 7;
    341. 	char op = 0x30;
    342. 	short obj_count;
    343. 	long long lId;
    344. 	float x;
    345. 	float h;
    346. 	float y;
    347. 	float face;
    348. 	float tx;
    349. 	float th;
    350. 	float ty;
    351. 	float tface;
    352. 	int State;
    353. 	float un2[4]{};
    354. 	short icount;
    355. 	short type;
    356. }*PNR_OBJINITEX;
    357.  
    358. // 角色初始化数据
    359. /*
    360. 	28  op
    361. 	E6 44 00 01 39 0A 63 04 lId
    362. 	6F 3A 07 C4 x
    363. 	49 C8 81 41 h
    364. 	46 1E 40 44 y
    365. 	BC 74 03 40 face
    366. 	6F 3A 07 C4 tx
    367. 	49 C8 81 41 th
    368. 	46 1E 40 44 ty
    369. 	BC 74 03 40 tface
    370. 	00 00 00 00 un[0]
    371. 	00 00 00 00 un[1]
    372. 	00 00 00 00 un[2]
    373. 	00 00 00 00 un[3]
    374. 	00 00 00 00 un[4]
    375. 	5E 00 icount
    377. 	多出来的type是为了内存对齐才写的
    378. */
    379. typedef struct NR_OBNJECT_INIT {
    380. 	char un1[6];
    381. 	char len = sizeof(NR_OBNJECT_INIT) - 9;
    382. 	char op = 0x28;
    383. 	long long lId;
    384. 	float x;
    385. 	float h;
    386. 	float y;
    387. 	float face;
    388. 	float tx;
    389. 	float th;
    390. 	float ty;
    391. 	float tface;
    392.  
    393. 	float un2[5]{};
    394. 	short icount;
    395. 	short type;
    396. }*PNR_OBJINIT;
    397. // 保存结构数据描述信息的结构体
    398. typedef struct STRUCT_DESC {
    399. 	char* name;
    400. 	int count;// 为了内存对齐这里使用int类型
    401. 	char* buff;
    402. 	short* offset;
    403. }*PSTRUCT_DESC;
    404. // 保存对象数据描述信息的结构体（游戏数据类型表）
    405. typedef struct OBJECT_DESC {
    406. 	char* name;
    407. 	int type;
    408. }*POBJ_DESC;
    409.  
    410. // 数据头结构体 数据结构约定
    411. // 也就是接收到1E包的头部
    412. typedef struct NR_NOTICE_HEAD {
    413. 	char un;
    414. 	char op;
    415. 	short count;
    416. }NR_HEAD, *PNR_HEAD, *PNR_NOTICE_HEAD;
    417.  
    418. // 选择角色头部
    419. typedef struct NET_SEND_SELECTROLE {
    420. 	char op = 0x04;
    421. 	char buff[83]{};
    422. }NS_SELECTROLE, * PNS_SELECTROLE;
    423.  
    424. // 创建角色数据头部
    425. typedef struct NET_SEHD_CREATEROLE_HEAD {
    426. 	/*
    427. 		char un[0x2];
    428. 		char len = sizeof(NET_SEHD_CREATEROLE_HEAD) - 0x03;
    429. 		这俩代码是为了解决内存对齐的问题，创建角色给服务端发送的
    430. 		05开头的数据包，把05变成00 00 00 05
    431. 	*/
    432. 	char un[0x2];
    433. 	char len = sizeof(NET_SEHD_CREATEROLE_HEAD) - 0x03;
    434. 	char op = 0x05;
    435. 	int index = 0x0; // 选择角色列表索引
    436. 	/*
    437. 		宽字节是2字节0x10是16两个是32，正好满足
    438. 		给服务端发送的创建角色数据包，也就是05开头的数据包
    439. 	*/
    440. 	wchar_t name[0x20];
    441. 	short unst = 0x00;
    442. 	short count = 0x08;
    443. }*PNS_CREATEROLE;
    444.  
    445. // 基类
    446. typedef class NET_SEND_BASE {
    447. public:
    448. 	// 实现编码操作，模拟游戏数据包给服务端发送数据，这个模拟的数据包通过调用 CodeMe函数得到
    449. 	unsigned CodeMe(int size, char* buffer);
    450. }NSR_BASE, *PNET_SEND_BASE, * PNSR_BASE;
    451.  
    452. typedef struct NS_CREATEROLE_HEAD_BUFF :public NET_SEHD_CREATEROLE_HEAD {
    453. 	char buff[0x300]{};
    454. }*PNS_CREATEROLEBUFF;
    455.  
    456. // 解析约定结构体
    457. // 创建角色数据结构体
    458. typedef class CREATE_ROLE_DATAS:public NET_SEND_BASE {
    459. public:
    460. 	GDOUBLE sex;//1.000000 性别 0 男 1 女
    461. 	GDOUBLE camp;//1.000000 阵营 1 艾森赫特 2 格兰蒂尔
    462. 	GDOUBLE face;//1.000000 种族 1 布冯特人 3 格洛玛人 4 尤恩图人 6 喀什人
    463. 	GDOUBLE occu;//3.000000 职业 1 仲裁者 3秘法师 6 猎魔人 8 元素法师
    464. 	GCHAR Photo;//gui\BG_team\TeamRole\Teamrole_zq_humF_001.PNG
    465. 	GCHAR Infos;//Face,0;Hat,0;Eyes,0;Beard,0;Ears,0;Tail,0;Finger,0;Cloth,0;Pants,0;Gloves,0;Shoes,0;Trait,0;HairColor,0;SkinColor,0;SkinMtl,0;Tattoo,0;TattooColor,16777215;
    466. 	GCHAR Txt;// 细节编辑捏脸
    467. 	GDOUBLE faceSahpe;//0.000000 脸型 0 1 2 3
    468. }* PCREATE_ROLE_DATAS;
    469.  
    470.  
    471. // 发送数据标准头 0xA数据包
    472. typedef struct NET_SEND_HEAD {
    473. 	// 为了内存对齐，当前结构不可能超过255，所以这样写是没问题的
    474. 	char len = sizeof(NET_SEND_HEAD) - 1;
    475. 	char op = 0x0A;
    476. 	short unst = 0;
    477. 	int unnt[4]{};
    478. 	short unst1 = 0;
    479. 	short count = 0;
    480. }*PNET_SEND_HEAD;
    481. // 开始创建角色的数据结构
    482. // 申请创建角色结构体
    483. typedef struct NET_CREATEROLE_START {
    484. 	char un[0x02];// 用来做内存对齐
    485. 	char len = sizeof(NET_CREATEROLE_START) - 3;// 用来做内存对齐
    486. 	char op = 0x03;
    487. 	int code = 0x01;
    488. }*PNET_CREATEROLE_START;
    489.  
    490. // 删除角色数据结构
    491. typedef struct DATA_DELROLE {
    492. 	char op;
    493. 	char buff[0x1F];
    494. 	int len;
    495. 	int un[8] = { 0x01 , 0x03 };
    496.  
    497. }*PDATADELROLE;
    498.  
    499. /*
    500. 	数据包还原结构体要注意内存对齐，如果数据不满4字节，它字段会补齐
    501. 	比如结构体里有一个char变量，它是1字节，在内存里它可能会为了内存对齐
    502. 	让它变成4字节，所以这要注意
    503. */
    504. // 登录数据
    505. typedef struct DATA_LOGIN {
    506. 	int op = 0x0300;
    507. 	char buff[0x10]{};
    508. 	int lenId = 0x10;
    509. 	/*
    510. 		这个是登录的账号，它可能会变成0x20或更长，现在默认让它0x10
    511. 		读的时候以长度为准就好了
    512. 	*/
    513. 	char Id[0x10]{};
    514. 	int lenPass = 0x10;
    515. 	/*
    516. 		这个是登录的密码，它可能会变成0x20或更长，现在默认让它0x10
    517. 		读的时候以长度为准就好了
    518. 	*/
    519. 	char Pass[0x10]{};
    520. 	int lenCode = 0x10;
    521. 	char Code[0x10]{};
    522. 	int eop = 0x01;
    523. }*PDATALOGIN;
    524. typedef struct DATA_LOGIN_OK {// 登录成功数据包头
    525. 	int un[8] = { 0, 0, 0x76B, 0x0C, 0x1E,0, 0, 0 };
    526. 	int index = 0;
    527. 	int RoleCount = 0;
    528. }*PDATALOGINOK;
    529.  
    530. // 发送数据包含内存空间，也就是数据参数，数据参数的意思看44文章里的内容
    531. typedef struct NET_SEND_BUFF:public NET_SEND_HEAD {
    532. 	char buff[0x1000]{};
    533. }*PNET_SEND_BUFF;
    534.  
    535. typedef class  NET_SEND_CHEAD:public NET_SEND_BASE {
    536. public:
    537. 	union {
    538. 		GCHAR msgHeader;
    539. 		GINT opcode;
    540. 	};
    541. public:
    542. 	NET_SEND_CHEAD() {};
    543. 	~NET_SEND_CHEAD() {};
    544. }NSR_CHEAD, *PNSR_CHEAD, *PNET_SEND_CHEAD;
    545.  
    546. // 选择角色
    547. typedef class NET_SEND_CHOOSECAMP :public NET_SEND_CHEAD {
    548. public:
    549. 	GCHAR camps;
    550. }*PNS_CHOOSECAMP;
    551.  
    552. // 心跳包数据结构
    553. typedef class HEART_BEEP :public NET_SEND_CHEAD {
    554. public:
    555. 	// 20秒一次
    556. 	GINT tick;//3
    557. }*PHEART_BEEP;
    558.  
    559. typedef class HEART_LOOP :public NET_SEND_CHEAD {
    560. public:
    561. 	// 5秒一次
    562. 	GINT64 tick;//9320695
    563. 	GCHAR txt;//
    564.  
    565. }*PHEART_LOOP;
    566.  
    567. typedef struct ONLINE_HAND: public NSR_CHEAD{
    568. 	GINT step; // 2
    569. 	GINT state; // 1
    570. }*PONLINE_HAND;
    571.  
    572. typedef struct ONLINE_INIT : public NSR_CHEAD {
    573. 	GINT state;//0
    574. 	GDOUBLE un;//180000000.000000
    575. }*PONLINE_INIT;
    576. // 登陆后角色数据区
    577. // 聊天数据包的数据结构
    578. typedef class CHAT_DATA :public NET_SEND_CHEAD {
    579. public:
    580. 	GINT ChartId;//1
    581. }*PCHAT_DATA;
    582. typedef class CHAT_PUBLIC :public CHAT_DATA {
    583. public:
    584. 	GUTF16 txt;//[222222222222222222222222222222222222222222]
    585. 	GDOUBLE un;//0.000000
    586. }*PCHAT_PUB;
    587. typedef class CHAT_PRIVATE :public CHAT_DATA {
    588. public:
    589. 	GUTF16 txt;//[222222222222222222222222222222222222222222]
    590. 	GUTF16 name;//[皮革兔]
    591. 	GDOUBLE un;//0.000000
    592. }*PCHAT_PRV;
    593.  
    594.  
    595. // 登陆后角色数据包
    596. typedef class ROLE_DATA {// 登录成功数据包
    597. public:
    598. 	GBYTE byte;
    599. 	GINT index;
    600. 	GINT un1;
    601. 	GUTF16 name;
    602. 	GUTF16 infos;
    603. 	GINT un2;
    604. 	GINT64 un3;
    605. }*PROLEDATA;
    606.  
    607. typedef class MOVE_DATA :public NET_SEND_CHEAD {
    608. public:
    609. 	GINT Mode; // 0停止 1移动中 2跳跃
    610. 	GINT Count; // 带入场景这里就是一共有几个与坐标相关的数据
    611. }*PMOVE_DATA;
    612.  
    613. // 停止移动
    614. typedef class MOVE_DATA_STOP :public MOVE_DATA {
    615. public:
    616. 	GFLOAT x;//-584.845459
    617. 	GFLOAT h;//65.004677
    618. 	GFLOAT y;//708.458740 
    619. 	GFLOAT face;//4.912942
    620. }*PMOVE_DATA_STOP;
    621.  
    622. // 移动
    623. typedef class MOVE_DATA_WALK :public MOVE_DATA {
    624. public:
    625. 	GFLOAT x;//-584.845459 当前坐标 x
    626. 	GFLOAT h;//65.004677 当前坐标 h
    627. 	GFLOAT y;//708.458740 当前坐标 y
    628. 	GFLOAT xNext;//-596.604919 预计移动到的坐标
    629. 	GFLOAT yNext;//710.849304 预计移动到的坐标
    630. 	GFLOAT MoveSpeed;//5.000000 移动速度
    631. 	GFLOAT GSpeed;//0.000000 根据跳跃的数据包猜测它是重力加速（也就是坠落的速度）
    632. 	GFLOAT face;//4.912942 面向
    633. }*PMOVE_DATA_WALK;
    634.  
    635. // 跳跃或往前跳（前后左右跳）
    636. typedef class MOVE_DATA_JUMP:public MOVE_DATA {
    637. public:
    638. 	GFLOAT x;//-599.624939
    639. 	GFLOAT h;//65.004105
    640. 	GFLOAT y;//711.464600
    641. 	GFLOAT xNext;//-599.624939
    642. 	GFLOAT yNext;//711.464600
    643. 	GFLOAT MoveSpeed;//5.000000
    644. 	GFLOAT JumpSpeed;//4.500000
    645. 	GFLOAT GSpeed;//9.800000 重力加速（也就是坠落的速度）
    646. 	GFLOAT face;//4.912942
    647. }*PMOVE_DATA_JUMP;
    648.  
    649. // 移动时跳跃
    650. typedef class MOVE_DATA_WJUMP :public MOVE_DATA {
    651. public:
    652. 	GFLOAT x;//-394.622162
    653. 	GFLOAT h;//8.719633
    654. 	GFLOAT y;//912.655151
    655. 	GFLOAT xNext;//-400.995270
    656. 	GFLOAT yNext;//902.487366
    657. 	GFLOAT MoveSpeed;//50.000000
    658. 	GFLOAT face;//3.701483
    659. }*PMOVE_DATA_WJUMP;
    660.  
    661. // 开始坠落
    662. typedef class FALL_DATA_START :public NET_SEND_CHEAD {
    663. public:
    664. 	GINT Mode;//890
    665. 	GINT StartH;//1
    666. 	GFLOAT NextH;//58.223557
    667. 	GINT EndH;//0
    668.  
    669. }*PFALL_DATA_START;
    670.  
    671. // 坠落结束
    672. typedef class FALL_DATA_STOP :public NET_SEND_CHEAD {
    673. public:
    674. 	GINT Mode;//2
    675. 	GFLOAT StartH;//58.223557
    676. 	GFLOAT NextH;//48.128914
    677. 	GFLOAT EndH;//24.581387
    678. }*PFALL_DATA_STOP;
    679.  
    680. // 释放技能结构
    681. typedef class USESKILL_DATA :public NET_SEND_CHEAD {
    682. public:
    683. 	//GINT gint;//211
    684. 	GCHAR skillName;//Skill_In1025_01_1
    685. 	GFLOAT x;//-522.842712，猜测它是使用技能的坐标
    686. 	GFLOAT h;//8.122560，猜测它是使用技能的坐标
    687. 	GFLOAT y;//866.518250，猜测它是使用技能的坐标
    688. 	GFLOAT face;//5.872537 面向
    689. 	GFLOAT xTarget;//0.000000 释放技能的目标位置，也就是技能释放到哪
    690. 	GFLOAT hTarget;//0.000000 释放技能的目标位置，也就是技能释放到哪
    691. 	GFLOAT yTarget;//0.000000 释放技能的目标位置，也就是技能释放到哪
    692. 	GINT un0;//0
    693. 	GINT un1;//0
    694. 	GINT un2;//1
    695. }*PUSESKILL;
    696.  
    697. /*
    698. 	装备替换
    699. 	GINT gint;//40
    700. 	GINT gint;//2
    701. 	GINT gint;//1
    702. 	GINT gint;//1
    703. 	GINT gint;//3
    704. 	装备装备
    705. 	(注意这个不是替换装备，这是比如帽子这个装备，然后当前身上并没有装备帽子，帽子在背包中，这时装备帽子就会是下方的数据包)
    706. 	GINT gint;//30
    707. 	GINT gint;//2
    708. 	GINT gint;//20
    709. 	GINT gint;//1
    710. 	GINT gint;//1
    711. 	物品数量拆分
    712. 	GINT gint;//33
    713. 	GINT gint;//2
    714. 	GINT gint;//3
    715. 	GINT gint;//2
    716. 	GINT gint;//18
    717. 	GINT gint;//3
    718. 	物品合并
    719. 	GINT gint;//40
    720. 	GINT gint;//2
    721. 	GINT gint;//18
    722. 	GINT gint;//2
    723. 	GINT gint;//3
    724. 	物品交换：物品与物品交换
    725. 	GINT gint;//40
    726. 	GINT gint;//2
    727. 	GINT gint;//6
    728. 	GINT gint;//2
    729. 	GINT gint;//5
    730. 	物品交换：物品与空位置交换
    731. 	GINT gint;//30
    732. 	GINT gint;//2
    733. 	GINT gint;//5
    734. 	GINT gint;//2
    735. 	GINT gint;//4
    736. 	使用物品
    737. 	GINT gint;//31 使用物品的操作码
    738. 	GINT gint;//2 背包编号
    739. 	GINT gint;//15 物品在背包中的位置
    740. 	丢弃物品
    741. 	GINT gint;//34 丢弃物品的操作码
    742. 	GINT gint;//2 背包编号
    743. 	GINT gint;//1 物品在背包中的位置
    744. 	GINT gint;//3 数量
    745. */
    746. // 召唤或解除坐骑
    747. typedef class MOUNT_DATA :public NET_SEND_CHEAD {
    748. public:
    749. 	GINT Index;
    750. }ITEM_PICK_DATA,*PMOUNT_DATA, *PMOUNT_DATA;
    751. // 使用物品发送的数据包的结构
    752. typedef class ITEMOP_DATA :public NET_SEND_CHEAD {// 物品丢弃、使用、拆分、合并交换相关数据包的结构
    753. public:
    754. 	GINT MainIndex; // 背包编码
    755. 	GINT Index; // 物品所在背包的位置
    756. }ITEM_USE_DATA, *PITEMOP_DATA, *PITEM_USE_DATA;
    757. // 丢掉物品发送的数据包的结构
    758. typedef class ITEM_DROP_DATA :public ITEMOP_DATA {
    759. public:
    760. 	GINT Amount; // 物品的数量
    761. }*PITEM_DROP_DATA;
    762. // 交换物品
    763. typedef class ITEM_EXCHANGE_DATA :public ITEMOP_DATA {
    764. public:
    765. 	GINT TargetId; // 背包编号，在这里的意思是交换到什么背包里
    766. 	GINT TargetIndex; // 物品所在背包的位置，也就是物品在 TargetId 里什么位置
    767. }*PITEM_EXCHANGE_DATA;
    768. // 拆分物品
    769. typedef class ITEM_SPLIT_DATA :public ITEMOP_DATA {
    770. public:
    771. 	GINT TargetId; // 背包编号，在这里的意思是拆分到什么背包里
    772. 	GINT TargetIndex; // 物品所在背包的位置，也就是物品在 TargetId 里什么位置
    773. 	GINT TargetAmount; // 拆分的数量
    774. }*PITEM_SPLIT_DATA;
    775.  
    776. /*
    777. 	GINT gint;//70 数据头
    778. 	GINT gint;//20 操作码
    779. 	GCHAR gchar;//Shop_ys_qh_001 商店id
    780. 	GINT gint;//1 商店物品页码
    781. 	GINT gint;//1
    782. 	GINT gint;//4 物品所在商店位置
    783. 	GINT gint;//1 数量
    784. 	GINT gint;//0
    785. 	GINT gint;//0
    786. */
    787. typedef class ITEM_BUY_DATA : public NET_SEND_CHEAD {
    788. public:
    789. 	GINT opMode;//20 操作码
    790. 	GCHAR ShopId;//Shop_ys_qh_001 商店id
    791. 	GINT ShopPage;//1 商店物品页码
    792. 	GINT ShopIndex;//1
    793. 	GINT Index;//4 物品所在商店位置
    794. 	GINT Amount;//1 数量
    795. 	GINT un1;//0
    796. 	GINT un2;//0
    797. }*PITEM_BUY_DATA;
    798.  
    799. /*
    800. 	GINT gint;//70
    801. 	GINT gint;//21
    802. 	GINT gint;//0
    803. 	GCHAR gchar;//Shop_ZH_005
    804. 	GINT gint;//2
    805. 	GINT gint;//1
    806. 	GINT gint;//30
    807. */
    808. typedef class ITEM_SOLD_DATA : public NET_SEND_CHEAD {
    809. public:
    810. 	GINT opMode;//21
    811. 	GINT un1;//0
    812. 	GCHAR ShopId;//Shop_ZH_005
    813. 	GINT MainIndex;//2
    814. 	GINT Index;//1
    815. 	GINT Amount;//30
    816. }*PITEM_SOLD_DATA;
    817.  
    818. /*
    819.   打开邮箱窗口
    820. 	GINT gint;//350
    821. 	GINT gint;//3
    822. 	GCHAR gchar;//2C3B97C1C6E542AD90E540E6A4C8754C
    823.   删除邮件
    824. 	GINT gint;//350
    825. 	GINT gint;//5
    826. 	GCHAR gchar;//B70E3A5FA60A47B0982FCF7571D9242F
    827. */
    828. typedef class MAIL_OPERAION : public NET_SEND_CHEAD {
    829. public:
    830. 	GINT optype;//3
    831. 	// GCHAR gchar;//2C3B97C1C6E542AD90E540E6A4C8754C
    832. }*PMAIL_OPERAION;
    833.  
    834. // 邮件的读取删除
    835. typedef class MAIL_OPERAION_RD : public MAIL_OPERAION {
    836. public:
    837. 	GCHAR Guid;//2C3B97C1C6E542AD90E540E6A4C8754C
    838. }*PMAIL_OPERAION_RD;
    839.  
    840. /*
    841.   附件收取
    842. 	GINT gint;//350
    843. 	GINT gint;//8
    844. 	GCHAR gchar;//6AB6F03436154524A73CFF5C12D6691C
    845. 	GINT gint;//-1
    846. */
    847. typedef class MAIL_OPERAION_GET : public MAIL_OPERAION_RD {
    848. public:
    849. 	GINT opother;//-1
    850. }*PMAIL_OPERAION_GET;
    851.  
    852.  
    853.

    GameSTRUCTRENAME.h文件的修改：修改 RecvLetterRec类

    1. #pragma once
    2. #define GASCII CStringA
    3. #define GUNICODE CString
    4. #define GOBJECT long long
    5. // [1][OpenTransPointRec]
    6.  
    7. typedef class OpenTransPointRec{
    8. public:
    9.     int value_0;
    10. }*POpenTransPointRec;
    11. // [2][capital_rec]
    12.  
    13. typedef class capital_rec{
    14. public:
    15.     GASCII value_0;
    16.     char value_1;
    17.     long long value_2;
    18. }*Pcapital_rec;
    19. // [3][SkillType_Lock_State_Rec]
    20.  
    21. typedef class SkillType_Lock_State_Rec{
    22. public:
    23.     GASCII value_0;
    24. }*PSkillType_Lock_State_Rec;
    25. // [4][SkillType_Rec]
    26.  
    27. typedef class SkillType_Rec{
    28. public:
    29.     int value_0;
    30. }*PSkillType_Rec;
    31. // [5][NormalSkill_Pos_Rec]
    32.  
    33. typedef class NormalSkill_Pos_Rec{
    34. public:
    35.     short value_0;
    36.     short value_1;
    37.     short value_2;
    38. }*PNormalSkill_Pos_Rec;
    39. // [6][count_limit_rec]
    40.  
    41. typedef class count_limit_rec{
    42. public:
    43.     short value_0;
    44.     short value_1;
    45.     double value_2;
    46. }*Pcount_limit_rec;
    47. // [7][connect_skill_rec]
    48.  
    49. typedef class connect_skill_rec{
    50. public:
    51.     GASCII value_0;
    52.     long long value_1;
    53.     int value_2;
    54. }*Pconnect_skill_rec;
    55. // [8][PropRefreshCompute]
    56.  
    57. typedef class PropRefreshCompute{
    58. public:
    59.     GASCII value_0;
    60.     char value_1;
    61.     double value_2;
    62.     double value_3;
    63.     double value_4;
    64.     double value_5;
    65.     double value_6;
    66. }*PPropRefreshCompute;
    67. // [9][HeadDetailRecord]
    68.  
    69. typedef class HeadDetailRecord{
    70. public:
    71.     char value_0;
    72.     char value_1;
    73. }*PHeadDetailRecord;
    74. // [a][relive_point_rec]
    75.  
    76. typedef class relive_point_rec{
    77. public:
    78.     char value_0;
    79.     GASCII value_1;
    80. }*Prelive_point_rec;
    81. // [b][target_hate_rec]
    82.  
    83. typedef class target_hate_rec{
    84. public:
    85.     GUNICODE value_0;
    86.     int value_1;
    87. }*Ptarget_hate_rec;
    88. // [c][cooldown_rec]
    89.  
    90. typedef class cooldown_rec{
    91. public:
    92.     int value_0;
    93.     long long value_1;
    94.     long long value_2;
    95.     int value_3;
    96. }*Pcooldown_rec;
    97. // [d][nocooldown_team_rec]
    98.  
    99. typedef class nocooldown_team_rec{
    100. public:
    101.     int value_0;
    102. }*Pnocooldown_team_rec;
    103. // [e][nocooldown_skill_rec]
    104.  
    105. typedef class nocooldown_skill_rec{
    106. public:
    107.     int value_0;
    108.     int value_1;
    109. }*Pnocooldown_skill_rec;
    110. // [f][fight_relation_rec]
    111.  
    112. typedef class fight_relation_rec{
    113. public:
    114.     GOBJECT value_0;
    115.     short value_1;
    116. }*Pfight_relation_rec;
    117. // [10][attack_back_rec]
    118.  
    119. typedef class attack_back_rec{
    120. public:
    121.     GOBJECT value_0;
    122.     char value_1;
    123.     GUNICODE value_2;
    124. }*Pattack_back_rec;
    125. // [11][fly_path_rec]
    126.  
    127. typedef class fly_path_rec{
    128. public:
    129.     float value_0;
    130.     float value_1;
    131.     float value_2;
    132.     short value_3;
    133. }*Pfly_path_rec;
    134. // [12][battlewar_statistics]
    135.  
    136. typedef class battlewar_statistics{
    137. public:
    138.     char value_0;
    139.     GUNICODE value_1;
    140.     char value_2;
    141.     char value_3;
    142.     int value_4;
    143.     int value_5;
    144.     int value_6;
    145.     int value_7;
    146.     char value_8;
    147.     long long value_9;
    148. }*Pbattlewar_statistics;
    149. // [13][ForceReputeRecord]
    150.  
    151. typedef class ForceReputeRecord{
    152. public:
    153.     short value_0;
    154.     short value_1;
    155.     short value_2;
    156.     short value_3;
    157.     short value_4;
    158.     char value_5;
    159.     char value_6;
    160.     short value_7;
    161.     short value_8;
    162. }*PForceReputeRecord;
    163. // [14][guild_player_ralation_record]
    164.  
    165. typedef class guild_player_ralation_record{
    166. public:
    167.     GUNICODE value_0;
    168.     char value_1;
    169. }*Pguild_player_ralation_record;
    170. // [15][bc_cooldown_rec]
    171.  
    172. typedef class bc_cooldown_rec{
    173. public:
    174.     int value_0;
    175.     long long value_1;
    176.     long long value_2;
    177.     int value_3;
    178. }*Pbc_cooldown_rec;
    179. // [16][ReduceCountRec]
    180.  
    181. typedef class ReduceCountRec{
    182. public:
    183.     char value_0;
    184.     char value_1;
    185.     char value_2;
    186. }*PReduceCountRec;
    187. // [17][TomplimitRec]
    188.  
    189. typedef class TomplimitRec{
    190. public:
    191.     long long value_0;
    192.     long long value_1;
    193.     long long value_2;
    194.     long long value_3;
    195. }*PTomplimitRec;
    196. // [18][ChargeBoxRec]
    197.  
    198. typedef class ChargeBoxRec{
    199. public:
    200.     GASCII value_0;
    201.     short value_1;
    202.     char value_2;
    203.     long long value_3;
    204.     long long value_4;
    205. }*PChargeBoxRec;
    206. // [19][ChargeHistoryRec]
    207.  
    208. typedef class ChargeHistoryRec{
    209. public:
    210.     GASCII value_0;
    211.     short value_1;
    212.     long long value_2;
    213.     long long value_3;
    214. }*PChargeHistoryRec;
    215. // [1a][ChargeCollectRec]
    216.  
    217. typedef class ChargeCollectRec{
    218. public:
    219.     GASCII value_0;
    220.     short value_1;
    221.     long long value_2;
    222.     long long value_3;
    223. }*PChargeCollectRec;
    224. // [1b][friend_rec]
    225.  
    226. typedef class friend_rec{
    227. public:
    228.     GUNICODE value_0;
    229.     char value_1;
    230.     char value_2;
    231.     char value_3;
    232.     short value_4;
    233.     char value_5;
    234.     short value_6;
    235.     char value_7;
    236.     GASCII value_8;
    237.     GASCII value_9;
    238.     int value_10;
    239.     int value_11;
    240.     double value_12;
    241.     double value_13;
    242.     double value_14;
    243.     double value_15;
    244.     GASCII value_16;
    245.     int value_17;
    246.     int value_18;
    247. }*Pfriend_rec;
    248. // [1c][unfamiliar_rec]
    249.  
    250. typedef class unfamiliar_rec{
    251. public:
    252.     GUNICODE value_0;
    253.     char value_1;
    254.     char value_2;
    255.     char value_3;
    256.     int value_4;
    257.     GASCII value_5;
    258.     short value_6;
    259.     int value_7;
    260. }*Punfamiliar_rec;
    261. // [1d][blacklist_rec]
    262.  
    263. typedef class blacklist_rec{
    264. public:
    265.     GUNICODE value_0;
    266.     char value_1;
    267.     char value_2;
    268.     char value_3;
    269.     GASCII value_4;
    270.     int value_5;
    271.     int value_6;
    272. }*Pblacklist_rec;
    273. // [1e][enemy_rec]
    274.  
    275. typedef class enemy_rec{
    276. public:
    277.     GUNICODE value_0;
    278.     char value_1;
    279.     char value_2;
    280.     char value_3;
    281.     int value_4;
    282.     int value_5;
    283.     GASCII value_6;
    284.     int value_7;
    285. }*Penemy_rec;
    286. // [1f][team_rec]
    287.  
    288. typedef class team_rec{
    289. public:
    290.     GUNICODE value_0;
    291.     GASCII value_1;
    292.     GASCII value_2;
    293.     float value_3;
    294.     float value_4;
    295.     float value_5;
    296.     char value_6;
    297.     char value_7;
    298.     GASCII value_8;
    299.     char value_9;
    300.     char value_10;
    301.     char value_11;
    302.     long long value_12;
    303.     GASCII value_13;
    304.     char value_14;
    305.     char value_15;
    306.     char value_16;
    307.     char value_17;
    308.     GASCII value_18;
    309.     int value_19;
    310.     int value_20;
    311. }*Pteam_rec;
    312. // [20][team_recruit_info_rec]
    313.  
    314. typedef class team_recruit_info_rec{
    315. public:
    316.     GUNICODE value_0;
    317.     char value_1;
    318.     char value_2;
    319.     char value_3;
    320.     char value_4;
    321. }*Pteam_recruit_info_rec;
    322. // [21][team_recruit_rec]
    323.  
    324. typedef class team_recruit_rec{
    325. public:
    326.     char value_0;
    327.     GUNICODE value_1;
    328.     char value_2;
    329.     char value_3;
    330.     char value_4;
    331.     char value_5;
    332.     char value_6;
    333.     char value_7;
    334.     char value_8;
    335.     GUNICODE value_9;
    336.     long long value_10;
    337. }*Pteam_recruit_rec;
    338. // [22][shortcut_rec]
    339.  
    340. typedef class shortcut_rec{
    341. public:
    342.     short value_0;
    343.     GASCII value_1;
    344.     GASCII value_2;
    345.     char value_3;
    346. }*Pshortcut_rec;
    347. // [23][equip_skill_rec]
    348.  
    349. typedef class equip_skill_rec{
    350. public:
    351.     short value_0;
    352.     GASCII value_1;
    353.     char value_2;
    354.     short value_3;
    355. }*Pequip_skill_rec;
    356. // [24][equip_skill_rec_all]
    357.  
    358. typedef class equip_skill_rec_all{
    359. public:
    360.     short value_0;
    361.     GASCII value_1;
    362.     char value_2;
    363.     short value_3;
    364.     char value_4;
    365. }*Pequip_skill_rec_all;
    366. // [25][clone_info_record]
    367.  
    368. typedef class clone_info_record{
    369. public:
    370.     short value_0;
    371.     char value_1;
    372.     char value_2;
    373.     char value_3;
    374.     short value_4;
    375.     long long value_5;
    376.     GASCII value_6;
    377.     char value_7;
    378.     short value_8;
    379.     GUNICODE value_9;
    380.     char value_10;
    381.     GASCII value_11;
    382.     long long value_12;
    383. }*Pclone_info_record;
    384. // [26][clone_pass_info_record]
    385.  
    386. typedef class clone_pass_info_record{
    387. public:
    388.     short value_0;
    389.     char value_1;
    390.     short value_2;
    391.     long long value_3;
    392.     long long value_4;
    393.     short value_5;
    394.     long long value_6;
    395.     char value_7;
    396.     GASCII value_8;
    397.     char value_9;
    398.     GASCII value_10;
    399.     GASCII value_11;
    400.     GASCII value_12;
    401.     char value_13;
    402.     GASCII value_14;
    403. }*Pclone_pass_info_record;
    404. // [27][clone_boss_fight_info_rec]
    405.  
    406. typedef class clone_boss_fight_info_rec{
    407. public:
    408.     short value_0;
    409.     GASCII value_1;
    410.     GASCII value_2;
    411. }*Pclone_boss_fight_info_rec;
    412. // [28][clone_player_fight_info_rec]
    413.  
    414. typedef class clone_player_fight_info_rec{
    415. public:
    416.     short value_0;
    417.     char value_1;
    418.     short value_2;
    419.     GASCII value_3;
    420. }*Pclone_player_fight_info_rec;
    421. // [29][clone_pass_info_max_record]
    422.  
    423. typedef class clone_pass_info_max_record{
    424. public:
    425.     short value_0;
    426.     char value_1;
    427.     short value_2;
    428.     long long value_3;
    429.     long long value_4;
    430.     short value_5;
    431.     long long value_6;
    432.     char value_7;
    433.     GASCII value_8;
    434.     char value_9;
    435.     GASCII value_10;
    436.     GASCII value_11;
    437.     GASCII value_12;
    438.     short value_13;
    439.     long long value_14;
    440. }*Pclone_pass_info_max_record;
    441. // [2a][clone_boss_fight_info_max_rec]
    442.  
    443. typedef class clone_boss_fight_info_max_rec{
    444. public:
    445.     short value_0;
    446.     GASCII value_1;
    447.     GASCII value_2;
    448. }*Pclone_boss_fight_info_max_rec;
    449. // [2b][clone_player_fight_info_max_rec]
    450.  
    451. typedef class clone_player_fight_info_max_rec{
    452. public:
    453.     short value_0;
    454.     char value_1;
    455.     short value_2;
    456.     GASCII value_3;
    457. }*Pclone_player_fight_info_max_rec;
    458. // [2c][clone_team_first_into_rec]
    459.  
    460. typedef class clone_team_first_into_rec{
    461. public:
    462.     short value_0;
    463.     GUNICODE value_1;
    464.     short value_2;
    465.     GASCII value_3;
    466.     GASCII value_4;
    467. }*Pclone_team_first_into_rec;
    468. // [2d][title_rec]
    469.  
    470. typedef class title_rec{
    471. public:
    472.     int value_0;
    473.     int value_1;
    474.     double value_2;
    475.     char value_3;
    476.     double value_4;
    477. }*Ptitle_rec;
    478. // [2e][title_unlock_rec]
    479.  
    480. typedef class title_unlock_rec{
    481. public:
    482.     int value_0;
    483.     int value_1;
    484.     double value_2;
    485.     char value_3;
    486. }*Ptitle_unlock_rec;
    487. // [2f][title_progress_rec]
    488.  
    489. typedef class title_progress_rec{
    490. public:
    491.     int value_0;
    492.     char value_1;
    493.     char value_2;
    494. }*Ptitle_progress_rec;
    495. // [30][formula_rec]
    496.  
    497. typedef class formula_rec{
    498. public:
    499.     GASCII value_0;
    500. }*Pformula_rec;
    501. // [31][chatpage_rec]
    502.  
    503. typedef class chatpage_rec{
    504. public:
    505.     char value_0;
    506.     GUNICODE value_1;
    507.     char value_2;
    508.     char value_3;
    509.     char value_4;
    510.     short value_5;
    511.     float value_6;
    512.     float value_7;
    513.     int value_8;
    514.     int value_9;
    515.     char value_10;
    516.     char value_11;
    517.     char value_12;
    518.     char value_13;
    519.     char value_14;
    520.     char value_15;
    521.     char value_16;
    522.     char value_17;
    523.     char value_18;
    524.     char value_19;
    525.     char value_20;
    526.     char value_21;
    527. }*Pchatpage_rec;
    528. // [32][chatroom_playerlist_rec]
    529.  
    530. typedef class chatroom_playerlist_rec{
    531. public:
    532.     GUNICODE value_0;
    533.     GASCII value_1;
    534.     char value_2;
    535. }*Pchatroom_playerlist_rec;
    536. // [33][PlayerESRec]
    537.  
    538. typedef class PlayerESRec{
    539. public:
    540.     int value_0;
    541.     short value_1;
    542.     long long value_2;
    543.     char value_3;
    544. }*PPlayerESRec;
    545. // [34][PlayerESCriteriaRec]
    546.  
    547. typedef class PlayerESCriteriaRec{
    548. public:
    549.     int value_0;
    550.     int value_1;
    551.     char value_2;
    552.     char value_3;
    553.     int value_4;
    554.     int value_5;
    555. }*PPlayerESCriteriaRec;
    556. // [35][PlayerESRewardRec]
    557.  
    558. typedef class PlayerESRewardRec{
    559. public:
    560.     int value_0;
    561.     char value_1;
    562.     char value_2;
    563.     float value_3;
    564.     GASCII value_4;
    565.     int value_5;
    566.     int value_6;
    567.     int value_7;
    568. }*PPlayerESRewardRec;
    569. // [36][arena_request_rec]
    570.  
    571. typedef class arena_request_rec{
    572. public:
    573.     GUNICODE value_0;
    574. }*Parena_request_rec;
    575. // [37][player_arena_info_rec]
    576.  
    577. typedef class player_arena_info_rec{
    578. public:
    579.     char value_0;
    580.     int value_1;
    581.     int value_2;
    582.     int value_3;
    583.     int value_4;
    584.     short value_5;
    585.     short value_6;
    586.     char value_7;
    587.     char value_8;
    588.     char value_9;
    589. }*Pplayer_arena_info_rec;
    590. // [38][AchievementCriteriaProgress]
    591.  
    592. typedef class AchievementCriteriaProgress{
    593. public:
    594.     int value_0;
    595.     int value_1;
    596.     char value_2;
    597.     int value_3;
    598.     int value_4;
    599.     int value_5;
    600. }*PAchievementCriteriaProgress;
    601. // [39][AchievementCompleted]
    602.  
    603. typedef class AchievementCompleted{
    604. public:
    605.     int value_0;
    606.     char value_1;
    607.     GASCII value_2;
    608. }*PAchievementCompleted;
    609. // [3a][AchievementTotalProgress]
    610.  
    611. typedef class AchievementTotalProgress{
    612. public:
    613.     char value_0;
    614.     int value_1;
    615.     int value_2;
    616.     int value_3;
    617. }*PAchievementTotalProgress;
    618. // [3b][AchievementBonus]
    619.  
    620. typedef class AchievementBonus{
    621. public:
    622.     int value_0;
    623. }*PAchievementBonus;
    624. // [3c][AchievementTrace]
    625.  
    626. typedef class AchievementTrace{
    627. public:
    628.     int value_0;
    629. }*PAchievementTrace;
    630. // [3d][ActivityRec]
    631.  
    632. typedef class ActivityRec{
    633. public:
    634.     int value_0;
    635.     char value_1;
    636. }*PActivityRec;
    637. // [3e][battlewar_queued_rec]
    638.  
    639. typedef class battlewar_queued_rec{
    640. public:
    641.     int value_0;
    642.     GASCII value_1;
    643.     short value_2;
    644.     long long value_3;
    645.     char value_4;
    646. }*Pbattlewar_queued_rec;
    647. // [3f][petshow_rec]
    648.  
    649. typedef class petshow_rec{
    650. public:
    651.     GOBJECT value_0;
    652.     GASCII value_1;
    653. }*Ppetshow_rec;
    654. // [40][Pet_MagicianStar_Rec]
    655.  
    656. typedef class Pet_MagicianStar_Rec{
    657. public:
    658.     char value_0;
    659.     GASCII value_1;
    660.     GASCII value_2;
    661.     GASCII value_3;
    662.     GASCII value_4;
    663.     GASCII value_5;
    664.     char value_6;
    665. }*PPet_MagicianStar_Rec;
    666. // [41][pet_mac_rec]
    667.  
    668. typedef class pet_mac_rec{
    669. public:
    670.     GASCII value_0;
    671.     GASCII value_1;
    672.     char value_2;
    673.     short value_3;
    674.     short value_4;
    675.     char value_5;
    676.     short value_6;
    677.     char value_7;
    678. }*Ppet_mac_rec;
    679. // [42][pointdisp_rec]
    680.  
    681. typedef class pointdisp_rec{
    682. public:
    683.     GASCII value_0;
    684.     char value_1;
    685. }*Ppointdisp_rec;
    686. // [43][pet_active_rec]
    687.  
    688. typedef class pet_active_rec{
    689. public:
    690.     GASCII value_0;
    691.     GASCII value_1;
    692.     GASCII value_2;
    693.     char value_3;
    694.     char value_4;
    695.     char value_5;
    696.     char value_6;
    697.     char value_7;
    698.     char value_8;
    699.     char value_9;
    700.     char value_10;
    701.     char value_11;
    702.     char value_12;
    703.     char value_13;
    704.     char value_14;
    705.     char value_15;
    706.     char value_16;
    707.     GASCII value_17;
    708. }*Ppet_active_rec;
    709. // [44][pet_item_rec]
    710.  
    711. typedef class pet_item_rec{
    712. public:
    713.     GASCII value_0;
    714.     GUNICODE value_1;
    715. }*Ppet_item_rec;
    716. // [45][pet_info_rec]
    717.  
    718. typedef class pet_info_rec{
    719. public:
    720.     GASCII value_0;
    721.     short value_1;
    722.     short value_2;
    723.     short value_3;
    724.     float value_4;
    725.     float value_5;
    726.     float value_6;
    727.     float value_7;
    728.     short value_8;
    729.     short value_9;
    730.     float value_10;
    731.     float value_11;
    732.     float value_12;
    733.     float value_13;
    734.     float value_14;
    735.     float value_15;
    736.     short value_16;
    737.     short value_17;
    738.     short value_18;
    739.     short value_19;
    740.     short value_20;
    741.     short value_21;
    742.     short value_22;
    743.     short value_23;
    744.     short value_24;
    745.     short value_25;
    746.     short value_26;
    747.     float value_27;
    748.     short value_28;
    749.     short value_29;
    750.     short value_30;
    751.     short value_31;
    752.     short value_32;
    753.     short value_33;
    754.     short value_34;
    755.     short value_35;
    756.     short value_36;
    757.     GASCII value_37;
    758.     short value_38;
    759.     float value_39;
    760.     float value_40;
    761. }*Ppet_info_rec;
    762. // [46][npc_cooldown_rec]
    763.  
    764. typedef class npc_cooldown_rec{
    765. public:
    766.     int value_0;
    767.     long long value_1;
    768.     long long value_2;
    769.     int value_3;
    770. }*Pnpc_cooldown_rec;
    771. // [47][active_skill_rec]
    772.  
    773. typedef class active_skill_rec{
    774. public:
    775.     GASCII value_0;
    776. }*Pactive_skill_rec;
    777. // [48][RecvLetterRec]
    778.  
    779. typedef class RecvLetterRec{
    780. public:
    781.     GUNICODE sender; // 发件人
    782.     GASCII value_1; // 校验码
    783.     bool opened; // 是否打开
    784.     long long value_3;
    785.     char type; // 1普通邮件 2付费邮件 101系统邮件
    786.     bool urgent;// 紧急
    787.     GUNICODE title;// 邮件主题
    788.     GUNICODE txt;// 邮件内容
    789.     GASCII Money; // 金钱
    790.     GASCII details; // xml，
    791.     GASCII szTime;// 时间，时间格式 yyyy-MM-dd HH:mm:ss
    792.     char IsRead; // 打开邮件，
    793.     GASCII Guid; // 校验码
    794.     GASCII TradeMoney; // 交易金额
    795.     char value_14;
    796. }*PRecvLetterRec;
    797. // [49][BackstageLetterRec]
    798.  
    799. typedef class BackstageLetterRec{
    800. public:
    801.     GASCII value_0;
    802.     GASCII value_1;
    803.     char value_2;
    804.     GUNICODE value_3;
    805.     GUNICODE value_4;
    806.     GASCII value_5;
    807.     GASCII value_6;
    808.     char value_7;
    809. }*PBackstageLetterRec;
    810. // [4a][AreaLvOneExploreRec]
    811.  
    812. typedef class AreaLvOneExploreRec{
    813. public:
    814.     int value_0;
    815. }*PAreaLvOneExploreRec;
    816. // [4b][MapMarksRec]
    817.  
    818. typedef class MapMarksRec{
    819. public:
    820.     GUNICODE value_0;
    821.     char value_1;
    822.     int value_2;
    823.     int value_3;
    824. }*PMapMarksRec;
    825. // [4c][consum_capital_limit]
    826.  
    827. typedef class consum_capital_limit{
    828. public:
    829.     char value_0;
    830.     long long value_1;
    831.     short value_2;
    832.     long long value_3;
    833. }*Pconsum_capital_limit;
    834. // [4d][daygain_capital_limit]
    835.  
    836. typedef class daygain_capital_limit{
    837. public:
    838.     char value_0;
    839.     long long value_1;
    840.     short value_2;
    841. }*Pdaygain_capital_limit;
    842. // [4e][exchange_ticket_rec]
    843.  
    844. typedef class exchange_ticket_rec{
    845. public:
    846.     double value_0;
    847.     long long value_1;
    848.     long long value_2;
    849. }*Pexchange_ticket_rec;
    850. // [4f][exchange_gold_rec]
    851.  
    852. typedef class exchange_gold_rec{
    853. public:
    854.     double value_0;
    855.     long long value_1;
    856.     long long value_2;
    857. }*Pexchange_gold_rec;
    858. // [50][QuestRecord]
    859.  
    860. typedef class QuestRecord{
    861. public:
    862.     short value_0;
    863.     char value_1;
    864.     char value_2;
    865.     short value_3;
    866. }*PQuestRecord;
    867. // [51][QuestCriteriaRecord]
    868.  
    869. typedef class QuestCriteriaRecord{
    870. public:
    871.     short value_0;
    872.     char value_1;
    873.     short value_2;
    874.     short value_3;
    875.     short value_4;
    876.     char value_5;
    877. }*PQuestCriteriaRecord;
    878. // [52][QuestRewarded]
    879.  
    880. typedef class QuestRewarded{
    881. public:
    882.     int value_0;
    883. }*PQuestRewarded;
    884. // [53][QuestRepeatRecord]
    885.  
    886. typedef class QuestRepeatRecord{
    887. public:
    888.     short value_0;
    889.     short value_1;
    890.     short value_2;
    891.     long long value_3;
    892. }*PQuestRepeatRecord;
    893. // [54][QuestTimeLimitRecord]
    894.  
    895. typedef class QuestTimeLimitRecord{
    896. public:
    897.     short value_0;
    898.     long long value_1;
    899.     long long value_2;
    900. }*PQuestTimeLimitRecord;
    901. // [55][QuestSeriesRecord]
    902.  
    903. typedef class QuestSeriesRecord{
    904. public:
    905.     GASCII value_0;
    906.     char value_1;
    907.     short value_2;
    908. }*PQuestSeriesRecord;
    909. // [56][Menu_Verify_Rec]
    910.  
    911. typedef class Menu_Verify_Rec{
    912. public:
    913.     short value_0;
    914.     GASCII value_1;
    915.     short value_2;
    916. }*PMenu_Verify_Rec;
    917. // [57][CloneRepeatQuestRec]
    918.  
    919. typedef class CloneRepeatQuestRec{
    920. public:
    921.     short value_0;
    922.     short value_1;
    923.     short value_2;
    924.     short value_3;
    925. }*PCloneRepeatQuestRec;
    926. // [58][PVPTaskProgressRecord]
    927.  
    928. typedef class PVPTaskProgressRecord{
    929. public:
    930.     GASCII value_0;
    931.     short value_1;
    932. }*PPVPTaskProgressRecord;
    933. // [59][PVPTaskCurrentRecord]
    934.  
    935. typedef class PVPTaskCurrentRecord{
    936. public:
    937.     GASCII value_0;
    938.     char value_1;
    939.     short value_2;
    940.     long long value_3;
    941.     char value_4;
    942.     char value_5;
    943. }*PPVPTaskCurrentRecord;
    944. // [5a][PVPTaskSubRecord]
    945.  
    946. typedef class PVPTaskSubRecord{
    947. public:
    948.     short value_0;
    949.     short value_1;
    950.     short value_2;
    951. }*PPVPTaskSubRecord;
    952. // [5b][PVPTaskScapegoatRecord]
    953.  
    954. typedef class PVPTaskScapegoatRecord{
    955. public:
    956.     short value_0;
    957.     GUNICODE value_1;
    958.     GUNICODE value_2;
    959.     int value_3;
    960.     float value_4;
    961.     float value_5;
    962.     float value_6;
    963. }*PPVPTaskScapegoatRecord;
    964. // [5c][PVPTaskFriendKillScapegoatRecord]
    965.  
    966. typedef class PVPTaskFriendKillScapegoatRecord{
    967. public:
    968.     GUNICODE value_0;
    969. }*PPVPTaskFriendKillScapegoatRecord;
    970. // [5d][PVPTaskScapegoatPosRecord]
    971.  
    972. typedef class PVPTaskScapegoatPosRecord{
    973. public:
    974.     GUNICODE value_0;
    975.     short value_1;
    976.     float value_2;
    977.     float value_3;
    978.     float value_4;
    979.     char value_5;
    980.     long long value_6;
    981.     int value_7;
    982. }*PPVPTaskScapegoatPosRecord;
    983. // [5e][PVPTaskFriendHelpScapegoatRecord]
    984.  
    985. typedef class PVPTaskFriendHelpScapegoatRecord{
    986. public:
    987.     GUNICODE value_0;
    988. }*PPVPTaskFriendHelpScapegoatRecord;
    989. // [5f][PVPHorseRaceTimeRecord]
    990.  
    991. typedef class PVPHorseRaceTimeRecord{
    992. public:
    993.     long long value_0;
    994.     long long value_1;
    995.     long long value_2;
    996. }*PPVPHorseRaceTimeRecord;
    997. // [60][PVPTowerWarTimeRecord]
    998.  
    999. typedef class PVPTowerWarTimeRecord{
    1000. public:
    1001.     long long value_0;
    1002.     long long value_1;
    1003.     long long value_2;
    1004.     long long value_3;
    1005.     long long value_4;
    1006.     short value_5;
    1007.     short value_6;
    1008. }*PPVPTowerWarTimeRecord;
    1009. // [61][PvpPlayerActivityState]
    1010.  
    1011. typedef class PvpPlayerActivityState{
    1012. public:
    1013.     GASCII value_0;
    1014.     char value_1;
    1015. }*PPvpPlayerActivityState;
    1016. // [62][new_use_lead_skill_rec]
    1017.  
    1018. typedef class new_use_lead_skill_rec{
    1019. public:
    1020.     GASCII value_0;
    1021.     GUNICODE value_1;
    1022. }*Pnew_use_lead_skill_rec;
    1023. // [63][item_box]
    1024.  
    1025. typedef class item_box{
    1026. public:
    1027.     GASCII value_0;
    1028.     int value_1;
    1029. }*Pitem_box;
    1030. // [64][everydayrecommend_rec]
    1031.  
    1032. typedef class everydayrecommend_rec{
    1033. public:
    1034.     GASCII value_0;
    1035.     char value_1;
    1036.     char value_2;
    1037. }*Peverydayrecommend_rec;
    1038. // [65][boxstate_rec]
    1039.  
    1040. typedef class boxstate_rec{
    1041. public:
    1042.     GASCII value_0;
    1043.     char value_1;
    1044.     char value_2;
    1045. }*Pboxstate_rec;
    1046. // [66][player_signin_rec]
    1047.  
    1048. typedef class player_signin_rec{
    1049. public:
    1050.     char value_0;
    1051.     int value_1;
    1052.     int value_2;
    1053.     long long value_3;
    1054.     GASCII value_4;
    1055.     GASCII value_5;
    1056.     char value_6;
    1057. }*Pplayer_signin_rec;
    1058. // [67][special_npc_rec]
    1059.  
    1060. typedef class special_npc_rec{
    1061. public:
    1062.     GOBJECT value_0;
    1063.     GASCII value_1;
    1064.     float value_2;
    1065.     float value_3;
    1066.     float value_4;
    1067.     char value_5;
    1068. }*Pspecial_npc_rec;
    1069. // [68][mode_selected_rec]
    1070.  
    1071. typedef class mode_selected_rec{
    1072. public:
    1073.     short value_0;
    1074.     short value_1;
    1075.     long long value_2;
    1076.     long long value_3;
    1077.     short value_4;
    1078. }*Pmode_selected_rec;
    1079. // [69][charge_config_rec]
    1080.  
    1081. typedef class charge_config_rec{
    1082. public:
    1083.     short value_0;
    1084.     GASCII value_1;
    1085.     GASCII value_2;
    1086.     short value_3;
    1087. }*Pcharge_config_rec;
    1088. // [6a][charge_capital_rec]
    1089.  
    1090. typedef class charge_capital_rec{
    1091. public:
    1092.     short value_0;
    1093.     long long value_1;
    1094.     long long value_2;
    1095.     long long value_3;
    1096. }*Pcharge_capital_rec;
    1097. // [6b][PersonalCarrierStore]
    1098.  
    1099. typedef class PersonalCarrierStore{
    1100. public:
    1101.     GASCII value_0;
    1102.     short value_1;
    1103.     char value_2;
    1104.     short value_3;
    1105.     short value_4;
    1106.     GASCII value_5;
    1107. }*PPersonalCarrierStore;
    1108. // [6c][player_energy_well_record]
    1109.  
    1110. typedef class player_energy_well_record{
    1111. public:
    1112.     int value_0;
    1113.     char value_1;
    1114.     int value_2;
    1115.     char value_3;
    1116.     char value_4;
    1117.     GUNICODE value_5;
    1118. }*Pplayer_energy_well_record;
    1119. // [6d][player_battle_carrier_record]
    1120.  
    1121. typedef class player_battle_carrier_record{
    1122. public:
    1123.     GASCII value_0;
    1124.     int value_1;
    1125.     int value_2;
    1126.     int value_3;
    1127.     int value_4;
    1128.     int value_5;
    1129.     int value_6;
    1130.     int value_7;
    1131.     GUNICODE value_8;
    1132.     long long value_9;
    1133.     GUNICODE value_10;
    1134.     long long value_11;
    1135.     int value_12;
    1136. }*Pplayer_battle_carrier_record;
    1137. // [6e][netbar_right_rec]
    1138.  
    1139. typedef class netbar_right_rec{
    1140. public:
    1141.     char value_0;
    1142.     int value_1;
    1143.     int value_2;
    1144.     int value_3;
    1145.     GASCII value_4;
    1146. }*Pnetbar_right_rec;
    1147. // [6f][rec_energywell_guildwar_member]
    1148.  
    1149. typedef class rec_energywell_guildwar_member{
    1150. public:
    1151.     GUNICODE value_0;
    1152.     char value_1;
    1153.     char value_2;
    1154.     GUNICODE value_3;
    1155.     int value_4;
    1156.     int value_5;
    1157.     int value_6;
    1158.     long long value_7;
    1159.     long long value_8;
    1160.     char value_9;
    1161.     char value_10;
    1162.     int value_11;
    1163. }*Prec_energywell_guildwar_member;
    1164. // [70][rec_energywell_guildwar_relive]
    1165.  
    1166. typedef class rec_energywell_guildwar_relive{
    1167. public:
    1168.     GASCII value_0;
    1169.     char value_1;
    1170. }*Prec_energywell_guildwar_relive;
    1171. // [71][rec_energywell_pillar_state]
    1172.  
    1173. typedef class rec_energywell_pillar_state{
    1174. public:
    1175.     GASCII value_0;
    1176.     char value_1;
    1177.     int value_2;
    1178.     int value_3;
    1179. }*Prec_energywell_pillar_state;
    1180. // [72][rec_energywell_ride_info]
    1181.  
    1182. typedef class rec_energywell_ride_info{
    1183. public:
    1184.     GOBJECT value_0;
    1185.     char value_1;
    1186. }*Prec_energywell_ride_info;
    1187. // [73][rec_ew_cw_battle_info]
    1188.  
    1189. typedef class rec_ew_cw_battle_info{
    1190. public:
    1191.     int value_0;
    1192.     int value_1;
    1193. }*Prec_ew_cw_battle_info;
    1194. // [74][rec_ew_cw_person]
    1195.  
    1196. typedef class rec_ew_cw_person{
    1197. public:
    1198.     int value_0;
    1199.     GUNICODE value_1;
    1200.     int value_2;
    1201.     int value_3;
    1202.     int value_4;
    1203.     int value_5;
    1204.     int value_6;
    1205.     int value_7;
    1206.     int value_8;
    1207.     int value_9;
    1208.     int value_10;
    1209.     int value_11;
    1210.     int value_12;
    1211. }*Prec_ew_cw_person;
    1212. // [75][rec_ew_cw_guild]
    1213.  
    1214. typedef class rec_ew_cw_guild{
    1215. public:
    1216.     int value_0;
    1217.     GUNICODE value_1;
    1218.     int value_2;
    1219.     GUNICODE value_3;
    1220.     int value_4;
    1221.     int value_5;
    1222.     int value_6;
    1223.     int value_7;
    1224.     int value_8;
    1225.     int value_9;
    1226.     int value_10;
    1227.     int value_11;
    1228.     int value_12;
    1229. }*Prec_ew_cw_guild;
    1230. // [76][rec_ew_cw_camp]
    1231.  
    1232. typedef class rec_ew_cw_camp{
    1233. public:
    1234.     int value_0;
    1235.     int value_1;
    1236.     int value_2;
    1237.     int value_3;
    1238.     int value_4;
    1239.     int value_5;
    1240.     int value_6;
    1241.     int value_7;
    1242.     int value_8;
    1243.     int value_9;
    1244. }*Prec_ew_cw_camp;
    1245. // [77][rec_ew_cw_boss]
    1246.  
    1247. typedef class rec_ew_cw_boss{
    1248. public:
    1249.     int value_0;
    1250.     GOBJECT value_1;
    1251.     int value_2;
    1252.     int value_3;
    1253. }*Prec_ew_cw_boss;
    1254. // [78][rec_ew_cw_npc]
    1255.  
    1256. typedef class rec_ew_cw_npc{
    1257. public:
    1258.     int value_0;
    1259.     GOBJECT value_1;
    1260. }*Prec_ew_cw_npc;
    1261. // [79][rec_ew_cw_pillar]
    1262.  
    1263. typedef class rec_ew_cw_pillar{
    1264. public:
    1265.     int value_0;
    1266.     GOBJECT value_1;
    1267. }*Prec_ew_cw_pillar;
    1268. // [7a][rec_ew_relive]
    1269.  
    1270. typedef class rec_ew_relive{
    1271. public:
    1272.     int value_0;
    1273.     GOBJECT value_1;
    1274. }*Prec_ew_relive;
    1275. // [7b][rec_ew_relivepos]
    1276.  
    1277. typedef class rec_ew_relivepos{
    1278. public:
    1279.     int value_0;
    1280.     GASCII value_1;
    1281. }*Prec_ew_relivepos;
    1282. // [7c][pickup_member_rec]
    1283.  
    1284. typedef class pickup_member_rec{
    1285. public:
    1286.     GUNICODE value_0;
    1287.     short value_1;
    1288. }*Ppickup_member_rec;
    1289. // [7d][link_rec]
    1290.  
    1291. typedef class link_rec{
    1292. public:
    1293.     GUNICODE value_0;
    1294.     float value_1;
    1295.     float value_2;
    1296.     float value_3;
    1297.     float value_4;
    1298.     GOBJECT value_5;
    1299. }*Plink_rec;
    1300. // [7e][bc_seat_rec]
    1301.  
    1302. typedef class bc_seat_rec{
    1303. public:
    1304.     char value_0;
    1305.     char value_1;
    1306.     GUNICODE value_2;
    1307.     char value_3;
    1308.     int value_4;
    1309.     int value_5;
    1310.     GASCII value_6;
    1311.     GASCII value_7;
    1312.     GOBJECT value_8;
    1313. }*Pbc_seat_rec;
    1314. // [7f][NpcToRoleRec]
    1315.  
    1316. typedef class NpcToRoleRec{
    1317. public:
    1318.     GASCII value_0;
    1319.     GASCII value_1;
    1320. }*PNpcToRoleRec;
    1321. // [80][dice_member_rec]
    1322.  
    1323. typedef class dice_member_rec{
    1324. public:
    1325.     GUNICODE value_0;
    1326.     char value_1;
    1327.     char value_2;
    1328. }*Pdice_member_rec;
    1329. // [81][RaPropertyRec]
    1330.  
    1331. typedef class RaPropertyRec{
    1332. public:
    1333.     char value_0;
    1334.     float value_1;
    1335.     float value_2;
    1336. }*PRaPropertyRec;
    1337. // [82][EnchaseRec]
    1338.  
    1339. typedef class EnchaseRec{
    1340. public:
    1341.     char value_0;
    1342.     GASCII value_1;
    1343.     GASCII value_2;
    1344. }*PEnchaseRec;
    1345. // [83][AddMagicRec]
    1346.  
    1347. typedef class AddMagicRec{
    1348. public:
    1349.     int value_0;
    1350. }*PAddMagicRec;
    1351.

     

  • 相关阅读:
    Linux用户空间与内核空间通信(Netlink通信机制)
    centos6.5升级ntp版本至ntp-4.2.6版本以上
    PB从入坑到放弃（二）编码规范
    等保测评答疑
    异步请求池——池式组件
    linux文件目录指令
    【Flutter 面试题】main()和runApp()函数在Flutter的作用分别是什么？有什么关系吗？
    SHELL中sed总结
    60岁首席工程师被SpaceX边缘化，主管：我怕他退休或死了
    Stanford CS143 速通PA2教程
  • 原文地址：https://blog.csdn.net/qq_36301061/article/details/139814871