SnxxServerCode.git

			@@ -561,33 +561,41 @@
			#A0 04 同步客户端时间 #tagServerDateTime

			class tagServerDateTime(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("Year", c_ushort),
			("Month", c_ubyte),
			("Day", c_ubyte),
			("Hour", c_ubyte),
			("Minute", c_ubyte),
			("Second", c_ubyte),
			("MicSecond", c_int),
			]
			Head = tagHead()
			Year = 0 #(WORD Year)
			Month = 0 #(BYTE Month)
			Day = 0 #(BYTE Day)
			Hour = 0 #(BYTE Hour)
			Minute = 0 #(BYTE Minute)
			Second = 0 #(BYTE Second)
			MicSecond = 0 #(DWORD MicSecond)
			CrossServerTime = "" #(char CrossServerTime[19])
			data = None

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

			def ReadData(self, stringData, _pos=0, _len=0):
			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			memmove(addressof(self), stringData[_pos:], self.GetLength())
			return _pos + self.GetLength()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Year,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Month,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Day,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Hour,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Minute,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Second,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MicSecond,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.CrossServerTime,_pos = CommFunc.ReadString(_lpData, _pos,19)
			return _pos

			def Clear(self):
			self.Cmd = 0xA0
			self.SubCmd = 0x04
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA0
			self.Head.SubCmd = 0x04
			self.Year = 0
			self.Month = 0
			self.Day = 0
			@@ -595,42 +603,64 @@
			self.Minute = 0
			self.Second = 0
			self.MicSecond = 0
			self.CrossServerTime = ""
			return

			def GetLength(self):
			return sizeof(tagServerDateTime)
			length = 0
			length += self.Head.GetLength()
			length += 2
			length += 1
			length += 1
			length += 1
			length += 1
			length += 1
			length += 4
			length += 19

			return length

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.Year)
			data = CommFunc.WriteBYTE(data, self.Month)
			data = CommFunc.WriteBYTE(data, self.Day)
			data = CommFunc.WriteBYTE(data, self.Hour)
			data = CommFunc.WriteBYTE(data, self.Minute)
			data = CommFunc.WriteBYTE(data, self.Second)
			data = CommFunc.WriteDWORD(data, self.MicSecond)
			data = CommFunc.WriteString(data, 19, self.CrossServerTime)
			return data

			def OutputString(self):
			DumpString = '''//A0 04 同步客户端时间 //tagServerDateTime:
			Cmd:%s,
			SubCmd:%s,
			DumpString = '''
			Head:%s,
			Year:%d,
			Month:%d,
			Day:%d,
			Hour:%d,
			Minute:%d,
			Second:%d,
			MicSecond:%d
			MicSecond:%d,
			CrossServerTime:%s
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Head.OutputString(),
			self.Year,
			self.Month,
			self.Day,
			self.Hour,
			self.Minute,
			self.Second,
			self.MicSecond
			self.MicSecond,
			self.CrossServerTime
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -1210,6 +1240,66 @@

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


			#------------------------------------------------------
			# A4 0E 家族boss副本信息 #tagGCFamilyBosFBInfo

			class tagGCFamilyBosFBInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("HurtTotal", c_int), # 仙盟累计伤血，亿求余部分
			("HurtTotalPoint", c_int), # 仙盟累计伤血，亿整除部分
			("FightMemCount", c_ubyte), # 目前正在仙盟boss副本中的成员数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA4
			self.SubCmd = 0x0E
			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 = 0xA4
			self.SubCmd = 0x0E
			self.HurtTotal = 0
			self.HurtTotalPoint = 0
			self.FightMemCount = 0
			return

			def GetLength(self):
			return sizeof(tagGCFamilyBosFBInfo)

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

			def OutputString(self):
			DumpString = '''// A4 0E 家族boss副本信息 //tagGCFamilyBosFBInfo:
			Cmd:%s,
			SubCmd:%s,
			HurtTotal:%d,
			HurtTotalPoint:%d,
			FightMemCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.HurtTotal,
			self.HurtTotalPoint,
			self.FightMemCount
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -4853,6 +4943,215 @@


			#------------------------------------------------------
			# A9 AD 通知天星塔全服奖励通关玩家信息 #tagGCSkyTowerPassPlayerInfo

			class tagGCSkyTowerPassPlayer(Structure):
			PlayerID = 0 #(DWORD PlayerID)
			PlayerName = "" #(char PlayerName[33])
			Job = 0 #(BYTE Job)
			LV = 0 #(WORD LV)//等级
			RealmLV = 0 #(WORD RealmLV)//境界
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.PlayerName = ""
			self.Job = 0
			self.LV = 0
			self.RealmLV = 0
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 33
			length += 1
			length += 2
			length += 2

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteString(data, 33, self.PlayerName)
			data = CommFunc.WriteBYTE(data, self.Job)
			data = CommFunc.WriteWORD(data, self.LV)
			data = CommFunc.WriteWORD(data, self.RealmLV)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			PlayerName:%s,
			Job:%d,
			LV:%d,
			RealmLV:%d
			'''\
			%(
			self.PlayerID,
			self.PlayerName,
			self.Job,
			self.LV,
			self.RealmLV
			)
			return DumpString


			class tagGCSkyTowerPassFloor(Structure):
			FloorID = 0 #(DWORD FloorID)// 层ID
			PassPlayerCount = 0 #(BYTE PassPlayerCount)// 通关记录玩家数
			PassPlayerIDList = list() #(vector<DWORD> PassPlayerIDList)// 通关记录玩家ID列表 [第1个通过玩家ID, 第2个, ...]
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.FloorID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PassPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PassPlayerCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.PassPlayerIDList.append(value)
			return _pos

			def Clear(self):
			self.FloorID = 0
			self.PassPlayerCount = 0
			self.PassPlayerIDList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.FloorID)
			data = CommFunc.WriteBYTE(data, self.PassPlayerCount)
			for i in range(self.PassPlayerCount):
			data = CommFunc.WriteDWORD(data, self.PassPlayerIDList[i])
			return data

			def OutputString(self):
			DumpString = '''
			FloorID:%d,
			PassPlayerCount:%d,
			PassPlayerIDList:%s
			'''\
			%(
			self.FloorID,
			self.PassPlayerCount,
			"..."
			)
			return DumpString


			class tagGCSkyTowerPassPlayerInfo(Structure):
			Head = tagHead()
			FloorCount = 0 #(WORD FloorCount)
			PassFloorList = list() #(vector<tagGCSkyTowerPassFloor> PassFloorList)// 通关塔层信息列表
			PlayerCount = 0 #(WORD PlayerCount)
			PassPlayerList = list() #(vector<tagGCSkyTowerPassPlayer> PassPlayerList)// 通关玩家信息列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.FloorCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.FloorCount):
			temPassFloorList = tagGCSkyTowerPassFloor()
			_pos = temPassFloorList.ReadData(_lpData, _pos)
			self.PassFloorList.append(temPassFloorList)
			self.PlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.PlayerCount):
			temPassPlayerList = tagGCSkyTowerPassPlayer()
			_pos = temPassPlayerList.ReadData(_lpData, _pos)
			self.PassPlayerList.append(temPassPlayerList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0xAD
			self.FloorCount = 0
			self.PassFloorList = list()
			self.PlayerCount = 0
			self.PassPlayerList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			for i in range(self.FloorCount):
			length += self.PassFloorList[i].GetLength()
			length += 2
			for i in range(self.PlayerCount):
			length += self.PassPlayerList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.FloorCount)
			for i in range(self.FloorCount):
			data = CommFunc.WriteString(data, self.PassFloorList[i].GetLength(), self.PassFloorList[i].GetBuffer())
			data = CommFunc.WriteWORD(data, self.PlayerCount)
			for i in range(self.PlayerCount):
			data = CommFunc.WriteString(data, self.PassPlayerList[i].GetLength(), self.PassPlayerList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			FloorCount:%d,
			PassFloorList:%s,
			PlayerCount:%d,
			PassPlayerList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.FloorCount,
			"...",
			self.PlayerCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# A9 06 商城全服购买次数通知 #tagGCStoreServerBuyCntInfo

			class tagGCStoreServerBuyCnt(Structure):
			@@ -5230,6 +5529,224 @@

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


			#------------------------------------------------------
			# AC 13 跨服全民充值活动信息 #tagGCCrossActAllRechargeInfo

			class tagGCCrossActAllRechargeItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemID", c_int),
			("ItemCount", c_ushort),
			("IsBind", 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.ItemID = 0
			self.ItemCount = 0
			self.IsBind = 0
			return

			def GetLength(self):
			return sizeof(tagGCCrossActAllRechargeItem)

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

			def OutputString(self):
			DumpString = '''// AC 13 跨服全民充值活动信息 //tagGCCrossActAllRechargeInfo:
			ItemID:%d,
			ItemCount:%d,
			IsBind:%d
			'''\
			%(
			self.ItemID,
			self.ItemCount,
			self.IsBind
			)
			return DumpString


			class tagGCCrossActAllRechargeAward(Structure):
			AwardIndex = 0 #(BYTE AwardIndex)// 奖励索引 0~31
			NeedRMB = 0 #(DWORD NeedRMB)// 所需全民充值RMB
			NeedPlayerCount = 0 #(WORD NeedPlayerCount)// 所需充值达到该档玩家数
			NowPlayerCount = 0 #(WORD NowPlayerCount)// 当前充值达到该档玩家数
			AwardItemCount = 0 #(BYTE AwardItemCount)// 奖励物品数
			AwardItemList = list() #(vector<tagGCCrossActAllRechargeItem> AwardItemList)// 奖励物品信息
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.AwardIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.NeedRMB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NeedPlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.NowPlayerCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.AwardItemCount):
			temAwardItemList = tagGCCrossActAllRechargeItem()
			_pos = temAwardItemList.ReadData(_lpData, _pos)
			self.AwardItemList.append(temAwardItemList)
			return _pos

			def Clear(self):
			self.AwardIndex = 0
			self.NeedRMB = 0
			self.NeedPlayerCount = 0
			self.NowPlayerCount = 0
			self.AwardItemCount = 0
			self.AwardItemList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.AwardIndex)
			data = CommFunc.WriteDWORD(data, self.NeedRMB)
			data = CommFunc.WriteWORD(data, self.NeedPlayerCount)
			data = CommFunc.WriteWORD(data, self.NowPlayerCount)
			data = CommFunc.WriteBYTE(data, self.AwardItemCount)
			for i in range(self.AwardItemCount):
			data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			AwardIndex:%d,
			NeedRMB:%d,
			NeedPlayerCount:%d,
			NowPlayerCount:%d,
			AwardItemCount:%d,
			AwardItemList:%s
			'''\
			%(
			self.AwardIndex,
			self.NeedRMB,
			self.NeedPlayerCount,
			self.NowPlayerCount,
			self.AwardItemCount,
			"..."
			)
			return DumpString


			class tagGCCrossActAllRechargeInfo(Structure):
			Head = tagHead()
			ServerInfoLen = 0 #(BYTE ServerInfoLen)
			ServerIDRangeInfo = "" #(String ServerIDRangeInfo)//开放该活动的服务器ID范围列表，json格式 [[IDA, IDB], ...]， [] 为全服
			StartDate = "" #(char StartDate[10])// 开始日期 y-m-d
			EndtDate = "" #(char EndtDate[10])// 结束日期 y-m-d
			AwardCount = 0 #(BYTE AwardCount)
			AwardList = list() #(vector<tagGCCrossActAllRechargeAward> AwardList)// 奖励档次信息
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xAC
			self.Head.SubCmd = 0x13
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ServerInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ServerIDRangeInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ServerInfoLen)
			self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.AwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.AwardCount):
			temAwardList = tagGCCrossActAllRechargeAward()
			_pos = temAwardList.ReadData(_lpData, _pos)
			self.AwardList.append(temAwardList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAC
			self.Head.SubCmd = 0x13
			self.ServerInfoLen = 0
			self.ServerIDRangeInfo = ""
			self.StartDate = ""
			self.EndtDate = ""
			self.AwardCount = 0
			self.AwardList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += len(self.ServerIDRangeInfo)
			length += 10
			length += 10
			length += 1
			for i in range(self.AwardCount):
			length += self.AwardList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ServerInfoLen)
			data = CommFunc.WriteString(data, self.ServerInfoLen, self.ServerIDRangeInfo)
			data = CommFunc.WriteString(data, 10, self.StartDate)
			data = CommFunc.WriteString(data, 10, self.EndtDate)
			data = CommFunc.WriteBYTE(data, self.AwardCount)
			for i in range(self.AwardCount):
			data = CommFunc.WriteString(data, self.AwardList[i].GetLength(), self.AwardList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ServerInfoLen:%d,
			ServerIDRangeInfo:%s,
			StartDate:%s,
			EndtDate:%s,
			AwardCount:%d,
			AwardList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ServerInfoLen,
			self.ServerIDRangeInfo,
			self.StartDate,
			self.EndtDate,
			self.AwardCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -7276,6 +7793,994 @@


			#------------------------------------------------------
			# B3 24 喜糖列表 #tagGCCandyList

			class tagGCCandyInfo(Structure):
			PlayerIDA = 0 #(DWORD PlayerIDA)// 玩家ID - 请求方
			NameALen = 0 #(BYTE NameALen)
			PlayerNameA = "" #(String PlayerNameA)
			PlayerIDB = 0 #(DWORD PlayerIDB)// 玩家ID - 接受方
			NameBLen = 0 #(BYTE NameBLen)
			PlayerNameB = "" #(String PlayerNameB)
			BridePriceID = 0 #(BYTE BridePriceID)// 聘礼ID
			MarryTime = 0 #(DWORD MarryTime)// 成亲时间戳，秒
			EndTime = 0 #(DWORD EndTime)// 结束时间戳，秒
			Prosperity = 0 #(DWORD Prosperity)// 当前繁荣度
			FireworksTotalBuyCount = 0 #(BYTE FireworksTotalBuyCount)// 烟花总已购买次数
			FireworksPlayerBuyCount = 0 #(BYTE FireworksPlayerBuyCount)// 烟花玩家已购买次数
			PlayerFreeEatCandyCount = 0 #(BYTE PlayerFreeEatCandyCount)// 玩家已免费吃该喜糖总次数，包含免费次数、烟花赠送次数
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.PlayerIDA,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameALen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerNameA,_pos = CommFunc.ReadString(_lpData, _pos,self.NameALen)
			self.PlayerIDB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameBLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerNameB,_pos = CommFunc.ReadString(_lpData, _pos,self.NameBLen)
			self.BridePriceID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MarryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EndTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Prosperity,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FireworksTotalBuyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.FireworksPlayerBuyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerFreeEatCandyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerIDA = 0
			self.NameALen = 0
			self.PlayerNameA = ""
			self.PlayerIDB = 0
			self.NameBLen = 0
			self.PlayerNameB = ""
			self.BridePriceID = 0
			self.MarryTime = 0
			self.EndTime = 0
			self.Prosperity = 0
			self.FireworksTotalBuyCount = 0
			self.FireworksPlayerBuyCount = 0
			self.PlayerFreeEatCandyCount = 0
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 1
			length += len(self.PlayerNameA)
			length += 4
			length += 1
			length += len(self.PlayerNameB)
			length += 1
			length += 4
			length += 4
			length += 4
			length += 1
			length += 1
			length += 1

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerIDA)
			data = CommFunc.WriteBYTE(data, self.NameALen)
			data = CommFunc.WriteString(data, self.NameALen, self.PlayerNameA)
			data = CommFunc.WriteDWORD(data, self.PlayerIDB)
			data = CommFunc.WriteBYTE(data, self.NameBLen)
			data = CommFunc.WriteString(data, self.NameBLen, self.PlayerNameB)
			data = CommFunc.WriteBYTE(data, self.BridePriceID)
			data = CommFunc.WriteDWORD(data, self.MarryTime)
			data = CommFunc.WriteDWORD(data, self.EndTime)
			data = CommFunc.WriteDWORD(data, self.Prosperity)
			data = CommFunc.WriteBYTE(data, self.FireworksTotalBuyCount)
			data = CommFunc.WriteBYTE(data, self.FireworksPlayerBuyCount)
			data = CommFunc.WriteBYTE(data, self.PlayerFreeEatCandyCount)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerIDA:%d,
			NameALen:%d,
			PlayerNameA:%s,
			PlayerIDB:%d,
			NameBLen:%d,
			PlayerNameB:%s,
			BridePriceID:%d,
			MarryTime:%d,
			EndTime:%d,
			Prosperity:%d,
			FireworksTotalBuyCount:%d,
			FireworksPlayerBuyCount:%d,
			PlayerFreeEatCandyCount:%d
			'''\
			%(
			self.PlayerIDA,
			self.NameALen,
			self.PlayerNameA,
			self.PlayerIDB,
			self.NameBLen,
			self.PlayerNameB,
			self.BridePriceID,
			self.MarryTime,
			self.EndTime,
			self.Prosperity,
			self.FireworksTotalBuyCount,
			self.FireworksPlayerBuyCount,
			self.PlayerFreeEatCandyCount
			)
			return DumpString


			class tagGCCandyList(Structure):
			Head = tagHead()
			CandyCount = 0 #(WORD CandyCount)
			CandyInfoList = list() #(vector<tagGCCandyInfo> CandyInfoList)// 可吃喜糖列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x24
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.CandyCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.CandyCount):
			temCandyInfoList = tagGCCandyInfo()
			_pos = temCandyInfoList.ReadData(_lpData, _pos)
			self.CandyInfoList.append(temCandyInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x24
			self.CandyCount = 0
			self.CandyInfoList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# B3 19 魅力贡献榜 #tagGCCharmOfferBillboardDataList

			class tagGCCharmOfferBillboardData(Structure):
			OrderIndex = 0 #(DWORD OrderIndex)//名次索引，0代表第一名
			PlayerID = 0 #(DWORD PlayerID)// 玩家ID - 贡献者
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)
			CharmValue = 0 #(DWORD CharmValue)//贡献魅力值
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.OrderIndex,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.CharmValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.OrderIndex = 0
			self.PlayerID = 0
			self.NameLen = 0
			self.PlayerName = ""
			self.CharmValue = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.OrderIndex)
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteDWORD(data, self.CharmValue)
			return data

			def OutputString(self):
			DumpString = '''
			OrderIndex:%d,
			PlayerID:%d,
			NameLen:%d,
			PlayerName:%s,
			CharmValue:%d
			'''\
			%(
			self.OrderIndex,
			self.PlayerID,
			self.NameLen,
			self.PlayerName,
			self.CharmValue
			)
			return DumpString


			class tagGCCharmOfferBillboardDataList(Structure):
			Head = tagHead()
			PlayerID = 0 #(DWORD PlayerID)// 魅力玩家ID
			QueryType = 0 #(BYTE QueryType)// 查看类型： 1-总榜，2-周榜，3-日榜
			DataCount = 0 #(BYTE DataCount)
			OfferBillboardDataList = list() #(vector<tagGCCharmOfferBillboardData> OfferBillboardDataList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x19
			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.QueryType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.DataCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.DataCount):
			temOfferBillboardDataList = tagGCCharmOfferBillboardData()
			_pos = temOfferBillboardDataList.ReadData(_lpData, _pos)
			self.OfferBillboardDataList.append(temOfferBillboardDataList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x19
			self.PlayerID = 0
			self.QueryType = 0
			self.DataCount = 0
			self.OfferBillboardDataList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 1
			length += 1
			for i in range(self.DataCount):
			length += self.OfferBillboardDataList[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.QueryType)
			data = CommFunc.WriteBYTE(data, self.DataCount)
			for i in range(self.DataCount):
			data = CommFunc.WriteString(data, self.OfferBillboardDataList[i].GetLength(), self.OfferBillboardDataList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			PlayerID:%d,
			QueryType:%d,
			DataCount:%d,
			OfferBillboardDataList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.PlayerID,
			self.QueryType,
			self.DataCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# B3 26 伴侣信息 #tagGCCoupleInfo

			class tagGCCoupleInfo(Structure):
			Head = tagHead()
			CoupleID = 0 #(DWORD CoupleID)// 伴侣玩家ID，一定是好友，社交信息从好友系统中获取
			NameLen = 0 #(BYTE NameLen)
			CoupleName = "" #(String CoupleName)
			NewMarryTime = 0 #(DWORD NewMarryTime)// 新婚时间戳，秒，计算结婚天数按该时间计算
			MarryTime = 0 #(DWORD MarryTime)// 最近一次提亲成功时间戳，秒，计算可离婚时间按该时间计算
			BridePriceState = 0 #(DWORD BridePriceState)// 聘礼状态，按位存储已购买次数，如205代表ID1买了5次，ID2买了0次，ID3买了2次，最高9次
			BreakRequestID = 0 #(DWORD BreakRequestID)// 当前请求中的和离时间戳 - 请求方ID，0代表没人发起请求
			BreakRequestTime = 0 #(DWORD BreakRequestTime)// 当前请求中的和离时间戳，秒，用于计算和离回应有效期
			PlayerBreakRequestTime = 0 #(DWORD PlayerBreakRequestTime)// 玩家最近一次和离请求时间戳，秒，用于计算自身的请求和离CD
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x26
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.CoupleID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.CoupleName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.NewMarryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MarryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.BridePriceState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.BreakRequestID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.BreakRequestTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PlayerBreakRequestTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x26
			self.CoupleID = 0
			self.NameLen = 0
			self.CoupleName = ""
			self.NewMarryTime = 0
			self.MarryTime = 0
			self.BridePriceState = 0
			self.BreakRequestID = 0
			self.BreakRequestTime = 0
			self.PlayerBreakRequestTime = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.CoupleID)
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.CoupleName)
			data = CommFunc.WriteDWORD(data, self.NewMarryTime)
			data = CommFunc.WriteDWORD(data, self.MarryTime)
			data = CommFunc.WriteDWORD(data, self.BridePriceState)
			data = CommFunc.WriteDWORD(data, self.BreakRequestID)
			data = CommFunc.WriteDWORD(data, self.BreakRequestTime)
			data = CommFunc.WriteDWORD(data, self.PlayerBreakRequestTime)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			CoupleID:%d,
			NameLen:%d,
			CoupleName:%s,
			NewMarryTime:%d,
			MarryTime:%d,
			BridePriceState:%d,
			BreakRequestID:%d,
			BreakRequestTime:%d,
			PlayerBreakRequestTime:%d
			'''\
			%(
			self.Head.OutputString(),
			self.CoupleID,
			self.NameLen,
			self.CoupleName,
			self.NewMarryTime,
			self.MarryTime,
			self.BridePriceState,
			self.BreakRequestID,
			self.BreakRequestTime,
			self.PlayerBreakRequestTime
			)
			return DumpString


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


			#------------------------------------------------------
			# B3 22 收到提亲信息 #tagGCMarryReqInfo

			class tagGCMarryReqInfo(Structure):
			Head = tagHead()
			PlayerID = 0 #(DWORD PlayerID)// 同一个玩家ID多次提亲时可能同步多次，前端覆盖数据即可
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)
			BridePriceID = 0 #(BYTE BridePriceID)// 聘礼ID
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x22
			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.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.BridePriceID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x22
			self.PlayerID = 0
			self.NameLen = 0
			self.PlayerName = ""
			self.BridePriceID = 0
			return

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

			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.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteBYTE(data, self.BridePriceID)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			PlayerID:%d,
			NameLen:%d,
			PlayerName:%s,
			BridePriceID:%d
			'''\
			%(
			self.Head.OutputString(),
			self.PlayerID,
			self.NameLen,
			self.PlayerName,
			self.BridePriceID
			)
			return DumpString


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


			#------------------------------------------------------
			# B3 21 提亲发送成功 #tagGCMarryReqOK

			class tagGCMarryReqOK(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB3
			self.SubCmd = 0x21
			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 = 0xB3
			self.SubCmd = 0x21
			return

			def GetLength(self):
			return sizeof(tagGCMarryReqOK)

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

			def OutputString(self):
			DumpString = '''// B3 21 提亲发送成功 //tagGCMarryReqOK:
			Cmd:%s,
			SubCmd:%s
			'''\
			%(
			self.Cmd,
			self.SubCmd
			)
			return DumpString


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


			#------------------------------------------------------
			# B3 23 提亲回应结果 #tagGCMarryResponseRet

			class tagGCMarryResponseRet(Structure):
			Head = tagHead()
			PlayerIDA = 0 #(DWORD PlayerIDA)// 玩家ID - 请求方
			NameALen = 0 #(BYTE NameALen)
			PlayerNameA = "" #(String PlayerNameA)
			PlayerIDB = 0 #(DWORD PlayerIDB)// 玩家ID - 接受方
			NameBLen = 0 #(BYTE NameBLen)
			PlayerNameB = "" #(String PlayerNameB)
			IsOK = 0 #(BYTE IsOK)// 是否同意，0-否，1-是; 如果同意则双方都会收到该包，根据玩家ID判断自己是请求或接受方，显示不同的同意结果界面；不同意只有请求方会收到
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x23
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.PlayerIDA,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameALen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerNameA,_pos = CommFunc.ReadString(_lpData, _pos,self.NameALen)
			self.PlayerIDB,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameBLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerNameB,_pos = CommFunc.ReadString(_lpData, _pos,self.NameBLen)
			self.IsOK,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x23
			self.PlayerIDA = 0
			self.NameALen = 0
			self.PlayerNameA = ""
			self.PlayerIDB = 0
			self.NameBLen = 0
			self.PlayerNameB = ""
			self.IsOK = 0
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 1
			length += len(self.PlayerNameA)
			length += 4
			length += 1
			length += len(self.PlayerNameB)
			length += 1

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.PlayerIDA)
			data = CommFunc.WriteBYTE(data, self.NameALen)
			data = CommFunc.WriteString(data, self.NameALen, self.PlayerNameA)
			data = CommFunc.WriteDWORD(data, self.PlayerIDB)
			data = CommFunc.WriteBYTE(data, self.NameBLen)
			data = CommFunc.WriteString(data, self.NameBLen, self.PlayerNameB)
			data = CommFunc.WriteBYTE(data, self.IsOK)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			PlayerIDA:%d,
			NameALen:%d,
			PlayerNameA:%s,
			PlayerIDB:%d,
			NameBLen:%d,
			PlayerNameB:%s,
			IsOK:%d
			'''\
			%(
			self.Head.OutputString(),
			self.PlayerIDA,
			self.NameALen,
			self.PlayerNameA,
			self.PlayerIDB,
			self.NameBLen,
			self.PlayerNameB,
			self.IsOK
			)
			return DumpString


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


			#------------------------------------------------------
			# B3 25 玩家魅力值信息 #tagGCPlayerCharmValueInfo

			class tagGCPlayerCharmValueInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("CharmValueTotal", c_int), #当前魅力值 - 总
			("CharmValueWeek", c_int), #当前魅力值 - 周
			("CharmValueDay", c_int), #当前魅力值 - 日
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB3
			self.SubCmd = 0x25
			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 = 0xB3
			self.SubCmd = 0x25
			self.CharmValueTotal = 0
			self.CharmValueWeek = 0
			self.CharmValueDay = 0
			return

			def GetLength(self):
			return sizeof(tagGCPlayerCharmValueInfo)

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

			def OutputString(self):
			DumpString = '''// B3 25 玩家魅力值信息 //tagGCPlayerCharmValueInfo:
			Cmd:%s,
			SubCmd:%s,
			CharmValueTotal:%d,
			CharmValueWeek:%d,
			CharmValueDay:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.CharmValueTotal,
			self.CharmValueWeek,
			self.CharmValueDay
			)
			return DumpString


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


			#------------------------------------------------------
			# B3 20 送礼物成功通知 #tagGCSendGiftsOKList

			class tagGCSendGiftsOK(Structure):
			NameLen = 0 #(BYTE NameLen)
			Name = "" #(String Name)// 赠送方玩家名
			PlayerID = 0 #(DWORD PlayerID)// 赠送方玩家ID
			GiftNum = 0 #(WORD GiftNum)// 赠送礼物编号
			GiftCount = 0 #(DWORD GiftCount)// 赠送礼物数量
			SendTime = 0 #(DWORD SendTime)// 赠送时间戳
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.GiftNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.GiftCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.SendTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.NameLen = 0
			self.Name = ""
			self.PlayerID = 0
			self.GiftNum = 0
			self.GiftCount = 0
			self.SendTime = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.Name)
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteWORD(data, self.GiftNum)
			data = CommFunc.WriteDWORD(data, self.GiftCount)
			data = CommFunc.WriteDWORD(data, self.SendTime)
			return data

			def OutputString(self):
			DumpString = '''
			NameLen:%d,
			Name:%s,
			PlayerID:%d,
			GiftNum:%d,
			GiftCount:%d,
			SendTime:%d
			'''\
			%(
			self.NameLen,
			self.Name,
			self.PlayerID,
			self.GiftNum,
			self.GiftCount,
			self.SendTime
			)
			return DumpString


			class tagGCSendGiftsOKList(Structure):
			Head = tagHead()
			Count = 0 #(WORD Count)
			SendGiftsOKList = list() #(vector<tagGCSendGiftsOK> SendGiftsOKList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x20
			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):
			temSendGiftsOKList = tagGCSendGiftsOK()
			_pos = temSendGiftsOKList.ReadData(_lpData, _pos)
			self.SendGiftsOKList.append(temSendGiftsOKList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x20
			self.Count = 0
			self.SendGiftsOKList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			for i in range(self.Count):
			length += self.SendGiftsOKList[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.SendGiftsOKList[i].GetLength(), self.SendGiftsOKList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# B3 14 社交人群伴侣信息 #tagGCSocialCouples

			class tagGCSocialCouple(Structure):
			_pack_ = 1
			_fields_ = [
			("PlayerID", c_int),
			("CoupleID", 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.PlayerID = 0
			self.CoupleID = 0
			return

			def GetLength(self):
			return sizeof(tagGCSocialCouple)

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

			def OutputString(self):
			DumpString = '''// B3 14 社交人群伴侣信息 //tagGCSocialCouples:
			PlayerID:%d,
			CoupleID:%d
			'''\
			%(
			self.PlayerID,
			self.CoupleID
			)
			return DumpString


			class tagGCSocialCouples(Structure):
			Head = tagHead()
			Count = 0 #(WORD Count)
			Player = list() #(vector<tagGCSocialCouple> Player)//size = Count
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x14
			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):
			temPlayer = tagGCSocialCouple()
			_pos = temPlayer.ReadData(_lpData, _pos)
			self.Player.append(temPlayer)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB3
			self.Head.SubCmd = 0x14
			self.Count = 0
			self.Player = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			for i in range(self.Count):
			length += self.Player[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.Player[i].GetLength(), self.Player[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			#B3 01 添加社交对象 #tagGCAddSocialPlayer

			class tagGCAddSocialPlayer(Structure):
			@@ -7646,7 +9151,7 @@
			_pack_ = 1
			_fields_ = [
			("PlayerID", c_int),
			("SortValue", c_int),
			("SortValue", c_int), # 亲密组时为亲密度
			]

			def __init__(self):
			@@ -7683,7 +9188,7 @@

			class tagGCGroupPlayers(Structure):
			Head = tagHead()
			GroupType = 0 #(BYTE GroupType)// 分组 1 最近联系人 2 好友 3 仇人 4 黑名单
			GroupType = 0 #(BYTE GroupType)// 分组 1 最近联系人 2 好友 3 仇人 4 黑名单 5亲密组
			Count = 0 #(WORD Count)
			Players = list() #(vector<tagGCGroupPlayer> Players)//size = Count
			data = None
			@@ -11270,6 +12775,1206 @@


			#------------------------------------------------------
			# C0 23 跨服排位竞猜个人信息 #tagGCChampionshipGuessPriInfo

			class tagGCChampionshipGuessPlayerPri(Structure):
			_pack_ = 1
			_fields_ = [
			("PlayerID", c_int), # 目标玩家ID
			("MoneyTotal", c_int), # 已投注该玩家货币总数
			("GuessRank", c_ubyte), # 竞猜名次，没有名次的竞猜默认0；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.PlayerID = 0
			self.MoneyTotal = 0
			self.GuessRank = 0
			return

			def GetLength(self):
			return sizeof(tagGCChampionshipGuessPlayerPri)

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

			def OutputString(self):
			DumpString = '''// C0 23 跨服排位竞猜个人信息 //tagGCChampionshipGuessPriInfo:
			PlayerID:%d,
			MoneyTotal:%d,
			GuessRank:%d
			'''\
			%(
			self.PlayerID,
			self.MoneyTotal,
			self.GuessRank
			)
			return DumpString


			class tagGCChampionshipGuessPriList(Structure):
			GuessType = 0 #(BYTE GuessType)//竞猜类型 8-8强；4-4强排位
			PlayerCount = 0 #(BYTE PlayerCount)
			GuessPlayerList = list() #(vector<tagGCChampionshipGuessPlayerPri> GuessPlayerList)// 被竞猜玩家列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.GuessType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PlayerCount):
			temGuessPlayerList = tagGCChampionshipGuessPlayerPri()
			_pos = temGuessPlayerList.ReadData(_lpData, _pos)
			self.GuessPlayerList.append(temGuessPlayerList)
			return _pos

			def Clear(self):
			self.GuessType = 0
			self.PlayerCount = 0
			self.GuessPlayerList = list()
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 1
			for i in range(self.PlayerCount):
			length += self.GuessPlayerList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.GuessType)
			data = CommFunc.WriteBYTE(data, self.PlayerCount)
			for i in range(self.PlayerCount):
			data = CommFunc.WriteString(data, self.GuessPlayerList[i].GetLength(), self.GuessPlayerList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			GuessType:%d,
			PlayerCount:%d,
			GuessPlayerList:%s
			'''\
			%(
			self.GuessType,
			self.PlayerCount,
			"..."
			)
			return DumpString


			class tagGCChampionshipGuessPriInfo(Structure):
			Head = tagHead()
			ZoneID = 0 #(BYTE ZoneID)// 排位数据分区ID
			Count = 0 #(BYTE Count)
			GuessList = list() #(vector<tagGCChampionshipGuessPriList> GuessList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x23
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temGuessList = tagGCChampionshipGuessPriList()
			_pos = temGuessList.ReadData(_lpData, _pos)
			self.GuessList.append(temGuessList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x23
			self.ZoneID = 0
			self.Count = 0
			self.GuessList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# C0 22 跨服排位竞猜公共信息 #tagGCChampionshipGuessPubInfo

			class tagGCChampionshipGuessPlayerPub(Structure):
			_pack_ = 1
			_fields_ = [
			("PlayerID", c_int), # 目标玩家ID
			("SupportCount", 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.PlayerID = 0
			self.SupportCount = 0
			return

			def GetLength(self):
			return sizeof(tagGCChampionshipGuessPlayerPub)

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

			def OutputString(self):
			DumpString = '''// C0 22 跨服排位竞猜公共信息 //tagGCChampionshipGuessPubInfo:
			PlayerID:%d,
			SupportCount:%d
			'''\
			%(
			self.PlayerID,
			self.SupportCount
			)
			return DumpString


			class tagGCChampionshipGuessPubList(Structure):
			GuessType = 0 #(BYTE GuessType)//竞猜类型 8-8强；4-4强排位
			PlayerCount = 0 #(BYTE PlayerCount)
			GuessPlayerList = list() #(vector<tagGCChampionshipGuessPlayerPub> GuessPlayerList)// 被竞猜玩家列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.GuessType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PlayerCount):
			temGuessPlayerList = tagGCChampionshipGuessPlayerPub()
			_pos = temGuessPlayerList.ReadData(_lpData, _pos)
			self.GuessPlayerList.append(temGuessPlayerList)
			return _pos

			def Clear(self):
			self.GuessType = 0
			self.PlayerCount = 0
			self.GuessPlayerList = list()
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 1
			for i in range(self.PlayerCount):
			length += self.GuessPlayerList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.GuessType)
			data = CommFunc.WriteBYTE(data, self.PlayerCount)
			for i in range(self.PlayerCount):
			data = CommFunc.WriteString(data, self.GuessPlayerList[i].GetLength(), self.GuessPlayerList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			GuessType:%d,
			PlayerCount:%d,
			GuessPlayerList:%s
			'''\
			%(
			self.GuessType,
			self.PlayerCount,
			"..."
			)
			return DumpString


			class tagGCChampionshipGuessPubInfo(Structure):
			Head = tagHead()
			ZoneID = 0 #(BYTE ZoneID)// 排位数据分区ID
			Count = 0 #(BYTE Count)
			GuessList = list() #(vector<tagGCChampionshipGuessPubList> GuessList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x22
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temGuessList = tagGCChampionshipGuessPubList()
			_pos = temGuessList.ReadData(_lpData, _pos)
			self.GuessList.append(temGuessList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x22
			self.ZoneID = 0
			self.Count = 0
			self.GuessList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# C0 19 跨服排位仙官申请回应结果 #tagGCChampionshipOfficialApplyReplyRet

			class tagGCChampionshipOfficialApplyReplyRet(Structure):
			Head = tagHead()
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)// 界主玩家名
			MainOfficialID = 0 #(WORD MainOfficialID)//界主官职ID
			OfficialID = 0 #(WORD OfficialID)//申请官职ID
			IsOK = 0 #(BYTE IsOK)//是否同意；1-是；0-否
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.MainOfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.OfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.IsOK,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x19
			self.NameLen = 0
			self.PlayerName = ""
			self.MainOfficialID = 0
			self.OfficialID = 0
			self.IsOK = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteWORD(data, self.MainOfficialID)
			data = CommFunc.WriteWORD(data, self.OfficialID)
			data = CommFunc.WriteBYTE(data, self.IsOK)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			NameLen:%d,
			PlayerName:%s,
			MainOfficialID:%d,
			OfficialID:%d,
			IsOK:%d
			'''\
			%(
			self.Head.OutputString(),
			self.NameLen,
			self.PlayerName,
			self.MainOfficialID,
			self.OfficialID,
			self.IsOK
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 21 跨服排位仙官挑战记录 #tagGCChampionshipOfficialChallengeRecordInfo

			class tagGCChampionshipOfficialChallengeRecord(Structure):
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)
			ChallengeTime = 0 #(DWORD ChallengeTime)//挑战时间戳
			Ret = 0 #(BYTE Ret)//挑战结果；0-失败；1-获胜；
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.ChallengeTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Ret,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.NameLen = 0
			self.PlayerName = ""
			self.ChallengeTime = 0
			self.Ret = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteDWORD(data, self.ChallengeTime)
			data = CommFunc.WriteBYTE(data, self.Ret)
			return data

			def OutputString(self):
			DumpString = '''
			NameLen:%d,
			PlayerName:%s,
			ChallengeTime:%d,
			Ret:%d
			'''\
			%(
			self.NameLen,
			self.PlayerName,
			self.ChallengeTime,
			self.Ret
			)
			return DumpString


			class tagGCChampionshipOfficialChallengeRecordInfo(Structure):
			Head = tagHead()
			ZoneID = 0 #(BYTE ZoneID)// 分区ID
			MainOfficialID = 0 #(WORD MainOfficialID)// 界主官职ID
			OfficialID = 0 #(WORD OfficialID)// 记录的官职ID
			RecordCount = 0 #(BYTE RecordCount)// 挑战记录数
			RecordList = list() #(vector<tagGCChampionshipOfficialChallengeRecord> RecordList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x21
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MainOfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.OfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.RecordCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RecordCount):
			temRecordList = tagGCChampionshipOfficialChallengeRecord()
			_pos = temRecordList.ReadData(_lpData, _pos)
			self.RecordList.append(temRecordList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x21
			self.ZoneID = 0
			self.MainOfficialID = 0
			self.OfficialID = 0
			self.RecordCount = 0
			self.RecordList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ZoneID)
			data = CommFunc.WriteWORD(data, self.MainOfficialID)
			data = CommFunc.WriteWORD(data, self.OfficialID)
			data = CommFunc.WriteBYTE(data, self.RecordCount)
			for i in range(self.RecordCount):
			data = CommFunc.WriteString(data, self.RecordList[i].GetLength(), self.RecordList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ZoneID:%d,
			MainOfficialID:%d,
			OfficialID:%d,
			RecordCount:%d,
			RecordList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ZoneID,
			self.MainOfficialID,
			self.OfficialID,
			self.RecordCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 20 跨服排位仙官挑战结果 #tagGCChampionshipOfficialChallengeRet

			class tagGCChampionshipOfficialChallengeRet(Structure):
			Head = tagHead()
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)// 原仙官玩家名，可能为空，代表本来无玩家
			MainOfficialID = 0 #(WORD MainOfficialID)//界主官职ID
			OfficialID = 0 #(WORD OfficialID)//挑战的官职ID
			Ret = 0 #(BYTE Ret)//挑战结果；0-失败；1-获胜；2-目标仙官玩家ID已变更，可刷新后重试
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x20
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.MainOfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.OfficialID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Ret,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x20
			self.NameLen = 0
			self.PlayerName = ""
			self.MainOfficialID = 0
			self.OfficialID = 0
			self.Ret = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteWORD(data, self.MainOfficialID)
			data = CommFunc.WriteWORD(data, self.OfficialID)
			data = CommFunc.WriteBYTE(data, self.Ret)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			NameLen:%d,
			PlayerName:%s,
			MainOfficialID:%d,
			OfficialID:%d,
			Ret:%d
			'''\
			%(
			self.Head.OutputString(),
			self.NameLen,
			self.PlayerName,
			self.MainOfficialID,
			self.OfficialID,
			self.Ret
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 18 跨服排位官职信息 #tagGCChampionshipOfficialInfo

			class tagGCChampionshipOfficialPlayer(Structure):
			PlayerID = 0 #(DWORD PlayerID)// 玩家ID
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)
			Job = 0 #(BYTE Job)
			LV = 0 #(WORD LV)
			FightPower = 0 #(DWORD FightPower)// 战力求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)// 战力整除亿部分
			RealmLV = 0 #(WORD RealmLV)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.NameLen = 0
			self.PlayerName = ""
			self.Job = 0
			self.LV = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			self.RealmLV = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteBYTE(data, self.Job)
			data = CommFunc.WriteWORD(data, self.LV)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteWORD(data, self.RealmLV)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			NameLen:%d,
			PlayerName:%s,
			Job:%d,
			LV:%d,
			FightPower:%d,
			FightPowerEx:%d,
			RealmLV:%d
			'''\
			%(
			self.PlayerID,
			self.NameLen,
			self.PlayerName,
			self.Job,
			self.LV,
			self.FightPower,
			self.FightPowerEx,
			self.RealmLV
			)
			return DumpString


			class tagGCChampionshipOfficial(Structure):
			OfficialID = 0 #(DWORD OfficialID)// 官职ID
			LastDismissJuniorTime = 0 #(DWORD LastDismissJuniorTime)// 上次辞退下级仙官时间戳，跨服时间，如果自己是本界主时，用于计算辞退CD
			WorshipCount = 0 #(DWORD WorshipCount)// 被膜拜次数
			WorshipDouble = 0 #(BYTE WorshipDouble)// 今日是否双倍膜拜，仅在规定时间点内有用
			OfficialPlayer=tagGCChampionshipOfficialPlayer() #(tagGCChampionshipOfficialPlayer OfficialPlayer)// 任职玩家信息，可能没有
			ApplyPlayerCount = 0 #(BYTE ApplyPlayerCount)// 申请该仙官玩家数
			ApplyPlayerList = list() #(vector<tagGCChampionshipOfficialPlayer> ApplyPlayerList)// 申请该仙官玩家列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.OfficialID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.LastDismissJuniorTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.WorshipCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.WorshipDouble,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			_pos = self.OfficialPlayer.ReadData(_lpData,_pos)
			self.ApplyPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.ApplyPlayerCount):
			temApplyPlayerList = tagGCChampionshipOfficialPlayer()
			_pos = temApplyPlayerList.ReadData(_lpData, _pos)
			self.ApplyPlayerList.append(temApplyPlayerList)
			return _pos

			def Clear(self):
			self.OfficialID = 0
			self.LastDismissJuniorTime = 0
			self.WorshipCount = 0
			self.WorshipDouble = 0
			self.OfficialPlayer=tagGCChampionshipOfficialPlayer()
			self.OfficialPlayer.Clear()
			self.ApplyPlayerCount = 0
			self.ApplyPlayerList = list()
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 4
			length += 4
			length += 1
			length += self.OfficialPlayer.GetLength()
			length += 1
			for i in range(self.ApplyPlayerCount):
			length += self.ApplyPlayerList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.OfficialID)
			data = CommFunc.WriteDWORD(data, self.LastDismissJuniorTime)
			data = CommFunc.WriteDWORD(data, self.WorshipCount)
			data = CommFunc.WriteBYTE(data, self.WorshipDouble)
			data = CommFunc.WriteString(data,self.OfficialPlayer.GetLength(),self.OfficialPlayer.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ApplyPlayerCount)
			for i in range(self.ApplyPlayerCount):
			data = CommFunc.WriteString(data, self.ApplyPlayerList[i].GetLength(), self.ApplyPlayerList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			OfficialID:%d,
			LastDismissJuniorTime:%d,
			WorshipCount:%d,
			WorshipDouble:%d,
			OfficialPlayer:%s,
			ApplyPlayerCount:%d,
			ApplyPlayerList:%s
			'''\
			%(
			self.OfficialID,
			self.LastDismissJuniorTime,
			self.WorshipCount,
			self.WorshipDouble,
			self.OfficialPlayer.OutputString(),
			self.ApplyPlayerCount,
			"..."
			)
			return DumpString


			class tagGCChampionshipOfficialInfo(Structure):
			Head = tagHead()
			ZoneID = 0 #(BYTE ZoneID)// 官职数据分区ID
			OfficialCount = 0 #(BYTE OfficialCount)// 官职数，包含界主及所有仙官
			OfficialList = list() #(vector<tagGCChampionshipOfficial> OfficialList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x18
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.OfficialCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.OfficialCount):
			temOfficialList = tagGCChampionshipOfficial()
			_pos = temOfficialList.ReadData(_lpData, _pos)
			self.OfficialList.append(temOfficialList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x18
			self.ZoneID = 0
			self.OfficialCount = 0
			self.OfficialList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ZoneID:%d,
			OfficialCount:%d,
			OfficialList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ZoneID,
			self.OfficialCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 09 跨服战场玩家购买战场信息 #tagGCCrossBattlefieldBuyInfo

			class tagGCCrossBattlefieldPlayer(Structure):
			PlayerID = 0 #(DWORD PlayerID)
			PlayerName = "" #(char PlayerName[33])
			Job = 0 #(BYTE Job)
			LV = 0 #(WORD LV)//等级
			RealmLV = 0 #(WORD RealmLV)//境界
			FightPower = 0 #(DWORD FightPower)//战力求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力整除亿部分
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.PlayerName = ""
			self.Job = 0
			self.LV = 0
			self.RealmLV = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 33
			length += 1
			length += 2
			length += 2
			length += 4
			length += 4

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteString(data, 33, self.PlayerName)
			data = CommFunc.WriteBYTE(data, self.Job)
			data = CommFunc.WriteWORD(data, self.LV)
			data = CommFunc.WriteWORD(data, self.RealmLV)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			PlayerName:%s,
			Job:%d,
			LV:%d,
			RealmLV:%d,
			FightPower:%d,
			FightPowerEx:%d
			'''\
			%(
			self.PlayerID,
			self.PlayerName,
			self.Job,
			self.LV,
			self.RealmLV,
			self.FightPower,
			self.FightPowerEx
			)
			return DumpString


			class tagGCCrossBattlefieldBuyPlayer(Structure):
			BuyPlayerID = 0 #(DWORD BuyPlayerID)//购买的玩家ID，即召集人
			Faction = 0 #(BYTE Faction)//阵营 1-红；2-蓝
			ServerOnly = 0 #(BYTE ServerOnly)//是否仅本服玩家可加入，0-否，1-是
			FactionPlayerCount = 0 #(BYTE FactionPlayerCount)
			FactionPlayerList = list() #(vector<tagGCCrossBattlefieldPlayer> FactionPlayerList)//阵营所有玩家列表，包含召集人
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.BuyPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Faction,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ServerOnly,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.FactionPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FactionPlayerCount):
			temFactionPlayerList = tagGCCrossBattlefieldPlayer()
			_pos = temFactionPlayerList.ReadData(_lpData, _pos)
			self.FactionPlayerList.append(temFactionPlayerList)
			return _pos

			def Clear(self):
			self.BuyPlayerID = 0
			self.Faction = 0
			self.ServerOnly = 0
			self.FactionPlayerCount = 0
			self.FactionPlayerList = list()
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 1
			length += 1
			length += 1
			for i in range(self.FactionPlayerCount):
			length += self.FactionPlayerList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.BuyPlayerID)
			data = CommFunc.WriteBYTE(data, self.Faction)
			data = CommFunc.WriteBYTE(data, self.ServerOnly)
			data = CommFunc.WriteBYTE(data, self.FactionPlayerCount)
			for i in range(self.FactionPlayerCount):
			data = CommFunc.WriteString(data, self.FactionPlayerList[i].GetLength(), self.FactionPlayerList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			BuyPlayerID:%d,
			Faction:%d,
			ServerOnly:%d,
			FactionPlayerCount:%d,
			FactionPlayerList:%s
			'''\
			%(
			self.BuyPlayerID,
			self.Faction,
			self.ServerOnly,
			self.FactionPlayerCount,
			"..."
			)
			return DumpString


			class tagGCCrossBattlefieldBuyHM(Structure):
			Hour = 0 #(BYTE Hour)//战场开启时
			Minute = 0 #(BYTE Minute)//战场开启分
			BuyPlayerCount = 0 #(BYTE BuyPlayerCount)
			BuyPlayerList = list() #(vector<tagGCCrossBattlefieldBuyPlayer> BuyPlayerList)//购买本场次的玩家信息列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.Hour,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Minute,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.BuyPlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.BuyPlayerCount):
			temBuyPlayerList = tagGCCrossBattlefieldBuyPlayer()
			_pos = temBuyPlayerList.ReadData(_lpData, _pos)
			self.BuyPlayerList.append(temBuyPlayerList)
			return _pos

			def Clear(self):
			self.Hour = 0
			self.Minute = 0
			self.BuyPlayerCount = 0
			self.BuyPlayerList = list()
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 1
			length += 1
			for i in range(self.BuyPlayerCount):
			length += self.BuyPlayerList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.Hour)
			data = CommFunc.WriteBYTE(data, self.Minute)
			data = CommFunc.WriteBYTE(data, self.BuyPlayerCount)
			for i in range(self.BuyPlayerCount):
			data = CommFunc.WriteString(data, self.BuyPlayerList[i].GetLength(), self.BuyPlayerList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Hour:%d,
			Minute:%d,
			BuyPlayerCount:%d,
			BuyPlayerList:%s
			'''\
			%(
			self.Hour,
			self.Minute,
			self.BuyPlayerCount,
			"..."
			)
			return DumpString


			class tagGCCrossBattlefieldBuyInfo(Structure):
			Head = tagHead()
			HMCount = 0 #(BYTE HMCount)// 为0时清空重置，其他为增量更新
			HMBuyList = list() #(vector<tagGCCrossBattlefieldBuyHM> HMBuyList)//购买场次列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.HMCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.HMCount):
			temHMBuyList = tagGCCrossBattlefieldBuyHM()
			_pos = temHMBuyList.ReadData(_lpData, _pos)
			self.HMBuyList.append(temHMBuyList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x09
			self.HMCount = 0
			self.HMBuyList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# C0 07 跨服排行榜信息 #tagGCCrossBillboardInfo

			class tagGCCrossBillboardData(Structure):
			@@ -11451,6 +14156,429 @@

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


			#------------------------------------------------------
			# C0 16 跨服排位战斗结果 #tagGCCrossChampionshipPKOver

			class tagGCCrossChampionshipPKOver(Structure):
			Head = tagHead()
			GroupMark = 0 #(DWORD GroupMark)// 分组标识：64、32、16、8 - 64、32、16、8强赛；4 - 半决赛； 2 - 决赛
			TimeStr = "" #(char TimeStr[19])// 结算时间，格式 yyyy-MM-dd HH:mm:ss
			OverType = 0 #(BYTE OverType)// 0-正常，1-有人离线
			WinnerID = 0 #(DWORD WinnerID)// 胜方ID
			LoserID = 0 #(DWORD LoserID)// 败方ID
			RoundCount = 0 #(BYTE RoundCount)// PK回合数
			RoundWinnerID = list() #(vector<DWORD> RoundWinnerID)// 回合获胜ID列表
			TagNameLen = 0 #(BYTE TagNameLen)
			TagName = "" #(String TagName)
			Rank = 0 #(BYTE Rank)// 最终名次，决赛才有
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.GroupMark,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TimeStr,_pos = CommFunc.ReadString(_lpData, _pos,19)
			self.OverType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.WinnerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.LoserID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RoundCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RoundCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.RoundWinnerID.append(value)
			self.TagNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.TagName,_pos = CommFunc.ReadString(_lpData, _pos,self.TagNameLen)
			self.Rank,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x16
			self.GroupMark = 0
			self.TimeStr = ""
			self.OverType = 0
			self.WinnerID = 0
			self.LoserID = 0
			self.RoundCount = 0
			self.RoundWinnerID = list()
			self.TagNameLen = 0
			self.TagName = ""
			self.Rank = 0
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 19
			length += 1
			length += 4
			length += 4
			length += 1
			length += 4 * self.RoundCount
			length += 1
			length += len(self.TagName)
			length += 1

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.GroupMark)
			data = CommFunc.WriteString(data, 19, self.TimeStr)
			data = CommFunc.WriteBYTE(data, self.OverType)
			data = CommFunc.WriteDWORD(data, self.WinnerID)
			data = CommFunc.WriteDWORD(data, self.LoserID)
			data = CommFunc.WriteBYTE(data, self.RoundCount)
			for i in range(self.RoundCount):
			data = CommFunc.WriteDWORD(data, self.RoundWinnerID[i])
			data = CommFunc.WriteBYTE(data, self.TagNameLen)
			data = CommFunc.WriteString(data, self.TagNameLen, self.TagName)
			data = CommFunc.WriteBYTE(data, self.Rank)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			GroupMark:%d,
			TimeStr:%s,
			OverType:%d,
			WinnerID:%d,
			LoserID:%d,
			RoundCount:%d,
			RoundWinnerID:%s,
			TagNameLen:%d,
			TagName:%s,
			Rank:%d
			'''\
			%(
			self.Head.OutputString(),
			self.GroupMark,
			self.TimeStr,
			self.OverType,
			self.WinnerID,
			self.LoserID,
			self.RoundCount,
			"...",
			self.TagNameLen,
			self.TagName,
			self.Rank
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 15 跨服排位分区分组信息 #tagGCCrossChampionshipPKZoneGroupInfo

			class tagGCCrossChampionshipPKBattle(Structure):
			_pack_ = 1
			_fields_ = [
			("BattleNum", c_ubyte), # 对战组编号 1~n
			("WinPlayerID", c_int), # 获胜玩家ID
			("PlayerIDA", c_int), # 玩家IDA
			("PlayerIDB", c_int), # 玩家IDB
			]

			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.BattleNum = 0
			self.WinPlayerID = 0
			self.PlayerIDA = 0
			self.PlayerIDB = 0
			return

			def GetLength(self):
			return sizeof(tagGCCrossChampionshipPKBattle)

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

			def OutputString(self):
			DumpString = '''// C0 15 跨服排位分区分组信息 //tagGCCrossChampionshipPKZoneGroupInfo:
			BattleNum:%d,
			WinPlayerID:%d,
			PlayerIDA:%d,
			PlayerIDB:%d
			'''\
			%(
			self.BattleNum,
			self.WinPlayerID,
			self.PlayerIDA,
			self.PlayerIDB
			)
			return DumpString


			class tagGCCrossChampionshipPKGroup(Structure):
			GroupMark = 0 #(DWORD GroupMark)// 战斗分区mark, 如 64、32、16、8、4-半决赛、2-决赛；
			BattleCount = 0 #(BYTE BattleCount)// 对战组数
			BattleList = list() #(vector<tagGCCrossChampionshipPKBattle> BattleList)// 对战组列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.GroupMark,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.BattleCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.BattleCount):
			temBattleList = tagGCCrossChampionshipPKBattle()
			_pos = temBattleList.ReadData(_lpData, _pos)
			self.BattleList.append(temBattleList)
			return _pos

			def Clear(self):
			self.GroupMark = 0
			self.BattleCount = 0
			self.BattleList = list()
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 1
			for i in range(self.BattleCount):
			length += self.BattleList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.GroupMark)
			data = CommFunc.WriteBYTE(data, self.BattleCount)
			for i in range(self.BattleCount):
			data = CommFunc.WriteString(data, self.BattleList[i].GetLength(), self.BattleList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			GroupMark:%d,
			BattleCount:%d,
			BattleList:%s
			'''\
			%(
			self.GroupMark,
			self.BattleCount,
			"..."
			)
			return DumpString


			class tagGCCrossChampionshipPKPlayer(Structure):
			PlayerID = 0 #(DWORD PlayerID)// 玩家ID
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)
			Job = 0 #(BYTE Job)
			LV = 0 #(WORD LV)
			FightPower = 0 #(DWORD FightPower)// 战力求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)// 战力整除亿部分
			RealmLV = 0 #(WORD RealmLV)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.Job,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.LV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RealmLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.NameLen = 0
			self.PlayerName = ""
			self.Job = 0
			self.LV = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			self.RealmLV = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteBYTE(data, self.Job)
			data = CommFunc.WriteWORD(data, self.LV)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteWORD(data, self.RealmLV)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			NameLen:%d,
			PlayerName:%s,
			Job:%d,
			LV:%d,
			FightPower:%d,
			FightPowerEx:%d,
			RealmLV:%d
			'''\
			%(
			self.PlayerID,
			self.NameLen,
			self.PlayerName,
			self.Job,
			self.LV,
			self.FightPower,
			self.FightPowerEx,
			self.RealmLV
			)
			return DumpString


			class tagGCCrossChampionshipPKZoneGroupInfo(Structure):
			Head = tagHead()
			ActID = 0 #(DWORD ActID)// 活动ID，活动ID不同则可重置前端排位赛相关缓存数据
			StateError = 0 #(BYTE StateError)// 本次活动是否已经出现流程状态异常；如服务器异常或维护服务器导致跳过步骤，则会废弃该次比赛，直到下次新活动；
			ZoneID = 0 #(BYTE ZoneID)// 排位分区ID
			PlayerCount = 0 #(BYTE PlayerCount)// 参赛玩家数
			PlayerList = list() #(vector<tagGCCrossChampionshipPKPlayer> PlayerList)
			GroupCount = 0 #(WORD GroupCount)
			GroupList = list() #(vector<tagGCCrossChampionshipPKGroup> GroupList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x15
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ActID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.StateError,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PlayerCount):
			temPlayerList = tagGCCrossChampionshipPKPlayer()
			_pos = temPlayerList.ReadData(_lpData, _pos)
			self.PlayerList.append(temPlayerList)
			self.GroupCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.GroupCount):
			temGroupList = tagGCCrossChampionshipPKGroup()
			_pos = temGroupList.ReadData(_lpData, _pos)
			self.GroupList.append(temGroupList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x15
			self.ActID = 0
			self.StateError = 0
			self.ZoneID = 0
			self.PlayerCount = 0
			self.PlayerList = list()
			self.GroupCount = 0
			self.GroupList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 1
			length += 1
			length += 1
			for i in range(self.PlayerCount):
			length += self.PlayerList[i].GetLength()
			length += 2
			for i in range(self.GroupCount):
			length += self.GroupList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.ActID)
			data = CommFunc.WriteBYTE(data, self.StateError)
			data = CommFunc.WriteBYTE(data, self.ZoneID)
			data = CommFunc.WriteBYTE(data, self.PlayerCount)
			for i in range(self.PlayerCount):
			data = CommFunc.WriteString(data, self.PlayerList[i].GetLength(), self.PlayerList[i].GetBuffer())
			data = CommFunc.WriteWORD(data, self.GroupCount)
			for i in range(self.GroupCount):
			data = CommFunc.WriteString(data, self.GroupList[i].GetLength(), self.GroupList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ActID:%d,
			StateError:%d,
			ZoneID:%d,
			PlayerCount:%d,
			PlayerList:%s,
			GroupCount:%d,
			GroupList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ActID,
			self.StateError,
			self.ZoneID,
			self.PlayerCount,
			"...",
			self.GroupCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -12281,6 +15409,684 @@


			#------------------------------------------------------
			# C0 11 跨服妖魔boss玩家伤害信息 #tagGCCrossYaomoBossPlayerHurtInfo

			class tagGCCrossYaomoBossPlayerHurtInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("HurtTotal", c_int), # 总伤害值，小于亿部分
			("HurtTotalEx", c_int), # 总伤害值，整除亿部分
			("AwardState", c_int), # 伤害目标值领奖状态，按奖励记录索引位运算判断是否已领取
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xC0
			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 = 0xC0
			self.SubCmd = 0x11
			self.HurtTotal = 0
			self.HurtTotalEx = 0
			self.AwardState = 0
			return

			def GetLength(self):
			return sizeof(tagGCCrossYaomoBossPlayerHurtInfo)

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

			def OutputString(self):
			DumpString = '''// C0 11 跨服妖魔boss玩家伤害信息 //tagGCCrossYaomoBossPlayerHurtInfo:
			Cmd:%s,
			SubCmd:%s,
			HurtTotal:%d,
			HurtTotalEx:%d,
			AwardState:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.HurtTotal,
			self.HurtTotalEx,
			self.AwardState
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 10 跨服所属分区信息 #tagGCCrossZoneInfo

			class tagGCCrossZoneInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("CommZoneID", c_ubyte), # 所属常规分区ID
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xC0
			self.SubCmd = 0x10
			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 = 0xC0
			self.SubCmd = 0x10
			self.CommZoneID = 0
			return

			def GetLength(self):
			return sizeof(tagGCCrossZoneInfo)

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

			def OutputString(self):
			DumpString = '''// C0 10 跨服所属分区信息 //tagGCCrossZoneInfo:
			Cmd:%s,
			SubCmd:%s,
			CommZoneID:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.CommZoneID
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 14 幸运云购开奖记录 #tagGCLuckyCloudBuyLotteryRecInfo

			class tagGCLuckyCloudBuyLotteryRec(Structure):
			SuperItemID = 0 #(DWORD SuperItemID)// 大奖物品ID
			SuperItemCount = 0 #(BYTE SuperItemCount)// 大奖物品个数
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)// 中奖玩家名
			LotteryNum = 0 #(WORD LotteryNum)// 开奖号码
			LotteryTime = 0 #(DWORD LotteryTime)// 开奖时间戳，秒
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.SuperItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.LotteryNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.LotteryTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.SuperItemID = 0
			self.SuperItemCount = 0
			self.NameLen = 0
			self.PlayerName = ""
			self.LotteryNum = 0
			self.LotteryTime = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.SuperItemID)
			data = CommFunc.WriteBYTE(data, self.SuperItemCount)
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteWORD(data, self.LotteryNum)
			data = CommFunc.WriteDWORD(data, self.LotteryTime)
			return data

			def OutputString(self):
			DumpString = '''
			SuperItemID:%d,
			SuperItemCount:%d,
			NameLen:%d,
			PlayerName:%s,
			LotteryNum:%d,
			LotteryTime:%d
			'''\
			%(
			self.SuperItemID,
			self.SuperItemCount,
			self.NameLen,
			self.PlayerName,
			self.LotteryNum,
			self.LotteryTime
			)
			return DumpString


			class tagGCLuckyCloudBuyLotteryRecInfo(Structure):
			Head = tagHead()
			ZoneCount = 0 #(BYTE ZoneCount)// 分区数
			ZoneIDList = list() #(vector<BYTE> ZoneIDList)// 所有分区ID列表
			ZoneID = 0 #(BYTE ZoneID)// 返回记录分区ID
			Count = 0 #(WORD Count)
			LotteryRecList = list() #(vector<tagGCLuckyCloudBuyLotteryRec> LotteryRecList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x14
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ZoneCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.ZoneCount):
			value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
			self.ZoneIDList.append(value)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temLotteryRecList = tagGCLuckyCloudBuyLotteryRec()
			_pos = temLotteryRecList.ReadData(_lpData, _pos)
			self.LotteryRecList.append(temLotteryRecList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x14
			self.ZoneCount = 0
			self.ZoneIDList = list()
			self.ZoneID = 0
			self.Count = 0
			self.LotteryRecList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ZoneCount:%d,
			ZoneIDList:%s,
			ZoneID:%d,
			Count:%d,
			LotteryRecList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ZoneCount,
			"...",
			self.ZoneID,
			self.Count,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 13 幸运云购购买号码记录 #tagGCLuckyCloudBuyNumRecInfo

			class tagGCLuckyCloudBuyNumRec(Structure):
			NameLen = 0 #(BYTE NameLen)
			PlayerName = "" #(String PlayerName)
			BuyNum = 0 #(WORD BuyNum)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.BuyNum,_pos = CommFunc.ReadWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.NameLen = 0
			self.PlayerName = ""
			self.BuyNum = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.PlayerName)
			data = CommFunc.WriteWORD(data, self.BuyNum)
			return data

			def OutputString(self):
			DumpString = '''
			NameLen:%d,
			PlayerName:%s,
			BuyNum:%d
			'''\
			%(
			self.NameLen,
			self.PlayerName,
			self.BuyNum
			)
			return DumpString


			class tagGCLuckyCloudBuyNumRecInfo(Structure):
			Head = tagHead()
			RemainCount = 0 #(WORD RemainCount)// 开奖剩余份数
			Count = 0 #(WORD Count)
			BuyNumRecList = list() #(vector<tagGCLuckyCloudBuyNumRec> BuyNumRecList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x13
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RemainCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temBuyNumRecList = tagGCLuckyCloudBuyNumRec()
			_pos = temBuyNumRecList.ReadData(_lpData, _pos)
			self.BuyNumRecList.append(temBuyNumRecList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x13
			self.RemainCount = 0
			self.Count = 0
			self.BuyNumRecList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# C0 12 幸运云购轮次信息 #tagGCLuckyCloudBuyRoundInfo

			class tagGCLuckyCloudBuyRoundItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemID", c_int),
			("ItemCount", c_ushort),
			("IsBind", 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.ItemID = 0
			self.ItemCount = 0
			self.IsBind = 0
			return

			def GetLength(self):
			return sizeof(tagGCLuckyCloudBuyRoundItem)

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

			def OutputString(self):
			DumpString = '''// C0 12 幸运云购轮次信息 //tagGCLuckyCloudBuyRoundInfo:
			ItemID:%d,
			ItemCount:%d,
			IsBind:%d
			'''\
			%(
			self.ItemID,
			self.ItemCount,
			self.IsBind
			)
			return DumpString


			class tagGCLuckyCloudBuyRoundTime(Structure):
			StartTime = "" #(char StartTime[5])// 开始时间 H:M
			EndtTime = "" #(char EndtTime[5])// 结束时间 H:M
			RoundMax = 0 #(BYTE RoundMax)// 本时段最大轮次
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
			self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)
			self.RoundMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.StartTime = ""
			self.EndtTime = ""
			self.RoundMax = 0
			return

			def GetLength(self):
			length = 0
			length += 5
			length += 5
			length += 1

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, 5, self.StartTime)
			data = CommFunc.WriteString(data, 5, self.EndtTime)
			data = CommFunc.WriteBYTE(data, self.RoundMax)
			return data

			def OutputString(self):
			DumpString = '''
			StartTime:%s,
			EndtTime:%s,
			RoundMax:%d
			'''\
			%(
			self.StartTime,
			self.EndtTime,
			self.RoundMax
			)
			return DumpString


			class tagGCLuckyCloudBuyRoundInfo(Structure):
			Head = tagHead()
			ZoneID = 0 #(BYTE ZoneID)// 所属分区ID
			StartDate = "" #(char StartDate[10])// 开始日期 y-m-d
			EndtDate = "" #(char EndtDate[10])// 结束日期 y-m-d
			RoundTimeCount = 0 #(BYTE RoundTimeCount)
			RoundTimeList = list() #(vector<tagGCLuckyCloudBuyRoundTime> RoundTimeList)//轮次时间段
			RoundID = 0 #(DWORD RoundID)// 轮次唯一ID标识，当收到的轮次ID变更时，前端需清空购买号码记录缓存
			RoundNum = 0 #(BYTE RoundNum)// 当前时段第几轮
			SuperItemID = 0 #(DWORD SuperItemID)// 大奖物品ID
			SuperItemCount = 0 #(BYTE SuperItemCount)// 大奖物品个数
			SuperItemMoneyType = 0 #(BYTE SuperItemMoneyType)// 大奖价值货币类型
			SuperItemMoneyValue = 0 #(DWORD SuperItemMoneyValue)// 大奖价值
			LVLimit = 0 #(WORD LVLimit)//开启等级
			BaseItemCount = 0 #(BYTE BaseItemCount)// 每次购买固定奖励物品数
			BaseItemList = list() #(vector<tagGCLuckyCloudBuyRoundItem> BaseItemList)// 每次购买固定奖励物品信息
			RandItemCount = 0 #(BYTE RandItemCount)// 每次购买随机奖励物品数
			RandItemList = list() #(vector<tagGCLuckyCloudBuyRoundItem> RandItemList)// 每次购买随机奖励物品信息
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.RoundTimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RoundTimeCount):
			temRoundTimeList = tagGCLuckyCloudBuyRoundTime()
			_pos = temRoundTimeList.ReadData(_lpData, _pos)
			self.RoundTimeList.append(temRoundTimeList)
			self.RoundID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RoundNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.SuperItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.SuperItemMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.SuperItemMoneyValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.LVLimit,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.BaseItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.BaseItemCount):
			temBaseItemList = tagGCLuckyCloudBuyRoundItem()
			_pos = temBaseItemList.ReadData(_lpData, _pos)
			self.BaseItemList.append(temBaseItemList)
			self.RandItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RandItemCount):
			temRandItemList = tagGCLuckyCloudBuyRoundItem()
			_pos = temRandItemList.ReadData(_lpData, _pos)
			self.RandItemList.append(temRandItemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x12
			self.ZoneID = 0
			self.StartDate = ""
			self.EndtDate = ""
			self.RoundTimeCount = 0
			self.RoundTimeList = list()
			self.RoundID = 0
			self.RoundNum = 0
			self.SuperItemID = 0
			self.SuperItemCount = 0
			self.SuperItemMoneyType = 0
			self.SuperItemMoneyValue = 0
			self.LVLimit = 0
			self.BaseItemCount = 0
			self.BaseItemList = list()
			self.RandItemCount = 0
			self.RandItemList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 10
			length += 10
			length += 1
			for i in range(self.RoundTimeCount):
			length += self.RoundTimeList[i].GetLength()
			length += 4
			length += 1
			length += 4
			length += 1
			length += 1
			length += 4
			length += 2
			length += 1
			for i in range(self.BaseItemCount):
			length += self.BaseItemList[i].GetLength()
			length += 1
			for i in range(self.RandItemCount):
			length += self.RandItemList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ZoneID)
			data = CommFunc.WriteString(data, 10, self.StartDate)
			data = CommFunc.WriteString(data, 10, self.EndtDate)
			data = CommFunc.WriteBYTE(data, self.RoundTimeCount)
			for i in range(self.RoundTimeCount):
			data = CommFunc.WriteString(data, self.RoundTimeList[i].GetLength(), self.RoundTimeList[i].GetBuffer())
			data = CommFunc.WriteDWORD(data, self.RoundID)
			data = CommFunc.WriteBYTE(data, self.RoundNum)
			data = CommFunc.WriteDWORD(data, self.SuperItemID)
			data = CommFunc.WriteBYTE(data, self.SuperItemCount)
			data = CommFunc.WriteBYTE(data, self.SuperItemMoneyType)
			data = CommFunc.WriteDWORD(data, self.SuperItemMoneyValue)
			data = CommFunc.WriteWORD(data, self.LVLimit)
			data = CommFunc.WriteBYTE(data, self.BaseItemCount)
			for i in range(self.BaseItemCount):
			data = CommFunc.WriteString(data, self.BaseItemList[i].GetLength(), self.BaseItemList[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.RandItemCount)
			for i in range(self.RandItemCount):
			data = CommFunc.WriteString(data, self.RandItemList[i].GetLength(), self.RandItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ZoneID:%d,
			StartDate:%s,
			EndtDate:%s,
			RoundTimeCount:%d,
			RoundTimeList:%s,
			RoundID:%d,
			RoundNum:%d,
			SuperItemID:%d,
			SuperItemCount:%d,
			SuperItemMoneyType:%d,
			SuperItemMoneyValue:%d,
			LVLimit:%d,
			BaseItemCount:%d,
			BaseItemList:%s,
			RandItemCount:%d,
			RandItemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ZoneID,
			self.StartDate,
			self.EndtDate,
			self.RoundTimeCount,
			"...",
			self.RoundID,
			self.RoundNum,
			self.SuperItemID,
			self.SuperItemCount,
			self.SuperItemMoneyType,
			self.SuperItemMoneyValue,
			self.LVLimit,
			self.BaseItemCount,
			"...",
			self.RandItemCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			#A1 25 请求切换地图失败#tagMCChangeMapFail

			class tagMCChangeMapFail(Structure):
			@@ -12337,6 +16143,8 @@
			("RecordID", c_ubyte),
			("TodayPayCount", c_ushort), # 今日已购买次数
			("TotalPayCount", c_int), # 累计总购买次数
			("WeekPayCount", c_ushort), # 周总购买次数
			("MonthPayCount", c_ushort), # 月总购买次数
			]

			def __init__(self):
			@@ -12352,6 +16160,8 @@
			self.RecordID = 0
			self.TodayPayCount = 0
			self.TotalPayCount = 0
			self.WeekPayCount = 0
			self.MonthPayCount = 0
			return

			def GetLength(self):
			@@ -12364,12 +16174,16 @@
			DumpString = '''// A1 10 充值购买次数信息 //tagMCCoinToGoldCountInfo:
			RecordID:%d,
			TodayPayCount:%d,
			TotalPayCount:%d
			TotalPayCount:%d,
			WeekPayCount:%d,
			MonthPayCount:%d
			'''\
			%(
			self.RecordID,
			self.TodayPayCount,
			self.TotalPayCount
			self.TotalPayCount,
			self.WeekPayCount,
			self.MonthPayCount
			)
			return DumpString

			@@ -14637,6 +18451,7 @@
			("KillCnt", c_int), #击杀次数
			("ItemAddCnt", c_int), #物品增加次数
			("BuyCnt", c_ubyte), #购买次数
			("KillCntTotal", c_int), #击杀次数 - 累计
			]

			def __init__(self):
			@@ -14653,6 +18468,7 @@
			self.KillCnt = 0
			self.ItemAddCnt = 0
			self.BuyCnt = 0
			self.KillCntTotal = 0
			return

			def GetLength(self):
			@@ -14666,13 +18482,15 @@
			BossType:%d,
			KillCnt:%d,
			ItemAddCnt:%d,
			BuyCnt:%d
			BuyCnt:%d,
			KillCntTotal:%d
			'''\
			%(
			self.BossType,
			self.KillCnt,
			self.ItemAddCnt,
			self.BuyCnt
			self.BuyCnt,
			self.KillCntTotal
			)
			return DumpString

			@@ -15095,6 +18913,118 @@

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


			#------------------------------------------------------
			# A3 CC 自定义奖励信息 #tagMCCustomAwardInfo

			class tagMCCustomAwardState(Structure):
			_pack_ = 1
			_fields_ = [
			("KeyNum", c_ushort), # 奖励记录key编号，0~255，每个key存31个ID记录 0-30为编号0, 31-61为编号1..
			("CanGetState", c_int), # 是否可领取；按位记录是否可领取
			("GetState", 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.KeyNum = 0
			self.CanGetState = 0
			self.GetState = 0
			return

			def GetLength(self):
			return sizeof(tagMCCustomAwardState)

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

			def OutputString(self):
			DumpString = '''// A3 CC 自定义奖励信息 //tagMCCustomAwardInfo:
			KeyNum:%d,
			CanGetState:%d,
			GetState:%d
			'''\
			%(
			self.KeyNum,
			self.CanGetState,
			self.GetState
			)
			return DumpString


			class tagMCCustomAwardInfo(Structure):
			Head = tagHead()
			RecordStateCnt = 0 #(WORD RecordStateCnt)// 记录个数
			RecordStateList = list() #(vector<tagMCCustomAwardState> RecordStateList)// 记录列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RecordStateCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.RecordStateCnt):
			temRecordStateList = tagMCCustomAwardState()
			_pos = temRecordStateList.ReadData(_lpData, _pos)
			self.RecordStateList.append(temRecordStateList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCC
			self.RecordStateCnt = 0
			self.RecordStateList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -16345,6 +20275,62 @@


			#------------------------------------------------------
			# A3 54 法器信息 #tagMCFaQiInfo

			class tagMCFaQiInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("LV", c_ubyte), #等阶
			("EatItemCount", c_int), #当前阶已吃丹个数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x54
			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 = 0x54
			self.LV = 0
			self.EatItemCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCFaQiInfo)

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

			def OutputString(self):
			DumpString = '''// A3 54 法器信息 //tagMCFaQiInfo:
			Cmd:%s,
			SubCmd:%s,
			LV:%d,
			EatItemCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.LV,
			self.EatItemCount
			)
			return DumpString


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


			#------------------------------------------------------
			#A3 0A 副本鼓舞信息通知 #tagMCFBEncourageInfo

			class tagMCFBEncourageCnt(Structure):
			@@ -17223,6 +21209,338 @@


			#------------------------------------------------------
			# A3 C7 古宝信息 #tagMCGubaoInfo

			class tagMCGubao(Structure):
			_pack_ = 1
			_fields_ = [
			("GubaoID", c_ushort),
			("GubaoStar", c_ubyte),
			("GubaoLV", 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.GubaoID = 0
			self.GubaoStar = 0
			self.GubaoLV = 0
			return

			def GetLength(self):
			return sizeof(tagMCGubao)

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

			def OutputString(self):
			DumpString = '''// A3 C7 古宝信息 //tagMCGubaoInfo:
			GubaoID:%d,
			GubaoStar:%d,
			GubaoLV:%d
			'''\
			%(
			self.GubaoID,
			self.GubaoStar,
			self.GubaoLV
			)
			return DumpString


			class tagMCGubaoInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			GubaoInfoList = list() #(vector<tagMCGubao> GubaoInfoList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xC7
			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):
			temGubaoInfoList = tagMCGubao()
			_pos = temGubaoInfoList.ReadData(_lpData, _pos)
			self.GubaoInfoList.append(temGubaoInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xC7
			self.Count = 0
			self.GubaoInfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.GubaoInfoList[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.GubaoInfoList[i].GetLength(), self.GubaoInfoList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# A3 CA 古宝物品特殊效果信息 #tagMCGubaoItemEffInfo

			class tagMCGubaoItemEff(Structure):
			_pack_ = 1
			_fields_ = [
			("GubaoID", c_ushort),
			("EffType", c_ubyte), # 不同古宝ID允许拥有相同效果类型，进度值每个古宝ID单独统计
			("EffValue", 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.GubaoID = 0
			self.EffType = 0
			self.EffValue = 0
			return

			def GetLength(self):
			return sizeof(tagMCGubaoItemEff)

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

			def OutputString(self):
			DumpString = '''// A3 CA 古宝物品特殊效果信息 //tagMCGubaoItemEffInfo:
			GubaoID:%d,
			EffType:%d,
			EffValue:%d
			'''\
			%(
			self.GubaoID,
			self.EffType,
			self.EffValue
			)
			return DumpString


			class tagMCGubaoItemEffInfo(Structure):
			Head = tagHead()
			Count = 0 #(WORD Count)
			ItemEffInfoList = list() #(vector<tagMCGubaoItemEff> ItemEffInfoList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCA
			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):
			temItemEffInfoList = tagMCGubaoItemEff()
			_pos = temItemEffInfoList.ReadData(_lpData, _pos)
			self.ItemEffInfoList.append(temItemEffInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCA
			self.Count = 0
			self.ItemEffInfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			for i in range(self.Count):
			length += self.ItemEffInfoList[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.ItemEffInfoList[i].GetLength(), self.ItemEffInfoList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# A3 CB 古宝碎片信息 #tagMCGubaoPieceInfo

			class tagMCGubaoPiece(Structure):
			_pack_ = 1
			_fields_ = [
			("GubaoID", c_ushort),
			("PieceCount", 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.GubaoID = 0
			self.PieceCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCGubaoPiece)

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

			def OutputString(self):
			DumpString = '''// A3 CB 古宝碎片信息 //tagMCGubaoPieceInfo:
			GubaoID:%d,
			PieceCount:%d
			'''\
			%(
			self.GubaoID,
			self.PieceCount
			)
			return DumpString


			class tagMCGubaoPieceInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			PieceInfoList = list() #(vector<tagMCGubaoPiece> PieceInfoList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCB
			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):
			temPieceInfoList = tagMCGubaoPiece()
			_pos = temPieceInfoList.ReadData(_lpData, _pos)
			self.PieceInfoList.append(temPieceInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCB
			self.Count = 0
			self.PieceInfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.PieceInfoList[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.PieceInfoList[i].GetLength(), self.PieceInfoList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# A3 28 历史累积充值奖励领取记录 #tagMCHistoryReChargeAwardRecord

			class tagMCHistoryReChargeAwardRecord(Structure):
			@@ -17395,6 +21713,222 @@


			#------------------------------------------------------
			# A3 10 通知坐骑幻化时效信息 #tagMCHorseSkinTimeInfoList

			class tagMCHorseSkinTimeInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("ID", c_int), # 对应坐骑幻化表ID
			("InvalidTime", 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.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.Star = 0
			return

			def GetLength(self):
			return sizeof(tagMCHorseStar)

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

			def OutputString(self):
			DumpString = '''// A3 CD 坐骑星级信息 //tagMCHorseStarInfo:
			HorseID:%d,
			Star:%d
			'''\
			%(
			self.HorseID,
			self.Star
			)
			return DumpString


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

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCD
			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):
			temHorseStarList = tagMCHorseStar()
			_pos = temHorseStarList.ReadData(_lpData, _pos)
			self.HorseStarList.append(temHorseStarList)
			return _pos

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

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.HorseStarList[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.HorseStarList[i].GetLength(), self.HorseStarList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# A3 38 投资理财信息 #tagMCInvestInfo

			class tagMCInvestInfo(Structure):
			@@ -17483,6 +22017,62 @@

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


			#------------------------------------------------------
			# A3 55 炼体信息 #tagMCLianTiInfo

			class tagMCLianTiInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("LianTiLV", c_ubyte), #炼体等级
			("EatItemCount", c_int), #当前等级已吃丹个数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x55
			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 = 0x55
			self.LianTiLV = 0
			self.EatItemCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCLianTiInfo)

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

			def OutputString(self):
			DumpString = '''// A3 55 炼体信息 //tagMCLianTiInfo:
			Cmd:%s,
			SubCmd:%s,
			LianTiLV:%d,
			EatItemCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.LianTiLV,
			self.EatItemCount
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -18491,6 +23081,7 @@
			ItemAddCnt = 0 #(WORD ItemAddCnt)//物品增加次数
			PassGradeCnt = 0 #(BYTE PassGradeCnt)//星级值对应个数, 每个key存9个lineID
			PassGrade = list() #(vector<DWORD> PassGrade)//副本线路对应星级值列表
			EnterCntTotal = 0 #(DWORD EnterCntTotal)//累计进入次数
			data = None

			def __init__(self):
			@@ -18507,6 +23098,7 @@
			for i in range(self.PassGradeCnt):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.PassGrade.append(value)
			self.EnterCntTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			@@ -18516,6 +23108,7 @@
			self.ItemAddCnt = 0
			self.PassGradeCnt = 0
			self.PassGrade = list()
			self.EnterCntTotal = 0
			return

			def GetLength(self):
			@@ -18526,6 +23119,7 @@
			length += 2
			length += 1
			length += 4 * self.PassGradeCnt
			length += 4

			return length

			@@ -18538,6 +23132,7 @@
			data = CommFunc.WriteBYTE(data, self.PassGradeCnt)
			for i in range(self.PassGradeCnt):
			data = CommFunc.WriteDWORD(data, self.PassGrade[i])
			data = CommFunc.WriteDWORD(data, self.EnterCntTotal)
			return data

			def OutputString(self):
			@@ -18547,7 +23142,8 @@
			RecoverCnt:%d,
			ItemAddCnt:%d,
			PassGradeCnt:%d,
			PassGrade:%s
			PassGrade:%s,
			EnterCntTotal:%d
			'''\
			%(
			self.FBID,
			@@ -18555,7 +23151,8 @@
			self.RecoverCnt,
			self.ItemAddCnt,
			self.PassGradeCnt,
			"..."
			"...",
			self.EnterCntTotal
			)
			return DumpString

			@@ -19340,6 +23937,185 @@


			#------------------------------------------------------
			# A3 C8 神通等级信息 #tagMCShentongLVInfo

			class tagMCShentongLV(Structure):
			_pack_ = 1
			_fields_ = [
			("ShentongID", c_ubyte),
			("ClassLV", c_ubyte),
			("LV", 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.ShentongID = 0
			self.ClassLV = 0
			self.LV = 0
			return

			def GetLength(self):
			return sizeof(tagMCShentongLV)

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

			def OutputString(self):
			DumpString = '''// A3 C8 神通等级信息 //tagMCShentongLVInfo:
			ShentongID:%d,
			ClassLV:%d,
			LV:%d
			'''\
			%(
			self.ShentongID,
			self.ClassLV,
			self.LV
			)
			return DumpString


			class tagMCShentongLVInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			ShentongLVList = list() #(vector<tagMCShentongLV> ShentongLVList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xC8
			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):
			temShentongLVList = tagMCShentongLV()
			_pos = temShentongLVList.ReadData(_lpData, _pos)
			self.ShentongLVList.append(temShentongLVList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xC8
			self.Count = 0
			self.ShentongLVList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.ShentongLVList[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.ShentongLVList[i].GetLength(), self.ShentongLVList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# A3 C9 神通技能设置信息 #tagMCShentongSkillInfo

			class tagMCShentongSkillInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			SkillIDList = list() #(vector<DWORD> SkillIDList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xC9
			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):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.SkillIDList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xC9
			self.Count = 0
			self.SkillIDList = list()
			return

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

			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.WriteDWORD(data, self.SkillIDList[i])
			return data

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


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


			#------------------------------------------------------
			# A3 44 当日累计充值多选一礼包信息 #tagMCSingleGoldGift

			class tagMCSingleGoldGift(Structure):
			@@ -19994,6 +24770,58 @@


			#------------------------------------------------------
			# A3 43 成就积分信息 #tagMCSuccessScoreInfo

			class tagMCSuccessScoreInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ScoreAwardState", c_int), #成就积分领奖记录，按奖励索引位记录是否领取
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x43
			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 = 0x43
			self.ScoreAwardState = 0
			return

			def GetLength(self):
			return sizeof(tagMCSuccessScoreInfo)

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

			def OutputString(self):
			DumpString = '''// A3 43 成就积分信息 //tagMCSuccessScoreInfo:
			Cmd:%s,
			SubCmd:%s,
			ScoreAwardState:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ScoreAwardState
			)
			return DumpString


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


			#------------------------------------------------------
			#A3 14 通知各功能的祝福值 #tagMCSyncBlessValue

			class tagMCSyncSingleBlessValue(Structure):
			@@ -20184,6 +25012,7 @@
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("IsPass", c_ubyte), #是否通关副本
			("XXZLAwardState", c_int), #修仙之路领奖状态；按二进制位存储每个任务ID是否已领取
			]

			def __init__(self):
			@@ -20201,6 +25030,7 @@
			self.Cmd = 0xA3
			self.SubCmd = 0x11
			self.IsPass = 0
			self.XXZLAwardState = 0
			return

			def GetLength(self):
			@@ -20213,12 +25043,14 @@
			DumpString = '''// A3 11 通知玩家境界信息 //tagMCSyncRealmInfo:
			Cmd:%s,
			SubCmd:%s,
			IsPass:%d
			IsPass:%d,
			XXZLAwardState:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.IsPass
			self.IsPass,
			self.XXZLAwardState
			)
			return DumpString

			@@ -20228,16 +25060,410 @@


			#------------------------------------------------------
			# A3 CE 称号星级信息 #tagMCTitleStarInfo

			class tagMCTitleStar(Structure):
			_pack_ = 1
			_fields_ = [
			("TitleID", 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.TitleID = 0
			self.Star = 0
			return

			def GetLength(self):
			return sizeof(tagMCTitleStar)

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

			def OutputString(self):
			DumpString = '''// A3 CE 称号星级信息 //tagMCTitleStarInfo:
			TitleID:%d,
			Star:%d
			'''\
			%(
			self.TitleID,
			self.Star
			)
			return DumpString


			class tagMCTitleStarInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			TitleStarList = list() #(vector<tagMCTitleStar> TitleStarList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCE
			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):
			temTitleStarList = tagMCTitleStar()
			_pos = temTitleStarList.ReadData(_lpData, _pos)
			self.TitleStarList.append(temTitleStarList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xCE
			self.Count = 0
			self.TitleStarList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.TitleStarList[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.TitleStarList[i].GetLength(), self.TitleStarList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# A3 56 通天令信息 #tagMCTongTianLingInfo

			class tagMCTongTianLingInfo(Structure):
			Head = tagHead()
			TTLBuyState = 0 #(BYTE TTLBuyState)//通天令是否已购买
			TTLLV = 0 #(BYTE TTLLV)//通天令等级，从0开始
			CurPoint = 0 #(DWORD CurPoint)//通天令当前等级经验积分点
			AwardStateCount = 0 #(BYTE AwardStateCount)//等级领奖记录值数，每个值存31个记录 0-30, 31-61, ...
			CommAwardStateList = list() #(vector<DWORD> CommAwardStateList)//常规奖励领奖记录，按等级二进制位存储是否领奖
			XianAwardStateList = list() #(vector<DWORD> XianAwardStateList)//仙品奖励领奖记录，按等级二进制位存储是否领奖
			StartTime = 0 #(DWORD StartTime)//通天令本轮开始时间戳，秒
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.TTLBuyState,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.TTLLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.CurPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.AwardStateCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.AwardStateCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.CommAwardStateList.append(value)
			for i in range(self.AwardStateCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.XianAwardStateList.append(value)
			self.StartTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x56
			self.TTLBuyState = 0
			self.TTLLV = 0
			self.CurPoint = 0
			self.AwardStateCount = 0
			self.CommAwardStateList = list()
			self.XianAwardStateList = list()
			self.StartTime = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.TTLBuyState)
			data = CommFunc.WriteBYTE(data, self.TTLLV)
			data = CommFunc.WriteDWORD(data, self.CurPoint)
			data = CommFunc.WriteBYTE(data, self.AwardStateCount)
			for i in range(self.AwardStateCount):
			data = CommFunc.WriteDWORD(data, self.CommAwardStateList[i])
			for i in range(self.AwardStateCount):
			data = CommFunc.WriteDWORD(data, self.XianAwardStateList[i])
			data = CommFunc.WriteDWORD(data, self.StartTime)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			TTLBuyState:%d,
			TTLLV:%d,
			CurPoint:%d,
			AwardStateCount:%d,
			CommAwardStateList:%s,
			XianAwardStateList:%s,
			StartTime:%d
			'''\
			%(
			self.Head.OutputString(),
			self.TTLBuyState,
			self.TTLLV,
			self.CurPoint,
			self.AwardStateCount,
			"...",
			"...",
			self.StartTime
			)
			return DumpString


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


			#------------------------------------------------------
			# A3 58 通天令任务奖励信息 #tagMCTongTianLingTaskAwardInfo

			class tagMCTongTianLingTaskAwardInfo(Structure):
			Head = tagHead()
			AwardStateCount = 0 #(BYTE AwardStateCount)
			TaskAwardStateList = list() #(vector<DWORD> TaskAwardStateList)//任务领奖记录值个数，按任务ID二进制位存储是否已领取，每个值存31个记录 0-30, 31-61, ...
			data = None

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

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x58
			self.AwardStateCount = 0
			self.TaskAwardStateList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# A3 57 通天令任务进度信息 #tagMCTongTianLingTaskValueInfo

			class tagMCTongTianLingTaskValue(Structure):
			_pack_ = 1
			_fields_ = [
			("TaskType", c_ubyte), #成就类型
			("IsDaily", c_ubyte), #是否每日任务
			("TaskValue", 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.TaskType = 0
			self.IsDaily = 0
			self.TaskValue = 0
			return

			def GetLength(self):
			return sizeof(tagMCTongTianLingTaskValue)

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

			def OutputString(self):
			DumpString = '''// A3 57 通天令任务进度信息 //tagMCTongTianLingTaskValueInfo:
			TaskType:%d,
			IsDaily:%d,
			TaskValue:%d
			'''\
			%(
			self.TaskType,
			self.IsDaily,
			self.TaskValue
			)
			return DumpString


			class tagMCTongTianLingTaskValueInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)//信息个数
			TaskValueList = list() #(vector<tagMCTongTianLingTaskValue> TaskValueList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x57
			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):
			temTaskValueList = tagMCTongTianLingTaskValue()
			_pos = temTaskValueList.ReadData(_lpData, _pos)
			self.TaskValueList.append(temTaskValueList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x57
			self.Count = 0
			self.TaskValueList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			for i in range(self.Count):
			length += self.TaskValueList[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.TaskValueList[i].GetLength(), self.TaskValueList[i].GetBuffer())
			return data

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


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


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

			class tagTrainHorseData(Structure):
			Head = tagHead()
			LV = 0 #(BYTE LV)//等阶
			EatItemCount = 0 #(DWORD EatItemCount)//当前阶已吃丹个数
			SkinPlusState = 0 #(DWORD SkinPlusState)//幻化激活状态，按位存储是否激活，幻化编号ID对应位
			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):
			@@ -20259,6 +25485,10 @@
			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):
			@@ -20272,6 +25502,8 @@
			self.TrainTypes = 0
			self.TrainLVList = list()
			self.TrainItemCountList = list()
			self.SkinPlusStateCount = 0
			self.SkinPlusStateList = list()
			return

			def GetLength(self):
			@@ -20283,6 +25515,8 @@
			length += 1
			length += 4 * self.TrainTypes
			length += 4 * self.TrainTypes
			length += 1
			length += 4 * self.SkinPlusStateCount

			return length

			@@ -20297,6 +25531,9 @@
			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):
			@@ -20307,7 +25544,9 @@
			SkinPlusState:%d,
			TrainTypes:%d,
			TrainLVList:%s,
			TrainItemCountList:%s
			TrainItemCountList:%s,
			SkinPlusStateCount:%d,
			SkinPlusStateList:%s
			'''\
			%(
			self.Head.OutputString(),
			@@ -20316,6 +25555,8 @@
			self.SkinPlusState,
			self.TrainTypes,
			"...",
			"...",
			self.SkinPlusStateCount,
			"..."
			)
			return DumpString
			@@ -21002,6 +26243,74 @@

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


			#------------------------------------------------------
			# 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


			#------------------------------------------------------
			@@ -24698,6 +30007,348 @@


			#------------------------------------------------------
			# AA 65 买一送多活动信息 #tagMCActBuyOneInfo

			class tagMCActBuyOneInfoFreeItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemID", c_int),
			("ItemCount", c_ushort),
			("IsBind", 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.ItemID = 0
			self.ItemCount = 0
			self.IsBind = 0
			return

			def GetLength(self):
			return sizeof(tagMCActBuyOneInfoFreeItem)

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

			def OutputString(self):
			DumpString = '''// AA 65 买一送多活动信息 //tagMCActBuyOneInfo:
			ItemID:%d,
			ItemCount:%d,
			IsBind:%d
			'''\
			%(
			self.ItemID,
			self.ItemCount,
			self.IsBind
			)
			return DumpString


			class tagMCActBuyOneInfoFreeGift(Structure):
			FreeIndex = 0 #(BYTE FreeIndex)// 免费领取索引
			FreeItemCount = 0 #(BYTE FreeItemCount)// 免费礼包数
			FreeItemList = list() #(vector<tagMCActBuyOneInfoFreeItem> FreeItemList)// 免费礼包列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.FreeIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.FreeItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FreeItemCount):
			temFreeItemList = tagMCActBuyOneInfoFreeItem()
			_pos = temFreeItemList.ReadData(_lpData, _pos)
			self.FreeItemList.append(temFreeItemList)
			return _pos

			def Clear(self):
			self.FreeIndex = 0
			self.FreeItemCount = 0
			self.FreeItemList = list()
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 1
			for i in range(self.FreeItemCount):
			length += self.FreeItemList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.FreeIndex)
			data = CommFunc.WriteBYTE(data, self.FreeItemCount)
			for i in range(self.FreeItemCount):
			data = CommFunc.WriteString(data, self.FreeItemList[i].GetLength(), self.FreeItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			FreeIndex:%d,
			FreeItemCount:%d,
			FreeItemList:%s
			'''\
			%(
			self.FreeIndex,
			self.FreeItemCount,
			"..."
			)
			return DumpString


			class tagMCActBuyOneInfoGiftbag(Structure):
			CTGID = 0 #(DWORD CTGID)//所需充值ID
			RecordIndex = 0 #(BYTE RecordIndex)// 记录索引
			FreeGiftCount = 0 #(BYTE FreeGiftCount)// 免费礼包数
			FreeGiftList = list() #(vector<tagMCActBuyOneInfoFreeGift> FreeGiftList)// 免费礼包列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.CTGID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RecordIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.FreeGiftCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FreeGiftCount):
			temFreeGiftList = tagMCActBuyOneInfoFreeGift()
			_pos = temFreeGiftList.ReadData(_lpData, _pos)
			self.FreeGiftList.append(temFreeGiftList)
			return _pos

			def Clear(self):
			self.CTGID = 0
			self.RecordIndex = 0
			self.FreeGiftCount = 0
			self.FreeGiftList = list()
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 1
			length += 1
			for i in range(self.FreeGiftCount):
			length += self.FreeGiftList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.CTGID)
			data = CommFunc.WriteBYTE(data, self.RecordIndex)
			data = CommFunc.WriteBYTE(data, self.FreeGiftCount)
			for i in range(self.FreeGiftCount):
			data = CommFunc.WriteString(data, self.FreeGiftList[i].GetLength(), self.FreeGiftList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			CTGID:%d,
			RecordIndex:%d,
			FreeGiftCount:%d,
			FreeGiftList:%s
			'''\
			%(
			self.CTGID,
			self.RecordIndex,
			self.FreeGiftCount,
			"..."
			)
			return DumpString


			class tagMCActBuyOneInfo(Structure):
			Head = tagHead()
			ActNum = 0 #(BYTE ActNum)//活动编号
			StartDate = "" #(char StartDate[10])// 开始日期 y-m-d
			EndtDate = "" #(char EndtDate[10])// 结束日期 y-m-d
			IsDayReset = 0 #(BYTE IsDayReset)//是否每天重置
			LimitLV = 0 #(WORD LimitLV)// 限制等级
			GiftbagCount = 0 #(BYTE GiftbagCount)// 活动礼包个数
			GiftbagList = list() #(vector<tagMCActBuyOneInfoGiftbag> GiftbagList)// 礼包列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x65
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.GiftbagCount):
			temGiftbagList = tagMCActBuyOneInfoGiftbag()
			_pos = temGiftbagList.ReadData(_lpData, _pos)
			self.GiftbagList.append(temGiftbagList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x65
			self.ActNum = 0
			self.StartDate = ""
			self.EndtDate = ""
			self.IsDayReset = 0
			self.LimitLV = 0
			self.GiftbagCount = 0
			self.GiftbagList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ActNum)
			data = CommFunc.WriteString(data, 10, self.StartDate)
			data = CommFunc.WriteString(data, 10, self.EndtDate)
			data = CommFunc.WriteBYTE(data, self.IsDayReset)
			data = CommFunc.WriteWORD(data, self.LimitLV)
			data = CommFunc.WriteBYTE(data, self.GiftbagCount)
			for i in range(self.GiftbagCount):
			data = CommFunc.WriteString(data, self.GiftbagList[i].GetLength(), self.GiftbagList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ActNum:%d,
			StartDate:%s,
			EndtDate:%s,
			IsDayReset:%d,
			LimitLV:%d,
			GiftbagCount:%d,
			GiftbagList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ActNum,
			self.StartDate,
			self.EndtDate,
			self.IsDayReset,
			self.LimitLV,
			self.GiftbagCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# AA 66 买一送多活动玩家信息 #tagMCActBuyOnePlayerInfo

			class tagMCActBuyOnePlayerInfo(Structure):
			Head = tagHead()
			ActNum = 0 #(BYTE ActNum)// 活动编号
			FreeRecordCount = 0 #(BYTE FreeRecordCount)// 免费礼包领奖记录个数
			FreeRecordList = list() #(vector<DWORD> FreeRecordList)// 免费礼包领奖记录列表，按所需充值ID记录索引取记录，每个记录代表每个充值ID对应免费礼包的领取记录，按免费领取索引位运算记录是否已领取
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x66
			return

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x66
			self.ActNum = 0
			self.FreeRecordCount = 0
			self.FreeRecordList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ActNum:%d,
			FreeRecordCount:%d,
			FreeRecordList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ActNum,
			self.FreeRecordCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# AA 40 集字活动信息 #tagMCActCollectWordsInfo

			class tagMCActCollectWordsNeedItem(Structure):
			@@ -25321,6 +30972,424 @@

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


			#------------------------------------------------------
			# AA 60 天帝礼包活动信息 #tagMCActGodGiftInfo

			class tagMCActGodGiftItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemNum", c_ubyte), # 物品在本库中的编号
			("ItemID", c_int),
			("ItemCount", c_ushort),
			("IsBind", c_ubyte),
			("CanChooseTimes", c_ubyte), #可选择次数，0代表不限次数
			("ChooseTimes", c_ubyte), #已选次数
			("IsChoose", 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.ItemNum = 0
			self.ItemID = 0
			self.ItemCount = 0
			self.IsBind = 0
			self.CanChooseTimes = 0
			self.ChooseTimes = 0
			self.IsChoose = 0
			return

			def GetLength(self):
			return sizeof(tagMCActGodGiftItem)

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

			def OutputString(self):
			DumpString = '''// AA 60 天帝礼包活动信息 //tagMCActGodGiftInfo:
			ItemNum:%d,
			ItemID:%d,
			ItemCount:%d,
			IsBind:%d,
			CanChooseTimes:%d,
			ChooseTimes:%d,
			IsChoose:%d
			'''\
			%(
			self.ItemNum,
			self.ItemID,
			self.ItemCount,
			self.IsBind,
			self.CanChooseTimes,
			self.ChooseTimes,
			self.IsChoose
			)
			return DumpString


			class tagMCActGodGiftItemLib(Structure):
			ItemLibType = 0 #(BYTE ItemLibType)//物品库类型
			NeedChooseCount = 0 #(BYTE NeedChooseCount)//需要选择个数
			GodGiftItemCount = 0 #(BYTE GodGiftItemCount)//可选择物品个数
			GodGiftItemList = list() #(vector<tagMCActGodGiftItem> GodGiftItemList)//可选物品列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.ItemLibType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.NeedChooseCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.GodGiftItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.GodGiftItemCount):
			temGodGiftItemList = tagMCActGodGiftItem()
			_pos = temGodGiftItemList.ReadData(_lpData, _pos)
			self.GodGiftItemList.append(temGodGiftItemList)
			return _pos

			def Clear(self):
			self.ItemLibType = 0
			self.NeedChooseCount = 0
			self.GodGiftItemCount = 0
			self.GodGiftItemList = list()
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 1
			length += 1
			for i in range(self.GodGiftItemCount):
			length += self.GodGiftItemList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.ItemLibType)
			data = CommFunc.WriteBYTE(data, self.NeedChooseCount)
			data = CommFunc.WriteBYTE(data, self.GodGiftItemCount)
			for i in range(self.GodGiftItemCount):
			data = CommFunc.WriteString(data, self.GodGiftItemList[i].GetLength(), self.GodGiftItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			ItemLibType:%d,
			NeedChooseCount:%d,
			GodGiftItemCount:%d,
			GodGiftItemList:%s
			'''\
			%(
			self.ItemLibType,
			self.NeedChooseCount,
			self.GodGiftItemCount,
			"..."
			)
			return DumpString


			class tagMCActGodGiftInfo(Structure):
			Head = tagHead()
			ActNum = 0 #(BYTE ActNum)// 活动编号
			StartDate = "" #(char StartDate[10])// 开始日期 y-m-d
			EndtDate = "" #(char EndtDate[10])// 结束日期 y-m-d
			IsDayReset = 0 #(BYTE IsDayReset)// 是否每日重置
			LimitLV = 0 #(WORD LimitLV)// 限制等级
			CostMoneyType = 0 #(BYTE CostMoneyType)//消耗货币类型
			CostMoneyValueCount = 0 #(BYTE CostMoneyValueCount)
			CostMoneyValueList = list() #(vector<DWORD> CostMoneyValueList)//消耗货币值列表
			PrizeMoneyType = 0 #(BYTE PrizeMoneyType)//奖励货币类型
			PrizeMoneyValueCount = 0 #(BYTE PrizeMoneyValueCount)
			PrizeMoneyValueList = list() #(vector<DWORD> PrizeMoneyValueList)//奖励货币值列表
			ResetLimitTimes = 0 #(BYTE ResetLimitTimes)//至少抽几次才可重置奖池
			ResetCountMax = 0 #(BYTE ResetCountMax)//最大可重置奖池次数
			IsAwardPoolOK = 0 #(BYTE IsAwardPoolOK)//奖池是否选择完毕，否的话需要先选择奖池才可抽奖
			ItemLibCount = 0 #(BYTE ItemLibCount)//奖池库个数
			ItemLibList = list() #(vector<tagMCActGodGiftItemLib> ItemLibList)//奖池库信息列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x60
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.CostMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.CostMoneyValueCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.CostMoneyValueCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.CostMoneyValueList.append(value)
			self.PrizeMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PrizeMoneyValueCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PrizeMoneyValueCount):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.PrizeMoneyValueList.append(value)
			self.ResetLimitTimes,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ResetCountMax,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.IsAwardPoolOK,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ItemLibCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.ItemLibCount):
			temItemLibList = tagMCActGodGiftItemLib()
			_pos = temItemLibList.ReadData(_lpData, _pos)
			self.ItemLibList.append(temItemLibList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x60
			self.ActNum = 0
			self.StartDate = ""
			self.EndtDate = ""
			self.IsDayReset = 0
			self.LimitLV = 0
			self.CostMoneyType = 0
			self.CostMoneyValueCount = 0
			self.CostMoneyValueList = list()
			self.PrizeMoneyType = 0
			self.PrizeMoneyValueCount = 0
			self.PrizeMoneyValueList = list()
			self.ResetLimitTimes = 0
			self.ResetCountMax = 0
			self.IsAwardPoolOK = 0
			self.ItemLibCount = 0
			self.ItemLibList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 10
			length += 10
			length += 1
			length += 2
			length += 1
			length += 1
			length += 4 * self.CostMoneyValueCount
			length += 1
			length += 1
			length += 4 * self.PrizeMoneyValueCount
			length += 1
			length += 1
			length += 1
			length += 1
			for i in range(self.ItemLibCount):
			length += self.ItemLibList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ActNum)
			data = CommFunc.WriteString(data, 10, self.StartDate)
			data = CommFunc.WriteString(data, 10, self.EndtDate)
			data = CommFunc.WriteBYTE(data, self.IsDayReset)
			data = CommFunc.WriteWORD(data, self.LimitLV)
			data = CommFunc.WriteBYTE(data, self.CostMoneyType)
			data = CommFunc.WriteBYTE(data, self.CostMoneyValueCount)
			for i in range(self.CostMoneyValueCount):
			data = CommFunc.WriteDWORD(data, self.CostMoneyValueList[i])
			data = CommFunc.WriteBYTE(data, self.PrizeMoneyType)
			data = CommFunc.WriteBYTE(data, self.PrizeMoneyValueCount)
			for i in range(self.PrizeMoneyValueCount):
			data = CommFunc.WriteDWORD(data, self.PrizeMoneyValueList[i])
			data = CommFunc.WriteBYTE(data, self.ResetLimitTimes)
			data = CommFunc.WriteBYTE(data, self.ResetCountMax)
			data = CommFunc.WriteBYTE(data, self.IsAwardPoolOK)
			data = CommFunc.WriteBYTE(data, self.ItemLibCount)
			for i in range(self.ItemLibCount):
			data = CommFunc.WriteString(data, self.ItemLibList[i].GetLength(), self.ItemLibList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ActNum:%d,
			StartDate:%s,
			EndtDate:%s,
			IsDayReset:%d,
			LimitLV:%d,
			CostMoneyType:%d,
			CostMoneyValueCount:%d,
			CostMoneyValueList:%s,
			PrizeMoneyType:%d,
			PrizeMoneyValueCount:%d,
			PrizeMoneyValueList:%s,
			ResetLimitTimes:%d,
			ResetCountMax:%d,
			IsAwardPoolOK:%d,
			ItemLibCount:%d,
			ItemLibList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ActNum,
			self.StartDate,
			self.EndtDate,
			self.IsDayReset,
			self.LimitLV,
			self.CostMoneyType,
			self.CostMoneyValueCount,
			"...",
			self.PrizeMoneyType,
			self.PrizeMoneyValueCount,
			"...",
			self.ResetLimitTimes,
			self.ResetCountMax,
			self.IsAwardPoolOK,
			self.ItemLibCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# AA 61 天帝礼包活动玩家信息 #tagMCActGodGiftPlayerInfo

			class tagMCActGodGiftAwardItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemLibType", c_ubyte), #物品库类型
			("ItemNum", 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.ItemLibType = 0
			self.ItemNum = 0
			return

			def GetLength(self):
			return sizeof(tagMCActGodGiftAwardItem)

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

			def OutputString(self):
			DumpString = '''// AA 61 天帝礼包活动玩家信息 //tagMCActGodGiftPlayerInfo:
			ItemLibType:%d,
			ItemNum:%d
			'''\
			%(
			self.ItemLibType,
			self.ItemNum
			)
			return DumpString


			class tagMCActGodGiftPlayerInfo(Structure):
			Head = tagHead()
			ActNum = 0 #(BYTE ActNum)// 活动编号
			ResetCount = 0 #(BYTE ResetCount)// 本次活动已重置次数
			AwardItemCount = 0 #(BYTE AwardItemCount)// 本次奖池已抽中奖品个数，也代表本次奖池已抽奖次数
			AwardItemList = list() #(vector<tagMCActGodGiftAwardItem> AwardItemList)// 本次奖池已抽中物品列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x61
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ResetCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.AwardItemCount):
			temAwardItemList = tagMCActGodGiftAwardItem()
			_pos = temAwardItemList.ReadData(_lpData, _pos)
			self.AwardItemList.append(temAwardItemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x61
			self.ActNum = 0
			self.ResetCount = 0
			self.AwardItemCount = 0
			self.AwardItemList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ActNum)
			data = CommFunc.WriteBYTE(data, self.ResetCount)
			data = CommFunc.WriteBYTE(data, self.AwardItemCount)
			for i in range(self.AwardItemCount):
			data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ActNum:%d,
			ResetCount:%d,
			AwardItemCount:%d,
			AwardItemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ActNum,
			self.ResetCount,
			self.AwardItemCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -26439,6 +32508,305 @@

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


			#------------------------------------------------------
			# AA 62 充值抵扣活动信息 #tagMCActRecharegeCouponInfo

			class tagMCActRecharegeCouponItem(Structure):
			_pack_ = 1
			_fields_ = [
			("ItemID", c_int),
			("ItemCount", c_ushort),
			("IsBind", c_ubyte),
			("IsMainItem", 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.ItemID = 0
			self.ItemCount = 0
			self.IsBind = 0
			self.IsMainItem = 0
			return

			def GetLength(self):
			return sizeof(tagMCActRecharegeCouponItem)

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

			def OutputString(self):
			DumpString = '''// AA 62 充值抵扣活动信息 //tagMCActRecharegeCouponInfo:
			ItemID:%d,
			ItemCount:%d,
			IsBind:%d,
			IsMainItem:%d
			'''\
			%(
			self.ItemID,
			self.ItemCount,
			self.IsBind,
			self.IsMainItem
			)
			return DumpString


			class tagMCActRecharegeCouponGiftbag(Structure):
			GiftID = 0 #(DWORD GiftID)//商城表的物品ID
			BuyCountLimit = 0 #(BYTE BuyCountLimit)//限购数
			MoneyType = 0 #(BYTE MoneyType)//消耗货币类型
			MoneyNumber = 0 #(DWORD MoneyNumber)//消耗货币数量
			MoneyOriginal = 0 #(DWORD MoneyOriginal)//原价
			GiftItemCount = 0 #(BYTE GiftItemCount)// 礼包物品数
			ItemInfo = list() #(vector<tagMCActRecharegeCouponItem> ItemInfo)// 物品信息
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.GiftID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.BuyCountLimit,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MoneyNumber,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MoneyOriginal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.GiftItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.GiftItemCount):
			temItemInfo = tagMCActRecharegeCouponItem()
			_pos = temItemInfo.ReadData(_lpData, _pos)
			self.ItemInfo.append(temItemInfo)
			return _pos

			def Clear(self):
			self.GiftID = 0
			self.BuyCountLimit = 0
			self.MoneyType = 0
			self.MoneyNumber = 0
			self.MoneyOriginal = 0
			self.GiftItemCount = 0
			self.ItemInfo = list()
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 1
			length += 1
			length += 4
			length += 4
			length += 1
			for i in range(self.GiftItemCount):
			length += self.ItemInfo[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.GiftID)
			data = CommFunc.WriteBYTE(data, self.BuyCountLimit)
			data = CommFunc.WriteBYTE(data, self.MoneyType)
			data = CommFunc.WriteDWORD(data, self.MoneyNumber)
			data = CommFunc.WriteDWORD(data, self.MoneyOriginal)
			data = CommFunc.WriteBYTE(data, self.GiftItemCount)
			for i in range(self.GiftItemCount):
			data = CommFunc.WriteString(data, self.ItemInfo[i].GetLength(), self.ItemInfo[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			GiftID:%d,
			BuyCountLimit:%d,
			MoneyType:%d,
			MoneyNumber:%d,
			MoneyOriginal:%d,
			GiftItemCount:%d,
			ItemInfo:%s
			'''\
			%(
			self.GiftID,
			self.BuyCountLimit,
			self.MoneyType,
			self.MoneyNumber,
			self.MoneyOriginal,
			self.GiftItemCount,
			"..."
			)
			return DumpString


			class tagMCActRecharegeCouponInfo(Structure):
			Head = tagHead()
			ActNum = 0 #(BYTE ActNum)//活动编号
			StartDate = "" #(char StartDate[10])// 开始日期 y-m-d
			EndtDate = "" #(char EndtDate[10])// 结束日期 y-m-d
			IsDayReset = 0 #(BYTE IsDayReset)//是否每天重置
			LimitLV = 0 #(WORD LimitLV)// 限制等级
			CouponMoneyType = 0 #(BYTE CouponMoneyType)//抵扣券对应货币类型
			GiftbagCount = 0 #(BYTE GiftbagCount)// 可购买礼包个数
			GiftbagList = list() #(vector<tagMCActRecharegeCouponGiftbag> GiftbagList)// 可购买礼包顺序列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x62
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.CouponMoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.GiftbagCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.GiftbagCount):
			temGiftbagList = tagMCActRecharegeCouponGiftbag()
			_pos = temGiftbagList.ReadData(_lpData, _pos)
			self.GiftbagList.append(temGiftbagList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x62
			self.ActNum = 0
			self.StartDate = ""
			self.EndtDate = ""
			self.IsDayReset = 0
			self.LimitLV = 0
			self.CouponMoneyType = 0
			self.GiftbagCount = 0
			self.GiftbagList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ActNum)
			data = CommFunc.WriteString(data, 10, self.StartDate)
			data = CommFunc.WriteString(data, 10, self.EndtDate)
			data = CommFunc.WriteBYTE(data, self.IsDayReset)
			data = CommFunc.WriteWORD(data, self.LimitLV)
			data = CommFunc.WriteBYTE(data, self.CouponMoneyType)
			data = CommFunc.WriteBYTE(data, self.GiftbagCount)
			for i in range(self.GiftbagCount):
			data = CommFunc.WriteString(data, self.GiftbagList[i].GetLength(), self.GiftbagList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ActNum:%d,
			StartDate:%s,
			EndtDate:%s,
			IsDayReset:%d,
			LimitLV:%d,
			CouponMoneyType:%d,
			GiftbagCount:%d,
			GiftbagList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ActNum,
			self.StartDate,
			self.EndtDate,
			self.IsDayReset,
			self.LimitLV,
			self.CouponMoneyType,
			self.GiftbagCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# AA 63 充值抵扣活动玩家信息 #tagMCActRecharegeCouponPlayerInfo

			class tagMCActRecharegeCouponPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ActNum", c_ubyte), # 活动编号
			("CouponMoney", c_int), # 当前可用抵扣点
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xAA
			self.SubCmd = 0x63
			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 = 0xAA
			self.SubCmd = 0x63
			self.ActNum = 0
			self.CouponMoney = 0
			return

			def GetLength(self):
			return sizeof(tagMCActRecharegeCouponPlayerInfo)

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

			def OutputString(self):
			DumpString = '''// AA 63 充值抵扣活动玩家信息 //tagMCActRecharegeCouponPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			ActNum:%d,
			CouponMoney:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ActNum,
			self.CouponMoney
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -29267,6 +35635,62 @@

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


			#------------------------------------------------------
			# AA 34 跨服全民充值活动玩家信息 #tagMCCrossActAllRechargePlayerInfo

			class tagMCCrossActAllRechargePlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("CTGRMBTotal", c_int), # 活动已累计充值RMB
			("AwardRecord", c_int), # 奖励记录，根据奖励索引位或运算判断是否已领取
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xAA
			self.SubCmd = 0x34
			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 = 0xAA
			self.SubCmd = 0x34
			self.CTGRMBTotal = 0
			self.AwardRecord = 0
			return

			def GetLength(self):
			return sizeof(tagMCCrossActAllRechargePlayerInfo)

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

			def OutputString(self):
			DumpString = '''// AA 34 跨服全民充值活动玩家信息 //tagMCCrossActAllRechargePlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			CTGRMBTotal:%d,
			AwardRecord:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.CTGRMBTotal,
			self.AwardRecord
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -35246,6 +41670,7 @@
			TodayExpPoint = 0 #(DWORD TodayExpPoint)
			YestordayExp = 0 #(DWORD YestordayExp)
			YestordayExpPoint = 0 #(DWORD YestordayExpPoint)
			TotalCount = 0 #(DWORD TotalCount)// 累计活跃放置次数
			data = None

			def __init__(self):
			@@ -35266,6 +41691,7 @@
			self.TodayExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.YestordayExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.YestordayExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TotalCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			@@ -35282,6 +41708,7 @@
			self.TodayExpPoint = 0
			self.YestordayExp = 0
			self.YestordayExpPoint = 0
			self.TotalCount = 0
			return

			def GetLength(self):
			@@ -35292,6 +41719,7 @@
			length += 1
			length += 1
			length += len(self.RewardInfo)
			length += 4
			length += 4
			length += 4
			length += 4
			@@ -35311,6 +41739,7 @@
			data = CommFunc.WriteDWORD(data, self.TodayExpPoint)
			data = CommFunc.WriteDWORD(data, self.YestordayExp)
			data = CommFunc.WriteDWORD(data, self.YestordayExpPoint)
			data = CommFunc.WriteDWORD(data, self.TotalCount)
			return data

			def OutputString(self):
			@@ -35324,7 +41753,8 @@
			TodayExp:%d,
			TodayExpPoint:%d,
			YestordayExp:%d,
			YestordayExpPoint:%d
			YestordayExpPoint:%d,
			TotalCount:%d
			'''\
			%(
			self.Head.OutputString(),
			@@ -35336,7 +41766,8 @@
			self.TodayExp,
			self.TodayExpPoint,
			self.YestordayExp,
			self.YestordayExpPoint
			self.YestordayExpPoint,
			self.TotalCount
			)
			return DumpString

			@@ -37527,19 +43958,15 @@
			#------------------------------------------------------
			# B2 13 天星塔通关层数 #tagMCSkyTowerInfo

			class tagMCSkyTowerInfo(Structure):
			class tagMCSkyTowerServerReward(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("Floor", c_int), # 已通关层
			("ServerRewardRecord", c_int), #全服挑战层领奖记录，按奖励记录二进制位存储是否已领取
			("Floor", c_int), # 全服奖励层ID
			("ServerRewardRecord", c_int), #该层全服领奖记录，按所需人数作为二进制位进行位运算判断是否已领取
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB2
			self.SubCmd = 0x13
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			@@ -37548,36 +43975,99 @@
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xB2
			self.SubCmd = 0x13
			self.Floor = 0
			self.ServerRewardRecord = 0
			return

			def GetLength(self):
			return sizeof(tagMCSkyTowerInfo)
			return sizeof(tagMCSkyTowerServerReward)

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

			def OutputString(self):
			DumpString = '''// B2 13 天星塔通关层数 //tagMCSkyTowerInfo:
			Cmd:%s,
			SubCmd:%s,
			Floor:%d,
			ServerRewardRecord:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Floor,
			self.ServerRewardRecord
			)
			return DumpString


			class tagMCSkyTowerInfo(Structure):
			Head = tagHead()
			Floor = 0 #(DWORD Floor)// 已通关层
			ServerRewardCount = 0 #(WORD ServerRewardCount)
			ServerRewardList = list() #(vector<tagMCSkyTowerServerReward> ServerRewardList)// 全服奖励领取记录列表，下发的层记录替换更新即可，领奖记录没有变化时服务端不会下发
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB2
			self.Head.SubCmd = 0x13
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Floor,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ServerRewardCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.ServerRewardCount):
			temServerRewardList = tagMCSkyTowerServerReward()
			_pos = temServerRewardList.ReadData(_lpData, _pos)
			self.ServerRewardList.append(temServerRewardList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB2
			self.Head.SubCmd = 0x13
			self.Floor = 0
			self.ServerRewardCount = 0
			self.ServerRewardList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.Floor)
			data = CommFunc.WriteWORD(data, self.ServerRewardCount)
			for i in range(self.ServerRewardCount):
			data = CommFunc.WriteString(data, self.ServerRewardList[i].GetLength(), self.ServerRewardList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Floor:%d,
			ServerRewardCount:%d,
			ServerRewardList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.Floor,
			self.ServerRewardCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -37761,6 +44251,114 @@

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


			#------------------------------------------------------
			# B3 27 情戒信息 #tagMCLoveRingInfo

			class tagMCLoveRingInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ClassLV", c_ubyte), # 阶
			("StarLV", c_ubyte), # 星
			("EatCount", c_int), # 本星已淬炼道具数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB3
			self.SubCmd = 0x27
			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 = 0xB3
			self.SubCmd = 0x27
			self.ClassLV = 0
			self.StarLV = 0
			self.EatCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCLoveRingInfo)

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

			def OutputString(self):
			DumpString = '''// B3 27 情戒信息 //tagMCLoveRingInfo:
			Cmd:%s,
			SubCmd:%s,
			ClassLV:%d,
			StarLV:%d,
			EatCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ClassLV,
			self.StarLV,
			self.EatCount
			)
			return DumpString


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


			#------------------------------------------------------
			# B3 29 情戒解锁成功 #tagMCLoveRingUnlockOK

			class tagMCLoveRingUnlockOK(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB3
			self.SubCmd = 0x29
			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 = 0xB3
			self.SubCmd = 0x29
			return

			def GetLength(self):
			return sizeof(tagMCLoveRingUnlockOK)

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

			def OutputString(self):
			DumpString = '''// B3 29 情戒解锁成功 //tagMCLoveRingUnlockOK:
			Cmd:%s,
			SubCmd:%s
			'''\
			%(
			self.Cmd,
			self.SubCmd
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -39294,6 +45892,126 @@


			#------------------------------------------------------
			# C1 09 跨服排位玩家信息 #tagMCChampionshipPlayerInfo

			class tagMCChampionshipPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("WorshipCount", c_ubyte), # 今日已膜拜次数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xC1
			self.SubCmd = 0x09
			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 = 0xC1
			self.SubCmd = 0x09
			self.WorshipCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCChampionshipPlayerInfo)

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

			def OutputString(self):
			DumpString = '''// C1 09 跨服排位玩家信息 //tagMCChampionshipPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			WorshipCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.WorshipCount
			)
			return DumpString


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


			#------------------------------------------------------
			# C1 07 跨服战场玩家信息 #tagMCCrossBattlefieldPlayerInfo

			class tagMCCrossBattlefieldPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("BuyOpenCountToday", c_ubyte), # 今日已购买开启战场次数
			("HighScoreToday", c_int), # 今日最高积分
			("EnterCountWeek", c_int), # 本周总参与次数
			("BuyOpenCountWeek", c_int), # 本周总购买召集次数
			("HighScoreTotalWeek", c_int), # 本周每日最高分累加总分
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xC1
			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 = 0xC1
			self.SubCmd = 0x07
			self.BuyOpenCountToday = 0
			self.HighScoreToday = 0
			self.EnterCountWeek = 0
			self.BuyOpenCountWeek = 0
			self.HighScoreTotalWeek = 0
			return

			def GetLength(self):
			return sizeof(tagMCCrossBattlefieldPlayerInfo)

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

			def OutputString(self):
			DumpString = '''// C1 07 跨服战场玩家信息 //tagMCCrossBattlefieldPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			BuyOpenCountToday:%d,
			HighScoreToday:%d,
			EnterCountWeek:%d,
			BuyOpenCountWeek:%d,
			HighScoreTotalWeek:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.BuyOpenCountToday,
			self.HighScoreToday,
			self.EnterCountWeek,
			self.BuyOpenCountWeek,
			self.HighScoreTotalWeek
			)
			return DumpString


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


			#------------------------------------------------------
			# C1 02 跨服PK玩家奖励记录 #tagMCCrossRealmPKAwardState

			class tagMCCrossRealmPKAwardState(Structure):
			@@ -39610,6 +46328,58 @@


			#------------------------------------------------------
			# C1 08 幸运云购玩家信息 #tagMCLuckyCloudBuyPlayerInfo

			class tagMCLuckyCloudBuyPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("BuyCount", c_ushort), # 本轮已购买份数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xC1
			self.SubCmd = 0x08
			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 = 0xC1
			self.SubCmd = 0x08
			self.BuyCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCLuckyCloudBuyPlayerInfo)

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

			def OutputString(self):
			DumpString = '''// C1 08 幸运云购玩家信息 //tagMCLuckyCloudBuyPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			BuyCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.BuyCount
			)
			return DumpString


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


			#------------------------------------------------------
			# C1 04 准备进入跨服服务器 #tagMCPrepareEnterCrossServer

			class tagMCPrepareEnterCrossServer(Structure):