SnxxServerCode.git

			@@ -17027,8 +17027,8 @@
			class tagGCCrossBillboardInfo(Structure):
			Head = tagHead()
			Type = 0 #(BYTE Type)//榜单类型
			GroupValue1 = 0 #(BYTE GroupValue1)// 分组值1
			GroupValue2 = 0 #(BYTE GroupValue2)// 分组值2，与分组值1组合归为同组榜单数据
			GroupValue1 = 0 #(DWORD GroupValue1)// 分组值1
			GroupValue2 = 0 #(DWORD GroupValue2)// 分组值2，与分组值1组合归为同组榜单数据
			WatchID = 0 #(DWORD WatchID)//查看指定ID名次前后，如玩家ID、家族ID等
			BillboardCount = 0 #(BYTE BillboardCount)
			CrossBillboardDataList = list() #(vector<tagGCCrossBillboardData> CrossBillboardDataList)
			@@ -17044,8 +17044,8 @@
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.Type,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.GroupValue2,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.GroupValue1,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.GroupValue2,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.WatchID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.BillboardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.BillboardCount):
			@@ -17071,8 +17071,8 @@
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 1
			length += 1
			length += 4
			length += 4
			length += 4
			length += 1
			for i in range(self.BillboardCount):
			@@ -17084,8 +17084,8 @@
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.Type)
			data = CommFunc.WriteBYTE(data, self.GroupValue1)
			data = CommFunc.WriteBYTE(data, self.GroupValue2)
			data = CommFunc.WriteDWORD(data, self.GroupValue1)
			data = CommFunc.WriteDWORD(data, self.GroupValue2)
			data = CommFunc.WriteDWORD(data, self.WatchID)
			data = CommFunc.WriteBYTE(data, self.BillboardCount)
			for i in range(self.BillboardCount):
			@@ -18518,6 +18518,1750 @@

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


			#------------------------------------------------------
			# C0 24 仙盟攻城战活动信息 #tagGCFamilyGCZActInfo

			class tagGCFamilyGCZActFamily(Structure):
			FamilyID = 0 #(DWORD FamilyID)
			Name = "" #(char Name[33])//参与仙盟名字
			LV = 0 #(BYTE LV)//仙盟等级
			ServerID = 0 #(DWORD ServerID)//仙盟所属区服ID
			EmblemID = 0 #(DWORD EmblemID)//徽章ID
			FightPower = 0 #(DWORD FightPower)//仙盟总战力，求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//仙盟总战力，整除亿部分
			LeaderID = 0 #(DWORD LeaderID)//盟主ID
			LeaderName = "" #(char LeaderName[33])//盟主名
			LeaderFace = 0 #(DWORD LeaderFace)
			LeaderFacePic = 0 #(DWORD LeaderFacePic)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.LV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ServerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.EmblemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.LeaderID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.LeaderName,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.LeaderFace,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.LeaderFacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.FamilyID = 0
			self.Name = ""
			self.LV = 0
			self.ServerID = 0
			self.EmblemID = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			self.LeaderID = 0
			self.LeaderName = ""
			self.LeaderFace = 0
			self.LeaderFacePic = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.FamilyID)
			data = CommFunc.WriteString(data, 33, self.Name)
			data = CommFunc.WriteBYTE(data, self.LV)
			data = CommFunc.WriteDWORD(data, self.ServerID)
			data = CommFunc.WriteDWORD(data, self.EmblemID)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteDWORD(data, self.LeaderID)
			data = CommFunc.WriteString(data, 33, self.LeaderName)
			data = CommFunc.WriteDWORD(data, self.LeaderFace)
			data = CommFunc.WriteDWORD(data, self.LeaderFacePic)
			return data

			def OutputString(self):
			DumpString = '''
			FamilyID:%d,
			Name:%s,
			LV:%d,
			ServerID:%d,
			EmblemID:%d,
			FightPower:%d,
			FightPowerEx:%d,
			LeaderID:%d,
			LeaderName:%s,
			LeaderFace:%d,
			LeaderFacePic:%d
			'''\
			%(
			self.FamilyID,
			self.Name,
			self.LV,
			self.ServerID,
			self.EmblemID,
			self.FightPower,
			self.FightPowerEx,
			self.LeaderID,
			self.LeaderName,
			self.LeaderFace,
			self.LeaderFacePic
			)
			return DumpString


			class tagGCFamilyGCZActInfo(Structure):
			Head = tagHead()
			ServerInfoLen = 0 #(BYTE ServerInfoLen)
			ServerIDRangeInfo = "" #(String ServerIDRangeInfo)//开放该活动的服务器ID范围列表，json格式 [[IDA, IDB], ...]， [] 为全服
			ZoneID = 0 #(BYTE ZoneID)// 活动分区ID，公示期为0
			ActID = 0 #(DWORD ActID)// 活动ID，代表某一次活动的唯一ID，前端如果有活动相关的本地记录可以通过验证此ID变更进行重置
			StartDate = "" #(char StartDate[10])// 开始日期 y-m-d
			EndtDate = "" #(char EndtDate[10])// 结束日期 y-m-d
			JoinFamilyCnt = 0 #(BYTE JoinFamilyCnt)// 参与仙盟数
			ActFlowID = 0 #(WORD ActFlowID)// 活动流程ID，对应H.活动时间流程表中的编号，前端根据跨服时间自行计算当前所处流程状态
			GuessTemplateID = 0 #(WORD GuessTemplateID)// 竞猜奖励模版，对应H.活动竞猜表，前端自行读表展示
			PersonalTemplateID = 0 #(WORD PersonalTemplateID)// 个人伤害排行奖励模版，对应H.活动榜单奖励模版表，前端自行读表展示
			FamilyTemplateID = 0 #(WORD FamilyTemplateID)// 仙盟积分排行奖励模版，对应H.活动榜单奖励模版表，前端自行读表展示
			StateError = 0 #(BYTE StateError)// 活动流程状态是否异常，如果不为0代表活动已异常，前端自行决定是不显示活动还是活动页面做提示
			FamilyCount = 0 #(BYTE FamilyCount)
			ActFamilyList = list() #(vector<tagGCFamilyGCZActFamily> ActFamilyList)//本分区参与的仙盟名单
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ServerInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ServerIDRangeInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ServerInfoLen)
			self.ZoneID,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ActID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)
			self.JoinFamilyCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.ActFlowID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.GuessTemplateID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.PersonalTemplateID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.FamilyTemplateID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.StateError,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.FamilyCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FamilyCount):
			temActFamilyList = tagGCFamilyGCZActFamily()
			_pos = temActFamilyList.ReadData(_lpData, _pos)
			self.ActFamilyList.append(temActFamilyList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x24
			self.ServerInfoLen = 0
			self.ServerIDRangeInfo = ""
			self.ZoneID = 0
			self.ActID = 0
			self.StartDate = ""
			self.EndtDate = ""
			self.JoinFamilyCnt = 0
			self.ActFlowID = 0
			self.GuessTemplateID = 0
			self.PersonalTemplateID = 0
			self.FamilyTemplateID = 0
			self.StateError = 0
			self.FamilyCount = 0
			self.ActFamilyList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += len(self.ServerIDRangeInfo)
			length += 1
			length += 4
			length += 10
			length += 10
			length += 1
			length += 2
			length += 2
			length += 2
			length += 2
			length += 1
			length += 1
			for i in range(self.FamilyCount):
			length += self.ActFamilyList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ServerInfoLen)
			data = CommFunc.WriteString(data, self.ServerInfoLen, self.ServerIDRangeInfo)
			data = CommFunc.WriteBYTE(data, self.ZoneID)
			data = CommFunc.WriteDWORD(data, self.ActID)
			data = CommFunc.WriteString(data, 10, self.StartDate)
			data = CommFunc.WriteString(data, 10, self.EndtDate)
			data = CommFunc.WriteBYTE(data, self.JoinFamilyCnt)
			data = CommFunc.WriteWORD(data, self.ActFlowID)
			data = CommFunc.WriteWORD(data, self.GuessTemplateID)
			data = CommFunc.WriteWORD(data, self.PersonalTemplateID)
			data = CommFunc.WriteWORD(data, self.FamilyTemplateID)
			data = CommFunc.WriteBYTE(data, self.StateError)
			data = CommFunc.WriteBYTE(data, self.FamilyCount)
			for i in range(self.FamilyCount):
			data = CommFunc.WriteString(data, self.ActFamilyList[i].GetLength(), self.ActFamilyList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			ServerInfoLen:%d,
			ServerIDRangeInfo:%s,
			ZoneID:%d,
			ActID:%d,
			StartDate:%s,
			EndtDate:%s,
			JoinFamilyCnt:%d,
			ActFlowID:%d,
			GuessTemplateID:%d,
			PersonalTemplateID:%d,
			FamilyTemplateID:%d,
			StateError:%d,
			FamilyCount:%d,
			ActFamilyList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.ServerInfoLen,
			self.ServerIDRangeInfo,
			self.ZoneID,
			self.ActID,
			self.StartDate,
			self.EndtDate,
			self.JoinFamilyCnt,
			self.ActFlowID,
			self.GuessTemplateID,
			self.PersonalTemplateID,
			self.FamilyTemplateID,
			self.StateError,
			self.FamilyCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 29 仙盟攻城战城池战斗信息 #tagGCFamilyGCZBatCityInfo

			class tagGCFamilyGCZBatCityInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("CityID", c_int), #城池ID
			("CityLV", c_ubyte), #城池等级
			("FamilyID", c_int), #所属仙盟ID，可能为0
			("GuardID", c_int), #当前防守成员ID，为0时表示没有防守成员了，城池已被击毁
			("HP", c_int), #防守成员剩余生命，求余亿部分，剩余生命为0时代表该防守成员被击败
			("HPEx", c_int), #防守成员剩余生命，整除亿部分
			("HPMax", c_int), #防守成员最大生命，求余亿部分
			("HPMaxEx", c_int), #防守成员最大生命，整除亿部分
			("AtkPlayerID", c_int), #发起攻击的玩家ID，可能为0，判断是否自己的ID进行相应的攻击表现
			("AtkRet", c_ubyte), #攻击结果，仅在攻击玩家ID不为0时有效，0--成功；1-目标已被击杀；2-城池已被摧毁；3-其他
			("KillCnt", c_ubyte), #本次攻击击杀防守人员数
			("HurtValue", c_int), #伤害飘血，求余亿部分
			("HurtValueEx", c_int), #伤害飘血，整除亿部分
			]

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

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

			def Clear(self):
			self.Cmd = 0xC0
			self.SubCmd = 0x29
			self.CityID = 0
			self.CityLV = 0
			self.FamilyID = 0
			self.GuardID = 0
			self.HP = 0
			self.HPEx = 0
			self.HPMax = 0
			self.HPMaxEx = 0
			self.AtkPlayerID = 0
			self.AtkRet = 0
			self.KillCnt = 0
			self.HurtValue = 0
			self.HurtValueEx = 0
			return

			def GetLength(self):
			return sizeof(tagGCFamilyGCZBatCityInfo)

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

			def OutputString(self):
			DumpString = '''// C0 29 仙盟攻城战城池战斗信息 //tagGCFamilyGCZBatCityInfo:
			Cmd:%s,
			SubCmd:%s,
			CityID:%d,
			CityLV:%d,
			FamilyID:%d,
			GuardID:%d,
			HP:%d,
			HPEx:%d,
			HPMax:%d,
			HPMaxEx:%d,
			AtkPlayerID:%d,
			AtkRet:%d,
			KillCnt:%d,
			HurtValue:%d,
			HurtValueEx:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.CityID,
			self.CityLV,
			self.FamilyID,
			self.GuardID,
			self.HP,
			self.HPEx,
			self.HPMax,
			self.HPMaxEx,
			self.AtkPlayerID,
			self.AtkRet,
			self.KillCnt,
			self.HurtValue,
			self.HurtValueEx
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 25 仙盟攻城战轮次分组信息 #tagGCFamilyGCZBatGroupInfo

			class tagGCFamilyGCZBatGroup(Structure):
			GroupNum = 0 #(BYTE GroupNum)// 分组编号，从1开始，对应A
			FamilyIDCnt = 0 #(BYTE FamilyIDCnt)
			FamilyIDList = list() #(vector<DWORD> FamilyIDList)// 仙盟ID列表，前端可以通过判断参与的仙盟ID是否在某个分组里面验证有没有战场参赛资格
			data = None

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

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

			def Clear(self):
			self.GroupNum = 0
			self.FamilyIDCnt = 0
			self.FamilyIDList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.GroupNum)
			data = CommFunc.WriteBYTE(data, self.FamilyIDCnt)
			for i in range(self.FamilyIDCnt):
			data = CommFunc.WriteDWORD(data, self.FamilyIDList[i])
			return data

			def OutputString(self):
			DumpString = '''
			GroupNum:%d,
			FamilyIDCnt:%d,
			FamilyIDList:%s
			'''\
			%(
			self.GroupNum,
			self.FamilyIDCnt,
			"..."
			)
			return DumpString


			class tagGCFamilyGCZBat(Structure):
			BatType = 0 #(BYTE BatType)// 战场类型 1-初级；2-中级；3-高级；
			GroupCnt = 0 #(BYTE GroupCnt)// 分组数
			GroupList = list() #(vector<tagGCFamilyGCZBatGroup> GroupList)// 分组列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.BatType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.GroupCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.GroupCnt):
			temGroupList = tagGCFamilyGCZBatGroup()
			_pos = temGroupList.ReadData(_lpData, _pos)
			self.GroupList.append(temGroupList)
			return _pos

			def Clear(self):
			self.BatType = 0
			self.GroupCnt = 0
			self.GroupList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.BatType)
			data = CommFunc.WriteBYTE(data, self.GroupCnt)
			for i in range(self.GroupCnt):
			data = CommFunc.WriteString(data, self.GroupList[i].GetLength(), self.GroupList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			BatType:%d,
			GroupCnt:%d,
			GroupList:%s
			'''\
			%(
			self.BatType,
			self.GroupCnt,
			"..."
			)
			return DumpString


			class tagGCFamilyGCZBatGroupInfo(Structure):
			Head = tagHead()
			RoundNum = 0 #(BYTE RoundNum)// 第x轮的分组，从1开始，没有在对应轮次战场分组里的视为没有该轮次的参赛资格
			BatTypeCnt = 0 #(BYTE BatTypeCnt)// 战场类型数
			BatList = list() #(vector<tagGCFamilyGCZBat> BatList)//战场列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.RoundNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.BatTypeCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.BatTypeCnt):
			temBatList = tagGCFamilyGCZBat()
			_pos = temBatList.ReadData(_lpData, _pos)
			self.BatList.append(temBatList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x25
			self.RoundNum = 0
			self.BatTypeCnt = 0
			self.BatList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			RoundNum:%d,
			BatTypeCnt:%d,
			BatList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.RoundNum,
			self.BatTypeCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 30 仙盟攻城战战斗战报 #tagGCFamilyGCZBatReport

			class tagGCFamilyGCZBatRepHurt(Structure):
			_pack_ = 1
			_fields_ = [
			("TagFamilyID", c_int), #目标仙盟ID
			("HurtValue", c_int), #输出伤害，求余亿部分
			("HurtValueEx", c_int), #输出伤害，整除亿部分
			]

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

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

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

			def GetLength(self):
			return sizeof(tagGCFamilyGCZBatRepHurt)

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

			def OutputString(self):
			DumpString = '''// C0 30 仙盟攻城战战斗战报 //tagGCFamilyGCZBatReport:
			TagFamilyID:%d,
			HurtValue:%d,
			HurtValueEx:%d
			'''\
			%(
			self.TagFamilyID,
			self.HurtValue,
			self.HurtValueEx
			)
			return DumpString


			class tagGCFamilyGCZBatReport(Structure):
			Head = tagHead()
			FamilyID = 0 #(DWORD FamilyID)// 战报仙盟ID
			DefRepCnt = 0 #(BYTE DefRepCnt)
			DefRepList = list() #(vector<tagGCFamilyGCZBatRepHurt> DefRepList)// 防守战报
			AtkRepCnt = 0 #(BYTE AtkRepCnt)
			AtkRepList = list() #(vector<tagGCFamilyGCZBatRepHurt> AtkRepList)// 进攻战报
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.DefRepCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.DefRepCnt):
			temDefRepList = tagGCFamilyGCZBatRepHurt()
			_pos = temDefRepList.ReadData(_lpData, _pos)
			self.DefRepList.append(temDefRepList)
			self.AtkRepCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.AtkRepCnt):
			temAtkRepList = tagGCFamilyGCZBatRepHurt()
			_pos = temAtkRepList.ReadData(_lpData, _pos)
			self.AtkRepList.append(temAtkRepList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x30
			self.FamilyID = 0
			self.DefRepCnt = 0
			self.DefRepList = list()
			self.AtkRepCnt = 0
			self.AtkRepList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 1
			for i in range(self.DefRepCnt):
			length += self.DefRepList[i].GetLength()
			length += 1
			for i in range(self.AtkRepCnt):
			length += self.AtkRepList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.FamilyID)
			data = CommFunc.WriteBYTE(data, self.DefRepCnt)
			for i in range(self.DefRepCnt):
			data = CommFunc.WriteString(data, self.DefRepList[i].GetLength(), self.DefRepList[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.AtkRepCnt)
			for i in range(self.AtkRepCnt):
			data = CommFunc.WriteString(data, self.AtkRepList[i].GetLength(), self.AtkRepList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			FamilyID:%d,
			DefRepCnt:%d,
			DefRepList:%s,
			AtkRepCnt:%d,
			AtkRepList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.FamilyID,
			self.DefRepCnt,
			"...",
			self.AtkRepCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 28 仙盟攻城战城池场景信息 #tagGCFamilyGCZBatSceneInfo

			class tagGCFamilyGCZBatScenePlayer(Structure):
			PlayerID = 0 #(DWORD PlayerID)
			Name = "" #(char Name[33])
			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.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.Name = ""
			self.Face = 0
			self.FacePic = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteString(data, 33, self.Name)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			return data

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


			class tagGCFamilyGCZBatSceneHurt(Structure):
			_pack_ = 1
			_fields_ = [
			("CityID", c_int), #被攻击的城池ID
			("HurtValue", c_int), #伤害飘血，求余亿部分
			("HurtValueEx", c_int), #伤害飘血，整除亿部分
			]

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

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

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

			def GetLength(self):
			return sizeof(tagGCFamilyGCZBatSceneHurt)

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

			def OutputString(self):
			DumpString = '''// C0 28 仙盟攻城战城池场景信息 //tagGCFamilyGCZBatSceneInfo:
			CityID:%d,
			HurtValue:%d,
			HurtValueEx:%d
			'''\
			%(
			self.CityID,
			self.HurtValue,
			self.HurtValueEx
			)
			return DumpString


			class tagGCFamilyGCZBatSceneCity(Structure):
			_pack_ = 1
			_fields_ = [
			("CityID", c_int), #城池ID
			("CityLV", c_ubyte), #城池等级
			("FamilyID", c_int), #所属仙盟ID，可能为0
			("Rank", c_ubyte), #当前名次，从1开始
			("HP", c_int), #剩余生命，求余亿部分，剩余生命为0时代表被摧毁
			("HPEx", c_int), #剩余生命，整除亿部分
			("HPMax", c_int), #最大生命，求余亿部分
			("HPMaxEx", c_int), #最大生命，整除亿部分
			("LastAtkedTime", c_int), #最后一次被攻击时间戳，可能为0
			]

			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.CityID = 0
			self.CityLV = 0
			self.FamilyID = 0
			self.Rank = 0
			self.HP = 0
			self.HPEx = 0
			self.HPMax = 0
			self.HPMaxEx = 0
			self.LastAtkedTime = 0
			return

			def GetLength(self):
			return sizeof(tagGCFamilyGCZBatSceneCity)

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

			def OutputString(self):
			DumpString = '''// C0 28 仙盟攻城战城池场景信息 //tagGCFamilyGCZBatSceneInfo:
			CityID:%d,
			CityLV:%d,
			FamilyID:%d,
			Rank:%d,
			HP:%d,
			HPEx:%d,
			HPMax:%d,
			HPMaxEx:%d,
			LastAtkedTime:%d
			'''\
			%(
			self.CityID,
			self.CityLV,
			self.FamilyID,
			self.Rank,
			self.HP,
			self.HPEx,
			self.HPMax,
			self.HPMaxEx,
			self.LastAtkedTime
			)
			return DumpString


			class tagGCFamilyGCZBatSceneInfo(Structure):
			Head = tagHead()
			BatType = 0 #(BYTE BatType)// 战场类型 1-初级；2-中级；3-高级；
			GroupNum = 0 #(BYTE GroupNum)// 分组编号，从1开始，对应A
			TopFamilyID = 0 #(DWORD TopFamilyID)// 伤害第一仙盟ID
			TopLeaderID = 0 #(DWORD TopLeaderID)// 伤害第一盟主ID
			TopPlayerID = 0 #(DWORD TopPlayerID)// 伤害第一玩家ID
			TopPlayerFamilyID = 0 #(DWORD TopPlayerFamilyID)// 伤害第一玩家仙盟ID
			AtkPlayerID = 0 #(DWORD AtkPlayerID)// 发起攻击的玩家，可能为0，仅技能攻击时通知，普攻时仅通知血量等信息
			AtkType = 0 #(BYTE AtkType)// 攻击类型，有发起攻击的玩家时有效
			KillCnt = 0 #(BYTE KillCnt)// 本次攻击累计击杀数，有发起攻击的玩家时有效
			HurtCnt = 0 #(BYTE HurtCnt)
			HurtList = list() #(vector<tagGCFamilyGCZBatSceneHurt> HurtList)//本次攻击伤血信息，有发起攻击的玩家时有效
			CityCnt = 0 #(BYTE CityCnt)
			CityList = list() #(vector<tagGCFamilyGCZBatSceneCity> CityList)// 城池信息，仅通知变化的城池
			PlayerCnt = 0 #(BYTE PlayerCnt)
			PlayerInfoList = list() #(vector<tagGCFamilyGCZBatScenePlayer> PlayerInfoList)// 场景展示所需要用到的玩家信息，如第一玩家、使用技能玩家
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.BatType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.GroupNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.TopFamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TopLeaderID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TopPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TopPlayerFamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.AtkPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.AtkType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.KillCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.HurtCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.HurtCnt):
			temHurtList = tagGCFamilyGCZBatSceneHurt()
			_pos = temHurtList.ReadData(_lpData, _pos)
			self.HurtList.append(temHurtList)
			self.CityCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.CityCnt):
			temCityList = tagGCFamilyGCZBatSceneCity()
			_pos = temCityList.ReadData(_lpData, _pos)
			self.CityList.append(temCityList)
			self.PlayerCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.PlayerCnt):
			temPlayerInfoList = tagGCFamilyGCZBatScenePlayer()
			_pos = temPlayerInfoList.ReadData(_lpData, _pos)
			self.PlayerInfoList.append(temPlayerInfoList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x28
			self.BatType = 0
			self.GroupNum = 0
			self.TopFamilyID = 0
			self.TopLeaderID = 0
			self.TopPlayerID = 0
			self.TopPlayerFamilyID = 0
			self.AtkPlayerID = 0
			self.AtkType = 0
			self.KillCnt = 0
			self.HurtCnt = 0
			self.HurtList = list()
			self.CityCnt = 0
			self.CityList = list()
			self.PlayerCnt = 0
			self.PlayerInfoList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 1
			length += 4
			length += 4
			length += 4
			length += 4
			length += 4
			length += 1
			length += 1
			length += 1
			for i in range(self.HurtCnt):
			length += self.HurtList[i].GetLength()
			length += 1
			for i in range(self.CityCnt):
			length += self.CityList[i].GetLength()
			length += 1
			for i in range(self.PlayerCnt):
			length += self.PlayerInfoList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.BatType)
			data = CommFunc.WriteBYTE(data, self.GroupNum)
			data = CommFunc.WriteDWORD(data, self.TopFamilyID)
			data = CommFunc.WriteDWORD(data, self.TopLeaderID)
			data = CommFunc.WriteDWORD(data, self.TopPlayerID)
			data = CommFunc.WriteDWORD(data, self.TopPlayerFamilyID)
			data = CommFunc.WriteDWORD(data, self.AtkPlayerID)
			data = CommFunc.WriteBYTE(data, self.AtkType)
			data = CommFunc.WriteBYTE(data, self.KillCnt)
			data = CommFunc.WriteBYTE(data, self.HurtCnt)
			for i in range(self.HurtCnt):
			data = CommFunc.WriteString(data, self.HurtList[i].GetLength(), self.HurtList[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.CityCnt)
			for i in range(self.CityCnt):
			data = CommFunc.WriteString(data, self.CityList[i].GetLength(), self.CityList[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.PlayerCnt)
			for i in range(self.PlayerCnt):
			data = CommFunc.WriteString(data, self.PlayerInfoList[i].GetLength(), self.PlayerInfoList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			BatType:%d,
			GroupNum:%d,
			TopFamilyID:%d,
			TopLeaderID:%d,
			TopPlayerID:%d,
			TopPlayerFamilyID:%d,
			AtkPlayerID:%d,
			AtkType:%d,
			KillCnt:%d,
			HurtCnt:%d,
			HurtList:%s,
			CityCnt:%d,
			CityList:%s,
			PlayerCnt:%d,
			PlayerInfoList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.BatType,
			self.GroupNum,
			self.TopFamilyID,
			self.TopLeaderID,
			self.TopPlayerID,
			self.TopPlayerFamilyID,
			self.AtkPlayerID,
			self.AtkType,
			self.KillCnt,
			self.HurtCnt,
			"...",
			self.CityCnt,
			"...",
			self.PlayerCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 26 仙盟攻城战大本营信息 #tagGCFamilyGCZCampInfo

			class tagGCFamilyGCZCampMem(Structure):
			PlayerID = 0 #(DWORD PlayerID)
			Name = "" #(char Name[33])//参与玩家名字
			FamilyLV = 0 #(BYTE FamilyLV)//参与时的家族职位
			Face = 0 #(DWORD Face)//基本脸型
			FacePic = 0 #(DWORD FacePic)//头像框
			FightPower = 0 #(DWORD FightPower)//战力，求余亿部分
			FightPowerEx = 0 #(DWORD FightPowerEx)//战力，整除亿部分
			HP = 0 #(DWORD HP)//剩余生命，求余亿部分
			HPEx = 0 #(DWORD HPEx)//剩余生命，整除亿部分
			HPMax = 0 #(DWORD HPMax)//最大生命，求余亿部分
			HPMaxEx = 0 #(DWORD HPMaxEx)//最大生命，整除亿部分
			TotalHurt = 0 #(DWORD TotalHurt)//活动总伤害，求余亿部分，如果不在榜上则读该值
			TotalHurtEx = 0 #(DWORD TotalHurtEx)//活动总伤害，整除亿部分
			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.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.FamilyLV,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPower,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FightPowerEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HPMax,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HPMaxEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TotalHurt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TotalHurtEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.Name = ""
			self.FamilyLV = 0
			self.Face = 0
			self.FacePic = 0
			self.FightPower = 0
			self.FightPowerEx = 0
			self.HP = 0
			self.HPEx = 0
			self.HPMax = 0
			self.HPMaxEx = 0
			self.TotalHurt = 0
			self.TotalHurtEx = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteString(data, 33, self.Name)
			data = CommFunc.WriteBYTE(data, self.FamilyLV)
			data = CommFunc.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.FightPower)
			data = CommFunc.WriteDWORD(data, self.FightPowerEx)
			data = CommFunc.WriteDWORD(data, self.HP)
			data = CommFunc.WriteDWORD(data, self.HPEx)
			data = CommFunc.WriteDWORD(data, self.HPMax)
			data = CommFunc.WriteDWORD(data, self.HPMaxEx)
			data = CommFunc.WriteDWORD(data, self.TotalHurt)
			data = CommFunc.WriteDWORD(data, self.TotalHurtEx)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			Name:%s,
			FamilyLV:%d,
			Face:%d,
			FacePic:%d,
			FightPower:%d,
			FightPowerEx:%d,
			HP:%d,
			HPEx:%d,
			HPMax:%d,
			HPMaxEx:%d,
			TotalHurt:%d,
			TotalHurtEx:%d
			'''\
			%(
			self.PlayerID,
			self.Name,
			self.FamilyLV,
			self.Face,
			self.FacePic,
			self.FightPower,
			self.FightPowerEx,
			self.HP,
			self.HPEx,
			self.HPMax,
			self.HPMaxEx,
			self.TotalHurt,
			self.TotalHurtEx
			)
			return DumpString


			class tagGCFamilyGCZCampInfo(Structure):
			Head = tagHead()
			FamilyID = 0 #(DWORD FamilyID)//所在活动仙盟ID，可能不是玩家当前的仙盟ID，活动以该ID为准
			Score = 0 #(WORD Score)//活动总积分，如果不在榜上则读该值
			CampLV = 0 #(WORD CampLV)//大本营当前等级
			CampExp = 0 #(DWORD CampExp)//大本营当前经验
			CityLV = 0 #(WORD CityLV)//城池属性等级，开战后可能与当前大本营等级不一样
			HPBase = 0 #(DWORD HPBase)//基础生命，求余亿部分
			HPBaseEx = 0 #(DWORD HPBaseEx)//基础生命，整除亿部分
			HPMax = 0 #(DWORD HPMax)//总生命，求余亿部分
			HPMaxEx = 0 #(DWORD HPMaxEx)//总大生命，整除亿部分
			HP = 0 #(DWORD HP)//剩余生命，求余亿部分
			HPEx = 0 #(DWORD HPEx)//剩余生命，整除亿部分
			DefMemCnt = 0 #(BYTE DefMemCnt)
			DefMemList = list() #(vector<tagGCFamilyGCZCampMem> DefMemList)//防守成员列表，有同步则差异更新，没有在防守成员里的视为没有参与资格
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Score,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.CampLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.CampExp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.CityLV,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.HPBase,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HPBaseEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HPMax,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HPMaxEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HP,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HPEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.DefMemCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.DefMemCnt):
			temDefMemList = tagGCFamilyGCZCampMem()
			_pos = temDefMemList.ReadData(_lpData, _pos)
			self.DefMemList.append(temDefMemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x26
			self.FamilyID = 0
			self.Score = 0
			self.CampLV = 0
			self.CampExp = 0
			self.CityLV = 0
			self.HPBase = 0
			self.HPBaseEx = 0
			self.HPMax = 0
			self.HPMaxEx = 0
			self.HP = 0
			self.HPEx = 0
			self.DefMemCnt = 0
			self.DefMemList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.FamilyID)
			data = CommFunc.WriteWORD(data, self.Score)
			data = CommFunc.WriteWORD(data, self.CampLV)
			data = CommFunc.WriteDWORD(data, self.CampExp)
			data = CommFunc.WriteWORD(data, self.CityLV)
			data = CommFunc.WriteDWORD(data, self.HPBase)
			data = CommFunc.WriteDWORD(data, self.HPBaseEx)
			data = CommFunc.WriteDWORD(data, self.HPMax)
			data = CommFunc.WriteDWORD(data, self.HPMaxEx)
			data = CommFunc.WriteDWORD(data, self.HP)
			data = CommFunc.WriteDWORD(data, self.HPEx)
			data = CommFunc.WriteBYTE(data, self.DefMemCnt)
			for i in range(self.DefMemCnt):
			data = CommFunc.WriteString(data, self.DefMemList[i].GetLength(), self.DefMemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			FamilyID:%d,
			Score:%d,
			CampLV:%d,
			CampExp:%d,
			CityLV:%d,
			HPBase:%d,
			HPBaseEx:%d,
			HPMax:%d,
			HPMaxEx:%d,
			HP:%d,
			HPEx:%d,
			DefMemCnt:%d,
			DefMemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.FamilyID,
			self.Score,
			self.CampLV,
			self.CampExp,
			self.CityLV,
			self.HPBase,
			self.HPBaseEx,
			self.HPMax,
			self.HPMaxEx,
			self.HP,
			self.HPEx,
			self.DefMemCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 27 仙盟攻城战成员贡献值信息 #tagGCFamilyGCZContributionInfo

			class tagGCFamilyGCZContribution(Structure):
			_pack_ = 1
			_fields_ = [
			("PlayerID", c_int),
			("ContributionValue", c_int), #贡献值
			]

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

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

			def Clear(self):
			self.PlayerID = 0
			self.ContributionValue = 0
			return

			def GetLength(self):
			return sizeof(tagGCFamilyGCZContribution)

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

			def OutputString(self):
			DumpString = '''// C0 27 仙盟攻城战成员贡献值信息 //tagGCFamilyGCZContributionInfo:
			PlayerID:%d,
			ContributionValue:%d
			'''\
			%(
			self.PlayerID,
			self.ContributionValue
			)
			return DumpString


			class tagGCFamilyGCZContributionInfo(Structure):
			Head = tagHead()
			ContriCnt = 0 #(BYTE ContriCnt)
			ContriList = list() #(vector<tagGCFamilyGCZContribution> ContriList)//成员贡献值列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.ContriCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.ContriCnt):
			temContriList = tagGCFamilyGCZContribution()
			_pos = temContriList.ReadData(_lpData, _pos)
			self.ContriList.append(temContriList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x27
			self.ContriCnt = 0
			self.ContriList = list()
			return

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

			return length

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

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


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


			#------------------------------------------------------
			# C0 31 仙盟攻城战分组仙盟成员伤害明细 #tagGCFamilyGCZGroupFamilyMemHurtInfo

			class tagGCFamilyGCZGroupFamilyMemHurt(Structure):
			PlayerID = 0 #(DWORD PlayerID)
			Name = "" #(char Name[33])//参与玩家名字
			HurtValue = 0 #(DWORD HurtValue)//伤害，求余亿部分
			HurtValueEx = 0 #(DWORD HurtValueEx)//伤害，整除亿部分
			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.Name,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.HurtValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HurtValueEx,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.Name = ""
			self.HurtValue = 0
			self.HurtValueEx = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteString(data, 33, self.Name)
			data = CommFunc.WriteDWORD(data, self.HurtValue)
			data = CommFunc.WriteDWORD(data, self.HurtValueEx)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			Name:%s,
			HurtValue:%d,
			HurtValueEx:%d
			'''\
			%(
			self.PlayerID,
			self.Name,
			self.HurtValue,
			self.HurtValueEx
			)
			return DumpString


			class tagGCFamilyGCZGroupFamilyMemHurtInfo(Structure):
			Head = tagHead()
			FamilyID = 0 #(DWORD FamilyID)//查看的目标仙盟ID
			HurtMemCnt = 0 #(BYTE HurtMemCnt)
			HurtMemList = list() #(vector<tagGCFamilyGCZGroupFamilyMemHurt> HurtMemList)//成员伤害明细列表，只算城池被摧毁前的伤害，未排序，前端自己排序
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.FamilyID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HurtMemCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.HurtMemCnt):
			temHurtMemList = tagGCFamilyGCZGroupFamilyMemHurt()
			_pos = temHurtMemList.ReadData(_lpData, _pos)
			self.HurtMemList.append(temHurtMemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x31
			self.FamilyID = 0
			self.HurtMemCnt = 0
			self.HurtMemList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			FamilyID:%d,
			HurtMemCnt:%d,
			HurtMemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.FamilyID,
			self.HurtMemCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# C0 32 仙盟攻城战竞猜名单信息 #tagGCFamilyGCZGuessInfo

			class tagGCFamilyGCZGuessFamily(Structure):
			_pack_ = 1
			_fields_ = [
			("FamilyID", c_int), #备选仙盟ID
			("GuessValue", c_ushort), #竞猜热度值，玩家每次选择则加1，重复选择也算
			]

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

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

			def Clear(self):
			self.FamilyID = 0
			self.GuessValue = 0
			return

			def GetLength(self):
			return sizeof(tagGCFamilyGCZGuessFamily)

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

			def OutputString(self):
			DumpString = '''// C0 32 仙盟攻城战竞猜名单信息 //tagGCFamilyGCZGuessInfo:
			FamilyID:%d,
			GuessValue:%d
			'''\
			%(
			self.FamilyID,
			self.GuessValue
			)
			return DumpString


			class tagGCFamilyGCZGuessRight(Structure):
			_pack_ = 1
			_fields_ = [
			("AwardID", c_ubyte), #奖励ID
			("RightPlayerCnt", 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.AwardID = 0
			self.RightPlayerCnt = 0
			return

			def GetLength(self):
			return sizeof(tagGCFamilyGCZGuessRight)

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

			def OutputString(self):
			DumpString = '''// C0 32 仙盟攻城战竞猜名单信息 //tagGCFamilyGCZGuessInfo:
			AwardID:%d,
			RightPlayerCnt:%d
			'''\
			%(
			self.AwardID,
			self.RightPlayerCnt
			)
			return DumpString


			class tagGCFamilyGCZGuessInfo(Structure):
			Head = tagHead()
			PlayerID = 0 #(DWORD PlayerID)//竞猜玩家ID，有玩家修改竞猜时会附带该信息，如果是自己ID，则更新自己的竞猜选项，否则无视
			SelectCnt = 0 #(BYTE SelectCnt)
			SelectFamilyIDList = list() #(vector<DWORD> SelectFamilyIDList)//竞猜玩家选择的仙盟ID顺序
			FinalCnt = 0 #(BYTE FinalCnt)
			FinalFamilyIDList = list() #(vector<DWORD> FinalFamilyIDList)//最终排名顺序，仅活动排名出来后才有值
			RightCnt = 0 #(BYTE RightCnt)
			RightInfoList = list() #(vector<tagGCFamilyGCZGuessRight> RightInfoList)//猜中个数明细列表
			FamilyCnt = 0 #(BYTE FamilyCnt)
			GuessFamilyList = list() #(vector<tagGCFamilyGCZGuessFamily> GuessFamilyList)//备选仙盟名单列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x32
			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.SelectCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.SelectCnt):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.SelectFamilyIDList.append(value)
			self.FinalCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FinalCnt):
			value,_pos=CommFunc.ReadDWORD(_lpData,_pos)
			self.FinalFamilyIDList.append(value)
			self.RightCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.RightCnt):
			temRightInfoList = tagGCFamilyGCZGuessRight()
			_pos = temRightInfoList.ReadData(_lpData, _pos)
			self.RightInfoList.append(temRightInfoList)
			self.FamilyCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.FamilyCnt):
			temGuessFamilyList = tagGCFamilyGCZGuessFamily()
			_pos = temGuessFamilyList.ReadData(_lpData, _pos)
			self.GuessFamilyList.append(temGuessFamilyList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xC0
			self.Head.SubCmd = 0x32
			self.PlayerID = 0
			self.SelectCnt = 0
			self.SelectFamilyIDList = list()
			self.FinalCnt = 0
			self.FinalFamilyIDList = list()
			self.RightCnt = 0
			self.RightInfoList = list()
			self.FamilyCnt = 0
			self.GuessFamilyList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 4
			length += 1
			length += 4 * self.SelectCnt
			length += 1
			length += 4 * self.FinalCnt
			length += 1
			for i in range(self.RightCnt):
			length += self.RightInfoList[i].GetLength()
			length += 1
			for i in range(self.FamilyCnt):
			length += self.GuessFamilyList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteBYTE(data, self.SelectCnt)
			for i in range(self.SelectCnt):
			data = CommFunc.WriteDWORD(data, self.SelectFamilyIDList[i])
			data = CommFunc.WriteBYTE(data, self.FinalCnt)
			for i in range(self.FinalCnt):
			data = CommFunc.WriteDWORD(data, self.FinalFamilyIDList[i])
			data = CommFunc.WriteBYTE(data, self.RightCnt)
			for i in range(self.RightCnt):
			data = CommFunc.WriteString(data, self.RightInfoList[i].GetLength(), self.RightInfoList[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.FamilyCnt)
			for i in range(self.FamilyCnt):
			data = CommFunc.WriteString(data, self.GuessFamilyList[i].GetLength(), self.GuessFamilyList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			PlayerID:%d,
			SelectCnt:%d,
			SelectFamilyIDList:%s,
			FinalCnt:%d,
			FinalFamilyIDList:%s,
			RightCnt:%d,
			RightInfoList:%s,
			FamilyCnt:%d,
			GuessFamilyList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.PlayerID,
			self.SelectCnt,
			"...",
			self.FinalCnt,
			"...",
			self.RightCnt,
			"...",
			self.FamilyCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -57675,6 +59419,70 @@


			#------------------------------------------------------
			# C1 10 仙盟攻城战玩家信息 #tagMCFamilyGCZPlayerInfo

			class tagMCFamilyGCZPlayerInfo(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("ContributionCnt", c_ubyte), # 轮次低级捐献已捐献次数，轮次变更时会重置
			("Energy", c_ubyte), # 当前可用免费体力
			("EnergyTime", c_int), # 上次恢复免费体力时间戳，为0时不再恢复
			("AwardState", c_int), # 活动奖励领取状态，按二进制位判断是否已领取，0-竞猜奖励；1-个人排行奖励；2-仙盟排名奖励；
			]

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

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

			def Clear(self):
			self.Cmd = 0xC1
			self.SubCmd = 0x10
			self.ContributionCnt = 0
			self.Energy = 0
			self.EnergyTime = 0
			self.AwardState = 0
			return

			def GetLength(self):
			return sizeof(tagMCFamilyGCZPlayerInfo)

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

			def OutputString(self):
			DumpString = '''// C1 10 仙盟攻城战玩家信息 //tagMCFamilyGCZPlayerInfo:
			Cmd:%s,
			SubCmd:%s,
			ContributionCnt:%d,
			Energy:%d,
			EnergyTime:%d,
			AwardState:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.ContributionCnt,
			self.Energy,
			self.EnergyTime,
			self.AwardState
			)
			return DumpString


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


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

			class tagMCLuckyCloudBuyPlayerInfo(Structure):