SnxxServerCode.git

			@@ -5263,6 +5263,224 @@


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


			#------------------------------------------------------
			# AC 12 跨服运营活动结束 # tagGCCrossActEnd

			class tagGCCrossActEnd(Structure):
			@@ -12288,6 +12506,922 @@


			#------------------------------------------------------
			# 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):
			@@ -12753,6 +13887,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


			#------------------------------------------------------
			@@ -19248,6 +20805,114 @@


			#------------------------------------------------------
			# 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 38 投资理财信息 #tagMCInvestInfo

			class tagMCInvestInfo(Structure):
			@@ -22137,16 +23802,302 @@


			#------------------------------------------------------
			# 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):
			@@ -22168,6 +24119,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):
			@@ -22181,6 +24136,8 @@
			self.TrainTypes = 0
			self.TrainLVList = list()
			self.TrainItemCountList = list()
			self.SkinPlusStateCount = 0
			self.SkinPlusStateList = list()
			return

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

			return length

			@@ -22206,6 +24165,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):
			@@ -22216,7 +24178,9 @@
			SkinPlusState:%d,
			TrainTypes:%d,
			TrainLVList:%s,
			TrainItemCountList:%s
			TrainItemCountList:%s,
			SkinPlusStateCount:%d,
			SkinPlusStateList:%s
			'''\
			%(
			self.Head.OutputString(),
			@@ -22225,6 +24189,8 @@
			self.SkinPlusState,
			self.TrainTypes,
			"...",
			"...",
			self.SkinPlusStateCount,
			"..."
			)
			return DumpString
			@@ -27233,6 +29199,424 @@


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


			#------------------------------------------------------
			# AA 31 成长必买活动信息 #tagMCActGrowupBuyInfo

			class tagMCActGrowupBuyCTGItem(Structure):
			@@ -31176,6 +33560,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


			#------------------------------------------------------
			@@ -41311,6 +43751,58 @@


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