Project_SG_ServerCode.git

			@@ -40077,54 +40077,6 @@


			#------------------------------------------------------
			# B0 50 收杆结果 #tagMCFishResult

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

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

			def GetLength(self):
			return sizeof(tagMCFishResult)

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

			def OutputString(self):
			DumpString = '''// B0 50 收杆结果 //tagMCFishResult:
			Cmd:%s,
			SubCmd:%s
			'''\
			%(
			self.Cmd,
			self.SubCmd
			)
			return DumpString


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


			#------------------------------------------------------
			# B0 05 接收协助感谢礼物预览 #tagGCGetAssistThanksGiftPreview

			class tagGCGetAssistThanksGiftPreview(Structure):
			@@ -40280,568 +40232,20 @@


			#------------------------------------------------------
			# B0 34 福地结算奖励信息 #tagGCMineAreaAwardInfo
			# B0 37 淘金营地信息 #tagSCGoldRushCampInfo

			class tagGCMineAreaAwardInfo(Structure):
			Head = tagHead()
			AwardType = 0 #(BYTE AwardType)// 0-通知有奖励，前端下次进入福地可请求进行结算；1-结算奖励结果通知
			AwardLen = 0 #(BYTE AwardLen)
			AwardInfo = "" #(String AwardInfo)//奖励信息 [物品ID,个数,是否拍品], ...]
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x34
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.AwardType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.AwardLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.AwardInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.AwardLen)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x34
			self.AwardType = 0
			self.AwardLen = 0
			self.AwardInfo = ""
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.AwardType)
			data = CommFunc.WriteBYTE(data, self.AwardLen)
			data = CommFunc.WriteString(data, self.AwardLen, self.AwardInfo)
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			AwardType:%d,
			AwardLen:%d,
			AwardInfo:%s
			'''\
			%(
			self.Head.OutputString(),
			self.AwardType,
			self.AwardLen,
			self.AwardInfo
			)
			return DumpString


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


			#------------------------------------------------------
			# B0 33 福地详细信息 #tagGCMineAreaInfo

			class tagGCMineItem(Structure):
			Index = 0 #(BYTE Index)// 矿物所在福地位置索引，0~n
			MineID = 0 #(WORD MineID)// 矿物ID，对应福地采集表中ID，0代表该索引位置没有矿物
			MineType = 0 #(BYTE MineType)// 矿物类型：0-常规；1-超级
			UpdTime = 0 #(DWORD UpdTime)// 最后一次更新时间戳
			PosLen = 0 #(BYTE PosLen)
			Position = "" #(String Position)// 最后一次更新时所在位置百分比，0~100，支持小数，下0上100，可认为分为100格，速度为 x格/秒
			SpeedLen = 0 #(BYTE SpeedLen)
			MoveSpeed = "" #(String MoveSpeed)// 移动速度，x格/秒，支持小数
			EndTime = 0 #(DWORD EndTime)// 拉取结束时间戳
			WorkerCount = 0 #(BYTE WorkerCount)// 工人个数，为0时代表福地玩家没有使用工人拉回
			RobPlayerID = 0 #(DWORD RobPlayerID)// 抢夺玩家ID，为0时代表没人抢夺
			RobWorkerCount = 0 #(BYTE RobWorkerCount)// 抢夺工人个数
			RobPlayerName = "" #(char RobPlayerName[33])
			RobJob = 0 #(BYTE RobJob)
			RobFace = 0 #(DWORD RobFace)
			RobFacePic = 0 #(DWORD RobFacePic)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.Index,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MineID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.MineType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.UpdTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PosLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.Position,_pos = CommFunc.ReadString(_lpData, _pos,self.PosLen)
			self.SpeedLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MoveSpeed,_pos = CommFunc.ReadString(_lpData, _pos,self.SpeedLen)
			self.EndTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.WorkerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.RobPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RobWorkerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.RobPlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.RobJob,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.RobFace,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RobFacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.Index = 0
			self.MineID = 0
			self.MineType = 0
			self.UpdTime = 0
			self.PosLen = 0
			self.Position = ""
			self.SpeedLen = 0
			self.MoveSpeed = ""
			self.EndTime = 0
			self.WorkerCount = 0
			self.RobPlayerID = 0
			self.RobWorkerCount = 0
			self.RobPlayerName = ""
			self.RobJob = 0
			self.RobFace = 0
			self.RobFacePic = 0
			return

			def GetLength(self):
			length = 0
			length += 1
			length += 2
			length += 1
			length += 4
			length += 1
			length += len(self.Position)
			length += 1
			length += len(self.MoveSpeed)
			length += 4
			length += 1
			length += 4
			length += 1
			length += 33
			length += 1
			length += 4
			length += 4

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.Index)
			data = CommFunc.WriteWORD(data, self.MineID)
			data = CommFunc.WriteBYTE(data, self.MineType)
			data = CommFunc.WriteDWORD(data, self.UpdTime)
			data = CommFunc.WriteBYTE(data, self.PosLen)
			data = CommFunc.WriteString(data, self.PosLen, self.Position)
			data = CommFunc.WriteBYTE(data, self.SpeedLen)
			data = CommFunc.WriteString(data, self.SpeedLen, self.MoveSpeed)
			data = CommFunc.WriteDWORD(data, self.EndTime)
			data = CommFunc.WriteBYTE(data, self.WorkerCount)
			data = CommFunc.WriteDWORD(data, self.RobPlayerID)
			data = CommFunc.WriteBYTE(data, self.RobWorkerCount)
			data = CommFunc.WriteString(data, 33, self.RobPlayerName)
			data = CommFunc.WriteBYTE(data, self.RobJob)
			data = CommFunc.WriteDWORD(data, self.RobFace)
			data = CommFunc.WriteDWORD(data, self.RobFacePic)
			return data

			def OutputString(self):
			DumpString = '''
			Index:%d,
			MineID:%d,
			MineType:%d,
			UpdTime:%d,
			PosLen:%d,
			Position:%s,
			SpeedLen:%d,
			MoveSpeed:%s,
			EndTime:%d,
			WorkerCount:%d,
			RobPlayerID:%d,
			RobWorkerCount:%d,
			RobPlayerName:%s,
			RobJob:%d,
			RobFace:%d,
			RobFacePic:%d
			'''\
			%(
			self.Index,
			self.MineID,
			self.MineType,
			self.UpdTime,
			self.PosLen,
			self.Position,
			self.SpeedLen,
			self.MoveSpeed,
			self.EndTime,
			self.WorkerCount,
			self.RobPlayerID,
			self.RobWorkerCount,
			self.RobPlayerName,
			self.RobJob,
			self.RobFace,
			self.RobFacePic
			)
			return DumpString


			class tagGCMineArea(Structure):
			PlayerID = 0 #(DWORD PlayerID)// 福地所属玩家ID，可能是自己或其他玩家ID，当ID小于10000时为假人
			PlayerName = "" #(char PlayerName[33])// 可能为空，如自己或假人
			Job = 0 #(BYTE Job)
			Face = 0 #(DWORD Face)
			FacePic = 0 #(DWORD FacePic)
			RobValue = 0 #(DWORD RobValue)// 抢劫敌对值
			MineCount = 0 #(BYTE MineCount)
			MineItemList = list() #(vector<tagGCMineItem> MineItemList)// 矿物列表
			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.Face,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.FacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RobValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MineCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.MineCount):
			temMineItemList = tagGCMineItem()
			_pos = temMineItemList.ReadData(_lpData, _pos)
			self.MineItemList.append(temMineItemList)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.PlayerName = ""
			self.Job = 0
			self.Face = 0
			self.FacePic = 0
			self.RobValue = 0
			self.MineCount = 0
			self.MineItemList = list()
			return

			def GetLength(self):
			length = 0
			length += 4
			length += 33
			length += 1
			length += 4
			length += 4
			length += 4
			length += 1
			for i in range(self.MineCount):
			length += self.MineItemList[i].GetLength()

			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.WriteDWORD(data, self.Face)
			data = CommFunc.WriteDWORD(data, self.FacePic)
			data = CommFunc.WriteDWORD(data, self.RobValue)
			data = CommFunc.WriteBYTE(data, self.MineCount)
			for i in range(self.MineCount):
			data = CommFunc.WriteString(data, self.MineItemList[i].GetLength(), self.MineItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			PlayerName:%s,
			Job:%d,
			Face:%d,
			FacePic:%d,
			RobValue:%d,
			MineCount:%d,
			MineItemList:%s
			'''\
			%(
			self.PlayerID,
			self.PlayerName,
			self.Job,
			self.Face,
			self.FacePic,
			self.RobValue,
			self.MineCount,
			"..."
			)
			return DumpString


			class tagGCMineAreaInfo(Structure):
			Head = tagHead()
			QueryType = 0 #(BYTE QueryType)// 查询同步类型：0-后端主动同步；1-查看指定福地；2-查看道友福地列表；3-查看周围随机福地列表
			QueryValue = 0 #(DWORD QueryValue)// 查询值，类型1时-发送目标玩家ID；3时-发送是否重新随机
			AreaCount = 0 #(BYTE AreaCount)
			AreaList = list() #(vector<tagGCMineArea> AreaList)// 福地列表
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x33
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.QueryType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.QueryValue,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.AreaCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.AreaCount):
			temAreaList = tagGCMineArea()
			_pos = temAreaList.ReadData(_lpData, _pos)
			self.AreaList.append(temAreaList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x33
			self.QueryType = 0
			self.QueryValue = 0
			self.AreaCount = 0
			self.AreaList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			QueryType:%d,
			QueryValue:%d,
			AreaCount:%d,
			AreaList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.QueryType,
			self.QueryValue,
			self.AreaCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# B0 35 福地记录信息 #tagGCMineAreaRecordInfo

			class tagGCMineAreaRecord(Structure):
			RecordType = 0 #(BYTE RecordType)// 记录类型；1-自己拉物品；2-物品被人抢
			TagPlayerID = 0 #(DWORD TagPlayerID)// 目标玩家ID，等于自己玩家ID时代表拉自己的，反之为抢别人的
			RecordTime = 0 #(DWORD RecordTime)// 记录时间戳
			MineID = 0 #(WORD MineID)// 矿物ID，对应福地采集表中ID
			TagPlayerName = "" #(char TagPlayerName[33])
			TagJob = 0 #(BYTE TagJob)
			TagFace = 0 #(DWORD TagFace)
			TagFacePic = 0 #(DWORD TagFacePic)
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			self.RecordType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.TagPlayerID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RecordTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MineID,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.TagPlayerName,_pos = CommFunc.ReadString(_lpData, _pos,33)
			self.TagJob,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.TagFace,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TagFacePic,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			return _pos

			def Clear(self):
			self.RecordType = 0
			self.TagPlayerID = 0
			self.RecordTime = 0
			self.MineID = 0
			self.TagPlayerName = ""
			self.TagJob = 0
			self.TagFace = 0
			self.TagFacePic = 0
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteBYTE(data, self.RecordType)
			data = CommFunc.WriteDWORD(data, self.TagPlayerID)
			data = CommFunc.WriteDWORD(data, self.RecordTime)
			data = CommFunc.WriteWORD(data, self.MineID)
			data = CommFunc.WriteString(data, 33, self.TagPlayerName)
			data = CommFunc.WriteBYTE(data, self.TagJob)
			data = CommFunc.WriteDWORD(data, self.TagFace)
			data = CommFunc.WriteDWORD(data, self.TagFacePic)
			return data

			def OutputString(self):
			DumpString = '''
			RecordType:%d,
			TagPlayerID:%d,
			RecordTime:%d,
			MineID:%d,
			TagPlayerName:%s,
			TagJob:%d,
			TagFace:%d,
			TagFacePic:%d
			'''\
			%(
			self.RecordType,
			self.TagPlayerID,
			self.RecordTime,
			self.MineID,
			self.TagPlayerName,
			self.TagJob,
			self.TagFace,
			self.TagFacePic
			)
			return DumpString


			class tagGCMineAreaRecordInfo(Structure):
			Head = tagHead()
			RecordCount = 0 #(BYTE RecordCount)
			AreaRecordList = list() #(vector<tagGCMineAreaRecord> AreaRecordList)
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x35
			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):
			temAreaRecordList = tagGCMineAreaRecord()
			_pos = temAreaRecordList.ReadData(_lpData, _pos)
			self.AreaRecordList.append(temAreaRecordList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x35
			self.RecordCount = 0
			self.AreaRecordList = list()
			return

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

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


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


			#------------------------------------------------------
			# B0 32 福地物品拉预览结果 #tagGCMineItemPullPreviewRet

			class tagGCMineItemPullPreviewRet(Structure):
			class tagSCGoldRushCamp(Structure):
			_pack_ = 1
			_fields_ = [
			("Cmd", c_ubyte),
			("SubCmd", c_ubyte),
			("PlayerID", c_int), # 福地所属玩家ID，0默认自己
			("ItemIndex", c_ubyte), # 物品所在位置索引0~n
			("WorkerCount", c_ubyte), # 上工人人数
			("NeedSeconds", c_int), # 预计需要时间，秒
			("CampID", c_ubyte), # 营地ID，从1开始
			("GoldID", c_ubyte), # 淘金ID，为0时代表该营地为空
			("RefreshCnt", c_ushort), # 已刷新次数
			("EndTime", c_int), # 预计完成时的时间戳，为0时代表还未开始淘金，通过该时间进行倒计时，完成时需发送操作完成淘金
			("WorkerCnt", c_ubyte), # 使用监工数
			]

			def __init__(self):
			self.Clear()
			self.Cmd = 0xB0
			self.SubCmd = 0x32
			return

			def ReadData(self, stringData, _pos=0, _len=0):
			@@ -40850,178 +40254,203 @@
			return _pos + self.GetLength()

			def Clear(self):
			self.Cmd = 0xB0
			self.SubCmd = 0x32
			self.PlayerID = 0
			self.ItemIndex = 0
			self.WorkerCount = 0
			self.NeedSeconds = 0
			self.CampID = 0
			self.GoldID = 0
			self.RefreshCnt = 0
			self.EndTime = 0
			self.WorkerCnt = 0
			return

			def GetLength(self):
			return sizeof(tagGCMineItemPullPreviewRet)
			return sizeof(tagSCGoldRushCamp)

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

			def OutputString(self):
			DumpString = '''// B0 32 福地物品拉预览结果 //tagGCMineItemPullPreviewRet:
			Cmd:%s,
			SubCmd:%s,
			PlayerID:%d,
			ItemIndex:%d,
			WorkerCount:%d,
			NeedSeconds:%d
			DumpString = '''// B0 37 淘金营地信息 //tagSCGoldRushCampInfo:
			CampID:%d,
			GoldID:%d,
			RefreshCnt:%d,
			EndTime:%d,
			WorkerCnt:%d
			'''\
			%(
			self.Cmd,
			self.SubCmd,
			self.PlayerID,
			self.ItemIndex,
			self.WorkerCount,
			self.NeedSeconds
			self.CampID,
			self.GoldID,
			self.RefreshCnt,
			self.EndTime,
			self.WorkerCnt
			)
			return DumpString


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


			#------------------------------------------------------
			# B0 30 玩家福地相关信息 #tagMCPlayerMineAreaInfo

			class tagMCPlayerMineAreaInfo(Structure):
			class tagSCGoldRushCampInfo(Structure):
			Head = tagHead()
			WorkerCount = 0 #(BYTE WorkerCount)// 已雇佣工人数
			EnergyUsed = 0 #(WORD EnergyUsed)// 今日已消耗体力
			RefreshCount = 0 #(DWORD RefreshCount)// 今日福地刷新物品次数 - 普通刷新
			RefreshCountSuper = 0 #(BYTE RefreshCountSuper)// 今日福地刷新物品次数 - 超级刷新
			RefreshCountRob = 0 #(WORD RefreshCountRob)// 今日福地刷新周围玩家次数
			TreasureCount = 0 #(BYTE TreasureCount)// 聚宝盆类型个数，对应类型 0~n
			TreasureState = list() #(vector<BYTE> TreasureState)// 聚宝盆是否已激活列表，[类型0是否已激活, ...]
			TreasureAward = list() #(vector<BYTE> TreasureAward)// 聚宝盆奖励是否已领取列表，[类型0是否已领取, ...]
			TreasureProgress = list() #(vector<BYTE> TreasureProgress)// 聚宝盆进度值列表，[类型0进度值, ...]，满进度100
			HelpAwardCount = 0 #(BYTE HelpAwardCount)// 今日已帮助别人奖励次数
			HousekeeperEndTime = 0 #(DWORD HousekeeperEndTime)// 自动管家到期时间戳，有值同时也代表免费试用已使用
			CampCnt = 0 #(BYTE CampCnt)
			CampList = list() #(vector<tagSCGoldRushCamp> CampList)// 营地列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.WorkerCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.EnergyUsed,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.RefreshCount,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.RefreshCountSuper,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.RefreshCountRob,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.TreasureCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.TreasureCount):
			value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
			self.TreasureState.append(value)
			for i in range(self.TreasureCount):
			value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
			self.TreasureAward.append(value)
			for i in range(self.TreasureCount):
			value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
			self.TreasureProgress.append(value)
			self.HelpAwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.HousekeeperEndTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.CampCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.CampCnt):
			temCampList = tagSCGoldRushCamp()
			_pos = temCampList.ReadData(_lpData, _pos)
			self.CampList.append(temCampList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x30
			self.WorkerCount = 0
			self.EnergyUsed = 0
			self.RefreshCount = 0
			self.RefreshCountSuper = 0
			self.RefreshCountRob = 0
			self.TreasureCount = 0
			self.TreasureState = list()
			self.TreasureAward = list()
			self.TreasureProgress = list()
			self.HelpAwardCount = 0
			self.HousekeeperEndTime = 0
			self.Head.SubCmd = 0x37
			self.CampCnt = 0
			self.CampList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 2
			length += 4
			length += 1
			length += 2
			length += 1
			length += 1 * self.TreasureCount
			length += 1 * self.TreasureCount
			length += 1 * self.TreasureCount
			length += 1
			length += 4
			for i in range(self.CampCnt):
			length += self.CampList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.WorkerCount)
			data = CommFunc.WriteWORD(data, self.EnergyUsed)
			data = CommFunc.WriteDWORD(data, self.RefreshCount)
			data = CommFunc.WriteBYTE(data, self.RefreshCountSuper)
			data = CommFunc.WriteWORD(data, self.RefreshCountRob)
			data = CommFunc.WriteBYTE(data, self.TreasureCount)
			for i in range(self.TreasureCount):
			data = CommFunc.WriteBYTE(data, self.TreasureState[i])
			for i in range(self.TreasureCount):
			data = CommFunc.WriteBYTE(data, self.TreasureAward[i])
			for i in range(self.TreasureCount):
			data = CommFunc.WriteBYTE(data, self.TreasureProgress[i])
			data = CommFunc.WriteBYTE(data, self.HelpAwardCount)
			data = CommFunc.WriteDWORD(data, self.HousekeeperEndTime)
			data = CommFunc.WriteBYTE(data, self.CampCnt)
			for i in range(self.CampCnt):
			data = CommFunc.WriteString(data, self.CampList[i].GetLength(), self.CampList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			WorkerCount:%d,
			EnergyUsed:%d,
			RefreshCount:%d,
			RefreshCountSuper:%d,
			RefreshCountRob:%d,
			TreasureCount:%d,
			TreasureState:%s,
			TreasureAward:%s,
			TreasureProgress:%s,
			HelpAwardCount:%d,
			HousekeeperEndTime:%d
			CampCnt:%d,
			CampList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.WorkerCount,
			self.EnergyUsed,
			self.RefreshCount,
			self.RefreshCountSuper,
			self.RefreshCountRob,
			self.TreasureCount,
			"...",
			"...",
			"...",
			self.HelpAwardCount,
			self.HousekeeperEndTime
			self.CampCnt,
			"..."
			)
			return DumpString


			m_NAtagMCPlayerMineAreaInfo=tagMCPlayerMineAreaInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCPlayerMineAreaInfo.Head.Cmd,m_NAtagMCPlayerMineAreaInfo.Head.SubCmd))] = m_NAtagMCPlayerMineAreaInfo
			m_NAtagSCGoldRushCampInfo=tagSCGoldRushCampInfo()
			ChNetPackDict[eval("0x%02x%02x"%(m_NAtagSCGoldRushCampInfo.Head.Cmd,m_NAtagSCGoldRushCampInfo.Head.SubCmd))] = m_NAtagSCGoldRushCampInfo


			#------------------------------------------------------
			# B0 36 淘金相关信息 #tagSCGoldRushInfo

			class tagSCGoldRushInfo(Structure):
			Head = tagHead()
			CampState = 0 #(DWORD CampState)// 已解锁营地状态，按营地ID二进制位运算判断是否已解锁
			WorkerState = 0 #(DWORD WorkerState)// 已雇佣工人状态，按工人ID二进制位运算判断是否已解锁
			PanningCnt = 0 #(DWORD PanningCnt)// 累计淘金次数
			LastRecoverTime = 0 #(DWORD LastRecoverTime)// 上次免费恢复淘金令时间戳，为0时可不用倒计时
			HousekeeperEndTime = 0 #(DWORD HousekeeperEndTime)// 自动管家到期时间戳，有值同时也代表免费试用已使用
			WarehouseCnt = 0 #(BYTE WarehouseCnt)// 淘金仓库物品数
			WarehouseIDList = list() #(vector<BYTE> WarehouseIDList)// 淘金仓库已完成淘金ID列表 [索引0淘金ID, ...]，淘金ID为0代表该索引位置为空
			data = None

			def __init__(self):
			self.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x36
			return

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.CampState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.WorkerState,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.PanningCnt,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.LastRecoverTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.HousekeeperEndTime,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.WarehouseCnt,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.WarehouseCnt):
			value,_pos=CommFunc.ReadBYTE(_lpData,_pos)
			self.WarehouseIDList.append(value)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB0
			self.Head.SubCmd = 0x36
			self.CampState = 0
			self.WorkerState = 0
			self.PanningCnt = 0
			self.LastRecoverTime = 0
			self.HousekeeperEndTime = 0
			self.WarehouseCnt = 0
			self.WarehouseIDList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.CampState)
			data = CommFunc.WriteDWORD(data, self.WorkerState)
			data = CommFunc.WriteDWORD(data, self.PanningCnt)
			data = CommFunc.WriteDWORD(data, self.LastRecoverTime)
			data = CommFunc.WriteDWORD(data, self.HousekeeperEndTime)
			data = CommFunc.WriteBYTE(data, self.WarehouseCnt)
			for i in range(self.WarehouseCnt):
			data = CommFunc.WriteBYTE(data, self.WarehouseIDList[i])
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			CampState:%d,
			WorkerState:%d,
			PanningCnt:%d,
			LastRecoverTime:%d,
			HousekeeperEndTime:%d,
			WarehouseCnt:%d,
			WarehouseIDList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.CampState,
			self.WorkerState,
			self.PanningCnt,
			self.LastRecoverTime,
			self.HousekeeperEndTime,
			self.WarehouseCnt,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -42050,207 +41479,6 @@

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


			#------------------------------------------------------
			# B1 09 玩家挂机系统信息 #tagMCGuajiInfo

			class tagMCGuajiMoney(Structure):
			_pack_ = 1
			_fields_ = [
			("MoneyType", c_ubyte),
			("MoneyValue", 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.MoneyType = 0
			self.MoneyValue = 0
			return

			def GetLength(self):
			return sizeof(tagMCGuajiMoney)

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

			def OutputString(self):
			DumpString = '''// B1 09 玩家挂机系统信息 //tagMCGuajiInfo:
			MoneyType:%d,
			MoneyValue:%d
			'''\
			%(
			self.MoneyType,
			self.MoneyValue
			)
			return DumpString


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

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

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

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

			def GetLength(self):
			return sizeof(tagMCGuajiItem)

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

			def OutputString(self):
			DumpString = '''// B1 09 玩家挂机系统信息 //tagMCGuajiInfo:
			ItemID:%d,
			Count:%d
			'''\
			%(
			self.ItemID,
			self.Count
			)
			return DumpString


			class tagMCGuajiInfo(Structure):
			Head = tagHead()
			QuickAwardCount = 0 #(BYTE QuickAwardCount)// 今日已快速挂机收益次数
			AwardType = 0 #(BYTE AwardType)// 收益类型： 0-已累计预览；1-领取结算结果（包含常规领取跟快速领取）
			AwardSeconds = 0 #(DWORD AwardSeconds)// 已累计收益时长，秒
			Exp = 0 #(DWORD Exp)// 已累计经验，求余亿部分
			ExpPoint = 0 #(DWORD ExpPoint)// 已累计经验，整除亿部分
			MoneyLen = 0 #(BYTE MoneyLen)
			MoneyList = list() #(vector<tagMCGuajiMoney> MoneyList)// 已累计货币
			ItemLen = 0 #(BYTE ItemLen)
			ItemList = list() #(vector<tagMCGuajiItem> ItemList)// 已累计物品
			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.QuickAwardCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.AwardType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.AwardSeconds,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.Exp,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.ExpPoint,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.MoneyLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.MoneyLen):
			temMoneyList = tagMCGuajiMoney()
			_pos = temMoneyList.ReadData(_lpData, _pos)
			self.MoneyList.append(temMoneyList)
			self.ItemLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.ItemLen):
			temItemList = tagMCGuajiItem()
			_pos = temItemList.ReadData(_lpData, _pos)
			self.ItemList.append(temItemList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB1
			self.Head.SubCmd = 0x09
			self.QuickAwardCount = 0
			self.AwardType = 0
			self.AwardSeconds = 0
			self.Exp = 0
			self.ExpPoint = 0
			self.MoneyLen = 0
			self.MoneyList = list()
			self.ItemLen = 0
			self.ItemList = list()
			return

			def GetLength(self):
			length = 0
			length += self.Head.GetLength()
			length += 1
			length += 1
			length += 4
			length += 4
			length += 4
			length += 1
			for i in range(self.MoneyLen):
			length += self.MoneyList[i].GetLength()
			length += 1
			for i in range(self.ItemLen):
			length += self.ItemList[i].GetLength()

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteBYTE(data, self.QuickAwardCount)
			data = CommFunc.WriteBYTE(data, self.AwardType)
			data = CommFunc.WriteDWORD(data, self.AwardSeconds)
			data = CommFunc.WriteDWORD(data, self.Exp)
			data = CommFunc.WriteDWORD(data, self.ExpPoint)
			data = CommFunc.WriteBYTE(data, self.MoneyLen)
			for i in range(self.MoneyLen):
			data = CommFunc.WriteString(data, self.MoneyList[i].GetLength(), self.MoneyList[i].GetBuffer())
			data = CommFunc.WriteBYTE(data, self.ItemLen)
			for i in range(self.ItemLen):
			data = CommFunc.WriteString(data, self.ItemList[i].GetLength(), self.ItemList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			QuickAwardCount:%d,
			AwardType:%d,
			AwardSeconds:%d,
			Exp:%d,
			ExpPoint:%d,
			MoneyLen:%d,
			MoneyList:%s,
			ItemLen:%d,
			ItemList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.QuickAwardCount,
			self.AwardType,
			self.AwardSeconds,
			self.Exp,
			self.ExpPoint,
			self.MoneyLen,
			"...",
			self.ItemLen,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			@@ -47164,6 +46392,7 @@
			("Value1", c_int),
			("Value2", c_int),
			("Value3", c_int),
			("IsAdd", c_ubyte), # 是否是添加/覆盖的，1-是；0-否一般为buff的数据刷新
			]

			def __init__(self):
			@@ -47190,6 +46419,7 @@
			self.Value1 = 0
			self.Value2 = 0
			self.Value3 = 0
			self.IsAdd = 0
			return

			def GetLength(self):
			@@ -47211,7 +46441,8 @@
			OwnerID:%d,
			Value1:%d,
			Value2:%d,
			Value3:%d
			Value3:%d,
			IsAdd:%d
			'''\
			%(
			self.Cmd,
			@@ -47225,7 +46456,8 @@
			self.OwnerID,
			self.Value1,
			self.Value2,
			self.Value3
			self.Value3,
			self.IsAdd
			)
			return DumpString

			@@ -48360,13 +47592,13 @@
			_fields_ = [
			("ObjID", c_int), # 战斗单位唯一ID
			("NPCID", c_int), # 战斗NPCID，不同的实例ID对应的NPCID可能一样
			("HeroID", c_int), # 玩家武将ID，仅玩家阵容有
			("SkinID", c_int), # 玩家武将皮肤ID，仅玩家阵容有
			("HeroID", c_int), # 武将ID，玩家或NPC均可能有，如果有值则外观相关以该武将为准，否则以NPCID为准
			("SkinID", c_int), # 武将皮肤ID，玩家或NPC均可能有，如果有值则皮肤以该值为准，否则取NPCID对应的皮肤ID
			("HP", c_int), # 当前血量，求余20亿部分
			("HPEx", c_int), # 当前血量，整除20亿部分
			("MaxHP", c_int), # 最大血量，求余20亿部分
			("MaxHPEx", c_int), # 最大血量，整除20亿部分
			("LV", c_ushort), # 等级
			("LV", c_ushort), # 等级，玩家的武将等级或NPC成长等级，等级显示以该值为准
			("PosNum", c_ubyte), # 在本阵容中的站位，从1开始，非主战斗武将为0，如红颜
			("AngreXP", c_ushort), # 当前怒气值
			]
			@@ -52683,135 +51915,6 @@


			#------------------------------------------------------
			# B9 11 队员进入副本准备状态刷新 #tagGCTeamEnterFBPrepare

			class tagGCTeamMemPrepareState(Structure):
			_pack_ = 1
			_fields_ = [
			("PlayerID", c_int),
			("PrepareState", c_ubyte), # 状态，0-未准备，1-已准备，2-拒绝
			]

			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.PrepareState = 0
			return

			def GetLength(self):
			return sizeof(tagGCTeamMemPrepareState)

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

			def OutputString(self):
			DumpString = '''// B9 11 队员进入副本准备状态刷新 //tagGCTeamEnterFBPrepare:
			PlayerID:%d,
			PrepareState:%d
			'''\
			%(
			self.PlayerID,
			self.PrepareState
			)
			return DumpString


			class tagGCTeamEnterFBPrepare(Structure):
			Head = tagHead()
			TagMapID = 0 #(DWORD TagMapID)// 目标地图，不一定是队伍目标
			TagMapEx = 0 #(WORD TagMapEx)// 目标地图扩展
			IsPrepareErr = 0 #(BYTE IsPrepareErr)// 是否准备异常(在所有队员都准备好后准备传入副本出现有队员最终不能进入的情况时该值为1)
			MemCount = 0 #(BYTE MemCount)
			MemStateList = list() #(vector<tagGCTeamMemPrepareState> MemStateList)// 队员状态列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.TagMapID,_pos = CommFunc.ReadDWORD(_lpData, _pos)
			self.TagMapEx,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.IsPrepareErr,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.MemCount):
			temMemStateList = tagGCTeamMemPrepareState()
			_pos = temMemStateList.ReadData(_lpData, _pos)
			self.MemStateList.append(temMemStateList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB9
			self.Head.SubCmd = 0x11
			self.TagMapID = 0
			self.TagMapEx = 0
			self.IsPrepareErr = 0
			self.MemCount = 0
			self.MemStateList = list()
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())
			data = CommFunc.WriteDWORD(data, self.TagMapID)
			data = CommFunc.WriteWORD(data, self.TagMapEx)
			data = CommFunc.WriteBYTE(data, self.IsPrepareErr)
			data = CommFunc.WriteBYTE(data, self.MemCount)
			for i in range(self.MemCount):
			data = CommFunc.WriteString(data, self.MemStateList[i].GetLength(), self.MemStateList[i].GetBuffer())
			return data

			def OutputString(self):
			DumpString = '''
			Head:%s,
			TagMapID:%d,
			TagMapEx:%d,
			IsPrepareErr:%d,
			MemCount:%d,
			MemStateList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.TagMapID,
			self.TagMapEx,
			self.IsPrepareErr,
			self.MemCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------
			# B9 03 队伍信息变更 #tagGCTeamInfoChange

			class tagGCTeamInfoChange(Structure):
			@@ -53218,134 +52321,6 @@

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


			#------------------------------------------------------
			# B9 12 队员功能数据查询结果 #tagGCTeamMemFuncDataList

			class tagGCTeamMemFuncData(Structure):
			PlayerID = 0 #(DWORD PlayerID)
			DataLen = 0 #(WORD DataLen)
			MemFuncData = "" #(String MemFuncData)// 队员对应功能数据查询结果
			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.DataLen,_pos = CommFunc.ReadWORD(_lpData, _pos)
			self.MemFuncData,_pos = CommFunc.ReadString(_lpData, _pos,self.DataLen)
			return _pos

			def Clear(self):
			self.PlayerID = 0
			self.DataLen = 0
			self.MemFuncData = ""
			return

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

			return length

			def GetBuffer(self):
			data = ''
			data = CommFunc.WriteDWORD(data, self.PlayerID)
			data = CommFunc.WriteWORD(data, self.DataLen)
			data = CommFunc.WriteString(data, self.DataLen, self.MemFuncData)
			return data

			def OutputString(self):
			DumpString = '''
			PlayerID:%d,
			DataLen:%d,
			MemFuncData:%s
			'''\
			%(
			self.PlayerID,
			self.DataLen,
			self.MemFuncData
			)
			return DumpString


			class tagGCTeamMemFuncDataList(Structure):
			Head = tagHead()
			TeamMemFuncType = 0 #(BYTE TeamMemFuncType)// 查询队员的功能数据类型
			MemCount = 0 #(BYTE MemCount)
			MemFuncDataList = list() #(vector<tagGCTeamMemFuncData> MemFuncDataList)// 数据列表
			data = None

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

			def ReadData(self, _lpData, _pos=0, _Len=0):
			self.Clear()
			_pos = self.Head.ReadData(_lpData, _pos)
			self.TeamMemFuncType,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			self.MemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)
			for i in range(self.MemCount):
			temMemFuncDataList = tagGCTeamMemFuncData()
			_pos = temMemFuncDataList.ReadData(_lpData, _pos)
			self.MemFuncDataList.append(temMemFuncDataList)
			return _pos

			def Clear(self):
			self.Head = tagHead()
			self.Head.Clear()
			self.Head.Cmd = 0xB9
			self.Head.SubCmd = 0x12
			self.TeamMemFuncType = 0
			self.MemCount = 0
			self.MemFuncDataList = list()
			return

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

			return length

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

			def OutputString(self):
			DumpString = '''
			Head:%s,
			TeamMemFuncType:%d,
			MemCount:%d,
			MemFuncDataList:%s
			'''\
			%(
			self.Head.OutputString(),
			self.TeamMemFuncType,
			self.MemCount,
			"..."
			)
			return DumpString


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


			#------------------------------------------------------