Project_SG_ServerCode.git

			@@ -193,6 +193,197 @@


			#------------------------------------------------------
			# A0 09 通用记录信息 #tagSCGameRecInfo

			class tagSCGameRec(Structure):
			Time = 0 #(DWORD Time)//时间
			Value1 = 0 #(DWORD Value1)//ֵ1
			Value2 = 0 #(DWORD Value2)//ֵ2
			Value3 = 0 #(DWORD Value3)//ֵ3
			Value4 = 0 #(DWORD Value4)//ֵ4
			Value5 = 0 #(DWORD Value5)//ֵ5
			Value6 = 0 #(DWORD Value6)//ֵ6
			Value7 = 0 #(DWORD Value7)//ֵ7
			Value8 = 0 #(DWORD Value8)//ֵ8
			UserDataLen = 0 #(WORD UserDataLen)//扩展数据长度
			UserData = "" #(String UserData)//扩展数据
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value7,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value8,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
			return _pos

			def Clear(self):
			self.Time = 0
			self.Value1 = 0
			self.Value2 = 0
			self.Value3 = 0
			self.Value4 = 0
			self.Value5 = 0
			self.Value6 = 0
			self.Value7 = 0
			self.Value8 = 0
			self.UserDataLen = 0
			self.UserData = ""
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.Time)
			data = CommFunc.WriteDWORD(data, self.Value1)
			data = CommFunc.WriteDWORD(data, self.Value2)
			data = CommFunc.WriteDWORD(data, self.Value3)
			data = CommFunc.WriteDWORD(data, self.Value4)
			data = CommFunc.WriteDWORD(data, self.Value5)
			data = CommFunc.WriteDWORD(data, self.Value6)
			data = CommFunc.WriteDWORD(data, self.Value7)
			data = CommFunc.WriteDWORD(data, self.Value8)
			data = CommFunc.WriteWORD(data, self.UserDataLen)
			data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
			return data

			def OutputString(self):
			DumpString = '''
			Time:%d,
			Value1:%d,
			Value2:%d,
			Value3:%d,
			Value4:%d,
			Value5:%d,
			Value6:%d,
			Value7:%d,
			Value8:%d,
			UserDataLen:%d,
			UserData:%s
			'''\
			%(
			self.Time,
			self.Value1,
			self.Value2,
			self.Value3,
			self.Value4,
			self.Value5,
			self.Value6,
			self.Value7,
			self.Value8,
			self.UserDataLen,
			self.UserData
			)
			return DumpString


			class tagSCGameRecInfo(Structure):
			Head = tagHead()
			RecType = 0 #(WORD RecType)//记录类型
			RecID = 0 #(DWORD RecID)//自定义记录ID
			Count = 0 #(WORD Count)//数量
			RecList = list() #(vector<tagSCGameRec> RecList)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RecType,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.RecID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temRecList = tagSCGameRec()
			_pos = temRecList.ReadData(_lpData, _pos)
			self.RecList.append(temRecList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA0
			self.Head.SubCmd = 0x09
			self.RecType = 0
			self.RecID = 0
			self.Count = 0
			self.RecList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# A0 07 副本地图功能线路人数 #tagGCFBLinePlayerCnt

			class tagGCFBLineInfo(Structure):
			@@ -421,190 +612,6 @@

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


			#------------------------------------------------------
			# A0 08 玩家记录信息 #tagGCPlayerRecInfo

			class tagGCPlayerRec(Structure):
			Time = 0 #(DWORD Time)//时间
			Value1 = 0 #(DWORD Value1)//ֵ1
			Value2 = 0 #(DWORD Value2)//ֵ2
			Value3 = 0 #(DWORD Value3)//ֵ3
			Value4 = 0 #(DWORD Value4)//ֵ4
			Value5 = 0 #(DWORD Value5)//ֵ5
			Value6 = 0 #(DWORD Value6)//ֵ6
			Value7 = 0 #(DWORD Value7)//ֵ7
			Value8 = 0 #(DWORD Value8)//ֵ8
			UserDataLen = 0 #(WORD UserDataLen)//扩展数据长度
			UserData = "" #(String UserData)//扩展数据
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value6,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value7,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value8,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.UserDataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.UserData,_pos = CommFunc.ReadString(_lpData, _pos,self.UserDataLen)
			return _pos

			def Clear(self):
			self.Time = 0
			self.Value1 = 0
			self.Value2 = 0
			self.Value3 = 0
			self.Value4 = 0
			self.Value5 = 0
			self.Value6 = 0
			self.Value7 = 0
			self.Value8 = 0
			self.UserDataLen = 0
			self.UserData = ""
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.Time)
			data = CommFunc.WriteDWORD(data, self.Value1)
			data = CommFunc.WriteDWORD(data, self.Value2)
			data = CommFunc.WriteDWORD(data, self.Value3)
			data = CommFunc.WriteDWORD(data, self.Value4)
			data = CommFunc.WriteDWORD(data, self.Value5)
			data = CommFunc.WriteDWORD(data, self.Value6)
			data = CommFunc.WriteDWORD(data, self.Value7)
			data = CommFunc.WriteDWORD(data, self.Value8)
			data = CommFunc.WriteWORD(data, self.UserDataLen)
			data = CommFunc.WriteString(data, self.UserDataLen, self.UserData)
			return data

			def OutputString(self):
			DumpString = '''
			Time:%d,
			Value1:%d,
			Value2:%d,
			Value3:%d,
			Value4:%d,
			Value5:%d,
			Value6:%d,
			Value7:%d,
			Value8:%d,
			UserDataLen:%d,
			UserData:%s
			'''\
			%(
			self.Time,
			self.Value1,
			self.Value2,
			self.Value3,
			self.Value4,
			self.Value5,
			self.Value6,
			self.Value7,
			self.Value8,
			self.UserDataLen,
			self.UserData
			)
			return DumpString


			class tagGCPlayerRecInfo(Structure):
			Head = tagHead()
			Type = 0 #(BYTE Type)//类型
			Count = 0 #(WORD Count)//数量
			PlayerRecList = list() #(vector<tagGCPlayerRec> PlayerRecList)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temPlayerRecList = tagGCPlayerRec()
			_pos = temPlayerRecList.ReadData(_lpData, _pos)
			self.PlayerRecList.append(temPlayerRecList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA0
			self.Head.SubCmd = 0x08
			self.Type = 0
			self.Count = 0
			self.PlayerRecList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -923,197 +930,6 @@

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


			#------------------------------------------------------
			#A0 03 玩家信息通用记录 #tagUniversalGameRecInfo

			class tagUniversalGameRec(Structure):
			Time = 0 #(DWORD Time)//时间
			StrValue1Len = 0 #(WORD StrValue1Len)//字符串1长度
			StrValue1 = "" #(String StrValue1)
			StrValue2Len = 0 #(WORD StrValue2Len)//字符串2长度
			StrValue2 = "" #(String StrValue2)
			StrValue3Len = 0 #(WORD StrValue3Len)//字符串3长度
			StrValue3 = "" #(String StrValue3)
			Value1 = 0 #(DWORD Value1)//数值1
			Value2 = 0 #(DWORD Value2)//数值1
			Value3 = 0 #(DWORD Value3)//数值1
			Value4 = 0 #(DWORD Value4)//数值1
			Value5 = 0 #(DWORD Value5)//数值1
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.StrValue1Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.StrValue1,_pos = CommFunc.ReadString(_lpData, _pos,self.StrValue1Len)
			self.StrValue2Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.StrValue2,_pos = CommFunc.ReadString(_lpData, _pos,self.StrValue2Len)
			self.StrValue3Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.StrValue3,_pos = CommFunc.ReadString(_lpData, _pos,self.StrValue3Len)
			self.Value1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value3,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value4,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Value5,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Time = 0
			self.StrValue1Len = 0
			self.StrValue1 = ""
			self.StrValue2Len = 0
			self.StrValue2 = ""
			self.StrValue3Len = 0
			self.StrValue3 = ""
			self.Value1 = 0
			self.Value2 = 0
			self.Value3 = 0
			self.Value4 = 0
			self.Value5 = 0
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 2
			length += len(self.StrValue1)
			length += 2
			length += len(self.StrValue2)
			length += 2
			length += len(self.StrValue3)
			length += 4
			length += 4
			length += 4
			length += 4
			length += 4

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.Time)
			data = CommFunc.WriteWORD(data, self.StrValue1Len)
			data = CommFunc.WriteString(data, self.StrValue1Len, self.StrValue1)
			data = CommFunc.WriteWORD(data, self.StrValue2Len)
			data = CommFunc.WriteString(data, self.StrValue2Len, self.StrValue2)
			data = CommFunc.WriteWORD(data, self.StrValue3Len)
			data = CommFunc.WriteString(data, self.StrValue3Len, self.StrValue3)
			data = CommFunc.WriteDWORD(data, self.Value1)
			data = CommFunc.WriteDWORD(data, self.Value2)
			data = CommFunc.WriteDWORD(data, self.Value3)
			data = CommFunc.WriteDWORD(data, self.Value4)
			data = CommFunc.WriteDWORD(data, self.Value5)
			return data

			def OutputString(self):
			DumpString = '''
			Time:%d,
			StrValue1Len:%d,
			StrValue1:%s,
			StrValue2Len:%d,
			StrValue2:%s,
			StrValue3Len:%d,
			StrValue3:%s,
			Value1:%d,
			Value2:%d,
			Value3:%d,
			Value4:%d,
			Value5:%d
			'''\
			%(
			self.Time,
			self.StrValue1Len,
			self.StrValue1,
			self.StrValue2Len,
			self.StrValue2,
			self.StrValue3Len,
			self.StrValue3,
			self.Value1,
			self.Value2,
			self.Value3,
			self.Value4,
			self.Value5
			)
			return DumpString


			class tagUniversalGameRecInfo(Structure):
			Head = tagHead()
			Type = 0 #(BYTE Type)//类型
			Count = 0 #(WORD Count)//数量
			UniversalGameRec = list() #(vector<tagUniversalGameRec> UniversalGameRec)///size = Count
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temUniversalGameRec = tagUniversalGameRec()
			_pos = temUniversalGameRec.ReadData(_lpData, _pos)
			self.UniversalGameRec.append(temUniversalGameRec)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA0
			self.Head.SubCmd = 0x03
			self.Type = 0
			self.Count = 0
			self.UniversalGameRec = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -3825,74 +3641,6 @@


			#------------------------------------------------------
			# A3 C3 竞技场玩家信息 #tagMCArenaPlayerInfo

			class tagMCArenaPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("IsReset", c_ubyte), #是否是重置的
			("Score", c_int), #当前积分
			("BattleCountToday", c_ubyte), #今日已挑战次数
			("MatchRefreshCount", c_ubyte), #当前已刷新匹配列表次数，每次挑战后会重置
			("ItemAddBattleCountToday", c_ubyte), #今日已使用物品增加的挑战次数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0xC3
			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 = 0xC3
			self.IsReset = 0
			self.Score = 0
			self.BattleCountToday = 0
			self.MatchRefreshCount = 0
			self.ItemAddBattleCountToday = 0
			return

			def GetLength(self):
			return sizeof(tagMCArenaPlayerInfo)

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

			def OutputString(self):
			DumpString = '''// A3 C3 竞技场玩家信息 //tagMCArenaPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			IsReset:%d,
			Score:%d,
			BattleCountToday:%d,
			MatchRefreshCount:%d,
			ItemAddBattleCountToday:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.IsReset,
			self.Score,
			self.BattleCountToday,
			self.MatchRefreshCount,
			self.ItemAddBattleCountToday
			)
			return DumpString


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


			#------------------------------------------------------
			# A3 0F 通知玩家悬赏任务信息 #tagMCArrestTaskInfo

			class tagMCArrestTaskInfo(Structure):
			@@ -4098,114 +3846,6 @@

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


			#------------------------------------------------------
			# A3 BD 通知玩家购买副本进入次数 #tagMCBuyEnterInfo

			class tagMCBuyInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("FBID", c_int), # 副本ID
			("BuyCount", c_ubyte), # 已购买次数
			]

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

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

			def Clear(self):
			self.FBID = 0
			self.BuyCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCBuyInfo)

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

			def OutputString(self):
			DumpString = '''// A3 BD 通知玩家购买副本进入次数 //tagMCBuyEnterInfo:
			FBID:%d,
			BuyCount:%d
			'''\
			%(
			self.FBID,
			self.BuyCount
			)
			return DumpString


			class tagMCBuyEnterInfo(Structure):
			Head = tagHead()
			FBCount = 0 #(BYTE FBCount)// 副本个数
			FBInfo = list() #(vector<tagMCBuyInfo> FBInfo)// 副本信息
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.FBCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FBCount):
			temFBInfo = tagMCBuyInfo()
			_pos = temFBInfo.ReadData(_lpData, _pos)
			self.FBInfo.append(temFBInfo)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0xBD
			self.FBCount = 0
			self.FBInfo = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -4567,69 +4207,18 @@


			#------------------------------------------------------
			# A3 15 日常活动次数通知 #tagMCDailyActionCnt
			#A3 0D 玩家签到信息记录 # tagSCDaySignInfo

			class tagMCDailyActionInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("ActionID", c_int), # ID
			("DayFinishCnt", c_ushort), # 今日已完成次数
			("DayBuyTimes", c_ubyte), # 今日购买次数
			("DayItemTimes", c_ubyte), # 今日物品增加次数
			("WeekFinishCnt", 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.ActionID = 0
			self.DayFinishCnt = 0
			self.DayBuyTimes = 0
			self.DayItemTimes = 0
			self.WeekFinishCnt = 0
			return

			def GetLength(self):
			return sizeof(tagMCDailyActionInfo)

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

			def OutputString(self):
			DumpString = '''// A3 15 日常活动次数通知 //tagMCDailyActionCnt:
			ActionID:%d,
			DayFinishCnt:%d,
			DayBuyTimes:%d,
			DayItemTimes:%d,
			WeekFinishCnt:%d
			'''\
			%(
			self.ActionID,
			self.DayFinishCnt,
			self.DayBuyTimes,
			self.DayItemTimes,
			self.WeekFinishCnt
			)
			return DumpString


			class tagMCDailyActionCnt(Structure):
			class tagSCDaySignInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)// 个数
			ActionInfo = list() #(vector<tagMCDailyActionInfo> ActionInfo)// 活动信息
			Count = 0 #(BYTE Count)
			SignStateList = list() #(vector<BYTE> SignStateList)//每日签到状态记录列表 [第1天状态, ...] 状态：0-不可签到；1-已签到；2-可补签；3-已领取
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			@@ -4637,26 +4226,24 @@
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temActionInfo = tagMCDailyActionInfo()
			_pos = temActionInfo.ReadData(_lpData, _pos)
			self.ActionInfo.append(temActionInfo)
			value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
			self.SignStateList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x15
			self.Head.SubCmd = 0x0D
			self.Count = 0
			self.ActionInfo = list()
			self.SignStateList = list()
			return

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

			return length

			@@ -4665,14 +4252,14 @@
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.ActionInfo[i].GetLength(), self.ActionInfo[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.SignStateList[i])
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			Count:%d,
			ActionInfo:%s
			SignStateList:%s
			'''\
			%(
			self.Head.OutputString(),
			@@ -4682,144 +4269,8 @@
			return DumpString


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


			#------------------------------------------------------
			#A3 33 玩家每日活跃度 #tagMCDailyActivityInfoList

			class tagMCDailyActivityInfoList(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("CurValue", c_int), # 当前总活跃度
			("RealmPoint", c_int), # 可领取修行点
			("StageIndex", c_ubyte), # 当前阶段索引
			("AwardRecord", c_int), # 领奖记录按位存储
			("ExtraPoint", c_int), # 多倍活动获得的额外修行点
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x33
			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 = 0x33
			self.CurValue = 0
			self.RealmPoint = 0
			self.StageIndex = 0
			self.AwardRecord = 0
			self.ExtraPoint = 0
			return

			def GetLength(self):
			return sizeof(tagMCDailyActivityInfoList)

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

			def OutputString(self):
			DumpString = '''//A3 33 玩家每日活跃度 //tagMCDailyActivityInfoList:
			Cmd:%s,
			SubCmd:%s,
			CurValue:%d,
			RealmPoint:%d,
			StageIndex:%d,
			AwardRecord:%d,
			ExtraPoint:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.CurValue,
			self.RealmPoint,
			self.StageIndex,
			self.AwardRecord,
			self.ExtraPoint
			)
			return DumpString


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


			#------------------------------------------------------
			#A3 0D 玩家签到信息记录 # tagMCDaySignInfo

			class tagMCDaySignInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("DaySignCount", c_ubyte), #已经签到天数
			("ReplenishSignCount", c_ubyte), # 可以补签天数
			("IsSign", c_ubyte), #当天是否已经签到,发送0和1
			("IsFrist", c_ubyte), #是否是第一个月
			("TotalSignCount", c_ushort), #累计总签到天数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xA3
			self.SubCmd = 0x0D
			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 = 0x0D
			self.DaySignCount = 0
			self.ReplenishSignCount = 0
			self.IsSign = 0
			self.IsFrist = 0
			self.TotalSignCount = 0
			return

			def GetLength(self):
			return sizeof(tagMCDaySignInfo)

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

			def OutputString(self):
			DumpString = '''//A3 0D 玩家签到信息记录 // tagMCDaySignInfo:
			Cmd:%s,
			SubCmd:%s,
			DaySignCount:%d,
			ReplenishSignCount:%d,
			IsSign:%d,
			IsFrist:%d,
			TotalSignCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.DaySignCount,
			self.ReplenishSignCount,
			self.IsSign,
			self.IsFrist,
			self.TotalSignCount
			)
			return DumpString


			m_NAtagMCDaySignInfo=tagMCDaySignInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCDaySignInfo.Cmd,m_NAtagMCDaySignInfo.SubCmd))] = m_NAtagMCDaySignInfo
			m_NAtagSCDaySignInfo=tagSCDaySignInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCDaySignInfo.Head.Cmd,m_NAtagSCDaySignInfo.Head.SubCmd))] = m_NAtagSCDaySignInfo


			#------------------------------------------------------
			@@ -5451,121 +4902,6 @@


			#------------------------------------------------------
			# A3 16 仙盟活跃信息通知 #tagMCFamilyActivityInfo

			class tagMCFamilyActionCnt(Structure):
			_pack_ = 1
			_fields_ = [
			("ActionID", c_ubyte), # ID
			("FinishCnt", c_ushort), # 已完成次数
			]

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

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

			def Clear(self):
			self.ActionID = 0
			self.FinishCnt = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyActionCnt)

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

			def OutputString(self):
			DumpString = '''// A3 16 仙盟活跃信息通知 //tagMCFamilyActivityInfo:
			ActionID:%d,
			FinishCnt:%d
			'''\
			%(
			self.ActionID,
			self.FinishCnt
			)
			return DumpString


			class tagMCFamilyActivityInfo(Structure):
			Head = tagHead()
			AwardRecord = 0 #(DWORD AwardRecord)// 领奖情况记录
			Count = 0 #(BYTE Count)// 个数
			InfoList = list() #(vector<tagMCFamilyActionCnt> InfoList)// 活动信息
			data = None

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

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x16
			self.AwardRecord = 0
			self.Count = 0
			self.InfoList = list()
			return

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

			return length

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

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


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


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

			class tagMCFaQiInfo(Structure):
			@@ -5622,111 +4958,162 @@


			#------------------------------------------------------
			#A3 0A 副本鼓舞信息通知 #tagMCFBEncourageInfo
			# A3 20 玩家副本相关信息 #tagSCFBInfoList

			class tagMCFBEncourageCnt(Structure):
			_pack_ = 1
			_fields_ = [
			("MoneyType", c_ubyte), # 金钱类型
			("EncourageCnt", c_ubyte), # 当前鼓舞次数
			]
			class tagSCFBInfo(Structure):
			MapID = 0 #(DWORD MapID)
			EnterCnt = 0 #(WORD EnterCnt)//今日累计进入次数
			ADAddCnt = 0 #(BYTE ADAddCnt)//广告增加次数
			BuyAddCnt = 0 #(BYTE BuyAddCnt)//购买增加次数
			ItemAddCnt = 0 #(WORD ItemAddCnt)//物品增加次数
			PassLineID = 0 #(DWORD PassLineID)//已过关到的lineID
			PassGradeCnt = 0 #(BYTE PassGradeCnt)//星级值对应个数, 每个key存9个lineID
			PassGrade = list() #(vector<DWORD> PassGrade)//副本线路对应星级值列表
			data = None

			def __init__(self):
			self.Clear()
			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()
			self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EnterCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.ADAddCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.BuyAddCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ItemAddCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.PassLineID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PassGradeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PassGradeCnt):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.PassGrade.append(value)
			return _pos

			def Clear(self):
			self.MoneyType = 0
			self.EncourageCnt = 0
			self.MapID = 0
			self.EnterCnt = 0
			self.ADAddCnt = 0
			self.BuyAddCnt = 0
			self.ItemAddCnt = 0
			self.PassLineID = 0
			self.PassGradeCnt = 0
			self.PassGrade = list()
			return

			def GetLength(self):
			return sizeof(tagMCFBEncourageCnt)
			length = 0
			length += 4
			length += 2
			length += 1
			length += 1
			length += 2
			length += 4
			length += 1
			length += 4 * self.PassGradeCnt

			return length

			def GetBuffer(self):
			return string_at(addressof(self), self.GetLength())
			data = ''
			data = CommFunc.WriteDWORD(data, self.MapID)
			data = CommFunc.WriteWORD(data, self.EnterCnt)
			data = CommFunc.WriteBYTE(data, self.ADAddCnt)
			data = CommFunc.WriteBYTE(data, self.BuyAddCnt)
			data = CommFunc.WriteWORD(data, self.ItemAddCnt)
			data = CommFunc.WriteDWORD(data, self.PassLineID)
			data = CommFunc.WriteBYTE(data, self.PassGradeCnt)
			for i in range(self.PassGradeCnt):
			data = CommFunc.WriteDWORD(data, self.PassGrade[i])
			return data

			def OutputString(self):
			DumpString = '''//A3 0A 副本鼓舞信息通知 //tagMCFBEncourageInfo:
			MoneyType:%d,
			EncourageCnt:%d
			DumpString = '''
			MapID:%d,
			EnterCnt:%d,
			ADAddCnt:%d,
			BuyAddCnt:%d,
			ItemAddCnt:%d,
			PassLineID:%d,
			PassGradeCnt:%d,
			PassGrade:%s
			'''\
			%(
			self.MoneyType,
			self.EncourageCnt
			self.MapID,
			self.EnterCnt,
			self.ADAddCnt,
			self.BuyAddCnt,
			self.ItemAddCnt,
			self.PassLineID,
			self.PassGradeCnt,
			"..."
			)
			return DumpString


			class tagMCFBEncourageInfo(Structure):
			class tagSCFBInfoList(Structure):
			Head = tagHead()
			Cnt = 0 #(BYTE Cnt)//
			InfoList = list() #(vector<tagMCFBEncourageCnt> InfoList)// 次数信息
			FBDataCnt = 0 #(BYTE FBDataCnt)// 副本数据个数
			FBDataList = list() #(vector<tagSCFBInfo> FBDataList)// 副本数据列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Cnt):
			temInfoList = tagMCFBEncourageCnt()
			_pos = temInfoList.ReadData(_lpData, _pos)
			self.InfoList.append(temInfoList)
			self.FBDataCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FBDataCnt):
			temFBDataList = tagSCFBInfo()
			_pos = temFBDataList.ReadData(_lpData, _pos)
			self.FBDataList.append(temFBDataList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x0A
			self.Cnt = 0
			self.InfoList = list()
			self.Head.SubCmd = 0x20
			self.FBDataCnt = 0
			self.FBDataList = list()
			return

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

			return length

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

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


			m_NAtagMCFBEncourageInfo=tagMCFBEncourageInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFBEncourageInfo.Head.Cmd,m_NAtagMCFBEncourageInfo.Head.SubCmd))] = m_NAtagMCFBEncourageInfo
			m_NAtagSCFBInfoList=tagSCFBInfoList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCFBInfoList.Head.Cmd,m_NAtagSCFBInfoList.Head.SubCmd))] = m_NAtagSCFBInfoList


			#------------------------------------------------------
			@@ -6381,58 +5768,6 @@


			#------------------------------------------------------
			# A3 B9 通知玩家今日抢红包次数 #tagMCGrabRedPacketCnt

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

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

			def GetLength(self):
			return sizeof(tagMCGrabRedPacketCnt)

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

			def OutputString(self):
			DumpString = '''// A3 B9 通知玩家今日抢红包次数 //tagMCGrabRedPacketCnt:
			Cmd:%s,
			SubCmd:%s,
			Cnt:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Cnt
			)
			return DumpString


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


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

			class tagMCGubao(Structure):
			@@ -6441,6 +5776,7 @@
			("GubaoID", c_ushort),
			("GubaoStar", c_ubyte),
			("GubaoLV", c_ubyte),
			("EffLayer", c_ubyte), # 该特殊效果累加层值
			]

			def __init__(self):
			@@ -6456,6 +5792,7 @@
			self.GubaoID = 0
			self.GubaoStar = 0
			self.GubaoLV = 0
			self.EffLayer = 0
			return

			def GetLength(self):
			@@ -6468,19 +5805,21 @@
			DumpString = '''// A3 C7 古宝信息 //tagMCGubaoInfo:
			GubaoID:%d,
			GubaoStar:%d,
			GubaoLV:%d
			GubaoLV:%d,
			EffLayer:%d
			'''\
			%(
			self.GubaoID,
			self.GubaoStar,
			self.GubaoLV
			self.GubaoLV,
			self.EffLayer
			)
			return DumpString


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

			@@ -6493,7 +5832,7 @@
			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temGubaoInfoList = tagMCGubao()
			_pos = temGubaoInfoList.ReadData(_lpData, _pos)
			@@ -6512,7 +5851,7 @@
			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 2
			for i in range(self.Count):
			length += self.GubaoInfoList[i].GetLength()

			@@ -6521,7 +5860,7 @@
			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.Count)
			data = CommFunc.WriteWORD(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.GubaoInfoList[i].GetLength(), self.GubaoInfoList[i].GetBuffer())
			return data
			@@ -6542,226 +5881,6 @@

			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


			#------------------------------------------------------
			@@ -8423,80 +7542,6 @@


			#------------------------------------------------------
			#A3 08 在线奖励信息 #tagMCOnlinePrize

			class tagMCOnlinePrize(Structure):
			Head = tagHead()
			OnlineTime = 0 #(DWORD OnlineTime)//在线时间毫秒
			Len = 0 #(BYTE Len)
			PrizeInfo = list() #(vector<DWORD> PrizeInfo)//领奖记录
			data = None

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

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x08
			self.OnlineTime = 0
			self.Len = 0
			self.PrizeInfo = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			OnlineTime:%d,
			Len:%d,
			PrizeInfo:%s
			'''\
			%(
			self.Head.OutputString(),
			self.OnlineTime,
			self.Len,
			"..."
			)
			return DumpString


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


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

			class tagMCPackDownloadRecord(Structure):
			@@ -8546,165 +7591,6 @@

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


			#------------------------------------------------------
			# A3 20 玩家副本相关信息 #tagMCPlayerFBInfoData

			class tagMCFBInfo(Structure):
			FBID = 0 #(DWORD FBID)//fbId
			EnterCnt = 0 #(WORD EnterCnt)//当日进入次数
			RecoverCnt = 0 #(WORD RecoverCnt)//找回次数
			ItemAddCnt = 0 #(WORD ItemAddCnt)//物品增加次数
			PassGradeCnt = 0 #(BYTE PassGradeCnt)//星级值对应个数, 每个key存9个lineID
			PassGrade = list() #(vector<DWORD> PassGrade)//副本线路对应星级值列表
			EnterCntTotal = 0 #(DWORD EnterCntTotal)//累计进入次数
			PassLineID = 0 #(DWORD PassLineID)//已过关到的lineID
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.FBID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EnterCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.RecoverCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.ItemAddCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.PassGradeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PassGradeCnt):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.PassGrade.append(value)
			self.EnterCntTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PassLineID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.FBID = 0
			self.EnterCnt = 0
			self.RecoverCnt = 0
			self.ItemAddCnt = 0
			self.PassGradeCnt = 0
			self.PassGrade = list()
			self.EnterCntTotal = 0
			self.PassLineID = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.FBID)
			data = CommFunc.WriteWORD(data, self.EnterCnt)
			data = CommFunc.WriteWORD(data, self.RecoverCnt)
			data = CommFunc.WriteWORD(data, self.ItemAddCnt)
			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)
			data = CommFunc.WriteDWORD(data, self.PassLineID)
			return data

			def OutputString(self):
			DumpString = '''
			FBID:%d,
			EnterCnt:%d,
			RecoverCnt:%d,
			ItemAddCnt:%d,
			PassGradeCnt:%d,
			PassGrade:%s,
			EnterCntTotal:%d,
			PassLineID:%d
			'''\
			%(
			self.FBID,
			self.EnterCnt,
			self.RecoverCnt,
			self.ItemAddCnt,
			self.PassGradeCnt,
			"...",
			self.EnterCntTotal,
			self.PassLineID
			)
			return DumpString


			class tagMCPlayerFBInfoData(Structure):
			Head = tagHead()
			FBDataCnt = 0 #(BYTE FBDataCnt)// 副本数据个数
			FBDataList = list() #(vector<tagMCFBInfo> FBDataList)// 副本数据列表
			data = None

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

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

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

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -8761,145 +7647,6 @@

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


			#------------------------------------------------------
			#A3 03 玩家在线奖励信息(暂停使用) #tagMCPlayerOnlinePrizeInfo

			class tagMCOnlinePrizeItem(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("PrizeItem", c_int),
			("ItemCount", c_ubyte),
			]

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

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

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

			def GetLength(self):
			return sizeof(tagMCOnlinePrizeItem)

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

			def OutputString(self):
			DumpString = '''//A3 03 玩家在线奖励信息(暂停使用) //tagMCPlayerOnlinePrizeInfo:
			Cmd:%s,
			SubCmd:%s,
			PrizeItem:%d,
			ItemCount:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.PrizeItem,
			self.ItemCount
			)
			return DumpString


			class tagMCPlayerOnlinePrizeInfo(Structure):
			Head = tagHead()
			RemaindTime = 0 #(DWORD RemaindTime)//产生奖励剩余时间
			HasPrize = 0 #(BYTE HasPrize)//是否可以领取
			PrizeType = 0 #(BYTE PrizeType)//在线奖励类型
			PrizeCnt = 0 #(BYTE PrizeCnt)//在线奖励类型
			PrizeInfo = list() #(vector<tagMCOnlinePrizeItem> PrizeInfo)//在线奖励类型
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RemaindTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HasPrize,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PrizeType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PrizeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PrizeCnt):
			temPrizeInfo = tagMCOnlinePrizeItem()
			_pos = temPrizeInfo.ReadData(_lpData, _pos)
			self.PrizeInfo.append(temPrizeInfo)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x03
			self.RemaindTime = 0
			self.HasPrize = 0
			self.PrizeType = 0
			self.PrizeCnt = 0
			self.PrizeInfo = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.RemaindTime)
			data = CommFunc.WriteBYTE(data, self.HasPrize)
			data = CommFunc.WriteBYTE(data, self.PrizeType)
			data = CommFunc.WriteBYTE(data, self.PrizeCnt)
			for i in range(self.PrizeCnt):
			data = CommFunc.WriteString(data, self.PrizeInfo[i].GetLength(), self.PrizeInfo[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			RemaindTime:%d,
			HasPrize:%d,
			PrizeType:%d,
			PrizeCnt:%d,
			PrizeInfo:%s
			'''\
			%(
			self.Head.OutputString(),
			self.RemaindTime,
			self.HasPrize,
			self.PrizeType,
			self.PrizeCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -9220,130 +7967,6 @@

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


			#------------------------------------------------------
			# A3 49 资源找回次数 #tagMCRecoverNum

			class tagMCRecoverNumInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Index", c_ubyte), # 找回项索引
			("RecoverCnt", c_ubyte), # 可找回次数
			("ExtraCnt", c_ubyte), # VIP额外次数
			("ExtraData", c_ubyte), # 额外参数1
			("ExtraData2", c_ubyte), # 额外参数2
			("HaveRecover", c_ubyte), # 已找回 1-全部已找回 2-非VIP已找回
			]

			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.Index = 0
			self.RecoverCnt = 0
			self.ExtraCnt = 0
			self.ExtraData = 0
			self.ExtraData2 = 0
			self.HaveRecover = 0
			return

			def GetLength(self):
			return sizeof(tagMCRecoverNumInfo)

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

			def OutputString(self):
			DumpString = '''// A3 49 资源找回次数 //tagMCRecoverNum:
			Index:%d,
			RecoverCnt:%d,
			ExtraCnt:%d,
			ExtraData:%d,
			ExtraData2:%d,
			HaveRecover:%d
			'''\
			%(
			self.Index,
			self.RecoverCnt,
			self.ExtraCnt,
			self.ExtraData,
			self.ExtraData2,
			self.HaveRecover
			)
			return DumpString


			class tagMCRecoverNum(Structure):
			Head = tagHead()
			Num = 0 #(BYTE Num)// 找回信息数
			NumInfo = list() #(vector<tagMCRecoverNumInfo> NumInfo)// 找回信息列表
			data = None

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

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

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

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -9962,66 +8585,13 @@


			#------------------------------------------------------
			# A3 41 成就完成 #tagMCSuccessFinish
			# A3 42 成就领奖记录列表 #tagSCSuccessAwardRecordList

			class tagMCSuccessFinish(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("SuccID", c_int), #成就id
			]

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

			def GetLength(self):
			return sizeof(tagMCSuccessFinish)

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

			def OutputString(self):
			DumpString = '''// A3 41 成就完成 //tagMCSuccessFinish:
			Cmd:%s,
			SubCmd:%s,
			SuccID:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.SuccID
			)
			return DumpString


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


			#------------------------------------------------------
			#A3 42 成就完成领奖记录列表 #tagMCSuccessFinishAwardRecordList

			class tagMCSuccessFinishAwardRecord(Structure):
			class tagSCSuccessAwardRecord(Structure):
			_pack_ = 1
			_fields_ = [
			("RecordIndex", c_ushort), #第几个记录值每个key存31个succid 0-30为0, 31-61为1..
			("Record", c_int), #对应是否领取值
			("PassportRecord", c_int), #通行证奖励是否领取值
			("Record", c_int), #根据成就ID位判断是否已领取
			]

			def __init__(self):
			@@ -10036,33 +8606,30 @@
			def Clear(self):
			self.RecordIndex = 0
			self.Record = 0
			self.PassportRecord = 0
			return

			def GetLength(self):
			return sizeof(tagMCSuccessFinishAwardRecord)
			return sizeof(tagSCSuccessAwardRecord)

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

			def OutputString(self):
			DumpString = '''//A3 42 成就完成领奖记录列表 //tagMCSuccessFinishAwardRecordList:
			DumpString = '''// A3 42 成就领奖记录列表 //tagSCSuccessAwardRecordList:
			RecordIndex:%d,
			Record:%d,
			PassportRecord:%d
			Record:%d
			'''\
			%(
			self.RecordIndex,
			self.Record,
			self.PassportRecord
			self.Record
			)
			return DumpString


			class tagMCSuccessFinishAwardRecordList(Structure):
			class tagSCSuccessAwardRecordList(Structure):
			Head = tagHead()
			RecordCnt = 0 #(WORD RecordCnt)//记录个数
			RecordList = list() #(vector<tagMCSuccessFinishAwardRecord> RecordList)//记录列表
			RecordList = list() #(vector<tagSCSuccessAwardRecord> RecordList)//记录列表
			data = None

			def __init__(self):
			@@ -10076,7 +8643,7 @@
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RecordCnt,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.RecordCnt):
			temRecordList = tagMCSuccessFinishAwardRecord()
			temRecordList = tagSCSuccessAwardRecord()
			_pos = temRecordList.ReadData(_lpData, _pos)
			self.RecordList.append(temRecordList)
			return _pos
			@@ -10121,18 +8688,18 @@
			return DumpString


			m_NAtagMCSuccessFinishAwardRecordList=tagMCSuccessFinishAwardRecordList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCSuccessFinishAwardRecordList.Head.Cmd,m_NAtagMCSuccessFinishAwardRecordList.Head.SubCmd))] = m_NAtagMCSuccessFinishAwardRecordList
			m_NAtagSCSuccessAwardRecordList=tagSCSuccessAwardRecordList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCSuccessAwardRecordList.Head.Cmd,m_NAtagSCSuccessAwardRecordList.Head.SubCmd))] = m_NAtagSCSuccessAwardRecordList


			#------------------------------------------------------
			# A3 40 成就信息列表 #tagMCSuccessInfoList
			# A3 40 成就信息列表 #tagSCSuccessInfoList

			class tagMCSuccessInfo(Structure):
			class tagSCSuccessInfo(Structure):
			SuccType = 0 #(WORD SuccType)//成就类型
			Len = 0 #(WORD Len)//条件长度
			Condition = "" #(String Condition)//成就条件
			CntValue = 0 #(DWORD CntValue)//当前完成进度值
			CLen = 0 #(BYTE CLen)
			Conds = list() #(vector<DWORD> Conds)// 条件列表
			CurValue = 0 #(DWORD CurValue)// 进度值，相同任务类型条件的进度值共享
			data = None

			def __init__(self):
			@@ -10142,23 +8709,25 @@
			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.SuccType,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Len,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Condition,_pos = CommFunc.ReadString(_lpData, _pos,self.Len)
			self.CntValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.CLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.CLen):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.Conds.append(value)
			self.CurValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.SuccType = 0
			self.Len = 0
			self.Condition = ""
			self.CntValue = 0
			self.CLen = 0
			self.Conds = list()
			self.CurValue = 0
			return

			def GetLength(self):
			length = 0
			length += 2
			length += 2
			length += len(self.Condition)
			length += 1
			length += 4 * self.CLen
			length += 4

			return length
			@@ -10166,31 +8735,32 @@
			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteWORD(data, self.SuccType)
			data = CommFunc.WriteWORD(data, self.Len)
			data = CommFunc.WriteString(data, self.Len, self.Condition)
			data = CommFunc.WriteDWORD(data, self.CntValue)
			data = CommFunc.WriteBYTE(data, self.CLen)
			for i in range(self.CLen):
			data = CommFunc.WriteDWORD(data, self.Conds[i])
			data = CommFunc.WriteDWORD(data, self.CurValue)
			return data

			def OutputString(self):
			DumpString = '''
			SuccType:%d,
			Len:%d,
			Condition:%s,
			CntValue:%d
			CLen:%d,
			Conds:%s,
			CurValue:%d
			'''\
			%(
			self.SuccType,
			self.Len,
			self.Condition,
			self.CntValue
			self.CLen,
			"...",
			self.CurValue
			)
			return DumpString


			class tagMCSuccessInfoList(Structure):
			class tagSCSuccessInfoList(Structure):
			Head = tagHead()
			count = 0 #(WORD count)//信息个数
			SuccessInfoList = list() #(vector<tagMCSuccessInfo> SuccessInfoList)
			Count = 0 #(WORD Count)//信息个数
			SuccessInfoList = list() #(vector<tagSCSuccessInfo> SuccessInfoList)
			data = None

			def __init__(self):
			@@ -10202,9 +8772,9 @@
			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):
			temSuccessInfoList = tagMCSuccessInfo()
			self.Count,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.Count):
			temSuccessInfoList = tagSCSuccessInfo()
			_pos = temSuccessInfoList.ReadData(_lpData, _pos)
			self.SuccessInfoList.append(temSuccessInfoList)
			return _pos
			@@ -10214,7 +8784,7 @@
			self.Head.Clear()
			self.Head.Cmd = 0xA3
			self.Head.SubCmd = 0x40
			self.count = 0
			self.Count = 0
			self.SuccessInfoList = list()
			return

			@@ -10222,7 +8792,7 @@
			length = 0
			length += self.Head.GetLength()
			length += 2
			for i in range(self.count):
			for i in range(self.Count):
			length += self.SuccessInfoList[i].GetLength()

			return length
			@@ -10230,79 +8800,27 @@
			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.WriteWORD(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.SuccessInfoList[i].GetLength(), self.SuccessInfoList[i].GetBuffer())
			return data

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


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


			#------------------------------------------------------
			# 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
			m_NAtagSCSuccessInfoList=tagSCSuccessInfoList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCSuccessInfoList.Head.Cmd,m_NAtagSCSuccessInfoList.Head.SubCmd))] = m_NAtagSCSuccessInfoList


			#------------------------------------------------------
			@@ -10600,114 +9118,6 @@

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


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


			#------------------------------------------------------
			@@ -12221,374 +10631,6 @@


			#------------------------------------------------------
			# A4 05 家族红包抢的信息 #tagGCFamilyRedPacketGrabInfo

			class tagFGrabRedPacketInfo(Structure):
			NameLen = 0 #(BYTE NameLen)
			Name = "" #(String Name)//名字
			PlayeJob = 0 #(BYTE PlayeJob)//玩家职业
			Face = 0 #(DWORD Face)//基本脸型
			FacePic = 0 #(DWORD FacePic)//头像框
			MoneyNum = 0 #(DWORD MoneyNum)//金钱数量
			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.PlayeJob,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MoneyNum,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.NameLen = 0
			self.Name = ""
			self.PlayeJob = 0
			self.Face = 0
			self.FacePic = 0
			self.MoneyNum = 0
			return

			def GetLength(self):
			length = 0
			length += 1
			length += len(self.Name)
			length += 1
			length += 4
			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.WriteBYTE(data, self.PlayeJob)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.MoneyNum)
			return data

			def OutputString(self):
			DumpString = '''
			NameLen:%d,
			Name:%s,
			PlayeJob:%d,
			Face:%d,
			FacePic:%d,
			MoneyNum:%d
			'''\
			%(
			self.NameLen,
			self.Name,
			self.PlayeJob,
			self.Face,
			self.FacePic,
			self.MoneyNum
			)
			return DumpString


			class tagGCFamilyRedPacketGrabInfo(Structure):
			Head = tagHead()
			RedPacketID = 0 #(DWORD RedPacketID)//红包唯一ID
			Count = 0 #(BYTE Count)//数量
			GrabInfo = list() #(vector<tagFGrabRedPacketInfo> GrabInfo)//size = Count
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RedPacketID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temGrabInfo = tagFGrabRedPacketInfo()
			_pos = temGrabInfo.ReadData(_lpData, _pos)
			self.GrabInfo.append(temGrabInfo)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA4
			self.Head.SubCmd = 0x05
			self.RedPacketID = 0
			self.Count = 0
			self.GrabInfo = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# A4 04 家族红包总信息 #tagGCFamilyRedPacketInfo

			class tagFRedPacketInfo(Structure):
			RedPacketID = 0 #(DWORD RedPacketID)//红包唯一ID
			PlayerID = 0 #(DWORD PlayerID)//玩家ID
			NameLen = 0 #(BYTE NameLen)
			Name = "" #(String Name)//玩家名字
			Time = 0 #(DWORD Time)//时间
			PlayeJob = 0 #(BYTE PlayeJob)//玩家职业
			Face = 0 #(DWORD Face)//基本脸型
			FacePic = 0 #(DWORD FacePic)//头像框
			MoneyType = 0 #(BYTE MoneyType)//金钱类型
			MoneyNum = 0 #(DWORD MoneyNum)//金钱数量
			GetWay = 0 #(BYTE GetWay)//获得途径
			PacketCnt = 0 #(BYTE PacketCnt)//可抢个数
			State = 0 #(BYTE State)//0未发,1未领取,2已领取,3全部领完
			WishLen = 0 #(BYTE WishLen)
			Wish = "" #(String Wish)//祝福语
			IsAnonymous = 0 #(BYTE IsAnonymous)//是否匿名
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.RedPacketID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Name,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PlayeJob,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MoneyNum,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.GetWay,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.PacketCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.State,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.WishLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Wish,_pos = CommFunc.ReadString(_lpData, _pos,self.WishLen)
			self.IsAnonymous,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.RedPacketID = 0
			self.PlayerID = 0
			self.NameLen = 0
			self.Name = ""
			self.Time = 0
			self.PlayeJob = 0
			self.Face = 0
			self.FacePic = 0
			self.MoneyType = 0
			self.MoneyNum = 0
			self.GetWay = 0
			self.PacketCnt = 0
			self.State = 0
			self.WishLen = 0
			self.Wish = ""
			self.IsAnonymous = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.RedPacketID)
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.Name)
			data = CommFunc.WriteDWORD(data, self.Time)
			data = CommFunc.WriteBYTE(data, self.PlayeJob)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteBYTE(data, self.MoneyType)
			data = CommFunc.WriteDWORD(data, self.MoneyNum)
			data = CommFunc.WriteBYTE(data, self.GetWay)
			data = CommFunc.WriteBYTE(data, self.PacketCnt)
			data = CommFunc.WriteBYTE(data, self.State)
			data = CommFunc.WriteBYTE(data, self.WishLen)
			data = CommFunc.WriteString(data, self.WishLen, self.Wish)
			data = CommFunc.WriteBYTE(data, self.IsAnonymous)
			return data

			def OutputString(self):
			DumpString = '''
			RedPacketID:%d,
			PlayerID:%d,
			NameLen:%d,
			Name:%s,
			Time:%d,
			PlayeJob:%d,
			Face:%d,
			FacePic:%d,
			MoneyType:%d,
			MoneyNum:%d,
			GetWay:%d,
			PacketCnt:%d,
			State:%d,
			WishLen:%d,
			Wish:%s,
			IsAnonymous:%d
			'''\
			%(
			self.RedPacketID,
			self.PlayerID,
			self.NameLen,
			self.Name,
			self.Time,
			self.PlayeJob,
			self.Face,
			self.FacePic,
			self.MoneyType,
			self.MoneyNum,
			self.GetWay,
			self.PacketCnt,
			self.State,
			self.WishLen,
			self.Wish,
			self.IsAnonymous
			)
			return DumpString


			class tagGCFamilyRedPacketInfo(Structure):
			Head = tagHead()
			IsAll = 0 #(BYTE IsAll)//是否全部红包
			Count = 0 #(BYTE Count)//红包数量
			RedPacketInfo = list() #(vector<tagFRedPacketInfo> RedPacketInfo)//size = Count
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.IsAll,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temRedPacketInfo = tagFRedPacketInfo()
			_pos = temRedPacketInfo.ReadData(_lpData, _pos)
			self.RedPacketInfo.append(temRedPacketInfo)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA4
			self.Head.SubCmd = 0x04
			self.IsAll = 0
			self.Count = 0
			self.RedPacketInfo = list()
			return

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

			return length

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

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


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


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

			class tagGCFamilyStoreItem(Structure):
			@@ -13712,6 +11754,73 @@


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

			class tagSCDonateCntInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			DonateCntList = list() #(vector<BYTE> DonateCntList)// 今日已捐献次数列表 [捐献类型1次数, ...]
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x02
			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.ReadBYTE(_lpData,_pos)
			self.DonateCntList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x02
			self.Count = 0
			self.DonateCntList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 1 * 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.WriteBYTE(data, self.DonateCntList[i])
			return data

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


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


			#------------------------------------------------------
			# A5 13 家族行为信息 #tagMCFamilyActionInfo

			class tagMCFamilyAction(Structure):
			@@ -13900,181 +12009,6 @@

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


			#------------------------------------------------------
			# A5 02 家族活跃令兑换结果 #tagMCFamilyActivityExchangeResult

			class tagMCFamilyActivityExchangeResult(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("Point", c_int), # 活跃令
			]

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

			def GetLength(self):
			return sizeof(tagMCFamilyActivityExchangeResult)

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

			def OutputString(self):
			DumpString = '''// A5 02 家族活跃令兑换结果 //tagMCFamilyActivityExchangeResult:
			Cmd:%s,
			SubCmd:%s,
			Point:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Point
			)
			return DumpString


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


			#------------------------------------------------------
			# A5 08 家族事务信息 #tagMCFamilyAffairInfo

			class tagMCFamilyAffair(Structure):
			_pack_ = 1
			_fields_ = [
			("AffairID", c_ushort), # 事务ID
			("Star", c_ubyte), # 星级
			("State", c_ubyte), # 状态：0-无；1-进行中；2-已完成
			("RemainDuration", c_ushort), # 剩余时长，秒，有剩余时间代表进行中
			]

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

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

			def Clear(self):
			self.AffairID = 0
			self.Star = 0
			self.State = 0
			self.RemainDuration = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyAffair)

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

			def OutputString(self):
			DumpString = '''// A5 08 家族事务信息 //tagMCFamilyAffairInfo:
			AffairID:%d,
			Star:%d,
			State:%d,
			RemainDuration:%d
			'''\
			%(
			self.AffairID,
			self.Star,
			self.State,
			self.RemainDuration
			)
			return DumpString


			class tagMCFamilyAffairInfo(Structure):
			Head = tagHead()
			RefreshFreeCount = 0 #(BYTE RefreshFreeCount)// 今日已免费刷新次数
			Count = 0 #(BYTE Count)
			AffairInfoList = list() #(vector<tagMCFamilyAffair> AffairInfoList)// 事务列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RefreshFreeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temAffairInfoList = tagMCFamilyAffair()
			_pos = temAffairInfoList.ReadData(_lpData, _pos)
			self.AffairInfoList.append(temAffairInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x08
			self.RefreshFreeCount = 0
			self.Count = 0
			self.AffairInfoList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -14306,62 +12240,6 @@


			#------------------------------------------------------
			# A5 05 通知家族钻石红包已用额度 #tagMCFamilyRedPacketGoldLimit

			class tagMCFamilyRedPacketGoldLimit(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("HasSendGold", c_int), # 已用额度
			("ServerGrabCnt", c_int), # 全服红包已抢次数
			]

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

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

			def Clear(self):
			self.Cmd = 0xA5
			self.SubCmd = 0x05
			self.HasSendGold = 0
			self.ServerGrabCnt = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyRedPacketGoldLimit)

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

			def OutputString(self):
			DumpString = '''// A5 05 通知家族钻石红包已用额度 //tagMCFamilyRedPacketGoldLimit:
			Cmd:%s,
			SubCmd:%s,
			HasSendGold:%d,
			ServerGrabCnt:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.HasSendGold,
			self.ServerGrabCnt
			)
			return DumpString


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


			#------------------------------------------------------
			# A5 22 家族申请加入的玩家信息 #tagMCFamilyReqJoinInfo

			class tagMCFamilyReqJoinPlayer(Structure):
			@@ -14374,6 +12252,7 @@
			RealmLV = 0 #(BYTE RealmLV)//境界
			Face = 0 #(DWORD Face)//基本脸型
			FacePic = 0 #(DWORD FacePic)//头像框
			TitleID = 0 #(DWORD TitleID)//称号
			FightPower = 0 #(DWORD FightPower)//战力，求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力，整除亿部分
			ServerID = 0 #(DWORD ServerID)//所属区服ID
			@@ -14395,6 +12274,7 @@
			self.RealmLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TitleID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			@@ -14411,6 +12291,7 @@
			self.RealmLV = 0
			self.Face = 0
			self.FacePic = 0
			self.TitleID = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			self.ServerID = 0
			@@ -14431,6 +12312,7 @@
			length += 4
			length += 4
			length += 4
			length += 4
			length += 1

			return length
			@@ -14446,6 +12328,7 @@
			data = CommFunc.WriteBYTE(data, self.RealmLV)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.TitleID)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteDWORD(data, self.ServerID)
			@@ -14463,6 +12346,7 @@
			RealmLV:%d,
			Face:%d,
			FacePic:%d,
			TitleID:%d,
			FightPower:%d,
			FightPowerEx:%d,
			ServerID:%d,
			@@ -14478,6 +12362,7 @@
			self.RealmLV,
			self.Face,
			self.FacePic,
			self.TitleID,
			self.FightPower,
			self.FightPowerEx,
			self.ServerID,
			@@ -14616,6 +12501,7 @@
			# A5 23 搜索家族返回列表 #tagMCFamilyViewList

			class tagMCFamilyView(Structure):
			Rank = 0 #(WORD Rank)//名次，从1开始
			FamilyID = 0 #(DWORD FamilyID)//家族ID
			FamilyNameLen = 0 #(BYTE FamilyNameLen)
			FamilyName = "" #(String FamilyName)//size = FamilyNameLen
			@@ -14627,6 +12513,7 @@
			JoinLVMin = 0 #(WORD JoinLVMin)//限制最低可加入的玩家等级
			ServerID = 0 #(DWORD ServerID)//区服ID
			EmblemID = 0 #(DWORD EmblemID)//徽章ID
			EmblemWord = "" #(char EmblemWord[3])//徽章文字
			FightPower = 0 #(DWORD FightPower)//总战力，求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//总战力，整除亿部分
			MemberCount = 0 #(BYTE MemberCount)//成员人数
			@@ -14638,6 +12525,7 @@

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.Rank,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FamilyNameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.FamilyName,_pos = CommFunc.ReadString(_lpData, _pos,self.FamilyNameLen)
			@@ -14649,12 +12537,14 @@
			self.JoinLVMin,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EmblemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EmblemWord,_pos = CommFunc.ReadString(_lpData, _pos,3)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MemberCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Rank = 0
			self.FamilyID = 0
			self.FamilyNameLen = 0
			self.FamilyName = ""
			@@ -14666,6 +12556,7 @@
			self.JoinLVMin = 0
			self.ServerID = 0
			self.EmblemID = 0
			self.EmblemWord = ""
			self.FightPower = 0
			self.FightPowerEx = 0
			self.MemberCount = 0
			@@ -14673,6 +12564,7 @@

			def GetLength(self):
			length = 0
			length += 2
			length += 4
			length += 1
			length += len(self.FamilyName)
			@@ -14684,6 +12576,7 @@
			length += 2
			length += 4
			length += 4
			length += 3
			length += 4
			length += 4
			length += 1
			@@ -14692,6 +12585,7 @@

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteWORD(data, self.Rank)
			data = CommFunc.WriteDWORD(data, self.FamilyID)
			data = CommFunc.WriteBYTE(data, self.FamilyNameLen)
			data = CommFunc.WriteString(data, self.FamilyNameLen, self.FamilyName)
			@@ -14703,6 +12597,7 @@
			data = CommFunc.WriteWORD(data, self.JoinLVMin)
			data = CommFunc.WriteDWORD(data, self.ServerID)
			data = CommFunc.WriteDWORD(data, self.EmblemID)
			data = CommFunc.WriteString(data, 3, self.EmblemWord)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteBYTE(data, self.MemberCount)
			@@ -14710,6 +12605,7 @@

			def OutputString(self):
			DumpString = '''
			Rank:%d,
			FamilyID:%d,
			FamilyNameLen:%d,
			FamilyName:%s,
			@@ -14721,11 +12617,13 @@
			JoinLVMin:%d,
			ServerID:%d,
			EmblemID:%d,
			EmblemWord:%s,
			FightPower:%d,
			FightPowerEx:%d,
			MemberCount:%d
			'''\
			%(
			self.Rank,
			self.FamilyID,
			self.FamilyNameLen,
			self.FamilyName,
			@@ -14737,6 +12635,7 @@
			self.JoinLVMin,
			self.ServerID,
			self.EmblemID,
			self.EmblemWord,
			self.FightPower,
			self.FightPowerEx,
			self.MemberCount
			@@ -15088,114 +12987,6 @@


			#------------------------------------------------------
			# A5 04 玩家战盟科技等级 #tagMCPlayerTechInfo

			class tagMCPlayerTech(Structure):
			_pack_ = 1
			_fields_ = [
			("TechID", c_ushort), # 科技ID
			("TechLV", c_ushort), # 特技等级
			]

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

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

			def Clear(self):
			self.TechID = 0
			self.TechLV = 0
			return

			def GetLength(self):
			return sizeof(tagMCPlayerTech)

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

			def OutputString(self):
			DumpString = '''// A5 04 玩家战盟科技等级 //tagMCPlayerTechInfo:
			TechID:%d,
			TechLV:%d
			'''\
			%(
			self.TechID,
			self.TechLV
			)
			return DumpString


			class tagMCPlayerTechInfo(Structure):
			Head = tagHead()
			TechCnt = 0 #(BYTE TechCnt)// 科技个数
			TechInfoList = list() #(vector<tagMCPlayerTech> TechInfoList)// 科技信息列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.TechCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.TechCnt):
			temTechInfoList = tagMCPlayerTech()
			_pos = temTechInfoList.ReadData(_lpData, _pos)
			self.TechInfoList.append(temTechInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA5
			self.Head.SubCmd = 0x04
			self.TechCnt = 0
			self.TechInfoList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# A5 20 玩家家族信息 #tagMCRoleFamilyInfo

			class tagMCRoleFamilyMember(Structure):
			@@ -15209,11 +13000,14 @@
			RealmLV = 0 #(BYTE RealmLV)//境界
			Face = 0 #(DWORD Face)//基本脸型
			FacePic = 0 #(DWORD FacePic)//头像框
			TitleID = 0 #(DWORD TitleID)//称号
			FightPower = 0 #(DWORD FightPower)//战力，求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力，整除亿部分
			ServerID = 0 #(DWORD ServerID)//所属区服ID
			ContribTotal = 0 #(DWORD ContribTotal)//总贡献度
			ContribWeek = 0 #(DWORD ContribWeek)//周贡献度
			ContribDay = 0 #(DWORD ContribDay)//日贡献度
			DonateCntTotal = 0 #(DWORD DonateCntTotal)//总捐献次数
			DonateCntDay = 0 #(BYTE DonateCntDay)//日捐献次数
			OffTime = 0 #(DWORD OffTime)// 0-在线; >0-/离线时间戳
			data = None

			@@ -15233,11 +13027,14 @@
			self.RealmLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TitleID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ContribTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ContribWeek,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ContribDay,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.DonateCntTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.DonateCntDay,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.OffTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			@@ -15252,11 +13049,14 @@
			self.RealmLV = 0
			self.Face = 0
			self.FacePic = 0
			self.TitleID = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			self.ServerID = 0
			self.ContribTotal = 0
			self.ContribWeek = 0
			self.ContribDay = 0
			self.DonateCntTotal = 0
			self.DonateCntDay = 0
			self.OffTime = 0
			return

			@@ -15278,6 +13078,9 @@
			length += 4
			length += 4
			length += 4
			length += 4
			length += 1
			length += 4

			return length

			@@ -15293,11 +13096,14 @@
			data = CommFunc.WriteBYTE(data, self.RealmLV)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.TitleID)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteDWORD(data, self.ServerID)
			data = CommFunc.WriteDWORD(data, self.ContribTotal)
			data = CommFunc.WriteDWORD(data, self.ContribWeek)
			data = CommFunc.WriteDWORD(data, self.ContribDay)
			data = CommFunc.WriteDWORD(data, self.DonateCntTotal)
			data = CommFunc.WriteBYTE(data, self.DonateCntDay)
			data = CommFunc.WriteDWORD(data, self.OffTime)
			return data

			@@ -15313,11 +13119,14 @@
			RealmLV:%d,
			Face:%d,
			FacePic:%d,
			TitleID:%d,
			FightPower:%d,
			FightPowerEx:%d,
			ServerID:%d,
			ContribTotal:%d,
			ContribWeek:%d,
			ContribDay:%d,
			DonateCntTotal:%d,
			DonateCntDay:%d,
			OffTime:%d
			'''\
			%(
			@@ -15331,11 +13140,14 @@
			self.RealmLV,
			self.Face,
			self.FacePic,
			self.TitleID,
			self.FightPower,
			self.FightPowerEx,
			self.ServerID,
			self.ContribTotal,
			self.ContribWeek,
			self.ContribDay,
			self.DonateCntTotal,
			self.DonateCntDay,
			self.OffTime
			)
			return DumpString
			@@ -15351,6 +13163,7 @@
			JoinLVMin = 0 #(WORD JoinLVMin)//限制最低可加入的玩家等级
			ServerID = 0 #(DWORD ServerID)//区服ID，创建时以族长的区服ID赋值
			EmblemID = 0 #(DWORD EmblemID)//徽章ID
			EmblemWord = "" #(char EmblemWord[3])//徽章文字
			FightPower = 0 #(DWORD FightPower)//总战力，求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//总战力，整除亿部分
			BroadcastLen = 0 #(WORD BroadcastLen)//公告
			@@ -15377,6 +13190,7 @@
			self.JoinLVMin,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EmblemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EmblemWord,_pos = CommFunc.ReadString(_lpData, _pos,3)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.BroadcastLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			@@ -15402,6 +13216,7 @@
			self.JoinLVMin = 0
			self.ServerID = 0
			self.EmblemID = 0
			self.EmblemWord = ""
			self.FightPower = 0
			self.FightPowerEx = 0
			self.BroadcastLen = 0
			@@ -15422,6 +13237,7 @@
			length += 2
			length += 4
			length += 4
			length += 3
			length += 4
			length += 4
			length += 2
			@@ -15444,6 +13260,7 @@
			data = CommFunc.WriteWORD(data, self.JoinLVMin)
			data = CommFunc.WriteDWORD(data, self.ServerID)
			data = CommFunc.WriteDWORD(data, self.EmblemID)
			data = CommFunc.WriteString(data, 3, self.EmblemWord)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteWORD(data, self.BroadcastLen)
			@@ -15465,6 +13282,7 @@
			JoinLVMin:%d,
			ServerID:%d,
			EmblemID:%d,
			EmblemWord:%s,
			FightPower:%d,
			FightPowerEx:%d,
			BroadcastLen:%d,
			@@ -15483,6 +13301,7 @@
			self.JoinLVMin,
			self.ServerID,
			self.EmblemID,
			self.EmblemWord,
			self.FightPower,
			self.FightPowerEx,
			self.BroadcastLen,
			@@ -15811,6 +13630,114 @@


			#------------------------------------------------------
			# A7 22 广告信息列表 #tagSCADInfoList

			class tagSCADInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("ADID", c_ushort), #广告ID
			("ADCnt", 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.ADID = 0
			self.ADCnt = 0
			return

			def GetLength(self):
			return sizeof(tagSCADInfo)

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

			def OutputString(self):
			DumpString = '''// A7 22 广告信息列表 //tagSCADInfoList:
			ADID:%d,
			ADCnt:%d
			'''\
			%(
			self.ADID,
			self.ADCnt
			)
			return DumpString


			class tagSCADInfoList(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			ADInfoList = list() #(vector<tagSCADInfo> ADInfoList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA7
			self.Head.SubCmd = 0x22
			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):
			temADInfoList = tagSCADInfo()
			_pos = temADInfoList.ReadData(_lpData, _pos)
			self.ADInfoList.append(temADInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA7
			self.Head.SubCmd = 0x22
			self.Count = 0
			self.ADInfoList = list()
			return

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

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


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


			#------------------------------------------------------
			# A7 04 通知世界Boss伤血列表 #tagMCBossHurtList

			class tagMCHurtPlayer(Structure):
			@@ -15969,122 +13896,6 @@

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


			#------------------------------------------------------
			# A7 17 聊天气泡框状态 #tagMCChatBubbleBoxState

			class tagMCChatBubbleBox(Structure):
			_pack_ = 1
			_fields_ = [
			("BoxID", c_ubyte), #气泡ID
			("State", c_ubyte), #是否已激活
			("EndTime", c_int), #到期时间戳，0为永久
			("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.BoxID = 0
			self.State = 0
			self.EndTime = 0
			self.Star = 0
			return

			def GetLength(self):
			return sizeof(tagMCChatBubbleBox)

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

			def OutputString(self):
			DumpString = '''// A7 17 聊天气泡框状态 //tagMCChatBubbleBoxState:
			BoxID:%d,
			State:%d,
			EndTime:%d,
			Star:%d
			'''\
			%(
			self.BoxID,
			self.State,
			self.EndTime,
			self.Star
			)
			return DumpString


			class tagMCChatBubbleBoxState(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			BoxList = list() #(vector<tagMCChatBubbleBox> BoxList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA7
			self.Head.SubCmd = 0x17
			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):
			temBoxList = tagMCChatBubbleBox()
			_pos = temBoxList.ReadData(_lpData, _pos)
			self.BoxList.append(temBoxList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA7
			self.Head.SubCmd = 0x17
			self.Count = 0
			self.BoxList = list()
			return

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

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


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


			#------------------------------------------------------
			@@ -16495,114 +14306,6 @@

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


			#------------------------------------------------------
			# A7 03 通知进入副本时间 #tagMCFBEnterTickList

			class tagMCFBEnterTick(Structure):
			_pack_ = 1
			_fields_ = [
			("MapID", c_int), # 副本地图id
			("LastEnterTick", 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.MapID = 0
			self.LastEnterTick = 0
			return

			def GetLength(self):
			return sizeof(tagMCFBEnterTick)

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

			def OutputString(self):
			DumpString = '''// A7 03 通知进入副本时间 //tagMCFBEnterTickList:
			MapID:%d,
			LastEnterTick:%d
			'''\
			%(
			self.MapID,
			self.LastEnterTick
			)
			return DumpString


			class tagMCFBEnterTickList(Structure):
			Head = tagHead()
			Cnt = 0 #(BYTE Cnt)// 信息个数
			EnterTickList = list() #(vector<tagMCFBEnterTick> EnterTickList)// 信息列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Cnt):
			temEnterTickList = tagMCFBEnterTick()
			_pos = temEnterTickList.ReadData(_lpData, _pos)
			self.EnterTickList.append(temEnterTickList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA7
			self.Head.SubCmd = 0x03
			self.Cnt = 0
			self.EnterTickList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -17435,6 +15138,7 @@
			RealmLV = 0 #(BYTE RealmLV)
			Face = 0 #(DWORD Face)
			FacePic = 0 #(DWORD FacePic)
			ModelMark = 0 #(DWORD ModelMark)//变形模型mark
			TitleID = 0 #(DWORD TitleID)//佩戴的称号
			ServerID = 0 #(DWORD ServerID)
			FightPower = 0 #(DWORD FightPower)
			@@ -17442,6 +15146,7 @@
			FamilyID = 0 #(DWORD FamilyID)
			FamilyName = "" #(char FamilyName[33])
			FamilyEmblemID = 0 #(DWORD FamilyEmblemID)//仙盟徽章ID
			FamilyEmblemWord = "" #(char FamilyEmblemWord[3])//徽章文字
			PlusDataSize = 0 #(DWORD PlusDataSize)
			PlusData = "" #(String PlusData)//扩展记录
			data = None
			@@ -17462,6 +15167,7 @@
			self.RealmLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ModelMark,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TitleID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			@@ -17469,6 +15175,7 @@
			self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FamilyName,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.FamilyEmblemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FamilyEmblemWord,_pos = CommFunc.ReadString(_lpData, _pos,3)
			self.PlusDataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PlusData,_pos = CommFunc.ReadString(_lpData, _pos,self.PlusDataSize)
			return _pos
			@@ -17485,6 +15192,7 @@
			self.RealmLV = 0
			self.Face = 0
			self.FacePic = 0
			self.ModelMark = 0
			self.TitleID = 0
			self.ServerID = 0
			self.FightPower = 0
			@@ -17492,6 +15200,7 @@
			self.FamilyID = 0
			self.FamilyName = ""
			self.FamilyEmblemID = 0
			self.FamilyEmblemWord = ""
			self.PlusDataSize = 0
			self.PlusData = ""
			return
			@@ -17511,8 +15220,10 @@
			length += 4
			length += 4
			length += 4
			length += 4
			length += 33
			length += 4
			length += 3
			length += 4
			length += len(self.PlusData)

			@@ -17528,6 +15239,7 @@
			data = CommFunc.WriteBYTE(data, self.RealmLV)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.ModelMark)
			data = CommFunc.WriteDWORD(data, self.TitleID)
			data = CommFunc.WriteDWORD(data, self.ServerID)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			@@ -17535,6 +15247,7 @@
			data = CommFunc.WriteDWORD(data, self.FamilyID)
			data = CommFunc.WriteString(data, 33, self.FamilyName)
			data = CommFunc.WriteDWORD(data, self.FamilyEmblemID)
			data = CommFunc.WriteString(data, 3, self.FamilyEmblemWord)
			data = CommFunc.WriteDWORD(data, self.PlusDataSize)
			data = CommFunc.WriteString(data, self.PlusDataSize, self.PlusData)
			return data
			@@ -17549,6 +15262,7 @@
			RealmLV:%d,
			Face:%d,
			FacePic:%d,
			ModelMark:%d,
			TitleID:%d,
			ServerID:%d,
			FightPower:%d,
			@@ -17556,6 +15270,7 @@
			FamilyID:%d,
			FamilyName:%s,
			FamilyEmblemID:%d,
			FamilyEmblemWord:%s,
			PlusDataSize:%d,
			PlusData:%s
			'''\
			@@ -17568,6 +15283,7 @@
			self.RealmLV,
			self.Face,
			self.FacePic,
			self.ModelMark,
			self.TitleID,
			self.ServerID,
			self.FightPower,
			@@ -17575,6 +15291,7 @@
			self.FamilyID,
			self.FamilyName,
			self.FamilyEmblemID,
			self.FamilyEmblemWord,
			self.PlusDataSize,
			self.PlusData
			)
			@@ -17977,73 +15694,6 @@

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


			#------------------------------------------------------
			# A8 12 守护成功拾取物品 #tagMCGuradPickupItemSucc

			class tagMCGuradPickupItemSucc(Structure):
			Head = tagHead()
			ItemCount = 0 #(WORD ItemCount)
			MapItemID = list() #(vector<WORD> MapItemID)//size = ItemCount
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ItemCount,_pos = CommFunc.ReadWORD(_lpData, _pos)
			for i in range(self.ItemCount):
			value,_pos=CommFunc.ReadWORD(_lpData,_pos)
			self.MapItemID.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA8
			self.Head.SubCmd = 0x12
			self.ItemCount = 0
			self.MapItemID = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			length += 2 * self.ItemCount

			return length

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

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


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


			#------------------------------------------------------
			@@ -18992,129 +16642,17 @@


			#------------------------------------------------------
			# A9 26 竞技场对战玩家最新信息 #tagGCArenaBattlePlayerInfo
			# A9 22 演武场匹配玩家列表 #tagSCArenaMatchList

			class tagGCArenaBattlePlayerInfo(Structure):
			Head = tagHead()
			class tagSCArenaMatchInfo(Structure):
			PlayerID = 0 #(DWORD PlayerID)//目标玩家ID
			PlayerName = "" #(char PlayerName[33])
			Job = 0 #(BYTE Job)
			LV = 0 #(WORD LV)//等级
			RealmLV = 0 #(WORD RealmLV)//境界，机器人读境界表取等级对应境界
			FightPower = 0 #(DWORD FightPower)//战力求余亿部分，机器人读等级表取等级对应战力
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力整除亿部分，机器人读等级表取等级对应战力
			Score = 0 #(DWORD Score)//积分
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0x26
			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.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)
			self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0x26
			self.PlayerID = 0
			self.PlayerName = ""
			self.Job = 0
			self.LV = 0
			self.RealmLV = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			self.Score = 0
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 33
			length += 1
			length += 2
			length += 2
			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.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)
			data = CommFunc.WriteDWORD(data, self.Score)
			return data

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


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


			#------------------------------------------------------
			# A9 23 竞技场对战记录列表 #tagGCArenaBattleRecordList

			class tagGCArenaBattleRecord(Structure):
			PlayerID = 0 #(DWORD PlayerID)//目标玩家ID，小于10000为机器人ID
			PlayerName = "" #(char PlayerName[33])
			Job = 0 #(BYTE Job)
			LV = 0 #(WORD LV)//等级
			RealmLV = 0 #(WORD RealmLV)//境界，机器人读境界表取等级对应境界
			FightPower = 0 #(DWORD FightPower)//战力求余亿部分，机器人读等级表取等级对应战力
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力整除亿部分，机器人读等级表取等级对应战力
			Score = 0 #(DWORD Score)//积分
			AddScoreLen = 0 #(BYTE AddScoreLen)
			AddScore = "" #(String AddScore)//本次对战增加的积分，有正负
			IsWin = 0 #(BYTE IsWin)//是否获胜
			Time = 0 #(DWORD Time)//时间戳
			FightPower = 0 #(DWORD FightPower)//战力求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力整除亿部分
			Face = 0 #(DWORD Face)//基本脸型
			FacePic = 0 #(DWORD FacePic)//头像框
			TitleID = 0 #(DWORD TitleID)//称号
			data = None

			def __init__(self):
			@@ -19125,229 +16663,29 @@
			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)
			self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.AddScoreLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.AddScore,_pos = CommFunc.ReadString(_lpData, _pos,self.AddScoreLen)
			self.IsWin,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Time,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TitleID,_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
			self.Score = 0
			self.AddScoreLen = 0
			self.AddScore = ""
			self.IsWin = 0
			self.Time = 0
			self.Face = 0
			self.FacePic = 0
			self.TitleID = 0
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 33
			length += 1
			length += 2
			length += 2
			length += 4
			length += 4
			length += 4
			length += 1
			length += len(self.AddScore)
			length += 1
			length += 4
			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)
			data = CommFunc.WriteDWORD(data, self.Score)
			data = CommFunc.WriteBYTE(data, self.AddScoreLen)
			data = CommFunc.WriteString(data, self.AddScoreLen, self.AddScore)
			data = CommFunc.WriteBYTE(data, self.IsWin)
			data = CommFunc.WriteDWORD(data, self.Time)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			PlayerName:%s,
			Job:%d,
			LV:%d,
			RealmLV:%d,
			FightPower:%d,
			FightPowerEx:%d,
			Score:%d,
			AddScoreLen:%d,
			AddScore:%s,
			IsWin:%d,
			Time:%d,
			Face:%d,
			FacePic:%d
			'''\
			%(
			self.PlayerID,
			self.PlayerName,
			self.Job,
			self.LV,
			self.RealmLV,
			self.FightPower,
			self.FightPowerEx,
			self.Score,
			self.AddScoreLen,
			self.AddScore,
			self.IsWin,
			self.Time,
			self.Face,
			self.FacePic
			)
			return DumpString


			class tagGCArenaBattleRecordList(Structure):
			Head = tagHead()
			RecordCount = 0 #(BYTE RecordCount)
			BattleRecordList = list() #(vector<tagGCArenaBattleRecord> BattleRecordList)// 对战列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RecordCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RecordCount):
			temBattleRecordList = tagGCArenaBattleRecord()
			_pos = temBattleRecordList.ReadData(_lpData, _pos)
			self.BattleRecordList.append(temBattleRecordList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0x23
			self.RecordCount = 0
			self.BattleRecordList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# A9 22 竞技场匹配玩家列表 #tagGCArenaMatchList

			class tagGCArenaMatchInfo(Structure):
			PlayerID = 0 #(DWORD PlayerID)//目标玩家ID，小于10000为机器人ID
			PlayerName = "" #(char PlayerName[33])
			Job = 0 #(BYTE Job)
			LV = 0 #(WORD LV)//等级
			RealmLV = 0 #(WORD RealmLV)//境界，机器人读境界表取等级对应境界
			FightPower = 0 #(DWORD FightPower)//战力求余亿部分，机器人读等级表取等级对应战力
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力整除亿部分，机器人读等级表取等级对应战力
			Score = 0 #(DWORD Score)//积分
			Face = 0 #(DWORD Face)//基本脸型
			FacePic = 0 #(DWORD FacePic)//头像框
			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)
			self.Score,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_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
			self.Score = 0
			self.Face = 0
			self.FacePic = 0
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 33
			length += 1
			length += 2
			length += 2
			length += 4
			length += 4
			@@ -19361,48 +16699,42 @@
			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)
			data = CommFunc.WriteDWORD(data, self.Score)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.TitleID)
			return data

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


			class tagGCArenaMatchList(Structure):
			class tagSCArenaMatchList(Structure):
			Head = tagHead()
			MatchCount = 0 #(BYTE MatchCount)
			MatchList = list() #(vector<tagGCArenaMatchInfo> MatchList)// 匹配列表
			MatchList = list() #(vector<tagSCArenaMatchInfo> MatchList)// 匹配列表，从高分到低分
			data = None

			def __init__(self):
			@@ -19416,7 +16748,7 @@
			_pos = self.Head.ReadData(_lpData, _pos)
			self.MatchCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.MatchCount):
			temMatchList = tagGCArenaMatchInfo()
			temMatchList = tagSCArenaMatchInfo()
			_pos = temMatchList.ReadData(_lpData, _pos)
			self.MatchList.append(temMatchList)
			return _pos
			@@ -19461,8 +16793,60 @@
			return DumpString


			m_NAtagGCArenaMatchList=tagGCArenaMatchList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagGCArenaMatchList.Head.Cmd,m_NAtagGCArenaMatchList.Head.SubCmd))] = m_NAtagGCArenaMatchList
			m_NAtagSCArenaMatchList=tagSCArenaMatchList()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCArenaMatchList.Head.Cmd,m_NAtagSCArenaMatchList.Head.SubCmd))] = m_NAtagSCArenaMatchList


			#------------------------------------------------------
			# A9 23 演武场玩家信息 #tagSCArenaPlayerInfo

			class tagSCArenaPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("Score", c_int), #当前积分
			]

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

			def GetLength(self):
			return sizeof(tagSCArenaPlayerInfo)

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

			def OutputString(self):
			DumpString = '''// A9 23 演武场玩家信息 //tagSCArenaPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			Score:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Score
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -20394,169 +17778,6 @@

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


			#------------------------------------------------------
			# A9 A7 通知可抢的红包信息 #tagGCGrabRedPacketInfo

			class tagGCGrabRedPacketInfo(Structure):
			Head = tagHead()
			RedPacketCnt = 0 #(DWORD RedPacketCnt)//可抢红包个数
			StrLen = 0 #(WORD StrLen)//字符串长度
			OwnerName = "" #(String OwnerName)//红包主人名字
			RedPacketID = 0 #(DWORD RedPacketID)//可抢红包ID
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RedPacketCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.StrLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.OwnerName,_pos = CommFunc.ReadString(_lpData, _pos,self.StrLen)
			self.RedPacketID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0xA7
			self.RedPacketCnt = 0
			self.StrLen = 0
			self.OwnerName = ""
			self.RedPacketID = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.RedPacketCnt)
			data = CommFunc.WriteWORD(data, self.StrLen)
			data = CommFunc.WriteString(data, self.StrLen, self.OwnerName)
			data = CommFunc.WriteDWORD(data, self.RedPacketID)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			RedPacketCnt:%d,
			StrLen:%d,
			OwnerName:%s,
			RedPacketID:%d
			'''\
			%(
			self.Head.OutputString(),
			self.RedPacketCnt,
			self.StrLen,
			self.OwnerName,
			self.RedPacketID
			)
			return DumpString


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


			#------------------------------------------------------
			# A9 A6 通知抢红包结果 #tagGCGrabRedPacketResult

			class tagGCGrabRedPacketResult(Structure):
			Head = tagHead()
			StrLen = 0 #(WORD StrLen)//字符串长度
			OwnerName = "" #(String OwnerName)//红包主人名字
			TotalMoney = 0 #(DWORD TotalMoney)//红包总额
			DataSize = 0 #(DWORD DataSize)
			GrabInfo = "" #(String GrabInfo)//抢红包具体结果
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.StrLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.OwnerName,_pos = CommFunc.ReadString(_lpData, _pos,self.StrLen)
			self.TotalMoney,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.DataSize,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.GrabInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.DataSize)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0xA6
			self.StrLen = 0
			self.OwnerName = ""
			self.TotalMoney = 0
			self.DataSize = 0
			self.GrabInfo = ""
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 2
			length += len(self.OwnerName)
			length += 4
			length += 4
			length += len(self.GrabInfo)

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteWORD(data, self.StrLen)
			data = CommFunc.WriteString(data, self.StrLen, self.OwnerName)
			data = CommFunc.WriteDWORD(data, self.TotalMoney)
			data = CommFunc.WriteDWORD(data, self.DataSize)
			data = CommFunc.WriteString(data, self.DataSize, self.GrabInfo)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			StrLen:%d,
			OwnerName:%s,
			TotalMoney:%d,
			DataSize:%d,
			GrabInfo:%s
			'''\
			%(
			self.Head.OutputString(),
			self.StrLen,
			self.OwnerName,
			self.TotalMoney,
			self.DataSize,
			self.GrabInfo
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -21575,6 +18796,63 @@


			#------------------------------------------------------
			# A9 21 角色改名结果 #tagSCRenameResult

			class tagSCRenameResult(Structure):
			Head = tagHead()
			PlayerName = "" #(char PlayerName[33])// 新名字
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.PlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xA9
			self.Head.SubCmd = 0x21
			self.PlayerName = ""
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 33

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteString(data, 33, self.PlayerName)
			return data

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


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


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

			class tagGCStoreServerBuyCnt(Structure):
			@@ -21680,58 +18958,6 @@

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


			#------------------------------------------------------
			#A9 21 角色改名结果 #tagUpdatePlayerNameResult

			class tagUpdatePlayerNameResult(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("Result", c_ubyte), #角色改名结果
			]

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

			def GetLength(self):
			return sizeof(tagUpdatePlayerNameResult)

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

			def OutputString(self):
			DumpString = '''//A9 21 角色改名结果 //tagUpdatePlayerNameResult:
			Cmd:%s,
			SubCmd:%s,
			Result:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Result
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -31501,22 +28727,18 @@


			#------------------------------------------------------
			# AA 02 首充信息 #tagMCFirstGoldInfo
			# AA 02 首充信息 #tagSCFirstChargeInfo

			class tagMCFirstGoldInfo(Structure):
			class tagSCFirstCharge(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("FirstGoldRewardState", c_ubyte), #首充奖励领奖记录，按位记录首充第X天是否已领取，第1天为第0索引位
			("FirstGoldTry", c_ubyte), #首充试用状态0-不可试用 1-可试用 2-已试用
			("FirstGoldServerDay", c_ushort), #首充时是开服第几天，从1开始，0代表未记录充值
			("FirstID", c_ubyte), #首充ID
			("ChargeTime", c_int), #充值该首充的时间戳
			("AwardRecord", c_ushort), #首充奖励领奖记录，按二进制位记录首充第X天是否已领取
			]

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

			def ReadData(self, stringData, _pos=0, _len=0):
			@@ -31525,91 +28747,95 @@
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xAA
			self.SubCmd = 0x02
			self.FirstGoldRewardState = 0
			self.FirstGoldTry = 0
			self.FirstGoldServerDay = 0
			self.FirstID = 0
			self.ChargeTime = 0
			self.AwardRecord = 0
			return

			def GetLength(self):
			return sizeof(tagMCFirstGoldInfo)
			return sizeof(tagSCFirstCharge)

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

			def OutputString(self):
			DumpString = '''// AA 02 首充信息 //tagMCFirstGoldInfo:
			Cmd:%s,
			SubCmd:%s,
			FirstGoldRewardState:%d,
			FirstGoldTry:%d,
			FirstGoldServerDay:%d
			DumpString = '''// AA 02 首充信息 //tagSCFirstChargeInfo:
			FirstID:%d,
			ChargeTime:%d,
			AwardRecord:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.FirstGoldRewardState,
			self.FirstGoldTry,
			self.FirstGoldServerDay
			self.FirstID,
			self.ChargeTime,
			self.AwardRecord
			)
			return DumpString


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


			#------------------------------------------------------
			# AA 08 首充提示剩余时间 #tagMCFirstGoldTime

			class tagMCFirstGoldTime(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("FirstGoldRemainTime", c_int), #首充提示剩余时间
			]
			class tagSCFirstChargeInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			FirstChargeList = list() #(vector<tagSCFirstCharge> FirstChargeList)
			data = None

			def __init__(self):
			self.Clear()
			self.Cmd = 0xAA
			self.SubCmd = 0x08
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x02
			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.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Count):
			temFirstChargeList = tagSCFirstCharge()
			_pos = temFirstChargeList.ReadData(_lpData, _pos)
			self.FirstChargeList.append(temFirstChargeList)
			return _pos

			def Clear(self):
			self.Cmd = 0xAA
			self.SubCmd = 0x08
			self.FirstGoldRemainTime = 0
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAA
			self.Head.SubCmd = 0x02
			self.Count = 0
			self.FirstChargeList = list()
			return

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

			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.WriteBYTE(data, self.Count)
			for i in range(self.Count):
			data = CommFunc.WriteString(data, self.FirstChargeList[i].GetLength(), self.FirstChargeList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''// AA 08 首充提示剩余时间 //tagMCFirstGoldTime:
			Cmd:%s,
			SubCmd:%s,
			FirstGoldRemainTime:%d
			DumpString = '''
			Head:%s,
			Count:%d,
			FirstChargeList:%s
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.FirstGoldRemainTime
			self.Head.OutputString(),
			self.Count,
			"..."
			)
			return DumpString


			m_NAtagMCFirstGoldTime=tagMCFirstGoldTime()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCFirstGoldTime.Cmd,m_NAtagMCFirstGoldTime.SubCmd))] = m_NAtagMCFirstGoldTime
			m_NAtagSCFirstChargeInfo=tagSCFirstChargeInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCFirstChargeInfo.Head.Cmd,m_NAtagSCFirstChargeInfo.Head.SubCmd))] = m_NAtagSCFirstChargeInfo


			#------------------------------------------------------
			@@ -34653,62 +31879,6 @@


			#------------------------------------------------------
			# AB 25 节日红包信息 #tagMCFeastRedPackInfo

			class tagMCFeastRedPackInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("MoneyNum", c_int), # 累积抢到多少钱
			("GrabCnt", c_ushort), # 已抢红包次数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xAB
			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 = 0xAB
			self.SubCmd = 0x25
			self.MoneyNum = 0
			self.GrabCnt = 0
			return

			def GetLength(self):
			return sizeof(tagMCFeastRedPackInfo)

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

			def OutputString(self):
			DumpString = '''// AB 25 节日红包信息 //tagMCFeastRedPackInfo:
			Cmd:%s,
			SubCmd:%s,
			MoneyNum:%d,
			GrabCnt:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.MoneyNum,
			self.GrabCnt
			)
			return DumpString


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


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

			class tagMCOpenServerCampaignAward(Structure):
			@@ -34826,66 +31996,6 @@

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


			#------------------------------------------------------
			# AB 24 开服红包信息 #tagMCOpenServerRedPacketInfo

			class tagMCOpenServerRedPacketInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("MoneyNum", c_int), # 累积抢到多少钱
			("GrabCnt", c_ushort), # 已抢红包次数
			("StartTime", c_int), # 开始倒计时时间
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xAB
			self.SubCmd = 0x24
			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 = 0xAB
			self.SubCmd = 0x24
			self.MoneyNum = 0
			self.GrabCnt = 0
			self.StartTime = 0
			return

			def GetLength(self):
			return sizeof(tagMCOpenServerRedPacketInfo)

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

			def OutputString(self):
			DumpString = '''// AB 24 开服红包信息 //tagMCOpenServerRedPacketInfo:
			Cmd:%s,
			SubCmd:%s,
			MoneyNum:%d,
			GrabCnt:%d,
			StartTime:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.MoneyNum,
			self.GrabCnt,
			self.StartTime
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -35299,151 +32409,6 @@


			#------------------------------------------------------
			# AC 11 节日红包活动信息 #tagGCFeastRedPacketInfo

			class tagGCFeastRedPacketDay(Structure):
			RedPacketCount = 0 #(BYTE RedPacketCount)
			RedPacketIDList = list() #(vector<WORD> RedPacketIDList)// 当日定时发放的系统红包表ID列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.RedPacketCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RedPacketCount):
			value,_pos=CommFunc.ReadWORD(_lpData,_pos)
			self.RedPacketIDList.append(value)
			return _pos

			def Clear(self):
			self.RedPacketCount = 0
			self.RedPacketIDList = list()
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 2 * self.RedPacketCount

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.RedPacketCount)
			for i in range(self.RedPacketCount):
			data = CommFunc.WriteWORD(data, self.RedPacketIDList[i])
			return data

			def OutputString(self):
			DumpString = '''
			RedPacketCount:%d,
			RedPacketIDList:%s
			'''\
			%(
			self.RedPacketCount,
			"..."
			)
			return DumpString


			class tagGCFeastRedPacketInfo(Structure):
			Head = tagHead()
			StartDate = "" #(char StartDate[10])// 开始日期 y-m-d
			EndtDate = "" #(char EndtDate[10])// 结束日期 y-m-d
			LimitLV = 0 #(WORD LimitLV)// 限制等级
			ResetType = 0 #(BYTE ResetType)// 重置类型 0-0点重置 1-5点重置
			RedPacketDays = 0 #(BYTE RedPacketDays)
			RedPacketDayList = list() #(vector<tagGCFeastRedPacketDay> RedPacketDayList)// 每日系统红包信息
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.RedPacketDays,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RedPacketDays):
			temRedPacketDayList = tagGCFeastRedPacketDay()
			_pos = temRedPacketDayList.ReadData(_lpData, _pos)
			self.RedPacketDayList.append(temRedPacketDayList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAC
			self.Head.SubCmd = 0x11
			self.StartDate = ""
			self.EndtDate = ""
			self.LimitLV = 0
			self.ResetType = 0
			self.RedPacketDays = 0
			self.RedPacketDayList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			StartDate:%s,
			EndtDate:%s,
			LimitLV:%d,
			ResetType:%d,
			RedPacketDays:%d,
			RedPacketDayList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.StartDate,
			self.EndtDate,
			self.LimitLV,
			self.ResetType,
			self.RedPacketDays,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# AC 06 多倍经验活动信息 #tagGCMultiExpRateInfo

			class tagGCMultiExpRateTime(Structure):
			@@ -35668,73 +32633,6 @@

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


			#------------------------------------------------------
			# AC 05 红包删除 #tagGCRedPacketDel

			class tagGCRedPacketDel(Structure):
			Head = tagHead()
			Cnt = 0 #(DWORD Cnt)// 个数
			DelRedPacketID = list() #(vector<DWORD> DelRedPacketID)// 红包ID
			data = None

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

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xAC
			self.Head.SubCmd = 0x05
			self.Cnt = 0
			self.DelRedPacketID = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			@@ -37416,6 +34314,122 @@


			#------------------------------------------------------
			# B1 27 聊天气泡框信息 #tagSCChatBoxInfo

			class tagSCChatBox(Structure):
			_pack_ = 1
			_fields_ = [
			("BoxID", c_int), #气泡框ID
			("State", c_ubyte), #是否已激活
			("EndTime", c_int), #到期时间戳，0为永久
			("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.BoxID = 0
			self.State = 0
			self.EndTime = 0
			self.Star = 0
			return

			def GetLength(self):
			return sizeof(tagSCChatBox)

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

			def OutputString(self):
			DumpString = '''// B1 27 聊天气泡框信息 //tagSCChatBoxInfo:
			BoxID:%d,
			State:%d,
			EndTime:%d,
			Star:%d
			'''\
			%(
			self.BoxID,
			self.State,
			self.EndTime,
			self.Star
			)
			return DumpString


			class tagSCChatBoxInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			BoxList = list() #(vector<tagSCChatBox> BoxList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x27
			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):
			temBoxList = tagSCChatBox()
			_pos = temBoxList.ReadData(_lpData, _pos)
			self.BoxList.append(temBoxList)
			return _pos

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

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

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


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


			#------------------------------------------------------
			# B1 02 玩家时装皮肤激活状态 #tagMCClothesCoatSkinState

			class tagMCClothesCoatLVInfo(Structure):
			@@ -37535,6 +34549,158 @@

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


			#------------------------------------------------------
			# B1 09 每日活跃任务信息 #tagSCDailyTaskInfo

			class tagSCDailyTask(Structure):
			TaskType = 0 #(BYTE TaskType)// 任务类型
			CLen = 0 #(BYTE CLen)
			Conds = list() #(vector<DWORD> Conds)// 条件列表
			CurValue = 0 #(DWORD CurValue)// 进度值，相同任务类型条件的进度值共享
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.TaskType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.CLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.CLen):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.Conds.append(value)
			self.CurValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.TaskType = 0
			self.CLen = 0
			self.Conds = list()
			self.CurValue = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.TaskType)
			data = CommFunc.WriteBYTE(data, self.CLen)
			for i in range(self.CLen):
			data = CommFunc.WriteDWORD(data, self.Conds[i])
			data = CommFunc.WriteDWORD(data, self.CurValue)
			return data

			def OutputString(self):
			DumpString = '''
			TaskType:%d,
			CLen:%d,
			Conds:%s,
			CurValue:%d
			'''\
			%(
			self.TaskType,
			self.CLen,
			"...",
			self.CurValue
			)
			return DumpString


			class tagSCDailyTaskInfo(Structure):
			Head = tagHead()
			ActivityTotal = 0 #(DWORD ActivityTotal)// 今日累计获得活跃度
			ActivityAward = 0 #(DWORD ActivityAward)// 累计活跃领奖记录，按活跃ID奖励二进制位存储是否已领取
			DailyTaskState = 0 #(DWORD DailyTaskState)// 今日任务是否已领取奖励，按任务ID二进制位存储是否已领取
			TaskCount = 0 #(BYTE TaskCount)
			TaskList = list() #(vector<tagSCDailyTask> TaskList)// 差异更新的任务信息
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ActivityTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ActivityAward,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.DailyTaskState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TaskCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.TaskCount):
			temTaskList = tagSCDailyTask()
			_pos = temTaskList.ReadData(_lpData, _pos)
			self.TaskList.append(temTaskList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x09
			self.ActivityTotal = 0
			self.ActivityAward = 0
			self.DailyTaskState = 0
			self.TaskCount = 0
			self.TaskList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.ActivityTotal)
			data = CommFunc.WriteDWORD(data, self.ActivityAward)
			data = CommFunc.WriteDWORD(data, self.DailyTaskState)
			data = CommFunc.WriteBYTE(data, self.TaskCount)
			for i in range(self.TaskCount):
			data = CommFunc.WriteString(data, self.TaskList[i].GetLength(), self.TaskList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ActivityTotal:%d,
			ActivityAward:%d,
			DailyTaskState:%d,
			TaskCount:%d,
			TaskList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ActivityTotal,
			self.ActivityAward,
			self.DailyTaskState,
			self.TaskCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -38249,6 +35415,122 @@


			#------------------------------------------------------
			# B1 19 形象信息 #tagSCModelInfo

			class tagSCModel(Structure):
			_pack_ = 1
			_fields_ = [
			("ModelID", c_int), #形象ID
			("State", c_ubyte), #是否已激活
			("EndTime", c_int), #到期时间戳，0为永久
			("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.ModelID = 0
			self.State = 0
			self.EndTime = 0
			self.Star = 0
			return

			def GetLength(self):
			return sizeof(tagSCModel)

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

			def OutputString(self):
			DumpString = '''// B1 19 形象信息 //tagSCModelInfo:
			ModelID:%d,
			State:%d,
			EndTime:%d,
			Star:%d
			'''\
			%(
			self.ModelID,
			self.State,
			self.EndTime,
			self.Star
			)
			return DumpString


			class tagSCModelInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			ModelList = list() #(vector<tagSCModel> ModelList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x19
			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):
			temModelList = tagSCModel()
			_pos = temModelList.ReadData(_lpData, _pos)
			self.ModelList.append(temModelList)
			return _pos

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

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

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


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


			#------------------------------------------------------
			# B1 06 通知玩家向目标点移动 #tagMCNotifyPlayerMove

			class tagMCNotifyPlayerMove(Structure):
			@@ -38306,80 +35588,6 @@

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


			#------------------------------------------------------
			# B1 13 在线奖励信息新 #tagMCOnlinePrizeNew

			class tagMCOnlinePrizeNew(Structure):
			Head = tagHead()
			OnlineTime = 0 #(DWORD OnlineTime)//在线时间毫秒
			Len = 0 #(BYTE Len)
			PrizeInfo = list() #(vector<DWORD> PrizeInfo)//领奖记录
			data = None

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

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x13
			self.OnlineTime = 0
			self.Len = 0
			self.PrizeInfo = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			OnlineTime:%d,
			Len:%d,
			PrizeInfo:%s
			'''\
			%(
			self.Head.OutputString(),
			self.OnlineTime,
			self.Len,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -39022,6 +36230,122 @@


			#------------------------------------------------------
			# B1 26 称号信息 #tagSCTitleInfo

			class tagSCTitle(Structure):
			_pack_ = 1
			_fields_ = [
			("TitleID", c_int), #称号ID
			("State", c_ubyte), #是否已激活
			("EndTime", c_int), #到期时间戳，0为永久
			("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.State = 0
			self.EndTime = 0
			self.Star = 0
			return

			def GetLength(self):
			return sizeof(tagSCTitle)

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

			def OutputString(self):
			DumpString = '''// B1 26 称号信息 //tagSCTitleInfo:
			TitleID:%d,
			State:%d,
			EndTime:%d,
			Star:%d
			'''\
			%(
			self.TitleID,
			self.State,
			self.EndTime,
			self.Star
			)
			return DumpString


			class tagSCTitleInfo(Structure):
			Head = tagHead()
			Count = 0 #(BYTE Count)
			TitleList = list() #(vector<tagSCTitle> TitleList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x26
			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):
			temTitleList = tagSCTitle()
			_pos = temTitleList.ReadData(_lpData, _pos)
			self.TitleList.append(temTitleList)
			return _pos

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

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

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


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


			#------------------------------------------------------
			# B1 12 培养功能境界信息 #tagMCTrainRealmLVInfo

			class tagMCTrainRealmLV(Structure):
			@@ -39572,359 +36896,18 @@


			#------------------------------------------------------
			# B2 08 获得仙缘币信息 #tagMCAddXianyuanCoinMsg
			# B2 01 天子考验信息 #tagSCTianziKYInfo

			class tagMCAddXianyuanCoinMsg(Structure):
			Head = tagHead()
			MapID = 0 #(DWORD MapID)
			FuncLineID = 0 #(BYTE FuncLineID)
			Relation = 0 #(BYTE Relation)// 当时的关系：0-无，1-好友，2-盟友
			RelationCoinAdd = 0 #(BYTE RelationCoinAdd)// 社交关系总加成
			XianyuanCoinAdd = 0 #(WORD XianyuanCoinAdd)// 实际增加的仙缘币
			Reason = 0 #(BYTE Reason)//仙缘币为0时的原因：1-助战次数上限；2-每日获得上限
			CallPlayerID = 0 #(DWORD CallPlayerID)// 助战的玩家ID，有值时代表真实助战，没有值时为自己打的
			NameLen = 0 #(BYTE NameLen)
			CallPlayerName = "" #(String CallPlayerName)// 助战的玩家名，size = NameLen
			IsSweep = 0 #(BYTE IsSweep)// 是否扫荡
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.MapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FuncLineID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Relation,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.RelationCoinAdd,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.XianyuanCoinAdd,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.Reason,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.CallPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.NameLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.CallPlayerName,_pos = CommFunc.ReadString(_lpData, _pos,self.NameLen)
			self.IsSweep,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB2
			self.Head.SubCmd = 0x08
			self.MapID = 0
			self.FuncLineID = 0
			self.Relation = 0
			self.RelationCoinAdd = 0
			self.XianyuanCoinAdd = 0
			self.Reason = 0
			self.CallPlayerID = 0
			self.NameLen = 0
			self.CallPlayerName = ""
			self.IsSweep = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.MapID)
			data = CommFunc.WriteBYTE(data, self.FuncLineID)
			data = CommFunc.WriteBYTE(data, self.Relation)
			data = CommFunc.WriteBYTE(data, self.RelationCoinAdd)
			data = CommFunc.WriteWORD(data, self.XianyuanCoinAdd)
			data = CommFunc.WriteBYTE(data, self.Reason)
			data = CommFunc.WriteDWORD(data, self.CallPlayerID)
			data = CommFunc.WriteBYTE(data, self.NameLen)
			data = CommFunc.WriteString(data, self.NameLen, self.CallPlayerName)
			data = CommFunc.WriteBYTE(data, self.IsSweep)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			MapID:%d,
			FuncLineID:%d,
			Relation:%d,
			RelationCoinAdd:%d,
			XianyuanCoinAdd:%d,
			Reason:%d,
			CallPlayerID:%d,
			NameLen:%d,
			CallPlayerName:%s,
			IsSweep:%d
			'''\
			%(
			self.Head.OutputString(),
			self.MapID,
			self.FuncLineID,
			self.Relation,
			self.RelationCoinAdd,
			self.XianyuanCoinAdd,
			self.Reason,
			self.CallPlayerID,
			self.NameLen,
			self.CallPlayerName,
			self.IsSweep
			)
			return DumpString


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


			#------------------------------------------------------
			# B2 15 副本买buff信息通知 #tagMCFBBuyBuffInfo

			class tagMCFBBuyBuffTime(Structure):
			_pack_ = 1
			_fields_ = [
			("MapID", c_int),
			("MoneyCnt", c_ushort),
			("BuyTime", 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.MapID = 0
			self.MoneyCnt = 0
			self.BuyTime = 0
			return

			def GetLength(self):
			return sizeof(tagMCFBBuyBuffTime)

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

			def OutputString(self):
			DumpString = '''// B2 15 副本买buff信息通知 //tagMCFBBuyBuffInfo:
			MapID:%d,
			MoneyCnt:%d,
			BuyTime:%d
			'''\
			%(
			self.MapID,
			self.MoneyCnt,
			self.BuyTime
			)
			return DumpString


			class tagMCFBBuyBuffInfo(Structure):
			Head = tagHead()
			Cnt = 0 #(BYTE Cnt)
			InfoList = list() #(vector<tagMCFBBuyBuffTime> InfoList)
			data = None

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

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB2
			self.Head.SubCmd = 0x15
			self.Cnt = 0
			self.InfoList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# B2 09 副本次数恢复剩余时间 #tagMCFBCntRegainRemainTime

			class tagMCFBCntRegain(Structure):
			_pack_ = 1
			_fields_ = [
			("DataMapID", c_int), # 地图ID
			("RemainTime", c_int), # 剩余时间秒
			("RegainCnt", 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.DataMapID = 0
			self.RemainTime = 0
			self.RegainCnt = 0
			return

			def GetLength(self):
			return sizeof(tagMCFBCntRegain)

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

			def OutputString(self):
			DumpString = '''// B2 09 副本次数恢复剩余时间 //tagMCFBCntRegainRemainTime:
			DataMapID:%d,
			RemainTime:%d,
			RegainCnt:%d
			'''\
			%(
			self.DataMapID,
			self.RemainTime,
			self.RegainCnt
			)
			return DumpString


			class tagMCFBCntRegainRemainTime(Structure):
			Head = tagHead()
			Cnt = 0 #(BYTE Cnt)// 信息数
			InfoList = list() #(vector<tagMCFBCntRegain> InfoList)// 信息列表
			data = None

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

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

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB2
			self.Head.SubCmd = 0x09
			self.Cnt = 0
			self.InfoList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# B2 01 通知封魔坛双倍击杀状态 #tagMCFMTDoubleState

			class tagMCFMTDoubleState(Structure):
			class tagSCTianziKYInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("IsDouble", c_ubyte), #是否双倍
			("OldDouble", c_ubyte), #是否曾经允许双倍
			("LineID", c_ubyte), #今日是哪个lineID，对应副本表的功能线路ID
			("HistoryHurt", c_int), #本考验历史最大伤害，求余亿部分
			("HistoryHurtEx", c_int), #本考验历史最大伤害，整除亿部分
			("TodayHurt", c_int), #本考验今日最大伤害，求余亿部分
			("TodayHurtEx", c_int), #本考验今日最大伤害，整除亿部分
			]

			def __init__(self):
			@@ -39941,295 +36924,43 @@
			def Clear(self):
			self.Cmd = 0xB2
			self.SubCmd = 0x01
			self.IsDouble = 0
			self.OldDouble = 0
			return

			def GetLength(self):
			return sizeof(tagMCFMTDoubleState)

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

			def OutputString(self):
			DumpString = '''// B2 01 通知封魔坛双倍击杀状态 //tagMCFMTDoubleState:
			Cmd:%s,
			SubCmd:%s,
			IsDouble:%d,
			OldDouble:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.IsDouble,
			self.OldDouble
			)
			return DumpString


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


			#------------------------------------------------------
			# B2 03 公共副本扫荡信息 #tagMCPubFBSweepData

			class tagMCPubFBSweep(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("PubNum", c_ubyte), # 公共组编号
			("FBMapID", c_int), # 当前扫荡的副本地图ID
			("LineID", c_ushort), # lineID
			("SweepTime", c_int), # 开始扫荡的时间
			("SweepCnt", c_ubyte), # 扫荡次数
			]

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

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

			def Clear(self):
			self.Cmd = 0xB2
			self.SubCmd = 0x03
			self.PubNum = 0
			self.FBMapID = 0
			self.LineID = 0
			self.SweepTime = 0
			self.SweepCnt = 0
			self.HistoryHurt = 0
			self.HistoryHurtEx = 0
			self.TodayHurt = 0
			self.TodayHurtEx = 0
			return

			def GetLength(self):
			return sizeof(tagMCPubFBSweep)
			return sizeof(tagSCTianziKYInfo)

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

			def OutputString(self):
			DumpString = '''// B2 03 公共副本扫荡信息 //tagMCPubFBSweepData:
			DumpString = '''// B2 01 天子考验信息 //tagSCTianziKYInfo:
			Cmd:%s,
			SubCmd:%s,
			PubNum:%d,
			FBMapID:%d,
			LineID:%d,
			SweepTime:%d,
			SweepCnt:%d
			HistoryHurt:%d,
			HistoryHurtEx:%d,
			TodayHurt:%d,
			TodayHurtEx:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.PubNum,
			self.FBMapID,
			self.LineID,
			self.SweepTime,
			self.SweepCnt
			self.HistoryHurt,
			self.HistoryHurtEx,
			self.TodayHurt,
			self.TodayHurtEx
			)
			return DumpString


			class tagMCPubFBSweepData(Structure):
			Head = tagHead()
			Cnt = 0 #(BYTE Cnt)// 信息数
			SweepDatList = list() #(vector<tagMCPubFBSweep> SweepDatList)// 信息列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Cnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.Cnt):
			temSweepDatList = tagMCPubFBSweep()
			_pos = temSweepDatList.ReadData(_lpData, _pos)
			self.SweepDatList.append(temSweepDatList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB2
			self.Head.SubCmd = 0x03
			self.Cnt = 0
			self.SweepDatList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# B2 16 开始自定义场景结果 #tagMCStartCustomSceneResult

			class tagMCStartCustomSceneResult(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("MapID", c_int),
			("FuncLineID", c_ushort),
			("Result", c_ubyte), #是否允许
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB2
			self.SubCmd = 0x16
			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 = 0xB2
			self.SubCmd = 0x16
			self.MapID = 0
			self.FuncLineID = 0
			self.Result = 0
			return

			def GetLength(self):
			return sizeof(tagMCStartCustomSceneResult)

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

			def OutputString(self):
			DumpString = '''// B2 16 开始自定义场景结果 //tagMCStartCustomSceneResult:
			Cmd:%s,
			SubCmd:%s,
			MapID:%d,
			FuncLineID:%d,
			Result:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.MapID,
			self.FuncLineID,
			self.Result
			)
			return DumpString


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


			#------------------------------------------------------
			#B2 02 推送提醒设置通知 #tagMCPushNotificationsSetting

			class tagMCPushNotificationsSetting(Structure):
			Head = tagHead()
			OnoffBit = 0 #(DWORD OnoffBit)// 按位约定开关
			TimeLen = 0 #(BYTE TimeLen)
			TimeStr = "" #(String TimeStr)// 时间字符串 01:02-05:00
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.OnoffBit,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TimeLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.TimeStr,_pos = CommFunc.ReadString(_lpData, _pos,self.TimeLen)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB2
			self.Head.SubCmd = 0x02
			self.OnoffBit = 0
			self.TimeLen = 0
			self.TimeStr = ""
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.OnoffBit)
			data = CommFunc.WriteBYTE(data, self.TimeLen)
			data = CommFunc.WriteString(data, self.TimeLen, self.TimeStr)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			OnoffBit:%d,
			TimeLen:%d,
			TimeStr:%s
			'''\
			%(
			self.Head.OutputString(),
			self.OnoffBit,
			self.TimeLen,
			self.TimeStr
			)
			return DumpString


			m_NAtagMCPushNotificationsSetting=tagMCPushNotificationsSetting()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPushNotificationsSetting.Head.Cmd,m_NAtagMCPushNotificationsSetting.Head.SubCmd))] = m_NAtagMCPushNotificationsSetting
			m_NAtagSCTianziKYInfo=tagSCTianziKYInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCTianziKYInfo.Cmd,m_NAtagSCTianziKYInfo.SubCmd))] = m_NAtagSCTianziKYInfo


			#------------------------------------------------------
			@@ -44948,10 +41679,11 @@
			Head = tagHead()
			ObjID = 0 #(DWORD ObjID)
			PMType = 0 #(BYTE PMType)// 物法类型 0或1-物理；2-法术
			BattleType = 0 #(BYTE BattleType)// 战斗类型 0-常规；1-连击；2-反击；3-追击
			BattleType = 0 #(BYTE BattleType)// 战斗类型 0-常规；1-连击；2-反击；3-追击；4-子技能；5-被动触发的
			CurHP = 0 #(DWORD CurHP)// 释放技能后剩余血量，吸血、反弹可能引起变化，求余亿部分
			CurHPEx = 0 #(DWORD CurHPEx)// 释放技能后剩余血量，吸血、反弹可能引起变化，整除亿部分
			SkillID = 0 #(DWORD SkillID)
			RelatedSkillID = 0 #(DWORD RelatedSkillID)// 关联的技能ID，一般是主技能ID或由于某个技能释放引起的
			HurtCount = 0 #(BYTE HurtCount)//伤害数目
			HurtList = list() #(vector<tagSCUseSkillHurt> HurtList)//size = HurtCount
			data = None
			@@ -44971,6 +41703,7 @@
			self.CurHP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.CurHPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.SkillID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RelatedSkillID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HurtCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.HurtCount):
			temHurtList = tagSCUseSkillHurt()
			@@ -44989,6 +41722,7 @@
			self.CurHP = 0
			self.CurHPEx = 0
			self.SkillID = 0
			self.RelatedSkillID = 0
			self.HurtCount = 0
			self.HurtList = list()
			return
			@@ -44999,6 +41733,7 @@
			length += 4
			length += 1
			length += 1
			length += 4
			length += 4
			length += 4
			length += 4
			@@ -45017,6 +41752,7 @@
			data = CommFunc.WriteDWORD(data, self.CurHP)
			data = CommFunc.WriteDWORD(data, self.CurHPEx)
			data = CommFunc.WriteDWORD(data, self.SkillID)
			data = CommFunc.WriteDWORD(data, self.RelatedSkillID)
			data = CommFunc.WriteBYTE(data, self.HurtCount)
			for i in range(self.HurtCount):
			data = CommFunc.WriteString(data, self.HurtList[i].GetLength(), self.HurtList[i].GetBuffer())
			@@ -45031,6 +41767,7 @@
			CurHP:%d,
			CurHPEx:%d,
			SkillID:%d,
			RelatedSkillID:%d,
			HurtCount:%d,
			HurtList:%s
			'''\
			@@ -45042,6 +41779,7 @@
			self.CurHP,
			self.CurHPEx,
			self.SkillID,
			self.RelatedSkillID,
			self.HurtCount,
			"..."
			)
			@@ -54541,4 +51279,56 @@


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


			#------------------------------------------------------
			# C2 01 跨服服务器间的测试包 #tagSSTest

			class tagSSTest(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("Data", c_int), #测试
			]

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

			def GetLength(self):
			return sizeof(tagSSTest)

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

			def OutputString(self):
			DumpString = '''// C2 01 跨服服务器间的测试包 //tagSSTest:
			Cmd:%s,
			SubCmd:%s,
			Data:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.Data
			)
			return DumpString


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