博客内容仅供学习，介绍基于“66.重新规划游戏分析信息的输出”代码进行修改。通过接收的09数据包的数据结构生成C++头文件，方便存放人物数据。还说明了多个文件的修改内容，如NetClient.cpp、NetClass.h等文件。
免责声明：内容仅供学习参考，请合法利用知识，禁止进行违法犯罪活动！
如果看不懂、不知道现在做的什么，那就跟着做完看效果，代码看不懂是正常的，只要会抄就行，抄着抄着就能懂了
内容参考于：易道云信息技术研究院
上一个内容：66.重新规划游戏分析信息的输出
码云版本号：de6847bfaeb904f65bc09755437cf6b69e51e1d5
代码下载地址，在 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的分享
以 66.重新规划游戏分析信息的输出 它的代码为基础进行修改
上一个内容里把解析数据包的函数重新规划重新封装了，本次通过接收的09数据包的数据结构，生成了c++头文件，以方便后续存放人物数据
效果图：通过09数据包生成头文件
所在目录
删除GameBaseT.h文件
新加 GameOBJECT.h头文件，它的内容通过复制1.h文件里的内容得到的
#pragma once
#include "pch.h"
#define GAscii CStringA
#define GUnicode CString
#define GCHAR CStringA
#define GWCHAR CString
#define GOBJECT int
typedef class GAMEOBJECT {
public:
char Type;
char Sex;
GCHAR Photo;
int Camp;
int Race;
int Job;
int Level;
int CurArea;
GCHAR SceneTriggerConfig;
GCHAR ToolEffect;
GCHAR SkillEnergyList;
int HideSkillTip;
int Coin_LLQD;
int DelaySkillTime;
int Pre_SceneID;
float Pre_PosX;
float Pre_PosY;
float Pre_PosZ;
GCHAR MountItemId;
long long WedgedTime;
char EnergyLevel;
char EnergyUpgradeNum;
char EnergyPreUpgradeNum;
char SpecState;
char IsHunterTreasure;
char AdjustOrient;
GWCHAR Name;
float CollideRadius;
float VisualRange;
int MPUpSpeed;
int MPUpSpeedAdd;
GCHAR State;
int FloatingState;
int FashionState;
int MaxHPAdd;
int MaxMPAdd;
int HPRatio;
int MPRatio;
int MaxHP;
int MaxMP;
int HP;
int MP;
int ArmHPUpSpeed;
int ArmEYUpSpeed;
char CantMove;
char CantMoveAdd;
char CantRotate;
char CantAttack;
char CantBeAttack;
char CantBeAttack2;
char CantUseSkill;
char CantUseSkillAdd;
char CantUseItem;
char CantUseItemAdd;
char CantRotateAdd;
char CantAttackAdd;
int PauseAction;
char CantJump;
int RoleHide;
int TrueSight;
int ShowHide;
int AreaHide;
float WarFogRadius;
int HideActionSet;
int FightPower;
int RC;
int AV;
int EY;
int FS;
int DP;
int RCRatio;
int AVRatio;
int EYRatio;
int FSRatio;
int DPRatio;
int MaxRC;
int MaxAV;
int MaxEY;
int MaxFS;
int MaxDP;
int MaxRCAdd;
int MaxAVAdd;
int MaxEYAdd;
int MaxFSAdd;
int MaxDPAdd;
float Gravity;
float JumpSpeed;
float MoveSpeed;
float WalkSpeed;
float RunSpeed;
float DropHeightPub;
float RunSpeedAdd;
int SpeedRatio;
int RequestSet;
int ArtKey;
int HidePlayer;
int HideOtherPet;
GCHAR Face;
GCHAR Eyes;
GCHAR Beard;
GCHAR Ears;
GCHAR Tail;
GCHAR Finger;
GCHAR HideParts;
GCHAR HideSkins;
int Stature;
int TattooColor;
GCHAR SkinMtl;
GCHAR HairColor;
GCHAR SkinColor;
GCHAR Hat;
GCHAR Cloth;
GCHAR Pants;
GCHAR Shoes;
GCHAR Gloves;
GCHAR Tattoo;
GCHAR Special;
GCHAR Mantle;
GCHAR Trait;
GCHAR LWeapon;
GCHAR RWeapon;
GCHAR LWeaponID;
GCHAR RWeaponID;
GCHAR ActionSet;
char HandType;
char WeaponState;
char WeaponStateType;
GCHAR LArmorWeapon;
GCHAR RArmorWeapon;
GCHAR LArmorWeaponID;
GCHAR RArmorWeaponID;
GCHAR HeadDetail;
GOBJECT LastObject;
int UnenthrallTime;
char PKMode;
int PKValue;
int ShaQi;
int ArenaSide;
short ArrestValue;
char ArrestState;
int RedNameEffect;
short ChangePKModule;
int PKProtected;
int ChallengeState;
GWCHAR ChallengeName;
char LogicState;
char Dead;
GCHAR GuardSkill;
float ModelScale;
char PvpFlag;
char PvpType;
int HPConsumeInc;
int MPConsumeInc;
int EYConsumeInc;
int RCConsumeInc;
int AVConsumeInc;
int FSConsumeInc;
int DPConsumeInc;
int ARMHPConsumeInc;
int ARMEYConsumeInc;
float HPConsumeMul;
float MPConsumeMul;
float EYConsumeMul;
float RCConsumeMul;
float AVConsumeMul;
float FSConsumeMul;
float DPConsumeMul;
float ARMHPConsumeMul;
float ARMEYConsumeMul;
int ShamDead;
GCHAR CurSkillID;
GCHAR CurSkillEffectID;
GOBJECT CurSkillTarget;
int CurSkillLevel;
GCHAR BufferListStr;
int PrepareTime;
int LeadTime;
float TargetShapePara1;
float TargetShapePara2;
float HitShapePara1;
float HitShapePara2;
int CoolDownTime;
char OnTransToolState;
GOBJECT LinkObj;
char OnSwitchTransState;
GCHAR TransToolID;
int FlyStep;
int FromTo;
float StoreHeight;
float UnderWaterSpeed;
float CurUnderWaterValue;
GCHAR TransJobList;
GCHAR CantTransJob;
int DoTransJob;
GCHAR TransConditionId;
int CurInsPoint;
int ExileStatus;
int Force;
GWCHAR GuildName;
int GuildPosition;
int MountID;
GCHAR MountItemID;
char MountType;
int MountSeatIndex;
char MultiSeatNum;
GOBJECT SeatPlayer2;
GOBJECT SeatPlayer3;
GOBJECT SeatPlayer4;
GOBJECT SeatPlayer5;
int SafeTime;
int CurSafeTime;
char SafeModeEquipLv;
char SafeModeEquipStar;
char IsHaveSafeModePsw;
char IsSafeModeUnLock;
GCHAR SafeModeEquipStr;
GCHAR SafeModeJewelStr;
double LastOffLineTime;
GCHAR LastAddress;
int TeamID;
GWCHAR TeamCaptain;
char TeamPickMode;
char TeamPickQuality;
char TeamType;
char AcceptRequest;
char CurMembers;
GCHAR TeamSceneSign;
GWCHAR STeamCaptain;
char STeamType;
GCHAR ShortcutKey;
GCHAR GunManLeftSkill;
int CurCloneSceneLevel;
long long CloneSceneScoreTop;
long long CloneScoreTopRefreshTime;
int CloneWeekLimitCount;
int CloneWeekLimitCountMax;
int TitleID;
int GunMan;
GCHAR GunManBullet;
int RFC;
int ChatRoomID;
GWCHAR ChatRoomTitle;
int CurrentESId;
int ArenaID;
int ArenaState;
int ArenaSinglePoints;
GWCHAR ArenaTeamName;
int IsArenaTeamCaptain;
int ArenaTeamType;
int ArenaMatchType;
int ArenaKill;
int AchievePoint;
int ActDegree;
char ActPhase;
int BattleWarState;
int LeaveGive;
int BattleWarID;
int BattleWarRand;
int MaxKeepKillNum;
int MaxKillEnemyNum;
int BWDeadNum;
long long CampaignStatus;
GCHAR MainRoleChange;
int PreChangeIndex;
int ChangeIndex;
int bRoleChange;
int RoleChangeType;
GCHAR RelivePositon;
int ReliveLocalFirst;
int RelivePerfectFirst;
int ReliveCityFirst;
int ReliveTime;
int ReliveCdTime;
int ReliveNoNearPos;
int RelivePosSelectOpen;
long long HotelexPerience;
int PlayerExp;
int PlayerUpgradeExp;
int Declare;
int PlayerHonor;
int RankLevel;
int UpgradeHonor;
int CanAddHonorPoint;
long long DepotMoney;
char AddDepotBagNum;
char AddToolBagNum;
char Link;
int GuideType;
int LifeOccupFirstType;
int LifeOccupFirstExp;
int LifeJobLevel;
int Physical;
int MaxPhysical;
int MatureTicketDay;
long long DayMaxGainGold;
int AutoQuestFlag;
int PVPChangeForce;
int PVPAttackPerfect;
int PVPTaskCanAccept;
char PvpLock;
int SwitchBeforeTime;
short PracticeWaitTime;
short PracticeFightTime;
char IsPractice;
GCHAR HorseRacePathID;
int HorseRaceRank;
int PVPTowerPlayerState;
int IsInNewUserLead;
GCHAR ItemSet;
GCHAR DecomposeUID;
GCHAR DecomMaterial;
int EveRecActive;
int EveRecLevel;
int EvePVECount;
int EvePVPCount;
int EveEventCount;
int EveBattleCount;
int EveAthleticsCount;
int EveSceneCount;
GCHAR OnlineTime;
int OffLineExp;
char IsVip;
GCHAR VipEndTime;
int VipCloneNum;
GCHAR VipCloneTime;
int VipPointTransferNum;
GCHAR VipPointTransTime;
int VipReliveNum;
GCHAR VipReliveTime;
GCHAR VipGiftTime;
GCHAR EWId;
int PreForce;
int EWResFightState;
float guildwar_offline_x;
float guildwar_offline_y;
float guildwar_offline_z;
char ChargeMode;
int ChargeTime;
GCHAR camp_war_task;
GCHAR camp_war_relive;
GCHAR camp_war_pillar;
int RidePoint;
char IsHaveSecondWord;
char WordBeLock;
int WordCheckNum;
char IsCheckPass;
int NetBarRight;
int NetBarReceiveState;
int NetBarDayPrize;
int SnDaNetBarRight;
int SnDaReceiveState;
int SnDaNetBarDayPrize;
GCHAR ConfigID;
GCHAR Resource;
int GroupNum;
long long CurrentTime;
long long ServerTime;
int ProtoSceneID;
int CloneSceneID;
int Grouping;
GCHAR HorseRaceCount;
int CloneDifficulty;
char NpcType;
char MotionNoRotate;
int NeedRotate;
GCHAR Scale;
char SelectState;
int WarnType;
GCHAR AIEffect;
float PatrolRange;
GWCHAR Owner;
GWCHAR AttackPlayer;
GCHAR WeaponName;
GCHAR WeaponMode;
GOBJECT MasterID;
int PathPointType;
GWCHAR OwnerList;
int CollideType;
char CantShowHeadInfo;
char CanPick;
int VisType;
int VisDataInt;
GWCHAR VisDataStr;
short NPCCanSelect;
GCHAR PeaceRandomAction;
GCHAR FightRandomAction;
GCHAR TalkRandomAction;
long long BornTime;
int HeadEffect;
GWCHAR NpcNickName;
GCHAR ExtraInfo;
char Fixed;
int bAllVisible;
GCHAR MainNpcChange;
int bNpcChange;
int NpcChangeType;
int AttackNpcType;
GCHAR QueryData;
int ConvoyType;
GWCHAR Master;
int SpringType;
int RoadSignID;
GCHAR MaterialPath;
int BelongType;
GCHAR BelongID;
int PointMaxValue;
int PointCurrentValue;
float RollSpeed;
GCHAR TransPath;
int TransStep;
GCHAR TransSecID;
GCHAR CarrierType;
int CarrierCtlType;
int CarrierDownInFight;
int CarrierViewAngle;
float CarrierAy;
float FaceAngle;
GOBJECT MainObj;
int SeatIndex;
int EnergyWellID;
int IsPlayGetOnAction;
int EWCarrierID;
int EWCarrierState;
GWCHAR CarrierOwner;
GCHAR AmmoValue;
GCHAR AmmoValueMax;
int AmmoNum;
int LockAction;
char CanBeKilled;
char CantBeLtd;
char CantBeLtdSpd;
char CantBeLtdHitMove;
char CantBeLtdMove;
char CantBeLtdUseSkill;
char CantBeLtdAttack;
char CantBeLtdShift;
char CantBeLtdRotate;
char StrCantUseSkill;
char StrCantUseSkillAdd;
GCHAR damagedeffect;
char StrengthType;
short GeneralType;
GCHAR Species;
int ItemType;
int ColorLevel;
GCHAR UniqueID;
int Amount;
int MaxAmount;
char Task;
int BindType;
int BindStatus;
int IsCanConsign;
int LockStatus;
int BuyType;
int SellPrice0;
int SellPrice1;
int BuyPrice0;
int BuyPrice1;
int ArtPack;
GCHAR ExpiredTime;
int ValidTime;
char NotValid;
int LeftTime;
GCHAR ItemCosts;
int MaxBuyNumPer;
GCHAR BuyConditionID;
int BuyNumLimit;
int BuyNumRest;
int BuyCoolTime;
int BuyCoolTimeRest;
int ShopBuyPrice;
int Hardiness;
int MaxHardiness;
GCHAR PropPack;
GCHAR PropBuilt;
GCHAR PropRanBuilt;
GCHAR EquipType;
GCHAR SkillRand;
GCHAR EquipSetSkillRand;
int CurHoleCount;
int StarLevel;
float Proadd;
int AppendLefttime;
GCHAR PetConfigID;
GCHAR SpecialType;
int EnergyValue;
int MaxEnergyValue;
char EnergyExpLv;
int EnergyExp;
int NeedEnergy;
GCHAR ArmorType;
char HoldType;
char HandPos;
int JewelLevel;
int Energy;
short BeginPos;
short EndPos;
GCHAR FormulaPack;
int UseCount;
GCHAR Picture;
GCHAR RealArea;
GCHAR MapArea;
char HasOpenFlag;
short CanUse;
int BaseCap;
int MaxItemNum;
GCHAR ShopID;
int NumPerPage;
int RepairType;
double FineRepairFeeCoe;
double NormalRepairFeeCoe;
double HardinessRecoverFeeCoe;
int Discount;
GCHAR ShopCondition;
char BeActived;
int AConsumeCurHP;
float PConsumeCurHP;
int AConsumeCurMP;
float PConsumeCurMP;
int AConsumeEnergy;
float PConsumeEnergy;
int AConsumeCuranger;
float PConsumeCuranger;
int AConsumeCurmobile;
float PConsumeCurmobile;
int AConsumeCurFS;
float PConsumeCurFS;
int AConsumeCurDP;
float PConsumeCurDP;
int AConsumeCurARMHP;
int AConsumeCurARMEY;
int AConsumeRFC;
GCHAR AConsumeAmmo;
GCHAR ConsumeItemID;
int ConsumeItemCount;
int LifeTime;
int IsDamage;
int TargetClassType;
int TargetRelationType;
float EffectRange;
int EventProcess;
GCHAR Buff_Display;
GCHAR Description;
int ExchangeMoney;
int ExchangeIsLock;
int ExchangeIsOk;
GWCHAR ExchangeTarget;
int ExchangeTargetLevel;
int ExchangeTargetJob;
GOBJECT ExchangeTargetObj;
public:
}*PGAMEOBJ;
NetClient.cpp文件的修改：修改了 OnSverObject函数、OnSvrObjectInit函数
#include "pch.h"
#include "NetClient.h"
#include "extern_all.h"
bool NetClient::login(const char* Id, const char* Pass)
{
const int bufflen = sizeof(DATA_LOGIN) + 1;
char buff[bufflen];
DATA_LOGIN data;
// 有些操作系统这样写会报错，因为内存不对齐，现在Windows下没事
//PDATALOGIN _data = (PDATALOGIN)(buff + 1);
// 这样写就能解决内存对齐问题
PDATALOGIN _data =&data;
int len = strlen(Id);
memcpy(_data->Id, Id, len);
len = strlen(Pass);
memcpy(_data->Pass, Pass, len);
memcpy(buff+1, _data, sizeof(DATA_LOGIN));
buff[0] = I_LOGIN;
return WinSock->OnSend(buff, sizeof(buff));
}
bool NetClient::DelRole(const wchar_t* rolename)
{
PROLEDATA _role = GetRoleByName(rolename);
if (_role == nullptr) {
return false;
}
else {
return DelRole(rolename, _role->name.lenth);
}
return false;
}
bool NetClient::StartCreateRole()
{
NET_CREATEROLE_START _data;
return WinSock->OnSend(&_data.op, _data.len);
}
bool NetClient::SelectCamp(const char* _campname)
{
NET_SEND_BUFF _buff;
NET_SEND_CHOOSECAMP _data;
_data.opcode.Set(SC_CHOOSECAMP);
_data.camps.Set(_campname);
/*
sizeof(_data) / sizeof(EnCode)的原因
NET_SEND_CHOOSECAMP结构体里面，没别 东西
全是 EnCode 这个结构
*/
short count = sizeof(_data) / sizeof(EnCode);
_buff.count = count;
/*
CodeMe函数给 _buff.buff里写数据参数的数据
也就是给0A开头数据包里写，数据参数个数后面的内容
然后返回值是写了多长的数据
也就是给0A开头数据包里的数据参数个数后面的数据写了多长
*/
int ilen = _data.CodeMe(count, _buff.buff);
ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
return WinSock->OnSend(&_buff.op, ilen);
}
bool NetClient::CreateRole(wchar_t* name, double sex, double camp, double face, double occu, const char* photo, const char* infos, const char* txt, double faceShape)
{
// rolecount > 4说明角色的数量够了
if (rolecount > 4)return false;
int index = 0;
bool roleindex[5]{true, true, true, true, true };
for (int i = 0; i < rolecount; i++) {
roleindex[roles[i].index] = false;
}
for (int i = 0; i < 5; i++)
{
if (roleindex[i]) {
index = i;
break;
}
}
// wchar_t _name[] = L"am52111";
NS_CREATEROLE_HEAD_BUFF _buff;
CREATE_ROLE_DATAS _data;
_data.sex.Set(sex);
_data.camp.Set(camp);
_data.face.Set(face);
_data.occu.Set(occu);
_data.faceSahpe.Set(faceShape);
//_data.Photo.Set("gui\BG_team\TeamRole\Teamrole_zq_humF_001.PNG");
_data.Photo.Set(photo);
//_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;");
_data.Infos.Set(infos);
_data.Txt.Set(txt);
short count = sizeof(_data) / sizeof(EnCode);
_buff.count = count;
_buff.index = index;
int lenth = wcslen(name) + 1;
lenth = lenth * 2;
memcpy(_buff.name, name, lenth);
int ilen = _data.CodeMe(count, _buff.buff);
ilen = ilen + sizeof(NET_SEHD_CREATEROLE_HEAD) - 3;
return WinSock->OnSend(&_buff.op, ilen);
}
bool NetClient::SelectRole(const wchar_t* rolename)
{
PROLEDATA roles = GetRoleByName(rolename);
if (roles == nullptr)return false;
NS_SELECTROLE _data;
memcpy(_data.buff, roles->name.value(), roles->name.lenth);
return WinSock->OnSend((char*)&_data, sizeof(_data));
}
PROLEDATA NetClient::GetRoleByName(const wchar_t* rolename)
{
//PROLEDATA result = nullptr;
for (int i = 0; i < rolecount; i++)
{
// StrCmpW判断两个字符串是否相同
// 比较时区分大小写，如果字符串相同返回0
if (StrCmpW(roles[i].name.value(), rolename) == 0) {
return &roles[i];
}
}
return nullptr;
}
bool NetClient::Talk(wchar_t* txt, int PdId, double un)
{
NET_SEND_BUFF _buff;
CHAT_PUBLIC _data;
_data.opcode.Set(SC_CHAT);
_data.ChartId.Set(PdId);
_data.txt.Set(txt);
_data.un.Set(un);
/*
sizeof(_data) / sizeof(EnCode)的原因
NET_SEND_CHOOSECAMP结构体里面，没别 东西
全是 EnCode 这个结构
*/
short count = sizeof(_data) / sizeof(EnCode);
_buff.count = count;
/*
CodeMe函数给 _buff.buff里写数据参数的数据
也就是给0A开头数据包里写，数据参数个数后面的内容
然后返回值是写了多长的数据
也就是给0A开头数据包里的数据参数个数后面的数据写了多长
*/
int ilen = _data.CodeMe(count, _buff.buff);
ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
return WinSock->OnSend(&_buff.op, ilen);
}
bool NetClient::TalkTo(wchar_t* name, wchar_t* txt, double un)
{
NET_SEND_BUFF _buff;
CHAT_PRIVATE _data;
_data.opcode.Set(SC_CHAT);
_data.ChartId.Set(3);
_data.txt.Set(txt);
_data.name.Set(name);
_data.un.Set(un);
/*
sizeof(_data) / sizeof(EnCode)的原因
NET_SEND_CHOOSECAMP结构体里面，没别 东西
全是 EnCode 这个结构
*/
short count = sizeof(_data) / sizeof(EnCode);
_buff.count = count;
/*
CodeMe函数给 _buff.buff里写数据参数的数据
也就是给0A开头数据包里写，数据参数个数后面的内容
然后返回值是写了多长的数据
也就是给0A开头数据包里的数据参数个数后面的数据写了多长
*/
int ilen = _data.CodeMe(count, _buff.buff);
ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
return WinSock->OnSend(&_buff.op, ilen);
}
bool NetClient::HeartBeep()
{
NET_SEND_BUFF _buff;
HEART_BEEP _data;
_data.opcode.Set(SC_BEEP);
_data.tick.Set(3);
/*
sizeof(_data) / sizeof(EnCode)的原因
NET_SEND_CHOOSECAMP结构体里面，没别 东西
全是 EnCode 这个结构
*/
short count = sizeof(_data) / sizeof(EnCode);
_buff.count = count;
/*
CodeMe函数给 _buff.buff里写数据参数的数据
也就是给0A开头数据包里写，数据参数个数后面的内容
然后返回值是写了多长的数据
也就是给0A开头数据包里的数据参数个数后面的数据写了多长
*/
int ilen = _data.CodeMe(count, _buff.buff);
ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
return WinSock->OnSend(&_buff.op, ilen);
}
bool NetClient::HeartLoop()
{
NET_SEND_BUFF _buff;
HEART_LOOP _data;
_data.opcode.Set(SC_LOOP);
_data.tick.Set(GetTickCount64());
_data.txt.Set("");
/*
sizeof(_data) / sizeof(EnCode)的原因
NET_SEND_CHOOSECAMP结构体里面，没别 东西
全是 EnCode 这个结构
*/
short count = sizeof(_data) / sizeof(EnCode);
_buff.count = count;
/*
CodeMe函数给 _buff.buff里写数据参数的数据
也就是给0A开头数据包里写，数据参数个数后面的内容
然后返回值是写了多长的数据
也就是给0A开头数据包里的数据参数个数后面的数据写了多长
*/
int ilen = _data.CodeMe(count, _buff.buff);
ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
return WinSock->OnSend(&_buff.op, ilen);
}
bool NetClient::Backtoroles()
{
// 返回角色
NET_SEND_BUFF _buff;
NSR_CHEAD _data;
_data.opcode.Set(SC_REONLINE);
/*
sizeof(_data) / sizeof(EnCode)的原因
NET_SEND_CHOOSECAMP结构体里面，没别 东西
全是 EnCode 这个结构
*/
short count = sizeof(_data) / sizeof(EnCode);
_buff.count = count;
/*
CodeMe函数给 _buff.buff里写数据参数的数据
也就是给0A开头数据包里写，数据参数个数后面的内容
然后返回值是写了多长的数据
也就是给0A开头数据包里的数据参数个数后面的数据写了多长
*/
int ilen = _data.CodeMe(count, _buff.buff);
ilen = ilen + sizeof(NET_SEND_HEAD) - 1;
return WinSock->OnSend(&_buff.op, ilen);
}
bool NetClient::DelRole(const wchar_t* rolename, unsigned _len)
{
DATA_DELROLE _data;
_data.op = 0x06;
_data.len = _len;
memcpy(_data.buff, rolename, _len);
return WinSock->OnSend((char*)&_data, sizeof(DATA_DELROLE) - 1);
}
void NetClient::Init(GameWinSock* _winSock)
{
for (int i = 0; i < 0x100; i++) {
SendProc[i] = &NetClient::DefaultProc;
RecvProc[i] = &NetClient::DefaultProc;
}
this->WinSock = _winSock;
// 注册登录数据包处理函数
SendProc[I_LOGIN] = &NetClient::OnClientlogin;
SendProc[I_CREATEROLE_START] = &NetClient::OnClientStartCreateRole;
SendProc[I_DELROLE] = &NetClient::OnClientDelRole;
SendProc[I_SEND_CUSTOM] = &NetClient::OnClientSendCustom;
SendProc[I_CREATEROLE] = &NetClient::OnClientCreateRole;
SendProc[I_SELECT_ROLE] = &NetClient::OnClientSelectRole;
// 注册数据登录失败数据包处理函数
RecvProc[S_TIPS] = &NetClient::OnSvrTips;
RecvProc[S_LOGINOK] = &NetClient::OnSverStruct;
RecvProc[S_CREATEROLE_START] = &NetClient::OnSvrStartCreateRole;
RecvProc[S_NOTICE] = &NetClient::OnSverNotice;
RecvProc[S_NOTICE_COM] = &NetClient::OnSverNotice;
RecvProc[S_OBJECT] = &NetClient::OnSverObject;
RecvProc[S_STRUCT] = &NetClient::OnSverStruct;
RecvProc[S_OBJECT_INIT] = &NetClient::OnSvrObjectInit;
}
bool NetClient::OnDelRole(wchar_t* rolename, unsigned _len)
{
// AfxMessageBox(rolename);
return true;
}
void NetClient::Onlogin(const char* Id, const char* Pass)
{
/*
const int bufflen = sizeof(DATA_LOGIN) + 1;
char buff[bufflen];
DATA_LOGIN data;
// 有些操作系统这样写会报错，因为内存不对齐，现在Windows下没事
//PDATALOGIN _data = (PDATALOGIN)(buff + 1);
// 这样写就能解决内存对齐问题
PDATALOGIN _data =&data;
int len = strlen(Id);
memcpy(_data->Id, Id, len);
len = strlen(Pass);
memcpy(_data->Pass, Pass, len);
memcpy(buff+1, _data, sizeof(DATA_LOGIN));
buff[0] = I_LOGIN;
return WinSock->OnSend(buff, sizeof(buff));
*/
}
bool NetClient::OnStartCreateRole(int code)
{
return true;
}
bool NetClient::OnCreateRole(PNS_CREATEROLE _header, PCREATE_ROLE_DATAS _body)
{
return true;
}
bool NetClient::OnSendCustom(PNET_SEND_CHEAD _coder, char*& buffer, unsigned& len)
{
switch (_coder->opcode.value())
{
case SC_CHOOSECAMP:
return OnChooseCamp((PNS_CHOOSECAMP)_coder);
case SC_CHAT:
return OnChat((PCHAT_DATA)_coder);
case SC_BEEP:
return OnHeartBeep((PHEART_BEEP)_coder);
case SC_LOOP:
return OnHeartLoop((PHEART_LOOP)_coder);
case SC_INITED:
// case SC_REONLINE:
case SC_INIT_START:
case SC_HAND:
case SC_HAND_IN:
return false;
default:
break;
}
return true;
}
bool NetClient::OnSelectRole(wchar_t* rolename)
{
//AfxMessageBox(rolename);
return true;
}
bool NetClient::OnChooseCamp(PNS_CHOOSECAMP _coder)
{
PNS_CHOOSECAMP _p = (PNS_CHOOSECAMP)_coder;
return true;
}
bool NetClient::OnChat(PCHAT_DATA _coder)
{
switch (_coder->ChartId)
{
case 3:// 私聊
return OnChatPrivate((PCHAT_PRV)_coder);
case 1:// 附近频道
case 2:// 区域频道
case 6:// 公会频道
case 9:// 阵营频道
case 21:// 喊话频道
return OnChatPublic((PCHAT_PUB)_coder);
break;
}
return true;
}
bool NetClient::OnChatPublic(PCHAT_PUB _coder)
{
return true;
}
bool NetClient::OnChatPrivate(PCHAT_PRV _coder)
{
return true;
}
bool NetClient::OnHeartBeep(PHEART_BEEP _coder)
{
return true; // 返回false会拦截81心跳包不给服务端发送
}
bool NetClient::OnHeartLoop(PHEART_LOOP _coder)
{
return true; // 返回false会拦截SC_LOOP心跳包不给服务端发送
}
bool NetClient::OnSvrChat(PCHAT_PRV _coder)
{
//AfxMessageBox(_coder->name);
//AfxMessageBox(_coder->txt);
//switch (_coder->ChartId)
//{
//case 3:// 私聊
// return OnChatPrivate((PCHAT_PRV)_coder);
//case 1:// 附近频道
//case 2:// 区域频道
//case 6:// 公会频道
//case 9:// 阵营频道
//case 21:// 喊话频道
// return OnChatPublic((PCHAT_PUB)_coder);
// break;
//}
return true;
}
bool NetClient::Tips(int code)
{
#ifdef Anly
CString txt;
if (code == 51001) {
txt = L"登陆失败,易道云通行证不存在!";
}else if (code == 51002) {
txt = L"登录失败,密码错误!";
}else if (code == 21101) {
txt = L"人物重名!";
}else if (code == 21109) {
txt = L"名字过长或包含非法字符!";
}
else {
txt.Format(L"未知登录错误:%d", code);
}
anly->SendData(TTYPE::I_LOG, 0, txt.GetBuffer(), (txt.GetLength() + 1)*2);
#endif
return true;
}
void NetClient::loginok(ROLE_DATA* _roles, int count)
{
logined = true;
if(roles) delete[] roles;
roles = _roles;
rolecount = count;
}
bool NetClient::OnScrStartCreateRole(short code, wchar_t* _txt)
{
return true;
}
bool NetClient::OnSvrNotice(PNET_SEND_CHEAD _coder, int count, char*& buffer, unsigned& len)
{
if (_coder->msgHeader == "chat") {
return OnSvrChat((PCHAT_PRV)_coder);
}
return true;
}
bool NetClient::OnRecvData(char*& buff, unsigned& len)
{
#ifdef Anly
anly->SendData(TTYPE::I_RECV, buff[0], buff, len);
#endif
return (this->*RecvProc[buff[0]])(buff, len);
}
bool NetClient::OnSendData(char*& buff, unsigned& len)
{
#ifdef Anly
anly->SendData(TTYPE::I_SEND, buff[0], buff, len);
#endif
return (this->*SendProc[buff[0]])(buff, len);
}
bool NetClient::OnConnect(char*& ip, unsigned& port)
{
#ifdef Anly
// 长度24的原因，它是宽字节要，一个文字要2个字节，一共是10个文字加上结尾的0是11个
// 所以 11 乘以2，然后再加2
anly->SendData(TTYPE::I_LOG, 0, L"服务器正在连接。。。", 24);
#endif
return true;
}
// 默认的数据处理函数
bool NetClient::DefaultProc(char*&, unsigned&)
{
return true;
}
// 复制过来的内容
bool NetClient::OnClientlogin(char*& buff, unsigned& len)
{
PDATALOGIN _data = (PDATALOGIN)(buff + 1);
char* _id = _data->Id;
_data = (PDATALOGIN)(buff + 1 + _data->lenId - 0x10);
char* _pass = _data->Pass;
Onlogin(_id, _pass);
/* 修改账号密码
len = sizeof(DATA_LOGIN) + 1;
buff = new char[len];
DATA_LOGIN data;
PDATALOGIN _data = &data;
buff[0] = 0x2;
CStringA _id = "";// 补充账号
CStringA _pass = "";// 补充密码
memcpy(_data->Id, _id.GetBuffer(), _id.GetLength());
memcpy(_data->Pass, _pass.GetBuffer(), _pass.GetLength());
memcpy(buff + 1, _data, len - 1);
*/
/* 监控登录数据
PDATALOGIN _data = (PDATALOGIN)buff;
CStringA _id = _data->Id;
_data = (PDATALOGIN)(buff + _data->lenId - 0x10);
CStringA _pass = _data->Pass;
CStringA _tmp;
// 请求登录 账号[% s]密码[% s] 这个内容别人在逆向的时候就会看到
// 所以这种东西需要自己搞个编码来代替它
_tmp.Format("请求登录 账号[%s]密码[%s]", _id, _pass);
#ifdef Anly
anly->SendData(TTYPE::I_DIS, 1, _tmp.GetBuffer(), _tmp.GetAllocLength());
#endif
*/
/*
返回false，游戏无法发送数据包
原因看调用此此函数的位置 OnSend 函数（if (SendDealProc[buff[0]]((buff + 1), len - 1))）
*/
return true;
}
bool NetClient::OnClientStartCreateRole(char*& buff, unsigned& len)
{
// 申请进入创建角色界面
int* code = (int*)&buff[1];
return OnStartCreateRole(code[0]);
}
bool NetClient::OnClientCreateRole(char*& buff, unsigned& len) {
PNS_CREATEROLE head = (PNS_CREATEROLE)(buff - 3);
int icount = head->count;
if (icount < 1)return true;
char* buffStart = (char*)head + sizeof(NET_SEHD_CREATEROLE_HEAD);
#ifdef Anly
GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0], 1);// 翻译解析约定数据
#endif // Anly
EnCode codes[sizeof(CREATE_ROLE_DATAS) / sizeof(EnCode)]{};
int stDecode = 0;
while (stDecode < icount) {
codes[stDecode++] = buffStart;
}
/*
Client->OnCreateRole(head, (PCREATE_ROLE_DATAS)codes) 数据包传给虚函数
如果想对发送创建角色数据包做些什么直接继承NetClient重写OnCreateRole函数既可以了
*/
return Client->OnCreateRole(head, (PCREATE_ROLE_DATAS)codes);// 返回false屏蔽05开头的数据包，也就是创建角色发送的数据包
}
bool NetClient::OnClientSendCustom(char*& buff, unsigned& len) {
PNET_SEND_HEAD head = (PNET_SEND_HEAD)(buff - 1);
int icount = head->count;
if (icount < 1)return true;
char* buffStart = (char*)head + sizeof(NET_SEND_HEAD);
if (buffStart[0] != 0x02) {
#ifdef Anly
if (icount < MAX_SEND_COUNT)
anly->SendData(TTYPE::I_DIS, I_SEND_CUSTOM, "SEND_CUSTOM MAX_SEND_COUNT 内存解码器空间不足", 46);
anly->SendData(TTYPE::I_DIS, I_SEND_CUSTOM, "SEND_CUSTOM 发现异常数据", 25);
#endif
return true;
}
#ifdef Anly
GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0], 1);
#endif
int stDecode = 0;
EnCode codes[MAX_SEND_COUNT]{};
while (stDecode < icount) {
codes[stDecode++] = buffStart;
}
/*
Client->OnSendCustom((PNET_SEND_CHEAD)codes, buff, len); 数据包传给虚函数
如果想对发送数据的0A开头的据包做些什么直接继承NetClient重写OnSendCustom函数既可以了
*/
return Client->OnSendCustom((PNET_SEND_CHEAD)codes, buff, len);
}
bool NetClient::OnClientSelectRole(char*& buff, unsigned& len) {
PNS_SELECTROLE p = (PNS_SELECTROLE)buff;
return Client->OnSelectRole((wchar_t*)(p->buff));
}
bool NetClient::OnClientDelRole(char*& buff, unsigned& len) {
PDATADELROLE p = (PDATADELROLE)buff;
return Client->OnDelRole((wchar_t*)(p->buff), p->len);
// 返回值改为false将拦截发送的删除角色数据包
// 详情看注册 OnDelRole 函数的位置，Init函数
// return true;
}
// 接收数据截取区
bool NetClient::OnSvrTips(char*& buff, unsigned& len) {
int* code = (int*)&buff[1];
return Client->Tips(code[0]);
}
bool NetClient::OnSvrloginOk(char*& buff, unsigned& len) {
PDATALOGINOK _p = (PDATALOGINOK)&buff[1];
ROLE_DATA* roleDatas = nullptr;
if (_p->RoleCount > 0) {
char* buffStart = buff + 1 + sizeof(DATA_LOGIN_OK);
#ifdef Anly
GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0]);
#endif // Anly
roleDatas = new ROLE_DATA[_p->RoleCount];
for (int i = 0; i < _p->RoleCount; i++)
{
roleDatas[i].byte.Init(buffStart, 0);
roleDatas[i].index.Init(buffStart, 0);
roleDatas[i].un1.Init(buffStart, 0);
roleDatas[i].name.Init(buffStart, 0);
roleDatas[i].infos.Init(buffStart, 0);
roleDatas[i].un2.Init(buffStart, 0);
roleDatas[i].un3.Init(buffStart, 0);
}
Client->loginok(roleDatas, _p->RoleCount);
}
return true;
}
bool NetClient::OnSverObject(char*& buff, unsigned& len) {
PNR_HEAD head = (PNR_HEAD)(buff - 1);
//head->count;
if (ObjectTable) {
delete[] ObjectTable;
}
if (ObjectTxt) {
delete[] ObjectTxt;
}
ObjectTable = new OBJECT_DESC[head->count];
ObjectTxt = new char[len];
memcpy(ObjectTxt, buff, len);// 这里怕 buff 的内容被游戏释放掉，后面我们用的时候没法用，所以把buff的内容复制到我们的变量里
char* buffStart = ObjectTxt + sizeof(NR_NOTICE_HEAD)-1;
//#ifdef Anly
// CStringA szTxtA;
// CStringA szTmp;
//#endif // Anly
//#ifdef Anly
// szTmp.Format("[%X]%s:%d\r\n", i, ObjectTable[i].name, ObjectTable[i].type);
// szTxtA += szTmp;
//#endif // Anly
//#ifdef Anly
// anly->SendData(TTYPE::I_DIS, S_OBJECT, szTxtA.GetBuffer(), szTxtA.GetAllocLength() + 1);
//#endif // Anly
for (int i = 0; i < head->count; i++)
{
ObjectTable[i].name = buffStart;
buffStart = buffStart + strlen(ObjectTable[i].name) + 1;
ObjectTable[i].type = buffStart[0];
buffStart++;
}
#ifdef Anly
GameAnlyer->CreateObjectfiles(ObjectTable, head->count);
#endif // Anly
return true;
}
bool NetClient::OnSverStruct(char*& buff, unsigned& len) {
return true;
}
bool NetClient::OnSvrObjectInit(char*& buff, unsigned& len)
{
// 初始化对象
PNR_OBJINIT head = (PNR_OBJINIT)(buff - 7);
char* buffStart = (char*)head + sizeof(NR_OBNJECT_INIT) - 2;
#ifdef Anly
GameAnlyer->AnlyData(buffStart, buff + len, head->icount, S_OBJECT_INIT, ObjectTable);
#endif
return true;
}
/*
OnSverrNotice函数处理的数据包格式如下
1E 06 00
06 11 00 00 00 70 6C 61 79 5F 70 6F 69 6E 74 5F 73 6F 75 6E 64 00
06 01 00 00 00 00
04 2C 92 87 C5
04 FA 03 BF 42
04 33 14 BD 45
02 00 00 00 00
1E 06 00 是 PNR_NOTICE_HEAD
06 11 00 00 00 70 6C 61 79 5F 70 6F 69 6E 74 5F 73 6F 75 6E 64 00是一个EnCode
06 01 00 00 00 00是一个EnCode
04 2C 92 87 C5是一个EnCode
04 FA 03 BF 42是一个EnCode
04 33 14 BD 45是一个EnCode
02 00 00 00 00是一个EnCode
*/
bool NetClient::OnSverNotice(char*& buff, unsigned& len) {
PNR_NOTICE_HEAD head = (PNR_NOTICE_HEAD)(buff - 1);
int icount = head->count;
char* buffStart = (char*)head + sizeof(NR_NOTICE_HEAD);
if (icount < 1) {
return true;
}
if (icount > MAX_RECV_COUNT) {
#ifdef Anly
anly->SendData(TTYPE::I_DIS, S_NOTICE, "S_NOTICE 解码器内存不足", 24);
#endif
return true;
}
#ifdef Anly
GameAnlyer->AnlyBuff(buffStart, buff + len, buff[0], 1);
#endif
int stDecode = 0;
EnCode codes[MAX_RECV_COUNT]{};
while (stDecode < icount) {
codes[stDecode++] = buffStart;
}
return Client->OnSvrNotice((PNET_SEND_CHEAD)codes, icount, buff, len);
}
bool NetClient::OnSvrStartCreateRole(char*& buff, unsigned& len) {
short* _st = (short*)&buff[1];
wchar_t* _txt = (wchar_t*)&buff[3];
#ifdef Anly
CString txt;
CStringA txtA;
txt.Format(L"code:%d\r\n%s", _st[0], _txt);
txtA = txt;
//AfxMessageBox(txtA);
anly->SendData(TTYPE::I_DIS, S_CREATEROLE_START, txtA.GetBuffer(), txt.GetAllocLength() + 1);
#endif
/*
Client->OnSendCustom((PNET_SEND_CHEAD)codes, buff, len); 数据包传给虚函数
如果想对0A开头的据包做些什么直接继承NetClient重写OnSendCustom函数既可以了
*/
return Client->OnScrStartCreateRole(_st[0], _txt);
}
NetClass.h文件的修改：修改了 OBJECT_DESC结构体
#pragma once
#include "EnCode.h"
// 数据包头
// 发送
#define I_LOGIN 0x2 // 登录
#define I_CREATEROLE_START 0x3 // 创建角色发送数据包的头
#define I_SELECT_ROLE 0x04 // 选择角色进入游戏的数据包头
#define I_CREATEROLE 0x05 // 创建角色给服务端发送的数据包头
#define I_DELROLE 0x6 // 删除角色发送数据包的头
#define I_SEND_CUSTOM 0x0A // 进入游戏之后大部分数据包的头
// 接收
#define S_TIPS 0x3 // 服务端返回错误的数据包头
#define S_LOGINOK 0x4 // 登录成功的返回数据包的头
// 创建角色服务端反馈的数据（发送03 01 00 00 00这个数据包服务端返回的数据包头）
#define S_CREATEROLE_START 0x05
#define S_OBJECT 0x9
#define S_STRUCT 0xA
#define S_NOTICE 0x1E // 里面有聊天数据
#define S_NOTICE_COM 0x27 // 里面有聊天数据
#define S_OBJECT_INIT 0x28 // 里面有角色基础信息
/*
最多的数据项, 0A开头的数据包里有数据参数个数，这个宏就是用来设定
数据参数个数最大数量是多少，0A开头的数据包目前见过最大
数据参数个数是十几个，这里写20应该完全够用，如果不够用
到时候再增加
*/
#define MAX_SEND_COUNT 100
#define MAX_RECV_COUNT 100
// 发送数据操作码定义
#define SC_CHOOSECAMP 591 // 阵营选择操作码
#define SC_CHAT 1
#define SC_BEEP 81
#define SC_LOOP 1015
// 游戏客户端处理完进入游戏按钮触发的数据包之后，发送的请求
#define SC_INITED 964
#define SC_REONLINE 860
#define SC_INIT_START 661
#define SC_HAND 962
#define SC_HAND_IN 102
// 角色初始化数据
/*
28 op
E6 44 00 01 39 0A 63 04 lId
6F 3A 07 C4 x
49 C8 81 41 h
46 1E 40 44 y
BC 74 03 40 face
6F 3A 07 C4 tx
49 C8 81 41 th
46 1E 40 44 ty
BC 74 03 40 tface
00 00 00 00 un[0]
00 00 00 00 un[1]
00 00 00 00 un[2]
00 00 00 00 un[3]
00 00 00 00 un[4]
5E 00 icount
多出来的type是为了内存对齐才写的
*/
typedef struct NR_OBNJECT_INIT {
char un1[6];
char len = sizeof(NR_OBNJECT_INIT) - 9;
char op = 0x28;
long long lId;
float x;
float h;
float y;
float face;
float tx;
float th;
float ty;
float tface;
float un2[5]{};
short icount;
short type;
}*PNR_OBJINIT;
// 保存对象数据描述信息的结构体（游戏数据类型表）
typedef struct OBJECT_DESC {
char* name;
int type;
}*POBJ_DESC;
// 数据头结构体 数据结构约定
// 也就是接收到1E包的头部
typedef struct NR_NOTICE_HEAD {
char un;
char op;
short count;
}NR_HEAD, *PNR_HEAD, *PNR_NOTICE_HEAD;
// 选择角色头部
typedef struct NET_SEND_SELECTROLE {
char op = 0x04;
char buff[83]{};
}NS_SELECTROLE, * PNS_SELECTROLE;
// 创建角色数据头部
typedef struct NET_SEHD_CREATEROLE_HEAD {
/*
char un[0x2];
char len = sizeof(NET_SEHD_CREATEROLE_HEAD) - 0x03;
这俩代码是为了解决内存对齐的问题，创建角色给服务端发送的
05开头的数据包，把05变成00 00 00 05
*/
char un[0x2];
char len = sizeof(NET_SEHD_CREATEROLE_HEAD) - 0x03;
char op = 0x05;
int index = 0x0; // 选择角色列表索引
/*
宽字节是2字节0x10是16两个是32，正好满足
给服务端发送的创建角色数据包，也就是05开头的数据包
*/
wchar_t name[0x20];
short unst = 0x00;
short count = 0x08;
}*PNS_CREATEROLE;
// 基类
typedef class NET_SEND_BASE {
public:
// 实现编码操作，模拟游戏数据包给服务端发送数据，这个模拟的数据包通过调用 CodeMe函数得到
unsigned CodeMe(int size, char* buffer);
}NSR_BASE, *PNET_SEND_BASE, * PNSR_BASE;
typedef struct NS_CREATEROLE_HEAD_BUFF :public NET_SEHD_CREATEROLE_HEAD {
char buff[0x300]{};
}*PNS_CREATEROLEBUFF;
// 解析约定结构体
// 创建角色数据结构体
typedef class CREATE_ROLE_DATAS:public NET_SEND_BASE {
public:
GDOUBLE sex;//1.000000 性别 0 男 1 女
GDOUBLE camp;//1.000000 阵营 1 艾森赫特 2 格兰蒂尔
GDOUBLE face;//1.000000 种族 1 布冯特人 3 格洛玛人 4 尤恩图人 6 喀什人
GDOUBLE occu;//3.000000 职业 1 仲裁者 3秘法师 6 猎魔人 8 元素法师
GCHAR Photo;//gui\BG_team\TeamRole\Teamrole_zq_humF_001.PNG
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;
GCHAR Txt;// 细节编辑捏脸
GDOUBLE faceSahpe;//0.000000 脸型 0 1 2 3
}* PCREATE_ROLE_DATAS;
// 发送数据标准头 0xA数据包
typedef struct NET_SEND_HEAD {
// 为了内存对齐，当前结构不可能超过255，所以这样写是没问题的
char len = sizeof(NET_SEND_HEAD) - 1;
char op = 0x0A;
short unst = 0;
int unnt[4]{};
short unst1 = 0;
short count = 0;
}*PNET_SEND_HEAD;
// 开始创建角色的数据结构
// 申请创建角色结构体
typedef struct NET_CREATEROLE_START {
char un[0x02];// 用来做内存对齐
char len = sizeof(NET_CREATEROLE_START) - 3;// 用来做内存对齐
char op = 0x03;
int code = 0x01;
}*PNET_CREATEROLE_START;
// 删除角色数据结构
typedef struct DATA_DELROLE {
char op;
char buff[0x1F];
int len;
int un[8] = { 0x01 , 0x03 };
}*PDATADELROLE;
/*
数据包还原结构体要注意内存对齐，如果数据不满4字节，它字段会补齐
比如结构体里有一个char变量，它是1字节，在内存里它可能会为了内存对齐
让它变成4字节，所以这要注意
*/
// 登录数据
typedef struct DATA_LOGIN {
int op = 0x0300;
char buff[0x10]{};
int lenId = 0x10;
/*
这个是登录的账号，它可能会变成0x20或更长，现在默认让它0x10
读的时候以长度为准就好了
*/
char Id[0x10]{};
int lenPass = 0x10;
/*
这个是登录的密码，它可能会变成0x20或更长，现在默认让它0x10
读的时候以长度为准就好了
*/
char Pass[0x10]{};
int lenCode = 0x10;
char Code[0x10]{};
int eop = 0x01;
}*PDATALOGIN;
typedef struct DATA_LOGIN_OK {// 登录成功数据包头
int un[8] = { 0, 0, 0x76B, 0x0C, 0x1E,0, 0, 0 };
int index = 0;
int RoleCount = 0;
}*PDATALOGINOK;
// 发送数据包含内存空间，也就是数据参数，数据参数的意思看44文章里的内容
typedef struct NET_SEND_BUFF:public NET_SEND_HEAD {
char buff[0x1000]{};
}*PNET_SEND_BUFF;
typedef class NET_SEND_CHEAD:public NET_SEND_BASE {
public:
union {
GCHAR msgHeader;
GINT opcode;
};
public:
NET_SEND_CHEAD() {};
~NET_SEND_CHEAD() {};
}NSR_CHEAD, *PNSR_CHEAD, *PNET_SEND_CHEAD;
// 选择角色
typedef class NET_SEND_CHOOSECAMP :public NET_SEND_CHEAD {
public:
GCHAR camps;
}*PNS_CHOOSECAMP;
// 心跳包数据结构
typedef class HEART_BEEP :public NET_SEND_CHEAD {
public:
// 20秒一次
GINT tick;//3
}*PHEART_BEEP;
typedef class HEART_LOOP :public NET_SEND_CHEAD {
public:
// 5秒一次
GINT64 tick;//9320695
GCHAR txt;//
}*PHEART_LOOP;
typedef struct ONLINE_HAND: public NSR_CHEAD{
GINT step; // 2
GINT state; // 1
}*PONLINE_HAND;
typedef struct ONLINE_INIT : public NSR_CHEAD {
GINT state;//0
GDOUBLE un;//180000000.000000
}*PONLINE_INIT;
// 登陆后角色数据区
// 聊天数据包的数据结构
typedef class CHAT_DATA :public NET_SEND_CHEAD {
public:
GINT ChartId;//1
}*PCHAT_DATA;
typedef class CHAT_PUBLIC :public CHAT_DATA {
public:
GUTF16 txt;//[222222222222222222222222222222222222222222<img src="Face37" valign="bottom" only="line"/>]
GDOUBLE un;//0.000000
}*PCHAT_PUB;
typedef class CHAT_PRIVATE :public CHAT_DATA {
public:
GUTF16 txt;//[222222222222222222222222222222222222222222<img src="Face37" valign="bottom" only="line"/>]
GUTF16 name;//[皮革兔]
GDOUBLE un;//0.000000
}*PCHAT_PRV;
// 登陆后角色数据包
typedef class ROLE_DATA {// 登录成功数据包
public:
GBYTE byte;
GINT index;
GINT un1;
GUTF16 name;
GUTF16 infos;
GINT un2;
GINT64 un3;
}*PROLEDATA;
GameAnly.cpp文件的修改：引入 iostream、fstream用于文件写入，修改了 AnlyData函数、ToAscii函数、ToUniode函数，新加 CreateObjectfiles函数
#include "pch.h"
#include "GameAnly.h"
#include <iostream>
#include <fstream>
#ifdef Anly
// 它会生成一个结构体，详情看效果图
void GameAnly::AnlyBuff(char* start, char* end, int MsgId, char index)
{
CStringA txt;
CStringA tmp;
CString utmp;
EnCode _coder;
GBYTE* _bytecoder;
GSHORT* _shortcoder;
GINT* _intcoder;
GFLOAT* _floatcoder;
GDOUBLE* _doublecoder;
GCHAR* _asccoder;
GUTF16* _utfcoder;
GINT64* _int64coder;
while (start < end) {
_coder.Init(start, index);
CStringA _opname = data_desc[_coder.index][_coder.op].name;
// _opname.MakeLower()是变为小写字母，会影响 _opname它的值
// 所以又写了一边 data_desc[_coder.index][_coder.op].name
tmp.Format("%s %s;//", data_desc[_coder.index][_coder.op].name, _opname.MakeLower().GetBuffer());
txt = txt + tmp;
if (_coder.index == 0) {
switch (_coder.op)
{
case 1:
_shortcoder = (GSHORT*)&_coder;
tmp.Format("%d\r\n", _shortcoder->value());
txt = txt + tmp;
break;
case 2:
_intcoder = (GINT*)&_coder;
tmp.Format("%d\r\n", _intcoder->value());
txt = txt + tmp;
break;
case 4:
_floatcoder = (GFLOAT*)&_coder;
tmp.Format("%f\r\n", _floatcoder->value());
txt = txt + tmp;
break;
case 6:
_bytecoder = (GBYTE*)&_coder;
tmp.Format("%d\r\n", _bytecoder->value());
txt = txt + tmp;
break;
case 7:
_utfcoder = (GUTF16*)&_coder;
utmp.Format(L"[%s]\r\n", _utfcoder->value());
tmp = utmp;
txt = txt + tmp;
break;
// 5号之前分析的忘记截图了，现在找不到它的数据包了，如果后面再见到05的时候再详细补充说明
// 之前的分析05就是double类型
case 5:
_doublecoder = (GDOUBLE*)&_coder;
tmp.Format("%lf\r\n", _doublecoder->value());
txt = txt + tmp;
break;
case 8:
case 3:
_int64coder = (GINT64*)&_coder;
tmp.Format("%lld\r\n", _int64coder->value());
txt = txt + tmp;
break;
default:
break;
}
}
if (_coder.index == 1) {
switch (_coder.op)
{
case 1:
_shortcoder = (GSHORT*)&_coder;
tmp.Format("%d\r\n", _shortcoder->value());
txt = txt + tmp;
break;
case 2:
_intcoder = (GINT*)&_coder;
tmp.Format("%d\r\n", _intcoder->value());
txt = txt + tmp;
break;
case 4:
_floatcoder = (GFLOAT*)&_coder;
tmp.Format("%f\r\n", _floatcoder->value());
txt = txt + tmp;
break;
case 6:
_asccoder = (GCHAR*)&_coder;
tmp.Format("%s\r\n", _asccoder->value());
txt = txt + tmp;
break;
case 7:
_utfcoder = (GUTF16*)&_coder;
utmp.Format(L"[%s]\r\n", _utfcoder->value());
tmp = utmp;
txt = txt + tmp;
break;
case 5:
_doublecoder = (GDOUBLE*)&_coder;
tmp.Format("%lf\r\n", _doublecoder->value());
txt = txt + tmp;
break;
case 8:
case 3:
_int64coder = (GINT64*)&_coder;
tmp.Format("%lld\r\n", _int64coder->value());
txt = txt + tmp;
break;
default:
break;
}
}
}
anly->SendData(TTYPE::I_DIS, MsgId, txt.GetBuffer(), txt.GetAllocLength() + 1);
}
void GameAnly::AnlyData(char* start, char* end, int count, int MsgId, POBJ_DESC desc)
{
int iProc = 0;
int value;
long long llvalue;
float fvalue;
double dbval;
CStringA szTmp, _tmp, szTxt;
CString wTmp;
while ((iProc < count) && (start <end)) {
short* index = (short*)start;
int type = desc[index[0]].type;
char* name = desc[index[0]].name;
switch (type)
{
case 0:
AfxMessageBox(L"0号信息！"); break;
case 1:
value = ToChar(start);
szTmp.Format("%s = %d", name, value);
break;
case 2:
value = ToShort(start);
szTmp.Format("%s = %d", name, value);
break;
case 3:
value = ToInt(start);
szTmp.Format("%s = %d", name, value);
break;
case 4:
llvalue = ToLLong(start);
szTmp.Format("%s = %lld", name, llvalue);
break;
case 5:
fvalue = ToFloat(start);
szTmp.Format("%s = %f", name, fvalue);
break;
case 6:
dbval = ToDouble(start);
szTmp.Format("%s = %lf", name, dbval);
break;
case 7:
_tmp = ToAscii(start);
szTmp.Format("%s = %s", name, _tmp.GetBuffer());
break;
case 8:
wTmp = ToUniode(start);
_tmp = wTmp;
szTmp.Format("%s = %s", name, _tmp.GetBuffer());
break;
case 9:AfxMessageBox(L"9号数据出现"); return;
default:
break;
}
szTxt = szTxt + szTmp + "\r\n";
iProc++;
}
anly->SendData(TTYPE::I_DIS, MsgId, szTxt.GetBuffer(), szTxt.GetAllocLength() + 1);
//CStringA tmpA;
//CStringA szTxt, szTmp;
//szTmp.Format("id:%lld\r\n", head->lId);
//szTxt = szTxt + szTmp;
//szTmp.Format("x:%f h:%f y:%f\r\n", head->x, head->h, head->y);
//szTxt = szTxt + szTmp;
//char* buffStart = (char*)head + sizeof(NR_OBNJECT_INIT) - 2;
//int icount = head->icount;
//int iProc = 0;
//while (iProc < icount) {
// short* type = (short*)buffStart;
// char* _name = ObjectTable[type[0]].name;
// int _type = ObjectTable[type[0]].type;
// char* _byte;
// short* _short;
// int* _int;
// float* _float;
// long long* _llong;
// double* _double;
// int lenth;
// CString _txt;
// /*
// 1B 00 type[0] buffStart + 2;
// 0C 00 00 00 CA 4E 5A 66 53 62 01 80 4E 86 00 00
// 1D 00 type[0]
// 00 00 48 42 buffStart + 2;
// 01 00 type[0]
// 02 buffStart + 2;
// 02 00 type[0]
// 01 buffStart + 2;
// 03 00 2E 00 00 00 67 75 69 5C 42 47 5F 74 65 61 6D 5C 54 65 61 6D 52 6F 6C 65 5C 54 65 61 6D 72 6F 6C 65 5F 7A 71 5F 68 75 6D 46 5F 30 30 31 2E 50 4E 47 00
// 04 00 01 00 00 00
// 05 00 01 00 00 00
// 06 00 01 00 00 00
// 07 00 01 00 00 00
// 08 00 00 B1 9E 00
// */
// buffStart = buffStart + 2;
// switch (_type)
// {
// case 0:
// AfxMessageBox(L"0号信息！"); break;
// case 1:
// _byte = buffStart;
// szTmp.Format("%s = %d", _name, _byte[0]);
// buffStart = buffStart + 1;
// break;
// case 2:
// _short = (short*)buffStart;
// szTmp.Format("%s = %d", _name, _short[0]);
// buffStart = buffStart + 2;
// break;
// case 3:
// _int = (int*)buffStart;
// szTmp.Format("%s = %d", _name, _int[0]);
// buffStart = buffStart + 4;
// break;
// case 4:
// _llong = (long long*)buffStart;
// szTmp.Format("%s = %lld", _name, _llong[0]);
// buffStart = buffStart + 8;
// break;
// case 5:
// _float = (float*)buffStart;
// szTmp.Format("%s = %f", _name, _float[0]);
// buffStart = buffStart + 4;
// break;
// case 6:
// _double = (double*)buffStart;
// szTmp.Format("%s = %lf", _name, _double[0]);
// buffStart = buffStart + 8;
// break;
// case 7:
// _int = (int*)buffStart;
// lenth = _int[0];
// // szTmp = buffStart + 4;
// szTmp.Format("%s = %s", _name, buffStart + 4);
// buffStart = buffStart + 4 + lenth;
// break;
// case 8:
// _int = (int*)buffStart;
// lenth = _int[0];
// _txt = (wchar_t*)(buffStart + 4);
// tmpA = _txt;
// szTmp.Format("%s = %s", _name, tmpA);
// buffStart = buffStart + 4 + lenth;
// break;
// case 9:MessageBoxA(0, buffStart, buffStart, MB_OK); return true;
// default:
// break;
// }
// szTxt = szTxt + szTmp + "\r\n";
// iProc++;
//}
//anly->SendData(TTYPE::I_DIS, S_OBJECT_INIT, szTxt.GetBuffer(), szTxt.GetAllocLength() + 1);
}
void GameAnly::CreateObjectfiles(POBJ_DESC desc, int icount)
{
char* _GameOBJECThpp = "F:\\1.h";
std::ofstream ofs(_GameOBJECThpp);
if (!ofs.bad()) {
ofs << "#pragma once" << std::endl;
ofs << "#define GCHAR CStringA" << std::endl;
ofs << "#define GWCHAR CString" << std::endl;
ofs << "#define GOBJECT int" << std::endl;
ofs << "typedef class GAMEOBJECT{" << std::endl;
ofs << "public:" << std::endl;
// 变量声明
// i = 1的原因是游戏的数据类型表里（接收的09数据包）第一个是NONE
for (int i = 1; i < icount; i++)
{
char* valueName = desc[i].name;
int valueType = desc[i].type;
char* valueTypeName = data_desc[2][valueType].name;
int valueSize = data_desc[2][valueType].lenth;
ofs << " " << valueTypeName << " " << valueName << ";" << std::endl;
}
// 函数声明
ofs << "public:" << std::endl;
ofs << "}*PGAMEOBJ;" << std::endl;
}
else return;
}
char GameAnly::ToChar(char*& start)
{
char result = start[0];
start = start + 3;
return result;
}
short GameAnly::ToShort(char*& start)
{
short* result = (short*)(start + 2);
start = start + 2 + 2;
return result[0];
}
int GameAnly::ToInt(char*& start)
{
int* result = (int*)(start + 2);
start = start + 2 + 4;
return result[0];
}
float GameAnly::ToFloat(char*& start)
{
float* result = (float*)(start + 2);
start = start + 2 + 4;
return result[0];
}
double GameAnly::ToDouble(char*& start)
{
double* result = (double*)(start + 2);
start = start + 2 + 8;
return result[0];
}
long long GameAnly::ToLLong(char*& start)
{
long long* result = (long long*)(start + 2);
start = start + 2 + 8;
return result[0];
}
char* GameAnly::ToAscii(char*& start)
{
int* lenth = (int*)(start + 2);
char* result = start + 2 + 4; // +4这个操作是跳过 lenth的值
start = start + 2 + 4 + lenth[0];
return result;
}
wchar_t* GameAnly::ToUniode(char*& start)
{
int* lenth = (int*)(start + 2);
wchar_t* result = (wchar_t*)(start + 2 + 4); // +4这个操作是跳过 lenth的值
start = start + 2 + 4 + lenth[0];
return result;
}
#endif // Anly
GameAnly.h文件的修改：新加 CreateObjectfiles函数，修改了 ToAscii函数、ToUniode函数
#pragma once
#include "extern_all.h"
#ifdef Anly
// 用来分析游戏数据包
class GameAnly
{
public:
char ToChar(char*& start);
short ToShort(char*& start);
int ToInt(char*& start);
float ToFloat(char*& start);
double ToDouble(char*& start);
long long ToLLong(char*& start);
char* ToAscii(char*& start);
wchar_t* ToUniode(char*& start);
// end为了避免超长解读
void AnlyBuff(char* start, char* end, int MsgId, char index = 0);
void AnlyData(char* start, char* end, int count, int MsgId, POBJ_DESC desc);
void CreateObjectfiles(POBJ_DESC desc, int icount);
};
#endif // Anly
extern_all.h文件的修改：修改了 data_desc变量
/*
此文件是用来存放全局变量、全局函数（通用函数）
*/
#pragma once
#include "GameWinSock.h"
#include "GameProc.h"
#include "CAnly.h"
#include "NetClient.h"
#include "GameAnly.h"
typedef struct DATA_DESC {
char* name;
short lenth;
}*PDATADESC;
extern GameWinSock* WinSock;
extern GameProc* PGameProc;
extern NetClient* Client;
extern DATA_DESC data_desc[3][10];
extern void InitClassProc(LPVOID proc_addr, unsigned value);
extern void init_datadesc();
class GameAnly; // 不加这一个会因为引用编译不通过
#ifdef Anly
extern CAnly* anly;
extern GameAnly* GameAnlyer;
#endif
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
