121 【武将】武将系统-服务端（天赋洗炼改为仅使用洗炼ID，锁定天赋增加消耗洗炼道具个数；）

hxp

2025-09-03 7401f56246945b00aa91d12ba03ec3865c4c2b25

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ChPyNetSendPack.py

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





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

@@ -48364,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),    # 当前怒气值

                  ]