Project_SG_ServerCode.git

			@@ -5117,129 +5117,6 @@


			#------------------------------------------------------
			#A3 04 玩家扫荡信息 #tagMCFBWipeOutData

			class tagMCFBData(Structure):
			_pack_ = 1
			_fields_ = [
			("FBID", c_int), #fbId
			("LineIndex", c_ubyte), #副本通关场次
			("WipeOutCnt", c_ubyte), #扫荡次数
			("passGrade", c_ubyte), #通关评级
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.FBID = 0
			self.LineIndex = 0
			self.WipeOutCnt = 0
			self.passGrade = 0
			return

			def GetLength(self):
			return sizeof(tagMCFBData)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''//A3 04 玩家扫荡信息 //tagMCFBWipeOutData:
			FBID:%d,
			LineIndex:%d,
			WipeOutCnt:%d,
			passGrade:%d
			'''\
			%(
			self.FBID,
			self.LineIndex,
			self.WipeOutCnt,
			self.passGrade
			)
			return DumpString


			class tagMCFBWipeOutData(Structure):
			Head = tagHead()
			WipeOutFBID = 0 #(DWORD WipeOutFBID)//当前扫荡的副本id
			FBDataCnt = 0 #(BYTE FBDataCnt)//
			FBDataList = list() #(vector<tagMCFBData> FBDataList)//
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x04
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.WipeOutFBID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FBDataCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FBDataCnt):
			temFBDataList = tagMCFBData()
			_pos = temFBDataList.ReadData(_lpData, _pos)
			self.FBDataList.append(temFBDataList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x04
			self.WipeOutFBID = 0
			self.FBDataCnt = 0
			self.FBDataList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 1
			for i in range(self.FBDataCnt):
			length += self.FBDataList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.WipeOutFBID)
			data = CommFunc.WriteBYTE(data, self.FBDataCnt)
			for i in range(self.FBDataCnt):
			data = CommFunc.WriteString(data, self.FBDataList[i].GetLength(), self.FBDataList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			WipeOutFBID:%d,
			FBDataCnt:%d,
			FBDataList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.WipeOutFBID,
			self.FBDataCnt,
			"..."
			)
			return DumpString


			m_NAtagMCFBWipeOutData=tagMCFBWipeOutData()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFBWipeOutData.Head.Cmd,m_NAtagMCFBWipeOutData.Head.SubCmd))] = m_NAtagMCFBWipeOutData


			#------------------------------------------------------
			# A3 18 极品白拿信息 #tagMCFreeGoodsInfo

			class tagMCFreeGoods(Structure):
			@@ -5524,118 +5401,6 @@

			m_NAtagMCFuncOpenStateList=tagMCFuncOpenStateList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFuncOpenStateList.Head.Cmd,m_NAtagMCFuncOpenStateList.Head.SubCmd))] = m_NAtagMCFuncOpenStateList


			#------------------------------------------------------
			# A3 1D 神兵等级信息 #tagMCGodWeaponLVList

			class tagMCGodWeaponLVInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("WeaponType", c_ubyte), #神兵类型
			("WeaponLV", c_ushort), #神兵等级
			("WeaponExp", c_int), #当前神兵经验
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.WeaponType = 0
			self.WeaponLV = 0
			self.WeaponExp = 0
			return

			def GetLength(self):
			return sizeof(tagMCGodWeaponLVInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A3 1D 神兵等级信息 //tagMCGodWeaponLVList:
			WeaponType:%d,
			WeaponLV:%d,
			WeaponExp:%d
			'''\
			%(
			self.WeaponType,
			self.WeaponLV,
			self.WeaponExp
			)
			return DumpString


			class tagMCGodWeaponLVList(Structure):
			Head = tagHead()
			WeaponNum = 0 #(BYTE WeaponNum)//神器个数
			WeaponInfoList = list() #(vector<tagMCGodWeaponLVInfo> WeaponInfoList)// 副本数据列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x1D
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.WeaponNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.WeaponNum):
			temWeaponInfoList = tagMCGodWeaponLVInfo()
			_pos = temWeaponInfoList.ReadData(_lpData, _pos)
			self.WeaponInfoList.append(temWeaponInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x1D
			self.WeaponNum = 0
			self.WeaponInfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.WeaponNum):
			length += self.WeaponInfoList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.WeaponNum)
			for i in range(self.WeaponNum):
			data = CommFunc.WriteString(data, self.WeaponInfoList[i].GetLength(), self.WeaponInfoList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			WeaponNum:%d,
			WeaponInfoList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.WeaponNum,
			"..."
			)
			return DumpString


			m_NAtagMCGodWeaponLVList=tagMCGodWeaponLVList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCGodWeaponLVList.Head.Cmd,m_NAtagMCGodWeaponLVList.Head.SubCmd))] = m_NAtagMCGodWeaponLVList


			#------------------------------------------------------
			@@ -5936,20 +5701,22 @@


			#------------------------------------------------------
			# A3 12 通知骑宠觉醒信息 #tagMCHorsePetSkinData
			# A3 03 坐骑阶级信息 #tagSCHorseClassInfo

			class tagMCHorsePetSkinInfo(Structure):
			class tagSCHorseClassInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Type", c_ubyte), # 1-坐骑 2-灵宠
			("ID", c_int), # 对应坐骑表灵宠表ID
			("Exp", c_int), #经验
			("SkinLV", c_ubyte), #觉醒等级
			("SkinIndex", c_ubyte), #当前选择外观
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ClassLV", c_ubyte), #当前阶级，从0开始
			("HorseLV", c_ushort), #当前阶等级，从1开始
			("Exp", c_ushort), #当前阶等级经验，每级从0开始
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x03
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			@@ -5958,111 +5725,51 @@
			return _pos + self.GetLength()

			def Clear(self):
			self.Type = 0
			self.ID = 0
			self.Cmd = 0xA3
			self.SubCmd = 0x03
			self.ClassLV = 0
			self.HorseLV = 0
			self.Exp = 0
			self.SkinLV = 0
			self.SkinIndex = 0
			return

			def GetLength(self):
			return sizeof(tagMCHorsePetSkinInfo)
			return sizeof(tagSCHorseClassInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A3 12 通知骑宠觉醒信息 //tagMCHorsePetSkinData:
			Type:%d,
			ID:%d,
			Exp:%d,
			SkinLV:%d,
			SkinIndex:%d
			DumpString = '''// A3 03 坐骑阶级信息 //tagSCHorseClassInfo:
			Cmd:%s,
			SubCmd:%s,
			ClassLV:%d,
			HorseLV:%d,
			Exp:%d
			'''\
			%(
			self.Type,
			self.ID,
			self.Exp,
			self.SkinLV,
			self.SkinIndex
			self.Cmd,
			self.SubCmd,
			self.ClassLV,
			self.HorseLV,
			self.Exp
			)
			return DumpString


			class tagMCHorsePetSkinData(Structure):
			Head = tagHead()
			Num = 0 #(BYTE Num)//个数
			InfoList = list() #(vector<tagMCHorsePetSkinInfo> InfoList)// 数据列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x12
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Num,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Num):
			temInfoList = tagMCHorsePetSkinInfo()
			_pos = temInfoList.ReadData(_lpData, _pos)
			self.InfoList.append(temInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x12
			self.Num = 0
			self.InfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Num):
			length += self.InfoList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.Num)
			for i in range(self.Num):
			data = CommFunc.WriteString(data, self.InfoList[i].GetLength(), self.InfoList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Num:%d,
			InfoList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.Num,
			"..."
			)
			return DumpString


			m_NAtagMCHorsePetSkinData=tagMCHorsePetSkinData()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHorsePetSkinData.Head.Cmd,m_NAtagMCHorsePetSkinData.Head.SubCmd))] = m_NAtagMCHorsePetSkinData
			m_NAtagSCHorseClassInfo=tagSCHorseClassInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCHorseClassInfo.Cmd,m_NAtagSCHorseClassInfo.SubCmd))] = m_NAtagSCHorseClassInfo


			#------------------------------------------------------
			# A3 10 通知坐骑幻化时效信息 #tagMCHorseSkinTimeInfoList
			# A3 04 坐骑外观信息 #tagSCHorseSkinInfo

			class tagMCHorseSkinTimeInfo(Structure):
			class tagSCHorseSkin(Structure):
			_pack_ = 1
			_fields_ = [
			("ID", c_int), # 对应坐骑幻化表ID
			("InvalidTime", c_int), # 失效时间戳
			("HorseSkinID", c_ubyte), #坐骑外观ID
			("State", c_ubyte), #是否已激活
			("EndTime", c_int), #到期时间戳，0为永久
			("Star", c_ubyte), #星级
			]

			def __init__(self):
			@@ -6075,146 +5782,44 @@
			return _pos + self.GetLength()

			def Clear(self):
			self.ID = 0
			self.InvalidTime = 0
			return

			def GetLength(self):
			return sizeof(tagMCHorseSkinTimeInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A3 10 通知坐骑幻化时效信息 //tagMCHorseSkinTimeInfoList:
			ID:%d,
			InvalidTime:%d
			'''\
			%(
			self.ID,
			self.InvalidTime
			)
			return DumpString


			class tagMCHorseSkinTimeInfoList(Structure):
			Head = tagHead()
			TimeCnt = 0 #(BYTE TimeCnt)//个数
			TimeInfoList = list() #(vector<tagMCHorseSkinTimeInfo> TimeInfoList)// 数据列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x10
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.TimeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.TimeCnt):
			temTimeInfoList = tagMCHorseSkinTimeInfo()
			_pos = temTimeInfoList.ReadData(_lpData, _pos)
			self.TimeInfoList.append(temTimeInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x10
			self.TimeCnt = 0
			self.TimeInfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.TimeCnt):
			length += self.TimeInfoList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.TimeCnt)
			for i in range(self.TimeCnt):
			data = CommFunc.WriteString(data, self.TimeInfoList[i].GetLength(), self.TimeInfoList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			TimeCnt:%d,
			TimeInfoList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.TimeCnt,
			"..."
			)
			return DumpString


			m_NAtagMCHorseSkinTimeInfoList=tagMCHorseSkinTimeInfoList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHorseSkinTimeInfoList.Head.Cmd,m_NAtagMCHorseSkinTimeInfoList.Head.SubCmd))] = m_NAtagMCHorseSkinTimeInfoList


			#------------------------------------------------------
			# A3 CD 坐骑星级信息 #tagMCHorseStarInfo

			class tagMCHorseStar(Structure):
			_pack_ = 1
			_fields_ = [
			("HorseID", c_int), # 坐骑表ID
			("Star", c_ubyte), # 星级
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.HorseID = 0
			self.HorseSkinID = 0
			self.State = 0
			self.EndTime = 0
			self.Star = 0
			return

			def GetLength(self):
			return sizeof(tagMCHorseStar)
			return sizeof(tagSCHorseSkin)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A3 CD 坐骑星级信息 //tagMCHorseStarInfo:
			HorseID:%d,
			DumpString = '''// A3 04 坐骑外观信息 //tagSCHorseSkinInfo:
			HorseSkinID:%d,
			State:%d,
			EndTime:%d,
			Star:%d
			'''\
			%(
			self.HorseID,
			self.HorseSkinID,
			self.State,
			self.EndTime,
			self.Star
			)
			return DumpString


			class tagMCHorseStarInfo(Structure):
			class tagSCHorseSkinInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			HorseStarList = list() #(vector<tagMCHorseStar> HorseStarList)
			HorseSkinList = list() #(vector<tagSCHorseSkin> HorseSkinList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCD
			self.Head.SubCmd = 0x04
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			@@ -6222,18 +5827,18 @@
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temHorseStarList = tagMCHorseStar()
			_pos = temHorseStarList.ReadData(_lpData, _pos)
			self.HorseStarList.append(temHorseStarList)
			temHorseSkinList = tagSCHorseSkin()
			_pos = temHorseSkinList.ReadData(_lpData, _pos)
			self.HorseSkinList.append(temHorseSkinList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCD
			self.Head.SubCmd = 0x04
			self.Count = 0
			self.HorseStarList = list()
			self.HorseSkinList = list()
			return

			def GetLength(self):
			@@ -6241,7 +5846,7 @@
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.HorseStarList[i].GetLength()
			length += self.HorseSkinList[i].GetLength()

			return length

			@@ -6250,14 +5855,14 @@
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.HorseStarList[i].GetLength(), self.HorseStarList[i].GetBuffer())
			data = CommFunc.WriteString(data, self.HorseSkinList[i].GetLength(), self.HorseSkinList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Count:%d,
			HorseStarList:%s
			HorseSkinList:%s
			'''\
			%(
			self.Head.OutputString(),
			@@ -6267,8 +5872,8 @@
			return DumpString


			m_NAtagMCHorseStarInfo=tagMCHorseStarInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCHorseStarInfo.Head.Cmd,m_NAtagMCHorseStarInfo.Head.SubCmd))] = m_NAtagMCHorseStarInfo
			m_NAtagSCHorseSkinInfo=tagSCHorseSkinInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCHorseSkinInfo.Head.Cmd,m_NAtagSCHorseSkinInfo.Head.SubCmd))] = m_NAtagSCHorseSkinInfo


			#------------------------------------------------------
			@@ -7539,58 +7144,6 @@

			m_NAtagMCNPCIDCollectionCntInfo=tagMCNPCIDCollectionCntInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNPCIDCollectionCntInfo.Head.Cmd,m_NAtagMCNPCIDCollectionCntInfo.Head.SubCmd))] = m_NAtagMCNPCIDCollectionCntInfo


			#------------------------------------------------------
			# A3 19 分包下载奖励记录 #tagMCPackDownloadRecord

			class tagMCPackDownloadRecord(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("Record", c_ubyte), #0-未领取 1-已领取
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x19
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xA3
			self.SubCmd = 0x19
			self.Record = 0
			return

			def GetLength(self):
			return sizeof(tagMCPackDownloadRecord)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A3 19 分包下载奖励记录 //tagMCPackDownloadRecord:
			Cmd:%s,
			SubCmd:%s,
			Record:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Record
			)
			return DumpString


			m_NAtagMCPackDownloadRecord=tagMCPackDownloadRecord()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPackDownloadRecord.Cmd,m_NAtagMCPackDownloadRecord.SubCmd))] = m_NAtagMCPackDownloadRecord


			#------------------------------------------------------
			@@ -9405,121 +8958,6 @@


			#------------------------------------------------------
			#A3 01 坐骑培养信息 #tagTrainHorseData

			class tagTrainHorseData(Structure):
			Head = tagHead()
			LV = 0 #(BYTE LV)//等阶
			EatItemCount = 0 #(DWORD EatItemCount)//当前阶已吃丹个数
			SkinPlusState = 0 #(DWORD SkinPlusState)//幻化激活状态，按位存储是否激活，幻化编号ID对应位，废弃，使用 SkinPlusStateList
			TrainTypes = 0 #(BYTE TrainTypes)//培养类型数
			TrainLVList = list() #(vector<DWORD> TrainLVList)//培养等阶列表，索引为培养类型减1
			TrainItemCountList = list() #(vector<DWORD> TrainItemCountList)//培养当前阶已吃培养丹个数列表，索引为培养类型减1
			SkinPlusStateCount = 0 #(BYTE SkinPlusStateCount)//幻化激活状态值数
			SkinPlusStateList = list() #(vector<DWORD> SkinPlusStateList)//幻化激活状态值列表，按位存储是否激活，幻化编号ID对应位
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x01
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.LV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.EatItemCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.SkinPlusState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TrainTypes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.TrainTypes):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.TrainLVList.append(value)
			for i in range(self.TrainTypes):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.TrainItemCountList.append(value)
			self.SkinPlusStateCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.SkinPlusStateCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.SkinPlusStateList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x01
			self.LV = 0
			self.EatItemCount = 0
			self.SkinPlusState = 0
			self.TrainTypes = 0
			self.TrainLVList = list()
			self.TrainItemCountList = list()
			self.SkinPlusStateCount = 0
			self.SkinPlusStateList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 4
			length += 4
			length += 1
			length += 4 * self.TrainTypes
			length += 4 * self.TrainTypes
			length += 1
			length += 4 * self.SkinPlusStateCount

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.LV)
			data = CommFunc.WriteDWORD(data, self.EatItemCount)
			data = CommFunc.WriteDWORD(data, self.SkinPlusState)
			data = CommFunc.WriteBYTE(data, self.TrainTypes)
			for i in range(self.TrainTypes):
			data = CommFunc.WriteDWORD(data, self.TrainLVList[i])
			for i in range(self.TrainTypes):
			data = CommFunc.WriteDWORD(data, self.TrainItemCountList[i])
			data = CommFunc.WriteBYTE(data, self.SkinPlusStateCount)
			for i in range(self.SkinPlusStateCount):
			data = CommFunc.WriteDWORD(data, self.SkinPlusStateList[i])
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			LV:%d,
			EatItemCount:%d,
			SkinPlusState:%d,
			TrainTypes:%d,
			TrainLVList:%s,
			TrainItemCountList:%s,
			SkinPlusStateCount:%d,
			SkinPlusStateList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.LV,
			self.EatItemCount,
			self.SkinPlusState,
			self.TrainTypes,
			"...",
			"...",
			self.SkinPlusStateCount,
			"..."
			)
			return DumpString


			m_NAtagTrainHorseData=tagTrainHorseData()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagTrainHorseData.Head.Cmd,m_NAtagTrainHorseData.Head.SubCmd))] = m_NAtagTrainHorseData


			#------------------------------------------------------
			# A3 51 寻宝功能信息 #tagMCTreasureInfo

			class tagMCTreasureGridLimit(Structure):
			@@ -9802,152 +9240,6 @@

			m_NAtagMCTreasureResult=tagMCTreasureResult()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCTreasureResult.Head.Cmd,m_NAtagMCTreasureResult.Head.SubCmd))] = m_NAtagMCTreasureResult


			#------------------------------------------------------
			#A3 05 扫荡奖励信息 #tagMCWipeOutPrize

			class tagMCPrizeItemInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ItemID", c_int), #物品id
			("ItemCnt", c_ubyte), #物品数量
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x05
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xA3
			self.SubCmd = 0x05
			self.ItemID = 0
			self.ItemCnt = 0
			return

			def GetLength(self):
			return sizeof(tagMCPrizeItemInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''//A3 05 扫荡奖励信息 //tagMCWipeOutPrize:
			Cmd:%s,
			SubCmd:%s,
			ItemID:%d,
			ItemCnt:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ItemID,
			self.ItemCnt
			)
			return DumpString


			class tagMCWipeOutPrize(Structure):
			Head = tagHead()
			FBID = 0 #(DWORD FBID)//副本id
			WipeOutCnt = 0 #(DWORD WipeOutCnt)//扫荡次数
			GiveExp = 0 #(DWORD GiveExp)//给予经验
			SilverCnt = 0 #(DWORD SilverCnt)//给予金币
			PrizeCnt = 0 #(BYTE PrizeCnt)//״̬
			PrizeInfo = list() #(vector<tagMCPrizeItemInfo> PrizeInfo)//״̬
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x05
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.FBID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.WipeOutCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.GiveExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.SilverCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PrizeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PrizeCnt):
			temPrizeInfo = tagMCPrizeItemInfo()
			_pos = temPrizeInfo.ReadData(_lpData, _pos)
			self.PrizeInfo.append(temPrizeInfo)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x05
			self.FBID = 0
			self.WipeOutCnt = 0
			self.GiveExp = 0
			self.SilverCnt = 0
			self.PrizeCnt = 0
			self.PrizeInfo = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 4
			length += 4
			length += 4
			length += 1
			for i in range(self.PrizeCnt):
			length += self.PrizeInfo[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.FBID)
			data = CommFunc.WriteDWORD(data, self.WipeOutCnt)
			data = CommFunc.WriteDWORD(data, self.GiveExp)
			data = CommFunc.WriteDWORD(data, self.SilverCnt)
			data = CommFunc.WriteBYTE(data, self.PrizeCnt)
			for i in range(self.PrizeCnt):
			data = CommFunc.WriteString(data, self.PrizeInfo[i].GetLength(), self.PrizeInfo[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			FBID:%d,
			WipeOutCnt:%d,
			GiveExp:%d,
			SilverCnt:%d,
			PrizeCnt:%d,
			PrizeInfo:%s
			'''\
			%(
			self.Head.OutputString(),
			self.FBID,
			self.WipeOutCnt,
			self.GiveExp,
			self.SilverCnt,
			self.PrizeCnt,
			"..."
			)
			return DumpString


			m_NAtagMCWipeOutPrize=tagMCWipeOutPrize()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCWipeOutPrize.Head.Cmd,m_NAtagMCWipeOutPrize.Head.SubCmd))] = m_NAtagMCWipeOutPrize


			#------------------------------------------------------
			@@ -10628,208 +9920,6 @@

			m_NAtagGCFamilyBosFBInfo=tagGCFamilyBosFBInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagGCFamilyBosFBInfo.Cmd,m_NAtagGCFamilyBosFBInfo.SubCmd))] = m_NAtagGCFamilyBosFBInfo


			#------------------------------------------------------
			# A4 06 家族仓库物品信息 #tagGCFamilyStoreItemInfo

			class tagGCFamilyStoreItem(Structure):
			Index = 0 #(BYTE Index)// 仓库格子索引，从0开始代表第一格
			ItemID = 0 #(DWORD ItemID)// 物品ID
			ItemDataLen = 0 #(WORD ItemDataLen)
			ItemData = "" #(String ItemData)//size = ItemDataLen
			data = None

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.Index,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ItemDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.ItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.ItemDataLen)
			return _pos

			def Clear(self):
			self.Index = 0
			self.ItemID = 0
			self.ItemDataLen = 0
			self.ItemData = ""
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 4
			length += 2
			length += len(self.ItemData)

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.Index)
			data = CommFunc.WriteDWORD(data, self.ItemID)
			data = CommFunc.WriteWORD(data, self.ItemDataLen)
			data = CommFunc.WriteString(data, self.ItemDataLen, self.ItemData)
			return data

			def OutputString(self):
			DumpString = '''
			Index:%d,
			ItemID:%d,
			ItemDataLen:%d,
			ItemData:%s
			'''\
			%(
			self.Index,
			self.ItemID,
			self.ItemDataLen,
			self.ItemData
			)
			return DumpString


			class tagGCFamilyStoreItemInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)//数量
			StoreItemList = list() #(vector<tagGCFamilyStoreItem> StoreItemList)//size = Count
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA4
			self.Head.SubCmd = 0x06
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temStoreItemList = tagGCFamilyStoreItem()
			_pos = temStoreItemList.ReadData(_lpData, _pos)
			self.StoreItemList.append(temStoreItemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA4
			self.Head.SubCmd = 0x06
			self.Count = 0
			self.StoreItemList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.StoreItemList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.StoreItemList[i].GetLength(), self.StoreItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Count:%d,
			StoreItemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.Count,
			"..."
			)
			return DumpString


			m_NAtagGCFamilyStoreItemInfo=tagGCFamilyStoreItemInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagGCFamilyStoreItemInfo.Head.Cmd,m_NAtagGCFamilyStoreItemInfo.Head.SubCmd))] = m_NAtagGCFamilyStoreItemInfo


			#------------------------------------------------------
			# A4 07 家族仓库物品清除 #tagGCFamilyStoreItemClear

			class tagGCFamilyStoreItemClear(Structure):
			Head = tagHead()
			ClearType = 0 #(BYTE ClearType)//0-指定格子清除; 1-所有物品清除
			IndexCount = 0 #(BYTE IndexCount)
			IndexList = list() #(vector<BYTE> IndexList)//清除的格子索引, 仅指定格子清除时有效,从0开始代表第一格
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA4
			self.Head.SubCmd = 0x07
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ClearType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.IndexCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.IndexCount):
			value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
			self.IndexList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA4
			self.Head.SubCmd = 0x07
			self.ClearType = 0
			self.IndexCount = 0
			self.IndexList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 1
			length += 1 * self.IndexCount

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ClearType)
			data = CommFunc.WriteBYTE(data, self.IndexCount)
			for i in range(self.IndexCount):
			data = CommFunc.WriteBYTE(data, self.IndexList[i])
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ClearType:%d,
			IndexCount:%d,
			IndexList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ClearType,
			self.IndexCount,
			"..."
			)
			return DumpString


			m_NAtagGCFamilyStoreItemClear=tagGCFamilyStoreItemClear()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagGCFamilyStoreItemClear.Head.Cmd,m_NAtagGCFamilyStoreItemClear.Head.SubCmd))] = m_NAtagGCFamilyStoreItemClear


			#------------------------------------------------------
			@@ -11566,194 +10656,6 @@


			#------------------------------------------------------
			# A5 35 王者仙盟每日俸禄奖励状态 #tagMCChampionFamilyDailyReward

			class tagMCChampionFamilyDailyReward(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("GetState", c_ubyte), #是否已领取
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA5
			self.SubCmd = 0x35
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xA5
			self.SubCmd = 0x35
			self.GetState = 0
			return

			def GetLength(self):
			return sizeof(tagMCChampionFamilyDailyReward)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 35 王者仙盟每日俸禄奖励状态 //tagMCChampionFamilyDailyReward:
			Cmd:%s,
			SubCmd:%s,
			GetState:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.GetState
			)
			return DumpString


			m_NAtagMCChampionFamilyDailyReward=tagMCChampionFamilyDailyReward()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCChampionFamilyDailyReward.Cmd,m_NAtagMCChampionFamilyDailyReward.SubCmd))] = m_NAtagMCChampionFamilyDailyReward


			#------------------------------------------------------
			# A5 10 传功奖励结果 #tagMCChuangongResult

			class tagMCChuangongItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemID", c_int),
			("ItemCount", c_ushort),
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.ItemID = 0
			self.ItemCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCChuangongItem)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 10 传功奖励结果 //tagMCChuangongResult:
			ItemID:%d,
			ItemCount:%d
			'''\
			%(
			self.ItemID,
			self.ItemCount
			)
			return DumpString


			class tagMCChuangongResult(Structure):
			Head = tagHead()
			FromLV = 0 #(WORD FromLV)// 传功前等级
			ToLV = 0 #(WORD ToLV)// 传功后等级
			Exp = 0 #(DWORD Exp)// 获得经验求余亿部分
			ExpPoint = 0 #(DWORD ExpPoint)// 获得经验整除亿部分
			ItemCount = 0 #(BYTE ItemCount)
			AwardItemList = list() #(vector<tagMCChuangongItem> AwardItemList)// 奖励物品列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x10
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.FromLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.ToLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Exp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.ItemCount):
			temAwardItemList = tagMCChuangongItem()
			_pos = temAwardItemList.ReadData(_lpData, _pos)
			self.AwardItemList.append(temAwardItemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x10
			self.FromLV = 0
			self.ToLV = 0
			self.Exp = 0
			self.ExpPoint = 0
			self.ItemCount = 0
			self.AwardItemList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			length += 2
			length += 4
			length += 4
			length += 1
			for i in range(self.ItemCount):
			length += self.AwardItemList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.FromLV)
			data = CommFunc.WriteWORD(data, self.ToLV)
			data = CommFunc.WriteDWORD(data, self.Exp)
			data = CommFunc.WriteDWORD(data, self.ExpPoint)
			data = CommFunc.WriteBYTE(data, self.ItemCount)
			for i in range(self.ItemCount):
			data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			FromLV:%d,
			ToLV:%d,
			Exp:%d,
			ExpPoint:%d,
			ItemCount:%d,
			AwardItemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.FromLV,
			self.ToLV,
			self.Exp,
			self.ExpPoint,
			self.ItemCount,
			"..."
			)
			return DumpString


			m_NAtagMCChuangongResult=tagMCChuangongResult()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCChuangongResult.Head.Cmd,m_NAtagMCChuangongResult.Head.SubCmd))] = m_NAtagMCChuangongResult


			#------------------------------------------------------
			# A5 02 捐献次数信息 #tagSCDonateCntInfo

			class tagSCDonateCntInfo(Structure):
			@@ -12012,74 +10914,6 @@


			#------------------------------------------------------
			# A5 07 家族boss副本玩家信息 #tagMCFamilyBosFBPlayerInfo

			class tagMCFamilyBosFBPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("HurtTotal", c_int), # 累计伤血，亿求余部分
			("HurtTotalPoint", c_int), # 累计伤血，亿整除部分
			("FightSeconds", c_int), # 已累计战斗时长，秒
			("HurtAwardState", c_int), # 个人总伤血领奖记录，按奖励位二进制位运算表示是否已领取
			("HurtAwardStateFamily", c_int), # 仙盟总伤血领奖记录，按奖励位二进制位运算表示是否已领取
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA5
			self.SubCmd = 0x07
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xA5
			self.SubCmd = 0x07
			self.HurtTotal = 0
			self.HurtTotalPoint = 0
			self.FightSeconds = 0
			self.HurtAwardState = 0
			self.HurtAwardStateFamily = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyBosFBPlayerInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 07 家族boss副本玩家信息 //tagMCFamilyBosFBPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			HurtTotal:%d,
			HurtTotalPoint:%d,
			FightSeconds:%d,
			HurtAwardState:%d,
			HurtAwardStateFamily:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.HurtTotal,
			self.HurtTotalPoint,
			self.FightSeconds,
			self.HurtAwardState,
			self.HurtAwardStateFamily
			)
			return DumpString


			m_NAtagMCFamilyBosFBPlayerInfo=tagMCFamilyBosFBPlayerInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyBosFBPlayerInfo.Cmd,m_NAtagMCFamilyBosFBPlayerInfo.SubCmd))] = m_NAtagMCFamilyBosFBPlayerInfo


			#------------------------------------------------------
			# A5 21 家族变更 #tagMCFamilyChange

			class tagMCFamilyChange(Structure):
			@@ -12129,114 +10963,6 @@

			m_NAtagMCFamilyChange=tagMCFamilyChange()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyChange.Cmd,m_NAtagMCFamilyChange.SubCmd))] = m_NAtagMCFamilyChange


			#------------------------------------------------------
			# A5 06 仙盟每日福利领取状态 #tagMCFamilyDayAward

			class tagMCFamilyDayAward(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("GetState", c_ubyte), #是否已领取
			("MoneyDonateCount", c_ubyte), #今日货币捐献次数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA5
			self.SubCmd = 0x06
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xA5
			self.SubCmd = 0x06
			self.GetState = 0
			self.MoneyDonateCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyDayAward)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 06 仙盟每日福利领取状态 //tagMCFamilyDayAward:
			Cmd:%s,
			SubCmd:%s,
			GetState:%d,
			MoneyDonateCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.GetState,
			self.MoneyDonateCount
			)
			return DumpString


			m_NAtagMCFamilyDayAward=tagMCFamilyDayAward()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyDayAward.Cmd,m_NAtagMCFamilyDayAward.SubCmd))] = m_NAtagMCFamilyDayAward


			#------------------------------------------------------
			# A5 03 当日祈福信息 #tagMCFamilyPrayInfo

			class tagMCFamilyPrayInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("PrayCntInfo", c_int), # 当日祈福次数信息, 按位存储祈福类型对应次数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA5
			self.SubCmd = 0x03
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xA5
			self.SubCmd = 0x03
			self.PrayCntInfo = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyPrayInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 03 当日祈福信息 //tagMCFamilyPrayInfo:
			Cmd:%s,
			SubCmd:%s,
			PrayCntInfo:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.PrayCntInfo
			)
			return DumpString


			m_NAtagMCFamilyPrayInfo=tagMCFamilyPrayInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyPrayInfo.Cmd,m_NAtagMCFamilyPrayInfo.SubCmd))] = m_NAtagMCFamilyPrayInfo


			#------------------------------------------------------
			@@ -12438,22 +11164,205 @@


			#------------------------------------------------------
			# A5 11 打坐信息 #tagMCFamilySitInfo
			# A5 04 公会讨伐攻击结果 #tagSCFamilyTaofaAtkRet

			class tagMCFamilySitInfo(Structure):
			class tagSCFamilyTaofaAtkItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemID", c_int),
			("Count", c_int),
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.ItemID = 0
			self.Count = 0
			return

			def GetLength(self):
			return sizeof(tagSCFamilyTaofaAtkItem)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 04 公会讨伐攻击结果 //tagSCFamilyTaofaAtkRet:
			ItemID:%d,
			Count:%d
			'''\
			%(
			self.ItemID,
			self.Count
			)
			return DumpString


			class tagSCFamilyTaofaAtkHurt(Structure):
			_pack_ = 1
			_fields_ = [
			("IsSuper", c_ubyte), # 是否暴击
			("HurtValue", c_int), # 本次伤害，求余亿部分
			("HurtValueEx", c_int), # 本次伤害，整除亿部分
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.IsSuper = 0
			self.HurtValue = 0
			self.HurtValueEx = 0
			return

			def GetLength(self):
			return sizeof(tagSCFamilyTaofaAtkHurt)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 04 公会讨伐攻击结果 //tagSCFamilyTaofaAtkRet:
			IsSuper:%d,
			HurtValue:%d,
			HurtValueEx:%d
			'''\
			%(
			self.IsSuper,
			self.HurtValue,
			self.HurtValueEx
			)
			return DumpString


			class tagSCFamilyTaofaAtkRet(Structure):
			Head = tagHead()
			AtkType = 0 #(BYTE AtkType)// 攻击类型：0-常规；1-怒气攻击
			HurtCount = 0 #(BYTE HurtCount)
			HurtList = list() #(vector<tagSCFamilyTaofaAtkHurt> HurtList)// 伤害次数列表，如怒气攻击有多次伤害
			ItemCount = 0 #(BYTE ItemCount)
			ItemList = list() #(vector<tagSCFamilyTaofaAtkItem> ItemList)// 奖励物品列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x04
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.AtkType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.HurtCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.HurtCount):
			temHurtList = tagSCFamilyTaofaAtkHurt()
			_pos = temHurtList.ReadData(_lpData, _pos)
			self.HurtList.append(temHurtList)
			self.ItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.ItemCount):
			temItemList = tagSCFamilyTaofaAtkItem()
			_pos = temItemList.ReadData(_lpData, _pos)
			self.ItemList.append(temItemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x04
			self.AtkType = 0
			self.HurtCount = 0
			self.HurtList = list()
			self.ItemCount = 0
			self.ItemList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 1
			for i in range(self.HurtCount):
			length += self.HurtList[i].GetLength()
			length += 1
			for i in range(self.ItemCount):
			length += self.ItemList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.AtkType)
			data = CommFunc.WriteBYTE(data, self.HurtCount)
			for i in range(self.HurtCount):
			data = CommFunc.WriteString(data, self.HurtList[i].GetLength(), self.HurtList[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ItemCount)
			for i in range(self.ItemCount):
			data = CommFunc.WriteString(data, self.ItemList[i].GetLength(), self.ItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			AtkType:%d,
			HurtCount:%d,
			HurtList:%s,
			ItemCount:%d,
			ItemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.AtkType,
			self.HurtCount,
			"...",
			self.ItemCount,
			"..."
			)
			return DumpString


			m_NAtagSCFamilyTaofaAtkRet=tagSCFamilyTaofaAtkRet()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCFamilyTaofaAtkRet.Head.Cmd,m_NAtagSCFamilyTaofaAtkRet.Head.SubCmd))] = m_NAtagSCFamilyTaofaAtkRet


			#------------------------------------------------------
			# A5 03 公会讨伐信息 #tagSCFamilyTaofaInfo

			class tagSCFamilyTaofaInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ExpRound", c_ushort), # 已获得经验轮次
			("Exp", c_int), # 获得经验求余亿部分
			("ExpPoint", c_int), # 获得经验整除亿部分
			("BuZhenState", c_ubyte), # 是否已布阵
			("AtkCount", c_ushort), # 已斩杀次数，用于计算剩余次数=免费次数+道具增加次数-已斩杀次数
			("ItemAddCount", c_ushort), # 道具增加斩杀次数
			("Anger", c_ushort), # 当前怒气值
			("BoxUnGetCount", c_ushort), # 当前未领取的宝箱数，即可领取的
			("BoxHurt", c_int), # 宝箱奖励计算累计伤害，求余亿部分；个人今日累计伤害，换公会不会重置
			("BoxHurtEx", c_int), # 宝箱奖励计算累计伤害，整除亿部分
			("BoxHurtHis", c_int), # 宝箱奖励计算累计历史最高伤害，求余亿部分
			("BoxHurtHisEx", c_int), # 宝箱奖励计算累计历史最高伤害，整除亿部分
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA5
			self.SubCmd = 0x11
			self.SubCmd = 0x03
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			@@ -12463,38 +11372,56 @@

			def Clear(self):
			self.Cmd = 0xA5
			self.SubCmd = 0x11
			self.ExpRound = 0
			self.Exp = 0
			self.ExpPoint = 0
			self.SubCmd = 0x03
			self.BuZhenState = 0
			self.AtkCount = 0
			self.ItemAddCount = 0
			self.Anger = 0
			self.BoxUnGetCount = 0
			self.BoxHurt = 0
			self.BoxHurtEx = 0
			self.BoxHurtHis = 0
			self.BoxHurtHisEx = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilySitInfo)
			return sizeof(tagSCFamilyTaofaInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 11 打坐信息 //tagMCFamilySitInfo:
			DumpString = '''// A5 03 公会讨伐信息 //tagSCFamilyTaofaInfo:
			Cmd:%s,
			SubCmd:%s,
			ExpRound:%d,
			Exp:%d,
			ExpPoint:%d
			BuZhenState:%d,
			AtkCount:%d,
			ItemAddCount:%d,
			Anger:%d,
			BoxUnGetCount:%d,
			BoxHurt:%d,
			BoxHurtEx:%d,
			BoxHurtHis:%d,
			BoxHurtHisEx:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ExpRound,
			self.Exp,
			self.ExpPoint
			self.BuZhenState,
			self.AtkCount,
			self.ItemAddCount,
			self.Anger,
			self.BoxUnGetCount,
			self.BoxHurt,
			self.BoxHurtEx,
			self.BoxHurtHis,
			self.BoxHurtHisEx
			)
			return DumpString


			m_NAtagMCFamilySitInfo=tagMCFamilySitInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilySitInfo.Cmd,m_NAtagMCFamilySitInfo.SubCmd))] = m_NAtagMCFamilySitInfo
			m_NAtagSCFamilyTaofaInfo=tagSCFamilyTaofaInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCFamilyTaofaInfo.Cmd,m_NAtagSCFamilyTaofaInfo.SubCmd))] = m_NAtagSCFamilyTaofaInfo


			#------------------------------------------------------
			@@ -12798,125 +11725,6 @@

			m_NAtagMCFamilyZhenbaogeInfo=tagMCFamilyZhenbaogeInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyZhenbaogeInfo.Cmd,m_NAtagMCFamilyZhenbaogeInfo.SubCmd))] = m_NAtagMCFamilyZhenbaogeInfo


			#------------------------------------------------------
			# A5 09 仙盟阵法信息 #tagMCFamilyZhenfaInfo

			class tagMCFamilyZhenfa(Structure):
			_pack_ = 1
			_fields_ = [
			("ZhenfaType", c_ubyte), # 阵法类型
			("ZhenfaLV", c_ushort), # 阵法等级
			("ZhenfaExp", c_int), # 阵法经验
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.ZhenfaType = 0
			self.ZhenfaLV = 0
			self.ZhenfaExp = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyZhenfa)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A5 09 仙盟阵法信息 //tagMCFamilyZhenfaInfo:
			ZhenfaType:%d,
			ZhenfaLV:%d,
			ZhenfaExp:%d
			'''\
			%(
			self.ZhenfaType,
			self.ZhenfaLV,
			self.ZhenfaExp
			)
			return DumpString


			class tagMCFamilyZhenfaInfo(Structure):
			Head = tagHead()
			PlayerID = 0 #(DWORD PlayerID)// 当前培养阵法的玩家ID，如果有做自动捐献，需等收到的玩家ID为自己的时候才发送下一个捐献包
			Count = 0 #(BYTE Count)
			ZhenfaInfoList = list() #(vector<tagMCFamilyZhenfa> ZhenfaInfoList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x09
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temZhenfaInfoList = tagMCFamilyZhenfa()
			_pos = temZhenfaInfoList.ReadData(_lpData, _pos)
			self.ZhenfaInfoList.append(temZhenfaInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x09
			self.PlayerID = 0
			self.Count = 0
			self.ZhenfaInfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 1
			for i in range(self.Count):
			length += self.ZhenfaInfoList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.ZhenfaInfoList[i].GetLength(), self.ZhenfaInfoList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			PlayerID:%d,
			Count:%d,
			ZhenfaInfoList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.PlayerID,
			self.Count,
			"..."
			)
			return DumpString


			m_NAtagMCFamilyZhenfaInfo=tagMCFamilyZhenfaInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFamilyZhenfaInfo.Head.Cmd,m_NAtagMCFamilyZhenfaInfo.Head.SubCmd))] = m_NAtagMCFamilyZhenfaInfo


			#------------------------------------------------------
			@@ -15139,6 +13947,7 @@
			Face = 0 #(DWORD Face)
			FacePic = 0 #(DWORD FacePic)
			ModelMark = 0 #(DWORD ModelMark)//变形模型mark
			EquipShowSwitch = 0 #(DWORD EquipShowSwitch)//其他外观信息
			TitleID = 0 #(DWORD TitleID)//佩戴的称号
			ServerID = 0 #(DWORD ServerID)
			FightPower = 0 #(DWORD FightPower)
			@@ -15168,6 +13977,7 @@
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ModelMark,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EquipShowSwitch,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TitleID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			@@ -15193,6 +14003,7 @@
			self.Face = 0
			self.FacePic = 0
			self.ModelMark = 0
			self.EquipShowSwitch = 0
			self.TitleID = 0
			self.ServerID = 0
			self.FightPower = 0
			@@ -15221,6 +14032,7 @@
			length += 4
			length += 4
			length += 4
			length += 4
			length += 33
			length += 4
			length += 3
			@@ -15240,6 +14052,7 @@
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.ModelMark)
			data = CommFunc.WriteDWORD(data, self.EquipShowSwitch)
			data = CommFunc.WriteDWORD(data, self.TitleID)
			data = CommFunc.WriteDWORD(data, self.ServerID)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			@@ -15263,6 +14076,7 @@
			Face:%d,
			FacePic:%d,
			ModelMark:%d,
			EquipShowSwitch:%d,
			TitleID:%d,
			ServerID:%d,
			FightPower:%d,
			@@ -15284,6 +14098,7 @@
			self.Face,
			self.FacePic,
			self.ModelMark,
			self.EquipShowSwitch,
			self.TitleID,
			self.ServerID,
			self.FightPower,
			@@ -16001,373 +14816,6 @@


			#------------------------------------------------------
			# A8 11 商店购买结果 #tagMCShoppingResult

			class tagMCShoppingResult(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ItemIndex", c_int),
			("ItemCnt", c_int), #购买数量
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA8
			self.SubCmd = 0x11
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xA8
			self.SubCmd = 0x11
			self.ItemIndex = 0
			self.ItemCnt = 0
			return

			def GetLength(self):
			return sizeof(tagMCShoppingResult)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A8 11 商店购买结果 //tagMCShoppingResult:
			Cmd:%s,
			SubCmd:%s,
			ItemIndex:%d,
			ItemCnt:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ItemIndex,
			self.ItemCnt
			)
			return DumpString


			m_NAtagMCShoppingResult=tagMCShoppingResult()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCShoppingResult.Cmd,m_NAtagMCShoppingResult.SubCmd))] = m_NAtagMCShoppingResult


			#------------------------------------------------------
			# A8 16 神秘商店商品信息 #tagMCMysticalShopInfo

			class tagMCMysticalShopGoods(Structure):
			_pack_ = 1
			_fields_ = [
			("GoodsID", c_int), # 商品ID
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.GoodsID = 0
			return

			def GetLength(self):
			return sizeof(tagMCMysticalShopGoods)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A8 16 神秘商店商品信息 //tagMCMysticalShopInfo:
			GoodsID:%d
			'''\
			%(
			self.GoodsID
			)
			return DumpString


			class tagMCMysticalShopInfo(Structure):
			Head = tagHead()
			RefreshCnt = 0 #(WORD RefreshCnt)// 刷新次数
			Count = 0 #(BYTE Count)// 商品数
			GoodsList = list() #(vector<tagMCMysticalShopGoods> GoodsList)// 商品信息
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x16
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RefreshCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temGoodsList = tagMCMysticalShopGoods()
			_pos = temGoodsList.ReadData(_lpData, _pos)
			self.GoodsList.append(temGoodsList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x16
			self.RefreshCnt = 0
			self.Count = 0
			self.GoodsList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			length += 1
			for i in range(self.Count):
			length += self.GoodsList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.RefreshCnt)
			data = CommFunc.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.GoodsList[i].GetLength(), self.GoodsList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			RefreshCnt:%d,
			Count:%d,
			GoodsList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.RefreshCnt,
			self.Count,
			"..."
			)
			return DumpString


			m_NAtagMCMysticalShopInfo=tagMCMysticalShopInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMysticalShopInfo.Head.Cmd,m_NAtagMCMysticalShopInfo.Head.SubCmd))] = m_NAtagMCMysticalShopInfo


			#------------------------------------------------------
			# A8 06 通知神秘限购商品时间 #tagMCMysticalShopTimeInfo

			class tagMCMysticalShopTime(Structure):
			_pack_ = 1
			_fields_ = [
			("GoodsID", c_int), # 商品ID
			("StartTime", c_int), # 开卖时间
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.GoodsID = 0
			self.StartTime = 0
			return

			def GetLength(self):
			return sizeof(tagMCMysticalShopTime)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A8 06 通知神秘限购商品时间 //tagMCMysticalShopTimeInfo:
			GoodsID:%d,
			StartTime:%d
			'''\
			%(
			self.GoodsID,
			self.StartTime
			)
			return DumpString


			class tagMCMysticalShopTimeInfo(Structure):
			Head = tagHead()
			Count = 0 #(WORD Count)// 商品数
			ShopTimeList = list() #(vector<tagMCMysticalShopTime> ShopTimeList)// 商品开卖信息
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x06
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temShopTimeList = tagMCMysticalShopTime()
			_pos = temShopTimeList.ReadData(_lpData, _pos)
			self.ShopTimeList.append(temShopTimeList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x06
			self.Count = 0
			self.ShopTimeList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			for i in range(self.Count):
			length += self.ShopTimeList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.ShopTimeList[i].GetLength(), self.ShopTimeList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Count:%d,
			ShopTimeList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.Count,
			"..."
			)
			return DumpString


			m_NAtagMCMysticalShopTimeInfo=tagMCMysticalShopTimeInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCMysticalShopTimeInfo.Head.Cmd,m_NAtagMCMysticalShopTimeInfo.Head.SubCmd))] = m_NAtagMCMysticalShopTimeInfo


			#------------------------------------------------------
			# A8 10 通知获得物品 #tagMCNotifyUseItemGetItem

			class tagMCNotifyUseItemGetItem(Structure):
			Head = tagHead()
			UseItemID = 0 #(DWORD UseItemID)// 使用的物品ID
			UseCount = 0 #(WORD UseCount)// 使用物品个数
			GetItemLen = 0 #(WORD GetItemLen)
			GetItemData = "" #(String GetItemData)// 获得物品信息 [[itemID,itemCount,isBind], [或itemID,itemCount,isBind,isAppoint], {或物品信息字典}, ...]
			MoneyType = 0 #(BYTE MoneyType)// 获得货币类型
			MoneyCount = 0 #(DWORD MoneyCount)// 获得货币数量
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x10
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.UseItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.UseCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.GetItemLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.GetItemData,_pos = CommFunc.ReadString(_lpData, _pos,self.GetItemLen)
			self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MoneyCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x10
			self.UseItemID = 0
			self.UseCount = 0
			self.GetItemLen = 0
			self.GetItemData = ""
			self.MoneyType = 0
			self.MoneyCount = 0
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 2
			length += 2
			length += len(self.GetItemData)
			length += 1
			length += 4

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.UseItemID)
			data = CommFunc.WriteWORD(data, self.UseCount)
			data = CommFunc.WriteWORD(data, self.GetItemLen)
			data = CommFunc.WriteString(data, self.GetItemLen, self.GetItemData)
			data = CommFunc.WriteBYTE(data, self.MoneyType)
			data = CommFunc.WriteDWORD(data, self.MoneyCount)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			UseItemID:%d,
			UseCount:%d,
			GetItemLen:%d,
			GetItemData:%s,
			MoneyType:%d,
			MoneyCount:%d
			'''\
			%(
			self.Head.OutputString(),
			self.UseItemID,
			self.UseCount,
			self.GetItemLen,
			self.GetItemData,
			self.MoneyType,
			self.MoneyCount
			)
			return DumpString


			m_NAtagMCNotifyUseItemGetItem=tagMCNotifyUseItemGetItem()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCNotifyUseItemGetItem.Head.Cmd,m_NAtagMCNotifyUseItemGetItem.Head.SubCmd))] = m_NAtagMCNotifyUseItemGetItem


			#------------------------------------------------------
			# A8 17 宠物培养信息 #tagMCPetTrainInfo

			class tagMCPetTrainInfo(Structure):
			@@ -16445,14 +14893,13 @@


			#------------------------------------------------------
			# A8 02 通知NPC商店物品今日已购买次数 #tagMCShopItemDayBuyCntInfo
			# A8 02 商店物品已购买次数 #tagSCShopItemBuyCntInfo

			class tagMCShopItemDayBuyCnt(Structure):
			class tagSCShopItemBuyCnt(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemIndex", c_int),
			("BuyCnt", c_int), # 今日已购买次数
			("IsReset", c_ubyte), #是否重置
			("ShopID", c_int), # 商品ID
			("BuyCnt", c_int), # 已购买次数
			]

			def __init__(self):
			@@ -16465,35 +14912,32 @@
			return _pos + self.GetLength()

			def Clear(self):
			self.ItemIndex = 0
			self.ShopID = 0
			self.BuyCnt = 0
			self.IsReset = 0
			return

			def GetLength(self):
			return sizeof(tagMCShopItemDayBuyCnt)
			return sizeof(tagSCShopItemBuyCnt)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// A8 02 通知NPC商店物品今日已购买次数 //tagMCShopItemDayBuyCntInfo:
			ItemIndex:%d,
			BuyCnt:%d,
			IsReset:%d
			DumpString = '''// A8 02 商店物品已购买次数 //tagSCShopItemBuyCntInfo:
			ShopID:%d,
			BuyCnt:%d
			'''\
			%(
			self.ItemIndex,
			self.BuyCnt,
			self.IsReset
			self.ShopID,
			self.BuyCnt
			)
			return DumpString


			class tagMCShopItemDayBuyCntInfo(Structure):
			class tagSCShopItemBuyCntInfo(Structure):
			Head = tagHead()
			Count = 0 #(WORD Count)//通知个数，注意不限制每日购买次数的默认不通知
			DayBuyCntList = list() #(vector<tagMCShopItemDayBuyCnt> DayBuyCntList)
			Count = 0 #(WORD Count)
			BuyCntList = list() #(vector<tagSCShopItemBuyCnt> BuyCntList)//仅通知有限购次数的商品
			data = None

			def __init__(self):
			@@ -16507,9 +14951,9 @@
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temDayBuyCntList = tagMCShopItemDayBuyCnt()
			_pos = temDayBuyCntList.ReadData(_lpData, _pos)
			self.DayBuyCntList.append(temDayBuyCntList)
			temBuyCntList = tagSCShopItemBuyCnt()
			_pos = temBuyCntList.ReadData(_lpData, _pos)
			self.BuyCntList.append(temBuyCntList)
			return _pos

			def Clear(self):
			@@ -16518,7 +14962,7 @@
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x02
			self.Count = 0
			self.DayBuyCntList = list()
			self.BuyCntList = list()
			return

			def GetLength(self):
			@@ -16526,7 +14970,7 @@
			length += self.Head.GetLength()
			length += 2
			for i in range(self.Count):
			length += self.DayBuyCntList[i].GetLength()
			length += self.BuyCntList[i].GetLength()

			return length

			@@ -16535,14 +14979,14 @@
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.DayBuyCntList[i].GetLength(), self.DayBuyCntList[i].GetBuffer())
			data = CommFunc.WriteString(data, self.BuyCntList[i].GetLength(), self.BuyCntList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Count:%d,
			DayBuyCntList:%s
			BuyCntList:%s
			'''\
			%(
			self.Head.OutputString(),
			@@ -16552,8 +14996,89 @@
			return DumpString


			m_NAtagMCShopItemDayBuyCntInfo=tagMCShopItemDayBuyCntInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCShopItemDayBuyCntInfo.Head.Cmd,m_NAtagMCShopItemDayBuyCntInfo.Head.SubCmd))] = m_NAtagMCShopItemDayBuyCntInfo
			m_NAtagSCShopItemBuyCntInfo=tagSCShopItemBuyCntInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCShopItemBuyCntInfo.Head.Cmd,m_NAtagSCShopItemBuyCntInfo.Head.SubCmd))] = m_NAtagSCShopItemBuyCntInfo


			#------------------------------------------------------
			# A8 03 商店刷新解锁的商品信息 #tagSCShopRefreshItemInfo

			class tagSCShopRefreshItemInfo(Structure):
			Head = tagHead()
			ShopType = 0 #(WORD ShopType)// 商店类型
			RefreshCnt = 0 #(BYTE RefreshCnt)// 今日已刷新次数
			Count = 0 #(BYTE Count)
			ShopIDList = list() #(vector<DWORD> ShopIDList)// 对应刷新出来的商店表商品ID列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x03
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.RefreshCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.ShopIDList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x03
			self.ShopType = 0
			self.RefreshCnt = 0
			self.Count = 0
			self.ShopIDList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			length += 1
			length += 1
			length += 4 * self.Count

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.ShopType)
			data = CommFunc.WriteBYTE(data, self.RefreshCnt)
			data = CommFunc.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteDWORD(data, self.ShopIDList[i])
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ShopType:%d,
			RefreshCnt:%d,
			Count:%d,
			ShopIDList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ShopType,
			self.RefreshCnt,
			self.Count,
			"..."
			)
			return DumpString


			m_NAtagSCShopRefreshItemInfo=tagSCShopRefreshItemInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCShopRefreshItemInfo.Head.Cmd,m_NAtagSCShopRefreshItemInfo.Head.SubCmd))] = m_NAtagSCShopRefreshItemInfo


			#------------------------------------------------------
			@@ -17969,80 +16494,6 @@

			m_NAtagGCNotifyEquipDetailInfo=tagGCNotifyEquipDetailInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagGCNotifyEquipDetailInfo.Head.Cmd,m_NAtagGCNotifyEquipDetailInfo.Head.SubCmd))] = m_NAtagGCNotifyEquipDetailInfo


			#------------------------------------------------------
			#A9 03 开服活动奖励数量刷新#tagGCOpenServerCampaignAwardCount

			class tagGCOpenServerCampaignAwardCount(Structure):
			Head = tagHead()
			CampaignType = 0 #(BYTE CampaignType)//奖励类型
			AwardTypeCount = 0 #(BYTE AwardTypeCount)//奖品种类数量
			GotCountList = list() #(vector<DWORD> GotCountList)//奖品已领取数量列表，根据种类索引依次
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0x03
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.CampaignType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.AwardTypeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.AwardTypeCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.GotCountList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0x03
			self.CampaignType = 0
			self.AwardTypeCount = 0
			self.GotCountList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 1
			length += 4 * self.AwardTypeCount

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.CampaignType)
			data = CommFunc.WriteBYTE(data, self.AwardTypeCount)
			for i in range(self.AwardTypeCount):
			data = CommFunc.WriteDWORD(data, self.GotCountList[i])
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			CampaignType:%d,
			AwardTypeCount:%d,
			GotCountList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.CampaignType,
			self.AwardTypeCount,
			"..."
			)
			return DumpString


			m_NAtagGCOpenServerCampaignAwardCount=tagGCOpenServerCampaignAwardCount()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagGCOpenServerCampaignAwardCount.Head.Cmd,m_NAtagGCOpenServerCampaignAwardCount.Head.SubCmd))] = m_NAtagGCOpenServerCampaignAwardCount


			#------------------------------------------------------
			@@ -31886,126 +30337,6 @@


			#------------------------------------------------------
			# AB 17 开服活动奖励状态 #tagMCOpenServerCampaignAwardList

			class tagMCOpenServerCampaignAward(Structure):
			_pack_ = 1
			_fields_ = [
			("CampaignType", c_ubyte), #奖励类型
			("BillAwardRecord", c_ubyte), #排行奖励是否已领取
			("TagAwardRecord", c_int), #目标奖励索引位领取记录：0-未领；1-已领
			("RecordData", c_int), #活动时的记录值，求余亿部分，为了统一逻辑，其他非战力榜的也使用此规则
			("RecordDataEx", c_int), #活动时的记录值，整除亿部分，1代表1亿
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.CampaignType = 0
			self.BillAwardRecord = 0
			self.TagAwardRecord = 0
			self.RecordData = 0
			self.RecordDataEx = 0
			return

			def GetLength(self):
			return sizeof(tagMCOpenServerCampaignAward)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// AB 17 开服活动奖励状态 //tagMCOpenServerCampaignAwardList:
			CampaignType:%d,
			BillAwardRecord:%d,
			TagAwardRecord:%d,
			RecordData:%d,
			RecordDataEx:%d
			'''\
			%(
			self.CampaignType,
			self.BillAwardRecord,
			self.TagAwardRecord,
			self.RecordData,
			self.RecordDataEx
			)
			return DumpString


			class tagMCOpenServerCampaignAwardList(Structure):
			Head = tagHead()
			OSCAwardCnt = 0 #(BYTE OSCAwardCnt)//奖励类型数
			OSCAwardList = list() #(vector<tagMCOpenServerCampaignAward> OSCAwardList)// 奖励状态列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xAB
			self.Head.SubCmd = 0x17
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.OSCAwardCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.OSCAwardCnt):
			temOSCAwardList = tagMCOpenServerCampaignAward()
			_pos = temOSCAwardList.ReadData(_lpData, _pos)
			self.OSCAwardList.append(temOSCAwardList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAB
			self.Head.SubCmd = 0x17
			self.OSCAwardCnt = 0
			self.OSCAwardList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.OSCAwardCnt):
			length += self.OSCAwardList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.OSCAwardCnt)
			for i in range(self.OSCAwardCnt):
			data = CommFunc.WriteString(data, self.OSCAwardList[i].GetLength(), self.OSCAwardList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			OSCAwardCnt:%d,
			OSCAwardList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.OSCAwardCnt,
			"..."
			)
			return DumpString


			m_NAtagMCOpenServerCampaignAwardList=tagMCOpenServerCampaignAwardList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCOpenServerCampaignAwardList.Head.Cmd,m_NAtagMCOpenServerCampaignAwardList.Head.SubCmd))] = m_NAtagMCOpenServerCampaignAwardList


			#------------------------------------------------------
			# AB 19 炼制奖励信息 #tagMCRefineGiftInfo

			class tagMCRefineGiftInfo(Structure):
			@@ -35419,6 +33750,178 @@

			m_NAtagSCLineupInfo=tagSCLineupInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCLineupInfo.Head.Cmd,m_NAtagSCLineupInfo.Head.SubCmd))] = m_NAtagSCLineupInfo


			#------------------------------------------------------
			# B1 29 阵容推荐信息 #tagSCLineupRecommendInfo

			class tagSCLineupRecommend(Structure):
			_pack_ = 1
			_fields_ = [
			("RecommendID", c_ubyte), #推荐阵容表ID
			("AwardState", c_int), #推荐武将领奖状态，按武将配置的顺序位存储是否已领取
			]

			def __init__(self):
			self.Clear()
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.RecommendID = 0
			self.AwardState = 0
			return

			def GetLength(self):
			return sizeof(tagSCLineupRecommend)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// B1 29 阵容推荐信息 //tagSCLineupRecommendInfo:
			RecommendID:%d,
			AwardState:%d
			'''\
			%(
			self.RecommendID,
			self.AwardState
			)
			return DumpString


			class tagSCLineupRecommendInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			RecommendList = list() #(vector<tagSCLineupRecommend> RecommendList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x29
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temRecommendList = tagSCLineupRecommend()
			_pos = temRecommendList.ReadData(_lpData, _pos)
			self.RecommendList.append(temRecommendList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x29
			self.Count = 0
			self.RecommendList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.RecommendList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.RecommendList[i].GetLength(), self.RecommendList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Count:%d,
			RecommendList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.Count,
			"..."
			)
			return DumpString


			m_NAtagSCLineupRecommendInfo=tagSCLineupRecommendInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCLineupRecommendInfo.Head.Cmd,m_NAtagSCLineupRecommendInfo.Head.SubCmd))] = m_NAtagSCLineupRecommendInfo


			#------------------------------------------------------
			# B1 28 历练秘笈信息 #tagSCLLMJInfo

			class tagSCLLMJInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("MJLV", c_ubyte), # 秘笈等级，激活后从1开始
			("Zhanchui", c_int), # 秘笈累计消耗战锤
			("ExpEx", c_int), # 秘笈今日已额外获得经验
			("DecomposeEx", c_int), # 秘笈今日已额外获得分解货币
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB1
			self.SubCmd = 0x28
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xB1
			self.SubCmd = 0x28
			self.MJLV = 0
			self.Zhanchui = 0
			self.ExpEx = 0
			self.DecomposeEx = 0
			return

			def GetLength(self):
			return sizeof(tagSCLLMJInfo)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// B1 28 历练秘笈信息 //tagSCLLMJInfo:
			Cmd:%s,
			SubCmd:%s,
			MJLV:%d,
			Zhanchui:%d,
			ExpEx:%d,
			DecomposeEx:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.MJLV,
			self.Zhanchui,
			self.ExpEx,
			self.DecomposeEx
			)
			return DumpString


			m_NAtagSCLLMJInfo=tagSCLLMJInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCLLMJInfo.Cmd,m_NAtagSCLLMJInfo.SubCmd))] = m_NAtagSCLLMJInfo


			#------------------------------------------------------
			@@ -39916,6 +38419,74 @@


			#------------------------------------------------------
			# B4 19 对象最新生命刷新 #tagSCObjHPRefresh

			class tagSCObjHPRefresh(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ObjID", c_int),
			("HP", c_int), # 当前血量，求余20亿部分
			("HPEx", c_int), # 当前血量，整除20亿部分
			("MaxHP", c_int), # 最大血量，求余20亿部分
			("MaxHPEx", c_int), # 最大血量，整除20亿部分
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB4
			self.SubCmd = 0x19
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xB4
			self.SubCmd = 0x19
			self.ObjID = 0
			self.HP = 0
			self.HPEx = 0
			self.MaxHP = 0
			self.MaxHPEx = 0
			return

			def GetLength(self):
			return sizeof(tagSCObjHPRefresh)

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())

			def OutputString(self):
			DumpString = '''// B4 19 对象最新生命刷新 //tagSCObjHPRefresh:
			Cmd:%s,
			SubCmd:%s,
			ObjID:%d,
			HP:%d,
			HPEx:%d,
			MaxHP:%d,
			MaxHPEx:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ObjID,
			self.HP,
			self.HPEx,
			self.MaxHP,
			self.MaxHPEx
			)
			return DumpString


			m_NAtagSCObjHPRefresh=tagSCObjHPRefresh()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCObjHPRefresh.Cmd,m_NAtagSCObjHPRefresh.SubCmd))] = m_NAtagSCObjHPRefresh


			#------------------------------------------------------
			# B4 18 对象属性刷新展示 #tagSCObjPropertyRefreshView

			class tagSCObjPropertyRefreshView(Structure):